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