drivers/media/rc/ir-rx51.c

   1 /*
   2  *  Copyright (C) 2008 Nokia Corporation
   3  *
   4  *  Based on lirc_serial.c
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  */
  16 #include <linux/clk.h>
  17 #include <linux/module.h>
  18 #include <linux/interrupt.h>
  19 #include <linux/uaccess.h>
  20 #include <linux/platform_device.h>
  21 #include <linux/sched.h>
  22 #include <linux/wait.h>
  23 #include <linux/pwm.h>
  24 #include <linux/of.h>
  25 #include <linux/hrtimer.h>
  26
  27 #include <media/lirc.h>
  28 #include <media/lirc_dev.h>
  29 #include <linux/platform_data/media/ir-rx51.h>
  30
  31 #define LIRC_RX51_DRIVER_FEATURES (LIRC_CAN_SET_SEND_DUTY_CYCLE |       \
  32                                    LIRC_CAN_SET_SEND_CARRIER |          \
  33                                    LIRC_CAN_SEND_PULSE)
  34
  35 #define DRIVER_NAME "lirc_rx51"
  36
  37 #define WBUF_LEN 256
  38
  39 struct lirc_rx51 {
  40         struct pwm_device *pwm;
  41         struct hrtimer timer;
  42         struct device        *dev;
  43         struct lirc_rx51_platform_data *pdata;
  44         wait_queue_head_t     wqueue;
  45
  46         unsigned int    freq;           /* carrier frequency */
  47         unsigned int    duty_cycle;     /* carrier duty cycle */
  48         int             wbuf[WBUF_LEN];
  49         int             wbuf_index;
  50         unsigned long   device_is_open;
  51 };
  52
  53 static inline void lirc_rx51_on(struct lirc_rx51 *lirc_rx51)
  54 {
  55         pwm_enable(lirc_rx51->pwm);
  56 }
  57
  58 static inline void lirc_rx51_off(struct lirc_rx51 *lirc_rx51)
  59 {
  60         pwm_disable(lirc_rx51->pwm);
  61 }
  62
  63 static int init_timing_params(struct lirc_rx51 *lirc_rx51)
  64 {
  65         struct pwm_device *pwm = lirc_rx51->pwm;
  66         int duty, period = DIV_ROUND_CLOSEST(NSEC_PER_SEC, lirc_rx51->freq);
  67
  68         duty = DIV_ROUND_CLOSEST(lirc_rx51->duty_cycle * period, 100);
  69
  70         pwm_config(pwm, duty, period);
  71
  72         return 0;
  73 }
  74
  75 static enum hrtimer_restart lirc_rx51_timer_cb(struct hrtimer *timer)
  76 {
  77         struct lirc_rx51 *lirc_rx51 =
  78                         container_of(timer, struct lirc_rx51, timer);
  79         ktime_t now;
  80
  81         if (lirc_rx51->wbuf_index < 0) {
  82                 dev_err_ratelimited(lirc_rx51->dev,
  83                                 "BUG wbuf_index has value of %i\n",
  84                                 lirc_rx51->wbuf_index);
  85                 goto end;
  86         }
  87
  88         /*
  89          * If we happen to hit an odd latency spike, loop through the
  90          * pulses until we catch up.
  91          */
  92         do {
  93                 u64 ns;
  94
  95                 if (lirc_rx51->wbuf_index >= WBUF_LEN)
  96                         goto end;
  97                 if (lirc_rx51->wbuf[lirc_rx51->wbuf_index] == -1)
  98                         goto end;
  99
 100                 if (lirc_rx51->wbuf_index % 2)
 101                         lirc_rx51_off(lirc_rx51);
 102                 else
 103                         lirc_rx51_on(lirc_rx51);
 104
 105                 ns = 1000 * lirc_rx51->wbuf[lirc_rx51->wbuf_index];
 106                 hrtimer_add_expires_ns(timer, ns);
 107
 108                 lirc_rx51->wbuf_index++;
 109
 110                 now = timer->base->get_time();
 111
 112         } while (hrtimer_get_expires_tv64(timer) < now.tv64);
 113
 114         return HRTIMER_RESTART;
 115 end:
 116         /* Stop TX here */
 117         lirc_rx51_off(lirc_rx51);
 118         lirc_rx51->wbuf_index = -1;
 119
 120         wake_up_interruptible(&lirc_rx51->wqueue);
 121
 122         return HRTIMER_NORESTART;
 123 }
 124
 125 static ssize_t lirc_rx51_write(struct file *file, const char *buf,
 126                           size_t n, loff_t *ppos)
 127 {
 128         int count, i;
 129         struct lirc_rx51 *lirc_rx51 = file->private_data;
 130
 131         if (n % sizeof(int))
 132                 return -EINVAL;
 133
 134         count = n / sizeof(int);
 135         if ((count > WBUF_LEN) || (count % 2 == 0))
 136                 return -EINVAL;
 137
 138         /* Wait any pending transfers to finish */
 139         wait_event_interruptible(lirc_rx51->wqueue, lirc_rx51->wbuf_index < 0);
 140
 141         if (copy_from_user(lirc_rx51->wbuf, buf, n))
 142                 return -EFAULT;
 143
 144         /* Sanity check the input pulses */
 145         for (i = 0; i < count; i++)
 146                 if (lirc_rx51->wbuf[i] < 0)
 147                         return -EINVAL;
 148
 149         init_timing_params(lirc_rx51);
 150         if (count < WBUF_LEN)
 151                 lirc_rx51->wbuf[count] = -1; /* Insert termination mark */
 152
 153         /*
 154          * Adjust latency requirements so the device doesn't go in too
 155          * deep sleep states
 156          */
 157         lirc_rx51->pdata->set_max_mpu_wakeup_lat(lirc_rx51->dev, 50);
 158
 159         lirc_rx51_on(lirc_rx51);
 160         lirc_rx51->wbuf_index = 1;
 161         hrtimer_start(&lirc_rx51->timer,
 162                       ns_to_ktime(1000 * lirc_rx51->wbuf[0]),
 163                       HRTIMER_MODE_REL);
 164         /*
 165          * Don't return back to the userspace until the transfer has
 166          * finished
 167          */
 168         wait_event_interruptible(lirc_rx51->wqueue, lirc_rx51->wbuf_index < 0);
 169
 170         /* We can sleep again */
 171         lirc_rx51->pdata->set_max_mpu_wakeup_lat(lirc_rx51->dev, -1);
 172
 173         return n;
 174 }
 175
 176 static long lirc_rx51_ioctl(struct file *filep,
 177                         unsigned int cmd, unsigned long arg)
 178 {
 179         int result;
 180         unsigned long value;
 181         unsigned int ivalue;
 182         struct lirc_rx51 *lirc_rx51 = filep->private_data;
 183
 184         switch (cmd) {
 185         case LIRC_GET_SEND_MODE:
 186                 result = put_user(LIRC_MODE_PULSE, (unsigned long *)arg);
 187                 if (result)
 188                         return result;
 189                 break;
 190
 191         case LIRC_SET_SEND_MODE:
 192                 result = get_user(value, (unsigned long *)arg);
 193                 if (result)
 194                         return result;
 195
 196                 /* only LIRC_MODE_PULSE supported */
 197                 if (value != LIRC_MODE_PULSE)
 198                         return -ENOSYS;
 199                 break;
 200
 201         case LIRC_GET_REC_MODE:
 202                 result = put_user(0, (unsigned long *) arg);
 203                 if (result)
 204                         return result;
 205                 break;
 206
 207         case LIRC_GET_LENGTH:
 208                 return -ENOSYS;
 209                 break;
 210
 211         case LIRC_SET_SEND_DUTY_CYCLE:
 212                 result = get_user(ivalue, (unsigned int *) arg);
 213                 if (result)
 214                         return result;
 215
 216                 if (ivalue <= 0 || ivalue > 100) {
 217                         dev_err(lirc_rx51->dev, ": invalid duty cycle %d\n",
 218                                 ivalue);
 219                         return -EINVAL;
 220                 }
 221
 222                 lirc_rx51->duty_cycle = ivalue;
 223                 break;
 224
 225         case LIRC_SET_SEND_CARRIER:
 226                 result = get_user(ivalue, (unsigned int *) arg);
 227                 if (result)
 228                         return result;
 229
 230                 if (ivalue > 500000 || ivalue < 20000) {
 231                         dev_err(lirc_rx51->dev, ": invalid carrier freq %d\n",
 232                                 ivalue);
 233                         return -EINVAL;
 234                 }
 235
 236                 lirc_rx51->freq = ivalue;
 237                 break;
 238
 239         case LIRC_GET_FEATURES:
 240                 result = put_user(LIRC_RX51_DRIVER_FEATURES,
 241                                   (unsigned long *) arg);
 242                 if (result)
 243                         return result;
 244                 break;
 245
 246         default:
 247                 return -ENOIOCTLCMD;
 248         }
 249
 250         return 0;
 251 }
 252
 253 static int lirc_rx51_open(struct inode *inode, struct file *file)
 254 {
 255         struct lirc_rx51 *lirc_rx51 = lirc_get_pdata(file);
 256         BUG_ON(!lirc_rx51);
 257
 258         file->private_data = lirc_rx51;
 259
 260         if (test_and_set_bit(1, &lirc_rx51->device_is_open))
 261                 return -EBUSY;
 262
 263         lirc_rx51->pwm = pwm_get(lirc_rx51->dev, NULL);
 264         if (IS_ERR(lirc_rx51->pwm)) {
 265                 int res = PTR_ERR(lirc_rx51->pwm);
 266
 267                 dev_err(lirc_rx51->dev, "pwm_get failed: %d\n", res);
 268                 return res;
 269         }
 270
 271         return 0;
 272 }
 273
 274 static int lirc_rx51_release(struct inode *inode, struct file *file)
 275 {
 276         struct lirc_rx51 *lirc_rx51 = file->private_data;
 277
 278         hrtimer_cancel(&lirc_rx51->timer);
 279         lirc_rx51_off(lirc_rx51);
 280         pwm_put(lirc_rx51->pwm);
 281
 282         clear_bit(1, &lirc_rx51->device_is_open);
 283
 284         return 0;
 285 }
 286
 287 static struct lirc_rx51 lirc_rx51 = {
 288         .duty_cycle     = 50,
 289         .wbuf_index     = -1,
 290 };
 291
 292 static const struct file_operations lirc_fops = {
 293         .owner          = THIS_MODULE,
 294         .write          = lirc_rx51_write,
 295         .unlocked_ioctl = lirc_rx51_ioctl,
 296         .read           = lirc_dev_fop_read,
 297         .poll           = lirc_dev_fop_poll,
 298         .open           = lirc_rx51_open,
 299         .release        = lirc_rx51_release,
 300 };
 301
 302 static struct lirc_driver lirc_rx51_driver = {
 303         .name           = DRIVER_NAME,
 304         .minor          = -1,
 305         .code_length    = 1,
 306         .data           = &lirc_rx51,
 307         .fops           = &lirc_fops,
 308         .owner          = THIS_MODULE,
 309 };
 310
 311 #ifdef CONFIG_PM
 312
 313 static int lirc_rx51_suspend(struct platform_device *dev, pm_message_t state)
 314 {
 315         /*
 316          * In case the device is still open, do not suspend. Normally
 317          * this should not be a problem as lircd only keeps the device
 318          * open only for short periods of time. We also don't want to
 319          * get involved with race conditions that might happen if we
 320          * were in a middle of a transmit. Thus, we defer any suspend
 321          * actions until transmit has completed.
 322          */
 323         if (test_and_set_bit(1, &lirc_rx51.device_is_open))
 324                 return -EAGAIN;
 325
 326         clear_bit(1, &lirc_rx51.device_is_open);
 327
 328         return 0;
 329 }
 330
 331 static int lirc_rx51_resume(struct platform_device *dev)
 332 {
 333         return 0;
 334 }
 335
 336 #else
 337
 338 #define lirc_rx51_suspend       NULL
 339 #define lirc_rx51_resume        NULL
 340
 341 #endif /* CONFIG_PM */
 342
 343 static int lirc_rx51_probe(struct platform_device *dev)
 344 {
 345         struct pwm_device *pwm;
 346
 347         lirc_rx51_driver.features = LIRC_RX51_DRIVER_FEATURES;
 348         lirc_rx51.pdata = dev->dev.platform_data;
 349
 350         if (!lirc_rx51.pdata) {
 351                 dev_err(&dev->dev, "Platform Data is missing\n");
 352                 return -ENXIO;
 353         }
 354
 355         pwm = pwm_get(&dev->dev, NULL);
 356         if (IS_ERR(pwm)) {
 357                 int err = PTR_ERR(pwm);
 358
 359                 if (err != -EPROBE_DEFER)
 360                         dev_err(&dev->dev, "pwm_get failed: %d\n", err);
 361                 return err;
 362         }
 363
 364         /* Use default, in case userspace does not set the carrier */
 365         lirc_rx51.freq = DIV_ROUND_CLOSEST(pwm_get_period(pwm), NSEC_PER_SEC);
 366         pwm_put(pwm);
 367
 368         hrtimer_init(&lirc_rx51.timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
 369         lirc_rx51.timer.function = lirc_rx51_timer_cb;
 370
 371         lirc_rx51.dev = &dev->dev;
 372         lirc_rx51_driver.dev = &dev->dev;
 373         lirc_rx51_driver.minor = lirc_register_driver(&lirc_rx51_driver);
 374         init_waitqueue_head(&lirc_rx51.wqueue);
 375
 376         if (lirc_rx51_driver.minor < 0) {
 377                 dev_err(lirc_rx51.dev, ": lirc_register_driver failed: %d\n",
 378                        lirc_rx51_driver.minor);
 379                 return lirc_rx51_driver.minor;
 380         }
 381
 382         return 0;
 383 }
 384
 385 static int lirc_rx51_remove(struct platform_device *dev)
 386 {
 387         return lirc_unregister_driver(lirc_rx51_driver.minor);
 388 }
 389
 390 static const struct of_device_id lirc_rx51_match[] = {
 391         {
 392                 .compatible = "nokia,n900-ir",
 393         },
 394         {},
 395 };
 396 MODULE_DEVICE_TABLE(of, lirc_rx51_match);
 397
 398 struct platform_driver lirc_rx51_platform_driver = {
 399         .probe          = lirc_rx51_probe,
 400         .remove         = lirc_rx51_remove,
 401         .suspend        = lirc_rx51_suspend,
 402         .resume         = lirc_rx51_resume,
 403         .driver         = {
 404                 .name   = DRIVER_NAME,
 405                 .of_match_table = of_match_ptr(lirc_rx51_match),
 406         },
 407 };
 408 module_platform_driver(lirc_rx51_platform_driver);
 409
 410 MODULE_DESCRIPTION("LIRC TX driver for Nokia RX51");
 411 MODULE_AUTHOR("Nokia Corporation");
 412 MODULE_LICENSE("GPL");