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