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_LCD
  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         DBG("[%s] start\n", __FUNCTION__);
 217         core_info = kmalloc(sizeof(struct rk610_core_info), GFP_KERNEL);
 218     if(!core_info)
 219     {
 220         dev_err(&client->dev, ">> rk610 core inf kmalloc fail!");
 221         return -ENOMEM;
 222     }
 223     memset(core_info, 0, sizeof(struct rk610_core_info));
 224                 #if defined(CONFIG_SND_RK29_SOC_I2S_8CH)
 225                 iis_clk = clk_get_sys("rk29_i2s.0", "i2s");
 226                 #elif defined(CONFIG_SND_RK29_SOC_I2S_2CH)
 227                 iis_clk = clk_get_sys("rk29_i2s.1", "i2s");
 228                 #else
 229                 iis_clk = clk_get_sys("rk29_i2s.2", "i2s");
 230                 #endif
 231                 if (IS_ERR(iis_clk)) {
 232                         printk("failed to get i2s clk\n");
 233                         ret = PTR_ERR(iis_clk);
 234                 }else{
 235                         DBG("got i2s clk ok!\n");
 236                         clk_enable(iis_clk);
 237                         clk_set_rate(iis_clk, 11289600);
 238                         #if defined(CONFIG_ARCH_RK29)
 239                         rk29_mux_api_set(GPIO2D0_I2S0CLK_MIIRXCLKIN_NAME, GPIO2H_I2S0_CLK);
 240                         #elif defined(CONFIG_ARCH_RK3066B)
 241                         rk30_mux_api_set(GPIO1C0_I2SCLK_NAME, GPIO1C_I2SCLK);
 242                         #elif defined(CONFIG_ARCH_RK30)
 243                         rk30_mux_api_set(GPIO0B0_I2S8CHCLK_NAME, GPIO0B_I2S_8CH_CLK);
 244                         #endif
 245                         clk_put(iis_clk);
 246                 }
 247
 248     rk610_control_client = client;
 249     msleep(100);
 250         if(RK610_RESET_PIN != INVALID_GPIO) {
 251             ret = gpio_request(RK610_RESET_PIN, "rk610 reset");
 252             if (ret){
 253                 printk(KERN_ERR "rk610_control_probe request gpio fail\n");
 254             }
 255             else {
 256                 DBG("rk610_control_probe request gpio ok\n");
 257                 gpio_direction_output(RK610_RESET_PIN, GPIO_HIGH);
 258                     gpio_direction_output(RK610_RESET_PIN, GPIO_LOW);
 259                         msleep(100);
 260                     gpio_set_value(RK610_RESET_PIN, GPIO_HIGH);
 261                 }
 262         }
 263     core_info->client = client;
 264         rk610_lcd_init(core_info);
 265         #ifdef RK610_DEBUG
 266         device_create_file(&(client->dev), &rk610_attrs[0]);
 267     #endif
 268     return 0;
 269 }
 270
 271 static int rk610_control_remove(struct i2c_client *client)
 272 {
 273         return 0;
 274 }
 275
 276 static const struct i2c_device_id rk610_control_id[] = {
 277         { "rk610_ctl", 0 },
 278         { }
 279 };
 280 MODULE_DEVICE_TABLE(i2c, rk610_control_id);
 281
 282 static struct i2c_driver rk610_control_driver = {
 283         .driver = {
 284                 .name = "rk610_ctl",
 285         },
 286         .probe = rk610_control_probe,
 287         .remove = rk610_control_remove,
 288         .id_table = rk610_control_id,
 289 };
 290
 291 static int __init rk610_control_init(void)
 292 {
 293         DBG("[%s] start\n", __FUNCTION__);
 294         return i2c_add_driver(&rk610_control_driver);
 295 }
 296
 297 static void __exit rk610_control_exit(void)
 298 {
 299         i2c_del_driver(&rk610_control_driver);
 300 }
 301
 302 subsys_initcall_sync(rk610_control_init);
 303 //module_init(rk610_control_init);
 304 module_exit(rk610_control_exit);
 305
 306
 307 MODULE_DESCRIPTION("RK610 control driver");
 308 MODULE_AUTHOR("Rock-chips, <www.rock-chips.com>");
 309 MODULE_LICENSE("GPL");
 310