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