drivers/block/paride/pf.c

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