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