Release 4.12 drivers/ata/pata_rz1000.c

/*
 *  RZ1000/1001 driver based upon
 *
 *  linux/drivers/ide/pci/rz1000.c      Version 0.06    January 12, 2003
 *  Copyright (C) 1995-1998  Linus Torvalds & author (see below)
 *  Principal Author:  mlord@pobox.com (Mark Lord)
 *
 *  See linux/MAINTAINERS for address of current maintainer.
 *
 *  This file provides support for disabling the buggy read-ahead
 *  mode of the RZ1000 IDE chipset, commonly used on Intel motherboards.
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/pci.h>
#include <linux/blkdev.h>
#include <linux/delay.h>
#include <scsi/scsi_host.h>
#include <linux/libata.h>


#define DRV_NAME	"pata_rz1000"

#define DRV_VERSION	"0.2.4"


/**
 *      rz1000_set_mode         -       mode setting function
 *      @link: ATA link
 *      @unused: returned device on set_mode failure
 *
 *      Use a non standard set_mode function. We don't want to be tuned. We
 *      would prefer to be BIOS generic but for the fact our hardware is
 *      whacked out.
 */



static int rz1000_set_mode(struct ata_link *link, struct ata_device **unused)
{
	struct ata_device *dev;

	ata_for_each_dev(dev, link, ENABLED) {
		/* We don't really care */
		dev->pio_mode = XFER_PIO_0;
		dev->xfer_mode = XFER_PIO_0;
		dev->xfer_shift = ATA_SHIFT_PIO;
		dev->flags |= ATA_DFLAG_PIO;
		ata_dev_info(dev, "configured for PIO\n");
	}
	return 0;
}


Contributors
Person
Tokens
Prop
Commits
CommitProp
Jeff Garzik
39
58.21%
1
14.29%
Alan Cox
16
23.88%
2
28.57%
Tejun Heo
11
16.42%
3
42.86%
Joe Perches
1
1.49%
1
14.29%
Total
67
100.00%
7
100.00%


static struct scsi_host_template rz1000_sht = {
	ATA_PIO_SHT(DRV_NAME),
};


static struct ata_port_operations rz1000_port_ops = {
	.inherits	= &ata_sff_port_ops,
	.cable_detect	= ata_cable_40wire,
	.set_mode	= rz1000_set_mode,
};



static int rz1000_fifo_disable(struct pci_dev *pdev)
{
	u16 reg;
	/* Be exceptionally paranoid as we must be sure to apply the fix */
	if (pci_read_config_word(pdev, 0x40, &reg) != 0)
		return -1;
	reg &= 0xDFFF;
	if (pci_write_config_word(pdev, 0x40, reg) != 0)
		return -1;
	printk(KERN_INFO DRV_NAME ": disabled chipset readahead.\n");
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Alan Cox
63
100.00%
1
100.00%
Total
63
100.00%
1
100.00%

/**
 *      rz1000_init_one - Register RZ1000 ATA PCI device with kernel services
 *      @pdev: PCI device to register
 *      @ent: Entry in rz1000_pci_tbl matching with @pdev
 *
 *      Configure an RZ1000 interface. This doesn't require much special
 *      handling except that we *MUST* kill the chipset readahead or the
 *      user may experience data corruption.
 */



static int rz1000_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
{
	static const struct ata_port_info info = {
		.flags = ATA_FLAG_SLAVE_POSS,
		.pio_mask = ATA_PIO4,
		.port_ops = &rz1000_port_ops
	};
	const struct ata_port_info *ppi[] = { &info, NULL };

	ata_print_version_once(&pdev->dev, DRV_VERSION);

	if (rz1000_fifo_disable(pdev) == 0)
		return ata_pci_sff_init_one(pdev, ppi, &rz1000_sht, NULL, 0);

	printk(KERN_ERR DRV_NAME ": failed to disable read-ahead on chipset..\n");
	/* Not safe to use so skip */
	return -ENODEV;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jeff Garzik
65
65.00%
1
11.11%
Tejun Heo
22
22.00%
4
44.44%
Joe Perches
8
8.00%
1
11.11%
Alan Cox
4
4.00%
2
22.22%
Erik Inge Bolsö
1
1.00%
1
11.11%
Total
100
100.00%
9
100.00%

#ifdef CONFIG_PM_SLEEP


static int rz1000_reinit_one(struct pci_dev *pdev)
{
	struct ata_host *host = pci_get_drvdata(pdev);
	int rc;

	rc = ata_pci_device_do_resume(pdev);
	if (rc)
		return rc;

	/* If this fails on resume (which is a "can't happen" case), we
           must stop as any progress risks data loss */
	if (rz1000_fifo_disable(pdev))
		panic("rz1000 fifo");

	ata_host_resume(host);
	return 0;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Bartlomiej Zolnierkiewicz
31
52.54%
1
25.00%
Alan Cox
26
44.07%
1
25.00%
Jingoo Han
1
1.69%
1
25.00%
Lucas De Marchi
1
1.69%
1
25.00%
Total
59
100.00%
4
100.00%

#endif


static const struct pci_device_id pata_rz1000[] = {
	{ PCI_VDEVICE(PCTECH, PCI_DEVICE_ID_PCTECH_RZ1000), },
	{ PCI_VDEVICE(PCTECH, PCI_DEVICE_ID_PCTECH_RZ1001), },

	{ },
};


static struct pci_driver rz1000_pci_driver = {
	.name 		= DRV_NAME,
	.id_table	= pata_rz1000,
	.probe 		= rz1000_init_one,
	.remove		= ata_pci_remove_one,
#ifdef CONFIG_PM_SLEEP
	.suspend	= ata_pci_device_suspend,
	.resume		= rz1000_reinit_one,
#endif
};


module_pci_driver(rz1000_pci_driver);

MODULE_AUTHOR("Alan Cox");
MODULE_DESCRIPTION("low-level driver for RZ1000 PCI ATA");
MODULE_LICENSE("GPL");
MODULE_DEVICE_TABLE(pci, pata_rz1000);

MODULE_VERSION(DRV_VERSION);
Overall Contributors
Person
Tokens
Prop
Commits
CommitProp
Jeff Garzik
241
51.83%
3
10.71%
Alan Cox
124
26.67%
5
17.86%
Tejun Heo
54
11.61%
12
42.86%
Bartlomiej Zolnierkiewicz
33
7.10%
2
7.14%
Joe Perches
9
1.94%
2
7.14%
Jingoo Han
1
0.22%
1
3.57%
Erik Inge Bolsö
1
0.22%
1
3.57%
Lucas De Marchi
1
0.22%
1
3.57%
Axel Lin
1
0.22%
1
3.57%
Total
465
100.00%
28
100.00%
Directory: drivers/ata

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.