aec62xx.c:	pci_read_config_word(dev, 0x40|(2*drive->dn), &d_conf);
aec62xx.c:	pci_write_config_word(dev, 0x40|(2*drive->dn), d_conf);
aec62xx.c:	tmp1 = ((0x00 << (2*drive->dn)) | (ultra & ~(3 << (2*drive->dn))));
aec62xx.c:	tmp2 = ((ultra_conf << (2*drive->dn)) | (tmp1 & ~(3 << (2*drive->dn))));
aec62xx.c:	byte unit		= (drive->select.b.unit & 0x01);
aec62xx.c:	pci_read_config_byte(dev, 0x40|drive->dn, &drive_conf);
aec62xx.c:	pci_write_config_byte(dev, 0x40|drive->dn, drive_conf);
aec62xx.c:	if (!drive->init_speed)
aec62xx.c:		drive->init_speed = speed;
aec62xx.c:	drive->current_speed = speed;
aec62xx.c:	struct hd_driveid *id	= drive->id;
aec62xx.c:	byte unit		= (drive->select.b.unit & 0x01);
aec62xx.c:	if (drive->media != ide_disk)
aec62xx.c:	struct hd_driveid *id	= drive->id;
aec62xx.c:	byte unit		= (drive->select.b.unit & 0x01);
aec62xx.c:	if (drive->media != ide_disk)
aec62xx.c:	struct hd_driveid *id	= drive->id;
aec62xx.c:	byte unit		= (drive->select.b.unit & 0x01);
aec62xx.c:	if (drive->media != ide_disk)
aec62xx.c:	struct hd_driveid *id = drive->id;
ali14xx.c:		drive->name, pio, time1, time2, param1, param2, param3, param4);
ali14xx.c:	driveNum = (HWIF(drive)->index << 1) + drive->select.b.unit;
alim15x3.c:	if (drive->media==ide_disk) {
alim15x3.c:	pci_write_config_byte(dev, port+drive->select.b.unit+2, (a_clc << 4) | r_clc);
alim15x3.c:	byte unit		= (drive->select.b.unit & 0x01);
alim15x3.c:	drive->current_speed = speed;
alim15x3.c:	struct hd_driveid *id	= drive->id;
alim15x3.c:	if (!drive->init_speed)
alim15x3.c:		drive->init_speed = speed;
alim15x3.c:	struct hd_driveid *id	= drive->id;
alim15x3.c:		    (drive->media!=ide_disk))) {
alim15x3.c:		   (drive->media!=ide_disk)) {
alim15x3.c:	struct hd_driveid *id		= drive->id;
alim15x3.c:	if ((m5229_revision<=0x20) && (drive->media!=ide_disk))
alim15x3.c:			if ((m5229_revision < 0xC2) && (drive->media != ide_disk))
amd74xx.c:	printk("%s: single-word DMA not support (revision < C4)\n", drive->name);
amd74xx.c:	byte unit		= (drive->select.b.unit & 0x01);
amd74xx.c:        switch (drive->dn) {
amd74xx.c:		drive->name, drive->dn, speed, ultra_timing, dma_pio_timing, pio_timing);
amd74xx.c:	pio_timing	&= ~(0x03 << drive->dn);
amd74xx.c:		drive->name, ultra_timing, dma_pio_timing, pio_timing);
amd74xx.c:	pio_timing |= (0x03 << drive->dn);
amd74xx.c:	if (!drive->init_speed)
amd74xx.c:		drive->init_speed = speed;
amd74xx.c:		drive->name, ultra_timing, dma_pio_timing, pio_timing);
amd74xx.c:	drive->current_speed = speed;
amd74xx.c:	unsigned short xfer_pio	= drive->id->eide_pio_modes;
amd74xx.c:	if (drive->id->eide_pio_iordy > 0) {
amd74xx.c:			drive->id->eide_pio_iordy>eide_pio_timing[xfer_pio];
amd74xx.c:		xfer_pio = (drive->id->eide_pio_modes & 4) ? 0x05 :
amd74xx.c:			   (drive->id->eide_pio_modes & 2) ? 0x04 :
amd74xx.c:			   (drive->id->eide_pio_modes & 1) ? 0x03 :
amd74xx.c:			   (drive->id->tPIO & 2) ? 0x02 :
amd74xx.c:			   (drive->id->tPIO & 1) ? 0x01 : xfer_pio;
amd74xx.c:			speed = (!drive->id->tPIO) ? XFER_PIO_0 : XFER_PIO_SLOW;
amd74xx.c:	drive->current_speed = speed;
amd74xx.c:	struct hd_driveid *id	= drive->id;
amd74xx.c:	struct hd_driveid *id = drive->id;
cmd640.c:		drive->no_unmask = 0;
cmd640.c:		drive->no_io_32bit = 1;
cmd640.c:		drive->io_32bit = 0;
cmd640.c:		drive->no_unmask = 1;
cmd640.c:		drive->unmask = 0;
cmd640.c:		drive->no_io_32bit = 0;
cmd640.c:		drive->no_unmask = 1;
cmd640.c:		drive->unmask = 0;
cmd640.c:		drive->no_io_32bit = 0;
cmd640.c:		drive->no_unmask = 0;
cmd640.c:		drive->no_io_32bit = 1;
cmd640.c:		drive->io_32bit = 0;
cmd640.c:			printk("%s: bad news in cmd640_tune_drive\n", drive->name);
cmd640.c:			printk("%s: %sabled cmd640 fast host timing (devsel)\n", drive->name, mode_wanted ? "en" : "dis");
cmd640.c:			printk("%s: %sabled cmd640 prefetch\n", drive->name, mode_wanted ? "en" : "dis");
cmd640.c:		drive->name,
cmd640.c:		if (drive->autotune || ((index > 1) && second_port_toggled)) {
cmd640.c:				index, drive->no_io_32bit ? "off" : "on");
cmd640.c:			index, drive->no_io_32bit ? "off" : "on");
cmd64x.c:		active_count, recovery_count, drive->present);
cmd64x.c:		drive->drive_data = setup_count;
cmd64x.c:			cmdprintk("%s: %sabled cmd640 prefetch\n", drive->name, mode_wanted ? "en" : "dis");
cmd64x.c:		drive->name, pio_mode, mode_wanted, cycle_time,
cmd64x.c:	switch (drive->dn) {
cmd64x.c:	u8 unit			= (drive->select.b.unit & 0x01);
cmd64x.c:		drive->current_speed = speed;
cmd64x.c:	u8 unit			= (drive->select.b.unit & 0x01);
cmd64x.c:	if ((drive->media != ide_disk) && (speed < XFER_SW_DMA_0))	return 1;
cmd64x.c:	drive->current_speed = speed;
cmd64x.c:	u8 unit			= (drive->select.b.unit & 0x01);
cmd64x.c:        switch (drive->dn) {
cmd64x.c:	drive->current_speed = speed;
cmd64x.c:	struct hd_driveid *id	= drive->id;
cmd64x.c:	if (drive->media != ide_disk) {
cmd64x.c:		cmdprintk("CMD64X: drive->media != ide_disk at double check, inital check failed!!\n");
cmd64x.c:	if (!drive->init_speed)
cmd64x.c:		drive->init_speed = speed;
cmd64x.c:	struct hd_driveid *id	= drive->id;
cmd64x.c:	if (!drive->init_speed)
cmd64x.c:		drive->init_speed = speed;
cmd64x.c:	struct hd_driveid *id	= drive->id;
cmd64x.c:	    hwif->autodma && (drive->media == ide_disk)) {
cmd64x.c:			drive->waiting_for_dma = 0;
cmd64x.c:			printk("%s: dma_stat: 0x%02x dma_alt_stat: 0x%02x mask: 0x%02x\n", drive->name, dma_stat, dma_alt_stat, mask);
cmd64x.c:			drive->waiting_for_dma = 0;
cs5530.c:	printk("%s: cs5530_set_xfer_mode(%s)\n", drive->name, ide_xfer_verbose(mode));
cs5530.c:		outl(cs5530_pio_timings[format][pio], basereg+(drive->select.b.unit<<3));
cs5530.c:	int			unit = drive->select.b.unit;
cs5530.c:	struct hd_driveid	*id = drive->id;
cs5530.c:			printk("%s: cs5530_config_dma: huh? mode=%02x\n", drive->name, mode);
cy82c693.c:	if (mode > drive->id->tDMA)  /* to be absolutly sure we have a valid mode */
cy82c693.c:		mode = drive->id->tDMA;
cy82c693.c:	printk (KERN_INFO "%s (ch=%d, dev=%d): DMA mode is %d (single=%d)\n", drive->name, HWIF(drive)->channel, drive->select.b.unit, (data&0x3), ((data>>2)&1));
cy82c693.c:	printk (KERN_INFO "%s (ch=%d, dev=%d): set DMA mode to %d (single=%d)\n", drive->name, HWIF(drive)->channel, drive->select.b.unit, mode, single);
cy82c693.c:	printk (KERN_INFO "%s: Set IDE Bus Master TimeOut Register to 0x%X\n", drive->name, data);
cy82c693.c:		struct hd_driveid *id = drive->id;
cy82c693.c:		printk (KERN_INFO "dma_on: %s\n", drive->name);
cy82c693.c:			printk(KERN_ERR "%s: tune_drive: Cannot find secondary interface!\n", drive->name);
cy82c693.c:       	if (drive->select.b.unit == 0) {
cy82c693.c:	printk (KERN_INFO "%s (ch=%d, dev=%d): PIO timing is (addr=0x%X, ior=0x%X, iow=0x%X, 8bit=0x%X)\n", drive->name, hwif->channel, drive->select.b.unit, addrCtrl, pclk.time_16r, pclk.time_16w, pclk.time_8);
cy82c693.c:	printk (KERN_INFO "%s: Selected PIO mode %d\n", drive->name, pio);
cy82c693.c:	if (drive->select.b.unit == 0) {
cy82c693.c:	printk (KERN_INFO "%s (ch=%d, dev=%d): set PIO timing to (addr=0x%X, ior=0x%X, iow=0x%X, 8bit=0x%X)\n", drive->name, hwif->channel, drive->select.b.unit, addrCtrl, pclk.time_16r, pclk.time_16w, pclk.time_8);
dtc2278.c:	drive->io_32bit = 1;
dtc2278.c:	HWIF(drive)->drives[!drive->select.b.unit].io_32bit = 1;
hd.c: *  IRQ-unmask, drive-id, multiple-mode, support for ">16 heads",
hpt34x.c:	tmp1 = ((0x00 << (3*drive->dn)) | (reg1 & ~(7 << (3*drive->dn))));
hpt34x.c:	tmp2 = (reg2 & ~(0x11 << drive->dn));
hpt34x.c:	tmp1 = ((lo_speed << (3*drive->dn)) | (reg1 & ~(7 << (3*drive->dn))));
hpt34x.c:	tmp2 = ((hi_speed << drive->dn) | reg2);
hpt34x.c:	if (!drive->init_speed)
hpt34x.c:		drive->init_speed = speed;
hpt34x.c:		drive->name, ide_xfer_verbose(speed),
hpt34x.c:		drive->dn, reg1, tmp1, reg2, tmp2,
hpt34x.c:	drive->current_speed = speed;
hpt34x.c:	unsigned short xfer_pio = drive->id->eide_pio_modes;
hpt34x.c:	if (drive->id->eide_pio_iordy > 0) {
hpt34x.c:			drive->id->eide_pio_iordy>eide_pio_timing[xfer_pio];
hpt34x.c:		xfer_pio = (drive->id->eide_pio_modes & 4) ? 0x05 :
hpt34x.c:			   (drive->id->eide_pio_modes & 2) ? 0x04 :
hpt34x.c:			   (drive->id->eide_pio_modes & 1) ? 0x03 : xfer_pio;
hpt34x.c:			speed = (!drive->id->tPIO) ? XFER_PIO_0 : XFER_PIO_SLOW;
hpt34x.c:	struct hd_driveid *id	= drive->id;
hpt34x.c:	if (drive->media != ide_disk)
hpt34x.c:	struct hd_driveid *id = drive->id;
hpt34x.c:			drive->waiting_for_dma = 1;
hpt34x.c:			if (drive->media != ide_disk)
hpt34x.c:			    (drive->addressing == 1)) {
hpt34x.c:			} else if (drive->addressing) {
hpt34x.c:			drive->waiting_for_dma = 0;
hpt366.c:	struct hd_driveid *id = drive->id;
hpt366.c:	byte regtime		= (drive->select.b.unit & 0x01) ? 0x44 : 0x40;
hpt366.c:	byte drive_pci		= 0x40 + (drive->dn * 4);
hpt366.c:	if ((drive->media != ide_disk) && (speed < XFER_SW_DMA_0))
hpt366.c:	if (!drive->init_speed)
hpt366.c:		drive->init_speed = speed;
hpt366.c:	drive->current_speed = speed;
hpt366.c:	unsigned short xfer_pio = drive->id->eide_pio_modes;
hpt366.c:	if (drive->id->eide_pio_iordy > 0) {
hpt366.c:			drive->id->eide_pio_iordy>eide_pio_timing[xfer_pio];
hpt366.c:		xfer_pio = (drive->id->eide_pio_modes & 4) ? 0x05 :
hpt366.c:			   (drive->id->eide_pio_modes & 2) ? 0x04 :
hpt366.c:			   (drive->id->eide_pio_modes & 1) ? 0x03 :
hpt366.c:			   (drive->id->tPIO & 2) ? 0x02 :
hpt366.c:			   (drive->id->tPIO & 1) ? 0x01 : xfer_pio;
hpt366.c:			speed = (!drive->id->tPIO) ? XFER_PIO_0 : XFER_PIO_SLOW;
hpt366.c:	struct hd_driveid *id	= drive->id;
hpt366.c:	if ((drive->media != ide_disk) && (speed < XFER_SW_DMA_0))
hpt366.c:	if (drive->quirk_list) {
hpt366.c:	if (drive->quirk_list) {
hpt366.c:			OUT_BYTE(mask ? (drive->ctl | 2) : (drive->ctl & ~2), IDE_CONTROL_REG);
hpt366.c:	struct hd_driveid *id = drive->id;
hpt366.c:				drive->name,
hpt366.c:			printk("%s: %d bytes in FIFO\n", drive->name, 
hpt371.c:	if (drive->media != ide_disk)
hpt371.c://      printk("%s: mode == %02x speed == %02x\n", drive->name, mode, speed);
hpt371.c:	struct hd_driveid *id = drive->id;
hpt371.c:	byte regtime = (drive->select.b.unit & 0x01) ? 0x44 : 0x40;
hpt371.c:	byte drive_pci = 0x40 + (drive->dn * 4);
hpt371.c:	byte drive_pci = 0x40 + (drive->dn * 4);
hpt371.c:	struct hd_driveid *id = drive->id;
hpt371.c:	if (drive->media != ide_disk)
hpt371.c:	if (drive->quirk_list)
hpt371.c:	if (drive->quirk_list) {
hpt371.c:			OUT_BYTE(mask ? (drive->ctl | 2) : (drive->ctl & ~2),
hpt371.c:	struct hd_driveid *id = drive->id;
hpt371.c:	drive->init_speed = 0;
hpt371.c:		       drive->name,
hpt371.c:		printk("%s: %d bytes in FIFO\n", drive->name, dma_stat);
ht6560b.c:		if (drive->media != ide_disk || !drive->present)
ht6560b.c:		printk("ht6560b: %s: select=%#x timing=%#x\n", drive->name, select, timing);
ht6560b.c:		printk("ht6560b: drive %s setting pio=%d recovery=%d (%dns) active=%d (%dns)\n", drive->name, pio, recovery_cycles, recovery_time, active_cycles, active_time);
ht6560b.c:		printk("ht6560b: drive %s setting pio=0\n", drive->name);
ht6560b.c:		drive->drive_data |= t;   /* enable prefetch mode */
ht6560b.c:		drive->no_unmask = 1;
ht6560b.c:		drive->unmask = 0;
ht6560b.c:		drive->drive_data &= ~t;  /* disable prefetch mode */
ht6560b.c:		drive->no_unmask = 0;
ht6560b.c:	printk("ht6560b: drive %s prefetch mode %sabled\n", drive->name, (state ? "en" : "dis"));
ht6560b.c:	drive->drive_data &= 0xff00;
ht6560b.c:	drive->drive_data |= timing;
ht6560b.c:	printk("ht6560b: drive %s tuned to pio mode %#x timing=%#x\n", drive->name, pio, timing);
ibm_ocp_ide.c:	if (speed != XFER_PIO_SLOW && speed != drive->current_speed)
ibm_ocp_ide.c:			       drive->dn >> 1, drive->dn & 1);
ibm_ocp_ide.c:	drive->dn = ((drive->select.all & 0x10) != 0);
ibm_ocp_ide.c:	peer = HWIF(drive)->drives + (~drive->dn & 1);
ibm_ocp_ide.c:	if (!drive->init_speed)
ibm_ocp_ide.c:		drive->init_speed = speed;
ibm_ocp_ide.c:	drive->current_speed = speed;
ibm_ocp_ide.c:	if (drive->dn & 1)
ibm_ocp_ide.c:	if (fast_device == (drive->dn & 1))
ibm_ocp_ide.c:		if (drive->dn & 1)
ibm_ocp_ide.c:		drive->using_dma = 1;
ibm_ocp_ide.c:				       drive->name);
ibm_ocp_ide.c:				       drive->name);
ibm_ocp_ide.c:		printk(KERN_DEBUG "%s: empty DMA table?\n", drive->name);
ibm_ocp_ide.c:	if (OK_STAT(stat, DRIVE_READY, drive->bad_wstat | DRQ_STAT)) {
ibm_ocp_ide.c:		       drive->name, dma_stat);
ibm_ocp_ide.c:	struct hd_driveid *id = drive->id;
ibm_ocp_ide.c:	struct hd_driveid *id = drive->id;
ibm_ocp_ide.c:	drive->using_dma = 0;
ibm_ocp_ide.c:	if (drive->media == ide_floppy)
ibm_ocp_ide.c:			drive->using_dma = 0;
ibm_ocp_ide.c:		printk(KERN_INFO "%s: DMA disabled\n", drive->name);
ibm_ocp_ide.c:		drive->using_dma = 0;
ibm_ocp_ide.c:		drive->waiting_for_dma = 1;
ibm_ocp_ide.c:		if (drive->media != ide_disk)
ibm_ocp_ide.c:		drive->waiting_for_dma = 0;
icside.c:	if (use_dma_info && drive->id->eide_dma_time > cycle_time)
icside.c:		cycle_time = drive->id->eide_dma_time;
icside.c:	drive->drive_data = cycle_time;
icside.c:		drive->drive_data = 480;
icside.c:	if (!drive->init_speed)
icside.c:		drive->init_speed = xfer_mode;
icside.c:		printk("%s: %s selected (peak %dMB/s)\n", drive->name,
icside.c:			ide_xfer_verbose(xfer_mode), 2000 / drive->drive_data);
icside.c:	drive->current_speed = xfer_mode;
icside.c:	if (OK_STAT(stat,DRIVE_READY,drive->bad_wstat|DRQ_STAT)) {
icside.c:		       drive->name, dma_stat);
icside.c:	struct hd_driveid *id = drive->id;
icside.c:				drive->name, id->model);
icside.c:	struct hd_driveid *id = drive->id;
icside.c:		ide_xfer_verbose(drive->current_speed),
icside.c:		2000 / drive->drive_data);
icside.c:		printk("%s: DMA disabled\n", drive->name);
icside.c:		drive->using_dma = (func == ide_dma_on);
icside.c:		set_dma_speed(hwif->hw.dma, drive->drive_data);
icside.c:		drive->waiting_for_dma = 1;
icside.c:		if (drive->media != ide_disk)
icside.c:		drive->waiting_for_dma = 0;
ide.c: *  | IRQ-unmask, drive-id, multiple-mode, support for ">16 heads",
ide.c:		drive->media			= ide_disk;
ide.c:		drive->select.all		= (unit<<4)|0xa0;
ide.c:		drive->hwif			= hwif;
ide.c:		drive->ctl			= 0x08;
ide.c:		drive->ready_stat		= READY_STAT;
ide.c:		drive->bad_wstat		= BAD_W_STAT;
ide.c:		drive->special.b.recalibrate	= 1;
ide.c:		drive->special.b.set_geometry	= 1;
ide.c:		drive->name[0]			= 'h';
ide.c:		drive->name[1]			= 'd';
ide.c:		drive->name[2]			= 'a' + (index * MAX_DRIVES) + unit;
ide.c:		drive->max_failures		= IDE_DEFAULT_MAX_FAILURES;
ide.c:		init_waitqueue_head(&drive->wqueue);
ide.c:	struct hd_driveid *id = drive->id;
ide.c:	if (drive->removable && id != NULL) {
ide.c:	if (drive->state == DMA_PIO_RETRY && drive->retry_pio <= 3) {
ide.c:		drive->state = 0;
ide.c:	if (!end_that_request_first(rq, uptodate, hwgroup->drive->name)) {
ide.c:			drive->name, hwgroup->handler, handler);
ide.c:	if (!drive->present)
ide.c:	if (drive->driver != NULL)
ide.c:		if (!drive->present)
ide.c:		if (drive->media!=ide_disk && drive->media!=ide_floppy)
ide.c:			(drive->forced_geom && drive->noprobe) ? 1 :
ide.c:		printk("%s: ATAPI reset complete\n", drive->name);
ide.c:		printk("%s: ATAPI reset timed-out, status=0x%02x\n", drive->name, stat);
ide.c:		drive->failures++;
ide.c:			drive->failures = 0;
ide.c:			drive->failures++;
ide.c:	if (drive->crc_count) {
ide.c:		if (drive->current_speed >= XFER_SW_DMA_0)
ide.c:	if (drive->driver != NULL)
ide.c:	if (!drive->keep_settings) {
ide.c:		if (drive->using_dma) {
ide.c:			drive->unmask = 0;
ide.c:			drive->io_32bit = 0;
ide.c:	if (drive->using_dma)
ide.c:	if (drive->media != ide_disk && !do_not_try_atapi) {
ide.c:	OUT_BYTE(drive->ctl|6,IDE_CONTROL_REG);	/* set SRST and nIEN */
ide.c:	if (drive->quirk_list == 2) {
ide.c:		OUT_BYTE(drive->ctl,IDE_CONTROL_REG);	/* clear SRST and nIEN */
ide.c:		OUT_BYTE(drive->ctl|2,IDE_CONTROL_REG);	/* clear SRST, leave nIEN */
ide.c:				if ((drive->id->command_set_2 & 0x0400) &&
ide.c:				    (drive->id->cfs_enable_2 & 0x0400) &&
ide.c:				    (drive->addressing == 1)) {
ide.c:					OUT_BYTE(drive->ctl|0x80, IDE_CONTROL_REG_HOB);
ide.c:	printk("%s: %s: status=0x%02x", drive->name, msg, stat);
ide.c:		printk("%s: %s: error=0x%02x", drive->name, msg, err);
ide.c:		if (drive->media == ide_disk) {
ide.c:				if ((drive->id->command_set_2 & 0x0400) &&
ide.c:				    (drive->id->cfs_enable_2 & 0x0400) &&
ide.c:				    (drive->addressing == 1)) {
ide.c:					OUT_BYTE(drive->ctl|0x80, IDE_CONTROL_REG);
ide.c:	int i = (drive->mult_count ? drive->mult_count : 1) * SECTOR_WORDS;
ide.c:	if (drive->media != ide_disk)
ide.c:	if (stat & BUSY_STAT || ((stat & WRERR_STAT) && !drive->nowerr)) { /* other bits are useless when BUSY */
ide.c:		if (drive->media == ide_disk && (stat & ERR_STAT)) {
ide.c:				if (drive->select.b.lba && IN_BYTE(IDE_COMMAND_REG) == WIN_SPECIFY)
ide.c:				drive->crc_count++; /* UDMA crc error -- just retry the operation */
ide.c:		if (drive->driver != NULL)
ide.c:			drive->special.b.recalibrate = 1;
ide.c:		OUT_BYTE(drive->ctl,IDE_CONTROL_REG);	/* clear nIEN */
ide.c:		byte io_32bit = drive->io_32bit;
ide.c:		drive->io_32bit = 0;
ide.c:		drive->io_32bit = io_32bit;
ide.c:	special_t *s = &drive->special;
ide.c:	printk("%s: do_special: 0x%02x\n", drive->name, s->all);
ide.c:			tuneproc(drive, drive->tune_req);
ide.c:	} else if (drive->driver != NULL) {
ide.c:		printk("%s: bad special flag: 0x%02x\n", drive->name, s->all);
ide.c:	if (drive->max_failures && (drive->failures > drive->max_failures)) {
ide.c:	printk(KERN_INFO "%s: ", drive->name);
ide.c:	printk(KERN_INFO "%s: ", drive->name);
ide.c: 			printk("%s: DRIVE_TASK_CMD ", drive->name);
ide.c: 			if (drive->select.b.unit)
ide.c: 			printk("%s: DRIVE_CMD ", drive->name);
ide.c: 	printk("%s: DRIVE_CMD (null)\n", drive->name);
ide.c:	if (drive->max_failures && (drive->failures > drive->max_failures)) {
ide.c:		printk("%s: block not locked\n", drive->name);
ide.c:	    (drive->media == ide_disk || drive->media == ide_floppy)) {
ide.c:		if ((blockend < block) || (blockend > drive->part[minor&PARTN_MASK].nr_sects)) {
ide.c:			printk("%s%c: bad access: block=%ld, count=%ld\n", drive->name,
ide.c:		block += drive->part[minor&PARTN_MASK].start_sect + drive->sect0;
ide.c:	if (block == 0 && drive->remap_0_to_1 == 1)
ide.c:	if (ide_wait_stat(&startstop, drive, drive->ready_stat, BUSY_STAT|DRQ_STAT, WAIT_READY)) {
ide.c:		printk("%s: drive not ready for command\n", drive->name);
ide.c:	if (!drive->special.all) {
ide.c:		if (drive->driver != NULL) {
ide.c:		printk("%s: media type %d not supported\n", drive->name, drive->media);
ide.c:	if (drive->driver != NULL)
ide.c:	drive->sleep = timeout + jiffies;
ide.c:		if (!list_empty(&drive->queue.queue_head) && (!drive->sleep || 0 <= (signed long)(jiffies - drive->sleep))) {
ide.c:			 || (drive->sleep && (!best->sleep || 0 < (signed long)(best->sleep - drive->sleep)))
ide.c:				if( !drive->queue.plugged )
ide.c:	} while ((drive = drive->next) != hwgroup->drive);
ide.c:				if (!drive->sleep
ide.c:			} while ((drive = drive->next) != best);
ide.c:				if (drive->sleep && (!sleep || 0 < (signed long)(sleep - drive->sleep)))
ide.c:					sleep = drive->sleep;
ide.c:			} while ((drive = drive->next) != hwgroup->drive);
ide.c:		drive->sleep = 0;
ide.c:		drive->service_start = jiffies;
ide.c:		if ( drive->queue.plugged )	/* paranoia */
ide.c:			printk("%s: Huh? nuking plugged queue\n", drive->name);
ide.c:		rq = hwgroup->rq = blkdev_entry_next_request(&drive->queue.queue_head);
ide.c:	printk("%s: timeout waiting for DMA\n", drive->name);
ide.c:	drive->retry_pio++;
ide.c:	drive->state = DMA_PIO_RETRY;
ide.c:				printk("%s: ide_timer_expiry: hwgroup->busy was 0 ??\n", drive->name);
ide.c:				if (drive->waiting_for_dma)
ide.c:				printk("%s: lost interrupt\n", drive->name);
ide.c:				if (drive->waiting_for_dma) {
ide.c:			drive->service_time = jiffies - drive->service_start;
ide.c:		printk("%s: ide_intr: hwgroup->busy was 0 ??\n", drive->name);
ide.c:	if (drive->unmask)
ide.c:	drive->service_time = jiffies - drive->service_start;
ide.c:			printk("%s: ide_intr: huh? expected NULL handler on exit\n", drive->name);
ide.c:				if ((drive->present) && (drive->part[minor].nr_sects))
ide.c:				if (drive->present)
ide.c:	struct list_head *queue_head = &drive->queue.queue_head;
ide.c:	rq->rq_dev = MKDEV(major,(drive->select.b.unit)<<PARTN_BITS);
ide.c:	minor = drive->select.b.unit << PARTN_BITS;
ide.c:	if (drive->busy || (drive->usage > 1)) {
ide.c:	drive->busy = 1;
ide.c:		if (drive->part[p].nr_sects > 0) {
ide.c:		drive->part[p].start_sect = 0;
ide.c:		drive->part[p].nr_sects   = 0;
ide.c:	drive->busy = 0;
ide.c:	wake_up(&drive->wqueue);
ide.c:			if (drive->revalidate) {
ide.c:				drive->revalidate = 0;
ide.c:	if (drive->driver == NULL)
ide.c:	if (drive->driver == NULL) {
ide.c:		if (drive->media == ide_disk)
ide.c:		if (drive->media == ide_cdrom)
ide.c:		if (drive->media == ide_tape)
ide.c:		if (drive->media == ide_floppy)
ide.c:		if (drive->media == ide_scsi)
ide.c:	while (drive->busy)
ide.c:		sleep_on(&drive->wqueue);
ide.c:	drive->usage++;
ide.c:	if (drive->driver != NULL)
ide.c:	printk ("%s: driver not present\n", drive->name);
ide.c:	drive->usage--;
ide.c:		drive->usage--;
ide.c:		if (drive->driver != NULL)
ide.c:	if (!drive->present || drive->busy || drive->usage)
ide.c:	if (drive->driver != NULL && DRIVER(drive)->cleanup(drive))
ide.c:	strncpy(drive->driver_req, driver, 9);
ide.c:	drive->driver_req[0] = 0;
ide.c:		if (!drive->present)
ide.c:		if (drive->busy || drive->usage)
ide.c:		if (drive->driver != NULL && DRIVER(drive)->cleanup(drive))
ide.c:		if (!drive->present)
ide.c:		minor = drive->select.b.unit << PARTN_BITS;
ide.c:			if (drive->part[p].nr_sects > 0) {
ide.c:		if (drive->de) {
ide.c:			devfs_unregister (drive->de);
ide.c:			drive->de = NULL;
ide.c:		if (!drive->present)
ide.c:		while (hwgroup->drive->next != drive)
ide.c:			hwgroup->drive = hwgroup->drive->next;
ide.c:		hwgroup->drive->next = drive->next;
ide.c:		if (drive->id != NULL) {
ide.c:			kfree(drive->id);
ide.c:			drive->id = NULL;
ide.c:		drive->present = 0;
ide.c:		blk_cleanup_queue(&drive->queue);
ide.c:	ide_settings_t **p = (ide_settings_t **) &drive->settings, *setting = NULL;
ide.c:	if (drive->driver)
ide.c:	ide_settings_t **p = (ide_settings_t **) &drive->settings, *setting;
ide.c:	ide_settings_t *setting = drive->settings;
ide.c:	ide_settings_t *setting = drive->settings;
ide.c:	setting = drive->settings;
ide.c:			printk("%s: channel busy\n", drive->name);
ide.c:	drive->io_32bit = arg;
ide.c:		HWIF(drive)->drives[!drive->select.b.unit].io_32bit = arg;
ide.c:	if (!drive->driver || !DRIVER(drive)->supports_dma)
ide.c:	if (!drive->id || !(drive->id->capability & 1) || !HWIF(drive)->dmaproc)
ide.c:	if (drive->special.b.set_tune)
ide.c:	drive->tune_req = (byte) arg;
ide.c:	drive->special.b.set_tune = 1;
ide.c:	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);
ide.c:	ide_add_setting(drive,	"keepsettings",		SETTING_RW,					HDIO_GET_KEEPSETTINGS,	HDIO_SET_KEEPSETTINGS,	TYPE_BYTE,	0,	1,				1,		1,		&drive->keep_settings,		NULL);
ide.c:	ide_add_setting(drive,	"nice1",		SETTING_RW,					-1,			-1,			TYPE_BYTE,	0,	1,				1,		1,		&drive->nice1,			NULL);
ide.c:	ide_add_setting(drive,	"slow",			SETTING_RW,					-1,			-1,			TYPE_BYTE,	0,	1,				1,		1,		&drive->slow,			NULL);
ide.c:	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);
ide.c:	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);
ide.c:	ide_add_setting(drive,	"ide_scsi",		SETTING_RW,					-1,			-1,			TYPE_BYTE,	0,	1,				1,		1,		&drive->scsi,			NULL);
ide.c:	ide_add_setting(drive,	"init_speed",		SETTING_RW,					-1,			-1,			TYPE_BYTE,	0,	70,				1,		1,		&drive->init_speed,		NULL);
ide.c:	ide_add_setting(drive,	"current_speed",	SETTING_RW,					-1,			-1,			TYPE_BYTE,	0,	70,				1,		1,		&drive->current_speed,		NULL);
ide.c:	ide_add_setting(drive,	"number",		SETTING_RW,					-1,			-1,			TYPE_BYTE,	0,	3,				1,		1,		&drive->dn,			NULL);
ide.c:	switch (drive->media) {
ide.c:			unsigned short bios_cyl = drive->bios_cyl; /* truncate */
ide.c:			if (!loc || (drive->media != ide_disk && drive->media != ide_floppy)) return -EINVAL;
ide.c:			if (put_user(drive->bios_head, (byte *) &loc->heads)) return -EFAULT;
ide.c:			if (put_user(drive->bios_sect, (byte *) &loc->sectors)) return -EFAULT;
ide.c:			if (put_user((unsigned)drive->part[MINOR(inode->i_rdev)&PARTN_MASK].start_sect,
ide.c:			if (!loc || (drive->media != ide_disk && drive->media != ide_floppy)) return -EINVAL;
ide.c:			if (put_user(drive->bios_head, (byte *) &loc->heads)) return -EFAULT;
ide.c:			if (put_user(drive->bios_sect, (byte *) &loc->sectors)) return -EFAULT;
ide.c:			if (put_user(drive->bios_cyl, (unsigned int *) &loc->cylinders)) return -EFAULT;
ide.c:			if (put_user((unsigned)drive->part[MINOR(inode->i_rdev)&PARTN_MASK].start_sect,
ide.c:			if (!loc || (drive->media != ide_disk && drive->media != ide_floppy)) return -EINVAL;
ide.c:			if (put_user(drive->head, (byte *) &loc->heads)) return -EFAULT;
ide.c:			if (put_user(drive->sect, (byte *) &loc->sectors)) return -EFAULT;
ide.c:			if (put_user(drive->cyl, (unsigned int *) &loc->cylinders)) return -EFAULT;
ide.c:			if (put_user((unsigned)drive->part[MINOR(inode->i_rdev)&PARTN_MASK].start_sect,
ide.c:			return put_user(drive->part[MINOR(inode->i_rdev)&PARTN_MASK].nr_sects, (unsigned long *) arg);
ide.c:			return put_user((u64)drive->part[MINOR(inode->i_rdev)&PARTN_MASK].nr_sects << 9, (u64 *) arg);
ide.c:			if (drive->id == NULL)
ide.c:			if (copy_to_user((char *)arg, (char *)drive->id, (cmd == HDIO_GET_IDENTITY) ? sizeof(*drive->id) : 142))
ide.c:			return put_user(drive->dsc_overlap	<<	IDE_NICE_DSC_OVERLAP	|
ide.c:					drive->atapi_overlap	<<	IDE_NICE_ATAPI_OVERLAP	|
ide.c:					drive->nice0		<< 	IDE_NICE_0		|
ide.c:					drive->nice1		<<	IDE_NICE_1		|
ide.c:					drive->nice2		<<	IDE_NICE_2,
ide.c:			if (drive->driver == NULL)
ide.c:			drive->dsc_overlap = (arg >> IDE_NICE_DSC_OVERLAP) & 1;
ide.c:			if (drive->dsc_overlap && !DRIVER(drive)->supports_dsc_overlap) {
ide.c:				drive->dsc_overlap = 0;
ide.c:			drive->nice1 = (arg >> IDE_NICE_1) & 1;
ide.c:				printk("%s: ide_set_handler: handler not null; %p\n", drive->name, hwgroup->handler);
ide.c:			if (drive->suspend_reset) {
ide.c:			if (drive->driver != NULL)
ide.c:	if (drive->driver != NULL)
ide.c:			strncpy(drive->driver_req, s + 4, 9);
ide.c:				drive->last_lun = vals[0];
ide.c:				drive->forced_lun = 1;
ide.c:				drive->nobios = 1;  /* drop into "noprobe" */
ide.c:				drive->noprobe = 1;
ide.c:				drive->bad_wstat = BAD_R_STAT;
ide.c:				drive->present = 1;
ide.c:				drive->media = ide_cdrom;
ide.c:				drive->autotune = 1;
ide.c:				drive->autotune = 2;
ide.c:				drive->slow = 1;
ide.c:				drive->bswap = 1;
ide.c:				drive->ata_flash = 1;
ide.c:				drive->remap_0_to_1 = 1;
ide.c:				drive->remap_0_to_1 = 2;
ide.c:				drive->scsi = 1;
ide.c:				drive->scsi = 0;
ide.c:				drive->media	= ide_disk;
ide.c:				drive->cyl	= drive->bios_cyl  = vals[0];
ide.c:				drive->head	= drive->bios_head = vals[1];
ide.c:				drive->sect	= drive->bios_sect = vals[2];
ide.c:				drive->present	= 1;
ide.c:				drive->forced_geom = 1;
ide.c:	drive->usage--;
ide.c:	special_t *s = &drive->special;
ide.c:	drive->mult_req = 0;
ide.c:	printk(KERN_ERR "%s: does not support hotswap of device class !\n", drive->name);
ide.c:	ide_driver_t *d = drive->driver;
ide.c:			char *req = drive->driver_req;
ide.c:			if (drive->present && drive->media == media && drive->driver == driver && ++i > n)
ide.c:	if (version != IDE_SUBDRIVER_VERSION || !drive->present || drive->driver != NULL || drive->busy || drive->usage) {
ide.c:	drive->driver = driver;
ide.c:	if (drive->autotune != 2) {
ide.c:		drive->dsc_overlap = (drive->next != drive && driver->supports_dsc_overlap);
ide.c:		drive->nice1 = 1;
ide.c:	drive->revalidate = 1;
ide.c:	drive->suspend_reset = 0;
ide.c:	ide_add_proc_entries(drive->proc, generic_subdriver_entries, drive);
ide.c:	ide_add_proc_entries(drive->proc, driver->proc, drive);
ide.c:	if (drive->usage || drive->busy || drive->driver == NULL || DRIVER(drive)->busy) {
ide.c:	ide_remove_proc_entries(drive->proc, DRIVER(drive)->proc);
ide.c:	ide_remove_proc_entries(drive->proc, generic_subdriver_entries);
ide.c:	drive->driver = NULL;
ide.c:			if (!drive->present)
ide.c:			printk("%s ", drive->name);
ide.c:				if (drive->driver != NULL && DRIVER(drive)->standby(drive))
ide.c:			if (drive->driver != NULL && DRIVER(drive)->cleanup(drive))
ide-cd.c: * 3.07a Feb 11, 1996 -- check drive->id for NULL before dereferencing, to fix
ide-cd.c:	struct cdrom_info *info = drive->driver_data;
ide-cd.c:		printk ("ATAPI device %s:\n", drive->name);
ide-cd.c:		drive->name,
ide-cd.c:	struct cdrom_info *info		= drive->driver_data;
ide-cd.c:		printk("%s: missing rq in cdrom_decode_status\n", drive->name);
ide-cd.c:			/*printk("%s: media changed\n",drive->name);*/
ide-cd.c:			printk ("%s: tray open\n", drive->name);
ide-cd.c:	struct cdrom_info *info = drive->driver_data;
ide-cd.c:		OUT_BYTE (drive->ctl, IDE_CONTROL_REG);
ide-cd.c:		struct cdrom_info *info = drive->driver_data;
ide-cd.c:	struct cdrom_info *info = drive->driver_data;
ide-cd.c:			drive->name);
ide-cd.c:			drive->name, ireason);
ide-cd.c:	struct cdrom_info *info = drive->driver_data;
ide-cd.c:				drive->name, rq->current_nr_sectors);
ide-cd.c:			drive->name, len);
ide-cd.c:	struct cdrom_info *info = drive->driver_data;
ide-cd.c:			drive->name, rq->sector);
ide-cd.c:				drive->name, rq->current_nr_sectors);
ide-cd.c:	struct cdrom_info *info = drive->driver_data;
ide-cd.c:			printk("%s: disabled DSC seek overlap\n", drive->name);
ide-cd.c:			drive->dsc_overlap = 0;
ide-cd.c:	struct cdrom_info *info = drive->driver_data;
ide-cd.c:		if (entry == &drive->queue.queue_head)
ide-cd.c:	struct cdrom_info *info = drive->driver_data;
ide-cd.c:	if (drive->using_dma && (rq->sector % SECTORS_PER_FRAME == 0) &&
ide-cd.c:				drive->name, pc->buflen);
ide-cd.c:			drive->name, ireason);
ide-cd.c:	struct cdrom_info *info = drive->driver_data;
ide-cd.c:			drive->name);
ide-cd.c:			drive->name, ireason);
ide-cd.c:	struct cdrom_info *info = drive->driver_data;
ide-cd.c:			drive->name, rq->current_nr_sectors);
ide-cd.c:	struct cdrom_info *info = drive->driver_data;
ide-cd.c:	info->dma = drive->using_dma ? 1 : 0;
ide-cd.c:	struct cdrom_info *info = drive->driver_data;
ide-cd.c:					printk ("%s: DSC timeout\n", drive->name);
ide-cd.c:			if (IDE_LARGE_SEEK(info->last_block, block, IDECD_SEEK_THRESHOLD) && drive->dsc_overlap)
ide-cd.c:	struct cdrom_info *info = drive->driver_data;
ide-cd.c:			drive->name);
ide-cd.c:	struct cdrom_info *info = drive->driver_data;
ide-cd.c:			printk ("%s: No cdrom TOC buffer!\n", drive->name);
ide-cd.c:	minor = (drive->select.b.unit) << PARTN_BITS;
ide-cd.c:	HWIF(drive)->gd->sizes[drive->select.b.unit << PARTN_BITS] = (toc->capacity * SECTORS_PER_FRAME) >> (BLOCK_SIZE_BITS - 9);
ide-cd.c:	drive->part[0].nr_sects = toc->capacity * SECTORS_PER_FRAME;
ide-cd.c:	struct cdrom_info *info = drive->driver_data;
ide-cd.c:	struct cdrom_info *info = drive->driver_data;
ide-cd.c:	struct cdrom_info *info = drive->driver_data;
ide-cd.c:	struct cdrom_info *info = drive->driver_data;
ide-cd.c:	int minor = (drive->select.b.unit) << PARTN_BITS;
ide-cd.c:	strcpy(devinfo->name, drive->name);
ide-cd.c:	devinfo->de = devfs_register(drive->de, "cd", DEVFS_FL_DEFAULT,
ide-cd.c:	struct cdrom_info *info = drive->driver_data;
ide-cd.c:	if (drive->id) {
ide-cd.c:		if (!(!strcmp(drive->id->model, "ATAPI CD ROM DRIVE 50X MAX") ||
ide-cd.c:		    !strcmp(drive->id->model, "WPI CDS-32X")))
ide-cd.c:	struct cdrom_info *info = drive->driver_data;
ide-cd.c:	if (strcmp (drive->id->model, "MATSHITADVD-ROM SR-8187") == 0 ||
ide-cd.c:	    strcmp (drive->id->model, "MATSHITADVD-ROM SR-8186") == 0)
ide-cd.c:	if (strcmp (drive->id->model, "MATSHITADVD-ROM SR-8187") == 0 ||
ide-cd.c:	    strcmp (drive->id->model, "MATSHITADVD-ROM SR-8186") == 0)
ide-cd.c:	if (drive->id && !drive->id->model[0] && !strncmp(drive->id->fw_rev, "241N", 4)) {
ide-cd.c:	printk("%s: ATAPI", drive->name);
ide-cd.c:	if (drive->using_dma)
ide-cd.c:	int minor = drive->select.b.unit << PARTN_BITS;
ide-cd.c:	ide_add_setting(drive,	"dsc_overlap",		SETTING_RW, -1, -1, TYPE_BYTE, 0, 1, 1,	1, &drive->dsc_overlap, NULL);
ide-cd.c:	struct cdrom_info *info = drive->driver_data;
ide-cd.c:	int minor = drive->select.b.unit << PARTN_BITS;
ide-cd.c:	drive->special.all	= 0;
ide-cd.c:	drive->ready_stat	= 0;
ide-cd.c:	if (drive->id != NULL)
ide-cd.c:			((drive->id->config & 0x0060) == 0x20);
ide-cd.c:	if (drive->id != NULL) {
ide-cd.c:		if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-2430"))
ide-cd.c:		else if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-2432"))
ide-cd.c:		else if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-3231"))
ide-cd.c:	if (drive->id != NULL) {
ide-cd.c:		if (strcmp (drive->id->model, "V003S0DS") == 0 &&
ide-cd.c:		    drive->id->fw_rev[4] == '1' &&
ide-cd.c:		    drive->id->fw_rev[6] <= '2') {
ide-cd.c:		else if (strcmp (drive->id->model, "V006E0DS") == 0 &&
ide-cd.c:		    drive->id->fw_rev[4] == '1' &&
ide-cd.c:		    drive->id->fw_rev[6] <= '2') {
ide-cd.c:		else if (strcmp (drive->id->model,
ide-cd.c:			 strncmp (drive->id->fw_rev, "1.01", 4) == 0) { /* FIXME */
ide-cd.c:		else if (strcmp (drive->id->model, "WEARNES CDD-120") == 0 &&
ide-cd.c:			 strncmp (drive->id->fw_rev, "A1.1", 4) == 0) { /* FIXME */
ide-cd.c:                 else if ((strcmp(drive->id->model, "CD-ROM CDR-C3 G") == 0) ||
ide-cd.c:                         (strcmp(drive->id->model, "CD-ROM CDR-C3G") == 0) ||
ide-cd.c:                         (strcmp(drive->id->model, "CD-ROM CDR_C36") == 0)) {
ide-cd.c:		printk ("%s: ide_cdrom_setup failed to register device with the cdrom driver.\n", drive->name);
ide-cd.c:	struct cdrom_info *info = drive->driver_data;
ide-cd.c:		drive->usage--;
ide-cd.c:			(drive->select.b.unit) << PARTN_BITS));
ide-cd.c:	struct cdrom_info *info = drive->driver_data;
ide-cd.c:	int minor = drive->select.b.unit << PARTN_BITS;
ide-cd.c:	drive->part[0].nr_sects = toc->capacity * SECTORS_PER_FRAME;
ide-cd.c:	struct cdrom_info *info = drive->driver_data;
ide-cd.c:		printk ("%s: ide_cdrom_cleanup failed to unregister device from the cdrom driver.\n", drive->name);
ide-cd.c:	drive->driver_data = NULL;
ide-cd.c:		printk ("%s: Can't allocate a cdrom structure\n", drive->name);
ide-cd.c:		printk ("%s: Failed to register the driver with ide.c\n", drive->name);
ide-cd.c:	drive->driver_data = info;
ide-cd.c:			printk ("%s: ide_cdrom_cleanup failed in ide_cdrom_init\n", drive->name);
ide-cd.c:			printk ("%s: cleanup_module() called while still busy\n", drive->name);
ide-cd.c:			if (strstr(ignore, drive->name)) {
ide-cd.c:				printk("ide-cd: ignoring drive %s\n", drive->name);
ide-cd.c:		if (drive->scsi) {
ide-cd.c:			printk("ide-cd: passing drive %s to ide-scsi emulation.\n", drive->name);
ide-cd.c:			printk ("%s: Can't allocate a cdrom structure\n", drive->name);
ide-cd.c:			printk ("%s: Failed to register the driver with ide.c\n", drive->name);
ide-cd.c:		drive->driver_data = info;
ide-cd.c:				printk ("%s: ide_cdrom_cleanup failed in ide_cdrom_init\n", drive->name);
ide-disk.c:	msect = drive->mult_count;
ide-disk.c:		drive->name, rq->sector, rq->sector+nsect-1,
ide-disk.c:	if (!OK_STAT(stat=GET_STAT(),DRIVE_READY,drive->bad_wstat)) {
ide-disk.c:		printk("%s: write_intr error1: nr_sectors=%ld, stat=0x%02x\n", drive->name, rq->nr_sectors, stat);
ide-disk.c:			drive->name, rq->sector, (unsigned long) rq->buffer,
ide-disk.c:	if (OK_STAT(stat=GET_STAT(),DRIVE_READY,drive->bad_wstat)) {
ide-disk.c:				if (ide_multwrite(drive, drive->mult_count))
ide-disk.c:	printk(KERN_ERR "%s: bad command: %d\n", drive->name, rq->cmd);
ide-disk.c:	if ((drive->id->cfs_enable_2 & 0x0400) && (drive->addressing))	/* 48-bit LBA */
ide-disk.c:	if (drive->select.b.lba)		/* 28-bit LBA */
ide-disk.c:	int lba48bit = (drive->id->cfs_enable_2 & 0x0400) ? 1 : 0;
ide-disk.c:	lba48bit = drive->addressing;
ide-disk.c:	if ((cmd == READ) && (drive->using_dma))
ide-disk.c:	else if ((cmd == READ) && (drive->mult_count))
ide-disk.c:	else if ((cmd == WRITE) && (drive->using_dma))
ide-disk.c:	else if ((cmd == WRITE) && (drive->mult_count))
ide-disk.c:	unsigned int track	= (block / drive->sect);
ide-disk.c:	unsigned int sect	= (block % drive->sect) + 1;
ide-disk.c:	unsigned int head	= (track % drive->head);
ide-disk.c:	unsigned int cyl	= (track / drive->head);
ide-disk.c:	taskfile.device_head	|= drive->select.all;
ide-disk.c:	printk("%s: %sing: ", drive->name, (rq->cmd==READ) ? "read" : "writ");
ide-disk.c:	taskfile.device_head	|= drive->select.all;
ide-disk.c:	printk("%s: %sing: ", drive->name, (rq->cmd==READ) ? "read" : "writ");
ide-disk.c:	taskfile.device_head	= drive->select.all;
ide-disk.c:	hobfile.control		= (drive->ctl|0x80);
ide-disk.c:	printk("%s: %sing: ", drive->name, (rq->cmd==READ) ? "read" : "writ");
ide-disk.c:		OUT_BYTE(drive->ctl,IDE_CONTROL_REG);
ide-disk.c:	if (drive->select.b.lba || IS_PDC4030_DRIVE) {
ide-disk.c:	//drive->select.b.lba=1;
ide-disk.c:	if (drive->select.b.lba) {
ide-disk.c:		if ((drive->id->cfs_enable_2 & 0x0400) && (drive->addressing)) {
ide-disk.c:				drive->name,
ide-disk.c:				drive->name, tasklets[3], tasklets[2],
ide-disk.c:			OUT_BYTE(0x00|drive->select.all,IDE_SELECT_REG);
ide-disk.c:				drive->name, (rq->cmd==READ)?"read":"writ",
ide-disk.c://			printk("--------------%4x--------------------\n",drive->select.b.bit7);
ide-disk.c://			printk("--------------%4x--------------------\n",drive->select.b.lba);
ide-disk.c://			printk("--------------%4x--------------------\n",drive->select.b.bit5);
ide-disk.c://			printk("--------------%4x--------------------\n",drive->select.b.unit);
ide-disk.c://			printk("--------------%4x--------------------\n",drive->select.b.head);			
ide-disk.c://			printk("--------------%4x--------------------\n",drive->select.all);
ide-disk.c:			OUT_BYTE(((block>>8)&0x0f)|drive->select.all,IDE_SELECT_REG);
ide-disk.c:		track = block / drive->sect;
ide-disk.c:		sect  = block % drive->sect + 1;
ide-disk.c:		head  = track % drive->head;
ide-disk.c:		cyl   = track / drive->head;
ide-disk.c:		OUT_BYTE(head|drive->select.all,IDE_SELECT_REG);
ide-disk.c:			drive->name, (rq->cmd==READ)?"read":"writ", cyl,
ide-disk.c:		if (drive->using_dma && !(HWIF(drive)->dmaproc(ide_dma_read, drive)))
ide-disk.c:		if ((drive->id->cfs_enable_2 & 0x0400) && (drive->addressing)) {
ide-disk.c:			OUT_BYTE(drive->mult_count ? WIN_MULTREAD_EXT : WIN_READ_EXT, IDE_COMMAND_REG);
ide-disk.c:			OUT_BYTE(drive->mult_count ? WIN_MULTREAD : WIN_READ, IDE_COMMAND_REG);
ide-disk.c:		if (drive->using_dma && !(HWIF(drive)->dmaproc(ide_dma_write, drive)))
ide-disk.c:		if ((drive->id->cfs_enable_2 & 0x0400) && (drive->addressing)) {
ide-disk.c:			OUT_BYTE(drive->mult_count ? WIN_MULTWRITE_EXT : WIN_WRITE_EXT, IDE_COMMAND_REG);
ide-disk.c:			OUT_BYTE(drive->mult_count ? WIN_MULTWRITE : WIN_WRITE, IDE_COMMAND_REG);
ide-disk.c:		if (ide_wait_stat(&startstop, drive, DATA_READY, drive->bad_wstat, WAIT_DRQ)) {
ide-disk.c:			printk(KERN_ERR "%s: no DRQ after issuing %s\n", drive->name,
ide-disk.c:				drive->mult_count ? "MULTWRITE" : "WRITE");
ide-disk.c:		if (!drive->unmask)
ide-disk.c:		if (drive->mult_count) {
ide-disk.c:			if (ide_multwrite(drive, drive->mult_count)) {
ide-disk.c:	printk(KERN_ERR "%s: bad command: %d\n", drive->name, rq->cmd);
ide-disk.c:	if (drive->removable && drive->usage == 1) {
ide-disk.c:		if (drive->doorlocking && ide_wait_taskfile(drive, &taskfile, &hobfile, NULL))
ide-disk.c:			drive->doorlocking = 0;
ide-disk.c:	if (drive->removable && !drive->usage) {
ide-disk.c:		if (drive->doorlocking && ide_wait_taskfile(drive, &taskfile, &hobfile, NULL))
ide-disk.c:			drive->doorlocking = 0;
ide-disk.c:	if ((drive->id->cfs_enable_2 & 0x3000) && drive->wcache)
ide-disk.c:				drive->name);
ide-disk.c:	return drive->removable;	/* if removable, always assume it was changed */
ide-disk.c:	grok_partitions(HWIF(drive)->gd, drive->select.b.unit,
ide-disk.c:	if (!(drive->id->command_set_1 & 0x0400) &&
ide-disk.c:	    !(drive->id->cfs_enable_2 & 0x0100))
ide-disk.c:	args.hobRegister[IDE_CONTROL_OFFSET_HOB]= (drive->ctl|0x80);
ide-disk.c:	int flag = (drive->id->cfs_enable_1 & 0x0400) ? 1 : 0;
ide-disk.c:	printk("%s: host protected area => %d\n", drive->name, flag);
ide-disk.c: * Compute drive->capacity, the full capacity of the drive
ide-disk.c: * Called with drive->id != NULL.
ide-disk.c:	struct hd_driveid *id = drive->id;
ide-disk.c:	unsigned long capacity = drive->cyl * drive->head * drive->sect;
ide-disk.c:	drive->capacity48 = 0;
ide-disk.c:	drive->select.b.lba = 0;
ide-disk.c:		drive->cyl = (unsigned int) capacity_2 / (drive->head * drive->sect);
ide-disk.c:		drive->head		= drive->bios_head = 255;
ide-disk.c:		drive->sect		= drive->bios_sect = 63;
ide-disk.c:		drive->select.b.lba	= 1;
ide-disk.c:				drive->capacity48 = capacity_2 = set_max_ext;
ide-disk.c:				drive->cyl = (unsigned int) set_max_ext / (drive->head * drive->sect);
ide-disk.c:				drive->select.b.lba = 1;
ide-disk.c:				drive->id->lba_capacity_2 = capacity_2;
ide-disk.c:				drive->name, set_max_ext, capacity_2);
ide-disk.c:		drive->cyl = (unsigned int) capacity_2 / (drive->head * drive->sect);
ide-disk.c:		drive->bios_cyl		= drive->cyl;
ide-disk.c:		drive->capacity48	= capacity_2;
ide-disk.c:		drive->capacity		= (unsigned long) capacity_2;
ide-disk.c:		drive->cyl = capacity / (drive->head * drive->sect);
ide-disk.c:		drive->select.b.lba = 1;
ide-disk.c:			drive->capacity = capacity = set_max;
ide-disk.c:			drive->cyl = set_max / (drive->head * drive->sect);
ide-disk.c:			drive->select.b.lba = 1;
ide-disk.c:			drive->id->lba_capacity = capacity;
ide-disk.c:			drive->name, set_max, capacity);
ide-disk.c:	drive->capacity = capacity;
ide-disk.c:		drive->capacity48 = id->lba_capacity_2;
ide-disk.c:		drive->head = 255;
ide-disk.c:		drive->sect = 63;
ide-disk.c:		drive->cyl = (unsigned long)(drive->capacity48) / (drive->head * drive->sect);
ide-disk.c:	if (drive->id->cfs_enable_2 & 0x0400)
ide-disk.c:		return (drive->capacity48 - drive->sect0);
ide-disk.c:	return (drive->capacity - drive->sect0);
ide-disk.c:	special_t *s = &drive->special;
ide-disk.c:		taskfile.sector_number	= drive->sect;
ide-disk.c:		taskfile.low_cylinder	= drive->cyl;
ide-disk.c:		taskfile.high_cylinder	= drive->cyl>>8;
ide-disk.c:		taskfile.device_head	= ((drive->head-1)|drive->select.all)&0xBF;
ide-disk.c:			taskfile.sector_count	= drive->sect;
ide-disk.c:			taskfile.sector_count	= drive->sect;
ide-disk.c:		if (drive->id && drive->mult_req > drive->id->max_multsect)
ide-disk.c:			drive->mult_req = drive->id->max_multsect;
ide-disk.c:			taskfile.sector_count	= drive->mult_req;
ide-disk.c:		printk(KERN_ERR "%s: bad special flag: 0x%02x\n", drive->name, special);
ide-disk.c:	int legacy = (drive->id->cfs_enable_2 & 0x0400) ? 0 : 1;
ide-disk.c:	drive->special.all = 0;
ide-disk.c:	drive->special.b.set_geometry = legacy;
ide-disk.c:	drive->special.b.recalibrate  = legacy;
ide-disk.c:		drive->mult_count = 0;
ide-disk.c:	if (!drive->keep_settings && !drive->using_dma)
ide-disk.c:		drive->mult_req = 0;
ide-disk.c:	if (drive->mult_req != drive->mult_count)
ide-disk.c:		drive->special.b.set_multmode = 1;
ide-disk.c:	if (drive->id)
ide-disk.c:		len = sprintf(out,"%i\n", drive->id->buf_size / 2);
ide-disk.c:	if (drive->special.b.set_multmode)
ide-disk.c:	drive->mult_req = arg;
ide-disk.c:	drive->special.b.set_multmode = 1;
ide-disk.c:	return (drive->mult_count == arg) ? 0 : -EIO;
ide-disk.c:	drive->nowerr = arg;
ide-disk.c:	drive->bad_wstat = arg ? BAD_R_STAT : BAD_W_STAT;
ide-disk.c:	if (!(drive->id->cfs_enable_2 & 0x3000))
ide-disk.c:	drive->wcache = arg;
ide-disk.c:	if (drive->id->cfs_enable_2 & 0x2400) {
ide-disk.c:	drive->acoustic = arg;
ide-disk.c:	drive->addressing =  0;
ide-disk.c:	if (!(drive->id->cfs_enable_2 & 0x0400))
ide-disk.c:	drive->addressing = arg;
ide-disk.c:	struct hd_driveid *id = drive->id;
ide-disk.c:	int minor = drive->select.b.unit << PARTN_BITS;
ide-disk.c:	ide_add_setting(drive,	"bios_cyl",		SETTING_RW,					-1,			-1,			TYPE_INT,	0,	65535,				1,	1,	&drive->bios_cyl,		NULL);
ide-disk.c:	ide_add_setting(drive,	"bios_head",		SETTING_RW,					-1,			-1,			TYPE_BYTE,	0,	255,				1,	1,	&drive->bios_head,		NULL);
ide-disk.c:	ide_add_setting(drive,	"bios_sect",		SETTING_RW,					-1,			-1,			TYPE_BYTE,	0,	63,				1,	1,	&drive->bios_sect,		NULL);
ide-disk.c:	ide_add_setting(drive,	"address",		SETTING_RW,					HDIO_GET_ADDRESS,	HDIO_SET_ADDRESS,	TYPE_INTA,	0,	2,				1,	1,	&drive->addressing,	set_lba_addressing);
ide-disk.c:	ide_add_setting(drive,	"bswap",		SETTING_READ,					-1,			-1,			TYPE_BYTE,	0,	1,				1,	1,	&drive->bswap,			NULL);
ide-disk.c:	ide_add_setting(drive,	"multcount",		id ? SETTING_RW : SETTING_READ,			HDIO_GET_MULTCOUNT,	HDIO_SET_MULTCOUNT,	TYPE_BYTE,	0,	id ? id->max_multsect : 0,	1,	1,	&drive->mult_count,		set_multcount);
ide-disk.c:	ide_add_setting(drive,	"nowerr",		SETTING_RW,					HDIO_GET_NOWERR,	HDIO_SET_NOWERR,	TYPE_BYTE,	0,	1,				1,	1,	&drive->nowerr,			set_nowerr);
ide-disk.c:	ide_add_setting(drive,	"lun",			SETTING_RW,					-1,			-1,			TYPE_INT,	0,	7,				1,	1,	&drive->lun,			NULL);
ide-disk.c:	ide_add_setting(drive,	"wcache",		SETTING_RW,					HDIO_GET_WCACHE,	HDIO_SET_WCACHE,	TYPE_BYTE,	0,	1,				1,	1,	&drive->wcache,			write_cache);
ide-disk.c:	ide_add_setting(drive,	"acoustic",		SETTING_RW,					HDIO_GET_ACOUSTIC,	HDIO_SET_ACOUSTIC,	TYPE_BYTE,	0,	254,				1,	1,	&drive->acoustic,		set_acoustic);
ide-disk.c: 	ide_add_setting(drive,	"failures",		SETTING_RW,					-1,			-1,			TYPE_INT,	0,	65535,				1,	1,	&drive->failures,		NULL);
ide-disk.c: 	ide_add_setting(drive,	"max_failures",		SETTING_RW,					-1,			-1,			TYPE_INT,	0,	65535,				1,	1,	&drive->max_failures,		NULL);
ide-disk.c:	struct hd_driveid *id = drive->id;
ide-disk.c:	if (drive->removable && !drive_is_flashcard(drive)) {
ide-disk.c:			drive->doorlocking = 1;
ide-disk.c:		hwif->gd->de_arr[i] = drive->de;
ide-disk.c:		if (drive->removable)
ide-disk.c:	if (!drive->cyl || !drive->head || !drive->sect) {
ide-disk.c:		drive->cyl     = drive->bios_cyl  = id->cyls;
ide-disk.c:		drive->head    = drive->bios_head = id->heads;
ide-disk.c:		drive->sect    = drive->bios_sect = id->sectors;
ide-disk.c:		drive->cyl  = id->cur_cyls;
ide-disk.c:		drive->head = id->cur_heads;
ide-disk.c:		drive->sect = id->cur_sectors;
ide-disk.c:	if (drive->head > 16 && id->heads && id->heads <= 16) {
ide-disk.c:		drive->cyl  = id->cyls;
ide-disk.c:		drive->head = id->heads;
ide-disk.c:		drive->sect = id->sectors;
ide-disk.c:	if ((capacity >= (drive->bios_cyl * drive->bios_sect * drive->bios_head)) &&
ide-disk.c:	    (!drive->forced_geom) && drive->bios_sect && drive->bios_head)
ide-disk.c:		drive->bios_cyl = (capacity / drive->bios_sect) / drive->bios_head;
ide-disk.c:	printk (KERN_INFO "%s: %ld sectors", drive->name, capacity);
ide-disk.c:	       drive->bios_cyl, drive->bios_head, drive->bios_sect);
ide-disk.c:	if (drive->using_dma)
ide-disk.c:	drive->mult_count = 0;
ide-disk.c:		drive->mult_req = id->multsect_valid ? id->max_multsect : INITIAL_MULT_COUNT;
ide-disk.c:		drive->special.b.set_multmode = drive->mult_req ? 1 : 0;
ide-disk.c:		drive->mult_req = INITIAL_MULT_COUNT;
ide-disk.c:		if (drive->mult_req > id->max_multsect)
ide-disk.c:			drive->mult_req = id->max_multsect;
ide-disk.c:		if (drive->mult_req || ((id->multsect_valid & 1) && id->multsect))
ide-disk.c:			drive->special.b.set_multmode = 1;
ide-disk.c:	drive->no_io_32bit = id->dword_io ? 1 : 0;
ide-disk.c:	if (drive->id->cfs_enable_2 & 0x3000)
ide-disk.c:		blk_queue_max_sectors(&drive->queue, 2048);
ide-disk.c:	if ((drive->id->cfs_enable_2 & 0x3000) && drive->wcache)
ide-disk.c:				drive->name);
ide-disk.c:		printk (KERN_ERR "ide-disk: %s: Failed to register the driver with ide.c\n", drive->name);
ide-disk.c:	if ((!drive->head || drive->head > 16) && !drive->select.b.lba) {
ide-disk.c:		printk(KERN_ERR "%s: INVALID GEOMETRY: %d PHYSICAL HEADS?\n", drive->name, drive->head);
ide-disk.c:			printk (KERN_ERR "%s: cleanup_module() called while still busy\n", drive->name);
ide-disk.c:		if (drive->proc)
ide-disk.c:			ide_remove_proc_entries(drive->proc, idedisk_proc);
ide-disk.c:			printk (KERN_ERR "ide-disk: %s: Failed to register the driver with ide.c\n", drive->name);
ide-disk.c:		if ((!drive->head || drive->head > 16) && !drive->select.b.lba) {
ide-disk.c:			printk(KERN_ERR "%s: INVALID GEOMETRY: %d PHYSICAL HEADS?\n", drive->name, drive->head);
ide-dma.c:	if (OK_STAT(stat,DRIVE_READY,drive->bad_wstat|DRQ_STAT)) {
ide-dma.c:		       drive->name, dma_stat);
ide-dma.c:				printk("%s: DMA table too small\n", drive->name);
ide-dma.c:						printk("%s: DMA table too small\n", drive->name);
ide-dma.c:	printk("%s: empty DMA table?\n", drive->name);
ide-dma.c:	struct hd_driveid *id = drive->id;
ide-dma.c:			printk("%s: Disabling (U)DMA for %s\n", drive->name, id->model);
ide-dma.c:					drive->name, id->model);
ide-dma.c:	struct hd_driveid *id = drive->id;
ide-dma.c:	struct hd_driveid *id = drive->id;
ide-dma.c:	printk("%s: dma_timer_expiry: dma status == 0x%02x\n", drive->name, dma_stat);
ide-dma.c:	int enable_dma		= drive->using_dma;
ide-dma.c:	drive->waiting_for_dma = 0;
ide-dma.c:	if ((enable_dma) && !(drive->using_dma))
ide-dma.c:	byte unit			= (drive->select.b.unit & 0x01);
ide-dma.c:			printk("%s: DMA disabled\n", drive->name);
ide-dma.c:			drive->using_dma = (func == ide_dma_on);
ide-dma.c:			if (drive->using_dma)
ide-dma.c:			drive->waiting_for_dma = 1;
ide-dma.c:			if (drive->media != ide_disk)
ide-dma.c:			    (drive->addressing == 1)) {
ide-dma.c:			} else if (drive->addressing) {
ide-dma.c:			drive->waiting_for_dma = 0;
ide-dma.c:				drive->name, ide_dmafunc_verbose(func),
ide-dma.c:				drive->name, ide_dmafunc_verbose(func),
ide-features.c:	switch (drive->media) {
ide-features.c:	if (!drive->crc_count)
ide-features.c:		return drive->current_speed;
ide-features.c:	drive->crc_count = 0;
ide-features.c:	switch(drive->current_speed) {
ide-features.c:	 * Re-read drive->id for possible DMA mode
ide-features.c:		OUT_BYTE(drive->ctl,IDE_CONTROL_REG);
ide-features.c:		printk("%s: CHECK for good STATUS\n", drive->name);
ide-features.c:		drive->id->dma_ultra = id->dma_ultra;
ide-features.c:		drive->id->dma_mword = id->dma_mword;
ide-features.c:		drive->id->dma_1word = id->dma_1word;
ide-features.c:		if ((drive->id->hw_config & 0x6000) == 0) {
ide-features.c:		if (((drive->id->hw_config & 0x2000) == 0) ||
ide-features.c:		    ((drive->id->hw_config & 0x4000) == 0)) {
ide-features.c:			printk("%s: Speed warnings UDMA 3/4/5 is not functional.\n", drive->name);
ide-features.c: * 1 : Safe to update drive->id DMA registers.
ide-features.c:	    (drive->id->dma_ultra ||
ide-features.c:	     drive->id->dma_mword ||
ide-features.c:	     drive->id->dma_1word))
ide-features.c:			(drive->id->hw_config & 0x4000) &&
ide-features.c:			(drive->id->hw_config & 0x6000)) ? 1 : 0);
ide-features.c:	byte unit = (drive->select.b.unit & 0x01);
ide-features.c:		OUT_BYTE(drive->ctl | 2, IDE_CONTROL_REG);
ide-features.c:	if ((IDE_CONTROL_REG) && (drive->quirk_list == 2))
ide-features.c:		OUT_BYTE(drive->ctl, IDE_CONTROL_REG);
ide-features.c:	drive->id->dma_ultra &= ~0xFF00;
ide-features.c:	drive->id->dma_mword &= ~0x0F00;
ide-features.c:	drive->id->dma_1word &= ~0x0F00;
ide-features.c:		case XFER_UDMA_7:   drive->id->dma_ultra |= 0x8080; break;
ide-features.c:		case XFER_UDMA_6:   drive->id->dma_ultra |= 0x4040; break;
ide-features.c:		case XFER_UDMA_5:   drive->id->dma_ultra |= 0x2020; break;
ide-features.c:		case XFER_UDMA_4:   drive->id->dma_ultra |= 0x1010; break;
ide-features.c:		case XFER_UDMA_3:   drive->id->dma_ultra |= 0x0808; break;
ide-features.c:		case XFER_UDMA_2:   drive->id->dma_ultra |= 0x0404; break;
ide-features.c:		case XFER_UDMA_1:   drive->id->dma_ultra |= 0x0202; break;
ide-features.c:		case XFER_UDMA_0:   drive->id->dma_ultra |= 0x0101; break;
ide-features.c:		case XFER_MW_DMA_2: drive->id->dma_mword |= 0x0404; break;
ide-features.c:		case XFER_MW_DMA_1: drive->id->dma_mword |= 0x0202; break;
ide-features.c:		case XFER_MW_DMA_0: drive->id->dma_mword |= 0x0101; break;
ide-features.c:		case XFER_SW_DMA_2: drive->id->dma_1word |= 0x0404; break;
ide-features.c:		case XFER_SW_DMA_1: drive->id->dma_1word |= 0x0202; break;
ide-features.c:		case XFER_SW_DMA_0: drive->id->dma_1word |= 0x0101; break;
ide-floppy.c:	idefloppy_floppy_t *floppy = drive->driver_data;
ide-floppy.c:			printk (KERN_ERR "%s: bh == NULL in idefloppy_input_buffers, bcount == %d\n", drive->name, bcount);
ide-floppy.c:			printk (KERN_ERR "%s: bh == NULL in idefloppy_output_buffers, bcount == %d\n", drive->name, bcount);
ide-floppy.c:	idefloppy_floppy_t *floppy = drive->driver_data;
ide-floppy.c:	idefloppy_floppy_t *floppy = drive->driver_data;
ide-floppy.c:	idefloppy_floppy_t *floppy = drive->driver_data;
ide-floppy.c:	idefloppy_floppy_t *floppy = drive->driver_data;
ide-floppy.c:	idefloppy_floppy_t *floppy = drive->driver_data;
ide-floppy.c:	idefloppy_floppy_t *floppy = drive->driver_data;
ide-floppy.c:			printk (KERN_INFO "ide-floppy: %s: I/O error\n",drive->name);
ide-floppy.c:	idefloppy_floppy_t *floppy = drive->driver_data;
ide-floppy.c:	idefloppy_floppy_t *floppy = drive->driver_data;
ide-floppy.c:	idefloppy_floppy_t *floppy = drive->driver_data;
ide-floppy.c:	idefloppy_floppy_t *floppy = drive->driver_data;
ide-floppy.c:				drive->name, pc->c[0], floppy->sense_key, floppy->asc, floppy->ascq);
ide-floppy.c:	if (test_bit (PC_DMA_RECOMMENDED, &pc->flags) && drive->using_dma)
ide-floppy.c:		OUT_BYTE (drive->ctl,IDE_CONTROL_REG);
ide-floppy.c:	OUT_BYTE (drive->select.all,IDE_SELECT_REG);
ide-floppy.c:	idefloppy_floppy_t *floppy = drive->driver_data;
ide-floppy.c:				drive->name, floppy->failed_pc->c[0], floppy->sense_key, floppy->asc, floppy->ascq);
ide-floppy.c:			printk (KERN_ERR "ide-floppy: %s: I/O error\n", drive->name);
ide-floppy.c:				printk ("%s: unsupported r/w request size\n", drive->name);
ide-floppy.c:	idefloppy_floppy_t *floppy = drive->driver_data;
ide-floppy.c:			drive->name, capacity / 1024, page->cyls, page->heads, page->sectors,
ide-floppy.c:	drive->bios_cyl = page->cyls;
ide-floppy.c:	drive->bios_head = page->heads;
ide-floppy.c:	drive->bios_sect = page->sectors;
ide-floppy.c:			drive->name, lba_capacity, capacity);
ide-floppy.c:	idefloppy_floppy_t *floppy = drive->driver_data;
ide-floppy.c:	idefloppy_floppy_t *floppy = drive->driver_data;
ide-floppy.c:	drive->bios_cyl = 0;
ide-floppy.c:	drive->bios_head = drive->bios_sect = 0;
ide-floppy.c:	drive->part[0].nr_sects = 0;
ide-floppy.c:                                printk (KERN_INFO "%s: %dkB, %d blocks, %d sector size\n", drive->name, blocks * length / 1024, blocks, length);
ide-floppy.c:                                printk (KERN_NOTICE "%s: %d bytes block size not supported\n", drive->name, length);
ide-floppy.c:                                        printk (KERN_NOTICE "%s: warning: non 512 bytes block size not fully supported\n", drive->name);
ide-floppy.c:                        printk (KERN_ERR "%s: No disk in drive\n", drive->name);
ide-floppy.c:                        printk (KERN_ERR "%s: Invalid capacity for disk in drive\n", drive->name);
ide-floppy.c:	drive->part[0].nr_sects = floppy->blocks * floppy->bs_factor;
ide-floppy.c:	idefloppy_floppy_t *floppy = drive->driver_data;
ide-floppy.c:	idefloppy_floppy_t *floppy = drive->driver_data;
ide-floppy.c:		if (drive->usage > 1)
ide-floppy.c:			idefloppy_floppy_t *floppy = drive->driver_data;
ide-floppy.c:			if (drive->usage > 1)
ide-floppy.c:	idefloppy_floppy_t *floppy = drive->driver_data;
ide-floppy.c:	if (drive->usage == 1) {
ide-floppy.c:			drive->usage--;
ide-floppy.c:			drive->usage--;
ide-floppy.c:		drive->usage--;
ide-floppy.c:	if (!drive->usage) {
ide-floppy.c:		idefloppy_floppy_t *floppy = drive->driver_data;
ide-floppy.c:	idefloppy_floppy_t *floppy = drive->driver_data;
ide-floppy.c:	grok_partitions(HWIF(drive)->gd, drive->select.b.unit,
ide-floppy.c:	idefloppy_floppy_t *floppy = drive->driver_data;
ide-floppy.c:	int minor = drive->select.b.unit << PARTN_BITS;
ide-floppy.c:	idefloppy_floppy_t *floppy = drive->driver_data;
ide-floppy.c:	ide_add_setting(drive,	"bios_cyl",		SETTING_RW,					-1,			-1,			TYPE_INT,	0,	1023,				1,	1,	&drive->bios_cyl,		NULL);
ide-floppy.c:	ide_add_setting(drive,	"bios_head",		SETTING_RW,					-1,			-1,			TYPE_BYTE,	0,	255,				1,	1,	&drive->bios_head,		NULL);
ide-floppy.c:	ide_add_setting(drive,	"bios_sect",		SETTING_RW,					-1,			-1,			TYPE_BYTE,	0,	63,				1,	1,	&drive->bios_sect,		NULL);
ide-floppy.c:	int minor = drive->select.b.unit << PARTN_BITS;
ide-floppy.c:	*((unsigned short *) &gcw) = drive->id->config;
ide-floppy.c:	drive->driver_data = floppy;
ide-floppy.c:	drive->ready_stat = 0;
ide-floppy.c:	if (strcmp(drive->id->model, "IOMEGA ZIP 100 ATAPI") == 0)
ide-floppy.c:	if (strcmp(drive->id->model, "IOMEGA Clik! 40 CZ ATAPI") == 0) 
ide-floppy.c:		hwif->gd->de_arr[i] = drive->de;
ide-floppy.c:		if (drive->removable)
ide-floppy.c:	idefloppy_floppy_t *floppy = drive->driver_data;
ide-floppy.c:	drive->driver_data = NULL;
ide-floppy.c:		if (!idefloppy_identify_device (drive, drive->id)) {
ide-floppy.c:			printk (KERN_ERR "ide-floppy: %s: not supported by this version of ide-floppy\n", drive->name);
ide-floppy.c:		if (drive->scsi) {
ide-floppy.c:			printk("ide-floppy: passing drive %s to ide-scsi emulation.\n", drive->name);
ide-floppy.c:			printk (KERN_ERR "ide-floppy: %s: Can't allocate a floppy structure\n", drive->name);
ide-floppy.c:			printk (KERN_ERR "ide-floppy: %s: Failed to register the driver with ide.c\n", drive->name);
ide-floppy.c:			printk ("%s: cleanup_module() called while still busy\n", drive->name);
ide-floppy.c:		if (drive->proc)
ide-floppy.c:			ide_remove_proc_entries(drive->proc, idefloppy_proc);
ide-floppy.c:		if (!idefloppy_identify_device (drive, drive->id)) {
ide-floppy.c:			printk (KERN_ERR "ide-floppy: %s: not supported by this version of ide-floppy\n", drive->name);
ide-floppy.c:		if (drive->scsi) {
ide-floppy.c:			printk("ide-floppy: passing drive %s to ide-scsi emulation.\n", drive->name);
ide-floppy.c:			printk (KERN_ERR "ide-floppy: %s: Can't allocate a floppy structure\n", drive->name);
ide-floppy.c:			printk (KERN_ERR "ide-floppy: %s: Failed to register the driver with ide.c\n", drive->name);
ide-geometry.c: * Consequently, also the former "drive->present = 1" below was a mistake.
ide-geometry.c:		   && !drive->present && !drive->nobios) {
ide-geometry.c:				drive->cyl   = drive->bios_cyl  = cyl;
ide-geometry.c:				drive->head  = drive->bios_head = head;
ide-geometry.c:				drive->sect  = drive->bios_sect = sect;
ide-geometry.c:				drive->ctl   = *(BIOS+8);
ide-geometry.c:	if (drive->remap_0_to_1 != 2) {
ide-geometry.c:			drive->sect0 = 63;
ide-geometry.c:			if (drive->remap_0_to_1 == 0) {
ide-geometry.c:				drive->remap_0_to_1 = 1;
ide-geometry.c:	/* There used to be code here that assigned drive->id->CHS
ide-geometry.c:	   to drive->CHS and that to drive->bios_CHS. However,
ide-geometry.c:	if (drive->forced_geom)
ide-geometry.c:		   (drive->bios_head >= heads && drive->bios_sect == 63))
ide-geometry.c:		if (drive->bios_head > 16)
ide-geometry.c:		drive->bios_cyl = c;
ide-geometry.c:		drive->bios_head = h;
ide-geometry.c:		drive->bios_sect = s;
ide-geometry.c:	drive->part[0].nr_sects = current_capacity(drive);
ide-geometry.c:		       drive->bios_cyl, drive->bios_head, drive->bios_sect);
ide-pmac.c:	if (drive->select.b.unit & 0x01)
ide-pmac.c:			if (drive->ready_stat == 0)
ide-pmac.c:			else if((stat & drive->ready_stat) || (stat & ERR_STAT))
ide-pmac.c:	OUT_BYTE(drive->ctl | 2, IDE_CONTROL_REG);
ide-pmac.c:	OUT_BYTE(drive->ctl, IDE_CONTROL_REG);
ide-pmac.c:	if (drive->select.b.unit & 0x01)
ide-pmac.c:	if (drive->select.all == IN_BYTE(IDE_SELECT_REG))
ide-pmac.c:	int unit		= (drive->select.b.unit & 0x01);
ide-pmac.c:	drive->current_speed = speed;
ide-pmac.c:				       drive->name);
ide-pmac.c:		printk(KERN_DEBUG "%s: empty DMA table?\n", drive->name);
ide-pmac.c:	byte bits = drive->id->dma_mword & 0x07;
ide-pmac.c:	struct hd_driveid *id = drive->id;
ide-pmac.c:    	printk(KERN_INFO "%s: Enabling MultiWord DMA %d\n", drive->name, feature & 0xf);
ide-pmac.c:	    	printk(KERN_WARNING "%s: Failed !\n", drive->name);
ide-pmac.c:	if (!drive->init_speed)
ide-pmac.c:		drive->init_speed = feature;
ide-pmac.c:	if (drive->select.b.unit & 0x01)
ide-pmac.c:	drive->current_speed = feature;	
ide-pmac.c:	byte bits = drive->id->dma_ultra & 0x1f;
ide-pmac.c:    	printk(KERN_INFO "%s: Enabling Ultra DMA %d\n", drive->name, feature & 0xf);
ide-pmac.c:		printk(KERN_WARNING "%s: Failed !\n", drive->name);
ide-pmac.c:	if (!drive->init_speed)
ide-pmac.c:		drive->init_speed = feature;
ide-pmac.c:	if (drive->select.b.unit & 0x01)
ide-pmac.c:	drive->current_speed = feature;	
ide-pmac.c:	struct hd_driveid *id = drive->id;
ide-pmac.c:	drive->using_dma = 0;
ide-pmac.c:	if (drive->media == ide_floppy)
ide-pmac.c:		if (ata4 && (drive->media == ide_disk) &&
ide-pmac.c:			drive->using_dma = pmac_ide_udma_enable(drive, idx,
ide-pmac.c:		if (!drive->using_dma && (id->dma_mword & 0x0007)) {
ide-pmac.c:			drive->using_dma = pmac_ide_mdma_enable(drive, idx);
ide-pmac.c:	byte unit = (drive->select.b.unit & 0x01);
ide-pmac.c:		printk(KERN_INFO "%s: DMA disabled\n", drive->name);
ide-pmac.c:		drive->using_dma = 0;
ide-pmac.c:		drive->waiting_for_dma = 1;
ide-pmac.c:		if (drive->media != ide_disk)
ide-pmac.c:		drive->waiting_for_dma = 0;
ide-pmac.c:		 * The trick here is to increment drive->waiting_for_dma,
ide-pmac.c:		if (!drive->waiting_for_dma)
ide-pmac.c:		drive->waiting_for_dma++;
ide-pmac.c:		if (drive->waiting_for_dma >= DMA_WAIT_TIMEOUT) {
ide-pmac.c:	switch (drive->media) {
ide-pmac.c:		outb(drive->select.all, base+0x60);
ide-pmac.c:	check_disk_change(MKDEV(HWIF(drive)->major, (drive->select.b.unit) << PARTN_BITS));
ide-pmac.c:		outb(drive->select.all, base + 0x60);
ide-pmac.c:		if (inb(base + 0x60) != drive->select.all)
ide-pmac.c:	if (!list_empty(&drive->queue.queue_head))
ide-pmac.c:				if (!drive->present)
ide-pmac.c:				used_dma = drive->using_dma;
ide-pmac.c:				drive->using_dma = 0;
ide-pmac.c:			if (drive->present) {
ide-probe.c: *			 with new flag : drive->ata_flash : 1;
ide-probe.c:	id = drive->id = kmalloc (SECTOR_WORDS*4, GFP_ATOMIC);	/* called with interrupts disabled! */
ide-probe.c:		printk("%s: drive->id->word156 == 0x%04x \n", drive->name, drive->id->word156);
ide-probe.c:	if (!drive->forced_lun)
ide-probe.c:		drive->last_lun = id->last_lun & 0x7;
ide-probe.c:		printk("%s: EATA SCSI HBA %.10s\n", drive->name, id->model);
ide-probe.c:	printk("%s: %s, ", drive->name, id->model);
ide-probe.c:	drive->present = 1;
ide-probe.c:					if (drive->media != ide_cdrom) {
ide-probe.c:				drive->removable = 1;
ide-probe.c:				drive->removable = 1;
ide-probe.c:		drive->media = type;
ide-probe.c:		drive->removable = 1;
ide-probe.c:		ide_drive_t *mate = &HWIF(drive)->drives[1^drive->select.b.unit];
ide-probe.c:	drive->media = ide_disk;
ide-probe.c:	drive->present = 0;
ide-probe.c:			printk("%s: probing with STATUS(0x%02x) instead of ALTSTATUS(0x%02x)\n", drive->name, s, a);
ide-probe.c:		OUT_BYTE(drive->ctl,IDE_CONTROL_REG);	/* enable device irq */
ide-probe.c:		OUT_BYTE(drive->ctl|2,IDE_CONTROL_REG);	/* mask device irq */
ide-probe.c:				printk("%s: IRQ probe failed (0x%lx)\n", drive->name, cookie);
ide-probe.c:					printk("%s: Hmmm.. probably a driver problem.\n", drive->name);
ide-probe.c:	if (drive->present) {	/* avoid waiting for inappropriate probes */
ide-probe.c:		if ((drive->media != ide_disk) && (cmd == WIN_IDENTIFY))
ide-probe.c:		drive->name, drive->present, drive->media,
ide-probe.c:	if (IN_BYTE(IDE_SELECT_REG) != drive->select.all && !drive->present) {
ide-probe.c:		if (drive->select.b.unit != 0) {
ide-probe.c:	 || drive->present || cmd == WIN_PIDENTIFY)
ide-probe.c:		if (rc == 1 && cmd == WIN_PIDENTIFY && drive->autotune != 2) {
ide-probe.c:			printk("%s: no response (status = 0x%02x), resetting drive\n", drive->name, GET_STAT());
ide-probe.c:			OUT_BYTE (drive->select.all, IDE_SELECT_REG);
ide-probe.c:			printk("%s: no response (status = 0x%02x)\n", drive->name, GET_STAT());
ide-probe.c:	if (drive->select.b.unit != 0) {
ide-probe.c:	printk("%s: enabling %s -- ", HWIF(drive)->name, drive->id->model);
ide-probe.c: *		1  device was found (note: drive->present might still be 0)
ide-probe.c:	if (drive->noprobe)			/* skip probing? */
ide-probe.c:		return drive->present;
ide-probe.c:	if (drive->id && strstr(drive->id->model, "E X A B Y T E N E S T"))
ide-probe.c:	if (!drive->present)
ide-probe.c:	if (drive->id == NULL) {		/* identification failed? */
ide-probe.c:		if (drive->media == ide_disk) {
ide-probe.c:			 drive->name, drive->cyl, drive->head, drive->sect);
ide-probe.c:		} else if (drive->media == ide_cdrom) {
ide-probe.c:			printk("%s: ATAPI cdrom (?)\n", drive->name);
ide-probe.c:			drive->present = 0;	/* nuke it */
ide-probe.c:			if (drive->present) {
ide-probe.c:				drive->present = 0;
ide-probe.c:				printk("%s: ERROR, PORTS ALREADY IN USE\n", drive->name);
ide-probe.c:		if (drive->present && !hwif->present) {
ide-probe.c:		if (drive->present) {
ide-probe.c:			if (tuneproc != NULL && drive->autotune == 1)
ide-probe.c:	request_queue_t *q = &drive->queue;
ide-probe.c:	if (drive->media == ide_disk) {
ide-probe.c:		if (!drive->present)
ide-probe.c:		drive->next = hwgroup->drive->next;
ide-probe.c:		hwgroup->drive->next = drive;
ide-proc.c:	taskfile.command = (drive->media == ide_disk) ? WIN_IDENTIFY : WIN_PIDENTIFY ;
ide-proc.c:	ide_settings_t	*setting = (ide_settings_t *) drive->settings;
ide-proc.c:	ide_driver_t    *driver = (ide_driver_t *) drive->driver;
ide-proc.c:		len = sprintf(page,"%llu\n", (__u64) ((ide_driver_t *)drive->driver)->capacity(drive));
ide-proc.c:	out += sprintf(out,"physical     %d/%d/%d\n", drive->cyl, drive->head, drive->sect);
ide-proc.c:	out += sprintf(out,"logical      %d/%d/%d\n", drive->bios_cyl, drive->bios_head, drive->bios_sect);
ide-proc.c:	struct hd_driveid *id = drive->id;
ide-proc.c:	ide_driver_t	*driver = (ide_driver_t *) drive->driver;
ide-proc.c:	switch (drive->media) {
ide-proc.c:		ide_driver_t *driver = drive->driver;
ide-proc.c:		if (!drive->present)
ide-proc.c:		if (drive->proc)
ide-proc.c:		drive->proc = proc_mkdir(drive->name, parent);
ide-proc.c:		if (drive->proc) {
ide-proc.c:			ide_add_proc_entries(drive->proc, generic_drive_entries, drive);
ide-proc.c:				ide_add_proc_entries(drive->proc, generic_subdriver_entries, drive);
ide-proc.c:				ide_add_proc_entries(drive->proc, driver->proc, drive);
ide-proc.c:		sprintf(name,"ide%d/%s", (drive->name[2]-'a')/2, drive->name);
ide-proc.c:		ent = proc_symlink(drive->name, proc_ide_root, name);
ide-proc.c://	ide_driver_t *driver = drive->driver;
ide-proc.c:	if (drive->present && !drive->proc) {
ide-proc.c:		drive->proc = proc_mkdir(drive->name, parent);
ide-proc.c:		if (drive->proc)
ide-proc.c:			ide_add_proc_entries(drive->proc, generic_drive_entries, drive);
ide-proc.c: *      ide_add_proc_entries(drive->proc, generic_subdriver_entries, drive);
ide-proc.c: *      ide_add_proc_entries(drive->proc, driver->proc, drive);
ide-proc.c:		sprintf(name,"ide%d/%s", (drive->name[2]-'a')/2, drive->name);
ide-proc.c:		ent = proc_symlink(drive->name, proc_ide_root, name);
ide-proc.c:	ide_driver_t *driver = drive->driver;
ide-proc.c:	if (drive->proc) {
ide-proc.c:			ide_remove_proc_entries(drive->proc, driver->proc);
ide-proc.c:		ide_remove_proc_entries(drive->proc, generic_drive_entries);
ide-proc.c:		remove_proc_entry(drive->name, proc_ide_root);
ide-proc.c:		remove_proc_entry(drive->name, hwif->proc);
ide-proc.c:		drive->proc = NULL;
ide-proc.c://		ide_driver_t *driver = drive->driver;
ide-proc.c:		if (drive->proc)
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	if (test_bit (PC_DMA_RECOMMENDED, &pc->flags) && drive->using_dma)
ide-tape.c:		OUT_BYTE (drive->ctl, IDE_CONTROL_REG);
ide-tape.c:	OUT_BYTE (drive->select.all, IDE_SELECT_REG);
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:		printk (KERN_NOTICE "ide-tape: %s: Unsupported command in request queue (%d)\n", drive->name, rq->cmd);
ide-tape.c:	if (!drive->dsc_overlap && rq->cmd != IDETAPE_PC_RQ2)
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	printk(KERN_INFO "ide-tape: %s <-> %s: %s %s rev %s\n", drive->name, tape->name, tape->vendor_id, tape->product_id, tape->firmware_revision);
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:               drive->name, tape->name, tape->capacity/32, ntohs(prm->segtrk), ntohs(prm->trks), tape->capacity, prm->density);
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:		printk(KERN_INFO "ide-tape: %s: overriding capabilities->speed (assuming 650KB/sec)\n", drive->name);
ide-tape.c:		printk(KERN_INFO "ide-tape: %s: overriding capabilities->max_speed (assuming 650KB/sec)\n", drive->name);
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	ide_add_setting(drive,	"dsc_overlap",	SETTING_RW,	-1,	-1,		TYPE_BYTE,	0,			1,			1,				1,				&drive->dsc_overlap,			NULL);
ide-tape.c:	drive->driver_data = tape;
ide-tape.c:	drive->ready_stat = 0;			/* An ATAPI device ignores DRDY */
ide-tape.c:	if (strstr(drive->id->model, "OnStream DI-"))
ide-tape.c:	drive->dsc_overlap = 1;
ide-tape.c:		    	drive->dsc_overlap = 0;
ide-tape.c:	*((unsigned short *) &gcw) = drive->id->config;
ide-tape.c:		drive->name, tape->name, tape->capabilities.speed, (tape->capabilities.buffer_size * 512) / tape->stage_size,
ide-tape.c:		tape->best_dsc_rw_frequency * 1000 / HZ, drive->using_dma ? ", DMA":"");
ide-tape.c:	idetape_tape_t *tape = drive->driver_data;
ide-tape.c:	if (test_bit (IDETAPE_BUSY, &tape->flags) || tape->first_stage != NULL || tape->merge_stage_size || drive->usage) {
ide-tape.c:	drive->driver_data = NULL;
ide-tape.c:	idetape_tape_t	*tape = drive->driver_data;
ide-tape.c:		if (!idetape_identify_device (drive, drive->id)) {
ide-tape.c:			printk (KERN_ERR "ide-tape: %s: not supported by this version of ide-tape\n", drive->name);
ide-tape.c:		if (drive->scsi) {
ide-tape.c:			if (strstr(drive->id->model, "OnStream DI-30")) {
ide-tape.c:				printk("ide-tape: ide-scsi emulation is not supported for %s.\n", drive->id->model);
ide-tape.c:				printk("ide-tape: passing drive %s to ide-scsi emulation.\n", drive->name);
ide-tape.c:			printk (KERN_ERR "ide-tape: %s: Can't allocate a tape structure\n", drive->name);
ide-tape.c:			printk (KERN_ERR "ide-tape: %s: Failed to register the driver with ide.c\n", drive->name);
ide-tape.c:		    devfs_register (drive->de, "mt", DEVFS_FL_DEFAULT,
ide-tape.c:		    devfs_register (drive->de, "mtn", DEVFS_FL_DEFAULT,
ide-tape.c:		printk (KERN_ERR "ide-tape: %s: cleanup_module() called while still busy\n", drive->name);
ide-tape.c:		if (!idetape_identify_device (drive, drive->id)) {
ide-tape.c:			printk (KERN_ERR "ide-tape: %s: not supported by this version of ide-tape\n", drive->name);
ide-tape.c:		if (drive->scsi) {
ide-tape.c:			if (strstr(drive->id->model, "OnStream DI-")) {
ide-tape.c:				printk("ide-tape: ide-scsi emulation is not supported for %s.\n", drive->id->model);
ide-tape.c:				printk("ide-tape: passing drive %s to ide-scsi emulation.\n", drive->name);
ide-tape.c:			printk (KERN_ERR "ide-tape: %s: Can't allocate a tape structure\n", drive->name);
ide-tape.c:			printk (KERN_ERR "ide-tape: %s: Failed to register the driver with ide.c\n", drive->name);
ide-tape.c:		    devfs_register (drive->de, "mt", DEVFS_FL_DEFAULT,
ide-tape.c:		    devfs_register (drive->de, "mtn", DEVFS_FL_DEFAULT,
ide-taskfile.c:	io_32bit = drive->io_32bit;
ide-taskfile.c:		if (drive->slow) {
ide-taskfile.c:	io_32bit = drive->io_32bit;
ide-taskfile.c:		if (drive->slow) {
ide-taskfile.c:	//printk("drive->bswap is %d\n",drive->bswap);
ide-taskfile.c:	if (drive->bswap)
ide-taskfile.c:	if (drive->bswap) {
ide-taskfile.c:	if (drive->waiting_for_dma)
ide-taskfile.c:			if (drive->ready_stat == 0)
ide-taskfile.c:			else if((stat & drive->ready_stat) || (stat & ERR_STAT))
ide-taskfile.c:			printk(KERN_ERR "%s: wait_for_ready, error status: %x\n", drive->name, stat);
ide-taskfile.c:	struct hd_driveid *id = drive->id;
ide-taskfile.c:	byte HIHI = (drive->addressing) ? 0xE0 : 0xEF;
ide-taskfile.c:			OUT_BYTE(drive->ctl, IDE_CONTROL_REG);	/* clear nIEN */
ide-taskfile.c:	    (drive->addressing == 1)) {
ide-taskfile.c:	OUT_BYTE((taskfile->device_head & HIHI) | drive->select.all, IDE_SELECT_REG);
ide-taskfile.c:		if (drive->using_dma && !(HWIF(drive)->dmaproc(((taskfile->command == WIN_WRITEDMA) || (taskfile->command == WIN_WRITEDMA_EXT)) ? ide_dma_write : ide_dma_read, drive)));
ide-taskfile.c:	struct hd_driveid *id = drive->id;
ide-taskfile.c:	byte HIHI = (drive->addressing) ? 0xE0 : 0xEF;
ide-taskfile.c:			OUT_BYTE(drive->ctl, IDE_CONTROL_REG);  /* clear nIEN */
ide-taskfile.c:	    (drive->addressing == 1)) {
ide-taskfile.c:	OUT_BYTE((taskfile->device_head & HIHI) | drive->select.all, IDE_SELECT_REG);
ide-taskfile.c:		if (drive->using_dma && !(HWIF(drive)->dmaproc(((taskfile->command == WIN_WRITEDMA) || (taskfile->command == WIN_WRITEDMA_EXT)) ? ide_dma_write : ide_dma_read, drive)));
ide-taskfile.c:	struct hd_driveid *id = drive->id;
ide-taskfile.c:		    (drive->addressing == 1)) {
ide-taskfile.c:		    (drive->addressing == 1)) {
ide-taskfile.c:		OUT_BYTE(drive->ctl, IDE_CONTROL_REG);	/* clear nIEN */
ide-taskfile.c:	OUT_BYTE(taskfile->device_head | drive->select.all, IDE_SELECT_REG);
ide-taskfile.c:		if (drive->using_dma && !(HWIF(drive)->dmaproc(((taskfile->command == WIN_WRITEDMA) || (taskfile->command == WIN_WRITEDMA_EXT)) ? ide_dma_write : ide_dma_read, drive)));
ide-taskfile.c:	printk("%s: %s: status=0x%02x", drive->name, msg, stat);
ide-taskfile.c:		printk("%s: %s: error=0x%02x", drive->name, msg, err);
ide-taskfile.c:		if (drive->media == ide_disk) {
ide-taskfile.c:				if ((drive->id->command_set_2 & 0x0400) &&
ide-taskfile.c:				    (drive->id->cfs_enable_2 & 0x0400) &&
ide-taskfile.c:				    (drive->addressing == 1)) {
ide-taskfile.c:	if ((drive->id->command_set_2 & 0x0400) &&
ide-taskfile.c:	    (drive->id->cfs_enable_2 & 0x0400) &&
ide-taskfile.c:	    (drive->addressing == 1)) {
ide-taskfile.c:		OUT_BYTE(drive->ctl|0x80, IDE_CONTROL_REG_HOB);
ide-taskfile.c:	int i = (drive->mult_count ? drive->mult_count : 1) * SECTOR_WORDS;
ide-taskfile.c:	if (drive->media != ide_disk)
ide-taskfile.c:	if (stat & BUSY_STAT || ((stat & WRERR_STAT) && !drive->nowerr)) { /* other bits are useless when BUSY */
ide-taskfile.c:		if (drive->media == ide_disk && (stat & ERR_STAT)) {
ide-taskfile.c:				if (drive->select.b.lba && IN_BYTE(IDE_COMMAND_REG) == WIN_SPECIFY)
ide-taskfile.c:				drive->crc_count++;	/* UDMA crc error -- just retry the operation */
ide-taskfile.c:		if (drive->driver != NULL)
ide-taskfile.c:			drive->special.b.recalibrate = 1;
ide-taskfile.c:		drive->mult_count = drive->mult_req;
ide-taskfile.c:		drive->mult_req = drive->mult_count = 0;
ide-taskfile.c:		drive->special.b.recalibrate = 1;
ide-taskfile.c:	byte io_32bit		= drive->io_32bit;
ide-taskfile.c:	drive->io_32bit = 0;
ide-taskfile.c:	drive->io_32bit = io_32bit;
ide-taskfile.c:	byte io_32bit			= drive->io_32bit;
ide-taskfile.c:	unsigned int nsect, msect	= drive->mult_count;
ide-taskfile.c:		 * drive->mult_count was not set
ide-taskfile.c:			drive->io_32bit = 0;
ide-taskfile.c:			drive->io_32bit = io_32bit;
ide-taskfile.c:		drive->io_32bit = 0;
ide-taskfile.c:		drive->io_32bit = io_32bit;
ide-taskfile.c:			drive->bad_wstat, WAIT_DRQ)) {
ide-taskfile.c:			drive->name,
ide-taskfile.c:			drive->addressing ? "WRITE_EXT" : "WRITE");
ide-taskfile.c:	byte io_32bit		= drive->io_32bit;
ide-taskfile.c:	if (!OK_STAT(stat,DRIVE_READY,drive->bad_wstat))
ide-taskfile.c:		drive->io_32bit = 0;
ide-taskfile.c:		drive->io_32bit = io_32bit;
ide-taskfile.c:			drive->bad_wstat, WAIT_DRQ)) {
ide-taskfile.c:			drive->name,
ide-taskfile.c:			drive->addressing ? "MULTWRITE_EXT" : "MULTWRITE");
ide-taskfile.c:	byte io_32bit			= drive->io_32bit;
ide-taskfile.c:	unsigned int nsect, msect	= drive->mult_count;
ide-taskfile.c:			drive->io_32bit = 0;
ide-taskfile.c:			drive->io_32bit = io_32bit;
ide-taskfile.c:		drive->io_32bit = 0;
ide-taskfile.c:		drive->io_32bit = io_32bit;
it8172.c:    int a_speed		= 3 << (drive->dn * 4);
it8172.c:    int u_flag		= 1 << drive->dn;
it8172.c:    case XFER_UDMA_2:	//u_speed = 2 << (drive->dn * 4); break;
it8172.c:    case XFER_UDMA_1:	//u_speed = 1 << (drive->dn * 4); break;
it8172.c:    case XFER_UDMA_0:	u_speed = 0 << (drive->dn * 4); break;
it8172.c:    if (!drive->init_speed)
it8172.c:	drive->init_speed = speed;
it8172.c:    drive->current_speed = speed;
it8172.c:    struct hd_driveid *id = drive->id;
macide.c:        		drive->capacity = drive->cyl*drive->head*drive->sect;
ns87415.c: * This routine either enables/disables (according to drive->present)
ns87415.c:	new = drive->present ? (new & ~bit) : (new | bit);
ns87415.c:	bit   = 1 << (20 + drive->select.b.unit       + (hwif->channel << 1));
ns87415.c:	other = 1 << (20 + (1 - drive->select.b.unit) + (hwif->channel << 1));
ns87415.c:	ns87415_prepare_drive (drive, drive->using_dma);
ns87415.c:			drive->waiting_for_dma = 0;
ns87415.c:			if (drive->media != ide_disk)
ocp_stbxxxxx.c:	if (!drive->init_speed)
ocp_stbxxxxx.c:		drive->init_speed = speed;
ocp_stbxxxxx.c:	drive->current_speed = speed;
ocp_stbxxxxx.c:	struct hd_driveid *id = drive->id;
ocp_stbxxxxx.c:		if (drive->select.b.lba) {
ocp_stbxxxxx.c:			OUT_BYTE(((block >> 8) & 0x0f) | drive->select.all,
ocp_stbxxxxx.c:			track = block / drive->sect;
ocp_stbxxxxx.c:			sect = block % drive->sect + 1;
ocp_stbxxxxx.c:			head = track % drive->head;
ocp_stbxxxxx.c:			cyl = track / drive->head;
ocp_stbxxxxx.c:			OUT_BYTE(head | drive->select.all, IDE_SELECT_REG);
ocp_stbxxxxx.c:		drive->using_dma = (func == ide_dma_on);
ocp_stbxxxxx.c:		if (drive->media != ide_disk)
ocp_stbxxxxx.c:		drive->waiting_for_dma = 1;
ocp_stbxxxxx.c:		drive->waiting_for_dma = 0;
opti621.c:/* Store values into drive->drive_data
opti621.c:	drive->drive_data = ide_get_best_pio_mode(drive, pio, OPTI621_MAX_PIO, NULL);
opti621.c:		if (drive->present) {
opti621.c:			if (drive->drive_data == PIO_DONT_KNOW)
opti621.c:				drive->drive_data = ide_get_best_pio_mode(drive, 255, OPTI621_MAX_PIO, NULL);
opti621.c:			printk("%s: Selected PIO mode %d\n", drive->name, drive->drive_data);
opti621.c:			drive->drive_data = PIO_NOT_EXIST;
opti621.c:	/* sets drive->drive_data for both drives */
pdc202xx.c:	struct hd_driveid *id = drive->id;
pdc202xx.c:	switch (drive->dn) {
pdc202xx.c:	if ((drive->media != ide_disk) && (speed < XFER_SW_DMA_0))	return -1;
pdc202xx.c:	if (!drive->init_speed)
pdc202xx.c:		drive->init_speed = speed;
pdc202xx.c:	drive->current_speed = speed;
pdc202xx.c:		drive->name, ide_xfer_verbose(speed),
pdc202xx.c:		drive->dn, drive_conf);
pdc202xx.c:	byte adj		= (drive->dn%2) ? 0x08 : 0x00;
pdc202xx.c:	if (!drive->init_speed)
pdc202xx.c:		drive->init_speed = speed;
pdc202xx.c:	drive->current_speed = speed;
pdc202xx.c:	struct hd_driveid *id	= drive->id;
pdc202xx.c:	byte adj		= (drive->dn%2) ? 0x08 : 0x00;
pdc202xx.c:	byte unit		= (drive->select.b.unit & 0x01);
pdc202xx.c:		printk("%s reduced to Ultra33 mode.\n", drive->name);
pdc202xx.c:			if (hwif->drives[!(drive->dn%2)].id) {
pdc202xx.c:				if ((hwif->drives[!(drive->dn%2)].id->dma_ultra & 0x0040) ||
pdc202xx.c:				    (hwif->drives[!(drive->dn%2)].id->dma_ultra
pdc202xx.c:				    (hwif->drives[!(drive->dn%2)].id->dma_ultra & 0x0010) ||
pdc202xx.c:				    (hwif->drives[!(drive->dn%2)].id->dma_ultra & 0x0008)) {
pdc202xx.c:		if (drive->media != ide_disk)	return ide_dma_off_quietly;
pdc202xx.c:	switch(drive->dn) {
pdc202xx.c:	if (drive->media != ide_disk)	return ide_dma_off_quietly;
pdc202xx.c:	if (drive->media == ide_disk)	/* PREFETCH_EN */
pdc202xx.c:	struct hd_driveid *id = drive->id;
pdc202xx.c:			if ((drive->addressing) && (hardware48hack)) {
pdc202xx.c:			if ((drive->addressing) && (hardware48hack)) {
pdc4030.c:	number = (HWIF(drive)->channel << 1) + drive->select.b.unit;
pdc4030.c:	       "buf=0x%08lx, rem=%ld\n", drive->name, rq->sector,
pdc4030.c:			       "interrupt\n", drive->name);
pdc4030.c:		       "!DRQ !BUSY\n", drive->name);
pdc4030.c:		       drive->name);
pdc4030.c:	printk(KERN_DEBUG "%s: Write complete - end_request\n", drive->name);
pdc4030.c:		printk(KERN_ERR "%s: write timed-out!\n",drive->name);
pdc4030.c:		drive->name, GET_STAT());
pdc4030.c:	       "buffer=%p\n", drive->name, rq->sector,
pdc4030.c:			"status = %02x\n", drive->name, GET_STAT());
pdc4030.c:		OUT_BYTE(drive->ctl, IDE_CONTROL_REG);	/* clear nIEN */
pdc4030.c:	printk(KERN_DEBUG "%s: read: waiting for interrupt\n", drive->name);
pdc4030.c:		printk(KERN_ERR "%s: reading: No DRQ and not waiting - Odd!\n", drive->name);
pdc4030.c:		if (ide_wait_stat(&startstop, drive, DATA_READY, drive->bad_wstat, WAIT_DRQ)) {
pdc4030.c:			printk(KERN_ERR "%s: no DRQ after issuing PROMISE_WRITE\n", drive->name);
pdc4030.c:		if (!drive->unmask)
pdc4030.c:		printk("KERN_WARNING %s: bad command: %d\n", drive->name, rq->cmd);
pdc4030.c:	taskfile.device_head	= ((block>>8)&0x0f)|drive->select.all;
piix.c:	int a_speed		= 3 << (drive->dn * 4);
piix.c:	int u_flag		= 1 << drive->dn;
piix.c:	int v_flag		= 0x01 << drive->dn;
piix.c:	int w_flag		= 0x10 << drive->dn;
piix.c:		case XFER_UDMA_2:	u_speed = 2 << (drive->dn * 4); break;
piix.c:		case XFER_UDMA_1:	u_speed = 1 << (drive->dn * 4); break;
piix.c:		case XFER_UDMA_0:	u_speed = 0 << (drive->dn * 4); break;
piix.c:	printk("%s: %s drive%d\n", drive->name, ide_xfer_verbose(speed), drive->dn);
piix.c:	if (!drive->init_speed)
piix.c:		drive->init_speed = speed;
piix.c:	drive->current_speed = speed;
piix.c:	struct hd_driveid *id	= drive->id;
piix.c:	struct hd_driveid *id = drive->id;
qd65xx.c:	if (!*drive->id->model) return 0;
qd65xx.c:	strncpy(model,drive->id->model,40);
qd65xx.c:			printk(KERN_DEBUG "%s: listed !\n",drive->name);
qd65xx.c:	drive->drive_data &= 0xff00;
qd65xx.c:	drive->drive_data |= timing;
qd65xx.c:	printk(KERN_DEBUG "%s: %#x\n",drive->name,timing);
qd65xx.c:	if (drive->id && !qd_find_disk_type(drive,&active_time,&recovery_time)
qd65xx.c:		&& drive->id->tPIO && (drive->id->field_valid & 0x02)
qd65xx.c:		&& drive->id->eide_pio >= 240) {
qd65xx.c:		printk(KERN_INFO "%s: PIO mode%d\n", drive->name,
qd65xx.c:				drive->id->tPIO);
qd65xx.c:		recovery_time = drive->id->eide_pio - 120;
qd65xx.c:	if (drive->id && !qd_find_disk_type(drive,&active_time,&recovery_time)) {
qd65xx.c:					printk(KERN_WARNING "%s: Strange recovery time !\n",drive->name);
qd65xx.c:					printk(KERN_WARNING "%s: Strange recovery time !\n",drive->name);
qd65xx.c:		printk(KERN_INFO "%s: PIO mode%d\n",drive->name,pio);
qd65xx.c:	if (!HWIF(drive)->channel && drive->media != ide_disk) {
qd65xx.c:		printk(KERN_WARNING "%s: ATAPI: disabled read-ahead FIFO and post-write buffer on %s.\n",drive->name,HWIF(drive)->name);
serverworks.c:	byte unit		= (drive->select.b.unit & 0x01);
serverworks.c:        switch (drive->dn) {
serverworks.c:		drive->name, ultra_timing, dma_timing, pio_timing);
serverworks.c:	ultra_enable	&= ~(0x01 << drive->dn);
serverworks.c:	csb5_pio	&= ~(0x0F << (4*drive->dn));
serverworks.c:			csb5_pio   |= ((speed - XFER_PIO_0) << (4*drive->dn));
serverworks.c:			csb5_pio   |= (pio << (4*drive->dn));
serverworks.c:			csb5_pio     |= (pio << (4*drive->dn));
serverworks.c:			ultra_enable |= (0x01 << drive->dn);
serverworks.c:		drive->name, ultra_timing, dma_timing, pio_timing);
serverworks.c:	printk("%s: %s drive%d\n", drive->name, ide_xfer_verbose(speed), drive->dn);
serverworks.c:	if (!drive->init_speed)
serverworks.c:		drive->init_speed = speed;
serverworks.c:	drive->current_speed = speed;
serverworks.c:	unsigned short xfer_pio = drive->id->eide_pio_modes;
serverworks.c:	if (drive->id->eide_pio_iordy > 0)
serverworks.c:			drive->id->eide_pio_iordy>eide_pio_timing[xfer_pio];
serverworks.c:		xfer_pio = (drive->id->eide_pio_modes & 4) ? 0x05 :
serverworks.c:			   (drive->id->eide_pio_modes & 2) ? 0x04 :
serverworks.c:			   (drive->id->eide_pio_modes & 1) ? 0x03 :
serverworks.c:			   (drive->id->tPIO & 2) ? 0x02 :
serverworks.c:			   (drive->id->tPIO & 1) ? 0x01 : xfer_pio;
serverworks.c:			speed = (!drive->id->tPIO) ? XFER_PIO_0 : XFER_PIO_SLOW;
serverworks.c:	drive->current_speed = speed;
serverworks.c:	struct hd_driveid *id	= drive->id;
serverworks.c:	struct hd_driveid *id = drive->id;
sis5513.c:	byte rw_prefetch	= (0x11 << drive->dn);
sis5513.c:	if (drive->media != ide_disk)
sis5513.c:	unsigned short xfer_pio = drive->id->eide_pio_modes;
sis5513.c:	if (drive->id->eide_pio_iordy > 0) {
sis5513.c:			drive->id->eide_pio_iordy>eide_pio_timing[xfer_pio];
sis5513.c:		xfer_pio = (drive->id->eide_pio_modes & 4) ? 0x05 :
sis5513.c:			   (drive->id->eide_pio_modes & 2) ? 0x04 :
sis5513.c:			   (drive->id->eide_pio_modes & 1) ? 0x03 : xfer_pio;
sis5513.c:	switch(drive->dn) {
sis5513.c:	drive->current_speed = speed;
sis5513.c:	switch(drive->dn) {
sis5513.c:	drive->current_speed = speed;
sis5513.c:	struct hd_driveid *id	= drive->id;
sis5513.c:	byte unit		= (drive->select.b.unit & 0x01);
sis5513.c:	printk("%s: %s drive%d\n", drive->name, ide_xfer_verbose(speed), drive->dn);
sis5513.c:	struct hd_driveid *id		= drive->id;
sl82c105.c:	reg = (hwif->channel ? 0x4c : 0x44) + (drive->select.b.unit ? 4 : 0);
sl82c105.c:	if (drive->using_dma == 0) {
sl82c105.c:			printk("%s: selected %s (%dns) (%04X)\n", drive->name,
sl82c105.c:	reg = (hwif->channel ? 0x4c : 0x44) + (drive->select.b.unit ? 4 : 0);
sl82c105.c:		struct hd_driveid *id = drive->id;
sl82c105.c:	drive->io_32bit = 1;
sl82c105.c:	drive->unmask = 1;
slc90e66.c:	int a_speed		= 7 << (drive->dn * 4);
slc90e66.c:	int u_flag		= 1 << drive->dn;
slc90e66.c:		case XFER_UDMA_4:	u_speed = 4 << (drive->dn * 4); break;
slc90e66.c:		case XFER_UDMA_3:	u_speed = 3 << (drive->dn * 4); break;
slc90e66.c:		case XFER_UDMA_2:	u_speed = 2 << (drive->dn * 4); break;
slc90e66.c:		case XFER_UDMA_1:	u_speed = 1 << (drive->dn * 4); break;
slc90e66.c:		case XFER_UDMA_0:	u_speed = 0 << (drive->dn * 4); break;
slc90e66.c:	printk("%s: %s drive%d\n", drive->name, ide_xfer_verbose(speed), drive->dn);
slc90e66.c:	if (!drive->init_speed)
slc90e66.c:		drive->init_speed = speed;
slc90e66.c:	drive->current_speed = speed;
slc90e66.c:	struct hd_driveid *id	= drive->id;
stb03xxx.c:	if (!drive->init_speed)
stb03xxx.c:		drive->init_speed = speed;
stb03xxx.c:	drive->current_speed = speed;
stb03xxx.c:	struct hd_driveid *id = drive->id;
stb03xxx.c:		if (drive->select.b.lba) {
stb03xxx.c:			OUT_BYTE(((block>>8)&0x0f)|drive->select.all,IDE_SELECT_REG);
stb03xxx.c:			track = block / drive->sect;
stb03xxx.c:			sect = block % drive->sect + 1;
stb03xxx.c:			head = track % drive->head;
stb03xxx.c:			cyl = track / drive->head;
stb03xxx.c:			OUT_BYTE(head|drive->select.all,IDE_SELECT_REG);
stb03xxx.c:		drive->using_dma = (func == ide_dma_on);
stb03xxx.c:		if (drive->media != ide_disk)
stb03xxx.c:		drive->waiting_for_dma = 1;
stb03xxx.c:		drive->waiting_for_dma = 0;
tc86c001.c:	drive->current_speed = speed;
tc86c001.c:			if (drive->media != ide_cdrom) {
tc86c001.c:			if (drive->media != ide_cdrom) {
tc86c001.c:	if (!drive->init_speed)
tc86c001.c:		drive->init_speed = speed;
tc86c001.c:	drive->current_speed = speed;
tc86c001.c:	struct hd_driveid *id	= drive->id;
tc86c001.c:		if (drive->media == ide_cdrom) {
tc86c001.c:			switch(drive->init_speed) {
tc86c001.c:			if (drive->select.b.unit & 0x1) {
tc86c001.c:				if (drive->select.b.unit & 0x1) {
tc86c001.c:		if (drive->media == ide_cdrom) {
tc86c001.c:			if (drive->select.b.unit & 0x1) {
trm290.c:	if (drive->present) {
trm290.c:	trm290_prepare_drive(drive, drive->using_dma);
trm290.c:			drive->waiting_for_dma = 1;
trm290.c:			if (drive->media != ide_disk)
trm290.c:			    (drive->addressing == 1)) {
trm290.c:			} else if (drive->addressing) {
trm290.c:			drive->waiting_for_dma = 0;
umc8672.c:	printk("%s: setting umc8672 to PIO mode%d (speed %d)\n", drive->name, pio, pio_to_umc[pio]);
umc8672.c:		current_speeds[drive->name[2] - 'a'] = pio_to_umc[pio];
via82cxxx.c:	ide_drive_t *peer = HWIF(drive)->drives + (~drive->dn & 1);
via82cxxx.c:	if (speed != XFER_PIO_SLOW && speed != drive->current_speed)
via82cxxx.c:				drive->dn >> 1, drive->dn & 1);
via82cxxx.c:	via_set_speed(HWIF(drive)->pci_dev, drive->dn, &t);
via82cxxx.c:	if (!drive->init_speed)
via82cxxx.c:		drive->init_speed = speed;
via82cxxx.c:	drive->current_speed = speed;
xilleon.c:    unsigned short adv_modes     = drive->id->eide_pio_modes;
xilleon.c:    unsigned short iordy_time    = drive->id->eide_pio_iordy;
xilleon.c:    if (drive->id->field_valid & 0x02) {
xilleon.c:        if (drive->id->eide_pio_iordy > 0) {
xilleon.c:    printk("XILLEON 220 IDE drive %d, max pio mode = %d\n", drive->dn, max_pio);
xilleon.c:    unsigned short dma_modes     = drive->id->dma_mword;
xilleon.c:    if (drive->id->field_valid & 0x02 && dma_modes & 0xff) {
xilleon.c:        printk("XILLEON 220 IDE drive %d, max dma mode = %d\n", drive->dn, max_dma);
xilleon.c:        printk("XILLEON 220 IDE: drive %d, dma not supported\n", drive->dn);
xilleon.c:    unsigned short udma_modes    = drive->id->dma_ultra;
xilleon.c:    if (drive->id->field_valid & 0x04 && udma_modes & 0xff) {
xilleon.c:            printk("XILLEON 220 IDE: drive %d, max udma mode = %d\n", drive->dn, max_udma);
xilleon.c:            printk("XILLEON 220 IDE: drive %d, max udma mode = %d\n", drive->dn, max_udma);
xilleon.c:        printk("XILLEON 220 IDE: drive %d, dma not supported\n", drive->dn);
xilleon.c:    if (drive->dn > 1)      // we only support two drives
xilleon.c:    pio_mode_reg = drive->dn ? pio_mode_reg & 0x0f : pio_mode_reg & 0xf0;
xilleon.c:    udma_control_reg = drive->dn ? udma_control_reg & 0xfd : pio_mode_reg & 0xfe;
xilleon.c:            timing_reg_off = drive->dn ? pciideIDE_PIO_TIMING + 1 : pciideIDE_PIO_TIMING;
xilleon.c:            printk("xilleon_ide_tune_chipset for drive %s (%d), pio mode %d\n", drive->name, drive->dn, pio_mode);
xilleon.c:            pio_control = drive->dn ? pio_control | 0x50 : pio_control | 0xa0;
xilleon.c:            timing_reg_off = drive->dn ? pciideIDE_DMA_TIMING + 1 : pciideIDE_DMA_TIMING;
xilleon.c:                    drive->name, drive->dn, dma_mode, pio_mode);
xilleon.c:            udma_enable       = drive->dn ? 0x82 : 0x81;
xilleon.c:            udma_mode_reg |= drive->dn ? (speed & 0xf) << 4 : speed & 0xf;
xilleon.c:                    drive->name, drive->dn, (speed - XFER_UDMA_0), pio_mode);
xilleon.c:	printk("%s: %s drive%d\n", drive->name, ide_xfer_verbose(speed), drive->dn);
xilleon.c:    if (!drive->init_speed)
xilleon.c:        drive->init_speed = speed;
xilleon.c:    drive->current_speed = speed;
xilleon.c:    drive->current_speed = speed;
xilleon.c:    printk("tune drive %s (%d) for pio %d\n", drive->name, drive->dn, pio);
xilleon.c:    struct hd_driveid *id   = drive->id;
xilleon.c:    printk("config_chipset_for_dma for drive %s (%d)\n", drive->name, drive->dn);
xilleon.c:    if (drive->media == ide_disk){
xilleon.c:    struct hd_driveid *id = drive->id;
xilleon.c:    printk("config_drive_xfer_rate for drive %s (%d)\n", drive->name, drive->dn);
xilleon.c:    printk("%s: dma_timer_expiry: dma status == 0x%02x\n", drive->name, dma_stat);
xilleon.c:            drive->waiting_for_dma = 1;
xilleon.c:            if (drive->media != ide_disk)
