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