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