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.10"
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 .cmd_per_lun
= ATA_SHT_CMD_PER_LUN
,
113 .emulated
= ATA_SHT_EMULATED
,
114 .use_clustering
= ATA_SHT_USE_CLUSTERING
,
115 .proc_name
= DRV_NAME
,
116 .dma_boundary
= ATA_DMA_BOUNDARY
,
117 .slave_configure
= ata_scsi_slave_config
,
118 .slave_destroy
= ata_scsi_slave_destroy
,
119 .bios_param
= ata_std_bios_param
,
120 .resume
= ata_scsi_device_resume
,
121 .suspend
= ata_scsi_device_suspend
,
124 static struct ata_port_operations generic_port_ops
= {
125 .set_mode
= generic_set_mode
,
127 .port_disable
= ata_port_disable
,
128 .tf_load
= ata_tf_load
,
129 .tf_read
= ata_tf_read
,
130 .check_status
= ata_check_status
,
131 .exec_command
= ata_exec_command
,
132 .dev_select
= ata_std_dev_select
,
134 .bmdma_setup
= ata_bmdma_setup
,
135 .bmdma_start
= ata_bmdma_start
,
136 .bmdma_stop
= ata_bmdma_stop
,
137 .bmdma_status
= ata_bmdma_status
,
139 .data_xfer
= ata_pio_data_xfer
,
141 .freeze
= ata_bmdma_freeze
,
142 .thaw
= ata_bmdma_thaw
,
143 .error_handler
= generic_error_handler
,
144 .post_internal_cmd
= ata_bmdma_post_internal_cmd
,
146 .qc_prep
= ata_qc_prep
,
147 .qc_issue
= ata_qc_issue_prot
,
149 .irq_handler
= ata_interrupt
,
150 .irq_clear
= ata_bmdma_irq_clear
,
152 .port_start
= ata_port_start
,
153 .port_stop
= ata_port_stop
,
154 .host_stop
= ata_host_stop
157 static int all_generic_ide
; /* Set to claim all devices */
160 * ata_generic_init - attach generic IDE
161 * @dev: PCI device found
164 * Called each time a matching IDE interface is found. We check if the
165 * interface is one we wish to claim and if so we perform any chip
166 * specific hacks then let the ATA layer do the heavy lifting.
169 static int ata_generic_init_one(struct pci_dev
*dev
, const struct pci_device_id
*id
)
172 static struct ata_port_info info
= {
174 .flags
= ATA_FLAG_SLAVE_POSS
| ATA_FLAG_SRST
,
178 .port_ops
= &generic_port_ops
180 static struct ata_port_info
*port_info
[2] = { &info
, &info
};
182 /* Don't use the generic entry unless instructed to do so */
183 if (id
->driver_data
== 1 && all_generic_ide
== 0)
186 /* Devices that need care */
187 if (dev
->vendor
== PCI_VENDOR_ID_UMC
&&
188 dev
->device
== PCI_DEVICE_ID_UMC_UM8886A
&&
189 (!(PCI_FUNC(dev
->devfn
) & 1)))
192 if (dev
->vendor
== PCI_VENDOR_ID_OPTI
&&
193 dev
->device
== PCI_DEVICE_ID_OPTI_82C558
&&
194 (!(PCI_FUNC(dev
->devfn
) & 1)))
197 /* Don't re-enable devices in generic mode or we will break some
198 motherboards with disabled and unused IDE controllers */
199 pci_read_config_word(dev
, PCI_COMMAND
, &command
);
200 if (!(command
& PCI_COMMAND_IO
))
203 if (dev
->vendor
== PCI_VENDOR_ID_AL
)
204 ata_pci_clear_simplex(dev
);
206 return ata_pci_init_one(dev
, port_info
, 2);
209 static struct pci_device_id ata_generic
[] = {
210 { PCI_DEVICE(PCI_VENDOR_ID_PCTECH
, PCI_DEVICE_ID_PCTECH_SAMURAI_IDE
), },
211 { PCI_DEVICE(PCI_VENDOR_ID_HOLTEK
, PCI_DEVICE_ID_HOLTEK_6565
), },
212 { PCI_DEVICE(PCI_VENDOR_ID_UMC
, PCI_DEVICE_ID_UMC_UM8673F
), },
213 { PCI_DEVICE(PCI_VENDOR_ID_UMC
, PCI_DEVICE_ID_UMC_UM8886A
), },
214 { PCI_DEVICE(PCI_VENDOR_ID_UMC
, PCI_DEVICE_ID_UMC_UM8886BF
), },
215 { PCI_DEVICE(PCI_VENDOR_ID_HINT
, PCI_DEVICE_ID_HINT_VXPROII_IDE
), },
216 { PCI_DEVICE(PCI_VENDOR_ID_VIA
, PCI_DEVICE_ID_VIA_82C561
), },
217 { PCI_DEVICE(PCI_VENDOR_ID_OPTI
, PCI_DEVICE_ID_OPTI_82C558
), },
218 { PCI_DEVICE(PCI_VENDOR_ID_TOSHIBA
,PCI_DEVICE_ID_TOSHIBA_PICCOLO
), },
219 { PCI_DEVICE(PCI_VENDOR_ID_TOSHIBA
,PCI_DEVICE_ID_TOSHIBA_PICCOLO_1
), },
220 { PCI_DEVICE(PCI_VENDOR_ID_TOSHIBA
,PCI_DEVICE_ID_TOSHIBA_PICCOLO_2
), },
221 /* Must come last. If you add entries adjust this table appropriately */
222 { PCI_ANY_ID
, PCI_ANY_ID
, PCI_ANY_ID
, PCI_ANY_ID
, PCI_CLASS_STORAGE_IDE
<< 8, 0xFFFFFF00UL
, 1},
226 static struct pci_driver ata_generic_pci_driver
= {
228 .id_table
= ata_generic
,
229 .probe
= ata_generic_init_one
,
230 .remove
= ata_pci_remove_one
,
231 .suspend
= ata_pci_device_suspend
,
232 .resume
= ata_pci_device_resume
,
235 static int __init
ata_generic_init(void)
237 return pci_register_driver(&ata_generic_pci_driver
);
241 static void __exit
ata_generic_exit(void)
243 pci_unregister_driver(&ata_generic_pci_driver
);
247 MODULE_AUTHOR("Alan Cox");
248 MODULE_DESCRIPTION("low-level driver for generic ATA");
249 MODULE_LICENSE("GPL");
250 MODULE_DEVICE_TABLE(pci
, ata_generic
);
251 MODULE_VERSION(DRV_VERSION
);
253 module_init(ata_generic_init
);
254 module_exit(ata_generic_exit
);
256 module_param(all_generic_ide
, int, 0);