paride drivers: initialize spinlocks
[linux-2.6.git] / drivers / block / paride / pf.c
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 /* Here are things one can override from the insmod command.
122    Most are autoprobed by paride unless set here.  Verbose is off
123    by default.
124
125 */
126
127 static int verbose = 0;
128 static int major = PF_MAJOR;
129 static char *name = PF_NAME;
130 static int cluster = 64;
131 static int nice = 0;
132 static int disable = 0;
133
134 static int drive0[7] = { 0, 0, 0, -1, -1, -1, -1 };
135 static int drive1[7] = { 0, 0, 0, -1, -1, -1, -1 };
136 static int drive2[7] = { 0, 0, 0, -1, -1, -1, -1 };
137 static int drive3[7] = { 0, 0, 0, -1, -1, -1, -1 };
138
139 static int (*drives[4])[7] = {&drive0, &drive1, &drive2, &drive3};
140 static int pf_drive_count;
141
142 enum {D_PRT, D_PRO, D_UNI, D_MOD, D_SLV, D_LUN, D_DLY};
143
144 /* end of parameters */
145
146 #include <linux/module.h>
147 #include <linux/init.h>
148 #include <linux/fs.h>
149 #include <linux/delay.h>
150 #include <linux/hdreg.h>
151 #include <linux/cdrom.h>
152 #include <linux/spinlock.h>
153 #include <linux/blkdev.h>
154 #include <linux/blkpg.h>
155 #include <asm/uaccess.h>
156
157 static DEFINE_SPINLOCK(pf_spin_lock);
158
159 module_param(verbose, bool, 0644);
160 module_param(major, int, 0);
161 module_param(name, charp, 0);
162 module_param(cluster, int, 0);
163 module_param(nice, int, 0);
164 module_param_array(drive0, int, NULL, 0);
165 module_param_array(drive1, int, NULL, 0);
166 module_param_array(drive2, int, NULL, 0);
167 module_param_array(drive3, int, NULL, 0);
168
169 #include "paride.h"
170 #include "pseudo.h"
171
172 /* constants for faking geometry numbers */
173
174 #define PF_FD_MAX       8192    /* use FD geometry under this size */
175 #define PF_FD_HDS       2
176 #define PF_FD_SPT       18
177 #define PF_HD_HDS       64
178 #define PF_HD_SPT       32
179
180 #define PF_MAX_RETRIES  5
181 #define PF_TMO          800     /* interrupt timeout in jiffies */
182 #define PF_SPIN_DEL     50      /* spin delay in micro-seconds  */
183
184 #define PF_SPIN         (1000000*PF_TMO)/(HZ*PF_SPIN_DEL)
185
186 #define STAT_ERR        0x00001
187 #define STAT_INDEX      0x00002
188 #define STAT_ECC        0x00004
189 #define STAT_DRQ        0x00008
190 #define STAT_SEEK       0x00010
191 #define STAT_WRERR      0x00020
192 #define STAT_READY      0x00040
193 #define STAT_BUSY       0x00080
194
195 #define ATAPI_REQ_SENSE         0x03
196 #define ATAPI_LOCK              0x1e
197 #define ATAPI_DOOR              0x1b
198 #define ATAPI_MODE_SENSE        0x5a
199 #define ATAPI_CAPACITY          0x25
200 #define ATAPI_IDENTIFY          0x12
201 #define ATAPI_READ_10           0x28
202 #define ATAPI_WRITE_10          0x2a
203
204 static int pf_open(struct inode *inode, struct file *file);
205 static void do_pf_request(request_queue_t * q);
206 static int pf_ioctl(struct inode *inode, struct file *file,
207                     unsigned int cmd, unsigned long arg);
208 static int pf_getgeo(struct block_device *bdev, struct hd_geometry *geo);
209
210 static int pf_release(struct inode *inode, struct file *file);
211
212 static int pf_detect(void);
213 static void do_pf_read(void);
214 static void do_pf_read_start(void);
215 static void do_pf_write(void);
216 static void do_pf_write_start(void);
217 static void do_pf_read_drq(void);
218 static void do_pf_write_done(void);
219
220 #define PF_NM           0
221 #define PF_RO           1
222 #define PF_RW           2
223
224 #define PF_NAMELEN      8
225
226 struct pf_unit {
227         struct pi_adapter pia;  /* interface to paride layer */
228         struct pi_adapter *pi;
229         int removable;          /* removable media device  ?  */
230         int media_status;       /* media present ?  WP ? */
231         int drive;              /* drive */
232         int lun;
233         int access;             /* count of active opens ... */
234         int present;            /* device present ? */
235         char name[PF_NAMELEN];  /* pf0, pf1, ... */
236         struct gendisk *disk;
237 };
238
239 static struct pf_unit units[PF_UNITS];
240
241 static int pf_identify(struct pf_unit *pf);
242 static void pf_lock(struct pf_unit *pf, int func);
243 static void pf_eject(struct pf_unit *pf);
244 static int pf_check_media(struct gendisk *disk);
245
246 static char pf_scratch[512];    /* scratch block buffer */
247
248 /* the variables below are used mainly in the I/O request engine, which
249    processes only one request at a time.
250 */
251
252 static int pf_retries = 0;      /* i/o error retry count */
253 static int pf_busy = 0;         /* request being processed ? */
254 static struct request *pf_req;  /* current request */
255 static int pf_block;            /* address of next requested block */
256 static int pf_count;            /* number of blocks still to do */
257 static int pf_run;              /* sectors in current cluster */
258 static int pf_cmd;              /* current command READ/WRITE */
259 static struct pf_unit *pf_current;/* unit of current request */
260 static int pf_mask;             /* stopper for pseudo-int */
261 static char *pf_buf;            /* buffer for request in progress */
262
263 /* kernel glue structures */
264
265 static struct block_device_operations pf_fops = {
266         .owner          = THIS_MODULE,
267         .open           = pf_open,
268         .release        = pf_release,
269         .ioctl          = pf_ioctl,
270         .getgeo         = pf_getgeo,
271         .media_changed  = pf_check_media,
272 };
273
274 static void __init pf_init_units(void)
275 {
276         struct pf_unit *pf;
277         int unit;
278
279         pf_drive_count = 0;
280         for (unit = 0, pf = units; unit < PF_UNITS; unit++, pf++) {
281                 struct gendisk *disk = alloc_disk(1);
282                 if (!disk)
283                         continue;
284                 pf->disk = disk;
285                 pf->pi = &pf->pia;
286                 pf->media_status = PF_NM;
287                 pf->drive = (*drives[unit])[D_SLV];
288                 pf->lun = (*drives[unit])[D_LUN];
289                 snprintf(pf->name, PF_NAMELEN, "%s%d", name, unit);
290                 disk->major = major;
291                 disk->first_minor = unit;
292                 strcpy(disk->disk_name, pf->name);
293                 disk->fops = &pf_fops;
294                 if (!(*drives[unit])[D_PRT])
295                         pf_drive_count++;
296         }
297 }
298
299 static int pf_open(struct inode *inode, struct file *file)
300 {
301         struct pf_unit *pf = inode->i_bdev->bd_disk->private_data;
302
303         pf_identify(pf);
304
305         if (pf->media_status == PF_NM)
306                 return -ENODEV;
307
308         if ((pf->media_status == PF_RO) && (file->f_mode & 2))
309                 return -EROFS;
310
311         pf->access++;
312         if (pf->removable)
313                 pf_lock(pf, 1);
314
315         return 0;
316 }
317
318 static int pf_getgeo(struct block_device *bdev, struct hd_geometry *geo)
319 {
320         struct pf_unit *pf = bdev->bd_disk->private_data;
321         sector_t capacity = get_capacity(pf->disk);
322
323         if (capacity < PF_FD_MAX) {
324                 geo->cylinders = sector_div(capacity, PF_FD_HDS * PF_FD_SPT);
325                 geo->heads = PF_FD_HDS;
326                 geo->sectors = PF_FD_SPT;
327         } else {
328                 geo->cylinders = sector_div(capacity, PF_HD_HDS * PF_HD_SPT);
329                 geo->heads = PF_HD_HDS;
330                 geo->sectors = PF_HD_SPT;
331         }
332
333         return 0;
334 }
335
336 static int pf_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
337 {
338         struct pf_unit *pf = inode->i_bdev->bd_disk->private_data;
339
340         if (cmd != CDROMEJECT)
341                 return -EINVAL;
342
343         if (pf->access != 1)
344                 return -EBUSY;
345         pf_eject(pf);
346         return 0;
347 }
348
349 static int pf_release(struct inode *inode, struct file *file)
350 {
351         struct pf_unit *pf = inode->i_bdev->bd_disk->private_data;
352
353         if (pf->access <= 0)
354                 return -EINVAL;
355
356         pf->access--;
357
358         if (!pf->access && pf->removable)
359                 pf_lock(pf, 0);
360
361         return 0;
362
363 }
364
365 static int pf_check_media(struct gendisk *disk)
366 {
367         return 1;
368 }
369
370 static inline int status_reg(struct pf_unit *pf)
371 {
372         return pi_read_regr(pf->pi, 1, 6);
373 }
374
375 static inline int read_reg(struct pf_unit *pf, int reg)
376 {
377         return pi_read_regr(pf->pi, 0, reg);
378 }
379
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
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
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
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
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
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
491 #define DBMSG(msg)      ((verbose>1)?(msg):NULL)
492
493 static void pf_lock(struct pf_unit *pf, int func)
494 {
495         char lo_cmd[12] = { ATAPI_LOCK, pf->lun << 5, 0, 0, func, 0, 0, 0, 0, 0, 0, 0 };
496
497         pf_atapi(pf, lo_cmd, 0, pf_scratch, func ? "unlock" : "lock");
498 }
499
500 static void pf_eject(struct pf_unit *pf)
501 {
502         char ej_cmd[12] = { ATAPI_DOOR, pf->lun << 5, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0 };
503
504         pf_lock(pf, 0);
505         pf_atapi(pf, ej_cmd, 0, pf_scratch, "eject");
506 }
507
508 #define PF_RESET_TMO   30       /* in tenths of a second */
509
510 static void pf_sleep(int cs)
511 {
512         schedule_timeout_interruptible(cs);
513 }
514
515 /* the ATAPI standard actually specifies the contents of all 7 registers
516    after a reset, but the specification is ambiguous concerning the last
517    two bytes, and different drives interpret the standard differently.
518  */
519
520 static int pf_reset(struct pf_unit *pf)
521 {
522         int i, k, flg;
523         int expect[5] = { 1, 1, 1, 0x14, 0xeb };
524
525         pi_connect(pf->pi);
526         write_reg(pf, 6, 0xa0+0x10*pf->drive);
527         write_reg(pf, 7, 8);
528
529         pf_sleep(20 * HZ / 1000);
530
531         k = 0;
532         while ((k++ < PF_RESET_TMO) && (status_reg(pf) & STAT_BUSY))
533                 pf_sleep(HZ / 10);
534
535         flg = 1;
536         for (i = 0; i < 5; i++)
537                 flg &= (read_reg(pf, i + 1) == expect[i]);
538
539         if (verbose) {
540                 printk("%s: Reset (%d) signature = ", pf->name, k);
541                 for (i = 0; i < 5; i++)
542                         printk("%3x", read_reg(pf, i + 1));
543                 if (!flg)
544                         printk(" (incorrect)");
545                 printk("\n");
546         }
547
548         pi_disconnect(pf->pi);
549         return flg - 1;
550 }
551
552 static void pf_mode_sense(struct pf_unit *pf)
553 {
554         char ms_cmd[12] =
555             { ATAPI_MODE_SENSE, pf->lun << 5, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0 };
556         char buf[8];
557
558         pf_atapi(pf, ms_cmd, 8, buf, DBMSG("mode sense"));
559         pf->media_status = PF_RW;
560         if (buf[3] & 0x80)
561                 pf->media_status = PF_RO;
562 }
563
564 static void xs(char *buf, char *targ, int offs, int len)
565 {
566         int j, k, l;
567
568         j = 0;
569         l = 0;
570         for (k = 0; k < len; k++)
571                 if ((buf[k + offs] != 0x20) || (buf[k + offs] != l))
572                         l = targ[j++] = buf[k + offs];
573         if (l == 0x20)
574                 j--;
575         targ[j] = 0;
576 }
577
578 static int xl(char *buf, int offs)
579 {
580         int v, k;
581
582         v = 0;
583         for (k = 0; k < 4; k++)
584                 v = v * 256 + (buf[k + offs] & 0xff);
585         return v;
586 }
587
588 static void pf_get_capacity(struct pf_unit *pf)
589 {
590         char rc_cmd[12] = { ATAPI_CAPACITY, pf->lun << 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
591         char buf[8];
592         int bs;
593
594         if (pf_atapi(pf, rc_cmd, 8, buf, DBMSG("get capacity"))) {
595                 pf->media_status = PF_NM;
596                 return;
597         }
598         set_capacity(pf->disk, xl(buf, 0) + 1);
599         bs = xl(buf, 4);
600         if (bs != 512) {
601                 set_capacity(pf->disk, 0);
602                 if (verbose)
603                         printk("%s: Drive %d, LUN %d,"
604                                " unsupported block size %d\n",
605                                pf->name, pf->drive, pf->lun, bs);
606         }
607 }
608
609 static int pf_identify(struct pf_unit *pf)
610 {
611         int dt, s;
612         char *ms[2] = { "master", "slave" };
613         char mf[10], id[18];
614         char id_cmd[12] =
615             { ATAPI_IDENTIFY, pf->lun << 5, 0, 0, 36, 0, 0, 0, 0, 0, 0, 0 };
616         char buf[36];
617
618         s = pf_atapi(pf, id_cmd, 36, buf, "identify");
619         if (s)
620                 return -1;
621
622         dt = buf[0] & 0x1f;
623         if ((dt != 0) && (dt != 7)) {
624                 if (verbose)
625                         printk("%s: Drive %d, LUN %d, unsupported type %d\n",
626                                pf->name, pf->drive, pf->lun, dt);
627                 return -1;
628         }
629
630         xs(buf, mf, 8, 8);
631         xs(buf, id, 16, 16);
632
633         pf->removable = (buf[1] & 0x80);
634
635         pf_mode_sense(pf);
636         pf_mode_sense(pf);
637         pf_mode_sense(pf);
638
639         pf_get_capacity(pf);
640
641         printk("%s: %s %s, %s LUN %d, type %d",
642                pf->name, mf, id, ms[pf->drive], pf->lun, dt);
643         if (pf->removable)
644                 printk(", removable");
645         if (pf->media_status == PF_NM)
646                 printk(", no media\n");
647         else {
648                 if (pf->media_status == PF_RO)
649                         printk(", RO");
650                 printk(", %llu blocks\n",
651                         (unsigned long long)get_capacity(pf->disk));
652         }
653         return 0;
654 }
655
656 /*      returns  0, with id set if drive is detected
657                 -1, if drive detection failed
658 */
659 static int pf_probe(struct pf_unit *pf)
660 {
661         if (pf->drive == -1) {
662                 for (pf->drive = 0; pf->drive <= 1; pf->drive++)
663                         if (!pf_reset(pf)) {
664                                 if (pf->lun != -1)
665                                         return pf_identify(pf);
666                                 else
667                                         for (pf->lun = 0; pf->lun < 8; pf->lun++)
668                                                 if (!pf_identify(pf))
669                                                         return 0;
670                         }
671         } else {
672                 if (pf_reset(pf))
673                         return -1;
674                 if (pf->lun != -1)
675                         return pf_identify(pf);
676                 for (pf->lun = 0; pf->lun < 8; pf->lun++)
677                         if (!pf_identify(pf))
678                                 return 0;
679         }
680         return -1;
681 }
682
683 static int pf_detect(void)
684 {
685         struct pf_unit *pf = units;
686         int k, unit;
687
688         printk("%s: %s version %s, major %d, cluster %d, nice %d\n",
689                name, name, PF_VERSION, major, cluster, nice);
690
691         k = 0;
692         if (pf_drive_count == 0) {
693                 if (pi_init(pf->pi, 1, -1, -1, -1, -1, -1, pf_scratch, PI_PF,
694                             verbose, pf->name)) {
695                         if (!pf_probe(pf) && pf->disk) {
696                                 pf->present = 1;
697                                 k++;
698                         } else
699                                 pi_release(pf->pi);
700                 }
701
702         } else
703                 for (unit = 0; unit < PF_UNITS; unit++, pf++) {
704                         int *conf = *drives[unit];
705                         if (!conf[D_PRT])
706                                 continue;
707                         if (pi_init(pf->pi, 0, conf[D_PRT], conf[D_MOD],
708                                     conf[D_UNI], conf[D_PRO], conf[D_DLY],
709                                     pf_scratch, PI_PF, verbose, pf->name)) {
710                                 if (pf->disk && !pf_probe(pf)) {
711                                         pf->present = 1;
712                                         k++;
713                                 } else
714                                         pi_release(pf->pi);
715                         }
716                 }
717         if (k)
718                 return 0;
719
720         printk("%s: No ATAPI disk detected\n", name);
721         for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++)
722                 put_disk(pf->disk);
723         return -1;
724 }
725
726 /* The i/o request engine */
727
728 static int pf_start(struct pf_unit *pf, int cmd, int b, int c)
729 {
730         int i;
731         char io_cmd[12] = { cmd, pf->lun << 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
732
733         for (i = 0; i < 4; i++) {
734                 io_cmd[5 - i] = b & 0xff;
735                 b = b >> 8;
736         }
737
738         io_cmd[8] = c & 0xff;
739         io_cmd[7] = (c >> 8) & 0xff;
740
741         i = pf_command(pf, io_cmd, c * 512, "start i/o");
742
743         mdelay(1);
744
745         return i;
746 }
747
748 static int pf_ready(void)
749 {
750         return (((status_reg(pf_current) & (STAT_BUSY | pf_mask)) == pf_mask));
751 }
752
753 static struct request_queue *pf_queue;
754
755 static void pf_end_request(int uptodate)
756 {
757         if (pf_req) {
758                 end_request(pf_req, uptodate);
759                 pf_req = NULL;
760         }
761 }
762
763 static void do_pf_request(request_queue_t * q)
764 {
765         if (pf_busy)
766                 return;
767 repeat:
768         pf_req = elv_next_request(q);
769         if (!pf_req)
770                 return;
771
772         pf_current = pf_req->rq_disk->private_data;
773         pf_block = pf_req->sector;
774         pf_run = pf_req->nr_sectors;
775         pf_count = pf_req->current_nr_sectors;
776
777         if (pf_block + pf_count > get_capacity(pf_req->rq_disk)) {
778                 pf_end_request(0);
779                 goto repeat;
780         }
781
782         pf_cmd = rq_data_dir(pf_req);
783         pf_buf = pf_req->buffer;
784         pf_retries = 0;
785
786         pf_busy = 1;
787         if (pf_cmd == READ)
788                 pi_do_claimed(pf_current->pi, do_pf_read);
789         else if (pf_cmd == WRITE)
790                 pi_do_claimed(pf_current->pi, do_pf_write);
791         else {
792                 pf_busy = 0;
793                 pf_end_request(0);
794                 goto repeat;
795         }
796 }
797
798 static int pf_next_buf(void)
799 {
800         unsigned long saved_flags;
801
802         pf_count--;
803         pf_run--;
804         pf_buf += 512;
805         pf_block++;
806         if (!pf_run)
807                 return 0;
808         if (!pf_count)
809                 return 1;
810         spin_lock_irqsave(&pf_spin_lock, saved_flags);
811         pf_end_request(1);
812         spin_unlock_irqrestore(&pf_spin_lock, saved_flags);
813         return 1;
814 }
815
816 static inline void next_request(int success)
817 {
818         unsigned long saved_flags;
819
820         spin_lock_irqsave(&pf_spin_lock, saved_flags);
821         pf_end_request(success);
822         pf_busy = 0;
823         do_pf_request(pf_queue);
824         spin_unlock_irqrestore(&pf_spin_lock, saved_flags);
825 }
826
827 /* detach from the calling context - in case the spinlock is held */
828 static void do_pf_read(void)
829 {
830         ps_set_intr(do_pf_read_start, NULL, 0, nice);
831 }
832
833 static void do_pf_read_start(void)
834 {
835         pf_busy = 1;
836
837         if (pf_start(pf_current, ATAPI_READ_10, pf_block, pf_run)) {
838                 pi_disconnect(pf_current->pi);
839                 if (pf_retries < PF_MAX_RETRIES) {
840                         pf_retries++;
841                         pi_do_claimed(pf_current->pi, do_pf_read_start);
842                         return;
843                 }
844                 next_request(0);
845                 return;
846         }
847         pf_mask = STAT_DRQ;
848         ps_set_intr(do_pf_read_drq, pf_ready, PF_TMO, nice);
849 }
850
851 static void do_pf_read_drq(void)
852 {
853         while (1) {
854                 if (pf_wait(pf_current, STAT_BUSY, STAT_DRQ | STAT_ERR,
855                             "read block", "completion") & STAT_ERR) {
856                         pi_disconnect(pf_current->pi);
857                         if (pf_retries < PF_MAX_RETRIES) {
858                                 pf_req_sense(pf_current, 0);
859                                 pf_retries++;
860                                 pi_do_claimed(pf_current->pi, do_pf_read_start);
861                                 return;
862                         }
863                         next_request(0);
864                         return;
865                 }
866                 pi_read_block(pf_current->pi, pf_buf, 512);
867                 if (pf_next_buf())
868                         break;
869         }
870         pi_disconnect(pf_current->pi);
871         next_request(1);
872 }
873
874 static void do_pf_write(void)
875 {
876         ps_set_intr(do_pf_write_start, NULL, 0, nice);
877 }
878
879 static void do_pf_write_start(void)
880 {
881         pf_busy = 1;
882
883         if (pf_start(pf_current, ATAPI_WRITE_10, pf_block, pf_run)) {
884                 pi_disconnect(pf_current->pi);
885                 if (pf_retries < PF_MAX_RETRIES) {
886                         pf_retries++;
887                         pi_do_claimed(pf_current->pi, do_pf_write_start);
888                         return;
889                 }
890                 next_request(0);
891                 return;
892         }
893
894         while (1) {
895                 if (pf_wait(pf_current, STAT_BUSY, STAT_DRQ | STAT_ERR,
896                             "write block", "data wait") & STAT_ERR) {
897                         pi_disconnect(pf_current->pi);
898                         if (pf_retries < PF_MAX_RETRIES) {
899                                 pf_retries++;
900                                 pi_do_claimed(pf_current->pi, do_pf_write_start);
901                                 return;
902                         }
903                         next_request(0);
904                         return;
905                 }
906                 pi_write_block(pf_current->pi, pf_buf, 512);
907                 if (pf_next_buf())
908                         break;
909         }
910         pf_mask = 0;
911         ps_set_intr(do_pf_write_done, pf_ready, PF_TMO, nice);
912 }
913
914 static void do_pf_write_done(void)
915 {
916         if (pf_wait(pf_current, STAT_BUSY, 0, "write block", "done") & 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(0);
924                 return;
925         }
926         pi_disconnect(pf_current->pi);
927         next_request(1);
928 }
929
930 static int __init pf_init(void)
931 {                               /* preliminary initialisation */
932         struct pf_unit *pf;
933         int unit;
934
935         if (disable)
936                 return -EINVAL;
937
938         pf_init_units();
939
940         if (pf_detect())
941                 return -ENODEV;
942         pf_busy = 0;
943
944         if (register_blkdev(major, name)) {
945                 for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++)
946                         put_disk(pf->disk);
947                 return -EBUSY;
948         }
949         pf_queue = blk_init_queue(do_pf_request, &pf_spin_lock);
950         if (!pf_queue) {
951                 unregister_blkdev(major, name);
952                 for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++)
953                         put_disk(pf->disk);
954                 return -ENOMEM;
955         }
956
957         blk_queue_max_phys_segments(pf_queue, cluster);
958         blk_queue_max_hw_segments(pf_queue, cluster);
959
960         for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++) {
961                 struct gendisk *disk = pf->disk;
962
963                 if (!pf->present)
964                         continue;
965                 disk->private_data = pf;
966                 disk->queue = pf_queue;
967                 add_disk(disk);
968         }
969         return 0;
970 }
971
972 static void __exit pf_exit(void)
973 {
974         struct pf_unit *pf;
975         int unit;
976         unregister_blkdev(major, name);
977         for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++) {
978                 if (!pf->present)
979                         continue;
980                 del_gendisk(pf->disk);
981                 put_disk(pf->disk);
982                 pi_release(pf->pi);
983         }
984         blk_cleanup_queue(pf_queue);
985 }
986
987 MODULE_LICENSE("GPL");
988 module_init(pf_init)
989 module_exit(pf_exit)