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