1 /*
2         pf.c    (c) 1997-8  Grant R. Guenther <grant@torque.net>
3                             Under the terms of the GNU General Public License.
4 
5         This is the high-level driver for parallel port ATAPI disk
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 disk drive, but if their individual parameters are
10         specified, the driver can handle up to 4 drives.
11 
12         The behaviour of the pf 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-7 integers as follows:
18             drive2
19             drive3      <prt>,<pro>,<uni>,<mod>,<slv>,<lun>,<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 CDroms 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 		<lun>   Some ATAPI devices support multiple LUNs.
47                         One example is the ATAPI PD/CD drive from
48                         Matshita/Panasonic.  This device has a
49                         CD drive on LUN 0 and a PD drive on LUN 1.
50                         By default, the driver will search for the
51                         first LUN with a supported device.  Set
52                         this parameter to force it to use a specific
53                         LUN.  (default -1)
54 
55                 <dly>   some parallel ports require the driver to
56                         go more slowly.  -1 sets a default value that
57                         should work with the chosen protocol.  Otherwise,
58                         set this to a small integer, the larger it is
59                         the slower the port i/o.  In some cases, setting
60                         this to zero will speed up the device. (default -1)
61 
62 	    major	You may use this parameter to overide the
63 			default major number (47) that this driver
64 			will use.  Be sure to change the device
65 			name as well.
66 
67 	    name	This parameter is a character string that
68 			contains the name the kernel will use for this
69 			device (in /proc output, for instance).
70 			(default "pf").
71 
72             cluster     The driver will attempt to aggregate requests
73                         for adjacent blocks into larger multi-block
74                         clusters.  The maximum cluster size (in 512
75                         byte sectors) is set with this parameter.
76                         (default 64)
77 
78             verbose     This parameter controls the amount of logging
79                         that the driver will do.  Set it to 0 for
80                         normal operation, 1 to see autoprobe progress
81                         messages, or 2 to see additional debugging
82                         output.  (default 0)
83 
84 	    nice        This parameter controls the driver's use of
85 			idle CPU time, at the expense of some speed.
86 
87         If this driver is built into the kernel, you can use the
88         following command line parameters, with the same values
89         as the corresponding module parameters listed above:
90 
91             pf.drive0
92             pf.drive1
93             pf.drive2
94             pf.drive3
95 	    pf.cluster
96             pf.nice
97 
98         In addition, you can use the parameter pf.disable to disable
99         the driver entirely.
100 
101 */
102 
103 /* Changes:
104 
105 	1.01	GRG 1998.05.03  Changes for SMP.  Eliminate sti().
106 				Fix for drives that don't clear STAT_ERR
107 			        until after next CDB delivered.
108 				Small change in pf_completion to round
109 				up transfer size.
110 	1.02    GRG 1998.06.16  Eliminated an Ugh
111 	1.03    GRG 1998.08.16  Use HZ in loop timings, extra debugging
112 	1.04    GRG 1998.09.24  Added jumbo support
113 
114 */
115 
116 #define PF_VERSION      "1.04"
117 #define PF_MAJOR	47
118 #define PF_NAME		"pf"
119 #define PF_UNITS	4
120 
121 #include <linux/types.h>
122 
123 /* Here are things one can override from the insmod command.
124    Most are autoprobed by paride unless set here.  Verbose is off
125    by default.
126 
127 */
128 
129 static bool verbose = 0;
130 static int major = PF_MAJOR;
131 static char *name = PF_NAME;
132 static int cluster = 64;
133 static int nice = 0;
134 static int disable = 0;
135 
136 static int drive0[7] = { 0, 0, 0, -1, -1, -1, -1 };
137 static int drive1[7] = { 0, 0, 0, -1, -1, -1, -1 };
138 static int drive2[7] = { 0, 0, 0, -1, -1, -1, -1 };
139 static int drive3[7] = { 0, 0, 0, -1, -1, -1, -1 };
140 
141 static int (*drives[4])[7] = {&drive0, &drive1, &drive2, &drive3};
142 static int pf_drive_count;
143 
144 enum {D_PRT, D_PRO, D_UNI, D_MOD, D_SLV, D_LUN, D_DLY};
145 
146 /* end of parameters */
147 
148 #include <linux/module.h>
149 #include <linux/init.h>
150 #include <linux/fs.h>
151 #include <linux/delay.h>
152 #include <linux/hdreg.h>
153 #include <linux/cdrom.h>
154 #include <linux/spinlock.h>
155 #include <linux/blkdev.h>
156 #include <linux/blkpg.h>
157 #include <linux/mutex.h>
158 #include <asm/uaccess.h>
159 
160 static DEFINE_MUTEX(pf_mutex);
161 static DEFINE_SPINLOCK(pf_spin_lock);
162 
163 module_param(verbose, bool, 0644);
164 module_param(major, int, 0);
165 module_param(name, charp, 0);
166 module_param(cluster, int, 0);
167 module_param(nice, int, 0);
168 module_param_array(drive0, int, NULL, 0);
169 module_param_array(drive1, int, NULL, 0);
170 module_param_array(drive2, int, NULL, 0);
171 module_param_array(drive3, int, NULL, 0);
172 
173 #include "paride.h"
174 #include "pseudo.h"
175 
176 /* constants for faking geometry numbers */
177 
178 #define PF_FD_MAX	8192	/* use FD geometry under this size */
179 #define PF_FD_HDS	2
180 #define PF_FD_SPT	18
181 #define PF_HD_HDS	64
182 #define PF_HD_SPT	32
183 
184 #define PF_MAX_RETRIES  5
185 #define PF_TMO          800	/* interrupt timeout in jiffies */
186 #define PF_SPIN_DEL     50	/* spin delay in micro-seconds  */
187 
188 #define PF_SPIN         (1000000*PF_TMO)/(HZ*PF_SPIN_DEL)
189 
190 #define STAT_ERR        0x00001
191 #define STAT_INDEX      0x00002
192 #define STAT_ECC        0x00004
193 #define STAT_DRQ        0x00008
194 #define STAT_SEEK       0x00010
195 #define STAT_WRERR      0x00020
196 #define STAT_READY      0x00040
197 #define STAT_BUSY       0x00080
198 
199 #define ATAPI_REQ_SENSE		0x03
200 #define ATAPI_LOCK		0x1e
201 #define ATAPI_DOOR		0x1b
202 #define ATAPI_MODE_SENSE	0x5a
203 #define ATAPI_CAPACITY		0x25
204 #define ATAPI_IDENTIFY		0x12
205 #define ATAPI_READ_10		0x28
206 #define ATAPI_WRITE_10		0x2a
207 
208 static int pf_open(struct block_device *bdev, fmode_t mode);
209 static void do_pf_request(struct request_queue * q);
210 static int pf_ioctl(struct block_device *bdev, fmode_t mode,
211 		    unsigned int cmd, unsigned long arg);
212 static int pf_getgeo(struct block_device *bdev, struct hd_geometry *geo);
213 
214 static int pf_release(struct gendisk *disk, fmode_t mode);
215 
216 static int pf_detect(void);
217 static void do_pf_read(void);
218 static void do_pf_read_start(void);
219 static void do_pf_write(void);
220 static void do_pf_write_start(void);
221 static void do_pf_read_drq(void);
222 static void do_pf_write_done(void);
223 
224 #define PF_NM           0
225 #define PF_RO           1
226 #define PF_RW           2
227 
228 #define PF_NAMELEN      8
229 
230 struct pf_unit {
231 	struct pi_adapter pia;	/* interface to paride layer */
232 	struct pi_adapter *pi;
233 	int removable;		/* removable media device  ?  */
234 	int media_status;	/* media present ?  WP ? */
235 	int drive;		/* drive */
236 	int lun;
237 	int access;		/* count of active opens ... */
238 	int present;		/* device present ? */
239 	char name[PF_NAMELEN];	/* pf0, pf1, ... */
240 	struct gendisk *disk;
241 };
242 
243 static struct pf_unit units[PF_UNITS];
244 
245 static int pf_identify(struct pf_unit *pf);
246 static void pf_lock(struct pf_unit *pf, int func);
247 static void pf_eject(struct pf_unit *pf);
248 static unsigned int pf_check_events(struct gendisk *disk,
249 				    unsigned int clearing);
250 
251 static char pf_scratch[512];	/* scratch block buffer */
252 
253 /* the variables below are used mainly in the I/O request engine, which
254    processes only one request at a time.
255 */
256 
257 static int pf_retries = 0;	/* i/o error retry count */
258 static int pf_busy = 0;		/* request being processed ? */
259 static struct request *pf_req;	/* current request */
260 static int pf_block;		/* address of next requested block */
261 static int pf_count;		/* number of blocks still to do */
262 static int pf_run;		/* sectors in current cluster */
263 static int pf_cmd;		/* current command READ/WRITE */
264 static struct pf_unit *pf_current;/* unit of current request */
265 static int pf_mask;		/* stopper for pseudo-int */
266 static char *pf_buf;		/* buffer for request in progress */
267 
268 /* kernel glue structures */
269 
270 static const struct block_device_operations pf_fops = {
271 	.owner		= THIS_MODULE,
272 	.open		= pf_open,
273 	.release	= pf_release,
274 	.ioctl		= pf_ioctl,
275 	.getgeo		= pf_getgeo,
276 	.check_events	= pf_check_events,
277 };
278 
pf_init_units(void)279 static void __init pf_init_units(void)
280 {
281 	struct pf_unit *pf;
282 	int unit;
283 
284 	pf_drive_count = 0;
285 	for (unit = 0, pf = units; unit < PF_UNITS; unit++, pf++) {
286 		struct gendisk *disk = alloc_disk(1);
287 		if (!disk)
288 			continue;
289 		pf->disk = disk;
290 		pf->pi = &pf->pia;
291 		pf->media_status = PF_NM;
292 		pf->drive = (*drives[unit])[D_SLV];
293 		pf->lun = (*drives[unit])[D_LUN];
294 		snprintf(pf->name, PF_NAMELEN, "%s%d", name, unit);
295 		disk->major = major;
296 		disk->first_minor = unit;
297 		strcpy(disk->disk_name, pf->name);
298 		disk->fops = &pf_fops;
299 		if (!(*drives[unit])[D_PRT])
300 			pf_drive_count++;
301 	}
302 }
303 
pf_open(struct block_device * bdev,fmode_t mode)304 static int pf_open(struct block_device *bdev, fmode_t mode)
305 {
306 	struct pf_unit *pf = bdev->bd_disk->private_data;
307 	int ret;
308 
309 	mutex_lock(&pf_mutex);
310 	pf_identify(pf);
311 
312 	ret = -ENODEV;
313 	if (pf->media_status == PF_NM)
314 		goto out;
315 
316 	ret = -EROFS;
317 	if ((pf->media_status == PF_RO) && (mode & FMODE_WRITE))
318 		goto out;
319 
320 	ret = 0;
321 	pf->access++;
322 	if (pf->removable)
323 		pf_lock(pf, 1);
324 out:
325 	mutex_unlock(&pf_mutex);
326 	return ret;
327 }
328 
pf_getgeo(struct block_device * bdev,struct hd_geometry * geo)329 static int pf_getgeo(struct block_device *bdev, struct hd_geometry *geo)
330 {
331 	struct pf_unit *pf = bdev->bd_disk->private_data;
332 	sector_t capacity = get_capacity(pf->disk);
333 
334 	if (capacity < PF_FD_MAX) {
335 		geo->cylinders = sector_div(capacity, PF_FD_HDS * PF_FD_SPT);
336 		geo->heads = PF_FD_HDS;
337 		geo->sectors = PF_FD_SPT;
338 	} else {
339 		geo->cylinders = sector_div(capacity, PF_HD_HDS * PF_HD_SPT);
340 		geo->heads = PF_HD_HDS;
341 		geo->sectors = PF_HD_SPT;
342 	}
343 
344 	return 0;
345 }
346 
pf_ioctl(struct block_device * bdev,fmode_t mode,unsigned int cmd,unsigned long arg)347 static int pf_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd, unsigned long arg)
348 {
349 	struct pf_unit *pf = bdev->bd_disk->private_data;
350 
351 	if (cmd != CDROMEJECT)
352 		return -EINVAL;
353 
354 	if (pf->access != 1)
355 		return -EBUSY;
356 	mutex_lock(&pf_mutex);
357 	pf_eject(pf);
358 	mutex_unlock(&pf_mutex);
359 
360 	return 0;
361 }
362 
pf_release(struct gendisk * disk,fmode_t mode)363 static int pf_release(struct gendisk *disk, fmode_t mode)
364 {
365 	struct pf_unit *pf = disk->private_data;
366 
367 	mutex_lock(&pf_mutex);
368 	if (pf->access <= 0) {
369 		mutex_unlock(&pf_mutex);
370 		return -EINVAL;
371 	}
372 
373 	pf->access--;
374 
375 	if (!pf->access && pf->removable)
376 		pf_lock(pf, 0);
377 
378 	mutex_unlock(&pf_mutex);
379 	return 0;
380 
381 }
382 
pf_check_events(struct gendisk * disk,unsigned int clearing)383 static unsigned int pf_check_events(struct gendisk *disk, unsigned int clearing)
384 {
385 	return DISK_EVENT_MEDIA_CHANGE;
386 }
387 
status_reg(struct pf_unit * pf)388 static inline int status_reg(struct pf_unit *pf)
389 {
390 	return pi_read_regr(pf->pi, 1, 6);
391 }
392 
read_reg(struct pf_unit * pf,int reg)393 static inline int read_reg(struct pf_unit *pf, int reg)
394 {
395 	return pi_read_regr(pf->pi, 0, reg);
396 }
397 
write_reg(struct pf_unit * pf,int reg,int val)398 static inline void write_reg(struct pf_unit *pf, int reg, int val)
399 {
400 	pi_write_regr(pf->pi, 0, reg, val);
401 }
402 
pf_wait(struct pf_unit * pf,int go,int stop,char * fun,char * msg)403 static int pf_wait(struct pf_unit *pf, int go, int stop, char *fun, char *msg)
404 {
405 	int j, r, e, s, p;
406 
407 	j = 0;
408 	while ((((r = status_reg(pf)) & go) || (stop && (!(r & stop))))
409 	       && (j++ < PF_SPIN))
410 		udelay(PF_SPIN_DEL);
411 
412 	if ((r & (STAT_ERR & stop)) || (j > PF_SPIN)) {
413 		s = read_reg(pf, 7);
414 		e = read_reg(pf, 1);
415 		p = read_reg(pf, 2);
416 		if (j > PF_SPIN)
417 			e |= 0x100;
418 		if (fun)
419 			printk("%s: %s %s: alt=0x%x stat=0x%x err=0x%x"
420 			       " loop=%d phase=%d\n",
421 			       pf->name, fun, msg, r, s, e, j, p);
422 		return (e << 8) + s;
423 	}
424 	return 0;
425 }
426 
pf_command(struct pf_unit * pf,char * cmd,int dlen,char * fun)427 static int pf_command(struct pf_unit *pf, char *cmd, int dlen, char *fun)
428 {
429 	pi_connect(pf->pi);
430 
431 	write_reg(pf, 6, 0xa0+0x10*pf->drive);
432 
433 	if (pf_wait(pf, STAT_BUSY | STAT_DRQ, 0, fun, "before command")) {
434 		pi_disconnect(pf->pi);
435 		return -1;
436 	}
437 
438 	write_reg(pf, 4, dlen % 256);
439 	write_reg(pf, 5, dlen / 256);
440 	write_reg(pf, 7, 0xa0);	/* ATAPI packet command */
441 
442 	if (pf_wait(pf, STAT_BUSY, STAT_DRQ, fun, "command DRQ")) {
443 		pi_disconnect(pf->pi);
444 		return -1;
445 	}
446 
447 	if (read_reg(pf, 2) != 1) {
448 		printk("%s: %s: command phase error\n", pf->name, fun);
449 		pi_disconnect(pf->pi);
450 		return -1;
451 	}
452 
453 	pi_write_block(pf->pi, cmd, 12);
454 
455 	return 0;
456 }
457 
pf_completion(struct pf_unit * pf,char * buf,char * fun)458 static int pf_completion(struct pf_unit *pf, char *buf, char *fun)
459 {
460 	int r, s, n;
461 
462 	r = pf_wait(pf, STAT_BUSY, STAT_DRQ | STAT_READY | STAT_ERR,
463 		    fun, "completion");
464 
465 	if ((read_reg(pf, 2) & 2) && (read_reg(pf, 7) & STAT_DRQ)) {
466 		n = (((read_reg(pf, 4) + 256 * read_reg(pf, 5)) +
467 		      3) & 0xfffc);
468 		pi_read_block(pf->pi, buf, n);
469 	}
470 
471 	s = pf_wait(pf, STAT_BUSY, STAT_READY | STAT_ERR, fun, "data done");
472 
473 	pi_disconnect(pf->pi);
474 
475 	return (r ? r : s);
476 }
477 
pf_req_sense(struct pf_unit * pf,int quiet)478 static void pf_req_sense(struct pf_unit *pf, int quiet)
479 {
480 	char rs_cmd[12] =
481 	    { ATAPI_REQ_SENSE, pf->lun << 5, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0 };
482 	char buf[16];
483 	int r;
484 
485 	r = pf_command(pf, rs_cmd, 16, "Request sense");
486 	mdelay(1);
487 	if (!r)
488 		pf_completion(pf, buf, "Request sense");
489 
490 	if ((!r) && (!quiet))
491 		printk("%s: Sense key: %x, ASC: %x, ASQ: %x\n",
492 		       pf->name, buf[2] & 0xf, buf[12], buf[13]);
493 }
494 
pf_atapi(struct pf_unit * pf,char * cmd,int dlen,char * buf,char * fun)495 static int pf_atapi(struct pf_unit *pf, char *cmd, int dlen, char *buf, char *fun)
496 {
497 	int r;
498 
499 	r = pf_command(pf, cmd, dlen, fun);
500 	mdelay(1);
501 	if (!r)
502 		r = pf_completion(pf, buf, fun);
503 	if (r)
504 		pf_req_sense(pf, !fun);
505 
506 	return r;
507 }
508 
pf_lock(struct pf_unit * pf,int func)509 static void pf_lock(struct pf_unit *pf, int func)
510 {
511 	char lo_cmd[12] = { ATAPI_LOCK, pf->lun << 5, 0, 0, func, 0, 0, 0, 0, 0, 0, 0 };
512 
513 	pf_atapi(pf, lo_cmd, 0, pf_scratch, func ? "lock" : "unlock");
514 }
515 
pf_eject(struct pf_unit * pf)516 static void pf_eject(struct pf_unit *pf)
517 {
518 	char ej_cmd[12] = { ATAPI_DOOR, pf->lun << 5, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0 };
519 
520 	pf_lock(pf, 0);
521 	pf_atapi(pf, ej_cmd, 0, pf_scratch, "eject");
522 }
523 
524 #define PF_RESET_TMO   30	/* in tenths of a second */
525 
pf_sleep(int cs)526 static void pf_sleep(int cs)
527 {
528 	schedule_timeout_interruptible(cs);
529 }
530 
531 /* the ATAPI standard actually specifies the contents of all 7 registers
532    after a reset, but the specification is ambiguous concerning the last
533    two bytes, and different drives interpret the standard differently.
534  */
535 
pf_reset(struct pf_unit * pf)536 static int pf_reset(struct pf_unit *pf)
537 {
538 	int i, k, flg;
539 	int expect[5] = { 1, 1, 1, 0x14, 0xeb };
540 
541 	pi_connect(pf->pi);
542 	write_reg(pf, 6, 0xa0+0x10*pf->drive);
543 	write_reg(pf, 7, 8);
544 
545 	pf_sleep(20 * HZ / 1000);
546 
547 	k = 0;
548 	while ((k++ < PF_RESET_TMO) && (status_reg(pf) & STAT_BUSY))
549 		pf_sleep(HZ / 10);
550 
551 	flg = 1;
552 	for (i = 0; i < 5; i++)
553 		flg &= (read_reg(pf, i + 1) == expect[i]);
554 
555 	if (verbose) {
556 		printk("%s: Reset (%d) signature = ", pf->name, k);
557 		for (i = 0; i < 5; i++)
558 			printk("%3x", read_reg(pf, i + 1));
559 		if (!flg)
560 			printk(" (incorrect)");
561 		printk("\n");
562 	}
563 
564 	pi_disconnect(pf->pi);
565 	return flg - 1;
566 }
567 
pf_mode_sense(struct pf_unit * pf)568 static void pf_mode_sense(struct pf_unit *pf)
569 {
570 	char ms_cmd[12] =
571 	    { ATAPI_MODE_SENSE, pf->lun << 5, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0 };
572 	char buf[8];
573 
574 	pf_atapi(pf, ms_cmd, 8, buf, "mode sense");
575 	pf->media_status = PF_RW;
576 	if (buf[3] & 0x80)
577 		pf->media_status = PF_RO;
578 }
579 
xs(char * buf,char * targ,int offs,int len)580 static void xs(char *buf, char *targ, int offs, int len)
581 {
582 	int j, k, l;
583 
584 	j = 0;
585 	l = 0;
586 	for (k = 0; k < len; k++)
587 		if ((buf[k + offs] != 0x20) || (buf[k + offs] != l))
588 			l = targ[j++] = buf[k + offs];
589 	if (l == 0x20)
590 		j--;
591 	targ[j] = 0;
592 }
593 
xl(char * buf,int offs)594 static int xl(char *buf, int offs)
595 {
596 	int v, k;
597 
598 	v = 0;
599 	for (k = 0; k < 4; k++)
600 		v = v * 256 + (buf[k + offs] & 0xff);
601 	return v;
602 }
603 
pf_get_capacity(struct pf_unit * pf)604 static void pf_get_capacity(struct pf_unit *pf)
605 {
606 	char rc_cmd[12] = { ATAPI_CAPACITY, pf->lun << 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
607 	char buf[8];
608 	int bs;
609 
610 	if (pf_atapi(pf, rc_cmd, 8, buf, "get capacity")) {
611 		pf->media_status = PF_NM;
612 		return;
613 	}
614 	set_capacity(pf->disk, xl(buf, 0) + 1);
615 	bs = xl(buf, 4);
616 	if (bs != 512) {
617 		set_capacity(pf->disk, 0);
618 		if (verbose)
619 			printk("%s: Drive %d, LUN %d,"
620 			       " unsupported block size %d\n",
621 			       pf->name, pf->drive, pf->lun, bs);
622 	}
623 }
624 
pf_identify(struct pf_unit * pf)625 static int pf_identify(struct pf_unit *pf)
626 {
627 	int dt, s;
628 	char *ms[2] = { "master", "slave" };
629 	char mf[10], id[18];
630 	char id_cmd[12] =
631 	    { ATAPI_IDENTIFY, pf->lun << 5, 0, 0, 36, 0, 0, 0, 0, 0, 0, 0 };
632 	char buf[36];
633 
634 	s = pf_atapi(pf, id_cmd, 36, buf, "identify");
635 	if (s)
636 		return -1;
637 
638 	dt = buf[0] & 0x1f;
639 	if ((dt != 0) && (dt != 7)) {
640 		if (verbose)
641 			printk("%s: Drive %d, LUN %d, unsupported type %d\n",
642 			       pf->name, pf->drive, pf->lun, dt);
643 		return -1;
644 	}
645 
646 	xs(buf, mf, 8, 8);
647 	xs(buf, id, 16, 16);
648 
649 	pf->removable = (buf[1] & 0x80);
650 
651 	pf_mode_sense(pf);
652 	pf_mode_sense(pf);
653 	pf_mode_sense(pf);
654 
655 	pf_get_capacity(pf);
656 
657 	printk("%s: %s %s, %s LUN %d, type %d",
658 	       pf->name, mf, id, ms[pf->drive], pf->lun, dt);
659 	if (pf->removable)
660 		printk(", removable");
661 	if (pf->media_status == PF_NM)
662 		printk(", no media\n");
663 	else {
664 		if (pf->media_status == PF_RO)
665 			printk(", RO");
666 		printk(", %llu blocks\n",
667 			(unsigned long long)get_capacity(pf->disk));
668 	}
669 	return 0;
670 }
671 
672 /*	returns  0, with id set if drive is detected
673 	        -1, if drive detection failed
674 */
pf_probe(struct pf_unit * pf)675 static int pf_probe(struct pf_unit *pf)
676 {
677 	if (pf->drive == -1) {
678 		for (pf->drive = 0; pf->drive <= 1; pf->drive++)
679 			if (!pf_reset(pf)) {
680 				if (pf->lun != -1)
681 					return pf_identify(pf);
682 				else
683 					for (pf->lun = 0; pf->lun < 8; pf->lun++)
684 						if (!pf_identify(pf))
685 							return 0;
686 			}
687 	} else {
688 		if (pf_reset(pf))
689 			return -1;
690 		if (pf->lun != -1)
691 			return pf_identify(pf);
692 		for (pf->lun = 0; pf->lun < 8; pf->lun++)
693 			if (!pf_identify(pf))
694 				return 0;
695 	}
696 	return -1;
697 }
698 
pf_detect(void)699 static int pf_detect(void)
700 {
701 	struct pf_unit *pf = units;
702 	int k, unit;
703 
704 	printk("%s: %s version %s, major %d, cluster %d, nice %d\n",
705 	       name, name, PF_VERSION, major, cluster, nice);
706 
707 	k = 0;
708 	if (pf_drive_count == 0) {
709 		if (pi_init(pf->pi, 1, -1, -1, -1, -1, -1, pf_scratch, PI_PF,
710 			    verbose, pf->name)) {
711 			if (!pf_probe(pf) && pf->disk) {
712 				pf->present = 1;
713 				k++;
714 			} else
715 				pi_release(pf->pi);
716 		}
717 
718 	} else
719 		for (unit = 0; unit < PF_UNITS; unit++, pf++) {
720 			int *conf = *drives[unit];
721 			if (!conf[D_PRT])
722 				continue;
723 			if (pi_init(pf->pi, 0, conf[D_PRT], conf[D_MOD],
724 				    conf[D_UNI], conf[D_PRO], conf[D_DLY],
725 				    pf_scratch, PI_PF, verbose, pf->name)) {
726 				if (pf->disk && !pf_probe(pf)) {
727 					pf->present = 1;
728 					k++;
729 				} else
730 					pi_release(pf->pi);
731 			}
732 		}
733 	if (k)
734 		return 0;
735 
736 	printk("%s: No ATAPI disk detected\n", name);
737 	for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++)
738 		put_disk(pf->disk);
739 	return -1;
740 }
741 
742 /* The i/o request engine */
743 
pf_start(struct pf_unit * pf,int cmd,int b,int c)744 static int pf_start(struct pf_unit *pf, int cmd, int b, int c)
745 {
746 	int i;
747 	char io_cmd[12] = { cmd, pf->lun << 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
748 
749 	for (i = 0; i < 4; i++) {
750 		io_cmd[5 - i] = b & 0xff;
751 		b = b >> 8;
752 	}
753 
754 	io_cmd[8] = c & 0xff;
755 	io_cmd[7] = (c >> 8) & 0xff;
756 
757 	i = pf_command(pf, io_cmd, c * 512, "start i/o");
758 
759 	mdelay(1);
760 
761 	return i;
762 }
763 
pf_ready(void)764 static int pf_ready(void)
765 {
766 	return (((status_reg(pf_current) & (STAT_BUSY | pf_mask)) == pf_mask));
767 }
768 
769 static struct request_queue *pf_queue;
770 
pf_end_request(int err)771 static void pf_end_request(int err)
772 {
773 	if (pf_req && !__blk_end_request_cur(pf_req, err))
774 		pf_req = NULL;
775 }
776 
do_pf_request(struct request_queue * q)777 static void do_pf_request(struct request_queue * q)
778 {
779 	if (pf_busy)
780 		return;
781 repeat:
782 	if (!pf_req) {
783 		pf_req = blk_fetch_request(q);
784 		if (!pf_req)
785 			return;
786 	}
787 
788 	pf_current = pf_req->rq_disk->private_data;
789 	pf_block = blk_rq_pos(pf_req);
790 	pf_run = blk_rq_sectors(pf_req);
791 	pf_count = blk_rq_cur_sectors(pf_req);
792 
793 	if (pf_block + pf_count > get_capacity(pf_req->rq_disk)) {
794 		pf_end_request(-EIO);
795 		goto repeat;
796 	}
797 
798 	pf_cmd = rq_data_dir(pf_req);
799 	pf_buf = pf_req->buffer;
800 	pf_retries = 0;
801 
802 	pf_busy = 1;
803 	if (pf_cmd == READ)
804 		pi_do_claimed(pf_current->pi, do_pf_read);
805 	else if (pf_cmd == WRITE)
806 		pi_do_claimed(pf_current->pi, do_pf_write);
807 	else {
808 		pf_busy = 0;
809 		pf_end_request(-EIO);
810 		goto repeat;
811 	}
812 }
813 
pf_next_buf(void)814 static int pf_next_buf(void)
815 {
816 	unsigned long saved_flags;
817 
818 	pf_count--;
819 	pf_run--;
820 	pf_buf += 512;
821 	pf_block++;
822 	if (!pf_run)
823 		return 1;
824 	if (!pf_count) {
825 		spin_lock_irqsave(&pf_spin_lock, saved_flags);
826 		pf_end_request(0);
827 		spin_unlock_irqrestore(&pf_spin_lock, saved_flags);
828 		if (!pf_req)
829 			return 1;
830 		pf_count = blk_rq_cur_sectors(pf_req);
831 		pf_buf = pf_req->buffer;
832 	}
833 	return 0;
834 }
835 
next_request(int err)836 static inline void next_request(int err)
837 {
838 	unsigned long saved_flags;
839 
840 	spin_lock_irqsave(&pf_spin_lock, saved_flags);
841 	pf_end_request(err);
842 	pf_busy = 0;
843 	do_pf_request(pf_queue);
844 	spin_unlock_irqrestore(&pf_spin_lock, saved_flags);
845 }
846 
847 /* detach from the calling context - in case the spinlock is held */
do_pf_read(void)848 static void do_pf_read(void)
849 {
850 	ps_set_intr(do_pf_read_start, NULL, 0, nice);
851 }
852 
do_pf_read_start(void)853 static void do_pf_read_start(void)
854 {
855 	pf_busy = 1;
856 
857 	if (pf_start(pf_current, ATAPI_READ_10, pf_block, pf_run)) {
858 		pi_disconnect(pf_current->pi);
859 		if (pf_retries < PF_MAX_RETRIES) {
860 			pf_retries++;
861 			pi_do_claimed(pf_current->pi, do_pf_read_start);
862 			return;
863 		}
864 		next_request(-EIO);
865 		return;
866 	}
867 	pf_mask = STAT_DRQ;
868 	ps_set_intr(do_pf_read_drq, pf_ready, PF_TMO, nice);
869 }
870 
do_pf_read_drq(void)871 static void do_pf_read_drq(void)
872 {
873 	while (1) {
874 		if (pf_wait(pf_current, STAT_BUSY, STAT_DRQ | STAT_ERR,
875 			    "read block", "completion") & STAT_ERR) {
876 			pi_disconnect(pf_current->pi);
877 			if (pf_retries < PF_MAX_RETRIES) {
878 				pf_req_sense(pf_current, 0);
879 				pf_retries++;
880 				pi_do_claimed(pf_current->pi, do_pf_read_start);
881 				return;
882 			}
883 			next_request(-EIO);
884 			return;
885 		}
886 		pi_read_block(pf_current->pi, pf_buf, 512);
887 		if (pf_next_buf())
888 			break;
889 	}
890 	pi_disconnect(pf_current->pi);
891 	next_request(0);
892 }
893 
do_pf_write(void)894 static void do_pf_write(void)
895 {
896 	ps_set_intr(do_pf_write_start, NULL, 0, nice);
897 }
898 
do_pf_write_start(void)899 static void do_pf_write_start(void)
900 {
901 	pf_busy = 1;
902 
903 	if (pf_start(pf_current, ATAPI_WRITE_10, pf_block, pf_run)) {
904 		pi_disconnect(pf_current->pi);
905 		if (pf_retries < PF_MAX_RETRIES) {
906 			pf_retries++;
907 			pi_do_claimed(pf_current->pi, do_pf_write_start);
908 			return;
909 		}
910 		next_request(-EIO);
911 		return;
912 	}
913 
914 	while (1) {
915 		if (pf_wait(pf_current, STAT_BUSY, STAT_DRQ | STAT_ERR,
916 			    "write block", "data wait") & STAT_ERR) {
917 			pi_disconnect(pf_current->pi);
918 			if (pf_retries < PF_MAX_RETRIES) {
919 				pf_retries++;
920 				pi_do_claimed(pf_current->pi, do_pf_write_start);
921 				return;
922 			}
923 			next_request(-EIO);
924 			return;
925 		}
926 		pi_write_block(pf_current->pi, pf_buf, 512);
927 		if (pf_next_buf())
928 			break;
929 	}
930 	pf_mask = 0;
931 	ps_set_intr(do_pf_write_done, pf_ready, PF_TMO, nice);
932 }
933 
do_pf_write_done(void)934 static void do_pf_write_done(void)
935 {
936 	if (pf_wait(pf_current, STAT_BUSY, 0, "write block", "done") & STAT_ERR) {
937 		pi_disconnect(pf_current->pi);
938 		if (pf_retries < PF_MAX_RETRIES) {
939 			pf_retries++;
940 			pi_do_claimed(pf_current->pi, do_pf_write_start);
941 			return;
942 		}
943 		next_request(-EIO);
944 		return;
945 	}
946 	pi_disconnect(pf_current->pi);
947 	next_request(0);
948 }
949 
pf_init(void)950 static int __init pf_init(void)
951 {				/* preliminary initialisation */
952 	struct pf_unit *pf;
953 	int unit;
954 
955 	if (disable)
956 		return -EINVAL;
957 
958 	pf_init_units();
959 
960 	if (pf_detect())
961 		return -ENODEV;
962 	pf_busy = 0;
963 
964 	if (register_blkdev(major, name)) {
965 		for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++)
966 			put_disk(pf->disk);
967 		return -EBUSY;
968 	}
969 	pf_queue = blk_init_queue(do_pf_request, &pf_spin_lock);
970 	if (!pf_queue) {
971 		unregister_blkdev(major, name);
972 		for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++)
973 			put_disk(pf->disk);
974 		return -ENOMEM;
975 	}
976 
977 	blk_queue_max_segments(pf_queue, cluster);
978 
979 	for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++) {
980 		struct gendisk *disk = pf->disk;
981 
982 		if (!pf->present)
983 			continue;
984 		disk->private_data = pf;
985 		disk->queue = pf_queue;
986 		add_disk(disk);
987 	}
988 	return 0;
989 }
990 
pf_exit(void)991 static void __exit pf_exit(void)
992 {
993 	struct pf_unit *pf;
994 	int unit;
995 	unregister_blkdev(major, name);
996 	for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++) {
997 		if (!pf->present)
998 			continue;
999 		del_gendisk(pf->disk);
1000 		put_disk(pf->disk);
1001 		pi_release(pf->pi);
1002 	}
1003 	blk_cleanup_queue(pf_queue);
1004 }
1005 
1006 MODULE_LICENSE("GPL");
1007 module_init(pf_init)
1008 module_exit(pf_exit)
1009