1 #include <linux/module.h>
2 #include <linux/init.h>
4 #include <linux/device.h>
5 #include <linux/delay.h>
7 #include <linux/mfd/rk610_core.h>
9 #include <mach/iomux.h>
10 #include <linux/err.h>
11 #include <linux/slab.h>
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
18 #define RK610_RESET_PIN RK29_PIN6_PC1
25 #define DBG(x...) printk(KERN_INFO x)
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);
34 int rk610_lcd_init(struct rk610_core_info *rk610_core_info){}
36 int rk610_control_send_byte(const char reg, const char data)
40 DBG("reg = 0x%02x, val=0x%02x\n", reg ,data);
42 if(rk610_control_client == NULL)
44 //i2c_master_reg8_send
45 ret = i2c_master_reg8_send(rk610_control_client, reg, &data, 1, 100*1000);
52 #ifdef CONFIG_SND_SOC_RK610
53 static unsigned int current_pll_value = 0;
54 int rk610_codec_pll_set(unsigned int rate)
60 if(current_pll_value == rate)
63 // Input clock is 12MHz.
64 if(rate == 11289600) {
65 // For 11.2896MHz, N = 2 M= 75 F = 0.264(0x43958) NO = 8
72 else if(rate == 12288000) {
73 // For 12.2888MHz, N = 2 M= 75 F = 0.92(0xEB851) NO = 8
81 printk(KERN_ERR "[%s] not support such frequency\n", __FUNCTION__);
85 //Enable codec pll fractional number and power down.
87 rk610_control_send_byte(RK610_CONTROL_REG_C_PLL_CON5, data);
91 rk610_control_send_byte(RK610_CONTROL_REG_C_PLL_CON0, data);
94 rk610_control_send_byte(RK610_CONTROL_REG_C_PLL_CON1, data);
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);
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;
107 rk610_control_send_byte(RK610_CONTROL_REG_CLOCK_CON1, data);
109 // Power up codec pll.
110 data |= C_PLL_POWER_ON;
111 rk610_control_send_byte(RK610_CONTROL_REG_C_PLL_CON5, data);
113 current_pll_value = rate;
114 DBG("[%s] rate %u\n", __FUNCTION__, rate);
119 void rk610_control_init_codec(void)
121 struct i2c_client *client = rk610_control_client;
125 if(rk610_control_client == NULL)
127 DBG("[%s] start\n", __FUNCTION__);
129 //gpio_set_value(RK610_RESET_PIN, GPIO_LOW); //reset rk601
131 //gpio_set_value(RK610_RESET_PIN, GPIO_HIGH);
134 // Set i2c glitch timeout.
136 ret = i2c_master_reg8_send(client, RK610_CONTROL_REG_I2C_CON, &data, 1, 20*1000);
138 // rk610_codec_pll_set(11289600);
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;
145 rk610_control_send_byte(RK610_CONTROL_REG_CODEC_CON, data);
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;
151 rk610_control_send_byte(RK610_CONTROL_REG_CLOCK_CON1, data);
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);
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);
161 static int rk610_read_p0_reg(struct i2c_client *client, char reg, char *val)
163 return i2c_master_reg8_recv(client, reg, val, 1, 100*1000) > 0? 0: -EINVAL;
166 static int rk610_write_p0_reg(struct i2c_client *client, char reg, char *val)
168 return i2c_master_reg8_send(client, reg, val, 1, 100*1000) > 0? 0: -EINVAL;
170 static ssize_t rk610_show_reg_attrs(struct device *dev,
171 struct device_attribute *attr,
177 struct i2c_client *client=rk610_control_client;
181 rk610_read_p0_reg(client, i, &val);
183 size += sprintf(buf+size,"\n>>>rk610_ctl %x:",i);
184 size += sprintf(buf+size," %2x",val);
189 static ssize_t rk610_store_reg_attrs(struct device *dev,
190 struct device_attribute *attr,
191 const char *buf, size_t size)
193 struct i2c_client *client=NULL;
194 static char val=0,reg=0;
195 client = rk610_control_client;
196 DBG("/**********rk610 reg config******/");
198 sscanf(buf, "%x%x", &val,®);
199 DBG("reg=%x val=%x\n",reg,val);
200 rk610_write_p0_reg(client, reg, &val);
205 static struct device_attribute rk610_attrs[] = {
206 __ATTR(reg_ctl, 0777,rk610_show_reg_attrs,rk610_store_reg_attrs),
210 static int rk610_control_probe(struct i2c_client *client,
211 const struct i2c_device_id *id)
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);
221 dev_err(&client->dev, ">> rk610 core inf kmalloc fail!");
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");
231 iis_clk = clk_get_sys("rk29_i2s.2", "i2s");
233 if (IS_ERR(iis_clk)) {
234 printk("failed to get i2s clk\n");
235 ret = PTR_ERR(iis_clk);
237 DBG("got i2s clk ok!\n");
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)||defined(CONFIG_ARCH_RK3188)
244 #elif defined(CONFIG_ARCH_RK30)
245 rk30_mux_api_set(GPIO0B0_I2S8CHCLK_NAME, GPIO0B_I2S_8CH_CLK);
250 rk610_control_client = client;
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);
257 device_create_file(&(client->dev), &rk610_attrs[0]);
262 static int rk610_control_remove(struct i2c_client *client)
267 static const struct i2c_device_id rk610_control_id[] = {
271 MODULE_DEVICE_TABLE(i2c, rk610_control_id);
273 static struct i2c_driver rk610_control_driver = {
277 .probe = rk610_control_probe,
278 .remove = rk610_control_remove,
279 .id_table = rk610_control_id,
282 static int __init rk610_control_init(void)
284 DBG("[%s] start\n", __FUNCTION__);
285 return i2c_add_driver(&rk610_control_driver);
288 static void __exit rk610_control_exit(void)
290 i2c_del_driver(&rk610_control_driver);
293 subsys_initcall_sync(rk610_control_init);
294 //module_init(rk610_control_init);
295 module_exit(rk610_control_exit);
298 MODULE_DESCRIPTION("RK610 control driver");
299 MODULE_AUTHOR("Rock-chips, <www.rock-chips.com>");
300 MODULE_LICENSE("GPL");