misc: C2port needs <linux/sched.h>
[linux-2.6.git] / drivers / misc / c2port / core.c
1 /*
2  *  Silicon Labs C2 port core Linux support
3  *
4  *  Copyright (c) 2007 Rodolfo Giometti <giometti@linux.it>
5  *  Copyright (c) 2007 Eurotech S.p.A. <info@eurotech.it>
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 version 2 as published by
9  * the Free Software Foundation
10  */
11
12 #include <linux/module.h>
13 #include <linux/init.h>
14 #include <linux/device.h>
15 #include <linux/errno.h>
16 #include <linux/err.h>
17 #include <linux/kernel.h>
18 #include <linux/ctype.h>
19 #include <linux/delay.h>
20 #include <linux/idr.h>
21 #include <linux/sched.h>
22
23 #include <linux/c2port.h>
24
25 #define DRIVER_NAME             "c2port"
26 #define DRIVER_VERSION          "0.51.0"
27
28 static DEFINE_SPINLOCK(c2port_idr_lock);
29 static DEFINE_IDR(c2port_idr);
30
31 /*
32  * Local variables
33  */
34
35 static struct class *c2port_class;
36
37 /*
38  * C2 registers & commands defines
39  */
40
41 /* C2 registers */
42 #define C2PORT_DEVICEID         0x00
43 #define C2PORT_REVID            0x01
44 #define C2PORT_FPCTL            0x02
45 #define C2PORT_FPDAT            0xB4
46
47 /* C2 interface commands */
48 #define C2PORT_GET_VERSION      0x01
49 #define C2PORT_DEVICE_ERASE     0x03
50 #define C2PORT_BLOCK_READ       0x06
51 #define C2PORT_BLOCK_WRITE      0x07
52 #define C2PORT_PAGE_ERASE       0x08
53
54 /* C2 status return codes */
55 #define C2PORT_INVALID_COMMAND  0x00
56 #define C2PORT_COMMAND_FAILED   0x02
57 #define C2PORT_COMMAND_OK       0x0d
58
59 /*
60  * C2 port low level signal managements
61  */
62
63 static void c2port_reset(struct c2port_device *dev)
64 {
65         struct c2port_ops *ops = dev->ops;
66
67         /* To reset the device we have to keep clock line low for at least
68          * 20us.
69          */
70         local_irq_disable();
71         ops->c2ck_set(dev, 0);
72         udelay(25);
73         ops->c2ck_set(dev, 1);
74         local_irq_enable();
75
76         udelay(1);
77 }
78
79 static void c2port_strobe_ck(struct c2port_device *dev)
80 {
81         struct c2port_ops *ops = dev->ops;
82
83         /* During hi-low-hi transition we disable local IRQs to avoid
84          * interructions since C2 port specification says that it must be
85          * shorter than 5us, otherwise the microcontroller may consider
86          * it as a reset signal!
87          */
88         local_irq_disable();
89         ops->c2ck_set(dev, 0);
90         udelay(1);
91         ops->c2ck_set(dev, 1);
92         local_irq_enable();
93
94         udelay(1);
95 }
96
97 /*
98  * C2 port basic functions
99  */
100
101 static void c2port_write_ar(struct c2port_device *dev, u8 addr)
102 {
103         struct c2port_ops *ops = dev->ops;
104         int i;
105
106         /* START field */
107         c2port_strobe_ck(dev);
108
109         /* INS field (11b, LSB first) */
110         ops->c2d_dir(dev, 0);
111         ops->c2d_set(dev, 1);
112         c2port_strobe_ck(dev);
113         ops->c2d_set(dev, 1);
114         c2port_strobe_ck(dev);
115
116         /* ADDRESS field */
117         for (i = 0; i < 8; i++) {
118                 ops->c2d_set(dev, addr & 0x01);
119                 c2port_strobe_ck(dev);
120
121                 addr >>= 1;
122         }
123
124         /* STOP field */
125         ops->c2d_dir(dev, 1);
126         c2port_strobe_ck(dev);
127 }
128
129 static int c2port_read_ar(struct c2port_device *dev, u8 *addr)
130 {
131         struct c2port_ops *ops = dev->ops;
132         int i;
133
134         /* START field */
135         c2port_strobe_ck(dev);
136
137         /* INS field (10b, LSB first) */
138         ops->c2d_dir(dev, 0);
139         ops->c2d_set(dev, 0);
140         c2port_strobe_ck(dev);
141         ops->c2d_set(dev, 1);
142         c2port_strobe_ck(dev);
143
144         /* ADDRESS field */
145         ops->c2d_dir(dev, 1);
146         *addr = 0;
147         for (i = 0; i < 8; i++) {
148                 *addr >>= 1;    /* shift in 8-bit ADDRESS field LSB first */
149
150                 c2port_strobe_ck(dev);
151                 if (ops->c2d_get(dev))
152                         *addr |= 0x80;
153         }
154
155         /* STOP field */
156         c2port_strobe_ck(dev);
157
158         return 0;
159 }
160
161 static int c2port_write_dr(struct c2port_device *dev, u8 data)
162 {
163         struct c2port_ops *ops = dev->ops;
164         int timeout, i;
165
166         /* START field */
167         c2port_strobe_ck(dev);
168
169         /* INS field (01b, LSB first) */
170         ops->c2d_dir(dev, 0);
171         ops->c2d_set(dev, 1);
172         c2port_strobe_ck(dev);
173         ops->c2d_set(dev, 0);
174         c2port_strobe_ck(dev);
175
176         /* LENGTH field (00b, LSB first -> 1 byte) */
177         ops->c2d_set(dev, 0);
178         c2port_strobe_ck(dev);
179         ops->c2d_set(dev, 0);
180         c2port_strobe_ck(dev);
181
182         /* DATA field */
183         for (i = 0; i < 8; i++) {
184                 ops->c2d_set(dev, data & 0x01);
185                 c2port_strobe_ck(dev);
186
187                 data >>= 1;
188         }
189
190         /* WAIT field */
191         ops->c2d_dir(dev, 1);
192         timeout = 20;
193         do {
194                 c2port_strobe_ck(dev);
195                 if (ops->c2d_get(dev))
196                         break;
197
198                 udelay(1);
199         } while (--timeout > 0);
200         if (timeout == 0)
201                 return -EIO;
202
203         /* STOP field */
204         c2port_strobe_ck(dev);
205
206         return 0;
207 }
208
209 static int c2port_read_dr(struct c2port_device *dev, u8 *data)
210 {
211         struct c2port_ops *ops = dev->ops;
212         int timeout, i;
213
214         /* START field */
215         c2port_strobe_ck(dev);
216
217         /* INS field (00b, LSB first) */
218         ops->c2d_dir(dev, 0);
219         ops->c2d_set(dev, 0);
220         c2port_strobe_ck(dev);
221         ops->c2d_set(dev, 0);
222         c2port_strobe_ck(dev);
223
224         /* LENGTH field (00b, LSB first -> 1 byte) */
225         ops->c2d_set(dev, 0);
226         c2port_strobe_ck(dev);
227         ops->c2d_set(dev, 0);
228         c2port_strobe_ck(dev);
229
230         /* WAIT field */
231         ops->c2d_dir(dev, 1);
232         timeout = 20;
233         do {
234                 c2port_strobe_ck(dev);
235                 if (ops->c2d_get(dev))
236                         break;
237
238                 udelay(1);
239         } while (--timeout > 0);
240         if (timeout == 0)
241                 return -EIO;
242
243         /* DATA field */
244         *data = 0;
245         for (i = 0; i < 8; i++) {
246                 *data >>= 1;    /* shift in 8-bit DATA field LSB first */
247
248                 c2port_strobe_ck(dev);
249                 if (ops->c2d_get(dev))
250                         *data |= 0x80;
251         }
252
253         /* STOP field */
254         c2port_strobe_ck(dev);
255
256         return 0;
257 }
258
259 static int c2port_poll_in_busy(struct c2port_device *dev)
260 {
261         u8 addr;
262         int ret, timeout = 20;
263
264         do {
265                 ret = (c2port_read_ar(dev, &addr));
266                 if (ret < 0)
267                         return -EIO;
268
269                 if (!(addr & 0x02))
270                         break;
271
272                 udelay(1);
273         } while (--timeout > 0);
274         if (timeout == 0)
275                 return -EIO;
276
277         return 0;
278 }
279
280 static int c2port_poll_out_ready(struct c2port_device *dev)
281 {
282         u8 addr;
283         int ret, timeout = 10000; /* erase flash needs long time... */
284
285         do {
286                 ret = (c2port_read_ar(dev, &addr));
287                 if (ret < 0)
288                         return -EIO;
289
290                 if (addr & 0x01)
291                         break;
292
293                 udelay(1);
294         } while (--timeout > 0);
295         if (timeout == 0)
296                 return -EIO;
297
298         return 0;
299 }
300
301 /*
302  * sysfs methods
303  */
304
305 static ssize_t c2port_show_name(struct device *dev,
306                                 struct device_attribute *attr, char *buf)
307 {
308         struct c2port_device *c2dev = dev_get_drvdata(dev);
309
310         return sprintf(buf, "%s\n", c2dev->name);
311 }
312
313 static ssize_t c2port_show_flash_blocks_num(struct device *dev,
314                                 struct device_attribute *attr, char *buf)
315 {
316         struct c2port_device *c2dev = dev_get_drvdata(dev);
317         struct c2port_ops *ops = c2dev->ops;
318
319         return sprintf(buf, "%d\n", ops->blocks_num);
320 }
321
322 static ssize_t c2port_show_flash_block_size(struct device *dev,
323                                 struct device_attribute *attr, char *buf)
324 {
325         struct c2port_device *c2dev = dev_get_drvdata(dev);
326         struct c2port_ops *ops = c2dev->ops;
327
328         return sprintf(buf, "%d\n", ops->block_size);
329 }
330
331 static ssize_t c2port_show_flash_size(struct device *dev,
332                                 struct device_attribute *attr, char *buf)
333 {
334         struct c2port_device *c2dev = dev_get_drvdata(dev);
335         struct c2port_ops *ops = c2dev->ops;
336
337         return sprintf(buf, "%d\n", ops->blocks_num * ops->block_size);
338 }
339
340 static ssize_t c2port_show_access(struct device *dev,
341                                 struct device_attribute *attr, char *buf)
342 {
343         struct c2port_device *c2dev = dev_get_drvdata(dev);
344
345         return sprintf(buf, "%d\n", c2dev->access);
346 }
347
348 static ssize_t c2port_store_access(struct device *dev,
349                                 struct device_attribute *attr,
350                                 const char *buf, size_t count)
351 {
352         struct c2port_device *c2dev = dev_get_drvdata(dev);
353         struct c2port_ops *ops = c2dev->ops;
354         int status, ret;
355
356         ret = sscanf(buf, "%d", &status);
357         if (ret != 1)
358                 return -EINVAL;
359
360         mutex_lock(&c2dev->mutex);
361
362         c2dev->access = !!status;
363
364         /* If access is "on" clock should be HIGH _before_ setting the line
365          * as output and data line should be set as INPUT anyway */
366         if (c2dev->access)
367                 ops->c2ck_set(c2dev, 1);
368         ops->access(c2dev, c2dev->access);
369         if (c2dev->access)
370                 ops->c2d_dir(c2dev, 1);
371
372         mutex_unlock(&c2dev->mutex);
373
374         return count;
375 }
376
377 static ssize_t c2port_store_reset(struct device *dev,
378                                 struct device_attribute *attr,
379                                 const char *buf, size_t count)
380 {
381         struct c2port_device *c2dev = dev_get_drvdata(dev);
382
383         /* Check the device access status */
384         if (!c2dev->access)
385                 return -EBUSY;
386
387         mutex_lock(&c2dev->mutex);
388
389         c2port_reset(c2dev);
390         c2dev->flash_access = 0;
391
392         mutex_unlock(&c2dev->mutex);
393
394         return count;
395 }
396
397 static ssize_t __c2port_show_dev_id(struct c2port_device *dev, char *buf)
398 {
399         u8 data;
400         int ret;
401
402         /* Select DEVICEID register for C2 data register accesses */
403         c2port_write_ar(dev, C2PORT_DEVICEID);
404
405         /* Read and return the device ID register */
406         ret = c2port_read_dr(dev, &data);
407         if (ret < 0)
408                 return ret;
409
410         return sprintf(buf, "%d\n", data);
411 }
412
413 static ssize_t c2port_show_dev_id(struct device *dev,
414                                 struct device_attribute *attr, char *buf)
415 {
416         struct c2port_device *c2dev = dev_get_drvdata(dev);
417         ssize_t ret;
418
419         /* Check the device access status */
420         if (!c2dev->access)
421                 return -EBUSY;
422
423         mutex_lock(&c2dev->mutex);
424         ret = __c2port_show_dev_id(c2dev, buf);
425         mutex_unlock(&c2dev->mutex);
426
427         if (ret < 0)
428                 dev_err(dev, "cannot read from %s\n", c2dev->name);
429
430         return ret;
431 }
432
433 static ssize_t __c2port_show_rev_id(struct c2port_device *dev, char *buf)
434 {
435         u8 data;
436         int ret;
437
438         /* Select REVID register for C2 data register accesses */
439         c2port_write_ar(dev, C2PORT_REVID);
440
441         /* Read and return the revision ID register */
442         ret = c2port_read_dr(dev, &data);
443         if (ret < 0)
444                 return ret;
445
446         return sprintf(buf, "%d\n", data);
447 }
448
449 static ssize_t c2port_show_rev_id(struct device *dev,
450                                 struct device_attribute *attr, char *buf)
451 {
452         struct c2port_device *c2dev = dev_get_drvdata(dev);
453         ssize_t ret;
454
455         /* Check the device access status */
456         if (!c2dev->access)
457                 return -EBUSY;
458
459         mutex_lock(&c2dev->mutex);
460         ret = __c2port_show_rev_id(c2dev, buf);
461         mutex_unlock(&c2dev->mutex);
462
463         if (ret < 0)
464                 dev_err(c2dev->dev, "cannot read from %s\n", c2dev->name);
465
466         return ret;
467 }
468
469 static ssize_t c2port_show_flash_access(struct device *dev,
470                                 struct device_attribute *attr, char *buf)
471 {
472         struct c2port_device *c2dev = dev_get_drvdata(dev);
473
474         return sprintf(buf, "%d\n", c2dev->flash_access);
475 }
476
477 static ssize_t __c2port_store_flash_access(struct c2port_device *dev,
478                                                 int status)
479 {
480         int ret;
481
482         /* Check the device access status */
483         if (!dev->access)
484                 return -EBUSY;
485
486         dev->flash_access = !!status;
487
488         /* If flash_access is off we have nothing to do... */
489         if (dev->flash_access == 0)
490                 return 0;
491
492         /* Target the C2 flash programming control register for C2 data
493          * register access */
494         c2port_write_ar(dev, C2PORT_FPCTL);
495
496         /* Write the first keycode to enable C2 Flash programming */
497         ret = c2port_write_dr(dev, 0x02);
498         if (ret < 0)
499                 return ret;
500
501         /* Write the second keycode to enable C2 Flash programming */
502         ret = c2port_write_dr(dev, 0x01);
503         if (ret < 0)
504                 return ret;
505
506         /* Delay for at least 20ms to ensure the target is ready for
507          * C2 flash programming */
508         mdelay(25);
509
510         return 0;
511 }
512
513 static ssize_t c2port_store_flash_access(struct device *dev,
514                                 struct device_attribute *attr,
515                                 const char *buf, size_t count)
516 {
517         struct c2port_device *c2dev = dev_get_drvdata(dev);
518         int status;
519         ssize_t ret;
520
521         ret = sscanf(buf, "%d", &status);
522         if (ret != 1)
523                 return -EINVAL;
524
525         mutex_lock(&c2dev->mutex);
526         ret = __c2port_store_flash_access(c2dev, status);
527         mutex_unlock(&c2dev->mutex);
528
529         if (ret < 0) {
530                 dev_err(c2dev->dev, "cannot enable %s flash programming\n",
531                         c2dev->name);
532                 return ret;
533         }
534
535         return count;
536 }
537
538 static ssize_t __c2port_write_flash_erase(struct c2port_device *dev)
539 {
540         u8 status;
541         int ret;
542
543         /* Target the C2 flash programming data register for C2 data register
544          * access.
545          */
546         c2port_write_ar(dev, C2PORT_FPDAT);
547
548         /* Send device erase command */
549         c2port_write_dr(dev, C2PORT_DEVICE_ERASE);
550
551         /* Wait for input acknowledge */
552         ret = c2port_poll_in_busy(dev);
553         if (ret < 0)
554                 return ret;
555
556         /* Should check status before starting FLASH access sequence */
557
558         /* Wait for status information */
559         ret = c2port_poll_out_ready(dev);
560         if (ret < 0)
561                 return ret;
562
563         /* Read flash programming interface status */
564         ret = c2port_read_dr(dev, &status);
565         if (ret < 0)
566                 return ret;
567         if (status != C2PORT_COMMAND_OK)
568                 return -EBUSY;
569
570         /* Send a three-byte arming sequence to enable the device erase.
571          * If the sequence is not received correctly, the command will be
572          * ignored.
573          * Sequence is: 0xde, 0xad, 0xa5.
574          */
575         c2port_write_dr(dev, 0xde);
576         ret = c2port_poll_in_busy(dev);
577         if (ret < 0)
578                 return ret;
579         c2port_write_dr(dev, 0xad);
580         ret = c2port_poll_in_busy(dev);
581         if (ret < 0)
582                 return ret;
583         c2port_write_dr(dev, 0xa5);
584         ret = c2port_poll_in_busy(dev);
585         if (ret < 0)
586                 return ret;
587
588         ret = c2port_poll_out_ready(dev);
589         if (ret < 0)
590                 return ret;
591
592         return 0;
593 }
594
595 static ssize_t c2port_store_flash_erase(struct device *dev,
596                                 struct device_attribute *attr,
597                                 const char *buf, size_t count)
598 {
599         struct c2port_device *c2dev = dev_get_drvdata(dev);
600         int ret;
601
602         /* Check the device and flash access status */
603         if (!c2dev->access || !c2dev->flash_access)
604                 return -EBUSY;
605
606         mutex_lock(&c2dev->mutex);
607         ret = __c2port_write_flash_erase(c2dev);
608         mutex_unlock(&c2dev->mutex);
609
610         if (ret < 0) {
611                 dev_err(c2dev->dev, "cannot erase %s flash\n", c2dev->name);
612                 return ret;
613         }
614
615         return count;
616 }
617
618 static ssize_t __c2port_read_flash_data(struct c2port_device *dev,
619                                 char *buffer, loff_t offset, size_t count)
620 {
621         struct c2port_ops *ops = dev->ops;
622         u8 status, nread = 128;
623         int i, ret;
624
625         /* Check for flash end */
626         if (offset >= ops->block_size * ops->blocks_num)
627                 return 0;
628
629         if (ops->block_size * ops->blocks_num - offset < nread)
630                 nread = ops->block_size * ops->blocks_num - offset;
631         if (count < nread)
632                 nread = count;
633         if (nread == 0)
634                 return nread;
635
636         /* Target the C2 flash programming data register for C2 data register
637          * access */
638         c2port_write_ar(dev, C2PORT_FPDAT);
639
640         /* Send flash block read command */
641         c2port_write_dr(dev, C2PORT_BLOCK_READ);
642
643         /* Wait for input acknowledge */
644         ret = c2port_poll_in_busy(dev);
645         if (ret < 0)
646                 return ret;
647
648         /* Should check status before starting FLASH access sequence */
649
650         /* Wait for status information */
651         ret = c2port_poll_out_ready(dev);
652         if (ret < 0)
653                 return ret;
654
655         /* Read flash programming interface status */
656         ret = c2port_read_dr(dev, &status);
657         if (ret < 0)
658                 return ret;
659         if (status != C2PORT_COMMAND_OK)
660                 return -EBUSY;
661
662         /* Send address high byte */
663         c2port_write_dr(dev, offset >> 8);
664         ret = c2port_poll_in_busy(dev);
665         if (ret < 0)
666                 return ret;
667
668         /* Send address low byte */
669         c2port_write_dr(dev, offset & 0x00ff);
670         ret = c2port_poll_in_busy(dev);
671         if (ret < 0)
672                 return ret;
673
674         /* Send address block size */
675         c2port_write_dr(dev, nread);
676         ret = c2port_poll_in_busy(dev);
677         if (ret < 0)
678                 return ret;
679
680         /* Should check status before reading FLASH block */
681
682         /* Wait for status information */
683         ret = c2port_poll_out_ready(dev);
684         if (ret < 0)
685                 return ret;
686
687         /* Read flash programming interface status */
688         ret = c2port_read_dr(dev, &status);
689         if (ret < 0)
690                 return ret;
691         if (status != C2PORT_COMMAND_OK)
692                 return -EBUSY;
693
694         /* Read flash block */
695         for (i = 0; i < nread; i++) {
696                 ret = c2port_poll_out_ready(dev);
697                 if (ret < 0)
698                         return ret;
699
700                 ret = c2port_read_dr(dev, buffer+i);
701                 if (ret < 0)
702                         return ret;
703         }
704
705         return nread;
706 }
707
708 static ssize_t c2port_read_flash_data(struct kobject *kobj,
709                                 struct bin_attribute *attr,
710                                 char *buffer, loff_t offset, size_t count)
711 {
712         struct c2port_device *c2dev =
713                         dev_get_drvdata(container_of(kobj,
714                                                 struct device, kobj));
715         ssize_t ret;
716
717         /* Check the device and flash access status */
718         if (!c2dev->access || !c2dev->flash_access)
719                 return -EBUSY;
720
721         mutex_lock(&c2dev->mutex);
722         ret = __c2port_read_flash_data(c2dev, buffer, offset, count);
723         mutex_unlock(&c2dev->mutex);
724
725         if (ret < 0)
726                 dev_err(c2dev->dev, "cannot read %s flash\n", c2dev->name);
727
728         return ret;
729 }
730
731 static ssize_t __c2port_write_flash_data(struct c2port_device *dev,
732                                 char *buffer, loff_t offset, size_t count)
733 {
734         struct c2port_ops *ops = dev->ops;
735         u8 status, nwrite = 128;
736         int i, ret;
737
738         if (nwrite > count)
739                 nwrite = count;
740         if (ops->block_size * ops->blocks_num - offset < nwrite)
741                 nwrite = ops->block_size * ops->blocks_num - offset;
742
743         /* Check for flash end */
744         if (offset >= ops->block_size * ops->blocks_num)
745                 return -EINVAL;
746
747         /* Target the C2 flash programming data register for C2 data register
748          * access */
749         c2port_write_ar(dev, C2PORT_FPDAT);
750
751         /* Send flash block write command */
752         c2port_write_dr(dev, C2PORT_BLOCK_WRITE);
753
754         /* Wait for input acknowledge */
755         ret = c2port_poll_in_busy(dev);
756         if (ret < 0)
757                 return ret;
758
759         /* Should check status before starting FLASH access sequence */
760
761         /* Wait for status information */
762         ret = c2port_poll_out_ready(dev);
763         if (ret < 0)
764                 return ret;
765
766         /* Read flash programming interface status */
767         ret = c2port_read_dr(dev, &status);
768         if (ret < 0)
769                 return ret;
770         if (status != C2PORT_COMMAND_OK)
771                 return -EBUSY;
772
773         /* Send address high byte */
774         c2port_write_dr(dev, offset >> 8);
775         ret = c2port_poll_in_busy(dev);
776         if (ret < 0)
777                 return ret;
778
779         /* Send address low byte */
780         c2port_write_dr(dev, offset & 0x00ff);
781         ret = c2port_poll_in_busy(dev);
782         if (ret < 0)
783                 return ret;
784
785         /* Send address block size */
786         c2port_write_dr(dev, nwrite);
787         ret = c2port_poll_in_busy(dev);
788         if (ret < 0)
789                 return ret;
790
791         /* Should check status before writing FLASH block */
792
793         /* Wait for status information */
794         ret = c2port_poll_out_ready(dev);
795         if (ret < 0)
796                 return ret;
797
798         /* Read flash programming interface status */
799         ret = c2port_read_dr(dev, &status);
800         if (ret < 0)
801                 return ret;
802         if (status != C2PORT_COMMAND_OK)
803                 return -EBUSY;
804
805         /* Write flash block */
806         for (i = 0; i < nwrite; i++) {
807                 ret = c2port_write_dr(dev, *(buffer+i));
808                 if (ret < 0)
809                         return ret;
810
811                 ret = c2port_poll_in_busy(dev);
812                 if (ret < 0)
813                         return ret;
814
815         }
816
817         /* Wait for last flash write to complete */
818         ret = c2port_poll_out_ready(dev);
819         if (ret < 0)
820                 return ret;
821
822         return nwrite;
823 }
824
825 static ssize_t c2port_write_flash_data(struct kobject *kobj,
826                                 struct bin_attribute *attr,
827                                 char *buffer, loff_t offset, size_t count)
828 {
829         struct c2port_device *c2dev =
830                         dev_get_drvdata(container_of(kobj,
831                                                 struct device, kobj));
832         int ret;
833
834         /* Check the device access status */
835         if (!c2dev->access || !c2dev->flash_access)
836                 return -EBUSY;
837
838         mutex_lock(&c2dev->mutex);
839         ret = __c2port_write_flash_data(c2dev, buffer, offset, count);
840         mutex_unlock(&c2dev->mutex);
841
842         if (ret < 0)
843                 dev_err(c2dev->dev, "cannot write %s flash\n", c2dev->name);
844
845         return ret;
846 }
847
848 /*
849  * Class attributes
850  */
851
852 static struct device_attribute c2port_attrs[] = {
853         __ATTR(name, 0444, c2port_show_name, NULL),
854         __ATTR(flash_blocks_num, 0444, c2port_show_flash_blocks_num, NULL),
855         __ATTR(flash_block_size, 0444, c2port_show_flash_block_size, NULL),
856         __ATTR(flash_size, 0444, c2port_show_flash_size, NULL),
857         __ATTR(access, 0644, c2port_show_access, c2port_store_access),
858         __ATTR(reset, 0200, NULL, c2port_store_reset),
859         __ATTR(dev_id, 0444, c2port_show_dev_id, NULL),
860         __ATTR(rev_id, 0444, c2port_show_rev_id, NULL),
861
862         __ATTR(flash_access, 0644, c2port_show_flash_access,
863                                         c2port_store_flash_access),
864         __ATTR(flash_erase, 0200, NULL, c2port_store_flash_erase),
865         __ATTR_NULL,
866 };
867
868 static struct bin_attribute c2port_bin_attrs = {
869         .attr   = {
870                 .name   = "flash_data",
871                 .mode   = 0644
872         },
873         .read   = c2port_read_flash_data,
874         .write  = c2port_write_flash_data,
875         /* .size is computed at run-time */
876 };
877
878 /*
879  * Exported functions
880  */
881
882 struct c2port_device *c2port_device_register(char *name,
883                                         struct c2port_ops *ops, void *devdata)
884 {
885         struct c2port_device *c2dev;
886         int id, ret;
887
888         if (unlikely(!ops) || unlikely(!ops->access) || \
889                 unlikely(!ops->c2d_dir) || unlikely(!ops->c2ck_set) || \
890                 unlikely(!ops->c2d_get) || unlikely(!ops->c2d_set))
891                 return ERR_PTR(-EINVAL);
892
893         c2dev = kmalloc(sizeof(struct c2port_device), GFP_KERNEL);
894         if (unlikely(!c2dev))
895                 return ERR_PTR(-ENOMEM);
896
897         ret = idr_pre_get(&c2port_idr, GFP_KERNEL);
898         if (!ret) {
899                 ret = -ENOMEM;
900                 goto error_idr_get_new;
901         }
902
903         spin_lock_irq(&c2port_idr_lock);
904         ret = idr_get_new(&c2port_idr, c2dev, &id);
905         spin_unlock_irq(&c2port_idr_lock);
906
907         if (ret < 0)
908                 goto error_idr_get_new;
909         c2dev->id = id;
910
911         c2dev->dev = device_create(c2port_class, NULL, 0, c2dev,
912                                         "c2port%d", id);
913         if (unlikely(!c2dev->dev)) {
914                 ret = -ENOMEM;
915                 goto error_device_create;
916         }
917         dev_set_drvdata(c2dev->dev, c2dev);
918
919         strncpy(c2dev->name, name, C2PORT_NAME_LEN);
920         c2dev->ops = ops;
921         mutex_init(&c2dev->mutex);
922
923         /* Create binary file */
924         c2port_bin_attrs.size = ops->blocks_num * ops->block_size;
925         ret = device_create_bin_file(c2dev->dev, &c2port_bin_attrs);
926         if (unlikely(ret))
927                 goto error_device_create_bin_file;
928
929         /* By default C2 port access is off */
930         c2dev->access = c2dev->flash_access = 0;
931         ops->access(c2dev, 0);
932
933         dev_info(c2dev->dev, "C2 port %s added\n", name);
934         dev_info(c2dev->dev, "%s flash has %d blocks x %d bytes "
935                                 "(%d bytes total)\n",
936                                 name, ops->blocks_num, ops->block_size,
937                                 ops->blocks_num * ops->block_size);
938
939         return c2dev;
940
941 error_device_create_bin_file:
942         device_destroy(c2port_class, 0);
943
944 error_device_create:
945         spin_lock_irq(&c2port_idr_lock);
946         idr_remove(&c2port_idr, id);
947         spin_unlock_irq(&c2port_idr_lock);
948
949 error_idr_get_new:
950         kfree(c2dev);
951
952         return ERR_PTR(ret);
953 }
954 EXPORT_SYMBOL(c2port_device_register);
955
956 void c2port_device_unregister(struct c2port_device *c2dev)
957 {
958         if (!c2dev)
959                 return;
960
961         dev_info(c2dev->dev, "C2 port %s removed\n", c2dev->name);
962
963         device_remove_bin_file(c2dev->dev, &c2port_bin_attrs);
964         spin_lock_irq(&c2port_idr_lock);
965         idr_remove(&c2port_idr, c2dev->id);
966         spin_unlock_irq(&c2port_idr_lock);
967
968         device_destroy(c2port_class, c2dev->id);
969
970         kfree(c2dev);
971 }
972 EXPORT_SYMBOL(c2port_device_unregister);
973
974 /*
975  * Module stuff
976  */
977
978 static int __init c2port_init(void)
979 {
980         printk(KERN_INFO "Silicon Labs C2 port support v. " DRIVER_VERSION
981                 " - (C) 2007 Rodolfo Giometti\n");
982
983         c2port_class = class_create(THIS_MODULE, "c2port");
984         if (!c2port_class) {
985                 printk(KERN_ERR "c2port: failed to allocate class\n");
986                 return -ENOMEM;
987         }
988         c2port_class->dev_attrs = c2port_attrs;
989
990         return 0;
991 }
992
993 static void __exit c2port_exit(void)
994 {
995         class_destroy(c2port_class);
996 }
997
998 module_init(c2port_init);
999 module_exit(c2port_exit);
1000
1001 MODULE_AUTHOR("Rodolfo Giometti <giometti@linux.it>");
1002 MODULE_DESCRIPTION("Silicon Labs C2 port support v. " DRIVER_VERSION);
1003 MODULE_LICENSE("GPL");