drivers/pwm/sysfs.c

   1 /*
   2  * A simple sysfs interface for the generic PWM framework
   3  *
   4  * Copyright (C) 2013 H Hartley Sweeten <hsweeten@visionengravers.com>
   5  *
   6  * Based on previous work by Lars Poeschel <poeschel@lemonage.de>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2, or (at your option)
  11  * any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  */
  18
  19 #include <linux/device.h>
  20 #include <linux/mutex.h>
  21 #include <linux/err.h>
  22 #include <linux/slab.h>
  23 #include <linux/kdev_t.h>
  24 #include <linux/pwm.h>
  25
  26 struct pwm_export {
  27         struct device child;
  28         struct pwm_device *pwm;
  29         struct mutex lock;
  30 };
  31
  32 static struct pwm_export *child_to_pwm_export(struct device *child)
  33 {
  34         return container_of(child, struct pwm_export, child);
  35 }
  36
  37 static struct pwm_device *child_to_pwm_device(struct device *child)
  38 {
  39         struct pwm_export *export = child_to_pwm_export(child);
  40
  41         return export->pwm;
  42 }
  43
  44 static ssize_t period_show(struct device *child,
  45                            struct device_attribute *attr,
  46                            char *buf)
  47 {
  48         const struct pwm_device *pwm = child_to_pwm_device(child);
  49         struct pwm_state state;
  50
  51         pwm_get_state(pwm, &state);
  52
  53         return sprintf(buf, "%u\n", state.period);
  54 }
  55
  56 static ssize_t period_store(struct device *child,
  57                             struct device_attribute *attr,
  58                             const char *buf, size_t size)
  59 {
  60         struct pwm_export *export = child_to_pwm_export(child);
  61         struct pwm_device *pwm = export->pwm;
  62         struct pwm_state state;
  63         unsigned int val;
  64         int ret;
  65
  66         ret = kstrtouint(buf, 0, &val);
  67         if (ret)
  68                 return ret;
  69
  70         mutex_lock(&export->lock);
  71         pwm_get_state(pwm, &state);
  72         state.period = val;
  73         ret = pwm_apply_state(pwm, &state);
  74         mutex_unlock(&export->lock);
  75
  76         return ret ? : size;
  77 }
  78
  79 static ssize_t duty_cycle_show(struct device *child,
  80                                struct device_attribute *attr,
  81                                char *buf)
  82 {
  83         const struct pwm_device *pwm = child_to_pwm_device(child);
  84         struct pwm_state state;
  85
  86         pwm_get_state(pwm, &state);
  87
  88         return sprintf(buf, "%u\n", state.duty_cycle);
  89 }
  90
  91 static ssize_t duty_cycle_store(struct device *child,
  92                                 struct device_attribute *attr,
  93                                 const char *buf, size_t size)
  94 {
  95         struct pwm_export *export = child_to_pwm_export(child);
  96         struct pwm_device *pwm = export->pwm;
  97         struct pwm_state state;
  98         unsigned int val;
  99         int ret;
 100
 101         ret = kstrtouint(buf, 0, &val);
 102         if (ret)
 103                 return ret;
 104
 105         mutex_lock(&export->lock);
 106         pwm_get_state(pwm, &state);
 107         state.duty_cycle = val;
 108         ret = pwm_apply_state(pwm, &state);
 109         mutex_unlock(&export->lock);
 110
 111         return ret ? : size;
 112 }
 113
 114 static ssize_t enable_show(struct device *child,
 115                            struct device_attribute *attr,
 116                            char *buf)
 117 {
 118         const struct pwm_device *pwm = child_to_pwm_device(child);
 119         struct pwm_state state;
 120
 121         pwm_get_state(pwm, &state);
 122
 123         return sprintf(buf, "%d\n", state.enabled);
 124 }
 125
 126 static ssize_t enable_store(struct device *child,
 127                             struct device_attribute *attr,
 128                             const char *buf, size_t size)
 129 {
 130         struct pwm_export *export = child_to_pwm_export(child);
 131         struct pwm_device *pwm = export->pwm;
 132         struct pwm_state state;
 133         int val, ret;
 134
 135         ret = kstrtoint(buf, 0, &val);
 136         if (ret)
 137                 return ret;
 138
 139         mutex_lock(&export->lock);
 140
 141         pwm_get_state(pwm, &state);
 142
 143         switch (val) {
 144         case 0:
 145                 state.enabled = false;
 146                 break;
 147         case 1:
 148                 state.enabled = true;
 149                 break;
 150         default:
 151                 ret = -EINVAL;
 152                 goto unlock;
 153         }
 154
 155         ret = pwm_apply_state(pwm, &state);
 156
 157 unlock:
 158         mutex_unlock(&export->lock);
 159         return ret ? : size;
 160 }
 161
 162 static ssize_t polarity_show(struct device *child,
 163                              struct device_attribute *attr,
 164                              char *buf)
 165 {
 166         const struct pwm_device *pwm = child_to_pwm_device(child);
 167         const char *polarity = "unknown";
 168         struct pwm_state state;
 169
 170         pwm_get_state(pwm, &state);
 171
 172         switch (state.polarity) {
 173         case PWM_POLARITY_NORMAL:
 174                 polarity = "normal";
 175                 break;
 176
 177         case PWM_POLARITY_INVERSED:
 178                 polarity = "inversed";
 179                 break;
 180         }
 181
 182         return sprintf(buf, "%s\n", polarity);
 183 }
 184
 185 static ssize_t polarity_store(struct device *child,
 186                               struct device_attribute *attr,
 187                               const char *buf, size_t size)
 188 {
 189         struct pwm_export *export = child_to_pwm_export(child);
 190         struct pwm_device *pwm = export->pwm;
 191         enum pwm_polarity polarity;
 192         struct pwm_state state;
 193         int ret;
 194
 195         if (sysfs_streq(buf, "normal"))
 196                 polarity = PWM_POLARITY_NORMAL;
 197         else if (sysfs_streq(buf, "inversed"))
 198                 polarity = PWM_POLARITY_INVERSED;
 199         else
 200                 return -EINVAL;
 201
 202         mutex_lock(&export->lock);
 203         pwm_get_state(pwm, &state);
 204         state.polarity = polarity;
 205         ret = pwm_apply_state(pwm, &state);
 206         mutex_unlock(&export->lock);
 207
 208         return ret ? : size;
 209 }
 210
 211 static ssize_t capture_show(struct device *child,
 212                             struct device_attribute *attr,
 213                             char *buf)
 214 {
 215         struct pwm_device *pwm = child_to_pwm_device(child);
 216         struct pwm_capture result;
 217         int ret;
 218
 219         ret = pwm_capture(pwm, &result, jiffies_to_msecs(HZ));
 220         if (ret)
 221                 return ret;
 222
 223         return sprintf(buf, "%u %u\n", result.period, result.duty_cycle);
 224 }
 225
 226 static DEVICE_ATTR_RW(period);
 227 static DEVICE_ATTR_RW(duty_cycle);
 228 static DEVICE_ATTR_RW(enable);
 229 static DEVICE_ATTR_RW(polarity);
 230 static DEVICE_ATTR_RO(capture);
 231
 232 static struct attribute *pwm_attrs[] = {
 233         &dev_attr_period.attr,
 234         &dev_attr_duty_cycle.attr,
 235         &dev_attr_enable.attr,
 236         &dev_attr_polarity.attr,
 237         &dev_attr_capture.attr,
 238         NULL
 239 };
 240 ATTRIBUTE_GROUPS(pwm);
 241
 242 static void pwm_export_release(struct device *child)
 243 {
 244         struct pwm_export *export = child_to_pwm_export(child);
 245
 246         kfree(export);
 247 }
 248
 249 static int pwm_export_child(struct device *parent, struct pwm_device *pwm)
 250 {
 251         struct pwm_export *export;
 252         char *pwm_prop[2];
 253         int ret;
 254
 255         if (test_and_set_bit(PWMF_EXPORTED, &pwm->flags))
 256                 return -EBUSY;
 257
 258         export = kzalloc(sizeof(*export), GFP_KERNEL);
 259         if (!export) {
 260                 clear_bit(PWMF_EXPORTED, &pwm->flags);
 261                 return -ENOMEM;
 262         }
 263
 264         export->pwm = pwm;
 265         mutex_init(&export->lock);
 266
 267         export->child.release = pwm_export_release;
 268         export->child.parent = parent;
 269         export->child.devt = MKDEV(0, 0);
 270         export->child.groups = pwm_groups;
 271         dev_set_name(&export->child, "pwm%u", pwm->hwpwm);
 272
 273         ret = device_register(&export->child);
 274         if (ret) {
 275                 clear_bit(PWMF_EXPORTED, &pwm->flags);
 276                 put_device(&export->child);
 277                 export = NULL;
 278                 return ret;
 279         }
 280         pwm_prop[0] = kasprintf(GFP_KERNEL, "EXPORT=pwm%u", pwm->hwpwm);
 281         pwm_prop[1] = NULL;
 282         kobject_uevent_env(&parent->kobj, KOBJ_CHANGE, pwm_prop);
 283         kfree(pwm_prop[0]);
 284
 285         return 0;
 286 }
 287
 288 static int pwm_unexport_match(struct device *child, void *data)
 289 {
 290         return child_to_pwm_device(child) == data;
 291 }
 292
 293 static int pwm_unexport_child(struct device *parent, struct pwm_device *pwm)
 294 {
 295         struct device *child;
 296         char *pwm_prop[2];
 297
 298         if (!test_and_clear_bit(PWMF_EXPORTED, &pwm->flags))
 299                 return -ENODEV;
 300
 301         child = device_find_child(parent, pwm, pwm_unexport_match);
 302         if (!child)
 303                 return -ENODEV;
 304
 305         pwm_prop[0] = kasprintf(GFP_KERNEL, "UNEXPORT=pwm%u", pwm->hwpwm);
 306         pwm_prop[1] = NULL;
 307         kobject_uevent_env(&parent->kobj, KOBJ_CHANGE, pwm_prop);
 308         kfree(pwm_prop[0]);
 309
 310         /* for device_find_child() */
 311         put_device(child);
 312         device_unregister(child);
 313         pwm_put(pwm);
 314
 315         return 0;
 316 }
 317
 318 static ssize_t export_store(struct device *parent,
 319                             struct device_attribute *attr,
 320                             const char *buf, size_t len)
 321 {
 322         struct pwm_chip *chip = dev_get_drvdata(parent);
 323         struct pwm_device *pwm;
 324         unsigned int hwpwm;
 325         int ret;
 326
 327         ret = kstrtouint(buf, 0, &hwpwm);
 328         if (ret < 0)
 329                 return ret;
 330
 331         if (hwpwm >= chip->npwm)
 332                 return -ENODEV;
 333
 334         pwm = pwm_request_from_chip(chip, hwpwm, "sysfs");
 335         if (IS_ERR(pwm))
 336                 return PTR_ERR(pwm);
 337
 338         ret = pwm_export_child(parent, pwm);
 339         if (ret < 0)
 340                 pwm_put(pwm);
 341
 342         return ret ? : len;
 343 }
 344 static DEVICE_ATTR_WO(export);
 345
 346 static ssize_t unexport_store(struct device *parent,
 347                               struct device_attribute *attr,
 348                               const char *buf, size_t len)
 349 {
 350         struct pwm_chip *chip = dev_get_drvdata(parent);
 351         unsigned int hwpwm;
 352         int ret;
 353
 354         ret = kstrtouint(buf, 0, &hwpwm);
 355         if (ret < 0)
 356                 return ret;
 357
 358         if (hwpwm >= chip->npwm)
 359                 return -ENODEV;
 360
 361         ret = pwm_unexport_child(parent, &chip->pwms[hwpwm]);
 362
 363         return ret ? : len;
 364 }
 365 static DEVICE_ATTR_WO(unexport);
 366
 367 static ssize_t npwm_show(struct device *parent, struct device_attribute *attr,
 368                          char *buf)
 369 {
 370         const struct pwm_chip *chip = dev_get_drvdata(parent);
 371
 372         return sprintf(buf, "%u\n", chip->npwm);
 373 }
 374 static DEVICE_ATTR_RO(npwm);
 375
 376 static struct attribute *pwm_chip_attrs[] = {
 377         &dev_attr_export.attr,
 378         &dev_attr_unexport.attr,
 379         &dev_attr_npwm.attr,
 380         NULL,
 381 };
 382 ATTRIBUTE_GROUPS(pwm_chip);
 383
 384 static struct class pwm_class = {
 385         .name = "pwm",
 386         .owner = THIS_MODULE,
 387         .dev_groups = pwm_chip_groups,
 388 };
 389
 390 static int pwmchip_sysfs_match(struct device *parent, const void *data)
 391 {
 392         return dev_get_drvdata(parent) == data;
 393 }
 394
 395 void pwmchip_sysfs_export(struct pwm_chip *chip)
 396 {
 397         struct device *parent;
 398
 399         /*
 400          * If device_create() fails the pwm_chip is still usable by
 401          * the kernel its just not exported.
 402          */
 403         parent = device_create(&pwm_class, chip->dev, MKDEV(0, 0), chip,
 404                                "pwmchip%d", chip->base);
 405         if (IS_ERR(parent)) {
 406                 dev_warn(chip->dev,
 407                          "device_create failed for pwm_chip sysfs export\n");
 408         }
 409 }
 410
 411 void pwmchip_sysfs_unexport(struct pwm_chip *chip)
 412 {
 413         struct device *parent;
 414
 415         parent = class_find_device(&pwm_class, NULL, chip,
 416                                    pwmchip_sysfs_match);
 417         if (parent) {
 418                 /* for class_find_device() */
 419                 put_device(parent);
 420                 device_unregister(parent);
 421         }
 422 }
 423
 424 void pwmchip_sysfs_unexport_children(struct pwm_chip *chip)
 425 {
 426         struct device *parent;
 427         unsigned int i;
 428
 429         parent = class_find_device(&pwm_class, NULL, chip,
 430                                    pwmchip_sysfs_match);
 431         if (!parent)
 432                 return;
 433
 434         for (i = 0; i < chip->npwm; i++) {
 435                 struct pwm_device *pwm = &chip->pwms[i];
 436
 437                 if (test_bit(PWMF_EXPORTED, &pwm->flags))
 438                         pwm_unexport_child(parent, pwm);
 439         }
 440
 441         put_device(parent);
 442 }
 443
 444 static int __init pwm_sysfs_init(void)
 445 {
 446         return class_register(&pwm_class);
 447 }
 448 subsys_initcall(pwm_sysfs_init);