ide-io.c revision 6b7d8fc36272169d1d07a07174f2c8a7909c025e
1/* 2 * IDE I/O functions 3 * 4 * Basic PIO and command management functionality. 5 * 6 * This code was split off from ide.c. See ide.c for history and original 7 * copyrights. 8 * 9 * This program is free software; you can redistribute it and/or modify it 10 * under the terms of the GNU General Public License as published by the 11 * Free Software Foundation; either version 2, or (at your option) any 12 * later version. 13 * 14 * This program is distributed in the hope that it will be useful, but 15 * WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 17 * General Public License for more details. 18 * 19 * For the avoidance of doubt the "preferred form" of this code is one which 20 * is in an open non patent encumbered format. Where cryptographic key signing 21 * forms part of the process of creating an executable the information 22 * including keys needed to generate an equivalently functional executable 23 * are deemed to be part of the source code. 24 */ 25 26 27#include <linux/module.h> 28#include <linux/types.h> 29#include <linux/string.h> 30#include <linux/kernel.h> 31#include <linux/timer.h> 32#include <linux/mm.h> 33#include <linux/interrupt.h> 34#include <linux/major.h> 35#include <linux/errno.h> 36#include <linux/genhd.h> 37#include <linux/blkpg.h> 38#include <linux/slab.h> 39#include <linux/init.h> 40#include <linux/pci.h> 41#include <linux/delay.h> 42#include <linux/ide.h> 43#include <linux/hdreg.h> 44#include <linux/completion.h> 45#include <linux/reboot.h> 46#include <linux/cdrom.h> 47#include <linux/seq_file.h> 48#include <linux/device.h> 49#include <linux/kmod.h> 50#include <linux/scatterlist.h> 51#include <linux/bitops.h> 52 53#include <asm/byteorder.h> 54#include <asm/irq.h> 55#include <asm/uaccess.h> 56#include <asm/io.h> 57 58static int __ide_end_request(ide_drive_t *drive, struct request *rq, 59 int uptodate, unsigned int nr_bytes, int dequeue) 60{ 61 int ret = 1; 62 int error = 0; 63 64 if (uptodate <= 0) 65 error = uptodate ? uptodate : -EIO; 66 67 /* 68 * if failfast is set on a request, override number of sectors and 69 * complete the whole request right now 70 */ 71 if (blk_noretry_request(rq) && error) 72 nr_bytes = rq->hard_nr_sectors << 9; 73 74 if (!blk_fs_request(rq) && error && !rq->errors) 75 rq->errors = -EIO; 76 77 /* 78 * decide whether to reenable DMA -- 3 is a random magic for now, 79 * if we DMA timeout more than 3 times, just stay in PIO 80 */ 81 if ((drive->dev_flags & IDE_DFLAG_DMA_PIO_RETRY) && 82 drive->retry_pio <= 3) { 83 drive->dev_flags &= ~IDE_DFLAG_DMA_PIO_RETRY; 84 ide_dma_on(drive); 85 } 86 87 if (!__blk_end_request(rq, error, nr_bytes)) { 88 if (dequeue) 89 HWGROUP(drive)->rq = NULL; 90 ret = 0; 91 } 92 93 return ret; 94} 95 96/** 97 * ide_end_request - complete an IDE I/O 98 * @drive: IDE device for the I/O 99 * @uptodate: 100 * @nr_sectors: number of sectors completed 101 * 102 * This is our end_request wrapper function. We complete the I/O 103 * update random number input and dequeue the request, which if 104 * it was tagged may be out of order. 105 */ 106 107int ide_end_request (ide_drive_t *drive, int uptodate, int nr_sectors) 108{ 109 unsigned int nr_bytes = nr_sectors << 9; 110 struct request *rq; 111 unsigned long flags; 112 int ret = 1; 113 114 /* 115 * room for locking improvements here, the calls below don't 116 * need the queue lock held at all 117 */ 118 spin_lock_irqsave(&ide_lock, flags); 119 rq = HWGROUP(drive)->rq; 120 121 if (!nr_bytes) { 122 if (blk_pc_request(rq)) 123 nr_bytes = rq->data_len; 124 else 125 nr_bytes = rq->hard_cur_sectors << 9; 126 } 127 128 ret = __ide_end_request(drive, rq, uptodate, nr_bytes, 1); 129 130 spin_unlock_irqrestore(&ide_lock, flags); 131 return ret; 132} 133EXPORT_SYMBOL(ide_end_request); 134 135static void ide_complete_power_step(ide_drive_t *drive, struct request *rq) 136{ 137 struct request_pm_state *pm = rq->data; 138 139#ifdef DEBUG_PM 140 printk(KERN_INFO "%s: complete_power_step(step: %d)\n", 141 drive->name, pm->pm_step); 142#endif 143 if (drive->media != ide_disk) 144 return; 145 146 switch (pm->pm_step) { 147 case IDE_PM_FLUSH_CACHE: /* Suspend step 1 (flush cache) */ 148 if (pm->pm_state == PM_EVENT_FREEZE) 149 pm->pm_step = IDE_PM_COMPLETED; 150 else 151 pm->pm_step = IDE_PM_STANDBY; 152 break; 153 case IDE_PM_STANDBY: /* Suspend step 2 (standby) */ 154 pm->pm_step = IDE_PM_COMPLETED; 155 break; 156 case IDE_PM_RESTORE_PIO: /* Resume step 1 (restore PIO) */ 157 pm->pm_step = IDE_PM_IDLE; 158 break; 159 case IDE_PM_IDLE: /* Resume step 2 (idle)*/ 160 pm->pm_step = IDE_PM_RESTORE_DMA; 161 break; 162 } 163} 164 165static ide_startstop_t ide_start_power_step(ide_drive_t *drive, struct request *rq) 166{ 167 struct request_pm_state *pm = rq->data; 168 ide_task_t *args = rq->special; 169 170 memset(args, 0, sizeof(*args)); 171 172 switch (pm->pm_step) { 173 case IDE_PM_FLUSH_CACHE: /* Suspend step 1 (flush cache) */ 174 if (drive->media != ide_disk) 175 break; 176 /* Not supported? Switch to next step now. */ 177 if (ata_id_flush_enabled(drive->id) == 0 || 178 (drive->dev_flags & IDE_DFLAG_WCACHE) == 0) { 179 ide_complete_power_step(drive, rq); 180 return ide_stopped; 181 } 182 if (ata_id_flush_ext_enabled(drive->id)) 183 args->tf.command = ATA_CMD_FLUSH_EXT; 184 else 185 args->tf.command = ATA_CMD_FLUSH; 186 goto out_do_tf; 187 case IDE_PM_STANDBY: /* Suspend step 2 (standby) */ 188 args->tf.command = ATA_CMD_STANDBYNOW1; 189 goto out_do_tf; 190 case IDE_PM_RESTORE_PIO: /* Resume step 1 (restore PIO) */ 191 ide_set_max_pio(drive); 192 /* 193 * skip IDE_PM_IDLE for ATAPI devices 194 */ 195 if (drive->media != ide_disk) 196 pm->pm_step = IDE_PM_RESTORE_DMA; 197 else 198 ide_complete_power_step(drive, rq); 199 return ide_stopped; 200 case IDE_PM_IDLE: /* Resume step 2 (idle) */ 201 args->tf.command = ATA_CMD_IDLEIMMEDIATE; 202 goto out_do_tf; 203 case IDE_PM_RESTORE_DMA: /* Resume step 3 (restore DMA) */ 204 /* 205 * Right now, all we do is call ide_set_dma(drive), 206 * we could be smarter and check for current xfer_speed 207 * in struct drive etc... 208 */ 209 if (drive->hwif->dma_ops == NULL) 210 break; 211 if (drive->dev_flags & IDE_DFLAG_USING_DMA) 212 ide_set_dma(drive); 213 break; 214 } 215 216 pm->pm_step = IDE_PM_COMPLETED; 217 return ide_stopped; 218 219out_do_tf: 220 args->tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE; 221 args->data_phase = TASKFILE_NO_DATA; 222 return do_rw_taskfile(drive, args); 223} 224 225/** 226 * ide_end_dequeued_request - complete an IDE I/O 227 * @drive: IDE device for the I/O 228 * @uptodate: 229 * @nr_sectors: number of sectors completed 230 * 231 * Complete an I/O that is no longer on the request queue. This 232 * typically occurs when we pull the request and issue a REQUEST_SENSE. 233 * We must still finish the old request but we must not tamper with the 234 * queue in the meantime. 235 * 236 * NOTE: This path does not handle barrier, but barrier is not supported 237 * on ide-cd anyway. 238 */ 239 240int ide_end_dequeued_request(ide_drive_t *drive, struct request *rq, 241 int uptodate, int nr_sectors) 242{ 243 unsigned long flags; 244 int ret; 245 246 spin_lock_irqsave(&ide_lock, flags); 247 BUG_ON(!blk_rq_started(rq)); 248 ret = __ide_end_request(drive, rq, uptodate, nr_sectors << 9, 0); 249 spin_unlock_irqrestore(&ide_lock, flags); 250 251 return ret; 252} 253EXPORT_SYMBOL_GPL(ide_end_dequeued_request); 254 255 256/** 257 * ide_complete_pm_request - end the current Power Management request 258 * @drive: target drive 259 * @rq: request 260 * 261 * This function cleans up the current PM request and stops the queue 262 * if necessary. 263 */ 264static void ide_complete_pm_request (ide_drive_t *drive, struct request *rq) 265{ 266 unsigned long flags; 267 268#ifdef DEBUG_PM 269 printk("%s: completing PM request, %s\n", drive->name, 270 blk_pm_suspend_request(rq) ? "suspend" : "resume"); 271#endif 272 spin_lock_irqsave(&ide_lock, flags); 273 if (blk_pm_suspend_request(rq)) { 274 blk_stop_queue(drive->queue); 275 } else { 276 drive->dev_flags &= ~IDE_DFLAG_BLOCKED; 277 blk_start_queue(drive->queue); 278 } 279 HWGROUP(drive)->rq = NULL; 280 if (__blk_end_request(rq, 0, 0)) 281 BUG(); 282 spin_unlock_irqrestore(&ide_lock, flags); 283} 284 285/** 286 * ide_end_drive_cmd - end an explicit drive command 287 * @drive: command 288 * @stat: status bits 289 * @err: error bits 290 * 291 * Clean up after success/failure of an explicit drive command. 292 * These get thrown onto the queue so they are synchronized with 293 * real I/O operations on the drive. 294 * 295 * In LBA48 mode we have to read the register set twice to get 296 * all the extra information out. 297 */ 298 299void ide_end_drive_cmd (ide_drive_t *drive, u8 stat, u8 err) 300{ 301 unsigned long flags; 302 struct request *rq; 303 304 spin_lock_irqsave(&ide_lock, flags); 305 rq = HWGROUP(drive)->rq; 306 spin_unlock_irqrestore(&ide_lock, flags); 307 308 if (rq->cmd_type == REQ_TYPE_ATA_TASKFILE) { 309 ide_task_t *task = (ide_task_t *)rq->special; 310 311 if (rq->errors == 0) 312 rq->errors = !OK_STAT(stat, ATA_DRDY, BAD_STAT); 313 314 if (task) { 315 struct ide_taskfile *tf = &task->tf; 316 317 tf->error = err; 318 tf->status = stat; 319 320 drive->hwif->tp_ops->tf_read(drive, task); 321 322 if (task->tf_flags & IDE_TFLAG_DYN) 323 kfree(task); 324 } 325 } else if (blk_pm_request(rq)) { 326 struct request_pm_state *pm = rq->data; 327 328 ide_complete_power_step(drive, rq); 329 if (pm->pm_step == IDE_PM_COMPLETED) 330 ide_complete_pm_request(drive, rq); 331 return; 332 } 333 334 spin_lock_irqsave(&ide_lock, flags); 335 HWGROUP(drive)->rq = NULL; 336 rq->errors = err; 337 if (unlikely(__blk_end_request(rq, (rq->errors ? -EIO : 0), 338 blk_rq_bytes(rq)))) 339 BUG(); 340 spin_unlock_irqrestore(&ide_lock, flags); 341} 342 343EXPORT_SYMBOL(ide_end_drive_cmd); 344 345static void ide_kill_rq(ide_drive_t *drive, struct request *rq) 346{ 347 if (rq->rq_disk) { 348 ide_driver_t *drv; 349 350 drv = *(ide_driver_t **)rq->rq_disk->private_data; 351 drv->end_request(drive, 0, 0); 352 } else 353 ide_end_request(drive, 0, 0); 354} 355 356static ide_startstop_t ide_ata_error(ide_drive_t *drive, struct request *rq, u8 stat, u8 err) 357{ 358 ide_hwif_t *hwif = drive->hwif; 359 360 if ((stat & ATA_BUSY) || 361 ((stat & ATA_DF) && (drive->dev_flags & IDE_DFLAG_NOWERR) == 0)) { 362 /* other bits are useless when BUSY */ 363 rq->errors |= ERROR_RESET; 364 } else if (stat & ATA_ERR) { 365 /* err has different meaning on cdrom and tape */ 366 if (err == ATA_ABORTED) { 367 if ((drive->dev_flags & IDE_DFLAG_LBA) && 368 /* some newer drives don't support ATA_CMD_INIT_DEV_PARAMS */ 369 hwif->tp_ops->read_status(hwif) == ATA_CMD_INIT_DEV_PARAMS) 370 return ide_stopped; 371 } else if ((err & BAD_CRC) == BAD_CRC) { 372 /* UDMA crc error, just retry the operation */ 373 drive->crc_count++; 374 } else if (err & (ATA_BBK | ATA_UNC)) { 375 /* retries won't help these */ 376 rq->errors = ERROR_MAX; 377 } else if (err & ATA_TRK0NF) { 378 /* help it find track zero */ 379 rq->errors |= ERROR_RECAL; 380 } 381 } 382 383 if ((stat & ATA_DRQ) && rq_data_dir(rq) == READ && 384 (hwif->host_flags & IDE_HFLAG_ERROR_STOPS_FIFO) == 0) { 385 int nsect = drive->mult_count ? drive->mult_count : 1; 386 387 ide_pad_transfer(drive, READ, nsect * SECTOR_SIZE); 388 } 389 390 if (rq->errors >= ERROR_MAX || blk_noretry_request(rq)) { 391 ide_kill_rq(drive, rq); 392 return ide_stopped; 393 } 394 395 if (hwif->tp_ops->read_status(hwif) & (ATA_BUSY | ATA_DRQ)) 396 rq->errors |= ERROR_RESET; 397 398 if ((rq->errors & ERROR_RESET) == ERROR_RESET) { 399 ++rq->errors; 400 return ide_do_reset(drive); 401 } 402 403 if ((rq->errors & ERROR_RECAL) == ERROR_RECAL) 404 drive->special.b.recalibrate = 1; 405 406 ++rq->errors; 407 408 return ide_stopped; 409} 410 411static ide_startstop_t ide_atapi_error(ide_drive_t *drive, struct request *rq, u8 stat, u8 err) 412{ 413 ide_hwif_t *hwif = drive->hwif; 414 415 if ((stat & ATA_BUSY) || 416 ((stat & ATA_DF) && (drive->dev_flags & IDE_DFLAG_NOWERR) == 0)) { 417 /* other bits are useless when BUSY */ 418 rq->errors |= ERROR_RESET; 419 } else { 420 /* add decoding error stuff */ 421 } 422 423 if (hwif->tp_ops->read_status(hwif) & (ATA_BUSY | ATA_DRQ)) 424 /* force an abort */ 425 hwif->tp_ops->exec_command(hwif, ATA_CMD_IDLEIMMEDIATE); 426 427 if (rq->errors >= ERROR_MAX) { 428 ide_kill_rq(drive, rq); 429 } else { 430 if ((rq->errors & ERROR_RESET) == ERROR_RESET) { 431 ++rq->errors; 432 return ide_do_reset(drive); 433 } 434 ++rq->errors; 435 } 436 437 return ide_stopped; 438} 439 440ide_startstop_t 441__ide_error(ide_drive_t *drive, struct request *rq, u8 stat, u8 err) 442{ 443 if (drive->media == ide_disk) 444 return ide_ata_error(drive, rq, stat, err); 445 return ide_atapi_error(drive, rq, stat, err); 446} 447 448EXPORT_SYMBOL_GPL(__ide_error); 449 450/** 451 * ide_error - handle an error on the IDE 452 * @drive: drive the error occurred on 453 * @msg: message to report 454 * @stat: status bits 455 * 456 * ide_error() takes action based on the error returned by the drive. 457 * For normal I/O that may well include retries. We deal with 458 * both new-style (taskfile) and old style command handling here. 459 * In the case of taskfile command handling there is work left to 460 * do 461 */ 462 463ide_startstop_t ide_error (ide_drive_t *drive, const char *msg, u8 stat) 464{ 465 struct request *rq; 466 u8 err; 467 468 err = ide_dump_status(drive, msg, stat); 469 470 if ((rq = HWGROUP(drive)->rq) == NULL) 471 return ide_stopped; 472 473 /* retry only "normal" I/O: */ 474 if (!blk_fs_request(rq)) { 475 rq->errors = 1; 476 ide_end_drive_cmd(drive, stat, err); 477 return ide_stopped; 478 } 479 480 if (rq->rq_disk) { 481 ide_driver_t *drv; 482 483 drv = *(ide_driver_t **)rq->rq_disk->private_data; 484 return drv->error(drive, rq, stat, err); 485 } else 486 return __ide_error(drive, rq, stat, err); 487} 488 489EXPORT_SYMBOL_GPL(ide_error); 490 491static void ide_tf_set_specify_cmd(ide_drive_t *drive, struct ide_taskfile *tf) 492{ 493 tf->nsect = drive->sect; 494 tf->lbal = drive->sect; 495 tf->lbam = drive->cyl; 496 tf->lbah = drive->cyl >> 8; 497 tf->device = (drive->head - 1) | drive->select; 498 tf->command = ATA_CMD_INIT_DEV_PARAMS; 499} 500 501static void ide_tf_set_restore_cmd(ide_drive_t *drive, struct ide_taskfile *tf) 502{ 503 tf->nsect = drive->sect; 504 tf->command = ATA_CMD_RESTORE; 505} 506 507static void ide_tf_set_setmult_cmd(ide_drive_t *drive, struct ide_taskfile *tf) 508{ 509 tf->nsect = drive->mult_req; 510 tf->command = ATA_CMD_SET_MULTI; 511} 512 513static ide_startstop_t ide_disk_special(ide_drive_t *drive) 514{ 515 special_t *s = &drive->special; 516 ide_task_t args; 517 518 memset(&args, 0, sizeof(ide_task_t)); 519 args.data_phase = TASKFILE_NO_DATA; 520 521 if (s->b.set_geometry) { 522 s->b.set_geometry = 0; 523 ide_tf_set_specify_cmd(drive, &args.tf); 524 } else if (s->b.recalibrate) { 525 s->b.recalibrate = 0; 526 ide_tf_set_restore_cmd(drive, &args.tf); 527 } else if (s->b.set_multmode) { 528 s->b.set_multmode = 0; 529 ide_tf_set_setmult_cmd(drive, &args.tf); 530 } else if (s->all) { 531 int special = s->all; 532 s->all = 0; 533 printk(KERN_ERR "%s: bad special flag: 0x%02x\n", drive->name, special); 534 return ide_stopped; 535 } 536 537 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE | 538 IDE_TFLAG_CUSTOM_HANDLER; 539 540 do_rw_taskfile(drive, &args); 541 542 return ide_started; 543} 544 545/** 546 * do_special - issue some special commands 547 * @drive: drive the command is for 548 * 549 * do_special() is used to issue ATA_CMD_INIT_DEV_PARAMS, 550 * ATA_CMD_RESTORE and ATA_CMD_SET_MULTI commands to a drive. 551 * 552 * It used to do much more, but has been scaled back. 553 */ 554 555static ide_startstop_t do_special (ide_drive_t *drive) 556{ 557 special_t *s = &drive->special; 558 559#ifdef DEBUG 560 printk("%s: do_special: 0x%02x\n", drive->name, s->all); 561#endif 562 if (drive->media == ide_disk) 563 return ide_disk_special(drive); 564 565 s->all = 0; 566 drive->mult_req = 0; 567 return ide_stopped; 568} 569 570void ide_map_sg(ide_drive_t *drive, struct request *rq) 571{ 572 ide_hwif_t *hwif = drive->hwif; 573 struct scatterlist *sg = hwif->sg_table; 574 575 if (hwif->sg_mapped) /* needed by ide-scsi */ 576 return; 577 578 if (rq->cmd_type != REQ_TYPE_ATA_TASKFILE) { 579 hwif->sg_nents = blk_rq_map_sg(drive->queue, rq, sg); 580 } else { 581 sg_init_one(sg, rq->buffer, rq->nr_sectors * SECTOR_SIZE); 582 hwif->sg_nents = 1; 583 } 584} 585 586EXPORT_SYMBOL_GPL(ide_map_sg); 587 588void ide_init_sg_cmd(ide_drive_t *drive, struct request *rq) 589{ 590 ide_hwif_t *hwif = drive->hwif; 591 592 hwif->nsect = hwif->nleft = rq->nr_sectors; 593 hwif->cursg_ofs = 0; 594 hwif->cursg = NULL; 595} 596 597EXPORT_SYMBOL_GPL(ide_init_sg_cmd); 598 599/** 600 * execute_drive_command - issue special drive command 601 * @drive: the drive to issue the command on 602 * @rq: the request structure holding the command 603 * 604 * execute_drive_cmd() issues a special drive command, usually 605 * initiated by ioctl() from the external hdparm program. The 606 * command can be a drive command, drive task or taskfile 607 * operation. Weirdly you can call it with NULL to wait for 608 * all commands to finish. Don't do this as that is due to change 609 */ 610 611static ide_startstop_t execute_drive_cmd (ide_drive_t *drive, 612 struct request *rq) 613{ 614 ide_hwif_t *hwif = HWIF(drive); 615 ide_task_t *task = rq->special; 616 617 if (task) { 618 hwif->data_phase = task->data_phase; 619 620 switch (hwif->data_phase) { 621 case TASKFILE_MULTI_OUT: 622 case TASKFILE_OUT: 623 case TASKFILE_MULTI_IN: 624 case TASKFILE_IN: 625 ide_init_sg_cmd(drive, rq); 626 ide_map_sg(drive, rq); 627 default: 628 break; 629 } 630 631 return do_rw_taskfile(drive, task); 632 } 633 634 /* 635 * NULL is actually a valid way of waiting for 636 * all current requests to be flushed from the queue. 637 */ 638#ifdef DEBUG 639 printk("%s: DRIVE_CMD (null)\n", drive->name); 640#endif 641 ide_end_drive_cmd(drive, hwif->tp_ops->read_status(hwif), 642 ide_read_error(drive)); 643 644 return ide_stopped; 645} 646 647int ide_devset_execute(ide_drive_t *drive, const struct ide_devset *setting, 648 int arg) 649{ 650 struct request_queue *q = drive->queue; 651 struct request *rq; 652 int ret = 0; 653 654 if (!(setting->flags & DS_SYNC)) 655 return setting->set(drive, arg); 656 657 rq = blk_get_request(q, READ, __GFP_WAIT); 658 rq->cmd_type = REQ_TYPE_SPECIAL; 659 rq->cmd_len = 5; 660 rq->cmd[0] = REQ_DEVSET_EXEC; 661 *(int *)&rq->cmd[1] = arg; 662 rq->special = setting->set; 663 664 if (blk_execute_rq(q, NULL, rq, 0)) 665 ret = rq->errors; 666 blk_put_request(rq); 667 668 return ret; 669} 670EXPORT_SYMBOL_GPL(ide_devset_execute); 671 672static ide_startstop_t ide_special_rq(ide_drive_t *drive, struct request *rq) 673{ 674 u8 cmd = rq->cmd[0]; 675 676 if (cmd == REQ_PARK_HEADS || cmd == REQ_UNPARK_HEADS) { 677 ide_task_t task; 678 struct ide_taskfile *tf = &task.tf; 679 680 memset(&task, 0, sizeof(task)); 681 if (cmd == REQ_PARK_HEADS) { 682 drive->sleep = *(unsigned long *)rq->special; 683 drive->dev_flags |= IDE_DFLAG_SLEEPING; 684 tf->command = ATA_CMD_IDLEIMMEDIATE; 685 tf->feature = 0x44; 686 tf->lbal = 0x4c; 687 tf->lbam = 0x4e; 688 tf->lbah = 0x55; 689 task.tf_flags |= IDE_TFLAG_CUSTOM_HANDLER; 690 } else /* cmd == REQ_UNPARK_HEADS */ 691 tf->command = ATA_CMD_CHK_POWER; 692 693 task.tf_flags |= IDE_TFLAG_TF | IDE_TFLAG_DEVICE; 694 task.rq = rq; 695 drive->hwif->data_phase = task.data_phase = TASKFILE_NO_DATA; 696 return do_rw_taskfile(drive, &task); 697 } 698 699 switch (cmd) { 700 case REQ_DEVSET_EXEC: 701 { 702 int err, (*setfunc)(ide_drive_t *, int) = rq->special; 703 704 err = setfunc(drive, *(int *)&rq->cmd[1]); 705 if (err) 706 rq->errors = err; 707 else 708 err = 1; 709 ide_end_request(drive, err, 0); 710 return ide_stopped; 711 } 712 case REQ_DRIVE_RESET: 713 return ide_do_reset(drive); 714 default: 715 blk_dump_rq_flags(rq, "ide_special_rq - bad request"); 716 ide_end_request(drive, 0, 0); 717 return ide_stopped; 718 } 719} 720 721static void ide_check_pm_state(ide_drive_t *drive, struct request *rq) 722{ 723 struct request_pm_state *pm = rq->data; 724 725 if (blk_pm_suspend_request(rq) && 726 pm->pm_step == IDE_PM_START_SUSPEND) 727 /* Mark drive blocked when starting the suspend sequence. */ 728 drive->dev_flags |= IDE_DFLAG_BLOCKED; 729 else if (blk_pm_resume_request(rq) && 730 pm->pm_step == IDE_PM_START_RESUME) { 731 /* 732 * The first thing we do on wakeup is to wait for BSY bit to 733 * go away (with a looong timeout) as a drive on this hwif may 734 * just be POSTing itself. 735 * We do that before even selecting as the "other" device on 736 * the bus may be broken enough to walk on our toes at this 737 * point. 738 */ 739 ide_hwif_t *hwif = drive->hwif; 740 int rc; 741#ifdef DEBUG_PM 742 printk("%s: Wakeup request inited, waiting for !BSY...\n", drive->name); 743#endif 744 rc = ide_wait_not_busy(hwif, 35000); 745 if (rc) 746 printk(KERN_WARNING "%s: bus not ready on wakeup\n", drive->name); 747 SELECT_DRIVE(drive); 748 hwif->tp_ops->set_irq(hwif, 1); 749 rc = ide_wait_not_busy(hwif, 100000); 750 if (rc) 751 printk(KERN_WARNING "%s: drive not ready on wakeup\n", drive->name); 752 } 753} 754 755/** 756 * start_request - start of I/O and command issuing for IDE 757 * 758 * start_request() initiates handling of a new I/O request. It 759 * accepts commands and I/O (read/write) requests. 760 * 761 * FIXME: this function needs a rename 762 */ 763 764static ide_startstop_t start_request (ide_drive_t *drive, struct request *rq) 765{ 766 ide_startstop_t startstop; 767 768 BUG_ON(!blk_rq_started(rq)); 769 770#ifdef DEBUG 771 printk("%s: start_request: current=0x%08lx\n", 772 HWIF(drive)->name, (unsigned long) rq); 773#endif 774 775 /* bail early if we've exceeded max_failures */ 776 if (drive->max_failures && (drive->failures > drive->max_failures)) { 777 rq->cmd_flags |= REQ_FAILED; 778 goto kill_rq; 779 } 780 781 if (blk_pm_request(rq)) 782 ide_check_pm_state(drive, rq); 783 784 SELECT_DRIVE(drive); 785 if (ide_wait_stat(&startstop, drive, drive->ready_stat, 786 ATA_BUSY | ATA_DRQ, WAIT_READY)) { 787 printk(KERN_ERR "%s: drive not ready for command\n", drive->name); 788 return startstop; 789 } 790 if (!drive->special.all) { 791 ide_driver_t *drv; 792 793 /* 794 * We reset the drive so we need to issue a SETFEATURES. 795 * Do it _after_ do_special() restored device parameters. 796 */ 797 if (drive->current_speed == 0xff) 798 ide_config_drive_speed(drive, drive->desired_speed); 799 800 if (rq->cmd_type == REQ_TYPE_ATA_TASKFILE) 801 return execute_drive_cmd(drive, rq); 802 else if (blk_pm_request(rq)) { 803 struct request_pm_state *pm = rq->data; 804#ifdef DEBUG_PM 805 printk("%s: start_power_step(step: %d)\n", 806 drive->name, pm->pm_step); 807#endif 808 startstop = ide_start_power_step(drive, rq); 809 if (startstop == ide_stopped && 810 pm->pm_step == IDE_PM_COMPLETED) 811 ide_complete_pm_request(drive, rq); 812 return startstop; 813 } else if (!rq->rq_disk && blk_special_request(rq)) 814 /* 815 * TODO: Once all ULDs have been modified to 816 * check for specific op codes rather than 817 * blindly accepting any special request, the 818 * check for ->rq_disk above may be replaced 819 * by a more suitable mechanism or even 820 * dropped entirely. 821 */ 822 return ide_special_rq(drive, rq); 823 824 drv = *(ide_driver_t **)rq->rq_disk->private_data; 825 826 return drv->do_request(drive, rq, rq->sector); 827 } 828 return do_special(drive); 829kill_rq: 830 ide_kill_rq(drive, rq); 831 return ide_stopped; 832} 833 834/** 835 * ide_stall_queue - pause an IDE device 836 * @drive: drive to stall 837 * @timeout: time to stall for (jiffies) 838 * 839 * ide_stall_queue() can be used by a drive to give excess bandwidth back 840 * to the hwgroup by sleeping for timeout jiffies. 841 */ 842 843void ide_stall_queue (ide_drive_t *drive, unsigned long timeout) 844{ 845 if (timeout > WAIT_WORSTCASE) 846 timeout = WAIT_WORSTCASE; 847 drive->sleep = timeout + jiffies; 848 drive->dev_flags |= IDE_DFLAG_SLEEPING; 849} 850 851EXPORT_SYMBOL(ide_stall_queue); 852 853#define WAKEUP(drive) ((drive)->service_start + 2 * (drive)->service_time) 854 855/** 856 * choose_drive - select a drive to service 857 * @hwgroup: hardware group to select on 858 * 859 * choose_drive() selects the next drive which will be serviced. 860 * This is necessary because the IDE layer can't issue commands 861 * to both drives on the same cable, unlike SCSI. 862 */ 863 864static inline ide_drive_t *choose_drive (ide_hwgroup_t *hwgroup) 865{ 866 ide_drive_t *drive, *best; 867 868repeat: 869 best = NULL; 870 drive = hwgroup->drive; 871 872 /* 873 * drive is doing pre-flush, ordered write, post-flush sequence. even 874 * though that is 3 requests, it must be seen as a single transaction. 875 * we must not preempt this drive until that is complete 876 */ 877 if (blk_queue_flushing(drive->queue)) { 878 /* 879 * small race where queue could get replugged during 880 * the 3-request flush cycle, just yank the plug since 881 * we want it to finish asap 882 */ 883 blk_remove_plug(drive->queue); 884 return drive; 885 } 886 887 do { 888 u8 dev_s = !!(drive->dev_flags & IDE_DFLAG_SLEEPING); 889 u8 best_s = (best && !!(best->dev_flags & IDE_DFLAG_SLEEPING)); 890 891 if ((dev_s == 0 || time_after_eq(jiffies, drive->sleep)) && 892 !elv_queue_empty(drive->queue)) { 893 if (best == NULL || 894 (dev_s && (best_s == 0 || time_before(drive->sleep, best->sleep))) || 895 (best_s == 0 && time_before(WAKEUP(drive), WAKEUP(best)))) { 896 if (!blk_queue_plugged(drive->queue)) 897 best = drive; 898 } 899 } 900 } while ((drive = drive->next) != hwgroup->drive); 901 902 if (best && (best->dev_flags & IDE_DFLAG_NICE1) && 903 (best->dev_flags & IDE_DFLAG_SLEEPING) == 0 && 904 best != hwgroup->drive && best->service_time > WAIT_MIN_SLEEP) { 905 long t = (signed long)(WAKEUP(best) - jiffies); 906 if (t >= WAIT_MIN_SLEEP) { 907 /* 908 * We *may* have some time to spare, but first let's see if 909 * someone can potentially benefit from our nice mood today.. 910 */ 911 drive = best->next; 912 do { 913 if ((drive->dev_flags & IDE_DFLAG_SLEEPING) == 0 914 && time_before(jiffies - best->service_time, WAKEUP(drive)) 915 && time_before(WAKEUP(drive), jiffies + t)) 916 { 917 ide_stall_queue(best, min_t(long, t, 10 * WAIT_MIN_SLEEP)); 918 goto repeat; 919 } 920 } while ((drive = drive->next) != best); 921 } 922 } 923 return best; 924} 925 926/* 927 * Issue a new request to a drive from hwgroup 928 * Caller must have already done spin_lock_irqsave(&ide_lock, ..); 929 * 930 * A hwgroup is a serialized group of IDE interfaces. Usually there is 931 * exactly one hwif (interface) per hwgroup, but buggy controllers (eg. CMD640) 932 * may have both interfaces in a single hwgroup to "serialize" access. 933 * Or possibly multiple ISA interfaces can share a common IRQ by being grouped 934 * together into one hwgroup for serialized access. 935 * 936 * Note also that several hwgroups can end up sharing a single IRQ, 937 * possibly along with many other devices. This is especially common in 938 * PCI-based systems with off-board IDE controller cards. 939 * 940 * The IDE driver uses the single global ide_lock spinlock to protect 941 * access to the request queues, and to protect the hwgroup->busy flag. 942 * 943 * The first thread into the driver for a particular hwgroup sets the 944 * hwgroup->busy flag to indicate that this hwgroup is now active, 945 * and then initiates processing of the top request from the request queue. 946 * 947 * Other threads attempting entry notice the busy setting, and will simply 948 * queue their new requests and exit immediately. Note that hwgroup->busy 949 * remains set even when the driver is merely awaiting the next interrupt. 950 * Thus, the meaning is "this hwgroup is busy processing a request". 951 * 952 * When processing of a request completes, the completing thread or IRQ-handler 953 * will start the next request from the queue. If no more work remains, 954 * the driver will clear the hwgroup->busy flag and exit. 955 * 956 * The ide_lock (spinlock) is used to protect all access to the 957 * hwgroup->busy flag, but is otherwise not needed for most processing in 958 * the driver. This makes the driver much more friendlier to shared IRQs 959 * than previous designs, while remaining 100% (?) SMP safe and capable. 960 */ 961static void ide_do_request (ide_hwgroup_t *hwgroup, int masked_irq) 962{ 963 ide_drive_t *drive; 964 ide_hwif_t *hwif; 965 struct request *rq; 966 ide_startstop_t startstop; 967 int loops = 0; 968 969 /* caller must own ide_lock */ 970 BUG_ON(!irqs_disabled()); 971 972 while (!hwgroup->busy) { 973 hwgroup->busy = 1; 974 /* for atari only */ 975 ide_get_lock(ide_intr, hwgroup); 976 drive = choose_drive(hwgroup); 977 if (drive == NULL) { 978 int sleeping = 0; 979 unsigned long sleep = 0; /* shut up, gcc */ 980 hwgroup->rq = NULL; 981 drive = hwgroup->drive; 982 do { 983 if ((drive->dev_flags & IDE_DFLAG_SLEEPING) && 984 (sleeping == 0 || 985 time_before(drive->sleep, sleep))) { 986 sleeping = 1; 987 sleep = drive->sleep; 988 } 989 } while ((drive = drive->next) != hwgroup->drive); 990 if (sleeping) { 991 /* 992 * Take a short snooze, and then wake up this hwgroup again. 993 * This gives other hwgroups on the same a chance to 994 * play fairly with us, just in case there are big differences 995 * in relative throughputs.. don't want to hog the cpu too much. 996 */ 997 if (time_before(sleep, jiffies + WAIT_MIN_SLEEP)) 998 sleep = jiffies + WAIT_MIN_SLEEP; 999#if 1 1000 if (timer_pending(&hwgroup->timer)) 1001 printk(KERN_CRIT "ide_set_handler: timer already active\n"); 1002#endif 1003 /* so that ide_timer_expiry knows what to do */ 1004 hwgroup->sleeping = 1; 1005 hwgroup->req_gen_timer = hwgroup->req_gen; 1006 mod_timer(&hwgroup->timer, sleep); 1007 /* we purposely leave hwgroup->busy==1 1008 * while sleeping */ 1009 } else { 1010 /* Ugly, but how can we sleep for the lock 1011 * otherwise? perhaps from tq_disk? 1012 */ 1013 1014 /* for atari only */ 1015 ide_release_lock(); 1016 hwgroup->busy = 0; 1017 } 1018 1019 /* no more work for this hwgroup (for now) */ 1020 return; 1021 } 1022 again: 1023 hwif = HWIF(drive); 1024 if (hwgroup->hwif->sharing_irq && hwif != hwgroup->hwif) { 1025 /* 1026 * set nIEN for previous hwif, drives in the 1027 * quirk_list may not like intr setups/cleanups 1028 */ 1029 if (drive->quirk_list != 1) 1030 hwif->tp_ops->set_irq(hwif, 0); 1031 } 1032 hwgroup->hwif = hwif; 1033 hwgroup->drive = drive; 1034 drive->dev_flags &= ~(IDE_DFLAG_SLEEPING | IDE_DFLAG_PARKED); 1035 drive->service_start = jiffies; 1036 1037 if (blk_queue_plugged(drive->queue)) { 1038 printk(KERN_ERR "ide: huh? queue was plugged!\n"); 1039 break; 1040 } 1041 1042 /* 1043 * we know that the queue isn't empty, but this can happen 1044 * if the q->prep_rq_fn() decides to kill a request 1045 */ 1046 rq = elv_next_request(drive->queue); 1047 if (!rq) { 1048 hwgroup->busy = 0; 1049 break; 1050 } 1051 1052 /* 1053 * Sanity: don't accept a request that isn't a PM request 1054 * if we are currently power managed. This is very important as 1055 * blk_stop_queue() doesn't prevent the elv_next_request() 1056 * above to return us whatever is in the queue. Since we call 1057 * ide_do_request() ourselves, we end up taking requests while 1058 * the queue is blocked... 1059 * 1060 * We let requests forced at head of queue with ide-preempt 1061 * though. I hope that doesn't happen too much, hopefully not 1062 * unless the subdriver triggers such a thing in its own PM 1063 * state machine. 1064 * 1065 * We count how many times we loop here to make sure we service 1066 * all drives in the hwgroup without looping for ever 1067 */ 1068 if ((drive->dev_flags & IDE_DFLAG_BLOCKED) && 1069 blk_pm_request(rq) == 0 && 1070 (rq->cmd_flags & REQ_PREEMPT) == 0) { 1071 drive = drive->next ? drive->next : hwgroup->drive; 1072 if (loops++ < 4 && !blk_queue_plugged(drive->queue)) 1073 goto again; 1074 /* We clear busy, there should be no pending ATA command at this point. */ 1075 hwgroup->busy = 0; 1076 break; 1077 } 1078 1079 hwgroup->rq = rq; 1080 1081 /* 1082 * Some systems have trouble with IDE IRQs arriving while 1083 * the driver is still setting things up. So, here we disable 1084 * the IRQ used by this interface while the request is being started. 1085 * This may look bad at first, but pretty much the same thing 1086 * happens anyway when any interrupt comes in, IDE or otherwise 1087 * -- the kernel masks the IRQ while it is being handled. 1088 */ 1089 if (masked_irq != IDE_NO_IRQ && hwif->irq != masked_irq) 1090 disable_irq_nosync(hwif->irq); 1091 spin_unlock(&ide_lock); 1092 local_irq_enable_in_hardirq(); 1093 /* allow other IRQs while we start this request */ 1094 startstop = start_request(drive, rq); 1095 spin_lock_irq(&ide_lock); 1096 if (masked_irq != IDE_NO_IRQ && hwif->irq != masked_irq) 1097 enable_irq(hwif->irq); 1098 if (startstop == ide_stopped) 1099 hwgroup->busy = 0; 1100 } 1101} 1102 1103/* 1104 * Passes the stuff to ide_do_request 1105 */ 1106void do_ide_request(struct request_queue *q) 1107{ 1108 ide_drive_t *drive = q->queuedata; 1109 1110 ide_do_request(HWGROUP(drive), IDE_NO_IRQ); 1111} 1112 1113/* 1114 * un-busy the hwgroup etc, and clear any pending DMA status. we want to 1115 * retry the current request in pio mode instead of risking tossing it 1116 * all away 1117 */ 1118static ide_startstop_t ide_dma_timeout_retry(ide_drive_t *drive, int error) 1119{ 1120 ide_hwif_t *hwif = HWIF(drive); 1121 struct request *rq; 1122 ide_startstop_t ret = ide_stopped; 1123 1124 /* 1125 * end current dma transaction 1126 */ 1127 1128 if (error < 0) { 1129 printk(KERN_WARNING "%s: DMA timeout error\n", drive->name); 1130 (void)hwif->dma_ops->dma_end(drive); 1131 ret = ide_error(drive, "dma timeout error", 1132 hwif->tp_ops->read_status(hwif)); 1133 } else { 1134 printk(KERN_WARNING "%s: DMA timeout retry\n", drive->name); 1135 hwif->dma_ops->dma_timeout(drive); 1136 } 1137 1138 /* 1139 * disable dma for now, but remember that we did so because of 1140 * a timeout -- we'll reenable after we finish this next request 1141 * (or rather the first chunk of it) in pio. 1142 */ 1143 drive->dev_flags |= IDE_DFLAG_DMA_PIO_RETRY; 1144 drive->retry_pio++; 1145 ide_dma_off_quietly(drive); 1146 1147 /* 1148 * un-busy drive etc (hwgroup->busy is cleared on return) and 1149 * make sure request is sane 1150 */ 1151 rq = HWGROUP(drive)->rq; 1152 1153 if (!rq) 1154 goto out; 1155 1156 HWGROUP(drive)->rq = NULL; 1157 1158 rq->errors = 0; 1159 1160 if (!rq->bio) 1161 goto out; 1162 1163 rq->sector = rq->bio->bi_sector; 1164 rq->current_nr_sectors = bio_iovec(rq->bio)->bv_len >> 9; 1165 rq->hard_cur_sectors = rq->current_nr_sectors; 1166 rq->buffer = bio_data(rq->bio); 1167out: 1168 return ret; 1169} 1170 1171/** 1172 * ide_timer_expiry - handle lack of an IDE interrupt 1173 * @data: timer callback magic (hwgroup) 1174 * 1175 * An IDE command has timed out before the expected drive return 1176 * occurred. At this point we attempt to clean up the current 1177 * mess. If the current handler includes an expiry handler then 1178 * we invoke the expiry handler, and providing it is happy the 1179 * work is done. If that fails we apply generic recovery rules 1180 * invoking the handler and checking the drive DMA status. We 1181 * have an excessively incestuous relationship with the DMA 1182 * logic that wants cleaning up. 1183 */ 1184 1185void ide_timer_expiry (unsigned long data) 1186{ 1187 ide_hwgroup_t *hwgroup = (ide_hwgroup_t *) data; 1188 ide_handler_t *handler; 1189 ide_expiry_t *expiry; 1190 unsigned long flags; 1191 unsigned long wait = -1; 1192 1193 spin_lock_irqsave(&ide_lock, flags); 1194 1195 if (((handler = hwgroup->handler) == NULL) || 1196 (hwgroup->req_gen != hwgroup->req_gen_timer)) { 1197 /* 1198 * Either a marginal timeout occurred 1199 * (got the interrupt just as timer expired), 1200 * or we were "sleeping" to give other devices a chance. 1201 * Either way, we don't really want to complain about anything. 1202 */ 1203 if (hwgroup->sleeping) { 1204 hwgroup->sleeping = 0; 1205 hwgroup->busy = 0; 1206 } 1207 } else { 1208 ide_drive_t *drive = hwgroup->drive; 1209 if (!drive) { 1210 printk(KERN_ERR "ide_timer_expiry: hwgroup->drive was NULL\n"); 1211 hwgroup->handler = NULL; 1212 } else { 1213 ide_hwif_t *hwif; 1214 ide_startstop_t startstop = ide_stopped; 1215 if (!hwgroup->busy) { 1216 hwgroup->busy = 1; /* paranoia */ 1217 printk(KERN_ERR "%s: ide_timer_expiry: hwgroup->busy was 0 ??\n", drive->name); 1218 } 1219 if ((expiry = hwgroup->expiry) != NULL) { 1220 /* continue */ 1221 if ((wait = expiry(drive)) > 0) { 1222 /* reset timer */ 1223 hwgroup->timer.expires = jiffies + wait; 1224 hwgroup->req_gen_timer = hwgroup->req_gen; 1225 add_timer(&hwgroup->timer); 1226 spin_unlock_irqrestore(&ide_lock, flags); 1227 return; 1228 } 1229 } 1230 hwgroup->handler = NULL; 1231 /* 1232 * We need to simulate a real interrupt when invoking 1233 * the handler() function, which means we need to 1234 * globally mask the specific IRQ: 1235 */ 1236 spin_unlock(&ide_lock); 1237 hwif = HWIF(drive); 1238 /* disable_irq_nosync ?? */ 1239 disable_irq(hwif->irq); 1240 /* local CPU only, 1241 * as if we were handling an interrupt */ 1242 local_irq_disable(); 1243 if (hwgroup->polling) { 1244 startstop = handler(drive); 1245 } else if (drive_is_ready(drive)) { 1246 if (drive->waiting_for_dma) 1247 hwif->dma_ops->dma_lost_irq(drive); 1248 (void)ide_ack_intr(hwif); 1249 printk(KERN_WARNING "%s: lost interrupt\n", drive->name); 1250 startstop = handler(drive); 1251 } else { 1252 if (drive->waiting_for_dma) { 1253 startstop = ide_dma_timeout_retry(drive, wait); 1254 } else 1255 startstop = 1256 ide_error(drive, "irq timeout", 1257 hwif->tp_ops->read_status(hwif)); 1258 } 1259 drive->service_time = jiffies - drive->service_start; 1260 spin_lock_irq(&ide_lock); 1261 enable_irq(hwif->irq); 1262 if (startstop == ide_stopped) 1263 hwgroup->busy = 0; 1264 } 1265 } 1266 ide_do_request(hwgroup, IDE_NO_IRQ); 1267 spin_unlock_irqrestore(&ide_lock, flags); 1268} 1269 1270/** 1271 * unexpected_intr - handle an unexpected IDE interrupt 1272 * @irq: interrupt line 1273 * @hwgroup: hwgroup being processed 1274 * 1275 * There's nothing really useful we can do with an unexpected interrupt, 1276 * other than reading the status register (to clear it), and logging it. 1277 * There should be no way that an irq can happen before we're ready for it, 1278 * so we needn't worry much about losing an "important" interrupt here. 1279 * 1280 * On laptops (and "green" PCs), an unexpected interrupt occurs whenever 1281 * the drive enters "idle", "standby", or "sleep" mode, so if the status 1282 * looks "good", we just ignore the interrupt completely. 1283 * 1284 * This routine assumes __cli() is in effect when called. 1285 * 1286 * If an unexpected interrupt happens on irq15 while we are handling irq14 1287 * and if the two interfaces are "serialized" (CMD640), then it looks like 1288 * we could screw up by interfering with a new request being set up for 1289 * irq15. 1290 * 1291 * In reality, this is a non-issue. The new command is not sent unless 1292 * the drive is ready to accept one, in which case we know the drive is 1293 * not trying to interrupt us. And ide_set_handler() is always invoked 1294 * before completing the issuance of any new drive command, so we will not 1295 * be accidentally invoked as a result of any valid command completion 1296 * interrupt. 1297 * 1298 * Note that we must walk the entire hwgroup here. We know which hwif 1299 * is doing the current command, but we don't know which hwif burped 1300 * mysteriously. 1301 */ 1302 1303static void unexpected_intr (int irq, ide_hwgroup_t *hwgroup) 1304{ 1305 u8 stat; 1306 ide_hwif_t *hwif = hwgroup->hwif; 1307 1308 /* 1309 * handle the unexpected interrupt 1310 */ 1311 do { 1312 if (hwif->irq == irq) { 1313 stat = hwif->tp_ops->read_status(hwif); 1314 1315 if (!OK_STAT(stat, ATA_DRDY, BAD_STAT)) { 1316 /* Try to not flood the console with msgs */ 1317 static unsigned long last_msgtime, count; 1318 ++count; 1319 if (time_after(jiffies, last_msgtime + HZ)) { 1320 last_msgtime = jiffies; 1321 printk(KERN_ERR "%s%s: unexpected interrupt, " 1322 "status=0x%02x, count=%ld\n", 1323 hwif->name, 1324 (hwif->next==hwgroup->hwif) ? "" : "(?)", stat, count); 1325 } 1326 } 1327 } 1328 } while ((hwif = hwif->next) != hwgroup->hwif); 1329} 1330 1331/** 1332 * ide_intr - default IDE interrupt handler 1333 * @irq: interrupt number 1334 * @dev_id: hwif group 1335 * @regs: unused weirdness from the kernel irq layer 1336 * 1337 * This is the default IRQ handler for the IDE layer. You should 1338 * not need to override it. If you do be aware it is subtle in 1339 * places 1340 * 1341 * hwgroup->hwif is the interface in the group currently performing 1342 * a command. hwgroup->drive is the drive and hwgroup->handler is 1343 * the IRQ handler to call. As we issue a command the handlers 1344 * step through multiple states, reassigning the handler to the 1345 * next step in the process. Unlike a smart SCSI controller IDE 1346 * expects the main processor to sequence the various transfer 1347 * stages. We also manage a poll timer to catch up with most 1348 * timeout situations. There are still a few where the handlers 1349 * don't ever decide to give up. 1350 * 1351 * The handler eventually returns ide_stopped to indicate the 1352 * request completed. At this point we issue the next request 1353 * on the hwgroup and the process begins again. 1354 */ 1355 1356irqreturn_t ide_intr (int irq, void *dev_id) 1357{ 1358 unsigned long flags; 1359 ide_hwgroup_t *hwgroup = (ide_hwgroup_t *)dev_id; 1360 ide_hwif_t *hwif; 1361 ide_drive_t *drive; 1362 ide_handler_t *handler; 1363 ide_startstop_t startstop; 1364 1365 spin_lock_irqsave(&ide_lock, flags); 1366 hwif = hwgroup->hwif; 1367 1368 if (!ide_ack_intr(hwif)) { 1369 spin_unlock_irqrestore(&ide_lock, flags); 1370 return IRQ_NONE; 1371 } 1372 1373 if ((handler = hwgroup->handler) == NULL || hwgroup->polling) { 1374 /* 1375 * Not expecting an interrupt from this drive. 1376 * That means this could be: 1377 * (1) an interrupt from another PCI device 1378 * sharing the same PCI INT# as us. 1379 * or (2) a drive just entered sleep or standby mode, 1380 * and is interrupting to let us know. 1381 * or (3) a spurious interrupt of unknown origin. 1382 * 1383 * For PCI, we cannot tell the difference, 1384 * so in that case we just ignore it and hope it goes away. 1385 * 1386 * FIXME: unexpected_intr should be hwif-> then we can 1387 * remove all the ifdef PCI crap 1388 */ 1389#ifdef CONFIG_BLK_DEV_IDEPCI 1390 if (hwif->chipset != ide_pci) 1391#endif /* CONFIG_BLK_DEV_IDEPCI */ 1392 { 1393 /* 1394 * Probably not a shared PCI interrupt, 1395 * so we can safely try to do something about it: 1396 */ 1397 unexpected_intr(irq, hwgroup); 1398#ifdef CONFIG_BLK_DEV_IDEPCI 1399 } else { 1400 /* 1401 * Whack the status register, just in case 1402 * we have a leftover pending IRQ. 1403 */ 1404 (void)hwif->tp_ops->read_status(hwif); 1405#endif /* CONFIG_BLK_DEV_IDEPCI */ 1406 } 1407 spin_unlock_irqrestore(&ide_lock, flags); 1408 return IRQ_NONE; 1409 } 1410 drive = hwgroup->drive; 1411 if (!drive) { 1412 /* 1413 * This should NEVER happen, and there isn't much 1414 * we could do about it here. 1415 * 1416 * [Note - this can occur if the drive is hot unplugged] 1417 */ 1418 spin_unlock_irqrestore(&ide_lock, flags); 1419 return IRQ_HANDLED; 1420 } 1421 if (!drive_is_ready(drive)) { 1422 /* 1423 * This happens regularly when we share a PCI IRQ with 1424 * another device. Unfortunately, it can also happen 1425 * with some buggy drives that trigger the IRQ before 1426 * their status register is up to date. Hopefully we have 1427 * enough advance overhead that the latter isn't a problem. 1428 */ 1429 spin_unlock_irqrestore(&ide_lock, flags); 1430 return IRQ_NONE; 1431 } 1432 if (!hwgroup->busy) { 1433 hwgroup->busy = 1; /* paranoia */ 1434 printk(KERN_ERR "%s: ide_intr: hwgroup->busy was 0 ??\n", drive->name); 1435 } 1436 hwgroup->handler = NULL; 1437 hwgroup->req_gen++; 1438 del_timer(&hwgroup->timer); 1439 spin_unlock(&ide_lock); 1440 1441 if (hwif->port_ops && hwif->port_ops->clear_irq) 1442 hwif->port_ops->clear_irq(drive); 1443 1444 if (drive->dev_flags & IDE_DFLAG_UNMASK) 1445 local_irq_enable_in_hardirq(); 1446 1447 /* service this interrupt, may set handler for next interrupt */ 1448 startstop = handler(drive); 1449 1450 spin_lock_irq(&ide_lock); 1451 /* 1452 * Note that handler() may have set things up for another 1453 * interrupt to occur soon, but it cannot happen until 1454 * we exit from this routine, because it will be the 1455 * same irq as is currently being serviced here, and Linux 1456 * won't allow another of the same (on any CPU) until we return. 1457 */ 1458 drive->service_time = jiffies - drive->service_start; 1459 if (startstop == ide_stopped) { 1460 if (hwgroup->handler == NULL) { /* paranoia */ 1461 hwgroup->busy = 0; 1462 ide_do_request(hwgroup, hwif->irq); 1463 } else { 1464 printk(KERN_ERR "%s: ide_intr: huh? expected NULL handler " 1465 "on exit\n", drive->name); 1466 } 1467 } 1468 spin_unlock_irqrestore(&ide_lock, flags); 1469 return IRQ_HANDLED; 1470} 1471 1472/** 1473 * ide_do_drive_cmd - issue IDE special command 1474 * @drive: device to issue command 1475 * @rq: request to issue 1476 * 1477 * This function issues a special IDE device request 1478 * onto the request queue. 1479 * 1480 * the rq is queued at the head of the request queue, displacing 1481 * the currently-being-processed request and this function 1482 * returns immediately without waiting for the new rq to be 1483 * completed. This is VERY DANGEROUS, and is intended for 1484 * careful use by the ATAPI tape/cdrom driver code. 1485 */ 1486 1487void ide_do_drive_cmd(ide_drive_t *drive, struct request *rq) 1488{ 1489 unsigned long flags; 1490 ide_hwgroup_t *hwgroup = HWGROUP(drive); 1491 1492 spin_lock_irqsave(&ide_lock, flags); 1493 hwgroup->rq = NULL; 1494 __elv_add_request(drive->queue, rq, ELEVATOR_INSERT_FRONT, 0); 1495 blk_start_queueing(drive->queue); 1496 spin_unlock_irqrestore(&ide_lock, flags); 1497} 1498 1499EXPORT_SYMBOL(ide_do_drive_cmd); 1500 1501void ide_pktcmd_tf_load(ide_drive_t *drive, u32 tf_flags, u16 bcount, u8 dma) 1502{ 1503 ide_hwif_t *hwif = drive->hwif; 1504 ide_task_t task; 1505 1506 memset(&task, 0, sizeof(task)); 1507 task.tf_flags = IDE_TFLAG_OUT_LBAH | IDE_TFLAG_OUT_LBAM | 1508 IDE_TFLAG_OUT_FEATURE | tf_flags; 1509 task.tf.feature = dma; /* Use PIO/DMA */ 1510 task.tf.lbam = bcount & 0xff; 1511 task.tf.lbah = (bcount >> 8) & 0xff; 1512 1513 ide_tf_dump(drive->name, &task.tf); 1514 hwif->tp_ops->set_irq(hwif, 1); 1515 SELECT_MASK(drive, 0); 1516 hwif->tp_ops->tf_load(drive, &task); 1517} 1518 1519EXPORT_SYMBOL_GPL(ide_pktcmd_tf_load); 1520 1521void ide_pad_transfer(ide_drive_t *drive, int write, int len) 1522{ 1523 ide_hwif_t *hwif = drive->hwif; 1524 u8 buf[4] = { 0 }; 1525 1526 while (len > 0) { 1527 if (write) 1528 hwif->tp_ops->output_data(drive, NULL, buf, min(4, len)); 1529 else 1530 hwif->tp_ops->input_data(drive, NULL, buf, min(4, len)); 1531 len -= 4; 1532 } 1533} 1534EXPORT_SYMBOL_GPL(ide_pad_transfer); 1535