1/* 2 * Copyright (C) 2000-2002 Andre Hedrick <andre@linux-ide.org> 3 * Copyright (C) 2003 Red Hat 4 * 5 */ 6 7#include <linux/module.h> 8#include <linux/types.h> 9#include <linux/string.h> 10#include <linux/kernel.h> 11#include <linux/timer.h> 12#include <linux/mm.h> 13#include <linux/interrupt.h> 14#include <linux/major.h> 15#include <linux/errno.h> 16#include <linux/genhd.h> 17#include <linux/blkpg.h> 18#include <linux/slab.h> 19#include <linux/pci.h> 20#include <linux/delay.h> 21#include <linux/ide.h> 22#include <linux/bitops.h> 23#include <linux/nmi.h> 24 25#include <asm/byteorder.h> 26#include <asm/irq.h> 27#include <asm/uaccess.h> 28#include <asm/io.h> 29 30void SELECT_MASK(ide_drive_t *drive, int mask) 31{ 32 const struct ide_port_ops *port_ops = drive->hwif->port_ops; 33 34 if (port_ops && port_ops->maskproc) 35 port_ops->maskproc(drive, mask); 36} 37 38u8 ide_read_error(ide_drive_t *drive) 39{ 40 struct ide_taskfile tf; 41 42 drive->hwif->tp_ops->tf_read(drive, &tf, IDE_VALID_ERROR); 43 44 return tf.error; 45} 46EXPORT_SYMBOL_GPL(ide_read_error); 47 48void ide_fix_driveid(u16 *id) 49{ 50#ifndef __LITTLE_ENDIAN 51# ifdef __BIG_ENDIAN 52 int i; 53 54 for (i = 0; i < 256; i++) 55 id[i] = __le16_to_cpu(id[i]); 56# else 57# error "Please fix <asm/byteorder.h>" 58# endif 59#endif 60} 61 62/* 63 * ide_fixstring() cleans up and (optionally) byte-swaps a text string, 64 * removing leading/trailing blanks and compressing internal blanks. 65 * It is primarily used to tidy up the model name/number fields as 66 * returned by the ATA_CMD_ID_ATA[PI] commands. 67 */ 68 69void ide_fixstring(u8 *s, const int bytecount, const int byteswap) 70{ 71 u8 *p, *end = &s[bytecount & ~1]; /* bytecount must be even */ 72 73 if (byteswap) { 74 /* convert from big-endian to host byte order */ 75 for (p = s ; p != end ; p += 2) 76 be16_to_cpus((u16 *) p); 77 } 78 79 /* strip leading blanks */ 80 p = s; 81 while (s != end && *s == ' ') 82 ++s; 83 /* compress internal blanks and strip trailing blanks */ 84 while (s != end && *s) { 85 if (*s++ != ' ' || (s != end && *s && *s != ' ')) 86 *p++ = *(s-1); 87 } 88 /* wipe out trailing garbage */ 89 while (p != end) 90 *p++ = '\0'; 91} 92EXPORT_SYMBOL(ide_fixstring); 93 94/* 95 * This routine busy-waits for the drive status to be not "busy". 96 * It then checks the status for all of the "good" bits and none 97 * of the "bad" bits, and if all is okay it returns 0. All other 98 * cases return error -- caller may then invoke ide_error(). 99 * 100 * This routine should get fixed to not hog the cpu during extra long waits.. 101 * That could be done by busy-waiting for the first jiffy or two, and then 102 * setting a timer to wake up at half second intervals thereafter, 103 * until timeout is achieved, before timing out. 104 */ 105int __ide_wait_stat(ide_drive_t *drive, u8 good, u8 bad, 106 unsigned long timeout, u8 *rstat) 107{ 108 ide_hwif_t *hwif = drive->hwif; 109 const struct ide_tp_ops *tp_ops = hwif->tp_ops; 110 unsigned long flags; 111 int i; 112 u8 stat; 113 114 udelay(1); /* spec allows drive 400ns to assert "BUSY" */ 115 stat = tp_ops->read_status(hwif); 116 117 if (stat & ATA_BUSY) { 118 local_save_flags(flags); 119 local_irq_enable_in_hardirq(); 120 timeout += jiffies; 121 while ((stat = tp_ops->read_status(hwif)) & ATA_BUSY) { 122 if (time_after(jiffies, timeout)) { 123 /* 124 * One last read after the timeout in case 125 * heavy interrupt load made us not make any 126 * progress during the timeout.. 127 */ 128 stat = tp_ops->read_status(hwif); 129 if ((stat & ATA_BUSY) == 0) 130 break; 131 132 local_irq_restore(flags); 133 *rstat = stat; 134 return -EBUSY; 135 } 136 } 137 local_irq_restore(flags); 138 } 139 /* 140 * Allow status to settle, then read it again. 141 * A few rare drives vastly violate the 400ns spec here, 142 * so we'll wait up to 10usec for a "good" status 143 * rather than expensively fail things immediately. 144 * This fix courtesy of Matthew Faupel & Niccolo Rigacci. 145 */ 146 for (i = 0; i < 10; i++) { 147 udelay(1); 148 stat = tp_ops->read_status(hwif); 149 150 if (OK_STAT(stat, good, bad)) { 151 *rstat = stat; 152 return 0; 153 } 154 } 155 *rstat = stat; 156 return -EFAULT; 157} 158 159/* 160 * In case of error returns error value after doing "*startstop = ide_error()". 161 * The caller should return the updated value of "startstop" in this case, 162 * "startstop" is unchanged when the function returns 0. 163 */ 164int ide_wait_stat(ide_startstop_t *startstop, ide_drive_t *drive, u8 good, 165 u8 bad, unsigned long timeout) 166{ 167 int err; 168 u8 stat; 169 170 /* bail early if we've exceeded max_failures */ 171 if (drive->max_failures && (drive->failures > drive->max_failures)) { 172 *startstop = ide_stopped; 173 return 1; 174 } 175 176 err = __ide_wait_stat(drive, good, bad, timeout, &stat); 177 178 if (err) { 179 char *s = (err == -EBUSY) ? "status timeout" : "status error"; 180 *startstop = ide_error(drive, s, stat); 181 } 182 183 return err; 184} 185EXPORT_SYMBOL(ide_wait_stat); 186 187/** 188 * ide_in_drive_list - look for drive in black/white list 189 * @id: drive identifier 190 * @table: list to inspect 191 * 192 * Look for a drive in the blacklist and the whitelist tables 193 * Returns 1 if the drive is found in the table. 194 */ 195 196int ide_in_drive_list(u16 *id, const struct drive_list_entry *table) 197{ 198 for ( ; table->id_model; table++) 199 if ((!strcmp(table->id_model, (char *)&id[ATA_ID_PROD])) && 200 (!table->id_firmware || 201 strstr((char *)&id[ATA_ID_FW_REV], table->id_firmware))) 202 return 1; 203 return 0; 204} 205EXPORT_SYMBOL_GPL(ide_in_drive_list); 206 207/* 208 * Early UDMA66 devices don't set bit14 to 1, only bit13 is valid. 209 * Some optical devices with the buggy firmwares have the same problem. 210 */ 211static const struct drive_list_entry ivb_list[] = { 212 { "QUANTUM FIREBALLlct10 05" , "A03.0900" }, 213 { "QUANTUM FIREBALLlct20 30" , "APL.0900" }, 214 { "TSSTcorp CDDVDW SH-S202J" , "SB00" }, 215 { "TSSTcorp CDDVDW SH-S202J" , "SB01" }, 216 { "TSSTcorp CDDVDW SH-S202N" , "SB00" }, 217 { "TSSTcorp CDDVDW SH-S202N" , "SB01" }, 218 { "TSSTcorp CDDVDW SH-S202H" , "SB00" }, 219 { "TSSTcorp CDDVDW SH-S202H" , "SB01" }, 220 { "SAMSUNG SP0822N" , "WA100-10" }, 221 { NULL , NULL } 222}; 223 224/* 225 * All hosts that use the 80c ribbon must use! 226 * The name is derived from upper byte of word 93 and the 80c ribbon. 227 */ 228u8 eighty_ninty_three(ide_drive_t *drive) 229{ 230 ide_hwif_t *hwif = drive->hwif; 231 u16 *id = drive->id; 232 int ivb = ide_in_drive_list(id, ivb_list); 233 234 if (hwif->cbl == ATA_CBL_SATA || hwif->cbl == ATA_CBL_PATA40_SHORT) 235 return 1; 236 237 if (ivb) 238 printk(KERN_DEBUG "%s: skipping word 93 validity check\n", 239 drive->name); 240 241 if (ata_id_is_sata(id) && !ivb) 242 return 1; 243 244 if (hwif->cbl != ATA_CBL_PATA80 && !ivb) 245 goto no_80w; 246 247 if (id[ATA_ID_HW_CONFIG] & 0x4000) 248 return 1; 249 250 if (ivb) { 251 const char *model = (char *)&id[ATA_ID_PROD]; 252 253 if (strstr(model, "TSSTcorp CDDVDW SH-S202")) { 254 /* 255 * These ATAPI devices always report 80c cable 256 * so we have to depend on the host in this case. 257 */ 258 if (hwif->cbl == ATA_CBL_PATA80) 259 return 1; 260 } else { 261 /* Depend on the device side cable detection. */ 262 if (id[ATA_ID_HW_CONFIG] & 0x2000) 263 return 1; 264 } 265 } 266no_80w: 267 if (drive->dev_flags & IDE_DFLAG_UDMA33_WARNED) 268 return 0; 269 270 printk(KERN_WARNING "%s: %s side 80-wire cable detection failed, " 271 "limiting max speed to UDMA33\n", 272 drive->name, 273 hwif->cbl == ATA_CBL_PATA80 ? "drive" : "host"); 274 275 drive->dev_flags |= IDE_DFLAG_UDMA33_WARNED; 276 277 return 0; 278} 279 280static const char *nien_quirk_list[] = { 281 "QUANTUM FIREBALLlct08 08", 282 "QUANTUM FIREBALLP KA6.4", 283 "QUANTUM FIREBALLP KA9.1", 284 "QUANTUM FIREBALLP KX13.6", 285 "QUANTUM FIREBALLP KX20.5", 286 "QUANTUM FIREBALLP KX27.3", 287 "QUANTUM FIREBALLP LM20.4", 288 "QUANTUM FIREBALLP LM20.5", 289 "FUJITSU MHZ2160BH G2", 290 NULL 291}; 292 293void ide_check_nien_quirk_list(ide_drive_t *drive) 294{ 295 const char **list, *m = (char *)&drive->id[ATA_ID_PROD]; 296 297 for (list = nien_quirk_list; *list != NULL; list++) 298 if (strstr(m, *list) != NULL) { 299 drive->dev_flags |= IDE_DFLAG_NIEN_QUIRK; 300 return; 301 } 302} 303 304int ide_driveid_update(ide_drive_t *drive) 305{ 306 u16 *id; 307 int rc; 308 309 id = kmalloc(SECTOR_SIZE, GFP_ATOMIC); 310 if (id == NULL) 311 return 0; 312 313 SELECT_MASK(drive, 1); 314 rc = ide_dev_read_id(drive, ATA_CMD_ID_ATA, id, 1); 315 SELECT_MASK(drive, 0); 316 317 if (rc) 318 goto out_err; 319 320 drive->id[ATA_ID_UDMA_MODES] = id[ATA_ID_UDMA_MODES]; 321 drive->id[ATA_ID_MWDMA_MODES] = id[ATA_ID_MWDMA_MODES]; 322 drive->id[ATA_ID_SWDMA_MODES] = id[ATA_ID_SWDMA_MODES]; 323 drive->id[ATA_ID_CFA_MODES] = id[ATA_ID_CFA_MODES]; 324 /* anything more ? */ 325 326 kfree(id); 327 328 return 1; 329out_err: 330 if (rc == 2) 331 printk(KERN_ERR "%s: %s: bad status\n", drive->name, __func__); 332 kfree(id); 333 return 0; 334} 335 336int ide_config_drive_speed(ide_drive_t *drive, u8 speed) 337{ 338 ide_hwif_t *hwif = drive->hwif; 339 const struct ide_tp_ops *tp_ops = hwif->tp_ops; 340 struct ide_taskfile tf; 341 u16 *id = drive->id, i; 342 int error = 0; 343 u8 stat; 344 345#ifdef CONFIG_BLK_DEV_IDEDMA 346 if (hwif->dma_ops) /* check if host supports DMA */ 347 hwif->dma_ops->dma_host_set(drive, 0); 348#endif 349 350 /* Skip setting PIO flow-control modes on pre-EIDE drives */ 351 if ((speed & 0xf8) == XFER_PIO_0 && ata_id_has_iordy(drive->id) == 0) 352 goto skip; 353 354 /* 355 * Don't use ide_wait_cmd here - it will 356 * attempt to set_geometry and recalibrate, 357 * but for some reason these don't work at 358 * this point (lost interrupt). 359 */ 360 361 udelay(1); 362 tp_ops->dev_select(drive); 363 SELECT_MASK(drive, 1); 364 udelay(1); 365 tp_ops->write_devctl(hwif, ATA_NIEN | ATA_DEVCTL_OBS); 366 367 memset(&tf, 0, sizeof(tf)); 368 tf.feature = SETFEATURES_XFER; 369 tf.nsect = speed; 370 371 tp_ops->tf_load(drive, &tf, IDE_VALID_FEATURE | IDE_VALID_NSECT); 372 373 tp_ops->exec_command(hwif, ATA_CMD_SET_FEATURES); 374 375 if (drive->dev_flags & IDE_DFLAG_NIEN_QUIRK) 376 tp_ops->write_devctl(hwif, ATA_DEVCTL_OBS); 377 378 error = __ide_wait_stat(drive, drive->ready_stat, 379 ATA_BUSY | ATA_DRQ | ATA_ERR, 380 WAIT_CMD, &stat); 381 382 SELECT_MASK(drive, 0); 383 384 if (error) { 385 (void) ide_dump_status(drive, "set_drive_speed_status", stat); 386 return error; 387 } 388 389 if (speed >= XFER_SW_DMA_0) { 390 id[ATA_ID_UDMA_MODES] &= ~0xFF00; 391 id[ATA_ID_MWDMA_MODES] &= ~0x0700; 392 id[ATA_ID_SWDMA_MODES] &= ~0x0700; 393 if (ata_id_is_cfa(id)) 394 id[ATA_ID_CFA_MODES] &= ~0x0E00; 395 } else if (ata_id_is_cfa(id)) 396 id[ATA_ID_CFA_MODES] &= ~0x01C0; 397 398 skip: 399#ifdef CONFIG_BLK_DEV_IDEDMA 400 if (speed >= XFER_SW_DMA_0 && (drive->dev_flags & IDE_DFLAG_USING_DMA)) 401 hwif->dma_ops->dma_host_set(drive, 1); 402 else if (hwif->dma_ops) /* check if host supports DMA */ 403 ide_dma_off_quietly(drive); 404#endif 405 406 if (speed >= XFER_UDMA_0) { 407 i = 1 << (speed - XFER_UDMA_0); 408 id[ATA_ID_UDMA_MODES] |= (i << 8 | i); 409 } else if (ata_id_is_cfa(id) && speed >= XFER_MW_DMA_3) { 410 i = speed - XFER_MW_DMA_2; 411 id[ATA_ID_CFA_MODES] |= i << 9; 412 } else if (speed >= XFER_MW_DMA_0) { 413 i = 1 << (speed - XFER_MW_DMA_0); 414 id[ATA_ID_MWDMA_MODES] |= (i << 8 | i); 415 } else if (speed >= XFER_SW_DMA_0) { 416 i = 1 << (speed - XFER_SW_DMA_0); 417 id[ATA_ID_SWDMA_MODES] |= (i << 8 | i); 418 } else if (ata_id_is_cfa(id) && speed >= XFER_PIO_5) { 419 i = speed - XFER_PIO_4; 420 id[ATA_ID_CFA_MODES] |= i << 6; 421 } 422 423 if (!drive->init_speed) 424 drive->init_speed = speed; 425 drive->current_speed = speed; 426 return error; 427} 428 429/* 430 * This should get invoked any time we exit the driver to 431 * wait for an interrupt response from a drive. handler() points 432 * at the appropriate code to handle the next interrupt, and a 433 * timer is started to prevent us from waiting forever in case 434 * something goes wrong (see the ide_timer_expiry() handler later on). 435 * 436 * See also ide_execute_command 437 */ 438void __ide_set_handler(ide_drive_t *drive, ide_handler_t *handler, 439 unsigned int timeout) 440{ 441 ide_hwif_t *hwif = drive->hwif; 442 443 BUG_ON(hwif->handler); 444 hwif->handler = handler; 445 hwif->timer.expires = jiffies + timeout; 446 hwif->req_gen_timer = hwif->req_gen; 447 add_timer(&hwif->timer); 448} 449 450void ide_set_handler(ide_drive_t *drive, ide_handler_t *handler, 451 unsigned int timeout) 452{ 453 ide_hwif_t *hwif = drive->hwif; 454 unsigned long flags; 455 456 spin_lock_irqsave(&hwif->lock, flags); 457 __ide_set_handler(drive, handler, timeout); 458 spin_unlock_irqrestore(&hwif->lock, flags); 459} 460EXPORT_SYMBOL(ide_set_handler); 461 462/** 463 * ide_execute_command - execute an IDE command 464 * @drive: IDE drive to issue the command against 465 * @cmd: command 466 * @handler: handler for next phase 467 * @timeout: timeout for command 468 * 469 * Helper function to issue an IDE command. This handles the 470 * atomicity requirements, command timing and ensures that the 471 * handler and IRQ setup do not race. All IDE command kick off 472 * should go via this function or do equivalent locking. 473 */ 474 475void ide_execute_command(ide_drive_t *drive, struct ide_cmd *cmd, 476 ide_handler_t *handler, unsigned timeout) 477{ 478 ide_hwif_t *hwif = drive->hwif; 479 unsigned long flags; 480 481 spin_lock_irqsave(&hwif->lock, flags); 482 if ((cmd->protocol != ATAPI_PROT_DMA && 483 cmd->protocol != ATAPI_PROT_PIO) || 484 (drive->atapi_flags & IDE_AFLAG_DRQ_INTERRUPT)) 485 __ide_set_handler(drive, handler, timeout); 486 hwif->tp_ops->exec_command(hwif, cmd->tf.command); 487 ndelay(400); 488 spin_unlock_irqrestore(&hwif->lock, flags); 489} 490 491/* 492 * ide_wait_not_busy() waits for the currently selected device on the hwif 493 * to report a non-busy status, see comments in ide_probe_port(). 494 */ 495int ide_wait_not_busy(ide_hwif_t *hwif, unsigned long timeout) 496{ 497 u8 stat = 0; 498 499 while (timeout--) { 500 /* 501 * Turn this into a schedule() sleep once I'm sure 502 * about locking issues (2.5 work ?). 503 */ 504 mdelay(1); 505 stat = hwif->tp_ops->read_status(hwif); 506 if ((stat & ATA_BUSY) == 0) 507 return 0; 508 /* 509 * Assume a value of 0xff means nothing is connected to 510 * the interface and it doesn't implement the pull-down 511 * resistor on D7. 512 */ 513 if (stat == 0xff) 514 return -ENODEV; 515 touch_softlockup_watchdog(); 516 touch_nmi_watchdog(); 517 } 518 return -EBUSY; 519} 520