1 /* drivers/i2c/busses/i2c-rk30.c
3 * Copyright (C) 2012 ROCKCHIP, Inc.
5 * This software is licensed under the terms of the GNU General Public
6 * License version 2, as published by the Free Software Foundation, and
7 * may be copied, distributed, and modified under those terms.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
18 static int i2c_max_adap = 0;
19 void i2c_adap_sel(struct rk30_i2c *i2c, int nr, int adap_type)
21 i2c_writel((1 << I2C_ADAP_SEL_BIT(nr)) | (1 << I2C_ADAP_SEL_MASK(nr)) ,
25 #ifdef CONFIG_CPU_FREQ
27 #define freq_to_i2c(_n) container_of(_n, struct rk30_i2c, freq_transition)
29 static int rk30_i2c_cpufreq_transition(struct notifier_block *nb,
30 unsigned long val, void *data)
32 struct rk30_i2c *i2c = freq_to_i2c(nb);
33 struct cpufreq_freqs *freqs = data;
38 if(val == CPUFREQ_PRECHANGE)
39 mutex_lock(&i2c->m_lock);
40 else if(val == CPUFREQ_POSTCHANGE)
41 mutex_unlock(&i2c->m_lock);
46 static inline int rk30_i2c_register_cpufreq(struct rk30_i2c *i2c)
48 if(!i2c->is_div_from_arm[i2c->adap.nr])
50 i2c->freq_transition.notifier_call = rk30_i2c_cpufreq_transition;
52 return cpufreq_register_notifier(&i2c->freq_transition,
53 CPUFREQ_TRANSITION_NOTIFIER);
56 static inline void rk30_i2c_deregister_cpufreq(struct rk30_i2c *i2c)
58 if(!i2c->is_div_from_arm[i2c->adap.nr])
60 cpufreq_unregister_notifier(&i2c->freq_transition,
61 CPUFREQ_TRANSITION_NOTIFIER);
65 static inline int rk30_i2c_register_cpufreq(struct rk30_i2c *i2c)
70 static inline void rk30_i2c_deregister_cpufreq(struct rk30_i2c *i2c)
77 * called by the bus driver when a suitable device is found
80 static int rk30_i2c_probe(struct platform_device *pdev)
82 struct rk30_i2c *i2c = NULL;
83 struct rk30_i2c_platform_data *pdata = NULL;
87 pdata = pdev->dev.platform_data;
89 dev_err(&pdev->dev, "no platform data\n");
94 i2c = kzalloc(sizeof(struct rk30_i2c), GFP_KERNEL);
96 dev_err(&pdev->dev, "no memory for state\n");
100 #if !defined(CONFIG_ARCH_RK319X)
101 i2c->con_base = (void __iomem *)GRF_I2C_CON_BASE;
102 i2c_adap_sel(i2c, pdata->bus_num, pdata->adap_type);
108 i2c->sda_mode = pdata->sda_mode;
109 i2c->scl_mode = pdata->scl_mode;
111 strlcpy(i2c->adap.name, "rk30_i2c", sizeof(i2c->adap.name));
112 i2c->adap.owner = THIS_MODULE;
113 i2c->adap.class = I2C_CLASS_HWMON | I2C_CLASS_SPD;
114 i2c->tx_setup = TX_SETUP;
115 i2c->adap.retries = 2;
116 i2c->adap.timeout = msecs_to_jiffies(100);
118 spin_lock_init(&i2c->lock);
119 init_waitqueue_head(&i2c->wait);
120 mutex_init(&i2c->m_lock);
122 /* find the clock and enable it */
124 i2c->dev = &pdev->dev;
125 i2c->clk = clk_get(&pdev->dev, "i2c");
126 if (IS_ERR(i2c->clk)) {
127 dev_err(&pdev->dev, "cannot get clock\n");
132 i2c_dbg(&pdev->dev, "clock source %p\n", i2c->clk);
134 clk_enable(i2c->clk);
136 /* map the registers */
138 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
140 dev_err(&pdev->dev, "cannot find IO resource\n");
142 goto err_get_resource;
145 i2c->ioarea = request_mem_region(res->start, resource_size(res),
148 if (i2c->ioarea == NULL) {
149 dev_err(&pdev->dev, "cannot request IO\n");
154 i2c->regs = ioremap(res->start, resource_size(res));
156 if (i2c->regs == NULL) {
157 dev_err(&pdev->dev, "cannot map IO\n");
162 i2c_dbg(&pdev->dev, "registers %p (%p, %p)\n",
163 i2c->regs, i2c->ioarea, res);
165 /* setup info block for the i2c core */
167 i2c->adap.algo_data = i2c;
168 i2c->adap.dev.parent = &pdev->dev;
169 i2c->adap.nr = pdata->bus_num;
170 if(pdata->adap_type == I2C_RK29_ADAP)
171 ret = i2c_add_rk29_adapter(&i2c->adap);
172 else // I2C_RK30_ADAP
173 ret = i2c_add_rk30_adapter(&i2c->adap);
176 dev_err(&pdev->dev, "failed to add adapter\n");
177 goto err_add_adapter;
180 /* find the IRQ for this unit (note, this relies on the init call to
181 * ensure no current IRQs pending
184 i2c->irq = ret = platform_get_irq(pdev, 0);
186 dev_err(&pdev->dev, "cannot find IRQ\n");
190 ret = request_irq(i2c->irq, i2c->i2c_irq, IRQF_DISABLED,
191 dev_name(&pdev->dev), i2c);
194 dev_err(&pdev->dev, "cannot claim IRQ %d\n", i2c->irq);
195 goto err_request_irq;
198 ret = rk30_i2c_register_cpufreq(i2c);
200 dev_err(&pdev->dev, "failed to register cpufreq notifier\n");
201 goto err_register_cpufreq;
204 platform_set_drvdata(pdev, i2c);
206 i2c->is_div_from_arm[i2c->adap.nr] = pdata->is_div_from_arm;
208 i2c->i2c_init_hw(i2c, 100 * 1000);
210 dev_info(&pdev->dev, "%s: RK30 I2C adapter\n", dev_name(&i2c->adap.dev));
213 // rk30_i2c_deregister_cpufreq(i2c);
214 err_register_cpufreq:
215 free_irq(i2c->irq, i2c);
218 i2c_del_adapter(&i2c->adap);
224 release_resource(i2c->ioarea);
234 * called when device is removed from the bus
237 static int rk30_i2c_remove(struct platform_device *pdev)
239 struct rk30_i2c *i2c = platform_get_drvdata(pdev);
241 rk30_i2c_deregister_cpufreq(i2c);
242 free_irq(i2c->irq, i2c);
243 i2c_del_adapter(&i2c->adap);
246 release_resource(i2c->ioarea);
253 static int rk30_i2c_suspend_noirq(struct device *dev)
255 struct platform_device *pdev = to_platform_device(dev);
256 struct rk30_i2c *i2c = platform_get_drvdata(pdev);
263 static int rk30_i2c_resume_noirq(struct device *dev)
265 struct platform_device *pdev = to_platform_device(dev);
266 struct rk30_i2c *i2c = platform_get_drvdata(pdev);
269 i2c->i2c_init_hw(i2c, i2c->scl_rate);
274 static const struct dev_pm_ops rk30_i2c_dev_pm_ops = {
275 .suspend_noirq = rk30_i2c_suspend_noirq,
276 .resume_noirq = rk30_i2c_resume_noirq,
279 #define rk30_DEV_PM_OPS (&rk30_i2c_dev_pm_ops)
281 #define rk30_DEV_PM_OPS NULL
284 MODULE_DEVICE_TABLE(platform, rk30_driver_ids);
286 static struct platform_driver rk30_i2c_driver = {
287 .probe = rk30_i2c_probe,
288 .remove = rk30_i2c_remove,
290 .owner = THIS_MODULE,
292 .pm = rk30_DEV_PM_OPS,
296 static int __init i2c_adap_init(void)
298 return platform_driver_register(&rk30_i2c_driver);
300 subsys_initcall(i2c_adap_init);
302 static void __exit i2c_adap_exit(void)
304 platform_driver_unregister(&rk30_i2c_driver);
306 module_exit(i2c_adap_exit);
308 static int detect_read(struct i2c_client *client, char *buf, int len)
312 msg.addr = client->addr;
313 msg.flags = client->flags | I2C_M_RD;
316 msg.scl_rate = 100 * 1000;
318 return i2c_transfer(client->adapter, &msg, 1);
321 static void detect_set_client(struct i2c_client *client, __u16 addr, int nr)
325 client->adapter = i2c_get_adapter(nr);
327 static void slave_detect(int nr)
332 char buf[6 * 0x80 + 20];
333 struct i2c_client client;
335 memset(buf, 0, 6 * 0x80 + 20);
337 sprintf(buf, "I2c%d slave list: ", nr);
339 for(addr = 0x01; addr < 0x80; addr++){
340 detect_set_client(&client, addr, nr);
341 ret = detect_read(&client, val, 1);
343 sprintf(buf, "%s 0x%02x", buf, addr);
349 static ssize_t i2c_detect_write(struct file *file,
350 const char __user *buf, size_t count, loff_t *offset)
357 ret = copy_from_user(nr_buf, buf, count);
361 sscanf(nr_buf, "%d", &nr);
362 if(nr >= 5 || nr < 0)
371 static const struct file_operations i2c_detect_fops = {
372 .write = i2c_detect_write,
374 static struct miscdevice i2c_detect_device = {
375 .minor = MISC_DYNAMIC_MINOR,
376 .name = "i2c_detect",
377 .fops = &i2c_detect_fops,
379 static int __init i2c_detect_init(void)
381 return misc_register(&i2c_detect_device);
384 static void __exit i2c_detect_exit(void)
386 misc_deregister(&i2c_detect_device);
388 module_init(i2c_detect_init);
389 module_exit(i2c_detect_exit);
391 static int __init i2c_detect_rk610(void)
395 for(i = 0; i < i2c_max_adap; i++){
396 i2c_check_rk610_ex(i);
400 late_initcall(i2c_detect_rk610);
405 MODULE_DESCRIPTION("Driver for RK30 I2C Bus");
406 MODULE_AUTHOR("kfx, kfx@rock-chips.com");
407 MODULE_LICENSE("GPL");