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