git.oblomov.eu Git - linux-2.6/blob - 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(struct request_queue * 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(struct request_queue * 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)