drivers/mfd/rt5025-debug.c

   1 /*
   2  *  drivers/mfd/rt5025-debug.c
   3  *  Driver foo Richtek RT5025 PMIC Debug
   4  *
   5  *  Copyright (C) 2013 Richtek Technologh 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/i2c.h>
  18 #include <linux/platform_device.h>
  19 #include <linux/debugfs.h>
  20 #include <linux/uaccess.h>
  21
  22 #include <linux/mfd/rt5025.h>
  23
  24 struct rt5025_debug_info {
  25         struct i2c_client *i2c;
  26         struct device *dev;
  27         unsigned char reg_addr;
  28         unsigned char reg_data;
  29 };
  30
  31 struct rt_debug_st {
  32         void *info;
  33         int id;
  34 };
  35
  36 enum {
  37         RT5025_DBG_REG,
  38         RT5025_DBG_DATA,
  39         RT5025_DBG_REGS,
  40         RT5025_DBG_MAX
  41 };
  42
  43 static struct dentry *debugfs_rt_dent;
  44 static struct dentry *debugfs_file[RT5025_DBG_MAX];
  45 static struct rt_debug_st rtdbg_data[RT5025_DBG_MAX];
  46
  47 static int reg_debug_open(struct inode *inode, struct file *file)
  48 {
  49         file->private_data = inode->i_private;
  50         return 0;
  51 }
  52
  53 static int get_parameters(char *buf, long int *param1, int num_of_par)
  54 {
  55         char *token;
  56         int base, cnt;
  57
  58         token = strsep(&buf, " ");
  59
  60         for (cnt = 0; cnt < num_of_par; cnt++) {
  61                 if (token != NULL) {
  62                         if ((token[1] == 'x') || (token[1] == 'X'))
  63                                 base = 16;
  64                         else
  65                                 base = 10;
  66
  67                         if (strict_strtoul(token, base, &param1[cnt]) != 0)
  68                                 return -EINVAL;
  69
  70                         token = strsep(&buf, " ");
  71                 } else {
  72                         return -EINVAL;
  73                 }
  74         }
  75         return 0;
  76 }
  77
  78 static ssize_t reg_debug_read(struct file *filp, char __user *ubuf,
  79                                 size_t count, loff_t *ppos)
  80 {
  81         struct rt_debug_st *st = filp->private_data;
  82         struct rt5025_debug_info *di = st->info;
  83         char lbuf[1000];
  84         int i = 0, j = 0;
  85
  86         lbuf[0] = '\0';
  87         switch (st->id) {
  88         case RT5025_DBG_REG:
  89                 snprintf(lbuf, sizeof(lbuf), "0x%x\n", di->reg_addr);
  90                 break;
  91         case RT5025_DBG_DATA:
  92                 di->reg_data = (unsigned char)rt5025_reg_read(di->i2c,
  93                         di->reg_addr);
  94                 snprintf(lbuf, sizeof(lbuf), "0x%x\n", di->reg_data);
  95                 break;
  96         case RT5025_DBG_REGS:
  97                 for (i = RT5025_REG_RANGE1START;
  98                         i <= RT5025_REG_RANGE1END; i++)
  99                         j += sprintf(lbuf+j, "0x%02x:%02x\n", i, \
 100                                 rt5025_reg_read(di->i2c, i));
 101                 for (i = RT5025_REG_RANGE2START;
 102                         i <= RT5025_REG_RANGE2END; i++)
 103                         j += sprintf(lbuf+j, "0x%02x:%02x\n", i, \
 104                                 rt5025_reg_read(di->i2c, i));
 105                 for (i = RT5025_REG_RANGE3START;
 106                         i <= RT5025_REG_RANGE3END; i++)
 107                         j += sprintf(lbuf+j, "0x%02x:%02x\n", i, \
 108                                 rt5025_reg_read(di->i2c, i));
 109                 for (i = RT5025_REG_RANGE4START;
 110                         i <= RT5025_REG_RANGE4END; i++)
 111                         j += sprintf(lbuf+j, "0x%02x:%02x\n", i, \
 112                                 rt5025_reg_read(di->i2c, i));
 113                 break;
 114         default:
 115                 return -EINVAL;
 116         }
 117         return simple_read_from_buffer(ubuf, count, ppos, lbuf, strlen(lbuf));
 118 }
 119
 120 static ssize_t reg_debug_write(struct file *filp,
 121         const char __user *ubuf, size_t cnt, loff_t *ppos)
 122 {
 123         struct rt_debug_st *st = filp->private_data;
 124         struct rt5025_debug_info *di = st->info;
 125         char lbuf[32];
 126         int rc;
 127         long int param[5];
 128
 129         if (cnt > sizeof(lbuf) - 1)
 130                 return -EINVAL;
 131
 132         rc = copy_from_user(lbuf, ubuf, cnt);
 133         if (rc)
 134                 return -EFAULT;
 135
 136         lbuf[cnt] = '\0';
 137
 138         switch (st->id) {
 139         case RT5025_DBG_REG:
 140                 rc = get_parameters(lbuf, param, 1);
 141                 if ((param[0] < RT5025_REG_MAX) && (rc == 0)) {
 142                         if ((param[0] >= RT5025_REG_RANGE1START && param[0]
 143                                 <= RT5025_REG_RANGE1END) || \
 144                                 (param[0] >= RT5025_REG_RANGE2START && param[0]
 145                                 <= RT5025_REG_RANGE2END) || \
 146                                 (param[0] >= RT5025_REG_RANGE3START && param[0]
 147                                 <= RT5025_REG_RANGE3END) || \
 148                                 (param[0] >= RT5025_REG_RANGE4START && param[0]
 149                                 <= RT5025_REG_RANGE4END))
 150                                 di->reg_addr = (unsigned char)param[0];
 151                         else
 152                                 rc = -EINVAL;
 153                 } else {
 154                                 rc = -EINVAL;
 155                 }
 156                 break;
 157         case RT5025_DBG_DATA:
 158                 rc = get_parameters(lbuf, param, 1);
 159                 if ((param[0] <= 0xff) && (rc == 0))
 160                         rt5025_reg_write(di->i2c, di->reg_addr, param[0]);
 161                 else
 162                         rc = -EINVAL;
 163                 break;
 164         default:
 165                 return -EINVAL;
 166         }
 167         if (rc == 0)
 168                 rc = cnt;
 169         return rc;
 170 }
 171
 172 static const struct file_operations reg_debug_ops = {
 173         .open = reg_debug_open,
 174         .write = reg_debug_write,
 175         .read = reg_debug_read
 176 };
 177
 178 static int rt5025_debug_probe(struct platform_device *pdev)
 179 {
 180         struct rt5025_chip *chip = dev_get_drvdata(pdev->dev.parent);
 181         struct rt5025_debug_info *di;
 182         int ret = 0;
 183
 184         di = devm_kzalloc(&pdev->dev, sizeof(*di), GFP_KERNEL);
 185         if (!di)
 186                 return -ENOMEM;
 187
 188         di->i2c = chip->i2c;
 189         di->dev = &pdev->dev;
 190
 191         RTINFO("add debugfs for RT5025");
 192         debugfs_rt_dent = debugfs_create_dir("rt5025_dbg", 0);
 193         if (!IS_ERR(debugfs_rt_dent)) {
 194                 rtdbg_data[0].info = di;
 195                 rtdbg_data[0].id = RT5025_DBG_REG;
 196                 debugfs_file[0] = debugfs_create_file("reg",
 197                 S_IFREG | S_IRUGO, debugfs_rt_dent,
 198                 (void *) &rtdbg_data[0], &reg_debug_ops);
 199
 200                 rtdbg_data[1].info = di;
 201                 rtdbg_data[1].id = RT5025_DBG_DATA;
 202                 debugfs_file[1] = debugfs_create_file("data",
 203                 S_IFREG | S_IRUGO, debugfs_rt_dent,
 204                 (void *) &rtdbg_data[1], &reg_debug_ops);
 205
 206                 rtdbg_data[2].info = di;
 207                 rtdbg_data[2].id = RT5025_DBG_REGS;
 208                 debugfs_file[2] = debugfs_create_file("regs",
 209                 S_IFREG | S_IRUGO, debugfs_rt_dent,
 210                 (void *) &rtdbg_data[2], &reg_debug_ops);
 211         } else {
 212                 dev_err(&pdev->dev, "create debugfs failed\n");
 213                 ret = -EINVAL;
 214                 goto err_init;
 215         }
 216         platform_set_drvdata(pdev, di);
 217         return 0;
 218 err_init:
 219         return ret;
 220 }
 221
 222 static int rt5025_debug_remove(struct platform_device *pdev)
 223 {
 224         if (!IS_ERR(debugfs_rt_dent))
 225                 debugfs_remove_recursive(debugfs_rt_dent);
 226         return 0;
 227 }
 228
 229 static const struct of_device_id rt_match_table[] = {
 230         { .compatible = "rt,rt5025-debug",},
 231         {},
 232 };
 233
 234 static struct platform_driver rt5025_debug_driver = {
 235         .driver = {
 236                 .name = RT5025_DEV_NAME "-debug",
 237                 .owner = THIS_MODULE,
 238                 .of_match_table = rt_match_table,
 239         },
 240         .probe = rt5025_debug_probe,
 241         .remove = rt5025_debug_remove,
 242 };
 243
 244 static int rt5025_debug_init(void)
 245 {
 246         return platform_driver_register(&rt5025_debug_driver);
 247 }
 248 module_init(rt5025_debug_init);
 249
 250 static void rt5025_debug_exit(void)
 251 {
 252         platform_driver_unregister(&rt5025_debug_driver);
 253 }
 254 module_exit(rt5025_debug_exit);
 255 MODULE_AUTHOR("CY Huang <cy_huang@richtek.com");
 256 MODULE_DESCRIPTION("Debug driver for RT5025");
 257 MODULE_ALIAS("platform:" RT5025_DEV_NAME "-debug");
 258 MODULE_VERSION(RT5025_DRV_VER);