xref: /linux/drivers/mfd/kempld-core.c (revision a13d7201d7deedcbb6ac6efa94a1a7d34d3d79ec)
1 /*
2  * Kontron PLD MFD core driver
3  *
4  * Copyright (c) 2010-2013 Kontron Europe GmbH
5  * Author: Michael Brunner <michael.brunner@kontron.com>
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License 2 as published
9  * by the Free Software Foundation.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  */
16 
17 #include <linux/platform_device.h>
18 #include <linux/mfd/core.h>
19 #include <linux/mfd/kempld.h>
20 #include <linux/module.h>
21 #include <linux/dmi.h>
22 #include <linux/io.h>
23 #include <linux/delay.h>
24 
25 #define MAX_ID_LEN 4
26 static char force_device_id[MAX_ID_LEN + 1] = "";
27 module_param_string(force_device_id, force_device_id,
28 		    sizeof(force_device_id), 0);
29 MODULE_PARM_DESC(force_device_id, "Override detected product");
30 
31 /*
32  * Get hardware mutex to block firmware from accessing the pld.
33  * It is possible for the firmware may hold the mutex for an extended length of
34  * time. This function will block until access has been granted.
35  */
36 static void kempld_get_hardware_mutex(struct kempld_device_data *pld)
37 {
38 	/* The mutex bit will read 1 until access has been granted */
39 	while (ioread8(pld->io_index) & KEMPLD_MUTEX_KEY)
40 		usleep_range(1000, 3000);
41 }
42 
43 static void kempld_release_hardware_mutex(struct kempld_device_data *pld)
44 {
45 	/* The harware mutex is released when 1 is written to the mutex bit. */
46 	iowrite8(KEMPLD_MUTEX_KEY, pld->io_index);
47 }
48 
49 static int kempld_get_info_generic(struct kempld_device_data *pld)
50 {
51 	u16 version;
52 	u8 spec;
53 
54 	kempld_get_mutex(pld);
55 
56 	version = kempld_read16(pld, KEMPLD_VERSION);
57 	spec = kempld_read8(pld, KEMPLD_SPEC);
58 	pld->info.buildnr = kempld_read16(pld, KEMPLD_BUILDNR);
59 
60 	pld->info.minor = KEMPLD_VERSION_GET_MINOR(version);
61 	pld->info.major = KEMPLD_VERSION_GET_MAJOR(version);
62 	pld->info.number = KEMPLD_VERSION_GET_NUMBER(version);
63 	pld->info.type = KEMPLD_VERSION_GET_TYPE(version);
64 
65 	if (spec == 0xff) {
66 		pld->info.spec_minor = 0;
67 		pld->info.spec_major = 1;
68 	} else {
69 		pld->info.spec_minor = KEMPLD_SPEC_GET_MINOR(spec);
70 		pld->info.spec_major = KEMPLD_SPEC_GET_MAJOR(spec);
71 	}
72 
73 	if (pld->info.spec_major > 0)
74 		pld->feature_mask = kempld_read16(pld, KEMPLD_FEATURE);
75 	else
76 		pld->feature_mask = 0;
77 
78 	kempld_release_mutex(pld);
79 
80 	return 0;
81 }
82 
83 enum kempld_cells {
84 	KEMPLD_I2C = 0,
85 	KEMPLD_WDT,
86 	KEMPLD_GPIO,
87 	KEMPLD_UART,
88 };
89 
90 static const struct mfd_cell kempld_devs[] = {
91 	[KEMPLD_I2C] = {
92 		.name = "kempld-i2c",
93 	},
94 	[KEMPLD_WDT] = {
95 		.name = "kempld-wdt",
96 	},
97 	[KEMPLD_GPIO] = {
98 		.name = "kempld-gpio",
99 	},
100 	[KEMPLD_UART] = {
101 		.name = "kempld-uart",
102 	},
103 };
104 
105 #define KEMPLD_MAX_DEVS	ARRAY_SIZE(kempld_devs)
106 
107 static int kempld_register_cells_generic(struct kempld_device_data *pld)
108 {
109 	struct mfd_cell devs[KEMPLD_MAX_DEVS];
110 	int i = 0;
111 
112 	if (pld->feature_mask & KEMPLD_FEATURE_BIT_I2C)
113 		devs[i++] = kempld_devs[KEMPLD_I2C];
114 
115 	if (pld->feature_mask & KEMPLD_FEATURE_BIT_WATCHDOG)
116 		devs[i++] = kempld_devs[KEMPLD_WDT];
117 
118 	if (pld->feature_mask & KEMPLD_FEATURE_BIT_GPIO)
119 		devs[i++] = kempld_devs[KEMPLD_GPIO];
120 
121 	if (pld->feature_mask & KEMPLD_FEATURE_MASK_UART)
122 		devs[i++] = kempld_devs[KEMPLD_UART];
123 
124 	return mfd_add_devices(pld->dev, -1, devs, i, NULL, 0, NULL);
125 }
126 
127 static struct resource kempld_ioresource = {
128 	.start	= KEMPLD_IOINDEX,
129 	.end	= KEMPLD_IODATA,
130 	.flags	= IORESOURCE_IO,
131 };
132 
133 static const struct kempld_platform_data kempld_platform_data_generic = {
134 	.pld_clock		= KEMPLD_CLK,
135 	.ioresource		= &kempld_ioresource,
136 	.get_hardware_mutex	= kempld_get_hardware_mutex,
137 	.release_hardware_mutex	= kempld_release_hardware_mutex,
138 	.get_info		= kempld_get_info_generic,
139 	.register_cells		= kempld_register_cells_generic,
140 };
141 
142 static struct platform_device *kempld_pdev;
143 
144 static int kempld_create_platform_device(const struct dmi_system_id *id)
145 {
146 	struct kempld_platform_data *pdata = id->driver_data;
147 	int ret;
148 
149 	kempld_pdev = platform_device_alloc("kempld", -1);
150 	if (!kempld_pdev)
151 		return -ENOMEM;
152 
153 	ret = platform_device_add_data(kempld_pdev, pdata, sizeof(*pdata));
154 	if (ret)
155 		goto err;
156 
157 	ret = platform_device_add_resources(kempld_pdev, pdata->ioresource, 1);
158 	if (ret)
159 		goto err;
160 
161 	ret = platform_device_add(kempld_pdev);
162 	if (ret)
163 		goto err;
164 
165 	return 0;
166 err:
167 	platform_device_put(kempld_pdev);
168 	return ret;
169 }
170 
171 /**
172  * kempld_read8 - read 8 bit register
173  * @pld: kempld_device_data structure describing the PLD
174  * @index: register index on the chip
175  *
176  * kempld_get_mutex must be called prior to calling this function.
177  */
178 u8 kempld_read8(struct kempld_device_data *pld, u8 index)
179 {
180 	iowrite8(index, pld->io_index);
181 	return ioread8(pld->io_data);
182 }
183 EXPORT_SYMBOL_GPL(kempld_read8);
184 
185 /**
186  * kempld_write8 - write 8 bit register
187  * @pld: kempld_device_data structure describing the PLD
188  * @index: register index on the chip
189  * @data: new register value
190  *
191  * kempld_get_mutex must be called prior to calling this function.
192  */
193 void kempld_write8(struct kempld_device_data *pld, u8 index, u8 data)
194 {
195 	iowrite8(index, pld->io_index);
196 	iowrite8(data, pld->io_data);
197 }
198 EXPORT_SYMBOL_GPL(kempld_write8);
199 
200 /**
201  * kempld_read16 - read 16 bit register
202  * @pld: kempld_device_data structure describing the PLD
203  * @index: register index on the chip
204  *
205  * kempld_get_mutex must be called prior to calling this function.
206  */
207 u16 kempld_read16(struct kempld_device_data *pld, u8 index)
208 {
209 	return kempld_read8(pld, index) | kempld_read8(pld, index + 1) << 8;
210 }
211 EXPORT_SYMBOL_GPL(kempld_read16);
212 
213 /**
214  * kempld_write16 - write 16 bit register
215  * @pld: kempld_device_data structure describing the PLD
216  * @index: register index on the chip
217  * @data: new register value
218  *
219  * kempld_get_mutex must be called prior to calling this function.
220  */
221 void kempld_write16(struct kempld_device_data *pld, u8 index, u16 data)
222 {
223 	kempld_write8(pld, index, (u8)data);
224 	kempld_write8(pld, index + 1, (u8)(data >> 8));
225 }
226 EXPORT_SYMBOL_GPL(kempld_write16);
227 
228 /**
229  * kempld_read32 - read 32 bit register
230  * @pld: kempld_device_data structure describing the PLD
231  * @index: register index on the chip
232  *
233  * kempld_get_mutex must be called prior to calling this function.
234  */
235 u32 kempld_read32(struct kempld_device_data *pld, u8 index)
236 {
237 	return kempld_read16(pld, index) | kempld_read16(pld, index + 2) << 16;
238 }
239 EXPORT_SYMBOL_GPL(kempld_read32);
240 
241 /**
242  * kempld_write32 - write 32 bit register
243  * @pld: kempld_device_data structure describing the PLD
244  * @index: register index on the chip
245  * @data: new register value
246  *
247  * kempld_get_mutex must be called prior to calling this function.
248  */
249 void kempld_write32(struct kempld_device_data *pld, u8 index, u32 data)
250 {
251 	kempld_write16(pld, index, (u16)data);
252 	kempld_write16(pld, index + 2, (u16)(data >> 16));
253 }
254 EXPORT_SYMBOL_GPL(kempld_write32);
255 
256 /**
257  * kempld_get_mutex - acquire PLD mutex
258  * @pld: kempld_device_data structure describing the PLD
259  */
260 void kempld_get_mutex(struct kempld_device_data *pld)
261 {
262 	struct kempld_platform_data *pdata = dev_get_platdata(pld->dev);
263 
264 	mutex_lock(&pld->lock);
265 	pdata->get_hardware_mutex(pld);
266 }
267 EXPORT_SYMBOL_GPL(kempld_get_mutex);
268 
269 /**
270  * kempld_release_mutex - release PLD mutex
271  * @pld: kempld_device_data structure describing the PLD
272  */
273 void kempld_release_mutex(struct kempld_device_data *pld)
274 {
275 	struct kempld_platform_data *pdata = dev_get_platdata(pld->dev);
276 
277 	pdata->release_hardware_mutex(pld);
278 	mutex_unlock(&pld->lock);
279 }
280 EXPORT_SYMBOL_GPL(kempld_release_mutex);
281 
282 /**
283  * kempld_get_info - update device specific information
284  * @pld: kempld_device_data structure describing the PLD
285  *
286  * This function calls the configured board specific kempld_get_info_XXXX
287  * function which is responsible for gathering information about the specific
288  * hardware. The information is then stored within the pld structure.
289  */
290 static int kempld_get_info(struct kempld_device_data *pld)
291 {
292 	int ret;
293 	struct kempld_platform_data *pdata = dev_get_platdata(pld->dev);
294 	char major, minor;
295 
296 	ret = pdata->get_info(pld);
297 	if (ret)
298 		return ret;
299 
300 	/* The Kontron PLD firmware version string has the following format:
301 	 * Pwxy.zzzz
302 	 *   P:    Fixed
303 	 *   w:    PLD number    - 1 hex digit
304 	 *   x:    Major version - 1 alphanumerical digit (0-9A-V)
305 	 *   y:    Minor version - 1 alphanumerical digit (0-9A-V)
306 	 *   zzzz: Build number  - 4 zero padded hex digits */
307 
308 	if (pld->info.major < 10)
309 		major = pld->info.major + '0';
310 	else
311 		major = (pld->info.major - 10) + 'A';
312 	if (pld->info.minor < 10)
313 		minor = pld->info.minor + '0';
314 	else
315 		minor = (pld->info.minor - 10) + 'A';
316 
317 	ret = scnprintf(pld->info.version, sizeof(pld->info.version),
318 			"P%X%c%c.%04X", pld->info.number, major, minor,
319 			pld->info.buildnr);
320 	if (ret < 0)
321 		return ret;
322 
323 	return 0;
324 }
325 
326 /*
327  * kempld_register_cells - register cell drivers
328  *
329  * This function registers cell drivers for the detected hardware by calling
330  * the configured kempld_register_cells_XXXX function which is responsible
331  * to detect and register the needed cell drivers.
332  */
333 static int kempld_register_cells(struct kempld_device_data *pld)
334 {
335 	struct kempld_platform_data *pdata = dev_get_platdata(pld->dev);
336 
337 	return pdata->register_cells(pld);
338 }
339 
340 static const char *kempld_get_type_string(struct kempld_device_data *pld)
341 {
342 	const char *version_type;
343 
344 	switch (pld->info.type) {
345 	case 0:
346 		version_type = "release";
347 		break;
348 	case 1:
349 		version_type = "debug";
350 		break;
351 	case 2:
352 		version_type = "custom";
353 		break;
354 	default:
355 		version_type = "unspecified";
356 		break;
357 	}
358 
359 	return version_type;
360 }
361 
362 static ssize_t kempld_version_show(struct device *dev,
363 		struct device_attribute *attr, char *buf)
364 {
365 	struct kempld_device_data *pld = dev_get_drvdata(dev);
366 
367 	return scnprintf(buf, PAGE_SIZE, "%s\n", pld->info.version);
368 }
369 
370 static ssize_t kempld_specification_show(struct device *dev,
371 		struct device_attribute *attr, char *buf)
372 {
373 	struct kempld_device_data *pld = dev_get_drvdata(dev);
374 
375 	return scnprintf(buf, PAGE_SIZE, "%d.%d\n", pld->info.spec_major,
376 		       pld->info.spec_minor);
377 }
378 
379 static ssize_t kempld_type_show(struct device *dev,
380 		struct device_attribute *attr, char *buf)
381 {
382 	struct kempld_device_data *pld = dev_get_drvdata(dev);
383 
384 	return scnprintf(buf, PAGE_SIZE, "%s\n", kempld_get_type_string(pld));
385 }
386 
387 static DEVICE_ATTR(pld_version, S_IRUGO, kempld_version_show, NULL);
388 static DEVICE_ATTR(pld_specification, S_IRUGO, kempld_specification_show,
389 		   NULL);
390 static DEVICE_ATTR(pld_type, S_IRUGO, kempld_type_show, NULL);
391 
392 static struct attribute *pld_attributes[] = {
393 	&dev_attr_pld_version.attr,
394 	&dev_attr_pld_specification.attr,
395 	&dev_attr_pld_type.attr,
396 	NULL
397 };
398 
399 static const struct attribute_group pld_attr_group = {
400 	.attrs = pld_attributes,
401 };
402 
403 static int kempld_detect_device(struct kempld_device_data *pld)
404 {
405 	u8 index_reg;
406 	int ret;
407 
408 	mutex_lock(&pld->lock);
409 
410 	/* Check for empty IO space */
411 	index_reg = ioread8(pld->io_index);
412 	if (index_reg == 0xff && ioread8(pld->io_data) == 0xff) {
413 		mutex_unlock(&pld->lock);
414 		return -ENODEV;
415 	}
416 
417 	/* Release hardware mutex if acquired */
418 	if (!(index_reg & KEMPLD_MUTEX_KEY)) {
419 		iowrite8(KEMPLD_MUTEX_KEY, pld->io_index);
420 		/* PXT and COMe-cPC2 boards may require a second release */
421 		iowrite8(KEMPLD_MUTEX_KEY, pld->io_index);
422 	}
423 
424 	mutex_unlock(&pld->lock);
425 
426 	ret = kempld_get_info(pld);
427 	if (ret)
428 		return ret;
429 
430 	dev_info(pld->dev, "Found Kontron PLD - %s (%s), spec %d.%d\n",
431 		 pld->info.version, kempld_get_type_string(pld),
432 		 pld->info.spec_major, pld->info.spec_minor);
433 
434 	ret = sysfs_create_group(&pld->dev->kobj, &pld_attr_group);
435 	if (ret)
436 		return ret;
437 
438 	ret = kempld_register_cells(pld);
439 	if (ret)
440 		sysfs_remove_group(&pld->dev->kobj, &pld_attr_group);
441 
442 	return ret;
443 }
444 
445 static int kempld_probe(struct platform_device *pdev)
446 {
447 	struct kempld_platform_data *pdata = dev_get_platdata(&pdev->dev);
448 	struct device *dev = &pdev->dev;
449 	struct kempld_device_data *pld;
450 	struct resource *ioport;
451 	int ret;
452 
453 	pld = devm_kzalloc(dev, sizeof(*pld), GFP_KERNEL);
454 	if (!pld)
455 		return -ENOMEM;
456 
457 	ioport = platform_get_resource(pdev, IORESOURCE_IO, 0);
458 	if (!ioport)
459 		return -EINVAL;
460 
461 	pld->io_base = devm_ioport_map(dev, ioport->start,
462 					ioport->end - ioport->start);
463 	if (!pld->io_base)
464 		return -ENOMEM;
465 
466 	pld->io_index = pld->io_base;
467 	pld->io_data = pld->io_base + 1;
468 	pld->pld_clock = pdata->pld_clock;
469 	pld->dev = dev;
470 
471 	mutex_init(&pld->lock);
472 	platform_set_drvdata(pdev, pld);
473 
474 	ret = kempld_detect_device(pld);
475 	if (ret)
476 		return ret;
477 
478 	return 0;
479 }
480 
481 static int kempld_remove(struct platform_device *pdev)
482 {
483 	struct kempld_device_data *pld = platform_get_drvdata(pdev);
484 	struct kempld_platform_data *pdata = dev_get_platdata(pld->dev);
485 
486 	sysfs_remove_group(&pld->dev->kobj, &pld_attr_group);
487 
488 	mfd_remove_devices(&pdev->dev);
489 	pdata->release_hardware_mutex(pld);
490 
491 	return 0;
492 }
493 
494 static struct platform_driver kempld_driver = {
495 	.driver		= {
496 		.name	= "kempld",
497 	},
498 	.probe		= kempld_probe,
499 	.remove		= kempld_remove,
500 };
501 
502 static struct dmi_system_id kempld_dmi_table[] __initdata = {
503 	{
504 		.ident = "BHL6",
505 		.matches = {
506 			DMI_MATCH(DMI_BOARD_VENDOR, "Kontron"),
507 			DMI_MATCH(DMI_BOARD_NAME, "COMe-bHL6"),
508 		},
509 		.driver_data = (void *)&kempld_platform_data_generic,
510 		.callback = kempld_create_platform_device,
511 	}, {
512 		.ident = "CBL6",
513 		.matches = {
514 			DMI_MATCH(DMI_BOARD_VENDOR, "Kontron"),
515 			DMI_MATCH(DMI_BOARD_NAME, "COMe-cBL6"),
516 		},
517 		.driver_data = (void *)&kempld_platform_data_generic,
518 		.callback = kempld_create_platform_device,
519 	}, {
520 		.ident = "CCR2",
521 		.matches = {
522 			DMI_MATCH(DMI_BOARD_VENDOR, "Kontron"),
523 			DMI_MATCH(DMI_BOARD_NAME, "COMe-bIP2"),
524 		},
525 		.driver_data = (void *)&kempld_platform_data_generic,
526 		.callback = kempld_create_platform_device,
527 	}, {
528 		.ident = "CCR6",
529 		.matches = {
530 			DMI_MATCH(DMI_BOARD_VENDOR, "Kontron"),
531 			DMI_MATCH(DMI_BOARD_NAME, "COMe-bIP6"),
532 		},
533 		.driver_data = (void *)&kempld_platform_data_generic,
534 		.callback = kempld_create_platform_device,
535 	}, {
536 		.ident = "CHL6",
537 		.matches = {
538 			DMI_MATCH(DMI_BOARD_VENDOR, "Kontron"),
539 			DMI_MATCH(DMI_BOARD_NAME, "COMe-cHL6"),
540 		},
541 		.driver_data = (void *)&kempld_platform_data_generic,
542 		.callback = kempld_create_platform_device,
543 	}, {
544 		.ident = "CHR2",
545 		.matches = {
546 			DMI_MATCH(DMI_BOARD_VENDOR, "Kontron"),
547 			DMI_MATCH(DMI_BOARD_NAME, "ETXexpress-SC T2"),
548 		},
549 		.driver_data = (void *)&kempld_platform_data_generic,
550 		.callback = kempld_create_platform_device,
551 	}, {
552 		.ident = "CHR2",
553 		.matches = {
554 			DMI_MATCH(DMI_BOARD_VENDOR, "Kontron"),
555 			DMI_MATCH(DMI_BOARD_NAME, "ETXe-SC T2"),
556 		},
557 		.driver_data = (void *)&kempld_platform_data_generic,
558 		.callback = kempld_create_platform_device,
559 	}, {
560 		.ident = "CHR2",
561 		.matches = {
562 			DMI_MATCH(DMI_BOARD_VENDOR, "Kontron"),
563 			DMI_MATCH(DMI_BOARD_NAME, "COMe-bSC2"),
564 		},
565 		.driver_data = (void *)&kempld_platform_data_generic,
566 		.callback = kempld_create_platform_device,
567 	}, {
568 		.ident = "CHR6",
569 		.matches = {
570 			DMI_MATCH(DMI_BOARD_VENDOR, "Kontron"),
571 			DMI_MATCH(DMI_BOARD_NAME, "ETXexpress-SC T6"),
572 		},
573 		.driver_data = (void *)&kempld_platform_data_generic,
574 		.callback = kempld_create_platform_device,
575 	}, {
576 		.ident = "CHR6",
577 		.matches = {
578 			DMI_MATCH(DMI_BOARD_VENDOR, "Kontron"),
579 			DMI_MATCH(DMI_BOARD_NAME, "ETXe-SC T6"),
580 		},
581 		.driver_data = (void *)&kempld_platform_data_generic,
582 		.callback = kempld_create_platform_device,
583 	}, {
584 		.ident = "CHR6",
585 		.matches = {
586 			DMI_MATCH(DMI_BOARD_VENDOR, "Kontron"),
587 			DMI_MATCH(DMI_BOARD_NAME, "COMe-bSC6"),
588 		},
589 		.driver_data = (void *)&kempld_platform_data_generic,
590 		.callback = kempld_create_platform_device,
591 	}, {
592 		.ident = "CNTG",
593 		.matches = {
594 			DMI_MATCH(DMI_BOARD_VENDOR, "Kontron"),
595 			DMI_MATCH(DMI_BOARD_NAME, "ETXexpress-PC"),
596 		},
597 		.driver_data = (void *)&kempld_platform_data_generic,
598 		.callback = kempld_create_platform_device,
599 	}, {
600 		.ident = "CNTG",
601 		.matches = {
602 			DMI_MATCH(DMI_BOARD_VENDOR, "Kontron"),
603 			DMI_MATCH(DMI_BOARD_NAME, "COMe-bPC2"),
604 		},
605 		.driver_data = (void *)&kempld_platform_data_generic,
606 		.callback = kempld_create_platform_device,
607 	}, {
608 		.ident = "CNTX",
609 		.matches = {
610 			DMI_MATCH(DMI_BOARD_VENDOR, "Kontron"),
611 			DMI_MATCH(DMI_BOARD_NAME, "PXT"),
612 		},
613 		.driver_data = (void *)&kempld_platform_data_generic,
614 		.callback = kempld_create_platform_device,
615 	}, {
616 		.ident = "CVV6",
617 		.matches = {
618 			DMI_MATCH(DMI_BOARD_VENDOR, "Kontron"),
619 			DMI_MATCH(DMI_BOARD_NAME, "COMe-cBT"),
620 		},
621 		.driver_data = (void *)&kempld_platform_data_generic,
622 		.callback = kempld_create_platform_device,
623 	}, {
624 		.ident = "FRI2",
625 		.matches = {
626 			DMI_MATCH(DMI_BOARD_VENDOR, "Kontron"),
627 			DMI_MATCH(DMI_BIOS_VERSION, "FRI2"),
628 		},
629 		.driver_data = (void *)&kempld_platform_data_generic,
630 		.callback = kempld_create_platform_device,
631 	}, {
632 		.ident = "FRI2",
633 		.matches = {
634 			DMI_MATCH(DMI_PRODUCT_NAME, "Fish River Island II"),
635 		},
636 		.driver_data = (void *)&kempld_platform_data_generic,
637 		.callback = kempld_create_platform_device,
638 	}, {
639 		.ident = "MBR1",
640 		.matches = {
641 			DMI_MATCH(DMI_BOARD_VENDOR, "Kontron"),
642 			DMI_MATCH(DMI_BOARD_NAME, "ETX-OH"),
643 		},
644 		.driver_data = (void *)&kempld_platform_data_generic,
645 		.callback = kempld_create_platform_device,
646 	}, {
647 		.ident = "MVV1",
648 		.matches = {
649 			DMI_MATCH(DMI_BOARD_VENDOR, "Kontron"),
650 			DMI_MATCH(DMI_BOARD_NAME, "COMe-mBT"),
651 		},
652 		.driver_data = (void *)&kempld_platform_data_generic,
653 		.callback = kempld_create_platform_device,
654 	}, {
655 		.ident = "NTC1",
656 		.matches = {
657 			DMI_MATCH(DMI_BOARD_VENDOR, "Kontron"),
658 			DMI_MATCH(DMI_BOARD_NAME, "nanoETXexpress-TT"),
659 		},
660 		.driver_data = (void *)&kempld_platform_data_generic,
661 		.callback = kempld_create_platform_device,
662 	}, {
663 		.ident = "NTC1",
664 		.matches = {
665 			DMI_MATCH(DMI_BOARD_VENDOR, "Kontron"),
666 			DMI_MATCH(DMI_BOARD_NAME, "nETXe-TT"),
667 		},
668 		.driver_data = (void *)&kempld_platform_data_generic,
669 		.callback = kempld_create_platform_device,
670 	}, {
671 		.ident = "NTC1",
672 		.matches = {
673 			DMI_MATCH(DMI_BOARD_VENDOR, "Kontron"),
674 			DMI_MATCH(DMI_BOARD_NAME, "COMe-mTT"),
675 		},
676 		.driver_data = (void *)&kempld_platform_data_generic,
677 		.callback = kempld_create_platform_device,
678 	}, {
679 		.ident = "NUP1",
680 		.matches = {
681 			DMI_MATCH(DMI_BOARD_VENDOR, "Kontron"),
682 			DMI_MATCH(DMI_BOARD_NAME, "COMe-mCT"),
683 		},
684 		.driver_data = (void *)&kempld_platform_data_generic,
685 		.callback = kempld_create_platform_device,
686 	}, {
687 		.ident = "UNP1",
688 		.matches = {
689 			DMI_MATCH(DMI_BOARD_VENDOR, "Kontron"),
690 			DMI_MATCH(DMI_BOARD_NAME, "microETXexpress-DC"),
691 		},
692 		.driver_data = (void *)&kempld_platform_data_generic,
693 		.callback = kempld_create_platform_device,
694 	}, {
695 		.ident = "UNP1",
696 		.matches = {
697 			DMI_MATCH(DMI_BOARD_VENDOR, "Kontron"),
698 			DMI_MATCH(DMI_BOARD_NAME, "COMe-cDC2"),
699 		},
700 		.driver_data = (void *)&kempld_platform_data_generic,
701 		.callback = kempld_create_platform_device,
702 	}, {
703 		.ident = "UNTG",
704 		.matches = {
705 			DMI_MATCH(DMI_BOARD_VENDOR, "Kontron"),
706 			DMI_MATCH(DMI_BOARD_NAME, "microETXexpress-PC"),
707 		},
708 		.driver_data = (void *)&kempld_platform_data_generic,
709 		.callback = kempld_create_platform_device,
710 	}, {
711 		.ident = "UNTG",
712 		.matches = {
713 			DMI_MATCH(DMI_BOARD_VENDOR, "Kontron"),
714 			DMI_MATCH(DMI_BOARD_NAME, "COMe-cPC2"),
715 		},
716 		.driver_data = (void *)&kempld_platform_data_generic,
717 		.callback = kempld_create_platform_device,
718 	}, {
719 		.ident = "UUP6",
720 		.matches = {
721 			DMI_MATCH(DMI_BOARD_VENDOR, "Kontron"),
722 			DMI_MATCH(DMI_BOARD_NAME, "COMe-cCT6"),
723 		},
724 		.driver_data = (void *)&kempld_platform_data_generic,
725 		.callback = kempld_create_platform_device,
726 	},
727 	{
728 		.ident = "UTH6",
729 		.matches = {
730 			DMI_MATCH(DMI_BOARD_VENDOR, "Kontron"),
731 			DMI_MATCH(DMI_BOARD_NAME, "COMe-cTH6"),
732 		},
733 		.driver_data = (void *)&kempld_platform_data_generic,
734 		.callback = kempld_create_platform_device,
735 	},
736 	{}
737 };
738 MODULE_DEVICE_TABLE(dmi, kempld_dmi_table);
739 
740 static int __init kempld_init(void)
741 {
742 	const struct dmi_system_id *id;
743 	int ret;
744 
745 	if (force_device_id[0]) {
746 		for (id = kempld_dmi_table;
747 		     id->matches[0].slot != DMI_NONE; id++)
748 			if (strstr(id->ident, force_device_id))
749 				if (id->callback && !id->callback(id))
750 					break;
751 		if (id->matches[0].slot == DMI_NONE)
752 			return -ENODEV;
753 	} else {
754 		if (!dmi_check_system(kempld_dmi_table))
755 			return -ENODEV;
756 	}
757 
758 	ret = platform_driver_register(&kempld_driver);
759 	if (ret)
760 		return ret;
761 
762 	return 0;
763 }
764 
765 static void __exit kempld_exit(void)
766 {
767 	if (kempld_pdev)
768 		platform_device_unregister(kempld_pdev);
769 
770 	platform_driver_unregister(&kempld_driver);
771 }
772 
773 module_init(kempld_init);
774 module_exit(kempld_exit);
775 
776 MODULE_DESCRIPTION("KEM PLD Core Driver");
777 MODULE_AUTHOR("Michael Brunner <michael.brunner@kontron.com>");
778 MODULE_LICENSE("GPL");
779 MODULE_ALIAS("platform:kempld-core");
780