blob: 24d52497524dce7b8935cb678c6084d39c6f2510 [file] [log] [blame]
Alessandro Rubini77864f22013-06-18 23:47:13 +02001/*
2 * Copyright (C) 2012 CERN (www.cern.ch)
3 * Author: Alessandro Rubini <rubini@gnudd.com>
4 *
5 * Released according to the GNU GPL, version 2 or any later version.
6 *
7 * This work is part of the White Rabbit project, a research effort led
8 * by CERN, the European Institute for Nuclear Research.
9 */
Alessandro Rubini9c9f32e2013-06-12 09:13:25 +020010#include <linux/kernel.h>
11#include <linux/module.h>
Alessandro Rubini77864f22013-06-18 23:47:13 +020012#include <linux/slab.h>
Alessandro Rubini9c9f32e2013-06-12 09:13:25 +020013#include <linux/init.h>
14#include <linux/device.h>
Alessandro Rubini77864f22013-06-18 23:47:13 +020015#include <linux/fmc.h>
16
17static int fmc_check_version(unsigned long version, const char *name)
18{
19 if (__FMC_MAJOR(version) != FMC_MAJOR) {
20 pr_err("%s: \"%s\" has wrong major (has %li, expected %i)\n",
21 __func__, name, __FMC_MAJOR(version), FMC_MAJOR);
22 return -EINVAL;
23 }
24
25 if (__FMC_MINOR(version) != FMC_MINOR)
26 pr_info("%s: \"%s\" has wrong minor (has %li, expected %i)\n",
27 __func__, name, __FMC_MINOR(version), FMC_MINOR);
28 return 0;
29}
30
31static int fmc_uevent(struct device *dev, struct kobj_uevent_env *env)
32{
33 /* struct fmc_device *fdev = to_fmc_device(dev); */
34
35 /* FIXME: The MODALIAS */
36 add_uevent_var(env, "MODALIAS=%s", "fmc");
37 return 0;
38}
39
40static int fmc_probe(struct device *dev)
41{
42 struct fmc_driver *fdrv = to_fmc_driver(dev->driver);
43 struct fmc_device *fdev = to_fmc_device(dev);
44
45 return fdrv->probe(fdev);
46}
47
48static int fmc_remove(struct device *dev)
49{
50 struct fmc_driver *fdrv = to_fmc_driver(dev->driver);
51 struct fmc_device *fdev = to_fmc_device(dev);
52
53 return fdrv->remove(fdev);
54}
55
56static void fmc_shutdown(struct device *dev)
57{
58 /* not implemented but mandatory */
59}
Alessandro Rubini9c9f32e2013-06-12 09:13:25 +020060
61static struct bus_type fmc_bus_type = {
62 .name = "fmc",
Alessandro Rubini77864f22013-06-18 23:47:13 +020063 .match = fmc_match,
64 .uevent = fmc_uevent,
65 .probe = fmc_probe,
66 .remove = fmc_remove,
67 .shutdown = fmc_shutdown,
Alessandro Rubini9c9f32e2013-06-12 09:13:25 +020068};
69
Alessandro Rubini77864f22013-06-18 23:47:13 +020070static void fmc_release(struct device *dev)
71{
72 struct fmc_device *fmc = container_of(dev, struct fmc_device, dev);
73
74 kfree(fmc);
75}
76
77/*
78 * The eeprom is exported in sysfs, through a binary attribute
79 */
80
81static ssize_t fmc_read_eeprom(struct file *file, struct kobject *kobj,
82 struct bin_attribute *bin_attr,
83 char *buf, loff_t off, size_t count)
84{
85 struct device *dev;
86 struct fmc_device *fmc;
87 int eelen;
88
89 dev = container_of(kobj, struct device, kobj);
90 fmc = container_of(dev, struct fmc_device, dev);
91 eelen = fmc->eeprom_len;
92 if (off > eelen)
93 return -ESPIPE;
94 if (off == eelen)
95 return 0; /* EOF */
96 if (off + count > eelen)
97 count = eelen - off;
98 memcpy(buf, fmc->eeprom + off, count);
99 return count;
100}
101
102static struct bin_attribute fmc_eeprom_attr = {
103 .attr = { .name = "eeprom", .mode = S_IRUGO, },
104 .size = 8192, /* more or less standard */
105 .read = fmc_read_eeprom,
106};
107
108/*
109 * Functions for client modules follow
110 */
111
112int fmc_driver_register(struct fmc_driver *drv)
113{
114 if (fmc_check_version(drv->version, drv->driver.name))
115 return -EINVAL;
116 drv->driver.bus = &fmc_bus_type;
117 return driver_register(&drv->driver);
118}
119EXPORT_SYMBOL(fmc_driver_register);
120
121void fmc_driver_unregister(struct fmc_driver *drv)
122{
123 driver_unregister(&drv->driver);
124}
125EXPORT_SYMBOL(fmc_driver_unregister);
126
127/*
128 * When a device set is registered, all eeproms must be read
129 * and all FRUs must be parsed
130 */
131int fmc_device_register_n(struct fmc_device **devs, int n)
132{
133 struct fmc_device *fmc, **devarray;
134 uint32_t device_id;
135 int i, ret = 0;
136
137 if (n < 1)
138 return 0;
139
140 /* Check the version of the first data structure (function prints) */
141 if (fmc_check_version(devs[0]->version, devs[0]->carrier_name))
142 return -EINVAL;
143
144 devarray = kmemdup(devs, n * sizeof(*devs), GFP_KERNEL);
145 if (!devarray)
146 return -ENOMEM;
147
148 /* Make all other checks before continuing, for all devices */
149 for (i = 0; i < n; i++) {
150 fmc = devarray[i];
151 if (!fmc->hwdev) {
152 pr_err("%s: device nr. %i has no hwdev pointer\n",
153 __func__, i);
154 ret = -EINVAL;
155 break;
156 }
157 if (fmc->flags == FMC_DEVICE_NO_MEZZANINE) {
158 dev_info(fmc->hwdev, "absent mezzanine in slot %d\n",
159 fmc->slot_id);
160 continue;
161 }
162 if (!fmc->eeprom) {
163 dev_err(fmc->hwdev, "no eeprom provided for slot %i\n",
164 fmc->slot_id);
165 ret = -EINVAL;
166 }
167 if (!fmc->eeprom_addr) {
168 dev_err(fmc->hwdev, "no eeprom_addr for slot %i\n",
169 fmc->slot_id);
170 ret = -EINVAL;
171 }
172 if (!fmc->carrier_name || !fmc->carrier_data ||
173 !fmc->device_id) {
174 dev_err(fmc->hwdev,
175 "deivce nr %i: carrier name, "
176 "data or dev_id not set\n", i);
177 ret = -EINVAL;
178 }
179 if (ret)
180 break;
181
182 }
183 if (ret) {
184 kfree(devarray);
185 return ret;
186 }
187
188 /* Validation is ok. Now init and register the devices */
189 for (i = 0; i < n; i++) {
190 fmc = devarray[i];
191
192 if (fmc->flags == FMC_DEVICE_NO_MEZZANINE)
193 continue; /* dev_info already done above */
194
195 fmc->nr_slots = n; /* each slot must know how many are there */
196 fmc->devarray = devarray;
197
198 device_initialize(&fmc->dev);
199 fmc->dev.release = fmc_release;
200 fmc->dev.parent = fmc->hwdev;
201
202 /* Fill the identification stuff (may fail) */
203 fmc_fill_id_info(fmc);
204
205 fmc->dev.bus = &fmc_bus_type;
206
207 /* Name from mezzanine info or carrier info. Or 0,1,2.. */
208 device_id = fmc->device_id;
209 if (!fmc->mezzanine_name)
210 dev_set_name(&fmc->dev, "fmc-%04x", device_id);
211 else
212 dev_set_name(&fmc->dev, "%s-%04x", fmc->mezzanine_name,
213 device_id);
214 ret = device_add(&fmc->dev);
215 if (ret < 0) {
216 dev_err(fmc->hwdev, "Slot %i: Failed in registering "
217 "\"%s\"\n", fmc->slot_id, fmc->dev.kobj.name);
218 goto out;
219 }
220 ret = sysfs_create_bin_file(&fmc->dev.kobj, &fmc_eeprom_attr);
221 if (ret < 0) {
222 dev_err(&fmc->dev, "Failed in registering eeprom\n");
223 goto out1;
224 }
225 /* This device went well, give information to the user */
226 fmc_dump_eeprom(fmc);
227 fmc_dump_sdb(fmc);
228 }
229 return 0;
230
231out1:
232 device_del(&fmc->dev);
233out:
234 fmc_free_id_info(fmc);
235 put_device(&fmc->dev);
236
237 kfree(devarray);
238 for (i--; i >= 0; i--) {
239 sysfs_remove_bin_file(&devs[i]->dev.kobj, &fmc_eeprom_attr);
240 device_del(&devs[i]->dev);
241 fmc_free_id_info(devs[i]);
242 put_device(&devs[i]->dev);
243 }
244 return ret;
245
246}
247EXPORT_SYMBOL(fmc_device_register_n);
248
249int fmc_device_register(struct fmc_device *fmc)
250{
251 return fmc_device_register_n(&fmc, 1);
252}
253EXPORT_SYMBOL(fmc_device_register);
254
255void fmc_device_unregister_n(struct fmc_device **devs, int n)
256{
257 int i;
258
259 if (n < 1)
260 return;
261
262 /* Free devarray first, not used by the later loop */
263 kfree(devs[0]->devarray);
264
265 for (i = 0; i < n; i++) {
266 if (devs[i]->flags == FMC_DEVICE_NO_MEZZANINE)
267 continue;
268 sysfs_remove_bin_file(&devs[i]->dev.kobj, &fmc_eeprom_attr);
269 device_del(&devs[i]->dev);
270 fmc_free_id_info(devs[i]);
271 put_device(&devs[i]->dev);
272 }
273}
274EXPORT_SYMBOL(fmc_device_unregister_n);
275
276void fmc_device_unregister(struct fmc_device *fmc)
277{
278 fmc_device_unregister_n(&fmc, 1);
279}
280EXPORT_SYMBOL(fmc_device_unregister);
281
282/* Init and exit are trivial */
Alessandro Rubini9c9f32e2013-06-12 09:13:25 +0200283static int fmc_init(void)
284{
285 return bus_register(&fmc_bus_type);
286}
287
288static void fmc_exit(void)
289{
290 bus_unregister(&fmc_bus_type);
291}
292
293module_init(fmc_init);
294module_exit(fmc_exit);
295
296MODULE_LICENSE("GPL");