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