xref: /openbmc/linux/drivers/media/rc/ir-rx51.c (revision c94b731d)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  *  Copyright (C) 2008 Nokia Corporation
4  *
5  *  Based on lirc_serial.c
6  */
7 #include <linux/clk.h>
8 #include <linux/module.h>
9 #include <linux/platform_device.h>
10 #include <linux/wait.h>
11 #include <linux/pwm.h>
12 #include <linux/of.h>
13 #include <linux/hrtimer.h>
14 
15 #include <media/rc-core.h>
16 
17 #define WBUF_LEN 256
18 
19 struct ir_rx51 {
20 	struct rc_dev *rcdev;
21 	struct pwm_device *pwm;
22 	struct pwm_state state;
23 	struct hrtimer timer;
24 	struct device	     *dev;
25 	wait_queue_head_t     wqueue;
26 
27 	unsigned int	freq;		/* carrier frequency */
28 	unsigned int	duty_cycle;	/* carrier duty cycle */
29 	int		wbuf[WBUF_LEN];
30 	int		wbuf_index;
31 	unsigned long	device_is_open;
32 };
33 
34 static inline void ir_rx51_on(struct ir_rx51 *ir_rx51)
35 {
36 	ir_rx51->state.enabled = true;
37 	pwm_apply_state(ir_rx51->pwm, &ir_rx51->state);
38 }
39 
40 static inline void ir_rx51_off(struct ir_rx51 *ir_rx51)
41 {
42 	ir_rx51->state.enabled = false;
43 	pwm_apply_state(ir_rx51->pwm, &ir_rx51->state);
44 }
45 
46 static int init_timing_params(struct ir_rx51 *ir_rx51)
47 {
48 	ir_rx51->state.period = DIV_ROUND_CLOSEST(NSEC_PER_SEC, ir_rx51->freq);
49 	pwm_set_relative_duty_cycle(&ir_rx51->state, ir_rx51->duty_cycle, 100);
50 
51 	return 0;
52 }
53 
54 static enum hrtimer_restart ir_rx51_timer_cb(struct hrtimer *timer)
55 {
56 	struct ir_rx51 *ir_rx51 = container_of(timer, struct ir_rx51, timer);
57 	ktime_t now;
58 
59 	if (ir_rx51->wbuf_index < 0) {
60 		dev_err_ratelimited(ir_rx51->dev,
61 				    "BUG wbuf_index has value of %i\n",
62 				    ir_rx51->wbuf_index);
63 		goto end;
64 	}
65 
66 	/*
67 	 * If we happen to hit an odd latency spike, loop through the
68 	 * pulses until we catch up.
69 	 */
70 	do {
71 		u64 ns;
72 
73 		if (ir_rx51->wbuf_index >= WBUF_LEN)
74 			goto end;
75 		if (ir_rx51->wbuf[ir_rx51->wbuf_index] == -1)
76 			goto end;
77 
78 		if (ir_rx51->wbuf_index % 2)
79 			ir_rx51_off(ir_rx51);
80 		else
81 			ir_rx51_on(ir_rx51);
82 
83 		ns = US_TO_NS(ir_rx51->wbuf[ir_rx51->wbuf_index]);
84 		hrtimer_add_expires_ns(timer, ns);
85 
86 		ir_rx51->wbuf_index++;
87 
88 		now = timer->base->get_time();
89 
90 	} while (hrtimer_get_expires_tv64(timer) < now);
91 
92 	return HRTIMER_RESTART;
93 end:
94 	/* Stop TX here */
95 	ir_rx51_off(ir_rx51);
96 	ir_rx51->wbuf_index = -1;
97 
98 	wake_up_interruptible(&ir_rx51->wqueue);
99 
100 	return HRTIMER_NORESTART;
101 }
102 
103 static int ir_rx51_tx(struct rc_dev *dev, unsigned int *buffer,
104 		      unsigned int count)
105 {
106 	struct ir_rx51 *ir_rx51 = dev->priv;
107 
108 	if (count > WBUF_LEN)
109 		return -EINVAL;
110 
111 	memcpy(ir_rx51->wbuf, buffer, count * sizeof(unsigned int));
112 
113 	/* Wait any pending transfers to finish */
114 	wait_event_interruptible(ir_rx51->wqueue, ir_rx51->wbuf_index < 0);
115 
116 	init_timing_params(ir_rx51);
117 	if (count < WBUF_LEN)
118 		ir_rx51->wbuf[count] = -1; /* Insert termination mark */
119 
120 	/*
121 	 * REVISIT: Adjust latency requirements so the device doesn't go in too
122 	 * deep sleep states with pm_qos_add_request().
123 	 */
124 
125 	ir_rx51_on(ir_rx51);
126 	ir_rx51->wbuf_index = 1;
127 	hrtimer_start(&ir_rx51->timer,
128 		      ns_to_ktime(US_TO_NS(ir_rx51->wbuf[0])),
129 		      HRTIMER_MODE_REL);
130 	/*
131 	 * Don't return back to the userspace until the transfer has
132 	 * finished
133 	 */
134 	wait_event_interruptible(ir_rx51->wqueue, ir_rx51->wbuf_index < 0);
135 
136 	/* REVISIT: Remove pm_qos constraint, we can sleep again */
137 
138 	return count;
139 }
140 
141 static int ir_rx51_open(struct rc_dev *dev)
142 {
143 	struct ir_rx51 *ir_rx51 = dev->priv;
144 
145 	if (test_and_set_bit(1, &ir_rx51->device_is_open))
146 		return -EBUSY;
147 
148 	ir_rx51->pwm = pwm_get(ir_rx51->dev, NULL);
149 	if (IS_ERR(ir_rx51->pwm)) {
150 		int res = PTR_ERR(ir_rx51->pwm);
151 
152 		dev_err(ir_rx51->dev, "pwm_get failed: %d\n", res);
153 		return res;
154 	}
155 
156 	return 0;
157 }
158 
159 static void ir_rx51_release(struct rc_dev *dev)
160 {
161 	struct ir_rx51 *ir_rx51 = dev->priv;
162 
163 	hrtimer_cancel(&ir_rx51->timer);
164 	ir_rx51_off(ir_rx51);
165 	pwm_put(ir_rx51->pwm);
166 
167 	clear_bit(1, &ir_rx51->device_is_open);
168 }
169 
170 static struct ir_rx51 ir_rx51 = {
171 	.duty_cycle	= 50,
172 	.wbuf_index	= -1,
173 };
174 
175 static int ir_rx51_set_duty_cycle(struct rc_dev *dev, u32 duty)
176 {
177 	struct ir_rx51 *ir_rx51 = dev->priv;
178 
179 	ir_rx51->duty_cycle = duty;
180 
181 	return 0;
182 }
183 
184 static int ir_rx51_set_tx_carrier(struct rc_dev *dev, u32 carrier)
185 {
186 	struct ir_rx51 *ir_rx51 = dev->priv;
187 
188 	if (carrier > 500000 || carrier < 20000)
189 		return -EINVAL;
190 
191 	ir_rx51->freq = carrier;
192 
193 	return 0;
194 }
195 
196 #ifdef CONFIG_PM
197 
198 static int ir_rx51_suspend(struct platform_device *dev, pm_message_t state)
199 {
200 	/*
201 	 * In case the device is still open, do not suspend. Normally
202 	 * this should not be a problem as lircd only keeps the device
203 	 * open only for short periods of time. We also don't want to
204 	 * get involved with race conditions that might happen if we
205 	 * were in a middle of a transmit. Thus, we defer any suspend
206 	 * actions until transmit has completed.
207 	 */
208 	if (test_and_set_bit(1, &ir_rx51.device_is_open))
209 		return -EAGAIN;
210 
211 	clear_bit(1, &ir_rx51.device_is_open);
212 
213 	return 0;
214 }
215 
216 static int ir_rx51_resume(struct platform_device *dev)
217 {
218 	return 0;
219 }
220 
221 #else
222 
223 #define ir_rx51_suspend	NULL
224 #define ir_rx51_resume	NULL
225 
226 #endif /* CONFIG_PM */
227 
228 static int ir_rx51_probe(struct platform_device *dev)
229 {
230 	struct pwm_device *pwm;
231 	struct rc_dev *rcdev;
232 
233 	pwm = pwm_get(&dev->dev, NULL);
234 	if (IS_ERR(pwm)) {
235 		int err = PTR_ERR(pwm);
236 
237 		if (err != -EPROBE_DEFER)
238 			dev_err(&dev->dev, "pwm_get failed: %d\n", err);
239 		return err;
240 	}
241 
242 	/* Use default, in case userspace does not set the carrier */
243 	ir_rx51.freq = DIV_ROUND_CLOSEST_ULL(pwm_get_period(pwm), NSEC_PER_SEC);
244 	pwm_init_state(pwm, &ir_rx51.state);
245 	pwm_put(pwm);
246 
247 	hrtimer_init(&ir_rx51.timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
248 	ir_rx51.timer.function = ir_rx51_timer_cb;
249 
250 	ir_rx51.dev = &dev->dev;
251 
252 	rcdev = devm_rc_allocate_device(&dev->dev, RC_DRIVER_IR_RAW_TX);
253 	if (!rcdev)
254 		return -ENOMEM;
255 
256 	rcdev->priv = &ir_rx51;
257 	rcdev->open = ir_rx51_open;
258 	rcdev->close = ir_rx51_release;
259 	rcdev->tx_ir = ir_rx51_tx;
260 	rcdev->s_tx_duty_cycle = ir_rx51_set_duty_cycle;
261 	rcdev->s_tx_carrier = ir_rx51_set_tx_carrier;
262 	rcdev->driver_name = KBUILD_MODNAME;
263 
264 	ir_rx51.rcdev = rcdev;
265 
266 	return devm_rc_register_device(&dev->dev, ir_rx51.rcdev);
267 }
268 
269 static int ir_rx51_remove(struct platform_device *dev)
270 {
271 	return 0;
272 }
273 
274 static const struct of_device_id ir_rx51_match[] = {
275 	{
276 		.compatible = "nokia,n900-ir",
277 	},
278 	{},
279 };
280 MODULE_DEVICE_TABLE(of, ir_rx51_match);
281 
282 static struct platform_driver ir_rx51_platform_driver = {
283 	.probe		= ir_rx51_probe,
284 	.remove		= ir_rx51_remove,
285 	.suspend	= ir_rx51_suspend,
286 	.resume		= ir_rx51_resume,
287 	.driver		= {
288 		.name	= KBUILD_MODNAME,
289 		.of_match_table = of_match_ptr(ir_rx51_match),
290 	},
291 };
292 module_platform_driver(ir_rx51_platform_driver);
293 
294 MODULE_DESCRIPTION("IR TX driver for Nokia RX51");
295 MODULE_AUTHOR("Nokia Corporation");
296 MODULE_LICENSE("GPL");
297