xref: /openbmc/linux/drivers/ipack/ipack.c (revision 6aa7de05)
1 /*
2  * Industry-pack bus support functions.
3  *
4  * Copyright (C) 2011-2012 CERN (www.cern.ch)
5  * Author: Samuel Iglesias Gonsalvez <siglesias@igalia.com>
6  *
7  * This program is free software; you can redistribute it and/or modify it
8  * under the terms of the GNU General Public License as published by the Free
9  * Software Foundation; version 2 of the License.
10  */
11 
12 #include <linux/module.h>
13 #include <linux/slab.h>
14 #include <linux/idr.h>
15 #include <linux/io.h>
16 #include <linux/ipack.h>
17 
18 #define to_ipack_dev(device) container_of(device, struct ipack_device, dev)
19 #define to_ipack_driver(drv) container_of(drv, struct ipack_driver, driver)
20 
21 static DEFINE_IDA(ipack_ida);
22 
23 static void ipack_device_release(struct device *dev)
24 {
25 	struct ipack_device *device = to_ipack_dev(dev);
26 	kfree(device->id);
27 	device->release(device);
28 }
29 
30 static inline const struct ipack_device_id *
31 ipack_match_one_device(const struct ipack_device_id *id,
32 		       const struct ipack_device *device)
33 {
34 	if ((id->format == IPACK_ANY_FORMAT ||
35 				id->format == device->id_format) &&
36 	    (id->vendor == IPACK_ANY_ID || id->vendor == device->id_vendor) &&
37 	    (id->device == IPACK_ANY_ID || id->device == device->id_device))
38 		return id;
39 	return NULL;
40 }
41 
42 static const struct ipack_device_id *
43 ipack_match_id(const struct ipack_device_id *ids, struct ipack_device *idev)
44 {
45 	if (ids) {
46 		while (ids->vendor || ids->device) {
47 			if (ipack_match_one_device(ids, idev))
48 				return ids;
49 			ids++;
50 		}
51 	}
52 	return NULL;
53 }
54 
55 static int ipack_bus_match(struct device *dev, struct device_driver *drv)
56 {
57 	struct ipack_device *idev = to_ipack_dev(dev);
58 	struct ipack_driver *idrv = to_ipack_driver(drv);
59 	const struct ipack_device_id *found_id;
60 
61 	found_id = ipack_match_id(idrv->id_table, idev);
62 	return found_id ? 1 : 0;
63 }
64 
65 static int ipack_bus_probe(struct device *device)
66 {
67 	struct ipack_device *dev = to_ipack_dev(device);
68 	struct ipack_driver *drv = to_ipack_driver(device->driver);
69 
70 	if (!drv->ops->probe)
71 		return -EINVAL;
72 
73 	return drv->ops->probe(dev);
74 }
75 
76 static int ipack_bus_remove(struct device *device)
77 {
78 	struct ipack_device *dev = to_ipack_dev(device);
79 	struct ipack_driver *drv = to_ipack_driver(device->driver);
80 
81 	if (!drv->ops->remove)
82 		return -EINVAL;
83 
84 	drv->ops->remove(dev);
85 	return 0;
86 }
87 
88 static int ipack_uevent(struct device *dev, struct kobj_uevent_env *env)
89 {
90 	struct ipack_device *idev;
91 
92 	if (!dev)
93 		return -ENODEV;
94 
95 	idev = to_ipack_dev(dev);
96 
97 	if (add_uevent_var(env,
98 			   "MODALIAS=ipack:f%02Xv%08Xd%08X", idev->id_format,
99 			   idev->id_vendor, idev->id_device))
100 		return -ENOMEM;
101 
102 	return 0;
103 }
104 
105 #define ipack_device_attr(field, format_string)				\
106 static ssize_t								\
107 field##_show(struct device *dev, struct device_attribute *attr,		\
108 		char *buf)						\
109 {									\
110 	struct ipack_device *idev = to_ipack_dev(dev);			\
111 	return sprintf(buf, format_string, idev->field);		\
112 }
113 
114 static ssize_t id_show(struct device *dev,
115 		       struct device_attribute *attr, char *buf)
116 {
117 	unsigned int i, c, l, s;
118 	struct ipack_device *idev = to_ipack_dev(dev);
119 
120 
121 	switch (idev->id_format) {
122 	case IPACK_ID_VERSION_1:
123 		l = 0x7; s = 1; break;
124 	case IPACK_ID_VERSION_2:
125 		l = 0xf; s = 2; break;
126 	default:
127 		return -EIO;
128 	}
129 	c = 0;
130 	for (i = 0; i < idev->id_avail; i++) {
131 		if (i > 0) {
132 			if ((i & l) == 0)
133 				buf[c++] = '\n';
134 			else if ((i & s) == 0)
135 				buf[c++] = ' ';
136 		}
137 		sprintf(&buf[c], "%02x", idev->id[i]);
138 		c += 2;
139 	}
140 	buf[c++] = '\n';
141 	return c;
142 }
143 
144 static ssize_t
145 id_vendor_show(struct device *dev, struct device_attribute *attr, char *buf)
146 {
147 	struct ipack_device *idev = to_ipack_dev(dev);
148 	switch (idev->id_format) {
149 	case IPACK_ID_VERSION_1:
150 		return sprintf(buf, "0x%02x\n", idev->id_vendor);
151 	case IPACK_ID_VERSION_2:
152 		return sprintf(buf, "0x%06x\n", idev->id_vendor);
153 	default:
154 		return -EIO;
155 	}
156 }
157 
158 static ssize_t
159 id_device_show(struct device *dev, struct device_attribute *attr, char *buf)
160 {
161 	struct ipack_device *idev = to_ipack_dev(dev);
162 	switch (idev->id_format) {
163 	case IPACK_ID_VERSION_1:
164 		return sprintf(buf, "0x%02x\n", idev->id_device);
165 	case IPACK_ID_VERSION_2:
166 		return sprintf(buf, "0x%04x\n", idev->id_device);
167 	default:
168 		return -EIO;
169 	}
170 }
171 
172 static ssize_t modalias_show(struct device *dev, struct device_attribute *attr,
173 			     char *buf)
174 {
175 	struct ipack_device *idev = to_ipack_dev(dev);
176 
177 	return sprintf(buf, "ipac:f%02Xv%08Xd%08X", idev->id_format,
178 		       idev->id_vendor, idev->id_device);
179 }
180 
181 ipack_device_attr(id_format, "0x%hhx\n");
182 
183 static DEVICE_ATTR_RO(id);
184 static DEVICE_ATTR_RO(id_device);
185 static DEVICE_ATTR_RO(id_format);
186 static DEVICE_ATTR_RO(id_vendor);
187 static DEVICE_ATTR_RO(modalias);
188 
189 static struct attribute *ipack_attrs[] = {
190 	&dev_attr_id.attr,
191 	&dev_attr_id_device.attr,
192 	&dev_attr_id_format.attr,
193 	&dev_attr_id_vendor.attr,
194 	&dev_attr_modalias.attr,
195 	NULL,
196 };
197 ATTRIBUTE_GROUPS(ipack);
198 
199 static struct bus_type ipack_bus_type = {
200 	.name      = "ipack",
201 	.probe     = ipack_bus_probe,
202 	.match     = ipack_bus_match,
203 	.remove    = ipack_bus_remove,
204 	.dev_groups = ipack_groups,
205 	.uevent	   = ipack_uevent,
206 };
207 
208 struct ipack_bus_device *ipack_bus_register(struct device *parent, int slots,
209 					    const struct ipack_bus_ops *ops,
210 					    struct module *owner)
211 {
212 	int bus_nr;
213 	struct ipack_bus_device *bus;
214 
215 	bus = kzalloc(sizeof(*bus), GFP_KERNEL);
216 	if (!bus)
217 		return NULL;
218 
219 	bus_nr = ida_simple_get(&ipack_ida, 0, 0, GFP_KERNEL);
220 	if (bus_nr < 0) {
221 		kfree(bus);
222 		return NULL;
223 	}
224 
225 	bus->bus_nr = bus_nr;
226 	bus->parent = parent;
227 	bus->slots = slots;
228 	bus->ops = ops;
229 	bus->owner = owner;
230 	return bus;
231 }
232 EXPORT_SYMBOL_GPL(ipack_bus_register);
233 
234 static int ipack_unregister_bus_member(struct device *dev, void *data)
235 {
236 	struct ipack_device *idev = to_ipack_dev(dev);
237 	struct ipack_bus_device *bus = data;
238 
239 	if (idev->bus == bus)
240 		ipack_device_del(idev);
241 
242 	return 1;
243 }
244 
245 int ipack_bus_unregister(struct ipack_bus_device *bus)
246 {
247 	bus_for_each_dev(&ipack_bus_type, NULL, bus,
248 		ipack_unregister_bus_member);
249 	ida_simple_remove(&ipack_ida, bus->bus_nr);
250 	kfree(bus);
251 	return 0;
252 }
253 EXPORT_SYMBOL_GPL(ipack_bus_unregister);
254 
255 int ipack_driver_register(struct ipack_driver *edrv, struct module *owner,
256 			  const char *name)
257 {
258 	edrv->driver.owner = owner;
259 	edrv->driver.name = name;
260 	edrv->driver.bus = &ipack_bus_type;
261 	return driver_register(&edrv->driver);
262 }
263 EXPORT_SYMBOL_GPL(ipack_driver_register);
264 
265 void ipack_driver_unregister(struct ipack_driver *edrv)
266 {
267 	driver_unregister(&edrv->driver);
268 }
269 EXPORT_SYMBOL_GPL(ipack_driver_unregister);
270 
271 static u16 ipack_crc_byte(u16 crc, u8 c)
272 {
273 	int i;
274 
275 	crc ^= c << 8;
276 	for (i = 0; i < 8; i++)
277 		crc = (crc << 1) ^ ((crc & 0x8000) ? 0x1021 : 0);
278 	return crc;
279 }
280 
281 /*
282  * The algorithm in lib/crc-ccitt.c does not seem to apply since it uses the
283  * opposite bit ordering.
284  */
285 static u8 ipack_calc_crc1(struct ipack_device *dev)
286 {
287 	u8 c;
288 	u16 crc;
289 	unsigned int i;
290 
291 	crc = 0xffff;
292 	for (i = 0; i < dev->id_avail; i++) {
293 		c = (i != 11) ? dev->id[i] : 0;
294 		crc = ipack_crc_byte(crc, c);
295 	}
296 	crc = ~crc;
297 	return crc & 0xff;
298 }
299 
300 static u16 ipack_calc_crc2(struct ipack_device *dev)
301 {
302 	u8 c;
303 	u16 crc;
304 	unsigned int i;
305 
306 	crc = 0xffff;
307 	for (i = 0; i < dev->id_avail; i++) {
308 		c = ((i != 0x18) && (i != 0x19)) ? dev->id[i] : 0;
309 		crc = ipack_crc_byte(crc, c);
310 	}
311 	crc = ~crc;
312 	return crc;
313 }
314 
315 static void ipack_parse_id1(struct ipack_device *dev)
316 {
317 	u8 *id = dev->id;
318 	u8 crc;
319 
320 	dev->id_vendor = id[4];
321 	dev->id_device = id[5];
322 	dev->speed_8mhz = 1;
323 	dev->speed_32mhz = (id[7] == 'H');
324 	crc = ipack_calc_crc1(dev);
325 	dev->id_crc_correct = (crc == id[11]);
326 	if (!dev->id_crc_correct) {
327 		dev_warn(&dev->dev, "ID CRC invalid found 0x%x, expected 0x%x.\n",
328 				id[11], crc);
329 	}
330 }
331 
332 static void ipack_parse_id2(struct ipack_device *dev)
333 {
334 	__be16 *id = (__be16 *) dev->id;
335 	u16 flags, crc;
336 
337 	dev->id_vendor = ((be16_to_cpu(id[3]) & 0xff) << 16)
338 			 + be16_to_cpu(id[4]);
339 	dev->id_device = be16_to_cpu(id[5]);
340 	flags = be16_to_cpu(id[10]);
341 	dev->speed_8mhz = !!(flags & 2);
342 	dev->speed_32mhz = !!(flags & 4);
343 	crc = ipack_calc_crc2(dev);
344 	dev->id_crc_correct = (crc == be16_to_cpu(id[12]));
345 	if (!dev->id_crc_correct) {
346 		dev_warn(&dev->dev, "ID CRC invalid found 0x%x, expected 0x%x.\n",
347 				id[11], crc);
348 	}
349 }
350 
351 static int ipack_device_read_id(struct ipack_device *dev)
352 {
353 	u8 __iomem *idmem;
354 	int i;
355 	int ret = 0;
356 
357 	idmem = ioremap(dev->region[IPACK_ID_SPACE].start,
358 			dev->region[IPACK_ID_SPACE].size);
359 	if (!idmem) {
360 		dev_err(&dev->dev, "error mapping memory\n");
361 		return -ENOMEM;
362 	}
363 
364 	/* Determine ID PROM Data Format.  If we find the ids "IPAC" or "IPAH"
365 	 * we are dealing with a IndustryPack  format 1 device.  If we detect
366 	 * "VITA4 " (16 bit big endian formatted) we are dealing with a
367 	 * IndustryPack format 2 device */
368 	if ((ioread8(idmem + 1) == 'I') &&
369 			(ioread8(idmem + 3) == 'P') &&
370 			(ioread8(idmem + 5) == 'A') &&
371 			((ioread8(idmem + 7) == 'C') ||
372 			 (ioread8(idmem + 7) == 'H'))) {
373 		dev->id_format = IPACK_ID_VERSION_1;
374 		dev->id_avail = ioread8(idmem + 0x15);
375 		if ((dev->id_avail < 0x0c) || (dev->id_avail > 0x40)) {
376 			dev_warn(&dev->dev, "invalid id size");
377 			dev->id_avail = 0x0c;
378 		}
379 	} else if ((ioread8(idmem + 0) == 'I') &&
380 			(ioread8(idmem + 1) == 'V') &&
381 			(ioread8(idmem + 2) == 'A') &&
382 			(ioread8(idmem + 3) == 'T') &&
383 			(ioread8(idmem + 4) == ' ') &&
384 			(ioread8(idmem + 5) == '4')) {
385 		dev->id_format = IPACK_ID_VERSION_2;
386 		dev->id_avail = ioread16be(idmem + 0x16);
387 		if ((dev->id_avail < 0x1a) || (dev->id_avail > 0x40)) {
388 			dev_warn(&dev->dev, "invalid id size");
389 			dev->id_avail = 0x1a;
390 		}
391 	} else {
392 		dev->id_format = IPACK_ID_VERSION_INVALID;
393 		dev->id_avail = 0;
394 	}
395 
396 	if (!dev->id_avail) {
397 		ret = -ENODEV;
398 		goto out;
399 	}
400 
401 	/* Obtain the amount of memory required to store a copy of the complete
402 	 * ID ROM contents */
403 	dev->id = kmalloc(dev->id_avail, GFP_KERNEL);
404 	if (!dev->id) {
405 		ret = -ENOMEM;
406 		goto out;
407 	}
408 	for (i = 0; i < dev->id_avail; i++) {
409 		if (dev->id_format == IPACK_ID_VERSION_1)
410 			dev->id[i] = ioread8(idmem + (i << 1) + 1);
411 		else
412 			dev->id[i] = ioread8(idmem + i);
413 	}
414 
415 	/* now we can finally work with the copy */
416 	switch (dev->id_format) {
417 	case IPACK_ID_VERSION_1:
418 		ipack_parse_id1(dev);
419 		break;
420 	case IPACK_ID_VERSION_2:
421 		ipack_parse_id2(dev);
422 		break;
423 	}
424 
425 out:
426 	iounmap(idmem);
427 
428 	return ret;
429 }
430 
431 int ipack_device_init(struct ipack_device *dev)
432 {
433 	int ret;
434 
435 	dev->dev.bus = &ipack_bus_type;
436 	dev->dev.release = ipack_device_release;
437 	dev->dev.parent = dev->bus->parent;
438 	dev_set_name(&dev->dev,
439 		     "ipack-dev.%u.%u", dev->bus->bus_nr, dev->slot);
440 	device_initialize(&dev->dev);
441 
442 	if (dev->bus->ops->set_clockrate(dev, 8))
443 		dev_warn(&dev->dev, "failed to switch to 8 MHz operation for reading of device ID.\n");
444 	if (dev->bus->ops->reset_timeout(dev))
445 		dev_warn(&dev->dev, "failed to reset potential timeout.");
446 
447 	ret = ipack_device_read_id(dev);
448 	if (ret < 0) {
449 		dev_err(&dev->dev, "error reading device id section.\n");
450 		return ret;
451 	}
452 
453 	/* if the device supports 32 MHz operation, use it. */
454 	if (dev->speed_32mhz) {
455 		ret = dev->bus->ops->set_clockrate(dev, 32);
456 		if (ret < 0)
457 			dev_err(&dev->dev, "failed to switch to 32 MHz operation.\n");
458 	}
459 
460 	return 0;
461 }
462 EXPORT_SYMBOL_GPL(ipack_device_init);
463 
464 int ipack_device_add(struct ipack_device *dev)
465 {
466 	return device_add(&dev->dev);
467 }
468 EXPORT_SYMBOL_GPL(ipack_device_add);
469 
470 void ipack_device_del(struct ipack_device *dev)
471 {
472 	device_del(&dev->dev);
473 	ipack_put_device(dev);
474 }
475 EXPORT_SYMBOL_GPL(ipack_device_del);
476 
477 void ipack_get_device(struct ipack_device *dev)
478 {
479 	get_device(&dev->dev);
480 }
481 EXPORT_SYMBOL_GPL(ipack_get_device);
482 
483 void ipack_put_device(struct ipack_device *dev)
484 {
485 	put_device(&dev->dev);
486 }
487 EXPORT_SYMBOL_GPL(ipack_put_device);
488 
489 static int __init ipack_init(void)
490 {
491 	ida_init(&ipack_ida);
492 	return bus_register(&ipack_bus_type);
493 }
494 
495 static void __exit ipack_exit(void)
496 {
497 	bus_unregister(&ipack_bus_type);
498 	ida_destroy(&ipack_ida);
499 }
500 
501 module_init(ipack_init);
502 module_exit(ipack_exit);
503 
504 MODULE_AUTHOR("Samuel Iglesias Gonsalvez <siglesias@igalia.com>");
505 MODULE_LICENSE("GPL");
506 MODULE_DESCRIPTION("Industry-pack bus core");
507