]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - drivers/mfd/ab8500-debugfs.c
projects / mirror_ubuntu-artful-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge remote-tracking branch 'airlied/drm-next' into topic/drm-misc
[mirror_ubuntu-artful-kernel.git] / drivers / mfd / ab8500-debugfs.c
1 /*
2 * Copyright (C) ST-Ericsson SA 2010
3 *
4 * Author: Mattias Wallin <mattias.wallin@stericsson.com> for ST-Ericsson.
5 * License Terms: GNU General Public License v2
6 */
7 /*
8 * AB8500 register access
9 * ======================
10 *
11 * read:
12 * # echo BANK > <debugfs>/ab8500/register-bank
13 * # echo ADDR > <debugfs>/ab8500/register-address
14 * # cat <debugfs>/ab8500/register-value
15 *
16 * write:
17 * # echo BANK > <debugfs>/ab8500/register-bank
18 * # echo ADDR > <debugfs>/ab8500/register-address
19 * # echo VALUE > <debugfs>/ab8500/register-value
20 *
21 * read all registers from a bank:
22 * # echo BANK > <debugfs>/ab8500/register-bank
23 * # cat <debugfs>/ab8500/all-bank-register
24 *
25 * BANK target AB8500 register bank
26 * ADDR target AB8500 register address
27 * VALUE decimal or 0x-prefixed hexadecimal
28 *
29 *
30 * User Space notification on AB8500 IRQ
31 * =====================================
32 *
33 * Allows user space entity to be notified when target AB8500 IRQ occurs.
34 * When subscribed, a sysfs entry is created in ab8500.i2c platform device.
35 * One can pool this file to get target IRQ occurence information.
36 *
37 * subscribe to an AB8500 IRQ:
38 * # echo IRQ > <debugfs>/ab8500/irq-subscribe
39 *
40 * unsubscribe from an AB8500 IRQ:
41 * # echo IRQ > <debugfs>/ab8500/irq-unsubscribe
42 *
43 *
44 * AB8500 register formated read/write access
45 * ==========================================
46 *
47 * Read: read data, data>>SHIFT, data&=MASK, output data
48 * [0xABCDEF98] shift=12 mask=0xFFF => 0x00000CDE
49 * Write: read data, data &= ~(MASK<<SHIFT), data |= (VALUE<<SHIFT), write data
50 * [0xABCDEF98] shift=12 mask=0xFFF value=0x123 => [0xAB123F98]
51 *
52 * Usage:
53 * # echo "CMD [OPTIONS] BANK ADRESS [VALUE]" > $debugfs/ab8500/hwreg
54 *
55 * CMD read read access
56 * write write access
57 *
58 * BANK target reg bank
59 * ADDRESS target reg address
60 * VALUE (write) value to be updated
61 *
62 * OPTIONS
63 * -d|-dec (read) output in decimal
64 * -h|-hexa (read) output in 0x-hexa (default)
65 * -l|-w|-b 32bit (default), 16bit or 8bit reg access
66 * -m|-mask MASK 0x-hexa mask (default 0xFFFFFFFF)
67 * -s|-shift SHIFT bit shift value (read:left, write:right)
68 * -o|-offset OFFSET address offset to add to ADDRESS value
69 *
70 * Warning: bit shift operation is applied to bit-mask.
71 * Warning: bit shift direction depends on read or right command.
72 */
73
74 #include <linux/seq_file.h>
75 #include <linux/uaccess.h>
76 #include <linux/fs.h>
77 #include <linux/module.h>
78 #include <linux/debugfs.h>
79 #include <linux/platform_device.h>
80 #include <linux/interrupt.h>
81 #include <linux/kobject.h>
82 #include <linux/slab.h>
83 #include <linux/irq.h>
84
85 #include <linux/mfd/abx500.h>
86 #include <linux/mfd/abx500/ab8500.h>
87 #include <linux/mfd/abx500/ab8500-gpadc.h>
88
89 #ifdef CONFIG_DEBUG_FS
90 #include <linux/string.h>
91 #include <linux/ctype.h>
92 #endif
93
94 static u32 debug_bank;
95 static u32 debug_address;
96
97 static int irq_ab8500;
98 static int irq_first;
99 static int irq_last;
100 static u32 *irq_count;
101 static int num_irqs;
102
103 static struct device_attribute **dev_attr;
104 static char **event_name;
105
106 static u8 avg_sample = SAMPLE_16;
107 static u8 trig_edge = RISING_EDGE;
108 static u8 conv_type = ADC_SW;
109 static u8 trig_timer;
110
111 /**
112 * struct ab8500_reg_range
113 * @first: the first address of the range
114 * @last: the last address of the range
115 * @perm: access permissions for the range
116 */
117 struct ab8500_reg_range {
118 u8 first;
119 u8 last;
120 u8 perm;
121 };
122
123 /**
124 * struct ab8500_prcmu_ranges
125 * @num_ranges: the number of ranges in the list
126 * @bankid: bank identifier
127 * @range: the list of register ranges
128 */
129 struct ab8500_prcmu_ranges {
130 u8 num_ranges;
131 u8 bankid;
132 const struct ab8500_reg_range *range;
133 };
134
135 /* hwreg- "mask" and "shift" entries ressources */
136 struct hwreg_cfg {
137 u32 bank; /* target bank */
138 unsigned long addr; /* target address */
139 uint fmt; /* format */
140 unsigned long mask; /* read/write mask, applied before any bit shift */
141 long shift; /* bit shift (read:right shift, write:left shift */
142 };
143 /* fmt bit #0: 0=hexa, 1=dec */
144 #define REG_FMT_DEC(c) ((c)->fmt & 0x1)
145 #define REG_FMT_HEX(c) (!REG_FMT_DEC(c))
146
147 static struct hwreg_cfg hwreg_cfg = {
148 .addr = 0, /* default: invalid phys addr */
149 .fmt = 0, /* default: 32bit access, hex output */
150 .mask = 0xFFFFFFFF, /* default: no mask */
151 .shift = 0, /* default: no bit shift */
152 };
153
154 #define AB8500_NAME_STRING "ab8500"
155 #define AB8500_ADC_NAME_STRING "gpadc"
156 #define AB8500_NUM_BANKS AB8500_DEBUG_FIELD_LAST
157
158 #define AB8500_REV_REG 0x80
159
160 static struct ab8500_prcmu_ranges *debug_ranges;
161
162 static struct ab8500_prcmu_ranges ab8500_debug_ranges[AB8500_NUM_BANKS] = {
163 [AB8500_M_FSM_RANK] = {
164 .num_ranges = 0,
165 .range = NULL,
166 },
167 [AB8500_SYS_CTRL1_BLOCK] = {
168 .num_ranges = 3,
169 .range = (struct ab8500_reg_range[]) {
170 {
171 .first = 0x00,
172 .last = 0x02,
173 },
174 {
175 .first = 0x42,
176 .last = 0x42,
177 },
178 {
179 .first = 0x80,
180 .last = 0x81,
181 },
182 },
183 },
184 [AB8500_SYS_CTRL2_BLOCK] = {
185 .num_ranges = 4,
186 .range = (struct ab8500_reg_range[]) {
187 {
188 .first = 0x00,
189 .last = 0x0D,
190 },
191 {
192 .first = 0x0F,
193 .last = 0x17,
194 },
195 {
196 .first = 0x30,
197 .last = 0x30,
198 },
199 {
200 .first = 0x32,
201 .last = 0x33,
202 },
203 },
204 },
205 [AB8500_REGU_CTRL1] = {
206 .num_ranges = 3,
207 .range = (struct ab8500_reg_range[]) {
208 {
209 .first = 0x00,
210 .last = 0x00,
211 },
212 {
213 .first = 0x03,
214 .last = 0x10,
215 },
216 {
217 .first = 0x80,
218 .last = 0x84,
219 },
220 },
221 },
222 [AB8500_REGU_CTRL2] = {
223 .num_ranges = 5,
224 .range = (struct ab8500_reg_range[]) {
225 {
226 .first = 0x00,
227 .last = 0x15,
228 },
229 {
230 .first = 0x17,
231 .last = 0x19,
232 },
233 {
234 .first = 0x1B,
235 .last = 0x1D,
236 },
237 {
238 .first = 0x1F,
239 .last = 0x22,
240 },
241 {
242 .first = 0x40,
243 .last = 0x44,
244 },
245 /*
246 * 0x80-0x8B are SIM registers and should
247 * not be accessed from here
248 */
249 },
250 },
251 [AB8500_USB] = {
252 .num_ranges = 2,
253 .range = (struct ab8500_reg_range[]) {
254 {
255 .first = 0x80,
256 .last = 0x83,
257 },
258 {
259 .first = 0x87,
260 .last = 0x8A,
261 },
262 },
263 },
264 [AB8500_TVOUT] = {
265 .num_ranges = 9,
266 .range = (struct ab8500_reg_range[]) {
267 {
268 .first = 0x00,
269 .last = 0x12,
270 },
271 {
272 .first = 0x15,
273 .last = 0x17,
274 },
275 {
276 .first = 0x19,
277 .last = 0x21,
278 },
279 {
280 .first = 0x27,
281 .last = 0x2C,
282 },
283 {
284 .first = 0x41,
285 .last = 0x41,
286 },
287 {
288 .first = 0x45,
289 .last = 0x5B,
290 },
291 {
292 .first = 0x5D,
293 .last = 0x5D,
294 },
295 {
296 .first = 0x69,
297 .last = 0x69,
298 },
299 {
300 .first = 0x80,
301 .last = 0x81,
302 },
303 },
304 },
305 [AB8500_DBI] = {
306 .num_ranges = 0,
307 .range = NULL,
308 },
309 [AB8500_ECI_AV_ACC] = {
310 .num_ranges = 1,
311 .range = (struct ab8500_reg_range[]) {
312 {
313 .first = 0x80,
314 .last = 0x82,
315 },
316 },
317 },
318 [AB8500_RESERVED] = {
319 .num_ranges = 0,
320 .range = NULL,
321 },
322 [AB8500_GPADC] = {
323 .num_ranges = 1,
324 .range = (struct ab8500_reg_range[]) {
325 {
326 .first = 0x00,
327 .last = 0x08,
328 },
329 },
330 },
331 [AB8500_CHARGER] = {
332 .num_ranges = 9,
333 .range = (struct ab8500_reg_range[]) {
334 {
335 .first = 0x00,
336 .last = 0x03,
337 },
338 {
339 .first = 0x05,
340 .last = 0x05,
341 },
342 {
343 .first = 0x40,
344 .last = 0x40,
345 },
346 {
347 .first = 0x42,
348 .last = 0x42,
349 },
350 {
351 .first = 0x44,
352 .last = 0x44,
353 },
354 {
355 .first = 0x50,
356 .last = 0x55,
357 },
358 {
359 .first = 0x80,
360 .last = 0x82,
361 },
362 {
363 .first = 0xC0,
364 .last = 0xC2,
365 },
366 {
367 .first = 0xf5,
368 .last = 0xf6,
369 },
370 },
371 },
372 [AB8500_GAS_GAUGE] = {
373 .num_ranges = 3,
374 .range = (struct ab8500_reg_range[]) {
375 {
376 .first = 0x00,
377 .last = 0x00,
378 },
379 {
380 .first = 0x07,
381 .last = 0x0A,
382 },
383 {
384 .first = 0x10,
385 .last = 0x14,
386 },
387 },
388 },
389 [AB8500_AUDIO] = {
390 .num_ranges = 1,
391 .range = (struct ab8500_reg_range[]) {
392 {
393 .first = 0x00,
394 .last = 0x6F,
395 },
396 },
397 },
398 [AB8500_INTERRUPT] = {
399 .num_ranges = 0,
400 .range = NULL,
401 },
402 [AB8500_RTC] = {
403 .num_ranges = 1,
404 .range = (struct ab8500_reg_range[]) {
405 {
406 .first = 0x00,
407 .last = 0x0F,
408 },
409 },
410 },
411 [AB8500_MISC] = {
412 .num_ranges = 8,
413 .range = (struct ab8500_reg_range[]) {
414 {
415 .first = 0x00,
416 .last = 0x05,
417 },
418 {
419 .first = 0x10,
420 .last = 0x15,
421 },
422 {
423 .first = 0x20,
424 .last = 0x25,
425 },
426 {
427 .first = 0x30,
428 .last = 0x35,
429 },
430 {
431 .first = 0x40,
432 .last = 0x45,
433 },
434 {
435 .first = 0x50,
436 .last = 0x50,
437 },
438 {
439 .first = 0x60,
440 .last = 0x67,
441 },
442 {
443 .first = 0x80,
444 .last = 0x80,
445 },
446 },
447 },
448 [AB8500_DEVELOPMENT] = {
449 .num_ranges = 1,
450 .range = (struct ab8500_reg_range[]) {
451 {
452 .first = 0x00,
453 .last = 0x00,
454 },
455 },
456 },
457 [AB8500_DEBUG] = {
458 .num_ranges = 1,
459 .range = (struct ab8500_reg_range[]) {
460 {
461 .first = 0x05,
462 .last = 0x07,
463 },
464 },
465 },
466 [AB8500_PROD_TEST] = {
467 .num_ranges = 0,
468 .range = NULL,
469 },
470 [AB8500_STE_TEST] = {
471 .num_ranges = 0,
472 .range = NULL,
473 },
474 [AB8500_OTP_EMUL] = {
475 .num_ranges = 1,
476 .range = (struct ab8500_reg_range[]) {
477 {
478 .first = 0x01,
479 .last = 0x0F,
480 },
481 },
482 },
483 };
484
485 static struct ab8500_prcmu_ranges ab8505_debug_ranges[AB8500_NUM_BANKS] = {
486 [0x0] = {
487 .num_ranges = 0,
488 .range = NULL,
489 },
490 [AB8500_SYS_CTRL1_BLOCK] = {
491 .num_ranges = 5,
492 .range = (struct ab8500_reg_range[]) {
493 {
494 .first = 0x00,
495 .last = 0x04,
496 },
497 {
498 .first = 0x42,
499 .last = 0x42,
500 },
501 {
502 .first = 0x52,
503 .last = 0x52,
504 },
505 {
506 .first = 0x54,
507 .last = 0x57,
508 },
509 {
510 .first = 0x80,
511 .last = 0x83,
512 },
513 },
514 },
515 [AB8500_SYS_CTRL2_BLOCK] = {
516 .num_ranges = 5,
517 .range = (struct ab8500_reg_range[]) {
518 {
519 .first = 0x00,
520 .last = 0x0D,
521 },
522 {
523 .first = 0x0F,
524 .last = 0x17,
525 },
526 {
527 .first = 0x20,
528 .last = 0x20,
529 },
530 {
531 .first = 0x30,
532 .last = 0x30,
533 },
534 {
535 .first = 0x32,
536 .last = 0x3A,
537 },
538 },
539 },
540 [AB8500_REGU_CTRL1] = {
541 .num_ranges = 3,
542 .range = (struct ab8500_reg_range[]) {
543 {
544 .first = 0x00,
545 .last = 0x00,
546 },
547 {
548 .first = 0x03,
549 .last = 0x11,
550 },
551 {
552 .first = 0x80,
553 .last = 0x86,
554 },
555 },
556 },
557 [AB8500_REGU_CTRL2] = {
558 .num_ranges = 6,
559 .range = (struct ab8500_reg_range[]) {
560 {
561 .first = 0x00,
562 .last = 0x06,
563 },
564 {
565 .first = 0x08,
566 .last = 0x15,
567 },
568 {
569 .first = 0x17,
570 .last = 0x19,
571 },
572 {
573 .first = 0x1B,
574 .last = 0x1D,
575 },
576 {
577 .first = 0x1F,
578 .last = 0x30,
579 },
580 {
581 .first = 0x40,
582 .last = 0x48,
583 },
584 /*
585 * 0x80-0x8B are SIM registers and should
586 * not be accessed from here
587 */
588 },
589 },
590 [AB8500_USB] = {
591 .num_ranges = 3,
592 .range = (struct ab8500_reg_range[]) {
593 {
594 .first = 0x80,
595 .last = 0x83,
596 },
597 {
598 .first = 0x87,
599 .last = 0x8A,
600 },
601 {
602 .first = 0x91,
603 .last = 0x94,
604 },
605 },
606 },
607 [AB8500_TVOUT] = {
608 .num_ranges = 0,
609 .range = NULL,
610 },
611 [AB8500_DBI] = {
612 .num_ranges = 0,
613 .range = NULL,
614 },
615 [AB8500_ECI_AV_ACC] = {
616 .num_ranges = 1,
617 .range = (struct ab8500_reg_range[]) {
618 {
619 .first = 0x80,
620 .last = 0x82,
621 },
622 },
623 },
624 [AB8500_RESERVED] = {
625 .num_ranges = 0,
626 .range = NULL,
627 },
628 [AB8500_GPADC] = {
629 .num_ranges = 1,
630 .range = (struct ab8500_reg_range[]) {
631 {
632 .first = 0x00,
633 .last = 0x08,
634 },
635 },
636 },
637 [AB8500_CHARGER] = {
638 .num_ranges = 9,
639 .range = (struct ab8500_reg_range[]) {
640 {
641 .first = 0x02,
642 .last = 0x03,
643 },
644 {
645 .first = 0x05,
646 .last = 0x05,
647 },
648 {
649 .first = 0x40,
650 .last = 0x44,
651 },
652 {
653 .first = 0x50,
654 .last = 0x57,
655 },
656 {
657 .first = 0x60,
658 .last = 0x60,
659 },
660 {
661 .first = 0xA0,
662 .last = 0xA7,
663 },
664 {
665 .first = 0xAF,
666 .last = 0xB2,
667 },
668 {
669 .first = 0xC0,
670 .last = 0xC2,
671 },
672 {
673 .first = 0xF5,
674 .last = 0xF5,
675 },
676 },
677 },
678 [AB8500_GAS_GAUGE] = {
679 .num_ranges = 3,
680 .range = (struct ab8500_reg_range[]) {
681 {
682 .first = 0x00,
683 .last = 0x00,
684 },
685 {
686 .first = 0x07,
687 .last = 0x0A,
688 },
689 {
690 .first = 0x10,
691 .last = 0x14,
692 },
693 },
694 },
695 [AB8500_AUDIO] = {
696 .num_ranges = 1,
697 .range = (struct ab8500_reg_range[]) {
698 {
699 .first = 0x00,
700 .last = 0x83,
701 },
702 },
703 },
704 [AB8500_INTERRUPT] = {
705 .num_ranges = 11,
706 .range = (struct ab8500_reg_range[]) {
707 {
708 .first = 0x00,
709 .last = 0x04,
710 },
711 {
712 .first = 0x06,
713 .last = 0x07,
714 },
715 {
716 .first = 0x09,
717 .last = 0x09,
718 },
719 {
720 .first = 0x0B,
721 .last = 0x0C,
722 },
723 {
724 .first = 0x12,
725 .last = 0x15,
726 },
727 {
728 .first = 0x18,
729 .last = 0x18,
730 },
731 /* Latch registers should not be read here */
732 {
733 .first = 0x40,
734 .last = 0x44,
735 },
736 {
737 .first = 0x46,
738 .last = 0x49,
739 },
740 {
741 .first = 0x4B,
742 .last = 0x4D,
743 },
744 {
745 .first = 0x52,
746 .last = 0x55,
747 },
748 {
749 .first = 0x58,
750 .last = 0x58,
751 },
752 /* LatchHier registers should not be read here */
753 },
754 },
755 [AB8500_RTC] = {
756 .num_ranges = 2,
757 .range = (struct ab8500_reg_range[]) {
758 {
759 .first = 0x00,
760 .last = 0x14,
761 },
762 {
763 .first = 0x16,
764 .last = 0x17,
765 },
766 },
767 },
768 [AB8500_MISC] = {
769 .num_ranges = 8,
770 .range = (struct ab8500_reg_range[]) {
771 {
772 .first = 0x00,
773 .last = 0x06,
774 },
775 {
776 .first = 0x10,
777 .last = 0x16,
778 },
779 {
780 .first = 0x20,
781 .last = 0x26,
782 },
783 {
784 .first = 0x30,
785 .last = 0x36,
786 },
787 {
788 .first = 0x40,
789 .last = 0x46,
790 },
791 {
792 .first = 0x50,
793 .last = 0x50,
794 },
795 {
796 .first = 0x60,
797 .last = 0x6B,
798 },
799 {
800 .first = 0x80,
801 .last = 0x82,
802 },
803 },
804 },
805 [AB8500_DEVELOPMENT] = {
806 .num_ranges = 2,
807 .range = (struct ab8500_reg_range[]) {
808 {
809 .first = 0x00,
810 .last = 0x00,
811 },
812 {
813 .first = 0x05,
814 .last = 0x05,
815 },
816 },
817 },
818 [AB8500_DEBUG] = {
819 .num_ranges = 1,
820 .range = (struct ab8500_reg_range[]) {
821 {
822 .first = 0x05,
823 .last = 0x07,
824 },
825 },
826 },
827 [AB8500_PROD_TEST] = {
828 .num_ranges = 0,
829 .range = NULL,
830 },
831 [AB8500_STE_TEST] = {
832 .num_ranges = 0,
833 .range = NULL,
834 },
835 [AB8500_OTP_EMUL] = {
836 .num_ranges = 1,
837 .range = (struct ab8500_reg_range[]) {
838 {
839 .first = 0x01,
840 .last = 0x15,
841 },
842 },
843 },
844 };
845
846 static struct ab8500_prcmu_ranges ab8540_debug_ranges[AB8500_NUM_BANKS] = {
847 [AB8500_M_FSM_RANK] = {
848 .num_ranges = 1,
849 .range = (struct ab8500_reg_range[]) {
850 {
851 .first = 0x00,
852 .last = 0x0B,
853 },
854 },
855 },
856 [AB8500_SYS_CTRL1_BLOCK] = {
857 .num_ranges = 6,
858 .range = (struct ab8500_reg_range[]) {
859 {
860 .first = 0x00,
861 .last = 0x04,
862 },
863 {
864 .first = 0x42,
865 .last = 0x42,
866 },
867 {
868 .first = 0x50,
869 .last = 0x54,
870 },
871 {
872 .first = 0x57,
873 .last = 0x57,
874 },
875 {
876 .first = 0x80,
877 .last = 0x83,
878 },
879 {
880 .first = 0x90,
881 .last = 0x90,
882 },
883 },
884 },
885 [AB8500_SYS_CTRL2_BLOCK] = {
886 .num_ranges = 5,
887 .range = (struct ab8500_reg_range[]) {
888 {
889 .first = 0x00,
890 .last = 0x0D,
891 },
892 {
893 .first = 0x0F,
894 .last = 0x10,
895 },
896 {
897 .first = 0x20,
898 .last = 0x21,
899 },
900 {
901 .first = 0x32,
902 .last = 0x3C,
903 },
904 {
905 .first = 0x40,
906 .last = 0x42,
907 },
908 },
909 },
910 [AB8500_REGU_CTRL1] = {
911 .num_ranges = 4,
912 .range = (struct ab8500_reg_range[]) {
913 {
914 .first = 0x03,
915 .last = 0x15,
916 },
917 {
918 .first = 0x20,
919 .last = 0x20,
920 },
921 {
922 .first = 0x80,
923 .last = 0x85,
924 },
925 {
926 .first = 0x87,
927 .last = 0x88,
928 },
929 },
930 },
931 [AB8500_REGU_CTRL2] = {
932 .num_ranges = 8,
933 .range = (struct ab8500_reg_range[]) {
934 {
935 .first = 0x00,
936 .last = 0x06,
937 },
938 {
939 .first = 0x08,
940 .last = 0x15,
941 },
942 {
943 .first = 0x17,
944 .last = 0x19,
945 },
946 {
947 .first = 0x1B,
948 .last = 0x1D,
949 },
950 {
951 .first = 0x1F,
952 .last = 0x2F,
953 },
954 {
955 .first = 0x31,
956 .last = 0x3A,
957 },
958 {
959 .first = 0x43,
960 .last = 0x44,
961 },
962 {
963 .first = 0x48,
964 .last = 0x49,
965 },
966 },
967 },
968 [AB8500_USB] = {
969 .num_ranges = 3,
970 .range = (struct ab8500_reg_range[]) {
971 {
972 .first = 0x80,
973 .last = 0x83,
974 },
975 {
976 .first = 0x87,
977 .last = 0x8A,
978 },
979 {
980 .first = 0x91,
981 .last = 0x94,
982 },
983 },
984 },
985 [AB8500_TVOUT] = {
986 .num_ranges = 0,
987 .range = NULL
988 },
989 [AB8500_DBI] = {
990 .num_ranges = 4,
991 .range = (struct ab8500_reg_range[]) {
992 {
993 .first = 0x00,
994 .last = 0x07,
995 },
996 {
997 .first = 0x10,
998 .last = 0x11,
999 },
1000 {
1001 .first = 0x20,
1002 .last = 0x21,
1003 },
1004 {
1005 .first = 0x30,
1006 .last = 0x43,
1007 },
1008 },
1009 },
1010 [AB8500_ECI_AV_ACC] = {
1011 .num_ranges = 2,
1012 .range = (struct ab8500_reg_range[]) {
1013 {
1014 .first = 0x00,
1015 .last = 0x03,
1016 },
1017 {
1018 .first = 0x80,
1019 .last = 0x82,
1020 },
1021 },
1022 },
1023 [AB8500_RESERVED] = {
1024 .num_ranges = 0,
1025 .range = NULL,
1026 },
1027 [AB8500_GPADC] = {
1028 .num_ranges = 4,
1029 .range = (struct ab8500_reg_range[]) {
1030 {
1031 .first = 0x00,
1032 .last = 0x01,
1033 },
1034 {
1035 .first = 0x04,
1036 .last = 0x06,
1037 },
1038 {
1039 .first = 0x09,
1040 .last = 0x0A,
1041 },
1042 {
1043 .first = 0x10,
1044 .last = 0x14,
1045 },
1046 },
1047 },
1048 [AB8500_CHARGER] = {
1049 .num_ranges = 10,
1050 .range = (struct ab8500_reg_range[]) {
1051 {
1052 .first = 0x00,
1053 .last = 0x00,
1054 },
1055 {
1056 .first = 0x02,
1057 .last = 0x05,
1058 },
1059 {
1060 .first = 0x40,
1061 .last = 0x44,
1062 },
1063 {
1064 .first = 0x50,
1065 .last = 0x57,
1066 },
1067 {
1068 .first = 0x60,
1069 .last = 0x60,
1070 },
1071 {
1072 .first = 0x70,
1073 .last = 0x70,
1074 },
1075 {
1076 .first = 0xA0,
1077 .last = 0xA9,
1078 },
1079 {
1080 .first = 0xAF,
1081 .last = 0xB2,
1082 },
1083 {
1084 .first = 0xC0,
1085 .last = 0xC6,
1086 },
1087 {
1088 .first = 0xF5,
1089 .last = 0xF5,
1090 },
1091 },
1092 },
1093 [AB8500_GAS_GAUGE] = {
1094 .num_ranges = 3,
1095 .range = (struct ab8500_reg_range[]) {
1096 {
1097 .first = 0x00,
1098 .last = 0x00,
1099 },
1100 {
1101 .first = 0x07,
1102 .last = 0x0A,
1103 },
1104 {
1105 .first = 0x10,
1106 .last = 0x14,
1107 },
1108 },
1109 },
1110 [AB8500_AUDIO] = {
1111 .num_ranges = 1,
1112 .range = (struct ab8500_reg_range[]) {
1113 {
1114 .first = 0x00,
1115 .last = 0x9f,
1116 },
1117 },
1118 },
1119 [AB8500_INTERRUPT] = {
1120 .num_ranges = 6,
1121 .range = (struct ab8500_reg_range[]) {
1122 {
1123 .first = 0x00,
1124 .last = 0x05,
1125 },
1126 {
1127 .first = 0x0B,
1128 .last = 0x0D,
1129 },
1130 {
1131 .first = 0x12,
1132 .last = 0x20,
1133 },
1134 /* Latch registers should not be read here */
1135 {
1136 .first = 0x40,
1137 .last = 0x45,
1138 },
1139 {
1140 .first = 0x4B,
1141 .last = 0x4D,
1142 },
1143 {
1144 .first = 0x52,
1145 .last = 0x60,
1146 },
1147 /* LatchHier registers should not be read here */
1148 },
1149 },
1150 [AB8500_RTC] = {
1151 .num_ranges = 3,
1152 .range = (struct ab8500_reg_range[]) {
1153 {
1154 .first = 0x00,
1155 .last = 0x07,
1156 },
1157 {
1158 .first = 0x0B,
1159 .last = 0x18,
1160 },
1161 {
1162 .first = 0x20,
1163 .last = 0x25,
1164 },
1165 },
1166 },
1167 [AB8500_MISC] = {
1168 .num_ranges = 9,
1169 .range = (struct ab8500_reg_range[]) {
1170 {
1171 .first = 0x00,
1172 .last = 0x06,
1173 },
1174 {
1175 .first = 0x10,
1176 .last = 0x16,
1177 },
1178 {
1179 .first = 0x20,
1180 .last = 0x26,
1181 },
1182 {
1183 .first = 0x30,
1184 .last = 0x36,
1185 },
1186 {
1187 .first = 0x40,
1188 .last = 0x49,
1189 },
1190 {
1191 .first = 0x50,
1192 .last = 0x50,
1193 },
1194 {
1195 .first = 0x60,
1196 .last = 0x6B,
1197 },
1198 {
1199 .first = 0x70,
1200 .last = 0x74,
1201 },
1202 {
1203 .first = 0x80,
1204 .last = 0x82,
1205 },
1206 },
1207 },
1208 [AB8500_DEVELOPMENT] = {
1209 .num_ranges = 3,
1210 .range = (struct ab8500_reg_range[]) {
1211 {
1212 .first = 0x00,
1213 .last = 0x01,
1214 },
1215 {
1216 .first = 0x06,
1217 .last = 0x06,
1218 },
1219 {
1220 .first = 0x10,
1221 .last = 0x21,
1222 },
1223 },
1224 },
1225 [AB8500_DEBUG] = {
1226 .num_ranges = 3,
1227 .range = (struct ab8500_reg_range[]) {
1228 {
1229 .first = 0x01,
1230 .last = 0x0C,
1231 },
1232 {
1233 .first = 0x0E,
1234 .last = 0x11,
1235 },
1236 {
1237 .first = 0x80,
1238 .last = 0x81,
1239 },
1240 },
1241 },
1242 [AB8500_PROD_TEST] = {
1243 .num_ranges = 0,
1244 .range = NULL,
1245 },
1246 [AB8500_STE_TEST] = {
1247 .num_ranges = 0,
1248 .range = NULL,
1249 },
1250 [AB8500_OTP_EMUL] = {
1251 .num_ranges = 1,
1252 .range = (struct ab8500_reg_range[]) {
1253 {
1254 .first = 0x00,
1255 .last = 0x3F,
1256 },
1257 },
1258 },
1259 };
1260
1261
1262 static irqreturn_t ab8500_debug_handler(int irq, void *data)
1263 {
1264 char buf[16];
1265 struct kobject *kobj = (struct kobject *)data;
1266 unsigned int irq_abb = irq - irq_first;
1267
1268 if (irq_abb < num_irqs)
1269 irq_count[irq_abb]++;
1270 /*
1271 * This makes it possible to use poll for events (POLLPRI | POLLERR)
1272 * from userspace on sysfs file named <irq-nr>
1273 */
1274 sprintf(buf, "%d", irq);
1275 sysfs_notify(kobj, NULL, buf);
1276
1277 return IRQ_HANDLED;
1278 }
1279
1280 /* Prints to seq_file or log_buf */
1281 static int ab8500_registers_print(struct device *dev, u32 bank,
1282 struct seq_file *s)
1283 {
1284 unsigned int i;
1285
1286 for (i = 0; i < debug_ranges[bank].num_ranges; i++) {
1287 u32 reg;
1288
1289 for (reg = debug_ranges[bank].range[i].first;
1290 reg <= debug_ranges[bank].range[i].last;
1291 reg++) {
1292 u8 value;
1293 int err;
1294
1295 err = abx500_get_register_interruptible(dev,
1296 (u8)bank, (u8)reg, &value);
1297 if (err < 0) {
1298 dev_err(dev, "ab->read fail %d\n", err);
1299 return err;
1300 }
1301
1302 if (s) {
1303 seq_printf(s, " [0x%02X/0x%02X]: 0x%02X\n",
1304 bank, reg, value);
1305 /*
1306 * Error is not returned here since
1307 * the output is wanted in any case
1308 */
1309 if (seq_has_overflowed(s))
1310 return 0;
1311 } else {
1312 dev_info(dev, " [0x%02X/0x%02X]: 0x%02X\n",
1313 bank, reg, value);
1314 }
1315 }
1316 }
1317
1318 return 0;
1319 }
1320
1321 static int ab8500_print_bank_registers(struct seq_file *s, void *p)
1322 {
1323 struct device *dev = s->private;
1324 u32 bank = debug_bank;
1325
1326 seq_puts(s, AB8500_NAME_STRING " register values:\n");
1327
1328 seq_printf(s, " bank 0x%02X:\n", bank);
1329
1330 return ab8500_registers_print(dev, bank, s);
1331 }
1332
1333 static int ab8500_registers_open(struct inode *inode, struct file *file)
1334 {
1335 return single_open(file, ab8500_print_bank_registers, inode->i_private);
1336 }
1337
1338 static const struct file_operations ab8500_registers_fops = {
1339 .open = ab8500_registers_open,
1340 .read = seq_read,
1341 .llseek = seq_lseek,
1342 .release = single_release,
1343 .owner = THIS_MODULE,
1344 };
1345
1346 static int ab8500_print_all_banks(struct seq_file *s, void *p)
1347 {
1348 struct device *dev = s->private;
1349 unsigned int i;
1350
1351 seq_puts(s, AB8500_NAME_STRING " register values:\n");
1352
1353 for (i = 0; i < AB8500_NUM_BANKS; i++) {
1354 int err;
1355
1356 seq_printf(s, " bank 0x%02X:\n", i);
1357 err = ab8500_registers_print(dev, i, s);
1358 if (err)
1359 return err;
1360 }
1361 return 0;
1362 }
1363
1364 /* Dump registers to kernel log */
1365 void ab8500_dump_all_banks(struct device *dev)
1366 {
1367 unsigned int i;
1368
1369 dev_info(dev, "ab8500 register values:\n");
1370
1371 for (i = 1; i < AB8500_NUM_BANKS; i++) {
1372 dev_info(dev, " bank 0x%02X:\n", i);
1373 ab8500_registers_print(dev, i, NULL);
1374 }
1375 }
1376
1377 static int ab8500_all_banks_open(struct inode *inode, struct file *file)
1378 {
1379 struct seq_file *s;
1380 int err;
1381
1382 err = single_open(file, ab8500_print_all_banks, inode->i_private);
1383 if (!err) {
1384 /* Default buf size in seq_read is not enough */
1385 s = (struct seq_file *)file->private_data;
1386 s->size = (PAGE_SIZE * 2);
1387 s->buf = kmalloc(s->size, GFP_KERNEL);
1388 if (!s->buf) {
1389 single_release(inode, file);
1390 err = -ENOMEM;
1391 }
1392 }
1393 return err;
1394 }
1395
1396 static const struct file_operations ab8500_all_banks_fops = {
1397 .open = ab8500_all_banks_open,
1398 .read = seq_read,
1399 .llseek = seq_lseek,
1400 .release = single_release,
1401 .owner = THIS_MODULE,
1402 };
1403
1404 static int ab8500_bank_print(struct seq_file *s, void *p)
1405 {
1406 seq_printf(s, "0x%02X\n", debug_bank);
1407 return 0;
1408 }
1409
1410 static int ab8500_bank_open(struct inode *inode, struct file *file)
1411 {
1412 return single_open(file, ab8500_bank_print, inode->i_private);
1413 }
1414
1415 static ssize_t ab8500_bank_write(struct file *file,
1416 const char __user *user_buf,
1417 size_t count, loff_t *ppos)
1418 {
1419 struct device *dev = ((struct seq_file *)(file->private_data))->private;
1420 unsigned long user_bank;
1421 int err;
1422
1423 err = kstrtoul_from_user(user_buf, count, 0, &user_bank);
1424 if (err)
1425 return err;
1426
1427 if (user_bank >= AB8500_NUM_BANKS) {
1428 dev_err(dev, "debugfs error input > number of banks\n");
1429 return -EINVAL;
1430 }
1431
1432 debug_bank = user_bank;
1433
1434 return count;
1435 }
1436
1437 static int ab8500_address_print(struct seq_file *s, void *p)
1438 {
1439 seq_printf(s, "0x%02X\n", debug_address);
1440 return 0;
1441 }
1442
1443 static int ab8500_address_open(struct inode *inode, struct file *file)
1444 {
1445 return single_open(file, ab8500_address_print, inode->i_private);
1446 }
1447
1448 static ssize_t ab8500_address_write(struct file *file,
1449 const char __user *user_buf,
1450 size_t count, loff_t *ppos)
1451 {
1452 struct device *dev = ((struct seq_file *)(file->private_data))->private;
1453 unsigned long user_address;
1454 int err;
1455
1456 err = kstrtoul_from_user(user_buf, count, 0, &user_address);
1457 if (err)
1458 return err;
1459
1460 if (user_address > 0xff) {
1461 dev_err(dev, "debugfs error input > 0xff\n");
1462 return -EINVAL;
1463 }
1464 debug_address = user_address;
1465
1466 return count;
1467 }
1468
1469 static int ab8500_val_print(struct seq_file *s, void *p)
1470 {
1471 struct device *dev = s->private;
1472 int ret;
1473 u8 regvalue;
1474
1475 ret = abx500_get_register_interruptible(dev,
1476 (u8)debug_bank, (u8)debug_address, &regvalue);
1477 if (ret < 0) {
1478 dev_err(dev, "abx500_get_reg fail %d, %d\n",
1479 ret, __LINE__);
1480 return -EINVAL;
1481 }
1482 seq_printf(s, "0x%02X\n", regvalue);
1483
1484 return 0;
1485 }
1486
1487 static int ab8500_val_open(struct inode *inode, struct file *file)
1488 {
1489 return single_open(file, ab8500_val_print, inode->i_private);
1490 }
1491
1492 static ssize_t ab8500_val_write(struct file *file,
1493 const char __user *user_buf,
1494 size_t count, loff_t *ppos)
1495 {
1496 struct device *dev = ((struct seq_file *)(file->private_data))->private;
1497 unsigned long user_val;
1498 int err;
1499
1500 err = kstrtoul_from_user(user_buf, count, 0, &user_val);
1501 if (err)
1502 return err;
1503
1504 if (user_val > 0xff) {
1505 dev_err(dev, "debugfs error input > 0xff\n");
1506 return -EINVAL;
1507 }
1508 err = abx500_set_register_interruptible(dev,
1509 (u8)debug_bank, debug_address, (u8)user_val);
1510 if (err < 0) {
1511 pr_err("abx500_set_reg failed %d, %d", err, __LINE__);
1512 return -EINVAL;
1513 }
1514
1515 return count;
1516 }
1517
1518 /*
1519 * Interrupt status
1520 */
1521 static u32 num_interrupts[AB8500_MAX_NR_IRQS];
1522 static u32 num_wake_interrupts[AB8500_MAX_NR_IRQS];
1523 static int num_interrupt_lines;
1524
1525 void ab8500_debug_register_interrupt(int line)
1526 {
1527 if (line < num_interrupt_lines)
1528 num_interrupts[line]++;
1529 }
1530
1531 static int ab8500_interrupts_print(struct seq_file *s, void *p)
1532 {
1533 int line;
1534
1535 seq_puts(s, "name: number: number of: wake:\n");
1536
1537 for (line = 0; line < num_interrupt_lines; line++) {
1538 struct irq_desc *desc = irq_to_desc(line + irq_first);
1539
1540 seq_printf(s, "%3i: %6i %4i",
1541 line,
1542 num_interrupts[line],
1543 num_wake_interrupts[line]);
1544
1545 if (desc && desc->name)
1546 seq_printf(s, "-%-8s", desc->name);
1547 if (desc && desc->action) {
1548 struct irqaction *action = desc->action;
1549
1550 seq_printf(s, " %s", action->name);
1551 while ((action = action->next) != NULL)
1552 seq_printf(s, ", %s", action->name);
1553 }
1554 seq_putc(s, '\n');
1555 }
1556
1557 return 0;
1558 }
1559
1560 static int ab8500_interrupts_open(struct inode *inode, struct file *file)
1561 {
1562 return single_open(file, ab8500_interrupts_print, inode->i_private);
1563 }
1564
1565 /*
1566 * - HWREG DB8500 formated routines
1567 */
1568 static int ab8500_hwreg_print(struct seq_file *s, void *d)
1569 {
1570 struct device *dev = s->private;
1571 int ret;
1572 u8 regvalue;
1573
1574 ret = abx500_get_register_interruptible(dev,
1575 (u8)hwreg_cfg.bank, (u8)hwreg_cfg.addr, &regvalue);
1576 if (ret < 0) {
1577 dev_err(dev, "abx500_get_reg fail %d, %d\n",
1578 ret, __LINE__);
1579 return -EINVAL;
1580 }
1581
1582 if (hwreg_cfg.shift >= 0)
1583 regvalue >>= hwreg_cfg.shift;
1584 else
1585 regvalue <<= -hwreg_cfg.shift;
1586 regvalue &= hwreg_cfg.mask;
1587
1588 if (REG_FMT_DEC(&hwreg_cfg))
1589 seq_printf(s, "%d\n", regvalue);
1590 else
1591 seq_printf(s, "0x%02X\n", regvalue);
1592 return 0;
1593 }
1594
1595 static int ab8500_hwreg_open(struct inode *inode, struct file *file)
1596 {
1597 return single_open(file, ab8500_hwreg_print, inode->i_private);
1598 }
1599
1600 #define AB8500_SUPPLY_CONTROL_CONFIG_1 0x01
1601 #define AB8500_SUPPLY_CONTROL_REG 0x00
1602 #define AB8500_FIRST_SIM_REG 0x80
1603 #define AB8500_LAST_SIM_REG 0x8B
1604 #define AB8505_LAST_SIM_REG 0x8C
1605
1606 static int ab8500_print_modem_registers(struct seq_file *s, void *p)
1607 {
1608 struct device *dev = s->private;
1609 struct ab8500 *ab8500;
1610 int err;
1611 u8 value;
1612 u8 orig_value;
1613 u32 bank = AB8500_REGU_CTRL2;
1614 u32 last_sim_reg = AB8500_LAST_SIM_REG;
1615 u32 reg;
1616
1617 ab8500 = dev_get_drvdata(dev->parent);
1618 dev_warn(dev, "WARNING! This operation can interfer with modem side\n"
1619 "and should only be done with care\n");
1620
1621 err = abx500_get_register_interruptible(dev,
1622 AB8500_REGU_CTRL1, AB8500_SUPPLY_CONTROL_REG, &orig_value);
1623 if (err < 0) {
1624 dev_err(dev, "ab->read fail %d\n", err);
1625 return err;
1626 }
1627 /* Config 1 will allow APE side to read SIM registers */
1628 err = abx500_set_register_interruptible(dev,
1629 AB8500_REGU_CTRL1, AB8500_SUPPLY_CONTROL_REG,
1630 AB8500_SUPPLY_CONTROL_CONFIG_1);
1631 if (err < 0) {
1632 dev_err(dev, "ab->write fail %d\n", err);
1633 return err;
1634 }
1635
1636 seq_printf(s, " bank 0x%02X:\n", bank);
1637
1638 if (is_ab9540(ab8500) || is_ab8505(ab8500))
1639 last_sim_reg = AB8505_LAST_SIM_REG;
1640
1641 for (reg = AB8500_FIRST_SIM_REG; reg <= last_sim_reg; reg++) {
1642 err = abx500_get_register_interruptible(dev,
1643 bank, reg, &value);
1644 if (err < 0) {
1645 dev_err(dev, "ab->read fail %d\n", err);
1646 return err;
1647 }
1648 seq_printf(s, " [0x%02X/0x%02X]: 0x%02X\n", bank, reg, value);
1649 }
1650 err = abx500_set_register_interruptible(dev,
1651 AB8500_REGU_CTRL1, AB8500_SUPPLY_CONTROL_REG, orig_value);
1652 if (err < 0) {
1653 dev_err(dev, "ab->write fail %d\n", err);
1654 return err;
1655 }
1656 return 0;
1657 }
1658
1659 static int ab8500_modem_open(struct inode *inode, struct file *file)
1660 {
1661 return single_open(file, ab8500_print_modem_registers,
1662 inode->i_private);
1663 }
1664
1665 static const struct file_operations ab8500_modem_fops = {
1666 .open = ab8500_modem_open,
1667 .read = seq_read,
1668 .llseek = seq_lseek,
1669 .release = single_release,
1670 .owner = THIS_MODULE,
1671 };
1672
1673 static int ab8500_gpadc_bat_ctrl_print(struct seq_file *s, void *p)
1674 {
1675 int bat_ctrl_raw;
1676 int bat_ctrl_convert;
1677 struct ab8500_gpadc *gpadc;
1678
1679 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1680 bat_ctrl_raw = ab8500_gpadc_read_raw(gpadc, BAT_CTRL,
1681 avg_sample, trig_edge, trig_timer, conv_type);
1682 bat_ctrl_convert = ab8500_gpadc_ad_to_voltage(gpadc,
1683 BAT_CTRL, bat_ctrl_raw);
1684
1685 seq_printf(s, "%d,0x%X\n", bat_ctrl_convert, bat_ctrl_raw);
1686
1687 return 0;
1688 }
1689
1690 static int ab8500_gpadc_bat_ctrl_open(struct inode *inode, struct file *file)
1691 {
1692 return single_open(file, ab8500_gpadc_bat_ctrl_print,
1693 inode->i_private);
1694 }
1695
1696 static const struct file_operations ab8500_gpadc_bat_ctrl_fops = {
1697 .open = ab8500_gpadc_bat_ctrl_open,
1698 .read = seq_read,
1699 .llseek = seq_lseek,
1700 .release = single_release,
1701 .owner = THIS_MODULE,
1702 };
1703
1704 static int ab8500_gpadc_btemp_ball_print(struct seq_file *s, void *p)
1705 {
1706 int btemp_ball_raw;
1707 int btemp_ball_convert;
1708 struct ab8500_gpadc *gpadc;
1709
1710 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1711 btemp_ball_raw = ab8500_gpadc_read_raw(gpadc, BTEMP_BALL,
1712 avg_sample, trig_edge, trig_timer, conv_type);
1713 btemp_ball_convert = ab8500_gpadc_ad_to_voltage(gpadc, BTEMP_BALL,
1714 btemp_ball_raw);
1715
1716 seq_printf(s, "%d,0x%X\n", btemp_ball_convert, btemp_ball_raw);
1717
1718 return 0;
1719 }
1720
1721 static int ab8500_gpadc_btemp_ball_open(struct inode *inode,
1722 struct file *file)
1723 {
1724 return single_open(file, ab8500_gpadc_btemp_ball_print,
1725 inode->i_private);
1726 }
1727
1728 static const struct file_operations ab8500_gpadc_btemp_ball_fops = {
1729 .open = ab8500_gpadc_btemp_ball_open,
1730 .read = seq_read,
1731 .llseek = seq_lseek,
1732 .release = single_release,
1733 .owner = THIS_MODULE,
1734 };
1735
1736 static int ab8500_gpadc_main_charger_v_print(struct seq_file *s, void *p)
1737 {
1738 int main_charger_v_raw;
1739 int main_charger_v_convert;
1740 struct ab8500_gpadc *gpadc;
1741
1742 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1743 main_charger_v_raw = ab8500_gpadc_read_raw(gpadc, MAIN_CHARGER_V,
1744 avg_sample, trig_edge, trig_timer, conv_type);
1745 main_charger_v_convert = ab8500_gpadc_ad_to_voltage(gpadc,
1746 MAIN_CHARGER_V, main_charger_v_raw);
1747
1748 seq_printf(s, "%d,0x%X\n", main_charger_v_convert, main_charger_v_raw);
1749
1750 return 0;
1751 }
1752
1753 static int ab8500_gpadc_main_charger_v_open(struct inode *inode,
1754 struct file *file)
1755 {
1756 return single_open(file, ab8500_gpadc_main_charger_v_print,
1757 inode->i_private);
1758 }
1759
1760 static const struct file_operations ab8500_gpadc_main_charger_v_fops = {
1761 .open = ab8500_gpadc_main_charger_v_open,
1762 .read = seq_read,
1763 .llseek = seq_lseek,
1764 .release = single_release,
1765 .owner = THIS_MODULE,
1766 };
1767
1768 static int ab8500_gpadc_acc_detect1_print(struct seq_file *s, void *p)
1769 {
1770 int acc_detect1_raw;
1771 int acc_detect1_convert;
1772 struct ab8500_gpadc *gpadc;
1773
1774 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1775 acc_detect1_raw = ab8500_gpadc_read_raw(gpadc, ACC_DETECT1,
1776 avg_sample, trig_edge, trig_timer, conv_type);
1777 acc_detect1_convert = ab8500_gpadc_ad_to_voltage(gpadc, ACC_DETECT1,
1778 acc_detect1_raw);
1779
1780 seq_printf(s, "%d,0x%X\n", acc_detect1_convert, acc_detect1_raw);
1781
1782 return 0;
1783 }
1784
1785 static int ab8500_gpadc_acc_detect1_open(struct inode *inode,
1786 struct file *file)
1787 {
1788 return single_open(file, ab8500_gpadc_acc_detect1_print,
1789 inode->i_private);
1790 }
1791
1792 static const struct file_operations ab8500_gpadc_acc_detect1_fops = {
1793 .open = ab8500_gpadc_acc_detect1_open,
1794 .read = seq_read,
1795 .llseek = seq_lseek,
1796 .release = single_release,
1797 .owner = THIS_MODULE,
1798 };
1799
1800 static int ab8500_gpadc_acc_detect2_print(struct seq_file *s, void *p)
1801 {
1802 int acc_detect2_raw;
1803 int acc_detect2_convert;
1804 struct ab8500_gpadc *gpadc;
1805
1806 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1807 acc_detect2_raw = ab8500_gpadc_read_raw(gpadc, ACC_DETECT2,
1808 avg_sample, trig_edge, trig_timer, conv_type);
1809 acc_detect2_convert = ab8500_gpadc_ad_to_voltage(gpadc,
1810 ACC_DETECT2, acc_detect2_raw);
1811
1812 seq_printf(s, "%d,0x%X\n", acc_detect2_convert, acc_detect2_raw);
1813
1814 return 0;
1815 }
1816
1817 static int ab8500_gpadc_acc_detect2_open(struct inode *inode,
1818 struct file *file)
1819 {
1820 return single_open(file, ab8500_gpadc_acc_detect2_print,
1821 inode->i_private);
1822 }
1823
1824 static const struct file_operations ab8500_gpadc_acc_detect2_fops = {
1825 .open = ab8500_gpadc_acc_detect2_open,
1826 .read = seq_read,
1827 .llseek = seq_lseek,
1828 .release = single_release,
1829 .owner = THIS_MODULE,
1830 };
1831
1832 static int ab8500_gpadc_aux1_print(struct seq_file *s, void *p)
1833 {
1834 int aux1_raw;
1835 int aux1_convert;
1836 struct ab8500_gpadc *gpadc;
1837
1838 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1839 aux1_raw = ab8500_gpadc_read_raw(gpadc, ADC_AUX1,
1840 avg_sample, trig_edge, trig_timer, conv_type);
1841 aux1_convert = ab8500_gpadc_ad_to_voltage(gpadc, ADC_AUX1,
1842 aux1_raw);
1843
1844 seq_printf(s, "%d,0x%X\n", aux1_convert, aux1_raw);
1845
1846 return 0;
1847 }
1848
1849 static int ab8500_gpadc_aux1_open(struct inode *inode, struct file *file)
1850 {
1851 return single_open(file, ab8500_gpadc_aux1_print, inode->i_private);
1852 }
1853
1854 static const struct file_operations ab8500_gpadc_aux1_fops = {
1855 .open = ab8500_gpadc_aux1_open,
1856 .read = seq_read,
1857 .llseek = seq_lseek,
1858 .release = single_release,
1859 .owner = THIS_MODULE,
1860 };
1861
1862 static int ab8500_gpadc_aux2_print(struct seq_file *s, void *p)
1863 {
1864 int aux2_raw;
1865 int aux2_convert;
1866 struct ab8500_gpadc *gpadc;
1867
1868 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1869 aux2_raw = ab8500_gpadc_read_raw(gpadc, ADC_AUX2,
1870 avg_sample, trig_edge, trig_timer, conv_type);
1871 aux2_convert = ab8500_gpadc_ad_to_voltage(gpadc, ADC_AUX2,
1872 aux2_raw);
1873
1874 seq_printf(s, "%d,0x%X\n", aux2_convert, aux2_raw);
1875
1876 return 0;
1877 }
1878
1879 static int ab8500_gpadc_aux2_open(struct inode *inode, struct file *file)
1880 {
1881 return single_open(file, ab8500_gpadc_aux2_print, inode->i_private);
1882 }
1883
1884 static const struct file_operations ab8500_gpadc_aux2_fops = {
1885 .open = ab8500_gpadc_aux2_open,
1886 .read = seq_read,
1887 .llseek = seq_lseek,
1888 .release = single_release,
1889 .owner = THIS_MODULE,
1890 };
1891
1892 static int ab8500_gpadc_main_bat_v_print(struct seq_file *s, void *p)
1893 {
1894 int main_bat_v_raw;
1895 int main_bat_v_convert;
1896 struct ab8500_gpadc *gpadc;
1897
1898 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1899 main_bat_v_raw = ab8500_gpadc_read_raw(gpadc, MAIN_BAT_V,
1900 avg_sample, trig_edge, trig_timer, conv_type);
1901 main_bat_v_convert = ab8500_gpadc_ad_to_voltage(gpadc, MAIN_BAT_V,
1902 main_bat_v_raw);
1903
1904 seq_printf(s, "%d,0x%X\n", main_bat_v_convert, main_bat_v_raw);
1905
1906 return 0;
1907 }
1908
1909 static int ab8500_gpadc_main_bat_v_open(struct inode *inode,
1910 struct file *file)
1911 {
1912 return single_open(file, ab8500_gpadc_main_bat_v_print,
1913 inode->i_private);
1914 }
1915
1916 static const struct file_operations ab8500_gpadc_main_bat_v_fops = {
1917 .open = ab8500_gpadc_main_bat_v_open,
1918 .read = seq_read,
1919 .llseek = seq_lseek,
1920 .release = single_release,
1921 .owner = THIS_MODULE,
1922 };
1923
1924 static int ab8500_gpadc_vbus_v_print(struct seq_file *s, void *p)
1925 {
1926 int vbus_v_raw;
1927 int vbus_v_convert;
1928 struct ab8500_gpadc *gpadc;
1929
1930 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1931 vbus_v_raw = ab8500_gpadc_read_raw(gpadc, VBUS_V,
1932 avg_sample, trig_edge, trig_timer, conv_type);
1933 vbus_v_convert = ab8500_gpadc_ad_to_voltage(gpadc, VBUS_V,
1934 vbus_v_raw);
1935
1936 seq_printf(s, "%d,0x%X\n", vbus_v_convert, vbus_v_raw);
1937
1938 return 0;
1939 }
1940
1941 static int ab8500_gpadc_vbus_v_open(struct inode *inode, struct file *file)
1942 {
1943 return single_open(file, ab8500_gpadc_vbus_v_print, inode->i_private);
1944 }
1945
1946 static const struct file_operations ab8500_gpadc_vbus_v_fops = {
1947 .open = ab8500_gpadc_vbus_v_open,
1948 .read = seq_read,
1949 .llseek = seq_lseek,
1950 .release = single_release,
1951 .owner = THIS_MODULE,
1952 };
1953
1954 static int ab8500_gpadc_main_charger_c_print(struct seq_file *s, void *p)
1955 {
1956 int main_charger_c_raw;
1957 int main_charger_c_convert;
1958 struct ab8500_gpadc *gpadc;
1959
1960 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1961 main_charger_c_raw = ab8500_gpadc_read_raw(gpadc, MAIN_CHARGER_C,
1962 avg_sample, trig_edge, trig_timer, conv_type);
1963 main_charger_c_convert = ab8500_gpadc_ad_to_voltage(gpadc,
1964 MAIN_CHARGER_C, main_charger_c_raw);
1965
1966 seq_printf(s, "%d,0x%X\n", main_charger_c_convert, main_charger_c_raw);
1967
1968 return 0;
1969 }
1970
1971 static int ab8500_gpadc_main_charger_c_open(struct inode *inode,
1972 struct file *file)
1973 {
1974 return single_open(file, ab8500_gpadc_main_charger_c_print,
1975 inode->i_private);
1976 }
1977
1978 static const struct file_operations ab8500_gpadc_main_charger_c_fops = {
1979 .open = ab8500_gpadc_main_charger_c_open,
1980 .read = seq_read,
1981 .llseek = seq_lseek,
1982 .release = single_release,
1983 .owner = THIS_MODULE,
1984 };
1985
1986 static int ab8500_gpadc_usb_charger_c_print(struct seq_file *s, void *p)
1987 {
1988 int usb_charger_c_raw;
1989 int usb_charger_c_convert;
1990 struct ab8500_gpadc *gpadc;
1991
1992 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1993 usb_charger_c_raw = ab8500_gpadc_read_raw(gpadc, USB_CHARGER_C,
1994 avg_sample, trig_edge, trig_timer, conv_type);
1995 usb_charger_c_convert = ab8500_gpadc_ad_to_voltage(gpadc,
1996 USB_CHARGER_C, usb_charger_c_raw);
1997
1998 seq_printf(s, "%d,0x%X\n", usb_charger_c_convert, usb_charger_c_raw);
1999
2000 return 0;
2001 }
2002
2003 static int ab8500_gpadc_usb_charger_c_open(struct inode *inode,
2004 struct file *file)
2005 {
2006 return single_open(file, ab8500_gpadc_usb_charger_c_print,
2007 inode->i_private);
2008 }
2009
2010 static const struct file_operations ab8500_gpadc_usb_charger_c_fops = {
2011 .open = ab8500_gpadc_usb_charger_c_open,
2012 .read = seq_read,
2013 .llseek = seq_lseek,
2014 .release = single_release,
2015 .owner = THIS_MODULE,
2016 };
2017
2018 static int ab8500_gpadc_bk_bat_v_print(struct seq_file *s, void *p)
2019 {
2020 int bk_bat_v_raw;
2021 int bk_bat_v_convert;
2022 struct ab8500_gpadc *gpadc;
2023
2024 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
2025 bk_bat_v_raw = ab8500_gpadc_read_raw(gpadc, BK_BAT_V,
2026 avg_sample, trig_edge, trig_timer, conv_type);
2027 bk_bat_v_convert = ab8500_gpadc_ad_to_voltage(gpadc,
2028 BK_BAT_V, bk_bat_v_raw);
2029
2030 seq_printf(s, "%d,0x%X\n", bk_bat_v_convert, bk_bat_v_raw);
2031
2032 return 0;
2033 }
2034
2035 static int ab8500_gpadc_bk_bat_v_open(struct inode *inode, struct file *file)
2036 {
2037 return single_open(file, ab8500_gpadc_bk_bat_v_print,
2038 inode->i_private);
2039 }
2040
2041 static const struct file_operations ab8500_gpadc_bk_bat_v_fops = {
2042 .open = ab8500_gpadc_bk_bat_v_open,
2043 .read = seq_read,
2044 .llseek = seq_lseek,
2045 .release = single_release,
2046 .owner = THIS_MODULE,
2047 };
2048
2049 static int ab8500_gpadc_die_temp_print(struct seq_file *s, void *p)
2050 {
2051 int die_temp_raw;
2052 int die_temp_convert;
2053 struct ab8500_gpadc *gpadc;
2054
2055 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
2056 die_temp_raw = ab8500_gpadc_read_raw(gpadc, DIE_TEMP,
2057 avg_sample, trig_edge, trig_timer, conv_type);
2058 die_temp_convert = ab8500_gpadc_ad_to_voltage(gpadc, DIE_TEMP,
2059 die_temp_raw);
2060
2061 seq_printf(s, "%d,0x%X\n", die_temp_convert, die_temp_raw);
2062
2063 return 0;
2064 }
2065
2066 static int ab8500_gpadc_die_temp_open(struct inode *inode, struct file *file)
2067 {
2068 return single_open(file, ab8500_gpadc_die_temp_print,
2069 inode->i_private);
2070 }
2071
2072 static const struct file_operations ab8500_gpadc_die_temp_fops = {
2073 .open = ab8500_gpadc_die_temp_open,
2074 .read = seq_read,
2075 .llseek = seq_lseek,
2076 .release = single_release,
2077 .owner = THIS_MODULE,
2078 };
2079
2080 static int ab8500_gpadc_usb_id_print(struct seq_file *s, void *p)
2081 {
2082 int usb_id_raw;
2083 int usb_id_convert;
2084 struct ab8500_gpadc *gpadc;
2085
2086 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
2087 usb_id_raw = ab8500_gpadc_read_raw(gpadc, USB_ID,
2088 avg_sample, trig_edge, trig_timer, conv_type);
2089 usb_id_convert = ab8500_gpadc_ad_to_voltage(gpadc, USB_ID,
2090 usb_id_raw);
2091
2092 seq_printf(s, "%d,0x%X\n", usb_id_convert, usb_id_raw);
2093
2094 return 0;
2095 }
2096
2097 static int ab8500_gpadc_usb_id_open(struct inode *inode, struct file *file)
2098 {
2099 return single_open(file, ab8500_gpadc_usb_id_print, inode->i_private);
2100 }
2101
2102 static const struct file_operations ab8500_gpadc_usb_id_fops = {
2103 .open = ab8500_gpadc_usb_id_open,
2104 .read = seq_read,
2105 .llseek = seq_lseek,
2106 .release = single_release,
2107 .owner = THIS_MODULE,
2108 };
2109
2110 static int ab8540_gpadc_xtal_temp_print(struct seq_file *s, void *p)
2111 {
2112 int xtal_temp_raw;
2113 int xtal_temp_convert;
2114 struct ab8500_gpadc *gpadc;
2115
2116 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
2117 xtal_temp_raw = ab8500_gpadc_read_raw(gpadc, XTAL_TEMP,
2118 avg_sample, trig_edge, trig_timer, conv_type);
2119 xtal_temp_convert = ab8500_gpadc_ad_to_voltage(gpadc, XTAL_TEMP,
2120 xtal_temp_raw);
2121
2122 seq_printf(s, "%d,0x%X\n", xtal_temp_convert, xtal_temp_raw);
2123
2124 return 0;
2125 }
2126
2127 static int ab8540_gpadc_xtal_temp_open(struct inode *inode, struct file *file)
2128 {
2129 return single_open(file, ab8540_gpadc_xtal_temp_print,
2130 inode->i_private);
2131 }
2132
2133 static const struct file_operations ab8540_gpadc_xtal_temp_fops = {
2134 .open = ab8540_gpadc_xtal_temp_open,
2135 .read = seq_read,
2136 .llseek = seq_lseek,
2137 .release = single_release,
2138 .owner = THIS_MODULE,
2139 };
2140
2141 static int ab8540_gpadc_vbat_true_meas_print(struct seq_file *s, void *p)
2142 {
2143 int vbat_true_meas_raw;
2144 int vbat_true_meas_convert;
2145 struct ab8500_gpadc *gpadc;
2146
2147 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
2148 vbat_true_meas_raw = ab8500_gpadc_read_raw(gpadc, VBAT_TRUE_MEAS,
2149 avg_sample, trig_edge, trig_timer, conv_type);
2150 vbat_true_meas_convert =
2151 ab8500_gpadc_ad_to_voltage(gpadc, VBAT_TRUE_MEAS,
2152 vbat_true_meas_raw);
2153
2154 seq_printf(s, "%d,0x%X\n", vbat_true_meas_convert, vbat_true_meas_raw);
2155
2156 return 0;
2157 }
2158
2159 static int ab8540_gpadc_vbat_true_meas_open(struct inode *inode,
2160 struct file *file)
2161 {
2162 return single_open(file, ab8540_gpadc_vbat_true_meas_print,
2163 inode->i_private);
2164 }
2165
2166 static const struct file_operations ab8540_gpadc_vbat_true_meas_fops = {
2167 .open = ab8540_gpadc_vbat_true_meas_open,
2168 .read = seq_read,
2169 .llseek = seq_lseek,
2170 .release = single_release,
2171 .owner = THIS_MODULE,
2172 };
2173
2174 static int ab8540_gpadc_bat_ctrl_and_ibat_print(struct seq_file *s, void *p)
2175 {
2176 int bat_ctrl_raw;
2177 int bat_ctrl_convert;
2178 int ibat_raw;
2179 int ibat_convert;
2180 struct ab8500_gpadc *gpadc;
2181
2182 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
2183 bat_ctrl_raw = ab8500_gpadc_double_read_raw(gpadc, BAT_CTRL_AND_IBAT,
2184 avg_sample, trig_edge, trig_timer, conv_type, &ibat_raw);
2185
2186 bat_ctrl_convert = ab8500_gpadc_ad_to_voltage(gpadc, BAT_CTRL,
2187 bat_ctrl_raw);
2188 ibat_convert = ab8500_gpadc_ad_to_voltage(gpadc, IBAT_VIRTUAL_CHANNEL,
2189 ibat_raw);
2190
2191 seq_printf(s,
2192 "%d,0x%X\n"
2193 "%d,0x%X\n",
2194 bat_ctrl_convert, bat_ctrl_raw,
2195 ibat_convert, ibat_raw);
2196
2197 return 0;
2198 }
2199
2200 static int ab8540_gpadc_bat_ctrl_and_ibat_open(struct inode *inode,
2201 struct file *file)
2202 {
2203 return single_open(file, ab8540_gpadc_bat_ctrl_and_ibat_print,
2204 inode->i_private);
2205 }
2206
2207 static const struct file_operations ab8540_gpadc_bat_ctrl_and_ibat_fops = {
2208 .open = ab8540_gpadc_bat_ctrl_and_ibat_open,
2209 .read = seq_read,
2210 .llseek = seq_lseek,
2211 .release = single_release,
2212 .owner = THIS_MODULE,
2213 };
2214
2215 static int ab8540_gpadc_vbat_meas_and_ibat_print(struct seq_file *s, void *p)
2216 {
2217 int vbat_meas_raw;
2218 int vbat_meas_convert;
2219 int ibat_raw;
2220 int ibat_convert;
2221 struct ab8500_gpadc *gpadc;
2222
2223 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
2224 vbat_meas_raw = ab8500_gpadc_double_read_raw(gpadc, VBAT_MEAS_AND_IBAT,
2225 avg_sample, trig_edge, trig_timer, conv_type, &ibat_raw);
2226 vbat_meas_convert = ab8500_gpadc_ad_to_voltage(gpadc, MAIN_BAT_V,
2227 vbat_meas_raw);
2228 ibat_convert = ab8500_gpadc_ad_to_voltage(gpadc, IBAT_VIRTUAL_CHANNEL,
2229 ibat_raw);
2230
2231 seq_printf(s,
2232 "%d,0x%X\n"
2233 "%d,0x%X\n",
2234 vbat_meas_convert, vbat_meas_raw,
2235 ibat_convert, ibat_raw);
2236
2237 return 0;
2238 }
2239
2240 static int ab8540_gpadc_vbat_meas_and_ibat_open(struct inode *inode,
2241 struct file *file)
2242 {
2243 return single_open(file, ab8540_gpadc_vbat_meas_and_ibat_print,
2244 inode->i_private);
2245 }
2246
2247 static const struct file_operations ab8540_gpadc_vbat_meas_and_ibat_fops = {
2248 .open = ab8540_gpadc_vbat_meas_and_ibat_open,
2249 .read = seq_read,
2250 .llseek = seq_lseek,
2251 .release = single_release,
2252 .owner = THIS_MODULE,
2253 };
2254
2255 static int ab8540_gpadc_vbat_true_meas_and_ibat_print(struct seq_file *s,
2256 void *p)
2257 {
2258 int vbat_true_meas_raw;
2259 int vbat_true_meas_convert;
2260 int ibat_raw;
2261 int ibat_convert;
2262 struct ab8500_gpadc *gpadc;
2263
2264 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
2265 vbat_true_meas_raw = ab8500_gpadc_double_read_raw(gpadc,
2266 VBAT_TRUE_MEAS_AND_IBAT, avg_sample, trig_edge,
2267 trig_timer, conv_type, &ibat_raw);
2268 vbat_true_meas_convert = ab8500_gpadc_ad_to_voltage(gpadc,
2269 VBAT_TRUE_MEAS, vbat_true_meas_raw);
2270 ibat_convert = ab8500_gpadc_ad_to_voltage(gpadc, IBAT_VIRTUAL_CHANNEL,
2271 ibat_raw);
2272
2273 seq_printf(s,
2274 "%d,0x%X\n"
2275 "%d,0x%X\n",
2276 vbat_true_meas_convert, vbat_true_meas_raw,
2277 ibat_convert, ibat_raw);
2278
2279 return 0;
2280 }
2281
2282 static int ab8540_gpadc_vbat_true_meas_and_ibat_open(struct inode *inode,
2283 struct file *file)
2284 {
2285 return single_open(file, ab8540_gpadc_vbat_true_meas_and_ibat_print,
2286 inode->i_private);
2287 }
2288
2289 static const struct file_operations
2290 ab8540_gpadc_vbat_true_meas_and_ibat_fops = {
2291 .open = ab8540_gpadc_vbat_true_meas_and_ibat_open,
2292 .read = seq_read,
2293 .llseek = seq_lseek,
2294 .release = single_release,
2295 .owner = THIS_MODULE,
2296 };
2297
2298 static int ab8540_gpadc_bat_temp_and_ibat_print(struct seq_file *s, void *p)
2299 {
2300 int bat_temp_raw;
2301 int bat_temp_convert;
2302 int ibat_raw;
2303 int ibat_convert;
2304 struct ab8500_gpadc *gpadc;
2305
2306 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
2307 bat_temp_raw = ab8500_gpadc_double_read_raw(gpadc, BAT_TEMP_AND_IBAT,
2308 avg_sample, trig_edge, trig_timer, conv_type, &ibat_raw);
2309 bat_temp_convert = ab8500_gpadc_ad_to_voltage(gpadc, BTEMP_BALL,
2310 bat_temp_raw);
2311 ibat_convert = ab8500_gpadc_ad_to_voltage(gpadc, IBAT_VIRTUAL_CHANNEL,
2312 ibat_raw);
2313
2314 seq_printf(s,
2315 "%d,0x%X\n"
2316 "%d,0x%X\n",
2317 bat_temp_convert, bat_temp_raw,
2318 ibat_convert, ibat_raw);
2319
2320 return 0;
2321 }
2322
2323 static int ab8540_gpadc_bat_temp_and_ibat_open(struct inode *inode,
2324 struct file *file)
2325 {
2326 return single_open(file, ab8540_gpadc_bat_temp_and_ibat_print,
2327 inode->i_private);
2328 }
2329
2330 static const struct file_operations ab8540_gpadc_bat_temp_and_ibat_fops = {
2331 .open = ab8540_gpadc_bat_temp_and_ibat_open,
2332 .read = seq_read,
2333 .llseek = seq_lseek,
2334 .release = single_release,
2335 .owner = THIS_MODULE,
2336 };
2337
2338 static int ab8540_gpadc_otp_cal_print(struct seq_file *s, void *p)
2339 {
2340 struct ab8500_gpadc *gpadc;
2341 u16 vmain_l, vmain_h, btemp_l, btemp_h;
2342 u16 vbat_l, vbat_h, ibat_l, ibat_h;
2343
2344 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
2345 ab8540_gpadc_get_otp(gpadc, &vmain_l, &vmain_h, &btemp_l, &btemp_h,
2346 &vbat_l, &vbat_h, &ibat_l, &ibat_h);
2347 seq_printf(s,
2348 "VMAIN_L:0x%X\n"
2349 "VMAIN_H:0x%X\n"
2350 "BTEMP_L:0x%X\n"
2351 "BTEMP_H:0x%X\n"
2352 "VBAT_L:0x%X\n"
2353 "VBAT_H:0x%X\n"
2354 "IBAT_L:0x%X\n"
2355 "IBAT_H:0x%X\n",
2356 vmain_l, vmain_h, btemp_l, btemp_h,
2357 vbat_l, vbat_h, ibat_l, ibat_h);
2358
2359 return 0;
2360 }
2361
2362 static int ab8540_gpadc_otp_cal_open(struct inode *inode, struct file *file)
2363 {
2364 return single_open(file, ab8540_gpadc_otp_cal_print, inode->i_private);
2365 }
2366
2367 static const struct file_operations ab8540_gpadc_otp_calib_fops = {
2368 .open = ab8540_gpadc_otp_cal_open,
2369 .read = seq_read,
2370 .llseek = seq_lseek,
2371 .release = single_release,
2372 .owner = THIS_MODULE,
2373 };
2374
2375 static int ab8500_gpadc_avg_sample_print(struct seq_file *s, void *p)
2376 {
2377 seq_printf(s, "%d\n", avg_sample);
2378
2379 return 0;
2380 }
2381
2382 static int ab8500_gpadc_avg_sample_open(struct inode *inode, struct file *file)
2383 {
2384 return single_open(file, ab8500_gpadc_avg_sample_print,
2385 inode->i_private);
2386 }
2387
2388 static ssize_t ab8500_gpadc_avg_sample_write(struct file *file,
2389 const char __user *user_buf,
2390 size_t count, loff_t *ppos)
2391 {
2392 struct device *dev = ((struct seq_file *)(file->private_data))->private;
2393 unsigned long user_avg_sample;
2394 int err;
2395
2396 err = kstrtoul_from_user(user_buf, count, 0, &user_avg_sample);
2397 if (err)
2398 return err;
2399
2400 if ((user_avg_sample == SAMPLE_1) || (user_avg_sample == SAMPLE_4)
2401 || (user_avg_sample == SAMPLE_8)
2402 || (user_avg_sample == SAMPLE_16)) {
2403 avg_sample = (u8) user_avg_sample;
2404 } else {
2405 dev_err(dev,
2406 "debugfs err input: should be egal to 1, 4, 8 or 16\n");
2407 return -EINVAL;
2408 }
2409
2410 return count;
2411 }
2412
2413 static const struct file_operations ab8500_gpadc_avg_sample_fops = {
2414 .open = ab8500_gpadc_avg_sample_open,
2415 .read = seq_read,
2416 .write = ab8500_gpadc_avg_sample_write,
2417 .llseek = seq_lseek,
2418 .release = single_release,
2419 .owner = THIS_MODULE,
2420 };
2421
2422 static int ab8500_gpadc_trig_edge_print(struct seq_file *s, void *p)
2423 {
2424 seq_printf(s, "%d\n", trig_edge);
2425
2426 return 0;
2427 }
2428
2429 static int ab8500_gpadc_trig_edge_open(struct inode *inode, struct file *file)
2430 {
2431 return single_open(file, ab8500_gpadc_trig_edge_print,
2432 inode->i_private);
2433 }
2434
2435 static ssize_t ab8500_gpadc_trig_edge_write(struct file *file,
2436 const char __user *user_buf,
2437 size_t count, loff_t *ppos)
2438 {
2439 struct device *dev = ((struct seq_file *)(file->private_data))->private;
2440 unsigned long user_trig_edge;
2441 int err;
2442
2443 err = kstrtoul_from_user(user_buf, count, 0, &user_trig_edge);
2444 if (err)
2445 return err;
2446
2447 if ((user_trig_edge == RISING_EDGE)
2448 || (user_trig_edge == FALLING_EDGE)) {
2449 trig_edge = (u8) user_trig_edge;
2450 } else {
2451 dev_err(dev, "Wrong input:\n"
2452 "Enter 0. Rising edge\n"
2453 "Enter 1. Falling edge\n");
2454 return -EINVAL;
2455 }
2456
2457 return count;
2458 }
2459
2460 static const struct file_operations ab8500_gpadc_trig_edge_fops = {
2461 .open = ab8500_gpadc_trig_edge_open,
2462 .read = seq_read,
2463 .write = ab8500_gpadc_trig_edge_write,
2464 .llseek = seq_lseek,
2465 .release = single_release,
2466 .owner = THIS_MODULE,
2467 };
2468
2469 static int ab8500_gpadc_trig_timer_print(struct seq_file *s, void *p)
2470 {
2471 seq_printf(s, "%d\n", trig_timer);
2472
2473 return 0;
2474 }
2475
2476 static int ab8500_gpadc_trig_timer_open(struct inode *inode, struct file *file)
2477 {
2478 return single_open(file, ab8500_gpadc_trig_timer_print,
2479 inode->i_private);
2480 }
2481
2482 static ssize_t ab8500_gpadc_trig_timer_write(struct file *file,
2483 const char __user *user_buf,
2484 size_t count, loff_t *ppos)
2485 {
2486 struct device *dev = ((struct seq_file *)(file->private_data))->private;
2487 unsigned long user_trig_timer;
2488 int err;
2489
2490 err = kstrtoul_from_user(user_buf, count, 0, &user_trig_timer);
2491 if (err)
2492 return err;
2493
2494 if (user_trig_timer & ~0xFF) {
2495 dev_err(dev,
2496 "debugfs error input: should be between 0 to 255\n");
2497 return -EINVAL;
2498 }
2499
2500 trig_timer = (u8) user_trig_timer;
2501
2502 return count;
2503 }
2504
2505 static const struct file_operations ab8500_gpadc_trig_timer_fops = {
2506 .open = ab8500_gpadc_trig_timer_open,
2507 .read = seq_read,
2508 .write = ab8500_gpadc_trig_timer_write,
2509 .llseek = seq_lseek,
2510 .release = single_release,
2511 .owner = THIS_MODULE,
2512 };
2513
2514 static int ab8500_gpadc_conv_type_print(struct seq_file *s, void *p)
2515 {
2516 seq_printf(s, "%d\n", conv_type);
2517
2518 return 0;
2519 }
2520
2521 static int ab8500_gpadc_conv_type_open(struct inode *inode, struct file *file)
2522 {
2523 return single_open(file, ab8500_gpadc_conv_type_print,
2524 inode->i_private);
2525 }
2526
2527 static ssize_t ab8500_gpadc_conv_type_write(struct file *file,
2528 const char __user *user_buf,
2529 size_t count, loff_t *ppos)
2530 {
2531 struct device *dev = ((struct seq_file *)(file->private_data))->private;
2532 unsigned long user_conv_type;
2533 int err;
2534
2535 err = kstrtoul_from_user(user_buf, count, 0, &user_conv_type);
2536 if (err)
2537 return err;
2538
2539 if ((user_conv_type == ADC_SW)
2540 || (user_conv_type == ADC_HW)) {
2541 conv_type = (u8) user_conv_type;
2542 } else {
2543 dev_err(dev, "Wrong input:\n"
2544 "Enter 0. ADC SW conversion\n"
2545 "Enter 1. ADC HW conversion\n");
2546 return -EINVAL;
2547 }
2548
2549 return count;
2550 }
2551
2552 static const struct file_operations ab8500_gpadc_conv_type_fops = {
2553 .open = ab8500_gpadc_conv_type_open,
2554 .read = seq_read,
2555 .write = ab8500_gpadc_conv_type_write,
2556 .llseek = seq_lseek,
2557 .release = single_release,
2558 .owner = THIS_MODULE,
2559 };
2560
2561 /*
2562 * return length of an ASCII numerical value, 0 is string is not a
2563 * numerical value.
2564 * string shall start at value 1st char.
2565 * string can be tailed with \0 or space or newline chars only.
2566 * value can be decimal or hexadecimal (prefixed 0x or 0X).
2567 */
2568 static int strval_len(char *b)
2569 {
2570 char *s = b;
2571
2572 if ((*s == '0') && ((*(s+1) == 'x') || (*(s+1) == 'X'))) {
2573 s += 2;
2574 for (; *s && (*s != ' ') && (*s != '\n'); s++) {
2575 if (!isxdigit(*s))
2576 return 0;
2577 }
2578 } else {
2579 if (*s == '-')
2580 s++;
2581 for (; *s && (*s != ' ') && (*s != '\n'); s++) {
2582 if (!isdigit(*s))
2583 return 0;
2584 }
2585 }
2586 return (int) (s-b);
2587 }
2588
2589 /*
2590 * parse hwreg input data.
2591 * update global hwreg_cfg only if input data syntax is ok.
2592 */
2593 static ssize_t hwreg_common_write(char *b, struct hwreg_cfg *cfg,
2594 struct device *dev)
2595 {
2596 uint write, val = 0;
2597 u8 regvalue;
2598 int ret;
2599 struct hwreg_cfg loc = {
2600 .bank = 0, /* default: invalid phys addr */
2601 .addr = 0, /* default: invalid phys addr */
2602 .fmt = 0, /* default: 32bit access, hex output */
2603 .mask = 0xFFFFFFFF, /* default: no mask */
2604 .shift = 0, /* default: no bit shift */
2605 };
2606
2607 /* read or write ? */
2608 if (!strncmp(b, "read ", 5)) {
2609 write = 0;
2610 b += 5;
2611 } else if (!strncmp(b, "write ", 6)) {
2612 write = 1;
2613 b += 6;
2614 } else
2615 return -EINVAL;
2616
2617 /* OPTIONS -l|-w|-b -s -m -o */
2618 while ((*b == ' ') || (*b == '-')) {
2619 if (*(b-1) != ' ') {
2620 b++;
2621 continue;
2622 }
2623 if ((!strncmp(b, "-d ", 3)) ||
2624 (!strncmp(b, "-dec ", 5))) {
2625 b += (*(b+2) == ' ') ? 3 : 5;
2626 loc.fmt |= (1<<0);
2627 } else if ((!strncmp(b, "-h ", 3)) ||
2628 (!strncmp(b, "-hex ", 5))) {
2629 b += (*(b+2) == ' ') ? 3 : 5;
2630 loc.fmt &= ~(1<<0);
2631 } else if ((!strncmp(b, "-m ", 3)) ||
2632 (!strncmp(b, "-mask ", 6))) {
2633 b += (*(b+2) == ' ') ? 3 : 6;
2634 if (strval_len(b) == 0)
2635 return -EINVAL;
2636 ret = kstrtoul(b, 0, &loc.mask);
2637 if (ret)
2638 return ret;
2639 } else if ((!strncmp(b, "-s ", 3)) ||
2640 (!strncmp(b, "-shift ", 7))) {
2641 b += (*(b+2) == ' ') ? 3 : 7;
2642 if (strval_len(b) == 0)
2643 return -EINVAL;
2644 ret = kstrtol(b, 0, &loc.shift);
2645 if (ret)
2646 return ret;
2647 } else {
2648 return -EINVAL;
2649 }
2650 }
2651 /* get arg BANK and ADDRESS */
2652 if (strval_len(b) == 0)
2653 return -EINVAL;
2654 ret = kstrtouint(b, 0, &loc.bank);
2655 if (ret)
2656 return ret;
2657 while (*b == ' ')
2658 b++;
2659 if (strval_len(b) == 0)
2660 return -EINVAL;
2661 ret = kstrtoul(b, 0, &loc.addr);
2662 if (ret)
2663 return ret;
2664
2665 if (write) {
2666 while (*b == ' ')
2667 b++;
2668 if (strval_len(b) == 0)
2669 return -EINVAL;
2670 ret = kstrtouint(b, 0, &val);
2671 if (ret)
2672 return ret;
2673 }
2674
2675 /* args are ok, update target cfg (mainly for read) */
2676 *cfg = loc;
2677
2678 #ifdef ABB_HWREG_DEBUG
2679 pr_warn("HWREG request: %s, %s,\n", (write) ? "write" : "read",
2680 REG_FMT_DEC(cfg) ? "decimal" : "hexa");
2681 pr_warn(" addr=0x%08X, mask=0x%X, shift=%d" "value=0x%X\n",
2682 cfg->addr, cfg->mask, cfg->shift, val);
2683 #endif
2684
2685 if (!write)
2686 return 0;
2687
2688 ret = abx500_get_register_interruptible(dev,
2689 (u8)cfg->bank, (u8)cfg->addr, &regvalue);
2690 if (ret < 0) {
2691 dev_err(dev, "abx500_get_reg fail %d, %d\n",
2692 ret, __LINE__);
2693 return -EINVAL;
2694 }
2695
2696 if (cfg->shift >= 0) {
2697 regvalue &= ~(cfg->mask << (cfg->shift));
2698 val = (val & cfg->mask) << (cfg->shift);
2699 } else {
2700 regvalue &= ~(cfg->mask >> (-cfg->shift));
2701 val = (val & cfg->mask) >> (-cfg->shift);
2702 }
2703 val = val | regvalue;
2704
2705 ret = abx500_set_register_interruptible(dev,
2706 (u8)cfg->bank, (u8)cfg->addr, (u8)val);
2707 if (ret < 0) {
2708 pr_err("abx500_set_reg failed %d, %d", ret, __LINE__);
2709 return -EINVAL;
2710 }
2711
2712 return 0;
2713 }
2714
2715 static ssize_t ab8500_hwreg_write(struct file *file,
2716 const char __user *user_buf, size_t count, loff_t *ppos)
2717 {
2718 struct device *dev = ((struct seq_file *)(file->private_data))->private;
2719 char buf[128];
2720 int buf_size, ret;
2721
2722 /* Get userspace string and assure termination */
2723 buf_size = min(count, (sizeof(buf)-1));
2724 if (copy_from_user(buf, user_buf, buf_size))
2725 return -EFAULT;
2726 buf[buf_size] = 0;
2727
2728 /* get args and process */
2729 ret = hwreg_common_write(buf, &hwreg_cfg, dev);
2730 return (ret) ? ret : buf_size;
2731 }
2732
2733 /*
2734 * - irq subscribe/unsubscribe stuff
2735 */
2736 static int ab8500_subscribe_unsubscribe_print(struct seq_file *s, void *p)
2737 {
2738 seq_printf(s, "%d\n", irq_first);
2739
2740 return 0;
2741 }
2742
2743 static int ab8500_subscribe_unsubscribe_open(struct inode *inode,
2744 struct file *file)
2745 {
2746 return single_open(file, ab8500_subscribe_unsubscribe_print,
2747 inode->i_private);
2748 }
2749
2750 /*
2751 * Userspace should use poll() on this file. When an event occur
2752 * the blocking poll will be released.
2753 */
2754 static ssize_t show_irq(struct device *dev,
2755 struct device_attribute *attr, char *buf)
2756 {
2757 unsigned long name;
2758 unsigned int irq_index;
2759 int err;
2760
2761 err = kstrtoul(attr->attr.name, 0, &name);
2762 if (err)
2763 return err;
2764
2765 irq_index = name - irq_first;
2766 if (irq_index >= num_irqs)
2767 return -EINVAL;
2768
2769 return sprintf(buf, "%u\n", irq_count[irq_index]);
2770 }
2771
2772 static ssize_t ab8500_subscribe_write(struct file *file,
2773 const char __user *user_buf,
2774 size_t count, loff_t *ppos)
2775 {
2776 struct device *dev = ((struct seq_file *)(file->private_data))->private;
2777 unsigned long user_val;
2778 int err;
2779 unsigned int irq_index;
2780
2781 err = kstrtoul_from_user(user_buf, count, 0, &user_val);
2782 if (err)
2783 return err;
2784
2785 if (user_val < irq_first) {
2786 dev_err(dev, "debugfs error input < %d\n", irq_first);
2787 return -EINVAL;
2788 }
2789 if (user_val > irq_last) {
2790 dev_err(dev, "debugfs error input > %d\n", irq_last);
2791 return -EINVAL;
2792 }
2793
2794 irq_index = user_val - irq_first;
2795 if (irq_index >= num_irqs)
2796 return -EINVAL;
2797
2798 /*
2799 * This will create a sysfs file named <irq-nr> which userspace can
2800 * use to select or poll and get the AB8500 events
2801 */
2802 dev_attr[irq_index] = kmalloc(sizeof(struct device_attribute),
2803 GFP_KERNEL);
2804 if (!dev_attr[irq_index])
2805 return -ENOMEM;
2806
2807 event_name[irq_index] = kmalloc(count, GFP_KERNEL);
2808 if (!event_name[irq_index])
2809 return -ENOMEM;
2810
2811 sprintf(event_name[irq_index], "%lu", user_val);
2812 dev_attr[irq_index]->show = show_irq;
2813 dev_attr[irq_index]->store = NULL;
2814 dev_attr[irq_index]->attr.name = event_name[irq_index];
2815 dev_attr[irq_index]->attr.mode = S_IRUGO;
2816 err = sysfs_create_file(&dev->kobj, &dev_attr[irq_index]->attr);
2817 if (err < 0) {
2818 pr_info("sysfs_create_file failed %d\n", err);
2819 return err;
2820 }
2821
2822 err = request_threaded_irq(user_val, NULL, ab8500_debug_handler,
2823 IRQF_SHARED | IRQF_NO_SUSPEND | IRQF_ONESHOT,
2824 "ab8500-debug", &dev->kobj);
2825 if (err < 0) {
2826 pr_info("request_threaded_irq failed %d, %lu\n",
2827 err, user_val);
2828 sysfs_remove_file(&dev->kobj, &dev_attr[irq_index]->attr);
2829 return err;
2830 }
2831
2832 return count;
2833 }
2834
2835 static ssize_t ab8500_unsubscribe_write(struct file *file,
2836 const char __user *user_buf,
2837 size_t count, loff_t *ppos)
2838 {
2839 struct device *dev = ((struct seq_file *)(file->private_data))->private;
2840 unsigned long user_val;
2841 int err;
2842 unsigned int irq_index;
2843
2844 err = kstrtoul_from_user(user_buf, count, 0, &user_val);
2845 if (err)
2846 return err;
2847
2848 if (user_val < irq_first) {
2849 dev_err(dev, "debugfs error input < %d\n", irq_first);
2850 return -EINVAL;
2851 }
2852 if (user_val > irq_last) {
2853 dev_err(dev, "debugfs error input > %d\n", irq_last);
2854 return -EINVAL;
2855 }
2856
2857 irq_index = user_val - irq_first;
2858 if (irq_index >= num_irqs)
2859 return -EINVAL;
2860
2861 /* Set irq count to 0 when unsubscribe */
2862 irq_count[irq_index] = 0;
2863
2864 if (dev_attr[irq_index])
2865 sysfs_remove_file(&dev->kobj, &dev_attr[irq_index]->attr);
2866
2867
2868 free_irq(user_val, &dev->kobj);
2869 kfree(event_name[irq_index]);
2870 kfree(dev_attr[irq_index]);
2871
2872 return count;
2873 }
2874
2875 /*
2876 * - several deubgfs nodes fops
2877 */
2878
2879 static const struct file_operations ab8500_bank_fops = {
2880 .open = ab8500_bank_open,
2881 .write = ab8500_bank_write,
2882 .read = seq_read,
2883 .llseek = seq_lseek,
2884 .release = single_release,
2885 .owner = THIS_MODULE,
2886 };
2887
2888 static const struct file_operations ab8500_address_fops = {
2889 .open = ab8500_address_open,
2890 .write = ab8500_address_write,
2891 .read = seq_read,
2892 .llseek = seq_lseek,
2893 .release = single_release,
2894 .owner = THIS_MODULE,
2895 };
2896
2897 static const struct file_operations ab8500_val_fops = {
2898 .open = ab8500_val_open,
2899 .write = ab8500_val_write,
2900 .read = seq_read,
2901 .llseek = seq_lseek,
2902 .release = single_release,
2903 .owner = THIS_MODULE,
2904 };
2905
2906 static const struct file_operations ab8500_interrupts_fops = {
2907 .open = ab8500_interrupts_open,
2908 .read = seq_read,
2909 .llseek = seq_lseek,
2910 .release = single_release,
2911 .owner = THIS_MODULE,
2912 };
2913
2914 static const struct file_operations ab8500_subscribe_fops = {
2915 .open = ab8500_subscribe_unsubscribe_open,
2916 .write = ab8500_subscribe_write,
2917 .read = seq_read,
2918 .llseek = seq_lseek,
2919 .release = single_release,
2920 .owner = THIS_MODULE,
2921 };
2922
2923 static const struct file_operations ab8500_unsubscribe_fops = {
2924 .open = ab8500_subscribe_unsubscribe_open,
2925 .write = ab8500_unsubscribe_write,
2926 .read = seq_read,
2927 .llseek = seq_lseek,
2928 .release = single_release,
2929 .owner = THIS_MODULE,
2930 };
2931
2932 static const struct file_operations ab8500_hwreg_fops = {
2933 .open = ab8500_hwreg_open,
2934 .write = ab8500_hwreg_write,
2935 .read = seq_read,
2936 .llseek = seq_lseek,
2937 .release = single_release,
2938 .owner = THIS_MODULE,
2939 };
2940
2941 static struct dentry *ab8500_dir;
2942 static struct dentry *ab8500_gpadc_dir;
2943
2944 static int ab8500_debug_probe(struct platform_device *plf)
2945 {
2946 struct dentry *file;
2947 struct ab8500 *ab8500;
2948 struct resource *res;
2949
2950 debug_bank = AB8500_MISC;
2951 debug_address = AB8500_REV_REG & 0x00FF;
2952
2953 ab8500 = dev_get_drvdata(plf->dev.parent);
2954 num_irqs = ab8500->mask_size;
2955
2956 irq_count = devm_kzalloc(&plf->dev,
2957 sizeof(*irq_count)*num_irqs, GFP_KERNEL);
2958 if (!irq_count)
2959 return -ENOMEM;
2960
2961 dev_attr = devm_kzalloc(&plf->dev,
2962 sizeof(*dev_attr)*num_irqs, GFP_KERNEL);
2963 if (!dev_attr)
2964 return -ENOMEM;
2965
2966 event_name = devm_kzalloc(&plf->dev,
2967 sizeof(*event_name)*num_irqs, GFP_KERNEL);
2968 if (!event_name)
2969 return -ENOMEM;
2970
2971 res = platform_get_resource_byname(plf, 0, "IRQ_AB8500");
2972 if (!res) {
2973 dev_err(&plf->dev, "AB8500 irq not found, err %d\n", irq_first);
2974 return -ENXIO;
2975 }
2976 irq_ab8500 = res->start;
2977
2978 irq_first = platform_get_irq_byname(plf, "IRQ_FIRST");
2979 if (irq_first < 0) {
2980 dev_err(&plf->dev, "First irq not found, err %d\n", irq_first);
2981 return irq_first;
2982 }
2983
2984 irq_last = platform_get_irq_byname(plf, "IRQ_LAST");
2985 if (irq_last < 0) {
2986 dev_err(&plf->dev, "Last irq not found, err %d\n", irq_last);
2987 return irq_last;
2988 }
2989
2990 ab8500_dir = debugfs_create_dir(AB8500_NAME_STRING, NULL);
2991 if (!ab8500_dir)
2992 goto err;
2993
2994 ab8500_gpadc_dir = debugfs_create_dir(AB8500_ADC_NAME_STRING,
2995 ab8500_dir);
2996 if (!ab8500_gpadc_dir)
2997 goto err;
2998
2999 file = debugfs_create_file("all-bank-registers", S_IRUGO, ab8500_dir,
3000 &plf->dev, &ab8500_registers_fops);
3001 if (!file)
3002 goto err;
3003
3004 file = debugfs_create_file("all-banks", S_IRUGO, ab8500_dir,
3005 &plf->dev, &ab8500_all_banks_fops);
3006 if (!file)
3007 goto err;
3008
3009 file = debugfs_create_file("register-bank",
3010 (S_IRUGO | S_IWUSR | S_IWGRP),
3011 ab8500_dir, &plf->dev, &ab8500_bank_fops);
3012 if (!file)
3013 goto err;
3014
3015 file = debugfs_create_file("register-address",
3016 (S_IRUGO | S_IWUSR | S_IWGRP),
3017 ab8500_dir, &plf->dev, &ab8500_address_fops);
3018 if (!file)
3019 goto err;
3020
3021 file = debugfs_create_file("register-value",
3022 (S_IRUGO | S_IWUSR | S_IWGRP),
3023 ab8500_dir, &plf->dev, &ab8500_val_fops);
3024 if (!file)
3025 goto err;
3026
3027 file = debugfs_create_file("irq-subscribe",
3028 (S_IRUGO | S_IWUSR | S_IWGRP), ab8500_dir,
3029 &plf->dev, &ab8500_subscribe_fops);
3030 if (!file)
3031 goto err;
3032
3033 if (is_ab8500(ab8500)) {
3034 debug_ranges = ab8500_debug_ranges;
3035 num_interrupt_lines = AB8500_NR_IRQS;
3036 } else if (is_ab8505(ab8500)) {
3037 debug_ranges = ab8505_debug_ranges;
3038 num_interrupt_lines = AB8505_NR_IRQS;
3039 } else if (is_ab9540(ab8500)) {
3040 debug_ranges = ab8505_debug_ranges;
3041 num_interrupt_lines = AB9540_NR_IRQS;
3042 } else if (is_ab8540(ab8500)) {
3043 debug_ranges = ab8540_debug_ranges;
3044 num_interrupt_lines = AB8540_NR_IRQS;
3045 }
3046
3047 file = debugfs_create_file("interrupts", (S_IRUGO), ab8500_dir,
3048 &plf->dev, &ab8500_interrupts_fops);
3049 if (!file)
3050 goto err;
3051
3052 file = debugfs_create_file("irq-unsubscribe",
3053 (S_IRUGO | S_IWUSR | S_IWGRP), ab8500_dir,
3054 &plf->dev, &ab8500_unsubscribe_fops);
3055 if (!file)
3056 goto err;
3057
3058 file = debugfs_create_file("hwreg", (S_IRUGO | S_IWUSR | S_IWGRP),
3059 ab8500_dir, &plf->dev, &ab8500_hwreg_fops);
3060 if (!file)
3061 goto err;
3062
3063 file = debugfs_create_file("all-modem-registers",
3064 (S_IRUGO | S_IWUSR | S_IWGRP),
3065 ab8500_dir, &plf->dev, &ab8500_modem_fops);
3066 if (!file)
3067 goto err;
3068
3069 file = debugfs_create_file("bat_ctrl", (S_IRUGO | S_IWUSR | S_IWGRP),
3070 ab8500_gpadc_dir, &plf->dev,
3071 &ab8500_gpadc_bat_ctrl_fops);
3072 if (!file)
3073 goto err;
3074
3075 file = debugfs_create_file("btemp_ball", (S_IRUGO | S_IWUSR | S_IWGRP),
3076 ab8500_gpadc_dir,
3077 &plf->dev, &ab8500_gpadc_btemp_ball_fops);
3078 if (!file)
3079 goto err;
3080
3081 file = debugfs_create_file("main_charger_v",
3082 (S_IRUGO | S_IWUSR | S_IWGRP),
3083 ab8500_gpadc_dir, &plf->dev,
3084 &ab8500_gpadc_main_charger_v_fops);
3085 if (!file)
3086 goto err;
3087
3088 file = debugfs_create_file("acc_detect1",
3089 (S_IRUGO | S_IWUSR | S_IWGRP),
3090 ab8500_gpadc_dir, &plf->dev,
3091 &ab8500_gpadc_acc_detect1_fops);
3092 if (!file)
3093 goto err;
3094
3095 file = debugfs_create_file("acc_detect2",
3096 (S_IRUGO | S_IWUSR | S_IWGRP),
3097 ab8500_gpadc_dir, &plf->dev,
3098 &ab8500_gpadc_acc_detect2_fops);
3099 if (!file)
3100 goto err;
3101
3102 file = debugfs_create_file("adc_aux1", (S_IRUGO | S_IWUSR | S_IWGRP),
3103 ab8500_gpadc_dir, &plf->dev,
3104 &ab8500_gpadc_aux1_fops);
3105 if (!file)
3106 goto err;
3107
3108 file = debugfs_create_file("adc_aux2", (S_IRUGO | S_IWUSR | S_IWGRP),
3109 ab8500_gpadc_dir, &plf->dev,
3110 &ab8500_gpadc_aux2_fops);
3111 if (!file)
3112 goto err;
3113
3114 file = debugfs_create_file("main_bat_v", (S_IRUGO | S_IWUSR | S_IWGRP),
3115 ab8500_gpadc_dir, &plf->dev,
3116 &ab8500_gpadc_main_bat_v_fops);
3117 if (!file)
3118 goto err;
3119
3120 file = debugfs_create_file("vbus_v", (S_IRUGO | S_IWUSR | S_IWGRP),
3121 ab8500_gpadc_dir, &plf->dev,
3122 &ab8500_gpadc_vbus_v_fops);
3123 if (!file)
3124 goto err;
3125
3126 file = debugfs_create_file("main_charger_c",
3127 (S_IRUGO | S_IWUSR | S_IWGRP),
3128 ab8500_gpadc_dir, &plf->dev,
3129 &ab8500_gpadc_main_charger_c_fops);
3130 if (!file)
3131 goto err;
3132
3133 file = debugfs_create_file("usb_charger_c",
3134 (S_IRUGO | S_IWUSR | S_IWGRP),
3135 ab8500_gpadc_dir,
3136 &plf->dev, &ab8500_gpadc_usb_charger_c_fops);
3137 if (!file)
3138 goto err;
3139
3140 file = debugfs_create_file("bk_bat_v", (S_IRUGO | S_IWUSR | S_IWGRP),
3141 ab8500_gpadc_dir, &plf->dev,
3142 &ab8500_gpadc_bk_bat_v_fops);
3143 if (!file)
3144 goto err;
3145
3146 file = debugfs_create_file("die_temp", (S_IRUGO | S_IWUSR | S_IWGRP),
3147 ab8500_gpadc_dir, &plf->dev,
3148 &ab8500_gpadc_die_temp_fops);
3149 if (!file)
3150 goto err;
3151
3152 file = debugfs_create_file("usb_id", (S_IRUGO | S_IWUSR | S_IWGRP),
3153 ab8500_gpadc_dir, &plf->dev,
3154 &ab8500_gpadc_usb_id_fops);
3155 if (!file)
3156 goto err;
3157
3158 if (is_ab8540(ab8500)) {
3159 file = debugfs_create_file("xtal_temp",
3160 (S_IRUGO | S_IWUSR | S_IWGRP),
3161 ab8500_gpadc_dir, &plf->dev,
3162 &ab8540_gpadc_xtal_temp_fops);
3163 if (!file)
3164 goto err;
3165 file = debugfs_create_file("vbattruemeas",
3166 (S_IRUGO | S_IWUSR | S_IWGRP),
3167 ab8500_gpadc_dir, &plf->dev,
3168 &ab8540_gpadc_vbat_true_meas_fops);
3169 if (!file)
3170 goto err;
3171 file = debugfs_create_file("batctrl_and_ibat",
3172 (S_IRUGO | S_IWUGO),
3173 ab8500_gpadc_dir,
3174 &plf->dev,
3175 &ab8540_gpadc_bat_ctrl_and_ibat_fops);
3176 if (!file)
3177 goto err;
3178 file = debugfs_create_file("vbatmeas_and_ibat",
3179 (S_IRUGO | S_IWUGO),
3180 ab8500_gpadc_dir, &plf->dev,
3181 &ab8540_gpadc_vbat_meas_and_ibat_fops);
3182 if (!file)
3183 goto err;
3184 file = debugfs_create_file("vbattruemeas_and_ibat",
3185 (S_IRUGO | S_IWUGO),
3186 ab8500_gpadc_dir,
3187 &plf->dev,
3188 &ab8540_gpadc_vbat_true_meas_and_ibat_fops);
3189 if (!file)
3190 goto err;
3191 file = debugfs_create_file("battemp_and_ibat",
3192 (S_IRUGO | S_IWUGO),
3193 ab8500_gpadc_dir,
3194 &plf->dev, &ab8540_gpadc_bat_temp_and_ibat_fops);
3195 if (!file)
3196 goto err;
3197 file = debugfs_create_file("otp_calib",
3198 (S_IRUGO | S_IWUSR | S_IWGRP),
3199 ab8500_gpadc_dir,
3200 &plf->dev, &ab8540_gpadc_otp_calib_fops);
3201 if (!file)
3202 goto err;
3203 }
3204 file = debugfs_create_file("avg_sample", (S_IRUGO | S_IWUSR | S_IWGRP),
3205 ab8500_gpadc_dir, &plf->dev,
3206 &ab8500_gpadc_avg_sample_fops);
3207 if (!file)
3208 goto err;
3209
3210 file = debugfs_create_file("trig_edge", (S_IRUGO | S_IWUSR | S_IWGRP),
3211 ab8500_gpadc_dir, &plf->dev,
3212 &ab8500_gpadc_trig_edge_fops);
3213 if (!file)
3214 goto err;
3215
3216 file = debugfs_create_file("trig_timer", (S_IRUGO | S_IWUSR | S_IWGRP),
3217 ab8500_gpadc_dir, &plf->dev,
3218 &ab8500_gpadc_trig_timer_fops);
3219 if (!file)
3220 goto err;
3221
3222 file = debugfs_create_file("conv_type", (S_IRUGO | S_IWUSR | S_IWGRP),
3223 ab8500_gpadc_dir, &plf->dev,
3224 &ab8500_gpadc_conv_type_fops);
3225 if (!file)
3226 goto err;
3227
3228 return 0;
3229
3230 err:
3231 debugfs_remove_recursive(ab8500_dir);
3232 dev_err(&plf->dev, "failed to create debugfs entries.\n");
3233
3234 return -ENOMEM;
3235 }
3236
3237 static int ab8500_debug_remove(struct platform_device *plf)
3238 {
3239 debugfs_remove_recursive(ab8500_dir);
3240
3241 return 0;
3242 }
3243
3244 static struct platform_driver ab8500_debug_driver = {
3245 .driver = {
3246 .name = "ab8500-debug",
3247 },
3248 .probe = ab8500_debug_probe,
3249 .remove = ab8500_debug_remove
3250 };
3251
3252 static int __init ab8500_debug_init(void)
3253 {
3254 return platform_driver_register(&ab8500_debug_driver);
3255 }
3256
3257 static void __exit ab8500_debug_exit(void)
3258 {
3259 platform_driver_unregister(&ab8500_debug_driver);
3260 }
3261 subsys_initcall(ab8500_debug_init);
3262 module_exit(ab8500_debug_exit);
3263
3264 MODULE_AUTHOR("Mattias WALLIN <mattias.wallin@stericsson.com");
3265 MODULE_DESCRIPTION("AB8500 DEBUG");
3266 MODULE_LICENSE("GPL v2");
Ubuntu Artful kernel mirror