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