ide-taskfile.c revision 94cd5b62ff9bb07ef065333eb97438f115a75890
1/* 2 * Copyright (C) 2000-2002 Michael Cornwell <cornwell@acm.org> 3 * Copyright (C) 2000-2002 Andre Hedrick <andre@linux-ide.org> 4 * Copyright (C) 2001-2002 Klaus Smolin 5 * IBM Storage Technology Division 6 * Copyright (C) 2003-2004, 2007 Bartlomiej Zolnierkiewicz 7 * 8 * The big the bad and the ugly. 9 */ 10 11#include <linux/module.h> 12#include <linux/types.h> 13#include <linux/string.h> 14#include <linux/kernel.h> 15#include <linux/timer.h> 16#include <linux/mm.h> 17#include <linux/sched.h> 18#include <linux/interrupt.h> 19#include <linux/major.h> 20#include <linux/errno.h> 21#include <linux/genhd.h> 22#include <linux/blkpg.h> 23#include <linux/slab.h> 24#include <linux/pci.h> 25#include <linux/delay.h> 26#include <linux/hdreg.h> 27#include <linux/ide.h> 28#include <linux/bitops.h> 29#include <linux/scatterlist.h> 30 31#include <asm/byteorder.h> 32#include <asm/irq.h> 33#include <asm/uaccess.h> 34#include <asm/io.h> 35 36void ide_tf_dump(const char *s, struct ide_taskfile *tf) 37{ 38#ifdef DEBUG 39 printk("%s: tf: feat 0x%02x nsect 0x%02x lbal 0x%02x " 40 "lbam 0x%02x lbah 0x%02x dev 0x%02x cmd 0x%02x\n", 41 s, tf->feature, tf->nsect, tf->lbal, 42 tf->lbam, tf->lbah, tf->device, tf->command); 43 printk("%s: hob: nsect 0x%02x lbal 0x%02x " 44 "lbam 0x%02x lbah 0x%02x\n", 45 s, tf->hob_nsect, tf->hob_lbal, 46 tf->hob_lbam, tf->hob_lbah); 47#endif 48} 49 50int taskfile_lib_get_identify (ide_drive_t *drive, u8 *buf) 51{ 52 ide_task_t args; 53 54 memset(&args, 0, sizeof(ide_task_t)); 55 args.tf.nsect = 0x01; 56 if (drive->media == ide_disk) 57 args.tf.command = WIN_IDENTIFY; 58 else 59 args.tf.command = WIN_PIDENTIFY; 60 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE; 61 args.data_phase = TASKFILE_IN; 62 return ide_raw_taskfile(drive, &args, buf, 1); 63} 64 65static int inline task_dma_ok(ide_task_t *task) 66{ 67 if (blk_fs_request(task->rq) || (task->tf_flags & IDE_TFLAG_FLAGGED)) 68 return 1; 69 70 switch (task->tf.command) { 71 case WIN_WRITEDMA_ONCE: 72 case WIN_WRITEDMA: 73 case WIN_WRITEDMA_EXT: 74 case WIN_READDMA_ONCE: 75 case WIN_READDMA: 76 case WIN_READDMA_EXT: 77 case WIN_IDENTIFY_DMA: 78 return 1; 79 } 80 81 return 0; 82} 83 84static ide_startstop_t task_no_data_intr(ide_drive_t *); 85static ide_startstop_t set_geometry_intr(ide_drive_t *); 86static ide_startstop_t recal_intr(ide_drive_t *); 87static ide_startstop_t set_multmode_intr(ide_drive_t *); 88static ide_startstop_t pre_task_out_intr(ide_drive_t *, struct request *); 89static ide_startstop_t task_in_intr(ide_drive_t *); 90 91ide_startstop_t do_rw_taskfile (ide_drive_t *drive, ide_task_t *task) 92{ 93 ide_hwif_t *hwif = HWIF(drive); 94 struct ide_taskfile *tf = &task->tf; 95 ide_handler_t *handler = NULL; 96 const struct ide_dma_ops *dma_ops = hwif->dma_ops; 97 98 if (task->data_phase == TASKFILE_MULTI_IN || 99 task->data_phase == TASKFILE_MULTI_OUT) { 100 if (!drive->mult_count) { 101 printk(KERN_ERR "%s: multimode not set!\n", 102 drive->name); 103 return ide_stopped; 104 } 105 } 106 107 if (task->tf_flags & IDE_TFLAG_FLAGGED) 108 task->tf_flags |= IDE_TFLAG_FLAGGED_SET_IN_FLAGS; 109 110 if ((task->tf_flags & IDE_TFLAG_DMA_PIO_FALLBACK) == 0) { 111 ide_tf_dump(drive->name, tf); 112 hwif->tf_load(drive, task); 113 } 114 115 switch (task->data_phase) { 116 case TASKFILE_MULTI_OUT: 117 case TASKFILE_OUT: 118 hwif->OUTBSYNC(drive, tf->command, hwif->io_ports.command_addr); 119 ndelay(400); /* FIXME */ 120 return pre_task_out_intr(drive, task->rq); 121 case TASKFILE_MULTI_IN: 122 case TASKFILE_IN: 123 handler = task_in_intr; 124 /* fall-through */ 125 case TASKFILE_NO_DATA: 126 if (handler == NULL) 127 handler = task_no_data_intr; 128 /* WIN_{SPECIFY,RESTORE,SETMULT} use custom handlers */ 129 if (task->tf_flags & IDE_TFLAG_CUSTOM_HANDLER) { 130 switch (tf->command) { 131 case WIN_SPECIFY: handler = set_geometry_intr; break; 132 case WIN_RESTORE: handler = recal_intr; break; 133 case WIN_SETMULT: handler = set_multmode_intr; break; 134 } 135 } 136 ide_execute_command(drive, tf->command, handler, 137 WAIT_WORSTCASE, NULL); 138 return ide_started; 139 default: 140 if (task_dma_ok(task) == 0 || drive->using_dma == 0 || 141 dma_ops->dma_setup(drive)) 142 return ide_stopped; 143 dma_ops->dma_exec_cmd(drive, tf->command); 144 dma_ops->dma_start(drive); 145 return ide_started; 146 } 147} 148EXPORT_SYMBOL_GPL(do_rw_taskfile); 149 150/* 151 * set_multmode_intr() is invoked on completion of a WIN_SETMULT cmd. 152 */ 153static ide_startstop_t set_multmode_intr(ide_drive_t *drive) 154{ 155 u8 stat = ide_read_status(drive); 156 157 if (OK_STAT(stat, READY_STAT, BAD_STAT)) 158 drive->mult_count = drive->mult_req; 159 else { 160 drive->mult_req = drive->mult_count = 0; 161 drive->special.b.recalibrate = 1; 162 (void) ide_dump_status(drive, "set_multmode", stat); 163 } 164 return ide_stopped; 165} 166 167/* 168 * set_geometry_intr() is invoked on completion of a WIN_SPECIFY cmd. 169 */ 170static ide_startstop_t set_geometry_intr(ide_drive_t *drive) 171{ 172 int retries = 5; 173 u8 stat; 174 175 while (((stat = ide_read_status(drive)) & BUSY_STAT) && retries--) 176 udelay(10); 177 178 if (OK_STAT(stat, READY_STAT, BAD_STAT)) 179 return ide_stopped; 180 181 if (stat & (ERR_STAT|DRQ_STAT)) 182 return ide_error(drive, "set_geometry_intr", stat); 183 184 BUG_ON(HWGROUP(drive)->handler != NULL); 185 ide_set_handler(drive, &set_geometry_intr, WAIT_WORSTCASE, NULL); 186 return ide_started; 187} 188 189/* 190 * recal_intr() is invoked on completion of a WIN_RESTORE (recalibrate) cmd. 191 */ 192static ide_startstop_t recal_intr(ide_drive_t *drive) 193{ 194 u8 stat = ide_read_status(drive); 195 196 if (!OK_STAT(stat, READY_STAT, BAD_STAT)) 197 return ide_error(drive, "recal_intr", stat); 198 return ide_stopped; 199} 200 201/* 202 * Handler for commands without a data phase 203 */ 204static ide_startstop_t task_no_data_intr(ide_drive_t *drive) 205{ 206 ide_task_t *args = HWGROUP(drive)->rq->special; 207 u8 stat; 208 209 local_irq_enable_in_hardirq(); 210 stat = ide_read_status(drive); 211 212 if (!OK_STAT(stat, READY_STAT, BAD_STAT)) 213 return ide_error(drive, "task_no_data_intr", stat); 214 /* calls ide_end_drive_cmd */ 215 216 if (args) 217 ide_end_drive_cmd(drive, stat, ide_read_error(drive)); 218 219 return ide_stopped; 220} 221 222static u8 wait_drive_not_busy(ide_drive_t *drive) 223{ 224 int retries; 225 u8 stat; 226 227 /* 228 * Last sector was transfered, wait until drive is ready. 229 * This can take up to 10 usec, but we will wait max 1 ms. 230 */ 231 for (retries = 0; retries < 100; retries++) { 232 stat = ide_read_status(drive); 233 234 if (stat & BUSY_STAT) 235 udelay(10); 236 else 237 break; 238 } 239 240 if (stat & BUSY_STAT) 241 printk(KERN_ERR "%s: drive still BUSY!\n", drive->name); 242 243 return stat; 244} 245 246static void ide_pio_sector(ide_drive_t *drive, struct request *rq, 247 unsigned int write) 248{ 249 ide_hwif_t *hwif = drive->hwif; 250 struct scatterlist *sg = hwif->sg_table; 251 struct scatterlist *cursg = hwif->cursg; 252 struct page *page; 253#ifdef CONFIG_HIGHMEM 254 unsigned long flags; 255#endif 256 unsigned int offset; 257 u8 *buf; 258 259 cursg = hwif->cursg; 260 if (!cursg) { 261 cursg = sg; 262 hwif->cursg = sg; 263 } 264 265 page = sg_page(cursg); 266 offset = cursg->offset + hwif->cursg_ofs * SECTOR_SIZE; 267 268 /* get the current page and offset */ 269 page = nth_page(page, (offset >> PAGE_SHIFT)); 270 offset %= PAGE_SIZE; 271 272#ifdef CONFIG_HIGHMEM 273 local_irq_save(flags); 274#endif 275 buf = kmap_atomic(page, KM_BIO_SRC_IRQ) + offset; 276 277 hwif->nleft--; 278 hwif->cursg_ofs++; 279 280 if ((hwif->cursg_ofs * SECTOR_SIZE) == cursg->length) { 281 hwif->cursg = sg_next(hwif->cursg); 282 hwif->cursg_ofs = 0; 283 } 284 285 /* do the actual data transfer */ 286 if (write) 287 hwif->output_data(drive, rq, buf, SECTOR_SIZE); 288 else 289 hwif->input_data(drive, rq, buf, SECTOR_SIZE); 290 291 kunmap_atomic(buf, KM_BIO_SRC_IRQ); 292#ifdef CONFIG_HIGHMEM 293 local_irq_restore(flags); 294#endif 295} 296 297static void ide_pio_multi(ide_drive_t *drive, struct request *rq, 298 unsigned int write) 299{ 300 unsigned int nsect; 301 302 nsect = min_t(unsigned int, drive->hwif->nleft, drive->mult_count); 303 while (nsect--) 304 ide_pio_sector(drive, rq, write); 305} 306 307static void ide_pio_datablock(ide_drive_t *drive, struct request *rq, 308 unsigned int write) 309{ 310 u8 saved_io_32bit = drive->io_32bit; 311 312 if (rq->bio) /* fs request */ 313 rq->errors = 0; 314 315 if (rq->cmd_type == REQ_TYPE_ATA_TASKFILE) { 316 ide_task_t *task = rq->special; 317 318 if (task->tf_flags & IDE_TFLAG_IO_16BIT) 319 drive->io_32bit = 0; 320 } 321 322 touch_softlockup_watchdog(); 323 324 switch (drive->hwif->data_phase) { 325 case TASKFILE_MULTI_IN: 326 case TASKFILE_MULTI_OUT: 327 ide_pio_multi(drive, rq, write); 328 break; 329 default: 330 ide_pio_sector(drive, rq, write); 331 break; 332 } 333 334 drive->io_32bit = saved_io_32bit; 335} 336 337static ide_startstop_t task_error(ide_drive_t *drive, struct request *rq, 338 const char *s, u8 stat) 339{ 340 if (rq->bio) { 341 ide_hwif_t *hwif = drive->hwif; 342 int sectors = hwif->nsect - hwif->nleft; 343 344 switch (hwif->data_phase) { 345 case TASKFILE_IN: 346 if (hwif->nleft) 347 break; 348 /* fall through */ 349 case TASKFILE_OUT: 350 sectors--; 351 break; 352 case TASKFILE_MULTI_IN: 353 if (hwif->nleft) 354 break; 355 /* fall through */ 356 case TASKFILE_MULTI_OUT: 357 sectors -= drive->mult_count; 358 default: 359 break; 360 } 361 362 if (sectors > 0) { 363 ide_driver_t *drv; 364 365 drv = *(ide_driver_t **)rq->rq_disk->private_data; 366 drv->end_request(drive, 1, sectors); 367 } 368 } 369 return ide_error(drive, s, stat); 370} 371 372void task_end_request(ide_drive_t *drive, struct request *rq, u8 stat) 373{ 374 if (rq->cmd_type == REQ_TYPE_ATA_TASKFILE) { 375 u8 err = ide_read_error(drive); 376 377 ide_end_drive_cmd(drive, stat, err); 378 return; 379 } 380 381 if (rq->rq_disk) { 382 ide_driver_t *drv; 383 384 drv = *(ide_driver_t **)rq->rq_disk->private_data;; 385 drv->end_request(drive, 1, rq->nr_sectors); 386 } else 387 ide_end_request(drive, 1, rq->nr_sectors); 388} 389 390/* 391 * We got an interrupt on a task_in case, but no errors and no DRQ. 392 * 393 * It might be a spurious irq (shared irq), but it might be a 394 * command that had no output. 395 */ 396static ide_startstop_t task_in_unexpected(ide_drive_t *drive, struct request *rq, u8 stat) 397{ 398 /* Command all done? */ 399 if (OK_STAT(stat, READY_STAT, BUSY_STAT)) { 400 task_end_request(drive, rq, stat); 401 return ide_stopped; 402 } 403 404 /* Assume it was a spurious irq */ 405 ide_set_handler(drive, &task_in_intr, WAIT_WORSTCASE, NULL); 406 return ide_started; 407} 408 409/* 410 * Handler for command with PIO data-in phase (Read/Read Multiple). 411 */ 412static ide_startstop_t task_in_intr(ide_drive_t *drive) 413{ 414 ide_hwif_t *hwif = drive->hwif; 415 struct request *rq = HWGROUP(drive)->rq; 416 u8 stat = ide_read_status(drive); 417 418 /* Error? */ 419 if (stat & ERR_STAT) 420 return task_error(drive, rq, __func__, stat); 421 422 /* Didn't want any data? Odd. */ 423 if (!(stat & DRQ_STAT)) 424 return task_in_unexpected(drive, rq, stat); 425 426 ide_pio_datablock(drive, rq, 0); 427 428 /* Are we done? Check status and finish transfer. */ 429 if (!hwif->nleft) { 430 stat = wait_drive_not_busy(drive); 431 if (!OK_STAT(stat, 0, BAD_STAT)) 432 return task_error(drive, rq, __func__, stat); 433 task_end_request(drive, rq, stat); 434 return ide_stopped; 435 } 436 437 /* Still data left to transfer. */ 438 ide_set_handler(drive, &task_in_intr, WAIT_WORSTCASE, NULL); 439 440 return ide_started; 441} 442 443/* 444 * Handler for command with PIO data-out phase (Write/Write Multiple). 445 */ 446static ide_startstop_t task_out_intr (ide_drive_t *drive) 447{ 448 ide_hwif_t *hwif = drive->hwif; 449 struct request *rq = HWGROUP(drive)->rq; 450 u8 stat = ide_read_status(drive); 451 452 if (!OK_STAT(stat, DRIVE_READY, drive->bad_wstat)) 453 return task_error(drive, rq, __func__, stat); 454 455 /* Deal with unexpected ATA data phase. */ 456 if (((stat & DRQ_STAT) == 0) ^ !hwif->nleft) 457 return task_error(drive, rq, __func__, stat); 458 459 if (!hwif->nleft) { 460 task_end_request(drive, rq, stat); 461 return ide_stopped; 462 } 463 464 /* Still data left to transfer. */ 465 ide_pio_datablock(drive, rq, 1); 466 ide_set_handler(drive, &task_out_intr, WAIT_WORSTCASE, NULL); 467 468 return ide_started; 469} 470 471static ide_startstop_t pre_task_out_intr(ide_drive_t *drive, struct request *rq) 472{ 473 ide_startstop_t startstop; 474 475 if (ide_wait_stat(&startstop, drive, DRQ_STAT, 476 drive->bad_wstat, WAIT_DRQ)) { 477 printk(KERN_ERR "%s: no DRQ after issuing %sWRITE%s\n", 478 drive->name, 479 drive->hwif->data_phase ? "MULT" : "", 480 drive->addressing ? "_EXT" : ""); 481 return startstop; 482 } 483 484 if (!drive->unmask) 485 local_irq_disable(); 486 487 ide_set_handler(drive, &task_out_intr, WAIT_WORSTCASE, NULL); 488 ide_pio_datablock(drive, rq, 1); 489 490 return ide_started; 491} 492 493int ide_raw_taskfile(ide_drive_t *drive, ide_task_t *task, u8 *buf, u16 nsect) 494{ 495 struct request rq; 496 497 memset(&rq, 0, sizeof(rq)); 498 rq.ref_count = 1; 499 rq.cmd_type = REQ_TYPE_ATA_TASKFILE; 500 rq.buffer = buf; 501 502 /* 503 * (ks) We transfer currently only whole sectors. 504 * This is suffient for now. But, it would be great, 505 * if we would find a solution to transfer any size. 506 * To support special commands like READ LONG. 507 */ 508 rq.hard_nr_sectors = rq.nr_sectors = nsect; 509 rq.hard_cur_sectors = rq.current_nr_sectors = nsect; 510 511 if (task->tf_flags & IDE_TFLAG_WRITE) 512 rq.cmd_flags |= REQ_RW; 513 514 rq.special = task; 515 task->rq = &rq; 516 517 return ide_do_drive_cmd(drive, &rq, ide_wait); 518} 519 520EXPORT_SYMBOL(ide_raw_taskfile); 521 522int ide_no_data_taskfile(ide_drive_t *drive, ide_task_t *task) 523{ 524 task->data_phase = TASKFILE_NO_DATA; 525 526 return ide_raw_taskfile(drive, task, NULL, 0); 527} 528EXPORT_SYMBOL_GPL(ide_no_data_taskfile); 529 530#ifdef CONFIG_IDE_TASK_IOCTL 531int ide_taskfile_ioctl (ide_drive_t *drive, unsigned int cmd, unsigned long arg) 532{ 533 ide_task_request_t *req_task; 534 ide_task_t args; 535 u8 *outbuf = NULL; 536 u8 *inbuf = NULL; 537 u8 *data_buf = NULL; 538 int err = 0; 539 int tasksize = sizeof(struct ide_task_request_s); 540 unsigned int taskin = 0; 541 unsigned int taskout = 0; 542 u16 nsect = 0; 543 char __user *buf = (char __user *)arg; 544 545// printk("IDE Taskfile ...\n"); 546 547 req_task = kzalloc(tasksize, GFP_KERNEL); 548 if (req_task == NULL) return -ENOMEM; 549 if (copy_from_user(req_task, buf, tasksize)) { 550 kfree(req_task); 551 return -EFAULT; 552 } 553 554 taskout = req_task->out_size; 555 taskin = req_task->in_size; 556 557 if (taskin > 65536 || taskout > 65536) { 558 err = -EINVAL; 559 goto abort; 560 } 561 562 if (taskout) { 563 int outtotal = tasksize; 564 outbuf = kzalloc(taskout, GFP_KERNEL); 565 if (outbuf == NULL) { 566 err = -ENOMEM; 567 goto abort; 568 } 569 if (copy_from_user(outbuf, buf + outtotal, taskout)) { 570 err = -EFAULT; 571 goto abort; 572 } 573 } 574 575 if (taskin) { 576 int intotal = tasksize + taskout; 577 inbuf = kzalloc(taskin, GFP_KERNEL); 578 if (inbuf == NULL) { 579 err = -ENOMEM; 580 goto abort; 581 } 582 if (copy_from_user(inbuf, buf + intotal, taskin)) { 583 err = -EFAULT; 584 goto abort; 585 } 586 } 587 588 memset(&args, 0, sizeof(ide_task_t)); 589 590 memcpy(&args.tf_array[0], req_task->hob_ports, HDIO_DRIVE_HOB_HDR_SIZE - 2); 591 memcpy(&args.tf_array[6], req_task->io_ports, HDIO_DRIVE_TASK_HDR_SIZE); 592 593 args.data_phase = req_task->data_phase; 594 595 args.tf_flags = IDE_TFLAG_IO_16BIT | IDE_TFLAG_DEVICE | 596 IDE_TFLAG_IN_TF; 597 if (drive->addressing == 1) 598 args.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_IN_HOB); 599 600 if (req_task->out_flags.all) { 601 args.tf_flags |= IDE_TFLAG_FLAGGED; 602 603 if (req_task->out_flags.b.data) 604 args.tf_flags |= IDE_TFLAG_OUT_DATA; 605 606 if (req_task->out_flags.b.nsector_hob) 607 args.tf_flags |= IDE_TFLAG_OUT_HOB_NSECT; 608 if (req_task->out_flags.b.sector_hob) 609 args.tf_flags |= IDE_TFLAG_OUT_HOB_LBAL; 610 if (req_task->out_flags.b.lcyl_hob) 611 args.tf_flags |= IDE_TFLAG_OUT_HOB_LBAM; 612 if (req_task->out_flags.b.hcyl_hob) 613 args.tf_flags |= IDE_TFLAG_OUT_HOB_LBAH; 614 615 if (req_task->out_flags.b.error_feature) 616 args.tf_flags |= IDE_TFLAG_OUT_FEATURE; 617 if (req_task->out_flags.b.nsector) 618 args.tf_flags |= IDE_TFLAG_OUT_NSECT; 619 if (req_task->out_flags.b.sector) 620 args.tf_flags |= IDE_TFLAG_OUT_LBAL; 621 if (req_task->out_flags.b.lcyl) 622 args.tf_flags |= IDE_TFLAG_OUT_LBAM; 623 if (req_task->out_flags.b.hcyl) 624 args.tf_flags |= IDE_TFLAG_OUT_LBAH; 625 } else { 626 args.tf_flags |= IDE_TFLAG_OUT_TF; 627 if (args.tf_flags & IDE_TFLAG_LBA48) 628 args.tf_flags |= IDE_TFLAG_OUT_HOB; 629 } 630 631 if (req_task->in_flags.b.data) 632 args.tf_flags |= IDE_TFLAG_IN_DATA; 633 634 switch(req_task->data_phase) { 635 case TASKFILE_MULTI_OUT: 636 if (!drive->mult_count) { 637 /* (hs): give up if multcount is not set */ 638 printk(KERN_ERR "%s: %s Multimode Write " \ 639 "multcount is not set\n", 640 drive->name, __func__); 641 err = -EPERM; 642 goto abort; 643 } 644 /* fall through */ 645 case TASKFILE_OUT: 646 /* fall through */ 647 case TASKFILE_OUT_DMAQ: 648 case TASKFILE_OUT_DMA: 649 nsect = taskout / SECTOR_SIZE; 650 data_buf = outbuf; 651 break; 652 case TASKFILE_MULTI_IN: 653 if (!drive->mult_count) { 654 /* (hs): give up if multcount is not set */ 655 printk(KERN_ERR "%s: %s Multimode Read failure " \ 656 "multcount is not set\n", 657 drive->name, __func__); 658 err = -EPERM; 659 goto abort; 660 } 661 /* fall through */ 662 case TASKFILE_IN: 663 /* fall through */ 664 case TASKFILE_IN_DMAQ: 665 case TASKFILE_IN_DMA: 666 nsect = taskin / SECTOR_SIZE; 667 data_buf = inbuf; 668 break; 669 case TASKFILE_NO_DATA: 670 break; 671 default: 672 err = -EFAULT; 673 goto abort; 674 } 675 676 if (req_task->req_cmd == IDE_DRIVE_TASK_NO_DATA) 677 nsect = 0; 678 else if (!nsect) { 679 nsect = (args.tf.hob_nsect << 8) | args.tf.nsect; 680 681 if (!nsect) { 682 printk(KERN_ERR "%s: in/out command without data\n", 683 drive->name); 684 err = -EFAULT; 685 goto abort; 686 } 687 } 688 689 if (req_task->req_cmd == IDE_DRIVE_TASK_RAW_WRITE) 690 args.tf_flags |= IDE_TFLAG_WRITE; 691 692 err = ide_raw_taskfile(drive, &args, data_buf, nsect); 693 694 memcpy(req_task->hob_ports, &args.tf_array[0], HDIO_DRIVE_HOB_HDR_SIZE - 2); 695 memcpy(req_task->io_ports, &args.tf_array[6], HDIO_DRIVE_TASK_HDR_SIZE); 696 697 if ((args.tf_flags & IDE_TFLAG_FLAGGED_SET_IN_FLAGS) && 698 req_task->in_flags.all == 0) { 699 req_task->in_flags.all = IDE_TASKFILE_STD_IN_FLAGS; 700 if (drive->addressing == 1) 701 req_task->in_flags.all |= (IDE_HOB_STD_IN_FLAGS << 8); 702 } 703 704 if (copy_to_user(buf, req_task, tasksize)) { 705 err = -EFAULT; 706 goto abort; 707 } 708 if (taskout) { 709 int outtotal = tasksize; 710 if (copy_to_user(buf + outtotal, outbuf, taskout)) { 711 err = -EFAULT; 712 goto abort; 713 } 714 } 715 if (taskin) { 716 int intotal = tasksize + taskout; 717 if (copy_to_user(buf + intotal, inbuf, taskin)) { 718 err = -EFAULT; 719 goto abort; 720 } 721 } 722abort: 723 kfree(req_task); 724 kfree(outbuf); 725 kfree(inbuf); 726 727// printk("IDE Taskfile ioctl ended. rc = %i\n", err); 728 729 return err; 730} 731#endif 732 733int ide_cmd_ioctl (ide_drive_t *drive, unsigned int cmd, unsigned long arg) 734{ 735 u8 *buf = NULL; 736 int bufsize = 0, err = 0; 737 u8 args[4], xfer_rate = 0; 738 ide_task_t tfargs; 739 struct ide_taskfile *tf = &tfargs.tf; 740 struct hd_driveid *id = drive->id; 741 742 if (NULL == (void *) arg) { 743 struct request rq; 744 745 ide_init_drive_cmd(&rq); 746 rq.cmd_type = REQ_TYPE_ATA_TASKFILE; 747 748 return ide_do_drive_cmd(drive, &rq, ide_wait); 749 } 750 751 if (copy_from_user(args, (void __user *)arg, 4)) 752 return -EFAULT; 753 754 memset(&tfargs, 0, sizeof(ide_task_t)); 755 tf->feature = args[2]; 756 if (args[0] == WIN_SMART) { 757 tf->nsect = args[3]; 758 tf->lbal = args[1]; 759 tf->lbam = 0x4f; 760 tf->lbah = 0xc2; 761 tfargs.tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_IN_NSECT; 762 } else { 763 tf->nsect = args[1]; 764 tfargs.tf_flags = IDE_TFLAG_OUT_FEATURE | 765 IDE_TFLAG_OUT_NSECT | IDE_TFLAG_IN_NSECT; 766 } 767 tf->command = args[0]; 768 tfargs.data_phase = args[3] ? TASKFILE_IN : TASKFILE_NO_DATA; 769 770 if (args[3]) { 771 tfargs.tf_flags |= IDE_TFLAG_IO_16BIT; 772 bufsize = SECTOR_WORDS * 4 * args[3]; 773 buf = kzalloc(bufsize, GFP_KERNEL); 774 if (buf == NULL) 775 return -ENOMEM; 776 } 777 778 if (tf->command == WIN_SETFEATURES && 779 tf->feature == SETFEATURES_XFER && 780 tf->nsect >= XFER_SW_DMA_0 && 781 (id->dma_ultra || id->dma_mword || id->dma_1word)) { 782 xfer_rate = args[1]; 783 if (tf->nsect > XFER_UDMA_2 && !eighty_ninty_three(drive)) { 784 printk(KERN_WARNING "%s: UDMA speeds >UDMA33 cannot " 785 "be set\n", drive->name); 786 goto abort; 787 } 788 } 789 790 err = ide_raw_taskfile(drive, &tfargs, buf, args[3]); 791 792 args[0] = tf->status; 793 args[1] = tf->error; 794 args[2] = tf->nsect; 795 796 if (!err && xfer_rate) { 797 /* active-retuning-calls future */ 798 ide_set_xfer_rate(drive, xfer_rate); 799 ide_driveid_update(drive); 800 } 801abort: 802 if (copy_to_user((void __user *)arg, &args, 4)) 803 err = -EFAULT; 804 if (buf) { 805 if (copy_to_user((void __user *)(arg + 4), buf, bufsize)) 806 err = -EFAULT; 807 kfree(buf); 808 } 809 return err; 810} 811 812int ide_task_ioctl (ide_drive_t *drive, unsigned int cmd, unsigned long arg) 813{ 814 void __user *p = (void __user *)arg; 815 int err = 0; 816 u8 args[7]; 817 ide_task_t task; 818 819 if (copy_from_user(args, p, 7)) 820 return -EFAULT; 821 822 memset(&task, 0, sizeof(task)); 823 memcpy(&task.tf_array[7], &args[1], 6); 824 task.tf.command = args[0]; 825 task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE; 826 827 err = ide_no_data_taskfile(drive, &task); 828 829 args[0] = task.tf.command; 830 memcpy(&args[1], &task.tf_array[7], 6); 831 832 if (copy_to_user(p, args, 7)) 833 err = -EFAULT; 834 835 return err; 836} 837