Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * PWM device driver for ST SoCs
0004  *
0005  * Copyright (C) 2013-2016 STMicroelectronics (R&D) Limited
0006  *
0007  * Author: Ajit Pal Singh <ajitpal.singh@st.com>
0008  *         Lee Jones <lee.jones@linaro.org>
0009  */
0010 
0011 #include <linux/clk.h>
0012 #include <linux/interrupt.h>
0013 #include <linux/math64.h>
0014 #include <linux/mfd/syscon.h>
0015 #include <linux/module.h>
0016 #include <linux/of.h>
0017 #include <linux/platform_device.h>
0018 #include <linux/pwm.h>
0019 #include <linux/regmap.h>
0020 #include <linux/sched.h>
0021 #include <linux/slab.h>
0022 #include <linux/time.h>
0023 #include <linux/wait.h>
0024 
0025 #define PWM_OUT_VAL(x)  (0x00 + (4 * (x))) /* Device's Duty Cycle register */
0026 #define PWM_CPT_VAL(x)  (0x10 + (4 * (x))) /* Capture value */
0027 #define PWM_CPT_EDGE(x) (0x30 + (4 * (x))) /* Edge to capture on */
0028 
0029 #define STI_PWM_CTRL        0x50    /* Control/Config register */
0030 #define STI_INT_EN      0x54    /* Interrupt Enable/Disable register */
0031 #define STI_INT_STA     0x58    /* Interrupt Status register */
0032 #define PWM_INT_ACK     0x5c
0033 #define PWM_PRESCALE_LOW_MASK   0x0f
0034 #define PWM_PRESCALE_HIGH_MASK  0xf0
0035 #define PWM_CPT_EDGE_MASK   0x03
0036 #define PWM_INT_ACK_MASK    0x1ff
0037 
0038 #define STI_MAX_CPT_DEVS    4
0039 #define CPT_DC_MAX      0xff
0040 
0041 /* Regfield IDs */
0042 enum {
0043     /* Bits in PWM_CTRL*/
0044     PWMCLK_PRESCALE_LOW,
0045     PWMCLK_PRESCALE_HIGH,
0046     CPTCLK_PRESCALE,
0047 
0048     PWM_OUT_EN,
0049     PWM_CPT_EN,
0050 
0051     PWM_CPT_INT_EN,
0052     PWM_CPT_INT_STAT,
0053 
0054     /* Keep last */
0055     MAX_REGFIELDS
0056 };
0057 
0058 /*
0059  * Each capture input can be programmed to detect rising-edge, falling-edge,
0060  * either edge or neither egde.
0061  */
0062 enum sti_cpt_edge {
0063     CPT_EDGE_DISABLED,
0064     CPT_EDGE_RISING,
0065     CPT_EDGE_FALLING,
0066     CPT_EDGE_BOTH,
0067 };
0068 
0069 struct sti_cpt_ddata {
0070     u32 snapshot[3];
0071     unsigned int index;
0072     struct mutex lock;
0073     wait_queue_head_t wait;
0074 };
0075 
0076 struct sti_pwm_compat_data {
0077     const struct reg_field *reg_fields;
0078     unsigned int pwm_num_devs;
0079     unsigned int cpt_num_devs;
0080     unsigned int max_pwm_cnt;
0081     unsigned int max_prescale;
0082 };
0083 
0084 struct sti_pwm_chip {
0085     struct device *dev;
0086     struct clk *pwm_clk;
0087     struct clk *cpt_clk;
0088     struct regmap *regmap;
0089     struct sti_pwm_compat_data *cdata;
0090     struct regmap_field *prescale_low;
0091     struct regmap_field *prescale_high;
0092     struct regmap_field *pwm_out_en;
0093     struct regmap_field *pwm_cpt_en;
0094     struct regmap_field *pwm_cpt_int_en;
0095     struct regmap_field *pwm_cpt_int_stat;
0096     struct pwm_chip chip;
0097     struct pwm_device *cur;
0098     unsigned long configured;
0099     unsigned int en_count;
0100     struct mutex sti_pwm_lock; /* To sync between enable/disable calls */
0101     void __iomem *mmio;
0102 };
0103 
0104 static const struct reg_field sti_pwm_regfields[MAX_REGFIELDS] = {
0105     [PWMCLK_PRESCALE_LOW] = REG_FIELD(STI_PWM_CTRL, 0, 3),
0106     [PWMCLK_PRESCALE_HIGH] = REG_FIELD(STI_PWM_CTRL, 11, 14),
0107     [CPTCLK_PRESCALE] = REG_FIELD(STI_PWM_CTRL, 4, 8),
0108     [PWM_OUT_EN] = REG_FIELD(STI_PWM_CTRL, 9, 9),
0109     [PWM_CPT_EN] = REG_FIELD(STI_PWM_CTRL, 10, 10),
0110     [PWM_CPT_INT_EN] = REG_FIELD(STI_INT_EN, 1, 4),
0111     [PWM_CPT_INT_STAT] = REG_FIELD(STI_INT_STA, 1, 4),
0112 };
0113 
0114 static inline struct sti_pwm_chip *to_sti_pwmchip(struct pwm_chip *chip)
0115 {
0116     return container_of(chip, struct sti_pwm_chip, chip);
0117 }
0118 
0119 /*
0120  * Calculate the prescaler value corresponding to the period.
0121  */
0122 static int sti_pwm_get_prescale(struct sti_pwm_chip *pc, unsigned long period,
0123                 unsigned int *prescale)
0124 {
0125     struct sti_pwm_compat_data *cdata = pc->cdata;
0126     unsigned long clk_rate;
0127     unsigned long value;
0128     unsigned int ps;
0129 
0130     clk_rate = clk_get_rate(pc->pwm_clk);
0131     if (!clk_rate) {
0132         dev_err(pc->dev, "failed to get clock rate\n");
0133         return -EINVAL;
0134     }
0135 
0136     /*
0137      * prescale = ((period_ns * clk_rate) / (10^9 * (max_pwm_cnt + 1)) - 1
0138      */
0139     value = NSEC_PER_SEC / clk_rate;
0140     value *= cdata->max_pwm_cnt + 1;
0141 
0142     if (period % value)
0143         return -EINVAL;
0144 
0145     ps  = period / value - 1;
0146     if (ps > cdata->max_prescale)
0147         return -EINVAL;
0148 
0149     *prescale = ps;
0150 
0151     return 0;
0152 }
0153 
0154 /*
0155  * For STiH4xx PWM IP, the PWM period is fixed to 256 local clock cycles. The
0156  * only way to change the period (apart from changing the PWM input clock) is
0157  * to change the PWM clock prescaler.
0158  *
0159  * The prescaler is of 8 bits, so 256 prescaler values and hence 256 possible
0160  * period values are supported (for a particular clock rate). The requested
0161  * period will be applied only if it matches one of these 256 values.
0162  */
0163 static int sti_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,
0164               int duty_ns, int period_ns)
0165 {
0166     struct sti_pwm_chip *pc = to_sti_pwmchip(chip);
0167     struct sti_pwm_compat_data *cdata = pc->cdata;
0168     unsigned int ncfg, value, prescale = 0;
0169     struct pwm_device *cur = pc->cur;
0170     struct device *dev = pc->dev;
0171     bool period_same = false;
0172     int ret;
0173 
0174     ncfg = hweight_long(pc->configured);
0175     if (ncfg)
0176         period_same = (period_ns == pwm_get_period(cur));
0177 
0178     /*
0179      * Allow configuration changes if one of the following conditions
0180      * satisfy.
0181      * 1. No devices have been configured.
0182      * 2. Only one device has been configured and the new request is for
0183      *    the same device.
0184      * 3. Only one device has been configured and the new request is for
0185      *    a new device and period of the new device is same as the current
0186      *    configured period.
0187      * 4. More than one devices are configured and period of the new
0188      *    requestis the same as the current period.
0189      */
0190     if (!ncfg ||
0191         ((ncfg == 1) && (pwm->hwpwm == cur->hwpwm)) ||
0192         ((ncfg == 1) && (pwm->hwpwm != cur->hwpwm) && period_same) ||
0193         ((ncfg > 1) && period_same)) {
0194         /* Enable clock before writing to PWM registers. */
0195         ret = clk_enable(pc->pwm_clk);
0196         if (ret)
0197             return ret;
0198 
0199         ret = clk_enable(pc->cpt_clk);
0200         if (ret)
0201             return ret;
0202 
0203         if (!period_same) {
0204             ret = sti_pwm_get_prescale(pc, period_ns, &prescale);
0205             if (ret)
0206                 goto clk_dis;
0207 
0208             value = prescale & PWM_PRESCALE_LOW_MASK;
0209 
0210             ret = regmap_field_write(pc->prescale_low, value);
0211             if (ret)
0212                 goto clk_dis;
0213 
0214             value = (prescale & PWM_PRESCALE_HIGH_MASK) >> 4;
0215 
0216             ret = regmap_field_write(pc->prescale_high, value);
0217             if (ret)
0218                 goto clk_dis;
0219         }
0220 
0221         /*
0222          * When PWMVal == 0, PWM pulse = 1 local clock cycle.
0223          * When PWMVal == max_pwm_count,
0224          * PWM pulse = (max_pwm_count + 1) local cycles,
0225          * that is continuous pulse: signal never goes low.
0226          */
0227         value = cdata->max_pwm_cnt * duty_ns / period_ns;
0228 
0229         ret = regmap_write(pc->regmap, PWM_OUT_VAL(pwm->hwpwm), value);
0230         if (ret)
0231             goto clk_dis;
0232 
0233         ret = regmap_field_write(pc->pwm_cpt_int_en, 0);
0234 
0235         set_bit(pwm->hwpwm, &pc->configured);
0236         pc->cur = pwm;
0237 
0238         dev_dbg(dev, "prescale:%u, period:%i, duty:%i, value:%u\n",
0239             prescale, period_ns, duty_ns, value);
0240     } else {
0241         return -EINVAL;
0242     }
0243 
0244 clk_dis:
0245     clk_disable(pc->pwm_clk);
0246     clk_disable(pc->cpt_clk);
0247     return ret;
0248 }
0249 
0250 static int sti_pwm_enable(struct pwm_chip *chip, struct pwm_device *pwm)
0251 {
0252     struct sti_pwm_chip *pc = to_sti_pwmchip(chip);
0253     struct device *dev = pc->dev;
0254     int ret = 0;
0255 
0256     /*
0257      * Since we have a common enable for all PWM devices, do not enable if
0258      * already enabled.
0259      */
0260     mutex_lock(&pc->sti_pwm_lock);
0261 
0262     if (!pc->en_count) {
0263         ret = clk_enable(pc->pwm_clk);
0264         if (ret)
0265             goto out;
0266 
0267         ret = clk_enable(pc->cpt_clk);
0268         if (ret)
0269             goto out;
0270 
0271         ret = regmap_field_write(pc->pwm_out_en, 1);
0272         if (ret) {
0273             dev_err(dev, "failed to enable PWM device %u: %d\n",
0274                 pwm->hwpwm, ret);
0275             goto out;
0276         }
0277     }
0278 
0279     pc->en_count++;
0280 
0281 out:
0282     mutex_unlock(&pc->sti_pwm_lock);
0283     return ret;
0284 }
0285 
0286 static void sti_pwm_disable(struct pwm_chip *chip, struct pwm_device *pwm)
0287 {
0288     struct sti_pwm_chip *pc = to_sti_pwmchip(chip);
0289 
0290     mutex_lock(&pc->sti_pwm_lock);
0291 
0292     if (--pc->en_count) {
0293         mutex_unlock(&pc->sti_pwm_lock);
0294         return;
0295     }
0296 
0297     regmap_field_write(pc->pwm_out_en, 0);
0298 
0299     clk_disable(pc->pwm_clk);
0300     clk_disable(pc->cpt_clk);
0301 
0302     mutex_unlock(&pc->sti_pwm_lock);
0303 }
0304 
0305 static void sti_pwm_free(struct pwm_chip *chip, struct pwm_device *pwm)
0306 {
0307     struct sti_pwm_chip *pc = to_sti_pwmchip(chip);
0308 
0309     clear_bit(pwm->hwpwm, &pc->configured);
0310 }
0311 
0312 static int sti_pwm_capture(struct pwm_chip *chip, struct pwm_device *pwm,
0313                struct pwm_capture *result, unsigned long timeout)
0314 {
0315     struct sti_pwm_chip *pc = to_sti_pwmchip(chip);
0316     struct sti_pwm_compat_data *cdata = pc->cdata;
0317     struct sti_cpt_ddata *ddata = pwm_get_chip_data(pwm);
0318     struct device *dev = pc->dev;
0319     unsigned int effective_ticks;
0320     unsigned long long high, low;
0321     int ret;
0322 
0323     if (pwm->hwpwm >= cdata->cpt_num_devs) {
0324         dev_err(dev, "device %u is not valid\n", pwm->hwpwm);
0325         return -EINVAL;
0326     }
0327 
0328     mutex_lock(&ddata->lock);
0329     ddata->index = 0;
0330 
0331     /* Prepare capture measurement */
0332     regmap_write(pc->regmap, PWM_CPT_EDGE(pwm->hwpwm), CPT_EDGE_RISING);
0333     regmap_field_write(pc->pwm_cpt_int_en, BIT(pwm->hwpwm));
0334 
0335     /* Enable capture */
0336     ret = regmap_field_write(pc->pwm_cpt_en, 1);
0337     if (ret) {
0338         dev_err(dev, "failed to enable PWM capture %u: %d\n",
0339             pwm->hwpwm, ret);
0340         goto out;
0341     }
0342 
0343     ret = wait_event_interruptible_timeout(ddata->wait, ddata->index > 1,
0344                            msecs_to_jiffies(timeout));
0345 
0346     regmap_write(pc->regmap, PWM_CPT_EDGE(pwm->hwpwm), CPT_EDGE_DISABLED);
0347 
0348     if (ret == -ERESTARTSYS)
0349         goto out;
0350 
0351     switch (ddata->index) {
0352     case 0:
0353     case 1:
0354         /*
0355          * Getting here could mean:
0356          *  - input signal is constant of less than 1 Hz
0357          *  - there is no input signal at all
0358          *
0359          * In such case the frequency is rounded down to 0
0360          */
0361         result->period = 0;
0362         result->duty_cycle = 0;
0363 
0364         break;
0365 
0366     case 2:
0367         /* We have everying we need */
0368         high = ddata->snapshot[1] - ddata->snapshot[0];
0369         low = ddata->snapshot[2] - ddata->snapshot[1];
0370 
0371         effective_ticks = clk_get_rate(pc->cpt_clk);
0372 
0373         result->period = (high + low) * NSEC_PER_SEC;
0374         result->period /= effective_ticks;
0375 
0376         result->duty_cycle = high * NSEC_PER_SEC;
0377         result->duty_cycle /= effective_ticks;
0378 
0379         break;
0380 
0381     default:
0382         dev_err(dev, "internal error\n");
0383         break;
0384     }
0385 
0386 out:
0387     /* Disable capture */
0388     regmap_field_write(pc->pwm_cpt_en, 0);
0389 
0390     mutex_unlock(&ddata->lock);
0391     return ret;
0392 }
0393 
0394 static int sti_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,
0395              const struct pwm_state *state)
0396 {
0397     int err;
0398 
0399     if (state->polarity != PWM_POLARITY_NORMAL)
0400         return -EINVAL;
0401 
0402     if (!state->enabled) {
0403         if (pwm->state.enabled)
0404             sti_pwm_disable(chip, pwm);
0405 
0406         return 0;
0407     }
0408 
0409     err = sti_pwm_config(pwm->chip, pwm, state->duty_cycle, state->period);
0410     if (err)
0411         return err;
0412 
0413     if (!pwm->state.enabled)
0414         err = sti_pwm_enable(chip, pwm);
0415 
0416     return err;
0417 }
0418 
0419 static const struct pwm_ops sti_pwm_ops = {
0420     .capture = sti_pwm_capture,
0421     .apply = sti_pwm_apply,
0422     .free = sti_pwm_free,
0423     .owner = THIS_MODULE,
0424 };
0425 
0426 static irqreturn_t sti_pwm_interrupt(int irq, void *data)
0427 {
0428     struct sti_pwm_chip *pc = data;
0429     struct device *dev = pc->dev;
0430     struct sti_cpt_ddata *ddata;
0431     int devicenum;
0432     unsigned int cpt_int_stat;
0433     unsigned int reg;
0434     int ret = IRQ_NONE;
0435 
0436     ret = regmap_field_read(pc->pwm_cpt_int_stat, &cpt_int_stat);
0437     if (ret)
0438         return ret;
0439 
0440     while (cpt_int_stat) {
0441         devicenum = ffs(cpt_int_stat) - 1;
0442 
0443         ddata = pwm_get_chip_data(&pc->chip.pwms[devicenum]);
0444 
0445         /*
0446          * Capture input:
0447          *    _______                   _______
0448          *   |       |                 |       |
0449          * __|       |_________________|       |________
0450          *   ^0      ^1                ^2
0451          *
0452          * Capture start by the first available rising edge. When a
0453          * capture event occurs, capture value (CPT_VALx) is stored,
0454          * index incremented, capture edge changed.
0455          *
0456          * After the capture, if the index > 1, we have collected the
0457          * necessary data so we signal the thread waiting for it and
0458          * disable the capture by setting capture edge to none
0459          */
0460 
0461         regmap_read(pc->regmap,
0462                 PWM_CPT_VAL(devicenum),
0463                 &ddata->snapshot[ddata->index]);
0464 
0465         switch (ddata->index) {
0466         case 0:
0467         case 1:
0468             regmap_read(pc->regmap, PWM_CPT_EDGE(devicenum), &reg);
0469             reg ^= PWM_CPT_EDGE_MASK;
0470             regmap_write(pc->regmap, PWM_CPT_EDGE(devicenum), reg);
0471 
0472             ddata->index++;
0473             break;
0474 
0475         case 2:
0476             regmap_write(pc->regmap,
0477                      PWM_CPT_EDGE(devicenum),
0478                      CPT_EDGE_DISABLED);
0479             wake_up(&ddata->wait);
0480             break;
0481 
0482         default:
0483             dev_err(dev, "Internal error\n");
0484         }
0485 
0486         cpt_int_stat &= ~BIT_MASK(devicenum);
0487 
0488         ret = IRQ_HANDLED;
0489     }
0490 
0491     /* Just ACK everything */
0492     regmap_write(pc->regmap, PWM_INT_ACK, PWM_INT_ACK_MASK);
0493 
0494     return ret;
0495 }
0496 
0497 static int sti_pwm_probe_dt(struct sti_pwm_chip *pc)
0498 {
0499     struct device *dev = pc->dev;
0500     const struct reg_field *reg_fields;
0501     struct device_node *np = dev->of_node;
0502     struct sti_pwm_compat_data *cdata = pc->cdata;
0503     u32 num_devs;
0504     int ret;
0505 
0506     ret = of_property_read_u32(np, "st,pwm-num-chan", &num_devs);
0507     if (!ret)
0508         cdata->pwm_num_devs = num_devs;
0509 
0510     ret = of_property_read_u32(np, "st,capture-num-chan", &num_devs);
0511     if (!ret)
0512         cdata->cpt_num_devs = num_devs;
0513 
0514     if (!cdata->pwm_num_devs && !cdata->cpt_num_devs) {
0515         dev_err(dev, "No channels configured\n");
0516         return -EINVAL;
0517     }
0518 
0519     reg_fields = cdata->reg_fields;
0520 
0521     pc->prescale_low = devm_regmap_field_alloc(dev, pc->regmap,
0522                     reg_fields[PWMCLK_PRESCALE_LOW]);
0523     if (IS_ERR(pc->prescale_low))
0524         return PTR_ERR(pc->prescale_low);
0525 
0526     pc->prescale_high = devm_regmap_field_alloc(dev, pc->regmap,
0527                     reg_fields[PWMCLK_PRESCALE_HIGH]);
0528     if (IS_ERR(pc->prescale_high))
0529         return PTR_ERR(pc->prescale_high);
0530 
0531     pc->pwm_out_en = devm_regmap_field_alloc(dev, pc->regmap,
0532                          reg_fields[PWM_OUT_EN]);
0533     if (IS_ERR(pc->pwm_out_en))
0534         return PTR_ERR(pc->pwm_out_en);
0535 
0536     pc->pwm_cpt_en = devm_regmap_field_alloc(dev, pc->regmap,
0537                          reg_fields[PWM_CPT_EN]);
0538     if (IS_ERR(pc->pwm_cpt_en))
0539         return PTR_ERR(pc->pwm_cpt_en);
0540 
0541     pc->pwm_cpt_int_en = devm_regmap_field_alloc(dev, pc->regmap,
0542                         reg_fields[PWM_CPT_INT_EN]);
0543     if (IS_ERR(pc->pwm_cpt_int_en))
0544         return PTR_ERR(pc->pwm_cpt_int_en);
0545 
0546     pc->pwm_cpt_int_stat = devm_regmap_field_alloc(dev, pc->regmap,
0547                         reg_fields[PWM_CPT_INT_STAT]);
0548     if (PTR_ERR_OR_ZERO(pc->pwm_cpt_int_stat))
0549         return PTR_ERR(pc->pwm_cpt_int_stat);
0550 
0551     return 0;
0552 }
0553 
0554 static const struct regmap_config sti_pwm_regmap_config = {
0555     .reg_bits = 32,
0556     .val_bits = 32,
0557     .reg_stride = 4,
0558 };
0559 
0560 static int sti_pwm_probe(struct platform_device *pdev)
0561 {
0562     struct device *dev = &pdev->dev;
0563     struct sti_pwm_compat_data *cdata;
0564     struct sti_pwm_chip *pc;
0565     unsigned int i;
0566     int irq, ret;
0567 
0568     pc = devm_kzalloc(dev, sizeof(*pc), GFP_KERNEL);
0569     if (!pc)
0570         return -ENOMEM;
0571 
0572     cdata = devm_kzalloc(dev, sizeof(*cdata), GFP_KERNEL);
0573     if (!cdata)
0574         return -ENOMEM;
0575 
0576     pc->mmio = devm_platform_ioremap_resource(pdev, 0);
0577     if (IS_ERR(pc->mmio))
0578         return PTR_ERR(pc->mmio);
0579 
0580     pc->regmap = devm_regmap_init_mmio(dev, pc->mmio,
0581                        &sti_pwm_regmap_config);
0582     if (IS_ERR(pc->regmap))
0583         return PTR_ERR(pc->regmap);
0584 
0585     irq = platform_get_irq(pdev, 0);
0586     if (irq < 0)
0587         return irq;
0588 
0589     ret = devm_request_irq(&pdev->dev, irq, sti_pwm_interrupt, 0,
0590                    pdev->name, pc);
0591     if (ret < 0) {
0592         dev_err(&pdev->dev, "Failed to request IRQ\n");
0593         return ret;
0594     }
0595 
0596     /*
0597      * Setup PWM data with default values: some values could be replaced
0598      * with specific ones provided from Device Tree.
0599      */
0600     cdata->reg_fields = sti_pwm_regfields;
0601     cdata->max_prescale = 0xff;
0602     cdata->max_pwm_cnt = 255;
0603     cdata->pwm_num_devs = 0;
0604     cdata->cpt_num_devs = 0;
0605 
0606     pc->cdata = cdata;
0607     pc->dev = dev;
0608     pc->en_count = 0;
0609     mutex_init(&pc->sti_pwm_lock);
0610 
0611     ret = sti_pwm_probe_dt(pc);
0612     if (ret)
0613         return ret;
0614 
0615     if (cdata->pwm_num_devs) {
0616         pc->pwm_clk = of_clk_get_by_name(dev->of_node, "pwm");
0617         if (IS_ERR(pc->pwm_clk)) {
0618             dev_err(dev, "failed to get PWM clock\n");
0619             return PTR_ERR(pc->pwm_clk);
0620         }
0621 
0622         ret = clk_prepare(pc->pwm_clk);
0623         if (ret) {
0624             dev_err(dev, "failed to prepare clock\n");
0625             return ret;
0626         }
0627     }
0628 
0629     if (cdata->cpt_num_devs) {
0630         pc->cpt_clk = of_clk_get_by_name(dev->of_node, "capture");
0631         if (IS_ERR(pc->cpt_clk)) {
0632             dev_err(dev, "failed to get PWM capture clock\n");
0633             return PTR_ERR(pc->cpt_clk);
0634         }
0635 
0636         ret = clk_prepare(pc->cpt_clk);
0637         if (ret) {
0638             dev_err(dev, "failed to prepare clock\n");
0639             return ret;
0640         }
0641     }
0642 
0643     pc->chip.dev = dev;
0644     pc->chip.ops = &sti_pwm_ops;
0645     pc->chip.npwm = pc->cdata->pwm_num_devs;
0646 
0647     ret = pwmchip_add(&pc->chip);
0648     if (ret < 0) {
0649         clk_unprepare(pc->pwm_clk);
0650         clk_unprepare(pc->cpt_clk);
0651         return ret;
0652     }
0653 
0654     for (i = 0; i < cdata->cpt_num_devs; i++) {
0655         struct sti_cpt_ddata *ddata;
0656 
0657         ddata = devm_kzalloc(dev, sizeof(*ddata), GFP_KERNEL);
0658         if (!ddata)
0659             return -ENOMEM;
0660 
0661         init_waitqueue_head(&ddata->wait);
0662         mutex_init(&ddata->lock);
0663 
0664         pwm_set_chip_data(&pc->chip.pwms[i], ddata);
0665     }
0666 
0667     platform_set_drvdata(pdev, pc);
0668 
0669     return 0;
0670 }
0671 
0672 static int sti_pwm_remove(struct platform_device *pdev)
0673 {
0674     struct sti_pwm_chip *pc = platform_get_drvdata(pdev);
0675 
0676     pwmchip_remove(&pc->chip);
0677 
0678     clk_unprepare(pc->pwm_clk);
0679     clk_unprepare(pc->cpt_clk);
0680 
0681     return 0;
0682 }
0683 
0684 static const struct of_device_id sti_pwm_of_match[] = {
0685     { .compatible = "st,sti-pwm", },
0686     { /* sentinel */ }
0687 };
0688 MODULE_DEVICE_TABLE(of, sti_pwm_of_match);
0689 
0690 static struct platform_driver sti_pwm_driver = {
0691     .driver = {
0692         .name = "sti-pwm",
0693         .of_match_table = sti_pwm_of_match,
0694     },
0695     .probe = sti_pwm_probe,
0696     .remove = sti_pwm_remove,
0697 };
0698 module_platform_driver(sti_pwm_driver);
0699 
0700 MODULE_AUTHOR("Ajit Pal Singh <ajitpal.singh@st.com>");
0701 MODULE_DESCRIPTION("STMicroelectronics ST PWM driver");
0702 MODULE_LICENSE("GPL");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!