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