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