Lines Matching defs:drive
37 * | IRQ-unmask, drive-id, multiple-mode, support for ">16 heads",
247 /* bulk initialize hwif & drive info with zeros */
268 ide_drive_t *drive = &hwif->drives[unit];
270 drive->media = ide_disk;
271 drive->select.all = (unit<<4)|0xa0;
272 drive->hwif = hwif;
273 drive->ctl = 0x08;
274 drive->ready_stat = READY_STAT;
275 drive->bad_wstat = BAD_W_STAT;
276 drive->special.b.recalibrate = 1;
277 drive->special.b.set_geometry = 1;
278 drive->name[0] = 'h';
279 drive->name[1] = 'd';
280 drive->name[2] = 'a' + (index * MAX_DRIVES) + unit;
281 drive->max_failures = IDE_DEFAULT_MAX_FAILURES;
282 init_waitqueue_head(&drive->wqueue);
321 int drive_is_flashcard (ide_drive_t *drive)
323 struct hd_driveid *id = drive->id;
325 if (drive->removable && id != NULL) {
382 void ide_input_data (ide_drive_t *drive, void *buffer, unsigned int wcount)
390 if(HWIF(drive)->ideproc) {
391 HWIF(drive)->ideproc(ideproc_ide_input_data,
392 drive, buffer, wcount);
396 io_32bit = drive->io_32bit;
412 if (drive->slow) {
427 void ide_output_data (ide_drive_t *drive, void *buffer, unsigned int wcount)
431 if(HWIF(drive)->ideproc) {
432 HWIF(drive)->ideproc(ideproc_ide_output_data,
433 drive, buffer, wcount);
437 io_32bit = drive->io_32bit;
453 if (drive->slow) {
472 void atapi_input_bytes (ide_drive_t *drive, void *buffer, unsigned int bytecount)
474 if(HWIF(drive)->ideproc) {
475 HWIF(drive)->ideproc(ideproc_atapi_input_bytes,
476 drive, buffer, bytecount);
488 ide_input_data (drive, buffer, bytecount / 4);
493 void atapi_output_bytes (ide_drive_t *drive, void *buffer, unsigned int bytecount)
495 if(HWIF(drive)->ideproc) {
496 HWIF(drive)->ideproc(ideproc_atapi_output_bytes,
497 drive, buffer, bytecount);
509 ide_output_data (drive, buffer, bytecount / 4);
518 int drive_is_ready (ide_drive_t *drive)
521 if (drive->waiting_for_dma)
522 return HWIF(drive)->dmaproc(ide_dma_test_irq, drive);
538 return 0; /* drive busy: definitely not interrupting */
539 return 1; /* drive ready: *might* be interrupting */
549 ide_drive_t *drive = hwgroup->drive;
558 if (drive->state == DMA_PIO_RETRY && drive->retry_pio <= 3) {
559 drive->state = 0;
560 hwgroup->hwif->dmaproc(ide_dma_on, drive);
563 if (!end_that_request_first(rq, uptodate, hwgroup->drive->name)) {
574 * wait for an interrupt response from a drive. handler() points
579 void ide_set_handler (ide_drive_t *drive, ide_handler_t *handler,
583 ide_hwgroup_t *hwgroup = HWGROUP(drive);
588 drive->name, hwgroup->handler, handler);
598 * current_capacity() returns the capacity (in sectors) of a drive
601 unsigned long current_capacity (ide_drive_t *drive)
603 if (!drive->present)
605 if (drive->driver != NULL)
606 return DRIVER(drive)->capacity(drive);
620 ide_drive_t *drive = &hwif->drives[unit];
622 if (!drive->present)
624 if (drive->media!=ide_disk && drive->media!=ide_floppy)
628 (drive->forced_geom && drive->noprobe) ? 1 :
631 current_capacity(drive));
639 * during an atapi drive reset operation. If the drive has not yet responded,
643 static ide_startstop_t atapi_reset_pollfunc (ide_drive_t *drive)
645 ide_hwgroup_t *hwgroup = HWGROUP(drive);
648 SELECT_DRIVE(HWIF(drive),drive);
652 printk("%s: ATAPI reset complete\n", drive->name);
655 ide_set_handler (drive, &atapi_reset_pollfunc, HZ/20, NULL);
659 printk("%s: ATAPI reset timed-out, status=0x%02x\n", drive->name, stat);
660 return do_reset1 (drive, 1); /* do it the old fashioned way */
672 static ide_startstop_t reset_pollfunc (ide_drive_t *drive)
674 ide_hwgroup_t *hwgroup = HWGROUP(drive);
675 ide_hwif_t *hwif = HWIF(drive);
680 ide_set_handler (drive, &reset_pollfunc, HZ/20, NULL);
684 drive->failures++;
689 drive->failures = 0;
691 drive->failures++;
719 static void check_dma_crc (ide_drive_t *drive)
721 if (drive->crc_count) {
722 (void) HWIF(drive)->dmaproc(ide_dma_off_quietly, drive);
723 if ((HWIF(drive)->speedproc) != NULL)
724 HWIF(drive)->speedproc(drive, ide_auto_reduce_xfer(drive));
725 if (drive->current_speed >= XFER_SW_DMA_0)
726 (void) HWIF(drive)->dmaproc(ide_dma_on, drive);
728 (void) HWIF(drive)->dmaproc(ide_dma_off, drive);
732 static void pre_reset (ide_drive_t *drive)
734 if (drive->driver != NULL)
735 DRIVER(drive)->pre_reset(drive);
737 if (!drive->keep_settings) {
738 if (drive->using_dma) {
739 check_dma_crc(drive);
741 drive->unmask = 0;
742 drive->io_32bit = 0;
746 if (drive->using_dma)
747 check_dma_crc(drive);
751 * do_reset1() attempts to recover a confused drive by resetting it.
752 * Unfortunately, resetting a disk drive actually resets all devices on
754 * interface rather than resetting the drive.
765 static ide_startstop_t do_reset1 (ide_drive_t *drive, int do_not_try_atapi)
769 ide_hwif_t *hwif = HWIF(drive);
770 ide_hwgroup_t *hwgroup = HWGROUP(drive);
776 if (drive->media != ide_disk && !do_not_try_atapi) {
777 pre_reset(drive);
778 SELECT_DRIVE(hwif,drive);
782 ide_set_handler (drive, &atapi_reset_pollfunc, HZ/20, NULL);
807 OUT_BYTE(drive->ctl|6,IDE_CONTROL_REG); /* set SRST and nIEN */
809 if (drive->quirk_list == 2) {
810 OUT_BYTE(drive->ctl,IDE_CONTROL_REG); /* clear SRST and nIEN */
812 OUT_BYTE(drive->ctl|2,IDE_CONTROL_REG); /* clear SRST, leave nIEN */
816 ide_set_handler (drive, &reset_pollfunc, HZ/20, NULL);
824 hwif->resetproc(drive);
833 * ide_do_reset() is the entry point to the drive/interface reset code.
835 ide_startstop_t ide_do_reset (ide_drive_t *drive)
837 return do_reset1 (drive, 0);
840 static inline u32 read_24 (ide_drive_t *drive)
848 * Clean up after success/failure of an explicit drive cmd
850 void ide_end_drive_cmd (ide_drive_t *drive, byte stat, byte err)
856 rq = HWGROUP(drive)->rq;
904 if ((drive->id->command_set_2 & 0x0400) &&
905 (drive->id->cfs_enable_2 & 0x0400) &&
906 (drive->addressing == 1)) {
907 OUT_BYTE(drive->ctl|0x80, IDE_CONTROL_REG_HOB);
922 HWGROUP(drive)->rq = NULL;
930 byte ide_dump_status (ide_drive_t *drive, const char *msg, byte stat)
937 printk("%s: %s: status=0x%02x", drive->name, msg, stat);
956 printk("%s: %s: error=0x%02x", drive->name, msg, err);
958 if (drive->media == ide_disk) {
968 if ((drive->id->command_set_2 & 0x0400) &&
969 (drive->id->cfs_enable_2 & 0x0400) &&
970 (drive->addressing == 1)) {
973 low = read_24(drive);
974 OUT_BYTE(drive->ctl|0x80, IDE_CONTROL_REG);
975 high = read_24(drive);
997 if (HWGROUP(drive) && HWGROUP(drive)->rq)
998 printk(", sector=%ld", HWGROUP(drive)->rq->sector);
1009 * try_to_flush_leftover_data() is invoked in response to a drive
1011 * resetting the drive, this routine tries to clear the condition
1012 * by read a sector's worth of data from the drive. Of course,
1013 * this may not help if the drive is *waiting* for data from *us*.
1015 static void try_to_flush_leftover_data (ide_drive_t *drive)
1017 int i = (drive->mult_count ? drive->mult_count : 1) * SECTOR_WORDS;
1019 if (drive->media != ide_disk)
1025 ide_input_data (drive, buffer, wcount);
1030 * ide_error() takes action based on the error returned by the drive.
1032 ide_startstop_t ide_error (ide_drive_t *drive, const char *msg, byte stat)
1037 err = ide_dump_status(drive, msg, stat);
1038 if (drive == NULL || (rq = HWGROUP(drive)->rq) == NULL)
1043 ide_end_drive_cmd(drive, stat, err);
1048 ide_end_drive_cmd(drive, stat, err);
1049 // ide_end_taskfile(drive, stat, err);
1053 if (stat & BUSY_STAT || ((stat & WRERR_STAT) && !drive->nowerr)) { /* other bits are useless when BUSY */
1056 if (drive->media == ide_disk && (stat & ERR_STAT)) {
1059 if (drive->select.b.lba && IN_BYTE(IDE_COMMAND_REG) == WIN_SPECIFY)
1062 drive->crc_count++; /* UDMA crc error -- just retry the operation */
1069 try_to_flush_leftover_data(drive);
1075 if (drive->driver != NULL)
1076 DRIVER(drive)->end_request(0, HWGROUP(drive));
1078 ide_end_request(0, HWGROUP(drive));
1082 return ide_do_reset(drive);
1085 drive->special.b.recalibrate = 1;
1092 * Issue a simple drive command
1093 * The drive must be selected beforehand.
1095 void ide_cmd (ide_drive_t *drive, byte cmd, byte nsect, ide_handler_t *handler)
1097 ide_set_handler (drive, handler, WAIT_CMD, NULL);
1099 OUT_BYTE(drive->ctl,IDE_CONTROL_REG); /* clear nIEN */
1100 SELECT_MASK(HWIF(drive),drive,0);
1108 static ide_startstop_t drive_cmd_intr (ide_drive_t *drive)
1110 struct request *rq = HWGROUP(drive)->rq;
1117 byte io_32bit = drive->io_32bit;
1118 drive->io_32bit = 0;
1119 ide_input_data(drive, &args[4], args[3] * SECTOR_WORDS);
1120 drive->io_32bit = io_32bit;
1126 return ide_error(drive, "drive_cmd", stat); /* calls ide_end_drive_cmd */
1127 ide_end_drive_cmd (drive, stat, GET_ERR());
1133 * commands to a drive. It used to do much more, but has been scaled back.
1135 static ide_startstop_t do_special (ide_drive_t *drive)
1137 special_t *s = &drive->special;
1140 printk("%s: do_special: 0x%02x\n", drive->name, s->all);
1143 ide_tuneproc_t *tuneproc = HWIF(drive)->tuneproc;
1146 tuneproc(drive, drive->tune_req);
1147 } else if (drive->driver != NULL) {
1148 return DRIVER(drive)->special(drive);
1150 printk("%s: bad special flag: 0x%02x\n", drive->name, s->all);
1157 * This routine busy-waits for the drive status to be not "busy".
1167 int ide_wait_stat (ide_startstop_t *startstop, ide_drive_t *drive, byte good, byte bad, unsigned long timeout) {
1173 if (drive->max_failures && (drive->failures > drive->max_failures)) {
1178 udelay(1); /* spec allows drive 400ns to assert "BUSY" */
1186 *startstop = ide_error(drive, "status timeout", stat);
1204 *startstop = ide_error(drive, "status error", stat);
1209 * execute_drive_cmd() issues a special drive command,
1212 static ide_startstop_t execute_drive_cmd (ide_drive_t *drive, struct request *rq)
1223 printk(KERN_INFO "%s: ", drive->name);
1232 printk(KERN_INFO "%s: ", drive->name);
1245 do_taskfile(drive,
1250 // return flagged_taskfile(drive, args);
1256 return args->prehandler(drive, rq);
1266 printk("%s: DRIVE_TASK_CMD ", drive->name);
1280 if (drive->select.b.unit)
1283 ide_cmd(drive, args[0], args[2], &drive_cmd_intr);
1292 printk("%s: DRIVE_CMD ", drive->name);
1303 ide_cmd(drive, args[0], args[3], &drive_cmd_intr);
1307 ide_cmd(drive, args[0], args[1], &drive_cmd_intr);
1318 printk("%s: DRIVE_CMD (null)\n", drive->name);
1320 ide_end_drive_cmd(drive, GET_STAT(), GET_ERR());
1329 static ide_startstop_t start_request (ide_drive_t *drive, struct request *rq)
1334 ide_hwif_t *hwif = HWIF(drive);
1340 if (drive->max_failures && (drive->failures > drive->max_failures)) {
1350 printk("%s: block not locked\n", drive->name);
1358 (drive->media == ide_disk || drive->media == ide_floppy)) {
1359 if ((blockend < block) || (blockend > drive->part[minor&PARTN_MASK].nr_sects)) {
1360 printk("%s%c: bad access: block=%ld, count=%ld\n", drive->name,
1364 block += drive->part[minor&PARTN_MASK].start_sect + drive->sect0;
1368 if (block == 0 && drive->remap_0_to_1 == 1)
1375 SELECT_DRIVE(hwif, drive);
1376 if (ide_wait_stat(&startstop, drive, drive->ready_stat, BUSY_STAT|DRQ_STAT, WAIT_READY)) {
1377 printk("%s: drive not ready for command\n", drive->name);
1380 if (!drive->special.all) {
1385 return execute_drive_cmd(drive, rq);
1389 if (drive->driver != NULL) {
1390 return (DRIVER(drive)->do_request(drive, rq, block));
1392 printk("%s: media type %d not supported\n", drive->name, drive->media);
1395 return do_special(drive);
1397 if (drive->driver != NULL)
1398 DRIVER(drive)->end_request(0, HWGROUP(drive));
1400 ide_end_request(0, HWGROUP(drive));
1404 ide_startstop_t restart_request (ide_drive_t *drive)
1406 ide_hwgroup_t *hwgroup = HWGROUP(drive);
1416 return start_request(drive, rq);
1420 * ide_stall_queue() can be used by a drive to give excess bandwidth back
1423 void ide_stall_queue (ide_drive_t *drive, unsigned long timeout)
1427 drive->sleep = timeout + jiffies;
1430 #define WAKEUP(drive) ((drive)->service_start + 2 * (drive)->service_time)
1433 * choose_drive() selects the next drive which will be serviced.
1437 ide_drive_t *drive, *best;
1441 drive = hwgroup->drive;
1443 if (!list_empty(&drive->queue.queue_head) && (!drive->sleep || 0 <= (signed long)(jiffies - drive->sleep))) {
1445 || (drive->sleep && (!best->sleep || 0 < (signed long)(best->sleep - drive->sleep)))
1446 || (!best->sleep && 0 < (signed long)(WAKEUP(best) - WAKEUP(drive))))
1448 if( !drive->queue.plugged )
1449 best = drive;
1452 } while ((drive = drive->next) != hwgroup->drive);
1453 if (best && best->nice1 && !best->sleep && best != hwgroup->drive && best->service_time > WAIT_MIN_SLEEP) {
1460 drive = best->next;
1462 if (!drive->sleep
1463 && 0 < (signed long)(WAKEUP(drive) - (jiffies - best->service_time))
1464 && 0 < (signed long)((jiffies + t) - WAKEUP(drive)))
1469 } while ((drive = drive->next) != best);
1476 * Issue a new request to a drive from hwgroup
1515 ide_drive_t *drive;
1526 drive = choose_drive(hwgroup);
1527 if (drive == NULL) {
1530 drive = hwgroup->drive;
1532 if (drive->sleep && (!sleep || 0 < (signed long)(sleep - drive->sleep)))
1533 sleep = drive->sleep;
1534 } while ((drive = drive->next) != hwgroup->drive);
1556 hwif = HWIF(drive);
1559 SELECT_INTERRUPT(hwif, drive);
1562 hwgroup->drive = drive;
1563 drive->sleep = 0;
1564 drive->service_start = jiffies;
1566 if ( drive->queue.plugged ) /* paranoia */
1567 printk("%s: Huh? nuking plugged queue\n", drive->name);
1569 rq = hwgroup->rq = blkdev_entry_next_request(&drive->queue.queue_head);
1582 startstop = start_request(drive, rq);
1614 void ide_dma_timeout_retry(ide_drive_t *drive)
1616 ide_hwif_t *hwif = HWIF(drive);
1622 (void) hwif->dmaproc(ide_dma_end, drive);
1627 printk("%s: timeout waiting for DMA\n", drive->name);
1628 (void) hwif->dmaproc(ide_dma_timeout, drive);
1635 drive->retry_pio++;
1636 drive->state = DMA_PIO_RETRY;
1637 (void) hwif->dmaproc(ide_dma_off_quietly, drive);
1640 * un-busy drive etc (hwgroup->busy is cleared on return) and
1643 rq = HWGROUP(drive)->rq;
1644 HWGROUP(drive)->rq = NULL;
1653 * ide_timer_expiry() is our timeout function for all drive operations.
1680 ide_drive_t *drive = hwgroup->drive;
1681 if (!drive) {
1682 printk("ide_timer_expiry: hwgroup->drive was NULL\n");
1689 printk("%s: ide_timer_expiry: hwgroup->busy was 0 ??\n", drive->name);
1693 if ((wait = expiry(drive)) != 0) {
1708 hwif = HWIF(drive);
1716 startstop = handler(drive);
1717 } else if (drive_is_ready(drive)) {
1718 if (drive->waiting_for_dma)
1719 (void) hwgroup->hwif->dmaproc(ide_dma_lostirq, drive);
1721 printk("%s: lost interrupt\n", drive->name);
1722 startstop = handler(drive);
1724 if (drive->waiting_for_dma) {
1726 ide_dma_timeout_retry(drive);
1728 startstop = ide_error(drive, "irq timeout", GET_STAT());
1731 drive->service_time = jiffies - drive->service_start;
1749 * drive enters "idle", "standby", or "sleep" mode, so if the status looks
1759 * drive is ready to accept one, in which case we know the drive is not
1761 * completing the issuance of any new drive command, so we will not be
1798 ide_drive_t *drive;
1812 * Not expecting an interrupt from this drive.
1816 * or (2) a drive just entered sleep or standby mode,
1843 drive = hwgroup->drive;
1844 if (!drive) {
1851 if (!drive_is_ready(drive)) {
1863 printk("%s: ide_intr: hwgroup->busy was 0 ??\n", drive->name);
1869 if (drive->unmask)
1871 startstop = handler(drive); /* service this interrupt, may set handler for next interrupt */
1881 set_recovery_timer(HWIF(drive));
1882 drive->service_time = jiffies - drive->service_start;
1888 printk("%s: ide_intr: huh? expected NULL handler on exit\n", drive->name);
1908 ide_drive_t *drive = &hwif->drives[unit];
1909 if (drive->present)
1910 return drive;
1952 int ide_do_drive_cmd (ide_drive_t *drive, struct request *rq, ide_action_t action)
1955 ide_hwgroup_t *hwgroup = HWGROUP(drive);
1956 unsigned int major = HWIF(drive)->major;
1957 struct list_head *queue_head = &drive->queue.queue_head;
1961 if (HWIF(drive)->chipset == ide_pdc4030 && rq->buffer != NULL)
1962 return -ENOSYS; /* special drive cmds not supported */
1966 rq->rq_dev = MKDEV(major,(drive->select.b.unit)<<PARTN_BITS);
2000 ide_drive_t *drive;
2005 if ((drive = get_info_ptr(i_rdev)) == NULL)
2008 minor = drive->select.b.unit << PARTN_BITS;
2009 hwgroup = HWGROUP(drive);
2011 if (drive->busy || (drive->usage > 1)) {
2015 drive->busy = 1;
2020 if (drive->part[p].nr_sects > 0) {
2024 drive->part[p].start_sect = 0;
2025 drive->part[p].nr_sects = 0;
2028 if (DRIVER(drive)->revalidate)
2029 DRIVER(drive)->revalidate(drive);
2031 drive->busy = 0;
2032 wake_up(&drive->wqueue);
2040 ide_drive_t *drive;
2046 drive = &ide_hwifs[index].drives[unit];
2047 if (drive->revalidate) {
2048 drive->revalidate = 0;
2087 ide_drive_t *drive;
2089 if ((drive = get_info_ptr(inode->i_rdev)) == NULL)
2091 if (drive->driver == NULL)
2094 if (drive->driver == NULL) {
2095 if (drive->media == ide_disk)
2097 if (drive->media == ide_cdrom)
2099 if (drive->media == ide_tape)
2101 if (drive->media == ide_floppy)
2104 if (drive->media == ide_scsi)
2109 while (drive->busy)
2110 sleep_on(&drive->wqueue);
2111 drive->usage++;
2112 if (drive->driver != NULL)
2113 return DRIVER(drive)->open(inode, filp, drive);
2114 printk ("%s: driver not present\n", drive->name);
2115 drive->usage--;
2125 ide_drive_t *drive;
2127 if ((drive = get_info_ptr(inode->i_rdev)) != NULL) {
2128 drive->usage--;
2129 if (drive->driver != NULL)
2130 DRIVER(drive)->release(inode, file, drive);
2135 int ide_replace_subdriver (ide_drive_t *drive, const char *driver)
2137 if (!drive->present || drive->busy || drive->usage)
2139 if (drive->driver != NULL && DRIVER(drive)->cleanup(drive))
2141 strncpy(drive->driver_req, driver, 9);
2143 drive->driver_req[0] = 0;
2145 if (DRIVER(drive) && !strcmp(DRIVER(drive)->name, driver))
2197 ide_drive_t *drive, *d;
2213 drive = &hwif->drives[unit];
2214 if (!drive->present)
2216 if (drive->busy || drive->usage)
2218 if (drive->driver != NULL && DRIVER(drive)->cleanup(drive))
2228 drive = &hwif->drives[unit];
2229 if (!drive->present)
2231 minor = drive->select.b.unit << PARTN_BITS;
2233 if (drive->part[p].nr_sects > 0) {
2268 d = hwgroup->drive;
2270 drive = &hwif->drives[i];
2271 if (drive->de) {
2272 devfs_unregister (drive->de);
2273 drive->de = NULL;
2275 if (!drive->present)
2277 while (hwgroup->drive->next != drive)
2278 hwgroup->drive = hwgroup->drive->next;
2279 hwgroup->drive->next = drive->next;
2280 if (hwgroup->drive == drive)
2281 hwgroup->drive = NULL;
2282 if (drive->id != NULL) {
2283 kfree(drive->id);
2284 drive->id = NULL;
2286 drive->present = 0;
2287 blk_cleanup_queue(&drive->queue);
2290 hwgroup->drive = d;
2297 hwgroup->hwif = HWIF(hwgroup->drive);
2463 void ide_add_setting (ide_drive_t *drive, const char *name, int rw, int read_ioctl, int write_ioctl, int data_type, int min, int max, int mul_factor, int div_factor, void *data, ide_procset_t *set)
2465 ide_settings_t **p = (ide_settings_t **) &drive->settings, *setting = NULL;
2480 if (drive->driver)
2489 void ide_remove_setting (ide_drive_t *drive, char *name)
2491 ide_settings_t **p = (ide_settings_t **) &drive->settings, *setting;
2502 static ide_settings_t *ide_find_setting_by_ioctl (ide_drive_t *drive, int cmd)
2504 ide_settings_t *setting = drive->settings;
2514 ide_settings_t *ide_find_setting_by_name (ide_drive_t *drive, char *name)
2516 ide_settings_t *setting = drive->settings;
2526 static void auto_remove_settings (ide_drive_t *drive)
2530 setting = drive->settings;
2533 ide_remove_setting(drive, setting->name);
2540 int ide_read_setting (ide_drive_t *drive, ide_settings_t *setting)
2564 int ide_spin_wait_hwgroup (ide_drive_t *drive)
2566 ide_hwgroup_t *hwgroup = HWGROUP(drive);
2578 printk("%s: channel busy\n", drive->name);
2587 int ide_write_setting (ide_drive_t *drive, ide_settings_t *setting, int val)
2599 return setting->set(drive, val);
2600 if (ide_spin_wait_hwgroup(drive))
2622 static int set_io_32bit(ide_drive_t *drive, int arg)
2624 drive->io_32bit = arg;
2626 if (HWIF(drive)->chipset == ide_dtc2278)
2627 HWIF(drive)->drives[!drive->select.b.unit].io_32bit = arg;
2632 static int set_using_dma (ide_drive_t *drive, int arg)
2634 if (!drive->driver || !DRIVER(drive)->supports_dma)
2636 if (!drive->id || !(drive->id->capability & 1) || !HWIF(drive)->dmaproc)
2638 if (HWIF(drive)->dmaproc(arg ? ide_dma_on : ide_dma_off, drive))
2643 static int set_pio_mode (ide_drive_t *drive, int arg)
2647 if (!HWIF(drive)->tuneproc)
2649 if (drive->special.b.set_tune)
2652 drive->tune_req = (byte) arg;
2653 drive->special.b.set_tune = 1;
2654 (void) ide_do_drive_cmd (drive, &rq, ide_wait);
2658 void ide_add_generic_settings (ide_drive_t *drive)
2661 * drive setting name read/write access read ioctl write ioctl data type min max mul_factor div_factor data pointer set function
2663 ide_add_setting(drive, "io_32bit", drive->no_io_32bit ? SETTING_READ : SETTING_RW, HDIO_GET_32BIT, HDIO_SET_32BIT, TYPE_BYTE, 0, 1 + (SUPPORT_VLB_SYNC << 1), 1, 1, &drive->io_32bit, set_io_32bit);
2664 ide_add_setting(drive, "keepsettings", SETTING_RW, HDIO_GET_KEEPSETTINGS, HDIO_SET_KEEPSETTINGS, TYPE_BYTE, 0, 1, 1, 1, &drive->keep_settings, NULL);
2665 ide_add_setting(drive, "nice1", SETTING_RW, -1, -1, TYPE_BYTE, 0, 1, 1, 1, &drive->nice1, NULL);
2666 ide_add_setting(drive, "pio_mode", SETTING_WRITE, -1, HDIO_SET_PIO_MODE, TYPE_BYTE, 0, 255, 1, 1, NULL, set_pio_mode);
2667 ide_add_setting(drive, "slow", SETTING_RW, -1, -1, TYPE_BYTE, 0, 1, 1, 1, &drive->slow, NULL);
2668 ide_add_setting(drive, "unmaskirq", drive->no_unmask ? SETTING_READ : SETTING_RW, HDIO_GET_UNMASKINTR, HDIO_SET_UNMASKINTR, TYPE_BYTE, 0, 1, 1, 1, &drive->unmask, NULL);
2669 ide_add_setting(drive, "using_dma", SETTING_RW, HDIO_GET_DMA, HDIO_SET_DMA, TYPE_BYTE, 0, 1, 1, 1, &drive->using_dma, set_using_dma);
2670 ide_add_setting(drive, "ide_scsi", SETTING_RW, -1, -1, TYPE_BYTE, 0, 1, 1, 1, &drive->scsi, NULL);
2671 ide_add_setting(drive, "init_speed", SETTING_RW, -1, -1, TYPE_BYTE, 0, 69, 1, 1, &drive->init_speed, NULL);
2672 ide_add_setting(drive, "current_speed", SETTING_RW, -1, -1, TYPE_BYTE, 0, 69, 1, 1, &drive->current_speed, NULL);
2673 ide_add_setting(drive, "number", SETTING_RW, -1, -1, TYPE_BYTE, 0, 3, 1, 1, &drive->dn, NULL);
2676 int ide_wait_cmd (ide_drive_t *drive, int cmd, int nsect, int feature, int sectors, byte *buf)
2690 return ide_do_drive_cmd(drive, &rq, ide_wait);
2693 int ide_wait_cmd_task (ide_drive_t *drive, byte *buf)
2700 return ide_do_drive_cmd(drive, &rq, ide_wait);
2726 int ide_reinit_drive (ide_drive_t *drive)
2728 switch (drive->media) {
2732 extern int ide_cdrom_reinit(ide_drive_t *drive);
2733 if (ide_cdrom_reinit(drive))
2741 extern int idedisk_reinit(ide_drive_t *drive);
2742 if (idedisk_reinit(drive))
2750 extern int idefloppy_reinit(ide_drive_t *drive);
2751 if (idefloppy_reinit(drive))
2759 extern int idetape_reinit(ide_drive_t *drive);
2760 if (idetape_reinit(drive))
2768 * extern int idescsi_reinit(ide_drive_t *drive);
2769 * if (idescsi_reinit(drive))
2785 ide_drive_t *drive;
2793 if ((drive = get_info_ptr(inode->i_rdev)) == NULL)
2796 if ((setting = ide_find_setting_by_ioctl(drive, cmd)) != NULL) {
2798 err = ide_read_setting(drive, setting);
2803 return ide_write_setting(drive, setting, arg);
2812 unsigned short bios_cyl = drive->bios_cyl; /* truncate */
2813 if (!loc || (drive->media != ide_disk && drive->media != ide_floppy)) return -EINVAL;
2814 if (put_user(drive->bios_head, (byte *) &loc->heads)) return -EFAULT;
2815 if (put_user(drive->bios_sect, (byte *) &loc->sectors)) return -EFAULT;
2817 if (put_user((unsigned)drive->part[MINOR(inode->i_rdev)&PARTN_MASK].start_sect,
2825 if (!loc || (drive->media != ide_disk && drive->media != ide_floppy)) return -EINVAL;
2826 if (put_user(drive->bios_head, (byte *) &loc->heads)) return -EFAULT;
2827 if (put_user(drive->bios_sect, (byte *) &loc->sectors)) return -EFAULT;
2828 if (put_user(drive->bios_cyl, (unsigned int *) &loc->cylinders)) return -EFAULT;
2829 if (put_user((unsigned)drive->part[MINOR(inode->i_rdev)&PARTN_MASK].start_sect,
2837 if (!loc || (drive->media != ide_disk && drive->media != ide_floppy)) return -EINVAL;
2838 if (put_user(drive->head, (byte *) &loc->heads)) return -EFAULT;
2839 if (put_user(drive->sect, (byte *) &loc->sectors)) return -EFAULT;
2840 if (put_user(drive->cyl, (unsigned int *) &loc->cylinders)) return -EFAULT;
2841 if (put_user((unsigned)drive->part[MINOR(inode->i_rdev)&PARTN_MASK].start_sect,
2847 return put_user(drive->part[MINOR(inode->i_rdev)&PARTN_MASK].nr_sects, (unsigned long *) arg);
2849 return put_user((u64)drive->part[MINOR(inode->i_rdev)&PARTN_MASK].nr_sects << 9, (u64 *) arg);
2859 if (drive->id == NULL)
2861 if (copy_to_user((char *)arg, (char *)drive->id, (cmd == HDIO_GET_IDENTITY) ? sizeof(*drive->id) : 142))
2866 return put_user(drive->dsc_overlap << IDE_NICE_DSC_OVERLAP |
2867 drive->atapi_overlap << IDE_NICE_ATAPI_OVERLAP |
2868 drive->nice0 << IDE_NICE_0 |
2869 drive->nice1 << IDE_NICE_1 |
2870 drive->nice2 << IDE_NICE_2,
2877 switch(drive->media) {
2879 return ide_taskfile_ioctl(drive, inode, file, cmd, arg);
2884 return pkt_taskfile_ioctl(drive, inode, file, cmd, arg);
2901 return ide_do_drive_cmd(drive, &rq, ide_wait);
2921 if (set_transfer(drive, &tfargs)) {
2923 if (ide_ata66_check(drive, &tfargs))
2927 err = ide_wait_cmd(drive, args[0], args[1], args[2], args[3], argbuf);
2931 if ((HWIF(drive)->speedproc) != NULL)
2932 HWIF(drive)->speedproc(drive, xfer_rate);
2933 ide_driveid_update(drive);
2949 err = ide_wait_cmd_task(drive, argbuf);
2971 if (drive->driver == NULL)
2975 drive->dsc_overlap = (arg >> IDE_NICE_DSC_OVERLAP) & 1;
2976 if (drive->dsc_overlap && !DRIVER(drive)->supports_dsc_overlap) {
2977 drive->dsc_overlap = 0;
2980 drive->nice1 = (arg >> IDE_NICE_1) & 1;
2985 ide_hwgroup_t *hwgroup = HWGROUP(drive);
2990 printk("%s: ide_set_handler: handler not null; %p\n", drive->name, hwgroup->handler);
2991 (void) hwgroup->handler(drive);
2999 (void) ide_do_reset(drive);
3000 if (drive->suspend_reset) {
3008 * HWIF(drive)->multiproc(drive);
3028 if (put_user(HWIF(drive)->bus_state, (long *)arg))
3035 if (HWIF(drive)->busproc)
3036 HWIF(drive)->busproc(drive, (int)arg);
3040 if (drive->driver != NULL)
3041 return DRIVER(drive)->ioctl(drive, inode, file, cmd, arg);
3048 ide_drive_t *drive;
3050 if ((drive = get_info_ptr(i_rdev)) == NULL)
3052 if (drive->driver != NULL)
3053 return DRIVER(drive)->media_change(drive);
3156 * "hdx=noprobe" : drive may be present, but do not probe for it
3157 * "hdx=none" : drive is NOT present, ignore cmos and do not probe
3158 * "hdx=nowerr" : ignore the WRERR_STAT bit on this drive
3159 * "hdx=cdrom" : drive is present, and is a cdrom drive
3160 * "hdx=cyl,head,sect" : disk drive is present, with specified geometry
3164 * if possible for this drive only.
3172 * "hdx=swapdata" : when the drive is a disk, byte swap all data
3174 * "hdxlun=xx" : set the drive last logical unit.
3232 ide_drive_t *drive;
3274 * Look for drive options: "hdx="
3285 drive = &hwif->drives[unit];
3287 strncpy(drive->driver_req, s + 4, 9);
3297 drive->last_lun = vals[0];
3298 drive->forced_lun = 1;
3305 drive->nobios = 1; /* drop into "noprobe" */
3307 drive->noprobe = 1;
3310 drive->bad_wstat = BAD_R_STAT;
3314 drive->present = 1;
3315 drive->media = ide_cdrom;
3322 drive->autotune = 1;
3325 drive->autotune = 2;
3328 drive->slow = 1;
3332 drive->bswap = 1;
3335 drive->ata_flash = 1;
3338 drive->remap_0_to_1 = 1;
3341 drive->remap_0_to_1 = 2;
3345 drive->scsi = 1;
3348 drive->scsi = 0;
3352 drive->media = ide_disk;
3353 drive->cyl = drive->bios_cyl = vals[0];
3354 drive->head = drive->bios_head = vals[1];
3355 drive->sect = drive->bios_sect = vals[2];
3356 drive->present = 1;
3357 drive->forced_geom = 1;
3702 static int default_cleanup (ide_drive_t *drive)
3704 return ide_unregister_subdriver(drive);
3707 static int default_standby (ide_drive_t *drive)
3712 static int default_flushcache (ide_drive_t *drive)
3717 static ide_startstop_t default_do_request(ide_drive_t *drive, struct request *rq, unsigned long block)
3719 ide_end_request(0, HWGROUP(drive));
3728 static int default_ioctl (ide_drive_t *drive, struct inode *inode, struct file *file,
3734 static int default_open (struct inode *inode, struct file *filp, ide_drive_t *drive)
3736 drive->usage--;
3740 static void default_release (struct inode *inode, struct file *filp, ide_drive_t *drive)
3744 static int default_check_media_change (ide_drive_t *drive)
3749 static void default_pre_reset (ide_drive_t *drive)
3753 static unsigned long default_capacity (ide_drive_t *drive)
3758 static ide_startstop_t default_special (ide_drive_t *drive)
3760 special_t *s = &drive->special;
3763 drive->mult_req = 0;
3767 static int default_reinit (ide_drive_t *drive)
3769 printk(KERN_ERR "%s: does not support hotswap of device class !\n", drive->name);
3774 static void setup_driver_defaults (ide_drive_t *drive)
3776 ide_driver_t *d = drive->driver;
3802 ide_drive_t *drive = &hwif->drives[unit];
3803 char *req = drive->driver_req;
3806 if (drive->present && drive->media == media && drive->driver == driver && ++i > n)
3807 return drive;
3813 int ide_register_subdriver (ide_drive_t *drive, ide_driver_t *driver, int version)
3819 if (version != IDE_SUBDRIVER_VERSION || !drive->present || drive->driver != NULL || drive->busy || drive->usage) {
3823 drive->driver = driver;
3824 setup_driver_defaults(drive);
3826 if (drive->autotune != 2) {
3827 if (driver->supports_dma && HWIF(drive)->dmaproc != NULL) {
3834 (void) (HWIF(drive)->dmaproc(ide_dma_off_quietly, drive));
3835 (void) (HWIF(drive)->dmaproc(ide_dma_check, drive));
3837 drive->dsc_overlap = (drive->next != drive && driver->supports_dsc_overlap);
3838 drive->nice1 = 1;
3840 drive->revalidate = 1;
3841 drive->suspend_reset = 0;
3843 ide_add_proc_entries(drive->proc, generic_subdriver_entries, drive);
3844 ide_add_proc_entries(drive->proc, driver->proc, drive);
3849 int ide_unregister_subdriver (ide_drive_t *drive)
3855 if (drive->usage || drive->busy || drive->driver == NULL || DRIVER(drive)->busy) {
3863 ide_remove_proc_entries(drive->proc, DRIVER(drive)->proc);
3864 ide_remove_proc_entries(drive->proc, generic_subdriver_entries);
3866 auto_remove_settings(drive);
3867 drive->driver = NULL;
3979 ide_drive_t *drive;
3998 drive = &hwif->drives[unit];
3999 if (!drive->present)
4002 /* set the drive to standby */
4003 printk("%s ", drive->name);
4005 if (drive->driver != NULL && DRIVER(drive)->standby(drive))
4008 if (drive->driver != NULL && DRIVER(drive)->cleanup(drive))