1 /*
2 pcd.c (c) 1997-8 Grant R. Guenther <grant@torque.net>
3 Under the terms of the GNU General Public License.
4
5 This is a high-level driver for parallel port ATAPI CD-ROM
6 drives based on chips supported by the paride module.
7
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.
11
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:
15
16 drive0 These four arguments can be arrays of
17 drive1 1-6 integers as follows:
18 drive2
19 drive3 <prt>,<pro>,<uni>,<mod>,<slv>,<dly>
20
21 Where,
22
23 <prt> is the base of the parallel port address for
24 the corresponding drive. (required)
25
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)
30
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.
35 (0 if not given)
36
37 <mod> this can be -1 to choose the best mode, or one
38 of the mode numbers supported by the adapter.
39 (-1 if not given)
40
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
44 first drive found.
45
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)
52
53 major You may use this parameter to override the
54 default major number (46) that this driver
55 will use. Be sure to change the device
56 name as well.
57
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).
61 (default "pcd")
62
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
67 output. (default 0)
68
69 nice This parameter controls the driver's use of
70 idle CPU time, at the expense of some speed.
71
72 If this driver is built into the kernel, you can use the
73 following kernel command line parameters, with the same values
74 as the corresponding module parameters listed above:
75
76 pcd.drive0
77 pcd.drive1
78 pcd.drive2
79 pcd.drive3
80 pcd.nice
81
82 In addition, you can use the parameter pcd.disable to disable
83 the driver entirely.
84
85 */
86
87 /* Changes:
88
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
100
101 */
102
103 #define PCD_VERSION "1.07"
104 #define PCD_MAJOR 46
105 #define PCD_NAME "pcd"
106 #define PCD_UNITS 4
107
108 /* Here are things one can override from the insmod command.
109 Most are autoprobed by paride unless set here. Verbose is off
110 by default.
111
112 */
113
114 static int verbose = 0;
115 static int major = PCD_MAJOR;
116 static char *name = PCD_NAME;
117 static int nice = 0;
118 static int disable = 0;
119
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 };
124
125 static int (*drives[4])[6] = {&drive0, &drive1, &drive2, &drive3};
126 static int pcd_drive_count;
127
128 enum {D_PRT, D_PRO, D_UNI, D_MOD, D_SLV, D_DLY};
129
130 /* end of parameters */
131
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/blk-mq.h>
141 #include <linux/mutex.h>
142 #include <linux/uaccess.h>
143
144 static DEFINE_MUTEX(pcd_mutex);
145 static DEFINE_SPINLOCK(pcd_lock);
146
147 module_param(verbose, int, 0644);
148 module_param(major, int, 0);
149 module_param(name, charp, 0);
150 module_param(nice, int, 0);
151 module_param_array(drive0, int, NULL, 0);
152 module_param_array(drive1, int, NULL, 0);
153 module_param_array(drive2, int, NULL, 0);
154 module_param_array(drive3, int, NULL, 0);
155
156 #include "paride.h"
157 #include "pseudo.h"
158
159 #define PCD_RETRIES 5
160 #define PCD_TMO 800 /* timeout in jiffies */
161 #define PCD_DELAY 50 /* spin delay in uS */
162 #define PCD_READY_TMO 20 /* in seconds */
163 #define PCD_RESET_TMO 100 /* in tenths of a second */
164
165 #define PCD_SPIN (1000000*PCD_TMO)/(HZ*PCD_DELAY)
166
167 #define IDE_ERR 0x01
168 #define IDE_DRQ 0x08
169 #define IDE_READY 0x40
170 #define IDE_BUSY 0x80
171
172 static int pcd_open(struct cdrom_device_info *cdi, int purpose);
173 static void pcd_release(struct cdrom_device_info *cdi);
174 static int pcd_drive_status(struct cdrom_device_info *cdi, int slot_nr);
175 static unsigned int pcd_check_events(struct cdrom_device_info *cdi,
176 unsigned int clearing, int slot_nr);
177 static int pcd_tray_move(struct cdrom_device_info *cdi, int position);
178 static int pcd_lock_door(struct cdrom_device_info *cdi, int lock);
179 static int pcd_drive_reset(struct cdrom_device_info *cdi);
180 static int pcd_get_mcn(struct cdrom_device_info *cdi, struct cdrom_mcn *mcn);
181 static int pcd_audio_ioctl(struct cdrom_device_info *cdi,
182 unsigned int cmd, void *arg);
183 static int pcd_packet(struct cdrom_device_info *cdi,
184 struct packet_command *cgc);
185
186 static int pcd_detect(void);
187 static void pcd_probe_capabilities(void);
188 static void do_pcd_read_drq(void);
189 static blk_status_t pcd_queue_rq(struct blk_mq_hw_ctx *hctx,
190 const struct blk_mq_queue_data *bd);
191 static void do_pcd_read(void);
192
193 struct pcd_unit {
194 struct pi_adapter pia; /* interface to paride layer */
195 struct pi_adapter *pi;
196 int drive; /* master/slave */
197 int last_sense; /* result of last request sense */
198 int changed; /* media change seen */
199 int present; /* does this unit exist ? */
200 char *name; /* pcd0, pcd1, etc */
201 struct cdrom_device_info info; /* uniform cdrom interface */
202 struct gendisk *disk;
203 struct blk_mq_tag_set tag_set;
204 struct list_head rq_list;
205 };
206
207 static struct pcd_unit pcd[PCD_UNITS];
208
209 static char pcd_scratch[64];
210 static char pcd_buffer[2048]; /* raw block buffer */
211 static int pcd_bufblk = -1; /* block in buffer, in CD units,
212 -1 for nothing there. See also
213 pd_unit.
214 */
215
216 /* the variables below are used mainly in the I/O request engine, which
217 processes only one request at a time.
218 */
219
220 static struct pcd_unit *pcd_current; /* current request's drive */
221 static struct request *pcd_req;
222 static int pcd_retries; /* retries on current request */
223 static int pcd_busy; /* request being processed ? */
224 static int pcd_sector; /* address of next requested sector */
225 static int pcd_count; /* number of blocks still to do */
226 static char *pcd_buf; /* buffer for request in progress */
227 static void *par_drv; /* reference of parport driver */
228
229 /* kernel glue structures */
230
pcd_block_open(struct block_device * bdev,fmode_t mode)231 static int pcd_block_open(struct block_device *bdev, fmode_t mode)
232 {
233 struct pcd_unit *cd = bdev->bd_disk->private_data;
234 int ret;
235
236 bdev_check_media_change(bdev);
237
238 mutex_lock(&pcd_mutex);
239 ret = cdrom_open(&cd->info, bdev, mode);
240 mutex_unlock(&pcd_mutex);
241
242 return ret;
243 }
244
pcd_block_release(struct gendisk * disk,fmode_t mode)245 static void pcd_block_release(struct gendisk *disk, fmode_t mode)
246 {
247 struct pcd_unit *cd = disk->private_data;
248 mutex_lock(&pcd_mutex);
249 cdrom_release(&cd->info, mode);
250 mutex_unlock(&pcd_mutex);
251 }
252
pcd_block_ioctl(struct block_device * bdev,fmode_t mode,unsigned cmd,unsigned long arg)253 static int pcd_block_ioctl(struct block_device *bdev, fmode_t mode,
254 unsigned cmd, unsigned long arg)
255 {
256 struct pcd_unit *cd = bdev->bd_disk->private_data;
257 int ret;
258
259 mutex_lock(&pcd_mutex);
260 ret = cdrom_ioctl(&cd->info, bdev, mode, cmd, arg);
261 mutex_unlock(&pcd_mutex);
262
263 return ret;
264 }
265
pcd_block_check_events(struct gendisk * disk,unsigned int clearing)266 static unsigned int pcd_block_check_events(struct gendisk *disk,
267 unsigned int clearing)
268 {
269 struct pcd_unit *cd = disk->private_data;
270 return cdrom_check_events(&cd->info, clearing);
271 }
272
273 static const struct block_device_operations pcd_bdops = {
274 .owner = THIS_MODULE,
275 .open = pcd_block_open,
276 .release = pcd_block_release,
277 .ioctl = pcd_block_ioctl,
278 #ifdef CONFIG_COMPAT
279 .compat_ioctl = blkdev_compat_ptr_ioctl,
280 #endif
281 .check_events = pcd_block_check_events,
282 };
283
284 static const struct cdrom_device_ops pcd_dops = {
285 .open = pcd_open,
286 .release = pcd_release,
287 .drive_status = pcd_drive_status,
288 .check_events = pcd_check_events,
289 .tray_move = pcd_tray_move,
290 .lock_door = pcd_lock_door,
291 .get_mcn = pcd_get_mcn,
292 .reset = pcd_drive_reset,
293 .audio_ioctl = pcd_audio_ioctl,
294 .generic_packet = pcd_packet,
295 .capability = CDC_CLOSE_TRAY | CDC_OPEN_TRAY | CDC_LOCK |
296 CDC_MCN | CDC_MEDIA_CHANGED | CDC_RESET |
297 CDC_PLAY_AUDIO | CDC_GENERIC_PACKET | CDC_CD_R |
298 CDC_CD_RW,
299 };
300
301 static const struct blk_mq_ops pcd_mq_ops = {
302 .queue_rq = pcd_queue_rq,
303 };
304
pcd_init_units(void)305 static void pcd_init_units(void)
306 {
307 struct pcd_unit *cd;
308 int unit;
309
310 pcd_drive_count = 0;
311 for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++) {
312 struct gendisk *disk = alloc_disk(1);
313
314 if (!disk)
315 continue;
316
317 disk->queue = blk_mq_init_sq_queue(&cd->tag_set, &pcd_mq_ops,
318 1, BLK_MQ_F_SHOULD_MERGE);
319 if (IS_ERR(disk->queue)) {
320 disk->queue = NULL;
321 put_disk(disk);
322 continue;
323 }
324
325 INIT_LIST_HEAD(&cd->rq_list);
326 disk->queue->queuedata = cd;
327 blk_queue_bounce_limit(disk->queue, BLK_BOUNCE_HIGH);
328 cd->disk = disk;
329 cd->pi = &cd->pia;
330 cd->present = 0;
331 cd->last_sense = 0;
332 cd->changed = 1;
333 cd->drive = (*drives[unit])[D_SLV];
334 if ((*drives[unit])[D_PRT])
335 pcd_drive_count++;
336
337 cd->name = &cd->info.name[0];
338 snprintf(cd->name, sizeof(cd->info.name), "%s%d", name, unit);
339 cd->info.ops = &pcd_dops;
340 cd->info.handle = cd;
341 cd->info.speed = 0;
342 cd->info.capacity = 1;
343 cd->info.mask = 0;
344 disk->major = major;
345 disk->first_minor = unit;
346 strcpy(disk->disk_name, cd->name); /* umm... */
347 disk->fops = &pcd_bdops;
348 disk->flags = GENHD_FL_BLOCK_EVENTS_ON_EXCL_WRITE;
349 disk->events = DISK_EVENT_MEDIA_CHANGE;
350 }
351 }
352
pcd_open(struct cdrom_device_info * cdi,int purpose)353 static int pcd_open(struct cdrom_device_info *cdi, int purpose)
354 {
355 struct pcd_unit *cd = cdi->handle;
356 if (!cd->present)
357 return -ENODEV;
358 return 0;
359 }
360
pcd_release(struct cdrom_device_info * cdi)361 static void pcd_release(struct cdrom_device_info *cdi)
362 {
363 }
364
status_reg(struct pcd_unit * cd)365 static inline int status_reg(struct pcd_unit *cd)
366 {
367 return pi_read_regr(cd->pi, 1, 6);
368 }
369
read_reg(struct pcd_unit * cd,int reg)370 static inline int read_reg(struct pcd_unit *cd, int reg)
371 {
372 return pi_read_regr(cd->pi, 0, reg);
373 }
374
write_reg(struct pcd_unit * cd,int reg,int val)375 static inline void write_reg(struct pcd_unit *cd, int reg, int val)
376 {
377 pi_write_regr(cd->pi, 0, reg, val);
378 }
379
pcd_wait(struct pcd_unit * cd,int go,int stop,char * fun,char * msg)380 static int pcd_wait(struct pcd_unit *cd, int go, int stop, char *fun, char *msg)
381 {
382 int j, r, e, s, p;
383
384 j = 0;
385 while ((((r = status_reg(cd)) & go) || (stop && (!(r & stop))))
386 && (j++ < PCD_SPIN))
387 udelay(PCD_DELAY);
388
389 if ((r & (IDE_ERR & stop)) || (j > PCD_SPIN)) {
390 s = read_reg(cd, 7);
391 e = read_reg(cd, 1);
392 p = read_reg(cd, 2);
393 if (j > PCD_SPIN)
394 e |= 0x100;
395 if (fun)
396 printk("%s: %s %s: alt=0x%x stat=0x%x err=0x%x"
397 " loop=%d phase=%d\n",
398 cd->name, fun, msg, r, s, e, j, p);
399 return (s << 8) + r;
400 }
401 return 0;
402 }
403
pcd_command(struct pcd_unit * cd,char * cmd,int dlen,char * fun)404 static int pcd_command(struct pcd_unit *cd, char *cmd, int dlen, char *fun)
405 {
406 pi_connect(cd->pi);
407
408 write_reg(cd, 6, 0xa0 + 0x10 * cd->drive);
409
410 if (pcd_wait(cd, IDE_BUSY | IDE_DRQ, 0, fun, "before command")) {
411 pi_disconnect(cd->pi);
412 return -1;
413 }
414
415 write_reg(cd, 4, dlen % 256);
416 write_reg(cd, 5, dlen / 256);
417 write_reg(cd, 7, 0xa0); /* ATAPI packet command */
418
419 if (pcd_wait(cd, IDE_BUSY, IDE_DRQ, fun, "command DRQ")) {
420 pi_disconnect(cd->pi);
421 return -1;
422 }
423
424 if (read_reg(cd, 2) != 1) {
425 printk("%s: %s: command phase error\n", cd->name, fun);
426 pi_disconnect(cd->pi);
427 return -1;
428 }
429
430 pi_write_block(cd->pi, cmd, 12);
431
432 return 0;
433 }
434
pcd_completion(struct pcd_unit * cd,char * buf,char * fun)435 static int pcd_completion(struct pcd_unit *cd, char *buf, char *fun)
436 {
437 int r, d, p, n, k, j;
438
439 r = -1;
440 k = 0;
441 j = 0;
442
443 if (!pcd_wait(cd, IDE_BUSY, IDE_DRQ | IDE_READY | IDE_ERR,
444 fun, "completion")) {
445 r = 0;
446 while (read_reg(cd, 7) & IDE_DRQ) {
447 d = read_reg(cd, 4) + 256 * read_reg(cd, 5);
448 n = (d + 3) & 0xfffc;
449 p = read_reg(cd, 2) & 3;
450
451 if ((p == 2) && (n > 0) && (j == 0)) {
452 pi_read_block(cd->pi, buf, n);
453 if (verbose > 1)
454 printk("%s: %s: Read %d bytes\n",
455 cd->name, fun, n);
456 r = 0;
457 j++;
458 } else {
459 if (verbose > 1)
460 printk
461 ("%s: %s: Unexpected phase %d, d=%d, k=%d\n",
462 cd->name, fun, p, d, k);
463 if (verbose < 2)
464 printk_once(
465 "%s: WARNING: ATAPI phase errors\n",
466 cd->name);
467 mdelay(1);
468 }
469 if (k++ > PCD_TMO) {
470 printk("%s: Stuck DRQ\n", cd->name);
471 break;
472 }
473 if (pcd_wait
474 (cd, IDE_BUSY, IDE_DRQ | IDE_READY | IDE_ERR, fun,
475 "completion")) {
476 r = -1;
477 break;
478 }
479 }
480 }
481
482 pi_disconnect(cd->pi);
483
484 return r;
485 }
486
pcd_req_sense(struct pcd_unit * cd,char * fun)487 static void pcd_req_sense(struct pcd_unit *cd, char *fun)
488 {
489 char rs_cmd[12] = { 0x03, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0 };
490 char buf[16];
491 int r, c;
492
493 r = pcd_command(cd, rs_cmd, 16, "Request sense");
494 mdelay(1);
495 if (!r)
496 pcd_completion(cd, buf, "Request sense");
497
498 cd->last_sense = -1;
499 c = 2;
500 if (!r) {
501 if (fun)
502 printk("%s: %s: Sense key: %x, ASC: %x, ASQ: %x\n",
503 cd->name, fun, buf[2] & 0xf, buf[12], buf[13]);
504 c = buf[2] & 0xf;
505 cd->last_sense =
506 c | ((buf[12] & 0xff) << 8) | ((buf[13] & 0xff) << 16);
507 }
508 if ((c == 2) || (c == 6))
509 cd->changed = 1;
510 }
511
pcd_atapi(struct pcd_unit * cd,char * cmd,int dlen,char * buf,char * fun)512 static int pcd_atapi(struct pcd_unit *cd, char *cmd, int dlen, char *buf, char *fun)
513 {
514 int r;
515
516 r = pcd_command(cd, cmd, dlen, fun);
517 mdelay(1);
518 if (!r)
519 r = pcd_completion(cd, buf, fun);
520 if (r)
521 pcd_req_sense(cd, fun);
522
523 return r;
524 }
525
pcd_packet(struct cdrom_device_info * cdi,struct packet_command * cgc)526 static int pcd_packet(struct cdrom_device_info *cdi, struct packet_command *cgc)
527 {
528 return pcd_atapi(cdi->handle, cgc->cmd, cgc->buflen, cgc->buffer,
529 "generic packet");
530 }
531
532 #define DBMSG(msg) ((verbose>1)?(msg):NULL)
533
pcd_check_events(struct cdrom_device_info * cdi,unsigned int clearing,int slot_nr)534 static unsigned int pcd_check_events(struct cdrom_device_info *cdi,
535 unsigned int clearing, int slot_nr)
536 {
537 struct pcd_unit *cd = cdi->handle;
538 int res = cd->changed;
539 if (res)
540 cd->changed = 0;
541 return res ? DISK_EVENT_MEDIA_CHANGE : 0;
542 }
543
pcd_lock_door(struct cdrom_device_info * cdi,int lock)544 static int pcd_lock_door(struct cdrom_device_info *cdi, int lock)
545 {
546 char un_cmd[12] = { 0x1e, 0, 0, 0, lock, 0, 0, 0, 0, 0, 0, 0 };
547
548 return pcd_atapi(cdi->handle, un_cmd, 0, pcd_scratch,
549 lock ? "lock door" : "unlock door");
550 }
551
pcd_tray_move(struct cdrom_device_info * cdi,int position)552 static int pcd_tray_move(struct cdrom_device_info *cdi, int position)
553 {
554 char ej_cmd[12] = { 0x1b, 0, 0, 0, 3 - position, 0, 0, 0, 0, 0, 0, 0 };
555
556 return pcd_atapi(cdi->handle, ej_cmd, 0, pcd_scratch,
557 position ? "eject" : "close tray");
558 }
559
pcd_sleep(int cs)560 static void pcd_sleep(int cs)
561 {
562 schedule_timeout_interruptible(cs);
563 }
564
pcd_reset(struct pcd_unit * cd)565 static int pcd_reset(struct pcd_unit *cd)
566 {
567 int i, k, flg;
568 int expect[5] = { 1, 1, 1, 0x14, 0xeb };
569
570 pi_connect(cd->pi);
571 write_reg(cd, 6, 0xa0 + 0x10 * cd->drive);
572 write_reg(cd, 7, 8);
573
574 pcd_sleep(20 * HZ / 1000); /* delay a bit */
575
576 k = 0;
577 while ((k++ < PCD_RESET_TMO) && (status_reg(cd) & IDE_BUSY))
578 pcd_sleep(HZ / 10);
579
580 flg = 1;
581 for (i = 0; i < 5; i++)
582 flg &= (read_reg(cd, i + 1) == expect[i]);
583
584 if (verbose) {
585 printk("%s: Reset (%d) signature = ", cd->name, k);
586 for (i = 0; i < 5; i++)
587 printk("%3x", read_reg(cd, i + 1));
588 if (!flg)
589 printk(" (incorrect)");
590 printk("\n");
591 }
592
593 pi_disconnect(cd->pi);
594 return flg - 1;
595 }
596
pcd_drive_reset(struct cdrom_device_info * cdi)597 static int pcd_drive_reset(struct cdrom_device_info *cdi)
598 {
599 return pcd_reset(cdi->handle);
600 }
601
pcd_ready_wait(struct pcd_unit * cd,int tmo)602 static int pcd_ready_wait(struct pcd_unit *cd, int tmo)
603 {
604 char tr_cmd[12] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
605 int k, p;
606
607 k = 0;
608 while (k < tmo) {
609 cd->last_sense = 0;
610 pcd_atapi(cd, tr_cmd, 0, NULL, DBMSG("test unit ready"));
611 p = cd->last_sense;
612 if (!p)
613 return 0;
614 if (!(((p & 0xffff) == 0x0402) || ((p & 0xff) == 6)))
615 return p;
616 k++;
617 pcd_sleep(HZ);
618 }
619 return 0x000020; /* timeout */
620 }
621
pcd_drive_status(struct cdrom_device_info * cdi,int slot_nr)622 static int pcd_drive_status(struct cdrom_device_info *cdi, int slot_nr)
623 {
624 char rc_cmd[12] = { 0x25, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
625 struct pcd_unit *cd = cdi->handle;
626
627 if (pcd_ready_wait(cd, PCD_READY_TMO))
628 return CDS_DRIVE_NOT_READY;
629 if (pcd_atapi(cd, rc_cmd, 8, pcd_scratch, DBMSG("check media")))
630 return CDS_NO_DISC;
631 return CDS_DISC_OK;
632 }
633
pcd_identify(struct pcd_unit * cd,char * id)634 static int pcd_identify(struct pcd_unit *cd, char *id)
635 {
636 int k, s;
637 char id_cmd[12] = { 0x12, 0, 0, 0, 36, 0, 0, 0, 0, 0, 0, 0 };
638
639 pcd_bufblk = -1;
640
641 s = pcd_atapi(cd, id_cmd, 36, pcd_buffer, "identify");
642
643 if (s)
644 return -1;
645 if ((pcd_buffer[0] & 0x1f) != 5) {
646 if (verbose)
647 printk("%s: %s is not a CD-ROM\n",
648 cd->name, cd->drive ? "Slave" : "Master");
649 return -1;
650 }
651 memcpy(id, pcd_buffer + 16, 16);
652 id[16] = 0;
653 k = 16;
654 while ((k >= 0) && (id[k] <= 0x20)) {
655 id[k] = 0;
656 k--;
657 }
658
659 printk("%s: %s: %s\n", cd->name, cd->drive ? "Slave" : "Master", id);
660
661 return 0;
662 }
663
664 /*
665 * returns 0, with id set if drive is detected
666 * -1, if drive detection failed
667 */
pcd_probe(struct pcd_unit * cd,int ms,char * id)668 static int pcd_probe(struct pcd_unit *cd, int ms, char *id)
669 {
670 if (ms == -1) {
671 for (cd->drive = 0; cd->drive <= 1; cd->drive++)
672 if (!pcd_reset(cd) && !pcd_identify(cd, id))
673 return 0;
674 } else {
675 cd->drive = ms;
676 if (!pcd_reset(cd) && !pcd_identify(cd, id))
677 return 0;
678 }
679 return -1;
680 }
681
pcd_probe_capabilities(void)682 static void pcd_probe_capabilities(void)
683 {
684 int unit, r;
685 char buffer[32];
686 char cmd[12] = { 0x5a, 1 << 3, 0x2a, 0, 0, 0, 0, 18, 0, 0, 0, 0 };
687 struct pcd_unit *cd;
688
689 for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++) {
690 if (!cd->present)
691 continue;
692 r = pcd_atapi(cd, cmd, 18, buffer, "mode sense capabilities");
693 if (r)
694 continue;
695 /* we should now have the cap page */
696 if ((buffer[11] & 1) == 0)
697 cd->info.mask |= CDC_CD_R;
698 if ((buffer[11] & 2) == 0)
699 cd->info.mask |= CDC_CD_RW;
700 if ((buffer[12] & 1) == 0)
701 cd->info.mask |= CDC_PLAY_AUDIO;
702 if ((buffer[14] & 1) == 0)
703 cd->info.mask |= CDC_LOCK;
704 if ((buffer[14] & 8) == 0)
705 cd->info.mask |= CDC_OPEN_TRAY;
706 if ((buffer[14] >> 6) == 0)
707 cd->info.mask |= CDC_CLOSE_TRAY;
708 }
709 }
710
pcd_detect(void)711 static int pcd_detect(void)
712 {
713 char id[18];
714 int k, unit;
715 struct pcd_unit *cd;
716
717 printk("%s: %s version %s, major %d, nice %d\n",
718 name, name, PCD_VERSION, major, nice);
719
720 par_drv = pi_register_driver(name);
721 if (!par_drv) {
722 pr_err("failed to register %s driver\n", name);
723 return -1;
724 }
725
726 k = 0;
727 if (pcd_drive_count == 0) { /* nothing spec'd - so autoprobe for 1 */
728 cd = pcd;
729 if (cd->disk && pi_init(cd->pi, 1, -1, -1, -1, -1, -1,
730 pcd_buffer, PI_PCD, verbose, cd->name)) {
731 if (!pcd_probe(cd, -1, id)) {
732 cd->present = 1;
733 k++;
734 } else
735 pi_release(cd->pi);
736 }
737 } else {
738 for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++) {
739 int *conf = *drives[unit];
740 if (!conf[D_PRT])
741 continue;
742 if (!cd->disk)
743 continue;
744 if (!pi_init(cd->pi, 0, conf[D_PRT], conf[D_MOD],
745 conf[D_UNI], conf[D_PRO], conf[D_DLY],
746 pcd_buffer, PI_PCD, verbose, cd->name))
747 continue;
748 if (!pcd_probe(cd, conf[D_SLV], id)) {
749 cd->present = 1;
750 k++;
751 } else
752 pi_release(cd->pi);
753 }
754 }
755 if (k)
756 return 0;
757
758 printk("%s: No CD-ROM drive found\n", name);
759 for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++) {
760 if (!cd->disk)
761 continue;
762 blk_cleanup_queue(cd->disk->queue);
763 cd->disk->queue = NULL;
764 blk_mq_free_tag_set(&cd->tag_set);
765 put_disk(cd->disk);
766 }
767 pi_unregister_driver(par_drv);
768 return -1;
769 }
770
771 /* I/O request processing */
772 static int pcd_queue;
773
set_next_request(void)774 static int set_next_request(void)
775 {
776 struct pcd_unit *cd;
777 int old_pos = pcd_queue;
778
779 do {
780 cd = &pcd[pcd_queue];
781 if (++pcd_queue == PCD_UNITS)
782 pcd_queue = 0;
783 if (cd->present && !list_empty(&cd->rq_list)) {
784 pcd_req = list_first_entry(&cd->rq_list, struct request,
785 queuelist);
786 list_del_init(&pcd_req->queuelist);
787 blk_mq_start_request(pcd_req);
788 break;
789 }
790 } while (pcd_queue != old_pos);
791
792 return pcd_req != NULL;
793 }
794
pcd_request(void)795 static void pcd_request(void)
796 {
797 struct pcd_unit *cd;
798
799 if (pcd_busy)
800 return;
801
802 if (!pcd_req && !set_next_request())
803 return;
804
805 cd = pcd_req->rq_disk->private_data;
806 if (cd != pcd_current)
807 pcd_bufblk = -1;
808 pcd_current = cd;
809 pcd_sector = blk_rq_pos(pcd_req);
810 pcd_count = blk_rq_cur_sectors(pcd_req);
811 pcd_buf = bio_data(pcd_req->bio);
812 pcd_busy = 1;
813 ps_set_intr(do_pcd_read, NULL, 0, nice);
814 }
815
pcd_queue_rq(struct blk_mq_hw_ctx * hctx,const struct blk_mq_queue_data * bd)816 static blk_status_t pcd_queue_rq(struct blk_mq_hw_ctx *hctx,
817 const struct blk_mq_queue_data *bd)
818 {
819 struct pcd_unit *cd = hctx->queue->queuedata;
820
821 if (rq_data_dir(bd->rq) != READ) {
822 blk_mq_start_request(bd->rq);
823 return BLK_STS_IOERR;
824 }
825
826 spin_lock_irq(&pcd_lock);
827 list_add_tail(&bd->rq->queuelist, &cd->rq_list);
828 pcd_request();
829 spin_unlock_irq(&pcd_lock);
830
831 return BLK_STS_OK;
832 }
833
next_request(blk_status_t err)834 static inline void next_request(blk_status_t err)
835 {
836 unsigned long saved_flags;
837
838 spin_lock_irqsave(&pcd_lock, saved_flags);
839 if (!blk_update_request(pcd_req, err, blk_rq_cur_bytes(pcd_req))) {
840 __blk_mq_end_request(pcd_req, err);
841 pcd_req = NULL;
842 }
843 pcd_busy = 0;
844 pcd_request();
845 spin_unlock_irqrestore(&pcd_lock, saved_flags);
846 }
847
pcd_ready(void)848 static int pcd_ready(void)
849 {
850 return (((status_reg(pcd_current) & (IDE_BUSY | IDE_DRQ)) == IDE_DRQ));
851 }
852
pcd_transfer(void)853 static void pcd_transfer(void)
854 {
855
856 while (pcd_count && (pcd_sector / 4 == pcd_bufblk)) {
857 int o = (pcd_sector % 4) * 512;
858 memcpy(pcd_buf, pcd_buffer + o, 512);
859 pcd_count--;
860 pcd_buf += 512;
861 pcd_sector++;
862 }
863 }
864
pcd_start(void)865 static void pcd_start(void)
866 {
867 int b, i;
868 char rd_cmd[12] = { 0xa8, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 };
869
870 pcd_bufblk = pcd_sector / 4;
871 b = pcd_bufblk;
872 for (i = 0; i < 4; i++) {
873 rd_cmd[5 - i] = b & 0xff;
874 b = b >> 8;
875 }
876
877 if (pcd_command(pcd_current, rd_cmd, 2048, "read block")) {
878 pcd_bufblk = -1;
879 next_request(BLK_STS_IOERR);
880 return;
881 }
882
883 mdelay(1);
884
885 ps_set_intr(do_pcd_read_drq, pcd_ready, PCD_TMO, nice);
886 }
887
do_pcd_read(void)888 static void do_pcd_read(void)
889 {
890 pcd_busy = 1;
891 pcd_retries = 0;
892 pcd_transfer();
893 if (!pcd_count) {
894 next_request(0);
895 return;
896 }
897
898 pi_do_claimed(pcd_current->pi, pcd_start);
899 }
900
do_pcd_read_drq(void)901 static void do_pcd_read_drq(void)
902 {
903 unsigned long saved_flags;
904
905 if (pcd_completion(pcd_current, pcd_buffer, "read block")) {
906 if (pcd_retries < PCD_RETRIES) {
907 mdelay(1);
908 pcd_retries++;
909 pi_do_claimed(pcd_current->pi, pcd_start);
910 return;
911 }
912 pcd_bufblk = -1;
913 next_request(BLK_STS_IOERR);
914 return;
915 }
916
917 do_pcd_read();
918 spin_lock_irqsave(&pcd_lock, saved_flags);
919 pcd_request();
920 spin_unlock_irqrestore(&pcd_lock, saved_flags);
921 }
922
923 /* the audio_ioctl stuff is adapted from sr_ioctl.c */
924
pcd_audio_ioctl(struct cdrom_device_info * cdi,unsigned int cmd,void * arg)925 static int pcd_audio_ioctl(struct cdrom_device_info *cdi, unsigned int cmd, void *arg)
926 {
927 struct pcd_unit *cd = cdi->handle;
928
929 switch (cmd) {
930
931 case CDROMREADTOCHDR:
932
933 {
934 char cmd[12] =
935 { GPCMD_READ_TOC_PMA_ATIP, 0, 0, 0, 0, 0, 0, 0, 12,
936 0, 0, 0 };
937 struct cdrom_tochdr *tochdr =
938 (struct cdrom_tochdr *) arg;
939 char buffer[32];
940 int r;
941
942 r = pcd_atapi(cd, cmd, 12, buffer, "read toc header");
943
944 tochdr->cdth_trk0 = buffer[2];
945 tochdr->cdth_trk1 = buffer[3];
946
947 return r ? -EIO : 0;
948 }
949
950 case CDROMREADTOCENTRY:
951
952 {
953 char cmd[12] =
954 { GPCMD_READ_TOC_PMA_ATIP, 0, 0, 0, 0, 0, 0, 0, 12,
955 0, 0, 0 };
956
957 struct cdrom_tocentry *tocentry =
958 (struct cdrom_tocentry *) arg;
959 unsigned char buffer[32];
960 int r;
961
962 cmd[1] =
963 (tocentry->cdte_format == CDROM_MSF ? 0x02 : 0);
964 cmd[6] = tocentry->cdte_track;
965
966 r = pcd_atapi(cd, cmd, 12, buffer, "read toc entry");
967
968 tocentry->cdte_ctrl = buffer[5] & 0xf;
969 tocentry->cdte_adr = buffer[5] >> 4;
970 tocentry->cdte_datamode =
971 (tocentry->cdte_ctrl & 0x04) ? 1 : 0;
972 if (tocentry->cdte_format == CDROM_MSF) {
973 tocentry->cdte_addr.msf.minute = buffer[9];
974 tocentry->cdte_addr.msf.second = buffer[10];
975 tocentry->cdte_addr.msf.frame = buffer[11];
976 } else
977 tocentry->cdte_addr.lba =
978 (((((buffer[8] << 8) + buffer[9]) << 8)
979 + buffer[10]) << 8) + buffer[11];
980
981 return r ? -EIO : 0;
982 }
983
984 default:
985
986 return -ENOSYS;
987 }
988 }
989
pcd_get_mcn(struct cdrom_device_info * cdi,struct cdrom_mcn * mcn)990 static int pcd_get_mcn(struct cdrom_device_info *cdi, struct cdrom_mcn *mcn)
991 {
992 char cmd[12] =
993 { GPCMD_READ_SUBCHANNEL, 0, 0x40, 2, 0, 0, 0, 0, 24, 0, 0, 0 };
994 char buffer[32];
995
996 if (pcd_atapi(cdi->handle, cmd, 24, buffer, "get mcn"))
997 return -EIO;
998
999 memcpy(mcn->medium_catalog_number, buffer + 9, 13);
1000 mcn->medium_catalog_number[13] = 0;
1001
1002 return 0;
1003 }
1004
pcd_init(void)1005 static int __init pcd_init(void)
1006 {
1007 struct pcd_unit *cd;
1008 int unit;
1009
1010 if (disable)
1011 return -EINVAL;
1012
1013 pcd_init_units();
1014
1015 if (pcd_detect())
1016 return -ENODEV;
1017
1018 /* get the atapi capabilities page */
1019 pcd_probe_capabilities();
1020
1021 if (register_blkdev(major, name)) {
1022 for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++) {
1023 if (!cd->disk)
1024 continue;
1025
1026 blk_cleanup_queue(cd->disk->queue);
1027 blk_mq_free_tag_set(&cd->tag_set);
1028 put_disk(cd->disk);
1029 }
1030 return -EBUSY;
1031 }
1032
1033 for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++) {
1034 if (cd->present) {
1035 register_cdrom(cd->disk, &cd->info);
1036 cd->disk->private_data = cd;
1037 add_disk(cd->disk);
1038 }
1039 }
1040
1041 return 0;
1042 }
1043
pcd_exit(void)1044 static void __exit pcd_exit(void)
1045 {
1046 struct pcd_unit *cd;
1047 int unit;
1048
1049 for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++) {
1050 if (!cd->disk)
1051 continue;
1052
1053 if (cd->present) {
1054 del_gendisk(cd->disk);
1055 pi_release(cd->pi);
1056 unregister_cdrom(&cd->info);
1057 }
1058 blk_cleanup_queue(cd->disk->queue);
1059 blk_mq_free_tag_set(&cd->tag_set);
1060 put_disk(cd->disk);
1061 }
1062 unregister_blkdev(major, name);
1063 pi_unregister_driver(par_drv);
1064 }
1065
1066 MODULE_LICENSE("GPL");
1067 module_init(pcd_init)
1068 module_exit(pcd_exit)
1069