2 pcd.c (c) 1997-8 Grant R. Guenther <grant@torque.net>
3 Under the terms of the GNU General Public License.
5 This is a high-level driver for parallel port ATAPI CD-ROM
6 drives based on chips supported by the paride module.
8 By default, the driver will autoprobe for a single parallel
9 port ATAPI CD-ROM drive, but if their individual parameters are
10 specified, the driver can handle up to 4 drives.
12 The behaviour of the pcd driver can be altered by setting
13 some parameters from the insmod command line. The following
14 parameters are adjustable:
16 drive0 These four arguments can be arrays of
17 drive1 1-6 integers as follows:
19 drive3 <prt>,<pro>,<uni>,<mod>,<slv>,<dly>
23 <prt> is the base of the parallel port address for
24 the corresponding drive. (required)
26 <pro> is the protocol number for the adapter that
27 supports this drive. These numbers are
28 logged by 'paride' when the protocol modules
29 are initialised. (0 if not given)
31 <uni> for those adapters that support chained
32 devices, this is the unit selector for the
33 chain of devices on the given port. It should
34 be zero for devices that don't support chaining.
37 <mod> this can be -1 to choose the best mode, or one
38 of the mode numbers supported by the adapter.
41 <slv> ATAPI CD-ROMs can be jumpered to master or slave.
42 Set this to 0 to choose the master drive, 1 to
43 choose the slave, -1 (the default) to choose the
46 <dly> some parallel ports require the driver to
47 go more slowly. -1 sets a default value that
48 should work with the chosen protocol. Otherwise,
49 set this to a small integer, the larger it is
50 the slower the port i/o. In some cases, setting
51 this to zero will speed up the device. (default -1)
53 major You may use this parameter to overide the
54 default major number (46) that this driver
55 will use. Be sure to change the device
58 name This parameter is a character string that
59 contains the name the kernel will use for this
60 device (in /proc output, for instance).
63 verbose This parameter controls the amount of logging
64 that the driver will do. Set it to 0 for
65 normal operation, 1 to see autoprobe progress
66 messages, or 2 to see additional debugging
69 nice This parameter controls the driver's use of
70 idle CPU time, at the expense of some speed.
72 If this driver is built into the kernel, you can use kernel
73 the following command line parameters, with the same values
74 as the corresponding module parameters listed above:
82 In addition, you can use the parameter pcd.disable to disable
89 1.01 GRG 1998.01.24 Added test unit ready support
90 1.02 GRG 1998.05.06 Changes to pcd_completion, ready_wait,
91 and loosen interpretation of ATAPI
92 standard for clearing error status.
93 Use spinlocks. Eliminate sti().
94 1.03 GRG 1998.06.16 Eliminated an Ugh
95 1.04 GRG 1998.08.15 Added extra debugging, improvements to
96 pcd_completion, use HZ in loop timing
97 1.05 GRG 1998.08.16 Conformed to "Uniform CD-ROM" standard
98 1.06 GRG 1998.08.19 Added audio ioctl support
99 1.07 GRG 1998.09.24 Increased reset timeout, added jumbo support
103 #define PCD_VERSION "1.07"
105 #define PCD_NAME "pcd"
108 /* Here are things one can override from the insmod command.
109 Most are autoprobed by paride unless set here. Verbose is off
114 static int verbose
= 0;
115 static int major
= PCD_MAJOR
;
116 static char *name
= PCD_NAME
;
118 static int disable
= 0;
120 static int drive0
[6] = { 0, 0, 0, -1, -1, -1 };
121 static int drive1
[6] = { 0, 0, 0, -1, -1, -1 };
122 static int drive2
[6] = { 0, 0, 0, -1, -1, -1 };
123 static int drive3
[6] = { 0, 0, 0, -1, -1, -1 };
125 static int (*drives
[4])[6] = {&drive0
, &drive1
, &drive2
, &drive3
};
126 static int pcd_drive_count
;
128 enum {D_PRT
, D_PRO
, D_UNI
, D_MOD
, D_SLV
, D_DLY
};
130 /* end of parameters */
132 #include <linux/module.h>
133 #include <linux/init.h>
134 #include <linux/errno.h>
135 #include <linux/fs.h>
136 #include <linux/kernel.h>
137 #include <linux/delay.h>
138 #include <linux/cdrom.h>
139 #include <linux/spinlock.h>
140 #include <linux/blkdev.h>
141 #include <linux/smp_lock.h>
142 #include <asm/uaccess.h>
144 static DEFINE_SPINLOCK(pcd_lock
);
146 module_param(verbose
, bool, 0644);
147 module_param(major
, int, 0);
148 module_param(name
, charp
, 0);
149 module_param(nice
, int, 0);
150 module_param_array(drive0
, int, NULL
, 0);
151 module_param_array(drive1
, int, NULL
, 0);
152 module_param_array(drive2
, int, NULL
, 0);
153 module_param_array(drive3
, int, NULL
, 0);
158 #define PCD_RETRIES 5
159 #define PCD_TMO 800 /* timeout in jiffies */
160 #define PCD_DELAY 50 /* spin delay in uS */
161 #define PCD_READY_TMO 20 /* in seconds */
162 #define PCD_RESET_TMO 100 /* in tenths of a second */
164 #define PCD_SPIN (1000000*PCD_TMO)/(HZ*PCD_DELAY)
168 #define IDE_READY 0x40
169 #define IDE_BUSY 0x80
171 static int pcd_open(struct cdrom_device_info
*cdi
, int purpose
);
172 static void pcd_release(struct cdrom_device_info
*cdi
);
173 static int pcd_drive_status(struct cdrom_device_info
*cdi
, int slot_nr
);
174 static int pcd_media_changed(struct cdrom_device_info
*cdi
, int slot_nr
);
175 static int pcd_tray_move(struct cdrom_device_info
*cdi
, int position
);
176 static int pcd_lock_door(struct cdrom_device_info
*cdi
, int lock
);
177 static int pcd_drive_reset(struct cdrom_device_info
*cdi
);
178 static int pcd_get_mcn(struct cdrom_device_info
*cdi
, struct cdrom_mcn
*mcn
);
179 static int pcd_audio_ioctl(struct cdrom_device_info
*cdi
,
180 unsigned int cmd
, void *arg
);
181 static int pcd_packet(struct cdrom_device_info
*cdi
,
182 struct packet_command
*cgc
);
184 static int pcd_detect(void);
185 static void pcd_probe_capabilities(void);
186 static void do_pcd_read_drq(void);
187 static void do_pcd_request(struct request_queue
* q
);
188 static void do_pcd_read(void);
191 struct pi_adapter pia
; /* interface to paride layer */
192 struct pi_adapter
*pi
;
193 int drive
; /* master/slave */
194 int last_sense
; /* result of last request sense */
195 int changed
; /* media change seen */
196 int present
; /* does this unit exist ? */
197 char *name
; /* pcd0, pcd1, etc */
198 struct cdrom_device_info info
; /* uniform cdrom interface */
199 struct gendisk
*disk
;
202 static struct pcd_unit pcd
[PCD_UNITS
];
204 static char pcd_scratch
[64];
205 static char pcd_buffer
[2048]; /* raw block buffer */
206 static int pcd_bufblk
= -1; /* block in buffer, in CD units,
207 -1 for nothing there. See also
211 /* the variables below are used mainly in the I/O request engine, which
212 processes only one request at a time.
215 static struct pcd_unit
*pcd_current
; /* current request's drive */
216 static struct request
*pcd_req
;
217 static int pcd_retries
; /* retries on current request */
218 static int pcd_busy
; /* request being processed ? */
219 static int pcd_sector
; /* address of next requested sector */
220 static int pcd_count
; /* number of blocks still to do */
221 static char *pcd_buf
; /* buffer for request in progress */
223 /* kernel glue structures */
225 static int pcd_block_open(struct block_device
*bdev
, fmode_t mode
)
227 struct pcd_unit
*cd
= bdev
->bd_disk
->private_data
;
228 return cdrom_open(&cd
->info
, bdev
, mode
);
231 static int pcd_block_release(struct gendisk
*disk
, fmode_t mode
)
233 struct pcd_unit
*cd
= disk
->private_data
;
234 cdrom_release(&cd
->info
, mode
);
238 static int pcd_block_ioctl(struct block_device
*bdev
, fmode_t mode
,
239 unsigned cmd
, unsigned long arg
)
241 struct pcd_unit
*cd
= bdev
->bd_disk
->private_data
;
245 ret
= cdrom_ioctl(&cd
->info
, bdev
, mode
, cmd
, arg
);
251 static int pcd_block_media_changed(struct gendisk
*disk
)
253 struct pcd_unit
*cd
= disk
->private_data
;
254 return cdrom_media_changed(&cd
->info
);
257 static const struct block_device_operations pcd_bdops
= {
258 .owner
= THIS_MODULE
,
259 .open
= pcd_block_open
,
260 .release
= pcd_block_release
,
261 .ioctl
= pcd_block_ioctl
,
262 .media_changed
= pcd_block_media_changed
,
265 static struct cdrom_device_ops pcd_dops
= {
267 .release
= pcd_release
,
268 .drive_status
= pcd_drive_status
,
269 .media_changed
= pcd_media_changed
,
270 .tray_move
= pcd_tray_move
,
271 .lock_door
= pcd_lock_door
,
272 .get_mcn
= pcd_get_mcn
,
273 .reset
= pcd_drive_reset
,
274 .audio_ioctl
= pcd_audio_ioctl
,
275 .generic_packet
= pcd_packet
,
276 .capability
= CDC_CLOSE_TRAY
| CDC_OPEN_TRAY
| CDC_LOCK
|
277 CDC_MCN
| CDC_MEDIA_CHANGED
| CDC_RESET
|
278 CDC_PLAY_AUDIO
| CDC_GENERIC_PACKET
| CDC_CD_R
|
282 static void pcd_init_units(void)
288 for (unit
= 0, cd
= pcd
; unit
< PCD_UNITS
; unit
++, cd
++) {
289 struct gendisk
*disk
= alloc_disk(1);
297 cd
->drive
= (*drives
[unit
])[D_SLV
];
298 if ((*drives
[unit
])[D_PRT
])
301 cd
->name
= &cd
->info
.name
[0];
302 snprintf(cd
->name
, sizeof(cd
->info
.name
), "%s%d", name
, unit
);
303 cd
->info
.ops
= &pcd_dops
;
304 cd
->info
.handle
= cd
;
306 cd
->info
.capacity
= 1;
309 disk
->first_minor
= unit
;
310 strcpy(disk
->disk_name
, cd
->name
); /* umm... */
311 disk
->fops
= &pcd_bdops
;
315 static int pcd_open(struct cdrom_device_info
*cdi
, int purpose
)
317 struct pcd_unit
*cd
= cdi
->handle
;
323 static void pcd_release(struct cdrom_device_info
*cdi
)
327 static inline int status_reg(struct pcd_unit
*cd
)
329 return pi_read_regr(cd
->pi
, 1, 6);
332 static inline int read_reg(struct pcd_unit
*cd
, int reg
)
334 return pi_read_regr(cd
->pi
, 0, reg
);
337 static inline void write_reg(struct pcd_unit
*cd
, int reg
, int val
)
339 pi_write_regr(cd
->pi
, 0, reg
, val
);
342 static int pcd_wait(struct pcd_unit
*cd
, int go
, int stop
, char *fun
, char *msg
)
347 while ((((r
= status_reg(cd
)) & go
) || (stop
&& (!(r
& stop
))))
351 if ((r
& (IDE_ERR
& stop
)) || (j
> PCD_SPIN
)) {
358 printk("%s: %s %s: alt=0x%x stat=0x%x err=0x%x"
359 " loop=%d phase=%d\n",
360 cd
->name
, fun
, msg
, r
, s
, e
, j
, p
);
366 static int pcd_command(struct pcd_unit
*cd
, char *cmd
, int dlen
, char *fun
)
370 write_reg(cd
, 6, 0xa0 + 0x10 * cd
->drive
);
372 if (pcd_wait(cd
, IDE_BUSY
| IDE_DRQ
, 0, fun
, "before command")) {
373 pi_disconnect(cd
->pi
);
377 write_reg(cd
, 4, dlen
% 256);
378 write_reg(cd
, 5, dlen
/ 256);
379 write_reg(cd
, 7, 0xa0); /* ATAPI packet command */
381 if (pcd_wait(cd
, IDE_BUSY
, IDE_DRQ
, fun
, "command DRQ")) {
382 pi_disconnect(cd
->pi
);
386 if (read_reg(cd
, 2) != 1) {
387 printk("%s: %s: command phase error\n", cd
->name
, fun
);
388 pi_disconnect(cd
->pi
);
392 pi_write_block(cd
->pi
, cmd
, 12);
397 static int pcd_completion(struct pcd_unit
*cd
, char *buf
, char *fun
)
399 int r
, d
, p
, n
, k
, j
;
405 if (!pcd_wait(cd
, IDE_BUSY
, IDE_DRQ
| IDE_READY
| IDE_ERR
,
406 fun
, "completion")) {
408 while (read_reg(cd
, 7) & IDE_DRQ
) {
409 d
= read_reg(cd
, 4) + 256 * read_reg(cd
, 5);
410 n
= (d
+ 3) & 0xfffc;
411 p
= read_reg(cd
, 2) & 3;
413 if ((p
== 2) && (n
> 0) && (j
== 0)) {
414 pi_read_block(cd
->pi
, buf
, n
);
416 printk("%s: %s: Read %d bytes\n",
423 ("%s: %s: Unexpected phase %d, d=%d, k=%d\n",
424 cd
->name
, fun
, p
, d
, k
);
427 "%s: WARNING: ATAPI phase errors\n",
432 printk("%s: Stuck DRQ\n", cd
->name
);
436 (cd
, IDE_BUSY
, IDE_DRQ
| IDE_READY
| IDE_ERR
, fun
,
444 pi_disconnect(cd
->pi
);
449 static void pcd_req_sense(struct pcd_unit
*cd
, char *fun
)
451 char rs_cmd
[12] = { 0x03, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0 };
455 r
= pcd_command(cd
, rs_cmd
, 16, "Request sense");
458 pcd_completion(cd
, buf
, "Request sense");
464 printk("%s: %s: Sense key: %x, ASC: %x, ASQ: %x\n",
465 cd
->name
, fun
, buf
[2] & 0xf, buf
[12], buf
[13]);
468 c
| ((buf
[12] & 0xff) << 8) | ((buf
[13] & 0xff) << 16);
470 if ((c
== 2) || (c
== 6))
474 static int pcd_atapi(struct pcd_unit
*cd
, char *cmd
, int dlen
, char *buf
, char *fun
)
478 r
= pcd_command(cd
, cmd
, dlen
, fun
);
481 r
= pcd_completion(cd
, buf
, fun
);
483 pcd_req_sense(cd
, fun
);
488 static int pcd_packet(struct cdrom_device_info
*cdi
, struct packet_command
*cgc
)
490 return pcd_atapi(cdi
->handle
, cgc
->cmd
, cgc
->buflen
, cgc
->buffer
,
494 #define DBMSG(msg) ((verbose>1)?(msg):NULL)
496 static int pcd_media_changed(struct cdrom_device_info
*cdi
, int slot_nr
)
498 struct pcd_unit
*cd
= cdi
->handle
;
499 int res
= cd
->changed
;
505 static int pcd_lock_door(struct cdrom_device_info
*cdi
, int lock
)
507 char un_cmd
[12] = { 0x1e, 0, 0, 0, lock
, 0, 0, 0, 0, 0, 0, 0 };
509 return pcd_atapi(cdi
->handle
, un_cmd
, 0, pcd_scratch
,
510 lock
? "lock door" : "unlock door");
513 static int pcd_tray_move(struct cdrom_device_info
*cdi
, int position
)
515 char ej_cmd
[12] = { 0x1b, 0, 0, 0, 3 - position
, 0, 0, 0, 0, 0, 0, 0 };
517 return pcd_atapi(cdi
->handle
, ej_cmd
, 0, pcd_scratch
,
518 position
? "eject" : "close tray");
521 static void pcd_sleep(int cs
)
523 schedule_timeout_interruptible(cs
);
526 static int pcd_reset(struct pcd_unit
*cd
)
529 int expect
[5] = { 1, 1, 1, 0x14, 0xeb };
532 write_reg(cd
, 6, 0xa0 + 0x10 * cd
->drive
);
535 pcd_sleep(20 * HZ
/ 1000); /* delay a bit */
538 while ((k
++ < PCD_RESET_TMO
) && (status_reg(cd
) & IDE_BUSY
))
542 for (i
= 0; i
< 5; i
++)
543 flg
&= (read_reg(cd
, i
+ 1) == expect
[i
]);
546 printk("%s: Reset (%d) signature = ", cd
->name
, k
);
547 for (i
= 0; i
< 5; i
++)
548 printk("%3x", read_reg(cd
, i
+ 1));
550 printk(" (incorrect)");
554 pi_disconnect(cd
->pi
);
558 static int pcd_drive_reset(struct cdrom_device_info
*cdi
)
560 return pcd_reset(cdi
->handle
);
563 static int pcd_ready_wait(struct pcd_unit
*cd
, int tmo
)
565 char tr_cmd
[12] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
571 pcd_atapi(cd
, tr_cmd
, 0, NULL
, DBMSG("test unit ready"));
575 if (!(((p
& 0xffff) == 0x0402) || ((p
& 0xff) == 6)))
580 return 0x000020; /* timeout */
583 static int pcd_drive_status(struct cdrom_device_info
*cdi
, int slot_nr
)
585 char rc_cmd
[12] = { 0x25, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
586 struct pcd_unit
*cd
= cdi
->handle
;
588 if (pcd_ready_wait(cd
, PCD_READY_TMO
))
589 return CDS_DRIVE_NOT_READY
;
590 if (pcd_atapi(cd
, rc_cmd
, 8, pcd_scratch
, DBMSG("check media")))
595 static int pcd_identify(struct pcd_unit
*cd
, char *id
)
598 char id_cmd
[12] = { 0x12, 0, 0, 0, 36, 0, 0, 0, 0, 0, 0, 0 };
602 s
= pcd_atapi(cd
, id_cmd
, 36, pcd_buffer
, "identify");
606 if ((pcd_buffer
[0] & 0x1f) != 5) {
608 printk("%s: %s is not a CD-ROM\n",
609 cd
->name
, cd
->drive
? "Slave" : "Master");
612 memcpy(id
, pcd_buffer
+ 16, 16);
615 while ((k
>= 0) && (id
[k
] <= 0x20)) {
620 printk("%s: %s: %s\n", cd
->name
, cd
->drive
? "Slave" : "Master", id
);
626 * returns 0, with id set if drive is detected
627 * -1, if drive detection failed
629 static int pcd_probe(struct pcd_unit
*cd
, int ms
, char *id
)
632 for (cd
->drive
= 0; cd
->drive
<= 1; cd
->drive
++)
633 if (!pcd_reset(cd
) && !pcd_identify(cd
, id
))
637 if (!pcd_reset(cd
) && !pcd_identify(cd
, id
))
643 static void pcd_probe_capabilities(void)
647 char cmd
[12] = { 0x5a, 1 << 3, 0x2a, 0, 0, 0, 0, 18, 0, 0, 0, 0 };
650 for (unit
= 0, cd
= pcd
; unit
< PCD_UNITS
; unit
++, cd
++) {
653 r
= pcd_atapi(cd
, cmd
, 18, buffer
, "mode sense capabilities");
656 /* we should now have the cap page */
657 if ((buffer
[11] & 1) == 0)
658 cd
->info
.mask
|= CDC_CD_R
;
659 if ((buffer
[11] & 2) == 0)
660 cd
->info
.mask
|= CDC_CD_RW
;
661 if ((buffer
[12] & 1) == 0)
662 cd
->info
.mask
|= CDC_PLAY_AUDIO
;
663 if ((buffer
[14] & 1) == 0)
664 cd
->info
.mask
|= CDC_LOCK
;
665 if ((buffer
[14] & 8) == 0)
666 cd
->info
.mask
|= CDC_OPEN_TRAY
;
667 if ((buffer
[14] >> 6) == 0)
668 cd
->info
.mask
|= CDC_CLOSE_TRAY
;
672 static int pcd_detect(void)
678 printk("%s: %s version %s, major %d, nice %d\n",
679 name
, name
, PCD_VERSION
, major
, nice
);
682 if (pcd_drive_count
== 0) { /* nothing spec'd - so autoprobe for 1 */
684 if (pi_init(cd
->pi
, 1, -1, -1, -1, -1, -1, pcd_buffer
,
685 PI_PCD
, verbose
, cd
->name
)) {
686 if (!pcd_probe(cd
, -1, id
) && cd
->disk
) {
693 for (unit
= 0, cd
= pcd
; unit
< PCD_UNITS
; unit
++, cd
++) {
694 int *conf
= *drives
[unit
];
697 if (!pi_init(cd
->pi
, 0, conf
[D_PRT
], conf
[D_MOD
],
698 conf
[D_UNI
], conf
[D_PRO
], conf
[D_DLY
],
699 pcd_buffer
, PI_PCD
, verbose
, cd
->name
))
701 if (!pcd_probe(cd
, conf
[D_SLV
], id
) && cd
->disk
) {
711 printk("%s: No CD-ROM drive found\n", name
);
712 for (unit
= 0, cd
= pcd
; unit
< PCD_UNITS
; unit
++, cd
++)
717 /* I/O request processing */
718 static struct request_queue
*pcd_queue
;
720 static void do_pcd_request(struct request_queue
* q
)
726 pcd_req
= blk_fetch_request(q
);
731 if (rq_data_dir(pcd_req
) == READ
) {
732 struct pcd_unit
*cd
= pcd_req
->rq_disk
->private_data
;
733 if (cd
!= pcd_current
)
736 pcd_sector
= blk_rq_pos(pcd_req
);
737 pcd_count
= blk_rq_cur_sectors(pcd_req
);
738 pcd_buf
= pcd_req
->buffer
;
740 ps_set_intr(do_pcd_read
, NULL
, 0, nice
);
743 __blk_end_request_all(pcd_req
, -EIO
);
749 static inline void next_request(int err
)
751 unsigned long saved_flags
;
753 spin_lock_irqsave(&pcd_lock
, saved_flags
);
754 if (!__blk_end_request_cur(pcd_req
, err
))
757 do_pcd_request(pcd_queue
);
758 spin_unlock_irqrestore(&pcd_lock
, saved_flags
);
761 static int pcd_ready(void)
763 return (((status_reg(pcd_current
) & (IDE_BUSY
| IDE_DRQ
)) == IDE_DRQ
));
766 static void pcd_transfer(void)
769 while (pcd_count
&& (pcd_sector
/ 4 == pcd_bufblk
)) {
770 int o
= (pcd_sector
% 4) * 512;
771 memcpy(pcd_buf
, pcd_buffer
+ o
, 512);
778 static void pcd_start(void)
781 char rd_cmd
[12] = { 0xa8, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 };
783 pcd_bufblk
= pcd_sector
/ 4;
785 for (i
= 0; i
< 4; i
++) {
786 rd_cmd
[5 - i
] = b
& 0xff;
790 if (pcd_command(pcd_current
, rd_cmd
, 2048, "read block")) {
798 ps_set_intr(do_pcd_read_drq
, pcd_ready
, PCD_TMO
, nice
);
801 static void do_pcd_read(void)
811 pi_do_claimed(pcd_current
->pi
, pcd_start
);
814 static void do_pcd_read_drq(void)
816 unsigned long saved_flags
;
818 if (pcd_completion(pcd_current
, pcd_buffer
, "read block")) {
819 if (pcd_retries
< PCD_RETRIES
) {
822 pi_do_claimed(pcd_current
->pi
, pcd_start
);
831 spin_lock_irqsave(&pcd_lock
, saved_flags
);
832 do_pcd_request(pcd_queue
);
833 spin_unlock_irqrestore(&pcd_lock
, saved_flags
);
836 /* the audio_ioctl stuff is adapted from sr_ioctl.c */
838 static int pcd_audio_ioctl(struct cdrom_device_info
*cdi
, unsigned int cmd
, void *arg
)
840 struct pcd_unit
*cd
= cdi
->handle
;
844 case CDROMREADTOCHDR
:
848 { GPCMD_READ_TOC_PMA_ATIP
, 0, 0, 0, 0, 0, 0, 0, 12,
850 struct cdrom_tochdr
*tochdr
=
851 (struct cdrom_tochdr
*) arg
;
855 r
= pcd_atapi(cd
, cmd
, 12, buffer
, "read toc header");
857 tochdr
->cdth_trk0
= buffer
[2];
858 tochdr
->cdth_trk1
= buffer
[3];
863 case CDROMREADTOCENTRY
:
867 { GPCMD_READ_TOC_PMA_ATIP
, 0, 0, 0, 0, 0, 0, 0, 12,
870 struct cdrom_tocentry
*tocentry
=
871 (struct cdrom_tocentry
*) arg
;
872 unsigned char buffer
[32];
876 (tocentry
->cdte_format
== CDROM_MSF
? 0x02 : 0);
877 cmd
[6] = tocentry
->cdte_track
;
879 r
= pcd_atapi(cd
, cmd
, 12, buffer
, "read toc entry");
881 tocentry
->cdte_ctrl
= buffer
[5] & 0xf;
882 tocentry
->cdte_adr
= buffer
[5] >> 4;
883 tocentry
->cdte_datamode
=
884 (tocentry
->cdte_ctrl
& 0x04) ? 1 : 0;
885 if (tocentry
->cdte_format
== CDROM_MSF
) {
886 tocentry
->cdte_addr
.msf
.minute
= buffer
[9];
887 tocentry
->cdte_addr
.msf
.second
= buffer
[10];
888 tocentry
->cdte_addr
.msf
.frame
= buffer
[11];
890 tocentry
->cdte_addr
.lba
=
891 (((((buffer
[8] << 8) + buffer
[9]) << 8)
892 + buffer
[10]) << 8) + buffer
[11];
903 static int pcd_get_mcn(struct cdrom_device_info
*cdi
, struct cdrom_mcn
*mcn
)
906 { GPCMD_READ_SUBCHANNEL
, 0, 0x40, 2, 0, 0, 0, 0, 24, 0, 0, 0 };
909 if (pcd_atapi(cdi
->handle
, cmd
, 24, buffer
, "get mcn"))
912 memcpy(mcn
->medium_catalog_number
, buffer
+ 9, 13);
913 mcn
->medium_catalog_number
[13] = 0;
918 static int __init
pcd_init(void)
931 /* get the atapi capabilities page */
932 pcd_probe_capabilities();
934 if (register_blkdev(major
, name
)) {
935 for (unit
= 0, cd
= pcd
; unit
< PCD_UNITS
; unit
++, cd
++)
940 pcd_queue
= blk_init_queue(do_pcd_request
, &pcd_lock
);
942 unregister_blkdev(major
, name
);
943 for (unit
= 0, cd
= pcd
; unit
< PCD_UNITS
; unit
++, cd
++)
948 for (unit
= 0, cd
= pcd
; unit
< PCD_UNITS
; unit
++, cd
++) {
950 register_cdrom(&cd
->info
);
951 cd
->disk
->private_data
= cd
;
952 cd
->disk
->queue
= pcd_queue
;
960 static void __exit
pcd_exit(void)
965 for (unit
= 0, cd
= pcd
; unit
< PCD_UNITS
; unit
++, cd
++) {
967 del_gendisk(cd
->disk
);
969 unregister_cdrom(&cd
->info
);
973 blk_cleanup_queue(pcd_queue
);
974 unregister_blkdev(major
, name
);
977 MODULE_LICENSE("GPL");
978 module_init(pcd_init
)
979 module_exit(pcd_exit
)