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