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