1 files changed, 1597 insertions, 144 deletions

diff --git a/drivers/mfd/ab8500-debugfs.c b/drivers/mfd/ab8500-debugfs.c
index 45fe3c50eb03..b88bbbc15f1e 100644
--- a/drivers/mfd/ab8500-debugfs.c
+++ b/drivers/mfd/ab8500-debugfs.c
@@ -80,6 +80,7 @@
 #include <linux/interrupt.h>
 #include <linux/kobject.h>
 #include <linux/slab.h>
+#include <linux/irq.h>
 
 #include <linux/mfd/abx500.h>
 #include <linux/mfd/abx500/ab8500.h>
@@ -90,6 +91,9 @@
 #include <linux/ctype.h>
 #endif
 
+/* TODO: this file should not reference IRQ_DB8500_AB8500! */
+#include <mach/irqs.h>
+
 static u32 debug_bank;
 static u32 debug_address;
 
@@ -101,6 +105,11 @@ static int num_irqs;
 static struct device_attribute **dev_attr;
 static char **event_name;
 
+static u8 avg_sample = SAMPLE_16;
+static u8 trig_edge = RISING_EDGE;
+static u8 conv_type = ADC_SW;
+static u8 trig_timer;
+
 /**
  * struct ab8500_reg_range
  * @first: the first address of the range
@@ -150,7 +159,9 @@ static struct hwreg_cfg hwreg_cfg = {
 
 #define AB8500_REV_REG 0x80
 
-static struct ab8500_prcmu_ranges debug_ranges[AB8500_NUM_BANKS] = {
+static struct ab8500_prcmu_ranges *debug_ranges;
+
+struct ab8500_prcmu_ranges ab8500_debug_ranges[AB8500_NUM_BANKS] = {
         [0x0] = {
                 .num_ranges = 0,
                 .range = NULL,
@@ -354,7 +365,7 @@ static struct ab8500_prcmu_ranges debug_ranges[AB8500_NUM_BANKS] = {
                         },
                         {
                                 .first = 0xf5,
-                                .last = 0xf6,
+                                .last = 0xf6,
                         },
                 },
         },
@@ -479,6 +490,781 @@ static struct ab8500_prcmu_ranges debug_ranges[AB8500_NUM_BANKS] = {
         },
 };
 
+struct ab8500_prcmu_ranges ab8505_debug_ranges[AB8500_NUM_BANKS] = {
+        [0x0] = {
+                .num_ranges = 0,
+                .range = NULL,
+        },
+        [AB8500_SYS_CTRL1_BLOCK] = {
+                .num_ranges = 5,
+                .range = (struct ab8500_reg_range[]) {
+                        {
+                                .first = 0x00,
+                                .last = 0x04,
+                        },
+                        {
+                                .first = 0x42,
+                                .last = 0x42,
+                        },
+                        {
+                                .first = 0x52,
+                                .last = 0x52,
+                        },
+                        {
+                                .first = 0x54,
+                                .last = 0x57,
+                        },
+                        {
+                                .first = 0x80,
+                                .last = 0x83,
+                        },
+                },
+        },
+        [AB8500_SYS_CTRL2_BLOCK] = {
+                .num_ranges = 5,
+                .range = (struct ab8500_reg_range[]) {
+                        {
+                                .first = 0x00,
+                                .last = 0x0D,
+                        },
+                        {
+                                .first = 0x0F,
+                                .last = 0x17,
+                        },
+                        {
+                                .first = 0x20,
+                                .last = 0x20,
+                        },
+                        {
+                                .first = 0x30,
+                                .last = 0x30,
+                        },
+                        {
+                                .first = 0x32,
+                                .last = 0x3A,
+                        },
+                },
+        },
+        [AB8500_REGU_CTRL1] = {
+                .num_ranges = 3,
+                .range = (struct ab8500_reg_range[]) {
+                        {
+                                .first = 0x00,
+                                .last = 0x00,
+                        },
+                        {
+                                .first = 0x03,
+                                .last = 0x11,
+                        },
+                        {
+                                .first = 0x80,
+                                .last = 0x86,
+                        },
+                },
+        },
+        [AB8500_REGU_CTRL2] = {
+                .num_ranges = 6,
+                .range = (struct ab8500_reg_range[]) {
+                        {
+                                .first = 0x00,
+                                .last = 0x06,
+                        },
+                        {
+                                .first = 0x08,
+                                .last = 0x15,
+                        },
+                        {
+                                .first = 0x17,
+                                .last = 0x19,
+                        },
+                        {
+                                .first = 0x1B,
+                                .last = 0x1D,
+                        },
+                        {
+                                .first = 0x1F,
+                                .last = 0x30,
+                        },
+                        {
+                                .first = 0x40,
+                                .last = 0x48,
+                        },
+                        /* 0x80-0x8B is SIM registers and should
+                         * not be accessed from here */
+                },
+        },
+        [AB8500_USB] = {
+                .num_ranges = 3,
+                .range = (struct ab8500_reg_range[]) {
+                        {
+                                .first = 0x80,
+                                .last = 0x83,
+                        },
+                        {
+                                .first = 0x87,
+                                .last = 0x8A,
+                        },
+                        {
+                                .first = 0x91,
+                                .last = 0x94,
+                        },
+                },
+        },
+        [AB8500_TVOUT] = {
+                .num_ranges = 0,
+                .range = NULL,
+        },
+        [AB8500_DBI] = {
+                .num_ranges = 0,
+                .range = NULL,
+        },
+        [AB8500_ECI_AV_ACC] = {
+                .num_ranges = 1,
+                .range = (struct ab8500_reg_range[]) {
+                        {
+                                .first = 0x80,
+                                .last = 0x82,
+                        },
+                },
+        },
+        [AB8500_RESERVED] = {
+                .num_ranges = 0,
+                .range = NULL,
+        },
+        [AB8500_GPADC] = {
+                .num_ranges = 1,
+                .range = (struct ab8500_reg_range[]) {
+                        {
+                                .first = 0x00,
+                                .last = 0x08,
+                        },
+                },
+        },
+        [AB8500_CHARGER] = {
+                .num_ranges = 9,
+                .range = (struct ab8500_reg_range[]) {
+                        {
+                                .first = 0x02,
+                                .last = 0x03,
+                        },
+                        {
+                                .first = 0x05,
+                                .last = 0x05,
+                        },
+                        {
+                                .first = 0x40,
+                                .last = 0x44,
+                        },
+                        {
+                                .first = 0x50,
+                                .last = 0x57,
+                        },
+                        {
+                                .first = 0x60,
+                                .last = 0x60,
+                        },
+                        {
+                                .first = 0xA0,
+                                .last = 0xA7,
+                        },
+                        {
+                                .first = 0xAF,
+                                .last = 0xB2,
+                        },
+                        {
+                                .first = 0xC0,
+                                .last = 0xC2,
+                        },
+                        {
+                                .first = 0xF5,
+                                .last = 0xF5,
+                        },
+                },
+        },
+        [AB8500_GAS_GAUGE] = {
+                .num_ranges = 3,
+                .range = (struct ab8500_reg_range[]) {
+                        {
+                                .first = 0x00,
+                                .last = 0x00,
+                        },
+                        {
+                                .first = 0x07,
+                                .last = 0x0A,
+                        },
+                        {
+                                .first = 0x10,
+                                .last = 0x14,
+                        },
+                },
+        },
+        [AB8500_AUDIO] = {
+                .num_ranges = 1,
+                .range = (struct ab8500_reg_range[]) {
+                        {
+                                .first = 0x00,
+                                .last = 0x83,
+                        },
+                },
+        },
+        [AB8500_INTERRUPT] = {
+                .num_ranges = 11,
+                .range = (struct ab8500_reg_range[]) {
+                        {
+                                .first = 0x00,
+                                .last = 0x04,
+                        },
+                        {
+                                .first = 0x06,
+                                .last = 0x07,
+                        },
+                        {
+                                .first = 0x09,
+                                .last = 0x09,
+                        },
+                        {
+                                .first = 0x0B,
+                                .last = 0x0C,
+                        },
+                        {
+                                .first = 0x12,
+                                .last = 0x15,
+                        },
+                        {
+                                .first = 0x18,
+                                .last = 0x18,
+                        },
+                        /* Latch registers should not be read here */
+                        {
+                                .first = 0x40,
+                                .last = 0x44,
+                        },
+                        {
+                                .first = 0x46,
+                                .last = 0x49,
+                        },
+                        {
+                                .first = 0x4B,
+                                .last = 0x4D,
+                        },
+                        {
+                                .first = 0x52,
+                                .last = 0x55,
+                        },
+                        {
+                                .first = 0x58,
+                                .last = 0x58,
+                        },
+                        /* LatchHier registers should not be read here */
+                },
+        },
+        [AB8500_RTC] = {
+                .num_ranges = 2,
+                .range = (struct ab8500_reg_range[]) {
+                        {
+                                .first = 0x00,
+                                .last = 0x14,
+                        },
+                        {
+                                .first = 0x16,
+                                .last = 0x17,
+                        },
+                },
+        },
+        [AB8500_MISC] = {
+                .num_ranges = 8,
+                .range = (struct ab8500_reg_range[]) {
+                        {
+                                .first = 0x00,
+                                .last = 0x06,
+                        },
+                        {
+                                .first = 0x10,
+                                .last = 0x16,
+                        },
+                        {
+                                .first = 0x20,
+                                .last = 0x26,
+                        },
+                        {
+                                .first = 0x30,
+                                .last = 0x36,
+                        },
+                        {
+                                .first = 0x40,
+                                .last = 0x46,
+                        },
+                        {
+                                .first = 0x50,
+                                .last = 0x50,
+                        },
+                        {
+                                .first = 0x60,
+                                .last = 0x6B,
+                        },
+                        {
+                                .first = 0x80,
+                                .last = 0x82,
+                        },
+                },
+        },
+        [AB8500_DEVELOPMENT] = {
+                .num_ranges = 2,
+                .range = (struct ab8500_reg_range[]) {
+                        {
+                                .first = 0x00,
+                                .last = 0x00,
+                        },
+                        {
+                                .first = 0x05,
+                                .last = 0x05,
+                        },
+                },
+        },
+        [AB8500_DEBUG] = {
+                .num_ranges = 1,
+                .range = (struct ab8500_reg_range[]) {
+                        {
+                                .first = 0x05,
+                                .last = 0x07,
+                        },
+                },
+        },
+        [AB8500_PROD_TEST] = {
+                .num_ranges = 0,
+                .range = NULL,
+        },
+        [AB8500_STE_TEST] = {
+                .num_ranges = 0,
+                .range = NULL,
+        },
+        [AB8500_OTP_EMUL] = {
+                .num_ranges = 1,
+                .range = (struct ab8500_reg_range[]) {
+                        {
+                                .first = 0x01,
+                                .last = 0x15,
+                        },
+                },
+        },
+};
+
+struct ab8500_prcmu_ranges ab8540_debug_ranges[AB8500_NUM_BANKS] = {
+        [AB8500_M_FSM_RANK] = {
+                .num_ranges = 1,
+                .range = (struct ab8500_reg_range[]) {
+                        {
+                                .first = 0x00,
+                                .last = 0x0B,
+                        },
+                },
+        },
+        [AB8500_SYS_CTRL1_BLOCK] = {
+                .num_ranges = 6,
+                .range = (struct ab8500_reg_range[]) {
+                        {
+                                .first = 0x00,
+                                .last = 0x04,
+                        },
+                        {
+                                .first = 0x42,
+                                .last = 0x42,
+                        },
+                        {
+                                .first = 0x50,
+                                .last = 0x54,
+                        },
+                        {
+                                .first = 0x57,
+                                .last = 0x57,
+                        },
+                        {
+                                .first = 0x80,
+                                .last = 0x83,
+                        },
+                        {
+                                .first = 0x90,
+                                .last = 0x90,
+                        },
+                },
+        },
+        [AB8500_SYS_CTRL2_BLOCK] = {
+                .num_ranges = 5,
+                .range = (struct ab8500_reg_range[]) {
+                        {
+                                .first = 0x00,
+                                .last = 0x0D,
+                        },
+                        {
+                                .first = 0x0F,
+                                .last = 0x10,
+                        },
+                        {
+                                .first = 0x20,
+                                .last = 0x21,
+                        },
+                        {
+                                .first = 0x32,
+                                .last = 0x3C,
+                        },
+                        {
+                                .first = 0x40,
+                                .last = 0x42,
+                        },
+                },
+        },
+        [AB8500_REGU_CTRL1] = {
+                .num_ranges = 4,
+                .range = (struct ab8500_reg_range[]) {
+                        {
+                                .first = 0x03,
+                                .last = 0x15,
+                        },
+                        {
+                                .first = 0x20,
+                                .last = 0x20,
+                        },
+                        {
+                                .first = 0x80,
+                                .last = 0x85,
+                        },
+                        {
+                                .first = 0x87,
+                                .last = 0x88,
+                        },
+                },
+        },
+        [AB8500_REGU_CTRL2] = {
+                .num_ranges = 8,
+                .range = (struct ab8500_reg_range[]) {
+                        {
+                                .first = 0x00,
+                                .last = 0x06,
+                        },
+                        {
+                                .first = 0x08,
+                                .last = 0x15,
+                        },
+                        {
+                                .first = 0x17,
+                                .last = 0x19,
+                        },
+                        {
+                                .first = 0x1B,
+                                .last = 0x1D,
+                        },
+                        {
+                                .first = 0x1F,
+                                .last = 0x2F,
+                        },
+                        {
+                                .first = 0x31,
+                                .last = 0x3A,
+                        },
+                        {
+                                .first = 0x43,
+                                .last = 0x44,
+                        },
+                        {
+                                .first = 0x48,
+                                .last = 0x49,
+                        },
+                },
+        },
+        [AB8500_USB] = {
+                .num_ranges = 3,
+                .range = (struct ab8500_reg_range[]) {
+                        {
+                                .first = 0x80,
+                                .last = 0x83,
+                        },
+                        {
+                                .first = 0x87,
+                                .last = 0x8A,
+                        },
+                        {
+                                .first = 0x91,
+                                .last = 0x94,
+                        },
+                },
+        },
+        [AB8500_TVOUT] = {
+                .num_ranges = 0,
+                .range = NULL
+        },
+        [AB8500_DBI] = {
+                .num_ranges = 4,
+                .range = (struct ab8500_reg_range[]) {
+                        {
+                                .first = 0x00,
+                                .last = 0x07,
+                        },
+                        {
+                                .first = 0x10,
+                                .last = 0x11,
+                        },
+                        {
+                                .first = 0x20,
+                                .last = 0x21,
+                        },
+                        {
+                                .first = 0x30,
+                                .last = 0x43,
+                        },
+                },
+        },
+        [AB8500_ECI_AV_ACC] = {
+                .num_ranges = 2,
+                .range = (struct ab8500_reg_range[]) {
+                        {
+                                .first = 0x00,
+                                .last = 0x03,
+                        },
+                        {
+                                .first = 0x80,
+                                .last = 0x82,
+                        },
+                },
+        },
+        [AB8500_RESERVED] = {
+                .num_ranges = 0,
+                .range = NULL,
+        },
+        [AB8500_GPADC] = {
+                .num_ranges = 4,
+                .range = (struct ab8500_reg_range[]) {
+                        {
+                                .first = 0x00,
+                                .last = 0x01,
+                        },
+                        {
+                                .first = 0x04,
+                                .last = 0x06,
+                        },
+                        {
+                                .first = 0x09,
+                                .last = 0x0A,
+                        },
+                        {
+                                .first = 0x10,
+                                .last = 0x14,
+                        },
+                },
+        },
+        [AB8500_CHARGER] = {
+                .num_ranges = 10,
+                .range = (struct ab8500_reg_range[]) {
+                        {
+                                .first = 0x00,
+                                .last = 0x00,
+                        },
+                        {
+                                .first = 0x02,
+                                .last = 0x05,
+                        },
+                        {
+                                .first = 0x40,
+                                .last = 0x44,
+                        },
+                        {
+                                .first = 0x50,
+                                .last = 0x57,
+                        },
+                        {
+                                .first = 0x60,
+                                .last = 0x60,
+                        },
+                        {
+                                .first = 0x70,
+                                .last = 0x70,
+                        },
+                        {
+                                .first = 0xA0,
+                                .last = 0xA9,
+                        },
+                        {
+                                .first = 0xAF,
+                                .last = 0xB2,
+                        },
+                        {
+                                .first = 0xC0,
+                                .last = 0xC6,
+                        },
+                        {
+                                .first = 0xF5,
+                                .last = 0xF5,
+                        },
+                },
+        },
+        [AB8500_GAS_GAUGE] = {
+                .num_ranges = 3,
+                .range = (struct ab8500_reg_range[]) {
+                        {
+                                .first = 0x00,
+                                .last = 0x00,
+                        },
+                        {
+                                .first = 0x07,
+                                .last = 0x0A,
+                        },
+                        {
+                                .first = 0x10,
+                                .last = 0x14,
+                        },
+                },
+        },
+        [AB8500_AUDIO] = {
+                .num_ranges = 1,
+                .range = (struct ab8500_reg_range[]) {
+                        {
+                                .first = 0x00,
+                                .last = 0x9f,
+                        },
+                },
+        },
+        [AB8500_INTERRUPT] = {
+                .num_ranges = 6,
+                .range = (struct ab8500_reg_range[]) {
+                        {
+                                .first = 0x00,
+                                .last = 0x05,
+                        },
+                        {
+                                .first = 0x0B,
+                                .last = 0x0D,
+                        },
+                        {
+                                .first = 0x12,
+                                .last = 0x20,
+                        },
+                        /* Latch registers should not be read here */
+                        {
+                                .first = 0x40,
+                                .last = 0x45,
+                        },
+                        {
+                                .first = 0x4B,
+                                .last = 0x4D,
+                        },
+                        {
+                                .first = 0x52,
+                                .last = 0x60,
+                        },
+                        /* LatchHier registers should not be read here */
+                },
+        },
+        [AB8500_RTC] = {
+                .num_ranges = 3,
+                .range = (struct ab8500_reg_range[]) {
+                        {
+                                .first = 0x00,
+                                .last = 0x07,
+                        },
+                        {
+                                .first = 0x0B,
+                                .last = 0x18,
+                        },
+                        {
+                                .first = 0x20,
+                                .last = 0x25,
+                        },
+                },
+        },
+        [AB8500_MISC] = {
+                .num_ranges = 9,
+                .range = (struct ab8500_reg_range[]) {
+                        {
+                                .first = 0x00,
+                                .last = 0x06,
+                        },
+                        {
+                                .first = 0x10,
+                                .last = 0x16,
+                        },
+                        {
+                                .first = 0x20,
+                                .last = 0x26,
+                        },
+                        {
+                                .first = 0x30,
+                                .last = 0x36,
+                        },
+                        {
+                                .first = 0x40,
+                                .last = 0x49,
+                        },
+                        {
+                                .first = 0x50,
+                                .last = 0x50,
+                        },
+                        {
+                                .first = 0x60,
+                                .last = 0x6B,
+                        },
+                        {
+                                .first = 0x70,
+                                .last = 0x74,
+                        },
+                        {
+                                .first = 0x80,
+                                .last = 0x82,
+                        },
+                },
+        },
+        [AB8500_DEVELOPMENT] = {
+                .num_ranges = 3,
+                .range = (struct ab8500_reg_range[]) {
+                        {
+                                .first = 0x00,
+                                .last = 0x01,
+                        },
+                        {
+                                .first = 0x06,
+                                .last = 0x06,
+                        },
+                        {
+                                .first = 0x10,
+                                .last = 0x21,
+                        },
+                },
+        },
+        [AB8500_DEBUG] = {
+                .num_ranges = 3,
+                .range = (struct ab8500_reg_range[]) {
+                        {
+                                .first = 0x01,
+                                .last = 0x0C,
+                        },
+                        {
+                                .first = 0x0E,
+                                .last = 0x11,
+                        },
+                        {
+                                .first = 0x80,
+                                .last = 0x81,
+                        },
+                },
+        },
+        [AB8500_PROD_TEST] = {
+                .num_ranges = 0,
+                .range = NULL,
+        },
+        [AB8500_STE_TEST] = {
+                .num_ranges = 0,
+                .range = NULL,
+        },
+        [AB8500_OTP_EMUL] = {
+                .num_ranges = 1,
+                .range = (struct ab8500_reg_range[]) {
+                        {
+                                .first = 0x00,
+                                .last = 0x3F,
+                        },
+                },
+        },
+};
+
+
 static irqreturn_t ab8500_debug_handler(int irq, void *data)
 {
         char buf[16];
@@ -520,19 +1306,16 @@ static int ab8500_registers_print(struct device *dev, u32 bank,
                         }
 
                         if (s) {
-                                err = seq_printf(s, "  [%u/0x%02X]: 0x%02X\n",
+                                err = seq_printf(s, "  [0x%02X/0x%02X]: 0x%02X\n",
                                         bank, reg, value);
                                 if (err < 0) {
-                                        dev_err(dev,
-                                        "seq_printf overflow bank=%d reg=%d\n",
-                                                bank, reg);
                                         /* Error is not returned here since
                                          * the output is wanted in any case */
                                         return 0;
                                 }
                         } else {
-                                printk(KERN_INFO" [%u/0x%02X]: 0x%02X\n", bank,
-                                        reg, value);
+                                printk(KERN_INFO" [0x%02X/0x%02X]: 0x%02X\n",
+                                        bank, reg, value);
                         }
                 }
         }
@@ -546,7 +1329,7 @@ static int ab8500_print_bank_registers(struct seq_file *s, void *p)
 
         seq_printf(s, AB8500_NAME_STRING " register values:\n");
 
-        seq_printf(s, " bank %u:\n", bank);
+        seq_printf(s, " bank 0x%02X:\n", bank);
 
         ab8500_registers_print(dev, bank, s);
         return 0;
@@ -573,10 +1356,8 @@ static int ab8500_print_all_banks(struct seq_file *s, void *p)
 
         seq_printf(s, AB8500_NAME_STRING " register values:\n");
 
-        for (i = 1; i < AB8500_NUM_BANKS; i++) {
-                err = seq_printf(s, " bank %u:\n", i);
-                if (err < 0)
-                        dev_err(dev, "seq_printf overflow, bank=%d\n", i);
+        for (i = 0; i < AB8500_NUM_BANKS; i++) {
+                err = seq_printf(s, " bank 0x%02X:\n", i);
 
                 ab8500_registers_print(dev, i, s);
         }
@@ -591,11 +1372,68 @@ void ab8500_dump_all_banks(struct device *dev)
         printk(KERN_INFO"ab8500 register values:\n");
 
         for (i = 1; i < AB8500_NUM_BANKS; i++) {
-                printk(KERN_INFO" bank %u:\n", i);
+                printk(KERN_INFO" bank 0x%02X:\n", i);
                 ab8500_registers_print(dev, i, NULL);
         }
 }
 
+/* Space for 500 registers. */
+#define DUMP_MAX_REGS 700
+struct ab8500_register_dump
+{
+        u8 bank;
+        u8 reg;
+        u8 value;
+} ab8500_complete_register_dump[DUMP_MAX_REGS];
+
+extern int prcmu_abb_read(u8 slave, u8 reg, u8 *value, u8 size);
+
+/* This shall only be called upon kernel panic! */
+void ab8500_dump_all_banks_to_mem(void)
+{
+        int i, r = 0;
+        u8 bank;
+        int err = 0;
+
+        pr_info("Saving all ABB registers at \"ab8500_complete_register_dump\" "
+                "for crash analyze.\n");
+
+        for (bank = 0; bank < AB8500_NUM_BANKS; bank++) {
+                for (i = 0; i < debug_ranges[bank].num_ranges; i++) {
+                        u8 reg;
+
+                        for (reg = debug_ranges[bank].range[i].first;
+                             reg <= debug_ranges[bank].range[i].last;
+                             reg++) {
+                                u8 value;
+
+                                err = prcmu_abb_read(bank, reg, &value, 1);
+
+                                if (err < 0)
+                                        goto out;
+
+                                ab8500_complete_register_dump[r].bank = bank;
+                                ab8500_complete_register_dump[r].reg = reg;
+                                ab8500_complete_register_dump[r].value = value;
+
+                                r++;
+
+                                if (r >= DUMP_MAX_REGS) {
+                                        pr_err("%s: too many register to dump!\n",
+                                                __func__);
+                                        err = -EINVAL;
+                                        goto out;
+                                }
+                        }
+                }
+        }
+out:
+        if (err >= 0)
+                pr_info("Saved all ABB registers.\n");
+        else
+                pr_info("Failed to save all ABB registers.\n");
+}
+
 static int ab8500_all_banks_open(struct inode *inode, struct file *file)
 {
         struct seq_file *s;
@@ -625,7 +1463,7 @@ static const struct file_operations ab8500_all_banks_fops = {
 
 static int ab8500_bank_print(struct seq_file *s, void *p)
 {
-        return seq_printf(s, "%d\n", debug_bank);
+        return seq_printf(s, "0x%02X\n", debug_bank);
 }
 
 static int ab8500_bank_open(struct inode *inode, struct file *file)
@@ -641,7 +1479,6 @@ static ssize_t ab8500_bank_write(struct file *file,
         unsigned long user_bank;
         int err;
 
-        /* Get userspace string and assure termination */
         err = kstrtoul_from_user(user_buf, count, 0, &user_bank);
         if (err)
                 return err;
@@ -667,14 +1504,13 @@ static int ab8500_address_open(struct inode *inode, struct file *file)
 }
 
 static ssize_t ab8500_address_write(struct file *file,
-        const char __user *user_buf,
-        size_t count, loff_t *ppos)
+                                    const char __user *user_buf,
+                                    size_t count, loff_t *ppos)
 {
         struct device *dev = ((struct seq_file *)(file->private_data))->private;
         unsigned long user_address;
         int err;
 
-        /* Get userspace string and assure termination */
         err = kstrtoul_from_user(user_buf, count, 0, &user_address);
         if (err)
                 return err;
@@ -684,6 +1520,7 @@ static ssize_t ab8500_address_write(struct file *file,
                 return -EINVAL;
         }
         debug_address = user_address;
+
         return count;
 }
 
@@ -711,14 +1548,13 @@ static int ab8500_val_open(struct inode *inode, struct file *file)
 }
 
 static ssize_t ab8500_val_write(struct file *file,
-        const char __user *user_buf,
-        size_t count, loff_t *ppos)
+                                const char __user *user_buf,
+                                size_t count, loff_t *ppos)
 {
         struct device *dev = ((struct seq_file *)(file->private_data))->private;
         unsigned long user_val;
         int err;
 
-        /* Get userspace string and assure termination */
         err = kstrtoul_from_user(user_buf, count, 0, &user_val);
         if (err)
                 return err;
@@ -741,22 +1577,46 @@ static ssize_t ab8500_val_write(struct file *file,
  * Interrupt status
  */
 static u32 num_interrupts[AB8500_MAX_NR_IRQS];
+static u32 num_wake_interrupts[AB8500_MAX_NR_IRQS];
 static int num_interrupt_lines;
 
+bool __attribute__((weak)) suspend_test_wake_cause_interrupt_is_mine(u32 my_int)
+{
+        return false;
+}
+
 void ab8500_debug_register_interrupt(int line)
 {
-        if (line < num_interrupt_lines)
+        if (line < num_interrupt_lines) {
                 num_interrupts[line]++;
+                if (suspend_test_wake_cause_interrupt_is_mine(IRQ_DB8500_AB8500))
+                        num_wake_interrupts[line]++;
+        }
 }
 
 static int ab8500_interrupts_print(struct seq_file *s, void *p)
 {
         int line;
 
-        seq_printf(s, "irq:  number of\n");
+        seq_printf(s, "name: number:  number of: wake:\n");
 
-        for (line = 0; line < num_interrupt_lines; line++)
-                seq_printf(s, "%3i:  %6i\n", line, num_interrupts[line]);
+        for (line = 0; line < num_interrupt_lines; line++) {
+                struct irq_desc *desc = irq_to_desc(line + irq_first);
+                struct irqaction *action = desc->action;
+
+                seq_printf(s, "%3i:  %6i %4i", line,
+                           num_interrupts[line],
+                           num_wake_interrupts[line]);
+
+                if (desc && desc->name)
+                        seq_printf(s, "-%-8s", desc->name);
+                if (action) {
+                        seq_printf(s, "  %s", action->name);
+                        while ((action = action->next) != NULL)
+                                seq_printf(s, ", %s", action->name);
+                }
+                seq_putc(s, '\n');
+        }
 
         return 0;
 }
@@ -801,6 +1661,79 @@ static int ab8500_hwreg_open(struct inode *inode, struct file *file)
         return single_open(file, ab8500_hwreg_print, inode->i_private);
 }
 
+#define AB8500_SUPPLY_CONTROL_CONFIG_1 0x01
+#define AB8500_SUPPLY_CONTROL_REG 0x00
+#define AB8500_FIRST_SIM_REG 0x80
+#define AB8500_LAST_SIM_REG 0x8B
+#define AB8505_LAST_SIM_REG 0x8C
+
+static int ab8500_print_modem_registers(struct seq_file *s, void *p)
+{
+        struct device *dev = s->private;
+        struct ab8500 *ab8500;
+        int err;
+        u8 value;
+        u8 orig_value;
+        u32 bank = AB8500_REGU_CTRL2;
+        u32 last_sim_reg = AB8500_LAST_SIM_REG;
+        u32 reg;
+
+        ab8500 = dev_get_drvdata(dev->parent);
+        dev_warn(dev, "WARNING! This operation can interfer with modem side\n"
+                "and should only be done with care\n");
+
+        err = abx500_get_register_interruptible(dev,
+                AB8500_REGU_CTRL1, AB8500_SUPPLY_CONTROL_REG, &orig_value);
+        if (err < 0) {
+                dev_err(dev, "ab->read fail %d\n", err);
+                return err;
+        }
+        /* Config 1 will allow APE side to read SIM registers */
+        err = abx500_set_register_interruptible(dev,
+                AB8500_REGU_CTRL1, AB8500_SUPPLY_CONTROL_REG,
+                AB8500_SUPPLY_CONTROL_CONFIG_1);
+        if (err < 0) {
+                dev_err(dev, "ab->write fail %d\n", err);
+                return err;
+        }
+
+        seq_printf(s, " bank 0x%02X:\n", bank);
+
+        if (is_ab9540(ab8500) || is_ab8505(ab8500))
+                last_sim_reg = AB8505_LAST_SIM_REG;
+
+        for (reg = AB8500_FIRST_SIM_REG; reg <= last_sim_reg; reg++) {
+                err = abx500_get_register_interruptible(dev,
+                        bank, reg, &value);
+                if (err < 0) {
+                        dev_err(dev, "ab->read fail %d\n", err);
+                        return err;
+                }
+                err = seq_printf(s, "  [0x%02X/0x%02X]: 0x%02X\n",
+                        bank, reg, value);
+        }
+        err = abx500_set_register_interruptible(dev,
+                AB8500_REGU_CTRL1, AB8500_SUPPLY_CONTROL_REG, orig_value);
+        if (err < 0) {
+                dev_err(dev, "ab->write fail %d\n", err);
+                return err;
+        }
+        return 0;
+}
+
+static int ab8500_modem_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, ab8500_print_modem_registers, inode->i_private);
+}
+
+static const struct file_operations ab8500_modem_fops = {
+        .open = ab8500_modem_open,
+        .read = seq_read,
+        .llseek = seq_lseek,
+        .release = single_release,
+        .owner = THIS_MODULE,
+};
+
 static int ab8500_gpadc_bat_ctrl_print(struct seq_file *s, void *p)
 {
         int bat_ctrl_raw;
@@ -808,12 +1741,13 @@ static int ab8500_gpadc_bat_ctrl_print(struct seq_file *s, void *p)
         struct ab8500_gpadc *gpadc;
 
         gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
-        bat_ctrl_raw = ab8500_gpadc_read_raw(gpadc, BAT_CTRL);
+        bat_ctrl_raw = ab8500_gpadc_read_raw(gpadc, BAT_CTRL,
+                avg_sample, trig_edge, trig_timer, conv_type);
         bat_ctrl_convert = ab8500_gpadc_ad_to_voltage(gpadc,
-                        BAT_CTRL, bat_ctrl_raw);
+                BAT_CTRL, bat_ctrl_raw);
 
         return seq_printf(s, "%d,0x%X\n",
-                        bat_ctrl_convert, bat_ctrl_raw);
+                bat_ctrl_convert, bat_ctrl_raw);
 }
 
 static int ab8500_gpadc_bat_ctrl_open(struct inode *inode, struct file *file)
@@ -836,16 +1770,17 @@ static int ab8500_gpadc_btemp_ball_print(struct seq_file *s, void *p)
         struct ab8500_gpadc *gpadc;
 
         gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
-        btemp_ball_raw = ab8500_gpadc_read_raw(gpadc, BTEMP_BALL);
+        btemp_ball_raw = ab8500_gpadc_read_raw(gpadc, BTEMP_BALL,
+                avg_sample, trig_edge, trig_timer, conv_type);
         btemp_ball_convert = ab8500_gpadc_ad_to_voltage(gpadc, BTEMP_BALL,
-                        btemp_ball_raw);
+                btemp_ball_raw);
 
         return seq_printf(s,
-                        "%d,0x%X\n", btemp_ball_convert, btemp_ball_raw);
+                "%d,0x%X\n", btemp_ball_convert, btemp_ball_raw);
 }
 
 static int ab8500_gpadc_btemp_ball_open(struct inode *inode,
-                struct file *file)
+                                        struct file *file)
 {
         return single_open(file, ab8500_gpadc_btemp_ball_print, inode->i_private);
 }
@@ -865,19 +1800,20 @@ static int ab8500_gpadc_main_charger_v_print(struct seq_file *s, void *p)
         struct ab8500_gpadc *gpadc;
 
         gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
-        main_charger_v_raw = ab8500_gpadc_read_raw(gpadc, MAIN_CHARGER_V);
+        main_charger_v_raw = ab8500_gpadc_read_raw(gpadc, MAIN_CHARGER_V,
+                avg_sample, trig_edge, trig_timer, conv_type);
         main_charger_v_convert = ab8500_gpadc_ad_to_voltage(gpadc,
-                        MAIN_CHARGER_V, main_charger_v_raw);
+                MAIN_CHARGER_V, main_charger_v_raw);
 
         return seq_printf(s, "%d,0x%X\n",
                         main_charger_v_convert, main_charger_v_raw);
 }
 
 static int ab8500_gpadc_main_charger_v_open(struct inode *inode,
-                struct file *file)
+                                            struct file *file)
 {
         return single_open(file, ab8500_gpadc_main_charger_v_print,
-                        inode->i_private);
+                inode->i_private);
 }
 
 static const struct file_operations ab8500_gpadc_main_charger_v_fops = {
@@ -895,19 +1831,20 @@ static int ab8500_gpadc_acc_detect1_print(struct seq_file *s, void *p)
         struct ab8500_gpadc *gpadc;
 
         gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
-        acc_detect1_raw = ab8500_gpadc_read_raw(gpadc, ACC_DETECT1);
+        acc_detect1_raw = ab8500_gpadc_read_raw(gpadc, ACC_DETECT1,
+                avg_sample, trig_edge, trig_timer, conv_type);
         acc_detect1_convert = ab8500_gpadc_ad_to_voltage(gpadc, ACC_DETECT1,
-                        acc_detect1_raw);
+                acc_detect1_raw);
 
         return seq_printf(s, "%d,0x%X\n",
-                        acc_detect1_convert, acc_detect1_raw);
+                acc_detect1_convert, acc_detect1_raw);
 }
 
 static int ab8500_gpadc_acc_detect1_open(struct inode *inode,
-                struct file *file)
+                                         struct file *file)
 {
         return single_open(file, ab8500_gpadc_acc_detect1_print,
-                        inode->i_private);
+                inode->i_private);
 }
 
 static const struct file_operations ab8500_gpadc_acc_detect1_fops = {
@@ -925,19 +1862,20 @@ static int ab8500_gpadc_acc_detect2_print(struct seq_file *s, void *p)
         struct ab8500_gpadc *gpadc;
 
         gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
-        acc_detect2_raw = ab8500_gpadc_read_raw(gpadc, ACC_DETECT2);
+        acc_detect2_raw = ab8500_gpadc_read_raw(gpadc, ACC_DETECT2,
+                avg_sample, trig_edge, trig_timer, conv_type);
         acc_detect2_convert = ab8500_gpadc_ad_to_voltage(gpadc,
-            ACC_DETECT2, acc_detect2_raw);
+                ACC_DETECT2, acc_detect2_raw);
 
         return seq_printf(s, "%d,0x%X\n",
-                        acc_detect2_convert, acc_detect2_raw);
+                acc_detect2_convert, acc_detect2_raw);
 }
 
 static int ab8500_gpadc_acc_detect2_open(struct inode *inode,
                 struct file *file)
 {
         return single_open(file, ab8500_gpadc_acc_detect2_print,
-            inode->i_private);
+                inode->i_private);
 }
 
 static const struct file_operations ab8500_gpadc_acc_detect2_fops = {
@@ -955,12 +1893,13 @@ static int ab8500_gpadc_aux1_print(struct seq_file *s, void *p)
         struct ab8500_gpadc *gpadc;
 
         gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
-        aux1_raw = ab8500_gpadc_read_raw(gpadc, ADC_AUX1);
+        aux1_raw = ab8500_gpadc_read_raw(gpadc, ADC_AUX1,
+                avg_sample, trig_edge, trig_timer, conv_type);
         aux1_convert = ab8500_gpadc_ad_to_voltage(gpadc, ADC_AUX1,
-                        aux1_raw);
+                aux1_raw);
 
         return seq_printf(s, "%d,0x%X\n",
-                        aux1_convert, aux1_raw);
+                aux1_convert, aux1_raw);
 }
 
 static int ab8500_gpadc_aux1_open(struct inode *inode, struct file *file)
@@ -983,9 +1922,10 @@ static int ab8500_gpadc_aux2_print(struct seq_file *s, void *p)
         struct ab8500_gpadc *gpadc;
 
         gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
-        aux2_raw = ab8500_gpadc_read_raw(gpadc, ADC_AUX2);
+        aux2_raw = ab8500_gpadc_read_raw(gpadc, ADC_AUX2,
+                avg_sample, trig_edge, trig_timer, conv_type);
         aux2_convert = ab8500_gpadc_ad_to_voltage(gpadc, ADC_AUX2,
-                        aux2_raw);
+                aux2_raw);
 
         return seq_printf(s, "%d,0x%X\n",
                         aux2_convert, aux2_raw);
@@ -1011,16 +1951,17 @@ static int ab8500_gpadc_main_bat_v_print(struct seq_file *s, void *p)
         struct ab8500_gpadc *gpadc;
 
         gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
-        main_bat_v_raw = ab8500_gpadc_read_raw(gpadc, MAIN_BAT_V);
+        main_bat_v_raw = ab8500_gpadc_read_raw(gpadc, MAIN_BAT_V,
+                avg_sample, trig_edge, trig_timer, conv_type);
         main_bat_v_convert = ab8500_gpadc_ad_to_voltage(gpadc, MAIN_BAT_V,
-                        main_bat_v_raw);
+                main_bat_v_raw);
 
         return seq_printf(s, "%d,0x%X\n",
-                        main_bat_v_convert, main_bat_v_raw);
+                main_bat_v_convert, main_bat_v_raw);
 }
 
 static int ab8500_gpadc_main_bat_v_open(struct inode *inode,
-                struct file *file)
+                                        struct file *file)
 {
         return single_open(file, ab8500_gpadc_main_bat_v_print, inode->i_private);
 }
@@ -1040,12 +1981,13 @@ static int ab8500_gpadc_vbus_v_print(struct seq_file *s, void *p)
         struct ab8500_gpadc *gpadc;
 
         gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
-        vbus_v_raw = ab8500_gpadc_read_raw(gpadc, VBUS_V);
+        vbus_v_raw =  ab8500_gpadc_read_raw(gpadc, VBUS_V,
+                avg_sample, trig_edge, trig_timer, conv_type);
         vbus_v_convert = ab8500_gpadc_ad_to_voltage(gpadc, VBUS_V,
-                        vbus_v_raw);
+                vbus_v_raw);
 
         return seq_printf(s, "%d,0x%X\n",
-                        vbus_v_convert, vbus_v_raw);
+                vbus_v_convert, vbus_v_raw);
 }
 
 static int ab8500_gpadc_vbus_v_open(struct inode *inode, struct file *file)
@@ -1068,19 +2010,20 @@ static int ab8500_gpadc_main_charger_c_print(struct seq_file *s, void *p)
         struct ab8500_gpadc *gpadc;
 
         gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
-        main_charger_c_raw = ab8500_gpadc_read_raw(gpadc, MAIN_CHARGER_C);
+        main_charger_c_raw = ab8500_gpadc_read_raw(gpadc, MAIN_CHARGER_C,
+                avg_sample, trig_edge, trig_timer, conv_type);
         main_charger_c_convert = ab8500_gpadc_ad_to_voltage(gpadc,
-                        MAIN_CHARGER_C, main_charger_c_raw);
+                MAIN_CHARGER_C, main_charger_c_raw);
 
         return seq_printf(s, "%d,0x%X\n",
-                        main_charger_c_convert, main_charger_c_raw);
+                main_charger_c_convert, main_charger_c_raw);
 }
 
 static int ab8500_gpadc_main_charger_c_open(struct inode *inode,
                 struct file *file)
 {
         return single_open(file, ab8500_gpadc_main_charger_c_print,
-                        inode->i_private);
+                inode->i_private);
 }
 
 static const struct file_operations ab8500_gpadc_main_charger_c_fops = {
@@ -1098,19 +2041,20 @@ static int ab8500_gpadc_usb_charger_c_print(struct seq_file *s, void *p)
         struct ab8500_gpadc *gpadc;
 
         gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
-        usb_charger_c_raw = ab8500_gpadc_read_raw(gpadc, USB_CHARGER_C);
+        usb_charger_c_raw = ab8500_gpadc_read_raw(gpadc, USB_CHARGER_C,
+                avg_sample, trig_edge, trig_timer, conv_type);
         usb_charger_c_convert = ab8500_gpadc_ad_to_voltage(gpadc,
-            USB_CHARGER_C, usb_charger_c_raw);
+                USB_CHARGER_C, usb_charger_c_raw);
 
         return seq_printf(s, "%d,0x%X\n",
-                        usb_charger_c_convert, usb_charger_c_raw);
+                usb_charger_c_convert, usb_charger_c_raw);
 }
 
 static int ab8500_gpadc_usb_charger_c_open(struct inode *inode,
                 struct file *file)
 {
         return single_open(file, ab8500_gpadc_usb_charger_c_print,
-            inode->i_private);
+                inode->i_private);
 }
 
 static const struct file_operations ab8500_gpadc_usb_charger_c_fops = {
@@ -1128,12 +2072,13 @@ static int ab8500_gpadc_bk_bat_v_print(struct seq_file *s, void *p)
         struct ab8500_gpadc *gpadc;
 
         gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
-        bk_bat_v_raw = ab8500_gpadc_read_raw(gpadc, BK_BAT_V);
+        bk_bat_v_raw = ab8500_gpadc_read_raw(gpadc, BK_BAT_V,
+                avg_sample, trig_edge, trig_timer, conv_type);
         bk_bat_v_convert = ab8500_gpadc_ad_to_voltage(gpadc,
-                        BK_BAT_V, bk_bat_v_raw);
+                BK_BAT_V, bk_bat_v_raw);
 
         return seq_printf(s, "%d,0x%X\n",
-                        bk_bat_v_convert, bk_bat_v_raw);
+                bk_bat_v_convert, bk_bat_v_raw);
 }
 
 static int ab8500_gpadc_bk_bat_v_open(struct inode *inode, struct file *file)
@@ -1156,12 +2101,13 @@ static int ab8500_gpadc_die_temp_print(struct seq_file *s, void *p)
         struct ab8500_gpadc *gpadc;
 
         gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
-        die_temp_raw = ab8500_gpadc_read_raw(gpadc, DIE_TEMP);
+        die_temp_raw = ab8500_gpadc_read_raw(gpadc, DIE_TEMP,
+                avg_sample, trig_edge, trig_timer, conv_type);
         die_temp_convert = ab8500_gpadc_ad_to_voltage(gpadc, DIE_TEMP,
-                        die_temp_raw);
+                die_temp_raw);
 
         return seq_printf(s, "%d,0x%X\n",
-                        die_temp_convert, die_temp_raw);
+                die_temp_convert, die_temp_raw);
 }
 
 static int ab8500_gpadc_die_temp_open(struct inode *inode, struct file *file)
@@ -1177,6 +2123,453 @@ static const struct file_operations ab8500_gpadc_die_temp_fops = {
         .owner = THIS_MODULE,
 };
 
+static int ab8500_gpadc_usb_id_print(struct seq_file *s, void *p)
+{
+        int usb_id_raw;
+        int usb_id_convert;
+        struct ab8500_gpadc *gpadc;
+
+        gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
+        usb_id_raw = ab8500_gpadc_read_raw(gpadc, USB_ID,
+                avg_sample, trig_edge, trig_timer, conv_type);
+        usb_id_convert = ab8500_gpadc_ad_to_voltage(gpadc, USB_ID,
+                usb_id_raw);
+
+        return seq_printf(s, "%d,0x%X\n",
+                usb_id_convert, usb_id_raw);
+}
+
+static int ab8500_gpadc_usb_id_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, ab8500_gpadc_usb_id_print, inode->i_private);
+}
+
+static const struct file_operations ab8500_gpadc_usb_id_fops = {
+        .open = ab8500_gpadc_usb_id_open,
+        .read = seq_read,
+        .llseek = seq_lseek,
+        .release = single_release,
+        .owner = THIS_MODULE,
+};
+
+static int ab8540_gpadc_xtal_temp_print(struct seq_file *s, void *p)
+{
+        int xtal_temp_raw;
+        int xtal_temp_convert;
+        struct ab8500_gpadc *gpadc;
+
+        gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
+        xtal_temp_raw = ab8500_gpadc_read_raw(gpadc, XTAL_TEMP,
+                avg_sample, trig_edge, trig_timer, conv_type);
+        xtal_temp_convert = ab8500_gpadc_ad_to_voltage(gpadc, XTAL_TEMP,
+                xtal_temp_raw);
+
+        return seq_printf(s, "%d,0x%X\n",
+                xtal_temp_convert, xtal_temp_raw);
+}
+
+static int ab8540_gpadc_xtal_temp_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, ab8540_gpadc_xtal_temp_print,
+                inode->i_private);
+}
+
+static const struct file_operations ab8540_gpadc_xtal_temp_fops = {
+        .open = ab8540_gpadc_xtal_temp_open,
+        .read = seq_read,
+        .llseek = seq_lseek,
+        .release = single_release,
+        .owner = THIS_MODULE,
+};
+
+static int ab8540_gpadc_vbat_true_meas_print(struct seq_file *s, void *p)
+{
+        int vbat_true_meas_raw;
+        int vbat_true_meas_convert;
+        struct ab8500_gpadc *gpadc;
+
+        gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
+        vbat_true_meas_raw = ab8500_gpadc_read_raw(gpadc, VBAT_TRUE_MEAS,
+                avg_sample, trig_edge, trig_timer, conv_type);
+        vbat_true_meas_convert = ab8500_gpadc_ad_to_voltage(gpadc, VBAT_TRUE_MEAS,
+                vbat_true_meas_raw);
+
+        return seq_printf(s, "%d,0x%X\n",
+                vbat_true_meas_convert, vbat_true_meas_raw);
+}
+
+static int ab8540_gpadc_vbat_true_meas_open(struct inode *inode,
+                struct file *file)
+{
+        return single_open(file, ab8540_gpadc_vbat_true_meas_print,
+                inode->i_private);
+}
+
+static const struct file_operations ab8540_gpadc_vbat_true_meas_fops = {
+        .open = ab8540_gpadc_vbat_true_meas_open,
+        .read = seq_read,
+        .llseek = seq_lseek,
+        .release = single_release,
+        .owner = THIS_MODULE,
+};
+
+static int ab8540_gpadc_bat_ctrl_and_ibat_print(struct seq_file *s, void *p)
+{
+        int bat_ctrl_raw;
+        int bat_ctrl_convert;
+        int ibat_raw;
+        int ibat_convert;
+        struct ab8500_gpadc *gpadc;
+
+        gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
+        bat_ctrl_raw = ab8500_gpadc_double_read_raw(gpadc, BAT_CTRL_AND_IBAT,
+                avg_sample, trig_edge, trig_timer, conv_type, &ibat_raw);
+
+        bat_ctrl_convert = ab8500_gpadc_ad_to_voltage(gpadc, BAT_CTRL,
+                bat_ctrl_raw);
+        ibat_convert = ab8500_gpadc_ad_to_voltage(gpadc, IBAT_VIRTUAL_CHANNEL,
+                ibat_raw);
+
+        return seq_printf(s, "%d,0x%X\n"  "%d,0x%X\n",
+                bat_ctrl_convert, bat_ctrl_raw,
+                ibat_convert, ibat_raw);
+}
+
+static int ab8540_gpadc_bat_ctrl_and_ibat_open(struct inode *inode,
+                struct file *file)
+{
+        return single_open(file, ab8540_gpadc_bat_ctrl_and_ibat_print,
+                inode->i_private);
+}
+
+static const struct file_operations ab8540_gpadc_bat_ctrl_and_ibat_fops = {
+        .open = ab8540_gpadc_bat_ctrl_and_ibat_open,
+        .read = seq_read,
+        .llseek = seq_lseek,
+        .release = single_release,
+        .owner = THIS_MODULE,
+};
+
+static int ab8540_gpadc_vbat_meas_and_ibat_print(struct seq_file *s, void *p)
+{
+        int vbat_meas_raw;
+        int vbat_meas_convert;
+        int ibat_raw;
+        int ibat_convert;
+        struct ab8500_gpadc *gpadc;
+
+        gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
+        vbat_meas_raw = ab8500_gpadc_double_read_raw(gpadc, VBAT_MEAS_AND_IBAT,
+                avg_sample, trig_edge, trig_timer, conv_type, &ibat_raw);
+        vbat_meas_convert = ab8500_gpadc_ad_to_voltage(gpadc, MAIN_BAT_V,
+                vbat_meas_raw);
+        ibat_convert = ab8500_gpadc_ad_to_voltage(gpadc, IBAT_VIRTUAL_CHANNEL,
+                ibat_raw);
+
+        return seq_printf(s, "%d,0x%X\n"  "%d,0x%X\n",
+                vbat_meas_convert, vbat_meas_raw,
+                ibat_convert, ibat_raw);
+}
+
+static int ab8540_gpadc_vbat_meas_and_ibat_open(struct inode *inode,
+                struct file *file)
+{
+        return single_open(file, ab8540_gpadc_vbat_meas_and_ibat_print,
+                inode->i_private);
+}
+
+static const struct file_operations ab8540_gpadc_vbat_meas_and_ibat_fops = {
+        .open = ab8540_gpadc_vbat_meas_and_ibat_open,
+        .read = seq_read,
+        .llseek = seq_lseek,
+        .release = single_release,
+        .owner = THIS_MODULE,
+};
+
+static int ab8540_gpadc_vbat_true_meas_and_ibat_print(struct seq_file *s, void *p)
+{
+        int vbat_true_meas_raw;
+        int vbat_true_meas_convert;
+        int ibat_raw;
+        int ibat_convert;
+        struct ab8500_gpadc *gpadc;
+
+        gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
+        vbat_true_meas_raw = ab8500_gpadc_double_read_raw(gpadc,
+                        VBAT_TRUE_MEAS_AND_IBAT, avg_sample, trig_edge,
+                        trig_timer, conv_type, &ibat_raw);
+        vbat_true_meas_convert = ab8500_gpadc_ad_to_voltage(gpadc,
+                        VBAT_TRUE_MEAS, vbat_true_meas_raw);
+        ibat_convert = ab8500_gpadc_ad_to_voltage(gpadc, IBAT_VIRTUAL_CHANNEL,
+                ibat_raw);
+
+        return seq_printf(s, "%d,0x%X\n"  "%d,0x%X\n",
+                vbat_true_meas_convert, vbat_true_meas_raw,
+                ibat_convert, ibat_raw);
+}
+
+static int ab8540_gpadc_vbat_true_meas_and_ibat_open(struct inode *inode,
+                struct file *file)
+{
+        return single_open(file, ab8540_gpadc_vbat_true_meas_and_ibat_print,
+                inode->i_private);
+}
+
+static const struct file_operations ab8540_gpadc_vbat_true_meas_and_ibat_fops = {
+        .open = ab8540_gpadc_vbat_true_meas_and_ibat_open,
+        .read = seq_read,
+        .llseek = seq_lseek,
+        .release = single_release,
+        .owner = THIS_MODULE,
+};
+
+static int ab8540_gpadc_bat_temp_and_ibat_print(struct seq_file *s, void *p)
+{
+        int bat_temp_raw;
+        int bat_temp_convert;
+        int ibat_raw;
+        int ibat_convert;
+        struct ab8500_gpadc *gpadc;
+
+        gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
+        bat_temp_raw = ab8500_gpadc_double_read_raw(gpadc, BAT_TEMP_AND_IBAT,
+                avg_sample, trig_edge, trig_timer, conv_type, &ibat_raw);
+        bat_temp_convert = ab8500_gpadc_ad_to_voltage(gpadc, BTEMP_BALL,
+                bat_temp_raw);
+        ibat_convert = ab8500_gpadc_ad_to_voltage(gpadc, IBAT_VIRTUAL_CHANNEL,
+                ibat_raw);
+
+        return seq_printf(s, "%d,0x%X\n"  "%d,0x%X\n",
+                bat_temp_convert, bat_temp_raw,
+                ibat_convert, ibat_raw);
+}
+
+static int ab8540_gpadc_bat_temp_and_ibat_open(struct inode *inode,
+                struct file *file)
+{
+        return single_open(file, ab8540_gpadc_bat_temp_and_ibat_print,
+                inode->i_private);
+}
+
+static const struct file_operations ab8540_gpadc_bat_temp_and_ibat_fops = {
+        .open = ab8540_gpadc_bat_temp_and_ibat_open,
+        .read = seq_read,
+        .llseek = seq_lseek,
+        .release = single_release,
+        .owner = THIS_MODULE,
+};
+
+static int ab8540_gpadc_otp_cal_print(struct seq_file *s, void *p)
+{
+        struct ab8500_gpadc *gpadc;
+        u16 vmain_l, vmain_h, btemp_l, btemp_h;
+        u16 vbat_l, vbat_h, ibat_l, ibat_h;
+
+        gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
+        ab8540_gpadc_get_otp(gpadc, &vmain_l, &vmain_h, &btemp_l, &btemp_h,
+                        &vbat_l, &vbat_h, &ibat_l, &ibat_h);
+        return seq_printf(s, "VMAIN_L:0x%X\n"
+                "VMAIN_H:0x%X\n"
+                "BTEMP_L:0x%X\n"
+                "BTEMP_H:0x%X\n"
+                "VBAT_L:0x%X\n"
+                "VBAT_H:0x%X\n"
+                "IBAT_L:0x%X\n"
+                "IBAT_H:0x%X\n",
+                vmain_l, vmain_h, btemp_l, btemp_h, vbat_l, vbat_h, ibat_l, ibat_h);
+}
+
+static int ab8540_gpadc_otp_cal_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, ab8540_gpadc_otp_cal_print, inode->i_private);
+}
+
+static const struct file_operations ab8540_gpadc_otp_calib_fops = {
+        .open = ab8540_gpadc_otp_cal_open,
+        .read = seq_read,
+        .llseek = seq_lseek,
+        .release = single_release,
+        .owner = THIS_MODULE,
+};
+
+static int ab8500_gpadc_avg_sample_print(struct seq_file *s, void *p)
+{
+        return seq_printf(s, "%d\n", avg_sample);
+}
+
+static int ab8500_gpadc_avg_sample_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, ab8500_gpadc_avg_sample_print,
+                inode->i_private);
+}
+
+static ssize_t ab8500_gpadc_avg_sample_write(struct file *file,
+        const char __user *user_buf,
+        size_t count, loff_t *ppos)
+{
+        struct device *dev = ((struct seq_file *)(file->private_data))->private;
+        unsigned long user_avg_sample;
+        int err;
+
+        err = kstrtoul_from_user(user_buf, count, 0, &user_avg_sample);
+        if (err)
+                return err;
+
+        if ((user_avg_sample == SAMPLE_1) || (user_avg_sample == SAMPLE_4)
+                        || (user_avg_sample == SAMPLE_8)
+                        || (user_avg_sample == SAMPLE_16)) {
+                avg_sample = (u8) user_avg_sample;
+        } else {
+                dev_err(dev, "debugfs error input: "
+                        "should be egal to 1, 4, 8 or 16\n");
+                return -EINVAL;
+        }
+
+        return count;
+}
+
+static const struct file_operations ab8500_gpadc_avg_sample_fops = {
+        .open = ab8500_gpadc_avg_sample_open,
+        .read = seq_read,
+        .write = ab8500_gpadc_avg_sample_write,
+        .llseek = seq_lseek,
+        .release = single_release,
+        .owner = THIS_MODULE,
+};
+
+static int ab8500_gpadc_trig_edge_print(struct seq_file *s, void *p)
+{
+        return seq_printf(s, "%d\n", trig_edge);
+}
+
+static int ab8500_gpadc_trig_edge_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, ab8500_gpadc_trig_edge_print,
+                inode->i_private);
+}
+
+static ssize_t ab8500_gpadc_trig_edge_write(struct file *file,
+        const char __user *user_buf,
+        size_t count, loff_t *ppos)
+{
+        struct device *dev = ((struct seq_file *)(file->private_data))->private;
+        unsigned long user_trig_edge;
+        int err;
+
+        err = kstrtoul_from_user(user_buf, count, 0, &user_trig_edge);
+        if (err)
+                return err;
+
+        if ((user_trig_edge == RISING_EDGE)
+                        || (user_trig_edge == FALLING_EDGE)) {
+                trig_edge = (u8) user_trig_edge;
+        } else {
+                dev_err(dev, "Wrong input:\n"
+                        "Enter 0. Rising edge\n"
+                        "Enter 1. Falling edge\n");
+                return -EINVAL;
+        }
+
+        return count;
+}
+
+static const struct file_operations ab8500_gpadc_trig_edge_fops = {
+        .open = ab8500_gpadc_trig_edge_open,
+        .read = seq_read,
+        .write = ab8500_gpadc_trig_edge_write,
+        .llseek = seq_lseek,
+        .release = single_release,
+        .owner = THIS_MODULE,
+};
+
+static int ab8500_gpadc_trig_timer_print(struct seq_file *s, void *p)
+{
+        return seq_printf(s, "%d\n", trig_timer);
+}
+
+static int ab8500_gpadc_trig_timer_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, ab8500_gpadc_trig_timer_print,
+                inode->i_private);
+}
+
+static ssize_t ab8500_gpadc_trig_timer_write(struct file *file,
+        const char __user *user_buf,
+        size_t count, loff_t *ppos)
+{
+        struct device *dev = ((struct seq_file *)(file->private_data))->private;
+        unsigned long user_trig_timer;
+        int err;
+
+        err = kstrtoul_from_user(user_buf, count, 0, &user_trig_timer);
+        if (err)
+                return err;
+
+        if ((user_trig_timer >= 0) && (user_trig_timer <= 255)) {
+                trig_timer = (u8) user_trig_timer;
+        } else {
+                dev_err(dev, "debugfs error input: "
+                        "should be beetween 0 to 255\n");
+                return -EINVAL;
+        }
+
+        return count;
+}
+
+static const struct file_operations ab8500_gpadc_trig_timer_fops = {
+        .open = ab8500_gpadc_trig_timer_open,
+        .read = seq_read,
+        .write = ab8500_gpadc_trig_timer_write,
+        .llseek = seq_lseek,
+        .release = single_release,
+        .owner = THIS_MODULE,
+};
+
+static int ab8500_gpadc_conv_type_print(struct seq_file *s, void *p)
+{
+        return seq_printf(s, "%d\n", conv_type);
+}
+
+static int ab8500_gpadc_conv_type_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, ab8500_gpadc_conv_type_print,
+                inode->i_private);
+}
+
+static ssize_t ab8500_gpadc_conv_type_write(struct file *file,
+        const char __user *user_buf,
+        size_t count, loff_t *ppos)
+{
+        struct device *dev = ((struct seq_file *)(file->private_data))->private;
+        unsigned long user_conv_type;
+        int err;
+
+        err = kstrtoul_from_user(user_buf, count, 0, &user_conv_type);
+        if (err)
+                return err;
+
+        if ((user_conv_type == ADC_SW)
+                        || (user_conv_type == ADC_HW)) {
+                conv_type = (u8) user_conv_type;
+        } else {
+                dev_err(dev, "Wrong input:\n"
+                        "Enter 0. ADC SW conversion\n"
+                        "Enter 1. ADC HW conversion\n");
+                return -EINVAL;
+        }
+
+        return count;
+}
+
+static const struct file_operations ab8500_gpadc_conv_type_fops = {
+        .open = ab8500_gpadc_conv_type_open,
+        .read = seq_read,
+        .write = ab8500_gpadc_conv_type_write,
+        .llseek = seq_lseek,
+        .release = single_release,
+        .owner = THIS_MODULE,
+};
+
 /*
  * return length of an ASCII numerical value, 0 is string is not a
  * numerical value.
@@ -1352,7 +2745,7 @@ static int ab8500_subscribe_unsubscribe_open(struct inode *inode,
                                              struct file *file)
 {
         return single_open(file, ab8500_subscribe_unsubscribe_print,
-                           inode->i_private);
+                inode->i_private);
 }
 
 /*
@@ -1382,21 +2775,14 @@ static ssize_t ab8500_subscribe_write(struct file *file,
                                       size_t count, loff_t *ppos)
 {
         struct device *dev = ((struct seq_file *)(file->private_data))->private;
-        char buf[32];
-        int buf_size;
         unsigned long user_val;
         int err;
         unsigned int irq_index;
 
-        /* Get userspace string and assure termination */
-        buf_size = min(count, (sizeof(buf)-1));
-        if (copy_from_user(buf, user_buf, buf_size))
-                return -EFAULT;
-        buf[buf_size] = 0;
-
-        err = strict_strtoul(buf, 0, &user_val);
+        err = kstrtoul_from_user(user_buf, count, 0, &user_val);
         if (err)
-                return -EINVAL;
+                return err;
+
         if (user_val < irq_first) {
                 dev_err(dev, "debugfs error input < %d\n", irq_first);
                 return -EINVAL;
@@ -1416,7 +2802,7 @@ static ssize_t ab8500_subscribe_write(struct file *file,
          */
         dev_attr[irq_index] = kmalloc(sizeof(struct device_attribute),
                 GFP_KERNEL);
-        event_name[irq_index] = kmalloc(buf_size, GFP_KERNEL);
+        event_name[irq_index] = kmalloc(count, GFP_KERNEL);
         sprintf(event_name[irq_index], "%lu", user_val);
         dev_attr[irq_index]->show = show_irq;
         dev_attr[irq_index]->store = NULL;
@@ -1438,7 +2824,7 @@ static ssize_t ab8500_subscribe_write(struct file *file,
                 return err;
         }
 
-        return buf_size;
+        return count;
 }
 
 static ssize_t ab8500_unsubscribe_write(struct file *file,
@@ -1446,21 +2832,14 @@ static ssize_t ab8500_unsubscribe_write(struct file *file,
                                         size_t count, loff_t *ppos)
 {
         struct device *dev = ((struct seq_file *)(file->private_data))->private;
-        char buf[32];
-        int buf_size;
         unsigned long user_val;
         int err;
         unsigned int irq_index;
 
-        /* Get userspace string and assure termination */
-        buf_size = min(count, (sizeof(buf)-1));
-        if (copy_from_user(buf, user_buf, buf_size))
-                return -EFAULT;
-        buf[buf_size] = 0;
-
-        err = strict_strtoul(buf, 0, &user_val);
+        err = kstrtoul_from_user(user_buf, count, 0, &user_val);
         if (err)
-                return -EINVAL;
+                return err;
+
         if (user_val < irq_first) {
                 dev_err(dev, "debugfs error input < %d\n", irq_first);
                 return -EINVAL;
@@ -1485,7 +2864,7 @@ static ssize_t ab8500_unsubscribe_write(struct file *file,
         kfree(event_name[irq_index]);
         kfree(dev_attr[irq_index]);
 
-        return buf_size;
+        return count;
 }
 
 /*
@@ -1583,7 +2962,7 @@ static int ab8500_debug_probe(struct platform_device *plf)
         irq_first = platform_get_irq_byname(plf, "IRQ_FIRST");
         if (irq_first < 0) {
                 dev_err(&plf->dev, "First irq not found, err %d\n",
-                                irq_first);
+                        irq_first);
                 ret = irq_first;
                 goto out_freeevent_name;
         }
@@ -1591,9 +2970,9 @@ static int ab8500_debug_probe(struct platform_device *plf)
         irq_last = platform_get_irq_byname(plf, "IRQ_LAST");
         if (irq_last < 0) {
                 dev_err(&plf->dev, "Last irq not found, err %d\n",
-                                irq_last);
+                        irq_last);
                 ret = irq_last;
-                goto out_freeevent_name;
+                goto out_freeevent_name;
         }
 
         ab8500_dir = debugfs_create_dir(AB8500_NAME_STRING, NULL);
@@ -1601,124 +2980,198 @@ static int ab8500_debug_probe(struct platform_device *plf)
                 goto err;
 
         ab8500_gpadc_dir = debugfs_create_dir(AB8500_ADC_NAME_STRING,
-            ab8500_dir);
+                ab8500_dir);
         if (!ab8500_gpadc_dir)
                 goto err;
 
         file = debugfs_create_file("all-bank-registers", S_IRUGO,
-            ab8500_dir, &plf->dev, &ab8500_registers_fops);
+                ab8500_dir, &plf->dev, &ab8500_registers_fops);
         if (!file)
                 goto err;
 
         file = debugfs_create_file("all-banks", S_IRUGO,
-            ab8500_dir, &plf->dev, &ab8500_all_banks_fops);
+                ab8500_dir, &plf->dev, &ab8500_all_banks_fops);
         if (!file)
                 goto err;
 
-        file = debugfs_create_file("register-bank", (S_IRUGO | S_IWUSR),
-            ab8500_dir, &plf->dev, &ab8500_bank_fops);
+        file = debugfs_create_file("register-bank", (S_IRUGO | S_IWUSR | S_IWGRP),
+                ab8500_dir, &plf->dev, &ab8500_bank_fops);
         if (!file)
                 goto err;
 
-        file = debugfs_create_file("register-address", (S_IRUGO | S_IWUSR),
-            ab8500_dir, &plf->dev, &ab8500_address_fops);
+        file = debugfs_create_file("register-address", (S_IRUGO | S_IWUSR | S_IWGRP),
+                ab8500_dir, &plf->dev, &ab8500_address_fops);
         if (!file)
                 goto err;
 
-        file = debugfs_create_file("register-value", (S_IRUGO | S_IWUSR),
-            ab8500_dir, &plf->dev, &ab8500_val_fops);
+        file = debugfs_create_file("register-value", (S_IRUGO | S_IWUSR | S_IWGRP),
+                ab8500_dir, &plf->dev, &ab8500_val_fops);
         if (!file)
                 goto err;
 
-        file = debugfs_create_file("irq-subscribe", (S_IRUGO | S_IWUSR),
-            ab8500_dir, &plf->dev, &ab8500_subscribe_fops);
+        file = debugfs_create_file("irq-subscribe", (S_IRUGO | S_IWUSR | S_IWGRP),
+                ab8500_dir, &plf->dev, &ab8500_subscribe_fops);
         if (!file)
                 goto err;
 
-        if (is_ab8500(ab8500))
+        if (is_ab8500(ab8500)) {
+                debug_ranges = ab8500_debug_ranges;
                 num_interrupt_lines = AB8500_NR_IRQS;
-        else if (is_ab8505(ab8500))
+        } else if (is_ab8505(ab8500)) {
+                debug_ranges = ab8505_debug_ranges;
                 num_interrupt_lines = AB8505_NR_IRQS;
-        else if (is_ab9540(ab8500))
+        } else if (is_ab9540(ab8500)) {
+                debug_ranges = ab8505_debug_ranges;
                 num_interrupt_lines = AB9540_NR_IRQS;
+        } else if (is_ab8540(ab8500)) {
+                debug_ranges = ab8540_debug_ranges;
+                num_interrupt_lines = AB8540_NR_IRQS;
+        }
 
         file = debugfs_create_file("interrupts", (S_IRUGO),
-            ab8500_dir, &plf->dev, &ab8500_interrupts_fops);
+                ab8500_dir, &plf->dev, &ab8500_interrupts_fops);
         if (!file)
                 goto err;
 
-        file = debugfs_create_file("irq-unsubscribe", (S_IRUGO | S_IWUSR),
-            ab8500_dir, &plf->dev, &ab8500_unsubscribe_fops);
+        file = debugfs_create_file("irq-unsubscribe", (S_IRUGO | S_IWUSR | S_IWGRP),
+                ab8500_dir, &plf->dev, &ab8500_unsubscribe_fops);
         if (!file)
                 goto err;
 
-        file = debugfs_create_file("hwreg", (S_IRUGO | S_IWUSR),
-            ab8500_dir, &plf->dev, &ab8500_hwreg_fops);
+        file = debugfs_create_file("hwreg", (S_IRUGO | S_IWUSR | S_IWGRP),
+                ab8500_dir, &plf->dev, &ab8500_hwreg_fops);
         if (!file)
                 goto err;
 
-        file = debugfs_create_file("bat_ctrl", (S_IRUGO | S_IWUSR),
-            ab8500_gpadc_dir, &plf->dev, &ab8500_gpadc_bat_ctrl_fops);
+        file = debugfs_create_file("all-modem-registers", (S_IRUGO | S_IWUSR | S_IWGRP),
+                ab8500_dir, &plf->dev, &ab8500_modem_fops);
         if (!file)
                 goto err;
 
-        file = debugfs_create_file("btemp_ball", (S_IRUGO | S_IWUSR),
-            ab8500_gpadc_dir, &plf->dev, &ab8500_gpadc_btemp_ball_fops);
+        file = debugfs_create_file("bat_ctrl", (S_IRUGO | S_IWUSR | S_IWGRP),
+                ab8500_gpadc_dir, &plf->dev, &ab8500_gpadc_bat_ctrl_fops);
         if (!file)
                 goto err;
 
-        file = debugfs_create_file("main_charger_v", (S_IRUGO | S_IWUSR),
-            ab8500_gpadc_dir, &plf->dev, &ab8500_gpadc_main_charger_v_fops);
+        file = debugfs_create_file("btemp_ball", (S_IRUGO | S_IWUSR | S_IWGRP),
+                ab8500_gpadc_dir, &plf->dev, &ab8500_gpadc_btemp_ball_fops);
         if (!file)
                 goto err;
 
-        file = debugfs_create_file("acc_detect1", (S_IRUGO | S_IWUSR),
-            ab8500_gpadc_dir, &plf->dev, &ab8500_gpadc_acc_detect1_fops);
+        file = debugfs_create_file("main_charger_v", (S_IRUGO | S_IWUSR | S_IWGRP),
+                ab8500_gpadc_dir, &plf->dev, &ab8500_gpadc_main_charger_v_fops);
         if (!file)
                 goto err;
 
-        file = debugfs_create_file("acc_detect2", (S_IRUGO | S_IWUSR),
-            ab8500_gpadc_dir, &plf->dev, &ab8500_gpadc_acc_detect2_fops);
+        file = debugfs_create_file("acc_detect1", (S_IRUGO | S_IWUSR | S_IWGRP),
+                ab8500_gpadc_dir, &plf->dev, &ab8500_gpadc_acc_detect1_fops);
         if (!file)
                 goto err;
 
-        file = debugfs_create_file("adc_aux1", (S_IRUGO | S_IWUSR),
-            ab8500_gpadc_dir, &plf->dev, &ab8500_gpadc_aux1_fops);
+        file = debugfs_create_file("acc_detect2", (S_IRUGO | S_IWUSR | S_IWGRP),
+                ab8500_gpadc_dir, &plf->dev, &ab8500_gpadc_acc_detect2_fops);
         if (!file)
                 goto err;
 
-        file = debugfs_create_file("adc_aux2", (S_IRUGO | S_IWUSR),
-            ab8500_gpadc_dir, &plf->dev, &ab8500_gpadc_aux2_fops);
+        file = debugfs_create_file("adc_aux1", (S_IRUGO | S_IWUSR | S_IWGRP),
+                ab8500_gpadc_dir, &plf->dev, &ab8500_gpadc_aux1_fops);
         if (!file)
                 goto err;
 
-        file = debugfs_create_file("main_bat_v", (S_IRUGO | S_IWUSR),
-            ab8500_gpadc_dir, &plf->dev, &ab8500_gpadc_main_bat_v_fops);
+        file = debugfs_create_file("adc_aux2", (S_IRUGO | S_IWUSR | S_IWGRP),
+                ab8500_gpadc_dir, &plf->dev, &ab8500_gpadc_aux2_fops);
         if (!file)
                 goto err;
 
-        file = debugfs_create_file("vbus_v", (S_IRUGO | S_IWUSR),
-            ab8500_gpadc_dir, &plf->dev, &ab8500_gpadc_vbus_v_fops);
+        file = debugfs_create_file("main_bat_v", (S_IRUGO | S_IWUSR | S_IWGRP),
+                ab8500_gpadc_dir, &plf->dev, &ab8500_gpadc_main_bat_v_fops);
         if (!file)
                 goto err;
 
-        file = debugfs_create_file("main_charger_c", (S_IRUGO | S_IWUSR),
-            ab8500_gpadc_dir, &plf->dev, &ab8500_gpadc_main_charger_c_fops);
+        file = debugfs_create_file("vbus_v", (S_IRUGO | S_IWUSR | S_IWGRP),
+                ab8500_gpadc_dir, &plf->dev, &ab8500_gpadc_vbus_v_fops);
+        if (!file)
+                goto err;
+
+        file = debugfs_create_file("main_charger_c", (S_IRUGO | S_IWUSR | S_IWGRP),
+                ab8500_gpadc_dir, &plf->dev, &ab8500_gpadc_main_charger_c_fops);
+        if (!file)
+                goto err;
+
+        file = debugfs_create_file("usb_charger_c", (S_IRUGO | S_IWUSR | S_IWGRP),
+                ab8500_gpadc_dir, &plf->dev, &ab8500_gpadc_usb_charger_c_fops);
+        if (!file)
+                goto err;
+
+        file = debugfs_create_file("bk_bat_v", (S_IRUGO | S_IWUSR | S_IWGRP),
+                ab8500_gpadc_dir, &plf->dev, &ab8500_gpadc_bk_bat_v_fops);
+        if (!file)
+                goto err;
+
+        file = debugfs_create_file("die_temp", (S_IRUGO | S_IWUSR | S_IWGRP),
+                ab8500_gpadc_dir, &plf->dev, &ab8500_gpadc_die_temp_fops);
+        if (!file)
+                goto err;
+
+        file = debugfs_create_file("usb_id", (S_IRUGO | S_IWUSR | S_IWGRP),
+                ab8500_gpadc_dir, &plf->dev, &ab8500_gpadc_usb_id_fops);
+        if (!file)
+                goto err;
+
+        if (is_ab8540(ab8500)) {
+                file = debugfs_create_file("xtal_temp", (S_IRUGO | S_IWUSR | S_IWGRP),
+                        ab8500_gpadc_dir, &plf->dev, &ab8540_gpadc_xtal_temp_fops);
+                if (!file)
+                        goto err;
+                file = debugfs_create_file("vbattruemeas", (S_IRUGO | S_IWUSR | S_IWGRP),
+                        ab8500_gpadc_dir, &plf->dev,
+                        &ab8540_gpadc_vbat_true_meas_fops);
+                if (!file)
+                        goto err;
+                file = debugfs_create_file("batctrl_and_ibat",
+                        (S_IRUGO | S_IWUGO), ab8500_gpadc_dir,
+                        &plf->dev, &ab8540_gpadc_bat_ctrl_and_ibat_fops);
+                if (!file)
+                        goto err;
+                file = debugfs_create_file("vbatmeas_and_ibat",
+                        (S_IRUGO | S_IWUGO), ab8500_gpadc_dir,
+                        &plf->dev,
+                        &ab8540_gpadc_vbat_meas_and_ibat_fops);
+                if (!file)
+                        goto err;
+                file = debugfs_create_file("vbattruemeas_and_ibat",
+                        (S_IRUGO | S_IWUGO), ab8500_gpadc_dir,
+                        &plf->dev,
+                        &ab8540_gpadc_vbat_true_meas_and_ibat_fops);
+                if (!file)
+                        goto err;
+                file = debugfs_create_file("battemp_and_ibat",
+                        (S_IRUGO | S_IWUGO), ab8500_gpadc_dir,
+                        &plf->dev, &ab8540_gpadc_bat_temp_and_ibat_fops);
+                if (!file)
+                        goto err;
+                file = debugfs_create_file("otp_calib", (S_IRUGO | S_IWUSR | S_IWGRP),
+                        ab8500_gpadc_dir, &plf->dev, &ab8540_gpadc_otp_calib_fops);
+                if (!file)
+                        goto err;
+        }
+        file = debugfs_create_file("avg_sample", (S_IRUGO | S_IWUSR | S_IWGRP),
+                ab8500_gpadc_dir, &plf->dev, &ab8500_gpadc_avg_sample_fops);
         if (!file)
                 goto err;
 
-        file = debugfs_create_file("usb_charger_c", (S_IRUGO | S_IWUSR),
-            ab8500_gpadc_dir, &plf->dev, &ab8500_gpadc_usb_charger_c_fops);
+        file = debugfs_create_file("trig_edge", (S_IRUGO | S_IWUSR | S_IWGRP),
+                ab8500_gpadc_dir, &plf->dev, &ab8500_gpadc_trig_edge_fops);
         if (!file)
                 goto err;
 
-        file = debugfs_create_file("bk_bat_v", (S_IRUGO | S_IWUSR),
-            ab8500_gpadc_dir, &plf->dev, &ab8500_gpadc_bk_bat_v_fops);
+        file = debugfs_create_file("trig_timer", (S_IRUGO | S_IWUSR | S_IWGRP),
+                ab8500_gpadc_dir, &plf->dev, &ab8500_gpadc_trig_timer_fops);
         if (!file)
                 goto err;
 
-        file = debugfs_create_file("die_temp", (S_IRUGO | S_IWUSR),
-            ab8500_gpadc_dir, &plf->dev, &ab8500_gpadc_die_temp_fops);
+        file = debugfs_create_file("conv_type", (S_IRUGO | S_IWUSR | S_IWGRP),
+                ab8500_gpadc_dir, &plf->dev, &ab8500_gpadc_conv_type_fops);
         if (!file)
                 goto err;