drivers/staging/greybus/pwm.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * PWM Greybus driver.
   4  *
   5  * Copyright 2014 Google Inc.
   6  * Copyright 2014 Linaro Ltd.
   7  */
   8
   9 #include <linux/kernel.h>
  10 #include <linux/module.h>
  11 #include <linux/slab.h>
  12 #include <linux/pwm.h>
  13 #include <linux/greybus.h>
  14
  15 #include "gbphy.h"
  16
  17 struct gb_pwm_chip {
  18         struct gb_connection    *connection;
  19         u8                      pwm_max;        /* max pwm number */
  20
  21         struct pwm_chip         chip;
  22         struct pwm_chip         *pwm;
  23 };
  24 #define pwm_chip_to_gb_pwm_chip(chip) \
  25         container_of(chip, struct gb_pwm_chip, chip)
  26
  27
  28 static int gb_pwm_count_operation(struct gb_pwm_chip *pwmc)
  29 {
  30         struct gb_pwm_count_response response;
  31         int ret;
  32
  33         ret = gb_operation_sync(pwmc->connection, GB_PWM_TYPE_PWM_COUNT,
  34                                 NULL, 0, &response, sizeof(response));
  35         if (ret)
  36                 return ret;
  37         pwmc->pwm_max = response.count;
  38         return 0;
  39 }
  40
  41 static int gb_pwm_activate_operation(struct gb_pwm_chip *pwmc,
  42                                      u8 which)
  43 {
  44         struct gb_pwm_activate_request request;
  45         struct gbphy_device *gbphy_dev;
  46         int ret;
  47
  48         if (which > pwmc->pwm_max)
  49                 return -EINVAL;
  50
  51         request.which = which;
  52
  53         gbphy_dev = to_gbphy_dev(pwmc->chip.dev);
  54         ret = gbphy_runtime_get_sync(gbphy_dev);
  55         if (ret)
  56                 return ret;
  57
  58         ret = gb_operation_sync(pwmc->connection, GB_PWM_TYPE_ACTIVATE,
  59                                 &request, sizeof(request), NULL, 0);
  60
  61         gbphy_runtime_put_autosuspend(gbphy_dev);
  62
  63         return ret;
  64 }
  65
  66 static int gb_pwm_deactivate_operation(struct gb_pwm_chip *pwmc,
  67                                        u8 which)
  68 {
  69         struct gb_pwm_deactivate_request request;
  70         struct gbphy_device *gbphy_dev;
  71         int ret;
  72
  73         if (which > pwmc->pwm_max)
  74                 return -EINVAL;
  75
  76         request.which = which;
  77
  78         gbphy_dev = to_gbphy_dev(pwmc->chip.dev);
  79         ret = gbphy_runtime_get_sync(gbphy_dev);
  80         if (ret)
  81                 return ret;
  82
  83         ret = gb_operation_sync(pwmc->connection, GB_PWM_TYPE_DEACTIVATE,
  84                                 &request, sizeof(request), NULL, 0);
  85
  86         gbphy_runtime_put_autosuspend(gbphy_dev);
  87
  88         return ret;
  89 }
  90
  91 static int gb_pwm_config_operation(struct gb_pwm_chip *pwmc,
  92                                    u8 which, u32 duty, u32 period)
  93 {
  94         struct gb_pwm_config_request request;
  95         struct gbphy_device *gbphy_dev;
  96         int ret;
  97
  98         if (which > pwmc->pwm_max)
  99                 return -EINVAL;
 100
 101         request.which = which;
 102         request.duty = cpu_to_le32(duty);
 103         request.period = cpu_to_le32(period);
 104
 105         gbphy_dev = to_gbphy_dev(pwmc->chip.dev);
 106         ret = gbphy_runtime_get_sync(gbphy_dev);
 107         if (ret)
 108                 return ret;
 109
 110         ret = gb_operation_sync(pwmc->connection, GB_PWM_TYPE_CONFIG,
 111                                 &request, sizeof(request), NULL, 0);
 112
 113         gbphy_runtime_put_autosuspend(gbphy_dev);
 114
 115         return ret;
 116 }
 117
 118 static int gb_pwm_set_polarity_operation(struct gb_pwm_chip *pwmc,
 119                                          u8 which, u8 polarity)
 120 {
 121         struct gb_pwm_polarity_request request;
 122         struct gbphy_device *gbphy_dev;
 123         int ret;
 124
 125         if (which > pwmc->pwm_max)
 126                 return -EINVAL;
 127
 128         request.which = which;
 129         request.polarity = polarity;
 130
 131         gbphy_dev = to_gbphy_dev(pwmc->chip.dev);
 132         ret = gbphy_runtime_get_sync(gbphy_dev);
 133         if (ret)
 134                 return ret;
 135
 136         ret = gb_operation_sync(pwmc->connection, GB_PWM_TYPE_POLARITY,
 137                                 &request, sizeof(request), NULL, 0);
 138
 139         gbphy_runtime_put_autosuspend(gbphy_dev);
 140
 141         return ret;
 142 }
 143
 144 static int gb_pwm_enable_operation(struct gb_pwm_chip *pwmc,
 145                                    u8 which)
 146 {
 147         struct gb_pwm_enable_request request;
 148         struct gbphy_device *gbphy_dev;
 149         int ret;
 150
 151         if (which > pwmc->pwm_max)
 152                 return -EINVAL;
 153
 154         request.which = which;
 155
 156         gbphy_dev = to_gbphy_dev(pwmc->chip.dev);
 157         ret = gbphy_runtime_get_sync(gbphy_dev);
 158         if (ret)
 159                 return ret;
 160
 161         ret = gb_operation_sync(pwmc->connection, GB_PWM_TYPE_ENABLE,
 162                                 &request, sizeof(request), NULL, 0);
 163         if (ret)
 164                 gbphy_runtime_put_autosuspend(gbphy_dev);
 165
 166         return ret;
 167 }
 168
 169 static int gb_pwm_disable_operation(struct gb_pwm_chip *pwmc,
 170                                     u8 which)
 171 {
 172         struct gb_pwm_disable_request request;
 173         struct gbphy_device *gbphy_dev;
 174         int ret;
 175
 176         if (which > pwmc->pwm_max)
 177                 return -EINVAL;
 178
 179         request.which = which;
 180
 181         ret = gb_operation_sync(pwmc->connection, GB_PWM_TYPE_DISABLE,
 182                                 &request, sizeof(request), NULL, 0);
 183
 184         gbphy_dev = to_gbphy_dev(pwmc->chip.dev);
 185         gbphy_runtime_put_autosuspend(gbphy_dev);
 186
 187         return ret;
 188 }
 189
 190 static int gb_pwm_request(struct pwm_chip *chip, struct pwm_device *pwm)
 191 {
 192         struct gb_pwm_chip *pwmc = pwm_chip_to_gb_pwm_chip(chip);
 193
 194         return gb_pwm_activate_operation(pwmc, pwm->hwpwm);
 195 };
 196
 197 static void gb_pwm_free(struct pwm_chip *chip, struct pwm_device *pwm)
 198 {
 199         struct gb_pwm_chip *pwmc = pwm_chip_to_gb_pwm_chip(chip);
 200
 201         if (pwm_is_enabled(pwm))
 202                 dev_warn(chip->dev, "freeing PWM device without disabling\n");
 203
 204         gb_pwm_deactivate_operation(pwmc, pwm->hwpwm);
 205 }
 206
 207 static int gb_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,
 208                          int duty_ns, int period_ns)
 209 {
 210         struct gb_pwm_chip *pwmc = pwm_chip_to_gb_pwm_chip(chip);
 211
 212         return gb_pwm_config_operation(pwmc, pwm->hwpwm, duty_ns, period_ns);
 213 };
 214
 215 static int gb_pwm_set_polarity(struct pwm_chip *chip, struct pwm_device *pwm,
 216                                enum pwm_polarity polarity)
 217 {
 218         struct gb_pwm_chip *pwmc = pwm_chip_to_gb_pwm_chip(chip);
 219
 220         return gb_pwm_set_polarity_operation(pwmc, pwm->hwpwm, polarity);
 221 };
 222
 223 static int gb_pwm_enable(struct pwm_chip *chip, struct pwm_device *pwm)
 224 {
 225         struct gb_pwm_chip *pwmc = pwm_chip_to_gb_pwm_chip(chip);
 226
 227         return gb_pwm_enable_operation(pwmc, pwm->hwpwm);
 228 };
 229
 230 static void gb_pwm_disable(struct pwm_chip *chip, struct pwm_device *pwm)
 231 {
 232         struct gb_pwm_chip *pwmc = pwm_chip_to_gb_pwm_chip(chip);
 233
 234         gb_pwm_disable_operation(pwmc, pwm->hwpwm);
 235 };
 236
 237 static const struct pwm_ops gb_pwm_ops = {
 238         .request = gb_pwm_request,
 239         .free = gb_pwm_free,
 240         .config = gb_pwm_config,
 241         .set_polarity = gb_pwm_set_polarity,
 242         .enable = gb_pwm_enable,
 243         .disable = gb_pwm_disable,
 244         .owner = THIS_MODULE,
 245 };
 246
 247 static int gb_pwm_probe(struct gbphy_device *gbphy_dev,
 248                         const struct gbphy_device_id *id)
 249 {
 250         struct gb_connection *connection;
 251         struct gb_pwm_chip *pwmc;
 252         struct pwm_chip *pwm;
 253         int ret;
 254
 255         pwmc = kzalloc(sizeof(*pwmc), GFP_KERNEL);
 256         if (!pwmc)
 257                 return -ENOMEM;
 258
 259         connection = gb_connection_create(gbphy_dev->bundle,
 260                                           le16_to_cpu(gbphy_dev->cport_desc->id),
 261                                           NULL);
 262         if (IS_ERR(connection)) {
 263                 ret = PTR_ERR(connection);
 264                 goto exit_pwmc_free;
 265         }
 266
 267         pwmc->connection = connection;
 268         gb_connection_set_data(connection, pwmc);
 269         gb_gbphy_set_data(gbphy_dev, pwmc);
 270
 271         ret = gb_connection_enable(connection);
 272         if (ret)
 273                 goto exit_connection_destroy;
 274
 275         /* Query number of pwms present */
 276         ret = gb_pwm_count_operation(pwmc);
 277         if (ret)
 278                 goto exit_connection_disable;
 279
 280         pwm = &pwmc->chip;
 281
 282         pwm->dev = &gbphy_dev->dev;
 283         pwm->ops = &gb_pwm_ops;
 284         pwm->base = -1;                 /* Allocate base dynamically */
 285         pwm->npwm = pwmc->pwm_max + 1;
 286
 287         ret = pwmchip_add(pwm);
 288         if (ret) {
 289                 dev_err(&gbphy_dev->dev,
 290                         "failed to register PWM: %d\n", ret);
 291                 goto exit_connection_disable;
 292         }
 293
 294         gbphy_runtime_put_autosuspend(gbphy_dev);
 295         return 0;
 296
 297 exit_connection_disable:
 298         gb_connection_disable(connection);
 299 exit_connection_destroy:
 300         gb_connection_destroy(connection);
 301 exit_pwmc_free:
 302         kfree(pwmc);
 303         return ret;
 304 }
 305
 306 static void gb_pwm_remove(struct gbphy_device *gbphy_dev)
 307 {
 308         struct gb_pwm_chip *pwmc = gb_gbphy_get_data(gbphy_dev);
 309         struct gb_connection *connection = pwmc->connection;
 310         int ret;
 311
 312         ret = gbphy_runtime_get_sync(gbphy_dev);
 313         if (ret)
 314                 gbphy_runtime_get_noresume(gbphy_dev);
 315
 316         pwmchip_remove(&pwmc->chip);
 317         gb_connection_disable(connection);
 318         gb_connection_destroy(connection);
 319         kfree(pwmc);
 320 }
 321
 322 static const struct gbphy_device_id gb_pwm_id_table[] = {
 323         { GBPHY_PROTOCOL(GREYBUS_PROTOCOL_PWM) },
 324         { },
 325 };
 326 MODULE_DEVICE_TABLE(gbphy, gb_pwm_id_table);
 327
 328 static struct gbphy_driver pwm_driver = {
 329         .name           = "pwm",
 330         .probe          = gb_pwm_probe,
 331         .remove         = gb_pwm_remove,
 332         .id_table       = gb_pwm_id_table,
 333 };
 334
 335 module_gbphy_driver(pwm_driver);
 336 MODULE_LICENSE("GPL v2");