drivers/mfd/timberdale.c

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