Loading...
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Copyright (C) ST-Ericsson SA 2010
4 *
5 * Author: Mattias Wallin <mattias.wallin@stericsson.com> for ST-Ericsson.
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
88#ifdef CONFIG_DEBUG_FS
89#include <linux/string.h>
90#include <linux/ctype.h>
91#endif
92
93static u32 debug_bank;
94static u32 debug_address;
95
96static int irq_ab8500;
97static int irq_first;
98static int irq_last;
99static u32 *irq_count;
100static int num_irqs;
101
102static struct device_attribute **dev_attr;
103static char **event_name;
104
105/**
106 * struct ab8500_reg_range
107 * @first: the first address of the range
108 * @last: the last address of the range
109 * @perm: access permissions for the range
110 */
111struct ab8500_reg_range {
112 u8 first;
113 u8 last;
114 u8 perm;
115};
116
117/**
118 * struct ab8500_prcmu_ranges
119 * @num_ranges: the number of ranges in the list
120 * @bankid: bank identifier
121 * @range: the list of register ranges
122 */
123struct ab8500_prcmu_ranges {
124 u8 num_ranges;
125 u8 bankid;
126 const struct ab8500_reg_range *range;
127};
128
129/* hwreg- "mask" and "shift" entries ressources */
130struct hwreg_cfg {
131 u32 bank; /* target bank */
132 unsigned long addr; /* target address */
133 uint fmt; /* format */
134 unsigned long mask; /* read/write mask, applied before any bit shift */
135 long shift; /* bit shift (read:right shift, write:left shift */
136};
137/* fmt bit #0: 0=hexa, 1=dec */
138#define REG_FMT_DEC(c) ((c)->fmt & 0x1)
139#define REG_FMT_HEX(c) (!REG_FMT_DEC(c))
140
141static struct hwreg_cfg hwreg_cfg = {
142 .addr = 0, /* default: invalid phys addr */
143 .fmt = 0, /* default: 32bit access, hex output */
144 .mask = 0xFFFFFFFF, /* default: no mask */
145 .shift = 0, /* default: no bit shift */
146};
147
148#define AB8500_NAME_STRING "ab8500"
149#define AB8500_NUM_BANKS AB8500_DEBUG_FIELD_LAST
150
151#define AB8500_REV_REG 0x80
152
153static struct ab8500_prcmu_ranges *debug_ranges;
154
155static struct ab8500_prcmu_ranges ab8500_debug_ranges[AB8500_NUM_BANKS] = {
156 [AB8500_M_FSM_RANK] = {
157 .num_ranges = 0,
158 .range = NULL,
159 },
160 [AB8500_SYS_CTRL1_BLOCK] = {
161 .num_ranges = 3,
162 .range = (struct ab8500_reg_range[]) {
163 {
164 .first = 0x00,
165 .last = 0x02,
166 },
167 {
168 .first = 0x42,
169 .last = 0x42,
170 },
171 {
172 .first = 0x80,
173 .last = 0x81,
174 },
175 },
176 },
177 [AB8500_SYS_CTRL2_BLOCK] = {
178 .num_ranges = 4,
179 .range = (struct ab8500_reg_range[]) {
180 {
181 .first = 0x00,
182 .last = 0x0D,
183 },
184 {
185 .first = 0x0F,
186 .last = 0x17,
187 },
188 {
189 .first = 0x30,
190 .last = 0x30,
191 },
192 {
193 .first = 0x32,
194 .last = 0x33,
195 },
196 },
197 },
198 [AB8500_REGU_CTRL1] = {
199 .num_ranges = 3,
200 .range = (struct ab8500_reg_range[]) {
201 {
202 .first = 0x00,
203 .last = 0x00,
204 },
205 {
206 .first = 0x03,
207 .last = 0x10,
208 },
209 {
210 .first = 0x80,
211 .last = 0x84,
212 },
213 },
214 },
215 [AB8500_REGU_CTRL2] = {
216 .num_ranges = 5,
217 .range = (struct ab8500_reg_range[]) {
218 {
219 .first = 0x00,
220 .last = 0x15,
221 },
222 {
223 .first = 0x17,
224 .last = 0x19,
225 },
226 {
227 .first = 0x1B,
228 .last = 0x1D,
229 },
230 {
231 .first = 0x1F,
232 .last = 0x22,
233 },
234 {
235 .first = 0x40,
236 .last = 0x44,
237 },
238 /*
239 * 0x80-0x8B are SIM registers and should
240 * not be accessed from here
241 */
242 },
243 },
244 [AB8500_USB] = {
245 .num_ranges = 2,
246 .range = (struct ab8500_reg_range[]) {
247 {
248 .first = 0x80,
249 .last = 0x83,
250 },
251 {
252 .first = 0x87,
253 .last = 0x8A,
254 },
255 },
256 },
257 [AB8500_TVOUT] = {
258 .num_ranges = 9,
259 .range = (struct ab8500_reg_range[]) {
260 {
261 .first = 0x00,
262 .last = 0x12,
263 },
264 {
265 .first = 0x15,
266 .last = 0x17,
267 },
268 {
269 .first = 0x19,
270 .last = 0x21,
271 },
272 {
273 .first = 0x27,
274 .last = 0x2C,
275 },
276 {
277 .first = 0x41,
278 .last = 0x41,
279 },
280 {
281 .first = 0x45,
282 .last = 0x5B,
283 },
284 {
285 .first = 0x5D,
286 .last = 0x5D,
287 },
288 {
289 .first = 0x69,
290 .last = 0x69,
291 },
292 {
293 .first = 0x80,
294 .last = 0x81,
295 },
296 },
297 },
298 [AB8500_DBI] = {
299 .num_ranges = 0,
300 .range = NULL,
301 },
302 [AB8500_ECI_AV_ACC] = {
303 .num_ranges = 1,
304 .range = (struct ab8500_reg_range[]) {
305 {
306 .first = 0x80,
307 .last = 0x82,
308 },
309 },
310 },
311 [AB8500_RESERVED] = {
312 .num_ranges = 0,
313 .range = NULL,
314 },
315 [AB8500_GPADC] = {
316 .num_ranges = 1,
317 .range = (struct ab8500_reg_range[]) {
318 {
319 .first = 0x00,
320 .last = 0x08,
321 },
322 },
323 },
324 [AB8500_CHARGER] = {
325 .num_ranges = 9,
326 .range = (struct ab8500_reg_range[]) {
327 {
328 .first = 0x00,
329 .last = 0x03,
330 },
331 {
332 .first = 0x05,
333 .last = 0x05,
334 },
335 {
336 .first = 0x40,
337 .last = 0x40,
338 },
339 {
340 .first = 0x42,
341 .last = 0x42,
342 },
343 {
344 .first = 0x44,
345 .last = 0x44,
346 },
347 {
348 .first = 0x50,
349 .last = 0x55,
350 },
351 {
352 .first = 0x80,
353 .last = 0x82,
354 },
355 {
356 .first = 0xC0,
357 .last = 0xC2,
358 },
359 {
360 .first = 0xf5,
361 .last = 0xf6,
362 },
363 },
364 },
365 [AB8500_GAS_GAUGE] = {
366 .num_ranges = 3,
367 .range = (struct ab8500_reg_range[]) {
368 {
369 .first = 0x00,
370 .last = 0x00,
371 },
372 {
373 .first = 0x07,
374 .last = 0x0A,
375 },
376 {
377 .first = 0x10,
378 .last = 0x14,
379 },
380 },
381 },
382 [AB8500_AUDIO] = {
383 .num_ranges = 1,
384 .range = (struct ab8500_reg_range[]) {
385 {
386 .first = 0x00,
387 .last = 0x6F,
388 },
389 },
390 },
391 [AB8500_INTERRUPT] = {
392 .num_ranges = 0,
393 .range = NULL,
394 },
395 [AB8500_RTC] = {
396 .num_ranges = 1,
397 .range = (struct ab8500_reg_range[]) {
398 {
399 .first = 0x00,
400 .last = 0x0F,
401 },
402 },
403 },
404 [AB8500_MISC] = {
405 .num_ranges = 8,
406 .range = (struct ab8500_reg_range[]) {
407 {
408 .first = 0x00,
409 .last = 0x05,
410 },
411 {
412 .first = 0x10,
413 .last = 0x15,
414 },
415 {
416 .first = 0x20,
417 .last = 0x25,
418 },
419 {
420 .first = 0x30,
421 .last = 0x35,
422 },
423 {
424 .first = 0x40,
425 .last = 0x45,
426 },
427 {
428 .first = 0x50,
429 .last = 0x50,
430 },
431 {
432 .first = 0x60,
433 .last = 0x67,
434 },
435 {
436 .first = 0x80,
437 .last = 0x80,
438 },
439 },
440 },
441 [AB8500_DEVELOPMENT] = {
442 .num_ranges = 1,
443 .range = (struct ab8500_reg_range[]) {
444 {
445 .first = 0x00,
446 .last = 0x00,
447 },
448 },
449 },
450 [AB8500_DEBUG] = {
451 .num_ranges = 1,
452 .range = (struct ab8500_reg_range[]) {
453 {
454 .first = 0x05,
455 .last = 0x07,
456 },
457 },
458 },
459 [AB8500_PROD_TEST] = {
460 .num_ranges = 0,
461 .range = NULL,
462 },
463 [AB8500_STE_TEST] = {
464 .num_ranges = 0,
465 .range = NULL,
466 },
467 [AB8500_OTP_EMUL] = {
468 .num_ranges = 1,
469 .range = (struct ab8500_reg_range[]) {
470 {
471 .first = 0x01,
472 .last = 0x0F,
473 },
474 },
475 },
476};
477
478static struct ab8500_prcmu_ranges ab8505_debug_ranges[AB8500_NUM_BANKS] = {
479 [0x0] = {
480 .num_ranges = 0,
481 .range = NULL,
482 },
483 [AB8500_SYS_CTRL1_BLOCK] = {
484 .num_ranges = 5,
485 .range = (struct ab8500_reg_range[]) {
486 {
487 .first = 0x00,
488 .last = 0x04,
489 },
490 {
491 .first = 0x42,
492 .last = 0x42,
493 },
494 {
495 .first = 0x52,
496 .last = 0x52,
497 },
498 {
499 .first = 0x54,
500 .last = 0x57,
501 },
502 {
503 .first = 0x80,
504 .last = 0x83,
505 },
506 },
507 },
508 [AB8500_SYS_CTRL2_BLOCK] = {
509 .num_ranges = 5,
510 .range = (struct ab8500_reg_range[]) {
511 {
512 .first = 0x00,
513 .last = 0x0D,
514 },
515 {
516 .first = 0x0F,
517 .last = 0x17,
518 },
519 {
520 .first = 0x20,
521 .last = 0x20,
522 },
523 {
524 .first = 0x30,
525 .last = 0x30,
526 },
527 {
528 .first = 0x32,
529 .last = 0x3A,
530 },
531 },
532 },
533 [AB8500_REGU_CTRL1] = {
534 .num_ranges = 3,
535 .range = (struct ab8500_reg_range[]) {
536 {
537 .first = 0x00,
538 .last = 0x00,
539 },
540 {
541 .first = 0x03,
542 .last = 0x11,
543 },
544 {
545 .first = 0x80,
546 .last = 0x86,
547 },
548 },
549 },
550 [AB8500_REGU_CTRL2] = {
551 .num_ranges = 6,
552 .range = (struct ab8500_reg_range[]) {
553 {
554 .first = 0x00,
555 .last = 0x06,
556 },
557 {
558 .first = 0x08,
559 .last = 0x15,
560 },
561 {
562 .first = 0x17,
563 .last = 0x19,
564 },
565 {
566 .first = 0x1B,
567 .last = 0x1D,
568 },
569 {
570 .first = 0x1F,
571 .last = 0x30,
572 },
573 {
574 .first = 0x40,
575 .last = 0x48,
576 },
577 /*
578 * 0x80-0x8B are SIM registers and should
579 * not be accessed from here
580 */
581 },
582 },
583 [AB8500_USB] = {
584 .num_ranges = 3,
585 .range = (struct ab8500_reg_range[]) {
586 {
587 .first = 0x80,
588 .last = 0x83,
589 },
590 {
591 .first = 0x87,
592 .last = 0x8A,
593 },
594 {
595 .first = 0x91,
596 .last = 0x94,
597 },
598 },
599 },
600 [AB8500_TVOUT] = {
601 .num_ranges = 0,
602 .range = NULL,
603 },
604 [AB8500_DBI] = {
605 .num_ranges = 0,
606 .range = NULL,
607 },
608 [AB8500_ECI_AV_ACC] = {
609 .num_ranges = 1,
610 .range = (struct ab8500_reg_range[]) {
611 {
612 .first = 0x80,
613 .last = 0x82,
614 },
615 },
616 },
617 [AB8500_RESERVED] = {
618 .num_ranges = 0,
619 .range = NULL,
620 },
621 [AB8500_GPADC] = {
622 .num_ranges = 1,
623 .range = (struct ab8500_reg_range[]) {
624 {
625 .first = 0x00,
626 .last = 0x08,
627 },
628 },
629 },
630 [AB8500_CHARGER] = {
631 .num_ranges = 9,
632 .range = (struct ab8500_reg_range[]) {
633 {
634 .first = 0x02,
635 .last = 0x03,
636 },
637 {
638 .first = 0x05,
639 .last = 0x05,
640 },
641 {
642 .first = 0x40,
643 .last = 0x44,
644 },
645 {
646 .first = 0x50,
647 .last = 0x57,
648 },
649 {
650 .first = 0x60,
651 .last = 0x60,
652 },
653 {
654 .first = 0xA0,
655 .last = 0xA7,
656 },
657 {
658 .first = 0xAF,
659 .last = 0xB2,
660 },
661 {
662 .first = 0xC0,
663 .last = 0xC2,
664 },
665 {
666 .first = 0xF5,
667 .last = 0xF5,
668 },
669 },
670 },
671 [AB8500_GAS_GAUGE] = {
672 .num_ranges = 3,
673 .range = (struct ab8500_reg_range[]) {
674 {
675 .first = 0x00,
676 .last = 0x00,
677 },
678 {
679 .first = 0x07,
680 .last = 0x0A,
681 },
682 {
683 .first = 0x10,
684 .last = 0x14,
685 },
686 },
687 },
688 [AB8500_AUDIO] = {
689 .num_ranges = 1,
690 .range = (struct ab8500_reg_range[]) {
691 {
692 .first = 0x00,
693 .last = 0x83,
694 },
695 },
696 },
697 [AB8500_INTERRUPT] = {
698 .num_ranges = 11,
699 .range = (struct ab8500_reg_range[]) {
700 {
701 .first = 0x00,
702 .last = 0x04,
703 },
704 {
705 .first = 0x06,
706 .last = 0x07,
707 },
708 {
709 .first = 0x09,
710 .last = 0x09,
711 },
712 {
713 .first = 0x0B,
714 .last = 0x0C,
715 },
716 {
717 .first = 0x12,
718 .last = 0x15,
719 },
720 {
721 .first = 0x18,
722 .last = 0x18,
723 },
724 /* Latch registers should not be read here */
725 {
726 .first = 0x40,
727 .last = 0x44,
728 },
729 {
730 .first = 0x46,
731 .last = 0x49,
732 },
733 {
734 .first = 0x4B,
735 .last = 0x4D,
736 },
737 {
738 .first = 0x52,
739 .last = 0x55,
740 },
741 {
742 .first = 0x58,
743 .last = 0x58,
744 },
745 /* LatchHier registers should not be read here */
746 },
747 },
748 [AB8500_RTC] = {
749 .num_ranges = 2,
750 .range = (struct ab8500_reg_range[]) {
751 {
752 .first = 0x00,
753 .last = 0x14,
754 },
755 {
756 .first = 0x16,
757 .last = 0x17,
758 },
759 },
760 },
761 [AB8500_MISC] = {
762 .num_ranges = 8,
763 .range = (struct ab8500_reg_range[]) {
764 {
765 .first = 0x00,
766 .last = 0x06,
767 },
768 {
769 .first = 0x10,
770 .last = 0x16,
771 },
772 {
773 .first = 0x20,
774 .last = 0x26,
775 },
776 {
777 .first = 0x30,
778 .last = 0x36,
779 },
780 {
781 .first = 0x40,
782 .last = 0x46,
783 },
784 {
785 .first = 0x50,
786 .last = 0x50,
787 },
788 {
789 .first = 0x60,
790 .last = 0x6B,
791 },
792 {
793 .first = 0x80,
794 .last = 0x82,
795 },
796 },
797 },
798 [AB8500_DEVELOPMENT] = {
799 .num_ranges = 2,
800 .range = (struct ab8500_reg_range[]) {
801 {
802 .first = 0x00,
803 .last = 0x00,
804 },
805 {
806 .first = 0x05,
807 .last = 0x05,
808 },
809 },
810 },
811 [AB8500_DEBUG] = {
812 .num_ranges = 1,
813 .range = (struct ab8500_reg_range[]) {
814 {
815 .first = 0x05,
816 .last = 0x07,
817 },
818 },
819 },
820 [AB8500_PROD_TEST] = {
821 .num_ranges = 0,
822 .range = NULL,
823 },
824 [AB8500_STE_TEST] = {
825 .num_ranges = 0,
826 .range = NULL,
827 },
828 [AB8500_OTP_EMUL] = {
829 .num_ranges = 1,
830 .range = (struct ab8500_reg_range[]) {
831 {
832 .first = 0x01,
833 .last = 0x15,
834 },
835 },
836 },
837};
838
839static struct ab8500_prcmu_ranges ab8540_debug_ranges[AB8500_NUM_BANKS] = {
840 [AB8500_M_FSM_RANK] = {
841 .num_ranges = 1,
842 .range = (struct ab8500_reg_range[]) {
843 {
844 .first = 0x00,
845 .last = 0x0B,
846 },
847 },
848 },
849 [AB8500_SYS_CTRL1_BLOCK] = {
850 .num_ranges = 6,
851 .range = (struct ab8500_reg_range[]) {
852 {
853 .first = 0x00,
854 .last = 0x04,
855 },
856 {
857 .first = 0x42,
858 .last = 0x42,
859 },
860 {
861 .first = 0x50,
862 .last = 0x54,
863 },
864 {
865 .first = 0x57,
866 .last = 0x57,
867 },
868 {
869 .first = 0x80,
870 .last = 0x83,
871 },
872 {
873 .first = 0x90,
874 .last = 0x90,
875 },
876 },
877 },
878 [AB8500_SYS_CTRL2_BLOCK] = {
879 .num_ranges = 5,
880 .range = (struct ab8500_reg_range[]) {
881 {
882 .first = 0x00,
883 .last = 0x0D,
884 },
885 {
886 .first = 0x0F,
887 .last = 0x10,
888 },
889 {
890 .first = 0x20,
891 .last = 0x21,
892 },
893 {
894 .first = 0x32,
895 .last = 0x3C,
896 },
897 {
898 .first = 0x40,
899 .last = 0x42,
900 },
901 },
902 },
903 [AB8500_REGU_CTRL1] = {
904 .num_ranges = 4,
905 .range = (struct ab8500_reg_range[]) {
906 {
907 .first = 0x03,
908 .last = 0x15,
909 },
910 {
911 .first = 0x20,
912 .last = 0x20,
913 },
914 {
915 .first = 0x80,
916 .last = 0x85,
917 },
918 {
919 .first = 0x87,
920 .last = 0x88,
921 },
922 },
923 },
924 [AB8500_REGU_CTRL2] = {
925 .num_ranges = 8,
926 .range = (struct ab8500_reg_range[]) {
927 {
928 .first = 0x00,
929 .last = 0x06,
930 },
931 {
932 .first = 0x08,
933 .last = 0x15,
934 },
935 {
936 .first = 0x17,
937 .last = 0x19,
938 },
939 {
940 .first = 0x1B,
941 .last = 0x1D,
942 },
943 {
944 .first = 0x1F,
945 .last = 0x2F,
946 },
947 {
948 .first = 0x31,
949 .last = 0x3A,
950 },
951 {
952 .first = 0x43,
953 .last = 0x44,
954 },
955 {
956 .first = 0x48,
957 .last = 0x49,
958 },
959 },
960 },
961 [AB8500_USB] = {
962 .num_ranges = 3,
963 .range = (struct ab8500_reg_range[]) {
964 {
965 .first = 0x80,
966 .last = 0x83,
967 },
968 {
969 .first = 0x87,
970 .last = 0x8A,
971 },
972 {
973 .first = 0x91,
974 .last = 0x94,
975 },
976 },
977 },
978 [AB8500_TVOUT] = {
979 .num_ranges = 0,
980 .range = NULL
981 },
982 [AB8500_DBI] = {
983 .num_ranges = 4,
984 .range = (struct ab8500_reg_range[]) {
985 {
986 .first = 0x00,
987 .last = 0x07,
988 },
989 {
990 .first = 0x10,
991 .last = 0x11,
992 },
993 {
994 .first = 0x20,
995 .last = 0x21,
996 },
997 {
998 .first = 0x30,
999 .last = 0x43,
1000 },
1001 },
1002 },
1003 [AB8500_ECI_AV_ACC] = {
1004 .num_ranges = 2,
1005 .range = (struct ab8500_reg_range[]) {
1006 {
1007 .first = 0x00,
1008 .last = 0x03,
1009 },
1010 {
1011 .first = 0x80,
1012 .last = 0x82,
1013 },
1014 },
1015 },
1016 [AB8500_RESERVED] = {
1017 .num_ranges = 0,
1018 .range = NULL,
1019 },
1020 [AB8500_GPADC] = {
1021 .num_ranges = 4,
1022 .range = (struct ab8500_reg_range[]) {
1023 {
1024 .first = 0x00,
1025 .last = 0x01,
1026 },
1027 {
1028 .first = 0x04,
1029 .last = 0x06,
1030 },
1031 {
1032 .first = 0x09,
1033 .last = 0x0A,
1034 },
1035 {
1036 .first = 0x10,
1037 .last = 0x14,
1038 },
1039 },
1040 },
1041 [AB8500_CHARGER] = {
1042 .num_ranges = 10,
1043 .range = (struct ab8500_reg_range[]) {
1044 {
1045 .first = 0x00,
1046 .last = 0x00,
1047 },
1048 {
1049 .first = 0x02,
1050 .last = 0x05,
1051 },
1052 {
1053 .first = 0x40,
1054 .last = 0x44,
1055 },
1056 {
1057 .first = 0x50,
1058 .last = 0x57,
1059 },
1060 {
1061 .first = 0x60,
1062 .last = 0x60,
1063 },
1064 {
1065 .first = 0x70,
1066 .last = 0x70,
1067 },
1068 {
1069 .first = 0xA0,
1070 .last = 0xA9,
1071 },
1072 {
1073 .first = 0xAF,
1074 .last = 0xB2,
1075 },
1076 {
1077 .first = 0xC0,
1078 .last = 0xC6,
1079 },
1080 {
1081 .first = 0xF5,
1082 .last = 0xF5,
1083 },
1084 },
1085 },
1086 [AB8500_GAS_GAUGE] = {
1087 .num_ranges = 3,
1088 .range = (struct ab8500_reg_range[]) {
1089 {
1090 .first = 0x00,
1091 .last = 0x00,
1092 },
1093 {
1094 .first = 0x07,
1095 .last = 0x0A,
1096 },
1097 {
1098 .first = 0x10,
1099 .last = 0x14,
1100 },
1101 },
1102 },
1103 [AB8500_AUDIO] = {
1104 .num_ranges = 1,
1105 .range = (struct ab8500_reg_range[]) {
1106 {
1107 .first = 0x00,
1108 .last = 0x9f,
1109 },
1110 },
1111 },
1112 [AB8500_INTERRUPT] = {
1113 .num_ranges = 6,
1114 .range = (struct ab8500_reg_range[]) {
1115 {
1116 .first = 0x00,
1117 .last = 0x05,
1118 },
1119 {
1120 .first = 0x0B,
1121 .last = 0x0D,
1122 },
1123 {
1124 .first = 0x12,
1125 .last = 0x20,
1126 },
1127 /* Latch registers should not be read here */
1128 {
1129 .first = 0x40,
1130 .last = 0x45,
1131 },
1132 {
1133 .first = 0x4B,
1134 .last = 0x4D,
1135 },
1136 {
1137 .first = 0x52,
1138 .last = 0x60,
1139 },
1140 /* LatchHier registers should not be read here */
1141 },
1142 },
1143 [AB8500_RTC] = {
1144 .num_ranges = 3,
1145 .range = (struct ab8500_reg_range[]) {
1146 {
1147 .first = 0x00,
1148 .last = 0x07,
1149 },
1150 {
1151 .first = 0x0B,
1152 .last = 0x18,
1153 },
1154 {
1155 .first = 0x20,
1156 .last = 0x25,
1157 },
1158 },
1159 },
1160 [AB8500_MISC] = {
1161 .num_ranges = 9,
1162 .range = (struct ab8500_reg_range[]) {
1163 {
1164 .first = 0x00,
1165 .last = 0x06,
1166 },
1167 {
1168 .first = 0x10,
1169 .last = 0x16,
1170 },
1171 {
1172 .first = 0x20,
1173 .last = 0x26,
1174 },
1175 {
1176 .first = 0x30,
1177 .last = 0x36,
1178 },
1179 {
1180 .first = 0x40,
1181 .last = 0x49,
1182 },
1183 {
1184 .first = 0x50,
1185 .last = 0x50,
1186 },
1187 {
1188 .first = 0x60,
1189 .last = 0x6B,
1190 },
1191 {
1192 .first = 0x70,
1193 .last = 0x74,
1194 },
1195 {
1196 .first = 0x80,
1197 .last = 0x82,
1198 },
1199 },
1200 },
1201 [AB8500_DEVELOPMENT] = {
1202 .num_ranges = 3,
1203 .range = (struct ab8500_reg_range[]) {
1204 {
1205 .first = 0x00,
1206 .last = 0x01,
1207 },
1208 {
1209 .first = 0x06,
1210 .last = 0x06,
1211 },
1212 {
1213 .first = 0x10,
1214 .last = 0x21,
1215 },
1216 },
1217 },
1218 [AB8500_DEBUG] = {
1219 .num_ranges = 3,
1220 .range = (struct ab8500_reg_range[]) {
1221 {
1222 .first = 0x01,
1223 .last = 0x0C,
1224 },
1225 {
1226 .first = 0x0E,
1227 .last = 0x11,
1228 },
1229 {
1230 .first = 0x80,
1231 .last = 0x81,
1232 },
1233 },
1234 },
1235 [AB8500_PROD_TEST] = {
1236 .num_ranges = 0,
1237 .range = NULL,
1238 },
1239 [AB8500_STE_TEST] = {
1240 .num_ranges = 0,
1241 .range = NULL,
1242 },
1243 [AB8500_OTP_EMUL] = {
1244 .num_ranges = 1,
1245 .range = (struct ab8500_reg_range[]) {
1246 {
1247 .first = 0x00,
1248 .last = 0x3F,
1249 },
1250 },
1251 },
1252};
1253
1254static irqreturn_t ab8500_debug_handler(int irq, void *data)
1255{
1256 char buf[16];
1257 struct kobject *kobj = (struct kobject *)data;
1258 unsigned int irq_abb = irq - irq_first;
1259
1260 if (irq_abb < num_irqs)
1261 irq_count[irq_abb]++;
1262 /*
1263 * This makes it possible to use poll for events (EPOLLPRI | EPOLLERR)
1264 * from userspace on sysfs file named <irq-nr>
1265 */
1266 sprintf(buf, "%d", irq);
1267 sysfs_notify(kobj, NULL, buf);
1268
1269 return IRQ_HANDLED;
1270}
1271
1272/* Prints to seq_file or log_buf */
1273static int ab8500_registers_print(struct device *dev, u32 bank,
1274 struct seq_file *s)
1275{
1276 unsigned int i;
1277
1278 for (i = 0; i < debug_ranges[bank].num_ranges; i++) {
1279 u32 reg;
1280
1281 for (reg = debug_ranges[bank].range[i].first;
1282 reg <= debug_ranges[bank].range[i].last;
1283 reg++) {
1284 u8 value;
1285 int err;
1286
1287 err = abx500_get_register_interruptible(dev,
1288 (u8)bank, (u8)reg, &value);
1289 if (err < 0) {
1290 dev_err(dev, "ab->read fail %d\n", err);
1291 return err;
1292 }
1293
1294 if (s) {
1295 seq_printf(s, " [0x%02X/0x%02X]: 0x%02X\n",
1296 bank, reg, value);
1297 /*
1298 * Error is not returned here since
1299 * the output is wanted in any case
1300 */
1301 if (seq_has_overflowed(s))
1302 return 0;
1303 } else {
1304 dev_info(dev, " [0x%02X/0x%02X]: 0x%02X\n",
1305 bank, reg, value);
1306 }
1307 }
1308 }
1309
1310 return 0;
1311}
1312
1313static int ab8500_bank_registers_show(struct seq_file *s, void *p)
1314{
1315 struct device *dev = s->private;
1316 u32 bank = debug_bank;
1317
1318 seq_puts(s, AB8500_NAME_STRING " register values:\n");
1319
1320 seq_printf(s, " bank 0x%02X:\n", bank);
1321
1322 return ab8500_registers_print(dev, bank, s);
1323}
1324
1325DEFINE_SHOW_ATTRIBUTE(ab8500_bank_registers);
1326
1327static int ab8500_print_all_banks(struct seq_file *s, void *p)
1328{
1329 struct device *dev = s->private;
1330 unsigned int i;
1331
1332 seq_puts(s, AB8500_NAME_STRING " register values:\n");
1333
1334 for (i = 0; i < AB8500_NUM_BANKS; i++) {
1335 int err;
1336
1337 seq_printf(s, " bank 0x%02X:\n", i);
1338 err = ab8500_registers_print(dev, i, s);
1339 if (err)
1340 return err;
1341 }
1342 return 0;
1343}
1344
1345/* Dump registers to kernel log */
1346void ab8500_dump_all_banks(struct device *dev)
1347{
1348 unsigned int i;
1349
1350 dev_info(dev, "ab8500 register values:\n");
1351
1352 for (i = 1; i < AB8500_NUM_BANKS; i++) {
1353 dev_info(dev, " bank 0x%02X:\n", i);
1354 ab8500_registers_print(dev, i, NULL);
1355 }
1356}
1357
1358static int ab8500_all_banks_open(struct inode *inode, struct file *file)
1359{
1360 struct seq_file *s;
1361 int err;
1362
1363 err = single_open(file, ab8500_print_all_banks, inode->i_private);
1364 if (!err) {
1365 /* Default buf size in seq_read is not enough */
1366 s = (struct seq_file *)file->private_data;
1367 s->size = (PAGE_SIZE * 2);
1368 s->buf = kmalloc(s->size, GFP_KERNEL);
1369 if (!s->buf) {
1370 single_release(inode, file);
1371 err = -ENOMEM;
1372 }
1373 }
1374 return err;
1375}
1376
1377static const struct file_operations ab8500_all_banks_fops = {
1378 .open = ab8500_all_banks_open,
1379 .read = seq_read,
1380 .llseek = seq_lseek,
1381 .release = single_release,
1382 .owner = THIS_MODULE,
1383};
1384
1385static int ab8500_bank_print(struct seq_file *s, void *p)
1386{
1387 seq_printf(s, "0x%02X\n", debug_bank);
1388 return 0;
1389}
1390
1391static int ab8500_bank_open(struct inode *inode, struct file *file)
1392{
1393 return single_open(file, ab8500_bank_print, inode->i_private);
1394}
1395
1396static ssize_t ab8500_bank_write(struct file *file,
1397 const char __user *user_buf,
1398 size_t count, loff_t *ppos)
1399{
1400 struct device *dev = ((struct seq_file *)(file->private_data))->private;
1401 unsigned long user_bank;
1402 int err;
1403
1404 err = kstrtoul_from_user(user_buf, count, 0, &user_bank);
1405 if (err)
1406 return err;
1407
1408 if (user_bank >= AB8500_NUM_BANKS) {
1409 dev_err(dev, "debugfs error input > number of banks\n");
1410 return -EINVAL;
1411 }
1412
1413 debug_bank = user_bank;
1414
1415 return count;
1416}
1417
1418static int ab8500_address_print(struct seq_file *s, void *p)
1419{
1420 seq_printf(s, "0x%02X\n", debug_address);
1421 return 0;
1422}
1423
1424static int ab8500_address_open(struct inode *inode, struct file *file)
1425{
1426 return single_open(file, ab8500_address_print, inode->i_private);
1427}
1428
1429static ssize_t ab8500_address_write(struct file *file,
1430 const char __user *user_buf,
1431 size_t count, loff_t *ppos)
1432{
1433 struct device *dev = ((struct seq_file *)(file->private_data))->private;
1434 unsigned long user_address;
1435 int err;
1436
1437 err = kstrtoul_from_user(user_buf, count, 0, &user_address);
1438 if (err)
1439 return err;
1440
1441 if (user_address > 0xff) {
1442 dev_err(dev, "debugfs error input > 0xff\n");
1443 return -EINVAL;
1444 }
1445 debug_address = user_address;
1446
1447 return count;
1448}
1449
1450static int ab8500_val_print(struct seq_file *s, void *p)
1451{
1452 struct device *dev = s->private;
1453 int ret;
1454 u8 regvalue;
1455
1456 ret = abx500_get_register_interruptible(dev,
1457 (u8)debug_bank, (u8)debug_address, ®value);
1458 if (ret < 0) {
1459 dev_err(dev, "abx500_get_reg fail %d, %d\n",
1460 ret, __LINE__);
1461 return -EINVAL;
1462 }
1463 seq_printf(s, "0x%02X\n", regvalue);
1464
1465 return 0;
1466}
1467
1468static int ab8500_val_open(struct inode *inode, struct file *file)
1469{
1470 return single_open(file, ab8500_val_print, inode->i_private);
1471}
1472
1473static ssize_t ab8500_val_write(struct file *file,
1474 const char __user *user_buf,
1475 size_t count, loff_t *ppos)
1476{
1477 struct device *dev = ((struct seq_file *)(file->private_data))->private;
1478 unsigned long user_val;
1479 int err;
1480
1481 err = kstrtoul_from_user(user_buf, count, 0, &user_val);
1482 if (err)
1483 return err;
1484
1485 if (user_val > 0xff) {
1486 dev_err(dev, "debugfs error input > 0xff\n");
1487 return -EINVAL;
1488 }
1489 err = abx500_set_register_interruptible(dev,
1490 (u8)debug_bank, debug_address, (u8)user_val);
1491 if (err < 0) {
1492 pr_err("abx500_set_reg failed %d, %d", err, __LINE__);
1493 return -EINVAL;
1494 }
1495
1496 return count;
1497}
1498
1499/*
1500 * Interrupt status
1501 */
1502static u32 num_interrupts[AB8500_MAX_NR_IRQS];
1503static u32 num_wake_interrupts[AB8500_MAX_NR_IRQS];
1504static int num_interrupt_lines;
1505
1506void ab8500_debug_register_interrupt(int line)
1507{
1508 if (line < num_interrupt_lines)
1509 num_interrupts[line]++;
1510}
1511
1512static int ab8500_interrupts_show(struct seq_file *s, void *p)
1513{
1514 int line;
1515
1516 seq_puts(s, "name: number: number of: wake:\n");
1517
1518 for (line = 0; line < num_interrupt_lines; line++) {
1519 struct irq_desc *desc = irq_to_desc(line + irq_first);
1520
1521 seq_printf(s, "%3i: %6i %4i",
1522 line,
1523 num_interrupts[line],
1524 num_wake_interrupts[line]);
1525
1526 if (desc && desc->name)
1527 seq_printf(s, "-%-8s", desc->name);
1528 if (desc && desc->action) {
1529 struct irqaction *action = desc->action;
1530
1531 seq_printf(s, " %s", action->name);
1532 while ((action = action->next) != NULL)
1533 seq_printf(s, ", %s", action->name);
1534 }
1535 seq_putc(s, '\n');
1536 }
1537
1538 return 0;
1539}
1540
1541DEFINE_SHOW_ATTRIBUTE(ab8500_interrupts);
1542
1543/*
1544 * - HWREG DB8500 formated routines
1545 */
1546static int ab8500_hwreg_print(struct seq_file *s, void *d)
1547{
1548 struct device *dev = s->private;
1549 int ret;
1550 u8 regvalue;
1551
1552 ret = abx500_get_register_interruptible(dev,
1553 (u8)hwreg_cfg.bank, (u8)hwreg_cfg.addr, ®value);
1554 if (ret < 0) {
1555 dev_err(dev, "abx500_get_reg fail %d, %d\n",
1556 ret, __LINE__);
1557 return -EINVAL;
1558 }
1559
1560 if (hwreg_cfg.shift >= 0)
1561 regvalue >>= hwreg_cfg.shift;
1562 else
1563 regvalue <<= -hwreg_cfg.shift;
1564 regvalue &= hwreg_cfg.mask;
1565
1566 if (REG_FMT_DEC(&hwreg_cfg))
1567 seq_printf(s, "%d\n", regvalue);
1568 else
1569 seq_printf(s, "0x%02X\n", regvalue);
1570 return 0;
1571}
1572
1573static int ab8500_hwreg_open(struct inode *inode, struct file *file)
1574{
1575 return single_open(file, ab8500_hwreg_print, inode->i_private);
1576}
1577
1578#define AB8500_SUPPLY_CONTROL_CONFIG_1 0x01
1579#define AB8500_SUPPLY_CONTROL_REG 0x00
1580#define AB8500_FIRST_SIM_REG 0x80
1581#define AB8500_LAST_SIM_REG 0x8B
1582#define AB8505_LAST_SIM_REG 0x8C
1583
1584static int ab8500_modem_show(struct seq_file *s, void *p)
1585{
1586 struct device *dev = s->private;
1587 struct ab8500 *ab8500;
1588 int err;
1589 u8 value;
1590 u8 orig_value;
1591 u32 bank = AB8500_REGU_CTRL2;
1592 u32 last_sim_reg = AB8500_LAST_SIM_REG;
1593 u32 reg;
1594
1595 ab8500 = dev_get_drvdata(dev->parent);
1596 dev_warn(dev, "WARNING! This operation can interfer with modem side\n"
1597 "and should only be done with care\n");
1598
1599 err = abx500_get_register_interruptible(dev,
1600 AB8500_REGU_CTRL1, AB8500_SUPPLY_CONTROL_REG, &orig_value);
1601 if (err < 0)
1602 goto report_read_failure;
1603
1604 /* Config 1 will allow APE side to read SIM registers */
1605 err = abx500_set_register_interruptible(dev,
1606 AB8500_REGU_CTRL1, AB8500_SUPPLY_CONTROL_REG,
1607 AB8500_SUPPLY_CONTROL_CONFIG_1);
1608 if (err < 0)
1609 goto report_write_failure;
1610
1611 seq_printf(s, " bank 0x%02X:\n", bank);
1612
1613 if (is_ab9540(ab8500) || is_ab8505(ab8500))
1614 last_sim_reg = AB8505_LAST_SIM_REG;
1615
1616 for (reg = AB8500_FIRST_SIM_REG; reg <= last_sim_reg; reg++) {
1617 err = abx500_get_register_interruptible(dev,
1618 bank, reg, &value);
1619 if (err < 0)
1620 goto report_read_failure;
1621
1622 seq_printf(s, " [0x%02X/0x%02X]: 0x%02X\n", bank, reg, value);
1623 }
1624 err = abx500_set_register_interruptible(dev,
1625 AB8500_REGU_CTRL1, AB8500_SUPPLY_CONTROL_REG, orig_value);
1626 if (err < 0)
1627 goto report_write_failure;
1628
1629 return 0;
1630
1631report_read_failure:
1632 dev_err(dev, "ab->read fail %d\n", err);
1633 return err;
1634
1635report_write_failure:
1636 dev_err(dev, "ab->write fail %d\n", err);
1637 return err;
1638}
1639
1640DEFINE_SHOW_ATTRIBUTE(ab8500_modem);
1641
1642/*
1643 * return length of an ASCII numerical value, 0 is string is not a
1644 * numerical value.
1645 * string shall start at value 1st char.
1646 * string can be tailed with \0 or space or newline chars only.
1647 * value can be decimal or hexadecimal (prefixed 0x or 0X).
1648 */
1649static int strval_len(char *b)
1650{
1651 char *s = b;
1652
1653 if ((*s == '0') && ((*(s+1) == 'x') || (*(s+1) == 'X'))) {
1654 s += 2;
1655 for (; *s && (*s != ' ') && (*s != '\n'); s++) {
1656 if (!isxdigit(*s))
1657 return 0;
1658 }
1659 } else {
1660 if (*s == '-')
1661 s++;
1662 for (; *s && (*s != ' ') && (*s != '\n'); s++) {
1663 if (!isdigit(*s))
1664 return 0;
1665 }
1666 }
1667 return (int) (s-b);
1668}
1669
1670/*
1671 * parse hwreg input data.
1672 * update global hwreg_cfg only if input data syntax is ok.
1673 */
1674static ssize_t hwreg_common_write(char *b, struct hwreg_cfg *cfg,
1675 struct device *dev)
1676{
1677 uint write, val = 0;
1678 u8 regvalue;
1679 int ret;
1680 struct hwreg_cfg loc = {
1681 .bank = 0, /* default: invalid phys addr */
1682 .addr = 0, /* default: invalid phys addr */
1683 .fmt = 0, /* default: 32bit access, hex output */
1684 .mask = 0xFFFFFFFF, /* default: no mask */
1685 .shift = 0, /* default: no bit shift */
1686 };
1687
1688 /* read or write ? */
1689 if (!strncmp(b, "read ", 5)) {
1690 write = 0;
1691 b += 5;
1692 } else if (!strncmp(b, "write ", 6)) {
1693 write = 1;
1694 b += 6;
1695 } else
1696 return -EINVAL;
1697
1698 /* OPTIONS -l|-w|-b -s -m -o */
1699 while ((*b == ' ') || (*b == '-')) {
1700 if (*(b-1) != ' ') {
1701 b++;
1702 continue;
1703 }
1704 if ((!strncmp(b, "-d ", 3)) ||
1705 (!strncmp(b, "-dec ", 5))) {
1706 b += (*(b+2) == ' ') ? 3 : 5;
1707 loc.fmt |= (1<<0);
1708 } else if ((!strncmp(b, "-h ", 3)) ||
1709 (!strncmp(b, "-hex ", 5))) {
1710 b += (*(b+2) == ' ') ? 3 : 5;
1711 loc.fmt &= ~(1<<0);
1712 } else if ((!strncmp(b, "-m ", 3)) ||
1713 (!strncmp(b, "-mask ", 6))) {
1714 b += (*(b+2) == ' ') ? 3 : 6;
1715 if (strval_len(b) == 0)
1716 return -EINVAL;
1717 ret = kstrtoul(b, 0, &loc.mask);
1718 if (ret)
1719 return ret;
1720 } else if ((!strncmp(b, "-s ", 3)) ||
1721 (!strncmp(b, "-shift ", 7))) {
1722 b += (*(b+2) == ' ') ? 3 : 7;
1723 if (strval_len(b) == 0)
1724 return -EINVAL;
1725 ret = kstrtol(b, 0, &loc.shift);
1726 if (ret)
1727 return ret;
1728 } else {
1729 return -EINVAL;
1730 }
1731 }
1732 /* get arg BANK and ADDRESS */
1733 if (strval_len(b) == 0)
1734 return -EINVAL;
1735 ret = kstrtouint(b, 0, &loc.bank);
1736 if (ret)
1737 return ret;
1738 while (*b == ' ')
1739 b++;
1740 if (strval_len(b) == 0)
1741 return -EINVAL;
1742 ret = kstrtoul(b, 0, &loc.addr);
1743 if (ret)
1744 return ret;
1745
1746 if (write) {
1747 while (*b == ' ')
1748 b++;
1749 if (strval_len(b) == 0)
1750 return -EINVAL;
1751 ret = kstrtouint(b, 0, &val);
1752 if (ret)
1753 return ret;
1754 }
1755
1756 /* args are ok, update target cfg (mainly for read) */
1757 *cfg = loc;
1758
1759#ifdef ABB_HWREG_DEBUG
1760 pr_warn("HWREG request: %s, %s,\n", (write) ? "write" : "read",
1761 REG_FMT_DEC(cfg) ? "decimal" : "hexa");
1762 pr_warn(" addr=0x%08X, mask=0x%X, shift=%d" "value=0x%X\n",
1763 cfg->addr, cfg->mask, cfg->shift, val);
1764#endif
1765
1766 if (!write)
1767 return 0;
1768
1769 ret = abx500_get_register_interruptible(dev,
1770 (u8)cfg->bank, (u8)cfg->addr, ®value);
1771 if (ret < 0) {
1772 dev_err(dev, "abx500_get_reg fail %d, %d\n",
1773 ret, __LINE__);
1774 return -EINVAL;
1775 }
1776
1777 if (cfg->shift >= 0) {
1778 regvalue &= ~(cfg->mask << (cfg->shift));
1779 val = (val & cfg->mask) << (cfg->shift);
1780 } else {
1781 regvalue &= ~(cfg->mask >> (-cfg->shift));
1782 val = (val & cfg->mask) >> (-cfg->shift);
1783 }
1784 val = val | regvalue;
1785
1786 ret = abx500_set_register_interruptible(dev,
1787 (u8)cfg->bank, (u8)cfg->addr, (u8)val);
1788 if (ret < 0) {
1789 pr_err("abx500_set_reg failed %d, %d", ret, __LINE__);
1790 return -EINVAL;
1791 }
1792
1793 return 0;
1794}
1795
1796static ssize_t ab8500_hwreg_write(struct file *file,
1797 const char __user *user_buf, size_t count, loff_t *ppos)
1798{
1799 struct device *dev = ((struct seq_file *)(file->private_data))->private;
1800 char buf[128];
1801 int buf_size, ret;
1802
1803 /* Get userspace string and assure termination */
1804 buf_size = min((int)count, (int)(sizeof(buf)-1));
1805 if (copy_from_user(buf, user_buf, buf_size))
1806 return -EFAULT;
1807 buf[buf_size] = 0;
1808
1809 /* get args and process */
1810 ret = hwreg_common_write(buf, &hwreg_cfg, dev);
1811 return (ret) ? ret : buf_size;
1812}
1813
1814/*
1815 * - irq subscribe/unsubscribe stuff
1816 */
1817static int ab8500_subscribe_unsubscribe_print(struct seq_file *s, void *p)
1818{
1819 seq_printf(s, "%d\n", irq_first);
1820
1821 return 0;
1822}
1823
1824static int ab8500_subscribe_unsubscribe_open(struct inode *inode,
1825 struct file *file)
1826{
1827 return single_open(file, ab8500_subscribe_unsubscribe_print,
1828 inode->i_private);
1829}
1830
1831/*
1832 * Userspace should use poll() on this file. When an event occur
1833 * the blocking poll will be released.
1834 */
1835static ssize_t show_irq(struct device *dev,
1836 struct device_attribute *attr, char *buf)
1837{
1838 unsigned long name;
1839 unsigned int irq_index;
1840 int err;
1841
1842 err = kstrtoul(attr->attr.name, 0, &name);
1843 if (err)
1844 return err;
1845
1846 irq_index = name - irq_first;
1847 if (irq_index >= num_irqs)
1848 return -EINVAL;
1849
1850 return sprintf(buf, "%u\n", irq_count[irq_index]);
1851}
1852
1853static ssize_t ab8500_subscribe_write(struct file *file,
1854 const char __user *user_buf,
1855 size_t count, loff_t *ppos)
1856{
1857 struct device *dev = ((struct seq_file *)(file->private_data))->private;
1858 unsigned long user_val;
1859 int err;
1860 unsigned int irq_index;
1861
1862 err = kstrtoul_from_user(user_buf, count, 0, &user_val);
1863 if (err)
1864 return err;
1865
1866 if (user_val < irq_first) {
1867 dev_err(dev, "debugfs error input < %d\n", irq_first);
1868 return -EINVAL;
1869 }
1870 if (user_val > irq_last) {
1871 dev_err(dev, "debugfs error input > %d\n", irq_last);
1872 return -EINVAL;
1873 }
1874
1875 irq_index = user_val - irq_first;
1876 if (irq_index >= num_irqs)
1877 return -EINVAL;
1878
1879 /*
1880 * This will create a sysfs file named <irq-nr> which userspace can
1881 * use to select or poll and get the AB8500 events
1882 */
1883 dev_attr[irq_index] = kmalloc(sizeof(struct device_attribute),
1884 GFP_KERNEL);
1885 if (!dev_attr[irq_index])
1886 return -ENOMEM;
1887
1888 event_name[irq_index] = kasprintf(GFP_KERNEL, "%lu", user_val);
1889 if (!event_name[irq_index])
1890 return -ENOMEM;
1891
1892 dev_attr[irq_index]->show = show_irq;
1893 dev_attr[irq_index]->store = NULL;
1894 dev_attr[irq_index]->attr.name = event_name[irq_index];
1895 dev_attr[irq_index]->attr.mode = S_IRUGO;
1896 err = sysfs_create_file(&dev->kobj, &dev_attr[irq_index]->attr);
1897 if (err < 0) {
1898 pr_info("sysfs_create_file failed %d\n", err);
1899 return err;
1900 }
1901
1902 err = request_threaded_irq(user_val, NULL, ab8500_debug_handler,
1903 IRQF_SHARED | IRQF_NO_SUSPEND | IRQF_ONESHOT,
1904 "ab8500-debug", &dev->kobj);
1905 if (err < 0) {
1906 pr_info("request_threaded_irq failed %d, %lu\n",
1907 err, user_val);
1908 sysfs_remove_file(&dev->kobj, &dev_attr[irq_index]->attr);
1909 return err;
1910 }
1911
1912 return count;
1913}
1914
1915static ssize_t ab8500_unsubscribe_write(struct file *file,
1916 const char __user *user_buf,
1917 size_t count, loff_t *ppos)
1918{
1919 struct device *dev = ((struct seq_file *)(file->private_data))->private;
1920 unsigned long user_val;
1921 int err;
1922 unsigned int irq_index;
1923
1924 err = kstrtoul_from_user(user_buf, count, 0, &user_val);
1925 if (err)
1926 return err;
1927
1928 if (user_val < irq_first) {
1929 dev_err(dev, "debugfs error input < %d\n", irq_first);
1930 return -EINVAL;
1931 }
1932 if (user_val > irq_last) {
1933 dev_err(dev, "debugfs error input > %d\n", irq_last);
1934 return -EINVAL;
1935 }
1936
1937 irq_index = user_val - irq_first;
1938 if (irq_index >= num_irqs)
1939 return -EINVAL;
1940
1941 /* Set irq count to 0 when unsubscribe */
1942 irq_count[irq_index] = 0;
1943
1944 if (dev_attr[irq_index])
1945 sysfs_remove_file(&dev->kobj, &dev_attr[irq_index]->attr);
1946
1947
1948 free_irq(user_val, &dev->kobj);
1949 kfree(event_name[irq_index]);
1950 kfree(dev_attr[irq_index]);
1951
1952 return count;
1953}
1954
1955/*
1956 * - several debugfs nodes fops
1957 */
1958
1959static const struct file_operations ab8500_bank_fops = {
1960 .open = ab8500_bank_open,
1961 .write = ab8500_bank_write,
1962 .read = seq_read,
1963 .llseek = seq_lseek,
1964 .release = single_release,
1965 .owner = THIS_MODULE,
1966};
1967
1968static const struct file_operations ab8500_address_fops = {
1969 .open = ab8500_address_open,
1970 .write = ab8500_address_write,
1971 .read = seq_read,
1972 .llseek = seq_lseek,
1973 .release = single_release,
1974 .owner = THIS_MODULE,
1975};
1976
1977static const struct file_operations ab8500_val_fops = {
1978 .open = ab8500_val_open,
1979 .write = ab8500_val_write,
1980 .read = seq_read,
1981 .llseek = seq_lseek,
1982 .release = single_release,
1983 .owner = THIS_MODULE,
1984};
1985
1986static const struct file_operations ab8500_subscribe_fops = {
1987 .open = ab8500_subscribe_unsubscribe_open,
1988 .write = ab8500_subscribe_write,
1989 .read = seq_read,
1990 .llseek = seq_lseek,
1991 .release = single_release,
1992 .owner = THIS_MODULE,
1993};
1994
1995static const struct file_operations ab8500_unsubscribe_fops = {
1996 .open = ab8500_subscribe_unsubscribe_open,
1997 .write = ab8500_unsubscribe_write,
1998 .read = seq_read,
1999 .llseek = seq_lseek,
2000 .release = single_release,
2001 .owner = THIS_MODULE,
2002};
2003
2004static const struct file_operations ab8500_hwreg_fops = {
2005 .open = ab8500_hwreg_open,
2006 .write = ab8500_hwreg_write,
2007 .read = seq_read,
2008 .llseek = seq_lseek,
2009 .release = single_release,
2010 .owner = THIS_MODULE,
2011};
2012
2013static int ab8500_debug_probe(struct platform_device *plf)
2014{
2015 struct dentry *ab8500_dir;
2016 struct ab8500 *ab8500;
2017 struct resource *res;
2018
2019 debug_bank = AB8500_MISC;
2020 debug_address = AB8500_REV_REG & 0x00FF;
2021
2022 ab8500 = dev_get_drvdata(plf->dev.parent);
2023 num_irqs = ab8500->mask_size;
2024
2025 irq_count = devm_kcalloc(&plf->dev,
2026 num_irqs, sizeof(*irq_count), GFP_KERNEL);
2027 if (!irq_count)
2028 return -ENOMEM;
2029
2030 dev_attr = devm_kcalloc(&plf->dev,
2031 num_irqs, sizeof(*dev_attr), GFP_KERNEL);
2032 if (!dev_attr)
2033 return -ENOMEM;
2034
2035 event_name = devm_kcalloc(&plf->dev,
2036 num_irqs, sizeof(*event_name), GFP_KERNEL);
2037 if (!event_name)
2038 return -ENOMEM;
2039
2040 res = platform_get_resource_byname(plf, 0, "IRQ_AB8500");
2041 if (!res) {
2042 dev_err(&plf->dev, "AB8500 irq not found, err %d\n", irq_first);
2043 return -ENXIO;
2044 }
2045 irq_ab8500 = res->start;
2046
2047 irq_first = platform_get_irq_byname(plf, "IRQ_FIRST");
2048 if (irq_first < 0)
2049 return irq_first;
2050
2051 irq_last = platform_get_irq_byname(plf, "IRQ_LAST");
2052 if (irq_last < 0)
2053 return irq_last;
2054
2055 ab8500_dir = debugfs_create_dir(AB8500_NAME_STRING, NULL);
2056
2057 debugfs_create_file("all-bank-registers", S_IRUGO, ab8500_dir,
2058 &plf->dev, &ab8500_bank_registers_fops);
2059 debugfs_create_file("all-banks", S_IRUGO, ab8500_dir,
2060 &plf->dev, &ab8500_all_banks_fops);
2061 debugfs_create_file("register-bank", (S_IRUGO | S_IWUSR | S_IWGRP),
2062 ab8500_dir, &plf->dev, &ab8500_bank_fops);
2063 debugfs_create_file("register-address", (S_IRUGO | S_IWUSR | S_IWGRP),
2064 ab8500_dir, &plf->dev, &ab8500_address_fops);
2065 debugfs_create_file("register-value", (S_IRUGO | S_IWUSR | S_IWGRP),
2066 ab8500_dir, &plf->dev, &ab8500_val_fops);
2067 debugfs_create_file("irq-subscribe", (S_IRUGO | S_IWUSR | S_IWGRP),
2068 ab8500_dir, &plf->dev, &ab8500_subscribe_fops);
2069
2070 if (is_ab8500(ab8500)) {
2071 debug_ranges = ab8500_debug_ranges;
2072 num_interrupt_lines = AB8500_NR_IRQS;
2073 } else if (is_ab8505(ab8500)) {
2074 debug_ranges = ab8505_debug_ranges;
2075 num_interrupt_lines = AB8505_NR_IRQS;
2076 } else if (is_ab9540(ab8500)) {
2077 debug_ranges = ab8505_debug_ranges;
2078 num_interrupt_lines = AB9540_NR_IRQS;
2079 } else if (is_ab8540(ab8500)) {
2080 debug_ranges = ab8540_debug_ranges;
2081 num_interrupt_lines = AB8540_NR_IRQS;
2082 }
2083
2084 debugfs_create_file("interrupts", (S_IRUGO), ab8500_dir, &plf->dev,
2085 &ab8500_interrupts_fops);
2086 debugfs_create_file("irq-unsubscribe", (S_IRUGO | S_IWUSR | S_IWGRP),
2087 ab8500_dir, &plf->dev, &ab8500_unsubscribe_fops);
2088 debugfs_create_file("hwreg", (S_IRUGO | S_IWUSR | S_IWGRP), ab8500_dir,
2089 &plf->dev, &ab8500_hwreg_fops);
2090 debugfs_create_file("all-modem-registers", (S_IRUGO | S_IWUSR | S_IWGRP),
2091 ab8500_dir, &plf->dev, &ab8500_modem_fops);
2092
2093 return 0;
2094}
2095
2096static struct platform_driver ab8500_debug_driver = {
2097 .driver = {
2098 .name = "ab8500-debug",
2099 .suppress_bind_attrs = true,
2100 },
2101 .probe = ab8500_debug_probe,
2102};
2103
2104static int __init ab8500_debug_init(void)
2105{
2106 return platform_driver_register(&ab8500_debug_driver);
2107}
2108subsys_initcall(ab8500_debug_init);
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Copyright (C) ST-Ericsson SA 2010
4 *
5 * Author: Mattias Wallin <mattias.wallin@stericsson.com> for ST-Ericsson.
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
94static u32 debug_bank;
95static u32 debug_address;
96
97static int irq_ab8500;
98static int irq_first;
99static int irq_last;
100static u32 *irq_count;
101static int num_irqs;
102
103static struct device_attribute **dev_attr;
104static char **event_name;
105
106static u8 avg_sample = SAMPLE_16;
107static u8 trig_edge = RISING_EDGE;
108static u8 conv_type = ADC_SW;
109static 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 */
117struct 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 */
129struct 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 */
136struct 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
147static 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
160static struct ab8500_prcmu_ranges *debug_ranges;
161
162static 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
485static 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
846static 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
1261static 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 */
1280static 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
1320static 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
1332DEFINE_SHOW_ATTRIBUTE(ab8500_bank_registers);
1333
1334static 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 */
1353void 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
1365static 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
1384static 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
1392static 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
1398static int ab8500_bank_open(struct inode *inode, struct file *file)
1399{
1400 return single_open(file, ab8500_bank_print, inode->i_private);
1401}
1402
1403static 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
1425static 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
1431static int ab8500_address_open(struct inode *inode, struct file *file)
1432{
1433 return single_open(file, ab8500_address_print, inode->i_private);
1434}
1435
1436static 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
1457static 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, ®value);
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
1475static int ab8500_val_open(struct inode *inode, struct file *file)
1476{
1477 return single_open(file, ab8500_val_print, inode->i_private);
1478}
1479
1480static 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 */
1509static u32 num_interrupts[AB8500_MAX_NR_IRQS];
1510static u32 num_wake_interrupts[AB8500_MAX_NR_IRQS];
1511static int num_interrupt_lines;
1512
1513void ab8500_debug_register_interrupt(int line)
1514{
1515 if (line < num_interrupt_lines)
1516 num_interrupts[line]++;
1517}
1518
1519static 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
1548DEFINE_SHOW_ATTRIBUTE(ab8500_interrupts);
1549
1550/*
1551 * - HWREG DB8500 formated routines
1552 */
1553static 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, ®value);
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
1580static 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
1591static 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
1638report_read_failure:
1639 dev_err(dev, "ab->read fail %d\n", err);
1640 return err;
1641
1642report_write_failure:
1643 dev_err(dev, "ab->write fail %d\n", err);
1644 return err;
1645}
1646
1647DEFINE_SHOW_ATTRIBUTE(ab8500_modem);
1648
1649static 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
1666DEFINE_SHOW_ATTRIBUTE(ab8500_gpadc_bat_ctrl);
1667
1668static 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
1685DEFINE_SHOW_ATTRIBUTE(ab8500_gpadc_btemp_ball);
1686
1687static 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
1704DEFINE_SHOW_ATTRIBUTE(ab8500_gpadc_main_charger_v);
1705
1706static 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
1723DEFINE_SHOW_ATTRIBUTE(ab8500_gpadc_acc_detect1);
1724
1725static 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
1742DEFINE_SHOW_ATTRIBUTE(ab8500_gpadc_acc_detect2);
1743
1744static 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
1761DEFINE_SHOW_ATTRIBUTE(ab8500_gpadc_aux1);
1762
1763static 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
1780DEFINE_SHOW_ATTRIBUTE(ab8500_gpadc_aux2);
1781
1782static 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
1799DEFINE_SHOW_ATTRIBUTE(ab8500_gpadc_main_bat_v);
1800
1801static 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
1818DEFINE_SHOW_ATTRIBUTE(ab8500_gpadc_vbus_v);
1819
1820static 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
1837DEFINE_SHOW_ATTRIBUTE(ab8500_gpadc_main_charger_c);
1838
1839static 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
1856DEFINE_SHOW_ATTRIBUTE(ab8500_gpadc_usb_charger_c);
1857
1858static 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
1875DEFINE_SHOW_ATTRIBUTE(ab8500_gpadc_bk_bat_v);
1876
1877static 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
1894DEFINE_SHOW_ATTRIBUTE(ab8500_gpadc_die_temp);
1895
1896static 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
1913DEFINE_SHOW_ATTRIBUTE(ab8500_gpadc_usb_id);
1914
1915static 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
1932DEFINE_SHOW_ATTRIBUTE(ab8540_gpadc_xtal_temp);
1933
1934static 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
1952DEFINE_SHOW_ATTRIBUTE(ab8540_gpadc_vbat_true_meas);
1953
1954static 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
1980DEFINE_SHOW_ATTRIBUTE(ab8540_gpadc_bat_ctrl_and_ibat);
1981
1982static 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
2007DEFINE_SHOW_ATTRIBUTE(ab8540_gpadc_vbat_meas_and_ibat);
2008
2009static 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
2035DEFINE_SHOW_ATTRIBUTE(ab8540_gpadc_vbat_true_meas_and_ibat);
2036
2037static 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
2062DEFINE_SHOW_ATTRIBUTE(ab8540_gpadc_bat_temp_and_ibat);
2063
2064static 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
2088DEFINE_SHOW_ATTRIBUTE(ab8540_gpadc_otp_calib);
2089
2090static 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
2097static 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
2103static 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
2128static 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
2137static 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
2144static 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
2150static 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
2175static 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
2184static 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
2191static 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
2197static 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
2220static 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
2229static 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
2236static 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
2242static 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
2267static 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 */
2283static 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 */
2308static 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, ®value);
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
2430static 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 */
2451static 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
2458static 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 */
2469static 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
2487static 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
2549static 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 debugfs nodes fops
2591 */
2592
2593static 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
2602static 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
2611static 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
2620static 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
2629static 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
2638static 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
2647static int ab8500_debug_probe(struct platform_device *plf)
2648{
2649 struct dentry *ab8500_dir;
2650 struct dentry *ab8500_gpadc_dir;
2651 struct ab8500 *ab8500;
2652 struct resource *res;
2653
2654 debug_bank = AB8500_MISC;
2655 debug_address = AB8500_REV_REG & 0x00FF;
2656
2657 ab8500 = dev_get_drvdata(plf->dev.parent);
2658 num_irqs = ab8500->mask_size;
2659
2660 irq_count = devm_kcalloc(&plf->dev,
2661 num_irqs, sizeof(*irq_count), GFP_KERNEL);
2662 if (!irq_count)
2663 return -ENOMEM;
2664
2665 dev_attr = devm_kcalloc(&plf->dev,
2666 num_irqs, sizeof(*dev_attr), GFP_KERNEL);
2667 if (!dev_attr)
2668 return -ENOMEM;
2669
2670 event_name = devm_kcalloc(&plf->dev,
2671 num_irqs, sizeof(*event_name), GFP_KERNEL);
2672 if (!event_name)
2673 return -ENOMEM;
2674
2675 res = platform_get_resource_byname(plf, 0, "IRQ_AB8500");
2676 if (!res) {
2677 dev_err(&plf->dev, "AB8500 irq not found, err %d\n", irq_first);
2678 return -ENXIO;
2679 }
2680 irq_ab8500 = res->start;
2681
2682 irq_first = platform_get_irq_byname(plf, "IRQ_FIRST");
2683 if (irq_first < 0)
2684 return irq_first;
2685
2686 irq_last = platform_get_irq_byname(plf, "IRQ_LAST");
2687 if (irq_last < 0)
2688 return irq_last;
2689
2690 ab8500_dir = debugfs_create_dir(AB8500_NAME_STRING, NULL);
2691
2692 ab8500_gpadc_dir = debugfs_create_dir(AB8500_ADC_NAME_STRING,
2693 ab8500_dir);
2694
2695 debugfs_create_file("all-bank-registers", S_IRUGO, ab8500_dir,
2696 &plf->dev, &ab8500_bank_registers_fops);
2697 debugfs_create_file("all-banks", S_IRUGO, ab8500_dir,
2698 &plf->dev, &ab8500_all_banks_fops);
2699 debugfs_create_file("register-bank", (S_IRUGO | S_IWUSR | S_IWGRP),
2700 ab8500_dir, &plf->dev, &ab8500_bank_fops);
2701 debugfs_create_file("register-address", (S_IRUGO | S_IWUSR | S_IWGRP),
2702 ab8500_dir, &plf->dev, &ab8500_address_fops);
2703 debugfs_create_file("register-value", (S_IRUGO | S_IWUSR | S_IWGRP),
2704 ab8500_dir, &plf->dev, &ab8500_val_fops);
2705 debugfs_create_file("irq-subscribe", (S_IRUGO | S_IWUSR | S_IWGRP),
2706 ab8500_dir, &plf->dev, &ab8500_subscribe_fops);
2707
2708 if (is_ab8500(ab8500)) {
2709 debug_ranges = ab8500_debug_ranges;
2710 num_interrupt_lines = AB8500_NR_IRQS;
2711 } else if (is_ab8505(ab8500)) {
2712 debug_ranges = ab8505_debug_ranges;
2713 num_interrupt_lines = AB8505_NR_IRQS;
2714 } else if (is_ab9540(ab8500)) {
2715 debug_ranges = ab8505_debug_ranges;
2716 num_interrupt_lines = AB9540_NR_IRQS;
2717 } else if (is_ab8540(ab8500)) {
2718 debug_ranges = ab8540_debug_ranges;
2719 num_interrupt_lines = AB8540_NR_IRQS;
2720 }
2721
2722 debugfs_create_file("interrupts", (S_IRUGO), ab8500_dir, &plf->dev,
2723 &ab8500_interrupts_fops);
2724 debugfs_create_file("irq-unsubscribe", (S_IRUGO | S_IWUSR | S_IWGRP),
2725 ab8500_dir, &plf->dev, &ab8500_unsubscribe_fops);
2726 debugfs_create_file("hwreg", (S_IRUGO | S_IWUSR | S_IWGRP), ab8500_dir,
2727 &plf->dev, &ab8500_hwreg_fops);
2728 debugfs_create_file("all-modem-registers", (S_IRUGO | S_IWUSR | S_IWGRP),
2729 ab8500_dir, &plf->dev, &ab8500_modem_fops);
2730 debugfs_create_file("bat_ctrl", (S_IRUGO | S_IWUSR | S_IWGRP),
2731 ab8500_gpadc_dir, &plf->dev,
2732 &ab8500_gpadc_bat_ctrl_fops);
2733 debugfs_create_file("btemp_ball", (S_IRUGO | S_IWUSR | S_IWGRP),
2734 ab8500_gpadc_dir, &plf->dev,
2735 &ab8500_gpadc_btemp_ball_fops);
2736 debugfs_create_file("main_charger_v", (S_IRUGO | S_IWUSR | S_IWGRP),
2737 ab8500_gpadc_dir, &plf->dev,
2738 &ab8500_gpadc_main_charger_v_fops);
2739 debugfs_create_file("acc_detect1", (S_IRUGO | S_IWUSR | S_IWGRP),
2740 ab8500_gpadc_dir, &plf->dev,
2741 &ab8500_gpadc_acc_detect1_fops);
2742 debugfs_create_file("acc_detect2", (S_IRUGO | S_IWUSR | S_IWGRP),
2743 ab8500_gpadc_dir, &plf->dev,
2744 &ab8500_gpadc_acc_detect2_fops);
2745 debugfs_create_file("adc_aux1", (S_IRUGO | S_IWUSR | S_IWGRP),
2746 ab8500_gpadc_dir, &plf->dev,
2747 &ab8500_gpadc_aux1_fops);
2748 debugfs_create_file("adc_aux2", (S_IRUGO | S_IWUSR | S_IWGRP),
2749 ab8500_gpadc_dir, &plf->dev,
2750 &ab8500_gpadc_aux2_fops);
2751 debugfs_create_file("main_bat_v", (S_IRUGO | S_IWUSR | S_IWGRP),
2752 ab8500_gpadc_dir, &plf->dev,
2753 &ab8500_gpadc_main_bat_v_fops);
2754 debugfs_create_file("vbus_v", (S_IRUGO | S_IWUSR | S_IWGRP),
2755 ab8500_gpadc_dir, &plf->dev,
2756 &ab8500_gpadc_vbus_v_fops);
2757 debugfs_create_file("main_charger_c", (S_IRUGO | S_IWUSR | S_IWGRP),
2758 ab8500_gpadc_dir, &plf->dev,
2759 &ab8500_gpadc_main_charger_c_fops);
2760 debugfs_create_file("usb_charger_c", (S_IRUGO | S_IWUSR | S_IWGRP),
2761 ab8500_gpadc_dir, &plf->dev,
2762 &ab8500_gpadc_usb_charger_c_fops);
2763 debugfs_create_file("bk_bat_v", (S_IRUGO | S_IWUSR | S_IWGRP),
2764 ab8500_gpadc_dir, &plf->dev,
2765 &ab8500_gpadc_bk_bat_v_fops);
2766 debugfs_create_file("die_temp", (S_IRUGO | S_IWUSR | S_IWGRP),
2767 ab8500_gpadc_dir, &plf->dev,
2768 &ab8500_gpadc_die_temp_fops);
2769 debugfs_create_file("usb_id", (S_IRUGO | S_IWUSR | S_IWGRP),
2770 ab8500_gpadc_dir, &plf->dev,
2771 &ab8500_gpadc_usb_id_fops);
2772 if (is_ab8540(ab8500)) {
2773 debugfs_create_file("xtal_temp", (S_IRUGO | S_IWUSR | S_IWGRP),
2774 ab8500_gpadc_dir, &plf->dev,
2775 &ab8540_gpadc_xtal_temp_fops);
2776 debugfs_create_file("vbattruemeas", (S_IRUGO | S_IWUSR | S_IWGRP),
2777 ab8500_gpadc_dir, &plf->dev,
2778 &ab8540_gpadc_vbat_true_meas_fops);
2779 debugfs_create_file("batctrl_and_ibat", (S_IRUGO | S_IWUGO),
2780 ab8500_gpadc_dir, &plf->dev,
2781 &ab8540_gpadc_bat_ctrl_and_ibat_fops);
2782 debugfs_create_file("vbatmeas_and_ibat", (S_IRUGO | S_IWUGO),
2783 ab8500_gpadc_dir, &plf->dev,
2784 &ab8540_gpadc_vbat_meas_and_ibat_fops);
2785 debugfs_create_file("vbattruemeas_and_ibat", (S_IRUGO | S_IWUGO),
2786 ab8500_gpadc_dir, &plf->dev,
2787 &ab8540_gpadc_vbat_true_meas_and_ibat_fops);
2788 debugfs_create_file("battemp_and_ibat", (S_IRUGO | S_IWUGO),
2789 ab8500_gpadc_dir, &plf->dev,
2790 &ab8540_gpadc_bat_temp_and_ibat_fops);
2791 debugfs_create_file("otp_calib", (S_IRUGO | S_IWUSR | S_IWGRP),
2792 ab8500_gpadc_dir, &plf->dev,
2793 &ab8540_gpadc_otp_calib_fops);
2794 }
2795 debugfs_create_file("avg_sample", (S_IRUGO | S_IWUSR | S_IWGRP),
2796 ab8500_gpadc_dir, &plf->dev,
2797 &ab8500_gpadc_avg_sample_fops);
2798 debugfs_create_file("trig_edge", (S_IRUGO | S_IWUSR | S_IWGRP),
2799 ab8500_gpadc_dir, &plf->dev,
2800 &ab8500_gpadc_trig_edge_fops);
2801 debugfs_create_file("trig_timer", (S_IRUGO | S_IWUSR | S_IWGRP),
2802 ab8500_gpadc_dir, &plf->dev,
2803 &ab8500_gpadc_trig_timer_fops);
2804 debugfs_create_file("conv_type", (S_IRUGO | S_IWUSR | S_IWGRP),
2805 ab8500_gpadc_dir, &plf->dev,
2806 &ab8500_gpadc_conv_type_fops);
2807
2808 return 0;
2809}
2810
2811static struct platform_driver ab8500_debug_driver = {
2812 .driver = {
2813 .name = "ab8500-debug",
2814 .suppress_bind_attrs = true,
2815 },
2816 .probe = ab8500_debug_probe,
2817};
2818
2819static int __init ab8500_debug_init(void)
2820{
2821 return platform_driver_register(&ab8500_debug_driver);
2822}
2823subsys_initcall(ab8500_debug_init);