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 overide 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 kernel
73 the following 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/blkdev.h>
141 #include <asm/uaccess.h>
142
143 static DEFINE_SPINLOCK(pcd_lock);
144
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);
153
154 #include "paride.h"
155 #include "pseudo.h"
156
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 */
162
163 #define PCD_SPIN (1000000*PCD_TMO)/(HZ*PCD_DELAY)
164
165 #define IDE_ERR 0x01
166 #define IDE_DRQ 0x08
167 #define IDE_READY 0x40
168 #define IDE_BUSY 0x80
169
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);
182
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);
188
189 struct pcd_unit {
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;
199 };
200
201 static struct pcd_unit pcd[PCD_UNITS];
202
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
207 pd_unit.
208 */
209
210 /* the variables below are used mainly in the I/O request engine, which
211 processes only one request at a time.
212 */
213
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 */
221
222 static int pcd_warned; /* Have we logged a phase warning ? */
223
224 /* kernel glue structures */
225
226 static int pcd_block_open(struct block_device *bdev, fmode_t mode)
227 {
228 struct pcd_unit *cd = bdev->bd_disk->private_data;
229 return cdrom_open(&cd->info, bdev, mode);
230 }
231
232 static int pcd_block_release(struct gendisk *disk, fmode_t mode)
233 {
234 struct pcd_unit *cd = disk->private_data;
235 cdrom_release(&cd->info, mode);
236 return 0;
237 }
238
239 static int pcd_block_ioctl(struct block_device *bdev, fmode_t mode,
240 unsigned cmd, unsigned long arg)
241 {
242 struct pcd_unit *cd = bdev->bd_disk->private_data;
243 return cdrom_ioctl(&cd->info, bdev, mode, cmd, arg);
244 }
245
246 static int pcd_block_media_changed(struct gendisk *disk)
247 {
248 struct pcd_unit *cd = disk->private_data;
249 return cdrom_media_changed(&cd->info);
250 }
251
252 static struct block_device_operations pcd_bdops = {
253 .owner = THIS_MODULE,
254 .open = pcd_block_open,
255 .release = pcd_block_release,
256 .locked_ioctl = pcd_block_ioctl,
257 .media_changed = pcd_block_media_changed,
258 };
259
260 static struct cdrom_device_ops pcd_dops = {
261 .open = pcd_open,
262 .release = pcd_release,
263 .drive_status = pcd_drive_status,
264 .media_changed = pcd_media_changed,
265 .tray_move = pcd_tray_move,
266 .lock_door = pcd_lock_door,
267 .get_mcn = pcd_get_mcn,
268 .reset = pcd_drive_reset,
269 .audio_ioctl = pcd_audio_ioctl,
270 .generic_packet = pcd_packet,
271 .capability = CDC_CLOSE_TRAY | CDC_OPEN_TRAY | CDC_LOCK |
272 CDC_MCN | CDC_MEDIA_CHANGED | CDC_RESET |
273 CDC_PLAY_AUDIO | CDC_GENERIC_PACKET | CDC_CD_R |
274 CDC_CD_RW,
275 };
276
277 static void pcd_init_units(void)
278 {
279 struct pcd_unit *cd;
280 int unit;
281
282 pcd_drive_count = 0;
283 for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++) {
284 struct gendisk *disk = alloc_disk(1);
285 if (!disk)
286 continue;
287 cd->disk = disk;
288 cd->pi = &cd->pia;
289 cd->present = 0;
290 cd->last_sense = 0;
291 cd->changed = 1;
292 cd->drive = (*drives[unit])[D_SLV];
293 if ((*drives[unit])[D_PRT])
294 pcd_drive_count++;
295
296 cd->name = &cd->info.name[0];
297 snprintf(cd->name, sizeof(cd->info.name), "%s%d", name, unit);
298 cd->info.ops = &pcd_dops;
299 cd->info.handle = cd;
300 cd->info.speed = 0;
301 cd->info.capacity = 1;
302 cd->info.mask = 0;
303 disk->major = major;
304 disk->first_minor = unit;
305 strcpy(disk->disk_name, cd->name); /* umm... */
306 disk->fops = &pcd_bdops;
307 }
308 }
309
310 static int pcd_open(struct cdrom_device_info *cdi, int purpose)
311 {
312 struct pcd_unit *cd = cdi->handle;
313 if (!cd->present)
314 return -ENODEV;
315 return 0;
316 }
317
318 static void pcd_release(struct cdrom_device_info *cdi)
319 {
320 }
321
322 static inline int status_reg(struct pcd_unit *cd)
323 {
324 return pi_read_regr(cd->pi, 1, 6);
325 }
326
327 static inline int read_reg(struct pcd_unit *cd, int reg)
328 {
329 return pi_read_regr(cd->pi, 0, reg);
330 }
331
332 static inline void write_reg(struct pcd_unit *cd, int reg, int val)
333 {
334 pi_write_regr(cd->pi, 0, reg, val);
335 }
336
337 static int pcd_wait(struct pcd_unit *cd, int go, int stop, char *fun, char *msg)
338 {
339 int j, r, e, s, p;
340
341 j = 0;
342 while ((((r = status_reg(cd)) & go) || (stop && (!(r & stop))))
343 && (j++ < PCD_SPIN))
344 udelay(PCD_DELAY);
345
346 if ((r & (IDE_ERR & stop)) || (j >= PCD_SPIN)) {
347 s = read_reg(cd, 7);
348 e = read_reg(cd, 1);
349 p = read_reg(cd, 2);
350 if (j >= PCD_SPIN)
351 e |= 0x100;
352 if (fun)
353 printk("%s: %s %s: alt=0x%x stat=0x%x err=0x%x"
354 " loop=%d phase=%d\n",
355 cd->name, fun, msg, r, s, e, j, p);
356 return (s << 8) + r;
357 }
358 return 0;
359 }
360
361 static int pcd_command(struct pcd_unit *cd, char *cmd, int dlen, char *fun)
362 {
363 pi_connect(cd->pi);
364
365 write_reg(cd, 6, 0xa0 + 0x10 * cd->drive);
366
367 if (pcd_wait(cd, IDE_BUSY | IDE_DRQ, 0, fun, "before command")) {
368 pi_disconnect(cd->pi);
369 return -1;
370 }
371
372 write_reg(cd, 4, dlen % 256);
373 write_reg(cd, 5, dlen / 256);
374 write_reg(cd, 7, 0xa0); /* ATAPI packet command */
375
376 if (pcd_wait(cd, IDE_BUSY, IDE_DRQ, fun, "command DRQ")) {
377 pi_disconnect(cd->pi);
378 return -1;
379 }
380
381 if (read_reg(cd, 2) != 1) {
382 printk("%s: %s: command phase error\n", cd->name, fun);
383 pi_disconnect(cd->pi);
384 return -1;
385 }
386
387 pi_write_block(cd->pi, cmd, 12);
388
389 return 0;
390 }
391
392 static int pcd_completion(struct pcd_unit *cd, char *buf, char *fun)
393 {
394 int r, d, p, n, k, j;
395
396 r = -1;
397 k = 0;
398 j = 0;
399
400 if (!pcd_wait(cd, IDE_BUSY, IDE_DRQ | IDE_READY | IDE_ERR,
401 fun, "completion")) {
402 r = 0;
403 while (read_reg(cd, 7) & IDE_DRQ) {
404 d = read_reg(cd, 4) + 256 * read_reg(cd, 5);
405 n = (d + 3) & 0xfffc;
406 p = read_reg(cd, 2) & 3;
407
408 if ((p == 2) && (n > 0) && (j == 0)) {
409 pi_read_block(cd->pi, buf, n);
410 if (verbose > 1)
411 printk("%s: %s: Read %d bytes\n",
412 cd->name, fun, n);
413 r = 0;
414 j++;
415 } else {
416 if (verbose > 1)
417 printk
418 ("%s: %s: Unexpected phase %d, d=%d, k=%d\n",
419 cd->name, fun, p, d, k);
420 if ((verbose < 2) && !pcd_warned) {
421 pcd_warned = 1;
422 printk
423 ("%s: WARNING: ATAPI phase errors\n",
424 cd->name);
425 }
426 mdelay(1);
427 }
428 if (k++ > PCD_TMO) {
429 printk("%s: Stuck DRQ\n", cd->name);
430 break;
431 }
432 if (pcd_wait
433 (cd, IDE_BUSY, IDE_DRQ | IDE_READY | IDE_ERR, fun,
434 "completion")) {
435 r = -1;
436 break;
437 }
438 }
439 }
440
441 pi_disconnect(cd->pi);
442
443 return r;
444 }
445
446 static void pcd_req_sense(struct pcd_unit *cd, char *fun)
447 {
448 char rs_cmd[12] = { 0x03, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0 };
449 char buf[16];
450 int r, c;
451
452 r = pcd_command(cd, rs_cmd, 16, "Request sense");
453 mdelay(1);
454 if (!r)
455 pcd_completion(cd, buf, "Request sense");
456
457 cd->last_sense = -1;
458 c = 2;
459 if (!r) {
460 if (fun)
461 printk("%s: %s: Sense key: %x, ASC: %x, ASQ: %x\n",
462 cd->name, fun, buf[2] & 0xf, buf[12], buf[13]);
463 c = buf[2] & 0xf;
464 cd->last_sense =
465 c | ((buf[12] & 0xff) << 8) | ((buf[13] & 0xff) << 16);
466 }
467 if ((c == 2) || (c == 6))
468 cd->changed = 1;
469 }
470
471 static int pcd_atapi(struct pcd_unit *cd, char *cmd, int dlen, char *buf, char *fun)
472 {
473 int r;
474
475 r = pcd_command(cd, cmd, dlen, fun);
476 mdelay(1);
477 if (!r)
478 r = pcd_completion(cd, buf, fun);
479 if (r)
480 pcd_req_sense(cd, fun);
481
482 return r;
483 }
484
485 static int pcd_packet(struct cdrom_device_info *cdi, struct packet_command *cgc)
486 {
487 return pcd_atapi(cdi->handle, cgc->cmd, cgc->buflen, cgc->buffer,
488 "generic packet");
489 }
490
491 #define DBMSG(msg) ((verbose>1)?(msg):NULL)
492
493 static int pcd_media_changed(struct cdrom_device_info *cdi, int slot_nr)
494 {
495 struct pcd_unit *cd = cdi->handle;
496 int res = cd->changed;
497 if (res)
498 cd->changed = 0;
499 return res;
500 }
501
502 static int pcd_lock_door(struct cdrom_device_info *cdi, int lock)
503 {
504 char un_cmd[12] = { 0x1e, 0, 0, 0, lock, 0, 0, 0, 0, 0, 0, 0 };
505
506 return pcd_atapi(cdi->handle, un_cmd, 0, pcd_scratch,
507 lock ? "lock door" : "unlock door");
508 }
509
510 static int pcd_tray_move(struct cdrom_device_info *cdi, int position)
511 {
512 char ej_cmd[12] = { 0x1b, 0, 0, 0, 3 - position, 0, 0, 0, 0, 0, 0, 0 };
513
514 return pcd_atapi(cdi->handle, ej_cmd, 0, pcd_scratch,
515 position ? "eject" : "close tray");
516 }
517
518 static void pcd_sleep(int cs)
519 {
520 schedule_timeout_interruptible(cs);
521 }
522
523 static int pcd_reset(struct pcd_unit *cd)
524 {
525 int i, k, flg;
526 int expect[5] = { 1, 1, 1, 0x14, 0xeb };
527
528 pi_connect(cd->pi);
529 write_reg(cd, 6, 0xa0 + 0x10 * cd->drive);
530 write_reg(cd, 7, 8);
531
532 pcd_sleep(20 * HZ / 1000); /* delay a bit */
533
534 k = 0;
535 while ((k++ < PCD_RESET_TMO) && (status_reg(cd) & IDE_BUSY))
536 pcd_sleep(HZ / 10);
537
538 flg = 1;
539 for (i = 0; i < 5; i++)
540 flg &= (read_reg(cd, i + 1) == expect[i]);
541
542 if (verbose) {
543 printk("%s: Reset (%d) signature = ", cd->name, k);
544 for (i = 0; i < 5; i++)
545 printk("%3x", read_reg(cd, i + 1));
546 if (!flg)
547 printk(" (incorrect)");
548 printk("\n");
549 }
550
551 pi_disconnect(cd->pi);
552 return flg - 1;
553 }
554
555 static int pcd_drive_reset(struct cdrom_device_info *cdi)
556 {
557 return pcd_reset(cdi->handle);
558 }
559
560 static int pcd_ready_wait(struct pcd_unit *cd, int tmo)
561 {
562 char tr_cmd[12] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
563 int k, p;
564
565 k = 0;
566 while (k < tmo) {
567 cd->last_sense = 0;
568 pcd_atapi(cd, tr_cmd, 0, NULL, DBMSG("test unit ready"));
569 p = cd->last_sense;
570 if (!p)
571 return 0;
572 if (!(((p & 0xffff) == 0x0402) || ((p & 0xff) == 6)))
573 return p;
574 k++;
575 pcd_sleep(HZ);
576 }
577 return 0x000020; /* timeout */
578 }
579
580 static int pcd_drive_status(struct cdrom_device_info *cdi, int slot_nr)
581 {
582 char rc_cmd[12] = { 0x25, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
583 struct pcd_unit *cd = cdi->handle;
584
585 if (pcd_ready_wait(cd, PCD_READY_TMO))
586 return CDS_DRIVE_NOT_READY;
587 if (pcd_atapi(cd, rc_cmd, 8, pcd_scratch, DBMSG("check media")))
588 return CDS_NO_DISC;
589 return CDS_DISC_OK;
590 }
591
592 static int pcd_identify(struct pcd_unit *cd, char *id)
593 {
594 int k, s;
595 char id_cmd[12] = { 0x12, 0, 0, 0, 36, 0, 0, 0, 0, 0, 0, 0 };
596
597 pcd_bufblk = -1;
598
599 s = pcd_atapi(cd, id_cmd, 36, pcd_buffer, "identify");
600
601 if (s)
602 return -1;
603 if ((pcd_buffer[0] & 0x1f) != 5) {
604 if (verbose)
605 printk("%s: %s is not a CD-ROM\n",
606 cd->name, cd->drive ? "Slave" : "Master");
607 return -1;
608 }
609 memcpy(id, pcd_buffer + 16, 16);
610 id[16] = 0;
611 k = 16;
612 while ((k >= 0) && (id[k] <= 0x20)) {
613 id[k] = 0;
614 k--;
615 }
616
617 printk("%s: %s: %s\n", cd->name, cd->drive ? "Slave" : "Master", id);
618
619 return 0;
620 }
621
622 /*
623 * returns 0, with id set if drive is detected
624 * -1, if drive detection failed
625 */
626 static int pcd_probe(struct pcd_unit *cd, int ms, char *id)
627 {
628 if (ms == -1) {
629 for (cd->drive = 0; cd->drive <= 1; cd->drive++)
630 if (!pcd_reset(cd) && !pcd_identify(cd, id))
631 return 0;
632 } else {
633 cd->drive = ms;
634 if (!pcd_reset(cd) && !pcd_identify(cd, id))
635 return 0;
636 }
637 return -1;
638 }
639
640 static void pcd_probe_capabilities(void)
641 {
642 int unit, r;
643 char buffer[32];
644 char cmd[12] = { 0x5a, 1 << 3, 0x2a, 0, 0, 0, 0, 18, 0, 0, 0, 0 };
645 struct pcd_unit *cd;
646
647 for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++) {
648 if (!cd->present)
649 continue;
650 r = pcd_atapi(cd, cmd, 18, buffer, "mode sense capabilities");
651 if (r)
652 continue;
653 /* we should now have the cap page */
654 if ((buffer[11] & 1) == 0)
655 cd->info.mask |= CDC_CD_R;
656 if ((buffer[11] & 2) == 0)
657 cd->info.mask |= CDC_CD_RW;
658 if ((buffer[12] & 1) == 0)
659 cd->info.mask |= CDC_PLAY_AUDIO;
660 if ((buffer[14] & 1) == 0)
661 cd->info.mask |= CDC_LOCK;
662 if ((buffer[14] & 8) == 0)
663 cd->info.mask |= CDC_OPEN_TRAY;
664 if ((buffer[14] >> 6) == 0)
665 cd->info.mask |= CDC_CLOSE_TRAY;
666 }
667 }
668
669 static int pcd_detect(void)
670 {
671 char id[18];
672 int k, unit;
673 struct pcd_unit *cd;
674
675 printk("%s: %s version %s, major %d, nice %d\n",
676 name, name, PCD_VERSION, major, nice);
677
678 k = 0;
679 if (pcd_drive_count == 0) { /* nothing spec'd - so autoprobe for 1 */
680 cd = pcd;
681 if (pi_init(cd->pi, 1, -1, -1, -1, -1, -1, pcd_buffer,
682 PI_PCD, verbose, cd->name)) {
683 if (!pcd_probe(cd, -1, id) && cd->disk) {
684 cd->present = 1;
685 k++;
686 } else
687 pi_release(cd->pi);
688 }
689 } else {
690 for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++) {
691 int *conf = *drives[unit];
692 if (!conf[D_PRT])
693 continue;
694 if (!pi_init(cd->pi, 0, conf[D_PRT], conf[D_MOD],
695 conf[D_UNI], conf[D_PRO], conf[D_DLY],
696 pcd_buffer, PI_PCD, verbose, cd->name))
697 continue;
698 if (!pcd_probe(cd, conf[D_SLV], id) && cd->disk) {
699 cd->present = 1;
700 k++;
701 } else
702 pi_release(cd->pi);
703 }
704 }
705 if (k)
706 return 0;
707
708 printk("%s: No CD-ROM drive found\n", name);
709 for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++)
710 put_disk(cd->disk);
711 return -1;
712 }
713
714 /* I/O request processing */
715 static struct request_queue *pcd_queue;
716
717 static void do_pcd_request(struct request_queue * q)
718 {
719 if (pcd_busy)
720 return;
721 while (1) {
722 if (!pcd_req) {
723 pcd_req = blk_fetch_request(q);
724 if (!pcd_req)
725 return;
726 }
727
728 if (rq_data_dir(pcd_req) == READ) {
729 struct pcd_unit *cd = pcd_req->rq_disk->private_data;
730 if (cd != pcd_current)
731 pcd_bufblk = -1;
732 pcd_current = cd;
733 pcd_sector = blk_rq_pos(pcd_req);
734 pcd_count = blk_rq_cur_sectors(pcd_req);
735 pcd_buf = pcd_req->buffer;
736 pcd_busy = 1;
737 ps_set_intr(do_pcd_read, NULL, 0, nice);
738 return;
739 } else {
740 __blk_end_request_all(pcd_req, -EIO);
741 pcd_req = NULL;
742 }
743 }
744 }
745
746 static inline void next_request(int err)
747 {
748 unsigned long saved_flags;
749
750 spin_lock_irqsave(&pcd_lock, saved_flags);
751 if (!__blk_end_request_cur(pcd_req, err))
752 pcd_req = NULL;
753 pcd_busy = 0;
754 do_pcd_request(pcd_queue);
755 spin_unlock_irqrestore(&pcd_lock, saved_flags);
756 }
757
758 static int pcd_ready(void)
759 {
760 return (((status_reg(pcd_current) & (IDE_BUSY | IDE_DRQ)) == IDE_DRQ));
761 }
762
763 static void pcd_transfer(void)
764 {
765
766 while (pcd_count && (pcd_sector / 4 == pcd_bufblk)) {
767 int o = (pcd_sector % 4) * 512;
768 memcpy(pcd_buf, pcd_buffer + o, 512);
769 pcd_count--;
770 pcd_buf += 512;
771 pcd_sector++;
772 }
773 }
774
775 static void pcd_start(void)
776 {
777 int b, i;
778 char rd_cmd[12] = { 0xa8, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 };
779
780 pcd_bufblk = pcd_sector / 4;
781 b = pcd_bufblk;
782 for (i = 0; i < 4; i++) {
783 rd_cmd[5 - i] = b & 0xff;
784 b = b >> 8;
785 }
786
787 if (pcd_command(pcd_current, rd_cmd, 2048, "read block")) {
788 pcd_bufblk = -1;
789 next_request(-EIO);
790 return;
791 }
792
793 mdelay(1);
794
795 ps_set_intr(do_pcd_read_drq, pcd_ready, PCD_TMO, nice);
796 }
797
798 static void do_pcd_read(void)
799 {
800 pcd_busy = 1;
801 pcd_retries = 0;
802 pcd_transfer();
803 if (!pcd_count) {
804 next_request(0);
805 return;
806 }
807
808 pi_do_claimed(pcd_current->pi, pcd_start);
809 }
810
811 static void do_pcd_read_drq(void)
812 {
813 unsigned long saved_flags;
814
815 if (pcd_completion(pcd_current, pcd_buffer, "read block")) {
816 if (pcd_retries < PCD_RETRIES) {
817 mdelay(1);
818 pcd_retries++;
819 pi_do_claimed(pcd_current->pi, pcd_start);
820 return;
821 }
822 pcd_bufblk = -1;
823 next_request(-EIO);
824 return;
825 }
826
827 do_pcd_read();
828 spin_lock_irqsave(&pcd_lock, saved_flags);
829 do_pcd_request(pcd_queue);
830 spin_unlock_irqrestore(&pcd_lock, saved_flags);
831 }
832
833 /* the audio_ioctl stuff is adapted from sr_ioctl.c */
834
835 static int pcd_audio_ioctl(struct cdrom_device_info *cdi, unsigned int cmd, void *arg)
836 {
837 struct pcd_unit *cd = cdi->handle;
838
839 switch (cmd) {
840
841 case CDROMREADTOCHDR:
842
843 {
844 char cmd[12] =
845 { GPCMD_READ_TOC_PMA_ATIP, 0, 0, 0, 0, 0, 0, 0, 12,
846 0, 0, 0 };
847 struct cdrom_tochdr *tochdr =
848 (struct cdrom_tochdr *) arg;
849 char buffer[32];
850 int r;
851
852 r = pcd_atapi(cd, cmd, 12, buffer, "read toc header");
853
854 tochdr->cdth_trk0 = buffer[2];
855 tochdr->cdth_trk1 = buffer[3];
856
857 return r ? -EIO : 0;
858 }
859
860 case CDROMREADTOCENTRY:
861
862 {
863 char cmd[12] =
864 { GPCMD_READ_TOC_PMA_ATIP, 0, 0, 0, 0, 0, 0, 0, 12,
865 0, 0, 0 };
866
867 struct cdrom_tocentry *tocentry =
868 (struct cdrom_tocentry *) arg;
869 unsigned char buffer[32];
870 int r;
871
872 cmd[1] =
873 (tocentry->cdte_format == CDROM_MSF ? 0x02 : 0);
874 cmd[6] = tocentry->cdte_track;
875
876 r = pcd_atapi(cd, cmd, 12, buffer, "read toc entry");
877
878 tocentry->cdte_ctrl = buffer[5] & 0xf;
879 tocentry->cdte_adr = buffer[5] >> 4;
880 tocentry->cdte_datamode =
881 (tocentry->cdte_ctrl & 0x04) ? 1 : 0;
882 if (tocentry->cdte_format == CDROM_MSF) {
883 tocentry->cdte_addr.msf.minute = buffer[9];
884 tocentry->cdte_addr.msf.second = buffer[10];
885 tocentry->cdte_addr.msf.frame = buffer[11];
886 } else
887 tocentry->cdte_addr.lba =
888 (((((buffer[8] << 8) + buffer[9]) << 8)
889 + buffer[10]) << 8) + buffer[11];
890
891 return r ? -EIO : 0;
892 }
893
894 default:
895
896 return -ENOSYS;
897 }
898 }
899
900 static int pcd_get_mcn(struct cdrom_device_info *cdi, struct cdrom_mcn *mcn)
901 {
902 char cmd[12] =
903 { GPCMD_READ_SUBCHANNEL, 0, 0x40, 2, 0, 0, 0, 0, 24, 0, 0, 0 };
904 char buffer[32];
905
906 if (pcd_atapi(cdi->handle, cmd, 24, buffer, "get mcn"))
907 return -EIO;
908
909 memcpy(mcn->medium_catalog_number, buffer + 9, 13);
910 mcn->medium_catalog_number[13] = 0;
911
912 return 0;
913 }
914
915 static int __init pcd_init(void)
916 {
917 struct pcd_unit *cd;
918 int unit;
919
920 if (disable)
921 return -EINVAL;
922
923 pcd_init_units();
924
925 if (pcd_detect())
926 return -ENODEV;
927
928 /* get the atapi capabilities page */
929 pcd_probe_capabilities();
930
931 if (register_blkdev(major, name)) {
932 for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++)
933 put_disk(cd->disk);
934 return -EBUSY;
935 }
936
937 pcd_queue = blk_init_queue(do_pcd_request, &pcd_lock);
938 if (!pcd_queue) {
939 unregister_blkdev(major, name);
940 for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++)
941 put_disk(cd->disk);
942 return -ENOMEM;
943 }
944
945 for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++) {
946 if (cd->present) {
947 register_cdrom(&cd->info);
948 cd->disk->private_data = cd;
949 cd->disk->queue = pcd_queue;
950 add_disk(cd->disk);
951 }
952 }
953
954 return 0;
955 }
956
957 static void __exit pcd_exit(void)
958 {
959 struct pcd_unit *cd;
960 int unit;
961
962 for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++) {
963 if (cd->present) {
964 del_gendisk(cd->disk);
965 pi_release(cd->pi);
966 unregister_cdrom(&cd->info);
967 }
968 put_disk(cd->disk);
969 }
970 blk_cleanup_queue(pcd_queue);
971 unregister_blkdev(major, name);
972 }
973
974 MODULE_LICENSE("GPL");
975 module_init(pcd_init)
976 module_exit(pcd_exit)
977
|
This page was automatically generated by the
LXR engine.
|