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