ide-lib.c revision 3ceca727fe3a38dd8d7a3adf938fefda83eee8af
1#include <linux/types.h> 2#include <linux/string.h> 3#include <linux/kernel.h> 4#include <linux/interrupt.h> 5#include <linux/ide.h> 6#include <linux/bitops.h> 7 8static const char *udma_str[] = 9 { "UDMA/16", "UDMA/25", "UDMA/33", "UDMA/44", 10 "UDMA/66", "UDMA/100", "UDMA/133", "UDMA7" }; 11static const char *mwdma_str[] = 12 { "MWDMA0", "MWDMA1", "MWDMA2" }; 13static const char *swdma_str[] = 14 { "SWDMA0", "SWDMA1", "SWDMA2" }; 15static const char *pio_str[] = 16 { "PIO0", "PIO1", "PIO2", "PIO3", "PIO4", "PIO5" }; 17 18/** 19 * ide_xfer_verbose - return IDE mode names 20 * @mode: transfer mode 21 * 22 * Returns a constant string giving the name of the mode 23 * requested. 24 */ 25 26const char *ide_xfer_verbose(u8 mode) 27{ 28 const char *s; 29 u8 i = mode & 0xf; 30 31 if (mode >= XFER_UDMA_0 && mode <= XFER_UDMA_7) 32 s = udma_str[i]; 33 else if (mode >= XFER_MW_DMA_0 && mode <= XFER_MW_DMA_2) 34 s = mwdma_str[i]; 35 else if (mode >= XFER_SW_DMA_0 && mode <= XFER_SW_DMA_2) 36 s = swdma_str[i]; 37 else if (mode >= XFER_PIO_0 && mode <= XFER_PIO_5) 38 s = pio_str[i & 0x7]; 39 else if (mode == XFER_PIO_SLOW) 40 s = "PIO SLOW"; 41 else 42 s = "XFER ERROR"; 43 44 return s; 45} 46 47EXPORT_SYMBOL(ide_xfer_verbose); 48 49/** 50 * ide_rate_filter - filter transfer mode 51 * @drive: IDE device 52 * @speed: desired speed 53 * 54 * Given the available transfer modes this function returns 55 * the best available speed at or below the speed requested. 56 * 57 * TODO: check device PIO capabilities 58 */ 59 60static u8 ide_rate_filter(ide_drive_t *drive, u8 speed) 61{ 62 ide_hwif_t *hwif = drive->hwif; 63 u8 mode = ide_find_dma_mode(drive, speed); 64 65 if (mode == 0) { 66 if (hwif->pio_mask) 67 mode = fls(hwif->pio_mask) - 1 + XFER_PIO_0; 68 else 69 mode = XFER_PIO_4; 70 } 71 72/* printk("%s: mode 0x%02x, speed 0x%02x\n", __func__, mode, speed); */ 73 74 return min(speed, mode); 75} 76 77/** 78 * ide_get_best_pio_mode - get PIO mode from drive 79 * @drive: drive to consider 80 * @mode_wanted: preferred mode 81 * @max_mode: highest allowed mode 82 * 83 * This routine returns the recommended PIO settings for a given drive, 84 * based on the drive->id information and the ide_pio_blacklist[]. 85 * 86 * Drive PIO mode is auto-selected if 255 is passed as mode_wanted. 87 * This is used by most chipset support modules when "auto-tuning". 88 */ 89 90u8 ide_get_best_pio_mode (ide_drive_t *drive, u8 mode_wanted, u8 max_mode) 91{ 92 u16 *id = drive->id; 93 int pio_mode = -1, overridden = 0; 94 95 if (mode_wanted != 255) 96 return min_t(u8, mode_wanted, max_mode); 97 98 if ((drive->hwif->host_flags & IDE_HFLAG_PIO_NO_BLACKLIST) == 0) 99 pio_mode = ide_scan_pio_blacklist((char *)&id[ATA_ID_PROD]); 100 101 if (pio_mode != -1) { 102 printk(KERN_INFO "%s: is on PIO blacklist\n", drive->name); 103 } else { 104 pio_mode = id[ATA_ID_OLD_PIO_MODES] >> 8; 105 if (pio_mode > 2) { /* 2 is maximum allowed tPIO value */ 106 pio_mode = 2; 107 overridden = 1; 108 } 109 110 if (id[ATA_ID_FIELD_VALID] & 2) { /* ATA2? */ 111 if (ata_id_has_iordy(id)) { 112 if (id[ATA_ID_PIO_MODES] & 7) { 113 overridden = 0; 114 if (id[ATA_ID_PIO_MODES] & 4) 115 pio_mode = 5; 116 else if (id[ATA_ID_PIO_MODES] & 2) 117 pio_mode = 4; 118 else 119 pio_mode = 3; 120 } 121 } 122 } 123 124 if (overridden) 125 printk(KERN_INFO "%s: tPIO > 2, assuming tPIO = 2\n", 126 drive->name); 127 } 128 129 if (pio_mode > max_mode) 130 pio_mode = max_mode; 131 132 return pio_mode; 133} 134 135EXPORT_SYMBOL_GPL(ide_get_best_pio_mode); 136 137/* req_pio == "255" for auto-tune */ 138void ide_set_pio(ide_drive_t *drive, u8 req_pio) 139{ 140 ide_hwif_t *hwif = drive->hwif; 141 const struct ide_port_ops *port_ops = hwif->port_ops; 142 u8 host_pio, pio; 143 144 if (port_ops == NULL || port_ops->set_pio_mode == NULL || 145 (hwif->host_flags & IDE_HFLAG_NO_SET_MODE)) 146 return; 147 148 BUG_ON(hwif->pio_mask == 0x00); 149 150 host_pio = fls(hwif->pio_mask) - 1; 151 152 pio = ide_get_best_pio_mode(drive, req_pio, host_pio); 153 154 /* 155 * TODO: 156 * - report device max PIO mode 157 * - check req_pio != 255 against device max PIO mode 158 */ 159 printk(KERN_DEBUG "%s: host max PIO%d wanted PIO%d%s selected PIO%d\n", 160 drive->name, host_pio, req_pio, 161 req_pio == 255 ? "(auto-tune)" : "", pio); 162 163 (void)ide_set_pio_mode(drive, XFER_PIO_0 + pio); 164} 165 166EXPORT_SYMBOL_GPL(ide_set_pio); 167 168/** 169 * ide_toggle_bounce - handle bounce buffering 170 * @drive: drive to update 171 * @on: on/off boolean 172 * 173 * Enable or disable bounce buffering for the device. Drives move 174 * between PIO and DMA and that changes the rules we need. 175 */ 176 177void ide_toggle_bounce(ide_drive_t *drive, int on) 178{ 179 u64 addr = BLK_BOUNCE_HIGH; /* dma64_addr_t */ 180 181 if (!PCI_DMA_BUS_IS_PHYS) { 182 addr = BLK_BOUNCE_ANY; 183 } else if (on && drive->media == ide_disk) { 184 struct device *dev = drive->hwif->dev; 185 186 if (dev && dev->dma_mask) 187 addr = *dev->dma_mask; 188 } 189 190 if (drive->queue) 191 blk_queue_bounce_limit(drive->queue, addr); 192} 193 194int ide_set_pio_mode(ide_drive_t *drive, const u8 mode) 195{ 196 ide_hwif_t *hwif = drive->hwif; 197 const struct ide_port_ops *port_ops = hwif->port_ops; 198 199 if (hwif->host_flags & IDE_HFLAG_NO_SET_MODE) 200 return 0; 201 202 if (port_ops == NULL || port_ops->set_pio_mode == NULL) 203 return -1; 204 205 /* 206 * TODO: temporary hack for some legacy host drivers that didn't 207 * set transfer mode on the device in ->set_pio_mode method... 208 */ 209 if (port_ops->set_dma_mode == NULL) { 210 port_ops->set_pio_mode(drive, mode - XFER_PIO_0); 211 return 0; 212 } 213 214 if (hwif->host_flags & IDE_HFLAG_POST_SET_MODE) { 215 if (ide_config_drive_speed(drive, mode)) 216 return -1; 217 port_ops->set_pio_mode(drive, mode - XFER_PIO_0); 218 return 0; 219 } else { 220 port_ops->set_pio_mode(drive, mode - XFER_PIO_0); 221 return ide_config_drive_speed(drive, mode); 222 } 223} 224 225int ide_set_dma_mode(ide_drive_t *drive, const u8 mode) 226{ 227 ide_hwif_t *hwif = drive->hwif; 228 const struct ide_port_ops *port_ops = hwif->port_ops; 229 230 if (hwif->host_flags & IDE_HFLAG_NO_SET_MODE) 231 return 0; 232 233 if (port_ops == NULL || port_ops->set_dma_mode == NULL) 234 return -1; 235 236 if (hwif->host_flags & IDE_HFLAG_POST_SET_MODE) { 237 if (ide_config_drive_speed(drive, mode)) 238 return -1; 239 port_ops->set_dma_mode(drive, mode); 240 return 0; 241 } else { 242 port_ops->set_dma_mode(drive, mode); 243 return ide_config_drive_speed(drive, mode); 244 } 245} 246 247EXPORT_SYMBOL_GPL(ide_set_dma_mode); 248 249/** 250 * ide_set_xfer_rate - set transfer rate 251 * @drive: drive to set 252 * @rate: speed to attempt to set 253 * 254 * General helper for setting the speed of an IDE device. This 255 * function knows about user enforced limits from the configuration 256 * which ->set_pio_mode/->set_dma_mode does not. 257 */ 258 259int ide_set_xfer_rate(ide_drive_t *drive, u8 rate) 260{ 261 ide_hwif_t *hwif = drive->hwif; 262 const struct ide_port_ops *port_ops = hwif->port_ops; 263 264 if (port_ops == NULL || port_ops->set_dma_mode == NULL || 265 (hwif->host_flags & IDE_HFLAG_NO_SET_MODE)) 266 return -1; 267 268 rate = ide_rate_filter(drive, rate); 269 270 BUG_ON(rate < XFER_PIO_0); 271 272 if (rate >= XFER_PIO_0 && rate <= XFER_PIO_5) 273 return ide_set_pio_mode(drive, rate); 274 275 return ide_set_dma_mode(drive, rate); 276} 277 278static void ide_dump_opcode(ide_drive_t *drive) 279{ 280 struct request *rq; 281 ide_task_t *task = NULL; 282 283 spin_lock(&ide_lock); 284 rq = NULL; 285 if (HWGROUP(drive)) 286 rq = HWGROUP(drive)->rq; 287 spin_unlock(&ide_lock); 288 if (!rq) 289 return; 290 291 if (rq->cmd_type == REQ_TYPE_ATA_TASKFILE) 292 task = rq->special; 293 294 printk("ide: failed opcode was: "); 295 if (task == NULL) 296 printk(KERN_CONT "unknown\n"); 297 else 298 printk(KERN_CONT "0x%02x\n", task->tf.command); 299} 300 301u64 ide_get_lba_addr(struct ide_taskfile *tf, int lba48) 302{ 303 u32 high, low; 304 305 if (lba48) 306 high = (tf->hob_lbah << 16) | (tf->hob_lbam << 8) | 307 tf->hob_lbal; 308 else 309 high = tf->device & 0xf; 310 low = (tf->lbah << 16) | (tf->lbam << 8) | tf->lbal; 311 312 return ((u64)high << 24) | low; 313} 314EXPORT_SYMBOL_GPL(ide_get_lba_addr); 315 316static void ide_dump_sector(ide_drive_t *drive) 317{ 318 ide_task_t task; 319 struct ide_taskfile *tf = &task.tf; 320 int lba48 = (drive->addressing == 1) ? 1 : 0; 321 322 memset(&task, 0, sizeof(task)); 323 if (lba48) 324 task.tf_flags = IDE_TFLAG_IN_LBA | IDE_TFLAG_IN_HOB_LBA | 325 IDE_TFLAG_LBA48; 326 else 327 task.tf_flags = IDE_TFLAG_IN_LBA | IDE_TFLAG_IN_DEVICE; 328 329 drive->hwif->tp_ops->tf_read(drive, &task); 330 331 if (lba48 || (tf->device & ATA_LBA)) 332 printk(", LBAsect=%llu", 333 (unsigned long long)ide_get_lba_addr(tf, lba48)); 334 else 335 printk(", CHS=%d/%d/%d", (tf->lbah << 8) + tf->lbam, 336 tf->device & 0xf, tf->lbal); 337} 338 339static void ide_dump_ata_error(ide_drive_t *drive, u8 err) 340{ 341 printk("{ "); 342 if (err & ATA_ABORTED) printk("DriveStatusError "); 343 if (err & ATA_ICRC) 344 printk((err & ATA_ABORTED) ? "BadCRC " : "BadSector "); 345 if (err & ATA_UNC) printk("UncorrectableError "); 346 if (err & ATA_IDNF) printk("SectorIdNotFound "); 347 if (err & ATA_TRK0NF) printk("TrackZeroNotFound "); 348 if (err & ATA_AMNF) printk("AddrMarkNotFound "); 349 printk("}"); 350 if ((err & (ATA_BBK | ATA_ABORTED)) == ATA_BBK || 351 (err & (ATA_UNC | ATA_IDNF | ATA_AMNF))) { 352 ide_dump_sector(drive); 353 if (HWGROUP(drive) && HWGROUP(drive)->rq) 354 printk(", sector=%llu", 355 (unsigned long long)HWGROUP(drive)->rq->sector); 356 } 357 printk("\n"); 358} 359 360static void ide_dump_atapi_error(ide_drive_t *drive, u8 err) 361{ 362 printk("{ "); 363 if (err & ATAPI_ILI) printk("IllegalLengthIndication "); 364 if (err & ATAPI_EOM) printk("EndOfMedia "); 365 if (err & ATA_ABORTED) printk("AbortedCommand "); 366 if (err & ATA_MCR) printk("MediaChangeRequested "); 367 if (err & ATAPI_LFS) printk("LastFailedSense=0x%02x ", 368 (err & ATAPI_LFS) >> 4); 369 printk("}\n"); 370} 371 372/** 373 * ide_dump_status - translate ATA/ATAPI error 374 * @drive: drive that status applies to 375 * @msg: text message to print 376 * @stat: status byte to decode 377 * 378 * Error reporting, in human readable form (luxurious, but a memory hog). 379 * Combines the drive name, message and status byte to provide a 380 * user understandable explanation of the device error. 381 */ 382 383u8 ide_dump_status(ide_drive_t *drive, const char *msg, u8 stat) 384{ 385 unsigned long flags; 386 u8 err = 0; 387 388 local_irq_save(flags); 389 printk("%s: %s: status=0x%02x { ", drive->name, msg, stat); 390 if (stat & ATA_BUSY) 391 printk("Busy "); 392 else { 393 if (stat & ATA_DRDY) printk("DriveReady "); 394 if (stat & ATA_DF) printk("DeviceFault "); 395 if (stat & ATA_DSC) printk("SeekComplete "); 396 if (stat & ATA_DRQ) printk("DataRequest "); 397 if (stat & ATA_CORR) printk("CorrectedError "); 398 if (stat & ATA_IDX) printk("Index "); 399 if (stat & ATA_ERR) printk("Error "); 400 } 401 printk("}\n"); 402 if ((stat & (ATA_BUSY | ATA_ERR)) == ATA_ERR) { 403 err = ide_read_error(drive); 404 printk("%s: %s: error=0x%02x ", drive->name, msg, err); 405 if (drive->media == ide_disk) 406 ide_dump_ata_error(drive, err); 407 else 408 ide_dump_atapi_error(drive, err); 409 } 410 ide_dump_opcode(drive); 411 local_irq_restore(flags); 412 return err; 413} 414 415EXPORT_SYMBOL(ide_dump_status); 416