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 override 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 <linux/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 void 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 static void *par_drv; /* reference of parport driver */
268
269 /* kernel glue structures */
270
271 static const struct block_device_operations pf_fops = {
272 .owner = THIS_MODULE,
273 .open = pf_open,
274 .release = pf_release,
275 .ioctl = pf_ioctl,
276 .getgeo = pf_getgeo,
277 .check_events = pf_check_events,
278 };
279
pf_init_units(void)280 static void __init pf_init_units(void)
281 {
282 struct pf_unit *pf;
283 int unit;
284
285 pf_drive_count = 0;
286 for (unit = 0, pf = units; unit < PF_UNITS; unit++, pf++) {
287 struct gendisk *disk = alloc_disk(1);
288 if (!disk)
289 continue;
290 disk->queue = blk_init_queue(do_pf_request, &pf_spin_lock);
291 if (!disk->queue) {
292 put_disk(disk);
293 return;
294 }
295 blk_queue_max_segments(disk->queue, cluster);
296 blk_queue_bounce_limit(disk->queue, BLK_BOUNCE_HIGH);
297 pf->disk = disk;
298 pf->pi = &pf->pia;
299 pf->media_status = PF_NM;
300 pf->drive = (*drives[unit])[D_SLV];
301 pf->lun = (*drives[unit])[D_LUN];
302 snprintf(pf->name, PF_NAMELEN, "%s%d", name, unit);
303 disk->major = major;
304 disk->first_minor = unit;
305 strcpy(disk->disk_name, pf->name);
306 disk->fops = &pf_fops;
307 if (!(*drives[unit])[D_PRT])
308 pf_drive_count++;
309 }
310 }
311
pf_open(struct block_device * bdev,fmode_t mode)312 static int pf_open(struct block_device *bdev, fmode_t mode)
313 {
314 struct pf_unit *pf = bdev->bd_disk->private_data;
315 int ret;
316
317 mutex_lock(&pf_mutex);
318 pf_identify(pf);
319
320 ret = -ENODEV;
321 if (pf->media_status == PF_NM)
322 goto out;
323
324 ret = -EROFS;
325 if ((pf->media_status == PF_RO) && (mode & FMODE_WRITE))
326 goto out;
327
328 ret = 0;
329 pf->access++;
330 if (pf->removable)
331 pf_lock(pf, 1);
332 out:
333 mutex_unlock(&pf_mutex);
334 return ret;
335 }
336
pf_getgeo(struct block_device * bdev,struct hd_geometry * geo)337 static int pf_getgeo(struct block_device *bdev, struct hd_geometry *geo)
338 {
339 struct pf_unit *pf = bdev->bd_disk->private_data;
340 sector_t capacity = get_capacity(pf->disk);
341
342 if (capacity < PF_FD_MAX) {
343 geo->cylinders = sector_div(capacity, PF_FD_HDS * PF_FD_SPT);
344 geo->heads = PF_FD_HDS;
345 geo->sectors = PF_FD_SPT;
346 } else {
347 geo->cylinders = sector_div(capacity, PF_HD_HDS * PF_HD_SPT);
348 geo->heads = PF_HD_HDS;
349 geo->sectors = PF_HD_SPT;
350 }
351
352 return 0;
353 }
354
pf_ioctl(struct block_device * bdev,fmode_t mode,unsigned int cmd,unsigned long arg)355 static int pf_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd, unsigned long arg)
356 {
357 struct pf_unit *pf = bdev->bd_disk->private_data;
358
359 if (cmd != CDROMEJECT)
360 return -EINVAL;
361
362 if (pf->access != 1)
363 return -EBUSY;
364 mutex_lock(&pf_mutex);
365 pf_eject(pf);
366 mutex_unlock(&pf_mutex);
367
368 return 0;
369 }
370
pf_release(struct gendisk * disk,fmode_t mode)371 static void pf_release(struct gendisk *disk, fmode_t mode)
372 {
373 struct pf_unit *pf = disk->private_data;
374
375 mutex_lock(&pf_mutex);
376 if (pf->access <= 0) {
377 mutex_unlock(&pf_mutex);
378 WARN_ON(1);
379 return;
380 }
381
382 pf->access--;
383
384 if (!pf->access && pf->removable)
385 pf_lock(pf, 0);
386
387 mutex_unlock(&pf_mutex);
388 }
389
pf_check_events(struct gendisk * disk,unsigned int clearing)390 static unsigned int pf_check_events(struct gendisk *disk, unsigned int clearing)
391 {
392 return DISK_EVENT_MEDIA_CHANGE;
393 }
394
status_reg(struct pf_unit * pf)395 static inline int status_reg(struct pf_unit *pf)
396 {
397 return pi_read_regr(pf->pi, 1, 6);
398 }
399
read_reg(struct pf_unit * pf,int reg)400 static inline int read_reg(struct pf_unit *pf, int reg)
401 {
402 return pi_read_regr(pf->pi, 0, reg);
403 }
404
write_reg(struct pf_unit * pf,int reg,int val)405 static inline void write_reg(struct pf_unit *pf, int reg, int val)
406 {
407 pi_write_regr(pf->pi, 0, reg, val);
408 }
409
pf_wait(struct pf_unit * pf,int go,int stop,char * fun,char * msg)410 static int pf_wait(struct pf_unit *pf, int go, int stop, char *fun, char *msg)
411 {
412 int j, r, e, s, p;
413
414 j = 0;
415 while ((((r = status_reg(pf)) & go) || (stop && (!(r & stop))))
416 && (j++ < PF_SPIN))
417 udelay(PF_SPIN_DEL);
418
419 if ((r & (STAT_ERR & stop)) || (j > PF_SPIN)) {
420 s = read_reg(pf, 7);
421 e = read_reg(pf, 1);
422 p = read_reg(pf, 2);
423 if (j > PF_SPIN)
424 e |= 0x100;
425 if (fun)
426 printk("%s: %s %s: alt=0x%x stat=0x%x err=0x%x"
427 " loop=%d phase=%d\n",
428 pf->name, fun, msg, r, s, e, j, p);
429 return (e << 8) + s;
430 }
431 return 0;
432 }
433
pf_command(struct pf_unit * pf,char * cmd,int dlen,char * fun)434 static int pf_command(struct pf_unit *pf, char *cmd, int dlen, char *fun)
435 {
436 pi_connect(pf->pi);
437
438 write_reg(pf, 6, 0xa0+0x10*pf->drive);
439
440 if (pf_wait(pf, STAT_BUSY | STAT_DRQ, 0, fun, "before command")) {
441 pi_disconnect(pf->pi);
442 return -1;
443 }
444
445 write_reg(pf, 4, dlen % 256);
446 write_reg(pf, 5, dlen / 256);
447 write_reg(pf, 7, 0xa0); /* ATAPI packet command */
448
449 if (pf_wait(pf, STAT_BUSY, STAT_DRQ, fun, "command DRQ")) {
450 pi_disconnect(pf->pi);
451 return -1;
452 }
453
454 if (read_reg(pf, 2) != 1) {
455 printk("%s: %s: command phase error\n", pf->name, fun);
456 pi_disconnect(pf->pi);
457 return -1;
458 }
459
460 pi_write_block(pf->pi, cmd, 12);
461
462 return 0;
463 }
464
pf_completion(struct pf_unit * pf,char * buf,char * fun)465 static int pf_completion(struct pf_unit *pf, char *buf, char *fun)
466 {
467 int r, s, n;
468
469 r = pf_wait(pf, STAT_BUSY, STAT_DRQ | STAT_READY | STAT_ERR,
470 fun, "completion");
471
472 if ((read_reg(pf, 2) & 2) && (read_reg(pf, 7) & STAT_DRQ)) {
473 n = (((read_reg(pf, 4) + 256 * read_reg(pf, 5)) +
474 3) & 0xfffc);
475 pi_read_block(pf->pi, buf, n);
476 }
477
478 s = pf_wait(pf, STAT_BUSY, STAT_READY | STAT_ERR, fun, "data done");
479
480 pi_disconnect(pf->pi);
481
482 return (r ? r : s);
483 }
484
pf_req_sense(struct pf_unit * pf,int quiet)485 static void pf_req_sense(struct pf_unit *pf, int quiet)
486 {
487 char rs_cmd[12] =
488 { ATAPI_REQ_SENSE, pf->lun << 5, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0 };
489 char buf[16];
490 int r;
491
492 r = pf_command(pf, rs_cmd, 16, "Request sense");
493 mdelay(1);
494 if (!r)
495 pf_completion(pf, buf, "Request sense");
496
497 if ((!r) && (!quiet))
498 printk("%s: Sense key: %x, ASC: %x, ASQ: %x\n",
499 pf->name, buf[2] & 0xf, buf[12], buf[13]);
500 }
501
pf_atapi(struct pf_unit * pf,char * cmd,int dlen,char * buf,char * fun)502 static int pf_atapi(struct pf_unit *pf, char *cmd, int dlen, char *buf, char *fun)
503 {
504 int r;
505
506 r = pf_command(pf, cmd, dlen, fun);
507 mdelay(1);
508 if (!r)
509 r = pf_completion(pf, buf, fun);
510 if (r)
511 pf_req_sense(pf, !fun);
512
513 return r;
514 }
515
pf_lock(struct pf_unit * pf,int func)516 static void pf_lock(struct pf_unit *pf, int func)
517 {
518 char lo_cmd[12] = { ATAPI_LOCK, pf->lun << 5, 0, 0, func, 0, 0, 0, 0, 0, 0, 0 };
519
520 pf_atapi(pf, lo_cmd, 0, pf_scratch, func ? "lock" : "unlock");
521 }
522
pf_eject(struct pf_unit * pf)523 static void pf_eject(struct pf_unit *pf)
524 {
525 char ej_cmd[12] = { ATAPI_DOOR, pf->lun << 5, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0 };
526
527 pf_lock(pf, 0);
528 pf_atapi(pf, ej_cmd, 0, pf_scratch, "eject");
529 }
530
531 #define PF_RESET_TMO 30 /* in tenths of a second */
532
pf_sleep(int cs)533 static void pf_sleep(int cs)
534 {
535 schedule_timeout_interruptible(cs);
536 }
537
538 /* the ATAPI standard actually specifies the contents of all 7 registers
539 after a reset, but the specification is ambiguous concerning the last
540 two bytes, and different drives interpret the standard differently.
541 */
542
pf_reset(struct pf_unit * pf)543 static int pf_reset(struct pf_unit *pf)
544 {
545 int i, k, flg;
546 int expect[5] = { 1, 1, 1, 0x14, 0xeb };
547
548 pi_connect(pf->pi);
549 write_reg(pf, 6, 0xa0+0x10*pf->drive);
550 write_reg(pf, 7, 8);
551
552 pf_sleep(20 * HZ / 1000);
553
554 k = 0;
555 while ((k++ < PF_RESET_TMO) && (status_reg(pf) & STAT_BUSY))
556 pf_sleep(HZ / 10);
557
558 flg = 1;
559 for (i = 0; i < 5; i++)
560 flg &= (read_reg(pf, i + 1) == expect[i]);
561
562 if (verbose) {
563 printk("%s: Reset (%d) signature = ", pf->name, k);
564 for (i = 0; i < 5; i++)
565 printk("%3x", read_reg(pf, i + 1));
566 if (!flg)
567 printk(" (incorrect)");
568 printk("\n");
569 }
570
571 pi_disconnect(pf->pi);
572 return flg - 1;
573 }
574
pf_mode_sense(struct pf_unit * pf)575 static void pf_mode_sense(struct pf_unit *pf)
576 {
577 char ms_cmd[12] =
578 { ATAPI_MODE_SENSE, pf->lun << 5, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0 };
579 char buf[8];
580
581 pf_atapi(pf, ms_cmd, 8, buf, "mode sense");
582 pf->media_status = PF_RW;
583 if (buf[3] & 0x80)
584 pf->media_status = PF_RO;
585 }
586
xs(char * buf,char * targ,int offs,int len)587 static void xs(char *buf, char *targ, int offs, int len)
588 {
589 int j, k, l;
590
591 j = 0;
592 l = 0;
593 for (k = 0; k < len; k++)
594 if ((buf[k + offs] != 0x20) || (buf[k + offs] != l))
595 l = targ[j++] = buf[k + offs];
596 if (l == 0x20)
597 j--;
598 targ[j] = 0;
599 }
600
xl(char * buf,int offs)601 static int xl(char *buf, int offs)
602 {
603 int v, k;
604
605 v = 0;
606 for (k = 0; k < 4; k++)
607 v = v * 256 + (buf[k + offs] & 0xff);
608 return v;
609 }
610
pf_get_capacity(struct pf_unit * pf)611 static void pf_get_capacity(struct pf_unit *pf)
612 {
613 char rc_cmd[12] = { ATAPI_CAPACITY, pf->lun << 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
614 char buf[8];
615 int bs;
616
617 if (pf_atapi(pf, rc_cmd, 8, buf, "get capacity")) {
618 pf->media_status = PF_NM;
619 return;
620 }
621 set_capacity(pf->disk, xl(buf, 0) + 1);
622 bs = xl(buf, 4);
623 if (bs != 512) {
624 set_capacity(pf->disk, 0);
625 if (verbose)
626 printk("%s: Drive %d, LUN %d,"
627 " unsupported block size %d\n",
628 pf->name, pf->drive, pf->lun, bs);
629 }
630 }
631
pf_identify(struct pf_unit * pf)632 static int pf_identify(struct pf_unit *pf)
633 {
634 int dt, s;
635 char *ms[2] = { "master", "slave" };
636 char mf[10], id[18];
637 char id_cmd[12] =
638 { ATAPI_IDENTIFY, pf->lun << 5, 0, 0, 36, 0, 0, 0, 0, 0, 0, 0 };
639 char buf[36];
640
641 s = pf_atapi(pf, id_cmd, 36, buf, "identify");
642 if (s)
643 return -1;
644
645 dt = buf[0] & 0x1f;
646 if ((dt != 0) && (dt != 7)) {
647 if (verbose)
648 printk("%s: Drive %d, LUN %d, unsupported type %d\n",
649 pf->name, pf->drive, pf->lun, dt);
650 return -1;
651 }
652
653 xs(buf, mf, 8, 8);
654 xs(buf, id, 16, 16);
655
656 pf->removable = (buf[1] & 0x80);
657
658 pf_mode_sense(pf);
659 pf_mode_sense(pf);
660 pf_mode_sense(pf);
661
662 pf_get_capacity(pf);
663
664 printk("%s: %s %s, %s LUN %d, type %d",
665 pf->name, mf, id, ms[pf->drive], pf->lun, dt);
666 if (pf->removable)
667 printk(", removable");
668 if (pf->media_status == PF_NM)
669 printk(", no media\n");
670 else {
671 if (pf->media_status == PF_RO)
672 printk(", RO");
673 printk(", %llu blocks\n",
674 (unsigned long long)get_capacity(pf->disk));
675 }
676 return 0;
677 }
678
679 /* returns 0, with id set if drive is detected
680 -1, if drive detection failed
681 */
pf_probe(struct pf_unit * pf)682 static int pf_probe(struct pf_unit *pf)
683 {
684 if (pf->drive == -1) {
685 for (pf->drive = 0; pf->drive <= 1; pf->drive++)
686 if (!pf_reset(pf)) {
687 if (pf->lun != -1)
688 return pf_identify(pf);
689 else
690 for (pf->lun = 0; pf->lun < 8; pf->lun++)
691 if (!pf_identify(pf))
692 return 0;
693 }
694 } else {
695 if (pf_reset(pf))
696 return -1;
697 if (pf->lun != -1)
698 return pf_identify(pf);
699 for (pf->lun = 0; pf->lun < 8; pf->lun++)
700 if (!pf_identify(pf))
701 return 0;
702 }
703 return -1;
704 }
705
pf_detect(void)706 static int pf_detect(void)
707 {
708 struct pf_unit *pf = units;
709 int k, unit;
710
711 printk("%s: %s version %s, major %d, cluster %d, nice %d\n",
712 name, name, PF_VERSION, major, cluster, nice);
713
714 par_drv = pi_register_driver(name);
715 if (!par_drv) {
716 pr_err("failed to register %s driver\n", name);
717 return -1;
718 }
719 k = 0;
720 if (pf_drive_count == 0) {
721 if (pi_init(pf->pi, 1, -1, -1, -1, -1, -1, pf_scratch, PI_PF,
722 verbose, pf->name)) {
723 if (!pf_probe(pf) && pf->disk) {
724 pf->present = 1;
725 k++;
726 } else
727 pi_release(pf->pi);
728 }
729
730 } else
731 for (unit = 0; unit < PF_UNITS; unit++, pf++) {
732 int *conf = *drives[unit];
733 if (!conf[D_PRT])
734 continue;
735 if (pi_init(pf->pi, 0, conf[D_PRT], conf[D_MOD],
736 conf[D_UNI], conf[D_PRO], conf[D_DLY],
737 pf_scratch, PI_PF, verbose, pf->name)) {
738 if (pf->disk && !pf_probe(pf)) {
739 pf->present = 1;
740 k++;
741 } else
742 pi_release(pf->pi);
743 }
744 }
745 if (k)
746 return 0;
747
748 printk("%s: No ATAPI disk detected\n", name);
749 for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++)
750 put_disk(pf->disk);
751 pi_unregister_driver(par_drv);
752 return -1;
753 }
754
755 /* The i/o request engine */
756
pf_start(struct pf_unit * pf,int cmd,int b,int c)757 static int pf_start(struct pf_unit *pf, int cmd, int b, int c)
758 {
759 int i;
760 char io_cmd[12] = { cmd, pf->lun << 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
761
762 for (i = 0; i < 4; i++) {
763 io_cmd[5 - i] = b & 0xff;
764 b = b >> 8;
765 }
766
767 io_cmd[8] = c & 0xff;
768 io_cmd[7] = (c >> 8) & 0xff;
769
770 i = pf_command(pf, io_cmd, c * 512, "start i/o");
771
772 mdelay(1);
773
774 return i;
775 }
776
pf_ready(void)777 static int pf_ready(void)
778 {
779 return (((status_reg(pf_current) & (STAT_BUSY | pf_mask)) == pf_mask));
780 }
781
782 static int pf_queue;
783
set_next_request(void)784 static int set_next_request(void)
785 {
786 struct pf_unit *pf;
787 struct request_queue *q;
788 int old_pos = pf_queue;
789
790 do {
791 pf = &units[pf_queue];
792 q = pf->present ? pf->disk->queue : NULL;
793 if (++pf_queue == PF_UNITS)
794 pf_queue = 0;
795 if (q) {
796 pf_req = blk_fetch_request(q);
797 if (pf_req)
798 break;
799 }
800 } while (pf_queue != old_pos);
801
802 return pf_req != NULL;
803 }
804
pf_end_request(blk_status_t err)805 static void pf_end_request(blk_status_t err)
806 {
807 if (pf_req && !__blk_end_request_cur(pf_req, err))
808 pf_req = NULL;
809 }
810
pf_request(void)811 static void pf_request(void)
812 {
813 if (pf_busy)
814 return;
815 repeat:
816 if (!pf_req && !set_next_request())
817 return;
818
819 pf_current = pf_req->rq_disk->private_data;
820 pf_block = blk_rq_pos(pf_req);
821 pf_run = blk_rq_sectors(pf_req);
822 pf_count = blk_rq_cur_sectors(pf_req);
823
824 if (pf_block + pf_count > get_capacity(pf_req->rq_disk)) {
825 pf_end_request(BLK_STS_IOERR);
826 goto repeat;
827 }
828
829 pf_cmd = rq_data_dir(pf_req);
830 pf_buf = bio_data(pf_req->bio);
831 pf_retries = 0;
832
833 pf_busy = 1;
834 if (pf_cmd == READ)
835 pi_do_claimed(pf_current->pi, do_pf_read);
836 else if (pf_cmd == WRITE)
837 pi_do_claimed(pf_current->pi, do_pf_write);
838 else {
839 pf_busy = 0;
840 pf_end_request(BLK_STS_IOERR);
841 goto repeat;
842 }
843 }
844
do_pf_request(struct request_queue * q)845 static void do_pf_request(struct request_queue *q)
846 {
847 pf_request();
848 }
849
pf_next_buf(void)850 static int pf_next_buf(void)
851 {
852 unsigned long saved_flags;
853
854 pf_count--;
855 pf_run--;
856 pf_buf += 512;
857 pf_block++;
858 if (!pf_run)
859 return 1;
860 if (!pf_count) {
861 spin_lock_irqsave(&pf_spin_lock, saved_flags);
862 pf_end_request(0);
863 spin_unlock_irqrestore(&pf_spin_lock, saved_flags);
864 if (!pf_req)
865 return 1;
866 pf_count = blk_rq_cur_sectors(pf_req);
867 pf_buf = bio_data(pf_req->bio);
868 }
869 return 0;
870 }
871
next_request(blk_status_t err)872 static inline void next_request(blk_status_t err)
873 {
874 unsigned long saved_flags;
875
876 spin_lock_irqsave(&pf_spin_lock, saved_flags);
877 pf_end_request(err);
878 pf_busy = 0;
879 pf_request();
880 spin_unlock_irqrestore(&pf_spin_lock, saved_flags);
881 }
882
883 /* detach from the calling context - in case the spinlock is held */
do_pf_read(void)884 static void do_pf_read(void)
885 {
886 ps_set_intr(do_pf_read_start, NULL, 0, nice);
887 }
888
do_pf_read_start(void)889 static void do_pf_read_start(void)
890 {
891 pf_busy = 1;
892
893 if (pf_start(pf_current, ATAPI_READ_10, pf_block, pf_run)) {
894 pi_disconnect(pf_current->pi);
895 if (pf_retries < PF_MAX_RETRIES) {
896 pf_retries++;
897 pi_do_claimed(pf_current->pi, do_pf_read_start);
898 return;
899 }
900 next_request(BLK_STS_IOERR);
901 return;
902 }
903 pf_mask = STAT_DRQ;
904 ps_set_intr(do_pf_read_drq, pf_ready, PF_TMO, nice);
905 }
906
do_pf_read_drq(void)907 static void do_pf_read_drq(void)
908 {
909 while (1) {
910 if (pf_wait(pf_current, STAT_BUSY, STAT_DRQ | STAT_ERR,
911 "read block", "completion") & STAT_ERR) {
912 pi_disconnect(pf_current->pi);
913 if (pf_retries < PF_MAX_RETRIES) {
914 pf_req_sense(pf_current, 0);
915 pf_retries++;
916 pi_do_claimed(pf_current->pi, do_pf_read_start);
917 return;
918 }
919 next_request(BLK_STS_IOERR);
920 return;
921 }
922 pi_read_block(pf_current->pi, pf_buf, 512);
923 if (pf_next_buf())
924 break;
925 }
926 pi_disconnect(pf_current->pi);
927 next_request(0);
928 }
929
do_pf_write(void)930 static void do_pf_write(void)
931 {
932 ps_set_intr(do_pf_write_start, NULL, 0, nice);
933 }
934
do_pf_write_start(void)935 static void do_pf_write_start(void)
936 {
937 pf_busy = 1;
938
939 if (pf_start(pf_current, ATAPI_WRITE_10, pf_block, pf_run)) {
940 pi_disconnect(pf_current->pi);
941 if (pf_retries < PF_MAX_RETRIES) {
942 pf_retries++;
943 pi_do_claimed(pf_current->pi, do_pf_write_start);
944 return;
945 }
946 next_request(BLK_STS_IOERR);
947 return;
948 }
949
950 while (1) {
951 if (pf_wait(pf_current, STAT_BUSY, STAT_DRQ | STAT_ERR,
952 "write block", "data wait") & STAT_ERR) {
953 pi_disconnect(pf_current->pi);
954 if (pf_retries < PF_MAX_RETRIES) {
955 pf_retries++;
956 pi_do_claimed(pf_current->pi, do_pf_write_start);
957 return;
958 }
959 next_request(BLK_STS_IOERR);
960 return;
961 }
962 pi_write_block(pf_current->pi, pf_buf, 512);
963 if (pf_next_buf())
964 break;
965 }
966 pf_mask = 0;
967 ps_set_intr(do_pf_write_done, pf_ready, PF_TMO, nice);
968 }
969
do_pf_write_done(void)970 static void do_pf_write_done(void)
971 {
972 if (pf_wait(pf_current, STAT_BUSY, 0, "write block", "done") & STAT_ERR) {
973 pi_disconnect(pf_current->pi);
974 if (pf_retries < PF_MAX_RETRIES) {
975 pf_retries++;
976 pi_do_claimed(pf_current->pi, do_pf_write_start);
977 return;
978 }
979 next_request(BLK_STS_IOERR);
980 return;
981 }
982 pi_disconnect(pf_current->pi);
983 next_request(0);
984 }
985
pf_init(void)986 static int __init pf_init(void)
987 { /* preliminary initialisation */
988 struct pf_unit *pf;
989 int unit;
990
991 if (disable)
992 return -EINVAL;
993
994 pf_init_units();
995
996 if (pf_detect())
997 return -ENODEV;
998 pf_busy = 0;
999
1000 if (register_blkdev(major, name)) {
1001 for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++)
1002 put_disk(pf->disk);
1003 return -EBUSY;
1004 }
1005
1006 for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++) {
1007 struct gendisk *disk = pf->disk;
1008
1009 if (!pf->present)
1010 continue;
1011 disk->private_data = pf;
1012 add_disk(disk);
1013 }
1014 return 0;
1015 }
1016
pf_exit(void)1017 static void __exit pf_exit(void)
1018 {
1019 struct pf_unit *pf;
1020 int unit;
1021 unregister_blkdev(major, name);
1022 for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++) {
1023 if (!pf->present)
1024 continue;
1025 del_gendisk(pf->disk);
1026 blk_cleanup_queue(pf->disk->queue);
1027 put_disk(pf->disk);
1028 pi_release(pf->pi);
1029 }
1030 }
1031
1032 MODULE_LICENSE("GPL");
1033 module_init(pf_init)
1034 module_exit(pf_exit)
1035