Version:  2.0.40 2.2.26 2.4.37 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5

Linux/drivers/mfd/ab8500-debugfs.c

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us