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