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