ide-lib.c revision 12eda14f8930ccad0d8b75fecab87b90eecba5fb
1#include <linux/module.h> 2#include <linux/types.h> 3#include <linux/string.h> 4#include <linux/kernel.h> 5#include <linux/timer.h> 6#include <linux/mm.h> 7#include <linux/interrupt.h> 8#include <linux/major.h> 9#include <linux/errno.h> 10#include <linux/genhd.h> 11#include <linux/blkpg.h> 12#include <linux/slab.h> 13#include <linux/pci.h> 14#include <linux/delay.h> 15#include <linux/hdreg.h> 16#include <linux/ide.h> 17#include <linux/bitops.h> 18 19#include <asm/byteorder.h> 20#include <asm/irq.h> 21#include <asm/uaccess.h> 22#include <asm/io.h> 23 24/* 25 * IDE library routines. These are plug in code that most 26 * drivers can use but occasionally may be weird enough 27 * to want to do their own thing with 28 * 29 * Add common non I/O op stuff here. Make sure it has proper 30 * kernel-doc function headers or your patch will be rejected 31 */ 32 33 34/** 35 * ide_xfer_verbose - return IDE mode names 36 * @xfer_rate: rate to name 37 * 38 * Returns a constant string giving the name of the mode 39 * requested. 40 */ 41 42char *ide_xfer_verbose (u8 xfer_rate) 43{ 44 switch(xfer_rate) { 45 case XFER_UDMA_7: return("UDMA 7"); 46 case XFER_UDMA_6: return("UDMA 6"); 47 case XFER_UDMA_5: return("UDMA 5"); 48 case XFER_UDMA_4: return("UDMA 4"); 49 case XFER_UDMA_3: return("UDMA 3"); 50 case XFER_UDMA_2: return("UDMA 2"); 51 case XFER_UDMA_1: return("UDMA 1"); 52 case XFER_UDMA_0: return("UDMA 0"); 53 case XFER_MW_DMA_2: return("MW DMA 2"); 54 case XFER_MW_DMA_1: return("MW DMA 1"); 55 case XFER_MW_DMA_0: return("MW DMA 0"); 56 case XFER_SW_DMA_2: return("SW DMA 2"); 57 case XFER_SW_DMA_1: return("SW DMA 1"); 58 case XFER_SW_DMA_0: return("SW DMA 0"); 59 case XFER_PIO_4: return("PIO 4"); 60 case XFER_PIO_3: return("PIO 3"); 61 case XFER_PIO_2: return("PIO 2"); 62 case XFER_PIO_1: return("PIO 1"); 63 case XFER_PIO_0: return("PIO 0"); 64 case XFER_PIO_SLOW: return("PIO SLOW"); 65 default: return("XFER ERROR"); 66 } 67} 68 69EXPORT_SYMBOL(ide_xfer_verbose); 70 71/** 72 * ide_rate_filter - filter transfer mode 73 * @drive: IDE device 74 * @speed: desired speed 75 * 76 * Given the available transfer modes this function returns 77 * the best available speed at or below the speed requested. 78 * 79 * TODO: check device PIO capabilities 80 */ 81 82static u8 ide_rate_filter(ide_drive_t *drive, u8 speed) 83{ 84 ide_hwif_t *hwif = drive->hwif; 85 u8 mode = ide_find_dma_mode(drive, speed); 86 87 if (mode == 0) { 88 if (hwif->pio_mask) 89 mode = fls(hwif->pio_mask) - 1 + XFER_PIO_0; 90 else 91 mode = XFER_PIO_4; 92 } 93 94// printk("%s: mode 0x%02x, speed 0x%02x\n", __FUNCTION__, mode, speed); 95 96 return min(speed, mode); 97} 98 99/* 100 * Standard (generic) timings for PIO modes, from ATA2 specification. 101 * These timings are for access to the IDE data port register *only*. 102 * Some drives may specify a mode, while also specifying a different 103 * value for cycle_time (from drive identification data). 104 */ 105const ide_pio_timings_t ide_pio_timings[6] = { 106 { 70, 165, 600 }, /* PIO Mode 0 */ 107 { 50, 125, 383 }, /* PIO Mode 1 */ 108 { 30, 100, 240 }, /* PIO Mode 2 */ 109 { 30, 80, 180 }, /* PIO Mode 3 with IORDY */ 110 { 25, 70, 120 }, /* PIO Mode 4 with IORDY */ 111 { 20, 50, 100 } /* PIO Mode 5 with IORDY (nonstandard) */ 112}; 113 114EXPORT_SYMBOL_GPL(ide_pio_timings); 115 116/* 117 * Shared data/functions for determining best PIO mode for an IDE drive. 118 * Most of this stuff originally lived in cmd640.c, and changes to the 119 * ide_pio_blacklist[] table should be made with EXTREME CAUTION to avoid 120 * breaking the fragile cmd640.c support. 121 */ 122 123/* 124 * Black list. Some drives incorrectly report their maximal PIO mode, 125 * at least in respect to CMD640. Here we keep info on some known drives. 126 */ 127static struct ide_pio_info { 128 const char *name; 129 int pio; 130} ide_pio_blacklist [] = { 131/* { "Conner Peripherals 1275MB - CFS1275A", 4 }, */ 132 { "Conner Peripherals 540MB - CFS540A", 3 }, 133 134 { "WDC AC2700", 3 }, 135 { "WDC AC2540", 3 }, 136 { "WDC AC2420", 3 }, 137 { "WDC AC2340", 3 }, 138 { "WDC AC2250", 0 }, 139 { "WDC AC2200", 0 }, 140 { "WDC AC21200", 4 }, 141 { "WDC AC2120", 0 }, 142 { "WDC AC2850", 3 }, 143 { "WDC AC1270", 3 }, 144 { "WDC AC1170", 1 }, 145 { "WDC AC1210", 1 }, 146 { "WDC AC280", 0 }, 147/* { "WDC AC21000", 4 }, */ 148 { "WDC AC31000", 3 }, 149 { "WDC AC31200", 3 }, 150/* { "WDC AC31600", 4 }, */ 151 152 { "Maxtor 7131 AT", 1 }, 153 { "Maxtor 7171 AT", 1 }, 154 { "Maxtor 7213 AT", 1 }, 155 { "Maxtor 7245 AT", 1 }, 156 { "Maxtor 7345 AT", 1 }, 157 { "Maxtor 7546 AT", 3 }, 158 { "Maxtor 7540 AV", 3 }, 159 160 { "SAMSUNG SHD-3121A", 1 }, 161 { "SAMSUNG SHD-3122A", 1 }, 162 { "SAMSUNG SHD-3172A", 1 }, 163 164/* { "ST51080A", 4 }, 165 * { "ST51270A", 4 }, 166 * { "ST31220A", 4 }, 167 * { "ST31640A", 4 }, 168 * { "ST32140A", 4 }, 169 * { "ST3780A", 4 }, 170 */ 171 { "ST5660A", 3 }, 172 { "ST3660A", 3 }, 173 { "ST3630A", 3 }, 174 { "ST3655A", 3 }, 175 { "ST3391A", 3 }, 176 { "ST3390A", 1 }, 177 { "ST3600A", 1 }, 178 { "ST3290A", 0 }, 179 { "ST3144A", 0 }, 180 { "ST3491A", 1 }, /* reports 3, should be 1 or 2 (depending on */ 181 /* drive) according to Seagates FIND-ATA program */ 182 183 { "QUANTUM ELS127A", 0 }, 184 { "QUANTUM ELS170A", 0 }, 185 { "QUANTUM LPS240A", 0 }, 186 { "QUANTUM LPS210A", 3 }, 187 { "QUANTUM LPS270A", 3 }, 188 { "QUANTUM LPS365A", 3 }, 189 { "QUANTUM LPS540A", 3 }, 190 { "QUANTUM LIGHTNING 540A", 3 }, 191 { "QUANTUM LIGHTNING 730A", 3 }, 192 193 { "QUANTUM FIREBALL_540", 3 }, /* Older Quantum Fireballs don't work */ 194 { "QUANTUM FIREBALL_640", 3 }, 195 { "QUANTUM FIREBALL_1080", 3 }, 196 { "QUANTUM FIREBALL_1280", 3 }, 197 { NULL, 0 } 198}; 199 200/** 201 * ide_scan_pio_blacklist - check for a blacklisted drive 202 * @model: Drive model string 203 * 204 * This routine searches the ide_pio_blacklist for an entry 205 * matching the start/whole of the supplied model name. 206 * 207 * Returns -1 if no match found. 208 * Otherwise returns the recommended PIO mode from ide_pio_blacklist[]. 209 */ 210 211static int ide_scan_pio_blacklist (char *model) 212{ 213 struct ide_pio_info *p; 214 215 for (p = ide_pio_blacklist; p->name != NULL; p++) { 216 if (strncmp(p->name, model, strlen(p->name)) == 0) 217 return p->pio; 218 } 219 return -1; 220} 221 222unsigned int ide_pio_cycle_time(ide_drive_t *drive, u8 pio) 223{ 224 struct hd_driveid *id = drive->id; 225 int cycle_time = 0; 226 227 if (id->field_valid & 2) { 228 if (id->capability & 8) 229 cycle_time = id->eide_pio_iordy; 230 else 231 cycle_time = id->eide_pio; 232 } 233 234 /* conservative "downgrade" for all pre-ATA2 drives */ 235 if (pio < 3) { 236 if (cycle_time && cycle_time < ide_pio_timings[pio].cycle_time) 237 cycle_time = 0; /* use standard timing */ 238 } 239 240 return cycle_time ? cycle_time : ide_pio_timings[pio].cycle_time; 241} 242 243EXPORT_SYMBOL_GPL(ide_pio_cycle_time); 244 245/** 246 * ide_get_best_pio_mode - get PIO mode from drive 247 * @drive: drive to consider 248 * @mode_wanted: preferred mode 249 * @max_mode: highest allowed mode 250 * 251 * This routine returns the recommended PIO settings for a given drive, 252 * based on the drive->id information and the ide_pio_blacklist[]. 253 * 254 * Drive PIO mode is auto-selected if 255 is passed as mode_wanted. 255 * This is used by most chipset support modules when "auto-tuning". 256 */ 257 258u8 ide_get_best_pio_mode (ide_drive_t *drive, u8 mode_wanted, u8 max_mode) 259{ 260 int pio_mode; 261 struct hd_driveid* id = drive->id; 262 int overridden = 0; 263 264 if (mode_wanted != 255) 265 return min_t(u8, mode_wanted, max_mode); 266 267 if ((drive->hwif->host_flags & IDE_HFLAG_PIO_NO_BLACKLIST) == 0 && 268 (pio_mode = ide_scan_pio_blacklist(id->model)) != -1) { 269 printk(KERN_INFO "%s: is on PIO blacklist\n", drive->name); 270 } else { 271 pio_mode = id->tPIO; 272 if (pio_mode > 2) { /* 2 is maximum allowed tPIO value */ 273 pio_mode = 2; 274 overridden = 1; 275 } 276 if (id->field_valid & 2) { /* drive implements ATA2? */ 277 if (id->capability & 8) { /* IORDY supported? */ 278 if (id->eide_pio_modes & 7) { 279 overridden = 0; 280 if (id->eide_pio_modes & 4) 281 pio_mode = 5; 282 else if (id->eide_pio_modes & 2) 283 pio_mode = 4; 284 else 285 pio_mode = 3; 286 } 287 } 288 } 289 290 if (overridden) 291 printk(KERN_INFO "%s: tPIO > 2, assuming tPIO = 2\n", 292 drive->name); 293 294 /* 295 * Conservative "downgrade" for all pre-ATA2 drives 296 */ 297 if ((drive->hwif->host_flags & IDE_HFLAG_PIO_NO_DOWNGRADE) == 0 && 298 pio_mode && pio_mode < 4) { 299 pio_mode--; 300 printk(KERN_INFO "%s: applying conservative " 301 "PIO \"downgrade\"\n", drive->name); 302 } 303 } 304 305 if (pio_mode > max_mode) 306 pio_mode = max_mode; 307 308 return pio_mode; 309} 310 311EXPORT_SYMBOL_GPL(ide_get_best_pio_mode); 312 313/* req_pio == "255" for auto-tune */ 314void ide_set_pio(ide_drive_t *drive, u8 req_pio) 315{ 316 ide_hwif_t *hwif = drive->hwif; 317 u8 host_pio, pio; 318 319 if (hwif->set_pio_mode == NULL) 320 return; 321 322 BUG_ON(hwif->pio_mask == 0x00); 323 324 host_pio = fls(hwif->pio_mask) - 1; 325 326 pio = ide_get_best_pio_mode(drive, req_pio, host_pio); 327 328 /* 329 * TODO: 330 * - report device max PIO mode 331 * - check req_pio != 255 against device max PIO mode 332 */ 333 printk(KERN_DEBUG "%s: host max PIO%d wanted PIO%d%s selected PIO%d\n", 334 drive->name, host_pio, req_pio, 335 req_pio == 255 ? "(auto-tune)" : "", pio); 336 337 (void)ide_set_pio_mode(drive, XFER_PIO_0 + pio); 338} 339 340EXPORT_SYMBOL_GPL(ide_set_pio); 341 342/** 343 * ide_toggle_bounce - handle bounce buffering 344 * @drive: drive to update 345 * @on: on/off boolean 346 * 347 * Enable or disable bounce buffering for the device. Drives move 348 * between PIO and DMA and that changes the rules we need. 349 */ 350 351void ide_toggle_bounce(ide_drive_t *drive, int on) 352{ 353 u64 addr = BLK_BOUNCE_HIGH; /* dma64_addr_t */ 354 355 if (!PCI_DMA_BUS_IS_PHYS) { 356 addr = BLK_BOUNCE_ANY; 357 } else if (on && drive->media == ide_disk) { 358 if (HWIF(drive)->pci_dev) 359 addr = HWIF(drive)->pci_dev->dma_mask; 360 } 361 362 if (drive->queue) 363 blk_queue_bounce_limit(drive->queue, addr); 364} 365 366int ide_set_pio_mode(ide_drive_t *drive, const u8 mode) 367{ 368 ide_hwif_t *hwif = drive->hwif; 369 370 if (hwif->set_pio_mode == NULL) 371 return -1; 372 373 /* 374 * TODO: temporary hack for some legacy host drivers that didn't 375 * set transfer mode on the device in ->set_pio_mode method... 376 */ 377 if (hwif->set_dma_mode == NULL) { 378 hwif->set_pio_mode(drive, mode - XFER_PIO_0); 379 return 0; 380 } 381 382 if (hwif->host_flags & IDE_HFLAG_POST_SET_MODE) { 383 if (ide_config_drive_speed(drive, mode)) 384 return -1; 385 hwif->set_pio_mode(drive, mode - XFER_PIO_0); 386 return 0; 387 } else { 388 hwif->set_pio_mode(drive, mode - XFER_PIO_0); 389 return ide_config_drive_speed(drive, mode); 390 } 391} 392 393int ide_set_dma_mode(ide_drive_t *drive, const u8 mode) 394{ 395 ide_hwif_t *hwif = drive->hwif; 396 397 if (hwif->set_dma_mode == NULL) 398 return -1; 399 400 if (hwif->host_flags & IDE_HFLAG_POST_SET_MODE) { 401 if (ide_config_drive_speed(drive, mode)) 402 return -1; 403 hwif->set_dma_mode(drive, mode); 404 return 0; 405 } else { 406 hwif->set_dma_mode(drive, mode); 407 return ide_config_drive_speed(drive, mode); 408 } 409} 410 411EXPORT_SYMBOL_GPL(ide_set_dma_mode); 412 413/** 414 * ide_set_xfer_rate - set transfer rate 415 * @drive: drive to set 416 * @rate: speed to attempt to set 417 * 418 * General helper for setting the speed of an IDE device. This 419 * function knows about user enforced limits from the configuration 420 * which ->set_pio_mode/->set_dma_mode does not. 421 */ 422 423int ide_set_xfer_rate(ide_drive_t *drive, u8 rate) 424{ 425 ide_hwif_t *hwif = drive->hwif; 426 427 if (hwif->set_dma_mode == NULL) 428 return -1; 429 430 rate = ide_rate_filter(drive, rate); 431 432 if (rate >= XFER_PIO_0 && rate <= XFER_PIO_5) 433 return ide_set_pio_mode(drive, rate); 434 435 /* 436 * TODO: transfer modes 0x00-0x07 passed from the user-space are 437 * currently handled here which needs fixing (please note that such 438 * case could happen iff the transfer mode has already been set on 439 * the device by ide-proc.c::set_xfer_rate()). 440 */ 441 442 return ide_set_dma_mode(drive, rate); 443} 444 445static void ide_dump_opcode(ide_drive_t *drive) 446{ 447 struct request *rq; 448 u8 opcode = 0; 449 int found = 0; 450 451 spin_lock(&ide_lock); 452 rq = NULL; 453 if (HWGROUP(drive)) 454 rq = HWGROUP(drive)->rq; 455 spin_unlock(&ide_lock); 456 if (!rq) 457 return; 458 if (rq->cmd_type == REQ_TYPE_ATA_CMD || 459 rq->cmd_type == REQ_TYPE_ATA_TASK) { 460 char *args = rq->buffer; 461 if (args) { 462 opcode = args[0]; 463 found = 1; 464 } 465 } else if (rq->cmd_type == REQ_TYPE_ATA_TASKFILE) { 466 ide_task_t *args = rq->special; 467 if (args) { 468 task_struct_t *tf = (task_struct_t *) args->tfRegister; 469 opcode = tf->command; 470 found = 1; 471 } 472 } 473 474 printk("ide: failed opcode was: "); 475 if (!found) 476 printk("unknown\n"); 477 else 478 printk("0x%02x\n", opcode); 479} 480 481static u8 ide_dump_ata_status(ide_drive_t *drive, const char *msg, u8 stat) 482{ 483 ide_hwif_t *hwif = HWIF(drive); 484 unsigned long flags; 485 u8 err = 0; 486 487 local_irq_save(flags); 488 printk("%s: %s: status=0x%02x { ", drive->name, msg, stat); 489 if (stat & BUSY_STAT) 490 printk("Busy "); 491 else { 492 if (stat & READY_STAT) printk("DriveReady "); 493 if (stat & WRERR_STAT) printk("DeviceFault "); 494 if (stat & SEEK_STAT) printk("SeekComplete "); 495 if (stat & DRQ_STAT) printk("DataRequest "); 496 if (stat & ECC_STAT) printk("CorrectedError "); 497 if (stat & INDEX_STAT) printk("Index "); 498 if (stat & ERR_STAT) printk("Error "); 499 } 500 printk("}\n"); 501 if ((stat & (BUSY_STAT|ERR_STAT)) == ERR_STAT) { 502 err = hwif->INB(IDE_ERROR_REG); 503 printk("%s: %s: error=0x%02x { ", drive->name, msg, err); 504 if (err & ABRT_ERR) printk("DriveStatusError "); 505 if (err & ICRC_ERR) 506 printk((err & ABRT_ERR) ? "BadCRC " : "BadSector "); 507 if (err & ECC_ERR) printk("UncorrectableError "); 508 if (err & ID_ERR) printk("SectorIdNotFound "); 509 if (err & TRK0_ERR) printk("TrackZeroNotFound "); 510 if (err & MARK_ERR) printk("AddrMarkNotFound "); 511 printk("}"); 512 if ((err & (BBD_ERR | ABRT_ERR)) == BBD_ERR || 513 (err & (ECC_ERR|ID_ERR|MARK_ERR))) { 514 if (drive->addressing == 1) { 515 __u64 sectors = 0; 516 u32 low = 0, high = 0; 517 hwif->OUTB(drive->ctl&~0x80, IDE_CONTROL_REG); 518 low = ide_read_24(drive); 519 hwif->OUTB(drive->ctl|0x80, IDE_CONTROL_REG); 520 high = ide_read_24(drive); 521 sectors = ((__u64)high << 24) | low; 522 printk(", LBAsect=%llu, high=%d, low=%d", 523 (unsigned long long) sectors, 524 high, low); 525 } else { 526 u8 cur = hwif->INB(IDE_SELECT_REG); 527 if (cur & 0x40) { /* using LBA? */ 528 printk(", LBAsect=%ld", (unsigned long) 529 ((cur&0xf)<<24) 530 |(hwif->INB(IDE_HCYL_REG)<<16) 531 |(hwif->INB(IDE_LCYL_REG)<<8) 532 | hwif->INB(IDE_SECTOR_REG)); 533 } else { 534 printk(", CHS=%d/%d/%d", 535 (hwif->INB(IDE_HCYL_REG)<<8) + 536 hwif->INB(IDE_LCYL_REG), 537 cur & 0xf, 538 hwif->INB(IDE_SECTOR_REG)); 539 } 540 } 541 if (HWGROUP(drive) && HWGROUP(drive)->rq) 542 printk(", sector=%llu", 543 (unsigned long long)HWGROUP(drive)->rq->sector); 544 } 545 printk("\n"); 546 } 547 ide_dump_opcode(drive); 548 local_irq_restore(flags); 549 return err; 550} 551 552/** 553 * ide_dump_atapi_status - print human readable atapi status 554 * @drive: drive that status applies to 555 * @msg: text message to print 556 * @stat: status byte to decode 557 * 558 * Error reporting, in human readable form (luxurious, but a memory hog). 559 */ 560 561static u8 ide_dump_atapi_status(ide_drive_t *drive, const char *msg, u8 stat) 562{ 563 unsigned long flags; 564 565 atapi_status_t status; 566 atapi_error_t error; 567 568 status.all = stat; 569 error.all = 0; 570 local_irq_save(flags); 571 printk("%s: %s: status=0x%02x { ", drive->name, msg, stat); 572 if (status.b.bsy) 573 printk("Busy "); 574 else { 575 if (status.b.drdy) printk("DriveReady "); 576 if (status.b.df) printk("DeviceFault "); 577 if (status.b.dsc) printk("SeekComplete "); 578 if (status.b.drq) printk("DataRequest "); 579 if (status.b.corr) printk("CorrectedError "); 580 if (status.b.idx) printk("Index "); 581 if (status.b.check) printk("Error "); 582 } 583 printk("}\n"); 584 if (status.b.check && !status.b.bsy) { 585 error.all = HWIF(drive)->INB(IDE_ERROR_REG); 586 printk("%s: %s: error=0x%02x { ", drive->name, msg, error.all); 587 if (error.b.ili) printk("IllegalLengthIndication "); 588 if (error.b.eom) printk("EndOfMedia "); 589 if (error.b.abrt) printk("AbortedCommand "); 590 if (error.b.mcr) printk("MediaChangeRequested "); 591 if (error.b.sense_key) printk("LastFailedSense=0x%02x ", 592 error.b.sense_key); 593 printk("}\n"); 594 } 595 ide_dump_opcode(drive); 596 local_irq_restore(flags); 597 return error.all; 598} 599 600/** 601 * ide_dump_status - translate ATA/ATAPI error 602 * @drive: drive the error occured on 603 * @msg: information string 604 * @stat: status byte 605 * 606 * Error reporting, in human readable form (luxurious, but a memory hog). 607 * Combines the drive name, message and status byte to provide a 608 * user understandable explanation of the device error. 609 */ 610 611u8 ide_dump_status(ide_drive_t *drive, const char *msg, u8 stat) 612{ 613 if (drive->media == ide_disk) 614 return ide_dump_ata_status(drive, msg, stat); 615 return ide_dump_atapi_status(drive, msg, stat); 616} 617 618EXPORT_SYMBOL(ide_dump_status); 619