1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (C) 2024 Analog Devices Inc. 4 * Copyright (C) 2024 BayLibre, SAS 5 * 6 * Generic PWM trigger for SPI offload. 7 */ 8 9 #include <linux/device.h> 10 #include <linux/err.h> 11 #include <linux/math.h> 12 #include <linux/mod_devicetable.h> 13 #include <linux/module.h> 14 #include <linux/platform_device.h> 15 #include <linux/property.h> 16 #include <linux/pwm.h> 17 #include <linux/spi/offload/provider.h> 18 #include <linux/spi/offload/types.h> 19 #include <linux/time.h> 20 #include <linux/types.h> 21 22 struct spi_offload_trigger_pwm_state { 23 struct device *dev; 24 struct pwm_device *pwm; 25 }; 26 27 static bool spi_offload_trigger_pwm_match(struct spi_offload_trigger *trigger, 28 enum spi_offload_trigger_type type, 29 u64 *args, u32 nargs) 30 { 31 if (nargs) 32 return false; 33 34 return type == SPI_OFFLOAD_TRIGGER_PERIODIC; 35 } 36 37 static int spi_offload_trigger_pwm_validate(struct spi_offload_trigger *trigger, 38 struct spi_offload_trigger_config *config) 39 { 40 struct spi_offload_trigger_pwm_state *st = spi_offload_trigger_get_priv(trigger); 41 struct spi_offload_trigger_periodic *periodic = &config->periodic; 42 struct pwm_waveform wf = { }; 43 int ret; 44 45 if (config->type != SPI_OFFLOAD_TRIGGER_PERIODIC) 46 return -EINVAL; 47 48 if (!periodic->frequency_hz) 49 return -EINVAL; 50 51 wf.period_length_ns = DIV_ROUND_UP_ULL(NSEC_PER_SEC, periodic->frequency_hz); 52 /* REVISIT: 50% duty-cycle for now - may add config parameter later */ 53 wf.duty_length_ns = wf.period_length_ns / 2; 54 55 ret = pwm_round_waveform_might_sleep(st->pwm, &wf); 56 if (ret < 0) 57 return ret; 58 59 periodic->frequency_hz = DIV_ROUND_UP_ULL(NSEC_PER_SEC, wf.period_length_ns); 60 61 return 0; 62 } 63 64 static int spi_offload_trigger_pwm_enable(struct spi_offload_trigger *trigger, 65 struct spi_offload_trigger_config *config) 66 { 67 struct spi_offload_trigger_pwm_state *st = spi_offload_trigger_get_priv(trigger); 68 struct spi_offload_trigger_periodic *periodic = &config->periodic; 69 struct pwm_waveform wf = { }; 70 71 if (config->type != SPI_OFFLOAD_TRIGGER_PERIODIC) 72 return -EINVAL; 73 74 if (!periodic->frequency_hz) 75 return -EINVAL; 76 77 wf.period_length_ns = DIV_ROUND_UP_ULL(NSEC_PER_SEC, periodic->frequency_hz); 78 /* REVISIT: 50% duty-cycle for now - may add config parameter later */ 79 wf.duty_length_ns = wf.period_length_ns / 2; 80 81 return pwm_set_waveform_might_sleep(st->pwm, &wf, false); 82 } 83 84 static void spi_offload_trigger_pwm_disable(struct spi_offload_trigger *trigger) 85 { 86 struct spi_offload_trigger_pwm_state *st = spi_offload_trigger_get_priv(trigger); 87 struct pwm_waveform wf; 88 int ret; 89 90 ret = pwm_get_waveform_might_sleep(st->pwm, &wf); 91 if (ret < 0) { 92 dev_err(st->dev, "failed to get waveform: %d\n", ret); 93 return; 94 } 95 96 wf.duty_length_ns = 0; 97 98 ret = pwm_set_waveform_might_sleep(st->pwm, &wf, false); 99 if (ret < 0) 100 dev_err(st->dev, "failed to disable PWM: %d\n", ret); 101 } 102 103 static const struct spi_offload_trigger_ops spi_offload_trigger_pwm_ops = { 104 .match = spi_offload_trigger_pwm_match, 105 .validate = spi_offload_trigger_pwm_validate, 106 .enable = spi_offload_trigger_pwm_enable, 107 .disable = spi_offload_trigger_pwm_disable, 108 }; 109 110 static void spi_offload_trigger_pwm_release(void *data) 111 { 112 pwm_disable(data); 113 } 114 115 static int spi_offload_trigger_pwm_probe(struct platform_device *pdev) 116 { 117 struct device *dev = &pdev->dev; 118 struct spi_offload_trigger_info info = { 119 .fwnode = dev_fwnode(dev), 120 .ops = &spi_offload_trigger_pwm_ops, 121 }; 122 struct spi_offload_trigger_pwm_state *st; 123 struct pwm_state state; 124 int ret; 125 126 st = devm_kzalloc(dev, sizeof(*st), GFP_KERNEL); 127 if (!st) 128 return -ENOMEM; 129 130 info.priv = st; 131 st->dev = dev; 132 133 st->pwm = devm_pwm_get(dev, NULL); 134 if (IS_ERR(st->pwm)) 135 return dev_err_probe(dev, PTR_ERR(st->pwm), "failed to get PWM\n"); 136 137 /* init with duty_cycle = 0, output enabled to ensure trigger off */ 138 pwm_init_state(st->pwm, &state); 139 state.enabled = true; 140 141 ret = pwm_apply_might_sleep(st->pwm, &state); 142 if (ret < 0) 143 return dev_err_probe(dev, ret, "failed to apply PWM state\n"); 144 145 ret = devm_add_action_or_reset(dev, spi_offload_trigger_pwm_release, st->pwm); 146 if (ret) 147 return ret; 148 149 return devm_spi_offload_trigger_register(dev, &info); 150 } 151 152 static const struct of_device_id spi_offload_trigger_pwm_of_match_table[] = { 153 { .compatible = "pwm-trigger" }, 154 { } 155 }; 156 MODULE_DEVICE_TABLE(of, spi_offload_trigger_pwm_of_match_table); 157 158 static struct platform_driver spi_offload_trigger_pwm_driver = { 159 .driver = { 160 .name = "pwm-trigger", 161 .of_match_table = spi_offload_trigger_pwm_of_match_table, 162 }, 163 .probe = spi_offload_trigger_pwm_probe, 164 }; 165 module_platform_driver(spi_offload_trigger_pwm_driver); 166 167 MODULE_AUTHOR("David Lechner <dlechner@baylibre.com>"); 168 MODULE_DESCRIPTION("Generic PWM trigger"); 169 MODULE_LICENSE("GPL"); 170