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