[net-next-2.6.git] / drivers / mfd / timberdale.c

/*
 * timberdale.c timberdale FPGA MFD driver
 * Copyright (c) 2009 Intel Corporation
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

/* Supports:
 * Timberdale FPGA
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/pci.h>
#include <linux/msi.h>
#include <linux/mfd/core.h>

#include <linux/timb_gpio.h>

#include <linux/i2c.h>
#include <linux/i2c-ocores.h>
#include <linux/i2c/tsc2007.h>

#include <linux/spi/spi.h>
#include <linux/spi/xilinx_spi.h>
#include <linux/spi/max7301.h>
#include <linux/spi/mc33880.h>

#include <media/timb_radio.h>

#include "timberdale.h"

#define DRIVER_NAME "timberdale"

struct timberdale_device {
	resource_size_t		ctl_mapbase;
	unsigned char __iomem   *ctl_membase;
	struct {
		u32 major;
		u32 minor;
		u32 config;
	} fw;
};

/*--------------------------------------------------------------------------*/

static struct tsc2007_platform_data timberdale_tsc2007_platform_data = {
	.model = 2003,
	.x_plate_ohms = 100
};

static struct i2c_board_info timberdale_i2c_board_info[] = {
	{
		I2C_BOARD_INFO("tsc2007", 0x48),
		.platform_data = &timberdale_tsc2007_platform_data,
		.irq = IRQ_TIMBERDALE_TSC_INT
	},
};

static __devinitdata struct ocores_i2c_platform_data
timberdale_ocores_platform_data = {
	.regstep = 4,
	.clock_khz = 62500,
	.devices = timberdale_i2c_board_info,
	.num_devices = ARRAY_SIZE(timberdale_i2c_board_info)
};

const static __devinitconst struct resource timberdale_ocores_resources[] = {
	{
		.start	= OCORESOFFSET,
		.end	= OCORESEND,
		.flags	= IORESOURCE_MEM,
	},
	{
		.start 	= IRQ_TIMBERDALE_I2C,
		.end	= IRQ_TIMBERDALE_I2C,
		.flags	= IORESOURCE_IRQ,
	},
};

const struct max7301_platform_data timberdale_max7301_platform_data = {
	.base = 200
};

const struct mc33880_platform_data timberdale_mc33880_platform_data = {
	.base = 100
};

static struct spi_board_info timberdale_spi_16bit_board_info[] = {
	{
		.modalias = "max7301",
		.max_speed_hz = 26000,
		.chip_select = 2,
		.mode = SPI_MODE_0,
		.platform_data = &timberdale_max7301_platform_data
	},
};

static struct spi_board_info timberdale_spi_8bit_board_info[] = {
	{
		.modalias = "mc33880",
		.max_speed_hz = 4000,
		.chip_select = 1,
		.mode = SPI_MODE_1,
		.platform_data = &timberdale_mc33880_platform_data
	},
};

static __devinitdata struct xspi_platform_data timberdale_xspi_platform_data = {
	.num_chipselect = 3,
	.little_endian = true,
	/* bits per word and devices will be filled in runtime depending
	 * on the HW config
	 */
};

const static __devinitconst struct resource timberdale_spi_resources[] = {
	{
		.start 	= SPIOFFSET,
		.end	= SPIEND,
		.flags	= IORESOURCE_MEM,
	},
	{
		.start	= IRQ_TIMBERDALE_SPI,
		.end	= IRQ_TIMBERDALE_SPI,
		.flags	= IORESOURCE_IRQ,
	},
};

const static __devinitconst struct resource timberdale_eth_resources[] = {
	{
		.start	= ETHOFFSET,
		.end	= ETHEND,
		.flags	= IORESOURCE_MEM,
	},
	{
		.start	= IRQ_TIMBERDALE_ETHSW_IF,
		.end	= IRQ_TIMBERDALE_ETHSW_IF,
		.flags	= IORESOURCE_IRQ,
	},
};

static __devinitdata struct timbgpio_platform_data
	timberdale_gpio_platform_data = {
	.gpio_base = 0,
	.nr_pins = GPIO_NR_PINS,
	.irq_base = 200,
};

const static __devinitconst struct resource timberdale_gpio_resources[] = {
	{
		.start	= GPIOOFFSET,
		.end	= GPIOEND,
		.flags	= IORESOURCE_MEM,
	},
	{
		.start	= IRQ_TIMBERDALE_GPIO,
		.end	= IRQ_TIMBERDALE_GPIO,
		.flags	= IORESOURCE_IRQ,
	},
};

const static __devinitconst struct resource timberdale_mlogicore_resources[] = {
	{
		.start	= MLCOREOFFSET,
		.end	= MLCOREEND,
		.flags	= IORESOURCE_MEM,
	},
	{
		.start	= IRQ_TIMBERDALE_MLCORE,
		.end	= IRQ_TIMBERDALE_MLCORE,
		.flags	= IORESOURCE_IRQ,
	},
	{
		.start	= IRQ_TIMBERDALE_MLCORE_BUF,
		.end	= IRQ_TIMBERDALE_MLCORE_BUF,
		.flags	= IORESOURCE_IRQ,
	},
};

const static __devinitconst struct resource timberdale_uart_resources[] = {
	{
		.start	= UARTOFFSET,
		.end	= UARTEND,
		.flags	= IORESOURCE_MEM,
	},
	{
		.start	= IRQ_TIMBERDALE_UART,
		.end	= IRQ_TIMBERDALE_UART,
		.flags	= IORESOURCE_IRQ,
	},
};

const static __devinitconst struct resource timberdale_uartlite_resources[] = {
	{
		.start	= UARTLITEOFFSET,
		.end	= UARTLITEEND,
		.flags	= IORESOURCE_MEM,
	},
	{
		.start	= IRQ_TIMBERDALE_UARTLITE,
		.end	= IRQ_TIMBERDALE_UARTLITE,
		.flags	= IORESOURCE_IRQ,
	},
};

const static __devinitconst struct resource timberdale_radio_resources[] = {
	{
		.start	= RDSOFFSET,
		.end	= RDSEND,
		.flags	= IORESOURCE_MEM,
	},
	{
		.start	= IRQ_TIMBERDALE_RDS,
		.end	= IRQ_TIMBERDALE_RDS,
		.flags	= IORESOURCE_IRQ,
	},
};

static __devinitdata struct i2c_board_info timberdale_tef6868_i2c_board_info = {
	I2C_BOARD_INFO("tef6862", 0x60)
};

static __devinitdata struct i2c_board_info timberdale_saa7706_i2c_board_info = {
	I2C_BOARD_INFO("saa7706h", 0x1C)
};

static __devinitdata struct timb_radio_platform_data
	timberdale_radio_platform_data = {
	.i2c_adapter = 0,
	.tuner = {
		.module_name = "tef6862",
		.info = &timberdale_tef6868_i2c_board_info
	},
	.dsp = {
		.module_name = "saa7706h",
		.info = &timberdale_saa7706_i2c_board_info
	}
};

const static __devinitconst struct resource timberdale_dma_resources[] = {
	{
		.start	= DMAOFFSET,
		.end	= DMAEND,
		.flags	= IORESOURCE_MEM,
	},
	{
		.start	= IRQ_TIMBERDALE_DMA,
		.end	= IRQ_TIMBERDALE_DMA,
		.flags	= IORESOURCE_IRQ,
	},
};

static __devinitdata struct mfd_cell timberdale_cells_bar0_cfg0[] = {
	{
		.name = "timb-uart",
		.num_resources = ARRAY_SIZE(timberdale_uart_resources),
		.resources = timberdale_uart_resources,
	},
	{
		.name = "timb-gpio",
		.num_resources = ARRAY_SIZE(timberdale_gpio_resources),
		.resources = timberdale_gpio_resources,
		.platform_data = &timberdale_gpio_platform_data,
		.data_size = sizeof(timberdale_gpio_platform_data),
	},
	{
		.name = "timb-radio",
		.num_resources = ARRAY_SIZE(timberdale_radio_resources),
		.resources = timberdale_radio_resources,
		.platform_data = &timberdale_radio_platform_data,
		.data_size = sizeof(timberdale_radio_platform_data),
	},
	{
		.name = "xilinx_spi",
		.num_resources = ARRAY_SIZE(timberdale_spi_resources),
		.resources = timberdale_spi_resources,
		.platform_data = &timberdale_xspi_platform_data,
		.data_size = sizeof(timberdale_xspi_platform_data),
	},
	{
		.name = "ks8842",
		.num_resources = ARRAY_SIZE(timberdale_eth_resources),
		.resources = timberdale_eth_resources,
	},
	{
		.name = "timb-dma",
		.num_resources = ARRAY_SIZE(timberdale_dma_resources),
		.resources = timberdale_dma_resources,
	},
};

static __devinitdata struct mfd_cell timberdale_cells_bar0_cfg1[] = {
	{
		.name = "timb-uart",
		.num_resources = ARRAY_SIZE(timberdale_uart_resources),
		.resources = timberdale_uart_resources,
	},
	{
		.name = "uartlite",
		.num_resources = ARRAY_SIZE(timberdale_uartlite_resources),
		.resources = timberdale_uartlite_resources,
	},
	{
		.name = "timb-gpio",
		.num_resources = ARRAY_SIZE(timberdale_gpio_resources),
		.resources = timberdale_gpio_resources,
		.platform_data = &timberdale_gpio_platform_data,
		.data_size = sizeof(timberdale_gpio_platform_data),
	},
	{
		.name = "timb-mlogicore",
		.num_resources = ARRAY_SIZE(timberdale_mlogicore_resources),
		.resources = timberdale_mlogicore_resources,
	},
	{
		.name = "timb-radio",
		.num_resources = ARRAY_SIZE(timberdale_radio_resources),
		.resources = timberdale_radio_resources,
		.platform_data = &timberdale_radio_platform_data,
		.data_size = sizeof(timberdale_radio_platform_data),
	},
	{
		.name = "xilinx_spi",
		.num_resources = ARRAY_SIZE(timberdale_spi_resources),
		.resources = timberdale_spi_resources,
		.platform_data = &timberdale_xspi_platform_data,
		.data_size = sizeof(timberdale_xspi_platform_data),
	},
	{
		.name = "ks8842",
		.num_resources = ARRAY_SIZE(timberdale_eth_resources),
		.resources = timberdale_eth_resources,
	},
	{
		.name = "timb-dma",
		.num_resources = ARRAY_SIZE(timberdale_dma_resources),
		.resources = timberdale_dma_resources,
	},
};

static __devinitdata struct mfd_cell timberdale_cells_bar0_cfg2[] = {
	{
		.name = "timb-uart",
		.num_resources = ARRAY_SIZE(timberdale_uart_resources),
		.resources = timberdale_uart_resources,
	},
	{
		.name = "timb-gpio",
		.num_resources = ARRAY_SIZE(timberdale_gpio_resources),
		.resources = timberdale_gpio_resources,
		.platform_data = &timberdale_gpio_platform_data,
		.data_size = sizeof(timberdale_gpio_platform_data),
	},
	{
		.name = "timb-radio",
		.num_resources = ARRAY_SIZE(timberdale_radio_resources),
		.resources = timberdale_radio_resources,
		.platform_data = &timberdale_radio_platform_data,
		.data_size = sizeof(timberdale_radio_platform_data),
	},
	{
		.name = "xilinx_spi",
		.num_resources = ARRAY_SIZE(timberdale_spi_resources),
		.resources = timberdale_spi_resources,
		.platform_data = &timberdale_xspi_platform_data,
		.data_size = sizeof(timberdale_xspi_platform_data),
	},
	{
		.name = "timb-dma",
		.num_resources = ARRAY_SIZE(timberdale_dma_resources),
		.resources = timberdale_dma_resources,
	},
};

static __devinitdata struct mfd_cell timberdale_cells_bar0_cfg3[] = {
	{
		.name = "timb-uart",
		.num_resources = ARRAY_SIZE(timberdale_uart_resources),
		.resources = timberdale_uart_resources,
	},
	{
		.name = "ocores-i2c",
		.num_resources = ARRAY_SIZE(timberdale_ocores_resources),
		.resources = timberdale_ocores_resources,
		.platform_data = &timberdale_ocores_platform_data,
		.data_size = sizeof(timberdale_ocores_platform_data),
	},
	{
		.name = "timb-gpio",
		.num_resources = ARRAY_SIZE(timberdale_gpio_resources),
		.resources = timberdale_gpio_resources,
		.platform_data = &timberdale_gpio_platform_data,
		.data_size = sizeof(timberdale_gpio_platform_data),
	},
	{
		.name = "timb-radio",
		.num_resources = ARRAY_SIZE(timberdale_radio_resources),
		.resources = timberdale_radio_resources,
		.platform_data = &timberdale_radio_platform_data,
		.data_size = sizeof(timberdale_radio_platform_data),
	},
	{
		.name = "xilinx_spi",
		.num_resources = ARRAY_SIZE(timberdale_spi_resources),
		.resources = timberdale_spi_resources,
		.platform_data = &timberdale_xspi_platform_data,
		.data_size = sizeof(timberdale_xspi_platform_data),
	},
	{
		.name = "ks8842",
		.num_resources = ARRAY_SIZE(timberdale_eth_resources),
		.resources = timberdale_eth_resources,
	},
	{
		.name = "timb-dma",
		.num_resources = ARRAY_SIZE(timberdale_dma_resources),
		.resources = timberdale_dma_resources,
	},
};

static const __devinitconst struct resource timberdale_sdhc_resources[] = {
	/* located in bar 1 and bar 2 */
	{
		.start	= SDHC0OFFSET,
		.end	= SDHC0END,
		.flags	= IORESOURCE_MEM,
	},
	{
		.start	= IRQ_TIMBERDALE_SDHC,
		.end	= IRQ_TIMBERDALE_SDHC,
		.flags	= IORESOURCE_IRQ,
	},
};

static __devinitdata struct mfd_cell timberdale_cells_bar1[] = {
	{
		.name = "sdhci",
		.num_resources = ARRAY_SIZE(timberdale_sdhc_resources),
		.resources = timberdale_sdhc_resources,
	},
};

static __devinitdata struct mfd_cell timberdale_cells_bar2[] = {
	{
		.name = "sdhci",
		.num_resources = ARRAY_SIZE(timberdale_sdhc_resources),
		.resources = timberdale_sdhc_resources,
	},
};

static ssize_t show_fw_ver(struct device *dev, struct device_attribute *attr,
	char *buf)
{
	struct pci_dev *pdev = to_pci_dev(dev);
	struct timberdale_device *priv = pci_get_drvdata(pdev);

	return sprintf(buf, "%d.%d.%d\n", priv->fw.major, priv->fw.minor,
		priv->fw.config);
}

static DEVICE_ATTR(fw_ver, S_IRUGO, show_fw_ver, NULL);

/*--------------------------------------------------------------------------*/

static int __devinit timb_probe(struct pci_dev *dev,
	const struct pci_device_id *id)
{
	struct timberdale_device *priv;
	int err, i;
	resource_size_t mapbase;
	struct msix_entry *msix_entries = NULL;
	u8 ip_setup;

	priv = kzalloc(sizeof(*priv), GFP_KERNEL);
	if (!priv)
		return -ENOMEM;

	pci_set_drvdata(dev, priv);

	err = pci_enable_device(dev);
	if (err)
		goto err_enable;

	mapbase = pci_resource_start(dev, 0);
	if (!mapbase) {
		dev_err(&dev->dev, "No resource\n");
		goto err_start;
	}

	/* create a resource for the PCI master register */
	priv->ctl_mapbase = mapbase + CHIPCTLOFFSET;
	if (!request_mem_region(priv->ctl_mapbase, CHIPCTLSIZE, "timb-ctl")) {
		dev_err(&dev->dev, "Failed to request ctl mem\n");
		goto err_request;
	}

	priv->ctl_membase = ioremap(priv->ctl_mapbase, CHIPCTLSIZE);
	if (!priv->ctl_membase) {
		dev_err(&dev->dev, "ioremap failed for ctl mem\n");
		goto err_ioremap;
	}

	/* read the HW config */
	priv->fw.major = ioread32(priv->ctl_membase + TIMB_REV_MAJOR);
	priv->fw.minor = ioread32(priv->ctl_membase + TIMB_REV_MINOR);
	priv->fw.config = ioread32(priv->ctl_membase + TIMB_HW_CONFIG);

	if (priv->fw.major > TIMB_SUPPORTED_MAJOR) {
		dev_err(&dev->dev, "The driver supports an older "
			"version of the FPGA, please update the driver to "
			"support %d.%d\n", priv->fw.major, priv->fw.minor);
		goto err_ioremap;
	}
	if (priv->fw.major < TIMB_SUPPORTED_MAJOR ||
		priv->fw.minor < TIMB_REQUIRED_MINOR) {
		dev_err(&dev->dev, "The FPGA image is too old (%d.%d), "
			"please upgrade the FPGA to at least: %d.%d\n",
			priv->fw.major, priv->fw.minor,
			TIMB_SUPPORTED_MAJOR, TIMB_REQUIRED_MINOR);
		goto err_ioremap;
	}

	msix_entries = kzalloc(TIMBERDALE_NR_IRQS * sizeof(*msix_entries),
		GFP_KERNEL);
	if (!msix_entries)
		goto err_ioremap;

	for (i = 0; i < TIMBERDALE_NR_IRQS; i++)
		msix_entries[i].entry = i;

	err = pci_enable_msix(dev, msix_entries, TIMBERDALE_NR_IRQS);
	if (err) {
		dev_err(&dev->dev,
			"MSI-X init failed: %d, expected entries: %d\n",
			err, TIMBERDALE_NR_IRQS);
		goto err_msix;
	}

	err = device_create_file(&dev->dev, &dev_attr_fw_ver);
	if (err)
		goto err_create_file;

	/* Reset all FPGA PLB peripherals */
	iowrite32(0x1, priv->ctl_membase + TIMB_SW_RST);

	/* update IRQ offsets in I2C board info */
	for (i = 0; i < ARRAY_SIZE(timberdale_i2c_board_info); i++)
		timberdale_i2c_board_info[i].irq =
			msix_entries[timberdale_i2c_board_info[i].irq].vector;

	/* Update the SPI configuration depending on the HW (8 or 16 bit) */
	if (priv->fw.config & TIMB_HW_CONFIG_SPI_8BIT) {
		timberdale_xspi_platform_data.bits_per_word = 8;
		timberdale_xspi_platform_data.devices =
			timberdale_spi_8bit_board_info;
		timberdale_xspi_platform_data.num_devices =
			ARRAY_SIZE(timberdale_spi_8bit_board_info);
	} else {
		timberdale_xspi_platform_data.bits_per_word = 16;
		timberdale_xspi_platform_data.devices =
			timberdale_spi_16bit_board_info;
		timberdale_xspi_platform_data.num_devices =
			ARRAY_SIZE(timberdale_spi_16bit_board_info);
	}

	ip_setup = priv->fw.config & TIMB_HW_VER_MASK;
	switch (ip_setup) {
	case TIMB_HW_VER0:
		err = mfd_add_devices(&dev->dev, -1,
			timberdale_cells_bar0_cfg0,
			ARRAY_SIZE(timberdale_cells_bar0_cfg0),
			&dev->resource[0], msix_entries[0].vector);
		break;
	case TIMB_HW_VER1:
		err = mfd_add_devices(&dev->dev, -1,
			timberdale_cells_bar0_cfg1,
			ARRAY_SIZE(timberdale_cells_bar0_cfg1),
			&dev->resource[0], msix_entries[0].vector);
		break;
	case TIMB_HW_VER2:
		err = mfd_add_devices(&dev->dev, -1,
			timberdale_cells_bar0_cfg2,
			ARRAY_SIZE(timberdale_cells_bar0_cfg2),
			&dev->resource[0], msix_entries[0].vector);
		break;
	case TIMB_HW_VER3:
		err = mfd_add_devices(&dev->dev, -1,
			timberdale_cells_bar0_cfg3,
			ARRAY_SIZE(timberdale_cells_bar0_cfg3),
			&dev->resource[0], msix_entries[0].vector);
		break;
	default:
		dev_err(&dev->dev, "Uknown IP setup: %d.%d.%d\n",
			priv->fw.major, priv->fw.minor, ip_setup);
		err = -ENODEV;
		goto err_mfd;
		break;
	}

	if (err) {
		dev_err(&dev->dev, "mfd_add_devices failed: %d\n", err);
		goto err_mfd;
	}

	err = mfd_add_devices(&dev->dev, 0,
		timberdale_cells_bar1, ARRAY_SIZE(timberdale_cells_bar1),
		&dev->resource[1], msix_entries[0].vector);
	if (err) {
		dev_err(&dev->dev, "mfd_add_devices failed: %d\n", err);
		goto err_mfd2;
	}

	/* only version 0 and 3 have the iNand routed to SDHCI */
	if (((priv->fw.config & TIMB_HW_VER_MASK) == TIMB_HW_VER0) ||
		((priv->fw.config & TIMB_HW_VER_MASK) == TIMB_HW_VER3)) {
		err = mfd_add_devices(&dev->dev, 1, timberdale_cells_bar2,
			ARRAY_SIZE(timberdale_cells_bar2),
			&dev->resource[2], msix_entries[0].vector);
		if (err) {
			dev_err(&dev->dev, "mfd_add_devices failed: %d\n", err);
			goto err_mfd2;
		}
	}

	kfree(msix_entries);

	dev_info(&dev->dev,
		"Found Timberdale Card. Rev: %d.%d, HW config: 0x%02x\n",
		priv->fw.major, priv->fw.minor, priv->fw.config);

	return 0;

err_mfd2:
	mfd_remove_devices(&dev->dev);
err_mfd:
	device_remove_file(&dev->dev, &dev_attr_fw_ver);
err_create_file:
	pci_disable_msix(dev);
err_msix:
	iounmap(priv->ctl_membase);
err_ioremap:
	release_mem_region(priv->ctl_mapbase, CHIPCTLSIZE);
err_request:
	pci_set_drvdata(dev, NULL);
err_start:
	pci_disable_device(dev);
err_enable:
	kfree(msix_entries);
	kfree(priv);
	pci_set_drvdata(dev, NULL);
	return -ENODEV;
}

static void __devexit timb_remove(struct pci_dev *dev)
{
	struct timberdale_device *priv = pci_get_drvdata(dev);

	mfd_remove_devices(&dev->dev);

	device_remove_file(&dev->dev, &dev_attr_fw_ver);

	iounmap(priv->ctl_membase);
	release_mem_region(priv->ctl_mapbase, CHIPCTLSIZE);

	pci_disable_msix(dev);
	pci_disable_device(dev);
	pci_set_drvdata(dev, NULL);
	kfree(priv);
}

static struct pci_device_id timberdale_pci_tbl[] = {
	{ PCI_DEVICE(PCI_VENDOR_ID_TIMB, PCI_DEVICE_ID_TIMB) },
	{ 0 }
};
MODULE_DEVICE_TABLE(pci, timberdale_pci_tbl);

static struct pci_driver timberdale_pci_driver = {
	.name = DRIVER_NAME,
	.id_table = timberdale_pci_tbl,
	.probe = timb_probe,
	.remove = __devexit_p(timb_remove),
};

static int __init timberdale_init(void)
{
	int err;

	err = pci_register_driver(&timberdale_pci_driver);
	if (err < 0) {
		printk(KERN_ERR
			"Failed to register PCI driver for %s device.\n",
			timberdale_pci_driver.name);
		return -ENODEV;
	}

	printk(KERN_INFO "Driver for %s has been successfully registered.\n",
		timberdale_pci_driver.name);

	return 0;
}

static void __exit timberdale_exit(void)
{
	pci_unregister_driver(&timberdale_pci_driver);

	printk(KERN_INFO "Driver for %s has been successfully unregistered.\n",
		timberdale_pci_driver.name);
}

module_init(timberdale_init);
module_exit(timberdale_exit);

MODULE_AUTHOR("Mocean Laboratories <info@mocean-labs.com>");
MODULE_VERSION(DRV_VERSION);
MODULE_LICENSE("GPL v2");
Commit	Line	Data
8edbede9 RR	1	/*
	2	* timberdale.c timberdale FPGA MFD driver
	3	* Copyright (c) 2009 Intel Corporation
	4	*
	5	* This program is free software; you can redistribute it and/or modify
	6	* it under the terms of the GNU General Public License version 2 as
	7	* published by the Free Software Foundation.
	8	*
	9	* This program is distributed in the hope that it will be useful,
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	* GNU General Public License for more details.
	13	*
	14	* You should have received a copy of the GNU General Public License
	15	* along with this program; if not, write to the Free Software
	16	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	17	*/
	18
	19	/* Supports:
	20	* Timberdale FPGA
	21	*/
	22
	23	#include <linux/kernel.h>
	24	#include <linux/module.h>
	25	#include <linux/pci.h>
	26	#include <linux/msi.h>
	27	#include <linux/mfd/core.h>
	28
	29	#include <linux/timb_gpio.h>
	30
	31	#include <linux/i2c.h>
	32	#include <linux/i2c-ocores.h>
	33	#include <linux/i2c/tsc2007.h>
	34
	35	#include <linux/spi/spi.h>
	36	#include <linux/spi/xilinx_spi.h>
	37	#include <linux/spi/max7301.h>
	38	#include <linux/spi/mc33880.h>
	39
071193ff RR	40	#include <media/timb_radio.h>
071193ff RR	41
8edbede9 RR	42	#include "timberdale.h"
	43
	44	#define DRIVER_NAME "timberdale"
	45
	46	struct timberdale_device {
	47	resource_size_t ctl_mapbase;
	48	unsigned char __iomem *ctl_membase;
	49	struct {
	50	u32 major;
	51	u32 minor;
	52	u32 config;
	53	} fw;
	54	};
	55
	56	/--------------------------------------------------------------------------/
	57
	58	static struct tsc2007_platform_data timberdale_tsc2007_platform_data = {
	59	.model = 2003,
	60	.x_plate_ohms = 100
	61	};
	62
	63	static struct i2c_board_info timberdale_i2c_board_info[] = {
	64	{
	65	I2C_BOARD_INFO("tsc2007", 0x48),
	66	.platform_data = &timberdale_tsc2007_platform_data,
	67	.irq = IRQ_TIMBERDALE_TSC_INT
	68	},
	69	};
	70
	71	static __devinitdata struct ocores_i2c_platform_data
	72	timberdale_ocores_platform_data = {
	73	.regstep = 4,
	74	.clock_khz = 62500,
	75	.devices = timberdale_i2c_board_info,
	76	.num_devices = ARRAY_SIZE(timberdale_i2c_board_info)
	77	};
	78
	79	const static __devinitconst struct resource timberdale_ocores_resources[] = {
	80	{
	81	.start = OCORESOFFSET,
	82	.end = OCORESEND,
	83	.flags = IORESOURCE_MEM,
	84	},
	85	{
	86	.start = IRQ_TIMBERDALE_I2C,
	87	.end = IRQ_TIMBERDALE_I2C,
	88	.flags = IORESOURCE_IRQ,
	89	},
	90	};
	91
	92	const struct max7301_platform_data timberdale_max7301_platform_data = {
	93	.base = 200
	94	};
	95
	96	const struct mc33880_platform_data timberdale_mc33880_platform_data = {
	97	.base = 100
	98	};
	99
	100	static struct spi_board_info timberdale_spi_16bit_board_info[] = {
	101	{
	102	.modalias = "max7301",
	103	.max_speed_hz = 26000,
	104	.chip_select = 2,
	105	.mode = SPI_MODE_0,
106	.platform_data = &timberdale_max7301_platform_data
107	},
108	};
109
110	static struct spi_board_info timberdale_spi_8bit_board_info[] = {
111	{
112	.modalias = "mc33880",
113	.max_speed_hz = 4000,
114	.chip_select = 1,
115	.mode = SPI_MODE_1,
116	.platform_data = &timberdale_mc33880_platform_data
117	},
118	};
119
120	static __devinitdata struct xspi_platform_data timberdale_xspi_platform_data = {
121	.num_chipselect = 3,
122	.little_endian = true,
123	/* bits per word and devices will be filled in runtime depending
124	* on the HW config
125	*/
126	};
127
128	const static __devinitconst struct resource timberdale_spi_resources[] = {
129	{
130	.start = SPIOFFSET,
131	.end = SPIEND,
132	.flags = IORESOURCE_MEM,
133	},
134	{
135	.start = IRQ_TIMBERDALE_SPI,
136	.end = IRQ_TIMBERDALE_SPI,
137	.flags = IORESOURCE_IRQ,
138	},
139	};
140
141	const static __devinitconst struct resource timberdale_eth_resources[] = {
142	{
143	.start = ETHOFFSET,
144	.end = ETHEND,
145	.flags = IORESOURCE_MEM,
146	},
147	{
148	.start = IRQ_TIMBERDALE_ETHSW_IF,
149	.end = IRQ_TIMBERDALE_ETHSW_IF,
150	.flags = IORESOURCE_IRQ,
151	},
152	};
153
154	static __devinitdata struct timbgpio_platform_data
155	timberdale_gpio_platform_data = {
156	.gpio_base = 0,
157	.nr_pins = GPIO_NR_PINS,
158	.irq_base = 200,
159	};
160
161	const static __devinitconst struct resource timberdale_gpio_resources[] = {
162	{
163	.start = GPIOOFFSET,
164	.end = GPIOEND,
165	.flags = IORESOURCE_MEM,
166	},
167	{
168	.start = IRQ_TIMBERDALE_GPIO,
169	.end = IRQ_TIMBERDALE_GPIO,
170	.flags = IORESOURCE_IRQ,
171	},
172	};
173
174	const static __devinitconst struct resource timberdale_mlogicore_resources[] = {
175	{
176	.start = MLCOREOFFSET,
177	.end = MLCOREEND,
178	.flags = IORESOURCE_MEM,
179	},
180	{
181	.start = IRQ_TIMBERDALE_MLCORE,
182	.end = IRQ_TIMBERDALE_MLCORE,
183	.flags = IORESOURCE_IRQ,
184	},
185	{
186	.start = IRQ_TIMBERDALE_MLCORE_BUF,
187	.end = IRQ_TIMBERDALE_MLCORE_BUF,
188	.flags = IORESOURCE_IRQ,
189	},
190	};
191
192	const static __devinitconst struct resource timberdale_uart_resources[] = {
193	{
194	.start = UARTOFFSET,
195	.end = UARTEND,
196	.flags = IORESOURCE_MEM,
197	},
198	{
199	.start = IRQ_TIMBERDALE_UART,
200	.end = IRQ_TIMBERDALE_UART,
201	.flags = IORESOURCE_IRQ,
202	},
203	};
204
205	const static __devinitconst struct resource timberdale_uartlite_resources[] = {
206	{
207	.start = UARTLITEOFFSET,
208	.end = UARTLITEEND,
209	.flags = IORESOURCE_MEM,
210	},
211	{
212	.start = IRQ_TIMBERDALE_UARTLITE,
213	.end = IRQ_TIMBERDALE_UARTLITE,
214	.flags = IORESOURCE_IRQ,
215	},
216	};
217
071193ff RR	218	const static __devinitconst struct resource timberdale_radio_resources[] = {
	219	{
	220	.start = RDSOFFSET,
	221	.end = RDSEND,
	222	.flags = IORESOURCE_MEM,
	223	},
	224	{
	225	.start = IRQ_TIMBERDALE_RDS,
	226	.end = IRQ_TIMBERDALE_RDS,
	227	.flags = IORESOURCE_IRQ,
	228	},
	229	};
	230
	231	static __devinitdata struct i2c_board_info timberdale_tef6868_i2c_board_info = {
	232	I2C_BOARD_INFO("tef6862", 0x60)
	233	};
	234
	235	static __devinitdata struct i2c_board_info timberdale_saa7706_i2c_board_info = {
	236	I2C_BOARD_INFO("saa7706h", 0x1C)
	237	};
	238
	239	static __devinitdata struct timb_radio_platform_data
	240	timberdale_radio_platform_data = {
	241	.i2c_adapter = 0,
	242	.tuner = {
	243	.module_name = "tef6862",
	244	.info = &timberdale_tef6868_i2c_board_info
	245	},
	246	.dsp = {
	247	.module_name = "saa7706h",
	248	.info = &timberdale_saa7706_i2c_board_info
	249	}
	250	};
	251
8edbede9 RR	252	const static __devinitconst struct resource timberdale_dma_resources[] = {
	253	{
	254	.start = DMAOFFSET,
	255	.end = DMAEND,
	256	.flags = IORESOURCE_MEM,
	257	},
	258	{
	259	.start = IRQ_TIMBERDALE_DMA,
	260	.end = IRQ_TIMBERDALE_DMA,
	261	.flags = IORESOURCE_IRQ,
	262	},
	263	};
	264
	265	static __devinitdata struct mfd_cell timberdale_cells_bar0_cfg0[] = {
	266	{
	267	.name = "timb-uart",
	268	.num_resources = ARRAY_SIZE(timberdale_uart_resources),
	269	.resources = timberdale_uart_resources,
	270	},
	271	{
	272	.name = "timb-gpio",
	273	.num_resources = ARRAY_SIZE(timberdale_gpio_resources),
	274	.resources = timberdale_gpio_resources,
	275	.platform_data = &timberdale_gpio_platform_data,
	276	.data_size = sizeof(timberdale_gpio_platform_data),
	277	},
071193ff RR	278	{
	279	.name = "timb-radio",
	280	.num_resources = ARRAY_SIZE(timberdale_radio_resources),
	281	.resources = timberdale_radio_resources,
	282	.platform_data = &timberdale_radio_platform_data,
	283	.data_size = sizeof(timberdale_radio_platform_data),
	284	},
8edbede9 RR	285	{
	286	.name = "xilinx_spi",
	287	.num_resources = ARRAY_SIZE(timberdale_spi_resources),
	288	.resources = timberdale_spi_resources,
	289	.platform_data = &timberdale_xspi_platform_data,
	290	.data_size = sizeof(timberdale_xspi_platform_data),
	291	},
	292	{
	293	.name = "ks8842",
	294	.num_resources = ARRAY_SIZE(timberdale_eth_resources),
	295	.resources = timberdale_eth_resources,
	296	},
	297	{
	298	.name = "timb-dma",
	299	.num_resources = ARRAY_SIZE(timberdale_dma_resources),
	300	.resources = timberdale_dma_resources,
	301	},
	302	};
	303
	304	static __devinitdata struct mfd_cell timberdale_cells_bar0_cfg1[] = {
	305	{
	306	.name = "timb-uart",
	307	.num_resources = ARRAY_SIZE(timberdale_uart_resources),
	308	.resources = timberdale_uart_resources,
	309	},
	310	{
	311	.name = "uartlite",
	312	.num_resources = ARRAY_SIZE(timberdale_uartlite_resources),
	313	.resources = timberdale_uartlite_resources,
	314	},
	315	{
	316	.name = "timb-gpio",
	317	.num_resources = ARRAY_SIZE(timberdale_gpio_resources),
	318	.resources = timberdale_gpio_resources,
	319	.platform_data = &timberdale_gpio_platform_data,
	320	.data_size = sizeof(timberdale_gpio_platform_data),
	321	},
	322	{
	323	.name = "timb-mlogicore",
	324	.num_resources = ARRAY_SIZE(timberdale_mlogicore_resources),
	325	.resources = timberdale_mlogicore_resources,
	326	},
071193ff RR	327	{
	328	.name = "timb-radio",
	329	.num_resources = ARRAY_SIZE(timberdale_radio_resources),
	330	.resources = timberdale_radio_resources,
	331	.platform_data = &timberdale_radio_platform_data,
	332	.data_size = sizeof(timberdale_radio_platform_data),
	333	},
8edbede9 RR	334	{
	335	.name = "xilinx_spi",
	336	.num_resources = ARRAY_SIZE(timberdale_spi_resources),
	337	.resources = timberdale_spi_resources,
	338	.platform_data = &timberdale_xspi_platform_data,
	339	.data_size = sizeof(timberdale_xspi_platform_data),
	340	},
	341	{
	342	.name = "ks8842",
	343	.num_resources = ARRAY_SIZE(timberdale_eth_resources),
	344	.resources = timberdale_eth_resources,
	345	},
	346	{
	347	.name = "timb-dma",
	348	.num_resources = ARRAY_SIZE(timberdale_dma_resources),
	349	.resources = timberdale_dma_resources,
	350	},
	351	};
	352
	353	static __devinitdata struct mfd_cell timberdale_cells_bar0_cfg2[] = {
	354	{
	355	.name = "timb-uart",
	356	.num_resources = ARRAY_SIZE(timberdale_uart_resources),
	357	.resources = timberdale_uart_resources,
	358	},
	359	{
	360	.name = "timb-gpio",
	361	.num_resources = ARRAY_SIZE(timberdale_gpio_resources),
	362	.resources = timberdale_gpio_resources,
	363	.platform_data = &timberdale_gpio_platform_data,
	364	.data_size = sizeof(timberdale_gpio_platform_data),
	365	},
071193ff RR	366	{
	367	.name = "timb-radio",
	368	.num_resources = ARRAY_SIZE(timberdale_radio_resources),
	369	.resources = timberdale_radio_resources,
	370	.platform_data = &timberdale_radio_platform_data,
	371	.data_size = sizeof(timberdale_radio_platform_data),
	372	},
8edbede9 RR	373	{
	374	.name = "xilinx_spi",
	375	.num_resources = ARRAY_SIZE(timberdale_spi_resources),
	376	.resources = timberdale_spi_resources,
	377	.platform_data = &timberdale_xspi_platform_data,
	378	.data_size = sizeof(timberdale_xspi_platform_data),
	379	},
	380	{
	381	.name = "timb-dma",
	382	.num_resources = ARRAY_SIZE(timberdale_dma_resources),
	383	.resources = timberdale_dma_resources,
	384	},
	385	};
	386
	387	static __devinitdata struct mfd_cell timberdale_cells_bar0_cfg3[] = {
	388	{
	389	.name = "timb-uart",
	390	.num_resources = ARRAY_SIZE(timberdale_uart_resources),
	391	.resources = timberdale_uart_resources,
	392	},
	393	{
	394	.name = "ocores-i2c",
	395	.num_resources = ARRAY_SIZE(timberdale_ocores_resources),
	396	.resources = timberdale_ocores_resources,
	397	.platform_data = &timberdale_ocores_platform_data,
	398	.data_size = sizeof(timberdale_ocores_platform_data),
	399	},
	400	{
	401	.name = "timb-gpio",
	402	.num_resources = ARRAY_SIZE(timberdale_gpio_resources),
	403	.resources = timberdale_gpio_resources,
	404	.platform_data = &timberdale_gpio_platform_data,
	405	.data_size = sizeof(timberdale_gpio_platform_data),
	406	},
071193ff RR	407	{
	408	.name = "timb-radio",
	409	.num_resources = ARRAY_SIZE(timberdale_radio_resources),
	410	.resources = timberdale_radio_resources,
	411	.platform_data = &timberdale_radio_platform_data,
	412	.data_size = sizeof(timberdale_radio_platform_data),
	413	},
8edbede9 RR	414	{
	415	.name = "xilinx_spi",
	416	.num_resources = ARRAY_SIZE(timberdale_spi_resources),
	417	.resources = timberdale_spi_resources,
	418	.platform_data = &timberdale_xspi_platform_data,
	419	.data_size = sizeof(timberdale_xspi_platform_data),
	420	},
	421	{
	422	.name = "ks8842",
	423	.num_resources = ARRAY_SIZE(timberdale_eth_resources),
	424	.resources = timberdale_eth_resources,
	425	},
	426	{
	427	.name = "timb-dma",
	428	.num_resources = ARRAY_SIZE(timberdale_dma_resources),
	429	.resources = timberdale_dma_resources,
	430	},
	431	};
	432
	433	static const __devinitconst struct resource timberdale_sdhc_resources[] = {
	434	/* located in bar 1 and bar 2 */
	435	{
	436	.start = SDHC0OFFSET,
	437	.end = SDHC0END,
	438	.flags = IORESOURCE_MEM,
	439	},
	440	{
	441	.start = IRQ_TIMBERDALE_SDHC,
	442	.end = IRQ_TIMBERDALE_SDHC,
	443	.flags = IORESOURCE_IRQ,
	444	},
	445	};
	446
	447	static __devinitdata struct mfd_cell timberdale_cells_bar1[] = {
	448	{
	449	.name = "sdhci",
	450	.num_resources = ARRAY_SIZE(timberdale_sdhc_resources),
	451	.resources = timberdale_sdhc_resources,
	452	},
	453	};
	454
	455	static __devinitdata struct mfd_cell timberdale_cells_bar2[] = {
	456	{
	457	.name = "sdhci",
	458	.num_resources = ARRAY_SIZE(timberdale_sdhc_resources),
	459	.resources = timberdale_sdhc_resources,
	460	},
	461	};
	462
	463	static ssize_t show_fw_ver(struct device dev, struct device_attribute attr,
	464	char *buf)
	465	{
	466	struct pci_dev *pdev = to_pci_dev(dev);
	467	struct timberdale_device *priv = pci_get_drvdata(pdev);
	468
	469	return sprintf(buf, "%d.%d.%d\n", priv->fw.major, priv->fw.minor,
	470	priv->fw.config);
	471	}
	472
	473	static DEVICE_ATTR(fw_ver, S_IRUGO, show_fw_ver, NULL);
	474
	475	/--------------------------------------------------------------------------/
	476
	477	static int __devinit timb_probe(struct pci_dev *dev,
478	const struct pci_device_id *id)
479	{
480	struct timberdale_device *priv;
481	int err, i;
482	resource_size_t mapbase;
483	struct msix_entry *msix_entries = NULL;
484	u8 ip_setup;
485
486	priv = kzalloc(sizeof(*priv), GFP_KERNEL);
487	if (!priv)
488	return -ENOMEM;
489
490	pci_set_drvdata(dev, priv);
491
492	err = pci_enable_device(dev);
493	if (err)
494	goto err_enable;
495
496	mapbase = pci_resource_start(dev, 0);
497	if (!mapbase) {
498	dev_err(&dev->dev, "No resource\n");
499	goto err_start;
500	}
501
502	/* create a resource for the PCI master register */
503	priv->ctl_mapbase = mapbase + CHIPCTLOFFSET;
504	if (!request_mem_region(priv->ctl_mapbase, CHIPCTLSIZE, "timb-ctl")) {
505	dev_err(&dev->dev, "Failed to request ctl mem\n");
506	goto err_request;
507	}
508
509	priv->ctl_membase = ioremap(priv->ctl_mapbase, CHIPCTLSIZE);
510	if (!priv->ctl_membase) {
511	dev_err(&dev->dev, "ioremap failed for ctl mem\n");
512	goto err_ioremap;
513	}
514
515	/* read the HW config */
516	priv->fw.major = ioread32(priv->ctl_membase + TIMB_REV_MAJOR);
517	priv->fw.minor = ioread32(priv->ctl_membase + TIMB_REV_MINOR);
518	priv->fw.config = ioread32(priv->ctl_membase + TIMB_HW_CONFIG);
519
520	if (priv->fw.major > TIMB_SUPPORTED_MAJOR) {
521	dev_err(&dev->dev, "The driver supports an older "
522	"version of the FPGA, please update the driver to "
523	"support %d.%d\n", priv->fw.major, priv->fw.minor);
524	goto err_ioremap;
525	}
526	if (priv->fw.major < TIMB_SUPPORTED_MAJOR \|\|
527	priv->fw.minor < TIMB_REQUIRED_MINOR) {
528	dev_err(&dev->dev, "The FPGA image is too old (%d.%d), "
529	"please upgrade the FPGA to at least: %d.%d\n",
530	priv->fw.major, priv->fw.minor,
531	TIMB_SUPPORTED_MAJOR, TIMB_REQUIRED_MINOR);
532	goto err_ioremap;
533	}
534
535	msix_entries = kzalloc(TIMBERDALE_NR_IRQS * sizeof(*msix_entries),
536	GFP_KERNEL);
537	if (!msix_entries)
538	goto err_ioremap;
539
540	for (i = 0; i < TIMBERDALE_NR_IRQS; i++)
541	msix_entries[i].entry = i;
542
543	err = pci_enable_msix(dev, msix_entries, TIMBERDALE_NR_IRQS);
544	if (err) {
545	dev_err(&dev->dev,
546	"MSI-X init failed: %d, expected entries: %d\n",
547	err, TIMBERDALE_NR_IRQS);
548	goto err_msix;
549	}
550
551	err = device_create_file(&dev->dev, &dev_attr_fw_ver);
552	if (err)
553	goto err_create_file;
554
555	/* Reset all FPGA PLB peripherals */
556	iowrite32(0x1, priv->ctl_membase + TIMB_SW_RST);
557
558	/* update IRQ offsets in I2C board info */
559	for (i = 0; i < ARRAY_SIZE(timberdale_i2c_board_info); i++)
560	timberdale_i2c_board_info[i].irq =
561	msix_entries[timberdale_i2c_board_info[i].irq].vector;
562
563	/* Update the SPI configuration depending on the HW (8 or 16 bit) */
564	if (priv->fw.config & TIMB_HW_CONFIG_SPI_8BIT) {
565	timberdale_xspi_platform_data.bits_per_word = 8;
566	timberdale_xspi_platform_data.devices =
567	timberdale_spi_8bit_board_info;
568	timberdale_xspi_platform_data.num_devices =
569	ARRAY_SIZE(timberdale_spi_8bit_board_info);
570	} else {
571	timberdale_xspi_platform_data.bits_per_word = 16;
572	timberdale_xspi_platform_data.devices =
573	timberdale_spi_16bit_board_info;
574	timberdale_xspi_platform_data.num_devices =
575	ARRAY_SIZE(timberdale_spi_16bit_board_info);
576	}
577
578	ip_setup = priv->fw.config & TIMB_HW_VER_MASK;
579	switch (ip_setup) {
580	case TIMB_HW_VER0:
581	err = mfd_add_devices(&dev->dev, -1,
582	timberdale_cells_bar0_cfg0,
583	ARRAY_SIZE(timberdale_cells_bar0_cfg0),
584	&dev->resource[0], msix_entries[0].vector);
585	break;
586	case TIMB_HW_VER1:
587	err = mfd_add_devices(&dev->dev, -1,
588	timberdale_cells_bar0_cfg1,
589	ARRAY_SIZE(timberdale_cells_bar0_cfg1),
590	&dev->resource[0], msix_entries[0].vector);
591	break;
592	case TIMB_HW_VER2:
593	err = mfd_add_devices(&dev->dev, -1,
594	timberdale_cells_bar0_cfg2,
595	ARRAY_SIZE(timberdale_cells_bar0_cfg2),
596	&dev->resource[0], msix_entries[0].vector);
597	break;
598	case TIMB_HW_VER3:
599	err = mfd_add_devices(&dev->dev, -1,
600	timberdale_cells_bar0_cfg3,
601	ARRAY_SIZE(timberdale_cells_bar0_cfg3),
602	&dev->resource[0], msix_entries[0].vector);
603	break;
604	default:
605	dev_err(&dev->dev, "Uknown IP setup: %d.%d.%d\n",
606	priv->fw.major, priv->fw.minor, ip_setup);
607	err = -ENODEV;
608	goto err_mfd;
609	break;
610	}
611
612	if (err) {
613	dev_err(&dev->dev, "mfd_add_devices failed: %d\n", err);
614	goto err_mfd;
615	}
616
617	err = mfd_add_devices(&dev->dev, 0,
618	timberdale_cells_bar1, ARRAY_SIZE(timberdale_cells_bar1),
619	&dev->resource[1], msix_entries[0].vector);
620	if (err) {
621	dev_err(&dev->dev, "mfd_add_devices failed: %d\n", err);
622	goto err_mfd2;
623	}
624
625	/* only version 0 and 3 have the iNand routed to SDHCI */
626	if (((priv->fw.config & TIMB_HW_VER_MASK) == TIMB_HW_VER0) \|\|
627	((priv->fw.config & TIMB_HW_VER_MASK) == TIMB_HW_VER3)) {
628	err = mfd_add_devices(&dev->dev, 1, timberdale_cells_bar2,
629	ARRAY_SIZE(timberdale_cells_bar2),
630	&dev->resource[2], msix_entries[0].vector);
631	if (err) {
632	dev_err(&dev->dev, "mfd_add_devices failed: %d\n", err);
633	goto err_mfd2;
634	}
635	}
636
637	kfree(msix_entries);
638
639	dev_info(&dev->dev,
640	"Found Timberdale Card. Rev: %d.%d, HW config: 0x%02x\n",
641	priv->fw.major, priv->fw.minor, priv->fw.config);
642
643	return 0;
644
645	err_mfd2:
646	mfd_remove_devices(&dev->dev);
647	err_mfd:
648	device_remove_file(&dev->dev, &dev_attr_fw_ver);
649	err_create_file:
650	pci_disable_msix(dev);
651	err_msix:
652	iounmap(priv->ctl_membase);
653	err_ioremap:
654	release_mem_region(priv->ctl_mapbase, CHIPCTLSIZE);
655	err_request:
656	pci_set_drvdata(dev, NULL);
657	err_start:
658	pci_disable_device(dev);
659	err_enable:
660	kfree(msix_entries);
661	kfree(priv);
662	pci_set_drvdata(dev, NULL);
663	return -ENODEV;
664	}
665
666	static void __devexit timb_remove(struct pci_dev *dev)
667	{
668	struct timberdale_device *priv = pci_get_drvdata(dev);
669
670	mfd_remove_devices(&dev->dev);
671
672	device_remove_file(&dev->dev, &dev_attr_fw_ver);
673
674	iounmap(priv->ctl_membase);
675	release_mem_region(priv->ctl_mapbase, CHIPCTLSIZE);
676
677	pci_disable_msix(dev);
678	pci_disable_device(dev);
679	pci_set_drvdata(dev, NULL);
680	kfree(priv);
681	}
682
683	static struct pci_device_id timberdale_pci_tbl[] = {
684	{ PCI_DEVICE(PCI_VENDOR_ID_TIMB, PCI_DEVICE_ID_TIMB) },
685	{ 0 }
686	};
687	MODULE_DEVICE_TABLE(pci, timberdale_pci_tbl);
688
689	static struct pci_driver timberdale_pci_driver = {
690	.name = DRIVER_NAME,
691	.id_table = timberdale_pci_tbl,
692	.probe = timb_probe,
693	.remove = __devexit_p(timb_remove),
694	};
695
696	static int __init timberdale_init(void)
697	{
698	int err;
699
700	err = pci_register_driver(&timberdale_pci_driver);
701	if (err < 0) {
702	printk(KERN_ERR
703	"Failed to register PCI driver for %s device.\n",
704	timberdale_pci_driver.name);
705	return -ENODEV;
706	}
707
708	printk(KERN_INFO "Driver for %s has been successfully registered.\n",
709	timberdale_pci_driver.name);
710
711	return 0;
712	}
713
714	static void __exit timberdale_exit(void)
715	{
716	pci_unregister_driver(&timberdale_pci_driver);
717
718	printk(KERN_INFO "Driver for %s has been successfully unregistered.\n",
719	timberdale_pci_driver.name);
720	}
721
722	module_init(timberdale_init);
723	module_exit(timberdale_exit);
724
725	MODULE_AUTHOR("Mocean Laboratories <info@mocean-labs.com>");
726	MODULE_VERSION(DRV_VERSION);
727	MODULE_LICENSE("GPL v2");