}
/* Arm the interrupt handler and send the command to the device. */
+ /* FIXME: make this locking go away */
spin_lock_irqsave(ch->lock, flags);
ata_set_handler(drive, handler, timeout, cdrom_timer_expiry);
atapi_write(drive, cmd, CDROM_PACKET_SIZE);
static ide_startstop_t
ide_cdrom_do_request(struct ata_device *drive, struct request *rq, sector_t block)
{
- ide_startstop_t action;
+ struct ata_channel *ch = drive->channel;
+ int ret;
struct cdrom_info *info = drive->driver_data;
if (rq->flags & REQ_CMD) {
}
CDROM_CONFIG_FLAGS(drive)->seeking = 0;
}
- if (IDE_LARGE_SEEK(info->last_block, block, IDECD_SEEK_THRESHOLD) && drive->dsc_overlap)
- action = cdrom_start_seek(drive, rq, block);
- else {
+ /* FIXME: make this unlocking go away*/
+ spin_unlock_irq(ch->lock);
+ if (IDE_LARGE_SEEK(info->last_block, block, IDECD_SEEK_THRESHOLD) && drive->dsc_overlap) {
+ ret = cdrom_start_seek(drive, rq, block);
+ } else {
if (rq_data_dir(rq) == READ)
- action = cdrom_start_read(drive, rq, block);
+ ret = cdrom_start_read(drive, rq, block);
else
- action = cdrom_start_write(drive, rq);
+ ret = cdrom_start_write(drive, rq);
}
info->last_block = block;
- return action;
+ spin_lock_irq(ch->lock);
+ return ret;
} else if (rq->flags & (REQ_PC | REQ_SENSE)) {
- return cdrom_do_packet_command(drive, rq);
+ /* FIXME: make this unlocking go away*/
+ spin_unlock_irq(ch->lock);
+ ret = cdrom_do_packet_command(drive, rq);
+ spin_lock_irq(ch->lock);
+
+ return ret;
} else if (rq->flags & REQ_SPECIAL) {
+ /* FIXME: make this unlocking go away*/
+ spin_unlock_irq(ch->lock);
/*
* FIXME: Kill REQ_SEPCIAL and replace it with commands queued
* at the request queue instead as suggested by Linus.
*/
cdrom_end_request(drive, rq, 1);
+ spin_lock_irq(ch->lock);
+
return ide_stopped;
} else if (rq->flags & REQ_BLOCK_PC) {
struct packet_command pc;
ide_startstop_t startstop;
+ /* FIXME: make this unlocking go away*/
+ spin_unlock_irq(ch->lock);
memset(&pc, 0, sizeof(pc));
pc.quiet = 1;
pc.timeout = 60 * HZ;
startstop = cdrom_do_packet_command(drive, rq);
if (pc.stat)
++rq->errors;
+ spin_lock_irq(ch->lock);
return startstop;
}
blk_dump_rq_flags(rq, "ide-cd bad flags");
+ /* FIXME: make this unlocking go away*/
+ spin_unlock_irq(ch->lock);
cdrom_end_request(drive, rq, 0);
+ spin_lock_irq(ch->lock);
+
return ide_stopped;
}
attach: ide_cdrom_attach,
cleanup: ide_cdrom_cleanup,
standby: NULL,
- do_request: ide_cdrom_do_request,
+ XXX_do_request: ide_cdrom_do_request,
end_request: NULL,
ioctl: ide_cdrom_ioctl,
open: ide_cdrom_open,
* Issue a READ or WRITE command to a disk, using LBA if supported, or CHS
* otherwise, to address sectors. It also takes care of issuing special
* DRIVE_CMDs.
+ *
+ * Channel lock should be held.
*/
static ide_startstop_t idedisk_do_request(struct ata_device *drive, struct request *rq, sector_t block)
{
struct ata_channel *ch = drive->channel;
int ret;
- /* make sure all request have bin finished
- * FIXME: this check doesn't make sense go! */
- while (drive->blocked) {
- yield();
- printk(KERN_ERR "ide: Request while drive blocked?");
- }
-
- /* FIXME: Move this lock entiery upstream. */
- spin_lock_irqsave(ch->lock, flags);
-
/* FIXME: this check doesn't make sense */
if (!(rq->flags & REQ_CMD)) {
blk_dump_rq_flags(rq, "idedisk_do_request - bad command");
__ata_end_request(drive, rq, 0, 0);
- spin_unlock_irqrestore(ch->lock, flags);
-
return ide_stopped;
}
if (IS_PDC4030_DRIVE) {
extern ide_startstop_t promise_do_request(struct ata_device *, struct request *, sector_t);
- spin_unlock_irqrestore(drive->channel->lock, flags);
-
return promise_do_request(drive, rq, block);
}
* start a tagged operation
*/
if (drive->using_tcq) {
- int ret;
-
- ret = blk_queue_start_tag(&drive->queue, rq);
+ int st = blk_queue_start_tag(&drive->queue, rq);
if (ata_pending_commands(drive) > drive->max_depth)
drive->max_depth = ata_pending_commands(drive);
if (ata_pending_commands(drive) > drive->max_last_depth)
drive->max_last_depth = ata_pending_commands(drive);
- if (ret) {
+ if (st) {
BUG_ON(!ata_pending_commands(drive));
- spin_unlock_irqrestore(ch->lock, flags);
-
return ide_started;
}
}
if ((drive->id->cfs_enable_2 & 0x0400) && (drive->addressing))
- ret = lba48_do_request(drive, rq, block);
+ return lba48_do_request(drive, rq, block);
else if (drive->select.b.lba)
- ret = lba28_do_request(drive, rq, block);
+ return lba28_do_request(drive, rq, block);
else
- ret = chs_do_request(drive, rq, block);
-
- spin_unlock_irqrestore(ch->lock, flags);
-
- return ret;
+ return chs_do_request(drive, rq, block);
}
static int idedisk_open(struct inode *inode, struct file *filp, struct ata_device *drive)
/* This is just a hook for the overall driver tree.
*/
-static struct device_driver idedisk_devdrv = {
- suspend: idedisk_suspend,
- resume: idedisk_resume,
+static struct device_driver disk_devdrv = {
+ .lock = RW_LOCK_UNLOCKED,
+ .suspend = idedisk_suspend,
+ .resume = idedisk_resume,
};
/*
sector_t capacity;
sector_t set_max;
int drvid = -1;
+ struct ata_channel *ch = drive->channel;
if (id == NULL)
return;
* to us, but they are removable and don't have a doorlock mechanism.
*/
if (drive->removable && !drive_is_flashcard(drive)) {
- /*
- * Removable disks (eg. SYQUEST); ignore 'WD' drives.
+ /* Removable disks (eg. SYQUEST); ignore 'WD' drives.
*/
- if (id->model[0] != 'W' || id->model[1] != 'D') {
+ if (!strncmp(id->model, "WD", 2))
drive->doorlocking = 1;
- }
}
- for (i = 0; i < MAX_DRIVES; ++i) {
- struct ata_channel *hwif = drive->channel;
- if (drive != &hwif->drives[i])
+ for (i = 0; i < MAX_DRIVES; ++i) {
+ if (drive != &ch->drives[i])
continue;
drvid = i;
- hwif->gd->de_arr[i] = drive->de;
+ ch->gd->de_arr[i] = drive->de;
if (drive->removable)
- hwif->gd->flags[i] |= GENHD_FL_REMOVABLE;
+ ch->gd->flags[i] |= GENHD_FL_REMOVABLE;
break;
}
/* Register us within the device tree.
*/
-
if (drvid != -1) {
- sprintf(drive->device.bus_id, "%d", drvid);
- sprintf(drive->device.name, "ide-disk");
- drive->device.driver = &idedisk_devdrv;
- drive->device.parent = &drive->channel->dev;
- drive->device.driver_data = drive;
- device_register(&drive->device);
+ sprintf(drive->dev.bus_id, "sd@%x,%x", ch->unit, drvid);
+ strcpy(drive->dev.name, "ATA-Disk");
+ drive->dev.driver = &disk_devdrv;
+ drive->dev.parent = &ch->dev;
+ drive->dev.driver_data = drive;
+ device_register(&drive->dev);
}
/* Extract geometry if we did not already have one for the drive */
printk(KERN_INFO " %s: %ld sectors", drive->name, capacity);
#if 0
-
/* Right now we avoid this calculation, since it can result in the
* usage of not supported compiler internal functions on 32 bit hosts.
* However since the calculation appears to be an interesting piece of
attach: idedisk_attach,
cleanup: idedisk_cleanup,
standby: idedisk_standby,
- do_request: idedisk_do_request,
+ XXX_do_request: idedisk_do_request,
end_request: NULL,
ioctl: idedisk_ioctl,
open: idedisk_open,
*/
static ide_startstop_t idefloppy_do_request(struct ata_device *drive, struct request *rq, sector_t block)
{
+ struct ata_channel *ch = drive->channel;
idefloppy_floppy_t *floppy = drive->driver_data;
struct atapi_packet_command *pc;
+ int ret;
#if IDEFLOPPY_DEBUG_LOG
printk (KERN_INFO "rq_status: %d, rq_dev: %u, flags: %lx, errors: %d\n",rq->rq_status,(unsigned int) rq->rq_dev,rq->flags,rq->errors);
drive->name, floppy->failed_pc->c[0], floppy->sense_key, floppy->asc, floppy->ascq);
else
printk (KERN_ERR "ide-floppy: %s: I/O error\n", drive->name);
+
+ /* FIXME: make this unlocking go away*/
+ spin_unlock_irq(ch->lock);
idefloppy_end_request(drive, rq, 0);
+ spin_lock_irq(ch->lock);
+
return ide_stopped;
}
if (rq->flags & REQ_CMD) {
if (rq->sector % floppy->bs_factor || rq->nr_sectors % floppy->bs_factor) {
printk ("%s: unsupported r/w request size\n", drive->name);
+ /* FIXME: make this unlocking go away*/
+ spin_unlock_irq(ch->lock);
idefloppy_end_request(drive, rq, 0);
+ spin_lock_irq(ch->lock);
+
return ide_stopped;
}
pc = idefloppy_next_pc_storage(drive);
pc = (struct atapi_packet_command *) rq->buffer;
} else {
blk_dump_rq_flags(rq, "ide-floppy: unsupported command in queue");
+ /* FIXME: make this unlocking go away*/
+ spin_unlock_irq(ch->lock);
idefloppy_end_request(drive, rq, 0);
+ spin_lock_irq(ch->lock);
+
return ide_stopped;
}
- return idefloppy_issue_pc(drive, rq, pc);
+ /* FIXME: make this unlocking go away*/
+ spin_unlock_irq(ch->lock);
+ ret = idefloppy_issue_pc(drive, rq, pc);
+ spin_lock_irq(ch->lock);
+
+ return ret;
}
/*
attach: idefloppy_attach,
cleanup: idefloppy_cleanup,
standby: NULL,
- do_request: idefloppy_do_request,
+ XXX_do_request: idefloppy_do_request,
end_request: idefloppy_end_request,
ioctl: idefloppy_ioctl,
open: idefloppy_open,
*/
static ide_startstop_t idetape_do_request(struct ata_device *drive, struct request *rq, sector_t block)
{
+ struct ata_channel *ch = drive->channel;
idetape_tape_t *tape = drive->driver_data;
struct atapi_packet_command *pc;
struct request *postponed_rq = tape->postponed_rq;
idetape_status_reg_t status;
+ int ret;
#if IDETAPE_DEBUG_LOG
/* if (tape->debug_level >= 5)
* We do not support buffer cache originated requests.
*/
printk (KERN_NOTICE "ide-tape: %s: Unsupported command in request queue (%ld)\n", drive->name, rq->flags);
- ata_end_request(drive, rq, 0); /* Let the common code handle it */
+ __ata_end_request(drive, rq, 0, 0); /* Let the common code handle it */
return ide_stopped;
}
* Retry a failed packet command
*/
if (tape->failed_pc != NULL && tape->pc->c[0] == IDETAPE_REQUEST_SENSE_CMD) {
- return idetape_issue_packet_command(drive, rq, tape->failed_pc);
+ int ret;
+
+ /* FIXME: make this unlocking go away*/
+ spin_unlock_irq(ch->lock);
+ ret = idetape_issue_packet_command(drive, rq, tape->failed_pc);
+ spin_lock_irq(ch->lock);
+
+ return ret;
}
#if IDETAPE_DEBUG_BUGS
if (postponed_rq != NULL)
if (rq != postponed_rq) {
printk (KERN_ERR "ide-tape: ide-tape.c bug - Two DSC requests were queued\n");
+ /* FIXME: make this unlocking go away*/
+ spin_unlock_irq(ch->lock);
idetape_end_request(drive, rq, 0);
+ spin_lock_irq(ch->lock);
+
return ide_stopped;
}
#endif
if (tape->onstream)
status.b.dsc = 1;
if (!drive->dsc_overlap && rq->flags != IDETAPE_PC_RQ2)
- set_bit (IDETAPE_IGNORE_DSC, &tape->flags);
+ set_bit(IDETAPE_IGNORE_DSC, &tape->flags);
/*
* For the OnStream tape, check the current status of the tape
tape->req_buffer_fill = 1;
}
#if ONSTREAM_DEBUG
- else if (tape->debug_level >= 4)
+ else if (tape->debug_level >= 4)
printk(KERN_INFO "ide-tape: %s: postpone_cnt %d\n", tape->name, tape->postpone_cnt);
#endif
}
} else if ((signed long) (jiffies - tape->dsc_timeout) > 0) {
printk (KERN_ERR "ide-tape: %s: DSC timeout\n", tape->name);
if (rq->flags == IDETAPE_PC_RQ2) {
+ /* FIXME: make this unlocking go away*/
+ spin_unlock_irq(ch->lock);
idetape_media_access_finished(drive, rq);
+ spin_lock_irq(ch->lock);
return ide_stopped;
} else {
return ide_stopped;
}
} else if (jiffies - tape->dsc_polling_start > IDETAPE_DSC_MA_THRESHOLD)
tape->dsc_polling_frequency = IDETAPE_DSC_MA_SLOW;
+ /* FIXME: make this unlocking go away*/
+ spin_unlock_irq(ch->lock);
idetape_postpone_request(drive, rq);
+ spin_lock_irq(ch->lock);
return ide_stopped;
}
switch (rq->flags) {
if (jiffies > tape->last_buffer_fill + 5 * HZ / 100)
tape->req_buffer_fill = 1;
}
- pc = idetape_next_pc_storage (drive);
- idetape_create_read_cmd (tape, pc, rq->current_nr_sectors, rq->bio);
+ pc = idetape_next_pc_storage(drive);
+ idetape_create_read_cmd(tape, pc, rq->current_nr_sectors, rq->bio);
break;
case IDETAPE_WRITE_RQ:
tape->buffer_head++;
calculate_speeds(drive);
}
pc = idetape_next_pc_storage (drive);
- idetape_create_write_cmd (tape, pc, rq->current_nr_sectors, rq->bio);
+ idetape_create_write_cmd(tape, pc, rq->current_nr_sectors, rq->bio);
break;
case IDETAPE_READ_BUFFER_RQ:
tape->postpone_cnt = 0;
pc = idetape_next_pc_storage (drive);
- idetape_create_read_buffer_cmd (tape, pc, rq->current_nr_sectors, rq->bio);
+ idetape_create_read_buffer_cmd(tape, pc, rq->current_nr_sectors, rq->bio);
break;
case IDETAPE_ABORTED_WRITE_RQ:
rq->flags = IDETAPE_WRITE_RQ;
rq->flags = IDETAPE_PC_RQ2;
break;
case IDETAPE_PC_RQ2:
+ /* FIXME: make this unlocking go away*/
+ spin_unlock_irq(ch->lock);
idetape_media_access_finished(drive, rq);
+ spin_lock_irq(ch->lock);
return ide_stopped;
default:
printk (KERN_ERR "ide-tape: bug in IDETAPE_RQ_CMD macro\n");
+ /* FIXME: make this unlocking go away*/
+ spin_unlock_irq(ch->lock);
idetape_end_request(drive, rq, 0);
+ spin_lock_irq(ch->lock);
return ide_stopped;
}
- return idetape_issue_packet_command(drive, rq, pc);
+ /* FIXME: make this unlocking go away*/
+ spin_unlock_irq(ch->lock);
+ ret = idetape_issue_packet_command(drive, rq, pc);
+ spin_lock_irq(ch->lock);
+
+ return ret;
}
/*
attach: idetape_attach,
cleanup: idetape_cleanup,
standby: NULL,
- do_request: idetape_do_request,
+ XXX_do_request: idetape_do_request,
end_request: idetape_end_request,
ioctl: idetape_blkdev_ioctl,
open: idetape_blkdev_open,
*/
static ide_startstop_t start_request(struct ata_device *drive, struct request *rq)
{
+ struct ata_channel *ch = drive->channel;
sector_t block;
unsigned int minor = minor(rq->rq_dev);
unsigned int unit = minor >> PARTN_BITS;
- struct ata_channel *ch = drive->channel;
+ ide_startstop_t ret;
BUG_ON(!(rq->flags & REQ_STARTED));
#ifdef DEBUG
- printk("%s: start_request: current=0x%08lx\n", ch->name, (unsigned long) rq);
+ printk("%s: %s: current=0x%08lx\n", ch->name, __FUNCTION__, (unsigned long) rq);
#endif
/* bail early if we've exceeded max_failures */
if (drive->type == ATA_DISK || drive->type == ATA_FLOPPY)
block += drive->sect0;
-
/* Yecch - this will shift the entire interval, possibly killing some
* innocent following sector.
*/
if (block == 0 && drive->remap_0_to_1 == 1)
block = 1; /* redirect MBR access to EZ-Drive partn table */
- {
- ide_startstop_t res;
- ata_select(drive, 0);
- if (ata_status_poll(drive, drive->ready_stat, BUSY_STAT | DRQ_STAT,
- WAIT_READY, rq, &res)) {
- printk(KERN_WARNING "%s: drive not ready for command\n", drive->name);
+ ata_select(drive, 0);
+ spin_unlock_irq(ch->lock);
+ if (ata_status_poll(drive, drive->ready_stat, BUSY_STAT | DRQ_STAT,
+ WAIT_READY, rq, &ret)) {
+ printk(KERN_WARNING "%s: drive not ready for command\n", drive->name);
+ spin_lock_irq(ch->lock);
- return res;
- }
+ return ret;
}
+ spin_lock_irq(ch->lock);
/* This issues a special drive command.
+ *
+ * FIXME: move this down to idedisk_do_request().
*/
if (rq->flags & REQ_SPECIAL)
- if (drive->type == ATA_DISK)
- return ata_taskfile(drive, rq->special, NULL);
-
- /* The normal way of execution is to pass and execute the request
- * handler down to the device type driver.
- */
- if (ata_ops(drive)) {
- if (ata_ops(drive)->do_request)
- return ata_ops(drive)->do_request(drive, rq, block);
- else {
- ata_end_request(drive, rq, 0);
+ if (drive->type == ATA_DISK) {
+ spin_unlock_irq(ch->lock);
+ ret = ata_taskfile(drive, rq->special, NULL);
+ spin_lock_irq(ch->lock);
- return ide_stopped;
+ return ret;
}
+
+ if (!ata_ops(drive)) {
+ printk(KERN_WARNING "%s: device type %d not supported\n",
+ drive->name, drive->type);
+ goto kill_rq;
}
- /*
- * Error handling:
+ /* The normal way of execution is to pass and execute the request
+ * handler down to the device type driver.
*/
- printk(KERN_WARNING "%s: device type %d not supported\n",
- drive->name, drive->type);
+ if (ata_ops(drive)->XXX_do_request) {
+ ret = ata_ops(drive)->XXX_do_request(drive, rq, block);
+ } else {
+ __ata_end_request(drive, rq, 0, 0);
+ ret = ide_stopped;
+ }
+ return ret;
kill_rq:
- if (ata_ops(drive) && ata_ops(drive)->end_request)
- ata_ops(drive)->end_request(drive, rq, 0);
- else
- ata_end_request(drive, rq, 0);
+ if (ata_ops(drive)) {
+ if (ata_ops(drive)->end_request) {
+ spin_unlock_irq(ch->lock);
+ ata_ops(drive)->end_request(drive, rq, 0);
+ spin_lock_irq(ch->lock);
+ }
+ } else
+ __ata_end_request(drive, rq, 0, 0);
return ide_stopped;
}
ch->handler = NULL;
del_timer(&ch->timer);
-
- spin_unlock_irqrestore(ch->lock, flags);
-
- /* FIXME make start_request do the unlock itself and
- * push this locking further down. */
-
ret = start_request(drive, drive->rq);
+ spin_unlock_irqrestore(ch->lock, flags);
return ret;
}
drive->rq = rq;
- /* FIXME: push this locaing further down */
- spin_unlock(drive->channel->lock);
ide__sti(); /* allow other IRQs while we start this request */
startstop = start_request(drive, rq);
- spin_lock_irq(drive->channel->lock);
/* command started, we are busy */
if (startstop == ide_started)
struct ata_operations *tmp;
unsigned long flags;
- struct ata_operations *sd = NULL;
-
spin_lock_irqsave(&ata_drivers_lock, flags);
for(tmp = ata_drivers; tmp; tmp = tmp->next) {
if (subdriver_match(ch, tmp) > 0)
{
struct pci_dev *dev = drive->channel->pci_dev;
u32 drive_conf;
- u8 drive_pci, AP, BP, CP, DP, TA = 0, TB, TC = 0;
+ u8 drive_pci, AP, BP, CP, TA = 0, TB, TC = 0;
+#if PDC202XX_DECODE_REGISTER_INFO
+ u8 DP;
+#endif
if (drive->dn > 3) /* FIXME: remove this --bkz */
return -1;
case XFER_SW_DMA_2: TB = 0x60; TC = 0x05; break;
case XFER_SW_DMA_1: TB = 0x80; TC = 0x06; break;
case XFER_SW_DMA_0: TB = 0xC0; TC = 0x0B; break;
-#endif /* CONFIG_BLK_DEV_IDEDMA */
+#endif
case XFER_PIO_4: TA = 0x01; TB = 0x04; break;
case XFER_PIO_3: TA = 0x02; TB = 0x06; break;
case XFER_PIO_2: TA = 0x03; TB = 0x08; break;
goto not_found;
/* Register this hardware interface within the global device tree.
+ *
+ * FIXME: This should be handled as a pci subdevice in a generic way.
*/
- sprintf(ch->dev.bus_id, "%04lx",
- (unsigned long) ch->io_ports[IDE_DATA_OFFSET]);
- sprintf(ch->dev.name, "ide");
+ sprintf(ch->dev.bus_id, "ata@%02x", ch->unit);
+ strcpy(ch->dev.name, "ATA/ATAPI Host-Channel");
ch->dev.driver_data = ch;
#ifdef CONFIG_PCI
if (ch->pci_dev)
*/
static ide_startstop_t idescsi_do_request(struct ata_device *drive, struct request *rq, sector_t block)
{
+ struct ata_channel *ch = drive->channel;
+ int ret;
+
#ifdef DEBUG
printk(KERN_INFO "rq_status: %d, cmd: %d, errors: %d\n",
rq->rq_status,
rq->current_nr_sectors);
#endif
+ /* FIXME: make this unlocking go away*/
+ spin_unlock_irq(ch->lock);
if (rq->flags & REQ_PC) {
- return idescsi_issue_pc(drive, rq, (struct atapi_packet_command *) rq->special);
+ ret = idescsi_issue_pc(drive, rq, (struct atapi_packet_command *) rq->special);
+ } else {
+ blk_dump_rq_flags(rq, "ide-scsi: unsup command");
+ idescsi_end_request(drive, rq, 0);
+ ret = ide_stopped;
}
- blk_dump_rq_flags(rq, "ide-scsi: unsup command");
- idescsi_end_request(drive, rq, 0);
- return ide_stopped;
+ spin_lock_irq(ch->lock);
+
+ return ret;
}
static int idescsi_open(struct inode *inode, struct file *filp, struct ata_device *drive)
owner: THIS_MODULE,
attach: idescsi_attach,
cleanup: idescsi_cleanup,
- do_request: idescsi_do_request,
+ XXX_do_request: idescsi_do_request,
end_request: idescsi_end_request,
open: idescsi_open,
release: idescsi_release,
byte queue_depth; /* max queue depth */
unsigned int failures; /* current failure count */
unsigned int max_failures; /* maximum allowed failure count */
- struct device device; /* global device tree handle */
+ struct device dev; /* global device tree handle */
/*
* tcq statistics
void (*attach) (struct ata_device *);
int (*cleanup)(struct ata_device *);
int (*standby)(struct ata_device *);
- ide_startstop_t (*do_request)(struct ata_device *, struct request *, sector_t);
+ ide_startstop_t (*XXX_do_request)(struct ata_device *, struct request *, sector_t);
int (*end_request)(struct ata_device *, struct request *, int);
int (*ioctl)(struct ata_device *, struct inode *, struct file *, unsigned int, unsigned long);
projects / linux / commitdiff