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