drivers/i2c/busses/i2c-rk30.c

   1 /* drivers/i2c/busses/i2c-rk30.c
   2  *
   3  * Copyright (C) 2012 ROCKCHIP, Inc.
   4  *
   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.
   8  *
   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.
  13  *
  14  */
  15 #include "i2c-rk30.h"
  16 #define TX_SETUP                        1
  17
  18 static int i2c_max_adap = 0;
  19 void i2c_adap_sel(struct rk30_i2c *i2c, int nr, int adap_type)
  20 {
  21         i2c_writel((1 << I2C_ADAP_SEL_BIT(nr)) | (1 << I2C_ADAP_SEL_MASK(nr)) ,
  22                         i2c->con_base);
  23 }
  24
  25 #ifdef CONFIG_CPU_FREQ
  26
  27 #define freq_to_i2c(_n) container_of(_n, struct rk30_i2c, freq_transition)
  28
  29 static int rk30_i2c_cpufreq_transition(struct notifier_block *nb,
  30                                           unsigned long val, void *data)
  31 {
  32         struct rk30_i2c *i2c = freq_to_i2c(nb);
  33         struct cpufreq_freqs *freqs = data;
  34
  35         if (freqs->cpu)
  36                 return 0;
  37
  38         if(val == CPUFREQ_PRECHANGE)
  39                 mutex_lock(&i2c->m_lock);
  40         else if(val == CPUFREQ_POSTCHANGE)
  41                 mutex_unlock(&i2c->m_lock);
  42
  43         return 0;
  44 }
  45
  46 static inline int rk30_i2c_register_cpufreq(struct rk30_i2c *i2c)
  47 {
  48         if(!i2c->is_div_from_arm[i2c->adap.nr])
  49                 return 0;
  50         i2c->freq_transition.notifier_call = rk30_i2c_cpufreq_transition;
  51
  52         return cpufreq_register_notifier(&i2c->freq_transition,
  53                                          CPUFREQ_TRANSITION_NOTIFIER);
  54 }
  55
  56 static inline void rk30_i2c_deregister_cpufreq(struct rk30_i2c *i2c)
  57 {
  58         if(!i2c->is_div_from_arm[i2c->adap.nr])
  59                 return;
  60         cpufreq_unregister_notifier(&i2c->freq_transition,
  61                                     CPUFREQ_TRANSITION_NOTIFIER);
  62 }
  63
  64 #else
  65 static inline int rk30_i2c_register_cpufreq(struct rk30_i2c *i2c)
  66 {
  67         return 0;
  68 }
  69
  70 static inline void rk30_i2c_deregister_cpufreq(struct rk30_i2c *i2c)
  71 {
  72 }
  73 #endif
  74
  75 /* rk30_i2c_probe
  76  *
  77  * called by the bus driver when a suitable device is found
  78 */
  79
  80 static int rk30_i2c_probe(struct platform_device *pdev)
  81 {
  82         struct rk30_i2c *i2c = NULL;
  83         struct rk30_i2c_platform_data *pdata = NULL;
  84         struct resource *res;
  85         int ret;
  86
  87         pdata = pdev->dev.platform_data;
  88         if (!pdata) {
  89                 dev_err(&pdev->dev, "no platform data\n");
  90                 return -EINVAL;
  91         }
  92
  93
  94         i2c = kzalloc(sizeof(struct rk30_i2c), GFP_KERNEL);
  95         if (!i2c) {
  96                 dev_err(&pdev->dev, "no memory for state\n");
  97                 return -ENOMEM;
  98         }
  99
 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);
 103 #endif
 104
 105         if(pdata->io_init)
 106                 pdata->io_init();
 107
 108         i2c->sda_mode = pdata->sda_mode;
 109         i2c->scl_mode = pdata->scl_mode;
 110
 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);
 117
 118         spin_lock_init(&i2c->lock);
 119         init_waitqueue_head(&i2c->wait);
 120         mutex_init(&i2c->m_lock);
 121
 122         /* find the clock and enable it */
 123
 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");
 128                 ret = -ENOENT;
 129                 goto err_noclk;
 130         }
 131
 132         i2c_dbg(&pdev->dev, "clock source %p\n", i2c->clk);
 133
 134         clk_enable(i2c->clk);
 135
 136         /* map the registers */
 137
 138         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 139         if (res == NULL) {
 140                 dev_err(&pdev->dev, "cannot find IO resource\n");
 141                 ret = -ENOENT;
 142                 goto err_get_resource;
 143         }
 144
 145         i2c->ioarea = request_mem_region(res->start, resource_size(res),
 146                                          pdev->name);
 147
 148         if (i2c->ioarea == NULL) {
 149                 dev_err(&pdev->dev, "cannot request IO\n");
 150                 ret = -ENXIO;
 151                 goto err_ioarea;
 152         }
 153
 154         i2c->regs = ioremap(res->start, resource_size(res));
 155
 156         if (i2c->regs == NULL) {
 157                 dev_err(&pdev->dev, "cannot map IO\n");
 158                 ret = -ENXIO;
 159                 goto err_ioremap;
 160         }
 161
 162         i2c_dbg(&pdev->dev, "registers %p (%p, %p)\n",
 163                 i2c->regs, i2c->ioarea, res);
 164
 165         /* setup info block for the i2c core */
 166
 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);
 174
 175         if (ret < 0) {
 176                 dev_err(&pdev->dev, "failed to add adapter\n");
 177                 goto err_add_adapter;
 178         }
 179
 180         /* find the IRQ for this unit (note, this relies on the init call to
 181          * ensure no current IRQs pending
 182          */
 183
 184         i2c->irq = ret = platform_get_irq(pdev, 0);
 185         if (ret <= 0) {
 186                 dev_err(&pdev->dev, "cannot find IRQ\n");
 187                 goto err_get_irq;
 188         }
 189
 190         ret = request_irq(i2c->irq, i2c->i2c_irq, IRQF_DISABLED,
 191                           dev_name(&pdev->dev), i2c);
 192
 193         if (ret != 0) {
 194                 dev_err(&pdev->dev, "cannot claim IRQ %d\n", i2c->irq);
 195                 goto err_request_irq;
 196         }
 197
 198         ret = rk30_i2c_register_cpufreq(i2c);
 199         if (ret < 0) {
 200                 dev_err(&pdev->dev, "failed to register cpufreq notifier\n");
 201                 goto err_register_cpufreq;
 202         }
 203
 204         platform_set_drvdata(pdev, i2c);
 205
 206         i2c->is_div_from_arm[i2c->adap.nr] = pdata->is_div_from_arm;
 207
 208         i2c->i2c_init_hw(i2c, 100 * 1000);
 209         i2c_max_adap++;
 210         dev_info(&pdev->dev, "%s: RK30 I2C adapter\n", dev_name(&i2c->adap.dev));
 211         return 0;
 212 //err_none:
 213 //      rk30_i2c_deregister_cpufreq(i2c);
 214 err_register_cpufreq:
 215         free_irq(i2c->irq, i2c);
 216 err_request_irq:
 217 err_get_irq:
 218         i2c_del_adapter(&i2c->adap);
 219 err_add_adapter:
 220         iounmap(i2c->regs);
 221 err_ioremap:
 222         kfree(i2c->ioarea);
 223 err_ioarea:
 224         release_resource(i2c->ioarea);
 225 err_get_resource:
 226         clk_put(i2c->clk);
 227 err_noclk:
 228         kfree(i2c);
 229         return ret;
 230 }
 231
 232 /* rk30_i2c_remove
 233  *
 234  * called when device is removed from the bus
 235 */
 236
 237 static int rk30_i2c_remove(struct platform_device *pdev)
 238 {
 239         struct rk30_i2c *i2c = platform_get_drvdata(pdev);
 240
 241         rk30_i2c_deregister_cpufreq(i2c);
 242         free_irq(i2c->irq, i2c);
 243         i2c_del_adapter(&i2c->adap);
 244         iounmap(i2c->regs);
 245         kfree(i2c->ioarea);
 246         release_resource(i2c->ioarea);
 247         clk_put(i2c->clk);
 248         kfree(i2c);
 249         return 0;
 250 }
 251
 252 #ifdef CONFIG_PM
 253 static int rk30_i2c_suspend_noirq(struct device *dev)
 254 {
 255         struct platform_device *pdev = to_platform_device(dev);
 256         struct rk30_i2c *i2c = platform_get_drvdata(pdev);
 257
 258         i2c->suspended = 1;
 259
 260         return 0;
 261 }
 262
 263 static int rk30_i2c_resume_noirq(struct device *dev)
 264 {
 265         struct platform_device *pdev = to_platform_device(dev);
 266         struct rk30_i2c *i2c = platform_get_drvdata(pdev);
 267
 268         i2c->suspended = 0;
 269         i2c->i2c_init_hw(i2c, i2c->scl_rate);
 270
 271         return 0;
 272 }
 273
 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,
 277 };
 278
 279 #define rk30_DEV_PM_OPS (&rk30_i2c_dev_pm_ops)
 280 #else
 281 #define rk30_DEV_PM_OPS NULL
 282 #endif
 283
 284 MODULE_DEVICE_TABLE(platform, rk30_driver_ids);
 285
 286 static struct platform_driver rk30_i2c_driver = {
 287         .probe          = rk30_i2c_probe,
 288         .remove         = rk30_i2c_remove,
 289         .driver         = {
 290                 .owner  = THIS_MODULE,
 291                 .name   = "rk30_i2c",
 292                 .pm     = rk30_DEV_PM_OPS,
 293         },
 294 };
 295
 296 static int __init i2c_adap_init(void)
 297 {
 298         return platform_driver_register(&rk30_i2c_driver);
 299 }
 300 subsys_initcall(i2c_adap_init);
 301
 302 static void __exit i2c_adap_exit(void)
 303 {
 304         platform_driver_unregister(&rk30_i2c_driver);
 305 }
 306 module_exit(i2c_adap_exit);
 307
 308 static int detect_read(struct i2c_client *client, char *buf, int len)
 309 {
 310         struct i2c_msg msg;
 311
 312         msg.addr = client->addr;
 313         msg.flags = client->flags | I2C_M_RD;
 314         msg.buf = buf;
 315         msg.len = len;
 316         msg.scl_rate = 100 * 1000;
 317
 318         return i2c_transfer(client->adapter, &msg, 1);
 319 }
 320
 321 static void detect_set_client(struct i2c_client *client, __u16 addr, int nr)
 322 {
 323         client->flags = 0;
 324         client->addr = addr;
 325         client->adapter = i2c_get_adapter(nr);
 326 }
 327 static void slave_detect(int nr)
 328 {
 329         int ret = 0;
 330         unsigned short addr;
 331         char val[8];
 332         char buf[6 * 0x80 + 20];
 333         struct i2c_client client;
 334
 335         memset(buf, 0, 6 * 0x80 + 20);
 336
 337         sprintf(buf, "I2c%d slave list: ", nr);
 338         do {
 339                 for(addr = 0x01; addr < 0x80; addr++){
 340                         detect_set_client(&client, addr, nr);
 341                         ret = detect_read(&client, val, 1);
 342                         if(ret > 0)
 343                                 sprintf(buf, "%s  0x%02x", buf, addr);
 344                 }
 345                 printk("%s\n", buf);
 346         }
 347         while(0);
 348 }
 349 static ssize_t i2c_detect_write(struct file *file,
 350                         const char __user *buf, size_t count, loff_t *offset)
 351 {
 352         char nr_buf[8];
 353         int nr = 0, ret;
 354
 355         if(count > 4)
 356                 return -EFAULT;
 357         ret = copy_from_user(nr_buf, buf, count);
 358         if(ret < 0)
 359                 return -EFAULT;
 360
 361         sscanf(nr_buf, "%d", &nr);
 362         if(nr >= 5 || nr < 0)
 363                 return -EFAULT;
 364
 365         slave_detect(nr);
 366
 367         return count;
 368 }
 369
 370
 371 static const struct file_operations i2c_detect_fops = {
 372         .write = i2c_detect_write,
 373 };
 374 static struct miscdevice i2c_detect_device = {
 375         .minor = MISC_DYNAMIC_MINOR,
 376         .name = "i2c_detect",
 377         .fops = &i2c_detect_fops,
 378 };
 379 static int __init i2c_detect_init(void)
 380 {
 381         return misc_register(&i2c_detect_device);
 382 }
 383
 384 static void __exit i2c_detect_exit(void)
 385 {
 386         misc_deregister(&i2c_detect_device);
 387 }
 388 module_init(i2c_detect_init);
 389 module_exit(i2c_detect_exit);
 390
 391 static int __init i2c_detect_rk610(void)
 392 {
 393         int i;
 394
 395         for(i = 0; i < i2c_max_adap; i++){
 396                 i2c_check_rk610_ex(i);
 397         }
 398         return 0;
 399 }
 400 late_initcall(i2c_detect_rk610);
 401
 402
 403
 404
 405 MODULE_DESCRIPTION("Driver for RK30 I2C Bus");
 406 MODULE_AUTHOR("kfx, kfx@rock-chips.com");
 407 MODULE_LICENSE("GPL");