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 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 pf->disk = disk;
291 pf->pi = &pf->pia;
292 pf->media_status = PF_NM;
293 pf->drive = (*drives[unit])[D_SLV];
294 pf->lun = (*drives[unit])[D_LUN];
295 snprintf(pf->name, PF_NAMELEN, "%s%d", name, unit);
296 disk->major = major;
297 disk->first_minor = unit;
298 strcpy(disk->disk_name, pf->name);
299 disk->fops = &pf_fops;
300 if (!(*drives[unit])[D_PRT])
301 pf_drive_count++;
302 }
303 }
304
pf_open(struct block_device * bdev,fmode_t mode)305 static int pf_open(struct block_device *bdev, fmode_t mode)
306 {
307 struct pf_unit *pf = bdev->bd_disk->private_data;
308 int ret;
309
310 mutex_lock(&pf_mutex);
311 pf_identify(pf);
312
313 ret = -ENODEV;
314 if (pf->media_status == PF_NM)
315 goto out;
316
317 ret = -EROFS;
318 if ((pf->media_status == PF_RO) && (mode & FMODE_WRITE))
319 goto out;
320
321 ret = 0;
322 pf->access++;
323 if (pf->removable)
324 pf_lock(pf, 1);
325 out:
326 mutex_unlock(&pf_mutex);
327 return ret;
328 }
329
pf_getgeo(struct block_device * bdev,struct hd_geometry * geo)330 static int pf_getgeo(struct block_device *bdev, struct hd_geometry *geo)
331 {
332 struct pf_unit *pf = bdev->bd_disk->private_data;
333 sector_t capacity = get_capacity(pf->disk);
334
335 if (capacity < PF_FD_MAX) {
336 geo->cylinders = sector_div(capacity, PF_FD_HDS * PF_FD_SPT);
337 geo->heads = PF_FD_HDS;
338 geo->sectors = PF_FD_SPT;
339 } else {
340 geo->cylinders = sector_div(capacity, PF_HD_HDS * PF_HD_SPT);
341 geo->heads = PF_HD_HDS;
342 geo->sectors = PF_HD_SPT;
343 }
344
345 return 0;
346 }
347
pf_ioctl(struct block_device * bdev,fmode_t mode,unsigned int cmd,unsigned long arg)348 static int pf_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd, unsigned long arg)
349 {
350 struct pf_unit *pf = bdev->bd_disk->private_data;
351
352 if (cmd != CDROMEJECT)
353 return -EINVAL;
354
355 if (pf->access != 1)
356 return -EBUSY;
357 mutex_lock(&pf_mutex);
358 pf_eject(pf);
359 mutex_unlock(&pf_mutex);
360
361 return 0;
362 }
363
pf_release(struct gendisk * disk,fmode_t mode)364 static void pf_release(struct gendisk *disk, fmode_t mode)
365 {
366 struct pf_unit *pf = disk->private_data;
367
368 mutex_lock(&pf_mutex);
369 if (pf->access <= 0) {
370 mutex_unlock(&pf_mutex);
371 WARN_ON(1);
372 return;
373 }
374
375 pf->access--;
376
377 if (!pf->access && pf->removable)
378 pf_lock(pf, 0);
379
380 mutex_unlock(&pf_mutex);
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 par_drv = pi_register_driver(name);
708 if (!par_drv) {
709 pr_err("failed to register %s driver\n", name);
710 return -1;
711 }
712 k = 0;
713 if (pf_drive_count == 0) {
714 if (pi_init(pf->pi, 1, -1, -1, -1, -1, -1, pf_scratch, PI_PF,
715 verbose, pf->name)) {
716 if (!pf_probe(pf) && pf->disk) {
717 pf->present = 1;
718 k++;
719 } else
720 pi_release(pf->pi);
721 }
722
723 } else
724 for (unit = 0; unit < PF_UNITS; unit++, pf++) {
725 int *conf = *drives[unit];
726 if (!conf[D_PRT])
727 continue;
728 if (pi_init(pf->pi, 0, conf[D_PRT], conf[D_MOD],
729 conf[D_UNI], conf[D_PRO], conf[D_DLY],
730 pf_scratch, PI_PF, verbose, pf->name)) {
731 if (pf->disk && !pf_probe(pf)) {
732 pf->present = 1;
733 k++;
734 } else
735 pi_release(pf->pi);
736 }
737 }
738 if (k)
739 return 0;
740
741 printk("%s: No ATAPI disk detected\n", name);
742 for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++)
743 put_disk(pf->disk);
744 pi_unregister_driver(par_drv);
745 return -1;
746 }
747
748 /* The i/o request engine */
749
pf_start(struct pf_unit * pf,int cmd,int b,int c)750 static int pf_start(struct pf_unit *pf, int cmd, int b, int c)
751 {
752 int i;
753 char io_cmd[12] = { cmd, pf->lun << 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
754
755 for (i = 0; i < 4; i++) {
756 io_cmd[5 - i] = b & 0xff;
757 b = b >> 8;
758 }
759
760 io_cmd[8] = c & 0xff;
761 io_cmd[7] = (c >> 8) & 0xff;
762
763 i = pf_command(pf, io_cmd, c * 512, "start i/o");
764
765 mdelay(1);
766
767 return i;
768 }
769
pf_ready(void)770 static int pf_ready(void)
771 {
772 return (((status_reg(pf_current) & (STAT_BUSY | pf_mask)) == pf_mask));
773 }
774
775 static struct request_queue *pf_queue;
776
pf_end_request(int err)777 static void pf_end_request(int err)
778 {
779 if (pf_req && !__blk_end_request_cur(pf_req, err))
780 pf_req = NULL;
781 }
782
do_pf_request(struct request_queue * q)783 static void do_pf_request(struct request_queue * q)
784 {
785 if (pf_busy)
786 return;
787 repeat:
788 if (!pf_req) {
789 pf_req = blk_fetch_request(q);
790 if (!pf_req)
791 return;
792 }
793
794 pf_current = pf_req->rq_disk->private_data;
795 pf_block = blk_rq_pos(pf_req);
796 pf_run = blk_rq_sectors(pf_req);
797 pf_count = blk_rq_cur_sectors(pf_req);
798
799 if (pf_block + pf_count > get_capacity(pf_req->rq_disk)) {
800 pf_end_request(-EIO);
801 goto repeat;
802 }
803
804 pf_cmd = rq_data_dir(pf_req);
805 pf_buf = bio_data(pf_req->bio);
806 pf_retries = 0;
807
808 pf_busy = 1;
809 if (pf_cmd == READ)
810 pi_do_claimed(pf_current->pi, do_pf_read);
811 else if (pf_cmd == WRITE)
812 pi_do_claimed(pf_current->pi, do_pf_write);
813 else {
814 pf_busy = 0;
815 pf_end_request(-EIO);
816 goto repeat;
817 }
818 }
819
pf_next_buf(void)820 static int pf_next_buf(void)
821 {
822 unsigned long saved_flags;
823
824 pf_count--;
825 pf_run--;
826 pf_buf += 512;
827 pf_block++;
828 if (!pf_run)
829 return 1;
830 if (!pf_count) {
831 spin_lock_irqsave(&pf_spin_lock, saved_flags);
832 pf_end_request(0);
833 spin_unlock_irqrestore(&pf_spin_lock, saved_flags);
834 if (!pf_req)
835 return 1;
836 pf_count = blk_rq_cur_sectors(pf_req);
837 pf_buf = bio_data(pf_req->bio);
838 }
839 return 0;
840 }
841
next_request(int err)842 static inline void next_request(int err)
843 {
844 unsigned long saved_flags;
845
846 spin_lock_irqsave(&pf_spin_lock, saved_flags);
847 pf_end_request(err);
848 pf_busy = 0;
849 do_pf_request(pf_queue);
850 spin_unlock_irqrestore(&pf_spin_lock, saved_flags);
851 }
852
853 /* detach from the calling context - in case the spinlock is held */
do_pf_read(void)854 static void do_pf_read(void)
855 {
856 ps_set_intr(do_pf_read_start, NULL, 0, nice);
857 }
858
do_pf_read_start(void)859 static void do_pf_read_start(void)
860 {
861 pf_busy = 1;
862
863 if (pf_start(pf_current, ATAPI_READ_10, pf_block, pf_run)) {
864 pi_disconnect(pf_current->pi);
865 if (pf_retries < PF_MAX_RETRIES) {
866 pf_retries++;
867 pi_do_claimed(pf_current->pi, do_pf_read_start);
868 return;
869 }
870 next_request(-EIO);
871 return;
872 }
873 pf_mask = STAT_DRQ;
874 ps_set_intr(do_pf_read_drq, pf_ready, PF_TMO, nice);
875 }
876
do_pf_read_drq(void)877 static void do_pf_read_drq(void)
878 {
879 while (1) {
880 if (pf_wait(pf_current, STAT_BUSY, STAT_DRQ | STAT_ERR,
881 "read block", "completion") & STAT_ERR) {
882 pi_disconnect(pf_current->pi);
883 if (pf_retries < PF_MAX_RETRIES) {
884 pf_req_sense(pf_current, 0);
885 pf_retries++;
886 pi_do_claimed(pf_current->pi, do_pf_read_start);
887 return;
888 }
889 next_request(-EIO);
890 return;
891 }
892 pi_read_block(pf_current->pi, pf_buf, 512);
893 if (pf_next_buf())
894 break;
895 }
896 pi_disconnect(pf_current->pi);
897 next_request(0);
898 }
899
do_pf_write(void)900 static void do_pf_write(void)
901 {
902 ps_set_intr(do_pf_write_start, NULL, 0, nice);
903 }
904
do_pf_write_start(void)905 static void do_pf_write_start(void)
906 {
907 pf_busy = 1;
908
909 if (pf_start(pf_current, ATAPI_WRITE_10, pf_block, pf_run)) {
910 pi_disconnect(pf_current->pi);
911 if (pf_retries < PF_MAX_RETRIES) {
912 pf_retries++;
913 pi_do_claimed(pf_current->pi, do_pf_write_start);
914 return;
915 }
916 next_request(-EIO);
917 return;
918 }
919
920 while (1) {
921 if (pf_wait(pf_current, STAT_BUSY, STAT_DRQ | STAT_ERR,
922 "write block", "data wait") & STAT_ERR) {
923 pi_disconnect(pf_current->pi);
924 if (pf_retries < PF_MAX_RETRIES) {
925 pf_retries++;
926 pi_do_claimed(pf_current->pi, do_pf_write_start);
927 return;
928 }
929 next_request(-EIO);
930 return;
931 }
932 pi_write_block(pf_current->pi, pf_buf, 512);
933 if (pf_next_buf())
934 break;
935 }
936 pf_mask = 0;
937 ps_set_intr(do_pf_write_done, pf_ready, PF_TMO, nice);
938 }
939
do_pf_write_done(void)940 static void do_pf_write_done(void)
941 {
942 if (pf_wait(pf_current, STAT_BUSY, 0, "write block", "done") & STAT_ERR) {
943 pi_disconnect(pf_current->pi);
944 if (pf_retries < PF_MAX_RETRIES) {
945 pf_retries++;
946 pi_do_claimed(pf_current->pi, do_pf_write_start);
947 return;
948 }
949 next_request(-EIO);
950 return;
951 }
952 pi_disconnect(pf_current->pi);
953 next_request(0);
954 }
955
pf_init(void)956 static int __init pf_init(void)
957 { /* preliminary initialisation */
958 struct pf_unit *pf;
959 int unit;
960
961 if (disable)
962 return -EINVAL;
963
964 pf_init_units();
965
966 if (pf_detect())
967 return -ENODEV;
968 pf_busy = 0;
969
970 if (register_blkdev(major, name)) {
971 for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++)
972 put_disk(pf->disk);
973 return -EBUSY;
974 }
975 pf_queue = blk_init_queue(do_pf_request, &pf_spin_lock);
976 if (!pf_queue) {
977 unregister_blkdev(major, name);
978 for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++)
979 put_disk(pf->disk);
980 return -ENOMEM;
981 }
982
983 blk_queue_max_segments(pf_queue, cluster);
984
985 for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++) {
986 struct gendisk *disk = pf->disk;
987
988 if (!pf->present)
989 continue;
990 disk->private_data = pf;
991 disk->queue = pf_queue;
992 add_disk(disk);
993 }
994 return 0;
995 }
996
pf_exit(void)997 static void __exit pf_exit(void)
998 {
999 struct pf_unit *pf;
1000 int unit;
1001 unregister_blkdev(major, name);
1002 for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++) {
1003 if (!pf->present)
1004 continue;
1005 del_gendisk(pf->disk);
1006 put_disk(pf->disk);
1007 pi_release(pf->pi);
1008 }
1009 blk_cleanup_queue(pf_queue);
1010 }
1011
1012 MODULE_LICENSE("GPL");
1013 module_init(pf_init)
1014 module_exit(pf_exit)
1015