?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ARM: 8228/1: sa1100: drop entry-macro.S
[linux-2.6/btrfs-unstable.git] / drivers / mfd / ab8500-debugfs.c
blobb2c7e3b1edfabce7500c84f3388f58ebc9344059
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 err = seq_printf(s,
1308 " [0x%02X/0x%02X]: 0x%02X\n",
1309 bank, reg, value);
1310 if (err < 0) {
1311 /* Error is not returned here since
1312 * the output is wanted in any case */
1313 return 0;
1314 }
1315 } else {
1316 dev_info(dev, " [0x%02X/0x%02X]: 0x%02X\n",
1317 bank, reg, value);
1318 }
1319 }
1320 }
1321 return 0;
1322 }
1323
1324 static int ab8500_print_bank_registers(struct seq_file *s, void *p)
1325 {
1326 struct device *dev = s->private;
1327 u32 bank = debug_bank;
1328
1329 seq_puts(s, AB8500_NAME_STRING " register values:\n");
1330
1331 seq_printf(s, " bank 0x%02X:\n", bank);
1332
1333 ab8500_registers_print(dev, bank, s);
1334 return 0;
1335 }
1336
1337 static int ab8500_registers_open(struct inode *inode, struct file *file)
1338 {
1339 return single_open(file, ab8500_print_bank_registers, inode->i_private);
1340 }
1341
1342 static const struct file_operations ab8500_registers_fops = {
1343 .open = ab8500_registers_open,
1344 .read = seq_read,
1345 .llseek = seq_lseek,
1346 .release = single_release,
1347 .owner = THIS_MODULE,
1348 };
1349
1350 static int ab8500_print_all_banks(struct seq_file *s, void *p)
1351 {
1352 struct device *dev = s->private;
1353 unsigned int i;
1354
1355 seq_puts(s, AB8500_NAME_STRING " register values:\n");
1356
1357 for (i = 0; i < AB8500_NUM_BANKS; i++) {
1358 seq_printf(s, " bank 0x%02X:\n", i);
1359
1360 ab8500_registers_print(dev, i, s);
1361 }
1362 return 0;
1363 }
1364
1365 /* Dump registers to kernel log */
1366 void ab8500_dump_all_banks(struct device *dev)
1367 {
1368 unsigned int i;
1369
1370 dev_info(dev, "ab8500 register values:\n");
1371
1372 for (i = 1; i < AB8500_NUM_BANKS; i++) {
1373 dev_info(dev, " bank 0x%02X:\n", i);
1374 ab8500_registers_print(dev, i, NULL);
1375 }
1376 }
1377
1378 /* Space for 500 registers. */
1379 #define DUMP_MAX_REGS 700
1380 static struct ab8500_register_dump
1381 {
1382 u8 bank;
1383 u8 reg;
1384 u8 value;
1385 } ab8500_complete_register_dump[DUMP_MAX_REGS];
1386
1387 /* This shall only be called upon kernel panic! */
1388 void ab8500_dump_all_banks_to_mem(void)
1389 {
1390 int i, r = 0;
1391 u8 bank;
1392 int err = 0;
1393
1394 pr_info("Saving all ABB registers for crash analysis.\n");
1395
1396 for (bank = 0; bank < AB8500_NUM_BANKS; bank++) {
1397 for (i = 0; i < debug_ranges[bank].num_ranges; i++) {
1398 u8 reg;
1399
1400 for (reg = debug_ranges[bank].range[i].first;
1401 reg <= debug_ranges[bank].range[i].last;
1402 reg++) {
1403 u8 value;
1404
1405 err = prcmu_abb_read(bank, reg, &value, 1);
1406
1407 if (err < 0)
1408 goto out;
1409
1410 ab8500_complete_register_dump[r].bank = bank;
1411 ab8500_complete_register_dump[r].reg = reg;
1412 ab8500_complete_register_dump[r].value = value;
1413
1414 r++;
1415
1416 if (r >= DUMP_MAX_REGS) {
1417 pr_err("%s: too many register to dump!\n",
1418 __func__);
1419 err = -EINVAL;
1420 goto out;
1421 }
1422 }
1423 }
1424 }
1425 out:
1426 if (err >= 0)
1427 pr_info("Saved all ABB registers.\n");
1428 else
1429 pr_info("Failed to save all ABB registers.\n");
1430 }
1431
1432 static int ab8500_all_banks_open(struct inode *inode, struct file *file)
1433 {
1434 struct seq_file *s;
1435 int err;
1436
1437 err = single_open(file, ab8500_print_all_banks, inode->i_private);
1438 if (!err) {
1439 /* Default buf size in seq_read is not enough */
1440 s = (struct seq_file *)file->private_data;
1441 s->size = (PAGE_SIZE * 2);
1442 s->buf = kmalloc(s->size, GFP_KERNEL);
1443 if (!s->buf) {
1444 single_release(inode, file);
1445 err = -ENOMEM;
1446 }
1447 }
1448 return err;
1449 }
1450
1451 static const struct file_operations ab8500_all_banks_fops = {
1452 .open = ab8500_all_banks_open,
1453 .read = seq_read,
1454 .llseek = seq_lseek,
1455 .release = single_release,
1456 .owner = THIS_MODULE,
1457 };
1458
1459 static int ab8500_bank_print(struct seq_file *s, void *p)
1460 {
1461 return seq_printf(s, "0x%02X\n", debug_bank);
1462 }
1463
1464 static int ab8500_bank_open(struct inode *inode, struct file *file)
1465 {
1466 return single_open(file, ab8500_bank_print, inode->i_private);
1467 }
1468
1469 static ssize_t ab8500_bank_write(struct file *file,
1470 const char __user *user_buf,
1471 size_t count, loff_t *ppos)
1472 {
1473 struct device *dev = ((struct seq_file *)(file->private_data))->private;
1474 unsigned long user_bank;
1475 int err;
1476
1477 err = kstrtoul_from_user(user_buf, count, 0, &user_bank);
1478 if (err)
1479 return err;
1480
1481 if (user_bank >= AB8500_NUM_BANKS) {
1482 dev_err(dev, "debugfs error input > number of banks\n");
1483 return -EINVAL;
1484 }
1485
1486 debug_bank = user_bank;
1487
1488 return count;
1489 }
1490
1491 static int ab8500_address_print(struct seq_file *s, void *p)
1492 {
1493 return seq_printf(s, "0x%02X\n", debug_address);
1494 }
1495
1496 static int ab8500_address_open(struct inode *inode, struct file *file)
1497 {
1498 return single_open(file, ab8500_address_print, inode->i_private);
1499 }
1500
1501 static ssize_t ab8500_address_write(struct file *file,
1502 const char __user *user_buf,
1503 size_t count, loff_t *ppos)
1504 {
1505 struct device *dev = ((struct seq_file *)(file->private_data))->private;
1506 unsigned long user_address;
1507 int err;
1508
1509 err = kstrtoul_from_user(user_buf, count, 0, &user_address);
1510 if (err)
1511 return err;
1512
1513 if (user_address > 0xff) {
1514 dev_err(dev, "debugfs error input > 0xff\n");
1515 return -EINVAL;
1516 }
1517 debug_address = user_address;
1518
1519 return count;
1520 }
1521
1522 static int ab8500_val_print(struct seq_file *s, void *p)
1523 {
1524 struct device *dev = s->private;
1525 int ret;
1526 u8 regvalue;
1527
1528 ret = abx500_get_register_interruptible(dev,
1529 (u8)debug_bank, (u8)debug_address, &regvalue);
1530 if (ret < 0) {
1531 dev_err(dev, "abx500_get_reg fail %d, %d\n",
1532 ret, __LINE__);
1533 return -EINVAL;
1534 }
1535 seq_printf(s, "0x%02X\n", regvalue);
1536
1537 return 0;
1538 }
1539
1540 static int ab8500_val_open(struct inode *inode, struct file *file)
1541 {
1542 return single_open(file, ab8500_val_print, inode->i_private);
1543 }
1544
1545 static ssize_t ab8500_val_write(struct file *file,
1546 const char __user *user_buf,
1547 size_t count, loff_t *ppos)
1548 {
1549 struct device *dev = ((struct seq_file *)(file->private_data))->private;
1550 unsigned long user_val;
1551 int err;
1552
1553 err = kstrtoul_from_user(user_buf, count, 0, &user_val);
1554 if (err)
1555 return err;
1556
1557 if (user_val > 0xff) {
1558 dev_err(dev, "debugfs error input > 0xff\n");
1559 return -EINVAL;
1560 }
1561 err = abx500_set_register_interruptible(dev,
1562 (u8)debug_bank, debug_address, (u8)user_val);
1563 if (err < 0) {
1564 pr_err("abx500_set_reg failed %d, %d", err, __LINE__);
1565 return -EINVAL;
1566 }
1567
1568 return count;
1569 }
1570
1571 /*
1572 * Interrupt status
1573 */
1574 static u32 num_interrupts[AB8500_MAX_NR_IRQS];
1575 static u32 num_wake_interrupts[AB8500_MAX_NR_IRQS];
1576 static int num_interrupt_lines;
1577
1578 bool __attribute__((weak)) suspend_test_wake_cause_interrupt_is_mine(u32 my_int)
1579 {
1580 return false;
1581 }
1582
1583 void ab8500_debug_register_interrupt(int line)
1584 {
1585 if (line < num_interrupt_lines) {
1586 num_interrupts[line]++;
1587 if (suspend_test_wake_cause_interrupt_is_mine(irq_ab8500))
1588 num_wake_interrupts[line]++;
1589 }
1590 }
1591
1592 static int ab8500_interrupts_print(struct seq_file *s, void *p)
1593 {
1594 int line;
1595
1596 seq_puts(s, "name: number: number of: wake:\n");
1597
1598 for (line = 0; line < num_interrupt_lines; line++) {
1599 struct irq_desc *desc = irq_to_desc(line + irq_first);
1600
1601 seq_printf(s, "%3i: %6i %4i", line,
1602 num_interrupts[line],
1603 num_wake_interrupts[line]);
1604
1605 if (desc && desc->name)
1606 seq_printf(s, "-%-8s", desc->name);
1607 if (desc && desc->action) {
1608 struct irqaction *action = desc->action;
1609
1610 seq_printf(s, " %s", action->name);
1611 while ((action = action->next) != NULL)
1612 seq_printf(s, ", %s", action->name);
1613 }
1614 seq_putc(s, '\n');
1615 }
1616
1617 return 0;
1618 }
1619
1620 static int ab8500_interrupts_open(struct inode *inode, struct file *file)
1621 {
1622 return single_open(file, ab8500_interrupts_print, inode->i_private);
1623 }
1624
1625 /*
1626 * - HWREG DB8500 formated routines
1627 */
1628 static int ab8500_hwreg_print(struct seq_file *s, void *d)
1629 {
1630 struct device *dev = s->private;
1631 int ret;
1632 u8 regvalue;
1633
1634 ret = abx500_get_register_interruptible(dev,
1635 (u8)hwreg_cfg.bank, (u8)hwreg_cfg.addr, &regvalue);
1636 if (ret < 0) {
1637 dev_err(dev, "abx500_get_reg fail %d, %d\n",
1638 ret, __LINE__);
1639 return -EINVAL;
1640 }
1641
1642 if (hwreg_cfg.shift >= 0)
1643 regvalue >>= hwreg_cfg.shift;
1644 else
1645 regvalue <<= -hwreg_cfg.shift;
1646 regvalue &= hwreg_cfg.mask;
1647
1648 if (REG_FMT_DEC(&hwreg_cfg))
1649 seq_printf(s, "%d\n", regvalue);
1650 else
1651 seq_printf(s, "0x%02X\n", regvalue);
1652 return 0;
1653 }
1654
1655 static int ab8500_hwreg_open(struct inode *inode, struct file *file)
1656 {
1657 return single_open(file, ab8500_hwreg_print, inode->i_private);
1658 }
1659
1660 #define AB8500_SUPPLY_CONTROL_CONFIG_1 0x01
1661 #define AB8500_SUPPLY_CONTROL_REG 0x00
1662 #define AB8500_FIRST_SIM_REG 0x80
1663 #define AB8500_LAST_SIM_REG 0x8B
1664 #define AB8505_LAST_SIM_REG 0x8C
1665
1666 static int ab8500_print_modem_registers(struct seq_file *s, void *p)
1667 {
1668 struct device *dev = s->private;
1669 struct ab8500 *ab8500;
1670 int err;
1671 u8 value;
1672 u8 orig_value;
1673 u32 bank = AB8500_REGU_CTRL2;
1674 u32 last_sim_reg = AB8500_LAST_SIM_REG;
1675 u32 reg;
1676
1677 ab8500 = dev_get_drvdata(dev->parent);
1678 dev_warn(dev, "WARNING! This operation can interfer with modem side\n"
1679 "and should only be done with care\n");
1680
1681 err = abx500_get_register_interruptible(dev,
1682 AB8500_REGU_CTRL1, AB8500_SUPPLY_CONTROL_REG, &orig_value);
1683 if (err < 0) {
1684 dev_err(dev, "ab->read fail %d\n", err);
1685 return err;
1686 }
1687 /* Config 1 will allow APE side to read SIM registers */
1688 err = abx500_set_register_interruptible(dev,
1689 AB8500_REGU_CTRL1, AB8500_SUPPLY_CONTROL_REG,
1690 AB8500_SUPPLY_CONTROL_CONFIG_1);
1691 if (err < 0) {
1692 dev_err(dev, "ab->write fail %d\n", err);
1693 return err;
1694 }
1695
1696 seq_printf(s, " bank 0x%02X:\n", bank);
1697
1698 if (is_ab9540(ab8500) || is_ab8505(ab8500))
1699 last_sim_reg = AB8505_LAST_SIM_REG;
1700
1701 for (reg = AB8500_FIRST_SIM_REG; reg <= last_sim_reg; reg++) {
1702 err = abx500_get_register_interruptible(dev,
1703 bank, reg, &value);
1704 if (err < 0) {
1705 dev_err(dev, "ab->read fail %d\n", err);
1706 return err;
1707 }
1708 err = seq_printf(s, " [0x%02X/0x%02X]: 0x%02X\n",
1709 bank, reg, value);
1710 }
1711 err = abx500_set_register_interruptible(dev,
1712 AB8500_REGU_CTRL1, AB8500_SUPPLY_CONTROL_REG, orig_value);
1713 if (err < 0) {
1714 dev_err(dev, "ab->write fail %d\n", err);
1715 return err;
1716 }
1717 return 0;
1718 }
1719
1720 static int ab8500_modem_open(struct inode *inode, struct file *file)
1721 {
1722 return single_open(file, ab8500_print_modem_registers,
1723 inode->i_private);
1724 }
1725
1726 static const struct file_operations ab8500_modem_fops = {
1727 .open = ab8500_modem_open,
1728 .read = seq_read,
1729 .llseek = seq_lseek,
1730 .release = single_release,
1731 .owner = THIS_MODULE,
1732 };
1733
1734 static int ab8500_gpadc_bat_ctrl_print(struct seq_file *s, void *p)
1735 {
1736 int bat_ctrl_raw;
1737 int bat_ctrl_convert;
1738 struct ab8500_gpadc *gpadc;
1739
1740 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1741 bat_ctrl_raw = ab8500_gpadc_read_raw(gpadc, BAT_CTRL,
1742 avg_sample, trig_edge, trig_timer, conv_type);
1743 bat_ctrl_convert = ab8500_gpadc_ad_to_voltage(gpadc,
1744 BAT_CTRL, bat_ctrl_raw);
1745
1746 return seq_printf(s, "%d,0x%X\n",
1747 bat_ctrl_convert, bat_ctrl_raw);
1748 }
1749
1750 static int ab8500_gpadc_bat_ctrl_open(struct inode *inode, struct file *file)
1751 {
1752 return single_open(file, ab8500_gpadc_bat_ctrl_print,
1753 inode->i_private);
1754 }
1755
1756 static const struct file_operations ab8500_gpadc_bat_ctrl_fops = {
1757 .open = ab8500_gpadc_bat_ctrl_open,
1758 .read = seq_read,
1759 .llseek = seq_lseek,
1760 .release = single_release,
1761 .owner = THIS_MODULE,
1762 };
1763
1764 static int ab8500_gpadc_btemp_ball_print(struct seq_file *s, void *p)
1765 {
1766 int btemp_ball_raw;
1767 int btemp_ball_convert;
1768 struct ab8500_gpadc *gpadc;
1769
1770 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1771 btemp_ball_raw = ab8500_gpadc_read_raw(gpadc, BTEMP_BALL,
1772 avg_sample, trig_edge, trig_timer, conv_type);
1773 btemp_ball_convert = ab8500_gpadc_ad_to_voltage(gpadc, BTEMP_BALL,
1774 btemp_ball_raw);
1775
1776 return seq_printf(s,
1777 "%d,0x%X\n", btemp_ball_convert, btemp_ball_raw);
1778 }
1779
1780 static int ab8500_gpadc_btemp_ball_open(struct inode *inode,
1781 struct file *file)
1782 {
1783 return single_open(file, ab8500_gpadc_btemp_ball_print,
1784 inode->i_private);
1785 }
1786
1787 static const struct file_operations ab8500_gpadc_btemp_ball_fops = {
1788 .open = ab8500_gpadc_btemp_ball_open,
1789 .read = seq_read,
1790 .llseek = seq_lseek,
1791 .release = single_release,
1792 .owner = THIS_MODULE,
1793 };
1794
1795 static int ab8500_gpadc_main_charger_v_print(struct seq_file *s, void *p)
1796 {
1797 int main_charger_v_raw;
1798 int main_charger_v_convert;
1799 struct ab8500_gpadc *gpadc;
1800
1801 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1802 main_charger_v_raw = ab8500_gpadc_read_raw(gpadc, MAIN_CHARGER_V,
1803 avg_sample, trig_edge, trig_timer, conv_type);
1804 main_charger_v_convert = ab8500_gpadc_ad_to_voltage(gpadc,
1805 MAIN_CHARGER_V, main_charger_v_raw);
1806
1807 return seq_printf(s, "%d,0x%X\n",
1808 main_charger_v_convert, main_charger_v_raw);
1809 }
1810
1811 static int ab8500_gpadc_main_charger_v_open(struct inode *inode,
1812 struct file *file)
1813 {
1814 return single_open(file, ab8500_gpadc_main_charger_v_print,
1815 inode->i_private);
1816 }
1817
1818 static const struct file_operations ab8500_gpadc_main_charger_v_fops = {
1819 .open = ab8500_gpadc_main_charger_v_open,
1820 .read = seq_read,
1821 .llseek = seq_lseek,
1822 .release = single_release,
1823 .owner = THIS_MODULE,
1824 };
1825
1826 static int ab8500_gpadc_acc_detect1_print(struct seq_file *s, void *p)
1827 {
1828 int acc_detect1_raw;
1829 int acc_detect1_convert;
1830 struct ab8500_gpadc *gpadc;
1831
1832 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1833 acc_detect1_raw = ab8500_gpadc_read_raw(gpadc, ACC_DETECT1,
1834 avg_sample, trig_edge, trig_timer, conv_type);
1835 acc_detect1_convert = ab8500_gpadc_ad_to_voltage(gpadc, ACC_DETECT1,
1836 acc_detect1_raw);
1837
1838 return seq_printf(s, "%d,0x%X\n",
1839 acc_detect1_convert, acc_detect1_raw);
1840 }
1841
1842 static int ab8500_gpadc_acc_detect1_open(struct inode *inode,
1843 struct file *file)
1844 {
1845 return single_open(file, ab8500_gpadc_acc_detect1_print,
1846 inode->i_private);
1847 }
1848
1849 static const struct file_operations ab8500_gpadc_acc_detect1_fops = {
1850 .open = ab8500_gpadc_acc_detect1_open,
1851 .read = seq_read,
1852 .llseek = seq_lseek,
1853 .release = single_release,
1854 .owner = THIS_MODULE,
1855 };
1856
1857 static int ab8500_gpadc_acc_detect2_print(struct seq_file *s, void *p)
1858 {
1859 int acc_detect2_raw;
1860 int acc_detect2_convert;
1861 struct ab8500_gpadc *gpadc;
1862
1863 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1864 acc_detect2_raw = ab8500_gpadc_read_raw(gpadc, ACC_DETECT2,
1865 avg_sample, trig_edge, trig_timer, conv_type);
1866 acc_detect2_convert = ab8500_gpadc_ad_to_voltage(gpadc,
1867 ACC_DETECT2, acc_detect2_raw);
1868
1869 return seq_printf(s, "%d,0x%X\n",
1870 acc_detect2_convert, acc_detect2_raw);
1871 }
1872
1873 static int ab8500_gpadc_acc_detect2_open(struct inode *inode,
1874 struct file *file)
1875 {
1876 return single_open(file, ab8500_gpadc_acc_detect2_print,
1877 inode->i_private);
1878 }
1879
1880 static const struct file_operations ab8500_gpadc_acc_detect2_fops = {
1881 .open = ab8500_gpadc_acc_detect2_open,
1882 .read = seq_read,
1883 .llseek = seq_lseek,
1884 .release = single_release,
1885 .owner = THIS_MODULE,
1886 };
1887
1888 static int ab8500_gpadc_aux1_print(struct seq_file *s, void *p)
1889 {
1890 int aux1_raw;
1891 int aux1_convert;
1892 struct ab8500_gpadc *gpadc;
1893
1894 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1895 aux1_raw = ab8500_gpadc_read_raw(gpadc, ADC_AUX1,
1896 avg_sample, trig_edge, trig_timer, conv_type);
1897 aux1_convert = ab8500_gpadc_ad_to_voltage(gpadc, ADC_AUX1,
1898 aux1_raw);
1899
1900 return seq_printf(s, "%d,0x%X\n",
1901 aux1_convert, aux1_raw);
1902 }
1903
1904 static int ab8500_gpadc_aux1_open(struct inode *inode, struct file *file)
1905 {
1906 return single_open(file, ab8500_gpadc_aux1_print, inode->i_private);
1907 }
1908
1909 static const struct file_operations ab8500_gpadc_aux1_fops = {
1910 .open = ab8500_gpadc_aux1_open,
1911 .read = seq_read,
1912 .llseek = seq_lseek,
1913 .release = single_release,
1914 .owner = THIS_MODULE,
1915 };
1916
1917 static int ab8500_gpadc_aux2_print(struct seq_file *s, void *p)
1918 {
1919 int aux2_raw;
1920 int aux2_convert;
1921 struct ab8500_gpadc *gpadc;
1922
1923 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1924 aux2_raw = ab8500_gpadc_read_raw(gpadc, ADC_AUX2,
1925 avg_sample, trig_edge, trig_timer, conv_type);
1926 aux2_convert = ab8500_gpadc_ad_to_voltage(gpadc, ADC_AUX2,
1927 aux2_raw);
1928
1929 return seq_printf(s, "%d,0x%X\n",
1930 aux2_convert, aux2_raw);
1931 }
1932
1933 static int ab8500_gpadc_aux2_open(struct inode *inode, struct file *file)
1934 {
1935 return single_open(file, ab8500_gpadc_aux2_print, inode->i_private);
1936 }
1937
1938 static const struct file_operations ab8500_gpadc_aux2_fops = {
1939 .open = ab8500_gpadc_aux2_open,
1940 .read = seq_read,
1941 .llseek = seq_lseek,
1942 .release = single_release,
1943 .owner = THIS_MODULE,
1944 };
1945
1946 static int ab8500_gpadc_main_bat_v_print(struct seq_file *s, void *p)
1947 {
1948 int main_bat_v_raw;
1949 int main_bat_v_convert;
1950 struct ab8500_gpadc *gpadc;
1951
1952 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1953 main_bat_v_raw = ab8500_gpadc_read_raw(gpadc, MAIN_BAT_V,
1954 avg_sample, trig_edge, trig_timer, conv_type);
1955 main_bat_v_convert = ab8500_gpadc_ad_to_voltage(gpadc, MAIN_BAT_V,
1956 main_bat_v_raw);
1957
1958 return seq_printf(s, "%d,0x%X\n",
1959 main_bat_v_convert, main_bat_v_raw);
1960 }
1961
1962 static int ab8500_gpadc_main_bat_v_open(struct inode *inode,
1963 struct file *file)
1964 {
1965 return single_open(file, ab8500_gpadc_main_bat_v_print,
1966 inode->i_private);
1967 }
1968
1969 static const struct file_operations ab8500_gpadc_main_bat_v_fops = {
1970 .open = ab8500_gpadc_main_bat_v_open,
1971 .read = seq_read,
1972 .llseek = seq_lseek,
1973 .release = single_release,
1974 .owner = THIS_MODULE,
1975 };
1976
1977 static int ab8500_gpadc_vbus_v_print(struct seq_file *s, void *p)
1978 {
1979 int vbus_v_raw;
1980 int vbus_v_convert;
1981 struct ab8500_gpadc *gpadc;
1982
1983 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1984 vbus_v_raw = ab8500_gpadc_read_raw(gpadc, VBUS_V,
1985 avg_sample, trig_edge, trig_timer, conv_type);
1986 vbus_v_convert = ab8500_gpadc_ad_to_voltage(gpadc, VBUS_V,
1987 vbus_v_raw);
1988
1989 return seq_printf(s, "%d,0x%X\n",
1990 vbus_v_convert, vbus_v_raw);
1991 }
1992
1993 static int ab8500_gpadc_vbus_v_open(struct inode *inode, struct file *file)
1994 {
1995 return single_open(file, ab8500_gpadc_vbus_v_print, inode->i_private);
1996 }
1997
1998 static const struct file_operations ab8500_gpadc_vbus_v_fops = {
1999 .open = ab8500_gpadc_vbus_v_open,
2000 .read = seq_read,
2001 .llseek = seq_lseek,
2002 .release = single_release,
2003 .owner = THIS_MODULE,
2004 };
2005
2006 static int ab8500_gpadc_main_charger_c_print(struct seq_file *s, void *p)
2007 {
2008 int main_charger_c_raw;
2009 int main_charger_c_convert;
2010 struct ab8500_gpadc *gpadc;
2011
2012 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
2013 main_charger_c_raw = ab8500_gpadc_read_raw(gpadc, MAIN_CHARGER_C,
2014 avg_sample, trig_edge, trig_timer, conv_type);
2015 main_charger_c_convert = ab8500_gpadc_ad_to_voltage(gpadc,
2016 MAIN_CHARGER_C, main_charger_c_raw);
2017
2018 return seq_printf(s, "%d,0x%X\n",
2019 main_charger_c_convert, main_charger_c_raw);
2020 }
2021
2022 static int ab8500_gpadc_main_charger_c_open(struct inode *inode,
2023 struct file *file)
2024 {
2025 return single_open(file, ab8500_gpadc_main_charger_c_print,
2026 inode->i_private);
2027 }
2028
2029 static const struct file_operations ab8500_gpadc_main_charger_c_fops = {
2030 .open = ab8500_gpadc_main_charger_c_open,
2031 .read = seq_read,
2032 .llseek = seq_lseek,
2033 .release = single_release,
2034 .owner = THIS_MODULE,
2035 };
2036
2037 static int ab8500_gpadc_usb_charger_c_print(struct seq_file *s, void *p)
2038 {
2039 int usb_charger_c_raw;
2040 int usb_charger_c_convert;
2041 struct ab8500_gpadc *gpadc;
2042
2043 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
2044 usb_charger_c_raw = ab8500_gpadc_read_raw(gpadc, USB_CHARGER_C,
2045 avg_sample, trig_edge, trig_timer, conv_type);
2046 usb_charger_c_convert = ab8500_gpadc_ad_to_voltage(gpadc,
2047 USB_CHARGER_C, usb_charger_c_raw);
2048
2049 return seq_printf(s, "%d,0x%X\n",
2050 usb_charger_c_convert, usb_charger_c_raw);
2051 }
2052
2053 static int ab8500_gpadc_usb_charger_c_open(struct inode *inode,
2054 struct file *file)
2055 {
2056 return single_open(file, ab8500_gpadc_usb_charger_c_print,
2057 inode->i_private);
2058 }
2059
2060 static const struct file_operations ab8500_gpadc_usb_charger_c_fops = {
2061 .open = ab8500_gpadc_usb_charger_c_open,
2062 .read = seq_read,
2063 .llseek = seq_lseek,
2064 .release = single_release,
2065 .owner = THIS_MODULE,
2066 };
2067
2068 static int ab8500_gpadc_bk_bat_v_print(struct seq_file *s, void *p)
2069 {
2070 int bk_bat_v_raw;
2071 int bk_bat_v_convert;
2072 struct ab8500_gpadc *gpadc;
2073
2074 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
2075 bk_bat_v_raw = ab8500_gpadc_read_raw(gpadc, BK_BAT_V,
2076 avg_sample, trig_edge, trig_timer, conv_type);
2077 bk_bat_v_convert = ab8500_gpadc_ad_to_voltage(gpadc,
2078 BK_BAT_V, bk_bat_v_raw);
2079
2080 return seq_printf(s, "%d,0x%X\n",
2081 bk_bat_v_convert, bk_bat_v_raw);
2082 }
2083
2084 static int ab8500_gpadc_bk_bat_v_open(struct inode *inode, struct file *file)
2085 {
2086 return single_open(file, ab8500_gpadc_bk_bat_v_print,
2087 inode->i_private);
2088 }
2089
2090 static const struct file_operations ab8500_gpadc_bk_bat_v_fops = {
2091 .open = ab8500_gpadc_bk_bat_v_open,
2092 .read = seq_read,
2093 .llseek = seq_lseek,
2094 .release = single_release,
2095 .owner = THIS_MODULE,
2096 };
2097
2098 static int ab8500_gpadc_die_temp_print(struct seq_file *s, void *p)
2099 {
2100 int die_temp_raw;
2101 int die_temp_convert;
2102 struct ab8500_gpadc *gpadc;
2103
2104 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
2105 die_temp_raw = ab8500_gpadc_read_raw(gpadc, DIE_TEMP,
2106 avg_sample, trig_edge, trig_timer, conv_type);
2107 die_temp_convert = ab8500_gpadc_ad_to_voltage(gpadc, DIE_TEMP,
2108 die_temp_raw);
2109
2110 return seq_printf(s, "%d,0x%X\n",
2111 die_temp_convert, die_temp_raw);
2112 }
2113
2114 static int ab8500_gpadc_die_temp_open(struct inode *inode, struct file *file)
2115 {
2116 return single_open(file, ab8500_gpadc_die_temp_print,
2117 inode->i_private);
2118 }
2119
2120 static const struct file_operations ab8500_gpadc_die_temp_fops = {
2121 .open = ab8500_gpadc_die_temp_open,
2122 .read = seq_read,
2123 .llseek = seq_lseek,
2124 .release = single_release,
2125 .owner = THIS_MODULE,
2126 };
2127
2128 static int ab8500_gpadc_usb_id_print(struct seq_file *s, void *p)
2129 {
2130 int usb_id_raw;
2131 int usb_id_convert;
2132 struct ab8500_gpadc *gpadc;
2133
2134 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
2135 usb_id_raw = ab8500_gpadc_read_raw(gpadc, USB_ID,
2136 avg_sample, trig_edge, trig_timer, conv_type);
2137 usb_id_convert = ab8500_gpadc_ad_to_voltage(gpadc, USB_ID,
2138 usb_id_raw);
2139
2140 return seq_printf(s, "%d,0x%X\n",
2141 usb_id_convert, usb_id_raw);
2142 }
2143
2144 static int ab8500_gpadc_usb_id_open(struct inode *inode, struct file *file)
2145 {
2146 return single_open(file, ab8500_gpadc_usb_id_print, inode->i_private);
2147 }
2148
2149 static const struct file_operations ab8500_gpadc_usb_id_fops = {
2150 .open = ab8500_gpadc_usb_id_open,
2151 .read = seq_read,
2152 .llseek = seq_lseek,
2153 .release = single_release,
2154 .owner = THIS_MODULE,
2155 };
2156
2157 static int ab8540_gpadc_xtal_temp_print(struct seq_file *s, void *p)
2158 {
2159 int xtal_temp_raw;
2160 int xtal_temp_convert;
2161 struct ab8500_gpadc *gpadc;
2162
2163 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
2164 xtal_temp_raw = ab8500_gpadc_read_raw(gpadc, XTAL_TEMP,
2165 avg_sample, trig_edge, trig_timer, conv_type);
2166 xtal_temp_convert = ab8500_gpadc_ad_to_voltage(gpadc, XTAL_TEMP,
2167 xtal_temp_raw);
2168
2169 return seq_printf(s, "%d,0x%X\n",
2170 xtal_temp_convert, xtal_temp_raw);
2171 }
2172
2173 static int ab8540_gpadc_xtal_temp_open(struct inode *inode, struct file *file)
2174 {
2175 return single_open(file, ab8540_gpadc_xtal_temp_print,
2176 inode->i_private);
2177 }
2178
2179 static const struct file_operations ab8540_gpadc_xtal_temp_fops = {
2180 .open = ab8540_gpadc_xtal_temp_open,
2181 .read = seq_read,
2182 .llseek = seq_lseek,
2183 .release = single_release,
2184 .owner = THIS_MODULE,
2185 };
2186
2187 static int ab8540_gpadc_vbat_true_meas_print(struct seq_file *s, void *p)
2188 {
2189 int vbat_true_meas_raw;
2190 int vbat_true_meas_convert;
2191 struct ab8500_gpadc *gpadc;
2192
2193 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
2194 vbat_true_meas_raw = ab8500_gpadc_read_raw(gpadc, VBAT_TRUE_MEAS,
2195 avg_sample, trig_edge, trig_timer, conv_type);
2196 vbat_true_meas_convert =
2197 ab8500_gpadc_ad_to_voltage(gpadc, VBAT_TRUE_MEAS,
2198 vbat_true_meas_raw);
2199
2200 return seq_printf(s, "%d,0x%X\n",
2201 vbat_true_meas_convert, vbat_true_meas_raw);
2202 }
2203
2204 static int ab8540_gpadc_vbat_true_meas_open(struct inode *inode,
2205 struct file *file)
2206 {
2207 return single_open(file, ab8540_gpadc_vbat_true_meas_print,
2208 inode->i_private);
2209 }
2210
2211 static const struct file_operations ab8540_gpadc_vbat_true_meas_fops = {
2212 .open = ab8540_gpadc_vbat_true_meas_open,
2213 .read = seq_read,
2214 .llseek = seq_lseek,
2215 .release = single_release,
2216 .owner = THIS_MODULE,
2217 };
2218
2219 static int ab8540_gpadc_bat_ctrl_and_ibat_print(struct seq_file *s, void *p)
2220 {
2221 int bat_ctrl_raw;
2222 int bat_ctrl_convert;
2223 int ibat_raw;
2224 int ibat_convert;
2225 struct ab8500_gpadc *gpadc;
2226
2227 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
2228 bat_ctrl_raw = ab8500_gpadc_double_read_raw(gpadc, BAT_CTRL_AND_IBAT,
2229 avg_sample, trig_edge, trig_timer, conv_type, &ibat_raw);
2230
2231 bat_ctrl_convert = ab8500_gpadc_ad_to_voltage(gpadc, BAT_CTRL,
2232 bat_ctrl_raw);
2233 ibat_convert = ab8500_gpadc_ad_to_voltage(gpadc, IBAT_VIRTUAL_CHANNEL,
2234 ibat_raw);
2235
2236 return seq_printf(s, "%d,0x%X\n" "%d,0x%X\n",
2237 bat_ctrl_convert, bat_ctrl_raw,
2238 ibat_convert, ibat_raw);
2239 }
2240
2241 static int ab8540_gpadc_bat_ctrl_and_ibat_open(struct inode *inode,
2242 struct file *file)
2243 {
2244 return single_open(file, ab8540_gpadc_bat_ctrl_and_ibat_print,
2245 inode->i_private);
2246 }
2247
2248 static const struct file_operations ab8540_gpadc_bat_ctrl_and_ibat_fops = {
2249 .open = ab8540_gpadc_bat_ctrl_and_ibat_open,
2250 .read = seq_read,
2251 .llseek = seq_lseek,
2252 .release = single_release,
2253 .owner = THIS_MODULE,
2254 };
2255
2256 static int ab8540_gpadc_vbat_meas_and_ibat_print(struct seq_file *s, void *p)
2257 {
2258 int vbat_meas_raw;
2259 int vbat_meas_convert;
2260 int ibat_raw;
2261 int ibat_convert;
2262 struct ab8500_gpadc *gpadc;
2263
2264 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
2265 vbat_meas_raw = ab8500_gpadc_double_read_raw(gpadc, VBAT_MEAS_AND_IBAT,
2266 avg_sample, trig_edge, trig_timer, conv_type, &ibat_raw);
2267 vbat_meas_convert = ab8500_gpadc_ad_to_voltage(gpadc, MAIN_BAT_V,
2268 vbat_meas_raw);
2269 ibat_convert = ab8500_gpadc_ad_to_voltage(gpadc, IBAT_VIRTUAL_CHANNEL,
2270 ibat_raw);
2271
2272 return seq_printf(s, "%d,0x%X\n" "%d,0x%X\n",
2273 vbat_meas_convert, vbat_meas_raw,
2274 ibat_convert, ibat_raw);
2275 }
2276
2277 static int ab8540_gpadc_vbat_meas_and_ibat_open(struct inode *inode,
2278 struct file *file)
2279 {
2280 return single_open(file, ab8540_gpadc_vbat_meas_and_ibat_print,
2281 inode->i_private);
2282 }
2283
2284 static const struct file_operations ab8540_gpadc_vbat_meas_and_ibat_fops = {
2285 .open = ab8540_gpadc_vbat_meas_and_ibat_open,
2286 .read = seq_read,
2287 .llseek = seq_lseek,
2288 .release = single_release,
2289 .owner = THIS_MODULE,
2290 };
2291
2292 static int ab8540_gpadc_vbat_true_meas_and_ibat_print(struct seq_file *s,
2293 void *p)
2294 {
2295 int vbat_true_meas_raw;
2296 int vbat_true_meas_convert;
2297 int ibat_raw;
2298 int ibat_convert;
2299 struct ab8500_gpadc *gpadc;
2300
2301 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
2302 vbat_true_meas_raw = ab8500_gpadc_double_read_raw(gpadc,
2303 VBAT_TRUE_MEAS_AND_IBAT, avg_sample, trig_edge,
2304 trig_timer, conv_type, &ibat_raw);
2305 vbat_true_meas_convert = ab8500_gpadc_ad_to_voltage(gpadc,
2306 VBAT_TRUE_MEAS, vbat_true_meas_raw);
2307 ibat_convert = ab8500_gpadc_ad_to_voltage(gpadc, IBAT_VIRTUAL_CHANNEL,
2308 ibat_raw);
2309
2310 return seq_printf(s, "%d,0x%X\n" "%d,0x%X\n",
2311 vbat_true_meas_convert, vbat_true_meas_raw,
2312 ibat_convert, ibat_raw);
2313 }
2314
2315 static int ab8540_gpadc_vbat_true_meas_and_ibat_open(struct inode *inode,
2316 struct file *file)
2317 {
2318 return single_open(file, ab8540_gpadc_vbat_true_meas_and_ibat_print,
2319 inode->i_private);
2320 }
2321
2322 static const struct file_operations
2323 ab8540_gpadc_vbat_true_meas_and_ibat_fops = {
2324 .open = ab8540_gpadc_vbat_true_meas_and_ibat_open,
2325 .read = seq_read,
2326 .llseek = seq_lseek,
2327 .release = single_release,
2328 .owner = THIS_MODULE,
2329 };
2330
2331 static int ab8540_gpadc_bat_temp_and_ibat_print(struct seq_file *s, void *p)
2332 {
2333 int bat_temp_raw;
2334 int bat_temp_convert;
2335 int ibat_raw;
2336 int ibat_convert;
2337 struct ab8500_gpadc *gpadc;
2338
2339 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
2340 bat_temp_raw = ab8500_gpadc_double_read_raw(gpadc, BAT_TEMP_AND_IBAT,
2341 avg_sample, trig_edge, trig_timer, conv_type, &ibat_raw);
2342 bat_temp_convert = ab8500_gpadc_ad_to_voltage(gpadc, BTEMP_BALL,
2343 bat_temp_raw);
2344 ibat_convert = ab8500_gpadc_ad_to_voltage(gpadc, IBAT_VIRTUAL_CHANNEL,
2345 ibat_raw);
2346
2347 return seq_printf(s, "%d,0x%X\n" "%d,0x%X\n",
2348 bat_temp_convert, bat_temp_raw,
2349 ibat_convert, ibat_raw);
2350 }
2351
2352 static int ab8540_gpadc_bat_temp_and_ibat_open(struct inode *inode,
2353 struct file *file)
2354 {
2355 return single_open(file, ab8540_gpadc_bat_temp_and_ibat_print,
2356 inode->i_private);
2357 }
2358
2359 static const struct file_operations ab8540_gpadc_bat_temp_and_ibat_fops = {
2360 .open = ab8540_gpadc_bat_temp_and_ibat_open,
2361 .read = seq_read,
2362 .llseek = seq_lseek,
2363 .release = single_release,
2364 .owner = THIS_MODULE,
2365 };
2366
2367 static int ab8540_gpadc_otp_cal_print(struct seq_file *s, void *p)
2368 {
2369 struct ab8500_gpadc *gpadc;
2370 u16 vmain_l, vmain_h, btemp_l, btemp_h;
2371 u16 vbat_l, vbat_h, ibat_l, ibat_h;
2372
2373 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
2374 ab8540_gpadc_get_otp(gpadc, &vmain_l, &vmain_h, &btemp_l, &btemp_h,
2375 &vbat_l, &vbat_h, &ibat_l, &ibat_h);
2376 return seq_printf(s, "VMAIN_L:0x%X\n"
2377 "VMAIN_H:0x%X\n"
2378 "BTEMP_L:0x%X\n"
2379 "BTEMP_H:0x%X\n"
2380 "VBAT_L:0x%X\n"
2381 "VBAT_H:0x%X\n"
2382 "IBAT_L:0x%X\n"
2383 "IBAT_H:0x%X\n",
2384 vmain_l, vmain_h, btemp_l, btemp_h,
2385 vbat_l, vbat_h, ibat_l, ibat_h);
2386 }
2387
2388 static int ab8540_gpadc_otp_cal_open(struct inode *inode, struct file *file)
2389 {
2390 return single_open(file, ab8540_gpadc_otp_cal_print, inode->i_private);
2391 }
2392
2393 static const struct file_operations ab8540_gpadc_otp_calib_fops = {
2394 .open = ab8540_gpadc_otp_cal_open,
2395 .read = seq_read,
2396 .llseek = seq_lseek,
2397 .release = single_release,
2398 .owner = THIS_MODULE,
2399 };
2400
2401 static int ab8500_gpadc_avg_sample_print(struct seq_file *s, void *p)
2402 {
2403 return seq_printf(s, "%d\n", avg_sample);
2404 }
2405
2406 static int ab8500_gpadc_avg_sample_open(struct inode *inode, struct file *file)
2407 {
2408 return single_open(file, ab8500_gpadc_avg_sample_print,
2409 inode->i_private);
2410 }
2411
2412 static ssize_t ab8500_gpadc_avg_sample_write(struct file *file,
2413 const char __user *user_buf,
2414 size_t count, loff_t *ppos)
2415 {
2416 struct device *dev = ((struct seq_file *)(file->private_data))->private;
2417 unsigned long user_avg_sample;
2418 int err;
2419
2420 err = kstrtoul_from_user(user_buf, count, 0, &user_avg_sample);
2421 if (err)
2422 return err;
2423
2424 if ((user_avg_sample == SAMPLE_1) || (user_avg_sample == SAMPLE_4)
2425 || (user_avg_sample == SAMPLE_8)
2426 || (user_avg_sample == SAMPLE_16)) {
2427 avg_sample = (u8) user_avg_sample;
2428 } else {
2429 dev_err(dev,
2430 "debugfs err input: should be egal to 1, 4, 8 or 16\n");
2431 return -EINVAL;
2432 }
2433
2434 return count;
2435 }
2436
2437 static const struct file_operations ab8500_gpadc_avg_sample_fops = {
2438 .open = ab8500_gpadc_avg_sample_open,
2439 .read = seq_read,
2440 .write = ab8500_gpadc_avg_sample_write,
2441 .llseek = seq_lseek,
2442 .release = single_release,
2443 .owner = THIS_MODULE,
2444 };
2445
2446 static int ab8500_gpadc_trig_edge_print(struct seq_file *s, void *p)
2447 {
2448 return seq_printf(s, "%d\n", trig_edge);
2449 }
2450
2451 static int ab8500_gpadc_trig_edge_open(struct inode *inode, struct file *file)
2452 {
2453 return single_open(file, ab8500_gpadc_trig_edge_print,
2454 inode->i_private);
2455 }
2456
2457 static ssize_t ab8500_gpadc_trig_edge_write(struct file *file,
2458 const char __user *user_buf,
2459 size_t count, loff_t *ppos)
2460 {
2461 struct device *dev = ((struct seq_file *)(file->private_data))->private;
2462 unsigned long user_trig_edge;
2463 int err;
2464
2465 err = kstrtoul_from_user(user_buf, count, 0, &user_trig_edge);
2466 if (err)
2467 return err;
2468
2469 if ((user_trig_edge == RISING_EDGE)
2470 || (user_trig_edge == FALLING_EDGE)) {
2471 trig_edge = (u8) user_trig_edge;
2472 } else {
2473 dev_err(dev, "Wrong input:\n"
2474 "Enter 0. Rising edge\n"
2475 "Enter 1. Falling edge\n");
2476 return -EINVAL;
2477 }
2478
2479 return count;
2480 }
2481
2482 static const struct file_operations ab8500_gpadc_trig_edge_fops = {
2483 .open = ab8500_gpadc_trig_edge_open,
2484 .read = seq_read,
2485 .write = ab8500_gpadc_trig_edge_write,
2486 .llseek = seq_lseek,
2487 .release = single_release,
2488 .owner = THIS_MODULE,
2489 };
2490
2491 static int ab8500_gpadc_trig_timer_print(struct seq_file *s, void *p)
2492 {
2493 return seq_printf(s, "%d\n", trig_timer);
2494 }
2495
2496 static int ab8500_gpadc_trig_timer_open(struct inode *inode, struct file *file)
2497 {
2498 return single_open(file, ab8500_gpadc_trig_timer_print,
2499 inode->i_private);
2500 }
2501
2502 static ssize_t ab8500_gpadc_trig_timer_write(struct file *file,
2503 const char __user *user_buf,
2504 size_t count, loff_t *ppos)
2505 {
2506 struct device *dev = ((struct seq_file *)(file->private_data))->private;
2507 unsigned long user_trig_timer;
2508 int err;
2509
2510 err = kstrtoul_from_user(user_buf, count, 0, &user_trig_timer);
2511 if (err)
2512 return err;
2513
2514 if (user_trig_timer & ~0xFF) {
2515 dev_err(dev,
2516 "debugfs error input: should be beetween 0 to 255\n");
2517 return -EINVAL;
2518 }
2519
2520 trig_timer = (u8) user_trig_timer;
2521
2522 return count;
2523 }
2524
2525 static const struct file_operations ab8500_gpadc_trig_timer_fops = {
2526 .open = ab8500_gpadc_trig_timer_open,
2527 .read = seq_read,
2528 .write = ab8500_gpadc_trig_timer_write,
2529 .llseek = seq_lseek,
2530 .release = single_release,
2531 .owner = THIS_MODULE,
2532 };
2533
2534 static int ab8500_gpadc_conv_type_print(struct seq_file *s, void *p)
2535 {
2536 return seq_printf(s, "%d\n", conv_type);
2537 }
2538
2539 static int ab8500_gpadc_conv_type_open(struct inode *inode, struct file *file)
2540 {
2541 return single_open(file, ab8500_gpadc_conv_type_print,
2542 inode->i_private);
2543 }
2544
2545 static ssize_t ab8500_gpadc_conv_type_write(struct file *file,
2546 const char __user *user_buf,
2547 size_t count, loff_t *ppos)
2548 {
2549 struct device *dev = ((struct seq_file *)(file->private_data))->private;
2550 unsigned long user_conv_type;
2551 int err;
2552
2553 err = kstrtoul_from_user(user_buf, count, 0, &user_conv_type);
2554 if (err)
2555 return err;
2556
2557 if ((user_conv_type == ADC_SW)
2558 || (user_conv_type == ADC_HW)) {
2559 conv_type = (u8) user_conv_type;
2560 } else {
2561 dev_err(dev, "Wrong input:\n"
2562 "Enter 0. ADC SW conversion\n"
2563 "Enter 1. ADC HW conversion\n");
2564 return -EINVAL;
2565 }
2566
2567 return count;
2568 }
2569
2570 static const struct file_operations ab8500_gpadc_conv_type_fops = {
2571 .open = ab8500_gpadc_conv_type_open,
2572 .read = seq_read,
2573 .write = ab8500_gpadc_conv_type_write,
2574 .llseek = seq_lseek,
2575 .release = single_release,
2576 .owner = THIS_MODULE,
2577 };
2578
2579 /*
2580 * return length of an ASCII numerical value, 0 is string is not a
2581 * numerical value.
2582 * string shall start at value 1st char.
2583 * string can be tailed with \0 or space or newline chars only.
2584 * value can be decimal or hexadecimal (prefixed 0x or 0X).
2585 */
2586 static int strval_len(char *b)
2587 {
2588 char *s = b;
2589
2590 if ((*s == '0') && ((*(s+1) == 'x') || (*(s+1) == 'X'))) {
2591 s += 2;
2592 for (; *s && (*s != ' ') && (*s != '\n'); s++) {
2593 if (!isxdigit(*s))
2594 return 0;
2595 }
2596 } else {
2597 if (*s == '-')
2598 s++;
2599 for (; *s && (*s != ' ') && (*s != '\n'); s++) {
2600 if (!isdigit(*s))
2601 return 0;
2602 }
2603 }
2604 return (int) (s-b);
2605 }
2606
2607 /*
2608 * parse hwreg input data.
2609 * update global hwreg_cfg only if input data syntax is ok.
2610 */
2611 static ssize_t hwreg_common_write(char *b, struct hwreg_cfg *cfg,
2612 struct device *dev)
2613 {
2614 uint write, val = 0;
2615 u8 regvalue;
2616 int ret;
2617 struct hwreg_cfg loc = {
2618 .bank = 0, /* default: invalid phys addr */
2619 .addr = 0, /* default: invalid phys addr */
2620 .fmt = 0, /* default: 32bit access, hex output */
2621 .mask = 0xFFFFFFFF, /* default: no mask */
2622 .shift = 0, /* default: no bit shift */
2623 };
2624
2625 /* read or write ? */
2626 if (!strncmp(b, "read ", 5)) {
2627 write = 0;
2628 b += 5;
2629 } else if (!strncmp(b, "write ", 6)) {
2630 write = 1;
2631 b += 6;
2632 } else
2633 return -EINVAL;
2634
2635 /* OPTIONS -l|-w|-b -s -m -o */
2636 while ((*b == ' ') || (*b == '-')) {
2637 if (*(b-1) != ' ') {
2638 b++;
2639 continue;
2640 }
2641 if ((!strncmp(b, "-d ", 3)) ||
2642 (!strncmp(b, "-dec ", 5))) {
2643 b += (*(b+2) == ' ') ? 3 : 5;
2644 loc.fmt |= (1<<0);
2645 } else if ((!strncmp(b, "-h ", 3)) ||
2646 (!strncmp(b, "-hex ", 5))) {
2647 b += (*(b+2) == ' ') ? 3 : 5;
2648 loc.fmt &= ~(1<<0);
2649 } else if ((!strncmp(b, "-m ", 3)) ||
2650 (!strncmp(b, "-mask ", 6))) {
2651 b += (*(b+2) == ' ') ? 3 : 6;
2652 if (strval_len(b) == 0)
2653 return -EINVAL;
2654 ret = kstrtoul(b, 0, &loc.mask);
2655 if (ret)
2656 return ret;
2657 } else if ((!strncmp(b, "-s ", 3)) ||
2658 (!strncmp(b, "-shift ", 7))) {
2659 b += (*(b+2) == ' ') ? 3 : 7;
2660 if (strval_len(b) == 0)
2661 return -EINVAL;
2662 ret = kstrtol(b, 0, &loc.shift);
2663 if (ret)
2664 return ret;
2665 } else {
2666 return -EINVAL;
2667 }
2668 }
2669 /* get arg BANK and ADDRESS */
2670 if (strval_len(b) == 0)
2671 return -EINVAL;
2672 ret = kstrtouint(b, 0, &loc.bank);
2673 if (ret)
2674 return ret;
2675 while (*b == ' ')
2676 b++;
2677 if (strval_len(b) == 0)
2678 return -EINVAL;
2679 ret = kstrtoul(b, 0, &loc.addr);
2680 if (ret)
2681 return ret;
2682
2683 if (write) {
2684 while (*b == ' ')
2685 b++;
2686 if (strval_len(b) == 0)
2687 return -EINVAL;
2688 ret = kstrtouint(b, 0, &val);
2689 if (ret)
2690 return ret;
2691 }
2692
2693 /* args are ok, update target cfg (mainly for read) */
2694 *cfg = loc;
2695
2696 #ifdef ABB_HWREG_DEBUG
2697 pr_warn("HWREG request: %s, %s,\n"
2698 " addr=0x%08X, mask=0x%X, shift=%d" "value=0x%X\n",
2699 (write) ? "write" : "read",
2700 REG_FMT_DEC(cfg) ? "decimal" : "hexa",
2701 cfg->addr, cfg->mask, cfg->shift, val);
2702 #endif
2703
2704 if (!write)
2705 return 0;
2706
2707 ret = abx500_get_register_interruptible(dev,
2708 (u8)cfg->bank, (u8)cfg->addr, &regvalue);
2709 if (ret < 0) {
2710 dev_err(dev, "abx500_get_reg fail %d, %d\n",
2711 ret, __LINE__);
2712 return -EINVAL;
2713 }
2714
2715 if (cfg->shift >= 0) {
2716 regvalue &= ~(cfg->mask << (cfg->shift));
2717 val = (val & cfg->mask) << (cfg->shift);
2718 } else {
2719 regvalue &= ~(cfg->mask >> (-cfg->shift));
2720 val = (val & cfg->mask) >> (-cfg->shift);
2721 }
2722 val = val | regvalue;
2723
2724 ret = abx500_set_register_interruptible(dev,
2725 (u8)cfg->bank, (u8)cfg->addr, (u8)val);
2726 if (ret < 0) {
2727 pr_err("abx500_set_reg failed %d, %d", ret, __LINE__);
2728 return -EINVAL;
2729 }
2730
2731 return 0;
2732 }
2733
2734 static ssize_t ab8500_hwreg_write(struct file *file,
2735 const char __user *user_buf, size_t count, loff_t *ppos)
2736 {
2737 struct device *dev = ((struct seq_file *)(file->private_data))->private;
2738 char buf[128];
2739 int buf_size, ret;
2740
2741 /* Get userspace string and assure termination */
2742 buf_size = min(count, (sizeof(buf)-1));
2743 if (copy_from_user(buf, user_buf, buf_size))
2744 return -EFAULT;
2745 buf[buf_size] = 0;
2746
2747 /* get args and process */
2748 ret = hwreg_common_write(buf, &hwreg_cfg, dev);
2749 return (ret) ? ret : buf_size;
2750 }
2751
2752 /*
2753 * - irq subscribe/unsubscribe stuff
2754 */
2755 static int ab8500_subscribe_unsubscribe_print(struct seq_file *s, void *p)
2756 {
2757 seq_printf(s, "%d\n", irq_first);
2758
2759 return 0;
2760 }
2761
2762 static int ab8500_subscribe_unsubscribe_open(struct inode *inode,
2763 struct file *file)
2764 {
2765 return single_open(file, ab8500_subscribe_unsubscribe_print,
2766 inode->i_private);
2767 }
2768
2769 /*
2770 * Userspace should use poll() on this file. When an event occur
2771 * the blocking poll will be released.
2772 */
2773 static ssize_t show_irq(struct device *dev,
2774 struct device_attribute *attr, char *buf)
2775 {
2776 unsigned long name;
2777 unsigned int irq_index;
2778 int err;
2779
2780 err = kstrtoul(attr->attr.name, 0, &name);
2781 if (err)
2782 return err;
2783
2784 irq_index = name - irq_first;
2785 if (irq_index >= num_irqs)
2786 return -EINVAL;
2787
2788 return sprintf(buf, "%u\n", irq_count[irq_index]);
2789 }
2790
2791 static ssize_t ab8500_subscribe_write(struct file *file,
2792 const char __user *user_buf,
2793 size_t count, loff_t *ppos)
2794 {
2795 struct device *dev = ((struct seq_file *)(file->private_data))->private;
2796 unsigned long user_val;
2797 int err;
2798 unsigned int irq_index;
2799
2800 err = kstrtoul_from_user(user_buf, count, 0, &user_val);
2801 if (err)
2802 return err;
2803
2804 if (user_val < irq_first) {
2805 dev_err(dev, "debugfs error input < %d\n", irq_first);
2806 return -EINVAL;
2807 }
2808 if (user_val > irq_last) {
2809 dev_err(dev, "debugfs error input > %d\n", irq_last);
2810 return -EINVAL;
2811 }
2812
2813 irq_index = user_val - irq_first;
2814 if (irq_index >= num_irqs)
2815 return -EINVAL;
2816
2817 /*
2818 * This will create a sysfs file named <irq-nr> which userspace can
2819 * use to select or poll and get the AB8500 events
2820 */
2821 dev_attr[irq_index] = kmalloc(sizeof(struct device_attribute),
2822 GFP_KERNEL);
2823 if (!dev_attr[irq_index])
2824 return -ENOMEM;
2825
2826 event_name[irq_index] = kmalloc(count, GFP_KERNEL);
2827 if (!event_name[irq_index])
2828 return -ENOMEM;
2829
2830 sprintf(event_name[irq_index], "%lu", user_val);
2831 dev_attr[irq_index]->show = show_irq;
2832 dev_attr[irq_index]->store = NULL;
2833 dev_attr[irq_index]->attr.name = event_name[irq_index];
2834 dev_attr[irq_index]->attr.mode = S_IRUGO;
2835 err = sysfs_create_file(&dev->kobj, &dev_attr[irq_index]->attr);
2836 if (err < 0) {
2837 pr_info("sysfs_create_file failed %d\n", err);
2838 return err;
2839 }
2840
2841 err = request_threaded_irq(user_val, NULL, ab8500_debug_handler,
2842 IRQF_SHARED | IRQF_NO_SUSPEND,
2843 "ab8500-debug", &dev->kobj);
2844 if (err < 0) {
2845 pr_info("request_threaded_irq failed %d, %lu\n",
2846 err, user_val);
2847 sysfs_remove_file(&dev->kobj, &dev_attr[irq_index]->attr);
2848 return err;
2849 }
2850
2851 return count;
2852 }
2853
2854 static ssize_t ab8500_unsubscribe_write(struct file *file,
2855 const char __user *user_buf,
2856 size_t count, loff_t *ppos)
2857 {
2858 struct device *dev = ((struct seq_file *)(file->private_data))->private;
2859 unsigned long user_val;
2860 int err;
2861 unsigned int irq_index;
2862
2863 err = kstrtoul_from_user(user_buf, count, 0, &user_val);
2864 if (err)
2865 return err;
2866
2867 if (user_val < irq_first) {
2868 dev_err(dev, "debugfs error input < %d\n", irq_first);
2869 return -EINVAL;
2870 }
2871 if (user_val > irq_last) {
2872 dev_err(dev, "debugfs error input > %d\n", irq_last);
2873 return -EINVAL;
2874 }
2875
2876 irq_index = user_val - irq_first;
2877 if (irq_index >= num_irqs)
2878 return -EINVAL;
2879
2880 /* Set irq count to 0 when unsubscribe */
2881 irq_count[irq_index] = 0;
2882
2883 if (dev_attr[irq_index])
2884 sysfs_remove_file(&dev->kobj, &dev_attr[irq_index]->attr);
2885
2886
2887 free_irq(user_val, &dev->kobj);
2888 kfree(event_name[irq_index]);
2889 kfree(dev_attr[irq_index]);
2890
2891 return count;
2892 }
2893
2894 /*
2895 * - several deubgfs nodes fops
2896 */
2897
2898 static const struct file_operations ab8500_bank_fops = {
2899 .open = ab8500_bank_open,
2900 .write = ab8500_bank_write,
2901 .read = seq_read,
2902 .llseek = seq_lseek,
2903 .release = single_release,
2904 .owner = THIS_MODULE,
2905 };
2906
2907 static const struct file_operations ab8500_address_fops = {
2908 .open = ab8500_address_open,
2909 .write = ab8500_address_write,
2910 .read = seq_read,
2911 .llseek = seq_lseek,
2912 .release = single_release,
2913 .owner = THIS_MODULE,
2914 };
2915
2916 static const struct file_operations ab8500_val_fops = {
2917 .open = ab8500_val_open,
2918 .write = ab8500_val_write,
2919 .read = seq_read,
2920 .llseek = seq_lseek,
2921 .release = single_release,
2922 .owner = THIS_MODULE,
2923 };
2924
2925 static const struct file_operations ab8500_interrupts_fops = {
2926 .open = ab8500_interrupts_open,
2927 .read = seq_read,
2928 .llseek = seq_lseek,
2929 .release = single_release,
2930 .owner = THIS_MODULE,
2931 };
2932
2933 static const struct file_operations ab8500_subscribe_fops = {
2934 .open = ab8500_subscribe_unsubscribe_open,
2935 .write = ab8500_subscribe_write,
2936 .read = seq_read,
2937 .llseek = seq_lseek,
2938 .release = single_release,
2939 .owner = THIS_MODULE,
2940 };
2941
2942 static const struct file_operations ab8500_unsubscribe_fops = {
2943 .open = ab8500_subscribe_unsubscribe_open,
2944 .write = ab8500_unsubscribe_write,
2945 .read = seq_read,
2946 .llseek = seq_lseek,
2947 .release = single_release,
2948 .owner = THIS_MODULE,
2949 };
2950
2951 static const struct file_operations ab8500_hwreg_fops = {
2952 .open = ab8500_hwreg_open,
2953 .write = ab8500_hwreg_write,
2954 .read = seq_read,
2955 .llseek = seq_lseek,
2956 .release = single_release,
2957 .owner = THIS_MODULE,
2958 };
2959
2960 static struct dentry *ab8500_dir;
2961 static struct dentry *ab8500_gpadc_dir;
2962
2963 static int ab8500_debug_probe(struct platform_device *plf)
2964 {
2965 struct dentry *file;
2966 struct ab8500 *ab8500;
2967 struct resource *res;
2968
2969 debug_bank = AB8500_MISC;
2970 debug_address = AB8500_REV_REG & 0x00FF;
2971
2972 ab8500 = dev_get_drvdata(plf->dev.parent);
2973 num_irqs = ab8500->mask_size;
2974
2975 irq_count = devm_kzalloc(&plf->dev,
2976 sizeof(*irq_count)*num_irqs, GFP_KERNEL);
2977 if (!irq_count)
2978 return -ENOMEM;
2979
2980 dev_attr = devm_kzalloc(&plf->dev,
2981 sizeof(*dev_attr)*num_irqs, GFP_KERNEL);
2982 if (!dev_attr)
2983 return -ENOMEM;
2984
2985 event_name = devm_kzalloc(&plf->dev,
2986 sizeof(*event_name)*num_irqs, GFP_KERNEL);
2987 if (!event_name)
2988 return -ENOMEM;
2989
2990 res = platform_get_resource_byname(plf, 0, "IRQ_AB8500");
2991 if (!res) {
2992 dev_err(&plf->dev, "AB8500 irq not found, err %d\n", irq_first);
2993 return -ENXIO;
2994 }
2995 irq_ab8500 = res->start;
2996
2997 irq_first = platform_get_irq_byname(plf, "IRQ_FIRST");
2998 if (irq_first < 0) {
2999 dev_err(&plf->dev, "First irq not found, err %d\n", irq_first);
3000 return irq_first;
3001 }
3002
3003 irq_last = platform_get_irq_byname(plf, "IRQ_LAST");
3004 if (irq_last < 0) {
3005 dev_err(&plf->dev, "Last irq not found, err %d\n", irq_last);
3006 return irq_last;
3007 }
3008
3009 ab8500_dir = debugfs_create_dir(AB8500_NAME_STRING, NULL);
3010 if (!ab8500_dir)
3011 goto err;
3012
3013 ab8500_gpadc_dir = debugfs_create_dir(AB8500_ADC_NAME_STRING,
3014 ab8500_dir);
3015 if (!ab8500_gpadc_dir)
3016 goto err;
3017
3018 file = debugfs_create_file("all-bank-registers", S_IRUGO, ab8500_dir,
3019 &plf->dev, &ab8500_registers_fops);
3020 if (!file)
3021 goto err;
3022
3023 file = debugfs_create_file("all-banks", S_IRUGO, ab8500_dir,
3024 &plf->dev, &ab8500_all_banks_fops);
3025 if (!file)
3026 goto err;
3027
3028 file = debugfs_create_file("register-bank",
3029 (S_IRUGO | S_IWUSR | S_IWGRP),
3030 ab8500_dir, &plf->dev, &ab8500_bank_fops);
3031 if (!file)
3032 goto err;
3033
3034 file = debugfs_create_file("register-address",
3035 (S_IRUGO | S_IWUSR | S_IWGRP),
3036 ab8500_dir, &plf->dev, &ab8500_address_fops);
3037 if (!file)
3038 goto err;
3039
3040 file = debugfs_create_file("register-value",
3041 (S_IRUGO | S_IWUSR | S_IWGRP),
3042 ab8500_dir, &plf->dev, &ab8500_val_fops);
3043 if (!file)
3044 goto err;
3045
3046 file = debugfs_create_file("irq-subscribe",
3047 (S_IRUGO | S_IWUSR | S_IWGRP), ab8500_dir,
3048 &plf->dev, &ab8500_subscribe_fops);
3049 if (!file)
3050 goto err;
3051
3052 if (is_ab8500(ab8500)) {
3053 debug_ranges = ab8500_debug_ranges;
3054 num_interrupt_lines = AB8500_NR_IRQS;
3055 } else if (is_ab8505(ab8500)) {
3056 debug_ranges = ab8505_debug_ranges;
3057 num_interrupt_lines = AB8505_NR_IRQS;
3058 } else if (is_ab9540(ab8500)) {
3059 debug_ranges = ab8505_debug_ranges;
3060 num_interrupt_lines = AB9540_NR_IRQS;
3061 } else if (is_ab8540(ab8500)) {
3062 debug_ranges = ab8540_debug_ranges;
3063 num_interrupt_lines = AB8540_NR_IRQS;
3064 }
3065
3066 file = debugfs_create_file("interrupts", (S_IRUGO), ab8500_dir,
3067 &plf->dev, &ab8500_interrupts_fops);
3068 if (!file)
3069 goto err;
3070
3071 file = debugfs_create_file("irq-unsubscribe",
3072 (S_IRUGO | S_IWUSR | S_IWGRP), ab8500_dir,
3073 &plf->dev, &ab8500_unsubscribe_fops);
3074 if (!file)
3075 goto err;
3076
3077 file = debugfs_create_file("hwreg", (S_IRUGO | S_IWUSR | S_IWGRP),
3078 ab8500_dir, &plf->dev, &ab8500_hwreg_fops);
3079 if (!file)
3080 goto err;
3081
3082 file = debugfs_create_file("all-modem-registers",
3083 (S_IRUGO | S_IWUSR | S_IWGRP),
3084 ab8500_dir, &plf->dev, &ab8500_modem_fops);
3085 if (!file)
3086 goto err;
3087
3088 file = debugfs_create_file("bat_ctrl", (S_IRUGO | S_IWUSR | S_IWGRP),
3089 ab8500_gpadc_dir, &plf->dev,
3090 &ab8500_gpadc_bat_ctrl_fops);
3091 if (!file)
3092 goto err;
3093
3094 file = debugfs_create_file("btemp_ball", (S_IRUGO | S_IWUSR | S_IWGRP),
3095 ab8500_gpadc_dir,
3096 &plf->dev, &ab8500_gpadc_btemp_ball_fops);
3097 if (!file)
3098 goto err;
3099
3100 file = debugfs_create_file("main_charger_v",
3101 (S_IRUGO | S_IWUSR | S_IWGRP),
3102 ab8500_gpadc_dir, &plf->dev,
3103 &ab8500_gpadc_main_charger_v_fops);
3104 if (!file)
3105 goto err;
3106
3107 file = debugfs_create_file("acc_detect1",
3108 (S_IRUGO | S_IWUSR | S_IWGRP),
3109 ab8500_gpadc_dir, &plf->dev,
3110 &ab8500_gpadc_acc_detect1_fops);
3111 if (!file)
3112 goto err;
3113
3114 file = debugfs_create_file("acc_detect2",
3115 (S_IRUGO | S_IWUSR | S_IWGRP),
3116 ab8500_gpadc_dir, &plf->dev,
3117 &ab8500_gpadc_acc_detect2_fops);
3118 if (!file)
3119 goto err;
3120
3121 file = debugfs_create_file("adc_aux1", (S_IRUGO | S_IWUSR | S_IWGRP),
3122 ab8500_gpadc_dir, &plf->dev,
3123 &ab8500_gpadc_aux1_fops);
3124 if (!file)
3125 goto err;
3126
3127 file = debugfs_create_file("adc_aux2", (S_IRUGO | S_IWUSR | S_IWGRP),
3128 ab8500_gpadc_dir, &plf->dev,
3129 &ab8500_gpadc_aux2_fops);
3130 if (!file)
3131 goto err;
3132
3133 file = debugfs_create_file("main_bat_v", (S_IRUGO | S_IWUSR | S_IWGRP),
3134 ab8500_gpadc_dir, &plf->dev,
3135 &ab8500_gpadc_main_bat_v_fops);
3136 if (!file)
3137 goto err;
3138
3139 file = debugfs_create_file("vbus_v", (S_IRUGO | S_IWUSR | S_IWGRP),
3140 ab8500_gpadc_dir, &plf->dev,
3141 &ab8500_gpadc_vbus_v_fops);
3142 if (!file)
3143 goto err;
3144
3145 file = debugfs_create_file("main_charger_c",
3146 (S_IRUGO | S_IWUSR | S_IWGRP),
3147 ab8500_gpadc_dir, &plf->dev,
3148 &ab8500_gpadc_main_charger_c_fops);
3149 if (!file)
3150 goto err;
3151
3152 file = debugfs_create_file("usb_charger_c",
3153 (S_IRUGO | S_IWUSR | S_IWGRP),
3154 ab8500_gpadc_dir,
3155 &plf->dev, &ab8500_gpadc_usb_charger_c_fops);
3156 if (!file)
3157 goto err;
3158
3159 file = debugfs_create_file("bk_bat_v", (S_IRUGO | S_IWUSR | S_IWGRP),
3160 ab8500_gpadc_dir, &plf->dev,
3161 &ab8500_gpadc_bk_bat_v_fops);
3162 if (!file)
3163 goto err;
3164
3165 file = debugfs_create_file("die_temp", (S_IRUGO | S_IWUSR | S_IWGRP),
3166 ab8500_gpadc_dir, &plf->dev,
3167 &ab8500_gpadc_die_temp_fops);
3168 if (!file)
3169 goto err;
3170
3171 file = debugfs_create_file("usb_id", (S_IRUGO | S_IWUSR | S_IWGRP),
3172 ab8500_gpadc_dir, &plf->dev,
3173 &ab8500_gpadc_usb_id_fops);
3174 if (!file)
3175 goto err;
3176
3177 if (is_ab8540(ab8500)) {
3178 file = debugfs_create_file("xtal_temp",
3179 (S_IRUGO | S_IWUSR | S_IWGRP),
3180 ab8500_gpadc_dir, &plf->dev,
3181 &ab8540_gpadc_xtal_temp_fops);
3182 if (!file)
3183 goto err;
3184 file = debugfs_create_file("vbattruemeas",
3185 (S_IRUGO | S_IWUSR | S_IWGRP),
3186 ab8500_gpadc_dir, &plf->dev,
3187 &ab8540_gpadc_vbat_true_meas_fops);
3188 if (!file)
3189 goto err;
3190 file = debugfs_create_file("batctrl_and_ibat",
3191 (S_IRUGO | S_IWUGO),
3192 ab8500_gpadc_dir,
3193 &plf->dev,
3194 &ab8540_gpadc_bat_ctrl_and_ibat_fops);
3195 if (!file)
3196 goto err;
3197 file = debugfs_create_file("vbatmeas_and_ibat",
3198 (S_IRUGO | S_IWUGO),
3199 ab8500_gpadc_dir, &plf->dev,
3200 &ab8540_gpadc_vbat_meas_and_ibat_fops);
3201 if (!file)
3202 goto err;
3203 file = debugfs_create_file("vbattruemeas_and_ibat",
3204 (S_IRUGO | S_IWUGO),
3205 ab8500_gpadc_dir,
3206 &plf->dev,
3207 &ab8540_gpadc_vbat_true_meas_and_ibat_fops);
3208 if (!file)
3209 goto err;
3210 file = debugfs_create_file("battemp_and_ibat",
3211 (S_IRUGO | S_IWUGO),
3212 ab8500_gpadc_dir,
3213 &plf->dev, &ab8540_gpadc_bat_temp_and_ibat_fops);
3214 if (!file)
3215 goto err;
3216 file = debugfs_create_file("otp_calib",
3217 (S_IRUGO | S_IWUSR | S_IWGRP),
3218 ab8500_gpadc_dir,
3219 &plf->dev, &ab8540_gpadc_otp_calib_fops);
3220 if (!file)
3221 goto err;
3222 }
3223 file = debugfs_create_file("avg_sample", (S_IRUGO | S_IWUSR | S_IWGRP),
3224 ab8500_gpadc_dir, &plf->dev,
3225 &ab8500_gpadc_avg_sample_fops);
3226 if (!file)
3227 goto err;
3228
3229 file = debugfs_create_file("trig_edge", (S_IRUGO | S_IWUSR | S_IWGRP),
3230 ab8500_gpadc_dir, &plf->dev,
3231 &ab8500_gpadc_trig_edge_fops);
3232 if (!file)
3233 goto err;
3234
3235 file = debugfs_create_file("trig_timer", (S_IRUGO | S_IWUSR | S_IWGRP),
3236 ab8500_gpadc_dir, &plf->dev,
3237 &ab8500_gpadc_trig_timer_fops);
3238 if (!file)
3239 goto err;
3240
3241 file = debugfs_create_file("conv_type", (S_IRUGO | S_IWUSR | S_IWGRP),
3242 ab8500_gpadc_dir, &plf->dev,
3243 &ab8500_gpadc_conv_type_fops);
3244 if (!file)
3245 goto err;
3246
3247 return 0;
3248
3249 err:
3250 debugfs_remove_recursive(ab8500_dir);
3251 dev_err(&plf->dev, "failed to create debugfs entries.\n");
3252
3253 return -ENOMEM;
3254 }
3255
3256 static int ab8500_debug_remove(struct platform_device *plf)
3257 {
3258 debugfs_remove_recursive(ab8500_dir);
3259
3260 return 0;
3261 }
3262
3263 static struct platform_driver ab8500_debug_driver = {
3264 .driver = {
3265 .name = "ab8500-debug",
3266 .owner = THIS_MODULE,
3267 },
3268 .probe = ab8500_debug_probe,
3269 .remove = ab8500_debug_remove
3270 };
3271
3272 static int __init ab8500_debug_init(void)
3273 {
3274 return platform_driver_register(&ab8500_debug_driver);
3275 }
3276
3277 static void __exit ab8500_debug_exit(void)
3278 {
3279 platform_driver_unregister(&ab8500_debug_driver);
3280 }
3281 subsys_initcall(ab8500_debug_init);
3282 module_exit(ab8500_debug_exit);
3283
3284 MODULE_AUTHOR("Mattias WALLIN <mattias.wallin@stericsson.com");
3285 MODULE_DESCRIPTION("AB8500 DEBUG");
3286 MODULE_LICENSE("GPL v2");
(deprecated) Btrfs devel tree