forked from Minki/linux
ced3ec8aa7
Prefix messages from IDE PCI host drivers by driver name instead of marketed
chipset name (it is still possible to exactly identify the particular chipset
basing on driver messages).
As a bonus this provides nice code savings for some drivers:
text data bss dec hex filename
3826 112 8 3946 f6a drivers/ide/pci/amd74xx.o.before
2786 112 8 2906 b5a drivers/ide/pci/amd74xx.o.after
764 108 0 872 368 drivers/ide/pci/cs5520.o.before
680 108 0 788 314 drivers/ide/pci/cs5520.o.after
1680 112 4 1796 704 drivers/ide/pci/generic.o.before
1155 112 4 1271 4f7 drivers/ide/pci/generic.o.after
7128 792 0 7920 1ef0 drivers/ide/pci/hpt366.o.before
6984 792 0 7776 1e60 drivers/ide/pci/hpt366.o.after
2800 148 0 2948 b84 drivers/ide/pci/pdc202xx_new.o.before
2523 148 0 2671 a6f drivers/ide/pci/pdc202xx_new.o.after
2831 148 0 2979 ba3 drivers/ide/pci/pdc202xx_old.o.before
2683 148 0 2831 b0f drivers/ide/pci/pdc202xx_old.o.after
3776 112 4 3892 f34 drivers/ide/pci/piix.o.before
2804 112 4 2920 b68 drivers/ide/pci/piix.o.after
4693 116 0 4809 12c9 drivers/ide/pci/siimage.o.before
4600 116 0 4716 126c drivers/ide/pci/siimage.o.after
Signed-off-by: Bartlomiej Zolnierkiewicz <bzolnier@gmail.com>
209 lines
5.5 KiB
C
209 lines
5.5 KiB
C
/*
|
|
* Copyright (C) 2003 ATI Inc. <hyu@ati.com>
|
|
* Copyright (C) 2004,2007 Bartlomiej Zolnierkiewicz
|
|
*/
|
|
|
|
#include <linux/types.h>
|
|
#include <linux/module.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/pci.h>
|
|
#include <linux/hdreg.h>
|
|
#include <linux/ide.h>
|
|
#include <linux/init.h>
|
|
|
|
#define DRV_NAME "atiixp"
|
|
|
|
#define ATIIXP_IDE_PIO_TIMING 0x40
|
|
#define ATIIXP_IDE_MDMA_TIMING 0x44
|
|
#define ATIIXP_IDE_PIO_CONTROL 0x48
|
|
#define ATIIXP_IDE_PIO_MODE 0x4a
|
|
#define ATIIXP_IDE_UDMA_CONTROL 0x54
|
|
#define ATIIXP_IDE_UDMA_MODE 0x56
|
|
|
|
typedef struct {
|
|
u8 command_width;
|
|
u8 recover_width;
|
|
} atiixp_ide_timing;
|
|
|
|
static atiixp_ide_timing pio_timing[] = {
|
|
{ 0x05, 0x0d },
|
|
{ 0x04, 0x07 },
|
|
{ 0x03, 0x04 },
|
|
{ 0x02, 0x02 },
|
|
{ 0x02, 0x00 },
|
|
};
|
|
|
|
static atiixp_ide_timing mdma_timing[] = {
|
|
{ 0x07, 0x07 },
|
|
{ 0x02, 0x01 },
|
|
{ 0x02, 0x00 },
|
|
};
|
|
|
|
static DEFINE_SPINLOCK(atiixp_lock);
|
|
|
|
/**
|
|
* atiixp_set_pio_mode - set host controller for PIO mode
|
|
* @drive: drive
|
|
* @pio: PIO mode number
|
|
*
|
|
* Set the interface PIO mode.
|
|
*/
|
|
|
|
static void atiixp_set_pio_mode(ide_drive_t *drive, const u8 pio)
|
|
{
|
|
struct pci_dev *dev = to_pci_dev(drive->hwif->dev);
|
|
unsigned long flags;
|
|
int timing_shift = (drive->dn & 2) ? 16 : 0 + (drive->dn & 1) ? 0 : 8;
|
|
u32 pio_timing_data;
|
|
u16 pio_mode_data;
|
|
|
|
spin_lock_irqsave(&atiixp_lock, flags);
|
|
|
|
pci_read_config_word(dev, ATIIXP_IDE_PIO_MODE, &pio_mode_data);
|
|
pio_mode_data &= ~(0x07 << (drive->dn * 4));
|
|
pio_mode_data |= (pio << (drive->dn * 4));
|
|
pci_write_config_word(dev, ATIIXP_IDE_PIO_MODE, pio_mode_data);
|
|
|
|
pci_read_config_dword(dev, ATIIXP_IDE_PIO_TIMING, &pio_timing_data);
|
|
pio_timing_data &= ~(0xff << timing_shift);
|
|
pio_timing_data |= (pio_timing[pio].recover_width << timing_shift) |
|
|
(pio_timing[pio].command_width << (timing_shift + 4));
|
|
pci_write_config_dword(dev, ATIIXP_IDE_PIO_TIMING, pio_timing_data);
|
|
|
|
spin_unlock_irqrestore(&atiixp_lock, flags);
|
|
}
|
|
|
|
/**
|
|
* atiixp_set_dma_mode - set host controller for DMA mode
|
|
* @drive: drive
|
|
* @speed: DMA mode
|
|
*
|
|
* Set a ATIIXP host controller to the desired DMA mode. This involves
|
|
* programming the right timing data into the PCI configuration space.
|
|
*/
|
|
|
|
static void atiixp_set_dma_mode(ide_drive_t *drive, const u8 speed)
|
|
{
|
|
struct pci_dev *dev = to_pci_dev(drive->hwif->dev);
|
|
unsigned long flags;
|
|
int timing_shift = (drive->dn & 2) ? 16 : 0 + (drive->dn & 1) ? 0 : 8;
|
|
u32 tmp32;
|
|
u16 tmp16;
|
|
u16 udma_ctl = 0;
|
|
|
|
spin_lock_irqsave(&atiixp_lock, flags);
|
|
|
|
pci_read_config_word(dev, ATIIXP_IDE_UDMA_CONTROL, &udma_ctl);
|
|
|
|
if (speed >= XFER_UDMA_0) {
|
|
pci_read_config_word(dev, ATIIXP_IDE_UDMA_MODE, &tmp16);
|
|
tmp16 &= ~(0x07 << (drive->dn * 4));
|
|
tmp16 |= ((speed & 0x07) << (drive->dn * 4));
|
|
pci_write_config_word(dev, ATIIXP_IDE_UDMA_MODE, tmp16);
|
|
|
|
udma_ctl |= (1 << drive->dn);
|
|
} else if (speed >= XFER_MW_DMA_0) {
|
|
u8 i = speed & 0x03;
|
|
|
|
pci_read_config_dword(dev, ATIIXP_IDE_MDMA_TIMING, &tmp32);
|
|
tmp32 &= ~(0xff << timing_shift);
|
|
tmp32 |= (mdma_timing[i].recover_width << timing_shift) |
|
|
(mdma_timing[i].command_width << (timing_shift + 4));
|
|
pci_write_config_dword(dev, ATIIXP_IDE_MDMA_TIMING, tmp32);
|
|
|
|
udma_ctl &= ~(1 << drive->dn);
|
|
}
|
|
|
|
pci_write_config_word(dev, ATIIXP_IDE_UDMA_CONTROL, udma_ctl);
|
|
|
|
spin_unlock_irqrestore(&atiixp_lock, flags);
|
|
}
|
|
|
|
static u8 __devinit atiixp_cable_detect(ide_hwif_t *hwif)
|
|
{
|
|
struct pci_dev *pdev = to_pci_dev(hwif->dev);
|
|
u8 udma_mode = 0, ch = hwif->channel;
|
|
|
|
pci_read_config_byte(pdev, ATIIXP_IDE_UDMA_MODE + ch, &udma_mode);
|
|
|
|
if ((udma_mode & 0x07) >= 0x04 || (udma_mode & 0x70) >= 0x40)
|
|
return ATA_CBL_PATA80;
|
|
else
|
|
return ATA_CBL_PATA40;
|
|
}
|
|
|
|
static const struct ide_port_ops atiixp_port_ops = {
|
|
.set_pio_mode = atiixp_set_pio_mode,
|
|
.set_dma_mode = atiixp_set_dma_mode,
|
|
.cable_detect = atiixp_cable_detect,
|
|
};
|
|
|
|
static const struct ide_port_info atiixp_pci_info[] __devinitdata = {
|
|
{ /* 0: IXP200/300/400/700 */
|
|
.name = DRV_NAME,
|
|
.enablebits = {{0x48,0x01,0x00}, {0x48,0x08,0x00}},
|
|
.port_ops = &atiixp_port_ops,
|
|
.host_flags = IDE_HFLAG_LEGACY_IRQS,
|
|
.pio_mask = ATA_PIO4,
|
|
.mwdma_mask = ATA_MWDMA2,
|
|
.udma_mask = ATA_UDMA5,
|
|
},
|
|
{ /* 1: IXP600 */
|
|
.name = DRV_NAME,
|
|
.enablebits = {{0x48,0x01,0x00}, {0x00,0x00,0x00}},
|
|
.port_ops = &atiixp_port_ops,
|
|
.host_flags = IDE_HFLAG_SINGLE | IDE_HFLAG_LEGACY_IRQS,
|
|
.pio_mask = ATA_PIO4,
|
|
.mwdma_mask = ATA_MWDMA2,
|
|
.udma_mask = ATA_UDMA5,
|
|
},
|
|
};
|
|
|
|
/**
|
|
* atiixp_init_one - called when a ATIIXP is found
|
|
* @dev: the atiixp device
|
|
* @id: the matching pci id
|
|
*
|
|
* Called when the PCI registration layer (or the IDE initialization)
|
|
* finds a device matching our IDE device tables.
|
|
*/
|
|
|
|
static int __devinit atiixp_init_one(struct pci_dev *dev, const struct pci_device_id *id)
|
|
{
|
|
return ide_pci_init_one(dev, &atiixp_pci_info[id->driver_data], NULL);
|
|
}
|
|
|
|
static const struct pci_device_id atiixp_pci_tbl[] = {
|
|
{ PCI_VDEVICE(ATI, PCI_DEVICE_ID_ATI_IXP200_IDE), 0 },
|
|
{ PCI_VDEVICE(ATI, PCI_DEVICE_ID_ATI_IXP300_IDE), 0 },
|
|
{ PCI_VDEVICE(ATI, PCI_DEVICE_ID_ATI_IXP400_IDE), 0 },
|
|
{ PCI_VDEVICE(ATI, PCI_DEVICE_ID_ATI_IXP600_IDE), 1 },
|
|
{ PCI_VDEVICE(ATI, PCI_DEVICE_ID_ATI_IXP700_IDE), 0 },
|
|
{ 0, },
|
|
};
|
|
MODULE_DEVICE_TABLE(pci, atiixp_pci_tbl);
|
|
|
|
static struct pci_driver driver = {
|
|
.name = "ATIIXP_IDE",
|
|
.id_table = atiixp_pci_tbl,
|
|
.probe = atiixp_init_one,
|
|
.remove = ide_pci_remove,
|
|
};
|
|
|
|
static int __init atiixp_ide_init(void)
|
|
{
|
|
return ide_pci_register_driver(&driver);
|
|
}
|
|
|
|
static void __exit atiixp_ide_exit(void)
|
|
{
|
|
pci_unregister_driver(&driver);
|
|
}
|
|
|
|
module_init(atiixp_ide_init);
|
|
module_exit(atiixp_ide_exit);
|
|
|
|
MODULE_AUTHOR("HUI YU");
|
|
MODULE_DESCRIPTION("PCI driver module for ATI IXP IDE");
|
|
MODULE_LICENSE("GPL");
|