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 #include <linux/types.h>
 122
 123 /* Here are things one can override from the insmod command.
 124    Most are autoprobed by paride unless set here.  Verbose is off
 125    by default.
 126
 127 */
 128
 129 static bool verbose = 0;
 130 static int major = PF_MAJOR;
 131 static char *name = PF_NAME;
 132 static int cluster = 64;
 133 static int nice = 0;
 134 static int disable = 0;
 135
 136 static int drive0[7] = { 0, 0, 0, -1, -1, -1, -1 };
 137 static int drive1[7] = { 0, 0, 0, -1, -1, -1, -1 };
 138 static int drive2[7] = { 0, 0, 0, -1, -1, -1, -1 };
 139 static int drive3[7] = { 0, 0, 0, -1, -1, -1, -1 };
 140
 141 static int (*drives[4])[7] = {&drive0, &drive1, &drive2, &drive3};
 142 static int pf_drive_count;
 143
 144 enum {D_PRT, D_PRO, D_UNI, D_MOD, D_SLV, D_LUN, D_DLY};
 145
 146 /* end of parameters */
 147
 148 #include <linux/module.h>
 149 #include <linux/init.h>
 150 #include <linux/fs.h>
 151 #include <linux/delay.h>
 152 #include <linux/hdreg.h>
 153 #include <linux/cdrom.h>
 154 #include <linux/spinlock.h>
 155 #include <linux/blkdev.h>
 156 #include <linux/blkpg.h>
 157 #include <linux/mutex.h>
 158 #include <asm/uaccess.h>
 159
 160 static DEFINE_MUTEX(pf_mutex);
 161 static DEFINE_SPINLOCK(pf_spin_lock);
 162
 163 module_param(verbose, bool, 0644);
 164 module_param(major, int, 0);
 165 module_param(name, charp, 0);
 166 module_param(cluster, int, 0);
 167 module_param(nice, int, 0);
 168 module_param_array(drive0, int, NULL, 0);
 169 module_param_array(drive1, int, NULL, 0);
 170 module_param_array(drive2, int, NULL, 0);
 171 module_param_array(drive3, int, NULL, 0);
 172
 173 #include "paride.h"
 174 #include "pseudo.h"
 175
 176 /* constants for faking geometry numbers */
 177
 178 #define PF_FD_MAX       8192    /* use FD geometry under this size */
 179 #define PF_FD_HDS       2
 180 #define PF_FD_SPT       18
 181 #define PF_HD_HDS       64
 182 #define PF_HD_SPT       32
 183
 184 #define PF_MAX_RETRIES  5
 185 #define PF_TMO          800     /* interrupt timeout in jiffies */
 186 #define PF_SPIN_DEL     50      /* spin delay in micro-seconds  */
 187
 188 #define PF_SPIN         (1000000*PF_TMO)/(HZ*PF_SPIN_DEL)
 189
 190 #define STAT_ERR        0x00001
 191 #define STAT_INDEX      0x00002
 192 #define STAT_ECC        0x00004
 193 #define STAT_DRQ        0x00008
 194 #define STAT_SEEK       0x00010
 195 #define STAT_WRERR      0x00020
 196 #define STAT_READY      0x00040
 197 #define STAT_BUSY       0x00080
 198
 199 #define ATAPI_REQ_SENSE         0x03
 200 #define ATAPI_LOCK              0x1e
 201 #define ATAPI_DOOR              0x1b
 202 #define ATAPI_MODE_SENSE        0x5a
 203 #define ATAPI_CAPACITY          0x25
 204 #define ATAPI_IDENTIFY          0x12
 205 #define ATAPI_READ_10           0x28
 206 #define ATAPI_WRITE_10          0x2a
 207
 208 static int pf_open(struct block_device *bdev, fmode_t mode);
 209 static void do_pf_request(struct request_queue * q);
 210 static int pf_ioctl(struct block_device *bdev, fmode_t mode,
 211                     unsigned int cmd, unsigned long arg);
 212 static int pf_getgeo(struct block_device *bdev, struct hd_geometry *geo);
 213
 214 static int pf_release(struct gendisk *disk, fmode_t mode);
 215
 216 static int pf_detect(void);
 217 static void do_pf_read(void);
 218 static void do_pf_read_start(void);
 219 static void do_pf_write(void);
 220 static void do_pf_write_start(void);
 221 static void do_pf_read_drq(void);
 222 static void do_pf_write_done(void);
 223
 224 #define PF_NM           0
 225 #define PF_RO           1
 226 #define PF_RW           2
 227
 228 #define PF_NAMELEN      8
 229
 230 struct pf_unit {
 231         struct pi_adapter pia;  /* interface to paride layer */
 232         struct pi_adapter *pi;
 233         int removable;          /* removable media device  ?  */
 234         int media_status;       /* media present ?  WP ? */
 235         int drive;              /* drive */
 236         int lun;
 237         int access;             /* count of active opens ... */
 238         int present;            /* device present ? */
 239         char name[PF_NAMELEN];  /* pf0, pf1, ... */
 240         struct gendisk *disk;
 241 };
 242
 243 static struct pf_unit units[PF_UNITS];
 244
 245 static int pf_identify(struct pf_unit *pf);
 246 static void pf_lock(struct pf_unit *pf, int func);
 247 static void pf_eject(struct pf_unit *pf);
 248 static unsigned int pf_check_events(struct gendisk *disk,
 249                                     unsigned int clearing);
 250
 251 static char pf_scratch[512];    /* scratch block buffer */
 252
 253 /* the variables below are used mainly in the I/O request engine, which
 254    processes only one request at a time.
 255 */
 256
 257 static int pf_retries = 0;      /* i/o error retry count */
 258 static int pf_busy = 0;         /* request being processed ? */
 259 static struct request *pf_req;  /* current request */
 260 static int pf_block;            /* address of next requested block */
 261 static int pf_count;            /* number of blocks still to do */
 262 static int pf_run;              /* sectors in current cluster */
 263 static int pf_cmd;              /* current command READ/WRITE */
 264 static struct pf_unit *pf_current;/* unit of current request */
 265 static int pf_mask;             /* stopper for pseudo-int */
 266 static char *pf_buf;            /* buffer for request in progress */
 267
 268 /* kernel glue structures */
 269
 270 static const struct block_device_operations pf_fops = {
 271         .owner          = THIS_MODULE,
 272         .open           = pf_open,
 273         .release        = pf_release,
 274         .ioctl          = pf_ioctl,
 275         .getgeo         = pf_getgeo,
 276         .check_events   = pf_check_events,
 277 };
 278
 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
 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
 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
 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
 363 static int pf_release(struct gendisk *disk, fmode_t mode)
 364 {
 365         struct pf_unit *pf = disk->private_data;
 366
 367         mutex_lock(&pf_mutex);
 368         if (pf->access <= 0) {
 369                 mutex_unlock(&pf_mutex);
 370                 return -EINVAL;
 371         }
 372
 373         pf->access--;
 374
 375         if (!pf->access && pf->removable)
 376                 pf_lock(pf, 0);
 377
 378         mutex_unlock(&pf_mutex);
 379         return 0;
 380
 381 }
 382
 383 static unsigned int pf_check_events(struct gendisk *disk, unsigned int clearing)
 384 {
 385         return DISK_EVENT_MEDIA_CHANGE;
 386 }
 387
 388 static inline int status_reg(struct pf_unit *pf)
 389 {
 390         return pi_read_regr(pf->pi, 1, 6);
 391 }
 392
 393 static inline int read_reg(struct pf_unit *pf, int reg)
 394 {
 395         return pi_read_regr(pf->pi, 0, reg);
 396 }
 397
 398 static inline void write_reg(struct pf_unit *pf, int reg, int val)
 399 {
 400         pi_write_regr(pf->pi, 0, reg, val);
 401 }
 402
 403 static int pf_wait(struct pf_unit *pf, int go, int stop, char *fun, char *msg)
 404 {
 405         int j, r, e, s, p;
 406
 407         j = 0;
 408         while ((((r = status_reg(pf)) & go) || (stop && (!(r & stop))))
 409                && (j++ < PF_SPIN))
 410                 udelay(PF_SPIN_DEL);
 411
 412         if ((r & (STAT_ERR & stop)) || (j > PF_SPIN)) {
 413                 s = read_reg(pf, 7);
 414                 e = read_reg(pf, 1);
 415                 p = read_reg(pf, 2);
 416                 if (j > PF_SPIN)
 417                         e |= 0x100;
 418                 if (fun)
 419                         printk("%s: %s %s: alt=0x%x stat=0x%x err=0x%x"
 420                                " loop=%d phase=%d\n",
 421                                pf->name, fun, msg, r, s, e, j, p);
 422                 return (e << 8) + s;
 423         }
 424         return 0;
 425 }
 426
 427 static int pf_command(struct pf_unit *pf, char *cmd, int dlen, char *fun)
 428 {
 429         pi_connect(pf->pi);
 430
 431         write_reg(pf, 6, 0xa0+0x10*pf->drive);
 432
 433         if (pf_wait(pf, STAT_BUSY | STAT_DRQ, 0, fun, "before command")) {
 434                 pi_disconnect(pf->pi);
 435                 return -1;
 436         }
 437
 438         write_reg(pf, 4, dlen % 256);
 439         write_reg(pf, 5, dlen / 256);
 440         write_reg(pf, 7, 0xa0); /* ATAPI packet command */
 441
 442         if (pf_wait(pf, STAT_BUSY, STAT_DRQ, fun, "command DRQ")) {
 443                 pi_disconnect(pf->pi);
 444                 return -1;
 445         }
 446
 447         if (read_reg(pf, 2) != 1) {
 448                 printk("%s: %s: command phase error\n", pf->name, fun);
 449                 pi_disconnect(pf->pi);
 450                 return -1;
 451         }
 452
 453         pi_write_block(pf->pi, cmd, 12);
 454
 455         return 0;
 456 }
 457
 458 static int pf_completion(struct pf_unit *pf, char *buf, char *fun)
 459 {
 460         int r, s, n;
 461
 462         r = pf_wait(pf, STAT_BUSY, STAT_DRQ | STAT_READY | STAT_ERR,
 463                     fun, "completion");
 464
 465         if ((read_reg(pf, 2) & 2) && (read_reg(pf, 7) & STAT_DRQ)) {
 466                 n = (((read_reg(pf, 4) + 256 * read_reg(pf, 5)) +
 467                       3) & 0xfffc);
 468                 pi_read_block(pf->pi, buf, n);
 469         }
 470
 471         s = pf_wait(pf, STAT_BUSY, STAT_READY | STAT_ERR, fun, "data done");
 472
 473         pi_disconnect(pf->pi);
 474
 475         return (r ? r : s);
 476 }
 477
 478 static void pf_req_sense(struct pf_unit *pf, int quiet)
 479 {
 480         char rs_cmd[12] =
 481             { ATAPI_REQ_SENSE, pf->lun << 5, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0 };
 482         char buf[16];
 483         int r;
 484
 485         r = pf_command(pf, rs_cmd, 16, "Request sense");
 486         mdelay(1);
 487         if (!r)
 488                 pf_completion(pf, buf, "Request sense");
 489
 490         if ((!r) && (!quiet))
 491                 printk("%s: Sense key: %x, ASC: %x, ASQ: %x\n",
 492                        pf->name, buf[2] & 0xf, buf[12], buf[13]);
 493 }
 494
 495 static int pf_atapi(struct pf_unit *pf, char *cmd, int dlen, char *buf, char *fun)
 496 {
 497         int r;
 498
 499         r = pf_command(pf, cmd, dlen, fun);
 500         mdelay(1);
 501         if (!r)
 502                 r = pf_completion(pf, buf, fun);
 503         if (r)
 504                 pf_req_sense(pf, !fun);
 505
 506         return r;
 507 }
 508
 509 static void pf_lock(struct pf_unit *pf, int func)
 510 {
 511         char lo_cmd[12] = { ATAPI_LOCK, pf->lun << 5, 0, 0, func, 0, 0, 0, 0, 0, 0, 0 };
 512
 513         pf_atapi(pf, lo_cmd, 0, pf_scratch, func ? "lock" : "unlock");
 514 }
 515
 516 static void pf_eject(struct pf_unit *pf)
 517 {
 518         char ej_cmd[12] = { ATAPI_DOOR, pf->lun << 5, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0 };
 519
 520         pf_lock(pf, 0);
 521         pf_atapi(pf, ej_cmd, 0, pf_scratch, "eject");
 522 }
 523
 524 #define PF_RESET_TMO   30       /* in tenths of a second */
 525
 526 static void pf_sleep(int cs)
 527 {
 528         schedule_timeout_interruptible(cs);
 529 }
 530
 531 /* the ATAPI standard actually specifies the contents of all 7 registers
 532    after a reset, but the specification is ambiguous concerning the last
 533    two bytes, and different drives interpret the standard differently.
 534  */
 535
 536 static int pf_reset(struct pf_unit *pf)
 537 {
 538         int i, k, flg;
 539         int expect[5] = { 1, 1, 1, 0x14, 0xeb };
 540
 541         pi_connect(pf->pi);
 542         write_reg(pf, 6, 0xa0+0x10*pf->drive);
 543         write_reg(pf, 7, 8);
 544
 545         pf_sleep(20 * HZ / 1000);
 546
 547         k = 0;
 548         while ((k++ < PF_RESET_TMO) && (status_reg(pf) & STAT_BUSY))
 549                 pf_sleep(HZ / 10);
 550
 551         flg = 1;
 552         for (i = 0; i < 5; i++)
 553                 flg &= (read_reg(pf, i + 1) == expect[i]);
 554
 555         if (verbose) {
 556                 printk("%s: Reset (%d) signature = ", pf->name, k);
 557                 for (i = 0; i < 5; i++)
 558                         printk("%3x", read_reg(pf, i + 1));
 559                 if (!flg)
 560                         printk(" (incorrect)");
 561                 printk("\n");
 562         }
 563
 564         pi_disconnect(pf->pi);
 565         return flg - 1;
 566 }
 567
 568 static void pf_mode_sense(struct pf_unit *pf)
 569 {
 570         char ms_cmd[12] =
 571             { ATAPI_MODE_SENSE, pf->lun << 5, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0 };
 572         char buf[8];
 573
 574         pf_atapi(pf, ms_cmd, 8, buf, "mode sense");
 575         pf->media_status = PF_RW;
 576         if (buf[3] & 0x80)
 577                 pf->media_status = PF_RO;
 578 }
 579
 580 static void xs(char *buf, char *targ, int offs, int len)
 581 {
 582         int j, k, l;
 583
 584         j = 0;
 585         l = 0;
 586         for (k = 0; k < len; k++)
 587                 if ((buf[k + offs] != 0x20) || (buf[k + offs] != l))
 588                         l = targ[j++] = buf[k + offs];
 589         if (l == 0x20)
 590                 j--;
 591         targ[j] = 0;
 592 }
 593
 594 static int xl(char *buf, int offs)
 595 {
 596         int v, k;
 597
 598         v = 0;
 599         for (k = 0; k < 4; k++)
 600                 v = v * 256 + (buf[k + offs] & 0xff);
 601         return v;
 602 }
 603
 604 static void pf_get_capacity(struct pf_unit *pf)
 605 {
 606         char rc_cmd[12] = { ATAPI_CAPACITY, pf->lun << 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 607         char buf[8];
 608         int bs;
 609
 610         if (pf_atapi(pf, rc_cmd, 8, buf, "get capacity")) {
 611                 pf->media_status = PF_NM;
 612                 return;
 613         }
 614         set_capacity(pf->disk, xl(buf, 0) + 1);
 615         bs = xl(buf, 4);
 616         if (bs != 512) {
 617                 set_capacity(pf->disk, 0);
 618                 if (verbose)
 619                         printk("%s: Drive %d, LUN %d,"
 620                                " unsupported block size %d\n",
 621                                pf->name, pf->drive, pf->lun, bs);
 622         }
 623 }
 624
 625 static int pf_identify(struct pf_unit *pf)
 626 {
 627         int dt, s;
 628         char *ms[2] = { "master", "slave" };
 629         char mf[10], id[18];
 630         char id_cmd[12] =
 631             { ATAPI_IDENTIFY, pf->lun << 5, 0, 0, 36, 0, 0, 0, 0, 0, 0, 0 };
 632         char buf[36];
 633
 634         s = pf_atapi(pf, id_cmd, 36, buf, "identify");
 635         if (s)
 636                 return -1;
 637
 638         dt = buf[0] & 0x1f;
 639         if ((dt != 0) && (dt != 7)) {
 640                 if (verbose)
 641                         printk("%s: Drive %d, LUN %d, unsupported type %d\n",
 642                                pf->name, pf->drive, pf->lun, dt);
 643                 return -1;
 644         }
 645
 646         xs(buf, mf, 8, 8);
 647         xs(buf, id, 16, 16);
 648
 649         pf->removable = (buf[1] & 0x80);
 650
 651         pf_mode_sense(pf);
 652         pf_mode_sense(pf);
 653         pf_mode_sense(pf);
 654
 655         pf_get_capacity(pf);
 656
 657         printk("%s: %s %s, %s LUN %d, type %d",
 658                pf->name, mf, id, ms[pf->drive], pf->lun, dt);
 659         if (pf->removable)
 660                 printk(", removable");
 661         if (pf->media_status == PF_NM)
 662                 printk(", no media\n");
 663         else {
 664                 if (pf->media_status == PF_RO)
 665                         printk(", RO");
 666                 printk(", %llu blocks\n",
 667                         (unsigned long long)get_capacity(pf->disk));
 668         }
 669         return 0;
 670 }
 671
 672 /*      returns  0, with id set if drive is detected
 673                 -1, if drive detection failed
 674 */
 675 static int pf_probe(struct pf_unit *pf)
 676 {
 677         if (pf->drive == -1) {
 678                 for (pf->drive = 0; pf->drive <= 1; pf->drive++)
 679                         if (!pf_reset(pf)) {
 680                                 if (pf->lun != -1)
 681                                         return pf_identify(pf);
 682                                 else
 683                                         for (pf->lun = 0; pf->lun < 8; pf->lun++)
 684                                                 if (!pf_identify(pf))
 685                                                         return 0;
 686                         }
 687         } else {
 688                 if (pf_reset(pf))
 689                         return -1;
 690                 if (pf->lun != -1)
 691                         return pf_identify(pf);
 692                 for (pf->lun = 0; pf->lun < 8; pf->lun++)
 693                         if (!pf_identify(pf))
 694                                 return 0;
 695         }
 696         return -1;
 697 }
 698
 699 static int pf_detect(void)
 700 {
 701         struct pf_unit *pf = units;
 702         int k, unit;
 703
 704         printk("%s: %s version %s, major %d, cluster %d, nice %d\n",
 705                name, name, PF_VERSION, major, cluster, nice);
 706
 707         k = 0;
 708         if (pf_drive_count == 0) {
 709                 if (pi_init(pf->pi, 1, -1, -1, -1, -1, -1, pf_scratch, PI_PF,
 710                             verbose, pf->name)) {
 711                         if (!pf_probe(pf) && pf->disk) {
 712                                 pf->present = 1;
 713                                 k++;
 714                         } else
 715                                 pi_release(pf->pi);
 716                 }
 717
 718         } else
 719                 for (unit = 0; unit < PF_UNITS; unit++, pf++) {
 720                         int *conf = *drives[unit];
 721                         if (!conf[D_PRT])
 722                                 continue;
 723                         if (pi_init(pf->pi, 0, conf[D_PRT], conf[D_MOD],
 724                                     conf[D_UNI], conf[D_PRO], conf[D_DLY],
 725                                     pf_scratch, PI_PF, verbose, pf->name)) {
 726                                 if (pf->disk && !pf_probe(pf)) {
 727                                         pf->present = 1;
 728                                         k++;
 729                                 } else
 730                                         pi_release(pf->pi);
 731                         }
 732                 }
 733         if (k)
 734                 return 0;
 735
 736         printk("%s: No ATAPI disk detected\n", name);
 737         for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++)
 738                 put_disk(pf->disk);
 739         return -1;
 740 }
 741
 742 /* The i/o request engine */
 743
 744 static int pf_start(struct pf_unit *pf, int cmd, int b, int c)
 745 {
 746         int i;
 747         char io_cmd[12] = { cmd, pf->lun << 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 748
 749         for (i = 0; i < 4; i++) {
 750                 io_cmd[5 - i] = b & 0xff;
 751                 b = b >> 8;
 752         }
 753
 754         io_cmd[8] = c & 0xff;
 755         io_cmd[7] = (c >> 8) & 0xff;
 756
 757         i = pf_command(pf, io_cmd, c * 512, "start i/o");
 758
 759         mdelay(1);
 760
 761         return i;
 762 }
 763
 764 static int pf_ready(void)
 765 {
 766         return (((status_reg(pf_current) & (STAT_BUSY | pf_mask)) == pf_mask));
 767 }
 768
 769 static struct request_queue *pf_queue;
 770
 771 static void pf_end_request(int err)
 772 {
 773         if (pf_req && !__blk_end_request_cur(pf_req, err))
 774                 pf_req = NULL;
 775 }
 776
 777 static void do_pf_request(struct request_queue * q)
 778 {
 779         if (pf_busy)
 780                 return;
 781 repeat:
 782         if (!pf_req) {
 783                 pf_req = blk_fetch_request(q);
 784                 if (!pf_req)
 785                         return;
 786         }
 787
 788         pf_current = pf_req->rq_disk->private_data;
 789         pf_block = blk_rq_pos(pf_req);
 790         pf_run = blk_rq_sectors(pf_req);
 791         pf_count = blk_rq_cur_sectors(pf_req);
 792
 793         if (pf_block + pf_count > get_capacity(pf_req->rq_disk)) {
 794                 pf_end_request(-EIO);
 795                 goto repeat;
 796         }
 797
 798         pf_cmd = rq_data_dir(pf_req);
 799         pf_buf = pf_req->buffer;
 800         pf_retries = 0;
 801
 802         pf_busy = 1;
 803         if (pf_cmd == READ)
 804                 pi_do_claimed(pf_current->pi, do_pf_read);
 805         else if (pf_cmd == WRITE)
 806                 pi_do_claimed(pf_current->pi, do_pf_write);
 807         else {
 808                 pf_busy = 0;
 809                 pf_end_request(-EIO);
 810                 goto repeat;
 811         }
 812 }
 813
 814 static int pf_next_buf(void)
 815 {
 816         unsigned long saved_flags;
 817
 818         pf_count--;
 819         pf_run--;
 820         pf_buf += 512;
 821         pf_block++;
 822         if (!pf_run)
 823                 return 1;
 824         if (!pf_count) {
 825                 spin_lock_irqsave(&pf_spin_lock, saved_flags);
 826                 pf_end_request(0);
 827                 spin_unlock_irqrestore(&pf_spin_lock, saved_flags);
 828                 if (!pf_req)
 829                         return 1;
 830                 pf_count = blk_rq_cur_sectors(pf_req);
 831                 pf_buf = pf_req->buffer;
 832         }
 833         return 0;
 834 }
 835
 836 static inline void next_request(int err)
 837 {
 838         unsigned long saved_flags;
 839
 840         spin_lock_irqsave(&pf_spin_lock, saved_flags);
 841         pf_end_request(err);
 842         pf_busy = 0;
 843         do_pf_request(pf_queue);
 844         spin_unlock_irqrestore(&pf_spin_lock, saved_flags);
 845 }
 846
 847 /* detach from the calling context - in case the spinlock is held */
 848 static void do_pf_read(void)
 849 {
 850         ps_set_intr(do_pf_read_start, NULL, 0, nice);
 851 }
 852
 853 static void do_pf_read_start(void)
 854 {
 855         pf_busy = 1;
 856
 857         if (pf_start(pf_current, ATAPI_READ_10, pf_block, pf_run)) {
 858                 pi_disconnect(pf_current->pi);
 859                 if (pf_retries < PF_MAX_RETRIES) {
 860                         pf_retries++;
 861                         pi_do_claimed(pf_current->pi, do_pf_read_start);
 862                         return;
 863                 }
 864                 next_request(-EIO);
 865                 return;
 866         }
 867         pf_mask = STAT_DRQ;
 868         ps_set_intr(do_pf_read_drq, pf_ready, PF_TMO, nice);
 869 }
 870
 871 static void do_pf_read_drq(void)
 872 {
 873         while (1) {
 874                 if (pf_wait(pf_current, STAT_BUSY, STAT_DRQ | STAT_ERR,
 875                             "read block", "completion") & STAT_ERR) {
 876                         pi_disconnect(pf_current->pi);
 877                         if (pf_retries < PF_MAX_RETRIES) {
 878                                 pf_req_sense(pf_current, 0);
 879                                 pf_retries++;
 880                                 pi_do_claimed(pf_current->pi, do_pf_read_start);
 881                                 return;
 882                         }
 883                         next_request(-EIO);
 884                         return;
 885                 }
 886                 pi_read_block(pf_current->pi, pf_buf, 512);
 887                 if (pf_next_buf())
 888                         break;
 889         }
 890         pi_disconnect(pf_current->pi);
 891         next_request(0);
 892 }
 893
 894 static void do_pf_write(void)
 895 {
 896         ps_set_intr(do_pf_write_start, NULL, 0, nice);
 897 }
 898
 899 static void do_pf_write_start(void)
 900 {
 901         pf_busy = 1;
 902
 903         if (pf_start(pf_current, ATAPI_WRITE_10, pf_block, pf_run)) {
 904                 pi_disconnect(pf_current->pi);
 905                 if (pf_retries < PF_MAX_RETRIES) {
 906                         pf_retries++;
 907                         pi_do_claimed(pf_current->pi, do_pf_write_start);
 908                         return;
 909                 }
 910                 next_request(-EIO);
 911                 return;
 912         }
 913
 914         while (1) {
 915                 if (pf_wait(pf_current, STAT_BUSY, STAT_DRQ | STAT_ERR,
 916                             "write block", "data wait") & STAT_ERR) {
 917                         pi_disconnect(pf_current->pi);
 918                         if (pf_retries < PF_MAX_RETRIES) {
 919                                 pf_retries++;
 920                                 pi_do_claimed(pf_current->pi, do_pf_write_start);
 921                                 return;
 922                         }
 923                         next_request(-EIO);
 924                         return;
 925                 }
 926                 pi_write_block(pf_current->pi, pf_buf, 512);
 927                 if (pf_next_buf())
 928                         break;
 929         }
 930         pf_mask = 0;
 931         ps_set_intr(do_pf_write_done, pf_ready, PF_TMO, nice);
 932 }
 933
 934 static void do_pf_write_done(void)
 935 {
 936         if (pf_wait(pf_current, STAT_BUSY, 0, "write block", "done") & STAT_ERR) {
 937                 pi_disconnect(pf_current->pi);
 938                 if (pf_retries < PF_MAX_RETRIES) {
 939                         pf_retries++;
 940                         pi_do_claimed(pf_current->pi, do_pf_write_start);
 941                         return;
 942                 }
 943                 next_request(-EIO);
 944                 return;
 945         }
 946         pi_disconnect(pf_current->pi);
 947         next_request(0);
 948 }
 949
 950 static int __init pf_init(void)
 951 {                               /* preliminary initialisation */
 952         struct pf_unit *pf;
 953         int unit;
 954
 955         if (disable)
 956                 return -EINVAL;
 957
 958         pf_init_units();
 959
 960         if (pf_detect())
 961                 return -ENODEV;
 962         pf_busy = 0;
 963
 964         if (register_blkdev(major, name)) {
 965                 for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++)
 966                         put_disk(pf->disk);
 967                 return -EBUSY;
 968         }
 969         pf_queue = blk_init_queue(do_pf_request, &pf_spin_lock);
 970         if (!pf_queue) {
 971                 unregister_blkdev(major, name);
 972                 for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++)
 973                         put_disk(pf->disk);
 974                 return -ENOMEM;
 975         }
 976
 977         blk_queue_max_segments(pf_queue, cluster);
 978
 979         for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++) {
 980                 struct gendisk *disk = pf->disk;
 981
 982                 if (!pf->present)
 983                         continue;
 984                 disk->private_data = pf;
 985                 disk->queue = pf_queue;
 986                 add_disk(disk);
 987         }
 988         return 0;
 989 }
 990
 991 static void __exit pf_exit(void)
 992 {
 993         struct pf_unit *pf;
 994         int unit;
 995         unregister_blkdev(major, name);
 996         for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++) {
 997                 if (!pf->present)
 998                         continue;
 999                 del_gendisk(pf->disk);
1000                 put_disk(pf->disk);
1001                 pi_release(pf->pi);
1002         }
1003         blk_cleanup_queue(pf_queue);
1004 }
1005
1006 MODULE_LICENSE("GPL");
1007 module_init(pf_init)
1008 module_exit(pf_exit)