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