1 #include <linux/module.h>
2 #include <linux/init.h>
4 #include <linux/device.h>
5 #include <linux/delay.h>
7 #include <linux/mfd/core.h>
8 #include <linux/mfd/rk610_core.h>
10 #include <linux/gpio.h>
11 #include <linux/err.h>
12 #include <linux/slab.h>
14 #include <linux/of_gpio.h>
16 #if defined(CONFIG_DEBUG_FS)
18 #include <linux/debugfs.h>
19 #include <linux/seq_file.h>
20 #include <linux/uaccess.h>
30 #define DBG(x...) printk(KERN_INFO x)
35 static struct i2c_client *rk610_control_client = NULL;
37 int i2c_master_reg8_send(const struct i2c_client *client, const char reg, const char *buf, int count, int scl_rate)
39 struct i2c_adapter *adap=client->adapter;
42 char *tx_buf = (char *)kmalloc(count + 1, GFP_KERNEL);
46 memcpy(tx_buf+1, buf, count);
48 msg.addr = client->addr;
49 msg.flags = client->flags;
51 msg.buf = (char *)tx_buf;
52 msg.scl_rate = scl_rate;
53 // msg.udelay = client->udelay;
55 ret = i2c_transfer(adap, &msg, 1);
57 return (ret == 1) ? count : ret;
61 int i2c_master_reg8_recv(const struct i2c_client *client, const char reg, char *buf, int count, int scl_rate)
63 struct i2c_adapter *adap=client->adapter;
64 struct i2c_msg msgs[2];
68 msgs[0].addr = client->addr;
69 msgs[0].flags = client->flags;
71 msgs[0].buf = ®_buf;
72 msgs[0].scl_rate = scl_rate;
73 // msgs[0].udelay = client->udelay;
75 msgs[1].addr = client->addr;
76 msgs[1].flags = client->flags | I2C_M_RD;
78 msgs[1].buf = (char *)buf;
79 msgs[1].scl_rate = scl_rate;
80 // msgs[1].udelay = client->udelay;
82 ret = i2c_transfer(adap, msgs, 2);
84 return (ret == 2)? count : ret;
88 static struct mfd_cell rk610_devs[] = {
95 int rk610_control_send_byte(const char reg, const char data)
99 DBG("reg = 0x%02x, val=0x%02x\n", reg ,data);
101 if(rk610_control_client == NULL)
103 //i2c_master_reg8_send
104 ret = i2c_master_reg8_send(rk610_control_client, reg, &data, 1, 100*1000);
111 #ifdef CONFIG_SND_SOC_RK610
112 static unsigned int current_pll_value = 0;
113 int rk610_codec_pll_set(unsigned int rate)
119 if(current_pll_value == rate)
122 // Input clock is 12MHz.
123 if(rate == 11289600) {
124 // For 11.2896MHz, N = 2 M= 75 F = 0.264(0x43958) NO = 8
131 else if(rate == 12288000) {
132 // For 12.2888MHz, N = 2 M= 75 F = 0.92(0xEB851) NO = 8
140 printk(KERN_ERR "[%s] not support such frequency\n", __FUNCTION__);
144 //Enable codec pll fractional number and power down.
146 rk610_control_send_byte(RK610_CONTROL_REG_C_PLL_CON5, data);
149 data = (N << 4) | NO;
150 rk610_control_send_byte(RK610_CONTROL_REG_C_PLL_CON0, data);
153 rk610_control_send_byte(RK610_CONTROL_REG_C_PLL_CON1, data);
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);
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;
166 rk610_control_send_byte(RK610_CONTROL_REG_CLOCK_CON1, data);
168 // Power up codec pll.
169 data |= C_PLL_POWER_ON;
170 rk610_control_send_byte(RK610_CONTROL_REG_C_PLL_CON5, data);
172 current_pll_value = rate;
173 DBG("[%s] rate %u\n", __FUNCTION__, rate);
178 void rk610_control_init_codec(void)
180 struct i2c_client *client = rk610_control_client;
184 if(rk610_control_client == NULL)
186 DBG("[%s] start\n", __FUNCTION__);
188 //gpio_set_value(RK610_RESET_PIN, GPIO_LOW); //reset rk601
190 //gpio_set_value(RK610_RESET_PIN, GPIO_HIGH);
193 // Set i2c glitch timeout.
195 ret = i2c_master_reg8_send(client, RK610_CONTROL_REG_I2C_CON, &data, 1, 20*1000);
197 // rk610_codec_pll_set(11289600);
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;
204 rk610_control_send_byte(RK610_CONTROL_REG_CODEC_CON, data);
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;
210 rk610_control_send_byte(RK610_CONTROL_REG_CLOCK_CON1, data);
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);
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);
220 static int rk610_read_p0_reg(struct i2c_client *client, char reg, char *val)
222 return i2c_master_reg8_recv(client, reg, val, 1, 100*1000) > 0? 0: -EINVAL;
225 static int rk610_write_p0_reg(struct i2c_client *client, char reg, char *val)
227 return i2c_master_reg8_send(client, reg, val, 1, 100*1000) > 0? 0: -EINVAL;
231 #if defined(CONFIG_DEBUG_FS)
232 static int rk610_reg_show(struct seq_file *s, void *v)
236 struct rk610_core_info *core_info = s->private;
239 dev_err(core_info->dev,"no mfd rk610!\n");
243 for(reg=C_PLL_CON0;reg<= I2C_CON;reg++)
245 rk610_read_p0_reg(core_info->client, reg, &val);
247 seq_printf(s,"\n0x%02x:",reg);
248 seq_printf(s," %02x",val);
255 static ssize_t rk610_reg_write (struct file *file, const char __user *buf, size_t count, loff_t *ppos)
257 struct rk610_core_info *core_info = file->f_path.dentry->d_inode->i_private;
261 if (copy_from_user(kbuf, buf, count))
263 sscanf(kbuf, "%x%x", ®,&val);
264 rk610_write_p0_reg(core_info->client, reg, (u8*)&val);
268 static int rk610_reg_open(struct inode *inode, struct file *file)
270 struct rk610_core_info *core_info = inode->i_private;
271 return single_open(file,rk610_reg_show,core_info);
274 static const struct file_operations rk610_reg_fops = {
275 .owner = THIS_MODULE,
276 .open = rk610_reg_open,
278 .write = rk610_reg_write,
280 .release = single_release,
284 static int rk610_control_probe(struct i2c_client *client,
285 const struct i2c_device_id *id)
288 struct rk610_core_info *core_info = NULL;
289 struct device_node *rk610_np;
291 DBG("[%s] start\n", __FUNCTION__);
292 core_info = kmalloc(sizeof(struct rk610_core_info), GFP_KERNEL);
295 dev_err(&client->dev, ">> rk610 core inf kmalloc fail!");
298 memset(core_info, 0, sizeof(struct rk610_core_info));
300 rk610_control_client = client;
302 core_info->client = client;
303 core_info->dev = &client->dev;
304 i2c_set_clientdata(client,core_info);
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);
312 ret = gpio_request(core_info->reset_gpio, "rk610-reset-io");
314 printk("gpio_request core_info->reset_gpio invalid: %d\n",core_info->reset_gpio);
317 gpio_direction_output(core_info->reset_gpio, GPIO_HIGH);
319 gpio_direction_output(core_info->reset_gpio, GPIO_LOW);
321 gpio_set_value(core_info->reset_gpio, GPIO_HIGH);
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);
329 clk_set_rate(core_info->i2s_clk, 11289600);
330 clk_prepare_enable(core_info->i2s_clk);
332 ret = mfd_add_devices(&client->dev, -1,
333 rk610_devs, ARRAY_SIZE(rk610_devs),
336 #if defined(CONFIG_DEBUG_FS)
337 core_info->debugfs_dir = debugfs_create_dir("rk610", NULL);
338 if (IS_ERR(core_info->debugfs_dir))
340 dev_err(&client->dev,"failed to create debugfs dir for rk610!\n");
343 debugfs_create_file("core", S_IRUSR,core_info->debugfs_dir,core_info,&rk610_reg_fops);
349 static int rk610_control_remove(struct i2c_client *client)
354 static const struct i2c_device_id rk610_control_id[] = {
358 MODULE_DEVICE_TABLE(i2c, rk610_control_id);
360 static struct i2c_driver rk610_control_driver = {
364 .probe = rk610_control_probe,
365 .remove = rk610_control_remove,
366 .id_table = rk610_control_id,
369 static int __init rk610_control_init(void)
371 return i2c_add_driver(&rk610_control_driver);
374 static void __exit rk610_control_exit(void)
376 i2c_del_driver(&rk610_control_driver);
379 subsys_initcall_sync(rk610_control_init);
380 module_exit(rk610_control_exit);
383 MODULE_DESCRIPTION("RK610 control driver");
384 MODULE_AUTHOR("Rock-chips, <www.rock-chips.com>");
385 MODULE_LICENSE("GPL");