drivers/mfd/rt5036-debug.c

   1 /*
   2  *  drivers/mfd/rt5036-debug.c
   3  *  Driver for Richtek RT5036 PMIC debug
   4  *
   5  *  Copyright (C) 2014 Richtek Technology Corp.
   6  *  cy_huang <cy_huang@richtek.com>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 as
  10  * published by the Free Software Foundation; either version 2
  11  * of the License, or (at your option) any later version.
  12  */
  13
  14 #include <linux/module.h>
  15 #include <linux/kernel.h>
  16 #include <linux/err.h>
  17 #include <linux/platform_device.h>
  18 #include <linux/i2c.h>
  19 #include <linux/debugfs.h>
  20 #include <linux/uaccess.h>
  21
  22 #include <linux/mfd/rt5036/rt5036.h>
  23
  24 struct rt5036_debug_info {
  25         struct i2c_client *i2c;
  26         unsigned char reg_addr;
  27         unsigned char reg_data;
  28 };
  29
  30 struct rt_debug_st {
  31         void *info;
  32         int id;
  33 };
  34
  35 enum {
  36         RT5036_DBG_REG,
  37         RT5036_DBG_DATA,
  38         RT5036_DBG_REGS,
  39         RT5036_DBG_MAX
  40 };
  41
  42 static struct dentry *debugfs_rt_dent;
  43 static struct dentry *debugfs_file[RT5036_DBG_MAX];
  44 static struct rt_debug_st rtdbg_data[RT5036_DBG_MAX];
  45
  46 static int reg_debug_open(struct inode *inode, struct file *file)
  47 {
  48         file->private_data = inode->i_private;
  49         return 0;
  50 }
  51
  52 static int get_parameters(char *buf, long int *param1, int num_of_par)
  53 {
  54         char *token;
  55         int base, cnt;
  56
  57         token = strsep(&buf, " ");
  58
  59         for (cnt = 0; cnt < num_of_par; cnt++) {
  60                 if (token != NULL) {
  61                         if ((token[1] == 'x') || (token[1] == 'X'))
  62                                 base = 16;
  63                         else
  64                                 base = 10;
  65
  66                         if (kstrtoul(token, base, &param1[cnt]) != 0)
  67                                 return -EINVAL;
  68
  69                         token = strsep(&buf, " ");
  70                 } else {
  71                         return -EINVAL;
  72                 }
  73         }
  74         return 0;
  75 }
  76
  77 static ssize_t reg_debug_read(struct file *filp, char __user *ubuf,
  78                               size_t count, loff_t *ppos)
  79 {
  80         struct rt_debug_st *st = filp->private_data;
  81         struct rt5036_debug_info *di = st->info;
  82         char lbuf[1000];
  83         int i = 0, j = 0;
  84
  85         lbuf[0] = '\0';
  86         switch (st->id) {
  87         case RT5036_DBG_REG:
  88                 snprintf(lbuf, sizeof(lbuf), "0x%x\n", di->reg_addr);
  89                 break;
  90         case RT5036_DBG_DATA:
  91                 di->reg_data =
  92                     (unsigned char)rt5036_reg_read(di->i2c, di->reg_addr);
  93                 snprintf(lbuf, sizeof(lbuf), "0x%x\n", di->reg_data);
  94                 break;
  95         case RT5036_DBG_REGS:
  96                 for (i = RT5036_REG_RANGE1START; i <= RT5036_REG_RANGE1END; i++)
  97                         j += sprintf(lbuf + j, "reg_%02x:%02x\n", i,
  98                                      rt5036_reg_read(di->i2c, i));
  99                 for (i = RT5036_REG_RANGE2START; i <= RT5036_REG_RANGE2END; i++)
 100                         j += sprintf(lbuf + j, "reg_%02x:%02x\n", i,
 101                                      rt5036_reg_read(di->i2c, i));
 102                 for (i = RT5036_REG_RANGE3START; i <= RT5036_REG_RANGE3END; i++)
 103                         j += sprintf(lbuf + j, "reg_%02x:%02x\n", i,
 104                                      rt5036_reg_read(di->i2c, i));
 105                 for (i = RT5036_REG_RANGE4START; i <= RT5036_REG_RANGE4END; i++)
 106                         j += sprintf(lbuf + j, "reg_%02x:%02x\n", i,
 107                                      rt5036_reg_read(di->i2c, i));
 108                 for (i = RT5036_REG_RANGE5START; i <= RT5036_REG_RANGE5END; i++)
 109                         j += sprintf(lbuf + j, "reg_%02x:%02x\n", i,
 110                                      rt5036_reg_read(di->i2c, i));
 111                 for (i = RT5036_REG_RANGE6START; i <= RT5036_REG_RANGE6END; i++)
 112                         j += sprintf(lbuf + j, "reg_%02x:%02x\n", i,
 113                                      rt5036_reg_read(di->i2c, i));
 114                 break;
 115         default:
 116                 return -EINVAL;
 117         }
 118         return simple_read_from_buffer(ubuf, count, ppos, lbuf, strlen(lbuf));
 119 }
 120
 121 static ssize_t reg_debug_write(struct file *filp,
 122                                const char __user *ubuf, size_t cnt,
 123                                loff_t *ppos)
 124 {
 125         struct rt_debug_st *st = filp->private_data;
 126         struct rt5036_debug_info *di = st->info;
 127         char lbuf[32];
 128         int rc;
 129         long int param[5];
 130
 131         if (cnt > sizeof(lbuf) - 1)
 132                 return -EINVAL;
 133
 134         rc = copy_from_user(lbuf, ubuf, cnt);
 135         if (rc)
 136                 return -EFAULT;
 137
 138         lbuf[cnt] = '\0';
 139
 140         switch (st->id) {
 141         case RT5036_DBG_REG:
 142                 rc = get_parameters(lbuf, param, 1);
 143                 if ((param[0] < RT5036_REG_MAX) && (rc == 0)) {
 144                         if ((param[0] >= RT5036_REG_RANGE1START
 145                              && param[0] <= RT5036_REG_RANGE1END)
 146                             || (param[0] >= RT5036_REG_RANGE2START
 147                                 && param[0] <= RT5036_REG_RANGE2END)
 148                             || (param[0] >= RT5036_REG_RANGE3START
 149                                 && param[0] <= RT5036_REG_RANGE3END)
 150                             || (param[0] >= RT5036_REG_RANGE4START
 151                                 && param[0] <= RT5036_REG_RANGE4END)
 152                             || (param[0] >= RT5036_REG_RANGE5START
 153                                 && param[0] <= RT5036_REG_RANGE5END))
 154                                 di->reg_addr = (unsigned char)param[0];
 155                         else
 156                                 rc = -EINVAL;
 157                 } else
 158                         rc = -EINVAL;
 159                 break;
 160         case RT5036_DBG_DATA:
 161                 rc = get_parameters(lbuf, param, 1);
 162                 if ((param[0] <= 0xff) && (rc == 0))
 163                         rt5036_reg_write(di->i2c, di->reg_addr, param[0]);
 164                 else
 165                         rc = -EINVAL;
 166                 break;
 167         default:
 168                 return -EINVAL;
 169         }
 170         if (rc == 0)
 171                 rc = cnt;
 172         return rc;
 173 }
 174
 175 static const struct file_operations reg_debug_ops = {
 176         .open = reg_debug_open,
 177         .write = reg_debug_write,
 178         .read = reg_debug_read
 179 };
 180
 181 static int rt5036_debug_probe(struct platform_device *pdev)
 182 {
 183         struct rt5036_chip *chip = dev_get_drvdata(pdev->dev.parent);
 184         struct rt5036_debug_info *di;
 185
 186         di = devm_kzalloc(&pdev->dev, sizeof(*di), GFP_KERNEL);
 187         if (!di)
 188                 return -ENOMEM;
 189
 190         di->i2c = chip->i2c;
 191
 192         RTINFO("add debugfs for RT5036");
 193         debugfs_rt_dent = debugfs_create_dir("rt5036_dbg", 0);
 194         if (!IS_ERR(debugfs_rt_dent)) {
 195                 rtdbg_data[0].info = di;
 196                 rtdbg_data[0].id = RT5036_DBG_REG;
 197                 debugfs_file[0] = debugfs_create_file("reg",
 198                                                       S_IFREG | S_IRUGO,
 199                                                       debugfs_rt_dent,
 200                                                       (void *)&rtdbg_data[0],
 201                                                       &reg_debug_ops);
 202
 203                 rtdbg_data[1].info = di;
 204                 rtdbg_data[1].id = RT5036_DBG_DATA;
 205                 debugfs_file[1] = debugfs_create_file("data",
 206                                                       S_IFREG | S_IRUGO,
 207                                                       debugfs_rt_dent,
 208                                                       (void *)&rtdbg_data[1],
 209                                                       &reg_debug_ops);
 210
 211                 rtdbg_data[2].info = di;
 212                 rtdbg_data[2].id = RT5036_DBG_REGS;
 213                 debugfs_file[2] = debugfs_create_file("regs",
 214                                                       S_IFREG | S_IRUGO,
 215                                                       debugfs_rt_dent,
 216                                                       (void *)&rtdbg_data[2],
 217                                                       &reg_debug_ops);
 218         }
 219         platform_set_drvdata(pdev, di);
 220         return 0;
 221 }
 222
 223 static int rt5036_debug_remove(struct platform_device *pdev)
 224 {
 225         if (!IS_ERR(debugfs_rt_dent))
 226                 debugfs_remove_recursive(debugfs_rt_dent);
 227         return 0;
 228 }
 229
 230 static const struct of_device_id rt_match_table[] = {
 231         {.compatible = "rt,rt5036-debug",},
 232         {},
 233 };
 234
 235 static struct platform_driver rt5036_debug_driver = {
 236         .driver = {
 237                    .name = RT5036_DEV_NAME "-debug",
 238                    .owner = THIS_MODULE,
 239                    .of_match_table = rt_match_table,
 240                    },
 241         .probe = rt5036_debug_probe,
 242         .remove = rt5036_debug_remove,
 243 };
 244
 245 static int __init rt5036_debug_init(void)
 246 {
 247         return platform_driver_register(&rt5036_debug_driver);
 248 }
 249 module_init(rt5036_debug_init);
 250
 251 static void __exit rt5036_debug_exit(void)
 252 {
 253         platform_driver_unregister(&rt5036_debug_driver);
 254 }
 255 module_exit(rt5036_debug_exit);
 256
 257 MODULE_LICENSE("GPL");
 258 MODULE_AUTHOR("CY Huang <cy_huang@richtek.com");
 259 MODULE_DESCRIPTION("Debugfs driver for RT5036");
 260 MODULE_ALIAS("platform:" RT5036_DEV_NAME "-debug");
 261 MODULE_VERSION(RT5036_DRV_VER);