2 * ata_generic.c - Generic PATA/SATA controller driver.
3 * Copyright 2005 Red Hat Inc <alan@redhat.com>, all rights reserved.
5 * Elements from ide/pci/generic.c
6 * Copyright (C) 2001-2002 Andre Hedrick <andre@linux-ide.org>
7 * Portions (C) Copyright 2002 Red Hat Inc <alan@redhat.com>
9 * May be copied or modified under the terms of the GNU General Public License
11 * Driver for PCI IDE interfaces implementing the standard bus mastering
12 * interface functionality. This assumes the BIOS did the drive set up and
13 * tuning for us. By default we do not grab all IDE class devices as they
14 * may have other drivers or need fixups to avoid problems. Instead we keep
15 * a default list of stuff without documentation/driver that appears to
19 #include <linux/kernel.h>
20 #include <linux/module.h>
21 #include <linux/pci.h>
22 #include <linux/init.h>
23 #include <linux/blkdev.h>
24 #include <linux/delay.h>
25 #include <scsi/scsi_host.h>
26 #include <linux/libata.h>
28 #define DRV_NAME "ata_generic"
29 #define DRV_VERSION "0.2.6"
32 * A generic parallel ATA driver using libata
36 * generic_pre_reset - probe begin
39 * Set up cable type and use generic probe init
42 static int generic_pre_reset(struct ata_port
*ap
)
44 ap
->cbl
= ATA_CBL_PATA80
;
45 return ata_std_prereset(ap
);
50 * generic_error_handler - Probe specified port on PATA host controller
55 * None (inherited from caller).
59 static void generic_error_handler(struct ata_port
*ap
)
61 ata_bmdma_drive_eh(ap
, generic_pre_reset
, ata_std_softreset
, NULL
, ata_std_postreset
);
65 * generic_set_mode - mode setting
66 * @ap: interface to set up
68 * Use a non standard set_mode function. We don't want to be tuned.
69 * The BIOS configured everything. Our job is not to fiddle. We
70 * read the dma enabled bits from the PCI configuration of the device
74 static void generic_set_mode(struct ata_port
*ap
)
79 /* Bits 5 and 6 indicate if DMA is active on master/slave */
80 if (ap
->ioaddr
.bmdma_addr
)
81 dma_enabled
= inb(ap
->ioaddr
.bmdma_addr
+ ATA_DMA_CMD
);
83 for (i
= 0; i
< ATA_MAX_DEVICES
; i
++) {
84 struct ata_device
*dev
= &ap
->device
[i
];
85 if (ata_dev_enabled(dev
)) {
86 /* We don't really care */
87 dev
->pio_mode
= XFER_PIO_0
;
88 dev
->dma_mode
= XFER_MW_DMA_0
;
89 /* We do need the right mode information for DMA or PIO
90 and this comes from the current configuration flags */
91 if (dma_enabled
& (1 << (5 + i
))) {
92 dev
->xfer_mode
= XFER_MW_DMA_0
;
93 dev
->xfer_shift
= ATA_SHIFT_MWDMA
;
94 dev
->flags
&= ~ATA_DFLAG_PIO
;
96 dev
->xfer_mode
= XFER_PIO_0
;
97 dev
->xfer_shift
= ATA_SHIFT_PIO
;
98 dev
->flags
|= ATA_DFLAG_PIO
;
104 static struct scsi_host_template generic_sht
= {
105 .module
= THIS_MODULE
,
107 .ioctl
= ata_scsi_ioctl
,
108 .queuecommand
= ata_scsi_queuecmd
,
109 .can_queue
= ATA_DEF_QUEUE
,
110 .this_id
= ATA_SHT_THIS_ID
,
111 .sg_tablesize
= LIBATA_MAX_PRD
,
112 .max_sectors
= ATA_MAX_SECTORS
,
113 .cmd_per_lun
= ATA_SHT_CMD_PER_LUN
,
114 .emulated
= ATA_SHT_EMULATED
,
115 .use_clustering
= ATA_SHT_USE_CLUSTERING
,
116 .proc_name
= DRV_NAME
,
117 .dma_boundary
= ATA_DMA_BOUNDARY
,
118 .slave_configure
= ata_scsi_slave_config
,
119 .slave_destroy
= ata_scsi_slave_destroy
,
120 .bios_param
= ata_std_bios_param
,
123 static struct ata_port_operations generic_port_ops
= {
124 .set_mode
= generic_set_mode
,
126 .port_disable
= ata_port_disable
,
127 .tf_load
= ata_tf_load
,
128 .tf_read
= ata_tf_read
,
129 .check_status
= ata_check_status
,
130 .exec_command
= ata_exec_command
,
131 .dev_select
= ata_std_dev_select
,
133 .bmdma_setup
= ata_bmdma_setup
,
134 .bmdma_start
= ata_bmdma_start
,
135 .bmdma_stop
= ata_bmdma_stop
,
136 .bmdma_status
= ata_bmdma_status
,
138 .data_xfer
= ata_pio_data_xfer
,
140 .freeze
= ata_bmdma_freeze
,
141 .thaw
= ata_bmdma_thaw
,
142 .error_handler
= generic_error_handler
,
143 .post_internal_cmd
= ata_bmdma_post_internal_cmd
,
145 .qc_prep
= ata_qc_prep
,
146 .qc_issue
= ata_qc_issue_prot
,
148 .irq_handler
= ata_interrupt
,
149 .irq_clear
= ata_bmdma_irq_clear
,
151 .port_start
= ata_port_start
,
152 .port_stop
= ata_port_stop
,
153 .host_stop
= ata_host_stop
156 static int all_generic_ide
; /* Set to claim all devices */
159 * ata_generic_init - attach generic IDE
160 * @dev: PCI device found
163 * Called each time a matching IDE interface is found. We check if the
164 * interface is one we wish to claim and if so we perform any chip
165 * specific hacks then let the ATA layer do the heavy lifting.
168 static int ata_generic_init_one(struct pci_dev
*dev
, const struct pci_device_id
*id
)
171 static struct ata_port_info info
= {
173 .flags
= ATA_FLAG_SLAVE_POSS
| ATA_FLAG_SRST
,
177 .port_ops
= &generic_port_ops
179 static struct ata_port_info
*port_info
[2] = { &info
, &info
};
181 /* Don't use the generic entry unless instructed to do so */
182 if (id
->driver_data
== 1 && all_generic_ide
== 0)
185 /* Devices that need care */
186 if (dev
->vendor
== PCI_VENDOR_ID_UMC
&&
187 dev
->device
== PCI_DEVICE_ID_UMC_UM8886A
&&
188 (!(PCI_FUNC(dev
->devfn
) & 1)))
191 if (dev
->vendor
== PCI_VENDOR_ID_OPTI
&&
192 dev
->device
== PCI_DEVICE_ID_OPTI_82C558
&&
193 (!(PCI_FUNC(dev
->devfn
) & 1)))
196 /* Don't re-enable devices in generic mode or we will break some
197 motherboards with disabled and unused IDE controllers */
198 pci_read_config_word(dev
, PCI_COMMAND
, &command
);
199 if (!(command
& PCI_COMMAND_IO
))
202 if (dev
->vendor
== PCI_VENDOR_ID_AL
)
203 ata_pci_clear_simplex(dev
);
205 return ata_pci_init_one(dev
, port_info
, 2);
208 static struct pci_device_id ata_generic
[] = {
209 { PCI_DEVICE(PCI_VENDOR_ID_PCTECH
, PCI_DEVICE_ID_PCTECH_SAMURAI_IDE
), },
210 { PCI_DEVICE(PCI_VENDOR_ID_HOLTEK
, PCI_DEVICE_ID_HOLTEK_6565
), },
211 { PCI_DEVICE(PCI_VENDOR_ID_UMC
, PCI_DEVICE_ID_UMC_UM8673F
), },
212 { PCI_DEVICE(PCI_VENDOR_ID_UMC
, PCI_DEVICE_ID_UMC_UM8886A
), },
213 { PCI_DEVICE(PCI_VENDOR_ID_UMC
, PCI_DEVICE_ID_UMC_UM8886BF
), },
214 { PCI_DEVICE(PCI_VENDOR_ID_HINT
, PCI_DEVICE_ID_HINT_VXPROII_IDE
), },
215 { PCI_DEVICE(PCI_VENDOR_ID_VIA
, PCI_DEVICE_ID_VIA_82C561
), },
216 { PCI_DEVICE(PCI_VENDOR_ID_OPTI
, PCI_DEVICE_ID_OPTI_82C558
), },
217 { PCI_DEVICE(PCI_VENDOR_ID_TOSHIBA
,PCI_DEVICE_ID_TOSHIBA_PICCOLO
), },
218 { PCI_DEVICE(PCI_VENDOR_ID_TOSHIBA
,PCI_DEVICE_ID_TOSHIBA_PICCOLO_1
), },
219 { PCI_DEVICE(PCI_VENDOR_ID_TOSHIBA
,PCI_DEVICE_ID_TOSHIBA_PICCOLO_2
), },
220 /* Must come last. If you add entries adjust this table appropriately */
221 { PCI_ANY_ID
, PCI_ANY_ID
, PCI_ANY_ID
, PCI_ANY_ID
, PCI_CLASS_STORAGE_IDE
<< 8, 0xFFFFFF00UL
, 1},
225 static struct pci_driver ata_generic_pci_driver
= {
227 .id_table
= ata_generic
,
228 .probe
= ata_generic_init_one
,
229 .remove
= ata_pci_remove_one
232 static int __init
ata_generic_init(void)
234 return pci_module_init(&ata_generic_pci_driver
);
238 static void __exit
ata_generic_exit(void)
240 pci_unregister_driver(&ata_generic_pci_driver
);
244 MODULE_AUTHOR("Alan Cox");
245 MODULE_DESCRIPTION("low-level driver for generic ATA");
246 MODULE_LICENSE("GPL");
247 MODULE_DEVICE_TABLE(pci
, ata_generic
);
248 MODULE_VERSION(DRV_VERSION
);
250 module_init(ata_generic_init
);
251 module_exit(ata_generic_exit
);
253 module_param(all_generic_ide
, int, 0);