Add CRC16 kernel module
[openwrt/svn-archive/archive.git] / package / ucmb / src / ucmb.c
1 /*
2 * Microcontroller Message Bus
3 *
4 * Copyright (c) 2009 Michael Buesch <mb@bu3sch.de>
5 *
6 * Licensed under the GNU/GPL. See COPYING for details.
7 */
8
9 #include "ucmb.h"
10
11 #include <linux/module.h>
12 #include <linux/platform_device.h>
13 #include <linux/miscdevice.h>
14 #include <linux/fs.h>
15 #include <linux/spi/spi.h>
16 #include <linux/spi/spi_gpio.h>
17 #include <linux/spi/spi_bitbang.h>
18 #include <linux/gfp.h>
19 #include <linux/delay.h>
20
21
22 #define PFX "ucmb: "
23
24
25 MODULE_LICENSE("GPL");
26 MODULE_DESCRIPTION("Microcontroller Message Bus");
27 MODULE_AUTHOR("Michael Buesch");
28
29
30 struct ucmb {
31 /* Misc character device driver */
32 struct miscdevice mdev;
33 struct file_operations mdev_fops;
34
35 /* SPI driver */
36 struct spi_device *sdev;
37
38 /* SPI-GPIO driver */
39 struct spi_gpio_platform_data spi_gpio_pdata;
40 struct platform_device spi_gpio_pdev;
41 };
42
43 struct ucmb_message_hdr {
44 __le16 magic; /* UCMB_MAGIC */
45 __le16 len; /* Payload length (excluding header) */
46 } __attribute__((packed));
47
48 struct ucmb_status {
49 __le16 magic; /* UCMB_MAGIC */
50 __le16 code; /* enum ucmb_status_code */
51 } __attribute__((packed));
52
53 #define UCMB_MAGIC 0x1337
54 #define UCMB_MAX_MSG_LEN 0x200
55
56 enum ucmb_status_code {
57 UCMB_STAT_OK = 0,
58 UCMB_STAT_EPROTO, /* Protocol format error */
59 UCMB_STAT_ENOMEM, /* Out of memory */
60 UCMB_STAT_E2BIG, /* Message too big */
61 };
62
63
64 static int ucmb_spi_busnum_count = 1337;
65
66
67 static struct ucmb_platform_data ucmb_list[] = {
68 { //FIXME don't define it here.
69 .name = "ucmb",
70 .gpio_cs = 3,
71 .gpio_sck = 0,
72 .gpio_miso = 1,
73 .gpio_mosi = 2,
74 },
75 };
76
77
78 static int __devinit ucmb_spi_probe(struct spi_device *sdev)
79 {
80 return 0;
81 }
82
83 static int __devexit ucmb_spi_remove(struct spi_device *sdev)
84 {
85 return 0;
86 }
87
88 static struct spi_driver ucmb_spi_driver = {
89 .driver = {
90 .name = "ucmb",
91 .bus = &spi_bus_type,
92 .owner = THIS_MODULE,
93 },
94 .probe = ucmb_spi_probe,
95 .remove = __devexit_p(ucmb_spi_remove),
96 };
97
98 static int ucmb_status_code_to_errno(enum ucmb_status_code code)
99 {
100 switch (code) {
101 case UCMB_STAT_OK:
102 return 0;
103 case UCMB_STAT_EPROTO:
104 return -EPROTO;
105 case UCMB_STAT_ENOMEM:
106 return -ENOMEM;
107 case UCMB_STAT_E2BIG:
108 return -E2BIG;
109 }
110 return -EBUSY;
111 }
112
113 static inline struct ucmb * filp_to_ucmb(struct file *filp)
114 {
115 return container_of(filp->f_op, struct ucmb, mdev_fops);
116 }
117
118 /* FIXME offp */
119 static ssize_t ucmb_read(struct file *filp, char __user *user_buf,
120 size_t size, loff_t *offp)
121 {
122 struct ucmb *ucmb = filp_to_ucmb(filp);
123 u8 *buf;
124 int res, err;
125 struct ucmb_message_hdr hdr;
126 struct ucmb_status status = { .magic = cpu_to_le16(UCMB_MAGIC), };
127
128 err = -E2BIG;
129 if (size > PAGE_SIZE)
130 goto out;
131 if (size > UCMB_MAX_MSG_LEN)
132 goto out;
133
134 err = -ENOMEM;
135 buf = (char *)__get_free_page(GFP_KERNEL);
136 if (!buf)
137 goto out;
138
139 err = spi_read(ucmb->sdev, (u8 *)&hdr, sizeof(hdr));
140 if (err)
141 goto out_free;
142 err = -EPROTO;
143 if (hdr.magic != cpu_to_le16(UCMB_MAGIC))
144 goto out_free;
145 err = -ENOBUFS;
146 if (size < le16_to_cpu(hdr.len))
147 goto out_free;
148 size = le16_to_cpu(hdr.len);
149 err = spi_read(ucmb->sdev, buf, size);
150 if (err)
151 goto out_free;
152
153 err = -EFAULT;
154 if (copy_to_user(user_buf, buf, size))
155 goto out_send_status;
156
157 err = 0;
158
159 out_send_status:
160 status.code = err ? UCMB_STAT_ENOMEM : UCMB_STAT_OK;
161 res = spi_write(ucmb->sdev, (u8 *)&status, sizeof(status));
162 if (res && !err)
163 err = res;
164 out_free:
165 free_page((unsigned long)buf);
166 out:
167 return err ? err : size;
168 }
169
170 /* FIXME offp */
171 static ssize_t ucmb_write(struct file *filp, const char __user *user_buf,
172 size_t size, loff_t *offp)
173 {
174 struct ucmb *ucmb = filp_to_ucmb(filp);
175 u8 *buf;
176 int err;
177 struct ucmb_message_hdr hdr = { .magic = cpu_to_le16(UCMB_MAGIC), };
178 struct ucmb_status status;
179 struct spi_transfer spi_hdr_xfer;
180 struct spi_transfer spi_data_xfer;
181 struct spi_message spi_msg;
182
183 err = -ENOMEM;
184 buf = (char *)__get_free_page(GFP_KERNEL);
185 if (!buf)
186 goto out;
187
188 size = min_t(size_t, PAGE_SIZE, size);
189 size = min_t(size_t, UCMB_MAX_MSG_LEN, size);
190 err = -EFAULT;
191 if (copy_from_user(buf, user_buf, size))
192 goto out_free;
193 hdr.len = cpu_to_le16(size);
194
195 spi_message_init(&spi_msg);
196
197 memset(&spi_hdr_xfer, 0, sizeof(spi_hdr_xfer));
198 spi_hdr_xfer.tx_buf = &hdr;
199 spi_hdr_xfer.len = sizeof(hdr);
200 spi_message_add_tail(&spi_hdr_xfer, &spi_msg);
201
202 memset(&spi_data_xfer, 0, sizeof(spi_data_xfer));
203 spi_data_xfer.tx_buf = buf;
204 spi_data_xfer.len = size;
205 spi_message_add_tail(&spi_data_xfer, &spi_msg);
206
207 /* Send the message, including header. */
208 err = spi_sync(ucmb->sdev, &spi_msg);
209 if (err)
210 goto out_free;
211
212 /* The microcontroller deserves some time to process the message. */
213 msleep(1);
214
215 /* Get the status code. */
216 err = spi_read(ucmb->sdev, (u8 *)&status, sizeof(status));
217 if (err)
218 goto out_free;
219 err = -EPROTO;
220 if (status.magic != cpu_to_le16(UCMB_MAGIC))
221 goto out_free;
222 err = ucmb_status_code_to_errno(le16_to_cpu(status.code));
223 if (err)
224 goto out_free;
225
226 out_free:
227 free_page((unsigned long)buf);
228 out:
229 return err ? err : size;
230 }
231
232 static int __devinit ucmb_probe(struct platform_device *pdev)
233 {
234 struct ucmb_platform_data *pdata;
235 struct ucmb *ucmb;
236 int err;
237 const int bus_num = ucmb_spi_busnum_count++;
238 struct spi_bitbang *bb;
239
240 pdata = pdev->dev.platform_data;
241 if (!pdata)
242 return -ENXIO;
243
244 ucmb = kzalloc(sizeof(struct ucmb), GFP_KERNEL);
245 if (!ucmb)
246 return -ENOMEM;
247
248 /* Create the SPI GPIO bus master. */
249
250 #ifdef CONFIG_SPI_GPIO_MODULE
251 err = request_module("spi_gpio");
252 if (err)
253 printk(KERN_WARNING PFX "Failed to request spi_gpio module\n");
254 #endif /* CONFIG_SPI_GPIO_MODULE */
255
256 ucmb->spi_gpio_pdata.sck = pdata->gpio_sck;
257 ucmb->spi_gpio_pdata.mosi = pdata->gpio_mosi;
258 ucmb->spi_gpio_pdata.miso = pdata->gpio_miso;
259 ucmb->spi_gpio_pdata.num_chipselect = 1;
260
261 ucmb->spi_gpio_pdev.name = "spi_gpio";
262 ucmb->spi_gpio_pdev.id = bus_num;
263 ucmb->spi_gpio_pdev.dev.platform_data = &ucmb->spi_gpio_pdata;
264
265 err = platform_device_register(&ucmb->spi_gpio_pdev);
266 if (err) {
267 printk(KERN_ERR PFX "Failed to register SPI-GPIO platform device\n");
268 goto err_free_ucmb;
269 }
270 bb = platform_get_drvdata(&ucmb->spi_gpio_pdev);
271 if (!bb || !bb->master) {
272 printk(KERN_ERR PFX "No bitbanged master device found.\n");
273 goto err_unreg_spi_gpio_pdev;
274 }
275
276 /* Create the SPI device. */
277
278 ucmb->sdev = spi_alloc_device(bb->master);
279 if (!ucmb->sdev) {
280 printk(KERN_ERR PFX "Failed to allocate SPI device\n");
281 goto err_unreg_spi_gpio_pdev;
282 }
283 ucmb->sdev->max_speed_hz = 500000;
284 ucmb->sdev->chip_select = 0;
285 ucmb->sdev->mode = SPI_MODE_0;
286 strlcpy(ucmb->sdev->modalias, "ucmb", /* We are the SPI driver. */
287 sizeof(ucmb->sdev->modalias));
288 ucmb->sdev->controller_data = (void *)pdata->gpio_cs;
289 err = spi_add_device(ucmb->sdev);
290 if (err) {
291 printk(KERN_ERR PFX "Failed to add SPI device\n");
292 goto err_free_spi_device;
293 }
294
295 /* Create the Misc char device. */
296
297 ucmb->mdev.minor = MISC_DYNAMIC_MINOR;
298 ucmb->mdev.name = pdata->name;
299 ucmb->mdev.parent = &pdev->dev;
300 ucmb->mdev_fops.read = ucmb_read;
301 ucmb->mdev_fops.write = ucmb_write;
302 ucmb->mdev.fops = &ucmb->mdev_fops;
303
304 err = misc_register(&ucmb->mdev);
305 if (err) {
306 printk(KERN_ERR PFX "Failed to register miscdev %s\n",
307 ucmb->mdev.name);
308 goto err_unreg_spi_device;
309 }
310
311 platform_set_drvdata(pdev, ucmb);
312
313 printk(KERN_INFO PFX "Registered message bus \"%s\"\n", pdata->name);
314
315 return 0;
316
317 err_unreg_spi_device:
318 spi_unregister_device(ucmb->sdev);
319 err_free_spi_device:
320 spi_dev_put(ucmb->sdev);
321 err_unreg_spi_gpio_pdev:
322 platform_device_unregister(&ucmb->spi_gpio_pdev);
323 err_free_ucmb:
324 kfree(ucmb);
325
326 return err;
327 }
328
329 static int __devexit ucmb_remove(struct platform_device *pdev)
330 {
331 struct ucmb *ucmb = platform_get_drvdata(pdev);
332 int err;
333
334 err = misc_deregister(&ucmb->mdev);
335 if (err) {
336 printk(KERN_ERR PFX "Failed to unregister miscdev %s\n",
337 ucmb->mdev.name);
338 }
339 spi_unregister_device(ucmb->sdev);
340 spi_dev_put(ucmb->sdev);
341 platform_device_unregister(&ucmb->spi_gpio_pdev);
342
343 kfree(ucmb);
344 platform_set_drvdata(pdev, NULL);
345
346 return 0;
347 }
348
349 static struct platform_driver ucmb_driver = {
350 .driver = {
351 .name = "ucmb",
352 .owner = THIS_MODULE,
353 },
354 .probe = ucmb_probe,
355 .remove = __devexit_p(ucmb_probe),
356 };
357
358 static int ucmb_modinit(void)
359 {
360 struct ucmb_platform_data *pdata;
361 struct platform_device *pdev;
362 int err, i;
363
364 printk(KERN_INFO "Microcontroller message bus driver\n");
365
366 err = platform_driver_register(&ucmb_driver);
367 if (err) {
368 printk(KERN_ERR PFX "Failed to register platform driver\n");
369 return err;
370 }
371 err = spi_register_driver(&ucmb_spi_driver);
372 if (err) {
373 printk(KERN_ERR PFX "Failed to register SPI driver\n");
374 platform_driver_unregister(&ucmb_driver);
375 return err;
376 }
377
378 for (i = 0; i < ARRAY_SIZE(ucmb_list); i++) {
379 pdata = &ucmb_list[i];
380
381 pdev = platform_device_alloc("ucmb", i);
382 if (!pdev) {
383 printk(KERN_ERR PFX "Failed to allocate platform device.\n");
384 break;
385 }
386 err = platform_device_add_data(pdev, pdata, sizeof(*pdata));
387 if (err) {
388 printk(KERN_ERR PFX "Failed to add platform data.\n");
389 platform_device_put(pdev);
390 break;
391 }
392 err = platform_device_add(pdev);
393 if (err) {
394 printk(KERN_ERR PFX "Failed to register platform device.\n");
395 platform_device_put(pdev);
396 break;
397 }
398 pdata->pdev = pdev;
399 }
400
401 return 0;
402 }
403 module_init(ucmb_modinit);
404
405 static void ucmb_modexit(void)
406 {
407 struct ucmb_platform_data *pdata;
408 int i;
409
410 for (i = 0; i < ARRAY_SIZE(ucmb_list); i++) {
411 pdata = &ucmb_list[i];
412
413 if (pdata->pdev) {
414 platform_device_unregister(pdata->pdev);
415 platform_device_put(pdata->pdev);
416 }
417 }
418 spi_unregister_driver(&ucmb_spi_driver);
419 platform_driver_unregister(&ucmb_driver);
420 }
421 module_exit(ucmb_modexit);