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 <asm/uaccess.h>
143 static spinlock_t pcd_lock;
149 static STT pcd_stt[6] = {
150 {"drive0", 6, drive0},
151 {"drive1", 6, drive1},
152 {"drive2", 6, drive2},
153 {"drive3", 6, drive3},
154 {"disable", 1, &disable},
158 void pcd_setup(char *str, int *ints)
160 generic_setup(pcd_stt, 6, str);
165 MODULE_PARM(verbose, "i");
166 MODULE_PARM(major, "i");
167 MODULE_PARM(name, "s");
168 MODULE_PARM(nice, "i");
169 MODULE_PARM(drive0, "1-6i");
170 MODULE_PARM(drive1, "1-6i");
171 MODULE_PARM(drive2, "1-6i");
172 MODULE_PARM(drive3, "1-6i");
177 #define PCD_RETRIES 5
178 #define PCD_TMO 800 /* timeout in jiffies */
179 #define PCD_DELAY 50 /* spin delay in uS */
180 #define PCD_READY_TMO 20 /* in seconds */
181 #define PCD_RESET_TMO 100 /* in tenths of a second */
183 #define PCD_SPIN (1000000*PCD_TMO)/(HZ*PCD_DELAY)
187 #define IDE_READY 0x40
188 #define IDE_BUSY 0x80
190 static int pcd_open(struct cdrom_device_info *cdi, int purpose);
191 static void pcd_release(struct cdrom_device_info *cdi);
192 static int pcd_drive_status(struct cdrom_device_info *cdi, int slot_nr);
193 static int pcd_media_changed(struct cdrom_device_info *cdi, int slot_nr);
194 static int pcd_tray_move(struct cdrom_device_info *cdi, int position);
195 static int pcd_lock_door(struct cdrom_device_info *cdi, int lock);
196 static int pcd_drive_reset(struct cdrom_device_info *cdi);
197 static int pcd_get_mcn(struct cdrom_device_info *cdi, struct cdrom_mcn *mcn);
198 static int pcd_audio_ioctl(struct cdrom_device_info *cdi,
199 unsigned int cmd, void *arg);
200 static int pcd_packet(struct cdrom_device_info *cdi,
201 struct cdrom_generic_command *cgc);
203 static int pcd_detect(void);
204 static void pcd_probe_capabilities(void);
205 static void do_pcd_read_drq(void);
206 static void do_pcd_request(request_queue_t * q);
207 static void do_pcd_read(void);
210 struct pi_adapter pia; /* interface to paride layer */
211 struct pi_adapter *pi;
212 int drive; /* master/slave */
213 int last_sense; /* result of last request sense */
214 int changed; /* media change seen */
215 int present; /* does this unit exist ? */
216 char *name; /* pcd0, pcd1, etc */
217 struct cdrom_device_info info; /* uniform cdrom interface */
218 struct gendisk *disk;
221 struct pcd_unit pcd[PCD_UNITS];
223 static char pcd_scratch[64];
224 static char pcd_buffer[2048]; /* raw block buffer */
225 static int pcd_bufblk = -1; /* block in buffer, in CD units,
226 -1 for nothing there. See also
230 /* the variables below are used mainly in the I/O request engine, which
231 processes only one request at a time.
234 static struct pcd_unit *pcd_current; /* current request's drive */
235 static struct request *pcd_req;
236 static int pcd_retries; /* retries on current request */
237 static int pcd_busy; /* request being processed ? */
238 static int pcd_sector; /* address of next requested sector */
239 static int pcd_count; /* number of blocks still to do */
240 static char *pcd_buf; /* buffer for request in progress */
242 static int pcd_warned; /* Have we logged a phase warning ? */
244 /* kernel glue structures */
246 static int pcd_block_open(struct inode *inode, struct file *file)
248 struct pcd_unit *cd = inode->i_bdev->bd_disk->private_data;
249 return cdrom_open(&cd->info, inode, file);
252 static int pcd_block_release(struct inode *inode, struct file *file)
254 struct pcd_unit *cd = inode->i_bdev->bd_disk->private_data;
255 return cdrom_release(&cd->info, file);
258 static int pcd_block_ioctl(struct inode *inode, struct file *file,
259 unsigned cmd, unsigned long arg)
261 struct pcd_unit *cd = inode->i_bdev->bd_disk->private_data;
262 return cdrom_ioctl(&cd->info, inode, cmd, arg);
265 static int pcd_block_media_changed(struct gendisk *disk)
267 struct pcd_unit *cd = disk->private_data;
268 return cdrom_media_changed(&cd->info);
271 static struct block_device_operations pcd_bdops = {
272 .owner = THIS_MODULE,
273 .open = pcd_block_open,
274 .release = pcd_block_release,
275 .ioctl = pcd_block_ioctl,
276 .media_changed = pcd_block_media_changed,
279 static struct cdrom_device_ops pcd_dops = {
281 .release = pcd_release,
282 .drive_status = pcd_drive_status,
283 .media_changed = pcd_media_changed,
284 .tray_move = pcd_tray_move,
285 .lock_door = pcd_lock_door,
286 .get_mcn = pcd_get_mcn,
287 .reset = pcd_drive_reset,
288 .audio_ioctl = pcd_audio_ioctl,
289 .generic_packet = pcd_packet,
290 .capability = CDC_CLOSE_TRAY | CDC_OPEN_TRAY | CDC_LOCK |
291 CDC_MCN | CDC_MEDIA_CHANGED | CDC_RESET |
292 CDC_PLAY_AUDIO | CDC_GENERIC_PACKET | CDC_CD_R |
296 static void pcd_init_units(void)
302 for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++) {
303 struct gendisk *disk = alloc_disk(1);
311 cd->drive = (*drives[unit])[D_SLV];
312 if ((*drives[unit])[D_PRT])
315 cd->name = &cd->info.name[0];
316 snprintf(cd->name, sizeof(cd->info.name), "%s%d", name, unit);
317 cd->info.ops = &pcd_dops;
318 cd->info.handle = cd;
320 cd->info.capacity = 1;
323 disk->first_minor = unit;
324 strcpy(disk->disk_name, cd->name); /* umm... */
325 disk->fops = &pcd_bdops;
329 static int pcd_open(struct cdrom_device_info *cdi, int purpose)
331 struct pcd_unit *cd = cdi->handle;
337 static void pcd_release(struct cdrom_device_info *cdi)
341 static inline int status_reg(struct pcd_unit *cd)
343 return pi_read_regr(cd->pi, 1, 6);
346 static inline int read_reg(struct pcd_unit *cd, int reg)
348 return pi_read_regr(cd->pi, 0, reg);
351 static inline void write_reg(struct pcd_unit *cd, int reg, int val)
353 pi_write_regr(cd->pi, 0, reg, val);
356 static int pcd_wait(struct pcd_unit *cd, int go, int stop, char *fun, char *msg)
361 while ((((r = status_reg(cd)) & go) || (stop && (!(r & stop))))
365 if ((r & (IDE_ERR & stop)) || (j >= PCD_SPIN)) {
372 printk("%s: %s %s: alt=0x%x stat=0x%x err=0x%x"
373 " loop=%d phase=%d\n",
374 cd->name, fun, msg, r, s, e, j, p);
380 static int pcd_command(struct pcd_unit *cd, char *cmd, int dlen, char *fun)
384 write_reg(cd, 6, 0xa0 + 0x10 * cd->drive);
386 if (pcd_wait(cd, IDE_BUSY | IDE_DRQ, 0, fun, "before command")) {
387 pi_disconnect(cd->pi);
391 write_reg(cd, 4, dlen % 256);
392 write_reg(cd, 5, dlen / 256);
393 write_reg(cd, 7, 0xa0); /* ATAPI packet command */
395 if (pcd_wait(cd, IDE_BUSY, IDE_DRQ, fun, "command DRQ")) {
396 pi_disconnect(cd->pi);
400 if (read_reg(cd, 2) != 1) {
401 printk("%s: %s: command phase error\n", cd->name, fun);
402 pi_disconnect(cd->pi);
406 pi_write_block(cd->pi, cmd, 12);
411 static int pcd_completion(struct pcd_unit *cd, char *buf, char *fun)
413 int r, d, p, n, k, j;
419 if (!pcd_wait(cd, IDE_BUSY, IDE_DRQ | IDE_READY | IDE_ERR,
420 fun, "completion")) {
422 while (read_reg(cd, 7) & IDE_DRQ) {
423 d = read_reg(cd, 4) + 256 * read_reg(cd, 5);
424 n = (d + 3) & 0xfffc;
425 p = read_reg(cd, 2) & 3;
427 if ((p == 2) && (n > 0) && (j == 0)) {
428 pi_read_block(cd->pi, buf, n);
430 printk("%s: %s: Read %d bytes\n",
437 ("%s: %s: Unexpected phase %d, d=%d, k=%d\n",
438 cd->name, fun, p, d, k);
439 if ((verbose < 2) && !pcd_warned) {
442 ("%s: WARNING: ATAPI phase errors\n",
448 printk("%s: Stuck DRQ\n", cd->name);
452 (cd, IDE_BUSY, IDE_DRQ | IDE_READY | IDE_ERR, fun,
460 pi_disconnect(cd->pi);
465 static void pcd_req_sense(struct pcd_unit *cd, char *fun)
467 char rs_cmd[12] = { 0x03, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0 };
471 r = pcd_command(cd, rs_cmd, 16, "Request sense");
474 pcd_completion(cd, buf, "Request sense");
480 printk("%s: %s: Sense key: %x, ASC: %x, ASQ: %x\n",
481 cd->name, fun, buf[2] & 0xf, buf[12], buf[13]);
484 c | ((buf[12] & 0xff) << 8) | ((buf[13] & 0xff) << 16);
486 if ((c == 2) || (c == 6))
490 static int pcd_atapi(struct pcd_unit *cd, char *cmd, int dlen, char *buf, char *fun)
494 r = pcd_command(cd, cmd, dlen, fun);
497 r = pcd_completion(cd, buf, fun);
499 pcd_req_sense(cd, fun);
504 static int pcd_packet(struct cdrom_device_info *cdi, struct cdrom_generic_command *cgc)
506 return pcd_atapi(cdi->handle, cgc->cmd, cgc->buflen, cgc->buffer,
510 #define DBMSG(msg) ((verbose>1)?(msg):NULL)
512 static int pcd_media_changed(struct cdrom_device_info *cdi, int slot_nr)
514 struct pcd_unit *cd = cdi->handle;
515 int res = cd->changed;
521 static int pcd_lock_door(struct cdrom_device_info *cdi, int lock)
523 char un_cmd[12] = { 0x1e, 0, 0, 0, lock, 0, 0, 0, 0, 0, 0, 0 };
525 return pcd_atapi(cdi->handle, un_cmd, 0, pcd_scratch,
526 lock ? "lock door" : "unlock door");
529 static int pcd_tray_move(struct cdrom_device_info *cdi, int position)
531 char ej_cmd[12] = { 0x1b, 0, 0, 0, 3 - position, 0, 0, 0, 0, 0, 0, 0 };
533 return pcd_atapi(cdi->handle, ej_cmd, 0, pcd_scratch,
534 position ? "eject" : "close tray");
537 static void pcd_sleep(int cs)
539 current->state = TASK_INTERRUPTIBLE;
540 schedule_timeout(cs);
543 static int pcd_reset(struct pcd_unit *cd)
546 int expect[5] = { 1, 1, 1, 0x14, 0xeb };
549 write_reg(cd, 6, 0xa0 + 0x10 * cd->drive);
552 pcd_sleep(20 * HZ / 1000); /* delay a bit */
555 while ((k++ < PCD_RESET_TMO) && (status_reg(cd) & IDE_BUSY))
559 for (i = 0; i < 5; i++)
560 flg &= (read_reg(cd, i + 1) == expect[i]);
563 printk("%s: Reset (%d) signature = ", cd->name, k);
564 for (i = 0; i < 5; i++)
565 printk("%3x", read_reg(cd, i + 1));
567 printk(" (incorrect)");
571 pi_disconnect(cd->pi);
575 static int pcd_drive_reset(struct cdrom_device_info *cdi)
577 return pcd_reset(cdi->handle);
580 static int pcd_ready_wait(struct pcd_unit *cd, int tmo)
582 char tr_cmd[12] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
588 pcd_atapi(cd, tr_cmd, 0, NULL, DBMSG("test unit ready"));
592 if (!(((p & 0xffff) == 0x0402) || ((p & 0xff) == 6)))
597 return 0x000020; /* timeout */
600 static int pcd_drive_status(struct cdrom_device_info *cdi, int slot_nr)
602 char rc_cmd[12] = { 0x25, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
603 struct pcd_unit *cd = cdi->handle;
605 if (pcd_ready_wait(cd, PCD_READY_TMO))
606 return CDS_DRIVE_NOT_READY;
607 if (pcd_atapi(cd, rc_cmd, 8, pcd_scratch, DBMSG("check media")))
612 static int pcd_identify(struct pcd_unit *cd, char *id)
615 char id_cmd[12] = { 0x12, 0, 0, 0, 36, 0, 0, 0, 0, 0, 0, 0 };
619 s = pcd_atapi(cd, id_cmd, 36, pcd_buffer, "identify");
623 if ((pcd_buffer[0] & 0x1f) != 5) {
625 printk("%s: %s is not a CD-ROM\n",
626 cd->name, cd->drive ? "Slave" : "Master");
629 memcpy(id, pcd_buffer + 16, 16);
632 while ((k >= 0) && (id[k] <= 0x20)) {
637 printk("%s: %s: %s\n", cd->name, cd->drive ? "Slave" : "Master", id);
643 * returns 0, with id set if drive is detected
644 * -1, if drive detection failed
646 static int pcd_probe(struct pcd_unit *cd, int ms, char *id)
649 for (cd->drive = 0; cd->drive <= 1; cd->drive++)
650 if (!pcd_reset(cd) && !pcd_identify(cd, id))
654 if (!pcd_reset(cd) && !pcd_identify(cd, id))
660 static void pcd_probe_capabilities(void)
664 char cmd[12] = { 0x5a, 1 << 3, 0x2a, 0, 0, 0, 0, 18, 0, 0, 0, 0 };
667 for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++) {
670 r = pcd_atapi(cd, cmd, 18, buffer, "mode sense capabilities");
673 /* we should now have the cap page */
674 if ((buffer[11] & 1) == 0)
675 cd->info.mask |= CDC_CD_R;
676 if ((buffer[11] & 2) == 0)
677 cd->info.mask |= CDC_CD_RW;
678 if ((buffer[12] & 1) == 0)
679 cd->info.mask |= CDC_PLAY_AUDIO;
680 if ((buffer[14] & 1) == 0)
681 cd->info.mask |= CDC_LOCK;
682 if ((buffer[14] & 8) == 0)
683 cd->info.mask |= CDC_OPEN_TRAY;
684 if ((buffer[14] >> 6) == 0)
685 cd->info.mask |= CDC_CLOSE_TRAY;
689 static int pcd_detect(void)
695 printk("%s: %s version %s, major %d, nice %d\n",
696 name, name, PCD_VERSION, major, nice);
699 if (pcd_drive_count == 0) { /* nothing spec'd - so autoprobe for 1 */
701 if (pi_init(cd->pi, 1, -1, -1, -1, -1, -1, pcd_buffer,
702 PI_PCD, verbose, cd->name)) {
703 if (!pcd_probe(cd, -1, id) && cd->disk) {
710 for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++) {
711 int *conf = *drives[unit];
714 if (!pi_init(cd->pi, 0, conf[D_PRT], conf[D_MOD],
715 conf[D_UNI], conf[D_PRO], conf[D_DLY],
716 pcd_buffer, PI_PCD, verbose, cd->name))
718 if (!pcd_probe(cd, conf[D_SLV], id) && cd->disk) {
728 printk("%s: No CD-ROM drive found\n", name);
729 for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++)
734 /* I/O request processing */
735 static struct request_queue *pcd_queue;
737 static void do_pcd_request(request_queue_t * q)
742 pcd_req = elv_next_request(q);
746 if (rq_data_dir(pcd_req) == READ) {
747 struct pcd_unit *cd = pcd_req->rq_disk->private_data;
748 if (cd != pcd_current)
751 pcd_sector = pcd_req->sector;
752 pcd_count = pcd_req->current_nr_sectors;
753 pcd_buf = pcd_req->buffer;
755 ps_set_intr(do_pcd_read, 0, 0, nice);
758 end_request(pcd_req, 0);
762 static inline void next_request(int success)
764 unsigned long saved_flags;
766 spin_lock_irqsave(&pcd_lock, saved_flags);
767 end_request(pcd_req, success);
769 do_pcd_request(pcd_queue);
770 spin_unlock_irqrestore(&pcd_lock, saved_flags);
773 static int pcd_ready(void)
775 return (((status_reg(pcd_current) & (IDE_BUSY | IDE_DRQ)) == IDE_DRQ));
778 static void pcd_transfer(void)
781 while (pcd_count && (pcd_sector / 4 == pcd_bufblk)) {
782 int o = (pcd_sector % 4) * 512;
783 memcpy(pcd_buf, pcd_buffer + o, 512);
790 static void pcd_start(void)
793 char rd_cmd[12] = { 0xa8, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 };
795 pcd_bufblk = pcd_sector / 4;
797 for (i = 0; i < 4; i++) {
798 rd_cmd[5 - i] = b & 0xff;
802 if (pcd_command(pcd_current, rd_cmd, 2048, "read block")) {
810 ps_set_intr(do_pcd_read_drq, pcd_ready, PCD_TMO, nice);
813 static void do_pcd_read(void)
823 pi_do_claimed(pcd_current->pi, pcd_start);
826 static void do_pcd_read_drq(void)
828 unsigned long saved_flags;
830 if (pcd_completion(pcd_current, pcd_buffer, "read block")) {
831 if (pcd_retries < PCD_RETRIES) {
834 pi_do_claimed(pcd_current->pi, pcd_start);
843 spin_lock_irqsave(&pcd_lock, saved_flags);
844 do_pcd_request(pcd_queue);
845 spin_unlock_irqrestore(&pcd_lock, saved_flags);
848 /* the audio_ioctl stuff is adapted from sr_ioctl.c */
850 static int pcd_audio_ioctl(struct cdrom_device_info *cdi, unsigned int cmd, void *arg)
852 struct pcd_unit *cd = cdi->handle;
856 case CDROMREADTOCHDR:
860 { GPCMD_READ_TOC_PMA_ATIP, 0, 0, 0, 0, 0, 0, 0, 12,
862 struct cdrom_tochdr *tochdr =
863 (struct cdrom_tochdr *) arg;
867 r = pcd_atapi(cd, cmd, 12, buffer, "read toc header");
869 tochdr->cdth_trk0 = buffer[2];
870 tochdr->cdth_trk1 = buffer[3];
875 case CDROMREADTOCENTRY:
879 { GPCMD_READ_TOC_PMA_ATIP, 0, 0, 0, 0, 0, 0, 0, 12,
882 struct cdrom_tocentry *tocentry =
883 (struct cdrom_tocentry *) arg;
884 unsigned char buffer[32];
888 (tocentry->cdte_format == CDROM_MSF ? 0x02 : 0);
889 cmd[6] = tocentry->cdte_track;
891 r = pcd_atapi(cd, cmd, 12, buffer, "read toc entry");
893 tocentry->cdte_ctrl = buffer[5] & 0xf;
894 tocentry->cdte_adr = buffer[5] >> 4;
895 tocentry->cdte_datamode =
896 (tocentry->cdte_ctrl & 0x04) ? 1 : 0;
897 if (tocentry->cdte_format == CDROM_MSF) {
898 tocentry->cdte_addr.msf.minute = buffer[9];
899 tocentry->cdte_addr.msf.second = buffer[10];
900 tocentry->cdte_addr.msf.frame = buffer[11];
902 tocentry->cdte_addr.lba =
903 (((((buffer[8] << 8) + buffer[9]) << 8)
904 + buffer[10]) << 8) + buffer[11];
915 static int pcd_get_mcn(struct cdrom_device_info *cdi, struct cdrom_mcn *mcn)
918 { GPCMD_READ_SUBCHANNEL, 0, 0x40, 2, 0, 0, 0, 0, 24, 0, 0, 0 };
921 if (pcd_atapi(cdi->handle, cmd, 24, buffer, "get mcn"))
924 memcpy(mcn->medium_catalog_number, buffer + 9, 13);
925 mcn->medium_catalog_number[13] = 0;
930 static int __init pcd_init(void)
943 /* get the atapi capabilities page */
944 pcd_probe_capabilities();
946 if (register_blkdev(major, name)) {
947 for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++)
952 pcd_queue = blk_init_queue(do_pcd_request, &pcd_lock);
954 unregister_blkdev(major, name);
955 for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++)
960 for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++) {
962 register_cdrom(&cd->info);
963 cd->disk->private_data = cd;
964 cd->disk->queue = pcd_queue;
972 static void __exit pcd_exit(void)
977 for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++) {
979 del_gendisk(cd->disk);
981 unregister_cdrom(&cd->info);
985 blk_cleanup_queue(pcd_queue);
986 unregister_blkdev(major, name);
989 MODULE_LICENSE("GPL");
990 module_init(pcd_init)
991 module_exit(pcd_exit)