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 DEFINE_SPINLOCK(pcd_lock);
145 module_param(verbose, bool, 0644);
146 module_param(major, int, 0);
147 module_param(name, charp, 0);
148 module_param(nice, int, 0);
149 module_param_array(drive0, int, NULL, 0);
150 module_param_array(drive1, int, NULL, 0);
151 module_param_array(drive2, int, NULL, 0);
152 module_param_array(drive3, int, NULL, 0);
157 #define PCD_RETRIES 5
158 #define PCD_TMO 800 /* timeout in jiffies */
159 #define PCD_DELAY 50 /* spin delay in uS */
160 #define PCD_READY_TMO 20 /* in seconds */
161 #define PCD_RESET_TMO 100 /* in tenths of a second */
163 #define PCD_SPIN (1000000*PCD_TMO)/(HZ*PCD_DELAY)
167 #define IDE_READY 0x40
168 #define IDE_BUSY 0x80
170 static int pcd_open(struct cdrom_device_info *cdi, int purpose);
171 static void pcd_release(struct cdrom_device_info *cdi);
172 static int pcd_drive_status(struct cdrom_device_info *cdi, int slot_nr);
173 static int pcd_media_changed(struct cdrom_device_info *cdi, int slot_nr);
174 static int pcd_tray_move(struct cdrom_device_info *cdi, int position);
175 static int pcd_lock_door(struct cdrom_device_info *cdi, int lock);
176 static int pcd_drive_reset(struct cdrom_device_info *cdi);
177 static int pcd_get_mcn(struct cdrom_device_info *cdi, struct cdrom_mcn *mcn);
178 static int pcd_audio_ioctl(struct cdrom_device_info *cdi,
179 unsigned int cmd, void *arg);
180 static int pcd_packet(struct cdrom_device_info *cdi,
181 struct packet_command *cgc);
183 static int pcd_detect(void);
184 static void pcd_probe_capabilities(void);
185 static void do_pcd_read_drq(void);
186 static void do_pcd_request(struct request_queue * q);
187 static void do_pcd_read(void);
190 struct pi_adapter pia; /* interface to paride layer */
191 struct pi_adapter *pi;
192 int drive; /* master/slave */
193 int last_sense; /* result of last request sense */
194 int changed; /* media change seen */
195 int present; /* does this unit exist ? */
196 char *name; /* pcd0, pcd1, etc */
197 struct cdrom_device_info info; /* uniform cdrom interface */
198 struct gendisk *disk;
201 static struct pcd_unit pcd[PCD_UNITS];
203 static char pcd_scratch[64];
204 static char pcd_buffer[2048]; /* raw block buffer */
205 static int pcd_bufblk = -1; /* block in buffer, in CD units,
206 -1 for nothing there. See also
210 /* the variables below are used mainly in the I/O request engine, which
211 processes only one request at a time.
214 static struct pcd_unit *pcd_current; /* current request's drive */
215 static struct request *pcd_req;
216 static int pcd_retries; /* retries on current request */
217 static int pcd_busy; /* request being processed ? */
218 static int pcd_sector; /* address of next requested sector */
219 static int pcd_count; /* number of blocks still to do */
220 static char *pcd_buf; /* buffer for request in progress */
222 static int pcd_warned; /* Have we logged a phase warning ? */
224 /* kernel glue structures */
226 static int pcd_block_open(struct inode *inode, struct file *file)
228 struct pcd_unit *cd = inode->i_bdev->bd_disk->private_data;
229 return cdrom_open(&cd->info, inode->i_bdev, file->f_mode);
232 static int pcd_block_release(struct inode *inode, struct file *file)
234 struct pcd_unit *cd = inode->i_bdev->bd_disk->private_data;
235 cdrom_release(&cd->info, file ? file->f_mode : 0);
239 static int pcd_block_ioctl(struct inode *inode, struct file *file,
240 unsigned cmd, unsigned long arg)
242 struct pcd_unit *cd = inode->i_bdev->bd_disk->private_data;
243 return cdrom_ioctl(&cd->info, inode->i_bdev,
244 file ? file->f_mode : 0, cmd, arg);
247 static int pcd_block_media_changed(struct gendisk *disk)
249 struct pcd_unit *cd = disk->private_data;
250 return cdrom_media_changed(&cd->info);
253 static struct block_device_operations pcd_bdops = {
254 .owner = THIS_MODULE,
255 .open = pcd_block_open,
256 .release = pcd_block_release,
257 .ioctl = pcd_block_ioctl,
258 .media_changed = pcd_block_media_changed,
261 static struct cdrom_device_ops pcd_dops = {
263 .release = pcd_release,
264 .drive_status = pcd_drive_status,
265 .media_changed = pcd_media_changed,
266 .tray_move = pcd_tray_move,
267 .lock_door = pcd_lock_door,
268 .get_mcn = pcd_get_mcn,
269 .reset = pcd_drive_reset,
270 .audio_ioctl = pcd_audio_ioctl,
271 .generic_packet = pcd_packet,
272 .capability = CDC_CLOSE_TRAY | CDC_OPEN_TRAY | CDC_LOCK |
273 CDC_MCN | CDC_MEDIA_CHANGED | CDC_RESET |
274 CDC_PLAY_AUDIO | CDC_GENERIC_PACKET | CDC_CD_R |
278 static void pcd_init_units(void)
284 for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++) {
285 struct gendisk *disk = alloc_disk(1);
293 cd->drive = (*drives[unit])[D_SLV];
294 if ((*drives[unit])[D_PRT])
297 cd->name = &cd->info.name[0];
298 snprintf(cd->name, sizeof(cd->info.name), "%s%d", name, unit);
299 cd->info.ops = &pcd_dops;
300 cd->info.handle = cd;
302 cd->info.capacity = 1;
305 disk->first_minor = unit;
306 strcpy(disk->disk_name, cd->name); /* umm... */
307 disk->fops = &pcd_bdops;
311 static int pcd_open(struct cdrom_device_info *cdi, int purpose)
313 struct pcd_unit *cd = cdi->handle;
319 static void pcd_release(struct cdrom_device_info *cdi)
323 static inline int status_reg(struct pcd_unit *cd)
325 return pi_read_regr(cd->pi, 1, 6);
328 static inline int read_reg(struct pcd_unit *cd, int reg)
330 return pi_read_regr(cd->pi, 0, reg);
333 static inline void write_reg(struct pcd_unit *cd, int reg, int val)
335 pi_write_regr(cd->pi, 0, reg, val);
338 static int pcd_wait(struct pcd_unit *cd, int go, int stop, char *fun, char *msg)
343 while ((((r = status_reg(cd)) & go) || (stop && (!(r & stop))))
347 if ((r & (IDE_ERR & stop)) || (j >= PCD_SPIN)) {
354 printk("%s: %s %s: alt=0x%x stat=0x%x err=0x%x"
355 " loop=%d phase=%d\n",
356 cd->name, fun, msg, r, s, e, j, p);
362 static int pcd_command(struct pcd_unit *cd, char *cmd, int dlen, char *fun)
366 write_reg(cd, 6, 0xa0 + 0x10 * cd->drive);
368 if (pcd_wait(cd, IDE_BUSY | IDE_DRQ, 0, fun, "before command")) {
369 pi_disconnect(cd->pi);
373 write_reg(cd, 4, dlen % 256);
374 write_reg(cd, 5, dlen / 256);
375 write_reg(cd, 7, 0xa0); /* ATAPI packet command */
377 if (pcd_wait(cd, IDE_BUSY, IDE_DRQ, fun, "command DRQ")) {
378 pi_disconnect(cd->pi);
382 if (read_reg(cd, 2) != 1) {
383 printk("%s: %s: command phase error\n", cd->name, fun);
384 pi_disconnect(cd->pi);
388 pi_write_block(cd->pi, cmd, 12);
393 static int pcd_completion(struct pcd_unit *cd, char *buf, char *fun)
395 int r, d, p, n, k, j;
401 if (!pcd_wait(cd, IDE_BUSY, IDE_DRQ | IDE_READY | IDE_ERR,
402 fun, "completion")) {
404 while (read_reg(cd, 7) & IDE_DRQ) {
405 d = read_reg(cd, 4) + 256 * read_reg(cd, 5);
406 n = (d + 3) & 0xfffc;
407 p = read_reg(cd, 2) & 3;
409 if ((p == 2) && (n > 0) && (j == 0)) {
410 pi_read_block(cd->pi, buf, n);
412 printk("%s: %s: Read %d bytes\n",
419 ("%s: %s: Unexpected phase %d, d=%d, k=%d\n",
420 cd->name, fun, p, d, k);
421 if ((verbose < 2) && !pcd_warned) {
424 ("%s: WARNING: ATAPI phase errors\n",
430 printk("%s: Stuck DRQ\n", cd->name);
434 (cd, IDE_BUSY, IDE_DRQ | IDE_READY | IDE_ERR, fun,
442 pi_disconnect(cd->pi);
447 static void pcd_req_sense(struct pcd_unit *cd, char *fun)
449 char rs_cmd[12] = { 0x03, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0 };
453 r = pcd_command(cd, rs_cmd, 16, "Request sense");
456 pcd_completion(cd, buf, "Request sense");
462 printk("%s: %s: Sense key: %x, ASC: %x, ASQ: %x\n",
463 cd->name, fun, buf[2] & 0xf, buf[12], buf[13]);
466 c | ((buf[12] & 0xff) << 8) | ((buf[13] & 0xff) << 16);
468 if ((c == 2) || (c == 6))
472 static int pcd_atapi(struct pcd_unit *cd, char *cmd, int dlen, char *buf, char *fun)
476 r = pcd_command(cd, cmd, dlen, fun);
479 r = pcd_completion(cd, buf, fun);
481 pcd_req_sense(cd, fun);
486 static int pcd_packet(struct cdrom_device_info *cdi, struct packet_command *cgc)
488 return pcd_atapi(cdi->handle, cgc->cmd, cgc->buflen, cgc->buffer,
492 #define DBMSG(msg) ((verbose>1)?(msg):NULL)
494 static int pcd_media_changed(struct cdrom_device_info *cdi, int slot_nr)
496 struct pcd_unit *cd = cdi->handle;
497 int res = cd->changed;
503 static int pcd_lock_door(struct cdrom_device_info *cdi, int lock)
505 char un_cmd[12] = { 0x1e, 0, 0, 0, lock, 0, 0, 0, 0, 0, 0, 0 };
507 return pcd_atapi(cdi->handle, un_cmd, 0, pcd_scratch,
508 lock ? "lock door" : "unlock door");
511 static int pcd_tray_move(struct cdrom_device_info *cdi, int position)
513 char ej_cmd[12] = { 0x1b, 0, 0, 0, 3 - position, 0, 0, 0, 0, 0, 0, 0 };
515 return pcd_atapi(cdi->handle, ej_cmd, 0, pcd_scratch,
516 position ? "eject" : "close tray");
519 static void pcd_sleep(int cs)
521 schedule_timeout_interruptible(cs);
524 static int pcd_reset(struct pcd_unit *cd)
527 int expect[5] = { 1, 1, 1, 0x14, 0xeb };
530 write_reg(cd, 6, 0xa0 + 0x10 * cd->drive);
533 pcd_sleep(20 * HZ / 1000); /* delay a bit */
536 while ((k++ < PCD_RESET_TMO) && (status_reg(cd) & IDE_BUSY))
540 for (i = 0; i < 5; i++)
541 flg &= (read_reg(cd, i + 1) == expect[i]);
544 printk("%s: Reset (%d) signature = ", cd->name, k);
545 for (i = 0; i < 5; i++)
546 printk("%3x", read_reg(cd, i + 1));
548 printk(" (incorrect)");
552 pi_disconnect(cd->pi);
556 static int pcd_drive_reset(struct cdrom_device_info *cdi)
558 return pcd_reset(cdi->handle);
561 static int pcd_ready_wait(struct pcd_unit *cd, int tmo)
563 char tr_cmd[12] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
569 pcd_atapi(cd, tr_cmd, 0, NULL, DBMSG("test unit ready"));
573 if (!(((p & 0xffff) == 0x0402) || ((p & 0xff) == 6)))
578 return 0x000020; /* timeout */
581 static int pcd_drive_status(struct cdrom_device_info *cdi, int slot_nr)
583 char rc_cmd[12] = { 0x25, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
584 struct pcd_unit *cd = cdi->handle;
586 if (pcd_ready_wait(cd, PCD_READY_TMO))
587 return CDS_DRIVE_NOT_READY;
588 if (pcd_atapi(cd, rc_cmd, 8, pcd_scratch, DBMSG("check media")))
593 static int pcd_identify(struct pcd_unit *cd, char *id)
596 char id_cmd[12] = { 0x12, 0, 0, 0, 36, 0, 0, 0, 0, 0, 0, 0 };
600 s = pcd_atapi(cd, id_cmd, 36, pcd_buffer, "identify");
604 if ((pcd_buffer[0] & 0x1f) != 5) {
606 printk("%s: %s is not a CD-ROM\n",
607 cd->name, cd->drive ? "Slave" : "Master");
610 memcpy(id, pcd_buffer + 16, 16);
613 while ((k >= 0) && (id[k] <= 0x20)) {
618 printk("%s: %s: %s\n", cd->name, cd->drive ? "Slave" : "Master", id);
624 * returns 0, with id set if drive is detected
625 * -1, if drive detection failed
627 static int pcd_probe(struct pcd_unit *cd, int ms, char *id)
630 for (cd->drive = 0; cd->drive <= 1; cd->drive++)
631 if (!pcd_reset(cd) && !pcd_identify(cd, id))
635 if (!pcd_reset(cd) && !pcd_identify(cd, id))
641 static void pcd_probe_capabilities(void)
645 char cmd[12] = { 0x5a, 1 << 3, 0x2a, 0, 0, 0, 0, 18, 0, 0, 0, 0 };
648 for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++) {
651 r = pcd_atapi(cd, cmd, 18, buffer, "mode sense capabilities");
654 /* we should now have the cap page */
655 if ((buffer[11] & 1) == 0)
656 cd->info.mask |= CDC_CD_R;
657 if ((buffer[11] & 2) == 0)
658 cd->info.mask |= CDC_CD_RW;
659 if ((buffer[12] & 1) == 0)
660 cd->info.mask |= CDC_PLAY_AUDIO;
661 if ((buffer[14] & 1) == 0)
662 cd->info.mask |= CDC_LOCK;
663 if ((buffer[14] & 8) == 0)
664 cd->info.mask |= CDC_OPEN_TRAY;
665 if ((buffer[14] >> 6) == 0)
666 cd->info.mask |= CDC_CLOSE_TRAY;
670 static int pcd_detect(void)
676 printk("%s: %s version %s, major %d, nice %d\n",
677 name, name, PCD_VERSION, major, nice);
680 if (pcd_drive_count == 0) { /* nothing spec'd - so autoprobe for 1 */
682 if (pi_init(cd->pi, 1, -1, -1, -1, -1, -1, pcd_buffer,
683 PI_PCD, verbose, cd->name)) {
684 if (!pcd_probe(cd, -1, id) && cd->disk) {
691 for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++) {
692 int *conf = *drives[unit];
695 if (!pi_init(cd->pi, 0, conf[D_PRT], conf[D_MOD],
696 conf[D_UNI], conf[D_PRO], conf[D_DLY],
697 pcd_buffer, PI_PCD, verbose, cd->name))
699 if (!pcd_probe(cd, conf[D_SLV], id) && cd->disk) {
709 printk("%s: No CD-ROM drive found\n", name);
710 for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++)
715 /* I/O request processing */
716 static struct request_queue *pcd_queue;
718 static void do_pcd_request(struct request_queue * q)
723 pcd_req = elv_next_request(q);
727 if (rq_data_dir(pcd_req) == READ) {
728 struct pcd_unit *cd = pcd_req->rq_disk->private_data;
729 if (cd != pcd_current)
732 pcd_sector = pcd_req->sector;
733 pcd_count = pcd_req->current_nr_sectors;
734 pcd_buf = pcd_req->buffer;
736 ps_set_intr(do_pcd_read, NULL, 0, nice);
739 end_request(pcd_req, 0);
743 static inline void next_request(int success)
745 unsigned long saved_flags;
747 spin_lock_irqsave(&pcd_lock, saved_flags);
748 end_request(pcd_req, success);
750 do_pcd_request(pcd_queue);
751 spin_unlock_irqrestore(&pcd_lock, saved_flags);
754 static int pcd_ready(void)
756 return (((status_reg(pcd_current) & (IDE_BUSY | IDE_DRQ)) == IDE_DRQ));
759 static void pcd_transfer(void)
762 while (pcd_count && (pcd_sector / 4 == pcd_bufblk)) {
763 int o = (pcd_sector % 4) * 512;
764 memcpy(pcd_buf, pcd_buffer + o, 512);
771 static void pcd_start(void)
774 char rd_cmd[12] = { 0xa8, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 };
776 pcd_bufblk = pcd_sector / 4;
778 for (i = 0; i < 4; i++) {
779 rd_cmd[5 - i] = b & 0xff;
783 if (pcd_command(pcd_current, rd_cmd, 2048, "read block")) {
791 ps_set_intr(do_pcd_read_drq, pcd_ready, PCD_TMO, nice);
794 static void do_pcd_read(void)
804 pi_do_claimed(pcd_current->pi, pcd_start);
807 static void do_pcd_read_drq(void)
809 unsigned long saved_flags;
811 if (pcd_completion(pcd_current, pcd_buffer, "read block")) {
812 if (pcd_retries < PCD_RETRIES) {
815 pi_do_claimed(pcd_current->pi, pcd_start);
824 spin_lock_irqsave(&pcd_lock, saved_flags);
825 do_pcd_request(pcd_queue);
826 spin_unlock_irqrestore(&pcd_lock, saved_flags);
829 /* the audio_ioctl stuff is adapted from sr_ioctl.c */
831 static int pcd_audio_ioctl(struct cdrom_device_info *cdi, unsigned int cmd, void *arg)
833 struct pcd_unit *cd = cdi->handle;
837 case CDROMREADTOCHDR:
841 { GPCMD_READ_TOC_PMA_ATIP, 0, 0, 0, 0, 0, 0, 0, 12,
843 struct cdrom_tochdr *tochdr =
844 (struct cdrom_tochdr *) arg;
848 r = pcd_atapi(cd, cmd, 12, buffer, "read toc header");
850 tochdr->cdth_trk0 = buffer[2];
851 tochdr->cdth_trk1 = buffer[3];
856 case CDROMREADTOCENTRY:
860 { GPCMD_READ_TOC_PMA_ATIP, 0, 0, 0, 0, 0, 0, 0, 12,
863 struct cdrom_tocentry *tocentry =
864 (struct cdrom_tocentry *) arg;
865 unsigned char buffer[32];
869 (tocentry->cdte_format == CDROM_MSF ? 0x02 : 0);
870 cmd[6] = tocentry->cdte_track;
872 r = pcd_atapi(cd, cmd, 12, buffer, "read toc entry");
874 tocentry->cdte_ctrl = buffer[5] & 0xf;
875 tocentry->cdte_adr = buffer[5] >> 4;
876 tocentry->cdte_datamode =
877 (tocentry->cdte_ctrl & 0x04) ? 1 : 0;
878 if (tocentry->cdte_format == CDROM_MSF) {
879 tocentry->cdte_addr.msf.minute = buffer[9];
880 tocentry->cdte_addr.msf.second = buffer[10];
881 tocentry->cdte_addr.msf.frame = buffer[11];
883 tocentry->cdte_addr.lba =
884 (((((buffer[8] << 8) + buffer[9]) << 8)
885 + buffer[10]) << 8) + buffer[11];
896 static int pcd_get_mcn(struct cdrom_device_info *cdi, struct cdrom_mcn *mcn)
899 { GPCMD_READ_SUBCHANNEL, 0, 0x40, 2, 0, 0, 0, 0, 24, 0, 0, 0 };
902 if (pcd_atapi(cdi->handle, cmd, 24, buffer, "get mcn"))
905 memcpy(mcn->medium_catalog_number, buffer + 9, 13);
906 mcn->medium_catalog_number[13] = 0;
911 static int __init pcd_init(void)
924 /* get the atapi capabilities page */
925 pcd_probe_capabilities();
927 if (register_blkdev(major, name)) {
928 for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++)
933 pcd_queue = blk_init_queue(do_pcd_request, &pcd_lock);
935 unregister_blkdev(major, name);
936 for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++)
941 for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++) {
943 register_cdrom(&cd->info);
944 cd->disk->private_data = cd;
945 cd->disk->queue = pcd_queue;
953 static void __exit pcd_exit(void)
958 for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++) {
960 del_gendisk(cd->disk);
962 unregister_cdrom(&cd->info);
966 blk_cleanup_queue(pcd_queue);
967 unregister_blkdev(major, name);
970 MODULE_LICENSE("GPL");
971 module_init(pcd_init)
972 module_exit(pcd_exit)