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.13"
32 * A generic parallel ATA driver using libata
36 * generic_set_mode - mode setting
37 * @link: link to set up
38 * @unused: returned device on error
40 * Use a non standard set_mode function. We don't want to be tuned.
41 * The BIOS configured everything. Our job is not to fiddle. We
42 * read the dma enabled bits from the PCI configuration of the device
46 static int generic_set_mode(struct ata_link
*link
, struct ata_device
**unused
)
48 struct ata_port
*ap
= link
->ap
;
50 struct ata_device
*dev
;
52 /* Bits 5 and 6 indicate if DMA is active on master/slave */
53 if (ap
->ioaddr
.bmdma_addr
)
54 dma_enabled
= ioread8(ap
->ioaddr
.bmdma_addr
+ ATA_DMA_STATUS
);
56 ata_link_for_each_dev(dev
, link
) {
57 if (!ata_dev_enabled(dev
))
60 /* We don't really care */
61 dev
->pio_mode
= XFER_PIO_0
;
62 dev
->dma_mode
= XFER_MW_DMA_0
;
63 /* We do need the right mode information for DMA or PIO
64 and this comes from the current configuration flags */
65 if (dma_enabled
& (1 << (5 + dev
->devno
))) {
66 unsigned int xfer_mask
= ata_id_xfermask(dev
->id
);
69 if (xfer_mask
& (ATA_MASK_MWDMA
| ATA_MASK_UDMA
))
70 name
= ata_mode_string(xfer_mask
);
74 xfer_mask
|= ata_xfer_mode2mask(XFER_MW_DMA_0
);
77 ata_dev_printk(dev
, KERN_INFO
, "configured for %s\n",
80 dev
->xfer_mode
= ata_xfer_mask2mode(xfer_mask
);
81 dev
->xfer_shift
= ata_xfer_mode2shift(dev
->xfer_mode
);
82 dev
->flags
&= ~ATA_DFLAG_PIO
;
84 ata_dev_printk(dev
, KERN_INFO
, "configured for PIO\n");
85 dev
->xfer_mode
= XFER_PIO_0
;
86 dev
->xfer_shift
= ATA_SHIFT_PIO
;
87 dev
->flags
|= ATA_DFLAG_PIO
;
93 static struct scsi_host_template generic_sht
= {
94 .module
= THIS_MODULE
,
96 .ioctl
= ata_scsi_ioctl
,
97 .queuecommand
= ata_scsi_queuecmd
,
98 .can_queue
= ATA_DEF_QUEUE
,
99 .this_id
= ATA_SHT_THIS_ID
,
100 .sg_tablesize
= LIBATA_MAX_PRD
,
101 .cmd_per_lun
= ATA_SHT_CMD_PER_LUN
,
102 .emulated
= ATA_SHT_EMULATED
,
103 .use_clustering
= ATA_SHT_USE_CLUSTERING
,
104 .proc_name
= DRV_NAME
,
105 .dma_boundary
= ATA_DMA_BOUNDARY
,
106 .slave_configure
= ata_scsi_slave_config
,
107 .slave_destroy
= ata_scsi_slave_destroy
,
108 .bios_param
= ata_std_bios_param
,
111 static struct ata_port_operations generic_port_ops
= {
112 .set_mode
= generic_set_mode
,
114 .tf_load
= ata_tf_load
,
115 .tf_read
= ata_tf_read
,
116 .check_status
= ata_check_status
,
117 .exec_command
= ata_exec_command
,
118 .dev_select
= ata_std_dev_select
,
120 .bmdma_setup
= ata_bmdma_setup
,
121 .bmdma_start
= ata_bmdma_start
,
122 .bmdma_stop
= ata_bmdma_stop
,
123 .bmdma_status
= ata_bmdma_status
,
125 .data_xfer
= ata_data_xfer
,
127 .freeze
= ata_bmdma_freeze
,
128 .thaw
= ata_bmdma_thaw
,
129 .error_handler
= ata_bmdma_error_handler
,
130 .post_internal_cmd
= ata_bmdma_post_internal_cmd
,
131 .cable_detect
= ata_cable_unknown
,
133 .qc_prep
= ata_qc_prep
,
134 .qc_issue
= ata_qc_issue_prot
,
136 .irq_handler
= ata_interrupt
,
137 .irq_clear
= ata_bmdma_irq_clear
,
138 .irq_on
= ata_irq_on
,
140 .port_start
= ata_sff_port_start
,
143 static int all_generic_ide
; /* Set to claim all devices */
146 * ata_generic_init - attach generic IDE
147 * @dev: PCI device found
150 * Called each time a matching IDE interface is found. We check if the
151 * interface is one we wish to claim and if so we perform any chip
152 * specific hacks then let the ATA layer do the heavy lifting.
155 static int ata_generic_init_one(struct pci_dev
*dev
, const struct pci_device_id
*id
)
158 static const struct ata_port_info info
= {
160 .flags
= ATA_FLAG_SLAVE_POSS
,
163 .udma_mask
= ATA_UDMA5
,
164 .port_ops
= &generic_port_ops
166 const struct ata_port_info
*ppi
[] = { &info
, NULL
};
168 /* Don't use the generic entry unless instructed to do so */
169 if (id
->driver_data
== 1 && all_generic_ide
== 0)
172 /* Devices that need care */
173 if (dev
->vendor
== PCI_VENDOR_ID_UMC
&&
174 dev
->device
== PCI_DEVICE_ID_UMC_UM8886A
&&
175 (!(PCI_FUNC(dev
->devfn
) & 1)))
178 if (dev
->vendor
== PCI_VENDOR_ID_OPTI
&&
179 dev
->device
== PCI_DEVICE_ID_OPTI_82C558
&&
180 (!(PCI_FUNC(dev
->devfn
) & 1)))
183 /* Don't re-enable devices in generic mode or we will break some
184 motherboards with disabled and unused IDE controllers */
185 pci_read_config_word(dev
, PCI_COMMAND
, &command
);
186 if (!(command
& PCI_COMMAND_IO
))
189 if (dev
->vendor
== PCI_VENDOR_ID_AL
)
190 ata_pci_clear_simplex(dev
);
192 return ata_pci_init_one(dev
, ppi
);
195 static struct pci_device_id ata_generic
[] = {
196 { PCI_DEVICE(PCI_VENDOR_ID_PCTECH
, PCI_DEVICE_ID_PCTECH_SAMURAI_IDE
), },
197 { PCI_DEVICE(PCI_VENDOR_ID_HOLTEK
, PCI_DEVICE_ID_HOLTEK_6565
), },
198 { PCI_DEVICE(PCI_VENDOR_ID_UMC
, PCI_DEVICE_ID_UMC_UM8673F
), },
199 { PCI_DEVICE(PCI_VENDOR_ID_UMC
, PCI_DEVICE_ID_UMC_UM8886A
), },
200 { PCI_DEVICE(PCI_VENDOR_ID_UMC
, PCI_DEVICE_ID_UMC_UM8886BF
), },
201 { PCI_DEVICE(PCI_VENDOR_ID_HINT
, PCI_DEVICE_ID_HINT_VXPROII_IDE
), },
202 { PCI_DEVICE(PCI_VENDOR_ID_VIA
, PCI_DEVICE_ID_VIA_82C561
), },
203 { PCI_DEVICE(PCI_VENDOR_ID_OPTI
, PCI_DEVICE_ID_OPTI_82C558
), },
204 { PCI_DEVICE(PCI_VENDOR_ID_TOSHIBA
,PCI_DEVICE_ID_TOSHIBA_PICCOLO
), },
205 { PCI_DEVICE(PCI_VENDOR_ID_TOSHIBA
,PCI_DEVICE_ID_TOSHIBA_PICCOLO_1
), },
206 { PCI_DEVICE(PCI_VENDOR_ID_TOSHIBA
,PCI_DEVICE_ID_TOSHIBA_PICCOLO_2
), },
207 /* Must come last. If you add entries adjust this table appropriately */
208 { PCI_ANY_ID
, PCI_ANY_ID
, PCI_ANY_ID
, PCI_ANY_ID
, PCI_CLASS_STORAGE_IDE
<< 8, 0xFFFFFF00UL
, 1},
212 static struct pci_driver ata_generic_pci_driver
= {
214 .id_table
= ata_generic
,
215 .probe
= ata_generic_init_one
,
216 .remove
= ata_pci_remove_one
,
218 .suspend
= ata_pci_device_suspend
,
219 .resume
= ata_pci_device_resume
,
223 static int __init
ata_generic_init(void)
225 return pci_register_driver(&ata_generic_pci_driver
);
229 static void __exit
ata_generic_exit(void)
231 pci_unregister_driver(&ata_generic_pci_driver
);
235 MODULE_AUTHOR("Alan Cox");
236 MODULE_DESCRIPTION("low-level driver for generic ATA");
237 MODULE_LICENSE("GPL");
238 MODULE_DEVICE_TABLE(pci
, ata_generic
);
239 MODULE_VERSION(DRV_VERSION
);
241 module_init(ata_generic_init
);
242 module_exit(ata_generic_exit
);
244 module_param(all_generic_ide
, int, 0);