drivers/media/platform/tegra/auto/isc_mgr.c

   1 /*
   2  * isc manager.
   3  *
   4  * Copyright (c) 2015-2017, NVIDIA Corporation. All Rights Reserved.
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms and conditions of the GNU General Public License,
   8  * version 2, as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  13  * more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 #include <linux/delay.h>
  20 #include <linux/fs.h>
  21 #include <linux/module.h>
  22 #include <linux/slab.h>
  23 #include <linux/gpio.h>
  24 #include <linux/of_gpio.h>
  25 #include <linux/regmap.h>
  26 #include <linux/delay.h>
  27 #include <linux/platform_device.h>
  28 #include <linux/device.h>
  29 #include <linux/of_irq.h>
  30 #include <linux/interrupt.h>
  31 #include <asm/siginfo.h>
  32 #include <linux/rcupdate.h>
  33 #include <linux/sched.h>
  34 #include <linux/uaccess.h>
  35 #include <linux/atomic.h>
  36 #include <linux/i2c.h>
  37 #include <linux/pwm.h>
  38 #include <media/isc-dev.h>
  39 #include <media/isc-mgr.h>
  40
  41 #include "isc-mgr-priv.h"
  42
  43 #define PW_ON(flag)     ((flag) ? 0 : 1)
  44 #define PW_OFF(flag)    ((flag) ? 1 : 0)
  45
  46 /* minor number range would be 0 to 127 */
  47 #define ISC_DEV_MAX     128
  48
  49 static irqreturn_t isc_mgr_isr(int irq, void *data)
  50 {
  51         struct isc_mgr_priv *isc_mgr;
  52         int ret;
  53         unsigned long flags;
  54
  55         if (data) {
  56                 isc_mgr = (struct isc_mgr_priv *)data;
  57                 spin_lock_irqsave(&isc_mgr->spinlock, flags);
  58                 if (isc_mgr->sinfo.si_signo && isc_mgr->t) {
  59                         /* send the signal to user space */
  60                         ret = send_sig_info(isc_mgr->sinfo.si_signo,
  61                                         &isc_mgr->sinfo,
  62                                         isc_mgr->t);
  63                         if (ret < 0) {
  64                                 pr_err("error sending signal\n");
  65                                 spin_unlock_irqrestore(&isc_mgr->spinlock,
  66                                                         flags);
  67                                 return IRQ_HANDLED;
  68                         }
  69                 }
  70                 spin_unlock_irqrestore(&isc_mgr->spinlock, flags);
  71         }
  72
  73         return IRQ_HANDLED;
  74 }
  75
  76 int isc_delete_lst(struct device *dev, struct i2c_client *client)
  77 {
  78         struct isc_mgr_priv *isc_mgr;
  79         struct isc_mgr_client *isc_dev;
  80
  81         if (dev == NULL)
  82                 return -EFAULT;
  83
  84         isc_mgr = (struct isc_mgr_priv *)dev_get_drvdata(dev);
  85
  86         mutex_lock(&isc_mgr->mutex);
  87         list_for_each_entry(isc_dev, &isc_mgr->dev_list, list) {
  88                 if (isc_dev->client == client) {
  89                         list_del(&isc_dev->list);
  90                         break;
  91                 }
  92         }
  93         mutex_unlock(&isc_mgr->mutex);
  94
  95         return 0;
  96 }
  97 EXPORT_SYMBOL_GPL(isc_delete_lst);
  98
  99 static int isc_remove_dev(struct isc_mgr_priv *isc_mgr, unsigned long arg)
 100 {
 101         struct isc_mgr_client *isc_dev;
 102
 103         dev_dbg(isc_mgr->dev, "%s %ld\n", __func__, arg);
 104         mutex_lock(&isc_mgr->mutex);
 105         list_for_each_entry(isc_dev, &isc_mgr->dev_list, list) {
 106                 if (isc_dev->id == arg) {
 107                         list_del(&isc_dev->list);
 108                         break;
 109                 }
 110         }
 111         mutex_unlock(&isc_mgr->mutex);
 112
 113         if (&isc_dev->list != &isc_mgr->dev_list)
 114                 i2c_unregister_device(isc_dev->client);
 115         else
 116                 dev_err(isc_mgr->dev, "%s: list %lx un-exist\n", __func__, arg);
 117
 118         return 0;
 119 }
 120
 121 static int __isc_create_dev(
 122         struct isc_mgr_priv *isc_mgr, struct isc_mgr_new_dev *new_dev)
 123 {
 124         struct isc_mgr_client *isc_dev;
 125         struct i2c_board_info brd;
 126         int err = 0;
 127
 128         if (new_dev->addr >= 0x80 || new_dev->drv_name[0] == '\0' ||
 129                 (new_dev->val_bits != 8 && new_dev->val_bits != 16) ||
 130                 (new_dev->reg_bits != 0 && new_dev->reg_bits != 8 &&
 131                 new_dev->reg_bits != 16)) {
 132                 dev_err(isc_mgr->dev,
 133                         "%s: invalid isc dev params: %s %x %d %d\n",
 134                         __func__, new_dev->drv_name, new_dev->addr,
 135                         new_dev->reg_bits, new_dev->val_bits);
 136                 return -EINVAL;
 137         }
 138
 139         isc_dev = devm_kzalloc(isc_mgr->dev, sizeof(*isc_dev), GFP_KERNEL);
 140         if (!isc_dev) {
 141                 dev_err(isc_mgr->dev, "Unable to allocate memory!\n");
 142                 return -ENOMEM;
 143         }
 144
 145         memcpy(&isc_dev->cfg, new_dev, sizeof(isc_dev->cfg));
 146         dev_dbg(isc_mgr->pdev, "%s - %s @ %x, %d %d\n", __func__,
 147                 isc_dev->cfg.drv_name, isc_dev->cfg.addr,
 148                 isc_dev->cfg.reg_bits, isc_dev->cfg.val_bits);
 149
 150         snprintf(isc_dev->pdata.drv_name, sizeof(isc_dev->pdata.drv_name),
 151                         "%s.%u.%02x", isc_dev->cfg.drv_name,
 152                         isc_mgr->adap->nr, isc_dev->cfg.addr);
 153         isc_dev->pdata.reg_bits = isc_dev->cfg.reg_bits;
 154         isc_dev->pdata.val_bits = isc_dev->cfg.val_bits;
 155         isc_dev->pdata.pdev = isc_mgr->dev;
 156
 157         mutex_init(&isc_dev->mutex);
 158         INIT_LIST_HEAD(&isc_dev->list);
 159
 160         memset(&brd, 0, sizeof(brd));
 161         strncpy(brd.type, "isc-dev", sizeof(brd.type));
 162         brd.addr = isc_dev->cfg.addr;
 163         brd.platform_data = &isc_dev->pdata;
 164         isc_dev->client = i2c_new_device(isc_mgr->adap, &brd);
 165         if (!isc_dev->client) {
 166                 dev_err(isc_mgr->dev,
 167                         "%s cannot allocate client: %s bus %d, %x\n", __func__,
 168                         isc_dev->pdata.drv_name, isc_mgr->adap->nr, brd.addr);
 169                 err = -EINVAL;
 170                 goto dev_create_err;
 171         }
 172
 173         mutex_lock(&isc_mgr->mutex);
 174         if (!list_empty(&isc_mgr->dev_list))
 175                 isc_dev->id = list_entry(isc_mgr->dev_list.next,
 176                         struct isc_mgr_client, list)->id + 1;
 177         list_add(&isc_dev->list, &isc_mgr->dev_list);
 178         mutex_unlock(&isc_mgr->mutex);
 179
 180 dev_create_err:
 181         if (err) {
 182                 devm_kfree(isc_mgr->dev, isc_dev);
 183                 return err;
 184         } else
 185                 return isc_dev->id;
 186 }
 187
 188 static int isc_create_dev(struct isc_mgr_priv *isc_mgr, const void __user *arg)
 189 {
 190         struct isc_mgr_new_dev d_cfg;
 191
 192         if (copy_from_user(&d_cfg, arg, sizeof(d_cfg))) {
 193                 dev_err(isc_mgr->pdev,
 194                         "%s: failed to copy from user\n", __func__);
 195                 return -EFAULT;
 196         }
 197
 198         return __isc_create_dev(isc_mgr, &d_cfg);
 199 }
 200
 201 static int isc_mgr_write_pid(struct file *file, const void __user *arg)
 202 {
 203         struct isc_mgr_priv *isc_mgr = file->private_data;
 204         struct isc_mgr_sinfo sinfo;
 205         unsigned long flags;
 206
 207         if (copy_from_user(&sinfo, arg, sizeof(sinfo))) {
 208                 dev_err(isc_mgr->pdev,
 209                         "%s: failed to copy from user\n", __func__);
 210                 return -EFAULT;
 211         }
 212
 213         if (isc_mgr->sinfo.si_int) {
 214                 dev_err(isc_mgr->pdev, "exist signal info\n");
 215                 return -EINVAL;
 216         }
 217
 218         if ((sinfo.sig_no < SIGRTMIN) || (sinfo.sig_no > SIGRTMAX)) {
 219                 dev_err(isc_mgr->pdev, "Invalid signal number\n");
 220                 return -EINVAL;
 221         }
 222
 223         if (!sinfo.pid) {
 224                 dev_err(isc_mgr->pdev, "Invalid PID\n");
 225                 return -EINVAL;
 226         }
 227
 228         spin_lock_irqsave(&isc_mgr->spinlock, flags);
 229         isc_mgr->sinfo.si_signo = isc_mgr->sig_no = sinfo.sig_no;
 230         isc_mgr->sinfo.si_code = SI_QUEUE;
 231         isc_mgr->sinfo.si_ptr = (void __user *)((unsigned long)sinfo.context);
 232         spin_unlock_irqrestore(&isc_mgr->spinlock, flags);
 233
 234         rcu_read_lock();
 235         isc_mgr->t = pid_task(find_pid_ns(sinfo.pid, &init_pid_ns),
 236                                 PIDTYPE_PID);
 237         if (isc_mgr->t == NULL) {
 238                 dev_err(isc_mgr->pdev, "no such pid\n");
 239                 rcu_read_unlock();
 240                 return -ENODEV;
 241         }
 242         rcu_read_unlock();
 243
 244         return 0;
 245 }
 246
 247 static int isc_mgr_get_pwr_info(struct isc_mgr_priv *isc_mgr,
 248                                 void __user *arg)
 249 {
 250         struct isc_mgr_platform_data *pd = isc_mgr->pdata;
 251         struct isc_mgr_pwr_info pinfo;
 252         int err;
 253
 254         if (copy_from_user(&pinfo, arg, sizeof(pinfo))) {
 255                 dev_err(isc_mgr->pdev,
 256                         "%s: failed to copy from user\n", __func__);
 257                 return -EFAULT;
 258         }
 259
 260         if (!pd->num_pwr_gpios) {
 261                 dev_err(isc_mgr->pdev,
 262                         "%s: no power gpios\n", __func__);
 263                 pinfo.pwr_status = -1;
 264                 err = -ENODEV;
 265                 goto pwr_info_end;
 266         }
 267
 268         if (pinfo.pwr_gpio >= pd->num_pwr_gpios || pinfo.pwr_gpio < 0) {
 269                 dev_err(isc_mgr->pdev,
 270                         "%s: invalid power gpio provided\n", __func__);
 271                 pinfo.pwr_status = -1;
 272                 err = -EINVAL;
 273                 goto pwr_info_end;
 274         }
 275
 276         pinfo.pwr_status  = gpio_get_value(pd->pwr_gpios[pinfo.pwr_gpio]);
 277         err = 0;
 278
 279 pwr_info_end:
 280         if (copy_to_user(arg, &pinfo, sizeof(pinfo))) {
 281                 dev_err(isc_mgr->pdev,
 282                         "%s: failed to copy to user\n", __func__);
 283                 return -EFAULT;
 284         }
 285         return err;
 286 }
 287
 288 int isc_mgr_power_up(struct isc_mgr_priv *isc_mgr, unsigned long arg)
 289 {
 290         struct isc_mgr_platform_data *pd = isc_mgr->pdata;
 291         int i;
 292         u32 pwr_gpio;
 293
 294         dev_dbg(isc_mgr->pdev, "%s - %lu\n", __func__, arg);
 295
 296         if (!pd->num_pwr_gpios)
 297                 goto pwr_up_end;
 298
 299         if (arg >= MAX_ISC_GPIOS)
 300                 arg = MAX_ISC_GPIOS - 1;
 301
 302         pwr_gpio = pd->pwr_mapping[arg];
 303
 304         if (pwr_gpio < pd->num_pwr_gpios) {
 305                 gpio_set_value(pd->pwr_gpios[pwr_gpio],
 306                         PW_ON(pd->pwr_flags[pwr_gpio]));
 307                 isc_mgr->pwr_state |= BIT(pwr_gpio);
 308                 return 0;
 309         }
 310
 311         for (i = 0; i < pd->num_pwr_gpios; i++) {
 312                 dev_dbg(isc_mgr->pdev, "  - %d, %d\n",
 313                         pd->pwr_gpios[i], PW_ON(pd->pwr_flags[i]));
 314                 gpio_set_value(pd->pwr_gpios[i], PW_ON(pd->pwr_flags[i]));
 315                 isc_mgr->pwr_state |= BIT(i);
 316         }
 317
 318 pwr_up_end:
 319         return 0;
 320 }
 321
 322 int isc_mgr_power_down(struct isc_mgr_priv *isc_mgr, unsigned long arg)
 323 {
 324         struct isc_mgr_platform_data *pd = isc_mgr->pdata;
 325         int i;
 326         u32 pwr_gpio;
 327
 328         dev_dbg(isc_mgr->pdev, "%s - %lx\n", __func__, arg);
 329
 330         if (!pd->num_pwr_gpios)
 331                 goto pwr_dn_end;
 332
 333         if (arg >= MAX_ISC_GPIOS)
 334                 arg = MAX_ISC_GPIOS - 1;
 335
 336         pwr_gpio = pd->pwr_mapping[arg];
 337
 338         if (pwr_gpio < pd->num_pwr_gpios) {
 339                 gpio_set_value(pd->pwr_gpios[pwr_gpio],
 340                                 PW_OFF(pd->pwr_flags[pwr_gpio]));
 341                 isc_mgr->pwr_state &= ~BIT(pwr_gpio);
 342                 return 0;
 343         }
 344
 345         for (i = 0; i < pd->num_pwr_gpios; i++) {
 346                 dev_dbg(isc_mgr->pdev, "  - %d, %d\n",
 347                         pd->pwr_gpios[i], PW_OFF(pd->pwr_flags[i]));
 348                 gpio_set_value(pd->pwr_gpios[i], PW_OFF(pd->pwr_flags[i]));
 349                 isc_mgr->pwr_state &= ~BIT(i);
 350         }
 351         mdelay(7);
 352
 353 pwr_dn_end:
 354         return 0;
 355 }
 356
 357 static int isc_mgr_misc_ctrl(struct isc_mgr_priv *isc_mgr, bool misc_on)
 358 {
 359         struct isc_mgr_platform_data *pd = isc_mgr->pdata;
 360         int err, i;
 361
 362         dev_dbg(isc_mgr->pdev, "%s - %s\n", __func__, misc_on ? "ON" : "OFF");
 363
 364         if (!pd->num_misc_gpios)
 365                 return 0;
 366
 367         for (i = 0; i < pd->num_misc_gpios; i++) {
 368                 if (misc_on) {
 369                         if (devm_gpio_request(isc_mgr->pdev,
 370                                               pd->misc_gpios[i],
 371                                               "misc-gpio")) {
 372                                 dev_err(isc_mgr->pdev, "failed req GPIO: %d\n",
 373                                         pd->misc_gpios[i]);
 374                                 goto misc_ctrl_err;
 375                         }
 376
 377                         err = gpio_direction_output(
 378                                 pd->misc_gpios[i], PW_ON(pd->misc_flags[i]));
 379                 } else {
 380                         err = gpio_direction_output(
 381                                 pd->misc_gpios[i], PW_OFF(pd->misc_flags[i]));
 382                         devm_gpio_free(isc_mgr->pdev, pd->misc_gpios[i]);
 383                 }
 384         }
 385         return 0;
 386
 387 misc_ctrl_err:
 388         for (; i >= 0; i--)
 389                 devm_gpio_free(isc_mgr->pdev, pd->misc_gpios[i]);
 390         return -EBUSY;
 391 }
 392
 393 static int isc_mgr_pwm_enable(
 394         struct isc_mgr_priv *isc_mgr, unsigned long arg)
 395 {
 396         int err = 0;
 397
 398         if (!isc_mgr || !isc_mgr->pwm)
 399                 return -EINVAL;
 400
 401         switch (arg) {
 402         case ISC_MGR_PWM_ENABLE:
 403                 err = pwm_enable(isc_mgr->pwm);
 404                 break;
 405         case ISC_MGR_PWM_DISABLE:
 406                 pwm_disable(isc_mgr->pwm);
 407                 break;
 408         default:
 409                 dev_err(isc_mgr->pdev, "%s unrecognized command: %lx\n",
 410                         __func__, arg);
 411         }
 412
 413         return err;
 414 }
 415
 416 static int isc_mgr_pwm_config(
 417         struct isc_mgr_priv *isc_mgr, const void __user *arg)
 418 {
 419         struct isc_mgr_pwm_info pwm_cfg;
 420         int err = 0;
 421
 422         if (!isc_mgr || !isc_mgr->pwm)
 423                 return -EINVAL;
 424
 425         if (copy_from_user(&pwm_cfg, arg, sizeof(pwm_cfg))) {
 426                 dev_err(isc_mgr->pdev,
 427                         "%s: failed to copy from user\n", __func__);
 428                 return -EFAULT;
 429         }
 430
 431         err = pwm_config(isc_mgr->pwm, pwm_cfg.duty_ns, pwm_cfg.period_ns);
 432
 433         return err;
 434 }
 435
 436 static long isc_mgr_ioctl(
 437         struct file *file, unsigned int cmd, unsigned long arg)
 438 {
 439         struct isc_mgr_priv *isc_mgr = file->private_data;
 440         int err = 0;
 441         unsigned long flags;
 442
 443         /* command distributor */
 444         switch (cmd) {
 445         case ISC_MGR_IOCTL_DEV_ADD:
 446                 err = isc_create_dev(isc_mgr, (const void __user *)arg);
 447                 break;
 448         case ISC_MGR_IOCTL_DEV_DEL:
 449                 isc_remove_dev(isc_mgr, arg);
 450                 break;
 451         case ISC_MGR_IOCTL_PWR_DN:
 452                 err = isc_mgr_power_down(isc_mgr, arg);
 453                 break;
 454         case ISC_MGR_IOCTL_PWR_UP:
 455                 err = isc_mgr_power_up(isc_mgr, arg);
 456                 break;
 457         case ISC_MGR_IOCTL_SET_PID:
 458                 /* first enable irq to clear pending interrupt
 459                  * and then register PID
 460                  */
 461                 if (isc_mgr->err_irq && !atomic_xchg(&isc_mgr->irq_in_use, 1))
 462                         enable_irq(isc_mgr->err_irq);
 463
 464                 err = isc_mgr_write_pid(file, (const void __user *)arg);
 465                 break;
 466         case ISC_MGR_IOCTL_SIGNAL:
 467                 switch (arg) {
 468                 case ISC_MGR_SIGNAL_RESUME:
 469                         if (!isc_mgr->sig_no) {
 470                                 dev_err(isc_mgr->pdev,
 471                                         "invalid sig_no, setup pid first\n");
 472                                 return -EINVAL;
 473                         }
 474                         spin_lock_irqsave(&isc_mgr->spinlock, flags);
 475                         isc_mgr->sinfo.si_signo = isc_mgr->sig_no;
 476                         spin_unlock_irqrestore(&isc_mgr->spinlock, flags);
 477                         break;
 478                 case ISC_MGR_SIGNAL_SUSPEND:
 479                         spin_lock_irqsave(&isc_mgr->spinlock, flags);
 480                         isc_mgr->sinfo.si_signo = 0;
 481                         spin_unlock_irqrestore(&isc_mgr->spinlock, flags);
 482                         break;
 483                 default:
 484                         dev_err(isc_mgr->pdev, "%s unrecognized signal: %lx\n",
 485                                 __func__, arg);
 486                 }
 487                 break;
 488         case ISC_MGR_IOCTL_PWR_INFO:
 489                 err = isc_mgr_get_pwr_info(isc_mgr, (void __user *)arg);
 490                 break;
 491         case ISC_MGR_IOCTL_PWM_ENABLE:
 492                 err = isc_mgr_pwm_enable(isc_mgr, arg);
 493                 break;
 494         case ISC_MGR_IOCTL_PWM_CONFIG:
 495                 err = isc_mgr_pwm_config(isc_mgr, (const void __user *)arg);
 496                 break;
 497         default:
 498                 dev_err(isc_mgr->pdev, "%s unsupported ioctl: %x\n",
 499                         __func__, cmd);
 500                 err = -EINVAL;
 501         }
 502
 503         if (err)
 504                 dev_dbg(isc_mgr->pdev, "err = %d\n", err);
 505
 506         return err;
 507 }
 508
 509 static int isc_mgr_open(struct inode *inode, struct file *file)
 510 {
 511         struct isc_mgr_priv *isc_mgr = container_of(inode->i_cdev,
 512                                         struct isc_mgr_priv, cdev);
 513
 514         /* only one application can open one isc_mgr device */
 515         if (atomic_xchg(&isc_mgr->in_use, 1))
 516                 return -EBUSY;
 517
 518         dev_dbg(isc_mgr->pdev, "%s\n", __func__);
 519         file->private_data = isc_mgr;
 520
 521         /* if runtime_pwrctrl_off is not true, power on all here */
 522         if (!isc_mgr->pdata->runtime_pwrctrl_off)
 523                 isc_mgr_power_up(isc_mgr, 0xffffffff);
 524
 525         isc_mgr_misc_ctrl(isc_mgr, true);
 526         return 0;
 527 }
 528
 529 static int isc_mgr_release(struct inode *inode, struct file *file)
 530 {
 531         struct isc_mgr_priv *isc_mgr = file->private_data;
 532
 533         if (isc_mgr->pwm)
 534                 if (pwm_is_enabled(isc_mgr->pwm))
 535                         pwm_disable(isc_mgr->pwm);
 536
 537         isc_mgr_misc_ctrl(isc_mgr, false);
 538
 539         /* disable irq if irq is in use, when device is closed */
 540         if (atomic_xchg(&isc_mgr->irq_in_use, 0))
 541                 disable_irq(isc_mgr->err_irq);
 542
 543         /* if runtime_pwrctrl_off is not true, power off all here */
 544         if (!isc_mgr->pdata->runtime_pwrctrl_off)
 545                 isc_mgr_power_down(isc_mgr, 0xffffffff);
 546
 547         /* clear sinfo to prevent report error after handler is closed */
 548         memset(&isc_mgr->sinfo, 0, sizeof(struct siginfo));
 549         isc_mgr->t = NULL;
 550         WARN_ON(!atomic_xchg(&isc_mgr->in_use, 0));
 551
 552         return 0;
 553 }
 554
 555 static const struct file_operations isc_mgr_fileops = {
 556         .owner = THIS_MODULE,
 557         .open = isc_mgr_open,
 558         .unlocked_ioctl = isc_mgr_ioctl,
 559 #ifdef CONFIG_COMPAT
 560         .compat_ioctl = isc_mgr_ioctl,
 561 #endif
 562         .release = isc_mgr_release,
 563 };
 564
 565 static void isc_mgr_del(struct isc_mgr_priv *isc_mgr)
 566 {
 567         struct isc_mgr_platform_data *pd = isc_mgr->pdata;
 568         struct isc_mgr_client *isc_dev;
 569         int i;
 570
 571         mutex_lock(&isc_mgr->mutex);
 572         list_for_each_entry(isc_dev, &isc_mgr->dev_list, list) {
 573                 list_del(&isc_dev->list);
 574                 i2c_unregister_device(isc_dev->client);
 575         }
 576         mutex_unlock(&isc_mgr->mutex);
 577
 578         for (i = 0; i < pd->num_pwr_gpios; i++)
 579                 if (pd->pwr_gpios[i])
 580                         gpio_direction_output(
 581                                 pd->pwr_gpios[i], PW_OFF(pd->pwr_flags[i]));
 582
 583         i2c_put_adapter(isc_mgr->adap);
 584 }
 585
 586 static void isc_mgr_dev_ins(struct work_struct *work)
 587 {
 588         struct isc_mgr_priv *isc_mgr =
 589                 container_of(work, struct isc_mgr_priv, ins_work);
 590         struct device_node *np = isc_mgr->pdev->of_node;
 591         struct device_node *subdev;
 592         struct isc_mgr_new_dev d_cfg = {.drv_name = "isc-dev"};
 593         const char *sname;
 594         u32 val;
 595         int err = 0;
 596
 597         if (np == NULL)
 598                 return;
 599
 600         dev_dbg(isc_mgr->dev, "%s - %s\n", __func__, np->full_name);
 601         sname = of_get_property(np, "isc-dev", NULL);
 602         if (sname)
 603                 strncpy(d_cfg.drv_name, sname, sizeof(d_cfg.drv_name) - 8);
 604
 605         for_each_child_of_node(np, subdev) {
 606                 err = of_property_read_u32(subdev, "addr", &val);
 607                 if (err || !val) {
 608                         dev_err(isc_mgr->dev, "%s: ERROR %d addr = %d\n",
 609                                 __func__, err, val);
 610                         continue;
 611                 }
 612                 d_cfg.addr = val;
 613                 err = of_property_read_u32(subdev, "reg_len", &val);
 614                 if (err || !val) {
 615                         dev_err(isc_mgr->dev, "%s: ERROR %d reg_len = %d\n",
 616                                 __func__, err, val);
 617                         continue;
 618                 }
 619                 d_cfg.reg_bits = val;
 620                 err = of_property_read_u32(subdev, "dat_len", &val);
 621                 if (err || !val) {
 622                         dev_err(isc_mgr->dev, "%s: ERROR %d dat_len = %d\n",
 623                                 __func__, err, val);
 624                         continue;
 625                 }
 626                 d_cfg.val_bits = val;
 627
 628                 __isc_create_dev(isc_mgr, &d_cfg);
 629         }
 630 }
 631
 632 static int isc_mgr_of_get_grp_gpio(
 633         struct device *dev, struct device_node *np,
 634         const char *name, int size, u32 *grp, u32 *flags)
 635 {
 636         int num, i;
 637
 638         num = of_gpio_named_count(np, name);
 639         dev_dbg(dev, "    num gpios of %s: %d\n", name, num);
 640         if (num < 0)
 641                 return 0;
 642
 643         for (i = 0; (i < num) && (i < size); i++) {
 644                 grp[i] = of_get_named_gpio_flags(np, name, i, &flags[i]);
 645                 if ((int)grp[i] < 0) {
 646                         dev_err(dev, "%s: gpio[%d] invalid\n", __func__, i);
 647                         return -EINVAL;
 648                 }
 649                 dev_dbg(dev, "        [%d] - %d %x\n", i, grp[i], flags[i]);
 650         }
 651
 652         return num;
 653 }
 654
 655 static int isc_mgr_get_pwr_map(
 656         struct device *dev, struct device_node *np,
 657         struct isc_mgr_platform_data *pd)
 658 {
 659         int num_map_items = 0;
 660         u32 pwr_map_val;
 661         unsigned int i;
 662
 663         for (i = 0; i < MAX_ISC_GPIOS; i++)
 664                 pd->pwr_mapping[i] = i;
 665
 666         if (!of_get_property(np, "pwr-items", NULL))
 667                 return 0;
 668
 669         num_map_items = of_property_count_elems_of_size(np,
 670                                 "pwr-items", sizeof(u32));
 671         if (num_map_items < 0) {
 672                 dev_err(dev, "%s: error processing pwr items\n",
 673                         __func__);
 674                 return -1;
 675         }
 676
 677         if (num_map_items < pd->num_pwr_gpios) {
 678                 dev_err(dev, "%s: invalid number of pwr items\n",
 679                         __func__);
 680                 return -1;
 681         }
 682
 683         for (i = 0; i < num_map_items; i++) {
 684                 if (of_property_read_u32_index(np, "pwr-items",
 685                         i, &pwr_map_val)) {
 686                         dev_err(dev, "%s: failed to get pwr item\n",
 687                                 __func__);
 688                         goto pwr_map_err;
 689                 }
 690
 691                 if (pwr_map_val >= pd->num_pwr_gpios) {
 692                         dev_err(dev, "%s: invalid power item index provided\n",
 693                                 __func__);
 694                         goto pwr_map_err;
 695                 }
 696                 pd->pwr_mapping[i] = pwr_map_val;
 697         }
 698
 699         pd->num_pwr_map = num_map_items;
 700         return 0;
 701
 702 pwr_map_err:
 703         for (i = 0; i < MAX_ISC_GPIOS; i++)
 704                 pd->pwr_mapping[i] = i;
 705
 706         pd->num_pwr_map = pd->num_pwr_gpios;
 707
 708         return -1;
 709 }
 710
 711 static struct isc_mgr_platform_data *of_isc_mgr_pdata(struct platform_device
 712         *pdev)
 713 {
 714         struct device_node *np = pdev->dev.of_node;
 715         struct isc_mgr_platform_data *pd = NULL;
 716         int err;
 717
 718         dev_dbg(&pdev->dev, "%s\n", __func__);
 719         pd = devm_kzalloc(&pdev->dev, sizeof(*pd), GFP_KERNEL);
 720         if (!pd) {
 721                 dev_err(&pdev->dev, "%s: allocate memory error\n", __func__);
 722                 return ERR_PTR(-ENOMEM);
 723         }
 724
 725         pd->drv_name = (void *)of_get_property(np, "drv_name", NULL);
 726         if (pd->drv_name)
 727                 dev_dbg(&pdev->dev, "    drvname: %s\n", pd->drv_name);
 728
 729         err = of_property_read_u32(np, "i2c-bus", &pd->bus);
 730         if (err) {
 731                 dev_err(&pdev->dev, "%s: missing i2c bus # DT %s\n",
 732                         __func__, np->full_name);
 733                 return ERR_PTR(-EEXIST);
 734         }
 735         dev_dbg(&pdev->dev, "    i2c-bus: %d\n", pd->bus);
 736
 737         err = of_property_read_u32(np, "csi-port", &pd->csi_port);
 738         if (err) {
 739                 dev_err(&pdev->dev, "%s: missing csi port # DT %s\n",
 740                         __func__, np->full_name);
 741                 return ERR_PTR(-EEXIST);
 742         }
 743         dev_dbg(&pdev->dev, "    csiport: %d\n", pd->csi_port);
 744
 745         pd->num_pwr_gpios = isc_mgr_of_get_grp_gpio(
 746                 &pdev->dev, np, "pwdn-gpios",
 747                 ARRAY_SIZE(pd->pwr_gpios), pd->pwr_gpios, pd->pwr_flags);
 748         if (pd->num_pwr_gpios < 0)
 749                 return ERR_PTR(pd->num_pwr_gpios);
 750
 751         pd->num_misc_gpios = isc_mgr_of_get_grp_gpio(
 752                 &pdev->dev, np, "misc-gpios",
 753                 ARRAY_SIZE(pd->misc_gpios), pd->misc_gpios, pd->misc_flags);
 754         if (pd->num_misc_gpios < 0)
 755                 return ERR_PTR(pd->num_misc_gpios);
 756
 757         pd->default_pwr_on = of_property_read_bool(np, "default-power-on");
 758         pd->runtime_pwrctrl_off =
 759                 of_property_read_bool(np, "runtime-pwrctrl-off");
 760
 761         err = isc_mgr_get_pwr_map(&pdev->dev, np, pd);
 762         if (err)
 763                 dev_err(&pdev->dev,
 764                         "%s: failed to map pwr items. Using default values\n",
 765                         __func__);
 766
 767         return pd;
 768 }
 769
 770 static char *isc_mgr_devnode(struct device *dev, umode_t *mode)
 771 {
 772         if (!mode)
 773                 return NULL;
 774
 775         /* set alway user to access this device */
 776         *mode = 0666;
 777
 778         return NULL;
 779 }
 780
 781 static int isc_mgr_probe(struct platform_device *pdev)
 782 {
 783         int err = 0;
 784         struct isc_mgr_priv *isc_mgr;
 785         struct isc_mgr_platform_data *pd;
 786         unsigned int i;
 787
 788         dev_info(&pdev->dev, "%sing...\n", __func__);
 789
 790         isc_mgr = devm_kzalloc(&pdev->dev,
 791                         sizeof(struct isc_mgr_priv),
 792                         GFP_KERNEL);
 793         if (!isc_mgr) {
 794                 dev_err(&pdev->dev, "Unable to allocate memory!\n");
 795                 return -ENOMEM;
 796         }
 797
 798         spin_lock_init(&isc_mgr->spinlock);
 799         atomic_set(&isc_mgr->in_use, 0);
 800         INIT_LIST_HEAD(&isc_mgr->dev_list);
 801         mutex_init(&isc_mgr->mutex);
 802         isc_mgr->pwm = NULL;
 803
 804         if (pdev->dev.of_node) {
 805                 pd = of_isc_mgr_pdata(pdev);
 806                 if (IS_ERR(pd))
 807                         return PTR_ERR(pd);
 808                 isc_mgr->pdata = pd;
 809         } else if (pdev->dev.platform_data) {
 810                 isc_mgr->pdata = pdev->dev.platform_data;
 811                 pd = isc_mgr->pdata;
 812         } else {
 813                 dev_err(&pdev->dev, "%s No platform data.\n", __func__);
 814                 return -EFAULT;
 815         }
 816
 817         if (of_property_read_bool(pdev->dev.of_node, "pwms")) {
 818                 isc_mgr->pwm = devm_pwm_get(&pdev->dev, NULL);
 819                 if (!IS_ERR(isc_mgr->pwm)) {
 820                         dev_info(&pdev->dev,
 821                                 "%s: success to get PWM\n", __func__);
 822                         pwm_disable(isc_mgr->pwm);
 823                 } else {
 824                         err = PTR_ERR(isc_mgr->pwm);
 825                         if (err != -EPROBE_DEFER)
 826                                 dev_err(&pdev->dev,
 827                                         "%s: fail to get PWM\n", __func__);
 828                         return err;
 829                 }
 830         }
 831
 832         isc_mgr->adap = i2c_get_adapter(pd->bus);
 833         if (!isc_mgr->adap) {
 834                 dev_err(&pdev->dev, "%s no such i2c bus %d\n",
 835                         __func__, pd->bus);
 836                 return -ENODEV;
 837         }
 838
 839         if (pd->num_pwr_gpios > 0) {
 840                 for (i = 0; i < pd->num_pwr_gpios; i++) {
 841                         if (!gpio_is_valid(pd->pwr_gpios[i]))
 842                                 goto err_probe;
 843
 844                         if (devm_gpio_request(
 845                                 &pdev->dev, pd->pwr_gpios[i], "pwdn-gpios")) {
 846                                 dev_err(&pdev->dev, "failed to req GPIO: %d\n",
 847                                         pd->pwr_gpios[i]);
 848                                 goto err_probe;
 849                         }
 850
 851                         err = gpio_direction_output(pd->pwr_gpios[i],
 852                                 pd->default_pwr_on ?
 853                                 PW_ON(pd->pwr_flags[i]) :
 854                                 PW_OFF(pd->pwr_flags[i]));
 855                         if (err < 0) {
 856                                 dev_err(&pdev->dev, "failed to setup GPIO: %d\n",
 857                                         pd->pwr_gpios[i]);
 858                                 i++;
 859                                 goto err_probe;
 860                         }
 861                         if (pd->default_pwr_on)
 862                                 isc_mgr->pwr_state |= BIT(i);
 863                 }
 864         }
 865
 866         isc_mgr->err_irq = platform_get_irq(pdev, 0);
 867         if (isc_mgr->err_irq > 0) {
 868                 err = devm_request_irq(&pdev->dev,
 869                                 isc_mgr->err_irq,
 870                                 isc_mgr_isr, 0, pdev->name, isc_mgr);
 871                 if (err) {
 872                         dev_err(&pdev->dev,
 873                                 "request_irq failed with err %d\n", err);
 874                         isc_mgr->err_irq = 0;
 875                         goto err_probe;
 876                 }
 877                 disable_irq(isc_mgr->err_irq);
 878                 atomic_set(&isc_mgr->irq_in_use, 0);
 879         }
 880
 881         isc_mgr->pdev = &pdev->dev;
 882         dev_set_drvdata(&pdev->dev, isc_mgr);
 883
 884         if (pd->drv_name)
 885                 snprintf(isc_mgr->devname, sizeof(isc_mgr->devname),
 886                         "%s.%x.%c", pd->drv_name, pd->bus, 'a' + pd->csi_port);
 887         else
 888                 snprintf(isc_mgr->devname, sizeof(isc_mgr->devname),
 889                         "isc-mgr.%x.%c", pd->bus, 'a' + pd->csi_port);
 890
 891         /* Request dynamic allocation of a device major number */
 892         err = alloc_chrdev_region(&isc_mgr->devt,
 893                                 0, ISC_DEV_MAX, isc_mgr->devname);
 894         if (err < 0) {
 895                 dev_err(&pdev->dev, "failed to allocate char dev region %d\n",
 896                         err);
 897                 goto err_probe;
 898         }
 899
 900         /* poluate sysfs entries */
 901         isc_mgr->isc_class = class_create(THIS_MODULE, isc_mgr->devname);
 902         if (IS_ERR(isc_mgr->isc_class)) {
 903                 err = PTR_ERR(isc_mgr->isc_class);
 904                 isc_mgr->isc_class = NULL;
 905                 dev_err(&pdev->dev, "failed to create class %d\n",
 906                         err);
 907                 goto err_probe;
 908         }
 909
 910         isc_mgr->isc_class->devnode = isc_mgr_devnode;
 911
 912         /* connect the file operations with the cdev */
 913         cdev_init(&isc_mgr->cdev, &isc_mgr_fileops);
 914         isc_mgr->cdev.owner = THIS_MODULE;
 915
 916         /* connect the major/minor number to this dev */
 917         err = cdev_add(&isc_mgr->cdev, MKDEV(MAJOR(isc_mgr->devt), 0), 1);
 918         if (err) {
 919                 dev_err(&pdev->dev, "Unable to add cdev %d\n", err);
 920                 goto err_probe;
 921         }
 922
 923         /* send uevents to udev, it will create /dev node for isc-mgr */
 924         isc_mgr->dev = device_create(isc_mgr->isc_class, &pdev->dev,
 925                                      isc_mgr->cdev.dev,
 926                                      isc_mgr,
 927                                      isc_mgr->devname);
 928         if (IS_ERR(isc_mgr->dev)) {
 929                 err = PTR_ERR(isc_mgr->dev);
 930                 isc_mgr->dev = NULL;
 931                 dev_err(&pdev->dev, "failed to create device %d\n", err);
 932                 goto err_probe;
 933         }
 934
 935         isc_mgr_debugfs_init(isc_mgr);
 936         INIT_WORK(&isc_mgr->ins_work, isc_mgr_dev_ins);
 937         schedule_work(&isc_mgr->ins_work);
 938         return 0;
 939
 940 err_probe:
 941         isc_mgr_del(isc_mgr);
 942         return err;
 943 }
 944
 945 static int isc_mgr_remove(struct platform_device *pdev)
 946 {
 947         struct isc_mgr_priv *isc_mgr = dev_get_drvdata(&pdev->dev);
 948
 949         if (isc_mgr) {
 950                 isc_mgr_debugfs_remove(isc_mgr);
 951                 isc_mgr_del(isc_mgr);
 952
 953                 if (isc_mgr->dev)
 954                         device_destroy(isc_mgr->isc_class,
 955                                        isc_mgr->cdev.dev);
 956                 if (isc_mgr->cdev.dev)
 957                         cdev_del(&isc_mgr->cdev);
 958
 959                 if (isc_mgr->isc_class)
 960                         class_destroy(isc_mgr->isc_class);
 961
 962                 if (isc_mgr->devt)
 963                         unregister_chrdev_region(isc_mgr->devt, ISC_DEV_MAX);
 964         }
 965
 966         return 0;
 967 }
 968
 969 static const struct of_device_id isc_mgr_of_match[] = {
 970         { .compatible = "nvidia,isc-mgr", },
 971         { }
 972 };
 973 MODULE_DEVICE_TABLE(of, isc_mgr_of_match);
 974
 975 static struct platform_driver isc_mgr_driver = {
 976         .driver = {
 977                 .name = "isc-mgr",
 978                 .owner = THIS_MODULE,
 979                 .of_match_table = of_match_ptr(isc_mgr_of_match)
 980         },
 981         .probe = isc_mgr_probe,
 982         .remove = isc_mgr_remove,
 983 };
 984
 985 module_platform_driver(isc_mgr_driver);
 986
 987 MODULE_DESCRIPTION("tegra auto isc manager driver");
 988 MODULE_AUTHOR("Songhee Baek <sbeak@nvidia.com>");
 989 MODULE_LICENSE("GPL v2");
 990 MODULE_ALIAS("platform:isc_mgr");