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