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