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