arch/powerpc/include/asm/mpc52xx.h

110

u32 pwm; /* GPTx + 0x08 */

drivers/bus/ts-nbus.c

269

struct pwm_device *pwm;

drivers/bus/ts-nbus.c

285

pwm = devm_pwm_get(dev, NULL);

drivers/bus/ts-nbus.c

286

if (IS_ERR(pwm))

drivers/bus/ts-nbus.c

287

return dev_err_probe(dev, PTR_ERR(pwm),

drivers/bus/ts-nbus.c

29

struct pwm_device *pwm;

drivers/bus/ts-nbus.c

290

pwm_init_state(pwm, &state);

drivers/bus/ts-nbus.c

297

ret = pwm_apply_might_sleep(pwm, &state);

drivers/bus/ts-nbus.c

304

ts_nbus->pwm = pwm;

drivers/bus/ts-nbus.c

327

pwm_disable(ts_nbus->pwm);

drivers/clk/bcm/clk-bcm281xx.c

326

KONA_CLK(slave, pwm, peri),

drivers/clk/clk-pwm.c

100

struct pwm_device *pwm;

drivers/clk/clk-pwm.c

109

pwm = devm_pwm_get(&pdev->dev, NULL);

drivers/clk/clk-pwm.c

110

if (IS_ERR(pwm))

drivers/clk/clk-pwm.c

111

return PTR_ERR(pwm);

drivers/clk/clk-pwm.c

113

pwm_get_args(pwm, &pargs);

drivers/clk/clk-pwm.c

134

pwm_init_state(pwm, &clk_pwm->state);

drivers/clk/clk-pwm.c

142

if (pwm_might_sleep(pwm))

drivers/clk/clk-pwm.c

150

clk_pwm->pwm = pwm;

drivers/clk/clk-pwm.c

16

struct pwm_device *pwm;

drivers/clk/clk-pwm.c

30

return pwm_apply_atomic(clk_pwm->pwm, &clk_pwm->state);

drivers/clk/clk-pwm.c

40

pwm_apply_atomic(clk_pwm->pwm, &state);

drivers/clk/clk-pwm.c

47

return pwm_apply_might_sleep(clk_pwm->pwm, &clk_pwm->state);

drivers/clk/clk-pwm.c

54

pwm_disable(clk_pwm->pwm);

drivers/clk/clk-pwm.c

71

ret = pwm_get_state_hw(clk_pwm->pwm, &state);

drivers/clk/mvebu/armada-37xx-periph.c

263

PERIPH_CLK_FULL_DD(pwm, 13, 14, DIV_SEL0, DIV_SEL0, 3, 0);

drivers/clk/mvebu/armada-37xx-periph.c

283

REF_CLK_FULL_DD(pwm),

drivers/clk/mxs/clk-imx23.c

142

clks[pwm] = mxs_clk_gate("pwm", "ref_xtal", XTAL, 29);

drivers/clk/mxs/clk-imx28.c

211

clks[pwm] = mxs_clk_gate("pwm", "ref_xtal", XTAL, 29);

drivers/clocksource/samsung_pwm_timer.c

107

bits = (fls(divisor) - 1) - pwm.variant.div_base;

drivers/clocksource/samsung_pwm_timer.c

111

reg = readl(pwm.base + REG_TCFG1);

drivers/clocksource/samsung_pwm_timer.c

114

writel(reg, pwm.base + REG_TCFG1);

drivers/clocksource/samsung_pwm_timer.c

129

tcon = readl_relaxed(pwm.base + REG_TCON);

drivers/clocksource/samsung_pwm_timer.c

131

writel_relaxed(tcon, pwm.base + REG_TCON);

drivers/clocksource/samsung_pwm_timer.c

147

tcon = readl_relaxed(pwm.base + REG_TCON);

drivers/clocksource/samsung_pwm_timer.c

152

writel_relaxed(tcnt, pwm.base + REG_TCNTB(channel));

drivers/clocksource/samsung_pwm_timer.c

153

writel_relaxed(tcnt, pwm.base + REG_TCMPB(channel));

drivers/clocksource/samsung_pwm_timer.c

154

writel_relaxed(tcon, pwm.base + REG_TCON);

drivers/clocksource/samsung_pwm_timer.c

169

tcon = readl_relaxed(pwm.base + REG_TCON);

drivers/clocksource/samsung_pwm_timer.c

179

writel_relaxed(tcon, pwm.base + REG_TCON);

drivers/clocksource/samsung_pwm_timer.c

200

samsung_time_setup(pwm.event_id, cycles);

drivers/clocksource/samsung_pwm_timer.c

201

samsung_time_start(pwm.event_id, false);

drivers/clocksource/samsung_pwm_timer.c

208

samsung_time_stop(pwm.event_id);

drivers/clocksource/samsung_pwm_timer.c

214

samsung_time_stop(pwm.event_id);

drivers/clocksource/samsung_pwm_timer.c

215

samsung_time_setup(pwm.event_id, pwm.clock_count_per_tick - 1);

drivers/clocksource/samsung_pwm_timer.c

216

samsung_time_start(pwm.event_id, true);

drivers/clocksource/samsung_pwm_timer.c

222

samsung_timer_set_prescale(pwm.event_id, pwm.tscaler_div);

drivers/clocksource/samsung_pwm_timer.c

223

samsung_timer_set_divisor(pwm.event_id, pwm.tdiv);

drivers/clocksource/samsung_pwm_timer.c

225

if (pwm.variant.has_tint_cstat) {

drivers/clocksource/samsung_pwm_timer.c

226

u32 mask = (1 << pwm.event_id);

drivers/clocksource/samsung_pwm_timer.c

228

writel(mask | (mask << 5), pwm.base + REG_TINT_CSTAT);

drivers/clocksource/samsung_pwm_timer.c

249

if (pwm.variant.has_tint_cstat) {

drivers/clocksource/samsung_pwm_timer.c

250

u32 mask = (1 << pwm.event_id);

drivers/clocksource/samsung_pwm_timer.c

252

writel(mask | (mask << 5), pwm.base + REG_TINT_CSTAT);

drivers/clocksource/samsung_pwm_timer.c

266

pclk = clk_get_rate(pwm.timerclk);

drivers/clocksource/samsung_pwm_timer.c

268

samsung_timer_set_prescale(pwm.event_id, pwm.tscaler_div);

drivers/clocksource/samsung_pwm_timer.c

269

samsung_timer_set_divisor(pwm.event_id, pwm.tdiv);

drivers/clocksource/samsung_pwm_timer.c

271

clock_rate = pclk / (pwm.tscaler_div * pwm.tdiv);

drivers/clocksource/samsung_pwm_timer.c

272

pwm.clock_count_per_tick = clock_rate / HZ;

drivers/clocksource/samsung_pwm_timer.c

276

clock_rate, 1, pwm.tcnt_max);

drivers/clocksource/samsung_pwm_timer.c

278

irq_number = pwm.irq[pwm.event_id];

drivers/clocksource/samsung_pwm_timer.c

284

if (pwm.variant.has_tint_cstat) {

drivers/clocksource/samsung_pwm_timer.c

285

u32 mask = (1 << pwm.event_id);

drivers/clocksource/samsung_pwm_timer.c

287

writel(mask | (mask << 5), pwm.base + REG_TINT_CSTAT);

drivers/clocksource/samsung_pwm_timer.c

293

samsung_time_stop(pwm.source_id);

drivers/clocksource/samsung_pwm_timer.c

298

samsung_timer_set_prescale(pwm.source_id, pwm.tscaler_div);

drivers/clocksource/samsung_pwm_timer.c

299

samsung_timer_set_divisor(pwm.source_id, pwm.tdiv);

drivers/clocksource/samsung_pwm_timer.c

301

samsung_time_setup(pwm.source_id, pwm.tcnt_max);

drivers/clocksource/samsung_pwm_timer.c

302

samsung_time_start(pwm.source_id, true);

drivers/clocksource/samsung_pwm_timer.c

307

return ~readl_relaxed(pwm.source_reg);

drivers/clocksource/samsung_pwm_timer.c

336

pclk = clk_get_rate(pwm.timerclk);

drivers/clocksource/samsung_pwm_timer.c

338

samsung_timer_set_prescale(pwm.source_id, pwm.tscaler_div);

drivers/clocksource/samsung_pwm_timer.c

339

samsung_timer_set_divisor(pwm.source_id, pwm.tdiv);

drivers/clocksource/samsung_pwm_timer.c

341

clock_rate = pclk / (pwm.tscaler_div * pwm.tdiv);

drivers/clocksource/samsung_pwm_timer.c

343

samsung_time_setup(pwm.source_id, pwm.tcnt_max);

drivers/clocksource/samsung_pwm_timer.c

344

samsung_time_start(pwm.source_id, true);

drivers/clocksource/samsung_pwm_timer.c

346

if (pwm.source_id == 4)

drivers/clocksource/samsung_pwm_timer.c

347

pwm.source_reg = pwm.base + 0x40;

drivers/clocksource/samsung_pwm_timer.c

349

pwm.source_reg = pwm.base + pwm.source_id * 0x0c + 0x14;

drivers/clocksource/samsung_pwm_timer.c

352

pwm.variant.bits, clock_rate);

drivers/clocksource/samsung_pwm_timer.c

354

samsung_clocksource.mask = CLOCKSOURCE_MASK(pwm.variant.bits);

drivers/clocksource/samsung_pwm_timer.c

360

clk_prepare_enable(pwm.timerclk);

drivers/clocksource/samsung_pwm_timer.c

362

pwm.tcnt_max = (1UL << pwm.variant.bits) - 1;

drivers/clocksource/samsung_pwm_timer.c

363

if (pwm.variant.bits == 16) {

drivers/clocksource/samsung_pwm_timer.c

364

pwm.tscaler_div = 25;

drivers/clocksource/samsung_pwm_timer.c

365

pwm.tdiv = 2;

drivers/clocksource/samsung_pwm_timer.c

367

pwm.tscaler_div = 2;

drivers/clocksource/samsung_pwm_timer.c

368

pwm.tdiv = 1;

drivers/clocksource/samsung_pwm_timer.c

380

mask = ~pwm.variant.output_mask & ((1 << SAMSUNG_PWM_NUM) - 1);

drivers/clocksource/samsung_pwm_timer.c

386

pwm.source_id = channel;

drivers/clocksource/samsung_pwm_timer.c

394

pwm.event_id = channel;

drivers/clocksource/samsung_pwm_timer.c

406

pwm.base = base;

drivers/clocksource/samsung_pwm_timer.c

407

memcpy(&pwm.variant, variant, sizeof(pwm.variant));

drivers/clocksource/samsung_pwm_timer.c

408

memcpy(pwm.irq, irqs, SAMSUNG_PWM_NUM * sizeof(*irqs));

drivers/clocksource/samsung_pwm_timer.c

410

pwm.timerclk = clk_get(NULL, "timers");

drivers/clocksource/samsung_pwm_timer.c

411

if (IS_ERR(pwm.timerclk))

drivers/clocksource/samsung_pwm_timer.c

424

memcpy(&pwm.variant, variant, sizeof(pwm.variant));

drivers/clocksource/samsung_pwm_timer.c

426

pwm.irq[i] = irq_of_parse_and_map(np, i);

drivers/clocksource/samsung_pwm_timer.c

433

pwm.variant.output_mask |= 1 << val;

drivers/clocksource/samsung_pwm_timer.c

436

pwm.base = of_iomap(np, 0);

drivers/clocksource/samsung_pwm_timer.c

437

if (!pwm.base) {

drivers/clocksource/samsung_pwm_timer.c

442

pwm.timerclk = of_clk_get_by_name(np, "timers");

drivers/clocksource/samsung_pwm_timer.c

443

if (IS_ERR(pwm.timerclk)) {

drivers/clocksource/samsung_pwm_timer.c

445

ret = PTR_ERR(pwm.timerclk);

drivers/clocksource/samsung_pwm_timer.c

456

clk_put(pwm.timerclk);

drivers/clocksource/samsung_pwm_timer.c

457

pwm.timerclk = NULL;

drivers/clocksource/samsung_pwm_timer.c

459

iounmap(pwm.base);

drivers/clocksource/samsung_pwm_timer.c

460

pwm.base = NULL;

drivers/clocksource/samsung_pwm_timer.c

79

static struct samsung_pwm_clocksource pwm;

drivers/clocksource/samsung_pwm_timer.c

92

reg = readl(pwm.base + REG_TCFG0);

drivers/clocksource/samsung_pwm_timer.c

95

writel(reg, pwm.base + REG_TCFG0);

drivers/gpio/gpio-mvebu.c

614

static int mvebu_pwm_request(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/gpio/gpio-mvebu.c

628

pwm->hwpwm, "mvebu-pwm",

drivers/gpio/gpio-mvebu.c

643

static void mvebu_pwm_free(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/gpio/gpio-mvebu.c

655

struct pwm_device *pwm,

drivers/gpio/gpio-mvebu.c

695

static int mvebu_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/gpio/gpio-mvebu.c

739

mvebu_gpio_blink(&mvchip->chip, pwm->hwpwm, 1);

drivers/gpio/gpio-mvebu.c

741

mvebu_gpio_blink(&mvchip->chip, pwm->hwpwm, 0);

drivers/gpu/drm/amd/display/modules/power/power_abm.c

294

struct core_power *core_power, unsigned int pwm, unsigned int inst)

drivers/gpu/drm/amd/display/modules/power/power_abm.c

313

if (pwm <= core_power->bl_prop[inst].backlight_lut[0])

drivers/gpu/drm/amd/display/modules/power/power_abm.c

316

if (pwm > core_power->bl_prop[inst].backlight_lut[max_index])

drivers/gpu/drm/amd/display/modules/power/power_abm.c

329

if (core_power->bl_prop[inst].backlight_lut[mid] < pwm)

drivers/gpu/drm/amd/display/modules/power/power_abm.c

331

else if (core_power->bl_prop[inst].backlight_lut[mid] > pwm)

drivers/gpu/drm/amd/display/modules/power/power_abm.c

345

min_delta = (core_power->bl_prop[inst].backlight_lut[min] > pwm) ?

drivers/gpu/drm/amd/display/modules/power/power_abm.c

346

core_power->bl_prop[inst].backlight_lut[min] - pwm :

drivers/gpu/drm/amd/display/modules/power/power_abm.c

347

pwm - core_power->bl_prop[inst].backlight_lut[min];

drivers/gpu/drm/amd/display/modules/power/power_abm.c

349

mid_delta = (core_power->bl_prop[inst].backlight_lut[mid] > pwm) ?

drivers/gpu/drm/amd/display/modules/power/power_abm.c

350

core_power->bl_prop[inst].backlight_lut[mid] - pwm :

drivers/gpu/drm/amd/display/modules/power/power_abm.c

351

pwm - core_power->bl_prop[inst].backlight_lut[mid];

drivers/gpu/drm/amd/display/modules/power/power_abm.c

353

max_delta = (core_power->bl_prop[inst].backlight_lut[max] > pwm) ?

drivers/gpu/drm/amd/display/modules/power/power_abm.c

354

core_power->bl_prop[inst].backlight_lut[max] - pwm :

drivers/gpu/drm/amd/display/modules/power/power_abm.c

355

pwm - core_power->bl_prop[inst].backlight_lut[max];

drivers/gpu/drm/amd/display/modules/power/power_abm.c

371

struct core_power *core_power, unsigned int pwm, unsigned int inst)

drivers/gpu/drm/amd/display/modules/power/power_abm.c

378

if (pwm <= core_power->bl_prop[inst].min_backlight_pwm)

drivers/gpu/drm/amd/display/modules/power/power_abm.c

381

if (pwm >= core_power->bl_prop[inst].max_backlight_pwm)

drivers/gpu/drm/amd/display/modules/power/power_abm.c

384

millinit = ((unsigned int)div_u64(((unsigned long long)pwm -

drivers/gpu/drm/amd/display/modules/power/power_abm.c

400

unsigned int pwm = (unsigned int)-1;

drivers/gpu/drm/amd/display/modules/power/power_abm.c

408

pwm = core_power->bl_prop[inst].min_backlight_pwm +

drivers/gpu/drm/amd/display/modules/power/power_abm.c

413

if (pwm > core_power->bl_prop[inst].max_backlight_pwm)

drivers/gpu/drm/amd/display/modules/power/power_abm.c

414

pwm = core_power->bl_prop[inst].max_backlight_pwm;

drivers/gpu/drm/amd/display/modules/power/power_abm.c

416

return pwm;

drivers/gpu/drm/amd/display/modules/power/power_abm.c

427

return pwm;

drivers/gpu/drm/amd/display/modules/power/power_abm.c

429

pwm = core_power->bl_prop[inst].backlight_lut[index];

drivers/gpu/drm/amd/display/modules/power/power_abm.c

431

return pwm;

drivers/gpu/drm/amd/display/modules/power/power_abm.c

437

unsigned int pwm = 0;

drivers/gpu/drm/amd/display/modules/power/power_abm.c

450

pwm = ((unsigned int)div_u64(((unsigned long long)millinit -

drivers/gpu/drm/amd/display/modules/power/power_abm.c

455

pwm += core_power->bl_prop[inst].min_backlight_pwm;

drivers/gpu/drm/amd/display/modules/power/power_abm.c

457

if (pwm > core_power->bl_prop[inst].max_backlight_pwm)

drivers/gpu/drm/amd/display/modules/power/power_abm.c

458

pwm = core_power->bl_prop[inst].max_backlight_pwm;

drivers/gpu/drm/amd/display/modules/power/power_abm.c

460

return pwm;

drivers/gpu/drm/bridge/ti-sn65dsi86.c

1514

static int ti_sn_pwm_request(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/gpu/drm/bridge/ti-sn65dsi86.c

1521

static void ti_sn_pwm_free(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/gpu/drm/bridge/ti-sn65dsi86.c

1539

static int ti_sn_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/gpu/drm/bridge/ti-sn65dsi86.c

1669

static int ti_sn_pwm_get_state(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/gpu/drm/gma500/cdv_intel_lvds.c

636

u32 pwm;

drivers/gpu/drm/gma500/cdv_intel_lvds.c

638

pwm = REG_READ(BLC_PWM_CTL2);

drivers/gpu/drm/gma500/cdv_intel_lvds.c

640

pwm |= PWM_PIPE_B;

drivers/gpu/drm/gma500/cdv_intel_lvds.c

642

pwm &= ~PWM_PIPE_B;

drivers/gpu/drm/gma500/cdv_intel_lvds.c

643

pwm |= PWM_ENABLE;

drivers/gpu/drm/gma500/cdv_intel_lvds.c

644

REG_WRITE(BLC_PWM_CTL2, pwm);

drivers/gpu/drm/i915/display/intel_backlight.c

1185

u32 pwm;

drivers/gpu/drm/i915/display/intel_backlight.c

1193

pwm = panel->backlight.pwm_funcs->hz_to_pwm(connector, pwm_freq_hz);

drivers/gpu/drm/i915/display/intel_backlight.c

1194

if (!pwm) {

drivers/gpu/drm/i915/display/intel_backlight.c

1200

return pwm;

drivers/gpu/drm/i915/display/intel_backlight.c

1550

panel->backlight.pwm = pwm_get(display->drm->dev,

drivers/gpu/drm/i915/display/intel_backlight.c

1554

panel->backlight.pwm = pwm_get(display->drm->dev,

drivers/gpu/drm/i915/display/intel_backlight.c

1559

if (IS_ERR(panel->backlight.pwm)) {

drivers/gpu/drm/i915/display/intel_backlight.c

1563

panel->backlight.pwm = NULL;

drivers/gpu/drm/i915/display/intel_backlight.c

1570

if (pwm_is_enabled(panel->backlight.pwm)) {

drivers/gpu/drm/i915/display/intel_backlight.c

1572

pwm_get_state(panel->backlight.pwm, &panel->backlight.pwm_state);

drivers/gpu/drm/i915/display/intel_backlight.c

1718

if (panel->backlight.pwm)

drivers/gpu/drm/i915/display/intel_backlight.c

1719

pwm_put(panel->backlight.pwm);

drivers/gpu/drm/i915/display/intel_backlight.c

207

pwm_get_state(panel->backlight.pwm, &state);

drivers/gpu/drm/i915/display/intel_backlight.c

286

pwm_apply_might_sleep(panel->backlight.pwm, &panel->backlight.pwm_state);

drivers/gpu/drm/i915/display/intel_backlight.c

440

pwm_apply_might_sleep(panel->backlight.pwm, &panel->backlight.pwm_state);

drivers/gpu/drm/i915/display/intel_backlight.c

770

pwm_apply_might_sleep(panel->backlight.pwm, &panel->backlight.pwm_state);

drivers/gpu/drm/i915/display/intel_display_types.h

420

struct pwm_device *pwm;

drivers/gpu/drm/nouveau/nouveau_hwmon.c

228

HWMON_CHANNEL_INFO(pwm,

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/disp.c

1171

r535_dp_get_caps(struct nvkm_disp *disp, int *plink_bw, bool *pmst, bool *pwm)

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/disp.c

1208

*pwm = ctrl->bHasIncreasedWatermarkLimits;

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r570/disp.c

136

*pwm = ctrl->bHasIncreasedWatermarkLimits;

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r570/disp.c

99

r570_dp_get_caps(struct nvkm_disp *disp, int *plink_bw, bool *pmst, bool *pwm)

drivers/gpu/drm/solomon/ssd130x.c

341

ssd130x->pwm = pwm_get(dev, NULL);

drivers/gpu/drm/solomon/ssd130x.c

342

if (IS_ERR(ssd130x->pwm)) {

drivers/gpu/drm/solomon/ssd130x.c

344

return PTR_ERR(ssd130x->pwm);

drivers/gpu/drm/solomon/ssd130x.c

347

pwm_init_state(ssd130x->pwm, &pwmstate);

drivers/gpu/drm/solomon/ssd130x.c

349

pwm_apply_might_sleep(ssd130x->pwm, &pwmstate);

drivers/gpu/drm/solomon/ssd130x.c

352

pwm_enable(ssd130x->pwm);

drivers/gpu/drm/solomon/ssd130x.c

355

ssd130x->pwm->label, pwm_get_period(ssd130x->pwm));

drivers/gpu/drm/solomon/ssd130x.c

399

pwm_disable(ssd130x->pwm);

drivers/gpu/drm/solomon/ssd130x.c

400

pwm_put(ssd130x->pwm);

drivers/gpu/drm/solomon/ssd130x.h

95

struct pwm_device *pwm;

drivers/hwmon/abituguru.c

1239

SENSOR_ATTR_2(pwm%d_enable, 0644, show_pwm_enable,

drivers/hwmon/abituguru.c

1241

SENSOR_ATTR_2(pwm%d_auto_channels_temp, 0644, show_pwm_sensor,

drivers/hwmon/abituguru.c

1243

SENSOR_ATTR_2(pwm%d_auto_point1_pwm, 0644, show_pwm_setting,

drivers/hwmon/abituguru.c

1245

SENSOR_ATTR_2(pwm%d_auto_point2_pwm, 0644, show_pwm_setting,

drivers/hwmon/abituguru.c

1247

SENSOR_ATTR_2(pwm%d_auto_point1_temp, 0644, show_pwm_setting,

drivers/hwmon/abituguru.c

1249

SENSOR_ATTR_2(pwm%d_auto_point2_temp, 0644, show_pwm_setting,

drivers/hwmon/adm1026.c

1275

return sprintf(buf, "%d\n", PWM_FROM_REG(data->pwm1.pwm));

drivers/hwmon/adm1026.c

1293

data->pwm1.pwm = PWM_TO_REG(val);

drivers/hwmon/adm1026.c

1294

adm1026_write_value(client, ADM1026_REG_PWM, data->pwm1.pwm);

drivers/hwmon/adm1026.c

1324

data->pwm1.pwm = PWM_TO_REG((data->pwm1.pwm & 0x0f) |

drivers/hwmon/adm1026.c

1326

adm1026_write_value(client, ADM1026_REG_PWM, data->pwm1.pwm);

drivers/hwmon/adm1026.c

1370

data->pwm1.pwm = PWM_TO_REG((data->pwm1.pwm & 0x0f) |

drivers/hwmon/adm1026.c

1372

adm1026_write_value(client, ADM1026_REG_PWM, data->pwm1.pwm);

drivers/hwmon/adm1026.c

1375

data->pwm1.pwm = 255;

drivers/hwmon/adm1026.c

1376

adm1026_write_value(client, ADM1026_REG_PWM, data->pwm1.pwm);

drivers/hwmon/adm1026.c

260

u8 pwm;

drivers/hwmon/adm1026.c

359

data->pwm1.pwm = adm1026_read_value(client,

drivers/hwmon/adm1026.c

448

PWM_MIN_FROM_REG(data->pwm1.pwm);

drivers/hwmon/adm1031.c

185

data->pwm[chan] =

drivers/hwmon/adm1031.c

242

static int AUTO_TEMP_MAX_TO_REG(int val, int reg, int pwm)

drivers/hwmon/adm1031.c

245

int range = ((val - AUTO_TEMP_MIN_FROM_REG(reg)) * 10) / (16 - pwm);

drivers/hwmon/adm1031.c

363

data->old_pwm[0] = data->pwm[0];

drivers/hwmon/adm1031.c

364

data->old_pwm[1] = data->pwm[1];

drivers/hwmon/adm1031.c

368

data->pwm[0] = data->old_pwm[0];

drivers/hwmon/adm1031.c

369

data->pwm[1] = data->old_pwm[1];

drivers/hwmon/adm1031.c

372

data->pwm[0] | (data->pwm[1] << 4));

drivers/hwmon/adm1031.c

448

data->pwm[nr]);

drivers/hwmon/adm1031.c

471

return sprintf(buf, "%d\n", PWM_FROM_REG(data->pwm[nr]));

drivers/hwmon/adm1031.c

493

data->pwm[nr] = PWM_TO_REG(val);

drivers/hwmon/adm1031.c

496

nr ? ((data->pwm[nr] << 4) & 0xf0) | (reg & 0xf)

drivers/hwmon/adm1031.c

497

: (data->pwm[nr] & 0xf) | (reg & 0xf0));

drivers/hwmon/adm1031.c

502

static SENSOR_DEVICE_ATTR_RW(pwm1, pwm, 0);

drivers/hwmon/adm1031.c

503

static SENSOR_DEVICE_ATTR_RW(pwm2, pwm, 1);

drivers/hwmon/adm1031.c

504

static SENSOR_DEVICE_ATTR_RW(auto_fan1_min_pwm, pwm, 0);

drivers/hwmon/adm1031.c

505

static SENSOR_DEVICE_ATTR_RW(auto_fan2_min_pwm, pwm, 1);

drivers/hwmon/adm1031.c

550

res = data->pwm[chan] > 0;

drivers/hwmon/adm1031.c

82

u8 pwm[2];

drivers/hwmon/adt7462.c

1089

return sprintf(buf, "%d\n", data->pwm[attr->index]);

drivers/hwmon/adt7462.c

1106

data->pwm[attr->index] = temp;

drivers/hwmon/adt7462.c

1545

static SENSOR_DEVICE_ATTR_RW(pwm1, pwm, 0);

drivers/hwmon/adt7462.c

1546

static SENSOR_DEVICE_ATTR_RW(pwm2, pwm, 1);

drivers/hwmon/adt7462.c

1547

static SENSOR_DEVICE_ATTR_RW(pwm3, pwm, 2);

drivers/hwmon/adt7462.c

1548

static SENSOR_DEVICE_ATTR_RW(pwm4, pwm, 3);

drivers/hwmon/adt7462.c

208

u8 pwm[ADT7462_PWM_COUNT];

drivers/hwmon/adt7462.c

704

data->pwm[i] = i2c_smbus_read_byte_data(client,

drivers/hwmon/adt7470.c

1245

HWMON_CHANNEL_INFO(pwm,

drivers/hwmon/adt7470.c

179

u8 pwm[ADT7470_PWM_COUNT];

drivers/hwmon/adt7470.c

225

u8 pwm[ADT7470_FAN_COUNT];

drivers/hwmon/adt7470.c

240

err = regmap_bulk_read(data->regmap, ADT7470_REG_PWM(0), &pwm[0],

drivers/hwmon/adt7470.c

256

err = regmap_bulk_write(data->regmap, ADT7470_REG_PWM(0), &pwm[0],

drivers/hwmon/adt7470.c

362

err = regmap_bulk_read(data->regmap, ADT7470_REG_PWM(0), &data->pwm[0], ADT7470_PWM_COUNT);

drivers/hwmon/adt7470.c

791

*val = data->pwm[channel];

drivers/hwmon/adt7470.c

858

data->pwm[channel] = val;

drivers/hwmon/adt7475.c

1168

static SENSOR_DEVICE_ATTR_2_RW(pwm1, pwm, INPUT, 0);

drivers/hwmon/adt7475.c

1172

static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point1_pwm, pwm, MIN, 0);

drivers/hwmon/adt7475.c

1173

static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point2_pwm, pwm, MAX, 0);

drivers/hwmon/adt7475.c

1175

static SENSOR_DEVICE_ATTR_2_RW(pwm2, pwm, INPUT, 1);

drivers/hwmon/adt7475.c

1179

static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point1_pwm, pwm, MIN, 1);

drivers/hwmon/adt7475.c

1180

static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point2_pwm, pwm, MAX, 1);

drivers/hwmon/adt7475.c

1182

static SENSOR_DEVICE_ATTR_2_RW(pwm3, pwm, INPUT, 2);

drivers/hwmon/adt7475.c

1186

static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_point1_pwm, pwm, MIN, 2);

drivers/hwmon/adt7475.c

1187

static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_point2_pwm, pwm, MAX, 2);

drivers/hwmon/adt7475.c

1474

data->pwm[MAX][i] = ret;

drivers/hwmon/adt7475.c

1479

data->pwm[MIN][i] = ret;

drivers/hwmon/adt7475.c

1771

data->pwm[CONTROL][cfg.index] = ret;

drivers/hwmon/adt7475.c

1773

data->pwm[CONTROL][cfg.index] |= BIT(4);

drivers/hwmon/adt7475.c

1775

data->pwm[CONTROL][cfg.index] &= ~BIT(4);

drivers/hwmon/adt7475.c

1778

data->pwm[CONTROL][cfg.index] &= ~0xE0;

drivers/hwmon/adt7475.c

1779

data->pwm[CONTROL][cfg.index] |= 0x07 << 5;

drivers/hwmon/adt7475.c

1782

data->pwm[CONTROL][cfg.index]);

drivers/hwmon/adt7475.c

1786

data->pwm[INPUT][cfg.index] = cfg.duty;

drivers/hwmon/adt7475.c

1788

data->pwm[INPUT][cfg.index]);

drivers/hwmon/adt7475.c

2021

data->pwm[CONTROL][index] = adt7475_read(PWM_CONFIG_REG(index));

drivers/hwmon/adt7475.c

2027

v = (data->pwm[CONTROL][index] >> 5) & 7;

drivers/hwmon/adt7475.c

2039

data->pwm[INPUT][index] = 0;

drivers/hwmon/adt7475.c

2040

data->pwm[CONTROL][index] &= ~0xE0;

drivers/hwmon/adt7475.c

2041

data->pwm[CONTROL][index] |= (7 << 5);

drivers/hwmon/adt7475.c

2044

data->pwm[INPUT][index]);

drivers/hwmon/adt7475.c

2047

data->pwm[CONTROL][index]);

drivers/hwmon/adt7475.c

217

u8 pwm[4][3];

drivers/hwmon/adt7475.c

2175

data->pwm[INPUT][i] = ret;

drivers/hwmon/adt7475.c

757

return sprintf(buf, "%d\n", data->pwm[sattr->nr][sattr->index]);

drivers/hwmon/adt7475.c

802

data->pwm[CONTROL][sattr->index] =

drivers/hwmon/adt7475.c

809

if (((data->pwm[CONTROL][sattr->index] >> 5) & 7) != 7) {

drivers/hwmon/adt7475.c

826

data->pwm[sattr->nr][sattr->index] = clamp_val(val, 0, 0xFF);

drivers/hwmon/adt7475.c

828

data->pwm[sattr->nr][sattr->index]);

drivers/hwmon/adt7475.c

920

data->pwm[CONTROL][index] &= ~0xE0;

drivers/hwmon/adt7475.c

921

data->pwm[CONTROL][index] |= (val & 7) << 5;

drivers/hwmon/adt7475.c

924

data->pwm[CONTROL][index]);

drivers/hwmon/amc6821.c

558

u32 pwm;

drivers/hwmon/amc6821.c

560

err = regmap_read(regmap, AMC6821_REG_DCY_LOW_TEMP, &pwm);

drivers/hwmon/amc6821.c

564

dpwm = 255 - pwm;

drivers/hwmon/amc6821.c

795

HWMON_CHANNEL_INFO(pwm,

drivers/hwmon/aquacomputer_d5next.c

1292

HWMON_CHANNEL_INFO(pwm,

drivers/hwmon/arctic_fan_controller.c

240

HWMON_CHANNEL_INFO(pwm,

drivers/hwmon/asb100.c

152

static u8 ASB100_PWM_TO_REG(int pwm)

drivers/hwmon/asb100.c

154

pwm = clamp_val(pwm, 0, 255);

drivers/hwmon/asb100.c

155

return (u8)(pwm / 16);

drivers/hwmon/asb100.c

199

u8 pwm; /* Register encoding */

drivers/hwmon/asb100.c

543

return sprintf(buf, "%d\n", ASB100_PWM_FROM_REG(data->pwm & 0x0f));

drivers/hwmon/asb100.c

559

data->pwm &= 0x80; /* keep the enable bit */

drivers/hwmon/asb100.c

560

data->pwm |= (0x0f & ASB100_PWM_TO_REG(val));

drivers/hwmon/asb100.c

561

asb100_write_value(client, ASB100_REG_PWM1, data->pwm);

drivers/hwmon/asb100.c

570

return sprintf(buf, "%d\n", (data->pwm & 0x80) ? 1 : 0);

drivers/hwmon/asb100.c

587

data->pwm &= 0x0f; /* keep the duty cycle bits */

drivers/hwmon/asb100.c

588

data->pwm |= (val ? 0x80 : 0x00);

drivers/hwmon/asb100.c

589

asb100_write_value(client, ASB100_REG_PWM1, data->pwm);

drivers/hwmon/asb100.c

987

data->pwm = asb100_read_value(client, ASB100_REG_PWM1);

drivers/hwmon/aspeed-g6-pwm-tach.c

149

static int aspeed_pwm_get_state(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/hwmon/aspeed-g6-pwm-tach.c

153

u32 hwpwm = pwm->hwpwm;

drivers/hwmon/aspeed-g6-pwm-tach.c

187

static int aspeed_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/hwmon/aspeed-g6-pwm-tach.c

191

u32 hwpwm = pwm->hwpwm, duty_pt, val;

drivers/hwmon/aspeed-pwm-tacho.c

649

static SENSOR_DEVICE_ATTR_RW(pwm1, pwm, 0);

drivers/hwmon/aspeed-pwm-tacho.c

650

static SENSOR_DEVICE_ATTR_RW(pwm2, pwm, 1);

drivers/hwmon/aspeed-pwm-tacho.c

651

static SENSOR_DEVICE_ATTR_RW(pwm3, pwm, 2);

drivers/hwmon/aspeed-pwm-tacho.c

652

static SENSOR_DEVICE_ATTR_RW(pwm4, pwm, 3);

drivers/hwmon/aspeed-pwm-tacho.c

653

static SENSOR_DEVICE_ATTR_RW(pwm5, pwm, 4);

drivers/hwmon/aspeed-pwm-tacho.c

654

static SENSOR_DEVICE_ATTR_RW(pwm6, pwm, 5);

drivers/hwmon/aspeed-pwm-tacho.c

655

static SENSOR_DEVICE_ATTR_RW(pwm7, pwm, 6);

drivers/hwmon/aspeed-pwm-tacho.c

656

static SENSOR_DEVICE_ATTR_RW(pwm8, pwm, 7);

drivers/hwmon/asus_rog_ryujin.c

375

HWMON_CHANNEL_INFO(pwm,

drivers/hwmon/axi-fan-control.c

398

HWMON_CHANNEL_INFO(pwm, HWMON_PWM_INPUT),

drivers/hwmon/corsair-cpro.c

430

HWMON_CHANNEL_INFO(pwm,

drivers/hwmon/corsair-psu.c

634

HWMON_CHANNEL_INFO(pwm,

drivers/hwmon/cros_ec_hwmon.c

355

HWMON_CHANNEL_INFO(pwm,

drivers/hwmon/dell-smm-hwmon.c

1025

unsigned long pwm;

drivers/hwmon/dell-smm-hwmon.c

1033

pwm = clamp_val(DIV_ROUND_CLOSEST(val, data->i8k_pwm_mult), 0,

drivers/hwmon/dell-smm-hwmon.c

1037

err = i8k_set_fan(data, channel, pwm);

drivers/hwmon/dell-smm-hwmon.c

1119

HWMON_CHANNEL_INFO(pwm,

drivers/hwmon/dme1737.c

1211

res = data->pwm[ix];

drivers/hwmon/dme1737.c

1277

data->pwm[ix] = clamp_val(val, 0, 255);

drivers/hwmon/dme1737.c

1278

dme1737_write(data, DME1737_REG_PWM(ix), data->pwm[ix]);

drivers/hwmon/dme1737.c

1603

static SENSOR_DEVICE_ATTR_2(pwm##ix, S_IRUGO, \

drivers/hwmon/dme1737.c

1605

static SENSOR_DEVICE_ATTR_2(pwm##ix##_freq, S_IRUGO, \

drivers/hwmon/dme1737.c

1607

static SENSOR_DEVICE_ATTR_2(pwm##ix##_enable, S_IRUGO, \

drivers/hwmon/dme1737.c

1609

static SENSOR_DEVICE_ATTR_2(pwm##ix##_ramp_rate, S_IRUGO, \

drivers/hwmon/dme1737.c

1611

static SENSOR_DEVICE_ATTR_2(pwm##ix##_auto_channels_zone, S_IRUGO, \

drivers/hwmon/dme1737.c

1613

static SENSOR_DEVICE_ATTR_2(pwm##ix##_auto_pwm_min, S_IRUGO, \

drivers/hwmon/dme1737.c

1615

static SENSOR_DEVICE_ATTR_2(pwm##ix##_auto_point1_pwm, S_IRUGO, \

drivers/hwmon/dme1737.c

1617

static SENSOR_DEVICE_ATTR_2(pwm##ix##_auto_point2_pwm, S_IRUGO, \

drivers/hwmon/dme1737.c

1627

static SENSOR_DEVICE_ATTR_2(pwm##ix, S_IRUGO, \

drivers/hwmon/dme1737.c

1629

static SENSOR_DEVICE_ATTR_2(pwm##ix##_freq, S_IRUGO, \

drivers/hwmon/dme1737.c

1631

static SENSOR_DEVICE_ATTR_2(pwm##ix##_enable, S_IRUGO, \

drivers/hwmon/dme1737.c

231

u8 pwm[6];

drivers/hwmon/dme1737.c

703

for (ix = 0; ix < ARRAY_SIZE(data->pwm); ix++) {

drivers/hwmon/dme1737.c

710

data->pwm[ix] = dme1737_read(data,

drivers/hwmon/emc2305.c

308

long pwm;

drivers/hwmon/emc2305.c

312

pwm = data->pwm_min[cdev_idx];

drivers/hwmon/emc2305.c

326

pwm = EMC2305_PWM_STATE2DUTY(data->cdev_data[cdev_idx].cur_state,

drivers/hwmon/emc2305.c

331

ret = emc2305_set_pwm(dev, pwm, cdev_idx);

drivers/hwmon/emc2305.c

336

ret = emc2305_set_pwm(dev, pwm, i);

drivers/hwmon/emc2305.c

342

EMC2305_PWM_DUTY2STATE(pwm, data->max_state,

drivers/hwmon/emc2305.c

345

EMC2305_PWM_DUTY2STATE(pwm, data->max_state,

drivers/hwmon/emc2305.c

497

HWMON_CHANNEL_INFO(pwm,

drivers/hwmon/f71805f.c

181

u8 pwm[3];

drivers/hwmon/f71805f.c

395

data->pwm[nr] = f71805f_read8(data,

drivers/hwmon/f71805f.c

643

return sprintf(buf, "%d\n", (int)data->pwm[nr]);

drivers/hwmon/f71805f.c

705

data->pwm[nr] = val;

drivers/hwmon/f71805f.c

706

f71805f_write8(data, F71805F_REG_PWM_DUTY(nr), data->pwm[nr]);

drivers/hwmon/f71882fg.c

1097

val = data->pwm[nr];

drivers/hwmon/f71882fg.c

1134

data->pwm[nr] = val;

drivers/hwmon/f71882fg.c

1324

val = data->pwm[nr];

drivers/hwmon/f71882fg.c

1344

data->pwm[nr] = val;

drivers/hwmon/f71882fg.c

1463

int pwm = to_sensor_dev_attr_2(devattr)->index;

drivers/hwmon/f71882fg.c

1467

if (data->pwm_enable & (1 << (2 * pwm))) {

drivers/hwmon/f71882fg.c

1469

result = data->pwm_auto_point_pwm[pwm][point];

drivers/hwmon/f71882fg.c

1472

result = 32 * 255 / (32 + data->pwm_auto_point_pwm[pwm][point]);

drivers/hwmon/f71882fg.c

1484

int err, pwm = to_sensor_dev_attr_2(devattr)->index;

drivers/hwmon/f71882fg.c

1496

if (data->pwm_enable & (1 << (2 * pwm))) {

drivers/hwmon/f71882fg.c

1505

f71882fg_write8(data, F71882FG_REG_POINT_PWM(pwm, point), val);

drivers/hwmon/f71882fg.c

1506

data->pwm_auto_point_pwm[pwm][point] = val;

drivers/hwmon/f71882fg.c

1518

int pwm = to_sensor_dev_attr_2(devattr)->index;

drivers/hwmon/f71882fg.c

1521

result = data->pwm_auto_point_temp[pwm][point];

drivers/hwmon/f71882fg.c

1530

int err, pwm = to_sensor_dev_attr_2(devattr)->index;

drivers/hwmon/f71882fg.c

1546

f71882fg_write8(data, F71882FG_REG_POINT_TEMP(pwm, point), val);

drivers/hwmon/f71882fg.c

1547

data->pwm_auto_point_temp[pwm][point] = val;

drivers/hwmon/f71882fg.c

281

u8 pwm[4];

drivers/hwmon/f71882fg.c

476

data->pwm[nr] =

drivers/hwmon/f71882fg.c

483

data->pwm[2] = f71882fg_read8(data,

drivers/hwmon/f71882fg.c

95

#define F71882FG_REG_POINT_PWM(pwm, point) (0xAA + (point) + (16 * (pwm)))

drivers/hwmon/f71882fg.c

96

#define F71882FG_REG_POINT_TEMP(pwm, point) (0xA6 + (point) + (16 * (pwm)))

drivers/hwmon/f75375s.c

101

u8 pwm[2];

drivers/hwmon/f75375s.c

145

f75375_write16(client, F75375_REG_FAN_EXP(nr), data->pwm[nr]);

drivers/hwmon/f75375s.c

148

data->pwm[nr]);

drivers/hwmon/f75375s.c

188

data->pwm[nr] = f75375_read8(client,

drivers/hwmon/f75375s.c

322

data->pwm[nr] = clamp_val(val, 0, 255);

drivers/hwmon/f75375s.c

357

data->pwm[nr] = 255;

drivers/hwmon/f75375s.c

378

data->pwm[nr] = 255;

drivers/hwmon/f75375s.c

468

return sprintf(buf, "%d\n", data->pwm[nr]);

drivers/hwmon/f75375s.c

785

data->pwm[nr] = clamp_val(f75375s_pdata->pwm[nr], 0, 255);

drivers/hwmon/ftsteutates.c

524

HWMON_CHANNEL_INFO(pwm,

drivers/hwmon/g760a.c

59

#define PWM_TO_CNT(pwm) (0xff-(pwm))

drivers/hwmon/gigabyte_waterforce.c

244

HWMON_CHANNEL_INFO(pwm,

drivers/hwmon/gpd-fan.c

584

HWMON_CHANNEL_INFO(pwm, HWMON_PWM_INPUT | HWMON_PWM_ENABLE),

drivers/hwmon/gpio-fan.c

191

u8 pwm = fan_data->speed_index * 255 / (fan_data->num_speed - 1);

drivers/hwmon/gpio-fan.c

193

return sprintf(buf, "%d\n", pwm);

drivers/hwmon/gpio-fan.c

200

unsigned long pwm;

drivers/hwmon/gpio-fan.c

204

if (kstrtoul(buf, 10, &pwm) || pwm > 255)

drivers/hwmon/gpio-fan.c

214

speed_index = DIV_ROUND_UP(pwm * (fan_data->num_speed - 1), 255);

drivers/hwmon/gxp-fan-ctrl.c

180

HWMON_CHANNEL_INFO(pwm,

drivers/hwmon/it87.c

3421

u8 pwm[3];

drivers/hwmon/it87.c

3423

for (i = 0; i < ARRAY_SIZE(pwm); i++)

drivers/hwmon/it87.c

3424

pwm[i] = it87_read_value(data,

drivers/hwmon/it87.c

3433

if (!((pwm[0] | pwm[1] | pwm[2]) & 0x80)) {

drivers/hwmon/it87.c

3441

0x7f & ~pwm[i]);

drivers/hwmon/lan966x-hwmon.c

266

HWMON_CHANNEL_INFO(pwm, HWMON_PWM_INPUT | HWMON_PWM_FREQ),

drivers/hwmon/lm63.c

375

int pwm;

drivers/hwmon/lm63.c

379

pwm = data->pwm1[nr];

drivers/hwmon/lm63.c

381

pwm = data->pwm1[nr] >= 2 * data->pwm1_freq ?

drivers/hwmon/lm63.c

386

return sprintf(buf, "%d\n", pwm);

drivers/hwmon/lm85.c

309

u8 pwm[3]; /* Register value */

drivers/hwmon/lm85.c

422

data->pwm[i] =

drivers/hwmon/lm85.c

688

return sprintf(buf, "%d\n", PWM_FROM_REG(data->pwm[nr]));

drivers/hwmon/lm85.c

705

data->pwm[nr] = PWM_TO_REG(val);

drivers/hwmon/lm85.c

706

lm85_write_value(client, LM85_REG_PWM(nr), data->pwm[nr]);

drivers/hwmon/lm85.c

831

static SENSOR_DEVICE_ATTR_RW(pwm1, pwm, 0);

drivers/hwmon/lm85.c

834

static SENSOR_DEVICE_ATTR_RW(pwm2, pwm, 1);

drivers/hwmon/lm85.c

837

static SENSOR_DEVICE_ATTR_RW(pwm3, pwm, 2);

drivers/hwmon/lm93.c

1793

static SENSOR_DEVICE_ATTR_RW(pwm1, pwm, 0);

drivers/hwmon/lm93.c

1794

static SENSOR_DEVICE_ATTR_RW(pwm2, pwm, 1);

drivers/hwmon/lm93.c

1870

struct lm93_data *data, int pwm)

drivers/hwmon/lm93.c

1876

mapping = (mapping >> pwm) & 0x55;

drivers/hwmon/lm93.c

582

static u8 LM93_PWM_TO_REG(int pwm, enum pwm_freq freq)

drivers/hwmon/lm93.c

586

if (pwm <= lm93_pwm_map[freq][i])

drivers/hwmon/max31760.c

332

HWMON_CHANNEL_INFO(pwm,

drivers/hwmon/max31760.c

433

u8 pwm;

drivers/hwmon/max31760.c

435

ret = kstrtou8(buf, 10, &pwm);

drivers/hwmon/max31760.c

439

ret = regmap_write(state->regmap, REG_LUT(sda->index), pwm);

drivers/hwmon/max31790.c

112

data->pwm[i] = rv;

drivers/hwmon/max31790.c

298

*val = data->pwm[channel] >> 8;

drivers/hwmon/max31790.c

443

HWMON_CHANNEL_INFO(pwm,

drivers/hwmon/max31790.c

68

u16 pwm[NR_CHANNEL];

drivers/hwmon/max6639.c

481

HWMON_CHANNEL_INFO(pwm,

drivers/hwmon/max6650.c

150

static u8 pwm_to_dac(unsigned int pwm, bool v12)

drivers/hwmon/max6650.c

154

return limit - (limit * pwm) / 255;

drivers/hwmon/max6650.c

746

HWMON_CHANNEL_INFO(pwm, HWMON_PWM_INPUT | HWMON_PWM_ENABLE),

drivers/hwmon/mlxreg-fan.c

112

struct mlxreg_fan_pwm pwm[MLXREG_FAN_MAX_PWM];

drivers/hwmon/mlxreg-fan.c

127

struct mlxreg_fan_pwm *pwm;

drivers/hwmon/mlxreg-fan.c

186

pwm = &fan->pwm[channel];

drivers/hwmon/mlxreg-fan.c

189

err = regmap_read(fan->regmap, pwm->reg, &regval);

drivers/hwmon/mlxreg-fan.c

213

struct mlxreg_fan_pwm *pwm;

drivers/hwmon/mlxreg-fan.c

222

pwm = &fan->pwm[channel];

drivers/hwmon/mlxreg-fan.c

225

pwm->last_hwmon_state = MLXREG_FAN_PWM_DUTY2STATE(val);

drivers/hwmon/mlxreg-fan.c

230

if (pwm->last_hwmon_state >= pwm->last_thermal_state)

drivers/hwmon/mlxreg-fan.c

231

return _mlxreg_fan_set_cur_state(pwm->cdev,

drivers/hwmon/mlxreg-fan.c

232

pwm->last_hwmon_state,

drivers/hwmon/mlxreg-fan.c

236

return regmap_write(fan->regmap, pwm->reg, val);

drivers/hwmon/mlxreg-fan.c

268

if (!(((struct mlxreg_fan *)data)->pwm[channel].connected))

drivers/hwmon/mlxreg-fan.c

319

HWMON_CHANNEL_INFO(pwm,

drivers/hwmon/mlxreg-fan.c

349

struct mlxreg_fan_pwm *pwm = cdev->devdata;

drivers/hwmon/mlxreg-fan.c

350

struct mlxreg_fan *fan = pwm->fan;

drivers/hwmon/mlxreg-fan.c

354

err = regmap_read(fan->regmap, pwm->reg, &regval);

drivers/hwmon/mlxreg-fan.c

368

struct mlxreg_fan_pwm *pwm = cdev->devdata;

drivers/hwmon/mlxreg-fan.c

369

struct mlxreg_fan *fan = pwm->fan;

drivers/hwmon/mlxreg-fan.c

377

pwm->last_thermal_state = state;

drivers/hwmon/mlxreg-fan.c

379

state = max_t(unsigned long, state, pwm->last_hwmon_state);

drivers/hwmon/mlxreg-fan.c

380

err = regmap_write(fan->regmap, pwm->reg,

drivers/hwmon/mlxreg-fan.c

508

fan->pwm[pwm_num].reg = data->reg;

drivers/hwmon/mlxreg-fan.c

509

fan->pwm[pwm_num].connected = true;

drivers/hwmon/mlxreg-fan.c

579

struct mlxreg_fan_pwm *pwm = &fan->pwm[i];

drivers/hwmon/mlxreg-fan.c

581

if (!pwm->connected)

drivers/hwmon/mlxreg-fan.c

583

pwm->fan = fan;

drivers/hwmon/mlxreg-fan.c

585

pwm->last_hwmon_state = MLXREG_FAN_PWM_DUTY2STATE(MLXREG_FAN_MIN_DUTY);

drivers/hwmon/mlxreg-fan.c

586

pwm->cdev = devm_thermal_cooling_device_register(dev, mlxreg_fan_name[i],

drivers/hwmon/mlxreg-fan.c

587

pwm, &mlxreg_fan_cooling_ops);

drivers/hwmon/mlxreg-fan.c

588

if (IS_ERR(pwm->cdev)) {

drivers/hwmon/mlxreg-fan.c

590

return PTR_ERR(pwm->cdev);

drivers/hwmon/nct6683.c

345

u8 pwm[NCT6683_NUM_REG_PWM];

drivers/hwmon/nct6683.c

599

data->pwm[i] = nct6683_read(data, NCT6683_REG_PWM(i));

drivers/hwmon/nct6683.c

926

return sprintf(buf, "%d\n", data->pwm[index]);

drivers/hwmon/nct6683.c

951

SENSOR_TEMPLATE(pwm, "pwm%d", S_IRUGO, show_pwm, store_pwm, 0);

drivers/hwmon/nct6683.c

958

int pwm = index; /* pwm index */

drivers/hwmon/nct6683.c

960

if (!(data->have_pwm & (1 << pwm)))

drivers/hwmon/nct6694-hwmon.c

119

u8 pwm;

drivers/hwmon/nct6694-hwmon.c

225

HWMON_CHANNEL_INFO(pwm,

drivers/hwmon/nct6694-hwmon.c

489

.len = cpu_to_le16(sizeof(data->rpt->pwm))

drivers/hwmon/nct6694-hwmon.c

492

&data->rpt->pwm);

drivers/hwmon/nct6694-hwmon.c

496

*val = data->rpt->pwm;

drivers/hwmon/nct6775-core.c

1414

data->pwm[j][i] = reg;

drivers/hwmon/nct6775-core.c

1418

data->pwm_enable[i] = reg_to_pwm_enable(data->pwm[0][i],

drivers/hwmon/nct6775-core.c

1448

data->pwm[2][i] = 0;

drivers/hwmon/nct6775-core.c

2520

u16 pwm;

drivers/hwmon/nct6775-core.c

2530

err = nct6775_read_value(data, data->REG_PWM_READ[nr], &pwm);

drivers/hwmon/nct6775-core.c

2534

pwm = data->pwm[index][nr];

drivers/hwmon/nct6775-core.c

2537

return sysfs_emit(buf, "%d\n", pwm);

drivers/hwmon/nct6775-core.c

2549

int minval[7] = { 0, 1, 1, data->pwm[2][nr], 0, 0, 0 };

drivers/hwmon/nct6775-core.c

2551

= { 255, 255, data->pwm[3][nr] ? : 255, 255, 255, 255, 255 };

drivers/hwmon/nct6775-core.c

2568

data->pwm[index][nr] = val;

drivers/hwmon/nct6775-core.c

2705

data->pwm[0][nr] = 255;

drivers/hwmon/nct6775-core.c

3046

SENSOR_TEMPLATE_2(pwm, "pwm%d", 0644, show_pwm, store_pwm, 0, 0);

drivers/hwmon/nct6775-core.c

3285

int pwm = index / 36; /* pwm index */

drivers/hwmon/nct6775-core.c

3288

if (!(data->has_pwm & BIT(pwm)))

drivers/hwmon/nct6775-core.c

3292

if (!data->REG_WEIGHT_TEMP_SEL[pwm])

drivers/hwmon/nct6775-core.c

899

static enum pwm_enable reg_to_pwm_enable(int pwm, int mode)

drivers/hwmon/nct6775-core.c

901

if (mode == 0 && pwm == 255)

drivers/hwmon/nct6775.h

136

u8 pwm[7][NUM_FAN]; /* [0]=pwm, [1]=pwm_start, [2]=pwm_floor,

drivers/hwmon/nct7363.c

271

HWMON_CHANNEL_INFO(pwm,

drivers/hwmon/nct7802.c

1001

static SENSOR_DEVICE_ATTR_RW(pwm3_auto_point1_pwm, pwm, 0xA5);

drivers/hwmon/nct7802.c

1002

static SENSOR_DEVICE_ATTR_RW(pwm3_auto_point2_pwm, pwm, 0xA6);

drivers/hwmon/nct7802.c

1003

static SENSOR_DEVICE_ATTR_RW(pwm3_auto_point3_pwm, pwm, 0xA7);

drivers/hwmon/nct7802.c

1004

static SENSOR_DEVICE_ATTR_RW(pwm3_auto_point4_pwm, pwm, 0xA8);

drivers/hwmon/nct7802.c

1005

static SENSOR_DEVICE_ATTR_RO(pwm3_auto_point5_pwm, pwm, 0);

drivers/hwmon/nct7802.c

901

static SENSOR_DEVICE_ATTR_RW(pwm1, pwm, REG_PWM(0));

drivers/hwmon/nct7802.c

902

static SENSOR_DEVICE_ATTR_RW(pwm2, pwm, REG_PWM(1));

drivers/hwmon/nct7802.c

903

static SENSOR_DEVICE_ATTR_RW(pwm3, pwm, REG_PWM(2));

drivers/hwmon/nct7802.c

973

static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point1_pwm, pwm, 0x85);

drivers/hwmon/nct7802.c

974

static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point2_pwm, pwm, 0x86);

drivers/hwmon/nct7802.c

975

static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point3_pwm, pwm, 0x87);

drivers/hwmon/nct7802.c

976

static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point4_pwm, pwm, 0x88);

drivers/hwmon/nct7802.c

977

static SENSOR_DEVICE_ATTR_RO(pwm1_auto_point5_pwm, pwm, 0);

drivers/hwmon/nct7802.c

987

static SENSOR_DEVICE_ATTR_RW(pwm2_auto_point1_pwm, pwm, 0x95);

drivers/hwmon/nct7802.c

988

static SENSOR_DEVICE_ATTR_RW(pwm2_auto_point2_pwm, pwm, 0x96);

drivers/hwmon/nct7802.c

989

static SENSOR_DEVICE_ATTR_RW(pwm2_auto_point3_pwm, pwm, 0x97);

drivers/hwmon/nct7802.c

990

static SENSOR_DEVICE_ATTR_RW(pwm2_auto_point4_pwm, pwm, 0x98);

drivers/hwmon/nct7802.c

991

static SENSOR_DEVICE_ATTR_RO(pwm2_auto_point5_pwm, pwm, 0);

drivers/hwmon/nct7904.c

850

HWMON_CHANNEL_INFO(pwm,

drivers/hwmon/npcm750-pwm-fan.c

636

HWMON_CHANNEL_INFO(pwm,

drivers/hwmon/nzxt-kraken3.c

719

HWMON_CHANNEL_INFO(pwm,

drivers/hwmon/nzxt-smart2.c

670

HWMON_CHANNEL_INFO(pwm, HWMON_PWM_INPUT | HWMON_PWM_MODE | HWMON_PWM_ENABLE,

drivers/hwmon/pc87360.c

1242

PWM_FROM_REG(data->pwm[attr->index],

drivers/hwmon/pc87360.c

1260

data->pwm[attr->index] = PWM_TO_REG(val,

drivers/hwmon/pc87360.c

1263

data->pwm[attr->index]);

drivers/hwmon/pc87360.c

1268

static struct sensor_device_attribute pwm[] = {

drivers/hwmon/pc87360.c

1269

SENSOR_ATTR_RW(pwm1, pwm, 0),

drivers/hwmon/pc87360.c

1270

SENSOR_ATTR_RW(pwm2, pwm, 1),

drivers/hwmon/pc87360.c

1271

SENSOR_ATTR_RW(pwm3, pwm, 2),

drivers/hwmon/pc87360.c

1293

device_remove_file(dev, &pwm[i].dev_attr);

drivers/hwmon/pc87360.c

1571

err = device_create_file(dev, &pwm[i].dev_attr);

drivers/hwmon/pc87360.c

203

u8 pwm[3]; /* Register value */

drivers/hwmon/pc87360.c

321

data->pwm[i] = pc87360_read_value(data, LD_FAN,

drivers/hwmon/pc87427.c

245

data->pwm[nr] = inb(iobase + PC87427_REG_PWM_DUTY);

drivers/hwmon/pc87427.c

593

update_pwm_enable(data, nr, pwm_enable_to_reg(val, data->pwm[nr]));

drivers/hwmon/pc87427.c

605

return sprintf(buf, "%d\n", (int)data->pwm[nr]);

drivers/hwmon/pc87427.c

61

u8 pwm[4]; /* register values */

drivers/hwmon/pc87427.c

646

data->pwm[nr] = val;

drivers/hwmon/pc87427.c

659

static SENSOR_DEVICE_ATTR_RW(pwm1, pwm, 0);

drivers/hwmon/pc87427.c

660

static SENSOR_DEVICE_ATTR_RW(pwm2, pwm, 1);

drivers/hwmon/pc87427.c

661

static SENSOR_DEVICE_ATTR_RW(pwm3, pwm, 2);

drivers/hwmon/pc87427.c

662

static SENSOR_DEVICE_ATTR_RW(pwm4, pwm, 3);

drivers/hwmon/pwm-fan.c

159

ret = pwm_apply_might_sleep(ctx->pwm, state);

drivers/hwmon/pwm-fan.c

190

ret = pwm_apply_might_sleep(ctx->pwm, state);

drivers/hwmon/pwm-fan.c

203

static int __set_pwm(struct pwm_fan_ctx *ctx, unsigned long pwm)

drivers/hwmon/pwm-fan.c

206

unsigned long final_pwm = pwm;

drivers/hwmon/pwm-fan.c

211

if (pwm > 0) {

drivers/hwmon/pwm-fan.c

221

state->duty_cycle = DIV_ROUND_UP(pwm * (period - 1), MAX_PWM);

drivers/hwmon/pwm-fan.c

222

ret = pwm_apply_might_sleep(ctx->pwm, state);

drivers/hwmon/pwm-fan.c

227

pwm = final_pwm;

drivers/hwmon/pwm-fan.c

228

state->duty_cycle = DIV_ROUND_UP(pwm * (period - 1), MAX_PWM);

drivers/hwmon/pwm-fan.c

231

ret = pwm_apply_might_sleep(ctx->pwm, state);

drivers/hwmon/pwm-fan.c

237

ctx->pwm_value = pwm;

drivers/hwmon/pwm-fan.c

242

static int set_pwm(struct pwm_fan_ctx *ctx, unsigned long pwm)

drivers/hwmon/pwm-fan.c

247

ret = __set_pwm(ctx, pwm);

drivers/hwmon/pwm-fan.c

253

static void pwm_fan_update_state(struct pwm_fan_ctx *ctx, unsigned long pwm)

drivers/hwmon/pwm-fan.c

258

if (pwm < ctx->pwm_fan_cooling_levels[i + 1])

drivers/hwmon/pwm-fan.c

300

pwm_apply_might_sleep(ctx->pwm, state);

drivers/hwmon/pwm-fan.c

42

struct pwm_device *pwm;

drivers/hwmon/pwm-fan.c

518

ctx->pwm = devm_pwm_get(dev, NULL);

drivers/hwmon/pwm-fan.c

519

if (IS_ERR(ctx->pwm))

drivers/hwmon/pwm-fan.c

520

return dev_err_probe(dev, PTR_ERR(ctx->pwm), "Could not get PWM\n");

drivers/hwmon/pwm-fan.c

532

pwm_init_state(ctx->pwm, &ctx->pwm_state);

drivers/hwmon/pwm-fan.c

620

channels[0] = HWMON_CHANNEL_INFO(pwm, HWMON_PWM_INPUT | HWMON_PWM_ENABLE);

drivers/hwmon/qnap-mcu-hwmon.c

286

HWMON_CHANNEL_INFO(pwm, HWMON_PWM_INPUT),

drivers/hwmon/qnap-mcu-hwmon.c

68

static int qnap_mcu_hwmon_set_pwm(struct qnap_mcu_hwmon *hwm, u8 pwm)

drivers/hwmon/qnap-mcu-hwmon.c

70

const u8 cmd[] = { '@', 'F', 'W', '0', pwm }; /* 0 = fan-id?, pwm 0-255 */

drivers/hwmon/sch5627.c

498

HWMON_CHANNEL_INFO(pwm,

drivers/hwmon/smsc47m1.c

129

u8 pwm[3]; /* Register value (bit 0 is disable) */

drivers/hwmon/smsc47m1.c

164

data->pwm[i] = smsc47m1_read_value(data,

drivers/hwmon/smsc47m1.c

209

int rpm = (data->pwm[nr] & 0x7F) == 0x00 ? 0 :

drivers/hwmon/smsc47m1.c

248

return sprintf(buf, "%d\n", PWM_FROM_REG(data->pwm[attr->index]));

drivers/hwmon/smsc47m1.c

256

return sprintf(buf, "%d\n", PWM_EN_FROM_REG(data->pwm[attr->index]));

drivers/hwmon/smsc47m1.c

386

data->pwm[nr] &= 0x81; /* Preserve additional bits */

drivers/hwmon/smsc47m1.c

387

data->pwm[nr] |= PWM_TO_REG(val);

drivers/hwmon/smsc47m1.c

389

data->pwm[nr]);

drivers/hwmon/smsc47m1.c

413

data->pwm[nr] &= 0xFE; /* preserve the other bits */

drivers/hwmon/smsc47m1.c

414

data->pwm[nr] |= !val;

drivers/hwmon/smsc47m1.c

416

data->pwm[nr]);

drivers/hwmon/smsc47m1.c

426

static SENSOR_DEVICE_ATTR_RW(pwm1, pwm, 0);

drivers/hwmon/smsc47m1.c

432

static SENSOR_DEVICE_ATTR_RW(pwm2, pwm, 1);

drivers/hwmon/smsc47m1.c

438

static SENSOR_DEVICE_ATTR_RW(pwm3, pwm, 2);

drivers/hwmon/tc654.c

370

int pwm;

drivers/hwmon/tc654.c

376

pwm = 0;

drivers/hwmon/tc654.c

378

pwm = tc654_pwm_map[data->duty_cycle];

drivers/hwmon/tc654.c

380

return sprintf(buf, "%d\n", pwm);

drivers/hwmon/tc654.c

437

static SENSOR_DEVICE_ATTR_RW(pwm1, pwm, 0);

drivers/hwmon/vt1211.c

1028

SENSOR_ATTR_2(pwm##ix, S_IRUGO, \

drivers/hwmon/vt1211.c

1030

SENSOR_ATTR_2(pwm##ix##_enable, S_IRUGO | S_IWUSR, \

drivers/hwmon/vt1211.c

1032

SENSOR_ATTR_2(pwm##ix##_auto_channels_temp, S_IRUGO | S_IWUSR, \

drivers/hwmon/vt1211.c

1036

SENSOR_ATTR_2(pwm##ix##_freq, S_IRUGO | S_IWUSR, \

drivers/hwmon/vt1211.c

1040

SENSOR_ATTR_2(pwm##ix##_freq, S_IRUGO, \

drivers/hwmon/vt1211.c

1044

SENSOR_ATTR_2(pwm##ix##_auto_point##ap##_temp, S_IRUGO | S_IWUSR, \

drivers/hwmon/vt1211.c

1049

SENSOR_ATTR_2(pwm##ix##_auto_point##ap##_temp, S_IRUGO, \

drivers/hwmon/vt1211.c

1054

SENSOR_ATTR_2(pwm##ix##_auto_point##ap##_pwm, S_IRUGO | S_IWUSR, \

drivers/hwmon/vt1211.c

1059

SENSOR_ATTR_2(pwm##ix##_auto_point##ap##_pwm, S_IRUGO, \

drivers/hwmon/vt1211.c

122

u8 pwm[2];

drivers/hwmon/vt1211.c

300

data->pwm[ix] = vt1211_read8(data,

drivers/hwmon/vt1211.c

619

res = data->pwm[ix];

drivers/hwmon/w83627ehf.c

1530

*val = data->pwm[channel];

drivers/hwmon/w83627ehf.c

1664

HWMON_CHANNEL_INFO(pwm,

drivers/hwmon/w83627ehf.c

356

u8 pwm[4];

drivers/hwmon/w83627ehf.c

557

data->pwm[i] = w83627ehf_read_value(data, W83627EHF_REG_PWM[i]);

drivers/hwmon/w83627ehf.c

842

data->pwm[channel] = val;

drivers/hwmon/w83627hf.c

1433

return sprintf(buf, "%ld\n", (long) data->pwm[nr]);

drivers/hwmon/w83627hf.c

1453

data->pwm[nr] = PWM_TO_REG(val) & 0xf0;

drivers/hwmon/w83627hf.c

1456

data->pwm[nr] |

drivers/hwmon/w83627hf.c

1460

data->pwm[nr] = PWM_TO_REG(val);

drivers/hwmon/w83627hf.c

1463

data->pwm[nr]);

drivers/hwmon/w83627hf.c

1470

static SENSOR_DEVICE_ATTR_RW(pwm1, pwm, 0);

drivers/hwmon/w83627hf.c

1471

static SENSOR_DEVICE_ATTR_RW(pwm2, pwm, 1);

drivers/hwmon/w83627hf.c

1472

static SENSOR_DEVICE_ATTR_RW(pwm3, pwm, 2);

drivers/hwmon/w83627hf.c

373

u8 pwm[3]; /* Register value */

drivers/hwmon/w83627hf.c

515

data->pwm[i] = tmp;

drivers/hwmon/w83781d.c

1474

data->pwm[i] =

drivers/hwmon/w83781d.c

227

u8 pwm[4]; /* Register value */

drivers/hwmon/w83781d.c

693

return sprintf(buf, "%d\n", (int)data->pwm[attr->index]);

drivers/hwmon/w83781d.c

718

data->pwm[nr] = clamp_val(val, 0, 255);

drivers/hwmon/w83781d.c

719

w83781d_write_value(data, W83781D_REG_PWM[nr], data->pwm[nr]);

drivers/hwmon/w83791d.c

1534

data->pwm[i] = w83791d_read(client,

drivers/hwmon/w83791d.c

304

u8 pwm[5]; /* pwm duty cycle */

drivers/hwmon/w83791d.c

719

return sprintf(buf, "%u\n", data->pwm[nr]);

drivers/hwmon/w83791d.c

735

data->pwm[nr] = clamp_val(val, 0, 255);

drivers/hwmon/w83791d.c

736

w83791d_write(client, W83791D_REG_PWM[nr], data->pwm[nr]);

drivers/hwmon/w83792d.c

1512

data->pwm[i] = w83792d_read_value(client,

drivers/hwmon/w83792d.c

1619

dev_dbg(dev, "pwm[%d] is: 0x%x\n", i, data->pwm[i]);

drivers/hwmon/w83792d.c

276

u8 pwm[7]; /* The 7 PWM outputs */

drivers/hwmon/w83792d.c

586

return sprintf(buf, "%d\n", (data->pwm[nr] & 0x0f) << 4);

drivers/hwmon/w83792d.c

631

data->pwm[nr] = val;

drivers/hwmon/w83792d.c

632

w83792d_write_value(client, W83792D_REG_PWM[nr], data->pwm[nr]);

drivers/hwmon/w83792d.c

687

return sprintf(buf, "%d\n", data->pwm[nr] >> 7);

drivers/hwmon/w83792d.c

708

data->pwm[nr] = w83792d_read_value(client, W83792D_REG_PWM[nr]);

drivers/hwmon/w83792d.c

710

data->pwm[nr] |= 0x80;

drivers/hwmon/w83792d.c

712

data->pwm[nr] &= 0x7f;

drivers/hwmon/w83792d.c

714

w83792d_write_value(client, W83792D_REG_PWM[nr], data->pwm[nr]);

drivers/hwmon/w83793.c

1038

SENSOR_ATTR_2(pwm##index, S_IWUSR | S_IRUGO, show_pwm, \

drivers/hwmon/w83793.c

1040

SENSOR_ATTR_2(pwm##index##_nonstop, S_IWUSR | S_IRUGO, \

drivers/hwmon/w83793.c

1042

SENSOR_ATTR_2(pwm##index##_start, S_IWUSR | S_IRUGO, \

drivers/hwmon/w83793.c

1044

SENSOR_ATTR_2(pwm##index##_stop_time, S_IWUSR | S_IRUGO, \

drivers/hwmon/w83793.c

1998

for (i = 0; i < ARRAY_SIZE(data->pwm); i++) {

drivers/hwmon/w83793.c

2001

data->pwm[i][PWM_NONSTOP] =

drivers/hwmon/w83793.c

2003

data->pwm[i][PWM_START] =

drivers/hwmon/w83793.c

2062

for (i = 0; i < ARRAY_SIZE(data->pwm); i++) {

drivers/hwmon/w83793.c

2064

data->pwm[i][PWM_DUTY] =

drivers/hwmon/w83793.c

238

u8 pwm[8][3]; /* Register value */

drivers/hwmon/w83793.c

520

val = (data->pwm[index][nr] & 0x3f) << 2;

drivers/hwmon/w83793.c

550

data->pwm[index][nr] =

drivers/hwmon/w83793.c

552

data->pwm[index][nr] |= val;

drivers/hwmon/w83793.c

554

data->pwm[index][nr]);

drivers/hwmon/w83795.c

1637

SENSOR_ATTR_2(pwm##index, S_IWUSR | S_IRUGO, show_pwm, \

drivers/hwmon/w83795.c

1639

SENSOR_ATTR_2(pwm##index##_enable, S_IWUSR | S_IRUGO, \

drivers/hwmon/w83795.c

1641

SENSOR_ATTR_2(pwm##index##_mode, S_IRUGO, \

drivers/hwmon/w83795.c

1643

SENSOR_ATTR_2(pwm##index##_freq, S_IWUSR | S_IRUGO, \

drivers/hwmon/w83795.c

1645

SENSOR_ATTR_2(pwm##index##_nonstop, S_IWUSR | S_IRUGO, \

drivers/hwmon/w83795.c

1647

SENSOR_ATTR_2(pwm##index##_start, S_IWUSR | S_IRUGO, \

drivers/hwmon/w83795.c

1649

SENSOR_ATTR_2(pwm##index##_stop_time, S_IWUSR | S_IRUGO, \

drivers/hwmon/w83795.c

359

u8 pwm[8][5]; /*

drivers/hwmon/w83795.c

544

data->pwm[i][tmp] =

drivers/hwmon/w83795.c

661

data->pwm[i][PWM_OUTPUT] =

drivers/hwmon/w83795.c

840

val = time_from_reg(data->pwm[index][nr]);

drivers/hwmon/w83795.c

843

val = pwm_freq_from_reg(data->pwm[index][nr], data->clkin);

drivers/hwmon/w83795.c

846

val = data->pwm[index][nr];

drivers/hwmon/w83795.c

881

data->pwm[index][nr] = val;

drivers/hwmon/w83l786ng.c

138

u8 pwm[2];

drivers/hwmon/w83l786ng.c

201

data->pwm[i] =

drivers/hwmon/w83l786ng.c

481

show_pwm_reg(pwm)

drivers/hwmon/w83l786ng.c

528

data->pwm[nr] = val * 0x11;

drivers/iio/adc/ad4695.c

1674

static void ad4695_pwm_disable(void *pwm)

drivers/iio/adc/ad4695.c

1676

pwm_disable(pwm);

drivers/input/keyboard/lm8323.c

148

struct lm8323_pwm pwm[LM8323_NUM_PWMS];

drivers/input/keyboard/lm8323.c

352

static void pwm_done(struct lm8323_pwm *pwm)

drivers/input/keyboard/lm8323.c

354

guard(mutex)(&pwm->lock);

drivers/input/keyboard/lm8323.c

356

pwm->running = false;

drivers/input/keyboard/lm8323.c

357

if (pwm->desired_brightness != pwm->brightness)

drivers/input/keyboard/lm8323.c

358

schedule_work(&pwm->work);

drivers/input/keyboard/lm8323.c

393

pwm_done(&lm->pwm[i]);

drivers/input/keyboard/lm8323.c

415

static void lm8323_write_pwm_one(struct lm8323_pwm *pwm, int pos, u16 cmd)

drivers/input/keyboard/lm8323.c

417

lm8323_write(pwm->chip, 4, LM8323_CMD_PWM_WRITE, (pos << 2) | pwm->id,

drivers/input/keyboard/lm8323.c

427

static void lm8323_write_pwm(struct lm8323_pwm *pwm, int kill,

drivers/input/keyboard/lm8323.c

433

lm8323_write_pwm_one(pwm, i, cmds[i]);

drivers/input/keyboard/lm8323.c

435

lm8323_write_pwm_one(pwm, i++, PWM_END(kill));

drivers/input/keyboard/lm8323.c

436

lm8323_write(pwm->chip, 2, LM8323_CMD_START_PWM, pwm->id);

drivers/input/keyboard/lm8323.c

437

pwm->running = true;

drivers/input/keyboard/lm8323.c

442

struct lm8323_pwm *pwm = work_to_pwm(work);

drivers/input/keyboard/lm8323.c

447

guard(mutex)(&pwm->lock);

drivers/input/keyboard/lm8323.c

455

if (pwm->running || pwm->desired_brightness == pwm->brightness)

drivers/input/keyboard/lm8323.c

458

kill = (pwm->desired_brightness == 0);

drivers/input/keyboard/lm8323.c

459

up = (pwm->desired_brightness > pwm->brightness);

drivers/input/keyboard/lm8323.c

460

steps = abs(pwm->desired_brightness - pwm->brightness);

drivers/input/keyboard/lm8323.c

466

if ((pwm->fade_time / steps) > (32768 / 512)) {

drivers/input/keyboard/lm8323.c

474

perstep = (hz * pwm->fade_time) / (steps * 1000);

drivers/input/keyboard/lm8323.c

489

lm8323_write_pwm(pwm, kill, num_cmds, pwm_cmds);

drivers/input/keyboard/lm8323.c

490

pwm->brightness = pwm->desired_brightness;

drivers/input/keyboard/lm8323.c

496

struct lm8323_pwm *pwm = cdev_to_pwm(led_cdev);

drivers/input/keyboard/lm8323.c

497

struct lm8323_chip *lm = pwm->chip;

drivers/input/keyboard/lm8323.c

499

scoped_guard(mutex, &pwm->lock) {

drivers/input/keyboard/lm8323.c

500

pwm->desired_brightness = brightness;

drivers/input/keyboard/lm8323.c

504

schedule_work(&pwm->work);

drivers/input/keyboard/lm8323.c

511

schedule_work(&pwm->work);

drivers/input/keyboard/lm8323.c

513

lm8323_pwm_work(&pwm->work);

drivers/input/keyboard/lm8323.c

522

struct lm8323_pwm *pwm = cdev_to_pwm(led_cdev);

drivers/input/keyboard/lm8323.c

524

return sprintf(buf, "%d\n", pwm->fade_time);

drivers/input/keyboard/lm8323.c

531

struct lm8323_pwm *pwm = cdev_to_pwm(led_cdev);

drivers/input/keyboard/lm8323.c

539

pwm->fade_time = time;

drivers/input/keyboard/lm8323.c

554

struct lm8323_pwm *pwm;

drivers/input/keyboard/lm8323.c

559

pwm = &lm->pwm[id - 1];

drivers/input/keyboard/lm8323.c

561

pwm->id = id;

drivers/input/keyboard/lm8323.c

562

pwm->fade_time = 0;

drivers/input/keyboard/lm8323.c

563

pwm->brightness = 0;

drivers/input/keyboard/lm8323.c

564

pwm->desired_brightness = 0;

drivers/input/keyboard/lm8323.c

565

pwm->running = false;

drivers/input/keyboard/lm8323.c

566

pwm->enabled = false;

drivers/input/keyboard/lm8323.c

567

INIT_WORK(&pwm->work, lm8323_pwm_work);

drivers/input/keyboard/lm8323.c

568

mutex_init(&pwm->lock);

drivers/input/keyboard/lm8323.c

569

pwm->chip = lm;

drivers/input/keyboard/lm8323.c

572

pwm->cdev.name = name;

drivers/input/keyboard/lm8323.c

573

pwm->cdev.brightness_set = lm8323_pwm_set_brightness;

drivers/input/keyboard/lm8323.c

574

pwm->cdev.groups = lm8323_pwm_groups;

drivers/input/keyboard/lm8323.c

576

err = devm_led_classdev_register(dev, &pwm->cdev);

drivers/input/keyboard/lm8323.c

581

pwm->enabled = true;

drivers/input/keyboard/lm8323.c

626

int pwm;

drivers/input/keyboard/lm8323.c

696

for (pwm = 0; pwm < LM8323_NUM_PWMS; pwm++) {

drivers/input/keyboard/lm8323.c

697

err = init_pwm(lm, pwm + 1, &client->dev,

drivers/input/keyboard/lm8323.c

698

pdata->pwm_names[pwm]);

drivers/input/keyboard/lm8323.c

762

if (lm->pwm[i].enabled)

drivers/input/keyboard/lm8323.c

763

led_classdev_suspend(&lm->pwm[i].cdev);

drivers/input/keyboard/lm8323.c

779

if (lm->pwm[i].enabled)

drivers/input/keyboard/lm8323.c

780

led_classdev_resume(&lm->pwm[i].cdev);

drivers/input/misc/max8997_haptic.c

170

pwm_init_state(chip->pwm, &state);

drivers/input/misc/max8997_haptic.c

175

error = pwm_apply_might_sleep(chip->pwm, &state);

drivers/input/misc/max8997_haptic.c

194

pwm_disable(chip->pwm);

drivers/input/misc/max8997_haptic.c

279

chip->pwm = pwm_get(&pdev->dev, NULL);

drivers/input/misc/max8997_haptic.c

280

if (IS_ERR(chip->pwm)) {

drivers/input/misc/max8997_haptic.c

281

error = PTR_ERR(chip->pwm);

drivers/input/misc/max8997_haptic.c

339

pwm_put(chip->pwm);

drivers/input/misc/max8997_haptic.c

355

pwm_put(chip->pwm);

drivers/input/misc/max8997_haptic.c

44

struct pwm_device *pwm;

drivers/input/misc/pwm-beeper.c

134

beeper->pwm = devm_pwm_get(dev, NULL);

drivers/input/misc/pwm-beeper.c

135

if (IS_ERR(beeper->pwm))

drivers/input/misc/pwm-beeper.c

136

return dev_err_probe(dev, PTR_ERR(beeper->pwm), "Failed to request PWM device\n");

drivers/input/misc/pwm-beeper.c

139

pwm_init_state(beeper->pwm, &state);

drivers/input/misc/pwm-beeper.c

141

error = pwm_apply_might_sleep(beeper->pwm, &state);

drivers/input/misc/pwm-beeper.c

20

struct pwm_device *pwm;

drivers/input/misc/pwm-beeper.c

36

pwm_get_state(beeper->pwm, &state);

drivers/input/misc/pwm-beeper.c

42

error = pwm_apply_might_sleep(beeper->pwm, &state);

drivers/input/misc/pwm-beeper.c

49

pwm_disable(beeper->pwm);

drivers/input/misc/pwm-beeper.c

66

pwm_disable(beeper->pwm);

drivers/input/misc/pwm-vibra.c

153

vibrator->pwm = devm_pwm_get(&pdev->dev, "enable");

drivers/input/misc/pwm-vibra.c

154

if (IS_ERR(vibrator->pwm))

drivers/input/misc/pwm-vibra.c

155

return dev_err_probe(&pdev->dev, PTR_ERR(vibrator->pwm),

drivers/input/misc/pwm-vibra.c

161

pwm_init_state(vibrator->pwm, &state);

drivers/input/misc/pwm-vibra.c

163

err = pwm_apply_might_sleep(vibrator->pwm, &state);

drivers/input/misc/pwm-vibra.c

28

struct pwm_device *pwm;

drivers/input/misc/pwm-vibra.c

55

pwm_get_state(vibrator->pwm, &state);

drivers/input/misc/pwm-vibra.c

59

err = pwm_apply_might_sleep(vibrator->pwm, &state);

drivers/input/misc/pwm-vibra.c

73

pwm_disable(vibrator->pwm);

drivers/input/misc/pwm-vibra.c

85

pwm_disable(vibrator->pwm);

drivers/input/misc/twl4030-vibra.c

113

256 - pwm, TWL4030_REG_VIBRA_SET);

drivers/input/misc/twl4030-vibra.c

90

int pwm;

drivers/input/misc/twl4030-vibra.c

94

pwm = info->speed;

drivers/input/misc/twl4030-vibra.c

98

if (pwm && (!info->coexist || !(reg & TWL4030_VIBRA_SEL))) {

drivers/leds/leds-cht-wcove.c

127

ret = regmap_write(led->regmap, led->regs->pwm, value);

drivers/leds/leds-cht-wcove.c

164

ret = regmap_read(led->regmap, led->regs->pwm, &val);

drivers/leds/leds-cht-wcove.c

325

return regmap_read(led->regmap, led->regs->pwm, &saved_regs->pwm);

drivers/leds/leds-cht-wcove.c

333

regmap_write(led->regmap, led->regs->pwm, saved_regs->pwm);

drivers/leds/leds-cht-wcove.c

54

u16 pwm;

drivers/leds/leds-cht-wcove.c

64

unsigned int pwm;

drivers/leds/leds-cht-wcove.c

85

.pwm = CHT_WC_LED1_PWM,

drivers/leds/leds-cht-wcove.c

93

.pwm = CHT_WC_LED2_PWM,

drivers/leds/leds-lm3530.c

233

struct lm3530_pwm_data *pwm = &pdata->pwm_data;

drivers/leds/leds-lm3530.c

289

if (pwm->pwm_set_intensity)

drivers/leds/leds-lm3530.c

290

pwm->pwm_set_intensity(reg_val[i],

drivers/leds/leds-lm3530.c

311

struct lm3530_pwm_data *pwm = &pdata->pwm_data;

drivers/leds/leds-lm3530.c

341

if (pwm->pwm_set_intensity)

drivers/leds/leds-lm3530.c

342

pwm->pwm_set_intensity(brt_val, max_brightness);

drivers/leds/leds-lm3530.c

373

struct lm3530_pwm_data *pwm;

drivers/leds/leds-lm3530.c

378

pwm = &drvdata->pdata->pwm_data;

drivers/leds/leds-lm3530.c

389

if (mode != LM3530_BL_MODE_PWM && pwm->pwm_set_intensity)

drivers/leds/leds-lm3530.c

390

pwm->pwm_set_intensity(0, max_brightness);

drivers/leds/leds-lm3533.c

594

static LM3533_ATTR_RW(pwm);

drivers/leds/leds-lm3533.c

644

return lm3533_ctrlbank_set_pwm(&led->cb, pdata->pwm);

drivers/leds/leds-pca9532.c

121

static int pca9532_calcpwm(struct i2c_client *client, int pwm, int blink,

drivers/leds/leds-pca9532.c

128

data->leds[i].state == PCA9532_PWM0+pwm) {

drivers/leds/leds-pca9532.c

142

data->pwm[pwm] = b;

drivers/leds/leds-pca9532.c

143

data->psc[pwm] = blink;

drivers/leds/leds-pca9532.c

147

static int pca9532_setpwm(struct i2c_client *client, int pwm)

drivers/leds/leds-pca9532.c

153

i2c_smbus_write_byte_data(client, PCA9532_REG_PWM(maxleds, pwm),

drivers/leds/leds-pca9532.c

154

data->pwm[pwm]);

drivers/leds/leds-pca9532.c

155

i2c_smbus_write_byte_data(client, PCA9532_REG_PSC(maxleds, pwm),

drivers/leds/leds-pca9532.c

156

data->psc[pwm]);

drivers/leds/leds-pca9532.c

234

data->pwm[PCA9532_PWM_ID_1] = (delay_on * PCA9532_PWM_DUTY_DIV) / (delay_on + delay_off);

drivers/leds/leds-pca9532.c

275

data->pwm[PCA9532_PWM_ID_1] = 127;

drivers/leds/leds-pca9532.c

277

data->pwm[PCA9532_PWM_ID_1] = 0;

drivers/leds/leds-pca9532.c

292

data->pwm[PCA9532_PWM_ID_1]);

drivers/leds/leds-pca9532.c

398

data->pwm[i] = pdata->pwm[i];

drivers/leds/leds-pca9532.c

401

data->pwm[i]);

drivers/leds/leds-pca9532.c

524

of_property_read_u8_array(np, "nxp,pwm", &pdata->pwm[PCA9532_PWM_ID_0],

drivers/leds/leds-pca9532.c

525

ARRAY_SIZE(pdata->pwm));

drivers/leds/leds-pca9532.c

54

u8 pwm[2];

drivers/leds/leds-pca955x.c

274

u8 ls, pwm;

drivers/leds/leds-pca955x.c

290

ret = pca955x_read_pwm(pca955x, 1, &pwm);

drivers/leds/leds-pca955x.c

293

ret = 255 - pwm;

drivers/leds/leds-pwm.c

108

pwm_get_state(led_data->pwm, &led_data->pwmstate);

drivers/leds/leds-pwm.c

117

pwm_init_state(led_data->pwm, &led_data->pwmstate);

drivers/leds/leds-pwm.c

32

struct pwm_device *pwm;

drivers/leds/leds-pwm.c

66

return pwm_apply_might_sleep(led_dat->pwm, &led_dat->pwmstate);

drivers/leds/leds-pwm.c

97

led_data->pwm = devm_fwnode_pwm_get(dev, fwnode, NULL);

drivers/leds/leds-pwm.c

98

if (IS_ERR(led_data->pwm))

drivers/leds/leds-pwm.c

99

return dev_err_probe(dev, PTR_ERR(led_data->pwm),

drivers/leds/leds-tlc591xx.c

102

u8 pwm = TLC591XX_REG_PWM(led->led_no);

drivers/leds/leds-tlc591xx.c

104

return regmap_write(priv->regmap, pwm, brightness);

drivers/leds/rgb/leds-pwm-multicolor.c

19

struct pwm_device *pwm;

drivers/leds/rgb/leds-pwm-multicolor.c

59

ret = pwm_apply_might_sleep(priv->leds[i].pwm,

drivers/leds/rgb/leds-pwm-multicolor.c

82

pwmled->pwm = devm_fwnode_pwm_get(dev, fwnode, NULL);

drivers/leds/rgb/leds-pwm-multicolor.c

83

if (IS_ERR(pwmled->pwm)) {

drivers/leds/rgb/leds-pwm-multicolor.c

84

ret = dev_err_probe(dev, PTR_ERR(pwmled->pwm), "unable to request PWM\n");

drivers/leds/rgb/leds-pwm-multicolor.c

87

pwm_init_state(pwmled->pwm, &pwmled->state);

drivers/leds/rgb/leds-qcom-lpg.c

1213

static int lpg_pwm_request(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/leds/rgb/leds-qcom-lpg.c

1216

struct lpg_channel *chan = &lpg->channels[pwm->hwpwm];

drivers/leds/rgb/leds-qcom-lpg.c

1228

static int lpg_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/leds/rgb/leds-qcom-lpg.c

1232

struct lpg_channel *chan = &lpg->channels[pwm->hwpwm];

drivers/leds/rgb/leds-qcom-lpg.c

1257

static int lpg_pwm_get_state(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/leds/rgb/leds-qcom-lpg.c

1261

struct lpg_channel *chan = &lpg->channels[pwm->hwpwm];

drivers/leds/rgb/leds-qcom-lpg.c

1331

lpg->pwm = chip = devm_pwmchip_alloc(lpg->dev, lpg->num_channels, 0);

drivers/leds/rgb/leds-qcom-lpg.c

196

struct pwm_chip *pwm;

drivers/macintosh/windfarm_smu_controls.c

54

static int smu_set_fan(int pwm, u8 id, u16 value)

drivers/macintosh/windfarm_smu_controls.c

81

buffer[0] = pwm ? 0x10 : 0x00;

drivers/media/dvb-frontends/atbm8830.c

375

u32 pwm;

drivers/media/dvb-frontends/atbm8830.c

382

pwm = t & 0x03;

drivers/media/dvb-frontends/atbm8830.c

383

pwm <<= 8;

drivers/media/dvb-frontends/atbm8830.c

385

pwm |= t;

drivers/media/dvb-frontends/atbm8830.c

389

dprintk("AGC PWM = 0x%02X\n", pwm);

drivers/media/dvb-frontends/atbm8830.c

390

pwm = 0x400 - pwm;

drivers/media/dvb-frontends/atbm8830.c

392

*signal = pwm * 0x10000 / 0x400;

drivers/media/dvb-frontends/tda10021.c

211

_tda10021_writereg (state, 0x34, state->pwm);

drivers/media/dvb-frontends/tda10021.c

287

_tda10021_writereg(state, 0x34, state->pwm);

drivers/media/dvb-frontends/tda10021.c

30

u8 pwm;

drivers/media/dvb-frontends/tda10021.c

448

u8 pwm)

drivers/media/dvb-frontends/tda10021.c

460

state->pwm = pwm;

drivers/media/dvb-frontends/tda10023.c

37

u8 pwm;

drivers/media/dvb-frontends/tda10023.c

509

u8 pwm)

drivers/media/dvb-frontends/tda10023.c

528

state->pwm = pwm;

drivers/media/dvb-frontends/tda1002x.h

50

struct i2c_adapter* i2c, u8 pwm);

drivers/media/dvb-frontends/tda1002x.h

53

struct i2c_adapter* i2c, u8 pwm)

drivers/media/dvb-frontends/tda1002x.h

63

struct i2c_adapter *i2c, u8 pwm);

drivers/media/dvb-frontends/tda1002x.h

67

struct i2c_adapter *i2c, u8 pwm)

drivers/media/dvb-frontends/ves1820.c

192

ves1820_writereg(state, 0x34, state->pwm);

drivers/media/dvb-frontends/ves1820.c

217

ves1820_writereg(state, 0x34, state->pwm);

drivers/media/dvb-frontends/ves1820.c

31

u8 pwm;

drivers/media/dvb-frontends/ves1820.c

364

u8 pwm)

drivers/media/dvb-frontends/ves1820.c

377

state->pwm = pwm;

drivers/media/dvb-frontends/ves1820.c

384

printk("ves1820: pwm=0x%02x\n", state->pwm);

drivers/media/dvb-frontends/ves1820.h

34

struct i2c_adapter* i2c, u8 pwm);

drivers/media/dvb-frontends/ves1820.h

37

struct i2c_adapter* i2c, u8 pwm)

drivers/media/pci/ddbridge/ddbridge-core.c

3239

u32 temp, temp2, pwm;

drivers/media/pci/ddbridge/ddbridge-core.c

3255

pwm = (ddblreadl(link, TEMPMON_FANCONTROL) >> 8) & 0x0F;

drivers/media/pci/ddbridge/ddbridge-core.c

3256

if (pwm > 10)

drivers/media/pci/ddbridge/ddbridge-core.c

3257

pwm = 10;

drivers/media/pci/ddbridge/ddbridge-core.c

3259

if (temp >= link->temp_tab[pwm]) {

drivers/media/pci/ddbridge/ddbridge-core.c

3260

while (pwm < 10 && temp >= link->temp_tab[pwm + 1])

drivers/media/pci/ddbridge/ddbridge-core.c

3261

pwm += 1;

drivers/media/pci/ddbridge/ddbridge-core.c

3263

while (pwm > 1 && temp < link->temp_tab[pwm - 2])

drivers/media/pci/ddbridge/ddbridge-core.c

3264

pwm -= 1;

drivers/media/pci/ddbridge/ddbridge-core.c

3266

ddblwritel(link, (pwm << 8), TEMPMON_FANCONTROL);

drivers/media/pci/mantis/mantis_vp2033.c

43

u8 pwm;

drivers/media/pci/mantis/mantis_vp2033.c

46

{.addr = 0x50, .flags = I2C_M_RD, .buf = &pwm, .len = 1}

drivers/media/pci/mantis/mantis_vp2033.c

50

|| (pwm == 0xff))

drivers/media/pci/mantis/mantis_vp2033.c

51

pwm = 0x48;

drivers/media/pci/mantis/mantis_vp2033.c

53

return pwm;

drivers/media/pci/mantis/mantis_vp2040.c

102

{.addr = 0x50, .flags = I2C_M_RD, .buf = &pwm, .len = 1}

drivers/media/pci/mantis/mantis_vp2040.c

106

|| (pwm == 0xff))

drivers/media/pci/mantis/mantis_vp2040.c

107

pwm = 0x48;

drivers/media/pci/mantis/mantis_vp2040.c

109

return pwm;

drivers/media/pci/mantis/mantis_vp2040.c

99

u8 pwm;

drivers/media/pci/ttpci/budget-av.c

1159

u8 pwm;

drivers/media/pci/ttpci/budget-av.c

1161

{.addr = 0x50, .flags = I2C_M_RD, .buf = &pwm, .len = 1}

drivers/media/pci/ttpci/budget-av.c

1165

|| (pwm == 0xff))

drivers/media/pci/ttpci/budget-av.c

1166

pwm = 0x48;

drivers/media/pci/ttpci/budget-av.c

1168

return pwm;

drivers/media/pci/ttpci/budget.c

438

u8 pwm;

drivers/media/pci/ttpci/budget.c

440

{ .addr = 0x50, .flags = I2C_M_RD, .buf = &pwm, .len = 1} };

drivers/media/pci/ttpci/budget.c

442

if ((i2c_transfer(&budget->i2c_adap, msg, 2) != 2) || (pwm == 0xff))

drivers/media/pci/ttpci/budget.c

443

pwm = 0x48;

drivers/media/pci/ttpci/budget.c

445

return pwm;

drivers/media/rc/pwm-ir-tx.c

100

pwm_init_state(pwm, &state);

drivers/media/rc/pwm-ir-tx.c

129

pwm_apply_atomic(pwm_ir->pwm, pwm_ir->state);

drivers/media/rc/pwm-ir-tx.c

156

pwm_ir->pwm = devm_pwm_get(&pdev->dev, NULL);

drivers/media/rc/pwm-ir-tx.c

157

if (IS_ERR(pwm_ir->pwm))

drivers/media/rc/pwm-ir-tx.c

158

return PTR_ERR(pwm_ir->pwm);

drivers/media/rc/pwm-ir-tx.c

167

if (pwm_might_sleep(pwm_ir->pwm)) {

drivers/media/rc/pwm-ir-tx.c

21

struct pwm_device *pwm;

drivers/media/rc/pwm-ir-tx.c

64

struct pwm_device *pwm = pwm_ir->pwm;

drivers/media/rc/pwm-ir-tx.c

70

pwm_init_state(pwm, &state);

drivers/media/rc/pwm-ir-tx.c

79

pwm_apply_might_sleep(pwm, &state);

drivers/media/rc/pwm-ir-tx.c

88

pwm_apply_might_sleep(pwm, &state);

drivers/media/rc/pwm-ir-tx.c

97

struct pwm_device *pwm = pwm_ir->pwm;

drivers/media/usb/ttusb-budget/dvb-ttusb-budget.c

1338

u8 pwm;

drivers/media/usb/ttusb-budget/dvb-ttusb-budget.c

1340

{ .addr = 0x50,.flags = I2C_M_RD,.buf = &pwm,.len = 1} };

drivers/media/usb/ttusb-budget/dvb-ttusb-budget.c

1342

if ((i2c_transfer(&ttusb->i2c_adap, msg, 2) != 2) || (pwm == 0xff))

drivers/media/usb/ttusb-budget/dvb-ttusb-budget.c

1343

pwm = 0x48;

drivers/media/usb/ttusb-budget/dvb-ttusb-budget.c

1345

return pwm;

drivers/net/can/dev/bittiming.c

157

const struct can_pwm *pwm,

drivers/net/can/dev/bittiming.c

163

u32 pwms_ns = can_tqmin_to_ns(pwm->pwms, priv->clock.freq);

drivers/net/can/dev/bittiming.c

164

u32 pwml_ns = can_tqmin_to_ns(pwm->pwml, priv->clock.freq);

drivers/net/can/dev/bittiming.c

180

if (pwm->pwms >= pwm->pwml) {

drivers/net/can/dev/bittiming.c

183

pwm->pwms, pwm->pwml);

drivers/net/can/dev/bittiming.c

194

if (xl_bit_time_tqmin % (pwm->pwms + pwm->pwml) != 0) {

drivers/net/can/dev/bittiming.c

197

pwm->pwms + pwm->pwml, xl_bit_time_tqmin);

drivers/net/can/dev/bittiming.c

201

if (pwm->pwmo >= pwm->pwms + pwm->pwml) {

drivers/net/can/dev/bittiming.c

204

pwm->pwmo, pwm->pwms + pwm->pwml);

drivers/net/can/dev/bittiming.c

208

if (nom_bit_time_tqmin % (pwm->pwms + pwm->pwml) != pwm->pwmo) {

drivers/net/can/dev/calc_bittiming.c

233

struct can_pwm *pwm = &priv->xl.pwm;

drivers/net/can/dev/calc_bittiming.c

257

pwm->pwms = DIV_ROUND_UP_POW2(pwm_tqmin, 4);

drivers/net/can/dev/calc_bittiming.c

258

pwm->pwml = pwm_tqmin - pwm->pwms;

drivers/net/can/dev/calc_bittiming.c

259

pwm->pwmo = nom_tqmin % pwm_tqmin;

drivers/net/can/dev/netlink.c

376

memset(&priv->xl.pwm, 0, sizeof(priv->xl.pwm));

drivers/net/can/dev/netlink.c

531

struct can_pwm pwm = { 0 };

drivers/net/can/dev/netlink.c

551

pwm.pwms = nla_get_u32(tb_pwm[IFLA_CAN_PWM_PWMS]);

drivers/net/can/dev/netlink.c

552

if (pwm.pwms < pwm_const->pwms_min ||

drivers/net/can/dev/netlink.c

553

pwm.pwms > pwm_const->pwms_max) {

drivers/net/can/dev/netlink.c

556

pwm.pwms, pwm_const->pwms_min,

drivers/net/can/dev/netlink.c

563

pwm.pwml = nla_get_u32(tb_pwm[IFLA_CAN_PWM_PWML]);

drivers/net/can/dev/netlink.c

564

if (pwm.pwml < pwm_const->pwml_min ||

drivers/net/can/dev/netlink.c

565

pwm.pwml > pwm_const->pwml_max) {

drivers/net/can/dev/netlink.c

568

pwm.pwml, pwm_const->pwml_min,

drivers/net/can/dev/netlink.c

575

pwm.pwmo = nla_get_u32(tb_pwm[IFLA_CAN_PWM_PWMO]);

drivers/net/can/dev/netlink.c

576

if (pwm.pwmo < pwm_const->pwmo_min ||

drivers/net/can/dev/netlink.c

577

pwm.pwmo > pwm_const->pwmo_max) {

drivers/net/can/dev/netlink.c

580

pwm.pwmo, pwm_const->pwmo_min,

drivers/net/can/dev/netlink.c

586

err = can_validate_pwm_bittiming(dev, &pwm, extack);

drivers/net/can/dev/netlink.c

590

priv->xl.pwm = pwm;

drivers/net/can/dev/netlink.c

936

const struct can_pwm *pwm = &priv->xl.pwm;

drivers/net/can/dev/netlink.c

955

if (nla_put_u32(skb, IFLA_CAN_PWM_PWMS, pwm->pwms) ||

drivers/net/can/dev/netlink.c

956

nla_put_u32(skb, IFLA_CAN_PWM_PWML, pwm->pwml) ||

drivers/net/can/dev/netlink.c

957

nla_put_u32(skb, IFLA_CAN_PWM_PWMO, pwm->pwmo))

drivers/net/can/dummy_can.c

109

static void dummy_can_print_pwm(struct net_device *dev, struct can_pwm *pwm,

drivers/net/can/dummy_can.c

112

netdev_dbg(dev, "\t\tpwms: %u\n", pwm->pwms);

drivers/net/can/dummy_can.c

113

netdev_dbg(dev, "\t\tpwml: %u\n", pwm->pwml);

drivers/net/can/dummy_can.c

114

netdev_dbg(dev, "\t\tpwmo: %u\n", pwm->pwmo);

drivers/net/can/dummy_can.c

175

dummy_can_print_pwm(dev, &can_priv->xl.pwm,

drivers/net/ethernet/mellanox/mlxsw/reg.h

9328

MLXSW_ITEM32(reg, mfsc, pwm, 0x00, 24, 3);

drivers/net/ethernet/mellanox/mlxsw/reg.h

9337

static inline void mlxsw_reg_mfsc_pack(char *payload, u8 pwm,

drivers/net/ethernet/mellanox/mlxsw/reg.h

9341

mlxsw_reg_mfsc_pwm_set(payload, pwm);

drivers/pinctrl/airoha/pinctrl-airoha.c

1807

PINCTRL_FUNC_DESC("pwm", pwm),

drivers/pinctrl/bcm/pinctrl-ns2-mux.c

492

NS2_PIN_FUNCTION(pwm),

drivers/pinctrl/bcm/pinctrl-nsp-mux.c

299

NSP_PIN_FUNCTION(pwm),

drivers/pinctrl/pinctrl-as3722.c

136

FUNCTION_GROUP(pwm-in, PWM_INPUT),

drivers/pinctrl/pinctrl-as3722.c

137

FUNCTION_GROUP(pwm-out, PWM_OUTPUT),

drivers/pinctrl/pinctrl-cy8c95x0.c

1145

DECLARE_BITMAP(pwm, MAX_LINE);

drivers/pinctrl/pinctrl-cy8c95x0.c

1150

if (cy8c95x0_read_regs_mask(chip, CY8C95X0_SELPWM, pwm, mask)) {

drivers/pinctrl/pinctrl-cy8c95x0.c

1155

seq_printf(s, "MODE:%s", cy8c95x0_get_fname(test_bit(pin, pwm)));

drivers/pinctrl/pinctrl-palmas.c

299

FUNCTION_GROUP(pwm, PWM), \

drivers/pinctrl/qcom/pinctrl-ipq9574.c

670

MSM_PIN_FUNCTION(pwm),

drivers/pinctrl/qcom/pinctrl-ipq9574.c

731

PINGROUP(30, pcie2_wake, pwm, atest_char, _, _, _, _, _, _),

drivers/pinctrl/qcom/pinctrl-ipq9574.c

732

PINGROUP(31, pcie3_clk, pwm, _, qdss_cti_trig_in_a1, _, _, _, _, _),

drivers/pinctrl/qcom/pinctrl-ipq9574.c

733

PINGROUP(32, pwm, _, qdss_cti_trig_out_a1, _, _, _, _, _, _),

drivers/pinctrl/qcom/pinctrl-ipq9574.c

734

PINGROUP(33, pcie3_wake, pwm, _, qdss_cti_trig_in_a0, _, _, _, _, _),

drivers/pinctrl/qcom/pinctrl-ipq9574.c

745

PINGROUP(44, pwm, audio_sec, wsa_swrm, _, qdss_tracectl_a, _, _, _, _),

drivers/pinctrl/qcom/pinctrl-ipq9574.c

746

PINGROUP(45, pwm, audio_sec, wsa_swrm, _, qdss_tracedata_a, _, _, _, _),

drivers/pinctrl/qcom/pinctrl-ipq9574.c

747

PINGROUP(46, pwm, audio_sec, rx1, mac, _, qdss_tracedata_a, _, _, _),

drivers/pinctrl/qcom/pinctrl-ipq9574.c

748

PINGROUP(47, pwm, audio_sec, mac, _, qdss_tracedata_a, _, _, _, _),

drivers/pinctrl/qcom/pinctrl-ipq9574.c

751

PINGROUP(50, blsp4_uart, blsp4_i2c, blsp4_spi, pwm, qdss_tracedata_a, _, _, _, _),

drivers/pinctrl/qcom/pinctrl-ipq9574.c

752

PINGROUP(51, blsp4_uart, blsp4_i2c, blsp4_spi, pwm, qdss_tracedata_a, _, _, _, _),

drivers/pinctrl/qcom/pinctrl-ipq9574.c

753

PINGROUP(52, blsp4_uart, blsp4_spi, pwm, qdss_tracedata_a, _, _, _, _, _),

drivers/pinctrl/qcom/pinctrl-ipq9574.c

754

PINGROUP(53, blsp4_uart, blsp4_spi, pwm, qdss_tracedata_a, _, _, _, _, _),

drivers/pinctrl/qcom/pinctrl-ipq9574.c

755

PINGROUP(54, pta, pwm, qdss_tracedata_a, _, _, _, _, _, _),

drivers/pinctrl/qcom/pinctrl-ipq9574.c

756

PINGROUP(55, pta, pwm, qdss_tracedata_a, _, _, _, _, _, _),

drivers/pinctrl/qcom/pinctrl-ipq9574.c

757

PINGROUP(56, pta, pwm, qdss_tracedata_a, _, _, _, _, _, _),

drivers/pinctrl/qcom/pinctrl-ipq9574.c

758

PINGROUP(57, wci20, cxc1, mac, pwm, qdss_tracedata_a, _, _, _, _),

drivers/pinctrl/qcom/pinctrl-ipq9574.c

759

PINGROUP(58, wci20, cxc1, mac, pwm, qdss_tracedata_a, _, _, _, _),

drivers/pinctrl/qcom/pinctrl-ipq9574.c

760

PINGROUP(59, rx0, pwm, qdss_tracedata_a, _, _, _, _, _, _),

drivers/pinctrl/qcom/pinctrl-ipq9574.c

761

PINGROUP(60, pwm, prng_rosc0, qdss_tracedata_a, _, gcc_plltest, _, _, _, _),

drivers/pinctrl/qcom/pinctrl-ipq9650.c

630

MSM_PIN_FUNCTION(pwm),

drivers/pinctrl/qcom/pinctrl-ipq9650.c

671

[6] = PINGROUP(6, qup_se0, pwm, _, cri_rng0, qdss_tracedata_a, _, _, _, _),

drivers/pinctrl/qcom/pinctrl-ipq9650.c

672

[7] = PINGROUP(7, qup_se0, pwm, _, cri_rng1, qdss_tracedata_a, _, _, _, _),

drivers/pinctrl/qcom/pinctrl-ipq9650.c

673

[8] = PINGROUP(8, qup_se0, pwm, _, cri_rng2, qdss_tracedata_a, _, _, _, _),

drivers/pinctrl/qcom/pinctrl-ipq9650.c

674

[9] = PINGROUP(9, qup_se0, pwm, _, qdss_tracedata_a, _, _, _, _, _),

drivers/pinctrl/qcom/pinctrl-ipq9650.c

675

[10] = PINGROUP(10, qup_se1, pwm, _, _, qdss_tracedata_a, _, _, _, _),

drivers/pinctrl/qcom/pinctrl-ipq9650.c

676

[11] = PINGROUP(11, qup_se1, pwm, _, _, qdss_tracedata_a, _, _, _, _),

drivers/pinctrl/qcom/pinctrl-ipq9650.c

681

[16] = PINGROUP(16, core_voltage_0, qup_se3, pwm, _, _, _, _, _, _),

drivers/pinctrl/qcom/pinctrl-ipq9650.c

682

[17] = PINGROUP(17, core_voltage_1, qup_se3, pwm, _, _, _, _, _, _),

drivers/pinctrl/qcom/pinctrl-ipq9650.c

698

[33] = PINGROUP(33, core_voltage_2, qup_se2, gcc_plltest_bypassnl, pwm, atest_char_status0, _, _, _, _),

drivers/pinctrl/qcom/pinctrl-ipq9650.c

699

[34] = PINGROUP(34, core_voltage_3, qup_se2, gcc_tlmm, pwm, _, _, _, _, _),

drivers/pinctrl/qcom/pinctrl-ipq9650.c

700

[35] = PINGROUP(35, core_voltage_4, gcc_plltest_resetn, pwm, atest_char_status1, _, _, _, _, _),

drivers/pinctrl/qcom/pinctrl-ipq9650.c

708

[43] = PINGROUP(43, qup_se4, qup_se6, pwm, _, qdss_cti_trig_in_b1, _, _, _, _),

drivers/pinctrl/qcom/pinctrl-ipq9650.c

709

[44] = PINGROUP(44, qup_se4, qup_se6, pwm, _, qdss_cti_trig_out_b1, _, _, _, _),

drivers/pinctrl/qcom/pinctrl-ipq9650.c

710

[45] = PINGROUP(45, qup_se5, rx_los2, audio_sec, pwm, _, qdss_traceclk_a, _, _, _),

drivers/pinctrl/qcom/pinctrl-ipq9650.c

711

[46] = PINGROUP(46, qup_se5, rx_los1, audio_sec, mdio_slv, pwm, dbg_out_clk, qdss_tracectl_a, _, _),

drivers/pinctrl/qcom/pinctrl-ipq9650.c

712

[47] = PINGROUP(47, qup_se5, rx_los0, audio_sec, mdio_slv, pll_bist_sync, pwm, _, _, _),

drivers/pinctrl/qcom/pinctrl-ipq9650.c

713

[48] = PINGROUP(48, qup_se5, audio_sec, pwm, _, _, _, _, _, _),

drivers/pinctrl/qcom/pinctrl-shikra.c

1044

[32] = PINGROUP(32, pwm, sdc_tb_trig, _, _, _, _, _, _, _, _, _),

drivers/pinctrl/qcom/pinctrl-shikra.c

1052

[40] = PINGROUP(40, cci_timer, emac_mcg, pwm, _, _, _, _, _, _, _, _),

drivers/pinctrl/qcom/pinctrl-shikra.c

1057

[45] = PINGROUP(45, tsc_async, emac_mcg, pwm, gcc_gp, _, _, _, _, _, _, _),

drivers/pinctrl/qcom/pinctrl-shikra.c

1065

[53] = PINGROUP(53, _, nav_gpio, gcc_gp, pwm, _, pbs_in, atest_usb, _, _, _, _),

drivers/pinctrl/qcom/pinctrl-shikra.c

1066

[54] = PINGROUP(54, _, pwm, _, pbs_in, phase_flag, atest_char, _, _, _, _, _),

drivers/pinctrl/qcom/pinctrl-shikra.c

1067

[55] = PINGROUP(55, _, pwm, _, pbs_in, phase_flag, atest_char, _, _, _, _, _),

drivers/pinctrl/qcom/pinctrl-shikra.c

1068

[56] = PINGROUP(56, _, pwm, _, pbs_in, phase_flag, atest_char, _, _, _, _, _),

drivers/pinctrl/qcom/pinctrl-shikra.c

1069

[57] = PINGROUP(57, _, pwm, _, pbs_in, phase_flag, atest_char, _, _, _, _, _),

drivers/pinctrl/qcom/pinctrl-shikra.c

1070

[58] = PINGROUP(58, _, nav_gpio, pwm, _, pbs_in, atest_bbrx, atest_usb,

drivers/pinctrl/qcom/pinctrl-shikra.c

1075

[61] = PINGROUP(61, _, pwm, gcc_gp, pa_indicator_or, dbg_out_clk, pbs_in, atest_usb,

drivers/pinctrl/qcom/pinctrl-shikra.c

1077

[62] = PINGROUP(62, _, pwm, _, pbs_in, phase_flag, atest_char, _, _, _, _, _),

drivers/pinctrl/qcom/pinctrl-shikra.c

1084

[68] = PINGROUP(68, _, ssbi_wtr, emac1_ptp_aux, emac1_ptp_pps, pwm, dac_calib, _, _, _,

drivers/pinctrl/qcom/pinctrl-shikra.c

1095

[77] = PINGROUP(77, uim2, pwm, _, _, _, _, _, _, _, _, _),

drivers/pinctrl/qcom/pinctrl-shikra.c

1097

[79] = PINGROUP(79, uim2, pwm, _, _, _, _, _, _, _, _, _),

drivers/pinctrl/qcom/pinctrl-shikra.c

1098

[80] = PINGROUP(80, uim2, pwm, _, _, _, _, _, _, _, _, _),

drivers/pinctrl/qcom/pinctrl-shikra.c

1105

[87] = PINGROUP(87, _, pwm, _, _, _, _, _, _, _, _, _),

drivers/pinctrl/qcom/pinctrl-shikra.c

1121

[102] = PINGROUP(102, i2s2, pwm, _, phase_flag, _, _, _, _, _, _, _),

drivers/pinctrl/qcom/pinctrl-shikra.c

969

MSM_PIN_FUNCTION(pwm),

drivers/pinctrl/tegra/pinctrl-tegra20.c

1930

FUNCTION(pwm),

drivers/pinctrl/visconti/pinctrl-tmpv7700.c

235

VISCONTI_GROUPS(pwm, "pwm0_gpio4_grp", "pwm0_gpio8_grp",

drivers/pinctrl/visconti/pinctrl-tmpv7700.c

267

VISCONTI_PIN_FUNCTION(pwm),

drivers/platform/x86/acer-wmi.c

3084

HWMON_CHANNEL_INFO(pwm,

drivers/platform/x86/acer-wmi.c

407

u8 pwm;

drivers/platform/x86/acer-wmi.c

428

if (quirks->pwm)

drivers/platform/x86/acer-wmi.c

460

.pwm = 1,

drivers/platform/x86/acer-wmi.c

474

.pwm = 1,

drivers/platform/x86/acer-wmi.c

482

.pwm = 1,

drivers/platform/x86/asus-wmi.c

3675

int value, pwm, index;

drivers/platform/x86/asus-wmi.c

3678

pwm = dev_attr->nr & FAN_CURVE_PWM_MASK;

drivers/platform/x86/asus-wmi.c

3681

if (pwm)

drivers/platform/x86/asus-wmi.c

3724

int err, pwm, index;

drivers/platform/x86/asus-wmi.c

3728

pwm = dev_attr->nr & FAN_CURVE_PWM_MASK;

drivers/platform/x86/asus-wmi.c

3735

if (pwm)

drivers/platform/x86/ayaneo-ec.c

270

HWMON_CHANNEL_INFO(pwm, HWMON_PWM_INPUT | HWMON_PWM_ENABLE),

drivers/platform/x86/compal-laptop.c

296

static void set_pwm(int pwm)

drivers/platform/x86/compal-laptop.c

298

ec_transaction(PWM_ADDRESS, &pwm_lookup_table[pwm], 1, NULL, 0);

drivers/platform/x86/dasharo-acpi.c

265

HWMON_CHANNEL_INFO(pwm,

drivers/platform/x86/dell/alienware-wmi-wmax.c

1006

HWMON_CHANNEL_INFO(pwm,

drivers/platform/x86/hp/hp-wmi.c

2417

ret = hp_wmi_fan_speed_set(priv, pwm_to_rpm(priv->pwm, priv));

drivers/platform/x86/hp/hp-wmi.c

2533

priv->pwm = rpm_to_pwm(rpm, priv);

drivers/platform/x86/hp/hp-wmi.c

2550

priv->pwm = rpm_to_pwm(rpm / 100, priv);

drivers/platform/x86/hp/hp-wmi.c

2566

HWMON_CHANNEL_INFO(pwm, HWMON_PWM_ENABLE | HWMON_PWM_INPUT),

drivers/platform/x86/hp/hp-wmi.c

505

u8 pwm;

drivers/platform/x86/hp/hp-wmi.c

537

static inline u8 pwm_to_rpm(u8 pwm, struct hp_wmi_hwmon_priv *priv)

drivers/platform/x86/hp/hp-wmi.c

540

clamp_val(pwm, 0, U8_MAX));

drivers/platform/x86/oxpec.c

895

HWMON_CHANNEL_INFO(pwm,

drivers/platform/x86/system76_acpi.c

612

HWMON_CHANNEL_INFO(pwm,

drivers/platform/x86/uniwill/uniwill-acpi.c

1281

HWMON_CHANNEL_INFO(pwm,

drivers/pwm/core.c

1001

pwm->last = pwm->state;

drivers/pwm/core.c

1004

set_bit(PWMF_REQUESTED, &pwm->flags);

drivers/pwm/core.c

1005

pwm->label = label;

drivers/pwm/core.c

1024

struct pwm_device *pwm;

drivers/pwm/core.c

1032

pwm = &chip->pwms[index];

drivers/pwm/core.c

1034

err = pwm_device_request(pwm, label);

drivers/pwm/core.c

1038

return pwm;

drivers/pwm/core.c

1044

struct pwm_device *pwm;

drivers/pwm/core.c

1050

pwm = pwm_request_from_chip(chip, args->args[0], NULL);

drivers/pwm/core.c

1051

if (IS_ERR(pwm))

drivers/pwm/core.c

1052

return pwm;

drivers/pwm/core.c

1055

pwm->args.period = args->args[1];

drivers/pwm/core.c

1057

pwm->args.polarity = PWM_POLARITY_NORMAL;

drivers/pwm/core.c

1059

pwm->args.polarity = PWM_POLARITY_INVERSED;

drivers/pwm/core.c

1061

return pwm;

drivers/pwm/core.c

1081

struct pwm_device *pwm;

drivers/pwm/core.c

1086

pwm = pwm_request_from_chip(chip, 0, NULL);

drivers/pwm/core.c

1087

if (IS_ERR(pwm))

drivers/pwm/core.c

1088

return pwm;

drivers/pwm/core.c

1091

pwm->args.period = args->args[0];

drivers/pwm/core.c

1093

pwm->args.polarity = PWM_POLARITY_NORMAL;

drivers/pwm/core.c

1095

pwm->args.polarity = PWM_POLARITY_INVERSED;

drivers/pwm/core.c

1097

return pwm;

drivers/pwm/core.c

1103

struct pwm_device *pwm;

drivers/pwm/core.c

1122

return export->pwm;

drivers/pwm/core.c

1129

const struct pwm_device *pwm = pwm_from_dev(pwm_dev);

drivers/pwm/core.c

1132

pwm_get_state(pwm, &state);

drivers/pwm/core.c

1142

struct pwm_device *pwm = export->pwm;

drivers/pwm/core.c

1153

pwm_get_state(pwm, &state);

drivers/pwm/core.c

1155

ret = pwm_apply_might_sleep(pwm, &state);

drivers/pwm/core.c

1164

const struct pwm_device *pwm = pwm_from_dev(pwm_dev);

drivers/pwm/core.c

1167

pwm_get_state(pwm, &state);

drivers/pwm/core.c

1177

struct pwm_device *pwm = export->pwm;

drivers/pwm/core.c

1188

pwm_get_state(pwm, &state);

drivers/pwm/core.c

1190

ret = pwm_apply_might_sleep(pwm, &state);

drivers/pwm/core.c

1199

const struct pwm_device *pwm = pwm_from_dev(pwm_dev);

drivers/pwm/core.c

1202

pwm_get_state(pwm, &state);

drivers/pwm/core.c

1212

struct pwm_device *pwm = export->pwm;

drivers/pwm/core.c

1222

pwm_get_state(pwm, &state);

drivers/pwm/core.c

1235

ret = pwm_apply_might_sleep(pwm, &state);

drivers/pwm/core.c

1244

const struct pwm_device *pwm = pwm_from_dev(pwm_dev);

drivers/pwm/core.c

1248

pwm_get_state(pwm, &state);

drivers/pwm/core.c

1268

struct pwm_device *pwm = export->pwm;

drivers/pwm/core.c

1282

pwm_get_state(pwm, &state);

drivers/pwm/core.c

1284

ret = pwm_apply_might_sleep(pwm, &state);

drivers/pwm/core.c

1293

struct pwm_device *pwm = pwm_from_dev(pwm_dev);

drivers/pwm/core.c

1297

ret = pwm_capture(pwm, &result, jiffies_to_msecs(HZ));

drivers/pwm/core.c

1318

ATTRIBUTE_GROUPS(pwm);

drivers/pwm/core.c

1327

static int pwm_export_child(struct device *pwmchip_dev, struct pwm_device *pwm)

drivers/pwm/core.c

1333

if (test_and_set_bit(PWMF_EXPORTED, &pwm->flags))

drivers/pwm/core.c

1338

clear_bit(PWMF_EXPORTED, &pwm->flags);

drivers/pwm/core.c

1342

export->pwm = pwm;

drivers/pwm/core.c

1349

dev_set_name(&export->pwm_dev, "pwm%u", pwm->hwpwm);

drivers/pwm/core.c

1353

clear_bit(PWMF_EXPORTED, &pwm->flags);

drivers/pwm/core.c

1358

pwm_prop[0] = kasprintf(GFP_KERNEL, "EXPORT=pwm%u", pwm->hwpwm);

drivers/pwm/core.c

1371

static int pwm_unexport_child(struct device *pwmchip_dev, struct pwm_device *pwm)

drivers/pwm/core.c

1376

if (!test_and_clear_bit(PWMF_EXPORTED, &pwm->flags))

drivers/pwm/core.c

1379

pwm_dev = device_find_child(pwmchip_dev, pwm, pwm_unexport_match);

drivers/pwm/core.c

1383

pwm_prop[0] = kasprintf(GFP_KERNEL, "UNEXPORT=pwm%u", pwm->hwpwm);

drivers/pwm/core.c

1391

pwm_put(pwm);

drivers/pwm/core.c

1401

struct pwm_device *pwm;

drivers/pwm/core.c

1412

pwm = pwm_request_from_chip(chip, hwpwm, "sysfs");

drivers/pwm/core.c

1413

if (IS_ERR(pwm))

drivers/pwm/core.c

1414

return PTR_ERR(pwm);

drivers/pwm/core.c

1416

ret = pwm_export_child(pwmchip_dev, pwm);

drivers/pwm/core.c

1418

pwm_put(pwm);

drivers/pwm/core.c

1464

struct pwm_device *pwm,

drivers/pwm/core.c

1470

if (!test_bit(PWMF_EXPORTED, &pwm->flags))

drivers/pwm/core.c

1473

pwm_dev = device_find_child(pwmchip_dev, pwm, pwm_unexport_match);

drivers/pwm/core.c

1481

pwm_get_state(pwm, state);

drivers/pwm/core.c

1487

struct pwm_device *pwm,

drivers/pwm/core.c

1490

int ret = pwm_apply_might_sleep(pwm, state);

drivers/pwm/core.c

1505

struct pwm_device *pwm = &chip->pwms[i];

drivers/pwm/core.c

1509

export = pwm_class_get_state(pwmchip_dev, pwm, &state);

drivers/pwm/core.c

1521

ret = pwm_class_apply_state(export, pwm, &state);

drivers/pwm/core.c

1536

struct pwm_device *pwm = &chip->pwms[i];

drivers/pwm/core.c

1540

export = pwm_class_get_state(pwmchip_dev, pwm, &state);

drivers/pwm/core.c

1556

ret = pwm_class_apply_state(export, pwm, &state);

drivers/pwm/core.c

1590

struct pwm_device *pwm = &chip->pwms[i];

drivers/pwm/core.c

1592

if (test_bit(PWMF_EXPORTED, &pwm->flags))

drivers/pwm/core.c

1593

pwm_unexport_child(&chip->dev, pwm);

drivers/pwm/core.c

1646

struct pwm_device *pwm = &chip->pwms[i];

drivers/pwm/core.c

1647

pwm->chip = chip;

drivers/pwm/core.c

1648

pwm->hwpwm = i;

drivers/pwm/core.c

167

static int __pwm_round_waveform_tohw(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/core.c

1722

struct pwm_device *pwm)

drivers/pwm/core.c

173

ret = ops->round_waveform_tohw(chip, pwm, wf, wfhw);

drivers/pwm/core.c

1732

dev_warn(pwmchip_parent(pwm->chip),

drivers/pwm/core.c

1737

dl = device_link_add(dev, pwmchip_parent(pwm->chip), DL_FLAG_AUTOREMOVE_CONSUMER);

drivers/pwm/core.c

174

trace_pwm_round_waveform_tohw(pwm, wf, wfhw, ret);

drivers/pwm/core.c

1740

dev_name(pwmchip_parent(pwm->chip)));

drivers/pwm/core.c

1784

struct pwm_device *pwm = NULL;

drivers/pwm/core.c

179

static int __pwm_round_waveform_fromhw(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/core.c

1808

pwm = ERR_CAST(chip);

drivers/pwm/core.c

1812

pwm = chip->of_xlate(chip, &args);

drivers/pwm/core.c

1813

if (IS_ERR(pwm))

drivers/pwm/core.c

1816

dl = pwm_device_link_add(dev, pwm);

drivers/pwm/core.c

1819

pwm_put(pwm);

drivers/pwm/core.c

1820

pwm = ERR_CAST(dl);

drivers/pwm/core.c

1836

pwm->label = con_id;

drivers/pwm/core.c

1841

return pwm;

drivers/pwm/core.c

185

ret = ops->round_waveform_fromhw(chip, pwm, wfhw, wf);

drivers/pwm/core.c

186

trace_pwm_round_waveform_fromhw(pwm, wfhw, wf, ret);

drivers/pwm/core.c

1863

struct pwm_device *pwm;

drivers/pwm/core.c

1881

pwm = pwm_request_from_chip(chip, args.args[0], NULL);

drivers/pwm/core.c

1882

if (IS_ERR(pwm))

drivers/pwm/core.c

1883

return pwm;

drivers/pwm/core.c

1885

pwm->args.period = args.args[1];

drivers/pwm/core.c

1886

pwm->args.polarity = PWM_POLARITY_NORMAL;

drivers/pwm/core.c

1889

pwm->args.polarity = PWM_POLARITY_INVERSED;

drivers/pwm/core.c

1891

return pwm;

drivers/pwm/core.c

191

static int __pwm_read_waveform(struct pwm_chip *chip, struct pwm_device *pwm, void *wfhw)

drivers/pwm/core.c

1916

struct pwm_device *pwm;

drivers/pwm/core.c

1930

pwm = acpi_pwm_get(fwnode);

drivers/pwm/core.c

1931

if (!IS_ERR(pwm) || PTR_ERR(pwm) != -ENOENT)

drivers/pwm/core.c

1932

return pwm;

drivers/pwm/core.c

196

ret = ops->read_waveform(chip, pwm, wfhw);

drivers/pwm/core.c

197

trace_pwm_read_waveform(pwm, wfhw, ret);

drivers/pwm/core.c

2003

pwm = pwm_request_from_chip(chip, chosen->index, con_id ?: dev_id);

drivers/pwm/core.c

2004

if (IS_ERR(pwm))

drivers/pwm/core.c

2005

return pwm;

drivers/pwm/core.c

2007

dl = pwm_device_link_add(dev, pwm);

drivers/pwm/core.c

2009

pwm_put(pwm);

drivers/pwm/core.c

2013

pwm->args.period = chosen->period;

drivers/pwm/core.c

2014

pwm->args.polarity = chosen->polarity;

drivers/pwm/core.c

2016

return pwm;

drivers/pwm/core.c

202

static int __pwm_write_waveform(struct pwm_chip *chip, struct pwm_device *pwm, const void *wfhw)

drivers/pwm/core.c

2020

static void __pwm_put(struct pwm_device *pwm)

drivers/pwm/core.c

2022

struct pwm_chip *chip = pwm->chip;

drivers/pwm/core.c

2029

if (chip->operational && !test_and_clear_bit(PWMF_REQUESTED, &pwm->flags)) {

drivers/pwm/core.c

2035

pwm->chip->ops->free(pwm->chip, pwm);

drivers/pwm/core.c

2037

pwm->label = NULL;

drivers/pwm/core.c

2048

void pwm_put(struct pwm_device *pwm)

drivers/pwm/core.c

2050

if (!pwm)

drivers/pwm/core.c

2055

__pwm_put(pwm);

drivers/pwm/core.c

2059

static void devm_pwm_release(void *pwm)

drivers/pwm/core.c

2061

pwm_put(pwm);

drivers/pwm/core.c

207

ret = ops->write_waveform(chip, pwm, wfhw);

drivers/pwm/core.c

2077

struct pwm_device *pwm;

drivers/pwm/core.c

208

trace_pwm_write_waveform(pwm, wfhw, ret);

drivers/pwm/core.c

2080

pwm = pwm_get(dev, con_id);

drivers/pwm/core.c

2081

if (IS_ERR(pwm))

drivers/pwm/core.c

2082

return pwm;

drivers/pwm/core.c

2084

ret = devm_add_action_or_reset(dev, devm_pwm_release, pwm);

drivers/pwm/core.c

2088

return pwm;

drivers/pwm/core.c

2108

struct pwm_device *pwm = ERR_PTR(-ENODEV);

drivers/pwm/core.c

2112

pwm = of_pwm_get(dev, to_of_node(fwnode), con_id);

drivers/pwm/core.c

2114

pwm = acpi_pwm_get(fwnode);

drivers/pwm/core.c

2115

if (IS_ERR(pwm))

drivers/pwm/core.c

2116

return pwm;

drivers/pwm/core.c

2118

ret = devm_add_action_or_reset(dev, devm_pwm_release, pwm);

drivers/pwm/core.c

2122

return pwm;

drivers/pwm/core.c

2128

struct pwm_device *pwm[];

drivers/pwm/core.c

2141

cdata = kzalloc_flex(*cdata, pwm, chip->npwm);

drivers/pwm/core.c

2158

struct pwm_device *pwm = cdata->pwm[i];

drivers/pwm/core.c

2160

if (pwm) {

drivers/pwm/core.c

2161

const char *label = pwm->label;

drivers/pwm/core.c

2163

pwm_put(cdata->pwm[i]);

drivers/pwm/core.c

2179

if (!cdata->pwm[hwpwm]) {

drivers/pwm/core.c

2180

struct pwm_device *pwm = &chip->pwms[hwpwm];

drivers/pwm/core.c

2188

ret = pwm_device_request(pwm, label);

drivers/pwm/core.c

2194

cdata->pwm[hwpwm] = pwm;

drivers/pwm/core.c

2207

if (cdata->pwm[hwpwm]) {

drivers/pwm/core.c

2208

struct pwm_device *pwm = cdata->pwm[hwpwm];

drivers/pwm/core.c

2209

const char *label = pwm->label;

drivers/pwm/core.c

2211

__pwm_put(pwm);

drivers/pwm/core.c

2215

cdata->pwm[hwpwm] = NULL;

drivers/pwm/core.c

2229

if (cdata->pwm[hwpwm])

drivers/pwm/core.c

2230

return cdata->pwm[hwpwm];

drivers/pwm/core.c

2265

struct pwm_device *pwm;

drivers/pwm/core.c

2276

pwm = pwm_cdev_get_requested_pwm(cdata, cwf.hwpwm);

drivers/pwm/core.c

2277

if (IS_ERR(pwm))

drivers/pwm/core.c

2278

return PTR_ERR(pwm);

drivers/pwm/core.c

2286

ret = pwm_round_waveform_might_sleep(pwm, &wf);

drivers/pwm/core.c

2306

struct pwm_device *pwm;

drivers/pwm/core.c

2317

pwm = pwm_cdev_get_requested_pwm(cdata, cwf.hwpwm);

drivers/pwm/core.c

2318

if (IS_ERR(pwm))

drivers/pwm/core.c

2319

return PTR_ERR(pwm);

drivers/pwm/core.c

2321

ret = pwm_get_waveform_might_sleep(pwm, &wf);

drivers/pwm/core.c

2342

struct pwm_device *pwm;

drivers/pwm/core.c

2362

pwm = pwm_cdev_get_requested_pwm(cdata, cwf.hwpwm);

drivers/pwm/core.c

2363

if (IS_ERR(pwm))

drivers/pwm/core.c

2364

return PTR_ERR(pwm);

drivers/pwm/core.c

2366

ret = pwm_set_waveform_might_sleep(pwm, &wf,

drivers/pwm/core.c

2399

struct pwm_device *pwm;

drivers/pwm/core.c

2401

pwm = pwm_request_from_chip(chip, offset, "pwm-gpio");

drivers/pwm/core.c

2402

if (IS_ERR(pwm))

drivers/pwm/core.c

2403

return PTR_ERR(pwm);

drivers/pwm/core.c

2423

struct pwm_device *pwm = &chip->pwms[offset];

drivers/pwm/core.c

2429

ret = pwm_round_waveform_might_sleep(pwm, &wf);

drivers/pwm/core.c

2438

return pwm_set_waveform_might_sleep(pwm, &wf, true);

drivers/pwm/core.c

244

int pwm_round_waveform_might_sleep(struct pwm_device *pwm, struct pwm_waveform *wf)

drivers/pwm/core.c

246

struct pwm_chip *chip = pwm->chip;

drivers/pwm/core.c

2566

struct pwm_device *pwm = &chip->pwms[i];

drivers/pwm/core.c

2568

if (test_and_clear_bit(PWMF_REQUESTED, &pwm->flags)) {

drivers/pwm/core.c

2570

if (pwm->chip->ops->free)

drivers/pwm/core.c

2571

pwm->chip->ops->free(pwm->chip, pwm);

drivers/pwm/core.c

2639

struct pwm_device *pwm = &chip->pwms[i];

drivers/pwm/core.c

2643

pwm_get_state(pwm, &state);

drivers/pwm/core.c

2645

seq_printf(s, " pwm-%-3d (%-20.20s):", i, pwm->label);

drivers/pwm/core.c

2647

if (test_bit(PWMF_REQUESTED, &pwm->flags))

drivers/pwm/core.c

265

ret_tohw = __pwm_round_waveform_tohw(chip, pwm, wf, wfhw);

drivers/pwm/core.c

2662

err = pwm_get_waveform_might_sleep(pwm, &wf);

drivers/pwm/core.c

2671

err = pwm_get_state_hw(pwm, &hwstate);

drivers/pwm/core.c

273

ret_fromhw = __pwm_round_waveform_fromhw(chip, pwm, wfhw, wf);

drivers/pwm/core.c

303

int pwm_get_waveform_might_sleep(struct pwm_device *pwm, struct pwm_waveform *wf)

drivers/pwm/core.c

305

struct pwm_chip *chip = pwm->chip;

drivers/pwm/core.c

320

err = __pwm_read_waveform(chip, pwm, &wfhw);

drivers/pwm/core.c

324

return __pwm_round_waveform_fromhw(chip, pwm, &wfhw, wf);

drivers/pwm/core.c

329

static int __pwm_set_waveform(struct pwm_device *pwm,

drivers/pwm/core.c

333

struct pwm_chip *chip = pwm->chip;

drivers/pwm/core.c

347

ret_tohw = __pwm_round_waveform_tohw(chip, pwm, wf, &wfhw);

drivers/pwm/core.c

352

err = __pwm_round_waveform_fromhw(chip, pwm, &wfhw, &wf_rounded);

drivers/pwm/core.c

370

err = __pwm_write_waveform(chip, pwm, &wfhw);

drivers/pwm/core.c

375

pwm_wf2state(wf, &pwm->state);

drivers/pwm/core.c

380

err = __pwm_read_waveform(chip, pwm, &wfhw);

drivers/pwm/core.c

385

err = __pwm_round_waveform_fromhw(chip, pwm, &wfhw, &wf_set);

drivers/pwm/core.c

442

int pwm_set_waveform_might_sleep(struct pwm_device *pwm,

drivers/pwm/core.c

445

struct pwm_chip *chip = pwm->chip;

drivers/pwm/core.c

461

err = __pwm_set_waveform(pwm, wf, exact);

drivers/pwm/core.c

464

err = __pwm_set_waveform(pwm, wf, exact);

drivers/pwm/core.c

484

static void pwm_apply_debug(struct pwm_device *pwm,

drivers/pwm/core.c

487

struct pwm_state *last = &pwm->last;

drivers/pwm/core.c

488

struct pwm_chip *chip = pwm->chip;

drivers/pwm/core.c

511

err = chip->ops->get_state(chip, pwm, &s1);

drivers/pwm/core.c

512

trace_pwm_get(pwm, &s1, err);

drivers/pwm/core.c

575

err = chip->ops->apply(chip, pwm, &s1);

drivers/pwm/core.c

576

trace_pwm_apply(pwm, &s1, err);

drivers/pwm/core.c

584

err = chip->ops->get_state(chip, pwm, last);

drivers/pwm/core.c

585

trace_pwm_get(pwm, last, err);

drivers/pwm/core.c

621

static int __pwm_apply(struct pwm_device *pwm, const struct pwm_state *state)

drivers/pwm/core.c

627

if (!pwm || !state)

drivers/pwm/core.c

639

if (!pwm_state_valid(&pwm->state)) {

drivers/pwm/core.c

640

pwm->state = *state;

drivers/pwm/core.c

647

chip = pwm->chip;

drivers/pwm/core.c

650

if (state->period == pwm->state.period &&

drivers/pwm/core.c

651

state->duty_cycle == pwm->state.duty_cycle &&

drivers/pwm/core.c

652

state->polarity == pwm->state.polarity &&

drivers/pwm/core.c

653

state->enabled == pwm->state.enabled &&

drivers/pwm/core.c

654

state->usage_power == pwm->state.usage_power)

drivers/pwm/core.c

674

err = __pwm_round_waveform_tohw(chip, pwm, &wf, &wfhw);

drivers/pwm/core.c

690

err = __pwm_round_waveform_fromhw(chip, pwm, &wfhw, &wf_rounded);

drivers/pwm/core.c

700

err = __pwm_write_waveform(chip, pwm, &wfhw);

drivers/pwm/core.c

704

pwm->state = *state;

drivers/pwm/core.c

707

err = ops->apply(chip, pwm, state);

drivers/pwm/core.c

708

trace_pwm_apply(pwm, state, err);

drivers/pwm/core.c

712

pwm->state = *state;

drivers/pwm/core.c

718

pwm_apply_debug(pwm, state);

drivers/pwm/core.c

733

int pwm_apply_might_sleep(struct pwm_device *pwm, const struct pwm_state *state)

drivers/pwm/core.c

736

struct pwm_chip *chip = pwm->chip;

drivers/pwm/core.c

758

err = __pwm_apply(pwm, state);

drivers/pwm/core.c

761

err = __pwm_apply(pwm, state);

drivers/pwm/core.c

777

int pwm_apply_atomic(struct pwm_device *pwm, const struct pwm_state *state)

drivers/pwm/core.c

779

struct pwm_chip *chip = pwm->chip;

drivers/pwm/core.c

789

return __pwm_apply(pwm, state);

drivers/pwm/core.c

804

int pwm_get_state_hw(struct pwm_device *pwm, struct pwm_state *state)

drivers/pwm/core.c

806

struct pwm_chip *chip = pwm->chip;

drivers/pwm/core.c

823

ret = __pwm_read_waveform(chip, pwm, &wfhw);

drivers/pwm/core.c

827

ret = __pwm_round_waveform_fromhw(chip, pwm, &wfhw, &wf);

drivers/pwm/core.c

834

ret = ops->get_state(chip, pwm, state);

drivers/pwm/core.c

835

trace_pwm_get(pwm, state, ret);

drivers/pwm/core.c

853

int pwm_adjust_config(struct pwm_device *pwm)

drivers/pwm/core.c

858

pwm_get_args(pwm, &pargs);

drivers/pwm/core.c

859

pwm_get_state(pwm, &state);

drivers/pwm/core.c

874

return pwm_apply_might_sleep(pwm, &state);

drivers/pwm/core.c

897

return pwm_apply_might_sleep(pwm, &state);

drivers/pwm/core.c

909

static int pwm_capture(struct pwm_device *pwm, struct pwm_capture *result,

drivers/pwm/core.c

912

struct pwm_chip *chip = pwm->chip;

drivers/pwm/core.c

930

return ops->capture(chip, pwm, result, timeout);

drivers/pwm/core.c

951

static int pwm_device_request(struct pwm_device *pwm, const char *label)

drivers/pwm/core.c

954

struct pwm_chip *chip = pwm->chip;

drivers/pwm/core.c

957

if (test_bit(PWMF_REQUESTED, &pwm->flags))

drivers/pwm/core.c

977

err = ops->request(chip, pwm);

drivers/pwm/core.c

996

err = pwm_get_state_hw(pwm, &state);

drivers/pwm/core.c

998

pwm->state = state;

drivers/pwm/pwm-ab8500.c

100

pwm->label, ret);

drivers/pwm/pwm-ab8500.c

133

pwm->label, ret);

drivers/pwm/pwm-ab8500.c

138

static int ab8500_pwm_get_state(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-ab8500.c

35

static int ab8500_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-adp5585.c

120

struct pwm_device *pwm,

drivers/pwm/pwm-adp5585.c

47

static int pwm_adp5585_request(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-adp5585.c

57

static void pwm_adp5585_free(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-adp5585.c

67

struct pwm_device *pwm,

drivers/pwm/pwm-airoha.c

448

static int airoha_pwm_config(struct airoha_pwm *pc, struct pwm_device *pwm,

drivers/pwm/pwm-airoha.c

451

unsigned int hwpwm = pwm->hwpwm;

drivers/pwm/pwm-airoha.c

489

static void airoha_pwm_disable(struct airoha_pwm *pc, struct pwm_device *pwm)

drivers/pwm/pwm-airoha.c

492

airoha_pwm_config_flash_map(pc, pwm->hwpwm, -1);

drivers/pwm/pwm-airoha.c

493

airoha_pwm_release_bucket_config(pc, pwm->hwpwm);

drivers/pwm/pwm-airoha.c

495

__clear_bit(pwm->hwpwm, pc->initialized);

drivers/pwm/pwm-airoha.c

504

static int airoha_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-airoha.c

512

airoha_pwm_disable(pc, pwm);

drivers/pwm/pwm-airoha.c

542

return airoha_pwm_config(pc, pwm, period_ticks, duty_ticks);

drivers/pwm/pwm-airoha.c

545

static int airoha_pwm_get_state(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-airoha.c

549

int ret, hwpwm = pwm->hwpwm;

drivers/pwm/pwm-apple.c

43

static int apple_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-apple.c

75

static int apple_pwm_get_state(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-argon-fan-hat.c

22

struct pwm_device *pwm,

drivers/pwm/pwm-argon-fan-hat.c

37

struct pwm_device *pwm,

drivers/pwm/pwm-argon-fan-hat.c

51

struct pwm_device *pwm,

drivers/pwm/pwm-atmel-hlcdc.c

186

struct pwm_device *pwm = &chip->pwms[0];

drivers/pwm/pwm-atmel-hlcdc.c

189

if (!pwm->state.enabled)

drivers/pwm/pwm-atmel-hlcdc.c

199

struct pwm_device *pwm = &chip->pwms[0];

drivers/pwm/pwm-atmel-hlcdc.c

203

if (!pwm->state.enabled) {

drivers/pwm/pwm-atmel-hlcdc.c

209

return atmel_hlcdc_pwm_apply(chip, pwm, &pwm->state);

drivers/pwm/pwm-atmel-hlcdc.c

41

static int atmel_hlcdc_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-atmel-tcb.c

117

static void atmel_tcb_pwm_free(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-atmel-tcb.c

124

static void atmel_tcb_pwm_disable(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-atmel-tcb.c

128

struct atmel_tcb_pwm_device *tcbpwm = &tcbpwmc->pwms[pwm->hwpwm];

drivers/pwm/pwm-atmel-tcb.c

145

if (pwm->hwpwm == 0) {

drivers/pwm/pwm-atmel-tcb.c

178

static int atmel_tcb_pwm_enable(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-atmel-tcb.c

182

struct atmel_tcb_pwm_device *tcbpwm = &tcbpwmc->pwms[pwm->hwpwm];

drivers/pwm/pwm-atmel-tcb.c

201

if (pwm->hwpwm == 0) {

drivers/pwm/pwm-atmel-tcb.c

224

if (pwm->hwpwm == 0) {

drivers/pwm/pwm-atmel-tcb.c

241

if (pwm->hwpwm == 0)

drivers/pwm/pwm-atmel-tcb.c

260

static int atmel_tcb_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-atmel-tcb.c

264

struct atmel_tcb_pwm_device *tcbpwm = &tcbpwmc->pwms[pwm->hwpwm];

drivers/pwm/pwm-atmel-tcb.c

266

struct atmel_tcb_pwm_device *atcbpwm = &tcbpwmc->pwms[pwm->hwpwm ^ 1];

drivers/pwm/pwm-atmel-tcb.c

333

static int atmel_tcb_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-atmel-tcb.c

343

atmel_tcb_pwm_disable(chip, pwm, state->polarity);

drivers/pwm/pwm-atmel-tcb.c

350

ret = atmel_tcb_pwm_config(chip, pwm, duty_cycle, period);

drivers/pwm/pwm-atmel-tcb.c

354

return atmel_tcb_pwm_enable(chip, pwm, state->polarity);

drivers/pwm/pwm-atmel-tcb.c

71

struct pwm_device *pwm)

drivers/pwm/pwm-atmel-tcb.c

74

struct atmel_tcb_pwm_device *tcbpwm = &tcbpwmc->pwms[pwm->hwpwm];

drivers/pwm/pwm-atmel-tcb.c

94

if (pwm->hwpwm == 0)

drivers/pwm/pwm-atmel.c

227

static void atmel_pwm_update_cdty(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-atmel.c

235

val = atmel_pwm_ch_readl(atmel_pwm, pwm->hwpwm, PWM_CMR);

drivers/pwm/pwm-atmel.c

237

atmel_pwm_ch_writel(atmel_pwm, pwm->hwpwm, PWM_CMR, val);

drivers/pwm/pwm-atmel.c

240

atmel_pwm_ch_writel(atmel_pwm, pwm->hwpwm,

drivers/pwm/pwm-atmel.c

242

atmel_pwm_set_pending(atmel_pwm, pwm->hwpwm);

drivers/pwm/pwm-atmel.c

246

struct pwm_device *pwm,

drivers/pwm/pwm-atmel.c

251

atmel_pwm_ch_writel(atmel_pwm, pwm->hwpwm,

drivers/pwm/pwm-atmel.c

253

atmel_pwm_ch_writel(atmel_pwm, pwm->hwpwm,

drivers/pwm/pwm-atmel.c

257

static void atmel_pwm_disable(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-atmel.c

263

atmel_pwm_wait_nonpending(atmel_pwm, pwm->hwpwm);

drivers/pwm/pwm-atmel.c

265

atmel_pwm_writel(atmel_pwm, PWM_DIS, 1 << pwm->hwpwm);

drivers/pwm/pwm-atmel.c

273

while ((atmel_pwm_readl(atmel_pwm, PWM_SR) & (1 << pwm->hwpwm)) &&

drivers/pwm/pwm-atmel.c

281

static int atmel_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-atmel.c

292

if (pwm->state.enabled &&

drivers/pwm/pwm-atmel.c

293

pwm->state.polarity == state->polarity &&

drivers/pwm/pwm-atmel.c

294

pwm->state.period == state->period) {

drivers/pwm/pwm-atmel.c

295

u32 cmr = atmel_pwm_ch_readl(atmel_pwm, pwm->hwpwm, PWM_CMR);

drivers/pwm/pwm-atmel.c

297

cprd = atmel_pwm_ch_readl(atmel_pwm, pwm->hwpwm,

drivers/pwm/pwm-atmel.c

302

atmel_pwm_update_cdty(chip, pwm, cdty);

drivers/pwm/pwm-atmel.c

316

if (pwm->state.enabled) {

drivers/pwm/pwm-atmel.c

317

atmel_pwm_disable(chip, pwm, false);

drivers/pwm/pwm-atmel.c

327

val = atmel_pwm_ch_readl(atmel_pwm, pwm->hwpwm, PWM_CMR);

drivers/pwm/pwm-atmel.c

333

atmel_pwm_ch_writel(atmel_pwm, pwm->hwpwm, PWM_CMR, val);

drivers/pwm/pwm-atmel.c

334

atmel_pwm_set_cprd_cdty(chip, pwm, cprd, cdty);

drivers/pwm/pwm-atmel.c

335

atmel_pwm_writel(atmel_pwm, PWM_ENA, 1 << pwm->hwpwm);

drivers/pwm/pwm-atmel.c

336

} else if (pwm->state.enabled) {

drivers/pwm/pwm-atmel.c

337

atmel_pwm_disable(chip, pwm, true);

drivers/pwm/pwm-atmel.c

343

static int atmel_pwm_get_state(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-atmel.c

350

cmr = atmel_pwm_ch_readl(atmel_pwm, pwm->hwpwm, PWM_CMR);

drivers/pwm/pwm-atmel.c

352

if (sr & (1 << pwm->hwpwm)) {

drivers/pwm/pwm-atmel.c

359

cprd = atmel_pwm_ch_readl(atmel_pwm, pwm->hwpwm,

drivers/pwm/pwm-atmel.c

366

atmel_pwm_wait_nonpending(atmel_pwm, pwm->hwpwm);

drivers/pwm/pwm-atmel.c

368

cdty = atmel_pwm_ch_readl(atmel_pwm, pwm->hwpwm,

drivers/pwm/pwm-axi-pwmgen.c

115

pwm->hwpwm, wf->duty_length_ns, wf->period_length_ns, wf->duty_offset_ns,

drivers/pwm/pwm-axi-pwmgen.c

121

static int axi_pwmgen_round_waveform_fromhw(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-axi-pwmgen.c

140

struct pwm_device *pwm,

drivers/pwm/pwm-axi-pwmgen.c

146

unsigned int ch = pwm->hwpwm;

drivers/pwm/pwm-axi-pwmgen.c

165

struct pwm_device *pwm,

drivers/pwm/pwm-axi-pwmgen.c

171

unsigned int ch = pwm->hwpwm;

drivers/pwm/pwm-axi-pwmgen.c

72

struct pwm_device *pwm,

drivers/pwm/pwm-bcm-iproc.c

102

value = readl(ip->base + IPROC_PWM_PERIOD_OFFSET(pwm->hwpwm));

drivers/pwm/pwm-bcm-iproc.c

106

value = readl(ip->base + IPROC_PWM_DUTY_CYCLE_OFFSET(pwm->hwpwm));

drivers/pwm/pwm-bcm-iproc.c

113

static int iproc_pwmc_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-bcm-iproc.c

154

iproc_pwmc_disable(ip, pwm->hwpwm);

drivers/pwm/pwm-bcm-iproc.c

158

value &= ~IPROC_PWM_PRESCALE_MASK(pwm->hwpwm);

drivers/pwm/pwm-bcm-iproc.c

159

value |= prescale << IPROC_PWM_PRESCALE_SHIFT(pwm->hwpwm);

drivers/pwm/pwm-bcm-iproc.c

163

writel(period, ip->base + IPROC_PWM_PERIOD_OFFSET(pwm->hwpwm));

drivers/pwm/pwm-bcm-iproc.c

164

writel(duty, ip->base + IPROC_PWM_DUTY_CYCLE_OFFSET(pwm->hwpwm));

drivers/pwm/pwm-bcm-iproc.c

170

value |= 1 << IPROC_PWM_CTRL_POLARITY_SHIFT(pwm->hwpwm);

drivers/pwm/pwm-bcm-iproc.c

172

value &= ~(1 << IPROC_PWM_CTRL_POLARITY_SHIFT(pwm->hwpwm));

drivers/pwm/pwm-bcm-iproc.c

177

iproc_pwmc_enable(ip, pwm->hwpwm);

drivers/pwm/pwm-bcm-iproc.c

70

static int iproc_pwmc_get_state(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-bcm-iproc.c

79

if (value & BIT(IPROC_PWM_CTRL_EN_SHIFT(pwm->hwpwm)))

drivers/pwm/pwm-bcm-iproc.c

84

if (value & BIT(IPROC_PWM_CTRL_POLARITY_SHIFT(pwm->hwpwm)))

drivers/pwm/pwm-bcm-iproc.c

97

prescale = value >> IPROC_PWM_PRESCALE_SHIFT(pwm->hwpwm);

drivers/pwm/pwm-bcm-kona.c

100

static int kona_pwmc_config(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-bcm-kona.c

106

unsigned int value, chan = pwm->hwpwm;

drivers/pwm/pwm-bcm-kona.c

156

static int kona_pwmc_set_polarity(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-bcm-kona.c

160

unsigned int chan = pwm->hwpwm;

drivers/pwm/pwm-bcm-kona.c

188

static int kona_pwmc_enable(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-bcm-kona.c

202

static void kona_pwmc_disable(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-bcm-kona.c

205

unsigned int chan = pwm->hwpwm;

drivers/pwm/pwm-bcm-kona.c

224

static int kona_pwmc_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-bcm-kona.c

229

bool enabled = pwm->state.enabled;

drivers/pwm/pwm-bcm-kona.c

231

if (state->polarity != pwm->state.polarity) {

drivers/pwm/pwm-bcm-kona.c

233

kona_pwmc_disable(chip, pwm);

drivers/pwm/pwm-bcm-kona.c

237

err = kona_pwmc_set_polarity(chip, pwm, state->polarity);

drivers/pwm/pwm-bcm-kona.c

241

pwm->state.polarity = state->polarity;

drivers/pwm/pwm-bcm-kona.c

246

kona_pwmc_disable(chip, pwm);

drivers/pwm/pwm-bcm-kona.c

257

err = kona_pwmc_enable(chip, pwm);

drivers/pwm/pwm-bcm-kona.c

262

err = kona_pwmc_config(chip, pwm, state->duty_cycle, state->period);

drivers/pwm/pwm-bcm-kona.c

263

if (err && !pwm->state.enabled)

drivers/pwm/pwm-bcm2835.c

37

static int bcm2835_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-bcm2835.c

73

writel(period_cycles, pc->base + PERIOD(pwm->hwpwm));

drivers/pwm/pwm-bcm2835.c

77

writel(val, pc->base + DUTY(pwm->hwpwm));

drivers/pwm/pwm-bcm2835.c

82

val &= ~(PWM_CONTROL_MASK << PWM_CONTROL_SHIFT(pwm->hwpwm));

drivers/pwm/pwm-bcm2835.c

83

val |= PWM_MODE << PWM_CONTROL_SHIFT(pwm->hwpwm);

drivers/pwm/pwm-bcm2835.c

86

val &= ~(PWM_POLARITY << PWM_CONTROL_SHIFT(pwm->hwpwm));

drivers/pwm/pwm-bcm2835.c

88

val |= PWM_POLARITY << PWM_CONTROL_SHIFT(pwm->hwpwm);

drivers/pwm/pwm-bcm2835.c

92

val |= PWM_ENABLE << PWM_CONTROL_SHIFT(pwm->hwpwm);

drivers/pwm/pwm-bcm2835.c

94

val &= ~(PWM_ENABLE << PWM_CONTROL_SHIFT(pwm->hwpwm));

drivers/pwm/pwm-berlin.c

104

berlin_pwm_writel(bpc, pwm->hwpwm, value, BERLIN_PWM_CONTROL);

drivers/pwm/pwm-berlin.c

106

berlin_pwm_writel(bpc, pwm->hwpwm, duty, BERLIN_PWM_DUTY);

drivers/pwm/pwm-berlin.c

107

berlin_pwm_writel(bpc, pwm->hwpwm, period, BERLIN_PWM_TCNT);

drivers/pwm/pwm-berlin.c

113

struct pwm_device *pwm,

drivers/pwm/pwm-berlin.c

119

value = berlin_pwm_readl(bpc, pwm->hwpwm, BERLIN_PWM_CONTROL);

drivers/pwm/pwm-berlin.c

126

berlin_pwm_writel(bpc, pwm->hwpwm, value, BERLIN_PWM_CONTROL);

drivers/pwm/pwm-berlin.c

131

static int berlin_pwm_enable(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-berlin.c

136

value = berlin_pwm_readl(bpc, pwm->hwpwm, BERLIN_PWM_EN);

drivers/pwm/pwm-berlin.c

138

berlin_pwm_writel(bpc, pwm->hwpwm, value, BERLIN_PWM_EN);

drivers/pwm/pwm-berlin.c

144

struct pwm_device *pwm)

drivers/pwm/pwm-berlin.c

149

value = berlin_pwm_readl(bpc, pwm->hwpwm, BERLIN_PWM_EN);

drivers/pwm/pwm-berlin.c

151

berlin_pwm_writel(bpc, pwm->hwpwm, value, BERLIN_PWM_EN);

drivers/pwm/pwm-berlin.c

154

static int berlin_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-berlin.c

158

bool enabled = pwm->state.enabled;

drivers/pwm/pwm-berlin.c

160

if (state->polarity != pwm->state.polarity) {

drivers/pwm/pwm-berlin.c

162

berlin_pwm_disable(chip, pwm);

drivers/pwm/pwm-berlin.c

166

err = berlin_pwm_set_polarity(chip, pwm, state->polarity);

drivers/pwm/pwm-berlin.c

173

berlin_pwm_disable(chip, pwm);

drivers/pwm/pwm-berlin.c

177

err = berlin_pwm_config(chip, pwm, state->duty_cycle, state->period);

drivers/pwm/pwm-berlin.c

182

return berlin_pwm_enable(chip, pwm);

drivers/pwm/pwm-berlin.c

74

static int berlin_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-berlin.c

99

value = berlin_pwm_readl(bpc, pwm->hwpwm, BERLIN_PWM_CONTROL);

drivers/pwm/pwm-brcmstb.c

100

unsigned int channel = pwm->hwpwm;

drivers/pwm/pwm-brcmstb.c

194

static int brcmstb_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-brcmstb.c

204

if (pwm->state.enabled)

drivers/pwm/pwm-brcmstb.c

205

brcmstb_pwm_enable_set(p, pwm->hwpwm, false);

drivers/pwm/pwm-brcmstb.c

210

err = brcmstb_pwm_config(chip, pwm, state->duty_cycle, state->period);

drivers/pwm/pwm-brcmstb.c

214

if (!pwm->state.enabled)

drivers/pwm/pwm-brcmstb.c

215

brcmstb_pwm_enable_set(p, pwm->hwpwm, true);

drivers/pwm/pwm-brcmstb.c

95

static int brcmstb_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-clk.c

40

static int pwm_clk_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-clk.c

50

if (pwm->state.enabled) {

drivers/pwm/pwm-clk.c

55

} else if (!pwm->state.enabled) {

drivers/pwm/pwm-clps711x.c

24

static int clps711x_pwm_request(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-clps711x.c

33

pwm->args.period = DIV_ROUND_CLOSEST(NSEC_PER_SEC, freq);

drivers/pwm/pwm-clps711x.c

38

static int clps711x_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-clps711x.c

43

u32 shift = (pwm->hwpwm + 1) * 4;

drivers/pwm/pwm-clps711x.c

49

if (state->period != pwm->args.period)

drivers/pwm/pwm-crc.c

111

if (!pwm_is_enabled(pwm) && state->enabled) {

drivers/pwm/pwm-crc.c

122

static int crc_pwm_get_state(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-crc.c

52

static int crc_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-crc.c

67

if (pwm_is_enabled(pwm) && !state->enabled) {

drivers/pwm/pwm-crc.c

75

if (pwm_get_duty_cycle(pwm) != state->duty_cycle ||

drivers/pwm/pwm-crc.c

76

pwm_get_period(pwm) != state->period) {

drivers/pwm/pwm-crc.c

88

if (pwm_is_enabled(pwm) && state->enabled &&

drivers/pwm/pwm-crc.c

89

pwm_get_period(pwm) != state->period) {

drivers/pwm/pwm-crc.c

98

if (pwm_get_period(pwm) != state->period ||

drivers/pwm/pwm-crc.c

99

pwm_is_enabled(pwm) != state->enabled) {

drivers/pwm/pwm-cros-ec.c

122

static int cros_ec_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-cros-ec.c

142

ret = cros_ec_pwm_set_duty(ec_pwm, pwm->hwpwm, duty_cycle);

drivers/pwm/pwm-cros-ec.c

149

static int cros_ec_pwm_get_state(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-cros-ec.c

155

ret = cros_ec_pwm_get_duty(ec_pwm->ec, ec_pwm->use_pwm_type, pwm->hwpwm);

drivers/pwm/pwm-dwc-core.c

107

if (!pwm->state.enabled)

drivers/pwm/pwm-dwc-core.c

109

return __dwc_pwm_configure_timer(dwc, pwm, state);

drivers/pwm/pwm-dwc-core.c

111

if (pwm->state.enabled) {

drivers/pwm/pwm-dwc-core.c

112

__dwc_pwm_set_enable(dwc, pwm->hwpwm, false);

drivers/pwm/pwm-dwc-core.c

120

static int dwc_pwm_get_state(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-dwc-core.c

129

ctrl = dwc_pwm_readl(dwc, DWC_TIM_CTRL(pwm->hwpwm));

drivers/pwm/pwm-dwc-core.c

130

ld = dwc_pwm_readl(dwc, DWC_TIM_LD_CNT(pwm->hwpwm));

drivers/pwm/pwm-dwc-core.c

131

ld2 = dwc_pwm_readl(dwc, DWC_TIM_LD_CNT2(pwm->hwpwm));

drivers/pwm/pwm-dwc-core.c

24

static void __dwc_pwm_set_enable(struct dwc_pwm *dwc, int pwm, int enabled)

drivers/pwm/pwm-dwc-core.c

28

reg = dwc_pwm_readl(dwc, DWC_TIM_CTRL(pwm));

drivers/pwm/pwm-dwc-core.c

35

dwc_pwm_writel(dwc, reg, DWC_TIM_CTRL(pwm));

drivers/pwm/pwm-dwc-core.c

39

struct pwm_device *pwm,

drivers/pwm/pwm-dwc-core.c

70

__dwc_pwm_set_enable(dwc, pwm->hwpwm, false);

drivers/pwm/pwm-dwc-core.c

78

dwc_pwm_writel(dwc, low, DWC_TIM_LD_CNT(pwm->hwpwm));

drivers/pwm/pwm-dwc-core.c

79

dwc_pwm_writel(dwc, high, DWC_TIM_LD_CNT2(pwm->hwpwm));

drivers/pwm/pwm-dwc-core.c

88

dwc_pwm_writel(dwc, ctrl, DWC_TIM_CTRL(pwm->hwpwm));

drivers/pwm/pwm-dwc-core.c

93

__dwc_pwm_set_enable(dwc, pwm->hwpwm, state->enabled);

drivers/pwm/pwm-dwc-core.c

98

static int dwc_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-ep93xx.c

124

if (!pwm_is_enabled(pwm))

drivers/pwm/pwm-ep93xx.c

44

static int ep93xx_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-ep93xx.c

56

if (state->polarity != pwm->state.polarity) {

drivers/pwm/pwm-ep93xx.c

92

if (!pwm_is_enabled(pwm)) {

drivers/pwm/pwm-fsl-ftm.c

104

regmap_clear_bits(fpc->regmap, FTM_SC, BIT(pwm->hwpwm + 16));

drivers/pwm/pwm-fsl-ftm.c

201

struct pwm_device *pwm)

drivers/pwm/pwm-fsl-ftm.c

213

struct pwm_device *pwm)

drivers/pwm/pwm-fsl-ftm.c

218

if (~(val | BIT(pwm->hwpwm)) & 0xFF)

drivers/pwm/pwm-fsl-ftm.c

225

struct pwm_device *pwm,

drivers/pwm/pwm-fsl-ftm.c

240

if (!fsl_pwm_is_any_pwm_enabled(fpc, pwm))

drivers/pwm/pwm-fsl-ftm.c

249

if (fsl_pwm_is_other_pwm_enabled(fpc, pwm)) {

drivers/pwm/pwm-fsl-ftm.c

252

pwm->hwpwm);

drivers/pwm/pwm-fsl-ftm.c

282

regmap_write(fpc->regmap, FTM_CSC(pwm->hwpwm),

drivers/pwm/pwm-fsl-ftm.c

284

regmap_write(fpc->regmap, FTM_CV(pwm->hwpwm), duty);

drivers/pwm/pwm-fsl-ftm.c

288

reg_polarity = BIT(pwm->hwpwm);

drivers/pwm/pwm-fsl-ftm.c

290

regmap_update_bits(fpc->regmap, FTM_POL, BIT(pwm->hwpwm), reg_polarity);

drivers/pwm/pwm-fsl-ftm.c

297

static int fsl_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-fsl-ftm.c

301

struct pwm_state *oldstate = &pwm->state;

drivers/pwm/pwm-fsl-ftm.c

316

BIT(pwm->hwpwm));

drivers/pwm/pwm-fsl-ftm.c

324

ret = fsl_pwm_apply_config(chip, pwm, newstate);

drivers/pwm/pwm-fsl-ftm.c

340

regmap_clear_bits(fpc->regmap, FTM_OUTMASK, BIT(pwm->hwpwm));

drivers/pwm/pwm-fsl-ftm.c

483

struct pwm_device *pwm = &chip->pwms[i];

drivers/pwm/pwm-fsl-ftm.c

485

if (!test_bit(PWMF_REQUESTED, &pwm->flags))

drivers/pwm/pwm-fsl-ftm.c

490

if (!pwm_is_enabled(pwm))

drivers/pwm/pwm-fsl-ftm.c

507

struct pwm_device *pwm = &chip->pwms[i];

drivers/pwm/pwm-fsl-ftm.c

509

if (!test_bit(PWMF_REQUESTED, &pwm->flags))

drivers/pwm/pwm-fsl-ftm.c

514

if (!pwm_is_enabled(pwm))

drivers/pwm/pwm-fsl-ftm.c

87

static int fsl_pwm_request(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-fsl-ftm.c

94

regmap_set_bits(fpc->regmap, FTM_SC, BIT(pwm->hwpwm + 16));

drivers/pwm/pwm-fsl-ftm.c

99

static void fsl_pwm_free(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-gpio.c

100

static int pwm_gpio_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-gpio.c

153

static int pwm_gpio_get_state(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-hibvt.c

109

hibvt_pwm_set_bits(hi_pwm_chip->base, PWM_CFG0_ADDR(pwm->hwpwm),

drivers/pwm/pwm-hibvt.c

112

hibvt_pwm_set_bits(hi_pwm_chip->base, PWM_CFG1_ADDR(pwm->hwpwm),

drivers/pwm/pwm-hibvt.c

117

struct pwm_device *pwm,

drivers/pwm/pwm-hibvt.c

123

hibvt_pwm_set_bits(hi_pwm_chip->base, PWM_CTRL_ADDR(pwm->hwpwm),

drivers/pwm/pwm-hibvt.c

126

hibvt_pwm_set_bits(hi_pwm_chip->base, PWM_CTRL_ADDR(pwm->hwpwm),

drivers/pwm/pwm-hibvt.c

130

static int hibvt_pwm_get_state(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-hibvt.c

140

value = readl(base + PWM_CFG0_ADDR(pwm->hwpwm));

drivers/pwm/pwm-hibvt.c

143

value = readl(base + PWM_CFG1_ADDR(pwm->hwpwm));

drivers/pwm/pwm-hibvt.c

146

value = readl(base + PWM_CTRL_ADDR(pwm->hwpwm));

drivers/pwm/pwm-hibvt.c

153

static int hibvt_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-hibvt.c

158

if (state->polarity != pwm->state.polarity)

drivers/pwm/pwm-hibvt.c

159

hibvt_pwm_set_polarity(chip, pwm, state->polarity);

drivers/pwm/pwm-hibvt.c

161

if (state->period != pwm->state.period ||

drivers/pwm/pwm-hibvt.c

162

state->duty_cycle != pwm->state.duty_cycle) {

drivers/pwm/pwm-hibvt.c

163

hibvt_pwm_config(chip, pwm, state->duty_cycle, state->period);

drivers/pwm/pwm-hibvt.c

170

hibvt_pwm_enable(chip, pwm);

drivers/pwm/pwm-hibvt.c

173

if (state->enabled != pwm->state.enabled) {

drivers/pwm/pwm-hibvt.c

175

hibvt_pwm_enable(chip, pwm);

drivers/pwm/pwm-hibvt.c

177

hibvt_pwm_disable(chip, pwm);

drivers/pwm/pwm-hibvt.c

82

static void hibvt_pwm_enable(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-hibvt.c

86

hibvt_pwm_set_bits(hi_pwm_chip->base, PWM_CTRL_ADDR(pwm->hwpwm),

drivers/pwm/pwm-hibvt.c

90

static void hibvt_pwm_disable(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-hibvt.c

94

hibvt_pwm_set_bits(hi_pwm_chip->base, PWM_CTRL_ADDR(pwm->hwpwm),

drivers/pwm/pwm-hibvt.c

98

static void hibvt_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-img.c

133

val &= ~(PWM_CTRL_CFG_DIV_MASK << PWM_CTRL_CFG_DIV_SHIFT(pwm->hwpwm));

drivers/pwm/pwm-img.c

135

PWM_CTRL_CFG_DIV_SHIFT(pwm->hwpwm);

drivers/pwm/pwm-img.c

140

img_pwm_writel(imgchip, PWM_CH_CFG(pwm->hwpwm), val);

drivers/pwm/pwm-img.c

147

static int img_pwm_enable(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-img.c

158

val |= BIT(pwm->hwpwm);

drivers/pwm/pwm-img.c

163

PERIP_PWM_PDM_CONTROL_CH_SHIFT(pwm->hwpwm));

drivers/pwm/pwm-img.c

168

static void img_pwm_disable(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-img.c

174

val &= ~BIT(pwm->hwpwm);

drivers/pwm/pwm-img.c

180

static int img_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-img.c

189

if (pwm->state.enabled)

drivers/pwm/pwm-img.c

190

img_pwm_disable(chip, pwm);

drivers/pwm/pwm-img.c

195

err = img_pwm_config(chip, pwm, state->duty_cycle, state->period);

drivers/pwm/pwm-img.c

199

if (!pwm->state.enabled)

drivers/pwm/pwm-img.c

200

err = img_pwm_enable(chip, pwm);

drivers/pwm/pwm-img.c

89

static int img_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-imx-tpm.c

138

struct pwm_device *pwm,

drivers/pwm/pwm-imx-tpm.c

152

tmp = readl(tpm->base + PWM_IMX_TPM_CnV(pwm->hwpwm));

drivers/pwm/pwm-imx-tpm.c

157

val = readl(tpm->base + PWM_IMX_TPM_CnSC(pwm->hwpwm));

drivers/pwm/pwm-imx-tpm.c

177

struct pwm_device *pwm)

drivers/pwm/pwm-imx-tpm.c

229

pwm_imx_tpm_get_state(chip, pwm, &c);

drivers/pwm/pwm-imx-tpm.c

244

writel(p->val, tpm->base + PWM_IMX_TPM_CnV(pwm->hwpwm));

drivers/pwm/pwm-imx-tpm.c

253

|| readl(tpm->base + PWM_IMX_TPM_CnV(pwm->hwpwm))

drivers/pwm/pwm-imx-tpm.c

267

val = readl(tpm->base + PWM_IMX_TPM_CnSC(pwm->hwpwm));

drivers/pwm/pwm-imx-tpm.c

283

writel(val, tpm->base + PWM_IMX_TPM_CnSC(pwm->hwpwm));

drivers/pwm/pwm-imx-tpm.c

302

struct pwm_device *pwm,

drivers/pwm/pwm-imx-tpm.c

315

ret = pwm_imx_tpm_apply_hw(chip, &param, &real_state, pwm);

drivers/pwm/pwm-imx-tpm.c

321

static int pwm_imx_tpm_request(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-imx-tpm.c

332

static void pwm_imx_tpm_free(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-imx1.c

112

static void pwm_imx1_disable(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-imx1.c

124

static int pwm_imx1_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-imx1.c

133

if (pwm->state.enabled)

drivers/pwm/pwm-imx1.c

134

pwm_imx1_disable(chip, pwm);

drivers/pwm/pwm-imx1.c

139

err = pwm_imx1_config(chip, pwm, state->duty_cycle, state->period);

drivers/pwm/pwm-imx1.c

143

if (!pwm->state.enabled)

drivers/pwm/pwm-imx1.c

144

return pwm_imx1_enable(chip, pwm);

drivers/pwm/pwm-imx1.c

65

struct pwm_device *pwm, u64 duty_ns, u64 period_ns)

drivers/pwm/pwm-imx1.c

95

static int pwm_imx1_enable(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-imx27.c

105

struct pwm_device *pwm, struct pwm_state *state)

drivers/pwm/pwm-imx27.c

179

struct pwm_device *pwm)

drivers/pwm/pwm-imx27.c

190

period_ms = DIV_ROUND_UP_ULL(pwm->state.period,

drivers/pwm/pwm-imx27.c

200

static int pwm_imx27_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-imx27.c

240

if (pwm->state.enabled) {

drivers/pwm/pwm-imx27.c

241

pwm_imx27_wait_fifo_slot(chip, pwm);

drivers/pwm/pwm-intel-lgm.c

62

static int lgm_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-intel-lgm.c

87

static int lgm_pwm_get_state(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-ipq.c

147

ipq_pwm_reg_write(pwm, IPQ_PWM_REG0, val);

drivers/pwm/pwm-ipq.c

150

ipq_pwm_reg_write(pwm, IPQ_PWM_REG1, val);

drivers/pwm/pwm-ipq.c

154

ipq_pwm_reg_write(pwm, IPQ_PWM_REG1, val);

drivers/pwm/pwm-ipq.c

159

static int ipq_pwm_get_state(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-ipq.c

167

reg1 = ipq_pwm_reg_read(pwm, IPQ_PWM_REG1);

drivers/pwm/pwm-ipq.c

173

reg0 = ipq_pwm_reg_read(pwm, IPQ_PWM_REG0);

drivers/pwm/pwm-ipq.c

210

struct ipq_pwm_chip *pwm;

drivers/pwm/pwm-ipq.c

215

chip = devm_pwmchip_alloc(dev, 4, sizeof(*pwm));

drivers/pwm/pwm-ipq.c

218

pwm = ipq_pwm_from_chip(chip);

drivers/pwm/pwm-ipq.c

220

pwm->mem = devm_platform_ioremap_resource(pdev, 0);

drivers/pwm/pwm-ipq.c

221

if (IS_ERR(pwm->mem))

drivers/pwm/pwm-ipq.c

222

return dev_err_probe(dev, PTR_ERR(pwm->mem),

drivers/pwm/pwm-ipq.c

234

pwm->clk_rate = clk_get_rate(clk);

drivers/pwm/pwm-ipq.c

235

if (!pwm->clk_rate)

drivers/pwm/pwm-ipq.c

71

static unsigned int ipq_pwm_reg_read(struct pwm_device *pwm, unsigned int reg)

drivers/pwm/pwm-ipq.c

73

struct ipq_pwm_chip *ipq_chip = ipq_pwm_from_chip(pwm->chip);

drivers/pwm/pwm-ipq.c

74

unsigned int off = 8 * pwm->hwpwm + reg;

drivers/pwm/pwm-ipq.c

79

static void ipq_pwm_reg_write(struct pwm_device *pwm, unsigned int reg,

drivers/pwm/pwm-ipq.c

82

struct ipq_pwm_chip *ipq_chip = ipq_pwm_from_chip(pwm->chip);

drivers/pwm/pwm-ipq.c

83

unsigned int off = 8 * pwm->hwpwm + reg;

drivers/pwm/pwm-ipq.c

88

static int ipq_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-ipq.c

99

ipq_pwm_reg_write(pwm, IPQ_PWM_REG1, IPQ_PWM_REG1_UPDATE);

drivers/pwm/pwm-iqs620a.c

112

static int iqs620_pwm_get_state(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-iqs620a.c

67

static int iqs620_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-jz4740.c

100

static void jz4740_pwm_disable(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-jz4740.c

108

regmap_write(jz->map, TCU_REG_TDHRc(pwm->hwpwm), 0xffff);

drivers/pwm/pwm-jz4740.c

109

regmap_write(jz->map, TCU_REG_TDFRc(pwm->hwpwm), 0x0);

drivers/pwm/pwm-jz4740.c

116

regmap_clear_bits(jz->map, TCU_REG_TCSRc(pwm->hwpwm), TCU_TCSR_PWM_EN);

drivers/pwm/pwm-jz4740.c

119

regmap_write(jz->map, TCU_REG_TECR, BIT(pwm->hwpwm));

drivers/pwm/pwm-jz4740.c

122

static int jz4740_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-jz4740.c

127

struct clk *clk = jz->clk[pwm->hwpwm];

drivers/pwm/pwm-jz4740.c

168

jz4740_pwm_disable(chip, pwm);

drivers/pwm/pwm-jz4740.c

177

regmap_write(jz->map, TCU_REG_TCNTc(pwm->hwpwm), 0);

drivers/pwm/pwm-jz4740.c

180

regmap_write(jz->map, TCU_REG_TDHRc(pwm->hwpwm), duty);

drivers/pwm/pwm-jz4740.c

183

regmap_write(jz->map, TCU_REG_TDFRc(pwm->hwpwm), period);

drivers/pwm/pwm-jz4740.c

186

regmap_set_bits(jz->map, TCU_REG_TCSRc(pwm->hwpwm),

drivers/pwm/pwm-jz4740.c

203

regmap_clear_bits(jz->map, TCU_REG_TCSRc(pwm->hwpwm),

drivers/pwm/pwm-jz4740.c

206

regmap_set_bits(jz->map, TCU_REG_TCSRc(pwm->hwpwm),

drivers/pwm/pwm-jz4740.c

210

jz4740_pwm_enable(chip, pwm);

drivers/pwm/pwm-jz4740.c

48

static int jz4740_pwm_request(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-jz4740.c

55

if (!jz4740_pwm_can_use_chn(chip, pwm->hwpwm))

drivers/pwm/pwm-jz4740.c

58

snprintf(name, sizeof(name), "timer%u", pwm->hwpwm);

drivers/pwm/pwm-jz4740.c

73

jz->clk[pwm->hwpwm] = clk;

drivers/pwm/pwm-jz4740.c

78

static void jz4740_pwm_free(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-jz4740.c

81

struct clk *clk = jz->clk[pwm->hwpwm];

drivers/pwm/pwm-jz4740.c

87

static int jz4740_pwm_enable(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-jz4740.c

92

regmap_set_bits(jz->map, TCU_REG_TCSRc(pwm->hwpwm), TCU_TCSR_PWM_EN);

drivers/pwm/pwm-jz4740.c

95

regmap_write(jz->map, TCU_REG_TESR, BIT(pwm->hwpwm));

drivers/pwm/pwm-keembay.c

101

highlow = readl(priv->base + KMB_PWM_LEADIN_OFFSET(pwm->hwpwm));

drivers/pwm/pwm-keembay.c

108

highlow = readl(priv->base + KMB_PWM_HIGHLOW_OFFSET(pwm->hwpwm));

drivers/pwm/pwm-keembay.c

118

static int keembay_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-keembay.c

136

KMB_PWM_LEADIN_OFFSET(pwm->hwpwm));

drivers/pwm/pwm-keembay.c

138

keembay_pwm_get_state(chip, pwm, &current_state);

drivers/pwm/pwm-keembay.c

142

keembay_pwm_disable(priv, pwm->hwpwm);

drivers/pwm/pwm-keembay.c

170

writel(pwm_count, priv->base + KMB_PWM_HIGHLOW_OFFSET(pwm->hwpwm));

drivers/pwm/pwm-keembay.c

173

keembay_pwm_enable(priv, pwm->hwpwm);

drivers/pwm/pwm-keembay.c

90

static int keembay_pwm_get_state(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-loongson.c

106

static int pwm_loongson_enable(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-loongson.c

118

static int pwm_loongson_config(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-loongson.c

140

static int pwm_loongson_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-loongson.c

144

bool enabled = pwm->state.enabled;

drivers/pwm/pwm-loongson.c

148

pwm_loongson_disable(chip, pwm);

drivers/pwm/pwm-loongson.c

152

ret = pwm_loongson_set_polarity(chip, pwm, state->polarity);

drivers/pwm/pwm-loongson.c

156

ret = pwm_loongson_config(chip, pwm, state->duty_cycle, state->period);

drivers/pwm/pwm-loongson.c

161

ret = pwm_loongson_enable(chip, pwm);

drivers/pwm/pwm-loongson.c

166

static int pwm_loongson_get_state(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-loongson.c

244

struct pwm_device *pwm = &chip->pwms[0];

drivers/pwm/pwm-loongson.c

246

if (pwm->state.enabled)

drivers/pwm/pwm-loongson.c

76

static int pwm_loongson_set_polarity(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-loongson.c

96

static void pwm_loongson_disable(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-lp3943.c

105

if (pwm->hwpwm == 0) {

drivers/pwm/pwm-lp3943.c

151

static int lp3943_pwm_enable(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-lp3943.c

154

struct lp3943_pwm_map *pwm_map = &lp3943_pwm->pwm_map[pwm->hwpwm];

drivers/pwm/pwm-lp3943.c

157

if (pwm->hwpwm == 0)

drivers/pwm/pwm-lp3943.c

170

static void lp3943_pwm_disable(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-lp3943.c

173

struct lp3943_pwm_map *pwm_map = &lp3943_pwm->pwm_map[pwm->hwpwm];

drivers/pwm/pwm-lp3943.c

183

static int lp3943_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-lp3943.c

192

if (pwm->state.enabled)

drivers/pwm/pwm-lp3943.c

193

lp3943_pwm_disable(chip, pwm);

drivers/pwm/pwm-lp3943.c

197

err = lp3943_pwm_config(chip, pwm, state->duty_cycle, state->period);

drivers/pwm/pwm-lp3943.c

201

if (!pwm->state.enabled)

drivers/pwm/pwm-lp3943.c

202

err = lp3943_pwm_enable(chip, pwm);

drivers/pwm/pwm-lp3943.c

55

static int lp3943_pwm_request(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-lp3943.c

60

pwm_map = lp3943_pwm_request_map(lp3943_pwm, pwm->hwpwm);

drivers/pwm/pwm-lp3943.c

79

static void lp3943_pwm_free(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-lp3943.c

82

struct lp3943_pwm_map *pwm_map = &lp3943_pwm->pwm_map[pwm->hwpwm];

drivers/pwm/pwm-lp3943.c

87

static int lp3943_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-lpc18xx-sct.c

124

struct pwm_device *pwm,

drivers/pwm/pwm-lpc18xx-sct.c

135

val &= ~LPC18XX_PWM_RES_MASK(pwm->hwpwm);

drivers/pwm/pwm-lpc18xx-sct.c

136

val |= LPC18XX_PWM_RES(pwm->hwpwm, action);

drivers/pwm/pwm-lpc18xx-sct.c

163

struct pwm_device *pwm, u64 duty_ns)

drivers/pwm/pwm-lpc18xx-sct.c

166

struct lpc18xx_pwm_data *lpc18xx_data = &lpc18xx_pwm->channeldata[pwm->hwpwm];

drivers/pwm/pwm-lpc18xx-sct.c

184

static int lpc18xx_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-lpc18xx-sct.c

207

pwm->hwpwm);

drivers/pwm/pwm-lpc18xx-sct.c

217

lpc18xx_pwm_config_duty(chip, pwm, duty_ns);

drivers/pwm/pwm-lpc18xx-sct.c

222

static int lpc18xx_pwm_enable(struct pwm_chip *chip, struct pwm_device *pwm, enum pwm_polarity polarity)

drivers/pwm/pwm-lpc18xx-sct.c

225

struct lpc18xx_pwm_data *lpc18xx_data = &lpc18xx_pwm->channeldata[pwm->hwpwm];

drivers/pwm/pwm-lpc18xx-sct.c

248

lpc18xx_pwm_writel(lpc18xx_pwm, LPC18XX_PWM_OUTPUTSET(pwm->hwpwm),

drivers/pwm/pwm-lpc18xx-sct.c

250

lpc18xx_pwm_writel(lpc18xx_pwm, LPC18XX_PWM_OUTPUTCL(pwm->hwpwm),

drivers/pwm/pwm-lpc18xx-sct.c

252

lpc18xx_pwm_set_conflict_res(lpc18xx_pwm, pwm, res_action);

drivers/pwm/pwm-lpc18xx-sct.c

257

static void lpc18xx_pwm_disable(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-lpc18xx-sct.c

260

struct lpc18xx_pwm_data *lpc18xx_data = &lpc18xx_pwm->channeldata[pwm->hwpwm];

drivers/pwm/pwm-lpc18xx-sct.c

264

lpc18xx_pwm_writel(lpc18xx_pwm, LPC18XX_PWM_OUTPUTSET(pwm->hwpwm), 0);

drivers/pwm/pwm-lpc18xx-sct.c

265

lpc18xx_pwm_writel(lpc18xx_pwm, LPC18XX_PWM_OUTPUTCL(pwm->hwpwm), 0);

drivers/pwm/pwm-lpc18xx-sct.c

268

static int lpc18xx_pwm_request(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-lpc18xx-sct.c

271

struct lpc18xx_pwm_data *lpc18xx_data = &lpc18xx_pwm->channeldata[pwm->hwpwm];

drivers/pwm/pwm-lpc18xx-sct.c

289

static void lpc18xx_pwm_free(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-lpc18xx-sct.c

292

struct lpc18xx_pwm_data *lpc18xx_data = &lpc18xx_pwm->channeldata[pwm->hwpwm];

drivers/pwm/pwm-lpc18xx-sct.c

297

static int lpc18xx_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-lpc18xx-sct.c

301

bool enabled = pwm->state.enabled;

drivers/pwm/pwm-lpc18xx-sct.c

303

if (state->polarity != pwm->state.polarity && pwm->state.enabled) {

drivers/pwm/pwm-lpc18xx-sct.c

304

lpc18xx_pwm_disable(chip, pwm);

drivers/pwm/pwm-lpc18xx-sct.c

310

lpc18xx_pwm_disable(chip, pwm);

drivers/pwm/pwm-lpc18xx-sct.c

315

err = lpc18xx_pwm_config(chip, pwm, state->duty_cycle, state->period);

drivers/pwm/pwm-lpc18xx-sct.c

320

err = lpc18xx_pwm_enable(chip, pwm, state->polarity);

drivers/pwm/pwm-lpc32xx.c

101

if (pwm->state.enabled)

drivers/pwm/pwm-lpc32xx.c

102

lpc32xx_pwm_disable(chip, pwm);

drivers/pwm/pwm-lpc32xx.c

107

err = lpc32xx_pwm_config(chip, pwm, state->duty_cycle, state->period);

drivers/pwm/pwm-lpc32xx.c

111

if (!pwm->state.enabled)

drivers/pwm/pwm-lpc32xx.c

112

err = lpc32xx_pwm_enable(chip, pwm);

drivers/pwm/pwm-lpc32xx.c

30

static int lpc32xx_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-lpc32xx.c

63

static int lpc32xx_pwm_enable(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-lpc32xx.c

80

static void lpc32xx_pwm_disable(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-lpc32xx.c

92

static int lpc32xx_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-lpss.c

110

dev_err(pwmchip_parent(pwm->chip), "PWM_SW_UPDATE was not cleared\n");

drivers/pwm/pwm-lpss.c

115

static inline int pwm_lpss_is_updating(struct pwm_device *pwm)

drivers/pwm/pwm-lpss.c

117

if (pwm_lpss_read(pwm) & PWM_SW_UPDATE) {

drivers/pwm/pwm-lpss.c

118

dev_err(pwmchip_parent(pwm->chip), "PWM_SW_UPDATE is still set, skipping update\n");

drivers/pwm/pwm-lpss.c

125

static void pwm_lpss_prepare(struct pwm_lpss_chip *lpwm, struct pwm_device *pwm,

drivers/pwm/pwm-lpss.c

150

ctrl = pwm_lpss_read(pwm);

drivers/pwm/pwm-lpss.c

156

pwm_lpss_write(pwm, ctrl);

drivers/pwm/pwm-lpss.c

157

pwm_lpss_write(pwm, ctrl | PWM_SW_UPDATE);

drivers/pwm/pwm-lpss.c

160

static inline void pwm_lpss_cond_enable(struct pwm_device *pwm, bool cond)

drivers/pwm/pwm-lpss.c

163

pwm_lpss_write(pwm, pwm_lpss_read(pwm) | PWM_ENABLE);

drivers/pwm/pwm-lpss.c

167

struct pwm_device *pwm,

drivers/pwm/pwm-lpss.c

172

ret = pwm_lpss_is_updating(pwm);

drivers/pwm/pwm-lpss.c

176

pwm_lpss_prepare(lpwm, pwm, state->duty_cycle, state->period);

drivers/pwm/pwm-lpss.c

177

pwm_lpss_cond_enable(pwm, lpwm->info->bypass == false);

drivers/pwm/pwm-lpss.c

178

ret = pwm_lpss_wait_for_update(pwm);

drivers/pwm/pwm-lpss.c

182

pwm_lpss_cond_enable(pwm, lpwm->info->bypass == true);

drivers/pwm/pwm-lpss.c

186

static int pwm_lpss_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-lpss.c

193

if (!pwm_is_enabled(pwm)) {

drivers/pwm/pwm-lpss.c

195

ret = pwm_lpss_prepare_enable(lpwm, pwm, state);

drivers/pwm/pwm-lpss.c

199

ret = pwm_lpss_prepare_enable(lpwm, pwm, state);

drivers/pwm/pwm-lpss.c

201

} else if (pwm_is_enabled(pwm)) {

drivers/pwm/pwm-lpss.c

202

pwm_lpss_write(pwm, pwm_lpss_read(pwm) & ~PWM_ENABLE);

drivers/pwm/pwm-lpss.c

209

static int pwm_lpss_get_state(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-lpss.c

221

ctrl = pwm_lpss_read(pwm);

drivers/pwm/pwm-lpss.c

75

static inline u32 pwm_lpss_read(const struct pwm_device *pwm)

drivers/pwm/pwm-lpss.c

77

struct pwm_lpss_chip *lpwm = to_lpwm(pwm->chip);

drivers/pwm/pwm-lpss.c

79

return readl(lpwm->regs + pwm->hwpwm * PWM_SIZE + PWM);

drivers/pwm/pwm-lpss.c

82

static inline void pwm_lpss_write(const struct pwm_device *pwm, u32 value)

drivers/pwm/pwm-lpss.c

84

struct pwm_lpss_chip *lpwm = to_lpwm(pwm->chip);

drivers/pwm/pwm-lpss.c

86

writel(value, lpwm->regs + pwm->hwpwm * PWM_SIZE + PWM);

drivers/pwm/pwm-lpss.c

89

static int pwm_lpss_wait_for_update(struct pwm_device *pwm)

drivers/pwm/pwm-lpss.c

91

struct pwm_lpss_chip *lpwm = to_lpwm(pwm->chip);

drivers/pwm/pwm-lpss.c

92

const void __iomem *addr = lpwm->regs + pwm->hwpwm * PWM_SIZE + PWM;

drivers/pwm/pwm-max7360.c

108

struct pwm_device *pwm,

drivers/pwm/pwm-max7360.c

117

ret = regmap_write(regmap, MAX7360_REG_PWM(pwm->hwpwm), wfhw->duty_steps);

drivers/pwm/pwm-max7360.c

122

val = wfhw->enabled ? BIT(pwm->hwpwm) : 0;

drivers/pwm/pwm-max7360.c

123

return regmap_write_bits(regmap, MAX7360_REG_GPIOCTRL, BIT(pwm->hwpwm), val);

drivers/pwm/pwm-max7360.c

127

struct pwm_device *pwm,

drivers/pwm/pwm-max7360.c

139

if (val & BIT(pwm->hwpwm)) {

drivers/pwm/pwm-max7360.c

141

ret = regmap_read(regmap, MAX7360_REG_PWM(pwm->hwpwm), &val);

drivers/pwm/pwm-max7360.c

41

static int max7360_pwm_request(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-max7360.c

51

return regmap_write_bits(regmap, MAX7360_REG_PWMCFG(pwm->hwpwm),

drivers/pwm/pwm-max7360.c

56

struct pwm_device *pwm,

drivers/pwm/pwm-max7360.c

86

static int max7360_pwm_round_waveform_fromhw(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-mc33xs2410.c

221

static int mc33xs2410_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-mc33xs2410.c

226

MC33XS2410_PWM_FREQ(pwm->hwpwm + 1),

drivers/pwm/pwm-mc33xs2410.c

227

MC33XS2410_PWM_DC(pwm->hwpwm + 1),

drivers/pwm/pwm-mc33xs2410.c

261

mask = MC33XS2410_PWM_CTRL1_POL_INV(pwm->hwpwm + 1);

drivers/pwm/pwm-mc33xs2410.c

268

mask = MC33XS2410_PWM_CTRL3_EN(pwm->hwpwm + 1);

drivers/pwm/pwm-mc33xs2410.c

279

struct pwm_device *pwm,

drivers/pwm/pwm-mc33xs2410.c

284

MC33XS2410_PWM_FREQ(pwm->hwpwm + 1),

drivers/pwm/pwm-mc33xs2410.c

285

MC33XS2410_PWM_DC(pwm->hwpwm + 1),

drivers/pwm/pwm-mc33xs2410.c

298

state->polarity = (val[2] & MC33XS2410_PWM_CTRL1_POL_INV(pwm->hwpwm + 1)) ?

drivers/pwm/pwm-mc33xs2410.c

300

state->enabled = !!(val[3] & MC33XS2410_PWM_CTRL3_EN(pwm->hwpwm + 1));

drivers/pwm/pwm-mediatek.c

148

static int pwm_mediatek_round_waveform_tohw(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-mediatek.c

166

if (!pc->clk_pwms[pwm->hwpwm].rate) {

drivers/pwm/pwm-mediatek.c

167

struct clk *clk = pc->clk_pwms[pwm->hwpwm].clk;

drivers/pwm/pwm-mediatek.c

173

pc->clk_pwms[pwm->hwpwm].rate = clk_get_rate(clk);

drivers/pwm/pwm-mediatek.c

178

clk_rate = pc->clk_pwms[pwm->hwpwm].rate;

drivers/pwm/pwm-mediatek.c

206

enable = BIT(pwm->hwpwm);

drivers/pwm/pwm-mediatek.c

214

pwm->hwpwm, wf->duty_length_ns, wf->period_length_ns, clk_rate,

drivers/pwm/pwm-mediatek.c

227

static int pwm_mediatek_round_waveform_fromhw(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-mediatek.c

239

clk_rate = pc->clk_pwms[pwm->hwpwm].rate;

drivers/pwm/pwm-mediatek.c

275

pwm->hwpwm, wfhw->enable, clkdiv, cnt_period, cnt_duty, clk_rate,

drivers/pwm/pwm-mediatek.c

282

struct pwm_device *pwm, void *_wfhw)

drivers/pwm/pwm-mediatek.c

290

ret = pwm_mediatek_clk_enable(pc, pwm->hwpwm);

drivers/pwm/pwm-mediatek.c

294

enable = readl(pc->regs) & BIT(pwm->hwpwm);

drivers/pwm/pwm-mediatek.c

297

if (pc->soc->pwm45_fixup && pwm->hwpwm > 2) {

drivers/pwm/pwm-mediatek.c

306

clkdiv = FIELD_GET(PWMCON_CLKDIV, pwm_mediatek_readl(pc, pwm->hwpwm, PWMCON));

drivers/pwm/pwm-mediatek.c

307

cnt_period = FIELD_GET(PWMDWIDTH_PERIOD, pwm_mediatek_readl(pc, pwm->hwpwm, reg_width));

drivers/pwm/pwm-mediatek.c

308

cnt_duty = FIELD_GET(PWMTHRES_DUTY, pwm_mediatek_readl(pc, pwm->hwpwm, reg_thres));

drivers/pwm/pwm-mediatek.c

322

pwm_mediatek_clk_disable(pc, pwm->hwpwm);

drivers/pwm/pwm-mediatek.c

328

struct pwm_device *pwm, const void *_wfhw)

drivers/pwm/pwm-mediatek.c

335

ret = pwm_mediatek_clk_enable(pc, pwm->hwpwm);

drivers/pwm/pwm-mediatek.c

345

if (pc->soc->pwm45_fixup && pwm->hwpwm > 2) {

drivers/pwm/pwm-mediatek.c

354

if (!(ctrl & BIT(pwm->hwpwm))) {

drivers/pwm/pwm-mediatek.c

359

ret = pwm_mediatek_clk_enable(pc, pwm->hwpwm);

drivers/pwm/pwm-mediatek.c

363

ctrl |= BIT(pwm->hwpwm);

drivers/pwm/pwm-mediatek.c

375

pwm_mediatek_writel(pc, pwm->hwpwm, PWMCON, con_val);

drivers/pwm/pwm-mediatek.c

376

pwm_mediatek_writel(pc, pwm->hwpwm, reg_width, wfhw->width);

drivers/pwm/pwm-mediatek.c

377

pwm_mediatek_writel(pc, pwm->hwpwm, reg_thres, wfhw->thres);

drivers/pwm/pwm-mediatek.c

379

if (ctrl & BIT(pwm->hwpwm)) {

drivers/pwm/pwm-mediatek.c

380

ctrl &= ~BIT(pwm->hwpwm);

drivers/pwm/pwm-mediatek.c

383

pwm_mediatek_clk_disable(pc, pwm->hwpwm);

drivers/pwm/pwm-mediatek.c

388

pwm_mediatek_clk_disable(pc, pwm->hwpwm);

drivers/pwm/pwm-meson.c

134

static int meson_pwm_request(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-meson.c

137

struct meson_pwm_channel *channel = &meson->channels[pwm->hwpwm];

drivers/pwm/pwm-meson.c

151

static void meson_pwm_free(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-meson.c

154

struct meson_pwm_channel *channel = &meson->channels[pwm->hwpwm];

drivers/pwm/pwm-meson.c

159

static int meson_pwm_calc(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-meson.c

163

struct meson_pwm_channel *channel = &meson->channels[pwm->hwpwm];

drivers/pwm/pwm-meson.c

224

static void meson_pwm_enable(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-meson.c

227

struct meson_pwm_channel *channel = &meson->channels[pwm->hwpwm];

drivers/pwm/pwm-meson.c

233

channel_data = &meson_pwm_per_channel_data[pwm->hwpwm];

drivers/pwm/pwm-meson.c

265

static void meson_pwm_disable(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-meson.c

268

struct meson_pwm_channel *channel = &meson->channels[pwm->hwpwm];

drivers/pwm/pwm-meson.c

273

channel_data = &meson_pwm_per_channel_data[pwm->hwpwm];

drivers/pwm/pwm-meson.c

291

static int meson_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-meson.c

295

struct meson_pwm_channel *channel = &meson->channels[pwm->hwpwm];

drivers/pwm/pwm-meson.c

319

meson_pwm_enable(chip, pwm);

drivers/pwm/pwm-meson.c

321

meson_pwm_disable(chip, pwm);

drivers/pwm/pwm-meson.c

324

err = meson_pwm_calc(chip, pwm, state);

drivers/pwm/pwm-meson.c

328

meson_pwm_enable(chip, pwm);

drivers/pwm/pwm-meson.c

339

static int meson_pwm_get_state(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-meson.c

348

channel_data = &meson_pwm_per_channel_data[pwm->hwpwm];

drivers/pwm/pwm-meson.c

349

fin_freq = clk_get_rate(meson->channels[pwm->hwpwm].clk);

drivers/pwm/pwm-microchip-core.c

148

static void mchp_core_pwm_apply_duty(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-microchip-core.c

178

writel_relaxed(posedge, mchp_core_pwm->base + MCHPCOREPWM_POSEDGE(pwm->hwpwm));

drivers/pwm/pwm-microchip-core.c

179

writel_relaxed(negedge, mchp_core_pwm->base + MCHPCOREPWM_NEGEDGE(pwm->hwpwm));

drivers/pwm/pwm-microchip-core.c

271

static int mchp_core_pwm_apply_locked(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-microchip-core.c

282

mchp_core_pwm_enable(chip, pwm, false, pwm->state.period);

drivers/pwm/pwm-microchip-core.c

308

period_locked = mchp_core_pwm->channel_enabled & ~(1 << pwm->hwpwm);

drivers/pwm/pwm-microchip-core.c

350

mchp_core_pwm_apply_duty(chip, pwm, state, duty_steps, period_steps);

drivers/pwm/pwm-microchip-core.c

352

mchp_core_pwm_enable(chip, pwm, true, pwm->state.period);

drivers/pwm/pwm-microchip-core.c

357

static int mchp_core_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-microchip-core.c

362

mchp_core_pwm_wait_for_sync_update(mchp_core_pwm, pwm->hwpwm);

drivers/pwm/pwm-microchip-core.c

364

return mchp_core_pwm_apply_locked(chip, pwm, state);

drivers/pwm/pwm-microchip-core.c

367

static int mchp_core_pwm_get_state(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-microchip-core.c

375

mchp_core_pwm_wait_for_sync_update(mchp_core_pwm, pwm->hwpwm);

drivers/pwm/pwm-microchip-core.c

377

if (mchp_core_pwm->channel_enabled & (1 << pwm->hwpwm))

drivers/pwm/pwm-microchip-core.c

404

posedge = readb_relaxed(mchp_core_pwm->base + MCHPCOREPWM_POSEDGE(pwm->hwpwm));

drivers/pwm/pwm-microchip-core.c

405

negedge = readb_relaxed(mchp_core_pwm->base + MCHPCOREPWM_NEGEDGE(pwm->hwpwm));

drivers/pwm/pwm-microchip-core.c

68

static void mchp_core_pwm_enable(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-microchip-core.c

79

reg_offset = MCHPCOREPWM_EN(pwm->hwpwm >> 3);

drivers/pwm/pwm-microchip-core.c

80

shift = pwm->hwpwm & 7;

drivers/pwm/pwm-microchip-core.c

87

mchp_core_pwm->channel_enabled &= ~BIT(pwm->hwpwm);

drivers/pwm/pwm-microchip-core.c

88

mchp_core_pwm->channel_enabled |= enable << pwm->hwpwm;

drivers/pwm/pwm-microchip-core.c

95

if (mchp_core_pwm->sync_update_mask & (1 << pwm->hwpwm))

drivers/pwm/pwm-mtk-disp.c

173

struct pwm_device *pwm,

drivers/pwm/pwm-mtk-disp.c

69

static int mtk_disp_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-mxs.c

100

mxs->base + PWM_ACTIVE0 + pwm->hwpwm * 0x20);

drivers/pwm/pwm-mxs.c

102

mxs->base + PWM_PERIOD0 + pwm->hwpwm * 0x20);

drivers/pwm/pwm-mxs.c

105

if (!pwm_is_enabled(pwm)) {

drivers/pwm/pwm-mxs.c

110

writel(1 << pwm->hwpwm, mxs->base + PWM_CTRL + SET);

drivers/pwm/pwm-mxs.c

49

static int mxs_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-mxs.c

64

if (!pwm_is_enabled(pwm)) {

drivers/pwm/pwm-mxs.c

70

if (!state->enabled && pwm_is_enabled(pwm))

drivers/pwm/pwm-mxs.c

71

writel(1 << pwm->hwpwm, mxs->base + PWM_CTRL + CLR);

drivers/pwm/pwm-omap-dmtimer.c

147

struct pwm_device *pwm,

drivers/pwm/pwm-omap-dmtimer.c

159

if (duty_ns == pwm_get_duty_cycle(pwm) &&

drivers/pwm/pwm-omap-dmtimer.c

160

period_ns == pwm_get_period(pwm))

drivers/pwm/pwm-omap-dmtimer.c

242

struct pwm_device *pwm,

drivers/pwm/pwm-omap-dmtimer.c

271

struct pwm_device *pwm,

drivers/pwm/pwm-omap-dmtimer.c

283

pwm_omap_dmtimer_set_polarity(chip, pwm, state->polarity);

drivers/pwm/pwm-omap-dmtimer.c

285

ret = pwm_omap_dmtimer_config(chip, pwm, state->duty_cycle,

drivers/pwm/pwm-pca9685.c

174

static int pca9685_round_waveform_tohw(struct pwm_chip *chip, struct pwm_device *pwm, const struct pwm_waveform *wf, void *_wfhw)

drivers/pwm/pwm-pca9685.c

190

pwm->hwpwm, wf->duty_length_ns, wf->period_length_ns, wf->duty_offset_ns,

drivers/pwm/pwm-pca9685.c

207

if (!pca9685_prescaler_can_change(pca, pwm->hwpwm)) {

drivers/pwm/pwm-pca9685.c

252

pwm->hwpwm, wf->duty_length_ns, wf->period_length_ns, wf->duty_offset_ns,

drivers/pwm/pwm-pca9685.c

258

static int pca9685_round_waveform_fromhw(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-pca9685.c

293

pwm->hwpwm,

drivers/pwm/pwm-pca9685.c

300

static int pca9685_read_waveform(struct pwm_chip *chip, struct pwm_device *pwm, void *_wfhw)

drivers/pwm/pwm-pca9685.c

309

ret = regmap_bulk_read(pca->regmap, REG_ON_L(pwm->hwpwm), &wfhw->onoff, 4);

drivers/pwm/pwm-pca9685.c

322

static int pca9685_write_waveform(struct pwm_chip *chip, struct pwm_device *pwm, const void *_wfhw)

drivers/pwm/pwm-pca9685.c

337

if (!pca9685_prescaler_can_change(pca, pwm->hwpwm))

drivers/pwm/pwm-pca9685.c

357

return regmap_bulk_write(pca->regmap, REG_ON_L(pwm->hwpwm), &wfhw->onoff, 4);

drivers/pwm/pwm-pca9685.c

360

static int pca9685_pwm_request(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-pca9685.c

364

if (pwm->hwpwm < PCA9685_MAXCHAN) {

drivers/pwm/pwm-pca9685.c

367

set_bit(pwm->hwpwm, pca->pwms_enabled);

drivers/pwm/pwm-pca9685.c

376

static void pca9685_pwm_free(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-pca9685.c

381

clear_bit(pwm->hwpwm, pca->pwms_enabled);

drivers/pwm/pwm-pxa.c

102

static int pxa_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-pxa.c

118

err = pxa_pwm_config(chip, pwm, duty_cycle, state->period);

drivers/pwm/pwm-pxa.c

124

if (state->enabled && !pwm->state.enabled)

drivers/pwm/pwm-pxa.c

129

if (!state->enabled && pwm->state.enabled)

drivers/pwm/pwm-pxa.c

67

static int pxa_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-pxa.c

75

offset = pwm->hwpwm ? 0x10 : 0;

drivers/pwm/pwm-raspberrypi-poe.c

85

struct pwm_device *pwm,

drivers/pwm/pwm-raspberrypi-poe.c

99

static int raspberrypi_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-rcar.c

134

static int rcar_pwm_request(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-rcar.c

139

static void rcar_pwm_free(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-rcar.c

164

static int rcar_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-renesas-tpu.c

212

static int tpu_pwm_request(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-renesas-tpu.c

217

if (pwm->hwpwm >= TPU_CHANNEL_MAX)

drivers/pwm/pwm-renesas-tpu.c

220

tpd = &tpu->tpd[pwm->hwpwm];

drivers/pwm/pwm-renesas-tpu.c

223

tpd->channel = pwm->hwpwm;

drivers/pwm/pwm-renesas-tpu.c

234

static void tpu_pwm_free(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-renesas-tpu.c

237

struct tpu_pwm_device *tpd = &tpu->tpd[pwm->hwpwm];

drivers/pwm/pwm-renesas-tpu.c

242

static int tpu_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-renesas-tpu.c

246

struct tpu_pwm_device *tpd = &tpu->tpd[pwm->hwpwm];

drivers/pwm/pwm-renesas-tpu.c

351

static int tpu_pwm_set_polarity(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-renesas-tpu.c

355

struct tpu_pwm_device *tpd = &tpu->tpd[pwm->hwpwm];

drivers/pwm/pwm-renesas-tpu.c

362

static int tpu_pwm_enable(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-renesas-tpu.c

365

struct tpu_pwm_device *tpd = &tpu->tpd[pwm->hwpwm];

drivers/pwm/pwm-renesas-tpu.c

385

static void tpu_pwm_disable(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-renesas-tpu.c

388

struct tpu_pwm_device *tpd = &tpu->tpd[pwm->hwpwm];

drivers/pwm/pwm-renesas-tpu.c

396

static int tpu_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-renesas-tpu.c

400

bool enabled = pwm->state.enabled;

drivers/pwm/pwm-renesas-tpu.c

402

if (state->polarity != pwm->state.polarity) {

drivers/pwm/pwm-renesas-tpu.c

404

tpu_pwm_disable(chip, pwm);

drivers/pwm/pwm-renesas-tpu.c

408

err = tpu_pwm_set_polarity(chip, pwm, state->polarity);

drivers/pwm/pwm-renesas-tpu.c

415

tpu_pwm_disable(chip, pwm);

drivers/pwm/pwm-renesas-tpu.c

420

err = tpu_pwm_config(chip, pwm,

drivers/pwm/pwm-renesas-tpu.c

426

err = tpu_pwm_enable(chip, pwm);

drivers/pwm/pwm-rockchip.c

105

static void rockchip_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-rockchip.c

164

struct pwm_device *pwm,

drivers/pwm/pwm-rockchip.c

193

static int rockchip_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-rockchip.c

209

pwm_get_state(pwm, &curstate);

drivers/pwm/pwm-rockchip.c

214

ret = rockchip_pwm_enable(chip, pwm, false);

drivers/pwm/pwm-rockchip.c

220

rockchip_pwm_config(chip, pwm, state);

drivers/pwm/pwm-rockchip.c

222

ret = rockchip_pwm_enable(chip, pwm, state->enabled);

drivers/pwm/pwm-rockchip.c

62

struct pwm_device *pwm,

drivers/pwm/pwm-rz-mtu3.c

165

static int rz_mtu3_pwm_request(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-rz-mtu3.c

172

priv = rz_mtu3_get_channel(rz_mtu3_pwm, pwm->hwpwm);

drivers/pwm/pwm-rz-mtu3.c

195

static void rz_mtu3_pwm_free(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-rz-mtu3.c

201

priv = rz_mtu3_get_channel(rz_mtu3_pwm, pwm->hwpwm);

drivers/pwm/pwm-rz-mtu3.c

212

static int rz_mtu3_pwm_enable(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-rz-mtu3.c

224

priv = rz_mtu3_get_channel(rz_mtu3_pwm, pwm->hwpwm);

drivers/pwm/pwm-rz-mtu3.c

229

if (priv->map->base_pwm_number == pwm->hwpwm)

drivers/pwm/pwm-rz-mtu3.c

244

static void rz_mtu3_pwm_disable(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-rz-mtu3.c

250

priv = rz_mtu3_get_channel(rz_mtu3_pwm, pwm->hwpwm);

drivers/pwm/pwm-rz-mtu3.c

254

if (priv->map->base_pwm_number == pwm->hwpwm)

drivers/pwm/pwm-rz-mtu3.c

269

static int rz_mtu3_pwm_get_state(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-rz-mtu3.c

279

state->enabled = rz_mtu3_pwm_is_ch_enabled(rz_mtu3_pwm, pwm->hwpwm);

drivers/pwm/pwm-rz-mtu3.c

286

priv = rz_mtu3_get_channel(rz_mtu3_pwm, pwm->hwpwm);

drivers/pwm/pwm-rz-mtu3.c

287

if (priv->map->base_pwm_number == pwm->hwpwm)

drivers/pwm/pwm-rz-mtu3.c

318

static int rz_mtu3_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-rz-mtu3.c

330

priv = rz_mtu3_get_channel(rz_mtu3_pwm, pwm->hwpwm);

drivers/pwm/pwm-rz-mtu3.c

360

if (!pwm->state.enabled) {

drivers/pwm/pwm-rz-mtu3.c

374

if (priv->map->base_pwm_number == pwm->hwpwm) {

drivers/pwm/pwm-rz-mtu3.c

399

if (!pwm->state.enabled)

drivers/pwm/pwm-rz-mtu3.c

405

static int rz_mtu3_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-rz-mtu3.c

409

bool enabled = pwm->state.enabled;

drivers/pwm/pwm-rz-mtu3.c

417

rz_mtu3_pwm_disable(chip, pwm);

drivers/pwm/pwm-rz-mtu3.c

423

ret = rz_mtu3_pwm_config(chip, pwm, state);

drivers/pwm/pwm-rz-mtu3.c

429

ret = rz_mtu3_pwm_enable(chip, pwm);

drivers/pwm/pwm-rzg2l-gpt.c

136

static int rzg2l_gpt_request(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-rzg2l-gpt.c

139

u32 ch = RZG2L_GET_CH(pwm->hwpwm);

drivers/pwm/pwm-rzg2l-gpt.c

147

static void rzg2l_gpt_free(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-rzg2l-gpt.c

150

u32 ch = RZG2L_GET_CH(pwm->hwpwm);

drivers/pwm/pwm-rzg2l-gpt.c

172

struct pwm_device *pwm)

drivers/pwm/pwm-rzg2l-gpt.c

174

u8 sub_ch = rzg2l_gpt_subchannel(pwm->hwpwm);

drivers/pwm/pwm-rzg2l-gpt.c

176

u8 ch = RZG2L_GET_CH(pwm->hwpwm);

drivers/pwm/pwm-rzg2l-gpt.c

190

struct pwm_device *pwm)

drivers/pwm/pwm-rzg2l-gpt.c

192

u8 sub_ch = rzg2l_gpt_subchannel(pwm->hwpwm);

drivers/pwm/pwm-rzg2l-gpt.c

193

u8 ch = RZG2L_GET_CH(pwm->hwpwm);

drivers/pwm/pwm-rzg2l-gpt.c

223

static int rzg2l_gpt_get_state(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-rzg2l-gpt.c

228

state->enabled = rzg2l_gpt_is_ch_enabled(rzg2l_gpt, pwm->hwpwm);

drivers/pwm/pwm-rzg2l-gpt.c

230

u32 sub_ch = rzg2l_gpt_subchannel(pwm->hwpwm);

drivers/pwm/pwm-rzg2l-gpt.c

231

u32 ch = RZG2L_GET_CH(pwm->hwpwm);

drivers/pwm/pwm-rzg2l-gpt.c

259

static int rzg2l_gpt_config(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-rzg2l-gpt.c

263

u8 sub_ch = rzg2l_gpt_subchannel(pwm->hwpwm);

drivers/pwm/pwm-rzg2l-gpt.c

264

u8 ch = RZG2L_GET_CH(pwm->hwpwm);

drivers/pwm/pwm-rzg2l-gpt.c

279

u8 sibling_ch = rzg2l_gpt_sibling(pwm->hwpwm);

drivers/pwm/pwm-rzg2l-gpt.c

346

static int rzg2l_gpt_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-rzg2l-gpt.c

350

bool enabled = pwm->state.enabled;

drivers/pwm/pwm-rzg2l-gpt.c

359

rzg2l_gpt_disable(rzg2l_gpt, pwm);

drivers/pwm/pwm-rzg2l-gpt.c

364

ret = rzg2l_gpt_config(chip, pwm, state);

drivers/pwm/pwm-rzg2l-gpt.c

366

rzg2l_gpt_enable(rzg2l_gpt, pwm);

drivers/pwm/pwm-samsung.c

121

struct pwm_device *pwm)

drivers/pwm/pwm-samsung.c

123

unsigned int tcon_chan = to_tcon_channel(pwm->hwpwm);

drivers/pwm/pwm-samsung.c

229

static int pwm_samsung_request(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-samsung.c

233

if (!(our_chip->variant.output_mask & BIT(pwm->hwpwm))) {

drivers/pwm/pwm-samsung.c

236

pwm->hwpwm);

drivers/pwm/pwm-samsung.c

240

memset(&our_chip->channel[pwm->hwpwm], 0, sizeof(our_chip->channel[pwm->hwpwm]));

drivers/pwm/pwm-samsung.c

245

static int pwm_samsung_enable(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-samsung.c

248

unsigned int tcon_chan = to_tcon_channel(pwm->hwpwm);

drivers/pwm/pwm-samsung.c

264

our_chip->disabled_mask &= ~BIT(pwm->hwpwm);

drivers/pwm/pwm-samsung.c

271

static void pwm_samsung_disable(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-samsung.c

274

unsigned int tcon_chan = to_tcon_channel(pwm->hwpwm);

drivers/pwm/pwm-samsung.c

288

if (readl(our_chip->base + REG_TCMPB(pwm->hwpwm)) == (u32)-1U)

drivers/pwm/pwm-samsung.c

289

__pwm_samsung_manual_update(our_chip, pwm);

drivers/pwm/pwm-samsung.c

291

our_chip->disabled_mask |= BIT(pwm->hwpwm);

drivers/pwm/pwm-samsung.c

297

struct pwm_device *pwm)

drivers/pwm/pwm-samsung.c

303

__pwm_samsung_manual_update(our_chip, pwm);

drivers/pwm/pwm-samsung.c

308

static int __pwm_samsung_config(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-samsung.c

312

struct samsung_pwm_channel *chan = &our_chip->channel[pwm->hwpwm];

drivers/pwm/pwm-samsung.c

315

tcnt = readl(our_chip->base + REG_TCNTB(pwm->hwpwm));

drivers/pwm/pwm-samsung.c

316

oldtcmp = readl(our_chip->base + REG_TCMPB(pwm->hwpwm));

drivers/pwm/pwm-samsung.c

331

tin_rate = pwm_samsung_calc_tin(chip, pwm->hwpwm, period);

drivers/pwm/pwm-samsung.c

360

writel(tcnt, our_chip->base + REG_TCNTB(pwm->hwpwm));

drivers/pwm/pwm-samsung.c

361

writel(tcmp, our_chip->base + REG_TCMPB(pwm->hwpwm));

drivers/pwm/pwm-samsung.c

370

pwm_samsung_manual_update(our_chip, pwm);

drivers/pwm/pwm-samsung.c

380

static int pwm_samsung_config(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-samsung.c

383

return __pwm_samsung_config(chip, pwm, duty_ns, period_ns, false);

drivers/pwm/pwm-samsung.c

411

struct pwm_device *pwm,

drivers/pwm/pwm-samsung.c

418

pwm_samsung_set_invert(our_chip, pwm->hwpwm, invert);

drivers/pwm/pwm-samsung.c

423

static int pwm_samsung_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-samsung.c

426

int err, enabled = pwm->state.enabled;

drivers/pwm/pwm-samsung.c

428

if (state->polarity != pwm->state.polarity) {

drivers/pwm/pwm-samsung.c

430

pwm_samsung_disable(chip, pwm);

drivers/pwm/pwm-samsung.c

434

err = pwm_samsung_set_polarity(chip, pwm, state->polarity);

drivers/pwm/pwm-samsung.c

441

pwm_samsung_disable(chip, pwm);

drivers/pwm/pwm-samsung.c

454

err = pwm_samsung_config(chip, pwm, state->duty_cycle, state->period);

drivers/pwm/pwm-samsung.c

458

if (!pwm->state.enabled)

drivers/pwm/pwm-samsung.c

459

err = pwm_samsung_enable(chip, pwm);

drivers/pwm/pwm-samsung.c

607

struct pwm_device *pwm = &chip->pwms[i];

drivers/pwm/pwm-samsung.c

610

if (!test_bit(PWMF_REQUESTED, &pwm->flags))

drivers/pwm/pwm-samsung.c

618

__pwm_samsung_config(chip, pwm, chan->duty_ns,

drivers/pwm/pwm-samsung.c

621

pwm_samsung_manual_update(our_chip, pwm);

drivers/pwm/pwm-samsung.c

625

pwm_samsung_disable(chip, pwm);

drivers/pwm/pwm-samsung.c

627

pwm_samsung_enable(chip, pwm);

drivers/pwm/pwm-sifive.c

125

static int pwm_sifive_get_state(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-sifive.c

131

inactive = readl(ddata->regs + PWM_SIFIVE_PWMCMP(pwm->hwpwm));

drivers/pwm/pwm-sifive.c

152

static int pwm_sifive_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-sifive.c

167

cur_state = pwm->state;

drivers/pwm/pwm-sifive.c

218

writel(inactive, ddata->regs + PWM_SIFIVE_PWMCMP(pwm->hwpwm));

drivers/pwm/pwm-sifive.c

343

struct pwm_device *pwm;

drivers/pwm/pwm-sifive.c

350

pwm = &chip->pwms[ch];

drivers/pwm/pwm-sifive.c

351

if (pwm->state.enabled)

drivers/pwm/pwm-sifive.c

76

static int pwm_sifive_request(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-sifive.c

87

static void pwm_sifive_free(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-sl28cpld.c

124

static int sl28cpld_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-sl28cpld.c

177

write_duty_cycle_first = pwm->state.period > state->period;

drivers/pwm/pwm-sl28cpld.c

93

struct pwm_device *pwm,

drivers/pwm/pwm-sophgo-sg2042.c

107

pwm_sg2042_config(ddata, pwm->hwpwm, 0, 0);

drivers/pwm/pwm-sophgo-sg2042.c

111

pwm_sg2042_set_dutycycle(chip, pwm, state);

drivers/pwm/pwm-sophgo-sg2042.c

116

static int pwm_sg2042_get_state(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-sophgo-sg2042.c

120

unsigned int chan = pwm->hwpwm;

drivers/pwm/pwm-sophgo-sg2042.c

143

static void pwm_sg2044_set_outputen(struct sg2042_pwm_ddata *ddata, struct pwm_device *pwm,

drivers/pwm/pwm-sophgo-sg2042.c

151

pwmstart |= BIT(pwm->hwpwm);

drivers/pwm/pwm-sophgo-sg2042.c

153

pwmstart &= ~BIT(pwm->hwpwm);

drivers/pwm/pwm-sophgo-sg2042.c

158

static void pwm_sg2044_set_outputdir(struct sg2042_pwm_ddata *ddata, struct pwm_device *pwm,

drivers/pwm/pwm-sophgo-sg2042.c

166

pwm_oe |= BIT(pwm->hwpwm);

drivers/pwm/pwm-sophgo-sg2042.c

168

pwm_oe &= ~BIT(pwm->hwpwm);

drivers/pwm/pwm-sophgo-sg2042.c

173

static void pwm_sg2044_set_polarity(struct sg2042_pwm_ddata *ddata, struct pwm_device *pwm,

drivers/pwm/pwm-sophgo-sg2042.c

181

pwm_polarity &= ~BIT(pwm->hwpwm);

drivers/pwm/pwm-sophgo-sg2042.c

183

pwm_polarity |= BIT(pwm->hwpwm);

drivers/pwm/pwm-sophgo-sg2042.c

188

static int pwm_sg2044_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-sophgo-sg2042.c

193

pwm_sg2044_set_polarity(ddata, pwm, state);

drivers/pwm/pwm-sophgo-sg2042.c

195

pwm_sg2042_set_dutycycle(chip, pwm, state);

drivers/pwm/pwm-sophgo-sg2042.c

200

pwm_sg2044_set_outputen(ddata, pwm, false);

drivers/pwm/pwm-sophgo-sg2042.c

205

pwm_sg2044_set_outputdir(ddata, pwm, true);

drivers/pwm/pwm-sophgo-sg2042.c

206

pwm_sg2044_set_outputen(ddata, pwm, true);

drivers/pwm/pwm-sophgo-sg2042.c

78

static void pwm_sg2042_set_dutycycle(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-sophgo-sg2042.c

93

pwm->hwpwm, state->enabled, period_ticks, hlperiod_ticks, state->polarity);

drivers/pwm/pwm-sophgo-sg2042.c

95

pwm_sg2042_config(ddata, pwm->hwpwm, period_ticks, hlperiod_ticks);

drivers/pwm/pwm-sophgo-sg2042.c

98

static int pwm_sg2042_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-spear.c

126

spear_pwm_writel(pc, pwm->hwpwm, PWMCR,

drivers/pwm/pwm-spear.c

128

spear_pwm_writel(pc, pwm->hwpwm, PWMDCR, dc);

drivers/pwm/pwm-spear.c

129

spear_pwm_writel(pc, pwm->hwpwm, PWMPCR, pv);

drivers/pwm/pwm-spear.c

135

static int spear_pwm_enable(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-spear.c

145

val = spear_pwm_readl(pc, pwm->hwpwm, PWMCR);

drivers/pwm/pwm-spear.c

147

spear_pwm_writel(pc, pwm->hwpwm, PWMCR, val);

drivers/pwm/pwm-spear.c

152

static void spear_pwm_disable(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-spear.c

157

val = spear_pwm_readl(pc, pwm->hwpwm, PWMCR);

drivers/pwm/pwm-spear.c

159

spear_pwm_writel(pc, pwm->hwpwm, PWMCR, val);

drivers/pwm/pwm-spear.c

164

static int spear_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-spear.c

173

if (pwm->state.enabled)

drivers/pwm/pwm-spear.c

174

spear_pwm_disable(chip, pwm);

drivers/pwm/pwm-spear.c

178

err = spear_pwm_config(chip, pwm, state->duty_cycle, state->period);

drivers/pwm/pwm-spear.c

182

if (!pwm->state.enabled)

drivers/pwm/pwm-spear.c

183

return spear_pwm_enable(chip, pwm);

drivers/pwm/pwm-spear.c

75

static int spear_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-sprd.c

104

val = sprd_pwm_read(spc, pwm->hwpwm, SPRD_PWM_PRESCALE);

drivers/pwm/pwm-sprd.c

109

val = sprd_pwm_read(spc, pwm->hwpwm, SPRD_PWM_DUTY);

drivers/pwm/pwm-sprd.c

122

static int sprd_pwm_config(struct sprd_pwm_chip *spc, struct pwm_device *pwm,

drivers/pwm/pwm-sprd.c

125

struct sprd_pwm_chn *chn = &spc->chn[pwm->hwpwm];

drivers/pwm/pwm-sprd.c

155

sprd_pwm_write(spc, pwm->hwpwm, SPRD_PWM_PRESCALE, prescale);

drivers/pwm/pwm-sprd.c

156

sprd_pwm_write(spc, pwm->hwpwm, SPRD_PWM_MOD, SPRD_PWM_MOD_MAX);

drivers/pwm/pwm-sprd.c

157

sprd_pwm_write(spc, pwm->hwpwm, SPRD_PWM_DUTY, duty);

drivers/pwm/pwm-sprd.c

162

static int sprd_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-sprd.c

166

struct sprd_pwm_chn *chn = &spc->chn[pwm->hwpwm];

drivers/pwm/pwm-sprd.c

167

struct pwm_state *cstate = &pwm->state;

drivers/pwm/pwm-sprd.c

184

pwm->hwpwm);

drivers/pwm/pwm-sprd.c

189

ret = sprd_pwm_config(spc, pwm, state->duty_cycle,

drivers/pwm/pwm-sprd.c

194

sprd_pwm_write(spc, pwm->hwpwm, SPRD_PWM_ENABLE, 1);

drivers/pwm/pwm-sprd.c

201

sprd_pwm_write(spc, pwm->hwpwm, SPRD_PWM_ENABLE, 0);

drivers/pwm/pwm-sprd.c

70

static int sprd_pwm_get_state(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-sprd.c

74

struct sprd_pwm_chn *chn = &spc->chn[pwm->hwpwm];

drivers/pwm/pwm-sprd.c

86

pwm->hwpwm);

drivers/pwm/pwm-sprd.c

90

val = sprd_pwm_read(spc, pwm->hwpwm, SPRD_PWM_ENABLE);

drivers/pwm/pwm-sti.c

156

static int sti_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-sti.c

183

((ncfg == 1) && (pwm->hwpwm == cur->hwpwm)) ||

drivers/pwm/pwm-sti.c

184

((ncfg == 1) && (pwm->hwpwm != cur->hwpwm) && period_same) ||

drivers/pwm/pwm-sti.c

221

ret = regmap_write(pc->regmap, PWM_OUT_VAL(pwm->hwpwm), value);

drivers/pwm/pwm-sti.c

227

set_bit(pwm->hwpwm, &pc->configured);

drivers/pwm/pwm-sti.c

228

pc->cur = pwm;

drivers/pwm/pwm-sti.c

242

static int sti_pwm_enable(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-sti.c

265

pwm->hwpwm, ret);

drivers/pwm/pwm-sti.c

275

static void sti_pwm_disable(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-sti.c

288

static void sti_pwm_free(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-sti.c

292

clear_bit(pwm->hwpwm, &pc->configured);

drivers/pwm/pwm-sti.c

295

static int sti_pwm_capture(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-sti.c

299

struct sti_cpt_ddata *ddata = &pc->ddata[pwm->hwpwm];

drivers/pwm/pwm-sti.c

305

if (pwm->hwpwm >= pc->cpt_num_devs) {

drivers/pwm/pwm-sti.c

306

dev_err(dev, "device %u is not valid\n", pwm->hwpwm);

drivers/pwm/pwm-sti.c

314

regmap_write(pc->regmap, PWM_CPT_EDGE(pwm->hwpwm), CPT_EDGE_RISING);

drivers/pwm/pwm-sti.c

315

regmap_field_write(pc->pwm_cpt_int_en, BIT(pwm->hwpwm));

drivers/pwm/pwm-sti.c

321

pwm->hwpwm, ret);

drivers/pwm/pwm-sti.c

328

regmap_write(pc->regmap, PWM_CPT_EDGE(pwm->hwpwm), CPT_EDGE_DISABLED);

drivers/pwm/pwm-sti.c

376

static int sti_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-sti.c

383

if (pwm->hwpwm >= pc->pwm_num_devs) {

drivers/pwm/pwm-sti.c

385

pwm->hwpwm);

drivers/pwm/pwm-sti.c

393

if (pwm->state.enabled)

drivers/pwm/pwm-sti.c

394

sti_pwm_disable(chip, pwm);

drivers/pwm/pwm-sti.c

399

err = sti_pwm_config(chip, pwm, state->duty_cycle, state->period);

drivers/pwm/pwm-sti.c

403

if (!pwm->state.enabled)

drivers/pwm/pwm-sti.c

404

err = sti_pwm_enable(chip, pwm);

drivers/pwm/pwm-stm32-lp.c

122

static int stm32_pwm_lp_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-stm32-lp.c

132

pwm_get_state(pwm, &cstate);

drivers/pwm/pwm-stm32-lp.c

138

ret = stm32_pwm_lp_compare_channel_apply(priv, pwm->hwpwm, false,

drivers/pwm/pwm-stm32-lp.c

142

ret = regmap_write(priv->regmap, pwm->hwpwm ?

drivers/pwm/pwm-stm32-lp.c

148

ret = stm32_pwm_lp_update_allowed(priv, pwm->hwpwm);

drivers/pwm/pwm-stm32-lp.c

197

if (!stm32_pwm_lp_update_allowed(priv, pwm->hwpwm)) {

drivers/pwm/pwm-stm32-lp.c

253

ret = regmap_write(priv->regmap, pwm->hwpwm ? STM32_LPTIM_CCR2 : STM32_LPTIM_CMP,

drivers/pwm/pwm-stm32-lp.c

259

ret = regmap_read_poll_timeout(priv->regmap, STM32_LPTIM_ISR, val, pwm->hwpwm ?

drivers/pwm/pwm-stm32-lp.c

267

ret = regmap_write(priv->regmap, STM32_LPTIM_ICR, pwm->hwpwm ?

drivers/pwm/pwm-stm32-lp.c

272

ret = stm32_pwm_lp_compare_channel_apply(priv, pwm->hwpwm, true, state->polarity);

drivers/pwm/pwm-stm32-lp.c

295

struct pwm_device *pwm,

drivers/pwm/pwm-stm32-lp.c

309

if (pwm->hwpwm)

drivers/pwm/pwm-stm32-lp.c

327

if (pwm->hwpwm)

drivers/pwm/pwm-stm32-lp.c

340

regmap_read(priv->regmap, pwm->hwpwm ? STM32_LPTIM_CCR2 : STM32_LPTIM_CMP, &val);

drivers/pwm/pwm-stm32.c

188

pwm->hwpwm, wf->duty_length_ns, wf->period_length_ns, wf->duty_offset_ns,

drivers/pwm/pwm-stm32.c

197

struct pwm_device *pwm,

drivers/pwm/pwm-stm32.c

204

unsigned int ch = pwm->hwpwm;

drivers/pwm/pwm-stm32.c

232

pwm->hwpwm, wfhw->ccer, wfhw->psc, wfhw->arr, wfhw->ccr, rate,

drivers/pwm/pwm-stm32.c

239

struct pwm_device *pwm,

drivers/pwm/pwm-stm32.c

244

unsigned int ch = pwm->hwpwm;

drivers/pwm/pwm-stm32.c

282

struct pwm_device *pwm,

drivers/pwm/pwm-stm32.c

287

unsigned int ch = pwm->hwpwm;

drivers/pwm/pwm-stm32.c

456

static int stm32_pwm_raw_capture(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-stm32.c

471

dma_id = pwm->hwpwm < 2 ? STM32_TIMERS_DMA_CH1 : STM32_TIMERS_DMA_CH3;

drivers/pwm/pwm-stm32.c

472

ccen = pwm->hwpwm < 2 ? TIM_CCER_CC12E : TIM_CCER_CC34E;

drivers/pwm/pwm-stm32.c

473

ccr = pwm->hwpwm < 2 ? TIM_CCR1 : TIM_CCR3;

drivers/pwm/pwm-stm32.c

494

if (pwm->chip->npwm < 2)

drivers/pwm/pwm-stm32.c

518

static int stm32_pwm_capture(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-stm32.c

565

pwm->hwpwm < 2 ? TIM_CCMR1 : TIM_CCMR2,

drivers/pwm/pwm-stm32.c

566

TIM_CCMR_CC1S | TIM_CCMR_CC2S, pwm->hwpwm & 0x1 ?

drivers/pwm/pwm-stm32.c

571

regmap_update_bits(priv->regmap, TIM_CCER, pwm->hwpwm < 2 ?

drivers/pwm/pwm-stm32.c

572

TIM_CCER_CC12P : TIM_CCER_CC34P, pwm->hwpwm < 2 ?

drivers/pwm/pwm-stm32.c

575

ret = stm32_pwm_raw_capture(chip, pwm, tmo_ms, &raw_prd, &raw_dty);

drivers/pwm/pwm-stm32.c

596

ret = stm32_pwm_raw_capture(chip, pwm, tmo_ms, &raw_prd,

drivers/pwm/pwm-stm32.c

619

pwm->hwpwm < 2 ? TIM_CCMR1 : TIM_CCMR2,

drivers/pwm/pwm-stm32.c

624

ret = stm32_pwm_raw_capture(chip, pwm, tmo_ms, &raw_prd, &raw_dty);

drivers/pwm/pwm-stm32.c

63

struct pwm_device *pwm,

drivers/pwm/pwm-stm32.c

665

regmap_write(priv->regmap, pwm->hwpwm < 2 ? TIM_CCMR1 : TIM_CCMR2, 0);

drivers/pwm/pwm-stm32.c

69

unsigned int ch = pwm->hwpwm;

drivers/pwm/pwm-stmpe.c

111

if (pwm_is_enabled(pwm)) {

drivers/pwm/pwm-stmpe.c

112

ret = stmpe_24xx_pwm_disable(chip, pwm);

drivers/pwm/pwm-stmpe.c

117

pin = pwm->hwpwm;

drivers/pwm/pwm-stmpe.c

128

pwm->hwpwm);

drivers/pwm/pwm-stmpe.c

134

switch (pwm->hwpwm) {

drivers/pwm/pwm-stmpe.c

153

pwm->hwpwm, duty_ns, period_ns);

drivers/pwm/pwm-stmpe.c

192

if (pwm_is_enabled(pwm))

drivers/pwm/pwm-stmpe.c

193

stmpe_24xx_pwm_enable(chip, pwm);

drivers/pwm/pwm-stmpe.c

220

pwm->hwpwm, value, last, program[0], program[1],

drivers/pwm/pwm-stmpe.c

251

if (pwm_is_enabled(pwm))

drivers/pwm/pwm-stmpe.c

252

stmpe_24xx_pwm_enable(chip, pwm);

drivers/pwm/pwm-stmpe.c

257

dev_dbg(pwmchip_parent(chip), "programmed PWM#%u, %u bytes\n", pwm->hwpwm, i);

drivers/pwm/pwm-stmpe.c

262

static int stmpe_24xx_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-stmpe.c

271

if (pwm->state.enabled)

drivers/pwm/pwm-stmpe.c

272

return stmpe_24xx_pwm_disable(chip, pwm);

drivers/pwm/pwm-stmpe.c

277

err = stmpe_24xx_pwm_config(chip, pwm, state->duty_cycle, state->period);

drivers/pwm/pwm-stmpe.c

281

if (!pwm->state.enabled)

drivers/pwm/pwm-stmpe.c

282

err = stmpe_24xx_pwm_enable(chip, pwm);

drivers/pwm/pwm-stmpe.c

38

static int stmpe_24xx_pwm_enable(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-stmpe.c

47

pwm->hwpwm);

drivers/pwm/pwm-stmpe.c

51

value = ret | BIT(pwm->hwpwm);

drivers/pwm/pwm-stmpe.c

56

pwm->hwpwm);

drivers/pwm/pwm-stmpe.c

64

struct pwm_device *pwm)

drivers/pwm/pwm-stmpe.c

73

pwm->hwpwm);

drivers/pwm/pwm-stmpe.c

77

value = ret & ~BIT(pwm->hwpwm);

drivers/pwm/pwm-stmpe.c

82

pwm->hwpwm);

drivers/pwm/pwm-stmpe.c

97

static int stmpe_24xx_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-sun4i.c

108

struct pwm_device *pwm,

drivers/pwm/pwm-sun4i.c

127

if ((val & BIT_CH(PWM_BYPASS, pwm->hwpwm)) &&

drivers/pwm/pwm-sun4i.c

136

if ((PWM_REG_PRESCAL(val, pwm->hwpwm) == PWM_PRESCAL_MASK) &&

drivers/pwm/pwm-sun4i.c

140

prescaler = prescaler_table[PWM_REG_PRESCAL(val, pwm->hwpwm)];

drivers/pwm/pwm-sun4i.c

145

if (val & BIT_CH(PWM_ACT_STATE, pwm->hwpwm))

drivers/pwm/pwm-sun4i.c

150

if ((val & BIT_CH(PWM_CLK_GATING | PWM_EN, pwm->hwpwm)) ==

drivers/pwm/pwm-sun4i.c

151

BIT_CH(PWM_CLK_GATING | PWM_EN, pwm->hwpwm))

drivers/pwm/pwm-sun4i.c

156

val = sun4i_pwm_readl(sun4ichip, PWM_CH_PRD(pwm->hwpwm));

drivers/pwm/pwm-sun4i.c

230

static int sun4i_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-sun4i.c

240

pwm_get_state(pwm, &cstate);

drivers/pwm/pwm-sun4i.c

263

ctrl |= BIT_CH(PWM_BYPASS, pwm->hwpwm);

drivers/pwm/pwm-sun4i.c

269

ctrl &= ~BIT_CH(PWM_BYPASS, pwm->hwpwm);

drivers/pwm/pwm-sun4i.c

272

if (PWM_REG_PRESCAL(ctrl, pwm->hwpwm) != prescaler) {

drivers/pwm/pwm-sun4i.c

274

ctrl &= ~BIT_CH(PWM_CLK_GATING, pwm->hwpwm);

drivers/pwm/pwm-sun4i.c

277

ctrl &= ~BIT_CH(PWM_PRESCAL_MASK, pwm->hwpwm);

drivers/pwm/pwm-sun4i.c

278

ctrl |= BIT_CH(prescaler, pwm->hwpwm);

drivers/pwm/pwm-sun4i.c

282

sun4i_pwm_writel(sun4ichip, val, PWM_CH_PRD(pwm->hwpwm));

drivers/pwm/pwm-sun4i.c

285

ctrl &= ~BIT_CH(PWM_ACT_STATE, pwm->hwpwm);

drivers/pwm/pwm-sun4i.c

287

ctrl |= BIT_CH(PWM_ACT_STATE, pwm->hwpwm);

drivers/pwm/pwm-sun4i.c

289

ctrl |= BIT_CH(PWM_CLK_GATING, pwm->hwpwm);

drivers/pwm/pwm-sun4i.c

292

ctrl |= BIT_CH(PWM_EN, pwm->hwpwm);

drivers/pwm/pwm-sun4i.c

307

ctrl &= ~BIT_CH(PWM_CLK_GATING, pwm->hwpwm);

drivers/pwm/pwm-sun4i.c

308

ctrl &= ~BIT_CH(PWM_EN, pwm->hwpwm);

drivers/pwm/pwm-sunplus.c

103

mode0 |= SP7021_PWM_MODE0_PWMEN(pwm->hwpwm);

drivers/pwm/pwm-sunplus.c

105

mode1 |= SP7021_PWM_MODE1_CNT_EN(pwm->hwpwm);

drivers/pwm/pwm-sunplus.c

108

mode0 |= SP7021_PWM_MODE0_BYPASS(pwm->hwpwm);

drivers/pwm/pwm-sunplus.c

109

duty = SP7021_PWM_DUTY_DD_SEL(pwm->hwpwm) | SP7021_PWM_DUTY_MAX;

drivers/pwm/pwm-sunplus.c

111

mode0 &= ~SP7021_PWM_MODE0_BYPASS(pwm->hwpwm);

drivers/pwm/pwm-sunplus.c

117

duty = SP7021_PWM_DUTY_DD_SEL(pwm->hwpwm) | duty;

drivers/pwm/pwm-sunplus.c

119

writel(duty, priv->base + SP7021_PWM_DUTY(pwm->hwpwm));

drivers/pwm/pwm-sunplus.c

126

static int sunplus_pwm_get_state(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-sunplus.c

135

if (mode0 & BIT(pwm->hwpwm)) {

drivers/pwm/pwm-sunplus.c

137

dd_freq = readl(priv->base + SP7021_PWM_FREQ(pwm->hwpwm));

drivers/pwm/pwm-sunplus.c

138

duty = readl(priv->base + SP7021_PWM_DUTY(pwm->hwpwm));

drivers/pwm/pwm-sunplus.c

54

static int sunplus_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-sunplus.c

61

if (state->polarity != pwm->state.polarity)

drivers/pwm/pwm-sunplus.c

67

mode0 &= ~SP7021_PWM_MODE0_PWMEN(pwm->hwpwm);

drivers/pwm/pwm-sunplus.c

71

mode1 &= ~SP7021_PWM_MODE1_CNT_EN(pwm->hwpwm);

drivers/pwm/pwm-sunplus.c

99

writel(dd_freq, priv->base + SP7021_PWM_FREQ(pwm->hwpwm));

drivers/pwm/pwm-tegra.c

193

if (!pwm_is_enabled(pwm)) {

drivers/pwm/pwm-tegra.c

200

pwm_writel(pc, pwm->hwpwm, val);

drivers/pwm/pwm-tegra.c

205

if (!pwm_is_enabled(pwm))

drivers/pwm/pwm-tegra.c

211

static int tegra_pwm_enable(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-tegra.c

221

val = pwm_readl(pc, pwm->hwpwm);

drivers/pwm/pwm-tegra.c

223

pwm_writel(pc, pwm->hwpwm, val);

drivers/pwm/pwm-tegra.c

228

static void tegra_pwm_disable(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-tegra.c

233

val = pwm_readl(pc, pwm->hwpwm);

drivers/pwm/pwm-tegra.c

235

pwm_writel(pc, pwm->hwpwm, val);

drivers/pwm/pwm-tegra.c

240

static int tegra_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-tegra.c

244

bool enabled = pwm->state.enabled;

drivers/pwm/pwm-tegra.c

251

tegra_pwm_disable(chip, pwm);

drivers/pwm/pwm-tegra.c

256

err = tegra_pwm_config(chip, pwm, state->duty_cycle, state->period);

drivers/pwm/pwm-tegra.c

261

err = tegra_pwm_enable(chip, pwm);

drivers/pwm/pwm-tegra.c

94

static int tegra_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-tiecap.c

111

static int ecap_pwm_set_polarity(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-tiecap.c

135

static int ecap_pwm_enable(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-tiecap.c

154

static void ecap_pwm_disable(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-tiecap.c

171

static int ecap_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-tiecap.c

175

int enabled = pwm->state.enabled;

drivers/pwm/pwm-tiecap.c

177

if (state->polarity != pwm->state.polarity) {

drivers/pwm/pwm-tiecap.c

180

ecap_pwm_disable(chip, pwm);

drivers/pwm/pwm-tiecap.c

184

err = ecap_pwm_set_polarity(chip, pwm, state->polarity);

drivers/pwm/pwm-tiecap.c

191

ecap_pwm_disable(chip, pwm);

drivers/pwm/pwm-tiecap.c

198

err = ecap_pwm_config(chip, pwm, state->duty_cycle,

drivers/pwm/pwm-tiecap.c

204

return ecap_pwm_enable(chip, pwm);

drivers/pwm/pwm-tiecap.c

298

struct pwm_device *pwm = chip->pwms;

drivers/pwm/pwm-tiecap.c

303

if (pwm_is_enabled(pwm))

drivers/pwm/pwm-tiecap.c

312

struct pwm_device *pwm = chip->pwms;

drivers/pwm/pwm-tiecap.c

315

if (pwm_is_enabled(pwm))

drivers/pwm/pwm-tiecap.c

53

static int ecap_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-tiehrpwm.c

179

static int ehrpwm_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-tiehrpwm.c

214

if (i == pwm->hwpwm)

drivers/pwm/pwm-tiehrpwm.c

224

pc->period_cycles[pwm->hwpwm] = period_cycles;

drivers/pwm/pwm-tiehrpwm.c

243

if (pwm->hwpwm == 1) {

drivers/pwm/pwm-tiehrpwm.c

294

static int ehrpwm_pwm_enable(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-tiehrpwm.c

304

if (pwm->hwpwm) {

drivers/pwm/pwm-tiehrpwm.c

329

static void ehrpwm_pwm_disable(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-tiehrpwm.c

335

if (pwm->hwpwm) {

drivers/pwm/pwm-tiehrpwm.c

363

static void ehrpwm_pwm_free(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-tiehrpwm.c

368

pc->period_cycles[pwm->hwpwm] = 0;

drivers/pwm/pwm-tiehrpwm.c

371

static int ehrpwm_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-tiehrpwm.c

375

bool enabled = pwm->state.enabled;

drivers/pwm/pwm-tiehrpwm.c

379

if (state->polarity != pwm->state.polarity) {

drivers/pwm/pwm-tiehrpwm.c

381

ehrpwm_pwm_disable(chip, pwm);

drivers/pwm/pwm-tiehrpwm.c

388

ehrpwm_pwm_disable(chip, pwm);

drivers/pwm/pwm-tiehrpwm.c

392

err = ehrpwm_pwm_config(chip, pwm, state->duty_cycle, state->period, state->polarity);

drivers/pwm/pwm-tiehrpwm.c

397

err = ehrpwm_pwm_enable(chip, pwm);

drivers/pwm/pwm-tiehrpwm.c

530

struct pwm_device *pwm = &chip->pwms[i];

drivers/pwm/pwm-tiehrpwm.c

532

if (!pwm_is_enabled(pwm))

drivers/pwm/pwm-tiehrpwm.c

548

struct pwm_device *pwm = &chip->pwms[i];

drivers/pwm/pwm-tiehrpwm.c

550

if (!pwm_is_enabled(pwm))

drivers/pwm/pwm-twl-led.c

103

static int twl4030_pwmled_enable(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-twl-led.c

110

dev_err(pwmchip_parent(chip), "%s: Failed to read LEDEN\n", pwm->label);

drivers/pwm/pwm-twl-led.c

114

val |= TWL4030_LED_TOGGLE(pwm->hwpwm, TWL4030_LED_PINS);

drivers/pwm/pwm-twl-led.c

118

dev_err(pwmchip_parent(chip), "%s: Failed to enable PWM\n", pwm->label);

drivers/pwm/pwm-twl-led.c

124

struct pwm_device *pwm)

drivers/pwm/pwm-twl-led.c

131

dev_err(pwmchip_parent(chip), "%s: Failed to read LEDEN\n", pwm->label);

drivers/pwm/pwm-twl-led.c

135

val &= ~TWL4030_LED_TOGGLE(pwm->hwpwm, TWL4030_LED_PINS);

drivers/pwm/pwm-twl-led.c

139

dev_err(pwmchip_parent(chip), "%s: Failed to disable PWM\n", pwm->label);

drivers/pwm/pwm-twl-led.c

142

static int twl4030_pwmled_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-twl-led.c

151

if (pwm->state.enabled)

drivers/pwm/pwm-twl-led.c

152

twl4030_pwmled_disable(chip, pwm);

drivers/pwm/pwm-twl-led.c

164

ret = twl4030_pwmled_config(chip, pwm,

drivers/pwm/pwm-twl-led.c

169

if (!pwm->state.enabled)

drivers/pwm/pwm-twl-led.c

170

ret = twl4030_pwmled_enable(chip, pwm);

drivers/pwm/pwm-twl-led.c

180

static int twl6030_pwmled_config(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-twl-led.c

192

dev_err(pwmchip_parent(chip), "%s: Failed to configure PWM\n", pwm->label);

drivers/pwm/pwm-twl-led.c

197

static int twl6030_pwmled_enable(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-twl-led.c

205

pwm->label);

drivers/pwm/pwm-twl-led.c

214

dev_err(pwmchip_parent(chip), "%s: Failed to enable PWM\n", pwm->label);

drivers/pwm/pwm-twl-led.c

220

struct pwm_device *pwm)

drivers/pwm/pwm-twl-led.c

228

pwm->label);

drivers/pwm/pwm-twl-led.c

237

dev_err(pwmchip_parent(chip), "%s: Failed to disable PWM\n", pwm->label);

drivers/pwm/pwm-twl-led.c

240

static int twl6030_pwmled_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-twl-led.c

245

if (state->polarity != pwm->state.polarity)

drivers/pwm/pwm-twl-led.c

249

if (pwm->state.enabled)

drivers/pwm/pwm-twl-led.c

250

twl6030_pwmled_disable(chip, pwm);

drivers/pwm/pwm-twl-led.c

255

err = twl6030_pwmled_config(chip, pwm,

drivers/pwm/pwm-twl-led.c

260

if (!pwm->state.enabled)

drivers/pwm/pwm-twl-led.c

261

err = twl6030_pwmled_enable(chip, pwm);

drivers/pwm/pwm-twl-led.c

266

static int twl6030_pwmled_request(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-twl-led.c

274

pwm->label);

drivers/pwm/pwm-twl-led.c

283

dev_err(pwmchip_parent(chip), "%s: Failed to request PWM\n", pwm->label);

drivers/pwm/pwm-twl-led.c

288

static void twl6030_pwmled_free(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-twl-led.c

296

pwm->label);

drivers/pwm/pwm-twl-led.c

305

dev_err(pwmchip_parent(chip), "%s: Failed to free PWM\n", pwm->label);

drivers/pwm/pwm-twl-led.c

69

static int twl4030_pwmled_config(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-twl-led.c

92

base = pwm->hwpwm * 2 + TWL4030_PWMA_REG;

drivers/pwm/pwm-twl-led.c

98

dev_err(pwmchip_parent(chip), "%s: Failed to configure PWM\n", pwm->label);

drivers/pwm/pwm-twl.c

102

dev_err(pwmchip_parent(chip), "%s: Failed to read GPBR1\n", pwm->label);

drivers/pwm/pwm-twl.c

106

val |= TWL4030_PWM_TOGGLE(pwm->hwpwm, TWL4030_PWMXCLK_ENABLE);

drivers/pwm/pwm-twl.c

110

dev_err(pwmchip_parent(chip), "%s: Failed to enable PWM\n", pwm->label);

drivers/pwm/pwm-twl.c

112

val |= TWL4030_PWM_TOGGLE(pwm->hwpwm, TWL4030_PWMX_ENABLE);

drivers/pwm/pwm-twl.c

116

dev_err(pwmchip_parent(chip), "%s: Failed to enable PWM\n", pwm->label);

drivers/pwm/pwm-twl.c

123

static void twl4030_pwm_disable(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-twl.c

132

dev_err(pwmchip_parent(chip), "%s: Failed to read GPBR1\n", pwm->label);

drivers/pwm/pwm-twl.c

136

val &= ~TWL4030_PWM_TOGGLE(pwm->hwpwm, TWL4030_PWMX_ENABLE);

drivers/pwm/pwm-twl.c

140

dev_err(pwmchip_parent(chip), "%s: Failed to disable PWM\n", pwm->label);

drivers/pwm/pwm-twl.c

142

val &= ~TWL4030_PWM_TOGGLE(pwm->hwpwm, TWL4030_PWMXCLK_ENABLE);

drivers/pwm/pwm-twl.c

146

dev_err(pwmchip_parent(chip), "%s: Failed to disable PWM\n", pwm->label);

drivers/pwm/pwm-twl.c

152

static int twl4030_pwm_request(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-twl.c

158

if (pwm->hwpwm == 1) {

drivers/pwm/pwm-twl.c

169

dev_err(pwmchip_parent(chip), "%s: Failed to read PMBR1\n", pwm->label);

drivers/pwm/pwm-twl.c

183

dev_err(pwmchip_parent(chip), "%s: Failed to request PWM\n", pwm->label);

drivers/pwm/pwm-twl.c

190

static void twl4030_pwm_free(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-twl.c

196

if (pwm->hwpwm == 1)

drivers/pwm/pwm-twl.c

204

dev_err(pwmchip_parent(chip), "%s: Failed to read PMBR1\n", pwm->label);

drivers/pwm/pwm-twl.c

214

dev_err(pwmchip_parent(chip), "%s: Failed to free PWM\n", pwm->label);

drivers/pwm/pwm-twl.c

220

static int twl6030_pwm_enable(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-twl.c

228

val |= TWL6030_PWM_TOGGLE(pwm->hwpwm, TWL6030_PWMXS | TWL6030_PWMXEN);

drivers/pwm/pwm-twl.c

229

val &= ~TWL6030_PWM_TOGGLE(pwm->hwpwm, TWL6030_PWMXR);

drivers/pwm/pwm-twl.c

233

dev_err(pwmchip_parent(chip), "%s: Failed to enable PWM\n", pwm->label);

drivers/pwm/pwm-twl.c

243

static void twl6030_pwm_disable(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-twl.c

251

val |= TWL6030_PWM_TOGGLE(pwm->hwpwm, TWL6030_PWMXR);

drivers/pwm/pwm-twl.c

252

val &= ~TWL6030_PWM_TOGGLE(pwm->hwpwm, TWL6030_PWMXS | TWL6030_PWMXEN);

drivers/pwm/pwm-twl.c

256

dev_err(pwmchip_parent(chip), "%s: Failed to disable PWM\n", pwm->label);

drivers/pwm/pwm-twl.c

260

val |= TWL6030_PWM_TOGGLE(pwm->hwpwm, TWL6030_PWMXEN);

drivers/pwm/pwm-twl.c

264

dev_err(pwmchip_parent(chip), "%s: Failed to disable PWM\n", pwm->label);

drivers/pwm/pwm-twl.c

268

val &= ~TWL6030_PWM_TOGGLE(pwm->hwpwm, TWL6030_PWMXEN);

drivers/pwm/pwm-twl.c

272

dev_err(pwmchip_parent(chip), "%s: Failed to disable PWM\n", pwm->label);

drivers/pwm/pwm-twl.c

281

static int twl4030_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-twl.c

290

if (pwm->state.enabled)

drivers/pwm/pwm-twl.c

291

twl4030_pwm_disable(chip, pwm);

drivers/pwm/pwm-twl.c

296

err = twl_pwm_config(chip, pwm, state->duty_cycle, state->period);

drivers/pwm/pwm-twl.c

300

if (!pwm->state.enabled)

drivers/pwm/pwm-twl.c

301

err = twl4030_pwm_enable(chip, pwm);

drivers/pwm/pwm-twl.c

306

static int twl6030_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-twl.c

315

if (pwm->state.enabled)

drivers/pwm/pwm-twl.c

316

twl6030_pwm_disable(chip, pwm);

drivers/pwm/pwm-twl.c

32

#define TWL4030_PWM_TOGGLE(pwm, x) ((x) << (pwm))

drivers/pwm/pwm-twl.c

321

err = twl_pwm_config(chip, pwm, state->duty_cycle, state->period);

drivers/pwm/pwm-twl.c

325

if (!pwm->state.enabled)

drivers/pwm/pwm-twl.c

326

err = twl6030_pwm_enable(chip, pwm);

drivers/pwm/pwm-twl.c

46

#define TWL6030_PWM_TOGGLE(pwm, x) ((x) << (pwm * 3))

drivers/pwm/pwm-twl.c

59

static int twl_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-twl.c

82

base = pwm->hwpwm * 3;

drivers/pwm/pwm-twl.c

88

dev_err(pwmchip_parent(chip), "%s: Failed to configure PWM\n", pwm->label);

drivers/pwm/pwm-twl.c

93

static int twl4030_pwm_enable(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-visconti.c

100

writel(period, priv->base + PIPGM_PCSR(pwm->hwpwm));

drivers/pwm/pwm-visconti.c

105

static int visconti_pwm_get_state(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-visconti.c

111

period = readl(priv->base + PIPGM_PCSR(pwm->hwpwm));

drivers/pwm/pwm-visconti.c

112

duty = readl(priv->base + PIPGM_PDUT(pwm->hwpwm));

drivers/pwm/pwm-visconti.c

113

pwmc0 = readl(priv->base + PIPGM_PWMC(pwm->hwpwm));

drivers/pwm/pwm-visconti.c

45

static int visconti_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-visconti.c

52

writel(0, priv->base + PIPGM_PCSR(pwm->hwpwm));

drivers/pwm/pwm-visconti.c

98

writel(pwmc0, priv->base + PIPGM_PWMC(pwm->hwpwm));

drivers/pwm/pwm-visconti.c

99

writel(duty_cycle, priv->base + PIPGM_PDUT(pwm->hwpwm));

drivers/pwm/pwm-vt8500.c

107

writel(prescale, vt8500->base + REG_SCALAR(pwm->hwpwm));

drivers/pwm/pwm-vt8500.c

108

vt8500_pwm_busy_wait(chip, pwm->hwpwm, STATUS_SCALAR_UPDATE);

drivers/pwm/pwm-vt8500.c

110

writel(pv, vt8500->base + REG_PERIOD(pwm->hwpwm));

drivers/pwm/pwm-vt8500.c

111

vt8500_pwm_busy_wait(chip, pwm->hwpwm, STATUS_PERIOD_UPDATE);

drivers/pwm/pwm-vt8500.c

113

writel(dc, vt8500->base + REG_DUTY(pwm->hwpwm));

drivers/pwm/pwm-vt8500.c

114

vt8500_pwm_busy_wait(chip, pwm->hwpwm, STATUS_DUTY_UPDATE);

drivers/pwm/pwm-vt8500.c

116

val = readl(vt8500->base + REG_CTRL(pwm->hwpwm));

drivers/pwm/pwm-vt8500.c

118

writel(val, vt8500->base + REG_CTRL(pwm->hwpwm));

drivers/pwm/pwm-vt8500.c

119

vt8500_pwm_busy_wait(chip, pwm->hwpwm, STATUS_CTRL_UPDATE);

drivers/pwm/pwm-vt8500.c

125

static int vt8500_pwm_enable(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-vt8500.c

137

val = readl(vt8500->base + REG_CTRL(pwm->hwpwm));

drivers/pwm/pwm-vt8500.c

139

writel(val, vt8500->base + REG_CTRL(pwm->hwpwm));

drivers/pwm/pwm-vt8500.c

140

vt8500_pwm_busy_wait(chip, pwm->hwpwm, STATUS_CTRL_UPDATE);

drivers/pwm/pwm-vt8500.c

145

static void vt8500_pwm_disable(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/pwm/pwm-vt8500.c

150

val = readl(vt8500->base + REG_CTRL(pwm->hwpwm));

drivers/pwm/pwm-vt8500.c

152

writel(val, vt8500->base + REG_CTRL(pwm->hwpwm));

drivers/pwm/pwm-vt8500.c

153

vt8500_pwm_busy_wait(chip, pwm->hwpwm, STATUS_CTRL_UPDATE);

drivers/pwm/pwm-vt8500.c

159

struct pwm_device *pwm,

drivers/pwm/pwm-vt8500.c

165

val = readl(vt8500->base + REG_CTRL(pwm->hwpwm));

drivers/pwm/pwm-vt8500.c

172

writel(val, vt8500->base + REG_CTRL(pwm->hwpwm));

drivers/pwm/pwm-vt8500.c

173

vt8500_pwm_busy_wait(chip, pwm->hwpwm, STATUS_CTRL_UPDATE);

drivers/pwm/pwm-vt8500.c

178

static int vt8500_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/pwm/pwm-vt8500.c

182

bool enabled = pwm->state.enabled;

drivers/pwm/pwm-vt8500.c

184

if (state->polarity != pwm->state.polarity) {

drivers/pwm/pwm-vt8500.c

190

vt8500_pwm_disable(chip, pwm);

drivers/pwm/pwm-vt8500.c

195

err = vt8500_pwm_set_polarity(chip, pwm, state->polarity);

drivers/pwm/pwm-vt8500.c

202

vt8500_pwm_disable(chip, pwm);

drivers/pwm/pwm-vt8500.c

214

err = vt8500_pwm_config(chip, pwm, state->duty_cycle, state->period);

drivers/pwm/pwm-vt8500.c

219

err = vt8500_pwm_enable(chip, pwm);

drivers/pwm/pwm-vt8500.c

27

#define REG_CTRL(pwm) (((pwm) << 4) + 0x00)

drivers/pwm/pwm-vt8500.c

28

#define REG_SCALAR(pwm) (((pwm) << 4) + 0x04)

drivers/pwm/pwm-vt8500.c

29

#define REG_PERIOD(pwm) (((pwm) << 4) + 0x08)

drivers/pwm/pwm-vt8500.c

30

#define REG_DUTY(pwm) (((pwm) << 4) + 0x0C)

drivers/pwm/pwm-vt8500.c

71

static int vt8500_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/regulator/max8973-regulator.c

213

int pwm;

drivers/regulator/max8973-regulator.c

218

pwm = MAX8973_FPWM_EN_M;

drivers/regulator/max8973-regulator.c

222

pwm = 0;

drivers/regulator/max8973-regulator.c

230

MAX8973_FPWM_EN_M, pwm);

drivers/regulator/pwm-regulator.c

121

return pwm_enable(drvdata->pwm);

drivers/regulator/pwm-regulator.c

128

pwm_disable(drvdata->pwm);

drivers/regulator/pwm-regulator.c

142

return pwm_is_enabled(drvdata->pwm);

drivers/regulator/pwm-regulator.c

158

pwm_get_state(drvdata->pwm, &pstate);

drivers/regulator/pwm-regulator.c

206

pwm_init_state(drvdata->pwm, &pstate);

drivers/regulator/pwm-regulator.c

229

ret = pwm_apply_might_sleep(drvdata->pwm, &pstate);

drivers/regulator/pwm-regulator.c

29

struct pwm_device *pwm;

drivers/regulator/pwm-regulator.c

333

pwm_get_state(drvdata->pwm, &pstate);

drivers/regulator/pwm-regulator.c

347

return pwm_apply_might_sleep(drvdata->pwm, &pstate);

drivers/regulator/pwm-regulator.c

387

drvdata->pwm = devm_pwm_get(&pdev->dev, NULL);

drivers/regulator/pwm-regulator.c

388

if (IS_ERR(drvdata->pwm))

drivers/regulator/pwm-regulator.c

389

return dev_err_probe(&pdev->dev, PTR_ERR(drvdata->pwm),

drivers/regulator/pwm-regulator.c

403

ret = pwm_adjust_config(drvdata->pwm);

drivers/regulator/pwm-regulator.c

61

pwm_get_state(drvdata->pwm, &pwm_state);

drivers/regulator/pwm-regulator.c

89

pwm_init_state(drvdata->pwm, &pstate);

drivers/regulator/pwm-regulator.c

93

ret = pwm_apply_might_sleep(drvdata->pwm, &pstate);

drivers/regulator/qcom_rpm-regulator.c

684

bool pwm;

drivers/regulator/qcom_rpm-regulator.c

705

pwm = !of_property_read_bool(node, key);

drivers/regulator/qcom_rpm-regulator.c

707

ret = rpm_reg_set(vreg, &vreg->parts->pm, pwm);

drivers/regulator/rpi-panel-v2-regulator.c

38

static int rpi_panel_v2_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/spi/spi-offload-trigger-pwm.c

100

ret = pwm_set_waveform_might_sleep(st->pwm, &wf, false);

drivers/spi/spi-offload-trigger-pwm.c

135

st->pwm = devm_pwm_get(dev, NULL);

drivers/spi/spi-offload-trigger-pwm.c

136

if (IS_ERR(st->pwm))

drivers/spi/spi-offload-trigger-pwm.c

137

return dev_err_probe(dev, PTR_ERR(st->pwm), "failed to get PWM\n");

drivers/spi/spi-offload-trigger-pwm.c

140

pwm_init_state(st->pwm, &state);

drivers/spi/spi-offload-trigger-pwm.c

143

ret = pwm_apply_might_sleep(st->pwm, &state);

drivers/spi/spi-offload-trigger-pwm.c

147

ret = devm_add_action_or_reset(dev, spi_offload_trigger_pwm_release, st->pwm);

drivers/spi/spi-offload-trigger-pwm.c

23

struct pwm_device *pwm;

drivers/spi/spi-offload-trigger-pwm.c

55

ret = pwm_round_waveform_might_sleep(st->pwm, &wf);

drivers/spi/spi-offload-trigger-pwm.c

83

return pwm_set_waveform_might_sleep(st->pwm, &wf, false);

drivers/spi/spi-offload-trigger-pwm.c

92

ret = pwm_get_waveform_might_sleep(st->pwm, &wf);

drivers/staging/greybus/pwm.c

177

static int gb_pwm_request(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/staging/greybus/pwm.c

179

return gb_pwm_activate_operation(chip, pwm->hwpwm);

drivers/staging/greybus/pwm.c

182

static void gb_pwm_free(struct pwm_chip *chip, struct pwm_device *pwm)

drivers/staging/greybus/pwm.c

184

if (pwm_is_enabled(pwm))

drivers/staging/greybus/pwm.c

187

gb_pwm_deactivate_operation(chip, pwm->hwpwm);

drivers/staging/greybus/pwm.c

190

static int gb_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,

drivers/staging/greybus/pwm.c

194

bool enabled = pwm->state.enabled;

drivers/staging/greybus/pwm.c

199

if (state->polarity != pwm->state.polarity) {

drivers/staging/greybus/pwm.c

201

gb_pwm_disable_operation(chip, pwm->hwpwm);

drivers/staging/greybus/pwm.c

204

err = gb_pwm_set_polarity_operation(chip, pwm->hwpwm, state->polarity);

drivers/staging/greybus/pwm.c

211

gb_pwm_disable_operation(chip, pwm->hwpwm);

drivers/staging/greybus/pwm.c

227

err = gb_pwm_config_operation(chip, pwm->hwpwm, duty_cycle, period);

drivers/staging/greybus/pwm.c

233

return gb_pwm_enable_operation(chip, pwm->hwpwm);

drivers/staging/media/av7110/av7110.c

2059

u8 pwm;

drivers/staging/media/av7110/av7110.c

2061

{ .addr = 0x50, .flags = I2C_M_RD, .buf = &pwm, .len = 1} };

drivers/staging/media/av7110/av7110.c

2063

if ((i2c_transfer(&av7110->i2c_adap, msg, 2) != 2) || (pwm == 0xff))

drivers/staging/media/av7110/av7110.c

2064

pwm = 0x48;

drivers/staging/media/av7110/av7110.c

2066

return pwm;

drivers/video/backlight/88pm860x_bl.c

167

&data->pwm);

drivers/video/backlight/88pm860x_bl.c

220

data->pwm = pdata->pwm;

drivers/video/backlight/88pm860x_bl.c

29

int pwm;

drivers/video/backlight/88pm860x_bl.c

84

if (data->pwm) {

drivers/video/backlight/88pm860x_bl.c

86

PM8606_PWM_FREQ_MASK, data->pwm);

drivers/video/backlight/lm3533_bl.c

217

static LM3533_ATTR_RW(pwm);

drivers/video/backlight/lm3533_bl.c

258

return lm3533_ctrlbank_set_pwm(&bl->cb, pdata->pwm);

drivers/video/backlight/lp855x_bl.c

225

pwm_init_state(lp->pwm, &state);

drivers/video/backlight/lp855x_bl.c

231

pwm_get_state(lp->pwm, &state);

drivers/video/backlight/lp855x_bl.c

237

return pwm_apply_might_sleep(lp->pwm, &state);

drivers/video/backlight/lp855x_bl.c

474

lp->pwm = devm_pwm_get(lp->dev, lp->chipname);

drivers/video/backlight/lp855x_bl.c

475

if (IS_ERR(lp->pwm)) {

drivers/video/backlight/lp855x_bl.c

476

ret = PTR_ERR(lp->pwm);

drivers/video/backlight/lp855x_bl.c

478

lp->pwm = NULL;

drivers/video/backlight/lp855x_bl.c

73

struct pwm_device *pwm;

drivers/video/backlight/pwm_bl.c

101

pwm_get_state(pb->pwm, &state);

drivers/video/backlight/pwm_bl.c

104

pwm_apply_might_sleep(pb->pwm, &state);

drivers/video/backlight/pwm_bl.c

110

pwm_get_state(pb->pwm, &state);

drivers/video/backlight/pwm_bl.c

121

pwm_apply_might_sleep(pb->pwm, &state);

drivers/video/backlight/pwm_bl.c

22

struct pwm_device *pwm;

drivers/video/backlight/pwm_bl.c

412

if (!pwm_is_enabled(pb->pwm))

drivers/video/backlight/pwm_bl.c

500

pb->pwm = devm_pwm_get(&pdev->dev, NULL);

drivers/video/backlight/pwm_bl.c

501

if (IS_ERR(pb->pwm)) {

drivers/video/backlight/pwm_bl.c

502

ret = dev_err_probe(&pdev->dev, PTR_ERR(pb->pwm),

drivers/video/backlight/pwm_bl.c

510

pwm_init_state(pb->pwm, &state);

drivers/video/backlight/pwm_bl.c

521

ret = pwm_apply_might_sleep(pb->pwm, &state);

drivers/video/backlight/pwm_bl.c

556

pwm_get_state(pb->pwm, &state);

drivers/video/backlight/pwm_bl.c

623

pwm_get_state(pb->pwm, &state);

drivers/video/backlight/pwm_bl.c

626

pwm_apply_might_sleep(pb->pwm, &state);

drivers/video/backlight/pwm_bl.c

639

pwm_get_state(pb->pwm, &state);

drivers/video/backlight/pwm_bl.c

642

pwm_apply_might_sleep(pb->pwm, &state);

drivers/video/backlight/pwm_bl.c

663

pwm_get_state(pb->pwm, &state);

drivers/video/backlight/pwm_bl.c

666

pwm_apply_might_sleep(pb->pwm, &state);

drivers/video/fbdev/ssd1307fb.c

342

par->pwm = pwm_get(&par->client->dev, NULL);

drivers/video/fbdev/ssd1307fb.c

343

if (IS_ERR(par->pwm)) {

drivers/video/fbdev/ssd1307fb.c

345

return PTR_ERR(par->pwm);

drivers/video/fbdev/ssd1307fb.c

348

pwm_init_state(par->pwm, &pwmstate);

drivers/video/fbdev/ssd1307fb.c

350

pwm_apply_might_sleep(par->pwm, &pwmstate);

drivers/video/fbdev/ssd1307fb.c

353

pwm_enable(par->pwm);

drivers/video/fbdev/ssd1307fb.c

356

par->pwm->label, pwm_get_period(par->pwm));

drivers/video/fbdev/ssd1307fb.c

753

pwm_disable(par->pwm);

drivers/video/fbdev/ssd1307fb.c

754

pwm_put(par->pwm);

drivers/video/fbdev/ssd1307fb.c

777

pwm_disable(par->pwm);

drivers/video/fbdev/ssd1307fb.c

778

pwm_put(par->pwm);

drivers/video/fbdev/ssd1307fb.c

80

struct pwm_device *pwm;

include/linux/can/bittiming.h

168

struct can_pwm pwm;

include/linux/can/bittiming.h

222

const struct can_pwm *pwm,

include/linux/f75375s.h

17

u8 pwm[2];

include/linux/leds-pca9532.h

38

u8 pwm[2];

include/linux/mfd/88pm860x.h

404

int pwm;

include/linux/mfd/lm3533.h

50

u8 pwm; /* 0 - 0x3f */

include/linux/mfd/lm3533.h

57

u8 pwm; /* 0 - 0x3f */

include/linux/pwm.h

129

static inline void pwm_get_state(const struct pwm_device *pwm,

include/linux/pwm.h

132

*state = pwm->state;

include/linux/pwm.h

135

static inline bool pwm_is_enabled(const struct pwm_device *pwm)

include/linux/pwm.h

139

pwm_get_state(pwm, &state);

include/linux/pwm.h

144

static inline u64 pwm_get_period(const struct pwm_device *pwm)

include/linux/pwm.h

148

pwm_get_state(pwm, &state);

include/linux/pwm.h

153

static inline u64 pwm_get_duty_cycle(const struct pwm_device *pwm)

include/linux/pwm.h

157

pwm_get_state(pwm, &state);

include/linux/pwm.h

162

static inline enum pwm_polarity pwm_get_polarity(const struct pwm_device *pwm)

include/linux/pwm.h

166

pwm_get_state(pwm, &state);

include/linux/pwm.h

171

static inline void pwm_get_args(const struct pwm_device *pwm,

include/linux/pwm.h

174

*args = pwm->args;

include/linux/pwm.h

194

static inline void pwm_init_state(const struct pwm_device *pwm,

include/linux/pwm.h

200

pwm_get_state(pwm, state);

include/linux/pwm.h

203

pwm_get_args(pwm, &args);

include/linux/pwm.h

294

int (*request)(struct pwm_chip *chip, struct pwm_device *pwm);

include/linux/pwm.h

295

void (*free)(struct pwm_chip *chip, struct pwm_device *pwm);

include/linux/pwm.h

296

int (*capture)(struct pwm_chip *chip, struct pwm_device *pwm,

include/linux/pwm.h

300

int (*round_waveform_tohw)(struct pwm_chip *chip, struct pwm_device *pwm,

include/linux/pwm.h

302

int (*round_waveform_fromhw)(struct pwm_chip *chip, struct pwm_device *pwm,

include/linux/pwm.h

304

int (*read_waveform)(struct pwm_chip *chip, struct pwm_device *pwm,

include/linux/pwm.h

306

int (*write_waveform)(struct pwm_chip *chip, struct pwm_device *pwm,

include/linux/pwm.h

309

int (*apply)(struct pwm_chip *chip, struct pwm_device *pwm,

include/linux/pwm.h

311

int (*get_state)(struct pwm_chip *chip, struct pwm_device *pwm,

include/linux/pwm.h

395

int pwm_round_waveform_might_sleep(struct pwm_device *pwm, struct pwm_waveform *wf);

include/linux/pwm.h

396

int pwm_get_waveform_might_sleep(struct pwm_device *pwm, struct pwm_waveform *wf);

include/linux/pwm.h

397

int pwm_set_waveform_might_sleep(struct pwm_device *pwm, const struct pwm_waveform *wf, bool exact);

include/linux/pwm.h

398

int pwm_apply_might_sleep(struct pwm_device *pwm, const struct pwm_state *state);

include/linux/pwm.h

399

int pwm_apply_atomic(struct pwm_device *pwm, const struct pwm_state *state);

include/linux/pwm.h

400

int pwm_get_state_hw(struct pwm_device *pwm, struct pwm_state *state);

include/linux/pwm.h

401

int pwm_adjust_config(struct pwm_device *pwm);

include/linux/pwm.h

411

static inline int pwm_config(struct pwm_device *pwm, int duty_ns,

include/linux/pwm.h

416

if (!pwm)

include/linux/pwm.h

422

pwm_get_state(pwm, &state);

include/linux/pwm.h

428

return pwm_apply_might_sleep(pwm, &state);

include/linux/pwm.h

437

static inline int pwm_enable(struct pwm_device *pwm)

include/linux/pwm.h

441

if (!pwm)

include/linux/pwm.h

444

pwm_get_state(pwm, &state);

include/linux/pwm.h

449

return pwm_apply_might_sleep(pwm, &state);

include/linux/pwm.h

456

static inline void pwm_disable(struct pwm_device *pwm)

include/linux/pwm.h

460

if (!pwm)

include/linux/pwm.h

463

pwm_get_state(pwm, &state);

include/linux/pwm.h

468

pwm_apply_might_sleep(pwm, &state);

include/linux/pwm.h

477

static inline bool pwm_might_sleep(struct pwm_device *pwm)

include/linux/pwm.h

479

return !pwm->chip->atomic;

include/linux/pwm.h

506

void pwm_put(struct pwm_device *pwm);

include/linux/pwm.h

513

static inline bool pwm_might_sleep(struct pwm_device *pwm)

include/linux/pwm.h

518

static inline int pwm_apply_might_sleep(struct pwm_device *pwm,

include/linux/pwm.h

525

static inline int pwm_apply_atomic(struct pwm_device *pwm,

include/linux/pwm.h

531

static inline int pwm_get_state_hw(struct pwm_device *pwm, struct pwm_state *state)

include/linux/pwm.h

536

static inline int pwm_adjust_config(struct pwm_device *pwm)

include/linux/pwm.h

541

static inline int pwm_config(struct pwm_device *pwm, int duty_ns,

include/linux/pwm.h

548

static inline int pwm_enable(struct pwm_device *pwm)

include/linux/pwm.h

554

static inline void pwm_disable(struct pwm_device *pwm)

include/linux/pwm.h

599

static inline void pwm_put(struct pwm_device *pwm)

include/trace/events/pwm.h

12

TP_PROTO(struct pwm_device *pwm, args)

include/trace/events/pwm.h

133

DECLARE_EVENT_CLASS(pwm,

include/trace/events/pwm.h

135

TP_PROTO(struct pwm_device *pwm, const struct pwm_state *state, int err),

include/trace/events/pwm.h

137

TP_ARGS(pwm, state, err),

include/trace/events/pwm.h

15

TP_ARGS(pwm, args)

include/trace/events/pwm.h

161

DEFINE_EVENT(pwm, pwm_apply,

include/trace/events/pwm.h

163

TP_PROTO(struct pwm_device *pwm, const struct pwm_state *state, int err),

include/trace/events/pwm.h

165

TP_ARGS(pwm, state, err)

include/trace/events/pwm.h

168

DEFINE_EVENT(pwm, pwm_get,

include/trace/events/pwm.h

170

TP_PROTO(struct pwm_device *pwm, const struct pwm_state *state, int err),

include/trace/events/pwm.h

172

TP_ARGS(pwm, state, err)

include/trace/events/pwm.h

25

__entry->chipid = pwm->chip->id; \

include/trace/events/pwm.h

26

__entry->hwpwm = pwm->hwpwm; \

include/trace/events/pwm.h

3

#define TRACE_SYSTEM pwm