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