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