Blame view
drivers/pwm/pwm-fsl-ftm.c
13.2 KB
2874c5fd2
|
1 |
// SPDX-License-Identifier: GPL-2.0-or-later |
b505183b5
|
2 3 4 5 |
/* * Freescale FlexTimer Module (FTM) PWM Driver * * Copyright 2012-2013 Freescale Semiconductor, Inc. |
b505183b5
|
6 7 8 9 10 11 12 13 14 |
*/ #include <linux/clk.h> #include <linux/err.h> #include <linux/io.h> #include <linux/kernel.h> #include <linux/module.h> #include <linux/mutex.h> #include <linux/of_address.h> |
db6c51ab1
|
15 |
#include <linux/of_device.h> |
b505183b5
|
16 |
#include <linux/platform_device.h> |
97d0b42e3
|
17 |
#include <linux/pm.h> |
b505183b5
|
18 |
#include <linux/pwm.h> |
42fa98a9c
|
19 |
#include <linux/regmap.h> |
b505183b5
|
20 |
#include <linux/slab.h> |
e590eb408
|
21 |
#include <linux/fsl/ftm.h> |
b505183b5
|
22 |
|
cd6d92d2a
|
23 |
#define FTM_SC_CLK(c) (((c) + 1) << FTM_SC_CLK_MASK_SHIFT) |
b505183b5
|
24 25 26 27 28 29 30 31 |
enum fsl_pwm_clk { FSL_PWM_CLK_SYS, FSL_PWM_CLK_FIX, FSL_PWM_CLK_EXT, FSL_PWM_CLK_CNTEN, FSL_PWM_CLK_MAX }; |
db6c51ab1
|
32 33 34 |
struct fsl_ftm_soc { bool has_enable_bits; }; |
3479bbd1e
|
35 36 37 38 39 |
struct fsl_pwm_periodcfg { enum fsl_pwm_clk clk_select; unsigned int clk_ps; unsigned int mod_period; }; |
b505183b5
|
40 41 |
struct fsl_pwm_chip { struct pwm_chip chip; |
b505183b5
|
42 |
struct mutex lock; |
42fa98a9c
|
43 |
struct regmap *regmap; |
b505183b5
|
44 |
|
3479bbd1e
|
45 46 |
/* This value is valid iff a pwm is running */ struct fsl_pwm_periodcfg period; |
b505183b5
|
47 |
|
82a9c55a2
|
48 |
struct clk *ipg_clk; |
b505183b5
|
49 |
struct clk *clk[FSL_PWM_CLK_MAX]; |
db6c51ab1
|
50 51 |
const struct fsl_ftm_soc *soc; |
b505183b5
|
52 53 54 55 56 57 |
}; static inline struct fsl_pwm_chip *to_fsl_chip(struct pwm_chip *chip) { return container_of(chip, struct fsl_pwm_chip, chip); } |
a2a28229c
|
58 59 60 61 62 63 64 65 66 67 68 69 70 71 |
static void ftm_clear_write_protection(struct fsl_pwm_chip *fpc) { u32 val; regmap_read(fpc->regmap, FTM_FMS, &val); if (val & FTM_FMS_WPEN) regmap_update_bits(fpc->regmap, FTM_MODE, FTM_MODE_WPDIS, FTM_MODE_WPDIS); } static void ftm_set_write_protection(struct fsl_pwm_chip *fpc) { regmap_update_bits(fpc->regmap, FTM_FMS, FTM_FMS_WPEN, FTM_FMS_WPEN); } |
3479bbd1e
|
72 73 74 75 76 77 78 79 80 81 82 |
static bool fsl_pwm_periodcfg_are_equal(const struct fsl_pwm_periodcfg *a, const struct fsl_pwm_periodcfg *b) { if (a->clk_select != b->clk_select) return false; if (a->clk_ps != b->clk_ps) return false; if (a->mod_period != b->mod_period) return false; return true; } |
b505183b5
|
83 84 |
static int fsl_pwm_request(struct pwm_chip *chip, struct pwm_device *pwm) { |
db6c51ab1
|
85 |
int ret; |
b505183b5
|
86 |
struct fsl_pwm_chip *fpc = to_fsl_chip(chip); |
db6c51ab1
|
87 88 89 90 91 92 93 94 95 |
ret = clk_prepare_enable(fpc->ipg_clk); if (!ret && fpc->soc->has_enable_bits) { mutex_lock(&fpc->lock); regmap_update_bits(fpc->regmap, FTM_SC, BIT(pwm->hwpwm + 16), BIT(pwm->hwpwm + 16)); mutex_unlock(&fpc->lock); } return ret; |
b505183b5
|
96 97 98 99 100 |
} static void fsl_pwm_free(struct pwm_chip *chip, struct pwm_device *pwm) { struct fsl_pwm_chip *fpc = to_fsl_chip(chip); |
db6c51ab1
|
101 102 103 104 105 106 |
if (fpc->soc->has_enable_bits) { mutex_lock(&fpc->lock); regmap_update_bits(fpc->regmap, FTM_SC, BIT(pwm->hwpwm + 16), 0); mutex_unlock(&fpc->lock); } |
82a9c55a2
|
107 |
clk_disable_unprepare(fpc->ipg_clk); |
b505183b5
|
108 |
} |
3479bbd1e
|
109 110 |
static unsigned int fsl_pwm_ticks_to_ns(struct fsl_pwm_chip *fpc, unsigned int ticks) |
b505183b5
|
111 |
{ |
3479bbd1e
|
112 113 114 115 116 117 118 119 |
unsigned long rate; unsigned long long exval; rate = clk_get_rate(fpc->clk[fpc->period.clk_select]); exval = ticks; exval *= 1000000000UL; do_div(exval, rate >> fpc->period.clk_ps); return exval; |
b505183b5
|
120 |
} |
3479bbd1e
|
121 122 123 124 125 |
static bool fsl_pwm_calculate_period_clk(struct fsl_pwm_chip *fpc, unsigned int period_ns, enum fsl_pwm_clk index, struct fsl_pwm_periodcfg *periodcfg ) |
b505183b5
|
126 |
{ |
3479bbd1e
|
127 128 |
unsigned long long c; unsigned int ps; |
b505183b5
|
129 |
|
3479bbd1e
|
130 |
c = clk_get_rate(fpc->clk[index]); |
b505183b5
|
131 132 |
c = c * period_ns; do_div(c, 1000000000UL); |
3479bbd1e
|
133 134 |
if (c == 0) return false; |
b505183b5
|
135 |
|
3479bbd1e
|
136 137 138 139 140 141 142 |
for (ps = 0; ps < 8 ; ++ps, c >>= 1) { if (c <= 0x10000) { periodcfg->clk_select = index; periodcfg->clk_ps = ps; periodcfg->mod_period = c - 1; return true; } |
b505183b5
|
143 |
} |
3479bbd1e
|
144 |
return false; |
b505183b5
|
145 |
} |
3479bbd1e
|
146 147 148 |
static bool fsl_pwm_calculate_period(struct fsl_pwm_chip *fpc, unsigned int period_ns, struct fsl_pwm_periodcfg *periodcfg) |
b505183b5
|
149 150 |
{ enum fsl_pwm_clk m0, m1; |
3479bbd1e
|
151 152 |
unsigned long fix_rate, ext_rate; bool ret; |
b505183b5
|
153 |
|
3479bbd1e
|
154 155 156 157 |
ret = fsl_pwm_calculate_period_clk(fpc, period_ns, FSL_PWM_CLK_SYS, periodcfg); if (ret) return true; |
b505183b5
|
158 159 160 161 162 163 164 165 166 167 168 |
fix_rate = clk_get_rate(fpc->clk[FSL_PWM_CLK_FIX]); ext_rate = clk_get_rate(fpc->clk[FSL_PWM_CLK_EXT]); if (fix_rate > ext_rate) { m0 = FSL_PWM_CLK_FIX; m1 = FSL_PWM_CLK_EXT; } else { m0 = FSL_PWM_CLK_EXT; m1 = FSL_PWM_CLK_FIX; } |
3479bbd1e
|
169 170 171 |
ret = fsl_pwm_calculate_period_clk(fpc, period_ns, m0, periodcfg); if (ret) return true; |
b505183b5
|
172 |
|
3479bbd1e
|
173 |
return fsl_pwm_calculate_period_clk(fpc, period_ns, m1, periodcfg); |
b505183b5
|
174 |
} |
3479bbd1e
|
175 176 |
static unsigned int fsl_pwm_calculate_duty(struct fsl_pwm_chip *fpc, unsigned int duty_ns) |
b505183b5
|
177 |
{ |
42fa98a9c
|
178 |
unsigned long long duty; |
b505183b5
|
179 |
|
3479bbd1e
|
180 181 182 183 |
unsigned int period = fpc->period.mod_period + 1; unsigned int period_ns = fsl_pwm_ticks_to_ns(fpc, period); duty = (unsigned long long)duty_ns * period; |
b505183b5
|
184 |
do_div(duty, period_ns); |
3479bbd1e
|
185 |
return (unsigned int)duty; |
b505183b5
|
186 |
} |
3479bbd1e
|
187 188 |
static bool fsl_pwm_is_any_pwm_enabled(struct fsl_pwm_chip *fpc, struct pwm_device *pwm) |
b505183b5
|
189 |
{ |
3479bbd1e
|
190 |
u32 val; |
b505183b5
|
191 |
|
3479bbd1e
|
192 193 194 195 196 197 198 199 200 201 202 |
regmap_read(fpc->regmap, FTM_OUTMASK, &val); if (~val & 0xFF) return true; else return false; } static bool fsl_pwm_is_other_pwm_enabled(struct fsl_pwm_chip *fpc, struct pwm_device *pwm) { u32 val; |
b505183b5
|
203 |
|
3479bbd1e
|
204 205 206 207 208 209 210 211 212 213 214 215 216 |
regmap_read(fpc->regmap, FTM_OUTMASK, &val); if (~(val | BIT(pwm->hwpwm)) & 0xFF) return true; else return false; } static int fsl_pwm_apply_config(struct fsl_pwm_chip *fpc, struct pwm_device *pwm, struct pwm_state *newstate) { unsigned int duty; u32 reg_polarity; |
b505183b5
|
217 |
|
3479bbd1e
|
218 219 220 221 222 223 224 225 226 227 228 |
struct fsl_pwm_periodcfg periodcfg; bool do_write_period = false; if (!fsl_pwm_calculate_period(fpc, newstate->period, &periodcfg)) { dev_err(fpc->chip.dev, "failed to calculate new period "); return -EINVAL; } if (!fsl_pwm_is_any_pwm_enabled(fpc, pwm)) do_write_period = true; |
b505183b5
|
229 230 |
/* * The Freescale FTM controller supports only a single period for |
3479bbd1e
|
231 232 233 |
* all PWM channels, therefore verify if the newly computed period * is different than the current period being used. In such case * we allow to change the period only if no other pwm is running. |
b505183b5
|
234 |
*/ |
3479bbd1e
|
235 236 237 238 239 240 241 |
else if (!fsl_pwm_periodcfg_are_equal(&fpc->period, &periodcfg)) { if (fsl_pwm_is_other_pwm_enabled(fpc, pwm)) { dev_err(fpc->chip.dev, "Cannot change period for PWM %u, disable other PWMs first ", pwm->hwpwm); return -EBUSY; |
b505183b5
|
242 |
} |
3479bbd1e
|
243 244 245 246 247 248 249 250 251 252 253 |
if (fpc->period.clk_select != periodcfg.clk_select) { int ret; enum fsl_pwm_clk oldclk = fpc->period.clk_select; enum fsl_pwm_clk newclk = periodcfg.clk_select; ret = clk_prepare_enable(fpc->clk[newclk]); if (ret) return ret; clk_disable_unprepare(fpc->clk[oldclk]); } do_write_period = true; |
b505183b5
|
254 |
} |
a2a28229c
|
255 |
ftm_clear_write_protection(fpc); |
b505183b5
|
256 |
|
3479bbd1e
|
257 258 259 |
if (do_write_period) { regmap_update_bits(fpc->regmap, FTM_SC, FTM_SC_CLK_MASK, FTM_SC_CLK(periodcfg.clk_select)); |
42fa98a9c
|
260 |
regmap_update_bits(fpc->regmap, FTM_SC, FTM_SC_PS_MASK, |
3479bbd1e
|
261 262 |
periodcfg.clk_ps); regmap_write(fpc->regmap, FTM_MOD, periodcfg.mod_period); |
b505183b5
|
263 |
|
3479bbd1e
|
264 |
fpc->period = periodcfg; |
b505183b5
|
265 |
} |
3479bbd1e
|
266 |
duty = fsl_pwm_calculate_duty(fpc, newstate->duty_cycle); |
b505183b5
|
267 |
|
42fa98a9c
|
268 269 270 |
regmap_write(fpc->regmap, FTM_CSC(pwm->hwpwm), FTM_CSC_MSB | FTM_CSC_ELSB); regmap_write(fpc->regmap, FTM_CV(pwm->hwpwm), duty); |
b505183b5
|
271 |
|
3479bbd1e
|
272 273 274 |
reg_polarity = 0; if (newstate->polarity == PWM_POLARITY_INVERSED) reg_polarity = BIT(pwm->hwpwm); |
b505183b5
|
275 |
|
3479bbd1e
|
276 |
regmap_update_bits(fpc->regmap, FTM_POL, BIT(pwm->hwpwm), reg_polarity); |
b505183b5
|
277 |
|
3479bbd1e
|
278 279 280 |
newstate->period = fsl_pwm_ticks_to_ns(fpc, fpc->period.mod_period + 1); newstate->duty_cycle = fsl_pwm_ticks_to_ns(fpc, duty); |
b505183b5
|
281 |
|
a2a28229c
|
282 |
ftm_set_write_protection(fpc); |
b505183b5
|
283 284 285 |
return 0; } |
3479bbd1e
|
286 287 |
static int fsl_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm, struct pwm_state *newstate) |
b505183b5
|
288 289 |
{ struct fsl_pwm_chip *fpc = to_fsl_chip(chip); |
3479bbd1e
|
290 291 |
struct pwm_state *oldstate = &pwm->state; int ret = 0; |
b505183b5
|
292 |
|
3479bbd1e
|
293 294 295 296 297 298 299 300 |
/* * oldstate to newstate : action * * disabled to disabled : ignore * enabled to disabled : disable * enabled to enabled : update settings * disabled to enabled : update settings + enable */ |
b505183b5
|
301 |
|
3479bbd1e
|
302 |
mutex_lock(&fpc->lock); |
b505183b5
|
303 |
|
3479bbd1e
|
304 305 306 307 308 309 310 |
if (!newstate->enabled) { if (oldstate->enabled) { regmap_update_bits(fpc->regmap, FTM_OUTMASK, BIT(pwm->hwpwm), BIT(pwm->hwpwm)); clk_disable_unprepare(fpc->clk[FSL_PWM_CLK_CNTEN]); clk_disable_unprepare(fpc->clk[fpc->period.clk_select]); } |
b505183b5
|
311 |
|
3479bbd1e
|
312 313 |
goto end_mutex; } |
b505183b5
|
314 |
|
3479bbd1e
|
315 316 317 318 319 320 321 322 |
ret = fsl_pwm_apply_config(fpc, pwm, newstate); if (ret) goto end_mutex; /* check if need to enable */ if (!oldstate->enabled) { ret = clk_prepare_enable(fpc->clk[fpc->period.clk_select]); if (ret) |
3d25025ce
|
323 |
goto end_mutex; |
3479bbd1e
|
324 325 326 327 |
ret = clk_prepare_enable(fpc->clk[FSL_PWM_CLK_CNTEN]); if (ret) { clk_disable_unprepare(fpc->clk[fpc->period.clk_select]); |
3d25025ce
|
328 |
goto end_mutex; |
3479bbd1e
|
329 |
} |
b505183b5
|
330 |
|
3479bbd1e
|
331 332 333 |
regmap_update_bits(fpc->regmap, FTM_OUTMASK, BIT(pwm->hwpwm), 0); } |
b505183b5
|
334 |
|
3479bbd1e
|
335 |
end_mutex: |
b505183b5
|
336 |
mutex_unlock(&fpc->lock); |
3479bbd1e
|
337 |
return ret; |
b505183b5
|
338 339 340 341 342 |
} static const struct pwm_ops fsl_pwm_ops = { .request = fsl_pwm_request, .free = fsl_pwm_free, |
3479bbd1e
|
343 |
.apply = fsl_pwm_apply, |
b505183b5
|
344 345 346 347 348 349 |
.owner = THIS_MODULE, }; static int fsl_pwm_init(struct fsl_pwm_chip *fpc) { int ret; |
82a9c55a2
|
350 |
ret = clk_prepare_enable(fpc->ipg_clk); |
b505183b5
|
351 352 |
if (ret) return ret; |
42fa98a9c
|
353 354 355 |
regmap_write(fpc->regmap, FTM_CNTIN, 0x00); regmap_write(fpc->regmap, FTM_OUTINIT, 0x00); regmap_write(fpc->regmap, FTM_OUTMASK, 0xFF); |
b505183b5
|
356 |
|
82a9c55a2
|
357 |
clk_disable_unprepare(fpc->ipg_clk); |
b505183b5
|
358 359 360 |
return 0; } |
49599cf6b
|
361 362 363 |
static bool fsl_pwm_volatile_reg(struct device *dev, unsigned int reg) { switch (reg) { |
a2a28229c
|
364 365 |
case FTM_FMS: case FTM_MODE: |
49599cf6b
|
366 367 368 369 370 |
case FTM_CNT: return true; } return false; } |
42fa98a9c
|
371 372 373 374 375 376 |
static const struct regmap_config fsl_pwm_regmap_config = { .reg_bits = 32, .reg_stride = 4, .val_bits = 32, .max_register = FTM_PWMLOAD, |
49599cf6b
|
377 |
.volatile_reg = fsl_pwm_volatile_reg, |
ad06fdeee
|
378 |
.cache_type = REGCACHE_FLAT, |
42fa98a9c
|
379 |
}; |
b505183b5
|
380 381 382 383 |
static int fsl_pwm_probe(struct platform_device *pdev) { struct fsl_pwm_chip *fpc; struct resource *res; |
42fa98a9c
|
384 |
void __iomem *base; |
b505183b5
|
385 386 387 388 389 390 391 |
int ret; fpc = devm_kzalloc(&pdev->dev, sizeof(*fpc), GFP_KERNEL); if (!fpc) return -ENOMEM; mutex_init(&fpc->lock); |
db6c51ab1
|
392 |
fpc->soc = of_device_get_match_data(&pdev->dev); |
b505183b5
|
393 394 395 |
fpc->chip.dev = &pdev->dev; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); |
42fa98a9c
|
396 397 398 |
base = devm_ioremap_resource(&pdev->dev, res); if (IS_ERR(base)) return PTR_ERR(base); |
97d0b42e3
|
399 |
fpc->regmap = devm_regmap_init_mmio_clk(&pdev->dev, "ftm_sys", base, |
42fa98a9c
|
400 401 402 403 404 405 |
&fsl_pwm_regmap_config); if (IS_ERR(fpc->regmap)) { dev_err(&pdev->dev, "regmap init failed "); return PTR_ERR(fpc->regmap); } |
b505183b5
|
406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 |
fpc->clk[FSL_PWM_CLK_SYS] = devm_clk_get(&pdev->dev, "ftm_sys"); if (IS_ERR(fpc->clk[FSL_PWM_CLK_SYS])) { dev_err(&pdev->dev, "failed to get \"ftm_sys\" clock "); return PTR_ERR(fpc->clk[FSL_PWM_CLK_SYS]); } fpc->clk[FSL_PWM_CLK_FIX] = devm_clk_get(fpc->chip.dev, "ftm_fix"); if (IS_ERR(fpc->clk[FSL_PWM_CLK_FIX])) return PTR_ERR(fpc->clk[FSL_PWM_CLK_FIX]); fpc->clk[FSL_PWM_CLK_EXT] = devm_clk_get(fpc->chip.dev, "ftm_ext"); if (IS_ERR(fpc->clk[FSL_PWM_CLK_EXT])) return PTR_ERR(fpc->clk[FSL_PWM_CLK_EXT]); fpc->clk[FSL_PWM_CLK_CNTEN] = devm_clk_get(fpc->chip.dev, "ftm_cnt_clk_en"); if (IS_ERR(fpc->clk[FSL_PWM_CLK_CNTEN])) return PTR_ERR(fpc->clk[FSL_PWM_CLK_CNTEN]); |
82a9c55a2
|
426 427 428 429 430 431 432 |
/* * ipg_clk is the interface clock for the IP. If not provided, use the * ftm_sys clock as the default. */ fpc->ipg_clk = devm_clk_get(&pdev->dev, "ipg"); if (IS_ERR(fpc->ipg_clk)) fpc->ipg_clk = fpc->clk[FSL_PWM_CLK_SYS]; |
b505183b5
|
433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 |
fpc->chip.ops = &fsl_pwm_ops; fpc->chip.of_xlate = of_pwm_xlate_with_flags; fpc->chip.of_pwm_n_cells = 3; fpc->chip.base = -1; fpc->chip.npwm = 8; ret = pwmchip_add(&fpc->chip); if (ret < 0) { dev_err(&pdev->dev, "failed to add PWM chip: %d ", ret); return ret; } platform_set_drvdata(pdev, fpc); return fsl_pwm_init(fpc); } static int fsl_pwm_remove(struct platform_device *pdev) { struct fsl_pwm_chip *fpc = platform_get_drvdata(pdev); return pwmchip_remove(&fpc->chip); } |
97d0b42e3
|
457 458 459 460 |
#ifdef CONFIG_PM_SLEEP static int fsl_pwm_suspend(struct device *dev) { struct fsl_pwm_chip *fpc = dev_get_drvdata(dev); |
816aec232
|
461 |
int i; |
97d0b42e3
|
462 463 464 |
regcache_cache_only(fpc->regmap, true); regcache_mark_dirty(fpc->regmap); |
816aec232
|
465 466 467 468 469 |
for (i = 0; i < fpc->chip.npwm; i++) { struct pwm_device *pwm = &fpc->chip.pwms[i]; if (!test_bit(PWMF_REQUESTED, &pwm->flags)) continue; |
82a9c55a2
|
470 |
clk_disable_unprepare(fpc->ipg_clk); |
816aec232
|
471 472 473 |
if (!pwm_is_enabled(pwm)) continue; |
97d0b42e3
|
474 |
clk_disable_unprepare(fpc->clk[FSL_PWM_CLK_CNTEN]); |
3479bbd1e
|
475 |
clk_disable_unprepare(fpc->clk[fpc->period.clk_select]); |
97d0b42e3
|
476 477 478 479 480 481 482 483 |
} return 0; } static int fsl_pwm_resume(struct device *dev) { struct fsl_pwm_chip *fpc = dev_get_drvdata(dev); |
816aec232
|
484 485 486 487 488 489 490 |
int i; for (i = 0; i < fpc->chip.npwm; i++) { struct pwm_device *pwm = &fpc->chip.pwms[i]; if (!test_bit(PWMF_REQUESTED, &pwm->flags)) continue; |
97d0b42e3
|
491 |
|
82a9c55a2
|
492 |
clk_prepare_enable(fpc->ipg_clk); |
816aec232
|
493 494 495 |
if (!pwm_is_enabled(pwm)) continue; |
3479bbd1e
|
496 |
clk_prepare_enable(fpc->clk[fpc->period.clk_select]); |
97d0b42e3
|
497 498 499 500 501 502 503 504 505 506 507 508 509 510 |
clk_prepare_enable(fpc->clk[FSL_PWM_CLK_CNTEN]); } /* restore all registers from cache */ regcache_cache_only(fpc->regmap, false); regcache_sync(fpc->regmap); return 0; } #endif static const struct dev_pm_ops fsl_pwm_pm_ops = { SET_SYSTEM_SLEEP_PM_OPS(fsl_pwm_suspend, fsl_pwm_resume) }; |
db6c51ab1
|
511 512 513 |
static const struct fsl_ftm_soc vf610_ftm_pwm = { .has_enable_bits = false, }; |
2c4f2e326
|
514 515 516 |
static const struct fsl_ftm_soc imx8qm_ftm_pwm = { .has_enable_bits = true, }; |
b505183b5
|
517 |
static const struct of_device_id fsl_pwm_dt_ids[] = { |
db6c51ab1
|
518 |
{ .compatible = "fsl,vf610-ftm-pwm", .data = &vf610_ftm_pwm }, |
2c4f2e326
|
519 |
{ .compatible = "fsl,imx8qm-ftm-pwm", .data = &imx8qm_ftm_pwm }, |
b505183b5
|
520 521 522 523 524 525 526 527 |
{ /* sentinel */ } }; MODULE_DEVICE_TABLE(of, fsl_pwm_dt_ids); static struct platform_driver fsl_pwm_driver = { .driver = { .name = "fsl-ftm-pwm", .of_match_table = fsl_pwm_dt_ids, |
97d0b42e3
|
528 |
.pm = &fsl_pwm_pm_ops, |
b505183b5
|
529 530 531 532 533 534 535 536 537 538 |
}, .probe = fsl_pwm_probe, .remove = fsl_pwm_remove, }; module_platform_driver(fsl_pwm_driver); MODULE_DESCRIPTION("Freescale FlexTimer Module PWM Driver"); MODULE_AUTHOR("Xiubo Li <Li.Xiubo@freescale.com>"); MODULE_ALIAS("platform:fsl-ftm-pwm"); MODULE_LICENSE("GPL"); |