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