Version:  2.0.40 2.2.26 2.4.37 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 4.6 4.7 4.8 4.9

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

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