drivers/block/paride/pf.c

   1 /*
   2         pf.c    (c) 1997-8  Grant R. Guenther <grant@torque.net>
   3                             Under the terms of the GNU General Public License.
   4
   5         This is the high-level driver for parallel port ATAPI disk
   6         drives based on chips supported by the paride module.
   7
   8         By default, the driver will autoprobe for a single parallel
   9         port ATAPI disk drive, but if their individual parameters are
  10         specified, the driver can handle up to 4 drives.
  11
  12         The behaviour of the pf driver can be altered by setting
  13         some parameters from the insmod command line.  The following
  14         parameters are adjustable:
  15
  16             drive0      These four arguments can be arrays of
  17             drive1      1-7 integers as follows:
  18             drive2
  19             drive3      <prt>,<pro>,<uni>,<mod>,<slv>,<lun>,<dly>
  20
  21                         Where,
  22
  23                 <prt>   is the base of the parallel port address for
  24                         the corresponding drive.  (required)
  25
  26                 <pro>   is the protocol number for the adapter that
  27                         supports this drive.  These numbers are
  28                         logged by 'paride' when the protocol modules
  29                         are initialised.  (0 if not given)
  30
  31                 <uni>   for those adapters that support chained
  32                         devices, this is the unit selector for the
  33                         chain of devices on the given port.  It should
  34                         be zero for devices that don't support chaining.
  35                         (0 if not given)
  36
  37                 <mod>   this can be -1 to choose the best mode, or one
  38                         of the mode numbers supported by the adapter.
  39                         (-1 if not given)
  40
  41                 <slv>   ATAPI CDroms can be jumpered to master or slave.
  42                         Set this to 0 to choose the master drive, 1 to
  43                         choose the slave, -1 (the default) to choose the
  44                         first drive found.
  45
  46                 <lun>   Some ATAPI devices support multiple LUNs.
  47                         One example is the ATAPI PD/CD drive from
  48                         Matshita/Panasonic.  This device has a
  49                         CD drive on LUN 0 and a PD drive on LUN 1.
  50                         By default, the driver will search for the
  51                         first LUN with a supported device.  Set
  52                         this parameter to force it to use a specific
  53                         LUN.  (default -1)
  54
  55                 <dly>   some parallel ports require the driver to
  56                         go more slowly.  -1 sets a default value that
  57                         should work with the chosen protocol.  Otherwise,
  58                         set this to a small integer, the larger it is
  59                         the slower the port i/o.  In some cases, setting
  60                         this to zero will speed up the device. (default -1)
  61
  62             major       You may use this parameter to overide the
  63                         default major number (47) that this driver
  64                         will use.  Be sure to change the device
  65                         name as well.
  66
  67             name        This parameter is a character string that
  68                         contains the name the kernel will use for this
  69                         device (in /proc output, for instance).
  70                         (default "pf").
  71
  72             cluster     The driver will attempt to aggregate requests
  73                         for adjacent blocks into larger multi-block
  74                         clusters.  The maximum cluster size (in 512
  75                         byte sectors) is set with this parameter.
  76                         (default 64)
  77
  78             verbose     This parameter controls the amount of logging
  79                         that the driver will do.  Set it to 0 for
  80                         normal operation, 1 to see autoprobe progress
  81                         messages, or 2 to see additional debugging
  82                         output.  (default 0)
  83
  84             nice        This parameter controls the driver's use of
  85                         idle CPU time, at the expense of some speed.
  86
  87         If this driver is built into the kernel, you can use the
  88         following command line parameters, with the same values
  89         as the corresponding module parameters listed above:
  90
  91             pf.drive0
  92             pf.drive1
  93             pf.drive2
  94             pf.drive3
  95             pf.cluster
  96             pf.nice
  97
  98         In addition, you can use the parameter pf.disable to disable
  99         the driver entirely.
 100
 101 */
 102
 103 /* Changes:
 104
 105         1.01    GRG 1998.05.03  Changes for SMP.  Eliminate sti().
 106                                 Fix for drives that don't clear STAT_ERR
 107                                 until after next CDB delivered.
 108                                 Small change in pf_completion to round
 109                                 up transfer size.
 110         1.02    GRG 1998.06.16  Eliminated an Ugh
 111         1.03    GRG 1998.08.16  Use HZ in loop timings, extra debugging
 112         1.04    GRG 1998.09.24  Added jumbo support
 113
 114 */
 115
 116 #define PF_VERSION      "1.04"
 117 #define PF_MAJOR        47
 118 #define PF_NAME         "pf"
 119 #define PF_UNITS        4
 120
 121 /* Here are things one can override from the insmod command.
 122    Most are autoprobed by paride unless set here.  Verbose is off
 123    by default.
 124
 125 */
 126
 127 static int verbose = 0;
 128 static int major = PF_MAJOR;
 129 static char *name = PF_NAME;
 130 static int cluster = 64;
 131 static int nice = 0;
 132 static int disable = 0;
 133
 134 static int drive0[7] = { 0, 0, 0, -1, -1, -1, -1 };
 135 static int drive1[7] = { 0, 0, 0, -1, -1, -1, -1 };
 136 static int drive2[7] = { 0, 0, 0, -1, -1, -1, -1 };
 137 static int drive3[7] = { 0, 0, 0, -1, -1, -1, -1 };
 138
 139 static int (*drives[4])[7] = {&drive0, &drive1, &drive2, &drive3};
 140 static int pf_drive_count;
 141
 142 enum {D_PRT, D_PRO, D_UNI, D_MOD, D_SLV, D_LUN, D_DLY};
 143
 144 /* end of parameters */
 145
 146 #include <linux/module.h>
 147 #include <linux/init.h>
 148 #include <linux/fs.h>
 149 #include <linux/delay.h>
 150 #include <linux/hdreg.h>
 151 #include <linux/cdrom.h>
 152 #include <linux/spinlock.h>
 153 #include <linux/blkdev.h>
 154 #include <linux/blkpg.h>
 155 #include <linux/mutex.h>
 156 #include <asm/uaccess.h>
 157
 158 static DEFINE_MUTEX(pf_mutex);
 159 static DEFINE_SPINLOCK(pf_spin_lock);
 160
 161 module_param(verbose, bool, 0644);
 162 module_param(major, int, 0);
 163 module_param(name, charp, 0);
 164 module_param(cluster, int, 0);
 165 module_param(nice, int, 0);
 166 module_param_array(drive0, int, NULL, 0);
 167 module_param_array(drive1, int, NULL, 0);
 168 module_param_array(drive2, int, NULL, 0);
 169 module_param_array(drive3, int, NULL, 0);
 170
 171 #include "paride.h"
 172 #include "pseudo.h"
 173
 174 /* constants for faking geometry numbers */
 175
 176 #define PF_FD_MAX       8192    /* use FD geometry under this size */
 177 #define PF_FD_HDS       2
 178 #define PF_FD_SPT       18
 179 #define PF_HD_HDS       64
 180 #define PF_HD_SPT       32
 181
 182 #define PF_MAX_RETRIES  5
 183 #define PF_TMO          800     /* interrupt timeout in jiffies */
 184 #define PF_SPIN_DEL     50      /* spin delay in micro-seconds  */
 185
 186 #define PF_SPIN         (1000000*PF_TMO)/(HZ*PF_SPIN_DEL)
 187
 188 #define STAT_ERR        0x00001
 189 #define STAT_INDEX      0x00002
 190 #define STAT_ECC        0x00004
 191 #define STAT_DRQ        0x00008
 192 #define STAT_SEEK       0x00010
 193 #define STAT_WRERR      0x00020
 194 #define STAT_READY      0x00040
 195 #define STAT_BUSY       0x00080
 196
 197 #define ATAPI_REQ_SENSE         0x03
 198 #define ATAPI_LOCK              0x1e
 199 #define ATAPI_DOOR              0x1b
 200 #define ATAPI_MODE_SENSE        0x5a
 201 #define ATAPI_CAPACITY          0x25
 202 #define ATAPI_IDENTIFY          0x12
 203 #define ATAPI_READ_10           0x28
 204 #define ATAPI_WRITE_10          0x2a
 205
 206 static int pf_open(struct block_device *bdev, fmode_t mode);
 207 static void do_pf_request(struct request_queue * q);
 208 static int pf_ioctl(struct block_device *bdev, fmode_t mode,
 209                     unsigned int cmd, unsigned long arg);
 210 static int pf_getgeo(struct block_device *bdev, struct hd_geometry *geo);
 211
 212 static int pf_release(struct gendisk *disk, fmode_t mode);
 213
 214 static int pf_detect(void);
 215 static void do_pf_read(void);
 216 static void do_pf_read_start(void);
 217 static void do_pf_write(void);
 218 static void do_pf_write_start(void);
 219 static void do_pf_read_drq(void);
 220 static void do_pf_write_done(void);
 221
 222 #define PF_NM           0
 223 #define PF_RO           1
 224 #define PF_RW           2
 225
 226 #define PF_NAMELEN      8
 227
 228 struct pf_unit {
 229         struct pi_adapter pia;  /* interface to paride layer */
 230         struct pi_adapter *pi;
 231         int removable;          /* removable media device  ?  */
 232         int media_status;       /* media present ?  WP ? */
 233         int drive;              /* drive */
 234         int lun;
 235         int access;             /* count of active opens ... */
 236         int present;            /* device present ? */
 237         char name[PF_NAMELEN];  /* pf0, pf1, ... */
 238         struct gendisk *disk;
 239 };
 240
 241 static struct pf_unit units[PF_UNITS];
 242
 243 static int pf_identify(struct pf_unit *pf);
 244 static void pf_lock(struct pf_unit *pf, int func);
 245 static void pf_eject(struct pf_unit *pf);
 246 static unsigned int pf_check_events(struct gendisk *disk,
 247                                     unsigned int clearing);
 248
 249 static char pf_scratch[512];    /* scratch block buffer */
 250
 251 /* the variables below are used mainly in the I/O request engine, which
 252    processes only one request at a time.
 253 */
 254
 255 static int pf_retries = 0;      /* i/o error retry count */
 256 static int pf_busy = 0;         /* request being processed ? */
 257 static struct request *pf_req;  /* current request */
 258 static int pf_block;            /* address of next requested block */
 259 static int pf_count;            /* number of blocks still to do */
 260 static int pf_run;              /* sectors in current cluster */
 261 static int pf_cmd;              /* current command READ/WRITE */
 262 static struct pf_unit *pf_current;/* unit of current request */
 263 static int pf_mask;             /* stopper for pseudo-int */
 264 static char *pf_buf;            /* buffer for request in progress */
 265
 266 /* kernel glue structures */
 267
 268 static const struct block_device_operations pf_fops = {
 269         .owner          = THIS_MODULE,
 270         .open           = pf_open,
 271         .release        = pf_release,
 272         .ioctl          = pf_ioctl,
 273         .getgeo         = pf_getgeo,
 274         .check_events   = pf_check_events,
 275 };
 276
 277 static void __init pf_init_units(void)
 278 {
 279         struct pf_unit *pf;
 280         int unit;
 281
 282         pf_drive_count = 0;
 283         for (unit = 0, pf = units; unit < PF_UNITS; unit++, pf++) {
 284                 struct gendisk *disk = alloc_disk(1);
 285                 if (!disk)
 286                         continue;
 287                 pf->disk = disk;
 288                 pf->pi = &pf->pia;
 289                 pf->media_status = PF_NM;
 290                 pf->drive = (*drives[unit])[D_SLV];
 291                 pf->lun = (*drives[unit])[D_LUN];
 292                 snprintf(pf->name, PF_NAMELEN, "%s%d", name, unit);
 293                 disk->major = major;
 294                 disk->first_minor = unit;
 295                 strcpy(disk->disk_name, pf->name);
 296                 disk->fops = &pf_fops;
 297                 disk->events = DISK_EVENT_MEDIA_CHANGE;
 298                 if (!(*drives[unit])[D_PRT])
 299                         pf_drive_count++;
 300         }
 301 }
 302
 303 static int pf_open(struct block_device *bdev, fmode_t mode)
 304 {
 305         struct pf_unit *pf = bdev->bd_disk->private_data;
 306         int ret;
 307
 308         mutex_lock(&pf_mutex);
 309         pf_identify(pf);
 310
 311         ret = -ENODEV;
 312         if (pf->media_status == PF_NM)
 313                 goto out;
 314
 315         ret = -EROFS;
 316         if ((pf->media_status == PF_RO) && (mode & FMODE_WRITE))
 317                 goto out;
 318
 319         ret = 0;
 320         pf->access++;
 321         if (pf->removable)
 322                 pf_lock(pf, 1);
 323 out:
 324         mutex_unlock(&pf_mutex);
 325         return ret;
 326 }
 327
 328 static int pf_getgeo(struct block_device *bdev, struct hd_geometry *geo)
 329 {
 330         struct pf_unit *pf = bdev->bd_disk->private_data;
 331         sector_t capacity = get_capacity(pf->disk);
 332
 333         if (capacity < PF_FD_MAX) {
 334                 geo->cylinders = sector_div(capacity, PF_FD_HDS * PF_FD_SPT);
 335                 geo->heads = PF_FD_HDS;
 336                 geo->sectors = PF_FD_SPT;
 337         } else {
 338                 geo->cylinders = sector_div(capacity, PF_HD_HDS * PF_HD_SPT);
 339                 geo->heads = PF_HD_HDS;
 340                 geo->sectors = PF_HD_SPT;
 341         }
 342
 343         return 0;
 344 }
 345
 346 static int pf_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd, unsigned long arg)
 347 {
 348         struct pf_unit *pf = bdev->bd_disk->private_data;
 349
 350         if (cmd != CDROMEJECT)
 351                 return -EINVAL;
 352
 353         if (pf->access != 1)
 354                 return -EBUSY;
 355         mutex_lock(&pf_mutex);
 356         pf_eject(pf);
 357         mutex_unlock(&pf_mutex);
 358
 359         return 0;
 360 }
 361
 362 static int pf_release(struct gendisk *disk, fmode_t mode)
 363 {
 364         struct pf_unit *pf = disk->private_data;
 365
 366         mutex_lock(&pf_mutex);
 367         if (pf->access <= 0) {
 368                 mutex_unlock(&pf_mutex);
 369                 return -EINVAL;
 370         }
 371
 372         pf->access--;
 373
 374         if (!pf->access && pf->removable)
 375                 pf_lock(pf, 0);
 376
 377         mutex_unlock(&pf_mutex);
 378         return 0;
 379
 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 = pf_req->buffer;
 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 = pf_req->buffer;
 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)