drivers/input/misc/max8997_haptic.c

   1 /*
   2  * MAX8997-haptic controller driver
   3  *
   4  * Copyright (C) 2012 Samsung Electronics
   5  * Donggeun Kim <dg77.kim@samsung.com>
   6  *
   7  * This program is not provided / owned by Maxim Integrated Products.
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  22  *
  23  */
  24
  25 #include <linux/module.h>
  26 #include <linux/init.h>
  27 #include <linux/slab.h>
  28 #include <linux/platform_device.h>
  29 #include <linux/err.h>
  30 #include <linux/pwm.h>
  31 #include <linux/input.h>
  32 #include <linux/mfd/max8997-private.h>
  33 #include <linux/mfd/max8997.h>
  34 #include <linux/regulator/consumer.h>
  35
  36 /* Haptic configuration 2 register */
  37 #define MAX8997_MOTOR_TYPE_SHIFT        7
  38 #define MAX8997_ENABLE_SHIFT            6
  39 #define MAX8997_MODE_SHIFT              5
  40
  41 /* Haptic driver configuration register */
  42 #define MAX8997_CYCLE_SHIFT             6
  43 #define MAX8997_SIG_PERIOD_SHIFT        4
  44 #define MAX8997_SIG_DUTY_SHIFT          2
  45 #define MAX8997_PWM_DUTY_SHIFT          0
  46
  47 struct max8997_haptic {
  48         struct device *dev;
  49         struct i2c_client *client;
  50         struct input_dev *input_dev;
  51         struct regulator *regulator;
  52
  53         struct work_struct work;
  54         struct mutex mutex;
  55
  56         bool enabled;
  57         unsigned int level;
  58
  59         struct pwm_device *pwm;
  60         unsigned int pwm_period;
  61         enum max8997_haptic_pwm_divisor pwm_divisor;
  62
  63         enum max8997_haptic_motor_type type;
  64         enum max8997_haptic_pulse_mode mode;
  65
  66         unsigned int internal_mode_pattern;
  67         unsigned int pattern_cycle;
  68         unsigned int pattern_signal_period;
  69 };
  70
  71 static int max8997_haptic_set_duty_cycle(struct max8997_haptic *chip)
  72 {
  73         int ret = 0;
  74
  75         if (chip->mode == MAX8997_EXTERNAL_MODE) {
  76                 unsigned int duty = chip->pwm_period * chip->level / 100;
  77                 ret = pwm_config(chip->pwm, duty, chip->pwm_period);
  78         } else {
  79                 int i;
  80                 u8 duty_index = 0;
  81
  82                 for (i = 0; i <= 64; i++) {
  83                         if (chip->level <= i * 100 / 64) {
  84                                 duty_index = i;
  85                                 break;
  86                         }
  87                 }
  88                 switch (chip->internal_mode_pattern) {
  89                 case 0:
  90                         max8997_write_reg(chip->client,
  91                                 MAX8997_HAPTIC_REG_SIGPWMDC1, duty_index);
  92                         break;
  93                 case 1:
  94                         max8997_write_reg(chip->client,
  95                                 MAX8997_HAPTIC_REG_SIGPWMDC2, duty_index);
  96                         break;
  97                 case 2:
  98                         max8997_write_reg(chip->client,
  99                                 MAX8997_HAPTIC_REG_SIGPWMDC3, duty_index);
 100                         break;
 101                 case 3:
 102                         max8997_write_reg(chip->client,
 103                                 MAX8997_HAPTIC_REG_SIGPWMDC4, duty_index);
 104                         break;
 105                 default:
 106                         break;
 107                 }
 108         }
 109         return ret;
 110 }
 111
 112 static void max8997_haptic_configure(struct max8997_haptic *chip)
 113 {
 114         u8 value;
 115
 116         value = chip->type << MAX8997_MOTOR_TYPE_SHIFT |
 117                 chip->enabled << MAX8997_ENABLE_SHIFT |
 118                 chip->mode << MAX8997_MODE_SHIFT | chip->pwm_divisor;
 119         max8997_write_reg(chip->client, MAX8997_HAPTIC_REG_CONF2, value);
 120
 121         if (chip->mode == MAX8997_INTERNAL_MODE && chip->enabled) {
 122                 value = chip->internal_mode_pattern << MAX8997_CYCLE_SHIFT |
 123                         chip->internal_mode_pattern << MAX8997_SIG_PERIOD_SHIFT |
 124                         chip->internal_mode_pattern << MAX8997_SIG_DUTY_SHIFT |
 125                         chip->internal_mode_pattern << MAX8997_PWM_DUTY_SHIFT;
 126                 max8997_write_reg(chip->client,
 127                         MAX8997_HAPTIC_REG_DRVCONF, value);
 128
 129                 switch (chip->internal_mode_pattern) {
 130                 case 0:
 131                         value = chip->pattern_cycle << 4;
 132                         max8997_write_reg(chip->client,
 133                                 MAX8997_HAPTIC_REG_CYCLECONF1, value);
 134                         value = chip->pattern_signal_period;
 135                         max8997_write_reg(chip->client,
 136                                 MAX8997_HAPTIC_REG_SIGCONF1, value);
 137                         break;
 138
 139                 case 1:
 140                         value = chip->pattern_cycle;
 141                         max8997_write_reg(chip->client,
 142                                 MAX8997_HAPTIC_REG_CYCLECONF1, value);
 143                         value = chip->pattern_signal_period;
 144                         max8997_write_reg(chip->client,
 145                                 MAX8997_HAPTIC_REG_SIGCONF2, value);
 146                         break;
 147
 148                 case 2:
 149                         value = chip->pattern_cycle << 4;
 150                         max8997_write_reg(chip->client,
 151                                 MAX8997_HAPTIC_REG_CYCLECONF2, value);
 152                         value = chip->pattern_signal_period;
 153                         max8997_write_reg(chip->client,
 154                                 MAX8997_HAPTIC_REG_SIGCONF3, value);
 155                         break;
 156
 157                 case 3:
 158                         value = chip->pattern_cycle;
 159                         max8997_write_reg(chip->client,
 160                                 MAX8997_HAPTIC_REG_CYCLECONF2, value);
 161                         value = chip->pattern_signal_period;
 162                         max8997_write_reg(chip->client,
 163                                 MAX8997_HAPTIC_REG_SIGCONF4, value);
 164                         break;
 165
 166                 default:
 167                         break;
 168                 }
 169         }
 170 }
 171
 172 static void max8997_haptic_enable(struct max8997_haptic *chip)
 173 {
 174         int error;
 175
 176         mutex_lock(&chip->mutex);
 177
 178         error = max8997_haptic_set_duty_cycle(chip);
 179         if (error) {
 180                 dev_err(chip->dev, "set_pwm_cycle failed, error: %d\n", error);
 181                 goto out;
 182         }
 183
 184         if (!chip->enabled) {
 185                 chip->enabled = true;
 186                 regulator_enable(chip->regulator);
 187                 max8997_haptic_configure(chip);
 188                 if (chip->mode == MAX8997_EXTERNAL_MODE)
 189                         pwm_enable(chip->pwm);
 190         }
 191
 192 out:
 193         mutex_unlock(&chip->mutex);
 194 }
 195
 196 static void max8997_haptic_disable(struct max8997_haptic *chip)
 197 {
 198         mutex_lock(&chip->mutex);
 199
 200         if (chip->enabled) {
 201                 chip->enabled = false;
 202                 max8997_haptic_configure(chip);
 203                 if (chip->mode == MAX8997_EXTERNAL_MODE)
 204                         pwm_disable(chip->pwm);
 205                 regulator_disable(chip->regulator);
 206         }
 207
 208         mutex_unlock(&chip->mutex);
 209 }
 210
 211 static void max8997_haptic_play_effect_work(struct work_struct *work)
 212 {
 213         struct max8997_haptic *chip =
 214                         container_of(work, struct max8997_haptic, work);
 215
 216         if (chip->level)
 217                 max8997_haptic_enable(chip);
 218         else
 219                 max8997_haptic_disable(chip);
 220 }
 221
 222 static int max8997_haptic_play_effect(struct input_dev *dev, void *data,
 223                                   struct ff_effect *effect)
 224 {
 225         struct max8997_haptic *chip = input_get_drvdata(dev);
 226
 227         chip->level = effect->u.rumble.strong_magnitude;
 228         if (!chip->level)
 229                 chip->level = effect->u.rumble.weak_magnitude;
 230
 231         schedule_work(&chip->work);
 232
 233         return 0;
 234 }
 235
 236 static void max8997_haptic_close(struct input_dev *dev)
 237 {
 238         struct max8997_haptic *chip = input_get_drvdata(dev);
 239
 240         cancel_work_sync(&chip->work);
 241         max8997_haptic_disable(chip);
 242 }
 243
 244 static int __devinit max8997_haptic_probe(struct platform_device *pdev)
 245 {
 246         struct max8997_dev *iodev = dev_get_drvdata(pdev->dev.parent);
 247         const struct max8997_platform_data *pdata =
 248                                         dev_get_platdata(iodev->dev);
 249         const struct max8997_haptic_platform_data *haptic_pdata =
 250                                         pdata->haptic_pdata;
 251         struct max8997_haptic *chip;
 252         struct input_dev *input_dev;
 253         int error;
 254
 255         if (!haptic_pdata) {
 256                 dev_err(&pdev->dev, "no haptic platform data\n");
 257                 return -EINVAL;
 258         }
 259
 260         chip = kzalloc(sizeof(struct max8997_haptic), GFP_KERNEL);
 261         input_dev = input_allocate_device();
 262         if (!chip || !input_dev) {
 263                 dev_err(&pdev->dev, "unable to allocate memory\n");
 264                 error = -ENOMEM;
 265                 goto err_free_mem;
 266         }
 267
 268         INIT_WORK(&chip->work, max8997_haptic_play_effect_work);
 269         mutex_init(&chip->mutex);
 270
 271         chip->client = iodev->haptic;
 272         chip->dev = &pdev->dev;
 273         chip->input_dev = input_dev;
 274         chip->pwm_period = haptic_pdata->pwm_period;
 275         chip->type = haptic_pdata->type;
 276         chip->mode = haptic_pdata->mode;
 277         chip->pwm_divisor = haptic_pdata->pwm_divisor;
 278
 279         switch (chip->mode) {
 280         case MAX8997_INTERNAL_MODE:
 281                 chip->internal_mode_pattern =
 282                                 haptic_pdata->internal_mode_pattern;
 283                 chip->pattern_cycle = haptic_pdata->pattern_cycle;
 284                 chip->pattern_signal_period =
 285                                 haptic_pdata->pattern_signal_period;
 286                 break;
 287
 288         case MAX8997_EXTERNAL_MODE:
 289                 chip->pwm = pwm_request(haptic_pdata->pwm_channel_id,
 290                                         "max8997-haptic");
 291                 if (IS_ERR(chip->pwm)) {
 292                         error = PTR_ERR(chip->pwm);
 293                         dev_err(&pdev->dev,
 294                                 "unable to request PWM for haptic, error: %d\n",
 295                                 error);
 296                         goto err_free_mem;
 297                 }
 298                 break;
 299
 300         default:
 301                 dev_err(&pdev->dev,
 302                         "Invalid chip mode specified (%d)\n", chip->mode);
 303                 error = -EINVAL;
 304                 goto err_free_mem;
 305         }
 306
 307         chip->regulator = regulator_get(&pdev->dev, "inmotor");
 308         if (IS_ERR(chip->regulator)) {
 309                 error = PTR_ERR(chip->regulator);
 310                 dev_err(&pdev->dev,
 311                         "unable to get regulator, error: %d\n",
 312                         error);
 313                 goto err_free_pwm;
 314         }
 315
 316         input_dev->name = "max8997-haptic";
 317         input_dev->id.version = 1;
 318         input_dev->dev.parent = &pdev->dev;
 319         input_dev->close = max8997_haptic_close;
 320         input_set_drvdata(input_dev, chip);
 321         input_set_capability(input_dev, EV_FF, FF_RUMBLE);
 322
 323         error = input_ff_create_memless(input_dev, NULL,
 324                                 max8997_haptic_play_effect);
 325         if (error) {
 326                 dev_err(&pdev->dev,
 327                         "unable to create FF device, error: %d\n",
 328                         error);
 329                 goto err_put_regulator;
 330         }
 331
 332         error = input_register_device(input_dev);
 333         if (error) {
 334                 dev_err(&pdev->dev,
 335                         "unable to register input device, error: %d\n",
 336                         error);
 337                 goto err_destroy_ff;
 338         }
 339
 340         platform_set_drvdata(pdev, chip);
 341         return 0;
 342
 343 err_destroy_ff:
 344         input_ff_destroy(input_dev);
 345 err_put_regulator:
 346         regulator_put(chip->regulator);
 347 err_free_pwm:
 348         if (chip->mode == MAX8997_EXTERNAL_MODE)
 349                 pwm_free(chip->pwm);
 350 err_free_mem:
 351         input_free_device(input_dev);
 352         kfree(chip);
 353
 354         return error;
 355 }
 356
 357 static int __devexit max8997_haptic_remove(struct platform_device *pdev)
 358 {
 359         struct max8997_haptic *chip = platform_get_drvdata(pdev);
 360
 361         input_unregister_device(chip->input_dev);
 362         regulator_put(chip->regulator);
 363
 364         if (chip->mode == MAX8997_EXTERNAL_MODE)
 365                 pwm_free(chip->pwm);
 366
 367         kfree(chip);
 368
 369         return 0;
 370 }
 371
 372 #ifdef CONFIG_PM_SLEEP
 373 static int max8997_haptic_suspend(struct device *dev)
 374 {
 375         struct platform_device *pdev = to_platform_device(dev);
 376         struct max8997_haptic *chip = platform_get_drvdata(pdev);
 377
 378         max8997_haptic_disable(chip);
 379
 380         return 0;
 381 }
 382 #endif
 383
 384 static SIMPLE_DEV_PM_OPS(max8997_haptic_pm_ops, max8997_haptic_suspend, NULL);
 385
 386 static const struct platform_device_id max8997_haptic_id[] = {
 387         { "max8997-haptic", 0 },
 388         { },
 389 };
 390 MODULE_DEVICE_TABLE(i2c, max8997_haptic_id);
 391
 392 static struct platform_driver max8997_haptic_driver = {
 393         .driver = {
 394                 .name   = "max8997-haptic",
 395                 .owner  = THIS_MODULE,
 396                 .pm     = &max8997_haptic_pm_ops,
 397         },
 398         .probe          = max8997_haptic_probe,
 399         .remove         = __devexit_p(max8997_haptic_remove),
 400         .id_table       = max8997_haptic_id,
 401 };
 402 module_platform_driver(max8997_haptic_driver);
 403
 404 MODULE_ALIAS("platform:max8997-haptic");
 405 MODULE_AUTHOR("Donggeun Kim <dg77.kim@samsung.com>");
 406 MODULE_DESCRIPTION("max8997_haptic driver");
 407 MODULE_LICENSE("GPL");