drivers/mfd/timberdale.c

   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
  40 #include <media/timb_radio.h>
  41
  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
 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
 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         },
 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         },
 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         },
 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         },
 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         },
 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         },
 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         },
 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         },
 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");