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