drivers/block/paride/pf.c

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

DEFINITIONS
