xref: /openbmc/linux/drivers/mfd/timberdale.c (revision 7b6d864b) 
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 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 struct ocores_i2c_platform_data
85 timberdale_ocores_platform_data = {
86 	.reg_shift = 2,
87 	.clock_khz = 62500,
88 	.devices = timberdale_i2c_board_info,
89 	.num_devices = ARRAY_SIZE(timberdale_i2c_board_info)
90 };
91 
92 static const 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 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 struct xspi_platform_data timberdale_xspi_platform_data = {
147 	.num_chipselect = 3,
148 	/* bits per word and devices will be filled in runtime depending
149 	 * on the HW config
150 	 */
151 };
152 
153 static const 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 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 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 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 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 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 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 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 struct i2c_board_info timberdale_adv7180_i2c_board_info = {
250 	/* Requires jumper JP9 to be off */
251 	I2C_BOARD_INFO("adv7180", 0x42 >> 1),
252 	.irq = IRQ_TIMBERDALE_ADV7180
253 };
254 
255 static struct timb_video_platform_data
256 	timberdale_video_platform_data = {
257 	.dma_channel = DMA_VIDEO_RX,
258 	.i2c_adapter = 0,
259 	.encoder = {
260 		.info = &timberdale_adv7180_i2c_board_info
261 	}
262 };
263 
264 static const struct resource
265 timberdale_radio_resources[] = {
266 	{
267 		.start	= RDSOFFSET,
268 		.end	= RDSEND,
269 		.flags	= IORESOURCE_MEM,
270 	},
271 	{
272 		.start	= IRQ_TIMBERDALE_RDS,
273 		.end	= IRQ_TIMBERDALE_RDS,
274 		.flags	= IORESOURCE_IRQ,
275 	},
276 };
277 
278 static struct i2c_board_info timberdale_tef6868_i2c_board_info = {
279 	I2C_BOARD_INFO("tef6862", 0x60)
280 };
281 
282 static struct i2c_board_info timberdale_saa7706_i2c_board_info = {
283 	I2C_BOARD_INFO("saa7706h", 0x1C)
284 };
285 
286 static struct timb_radio_platform_data
287 	timberdale_radio_platform_data = {
288 	.i2c_adapter = 0,
289 	.tuner = &timberdale_tef6868_i2c_board_info,
290 	.dsp = &timberdale_saa7706_i2c_board_info
291 };
292 
293 static const struct resource timberdale_video_resources[] = {
294 	{
295 		.start	= LOGIWOFFSET,
296 		.end	= LOGIWEND,
297 		.flags	= IORESOURCE_MEM,
298 	},
299 	/*
300 	note that the "frame buffer" is located in DMA area
301 	starting at 0x1200000
302 	*/
303 };
304 
305 static struct timb_dma_platform_data timb_dma_platform_data = {
306 	.nr_channels = 10,
307 	.channels = {
308 		{
309 			/* UART RX */
310 			.rx = true,
311 			.descriptors = 2,
312 			.descriptor_elements = 1
313 		},
314 		{
315 			/* UART TX */
316 			.rx = false,
317 			.descriptors = 2,
318 			.descriptor_elements = 1
319 		},
320 		{
321 			/* MLB RX */
322 			.rx = true,
323 			.descriptors = 2,
324 			.descriptor_elements = 1
325 		},
326 		{
327 			/* MLB TX */
328 			.rx = false,
329 			.descriptors = 2,
330 			.descriptor_elements = 1
331 		},
332 		{
333 			/* Video RX */
334 			.rx = true,
335 			.bytes_per_line = 1440,
336 			.descriptors = 2,
337 			.descriptor_elements = 16
338 		},
339 		{
340 			/* Video framedrop */
341 		},
342 		{
343 			/* SDHCI RX */
344 			.rx = true,
345 		},
346 		{
347 			/* SDHCI TX */
348 		},
349 		{
350 			/* ETH RX */
351 			.rx = true,
352 			.descriptors = 2,
353 			.descriptor_elements = 1
354 		},
355 		{
356 			/* ETH TX */
357 			.rx = false,
358 			.descriptors = 2,
359 			.descriptor_elements = 1
360 		},
361 	}
362 };
363 
364 static const struct resource timberdale_dma_resources[] = {
365 	{
366 		.start	= DMAOFFSET,
367 		.end	= DMAEND,
368 		.flags	= IORESOURCE_MEM,
369 	},
370 	{
371 		.start	= IRQ_TIMBERDALE_DMA,
372 		.end	= IRQ_TIMBERDALE_DMA,
373 		.flags	= IORESOURCE_IRQ,
374 	},
375 };
376 
377 static struct mfd_cell timberdale_cells_bar0_cfg0[] = {
378 	{
379 		.name = "timb-dma",
380 		.num_resources = ARRAY_SIZE(timberdale_dma_resources),
381 		.resources = timberdale_dma_resources,
382 		.platform_data = &timb_dma_platform_data,
383 		.pdata_size = sizeof(timb_dma_platform_data),
384 	},
385 	{
386 		.name = "timb-uart",
387 		.num_resources = ARRAY_SIZE(timberdale_uart_resources),
388 		.resources = timberdale_uart_resources,
389 	},
390 	{
391 		.name = "xiic-i2c",
392 		.num_resources = ARRAY_SIZE(timberdale_xiic_resources),
393 		.resources = timberdale_xiic_resources,
394 		.platform_data = &timberdale_xiic_platform_data,
395 		.pdata_size = sizeof(timberdale_xiic_platform_data),
396 	},
397 	{
398 		.name = "timb-gpio",
399 		.num_resources = ARRAY_SIZE(timberdale_gpio_resources),
400 		.resources = timberdale_gpio_resources,
401 		.platform_data = &timberdale_gpio_platform_data,
402 		.pdata_size = sizeof(timberdale_gpio_platform_data),
403 	},
404 	{
405 		.name = "timb-video",
406 		.num_resources = ARRAY_SIZE(timberdale_video_resources),
407 		.resources = timberdale_video_resources,
408 		.platform_data = &timberdale_video_platform_data,
409 		.pdata_size = sizeof(timberdale_video_platform_data),
410 	},
411 	{
412 		.name = "timb-radio",
413 		.num_resources = ARRAY_SIZE(timberdale_radio_resources),
414 		.resources = timberdale_radio_resources,
415 		.platform_data = &timberdale_radio_platform_data,
416 		.pdata_size = sizeof(timberdale_radio_platform_data),
417 	},
418 	{
419 		.name = "xilinx_spi",
420 		.num_resources = ARRAY_SIZE(timberdale_spi_resources),
421 		.resources = timberdale_spi_resources,
422 		.platform_data = &timberdale_xspi_platform_data,
423 		.pdata_size = sizeof(timberdale_xspi_platform_data),
424 	},
425 	{
426 		.name = "ks8842",
427 		.num_resources = ARRAY_SIZE(timberdale_eth_resources),
428 		.resources = timberdale_eth_resources,
429 		.platform_data = &timberdale_ks8842_platform_data,
430 		.pdata_size = sizeof(timberdale_ks8842_platform_data),
431 	},
432 };
433 
434 static struct mfd_cell timberdale_cells_bar0_cfg1[] = {
435 	{
436 		.name = "timb-dma",
437 		.num_resources = ARRAY_SIZE(timberdale_dma_resources),
438 		.resources = timberdale_dma_resources,
439 		.platform_data = &timb_dma_platform_data,
440 		.pdata_size = sizeof(timb_dma_platform_data),
441 	},
442 	{
443 		.name = "timb-uart",
444 		.num_resources = ARRAY_SIZE(timberdale_uart_resources),
445 		.resources = timberdale_uart_resources,
446 	},
447 	{
448 		.name = "uartlite",
449 		.num_resources = ARRAY_SIZE(timberdale_uartlite_resources),
450 		.resources = timberdale_uartlite_resources,
451 	},
452 	{
453 		.name = "xiic-i2c",
454 		.num_resources = ARRAY_SIZE(timberdale_xiic_resources),
455 		.resources = timberdale_xiic_resources,
456 		.platform_data = &timberdale_xiic_platform_data,
457 		.pdata_size = sizeof(timberdale_xiic_platform_data),
458 	},
459 	{
460 		.name = "timb-gpio",
461 		.num_resources = ARRAY_SIZE(timberdale_gpio_resources),
462 		.resources = timberdale_gpio_resources,
463 		.platform_data = &timberdale_gpio_platform_data,
464 		.pdata_size = sizeof(timberdale_gpio_platform_data),
465 	},
466 	{
467 		.name = "timb-mlogicore",
468 		.num_resources = ARRAY_SIZE(timberdale_mlogicore_resources),
469 		.resources = timberdale_mlogicore_resources,
470 	},
471 	{
472 		.name = "timb-video",
473 		.num_resources = ARRAY_SIZE(timberdale_video_resources),
474 		.resources = timberdale_video_resources,
475 		.platform_data = &timberdale_video_platform_data,
476 		.pdata_size = sizeof(timberdale_video_platform_data),
477 	},
478 	{
479 		.name = "timb-radio",
480 		.num_resources = ARRAY_SIZE(timberdale_radio_resources),
481 		.resources = timberdale_radio_resources,
482 		.platform_data = &timberdale_radio_platform_data,
483 		.pdata_size = sizeof(timberdale_radio_platform_data),
484 	},
485 	{
486 		.name = "xilinx_spi",
487 		.num_resources = ARRAY_SIZE(timberdale_spi_resources),
488 		.resources = timberdale_spi_resources,
489 		.platform_data = &timberdale_xspi_platform_data,
490 		.pdata_size = sizeof(timberdale_xspi_platform_data),
491 	},
492 	{
493 		.name = "ks8842",
494 		.num_resources = ARRAY_SIZE(timberdale_eth_resources),
495 		.resources = timberdale_eth_resources,
496 		.platform_data = &timberdale_ks8842_platform_data,
497 		.pdata_size = sizeof(timberdale_ks8842_platform_data),
498 	},
499 };
500 
501 static struct mfd_cell timberdale_cells_bar0_cfg2[] = {
502 	{
503 		.name = "timb-dma",
504 		.num_resources = ARRAY_SIZE(timberdale_dma_resources),
505 		.resources = timberdale_dma_resources,
506 		.platform_data = &timb_dma_platform_data,
507 		.pdata_size = sizeof(timb_dma_platform_data),
508 	},
509 	{
510 		.name = "timb-uart",
511 		.num_resources = ARRAY_SIZE(timberdale_uart_resources),
512 		.resources = timberdale_uart_resources,
513 	},
514 	{
515 		.name = "xiic-i2c",
516 		.num_resources = ARRAY_SIZE(timberdale_xiic_resources),
517 		.resources = timberdale_xiic_resources,
518 		.platform_data = &timberdale_xiic_platform_data,
519 		.pdata_size = sizeof(timberdale_xiic_platform_data),
520 	},
521 	{
522 		.name = "timb-gpio",
523 		.num_resources = ARRAY_SIZE(timberdale_gpio_resources),
524 		.resources = timberdale_gpio_resources,
525 		.platform_data = &timberdale_gpio_platform_data,
526 		.pdata_size = sizeof(timberdale_gpio_platform_data),
527 	},
528 	{
529 		.name = "timb-video",
530 		.num_resources = ARRAY_SIZE(timberdale_video_resources),
531 		.resources = timberdale_video_resources,
532 		.platform_data = &timberdale_video_platform_data,
533 		.pdata_size = sizeof(timberdale_video_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 		.pdata_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 		.pdata_size = sizeof(timberdale_xspi_platform_data),
548 	},
549 };
550 
551 static struct mfd_cell timberdale_cells_bar0_cfg3[] = {
552 	{
553 		.name = "timb-dma",
554 		.num_resources = ARRAY_SIZE(timberdale_dma_resources),
555 		.resources = timberdale_dma_resources,
556 		.platform_data = &timb_dma_platform_data,
557 		.pdata_size = sizeof(timb_dma_platform_data),
558 	},
559 	{
560 		.name = "timb-uart",
561 		.num_resources = ARRAY_SIZE(timberdale_uart_resources),
562 		.resources = timberdale_uart_resources,
563 	},
564 	{
565 		.name = "ocores-i2c",
566 		.num_resources = ARRAY_SIZE(timberdale_ocores_resources),
567 		.resources = timberdale_ocores_resources,
568 		.platform_data = &timberdale_ocores_platform_data,
569 		.pdata_size = sizeof(timberdale_ocores_platform_data),
570 	},
571 	{
572 		.name = "timb-gpio",
573 		.num_resources = ARRAY_SIZE(timberdale_gpio_resources),
574 		.resources = timberdale_gpio_resources,
575 		.platform_data = &timberdale_gpio_platform_data,
576 		.pdata_size = sizeof(timberdale_gpio_platform_data),
577 	},
578 	{
579 		.name = "timb-video",
580 		.num_resources = ARRAY_SIZE(timberdale_video_resources),
581 		.resources = timberdale_video_resources,
582 		.platform_data = &timberdale_video_platform_data,
583 		.pdata_size = sizeof(timberdale_video_platform_data),
584 	},
585 	{
586 		.name = "timb-radio",
587 		.num_resources = ARRAY_SIZE(timberdale_radio_resources),
588 		.resources = timberdale_radio_resources,
589 		.platform_data = &timberdale_radio_platform_data,
590 		.pdata_size = sizeof(timberdale_radio_platform_data),
591 	},
592 	{
593 		.name = "xilinx_spi",
594 		.num_resources = ARRAY_SIZE(timberdale_spi_resources),
595 		.resources = timberdale_spi_resources,
596 		.platform_data = &timberdale_xspi_platform_data,
597 		.pdata_size = sizeof(timberdale_xspi_platform_data),
598 	},
599 	{
600 		.name = "ks8842",
601 		.num_resources = ARRAY_SIZE(timberdale_eth_resources),
602 		.resources = timberdale_eth_resources,
603 		.platform_data = &timberdale_ks8842_platform_data,
604 		.pdata_size = sizeof(timberdale_ks8842_platform_data),
605 	},
606 };
607 
608 static const struct resource timberdale_sdhc_resources[] = {
609 	/* located in bar 1 and bar 2 */
610 	{
611 		.start	= SDHC0OFFSET,
612 		.end	= SDHC0END,
613 		.flags	= IORESOURCE_MEM,
614 	},
615 	{
616 		.start	= IRQ_TIMBERDALE_SDHC,
617 		.end	= IRQ_TIMBERDALE_SDHC,
618 		.flags	= IORESOURCE_IRQ,
619 	},
620 };
621 
622 static struct mfd_cell timberdale_cells_bar1[] = {
623 	{
624 		.name = "sdhci",
625 		.num_resources = ARRAY_SIZE(timberdale_sdhc_resources),
626 		.resources = timberdale_sdhc_resources,
627 	},
628 };
629 
630 static struct mfd_cell timberdale_cells_bar2[] = {
631 	{
632 		.name = "sdhci",
633 		.num_resources = ARRAY_SIZE(timberdale_sdhc_resources),
634 		.resources = timberdale_sdhc_resources,
635 	},
636 };
637 
638 static ssize_t show_fw_ver(struct device *dev, struct device_attribute *attr,
639 	char *buf)
640 {
641 	struct pci_dev *pdev = to_pci_dev(dev);
642 	struct timberdale_device *priv = pci_get_drvdata(pdev);
643 
644 	return sprintf(buf, "%d.%d.%d\n", priv->fw.major, priv->fw.minor,
645 		priv->fw.config);
646 }
647 
648 static DEVICE_ATTR(fw_ver, S_IRUGO, show_fw_ver, NULL);
649 
650 /*--------------------------------------------------------------------------*/
651 
652 static int timb_probe(struct pci_dev *dev,
653 	const struct pci_device_id *id)
654 {
655 	struct timberdale_device *priv;
656 	int err, i;
657 	resource_size_t mapbase;
658 	struct msix_entry *msix_entries = NULL;
659 	u8 ip_setup;
660 
661 	priv = kzalloc(sizeof(*priv), GFP_KERNEL);
662 	if (!priv)
663 		return -ENOMEM;
664 
665 	pci_set_drvdata(dev, priv);
666 
667 	err = pci_enable_device(dev);
668 	if (err)
669 		goto err_enable;
670 
671 	mapbase = pci_resource_start(dev, 0);
672 	if (!mapbase) {
673 		dev_err(&dev->dev, "No resource\n");
674 		goto err_start;
675 	}
676 
677 	/* create a resource for the PCI master register */
678 	priv->ctl_mapbase = mapbase + CHIPCTLOFFSET;
679 	if (!request_mem_region(priv->ctl_mapbase, CHIPCTLSIZE, "timb-ctl")) {
680 		dev_err(&dev->dev, "Failed to request ctl mem\n");
681 		goto err_request;
682 	}
683 
684 	priv->ctl_membase = ioremap(priv->ctl_mapbase, CHIPCTLSIZE);
685 	if (!priv->ctl_membase) {
686 		dev_err(&dev->dev, "ioremap failed for ctl mem\n");
687 		goto err_ioremap;
688 	}
689 
690 	/* read the HW config */
691 	priv->fw.major = ioread32(priv->ctl_membase + TIMB_REV_MAJOR);
692 	priv->fw.minor = ioread32(priv->ctl_membase + TIMB_REV_MINOR);
693 	priv->fw.config = ioread32(priv->ctl_membase + TIMB_HW_CONFIG);
694 
695 	if (priv->fw.major > TIMB_SUPPORTED_MAJOR) {
696 		dev_err(&dev->dev, "The driver supports an older "
697 			"version of the FPGA, please update the driver to "
698 			"support %d.%d\n", priv->fw.major, priv->fw.minor);
699 		goto err_config;
700 	}
701 	if (priv->fw.major < TIMB_SUPPORTED_MAJOR ||
702 		priv->fw.minor < TIMB_REQUIRED_MINOR) {
703 		dev_err(&dev->dev, "The FPGA image is too old (%d.%d), "
704 			"please upgrade the FPGA to at least: %d.%d\n",
705 			priv->fw.major, priv->fw.minor,
706 			TIMB_SUPPORTED_MAJOR, TIMB_REQUIRED_MINOR);
707 		goto err_config;
708 	}
709 
710 	msix_entries = kzalloc(TIMBERDALE_NR_IRQS * sizeof(*msix_entries),
711 		GFP_KERNEL);
712 	if (!msix_entries)
713 		goto err_config;
714 
715 	for (i = 0; i < TIMBERDALE_NR_IRQS; i++)
716 		msix_entries[i].entry = i;
717 
718 	err = pci_enable_msix(dev, msix_entries, TIMBERDALE_NR_IRQS);
719 	if (err) {
720 		dev_err(&dev->dev,
721 			"MSI-X init failed: %d, expected entries: %d\n",
722 			err, TIMBERDALE_NR_IRQS);
723 		goto err_msix;
724 	}
725 
726 	err = device_create_file(&dev->dev, &dev_attr_fw_ver);
727 	if (err)
728 		goto err_create_file;
729 
730 	/* Reset all FPGA PLB peripherals */
731 	iowrite32(0x1, priv->ctl_membase + TIMB_SW_RST);
732 
733 	/* update IRQ offsets in I2C board info */
734 	for (i = 0; i < ARRAY_SIZE(timberdale_i2c_board_info); i++)
735 		timberdale_i2c_board_info[i].irq =
736 			msix_entries[timberdale_i2c_board_info[i].irq].vector;
737 
738 	/* Update the SPI configuration depending on the HW (8 or 16 bit) */
739 	if (priv->fw.config & TIMB_HW_CONFIG_SPI_8BIT) {
740 		timberdale_xspi_platform_data.bits_per_word = 8;
741 		timberdale_xspi_platform_data.devices =
742 			timberdale_spi_8bit_board_info;
743 		timberdale_xspi_platform_data.num_devices =
744 			ARRAY_SIZE(timberdale_spi_8bit_board_info);
745 	} else {
746 		timberdale_xspi_platform_data.bits_per_word = 16;
747 		timberdale_xspi_platform_data.devices =
748 			timberdale_spi_16bit_board_info;
749 		timberdale_xspi_platform_data.num_devices =
750 			ARRAY_SIZE(timberdale_spi_16bit_board_info);
751 	}
752 
753 	ip_setup = priv->fw.config & TIMB_HW_VER_MASK;
754 	switch (ip_setup) {
755 	case TIMB_HW_VER0:
756 		err = mfd_add_devices(&dev->dev, -1,
757 			timberdale_cells_bar0_cfg0,
758 			ARRAY_SIZE(timberdale_cells_bar0_cfg0),
759 			&dev->resource[0], msix_entries[0].vector, NULL);
760 		break;
761 	case TIMB_HW_VER1:
762 		err = mfd_add_devices(&dev->dev, -1,
763 			timberdale_cells_bar0_cfg1,
764 			ARRAY_SIZE(timberdale_cells_bar0_cfg1),
765 			&dev->resource[0], msix_entries[0].vector, NULL);
766 		break;
767 	case TIMB_HW_VER2:
768 		err = mfd_add_devices(&dev->dev, -1,
769 			timberdale_cells_bar0_cfg2,
770 			ARRAY_SIZE(timberdale_cells_bar0_cfg2),
771 			&dev->resource[0], msix_entries[0].vector, NULL);
772 		break;
773 	case TIMB_HW_VER3:
774 		err = mfd_add_devices(&dev->dev, -1,
775 			timberdale_cells_bar0_cfg3,
776 			ARRAY_SIZE(timberdale_cells_bar0_cfg3),
777 			&dev->resource[0], msix_entries[0].vector, NULL);
778 		break;
779 	default:
780 		dev_err(&dev->dev, "Uknown IP setup: %d.%d.%d\n",
781 			priv->fw.major, priv->fw.minor, ip_setup);
782 		err = -ENODEV;
783 		goto err_mfd;
784 		break;
785 	}
786 
787 	if (err) {
788 		dev_err(&dev->dev, "mfd_add_devices failed: %d\n", err);
789 		goto err_mfd;
790 	}
791 
792 	err = mfd_add_devices(&dev->dev, 0,
793 		timberdale_cells_bar1, ARRAY_SIZE(timberdale_cells_bar1),
794 		&dev->resource[1], 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 	/* only version 0 and 3 have the iNand routed to SDHCI */
801 	if (((priv->fw.config & TIMB_HW_VER_MASK) == TIMB_HW_VER0) ||
802 		((priv->fw.config & TIMB_HW_VER_MASK) == TIMB_HW_VER3)) {
803 		err = mfd_add_devices(&dev->dev, 1, timberdale_cells_bar2,
804 			ARRAY_SIZE(timberdale_cells_bar2),
805 			&dev->resource[2], msix_entries[0].vector, NULL);
806 		if (err) {
807 			dev_err(&dev->dev, "mfd_add_devices failed: %d\n", err);
808 			goto err_mfd2;
809 		}
810 	}
811 
812 	kfree(msix_entries);
813 
814 	dev_info(&dev->dev,
815 		"Found Timberdale Card. Rev: %d.%d, HW config: 0x%02x\n",
816 		priv->fw.major, priv->fw.minor, priv->fw.config);
817 
818 	return 0;
819 
820 err_mfd2:
821 	mfd_remove_devices(&dev->dev);
822 err_mfd:
823 	device_remove_file(&dev->dev, &dev_attr_fw_ver);
824 err_create_file:
825 	pci_disable_msix(dev);
826 err_msix:
827 	kfree(msix_entries);
828 err_config:
829 	iounmap(priv->ctl_membase);
830 err_ioremap:
831 	release_mem_region(priv->ctl_mapbase, CHIPCTLSIZE);
832 err_request:
833 	pci_set_drvdata(dev, NULL);
834 err_start:
835 	pci_disable_device(dev);
836 err_enable:
837 	kfree(priv);
838 	pci_set_drvdata(dev, NULL);
839 	return -ENODEV;
840 }
841 
842 static void timb_remove(struct pci_dev *dev)
843 {
844 	struct timberdale_device *priv = pci_get_drvdata(dev);
845 
846 	mfd_remove_devices(&dev->dev);
847 
848 	device_remove_file(&dev->dev, &dev_attr_fw_ver);
849 
850 	iounmap(priv->ctl_membase);
851 	release_mem_region(priv->ctl_mapbase, CHIPCTLSIZE);
852 
853 	pci_disable_msix(dev);
854 	pci_disable_device(dev);
855 	pci_set_drvdata(dev, NULL);
856 	kfree(priv);
857 }
858 
859 static DEFINE_PCI_DEVICE_TABLE(timberdale_pci_tbl) = {
860 	{ PCI_DEVICE(PCI_VENDOR_ID_TIMB, PCI_DEVICE_ID_TIMB) },
861 	{ 0 }
862 };
863 MODULE_DEVICE_TABLE(pci, timberdale_pci_tbl);
864 
865 static struct pci_driver timberdale_pci_driver = {
866 	.name = DRIVER_NAME,
867 	.id_table = timberdale_pci_tbl,
868 	.probe = timb_probe,
869 	.remove = timb_remove,
870 };
871 
872 static int __init timberdale_init(void)
873 {
874 	int err;
875 
876 	err = pci_register_driver(&timberdale_pci_driver);
877 	if (err < 0) {
878 		printk(KERN_ERR
879 			"Failed to register PCI driver for %s device.\n",
880 			timberdale_pci_driver.name);
881 		return -ENODEV;
882 	}
883 
884 	printk(KERN_INFO "Driver for %s has been successfully registered.\n",
885 		timberdale_pci_driver.name);
886 
887 	return 0;
888 }
889 
890 static void __exit timberdale_exit(void)
891 {
892 	pci_unregister_driver(&timberdale_pci_driver);
893 
894 	printk(KERN_INFO "Driver for %s has been successfully unregistered.\n",
895 		timberdale_pci_driver.name);
896 }
897 
898 module_init(timberdale_init);
899 module_exit(timberdale_exit);
900 
901 MODULE_AUTHOR("Mocean Laboratories <info@mocean-labs.com>");
902 MODULE_VERSION(DRV_VERSION);
903 MODULE_LICENSE("GPL v2");
904