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/rk610_core.h>
   8 #include <linux/clk.h>
   9 #include <mach/iomux.h>
  10 #include <linux/err.h>
  11 #include <linux/slab.h>
  12
  13 #if defined(CONFIG_ARCH_RK3066B)
  14 #define RK610_RESET_PIN   RK30_PIN2_PC5
  15 #elif defined(CONFIG_ARCH_RK30)
  16 #define RK610_RESET_PIN   RK30_PIN0_PC6
  17 #else
  18 #define RK610_RESET_PIN   RK29_PIN6_PC1
  19 #endif
  20
  21 /*
  22  * Debug
  23  */
  24 #if 0
  25 #define DBG(x...)       printk(KERN_INFO x)
  26 #else
  27 #define DBG(x...)
  28 #endif
  29
  30 static struct i2c_client *rk610_control_client = NULL;
  31 #ifdef CONFIG_RK610_LVDS
  32 extern int rk610_lcd_init(struct rk610_core_info *rk610_core_info);
  33 #else
  34 int rk610_lcd_init(struct rk610_core_info *rk610_core_info){}
  35 #endif
  36 int rk610_control_send_byte(const char reg, const char data)
  37 {
  38         int ret;
  39
  40         DBG("reg = 0x%02x, val=0x%02x\n", reg ,data);
  41
  42         if(rk610_control_client == NULL)
  43                 return -1;
  44         //i2c_master_reg8_send
  45         ret = i2c_master_reg8_send(rk610_control_client, reg, &data, 1, 100*1000);
  46         if (ret > 0)
  47                 ret = 0;
  48
  49         return ret;
  50 }
  51
  52 #ifdef CONFIG_SND_SOC_RK610
  53 static unsigned int current_pll_value = 0;
  54 int rk610_codec_pll_set(unsigned int rate)
  55 {
  56         char N, M, NO, DIV;
  57         unsigned int F;
  58         char data;
  59
  60         if(current_pll_value == rate)
  61                 return 0;
  62
  63     // Input clock is 12MHz.
  64         if(rate == 11289600) {
  65                 // For 11.2896MHz, N = 2 M= 75 F = 0.264(0x43958) NO = 8
  66                 N = 2;
  67                 NO = 3;
  68                 M = 75;
  69                 F = 0x43958;
  70                 DIV = 5;
  71         }
  72         else if(rate == 12288000) {
  73                 // For 12.2888MHz, N = 2 M= 75 F = 0.92(0xEB851) NO = 8
  74                 N = 2;
  75                 NO = 3;
  76                 M = 75;
  77                 F = 0xEB851;
  78                 DIV = 5;
  79         }
  80         else {
  81                 printk(KERN_ERR "[%s] not support such frequency\n", __FUNCTION__);
  82                 return -1;
  83         }
  84
  85         //Enable codec pll fractional number and power down.
  86     data = 0x00;
  87     rk610_control_send_byte(RK610_CONTROL_REG_C_PLL_CON5, data);
  88         msleep(10);
  89
  90     data = (N << 4) | NO;
  91     rk610_control_send_byte(RK610_CONTROL_REG_C_PLL_CON0, data);
  92     // M
  93     data = M;
  94     rk610_control_send_byte(RK610_CONTROL_REG_C_PLL_CON1, data);
  95     // F
  96     data = F & 0xFF;
  97     rk610_control_send_byte(RK610_CONTROL_REG_C_PLL_CON2, data);
  98     data = (F >> 8) & 0xFF;
  99     rk610_control_send_byte(RK610_CONTROL_REG_C_PLL_CON3, data);
 100     data = (F >> 16) & 0xFF;
 101     rk610_control_send_byte(RK610_CONTROL_REG_C_PLL_CON4, data);
 102
 103     // i2s mclk = codec_pll/5;
 104     i2c_master_reg8_recv(rk610_control_client, RK610_CONTROL_REG_CLOCK_CON1, &data, 1, 100*1000);
 105     data &= ~CLOCK_CON1_I2S_DVIDER_MASK;
 106     data |= (DIV - 1);
 107     rk610_control_send_byte(RK610_CONTROL_REG_CLOCK_CON1, data);
 108
 109     // Power up codec pll.
 110     data |= C_PLL_POWER_ON;
 111     rk610_control_send_byte(RK610_CONTROL_REG_C_PLL_CON5, data);
 112
 113     current_pll_value = rate;
 114     DBG("[%s] rate %u\n", __FUNCTION__, rate);
 115
 116     return 0;
 117 }
 118
 119 void rk610_control_init_codec(void)
 120 {
 121     struct i2c_client *client = rk610_control_client;
 122     char data = 0;
 123     int ret;
 124
 125     if(rk610_control_client == NULL)
 126         return;
 127         DBG("[%s] start\n", __FUNCTION__);
 128
 129     //gpio_set_value(RK610_RESET_PIN, GPIO_LOW); //reset rk601
 130    // mdelay(100);
 131     //gpio_set_value(RK610_RESET_PIN, GPIO_HIGH);
 132     //mdelay(100);
 133
 134         // Set i2c glitch timeout.
 135         data = 0x22;
 136         ret = i2c_master_reg8_send(client, RK610_CONTROL_REG_I2C_CON, &data, 1, 20*1000);
 137
 138 //    rk610_codec_pll_set(11289600);
 139
 140     //use internal codec, enable DAC ADC LRCK output.
 141 //    i2c_master_reg8_recv(client, RK610_CONTROL_REG_CODEC_CON, &data, 1, 100*1000);
 142 //    data = CODEC_CON_BIT_DAC_LRCL_OUTPUT_DISABLE | CODEC_CON_BIT_ADC_LRCK_OUTPUT_DISABLE;
 143 //      data = CODEC_CON_BIT_ADC_LRCK_OUTPUT_DISABLE;
 144         data = 0;
 145         rk610_control_send_byte(RK610_CONTROL_REG_CODEC_CON, data);
 146
 147     // Select internal i2s clock from codec_pll.
 148     i2c_master_reg8_recv(rk610_control_client, RK610_CONTROL_REG_CLOCK_CON1, &data, 1, 100*1000);
 149 //    data |= CLOCK_CON1_I2S_CLK_CODEC_PLL;
 150         data = 0;
 151     rk610_control_send_byte(RK610_CONTROL_REG_CLOCK_CON1, data);
 152
 153     i2c_master_reg8_recv(client, RK610_CONTROL_REG_CODEC_CON, &data, 1, 100*1000);
 154     DBG("[%s] RK610_CONTROL_REG_CODEC_CON is %x\n", __FUNCTION__, data);
 155
 156     i2c_master_reg8_recv(client, RK610_CONTROL_REG_CLOCK_CON1, &data, 1, 100*1000);
 157     DBG("[%s] RK610_CONTROL_REG_CLOCK_CON1 is %x\n", __FUNCTION__, data);
 158 }
 159 #endif
 160 #ifdef RK610_DEBUG
 161 static int rk610_read_p0_reg(struct i2c_client *client, char reg, char *val)
 162 {
 163         return i2c_master_reg8_recv(client, reg, val, 1, 100*1000) > 0? 0: -EINVAL;
 164 }
 165
 166 static int rk610_write_p0_reg(struct i2c_client *client, char reg, char *val)
 167 {
 168         return i2c_master_reg8_send(client, reg, val, 1, 100*1000) > 0? 0: -EINVAL;
 169 }
 170 static ssize_t rk610_show_reg_attrs(struct device *dev,
 171                                               struct device_attribute *attr,
 172                                               char *buf)
 173 {
 174
 175         int i,size=0;
 176         char val;
 177         struct i2c_client *client=rk610_control_client;
 178
 179         for(i=0;i<256;i++)
 180         {
 181                 rk610_read_p0_reg(client, i,  &val);
 182                 if(i%16==0)
 183                         size += sprintf(buf+size,"\n>>>rk610_ctl %x:",i);
 184                 size += sprintf(buf+size," %2x",val);
 185         }
 186
 187         return size;
 188 }
 189 static ssize_t rk610_store_reg_attrs(struct device *dev,
 190                                                 struct device_attribute *attr,
 191                                                 const char *buf, size_t size)
 192 {
 193         struct i2c_client *client=NULL;
 194         static char val=0,reg=0;
 195         client = rk610_control_client;
 196         DBG("/**********rk610 reg config******/");
 197
 198         sscanf(buf, "%x%x", &val,&reg);
 199         DBG("reg=%x val=%x\n",reg,val);
 200         rk610_write_p0_reg(client, reg,  &val);
 201         DBG("val=%x\n",val);
 202         return size;
 203 }
 204
 205 static struct device_attribute rk610_attrs[] = {
 206         __ATTR(reg_ctl, 0777,rk610_show_reg_attrs,rk610_store_reg_attrs),
 207 };
 208 #endif
 209
 210 static int rk610_control_probe(struct i2c_client *client,
 211                         const struct i2c_device_id *id)
 212 {
 213         int ret;
 214         struct clk *iis_clk;
 215         struct rk610_core_info *core_info = NULL;
 216         struct rk610_ctl_platform_data *pdata = client->dev.platform_data;
 217         DBG("[%s] start\n", __FUNCTION__);
 218         core_info = kmalloc(sizeof(struct rk610_core_info), GFP_KERNEL);
 219         if(!core_info)
 220         {
 221                 dev_err(&client->dev, ">> rk610 core inf kmalloc fail!");
 222                 return -ENOMEM;
 223         }
 224         memset(core_info, 0, sizeof(struct rk610_core_info));
 225         core_info->pdata = pdata;
 226         #if defined(CONFIG_SND_RK29_SOC_I2S_8CH)
 227         iis_clk = clk_get_sys("rk29_i2s.0", "i2s");
 228         #elif defined(CONFIG_SND_RK29_SOC_I2S_2CH)
 229         iis_clk = clk_get_sys("rk29_i2s.1", "i2s");
 230         #else
 231         iis_clk = clk_get_sys("rk29_i2s.2", "i2s");
 232         #endif
 233         if (IS_ERR(iis_clk)) {
 234                 printk("failed to get i2s clk\n");
 235                 ret = PTR_ERR(iis_clk);
 236         }else{
 237                 DBG("got i2s clk ok!\n");
 238                 clk_enable(iis_clk);
 239                 clk_set_rate(iis_clk, 11289600);
 240                 #if defined(CONFIG_ARCH_RK29)
 241                 rk29_mux_api_set(GPIO2D0_I2S0CLK_MIIRXCLKIN_NAME, GPIO2H_I2S0_CLK);
 242                 #elif defined(CONFIG_ARCH_RK3066B)
 243                 rk30_mux_api_set(GPIO1C0_I2SCLK_NAME, GPIO1C_I2SCLK);
 244                 #elif defined(CONFIG_ARCH_RK30)
 245                 rk30_mux_api_set(GPIO0B0_I2S8CHCLK_NAME, GPIO0B_I2S_8CH_CLK);
 246                 #endif
 247                 clk_put(iis_clk);
 248         }
 249
 250         rk610_control_client = client;
 251         msleep(100);
 252         if(core_info->pdata->rk610_power_on_init)
 253                 core_info->pdata->rk610_power_on_init();
 254         core_info->client = client;
 255         rk610_lcd_init(core_info);
 256 #ifdef RK610_DEBUG
 257         device_create_file(&(client->dev), &rk610_attrs[0]);
 258 #endif
 259     return 0;
 260 }
 261
 262 static int rk610_control_remove(struct i2c_client *client)
 263 {
 264         return 0;
 265 }
 266
 267 static const struct i2c_device_id rk610_control_id[] = {
 268         { "rk610_ctl", 0 },
 269         { }
 270 };
 271 MODULE_DEVICE_TABLE(i2c, rk610_control_id);
 272
 273 static struct i2c_driver rk610_control_driver = {
 274         .driver = {
 275                 .name = "rk610_ctl",
 276         },
 277         .probe = rk610_control_probe,
 278         .remove = rk610_control_remove,
 279         .id_table = rk610_control_id,
 280 };
 281
 282 static int __init rk610_control_init(void)
 283 {
 284         DBG("[%s] start\n", __FUNCTION__);
 285         return i2c_add_driver(&rk610_control_driver);
 286 }
 287
 288 static void __exit rk610_control_exit(void)
 289 {
 290         i2c_del_driver(&rk610_control_driver);
 291 }
 292
 293 subsys_initcall_sync(rk610_control_init);
 294 //module_init(rk610_control_init);
 295 module_exit(rk610_control_exit);
 296
 297
 298 MODULE_DESCRIPTION("RK610 control driver");
 299 MODULE_AUTHOR("Rock-chips, <www.rock-chips.com>");
 300 MODULE_LICENSE("GPL");
 301