drivers/mfd/rk610-core.c

   1 #include <linux/module.h>
   2 #include <linux/init.h>
   3 #include <linux/i2c.h>
   4 #include <linux/device.h>
   5 #include <linux/delay.h>
   6 #include <asm/gpio.h>
   7 #include <linux/mfd/core.h>
   8 #include <linux/mfd/rk610_core.h>
   9 #include <linux/clk.h>
  10 #include <linux/gpio.h>
  11 #include <linux/err.h>
  12 #include <linux/slab.h>
  13 #include <linux/of.h>
  14 #include <linux/of_gpio.h>
  15
  16 #if defined(CONFIG_DEBUG_FS)
  17 #include <linux/fs.h>
  18 #include <linux/debugfs.h>
  19 #include <linux/seq_file.h>
  20 #include <linux/uaccess.h>
  21 #endif
  22
  23 #define GPIO_HIGH 1
  24 #define GPIO_LOW 0
  25
  26 /*
  27  * Debug
  28  */
  29 #if 0
  30 #define DBG(x...)       printk(KERN_INFO x)
  31 #else
  32 #define DBG(x...)
  33 #endif
  34
  35 static struct i2c_client *rk610_control_client = NULL;
  36
  37 int i2c_master_reg8_send(const struct i2c_client *client, const char reg, const char *buf, int count, int scl_rate)
  38 {
  39         struct i2c_adapter *adap=client->adapter;
  40         struct i2c_msg msg;
  41         int ret;
  42         char *tx_buf = (char *)kmalloc(count + 1, GFP_KERNEL);
  43         if(!tx_buf)
  44                 return -ENOMEM;
  45         tx_buf[0] = reg;
  46         memcpy(tx_buf+1, buf, count);
  47
  48         msg.addr = client->addr;
  49         msg.flags = client->flags;
  50         msg.len = count + 1;
  51         msg.buf = (char *)tx_buf;
  52         msg.scl_rate = scl_rate;
  53 //      msg.udelay = client->udelay;
  54
  55         ret = i2c_transfer(adap, &msg, 1);
  56         kfree(tx_buf);
  57         return (ret == 1) ? count : ret;
  58
  59 }
  60
  61 int i2c_master_reg8_recv(const struct i2c_client *client, const char reg, char *buf, int count, int scl_rate)
  62 {
  63         struct i2c_adapter *adap=client->adapter;
  64         struct i2c_msg msgs[2];
  65         int ret;
  66         char reg_buf = reg;
  67
  68         msgs[0].addr = client->addr;
  69         msgs[0].flags = client->flags;
  70         msgs[0].len = 1;
  71         msgs[0].buf = &reg_buf;
  72         msgs[0].scl_rate = scl_rate;
  73 //      msgs[0].udelay = client->udelay;
  74
  75         msgs[1].addr = client->addr;
  76         msgs[1].flags = client->flags | I2C_M_RD;
  77         msgs[1].len = count;
  78         msgs[1].buf = (char *)buf;
  79         msgs[1].scl_rate = scl_rate;
  80 //      msgs[1].udelay = client->udelay;
  81
  82         ret = i2c_transfer(adap, msgs, 2);
  83
  84         return (ret == 2)? count : ret;
  85 }
  86
  87
  88 static struct mfd_cell rk610_devs[] = {
  89         {
  90                 .name = "rk610-lcd",
  91                 .id = 0,
  92         },
  93 };
  94
  95 int rk610_control_send_byte(const char reg, const char data)
  96 {
  97         int ret;
  98
  99         DBG("reg = 0x%02x, val=0x%02x\n", reg ,data);
 100
 101         if(rk610_control_client == NULL)
 102                 return -1;
 103         //i2c_master_reg8_send
 104         ret = i2c_master_reg8_send(rk610_control_client, reg, &data, 1, 100*1000);
 105         if (ret > 0)
 106                 ret = 0;
 107
 108         return ret;
 109 }
 110
 111 #ifdef CONFIG_SND_SOC_RK610
 112 static unsigned int current_pll_value = 0;
 113 int rk610_codec_pll_set(unsigned int rate)
 114 {
 115         char N, M, NO, DIV;
 116         unsigned int F;
 117         char data;
 118
 119         if(current_pll_value == rate)
 120                 return 0;
 121
 122     // Input clock is 12MHz.
 123         if(rate == 11289600) {
 124                 // For 11.2896MHz, N = 2 M= 75 F = 0.264(0x43958) NO = 8
 125                 N = 2;
 126                 NO = 3;
 127                 M = 75;
 128                 F = 0x43958;
 129                 DIV = 5;
 130         }
 131         else if(rate == 12288000) {
 132                 // For 12.2888MHz, N = 2 M= 75 F = 0.92(0xEB851) NO = 8
 133                 N = 2;
 134                 NO = 3;
 135                 M = 75;
 136                 F = 0xEB851;
 137                 DIV = 5;
 138         }
 139         else {
 140                 printk(KERN_ERR "[%s] not support such frequency\n", __FUNCTION__);
 141                 return -1;
 142         }
 143
 144         //Enable codec pll fractional number and power down.
 145     data = 0x00;
 146     rk610_control_send_byte(RK610_CONTROL_REG_C_PLL_CON5, data);
 147         msleep(10);
 148
 149     data = (N << 4) | NO;
 150     rk610_control_send_byte(RK610_CONTROL_REG_C_PLL_CON0, data);
 151     // M
 152     data = M;
 153     rk610_control_send_byte(RK610_CONTROL_REG_C_PLL_CON1, data);
 154     // F
 155     data = F & 0xFF;
 156     rk610_control_send_byte(RK610_CONTROL_REG_C_PLL_CON2, data);
 157     data = (F >> 8) & 0xFF;
 158     rk610_control_send_byte(RK610_CONTROL_REG_C_PLL_CON3, data);
 159     data = (F >> 16) & 0xFF;
 160     rk610_control_send_byte(RK610_CONTROL_REG_C_PLL_CON4, data);
 161
 162     // i2s mclk = codec_pll/5;
 163     i2c_master_reg8_recv(rk610_control_client, RK610_CONTROL_REG_CLOCK_CON1, &data, 1, 100*1000);
 164     data &= ~CLOCK_CON1_I2S_DVIDER_MASK;
 165     data |= (DIV - 1);
 166     rk610_control_send_byte(RK610_CONTROL_REG_CLOCK_CON1, data);
 167
 168     // Power up codec pll.
 169     data |= C_PLL_POWER_ON;
 170     rk610_control_send_byte(RK610_CONTROL_REG_C_PLL_CON5, data);
 171
 172     current_pll_value = rate;
 173     DBG("[%s] rate %u\n", __FUNCTION__, rate);
 174
 175     return 0;
 176 }
 177
 178 void rk610_control_init_codec(void)
 179 {
 180     struct i2c_client *client = rk610_control_client;
 181     char data = 0;
 182     int ret;
 183
 184     if(rk610_control_client == NULL)
 185         return;
 186         DBG("[%s] start\n", __FUNCTION__);
 187
 188     //gpio_set_value(RK610_RESET_PIN, GPIO_LOW); //reset rk601
 189    // mdelay(100);
 190     //gpio_set_value(RK610_RESET_PIN, GPIO_HIGH);
 191     //mdelay(100);
 192
 193         // Set i2c glitch timeout.
 194         data = 0x22;
 195         ret = i2c_master_reg8_send(client, RK610_CONTROL_REG_I2C_CON, &data, 1, 20*1000);
 196
 197 //    rk610_codec_pll_set(11289600);
 198
 199     //use internal codec, enable DAC ADC LRCK output.
 200 //    i2c_master_reg8_recv(client, RK610_CONTROL_REG_CODEC_CON, &data, 1, 100*1000);
 201 //    data = CODEC_CON_BIT_DAC_LRCL_OUTPUT_DISABLE | CODEC_CON_BIT_ADC_LRCK_OUTPUT_DISABLE;
 202 //      data = CODEC_CON_BIT_ADC_LRCK_OUTPUT_DISABLE;
 203         data = 0;
 204         rk610_control_send_byte(RK610_CONTROL_REG_CODEC_CON, data);
 205
 206     // Select internal i2s clock from codec_pll.
 207     i2c_master_reg8_recv(rk610_control_client, RK610_CONTROL_REG_CLOCK_CON1, &data, 1, 100*1000);
 208 //    data |= CLOCK_CON1_I2S_CLK_CODEC_PLL;
 209         data = 0;
 210     rk610_control_send_byte(RK610_CONTROL_REG_CLOCK_CON1, data);
 211
 212     i2c_master_reg8_recv(client, RK610_CONTROL_REG_CODEC_CON, &data, 1, 100*1000);
 213     DBG("[%s] RK610_CONTROL_REG_CODEC_CON is %x\n", __FUNCTION__, data);
 214
 215     i2c_master_reg8_recv(client, RK610_CONTROL_REG_CLOCK_CON1, &data, 1, 100*1000);
 216     DBG("[%s] RK610_CONTROL_REG_CLOCK_CON1 is %x\n", __FUNCTION__, data);
 217 }
 218 #endif
 219
 220 static int rk610_read_p0_reg(struct i2c_client *client, char reg, char *val)
 221 {
 222         return i2c_master_reg8_recv(client, reg, val, 1, 100*1000) > 0? 0: -EINVAL;
 223 }
 224
 225 static int rk610_write_p0_reg(struct i2c_client *client, char reg, char *val)
 226 {
 227         return i2c_master_reg8_send(client, reg, val, 1, 100*1000) > 0? 0: -EINVAL;
 228 }
 229
 230
 231 #if defined(CONFIG_DEBUG_FS)
 232 static int rk610_reg_show(struct seq_file *s, void *v)
 233 {
 234         char reg = 0;
 235         u8 val = 0;
 236         struct rk610_core_info *core_info = s->private;
 237         if(!core_info)
 238         {
 239                 dev_err(core_info->dev,"no mfd rk610!\n");
 240                 return 0;
 241         }
 242
 243         for(reg=C_PLL_CON0;reg<= I2C_CON;reg++)
 244         {
 245                 rk610_read_p0_reg(core_info->client, reg,  &val);
 246                 if(reg%8==0)
 247                         seq_printf(s,"\n0x%02x:",reg);
 248                 seq_printf(s," %02x",val);
 249         }
 250         seq_printf(s,"\n");
 251
 252         return 0;
 253 }
 254
 255 static ssize_t rk610_reg_write (struct file *file, const char __user *buf, size_t count, loff_t *ppos)
 256 {
 257         struct rk610_core_info *core_info = file->f_path.dentry->d_inode->i_private;
 258         u32 reg,val;
 259
 260         char kbuf[25];
 261         if (copy_from_user(kbuf, buf, count))
 262                 return -EFAULT;
 263         sscanf(kbuf, "%x%x", &reg,&val);
 264         rk610_write_p0_reg(core_info->client, reg,  (u8*)&val);
 265         return count;
 266 }
 267
 268 static int rk610_reg_open(struct inode *inode, struct file *file)
 269 {
 270         struct rk610_core_info *core_info = inode->i_private;
 271         return single_open(file,rk610_reg_show,core_info);
 272 }
 273
 274 static const struct file_operations rk610_reg_fops = {
 275         .owner          = THIS_MODULE,
 276         .open           = rk610_reg_open,
 277         .read           = seq_read,
 278         .write          = rk610_reg_write,
 279         .llseek         = seq_lseek,
 280         .release        = single_release,
 281 };
 282 #endif
 283
 284 static int rk610_control_probe(struct i2c_client *client,
 285                         const struct i2c_device_id *id)
 286 {
 287         int ret;
 288         struct rk610_core_info *core_info = NULL;
 289         struct device_node *rk610_np;
 290
 291         DBG("[%s] start\n", __FUNCTION__);
 292         core_info = kmalloc(sizeof(struct rk610_core_info), GFP_KERNEL);
 293         if(!core_info)
 294         {
 295                 dev_err(&client->dev, ">> rk610 core inf kmalloc fail!");
 296                 return -ENOMEM;
 297         }
 298         memset(core_info, 0, sizeof(struct rk610_core_info));
 299
 300         rk610_control_client = client;
 301
 302         core_info->client = client;
 303         core_info->dev = &client->dev;
 304         i2c_set_clientdata(client,core_info);
 305
 306         rk610_np = core_info->dev->of_node;
 307         core_info->reset_gpio = of_get_named_gpio(rk610_np,"rk610-reset-io", 0);
 308         if (!gpio_is_valid(core_info->reset_gpio)){
 309                 printk("invalid core_info->reset_gpio: %d\n",core_info->reset_gpio);
 310                 return -1;
 311         }
 312         ret = gpio_request(core_info->reset_gpio, "rk610-reset-io");
 313         if( ret != 0){
 314                 printk("gpio_request core_info->reset_gpio invalid: %d\n",core_info->reset_gpio);
 315                 return ret;
 316         }
 317         gpio_direction_output(core_info->reset_gpio, GPIO_HIGH);
 318         msleep(100);
 319         gpio_direction_output(core_info->reset_gpio, GPIO_LOW);
 320         msleep(100);
 321         gpio_set_value(core_info->reset_gpio, GPIO_HIGH);
 322
 323         core_info->i2s_clk= clk_get(&client->dev, "i2s_clk");
 324         if (IS_ERR(core_info->i2s_clk)) {
 325                 dev_err(&client->dev, "Can't retrieve i2s clock\n");
 326                 ret = PTR_ERR(core_info->i2s_clk);
 327                 return ret;
 328         }
 329         clk_set_rate(core_info->i2s_clk, 11289600);
 330         clk_prepare_enable(core_info->i2s_clk);
 331
 332         ret = mfd_add_devices(&client->dev, -1,
 333                                       rk610_devs, ARRAY_SIZE(rk610_devs),
 334                                       NULL,0,NULL);
 335
 336 #if defined(CONFIG_DEBUG_FS)
 337         core_info->debugfs_dir = debugfs_create_dir("rk610", NULL);
 338         if (IS_ERR(core_info->debugfs_dir))
 339         {
 340                 dev_err(&client->dev,"failed to create debugfs dir for rk610!\n");
 341         }
 342         else
 343                 debugfs_create_file("core", S_IRUSR,core_info->debugfs_dir,core_info,&rk610_reg_fops);
 344 #endif
 345
 346     return 0;
 347 }
 348
 349 static int rk610_control_remove(struct i2c_client *client)
 350 {
 351         return 0;
 352 }
 353
 354 static const struct i2c_device_id rk610_control_id[] = {
 355         { "rk610_ctl", 0 },
 356         { }
 357 };
 358 MODULE_DEVICE_TABLE(i2c, rk610_control_id);
 359
 360 static struct i2c_driver rk610_control_driver = {
 361         .driver = {
 362                 .name = "rk610_ctl",
 363         },
 364         .probe = rk610_control_probe,
 365         .remove = rk610_control_remove,
 366         .id_table = rk610_control_id,
 367 };
 368
 369 static int __init rk610_control_init(void)
 370 {
 371         return i2c_add_driver(&rk610_control_driver);
 372 }
 373
 374 static void __exit rk610_control_exit(void)
 375 {
 376         i2c_del_driver(&rk610_control_driver);
 377 }
 378
 379 subsys_initcall_sync(rk610_control_init);
 380 module_exit(rk610_control_exit);
 381
 382
 383 MODULE_DESCRIPTION("RK610 control driver");
 384 MODULE_AUTHOR("Rock-chips, <www.rock-chips.com>");
 385 MODULE_LICENSE("GPL");
 386