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