1 | // SPDX-License-Identifier: GPL-2.0+ |
2 | /* |
3 | * userspace interface for pi433 radio module |
4 | * |
5 | * Pi433 is a 433MHz radio module for the Raspberry Pi. |
6 | * It is based on the HopeRf Module RFM69CW. Therefore inside of this |
7 | * driver, you'll find an abstraction of the rf69 chip. |
8 | * |
9 | * If needed, this driver could be extended, to also support other |
10 | * devices, basing on HopeRfs rf69. |
11 | * |
12 | * The driver can also be extended, to support other modules of |
13 | * HopeRf with a similar interace - e. g. RFM69HCW, RFM12, RFM95, ... |
14 | * |
15 | * Copyright (C) 2016 Wolf-Entwicklungen |
16 | * Marcus Wolf <linux@wolf-entwicklungen.de> |
17 | */ |
18 | |
19 | #undef DEBUG |
20 | |
21 | #include <linux/init.h> |
22 | #include <linux/module.h> |
23 | #include <linux/idr.h> |
24 | #include <linux/ioctl.h> |
25 | #include <linux/uaccess.h> |
26 | #include <linux/fs.h> |
27 | #include <linux/device.h> |
28 | #include <linux/cdev.h> |
29 | #include <linux/err.h> |
30 | #include <linux/kfifo.h> |
31 | #include <linux/errno.h> |
32 | #include <linux/mutex.h> |
33 | #include <linux/of.h> |
34 | #include <linux/interrupt.h> |
35 | #include <linux/irq.h> |
36 | #include <linux/gpio/consumer.h> |
37 | #include <linux/kthread.h> |
38 | #include <linux/wait.h> |
39 | #include <linux/spi/spi.h> |
40 | #ifdef CONFIG_COMPAT |
41 | #include <linux/compat.h> |
42 | #endif |
43 | #include <linux/debugfs.h> |
44 | #include <linux/seq_file.h> |
45 | |
46 | #include "pi433_if.h" |
47 | #include "rf69.h" |
48 | |
49 | #define N_PI433_MINORS BIT(MINORBITS) /*32*/ /* ... up to 256 */ |
50 | #define MAX_MSG_SIZE 900 /* min: FIFO_SIZE! */ |
51 | #define MSG_FIFO_SIZE 65536 /* 65536 = 2^16 */ |
52 | #define FIFO_THRESHOLD 15 /* bytes */ |
53 | #define NUM_DIO 2 |
54 | |
55 | static dev_t pi433_dev; |
56 | static DEFINE_IDR(pi433_idr); |
57 | static DEFINE_MUTEX(minor_lock); /* Protect idr accesses */ |
58 | static struct dentry *root_dir; /* debugfs root directory for the driver */ |
59 | |
60 | /* mainly for udev to create /dev/pi433 */ |
61 | static const struct class pi433_class = { |
62 | .name = "pi433" , |
63 | }; |
64 | |
65 | /* |
66 | * tx config is instance specific |
67 | * so with each open a new tx config struct is needed |
68 | */ |
69 | /* |
70 | * rx config is device specific |
71 | * so we have just one rx config, ebedded in device struct |
72 | */ |
73 | struct pi433_device { |
74 | /* device handling related values */ |
75 | dev_t devt; |
76 | int minor; |
77 | struct device *dev; |
78 | struct cdev *cdev; |
79 | struct spi_device *spi; |
80 | |
81 | /* irq related values */ |
82 | struct gpio_desc *gpiod[NUM_DIO]; |
83 | int irq_num[NUM_DIO]; |
84 | u8 irq_state[NUM_DIO]; |
85 | |
86 | /* tx related values */ |
87 | STRUCT_KFIFO_REC_1(MSG_FIFO_SIZE) tx_fifo; |
88 | struct mutex tx_fifo_lock; /* serialize userspace writers */ |
89 | struct task_struct *tx_task_struct; |
90 | wait_queue_head_t tx_wait_queue; |
91 | u8 free_in_fifo; |
92 | char buffer[MAX_MSG_SIZE]; |
93 | |
94 | /* rx related values */ |
95 | struct pi433_rx_cfg rx_cfg; |
96 | u8 *rx_buffer; |
97 | unsigned int rx_buffer_size; |
98 | u32 rx_bytes_to_drop; |
99 | u32 rx_bytes_dropped; |
100 | unsigned int rx_position; |
101 | struct mutex rx_lock; /* protects rx_* variable accesses */ |
102 | wait_queue_head_t rx_wait_queue; |
103 | |
104 | /* fifo wait queue */ |
105 | struct task_struct *fifo_task_struct; |
106 | wait_queue_head_t fifo_wait_queue; |
107 | |
108 | /* flags */ |
109 | bool rx_active; |
110 | bool tx_active; |
111 | bool interrupt_rx_allowed; |
112 | }; |
113 | |
114 | struct pi433_instance { |
115 | struct pi433_device *device; |
116 | struct pi433_tx_cfg tx_cfg; |
117 | |
118 | /* control flags */ |
119 | bool tx_cfg_initialized; |
120 | }; |
121 | |
122 | /*-------------------------------------------------------------------------*/ |
123 | |
124 | /* GPIO interrupt handlers */ |
125 | static irqreturn_t DIO0_irq_handler(int irq, void *dev_id) |
126 | { |
127 | struct pi433_device *device = dev_id; |
128 | |
129 | if (device->irq_state[DIO0] == DIO_PACKET_SENT) { |
130 | device->free_in_fifo = FIFO_SIZE; |
131 | dev_dbg(device->dev, "DIO0 irq: Packet sent\n" ); |
132 | wake_up_interruptible(&device->fifo_wait_queue); |
133 | } else if (device->irq_state[DIO0] == DIO_RSSI_DIO0) { |
134 | dev_dbg(device->dev, "DIO0 irq: RSSI level over threshold\n" ); |
135 | wake_up_interruptible(&device->rx_wait_queue); |
136 | } else if (device->irq_state[DIO0] == DIO_PAYLOAD_READY) { |
137 | dev_dbg(device->dev, "DIO0 irq: Payload ready\n" ); |
138 | device->free_in_fifo = 0; |
139 | wake_up_interruptible(&device->fifo_wait_queue); |
140 | } |
141 | |
142 | return IRQ_HANDLED; |
143 | } |
144 | |
145 | static irqreturn_t DIO1_irq_handler(int irq, void *dev_id) |
146 | { |
147 | struct pi433_device *device = dev_id; |
148 | |
149 | if (device->irq_state[DIO1] == DIO_FIFO_NOT_EMPTY_DIO1) { |
150 | device->free_in_fifo = FIFO_SIZE; |
151 | } else if (device->irq_state[DIO1] == DIO_FIFO_LEVEL) { |
152 | if (device->rx_active) |
153 | device->free_in_fifo = FIFO_THRESHOLD - 1; |
154 | else |
155 | device->free_in_fifo = FIFO_SIZE - FIFO_THRESHOLD - 1; |
156 | } |
157 | dev_dbg(device->dev, |
158 | "DIO1 irq: %d bytes free in fifo\n" , device->free_in_fifo); |
159 | wake_up_interruptible(&device->fifo_wait_queue); |
160 | |
161 | return IRQ_HANDLED; |
162 | } |
163 | |
164 | /*-------------------------------------------------------------------------*/ |
165 | |
166 | static int |
167 | rf69_set_rx_cfg(struct pi433_device *dev, struct pi433_rx_cfg *rx_cfg) |
168 | { |
169 | int ret; |
170 | int payload_length; |
171 | |
172 | /* receiver config */ |
173 | ret = rf69_set_frequency(spi: dev->spi, frequency: rx_cfg->frequency); |
174 | if (ret < 0) |
175 | return ret; |
176 | ret = rf69_set_modulation(spi: dev->spi, modulation: rx_cfg->modulation); |
177 | if (ret < 0) |
178 | return ret; |
179 | ret = rf69_set_bit_rate(spi: dev->spi, bit_rate: rx_cfg->bit_rate); |
180 | if (ret < 0) |
181 | return ret; |
182 | ret = rf69_set_antenna_impedance(spi: dev->spi, antenna_impedance: rx_cfg->antenna_impedance); |
183 | if (ret < 0) |
184 | return ret; |
185 | ret = rf69_set_rssi_threshold(spi: dev->spi, threshold: rx_cfg->rssi_threshold); |
186 | if (ret < 0) |
187 | return ret; |
188 | ret = rf69_set_ook_threshold_dec(spi: dev->spi, threshold_decrement: rx_cfg->threshold_decrement); |
189 | if (ret < 0) |
190 | return ret; |
191 | ret = rf69_set_bandwidth(spi: dev->spi, mantisse: rx_cfg->bw_mantisse, |
192 | exponent: rx_cfg->bw_exponent); |
193 | if (ret < 0) |
194 | return ret; |
195 | ret = rf69_set_bandwidth_during_afc(spi: dev->spi, mantisse: rx_cfg->bw_mantisse, |
196 | exponent: rx_cfg->bw_exponent); |
197 | if (ret < 0) |
198 | return ret; |
199 | ret = rf69_set_dagc(spi: dev->spi, dagc: rx_cfg->dagc); |
200 | if (ret < 0) |
201 | return ret; |
202 | |
203 | dev->rx_bytes_to_drop = rx_cfg->bytes_to_drop; |
204 | |
205 | /* packet config */ |
206 | /* enable */ |
207 | if (rx_cfg->enable_sync == OPTION_ON) { |
208 | ret = rf69_enable_sync(spi: dev->spi); |
209 | if (ret < 0) |
210 | return ret; |
211 | |
212 | ret = rf69_set_fifo_fill_condition(spi: dev->spi, |
213 | fifo_fill_condition: after_sync_interrupt); |
214 | if (ret < 0) |
215 | return ret; |
216 | } else { |
217 | ret = rf69_disable_sync(spi: dev->spi); |
218 | if (ret < 0) |
219 | return ret; |
220 | |
221 | ret = rf69_set_fifo_fill_condition(spi: dev->spi, fifo_fill_condition: always); |
222 | if (ret < 0) |
223 | return ret; |
224 | } |
225 | if (rx_cfg->enable_length_byte == OPTION_ON) { |
226 | ret = rf69_set_packet_format(spi: dev->spi, packet_format: packet_length_var); |
227 | if (ret < 0) |
228 | return ret; |
229 | } else { |
230 | ret = rf69_set_packet_format(spi: dev->spi, packet_format: packet_length_fix); |
231 | if (ret < 0) |
232 | return ret; |
233 | } |
234 | ret = rf69_set_address_filtering(spi: dev->spi, |
235 | address_filtering: rx_cfg->enable_address_filtering); |
236 | if (ret < 0) |
237 | return ret; |
238 | |
239 | if (rx_cfg->enable_crc == OPTION_ON) { |
240 | ret = rf69_enable_crc(spi: dev->spi); |
241 | if (ret < 0) |
242 | return ret; |
243 | } else { |
244 | ret = rf69_disable_crc(spi: dev->spi); |
245 | if (ret < 0) |
246 | return ret; |
247 | } |
248 | |
249 | /* lengths */ |
250 | ret = rf69_set_sync_size(spi: dev->spi, sync_size: rx_cfg->sync_length); |
251 | if (ret < 0) |
252 | return ret; |
253 | if (rx_cfg->enable_length_byte == OPTION_ON) { |
254 | ret = rf69_set_payload_length(spi: dev->spi, payload_length: 0xff); |
255 | if (ret < 0) |
256 | return ret; |
257 | } else if (rx_cfg->fixed_message_length != 0) { |
258 | payload_length = rx_cfg->fixed_message_length; |
259 | if (rx_cfg->enable_length_byte == OPTION_ON) |
260 | payload_length++; |
261 | if (rx_cfg->enable_address_filtering != filtering_off) |
262 | payload_length++; |
263 | ret = rf69_set_payload_length(spi: dev->spi, payload_length); |
264 | if (ret < 0) |
265 | return ret; |
266 | } else { |
267 | ret = rf69_set_payload_length(spi: dev->spi, payload_length: 0); |
268 | if (ret < 0) |
269 | return ret; |
270 | } |
271 | |
272 | /* values */ |
273 | if (rx_cfg->enable_sync == OPTION_ON) { |
274 | ret = rf69_set_sync_values(spi: dev->spi, sync_values: rx_cfg->sync_pattern); |
275 | if (ret < 0) |
276 | return ret; |
277 | } |
278 | if (rx_cfg->enable_address_filtering != filtering_off) { |
279 | ret = rf69_set_node_address(spi: dev->spi, node_address: rx_cfg->node_address); |
280 | if (ret < 0) |
281 | return ret; |
282 | ret = rf69_set_broadcast_address(spi: dev->spi, |
283 | broadcast_address: rx_cfg->broadcast_address); |
284 | if (ret < 0) |
285 | return ret; |
286 | } |
287 | |
288 | return 0; |
289 | } |
290 | |
291 | static int |
292 | rf69_set_tx_cfg(struct pi433_device *dev, struct pi433_tx_cfg *tx_cfg) |
293 | { |
294 | int ret; |
295 | |
296 | ret = rf69_set_frequency(spi: dev->spi, frequency: tx_cfg->frequency); |
297 | if (ret < 0) |
298 | return ret; |
299 | ret = rf69_set_modulation(spi: dev->spi, modulation: tx_cfg->modulation); |
300 | if (ret < 0) |
301 | return ret; |
302 | ret = rf69_set_bit_rate(spi: dev->spi, bit_rate: tx_cfg->bit_rate); |
303 | if (ret < 0) |
304 | return ret; |
305 | ret = rf69_set_deviation(spi: dev->spi, deviation: tx_cfg->dev_frequency); |
306 | if (ret < 0) |
307 | return ret; |
308 | ret = rf69_set_pa_ramp(spi: dev->spi, pa_ramp: tx_cfg->pa_ramp); |
309 | if (ret < 0) |
310 | return ret; |
311 | ret = rf69_set_modulation_shaping(spi: dev->spi, mod_shaping: tx_cfg->mod_shaping); |
312 | if (ret < 0) |
313 | return ret; |
314 | ret = rf69_set_tx_start_condition(spi: dev->spi, tx_start_condition: tx_cfg->tx_start_condition); |
315 | if (ret < 0) |
316 | return ret; |
317 | |
318 | /* packet format enable */ |
319 | if (tx_cfg->enable_preamble == OPTION_ON) { |
320 | ret = rf69_set_preamble_length(spi: dev->spi, |
321 | preamble_length: tx_cfg->preamble_length); |
322 | if (ret < 0) |
323 | return ret; |
324 | } else { |
325 | ret = rf69_set_preamble_length(spi: dev->spi, preamble_length: 0); |
326 | if (ret < 0) |
327 | return ret; |
328 | } |
329 | |
330 | if (tx_cfg->enable_sync == OPTION_ON) { |
331 | ret = rf69_set_sync_size(spi: dev->spi, sync_size: tx_cfg->sync_length); |
332 | if (ret < 0) |
333 | return ret; |
334 | ret = rf69_set_sync_values(spi: dev->spi, sync_values: tx_cfg->sync_pattern); |
335 | if (ret < 0) |
336 | return ret; |
337 | ret = rf69_enable_sync(spi: dev->spi); |
338 | if (ret < 0) |
339 | return ret; |
340 | } else { |
341 | ret = rf69_disable_sync(spi: dev->spi); |
342 | if (ret < 0) |
343 | return ret; |
344 | } |
345 | |
346 | if (tx_cfg->enable_length_byte == OPTION_ON) { |
347 | ret = rf69_set_packet_format(spi: dev->spi, packet_format: packet_length_var); |
348 | if (ret < 0) |
349 | return ret; |
350 | } else { |
351 | ret = rf69_set_packet_format(spi: dev->spi, packet_format: packet_length_fix); |
352 | if (ret < 0) |
353 | return ret; |
354 | } |
355 | |
356 | if (tx_cfg->enable_crc == OPTION_ON) { |
357 | ret = rf69_enable_crc(spi: dev->spi); |
358 | if (ret < 0) |
359 | return ret; |
360 | } else { |
361 | ret = rf69_disable_crc(spi: dev->spi); |
362 | if (ret < 0) |
363 | return ret; |
364 | } |
365 | |
366 | return 0; |
367 | } |
368 | |
369 | /*-------------------------------------------------------------------------*/ |
370 | |
371 | static int pi433_start_rx(struct pi433_device *dev) |
372 | { |
373 | int retval; |
374 | |
375 | /* return without action, if no pending read request */ |
376 | if (!dev->rx_active) |
377 | return 0; |
378 | |
379 | /* setup for receiving */ |
380 | retval = rf69_set_rx_cfg(dev, rx_cfg: &dev->rx_cfg); |
381 | if (retval) |
382 | return retval; |
383 | |
384 | /* setup rssi irq */ |
385 | retval = rf69_set_dio_mapping(spi: dev->spi, DIO0, DIO_RSSI_DIO0); |
386 | if (retval < 0) |
387 | return retval; |
388 | dev->irq_state[DIO0] = DIO_RSSI_DIO0; |
389 | irq_set_irq_type(irq: dev->irq_num[DIO0], type: IRQ_TYPE_EDGE_RISING); |
390 | |
391 | /* setup fifo level interrupt */ |
392 | retval = rf69_set_fifo_threshold(spi: dev->spi, FIFO_SIZE - FIFO_THRESHOLD); |
393 | if (retval < 0) |
394 | return retval; |
395 | retval = rf69_set_dio_mapping(spi: dev->spi, DIO1, DIO_FIFO_LEVEL); |
396 | if (retval < 0) |
397 | return retval; |
398 | dev->irq_state[DIO1] = DIO_FIFO_LEVEL; |
399 | irq_set_irq_type(irq: dev->irq_num[DIO1], type: IRQ_TYPE_EDGE_RISING); |
400 | |
401 | /* set module to receiving mode */ |
402 | retval = rf69_set_mode(spi: dev->spi, mode: receive); |
403 | if (retval < 0) |
404 | return retval; |
405 | |
406 | return 0; |
407 | } |
408 | |
409 | /*-------------------------------------------------------------------------*/ |
410 | |
411 | static int pi433_receive(void *data) |
412 | { |
413 | struct pi433_device *dev = data; |
414 | struct spi_device *spi = dev->spi; |
415 | int bytes_to_read, bytes_total; |
416 | int retval; |
417 | |
418 | dev->interrupt_rx_allowed = false; |
419 | |
420 | /* wait for any tx to finish */ |
421 | dev_dbg(dev->dev, "rx: going to wait for any tx to finish\n" ); |
422 | retval = wait_event_interruptible(dev->rx_wait_queue, !dev->tx_active); |
423 | if (retval) { |
424 | /* wait was interrupted */ |
425 | dev->interrupt_rx_allowed = true; |
426 | wake_up_interruptible(&dev->tx_wait_queue); |
427 | return retval; |
428 | } |
429 | |
430 | /* prepare status vars */ |
431 | dev->free_in_fifo = FIFO_SIZE; |
432 | dev->rx_position = 0; |
433 | dev->rx_bytes_dropped = 0; |
434 | |
435 | /* setup radio module to listen for something "in the air" */ |
436 | retval = pi433_start_rx(dev); |
437 | if (retval) |
438 | return retval; |
439 | |
440 | /* now check RSSI, if low wait for getting high (RSSI interrupt) */ |
441 | while (!(rf69_read_reg(spi, REG_IRQFLAGS1) & MASK_IRQFLAGS1_RSSI)) { |
442 | /* allow tx to interrupt us while waiting for high RSSI */ |
443 | dev->interrupt_rx_allowed = true; |
444 | wake_up_interruptible(&dev->tx_wait_queue); |
445 | |
446 | /* wait for RSSI level to become high */ |
447 | dev_dbg(dev->dev, "rx: going to wait for high RSSI level\n" ); |
448 | retval = wait_event_interruptible(dev->rx_wait_queue, |
449 | rf69_read_reg(spi, REG_IRQFLAGS1) & |
450 | MASK_IRQFLAGS1_RSSI); |
451 | if (retval) /* wait was interrupted */ |
452 | goto abort; |
453 | dev->interrupt_rx_allowed = false; |
454 | |
455 | /* cross check for ongoing tx */ |
456 | if (!dev->tx_active) |
457 | break; |
458 | } |
459 | |
460 | /* configure payload ready irq */ |
461 | retval = rf69_set_dio_mapping(spi, DIO0, DIO_PAYLOAD_READY); |
462 | if (retval < 0) |
463 | goto abort; |
464 | dev->irq_state[DIO0] = DIO_PAYLOAD_READY; |
465 | irq_set_irq_type(irq: dev->irq_num[DIO0], type: IRQ_TYPE_EDGE_RISING); |
466 | |
467 | /* fixed or unlimited length? */ |
468 | if (dev->rx_cfg.fixed_message_length != 0) { |
469 | if (dev->rx_cfg.fixed_message_length > dev->rx_buffer_size) { |
470 | retval = -1; |
471 | goto abort; |
472 | } |
473 | bytes_total = dev->rx_cfg.fixed_message_length; |
474 | dev_dbg(dev->dev, "rx: msg len set to %d by fixed length\n" , |
475 | bytes_total); |
476 | } else { |
477 | bytes_total = dev->rx_buffer_size; |
478 | dev_dbg(dev->dev, "rx: msg len set to %d as requested by read\n" , |
479 | bytes_total); |
480 | } |
481 | |
482 | /* length byte enabled? */ |
483 | if (dev->rx_cfg.enable_length_byte == OPTION_ON) { |
484 | retval = wait_event_interruptible(dev->fifo_wait_queue, |
485 | dev->free_in_fifo < FIFO_SIZE); |
486 | if (retval) /* wait was interrupted */ |
487 | goto abort; |
488 | |
489 | rf69_read_fifo(spi, buffer: (u8 *)&bytes_total, size: 1); |
490 | if (bytes_total > dev->rx_buffer_size) { |
491 | retval = -1; |
492 | goto abort; |
493 | } |
494 | dev->free_in_fifo++; |
495 | dev_dbg(dev->dev, "rx: msg len reset to %d due to length byte\n" , |
496 | bytes_total); |
497 | } |
498 | |
499 | /* address byte enabled? */ |
500 | if (dev->rx_cfg.enable_address_filtering != filtering_off) { |
501 | u8 dummy; |
502 | |
503 | bytes_total--; |
504 | |
505 | retval = wait_event_interruptible(dev->fifo_wait_queue, |
506 | dev->free_in_fifo < FIFO_SIZE); |
507 | if (retval) /* wait was interrupted */ |
508 | goto abort; |
509 | |
510 | rf69_read_fifo(spi, buffer: &dummy, size: 1); |
511 | dev->free_in_fifo++; |
512 | dev_dbg(dev->dev, "rx: address byte stripped off\n" ); |
513 | } |
514 | |
515 | /* get payload */ |
516 | while (dev->rx_position < bytes_total) { |
517 | if (!(rf69_read_reg(spi, REG_IRQFLAGS2) & MASK_IRQFLAGS2_PAYLOAD_READY)) { |
518 | retval = wait_event_interruptible(dev->fifo_wait_queue, |
519 | dev->free_in_fifo < FIFO_SIZE); |
520 | if (retval) /* wait was interrupted */ |
521 | goto abort; |
522 | } |
523 | |
524 | /* need to drop bytes or acquire? */ |
525 | if (dev->rx_bytes_to_drop > dev->rx_bytes_dropped) |
526 | bytes_to_read = dev->rx_bytes_to_drop - |
527 | dev->rx_bytes_dropped; |
528 | else |
529 | bytes_to_read = bytes_total - dev->rx_position; |
530 | |
531 | /* access the fifo */ |
532 | if (bytes_to_read > FIFO_SIZE - dev->free_in_fifo) |
533 | bytes_to_read = FIFO_SIZE - dev->free_in_fifo; |
534 | retval = rf69_read_fifo(spi, |
535 | buffer: &dev->rx_buffer[dev->rx_position], |
536 | size: bytes_to_read); |
537 | if (retval) /* read failed */ |
538 | goto abort; |
539 | |
540 | dev->free_in_fifo += bytes_to_read; |
541 | |
542 | /* adjust status vars */ |
543 | if (dev->rx_bytes_to_drop > dev->rx_bytes_dropped) |
544 | dev->rx_bytes_dropped += bytes_to_read; |
545 | else |
546 | dev->rx_position += bytes_to_read; |
547 | } |
548 | |
549 | /* rx done, wait was interrupted or error occurred */ |
550 | abort: |
551 | dev->interrupt_rx_allowed = true; |
552 | if (rf69_set_mode(spi: dev->spi, mode: standby)) |
553 | pr_err("rf69_set_mode(): radio module failed to go standby\n" ); |
554 | wake_up_interruptible(&dev->tx_wait_queue); |
555 | |
556 | if (retval) |
557 | return retval; |
558 | else |
559 | return bytes_total; |
560 | } |
561 | |
562 | static int pi433_tx_thread(void *data) |
563 | { |
564 | struct pi433_device *device = data; |
565 | struct spi_device *spi = device->spi; |
566 | struct pi433_tx_cfg tx_cfg; |
567 | size_t size; |
568 | bool rx_interrupted = false; |
569 | int position, repetitions; |
570 | int retval; |
571 | |
572 | while (1) { |
573 | /* wait for fifo to be populated or for request to terminate*/ |
574 | dev_dbg(device->dev, "thread: going to wait for new messages\n" ); |
575 | wait_event_interruptible(device->tx_wait_queue, |
576 | (!kfifo_is_empty(&device->tx_fifo) || |
577 | kthread_should_stop())); |
578 | if (kthread_should_stop()) |
579 | return 0; |
580 | |
581 | /* |
582 | * get data from fifo in the following order: |
583 | * - tx_cfg |
584 | * - size of message |
585 | * - message |
586 | */ |
587 | retval = kfifo_out(&device->tx_fifo, &tx_cfg, sizeof(tx_cfg)); |
588 | if (retval != sizeof(tx_cfg)) { |
589 | dev_dbg(device->dev, |
590 | "reading tx_cfg from fifo failed: got %d byte(s), expected %d\n" , |
591 | retval, (unsigned int)sizeof(tx_cfg)); |
592 | continue; |
593 | } |
594 | |
595 | retval = kfifo_out(&device->tx_fifo, &size, sizeof(size_t)); |
596 | if (retval != sizeof(size_t)) { |
597 | dev_dbg(device->dev, |
598 | "reading msg size from fifo failed: got %d, expected %d\n" , |
599 | retval, (unsigned int)sizeof(size_t)); |
600 | continue; |
601 | } |
602 | |
603 | /* use fixed message length, if requested */ |
604 | if (tx_cfg.fixed_message_length != 0) |
605 | size = tx_cfg.fixed_message_length; |
606 | |
607 | /* increase size, if len byte is requested */ |
608 | if (tx_cfg.enable_length_byte == OPTION_ON) |
609 | size++; |
610 | |
611 | /* increase size, if adr byte is requested */ |
612 | if (tx_cfg.enable_address_byte == OPTION_ON) |
613 | size++; |
614 | |
615 | /* prime buffer */ |
616 | memset(device->buffer, 0, size); |
617 | position = 0; |
618 | |
619 | /* add length byte, if requested */ |
620 | if (tx_cfg.enable_length_byte == OPTION_ON) |
621 | /* |
622 | * according to spec, length byte itself must be |
623 | * excluded from the length calculation |
624 | */ |
625 | device->buffer[position++] = size - 1; |
626 | |
627 | /* add adr byte, if requested */ |
628 | if (tx_cfg.enable_address_byte == OPTION_ON) |
629 | device->buffer[position++] = tx_cfg.address_byte; |
630 | |
631 | /* finally get message data from fifo */ |
632 | retval = kfifo_out(&device->tx_fifo, &device->buffer[position], |
633 | sizeof(device->buffer) - position); |
634 | dev_dbg(device->dev, |
635 | "read %d message byte(s) from fifo queue.\n" , retval); |
636 | |
637 | /* |
638 | * if rx is active, we need to interrupt the waiting for |
639 | * incoming telegrams, to be able to send something. |
640 | * We are only allowed, if currently no reception takes |
641 | * place otherwise we need to wait for the incoming telegram |
642 | * to finish |
643 | */ |
644 | wait_event_interruptible(device->tx_wait_queue, |
645 | !device->rx_active || |
646 | device->interrupt_rx_allowed); |
647 | |
648 | /* |
649 | * prevent race conditions |
650 | * irq will be reenabled after tx config is set |
651 | */ |
652 | disable_irq(irq: device->irq_num[DIO0]); |
653 | device->tx_active = true; |
654 | |
655 | /* clear fifo, set fifo threshold, set payload length */ |
656 | retval = rf69_set_mode(spi, mode: standby); /* this clears the fifo */ |
657 | if (retval < 0) |
658 | goto abort; |
659 | |
660 | if (device->rx_active && !rx_interrupted) { |
661 | /* |
662 | * rx is currently waiting for a telegram; |
663 | * we need to set the radio module to standby |
664 | */ |
665 | rx_interrupted = true; |
666 | } |
667 | |
668 | retval = rf69_set_fifo_threshold(spi, FIFO_THRESHOLD); |
669 | if (retval < 0) |
670 | goto abort; |
671 | if (tx_cfg.enable_length_byte == OPTION_ON) { |
672 | retval = rf69_set_payload_length(spi, payload_length: size * tx_cfg.repetitions); |
673 | if (retval < 0) |
674 | goto abort; |
675 | } else { |
676 | retval = rf69_set_payload_length(spi, payload_length: 0); |
677 | if (retval < 0) |
678 | goto abort; |
679 | } |
680 | |
681 | /* configure the rf chip */ |
682 | retval = rf69_set_tx_cfg(dev: device, tx_cfg: &tx_cfg); |
683 | if (retval < 0) |
684 | goto abort; |
685 | |
686 | /* enable fifo level interrupt */ |
687 | retval = rf69_set_dio_mapping(spi, DIO1, DIO_FIFO_LEVEL); |
688 | if (retval < 0) |
689 | goto abort; |
690 | device->irq_state[DIO1] = DIO_FIFO_LEVEL; |
691 | irq_set_irq_type(irq: device->irq_num[DIO1], type: IRQ_TYPE_EDGE_FALLING); |
692 | |
693 | /* enable packet sent interrupt */ |
694 | retval = rf69_set_dio_mapping(spi, DIO0, DIO_PACKET_SENT); |
695 | if (retval < 0) |
696 | goto abort; |
697 | device->irq_state[DIO0] = DIO_PACKET_SENT; |
698 | irq_set_irq_type(irq: device->irq_num[DIO0], type: IRQ_TYPE_EDGE_RISING); |
699 | enable_irq(irq: device->irq_num[DIO0]); /* was disabled by rx active check */ |
700 | |
701 | /* enable transmission */ |
702 | retval = rf69_set_mode(spi, mode: transmit); |
703 | if (retval < 0) |
704 | goto abort; |
705 | |
706 | /* transfer this msg (and repetitions) to chip fifo */ |
707 | device->free_in_fifo = FIFO_SIZE; |
708 | position = 0; |
709 | repetitions = tx_cfg.repetitions; |
710 | while ((repetitions > 0) && (size > position)) { |
711 | if ((size - position) > device->free_in_fifo) { |
712 | /* msg to big for fifo - take a part */ |
713 | int write_size = device->free_in_fifo; |
714 | |
715 | device->free_in_fifo = 0; |
716 | rf69_write_fifo(spi, |
717 | buffer: &device->buffer[position], |
718 | size: write_size); |
719 | position += write_size; |
720 | } else { |
721 | /* msg fits into fifo - take all */ |
722 | device->free_in_fifo -= size; |
723 | repetitions--; |
724 | rf69_write_fifo(spi, |
725 | buffer: &device->buffer[position], |
726 | size: (size - position)); |
727 | position = 0; /* reset for next repetition */ |
728 | } |
729 | |
730 | retval = wait_event_interruptible(device->fifo_wait_queue, |
731 | device->free_in_fifo > 0); |
732 | if (retval) { |
733 | dev_dbg(device->dev, "ABORT\n" ); |
734 | goto abort; |
735 | } |
736 | } |
737 | |
738 | /* we are done. Wait for packet to get sent */ |
739 | dev_dbg(device->dev, |
740 | "thread: wait for packet to get sent/fifo to be empty\n" ); |
741 | wait_event_interruptible(device->fifo_wait_queue, |
742 | device->free_in_fifo == FIFO_SIZE || |
743 | kthread_should_stop()); |
744 | if (kthread_should_stop()) |
745 | return 0; |
746 | |
747 | /* STOP_TRANSMISSION */ |
748 | dev_dbg(device->dev, "thread: Packet sent. Set mode to stby.\n" ); |
749 | retval = rf69_set_mode(spi, mode: standby); |
750 | if (retval < 0) |
751 | goto abort; |
752 | |
753 | /* everything sent? */ |
754 | if (kfifo_is_empty(&device->tx_fifo)) { |
755 | abort: |
756 | if (rx_interrupted) { |
757 | rx_interrupted = false; |
758 | pi433_start_rx(dev: device); |
759 | } |
760 | device->tx_active = false; |
761 | wake_up_interruptible(&device->rx_wait_queue); |
762 | } |
763 | } |
764 | } |
765 | |
766 | /*-------------------------------------------------------------------------*/ |
767 | |
768 | static ssize_t |
769 | pi433_read(struct file *filp, char __user *buf, size_t size, loff_t *f_pos) |
770 | { |
771 | struct pi433_instance *instance; |
772 | struct pi433_device *device; |
773 | int bytes_received; |
774 | ssize_t retval; |
775 | |
776 | /* check, whether internal buffer is big enough for requested size */ |
777 | if (size > MAX_MSG_SIZE) |
778 | return -EMSGSIZE; |
779 | |
780 | instance = filp->private_data; |
781 | device = instance->device; |
782 | |
783 | /* just one read request at a time */ |
784 | mutex_lock(&device->rx_lock); |
785 | if (device->rx_active) { |
786 | mutex_unlock(lock: &device->rx_lock); |
787 | return -EAGAIN; |
788 | } |
789 | |
790 | device->rx_active = true; |
791 | mutex_unlock(lock: &device->rx_lock); |
792 | |
793 | /* start receiving */ |
794 | /* will block until something was received*/ |
795 | device->rx_buffer_size = size; |
796 | bytes_received = pi433_receive(data: device); |
797 | |
798 | /* release rx */ |
799 | mutex_lock(&device->rx_lock); |
800 | device->rx_active = false; |
801 | mutex_unlock(lock: &device->rx_lock); |
802 | |
803 | /* if read was successful copy to user space*/ |
804 | if (bytes_received > 0) { |
805 | retval = copy_to_user(to: buf, from: device->rx_buffer, n: bytes_received); |
806 | if (retval) |
807 | return -EFAULT; |
808 | } |
809 | |
810 | return bytes_received; |
811 | } |
812 | |
813 | static ssize_t |
814 | pi433_write(struct file *filp, const char __user *buf, |
815 | size_t count, loff_t *f_pos) |
816 | { |
817 | struct pi433_instance *instance; |
818 | struct pi433_device *device; |
819 | int retval; |
820 | unsigned int required, available, copied; |
821 | |
822 | instance = filp->private_data; |
823 | device = instance->device; |
824 | |
825 | /* |
826 | * check, whether internal buffer (tx thread) is big enough |
827 | * for requested size |
828 | */ |
829 | if (count > MAX_MSG_SIZE) |
830 | return -EMSGSIZE; |
831 | |
832 | /* |
833 | * check if tx_cfg has been initialized otherwise we won't be able to |
834 | * config the RF trasmitter correctly due to invalid settings |
835 | */ |
836 | if (!instance->tx_cfg_initialized) { |
837 | dev_notice_once(device->dev, |
838 | "write: failed due to unconfigured tx_cfg (see PI433_IOC_WR_TX_CFG)\n" ); |
839 | return -EINVAL; |
840 | } |
841 | |
842 | /* |
843 | * write the following sequence into fifo: |
844 | * - tx_cfg |
845 | * - size of message |
846 | * - message |
847 | */ |
848 | mutex_lock(&device->tx_fifo_lock); |
849 | |
850 | required = sizeof(instance->tx_cfg) + sizeof(size_t) + count; |
851 | available = kfifo_avail(&device->tx_fifo); |
852 | if (required > available) { |
853 | dev_dbg(device->dev, "write to fifo failed: %d bytes required but %d available\n" , |
854 | required, available); |
855 | mutex_unlock(lock: &device->tx_fifo_lock); |
856 | return -EAGAIN; |
857 | } |
858 | |
859 | retval = kfifo_in(&device->tx_fifo, &instance->tx_cfg, |
860 | sizeof(instance->tx_cfg)); |
861 | if (retval != sizeof(instance->tx_cfg)) |
862 | goto abort; |
863 | |
864 | retval = kfifo_in(&device->tx_fifo, &count, sizeof(size_t)); |
865 | if (retval != sizeof(size_t)) |
866 | goto abort; |
867 | |
868 | retval = kfifo_from_user(&device->tx_fifo, buf, count, &copied); |
869 | if (retval || copied != count) |
870 | goto abort; |
871 | |
872 | mutex_unlock(lock: &device->tx_fifo_lock); |
873 | |
874 | /* start transfer */ |
875 | wake_up_interruptible(&device->tx_wait_queue); |
876 | dev_dbg(device->dev, "write: generated new msg with %d bytes.\n" , copied); |
877 | |
878 | return copied; |
879 | |
880 | abort: |
881 | dev_warn(device->dev, |
882 | "write to fifo failed, non recoverable: 0x%x\n" , retval); |
883 | mutex_unlock(lock: &device->tx_fifo_lock); |
884 | return -EAGAIN; |
885 | } |
886 | |
887 | static long pi433_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) |
888 | { |
889 | struct pi433_instance *instance; |
890 | struct pi433_device *device; |
891 | struct pi433_tx_cfg tx_cfg; |
892 | void __user *argp = (void __user *)arg; |
893 | |
894 | /* Check type and command number */ |
895 | if (_IOC_TYPE(cmd) != PI433_IOC_MAGIC) |
896 | return -ENOTTY; |
897 | |
898 | instance = filp->private_data; |
899 | device = instance->device; |
900 | |
901 | if (!device) |
902 | return -ESHUTDOWN; |
903 | |
904 | switch (cmd) { |
905 | case PI433_IOC_RD_TX_CFG: |
906 | if (copy_to_user(to: argp, from: &instance->tx_cfg, |
907 | n: sizeof(struct pi433_tx_cfg))) |
908 | return -EFAULT; |
909 | break; |
910 | case PI433_IOC_WR_TX_CFG: |
911 | if (copy_from_user(to: &tx_cfg, from: argp, n: sizeof(struct pi433_tx_cfg))) |
912 | return -EFAULT; |
913 | mutex_lock(&device->tx_fifo_lock); |
914 | memcpy(&instance->tx_cfg, &tx_cfg, sizeof(struct pi433_tx_cfg)); |
915 | instance->tx_cfg_initialized = true; |
916 | mutex_unlock(lock: &device->tx_fifo_lock); |
917 | break; |
918 | case PI433_IOC_RD_RX_CFG: |
919 | if (copy_to_user(to: argp, from: &device->rx_cfg, |
920 | n: sizeof(struct pi433_rx_cfg))) |
921 | return -EFAULT; |
922 | break; |
923 | case PI433_IOC_WR_RX_CFG: |
924 | mutex_lock(&device->rx_lock); |
925 | |
926 | /* during pendig read request, change of config not allowed */ |
927 | if (device->rx_active) { |
928 | mutex_unlock(lock: &device->rx_lock); |
929 | return -EAGAIN; |
930 | } |
931 | |
932 | if (copy_from_user(to: &device->rx_cfg, from: argp, |
933 | n: sizeof(struct pi433_rx_cfg))) { |
934 | mutex_unlock(lock: &device->rx_lock); |
935 | return -EFAULT; |
936 | } |
937 | |
938 | mutex_unlock(lock: &device->rx_lock); |
939 | break; |
940 | default: |
941 | return -EINVAL; |
942 | } |
943 | |
944 | return 0; |
945 | } |
946 | |
947 | /*-------------------------------------------------------------------------*/ |
948 | |
949 | static int pi433_open(struct inode *inode, struct file *filp) |
950 | { |
951 | struct pi433_device *device; |
952 | struct pi433_instance *instance; |
953 | |
954 | mutex_lock(&minor_lock); |
955 | device = idr_find(&pi433_idr, id: iminor(inode)); |
956 | mutex_unlock(lock: &minor_lock); |
957 | if (!device) { |
958 | pr_debug("device: minor %d unknown.\n" , iminor(inode)); |
959 | return -ENODEV; |
960 | } |
961 | |
962 | instance = kzalloc(size: sizeof(*instance), GFP_KERNEL); |
963 | if (!instance) |
964 | return -ENOMEM; |
965 | |
966 | /* setup instance data*/ |
967 | instance->device = device; |
968 | |
969 | /* instance data as context */ |
970 | filp->private_data = instance; |
971 | stream_open(inode, filp); |
972 | |
973 | return 0; |
974 | } |
975 | |
976 | static int pi433_release(struct inode *inode, struct file *filp) |
977 | { |
978 | struct pi433_instance *instance; |
979 | |
980 | instance = filp->private_data; |
981 | kfree(objp: instance); |
982 | filp->private_data = NULL; |
983 | |
984 | return 0; |
985 | } |
986 | |
987 | /*-------------------------------------------------------------------------*/ |
988 | |
989 | static int setup_gpio(struct pi433_device *device) |
990 | { |
991 | char name[5]; |
992 | int retval; |
993 | int i; |
994 | const irq_handler_t DIO_irq_handler[NUM_DIO] = { |
995 | DIO0_irq_handler, |
996 | DIO1_irq_handler |
997 | }; |
998 | |
999 | for (i = 0; i < NUM_DIO; i++) { |
1000 | /* "construct" name and get the gpio descriptor */ |
1001 | snprintf(buf: name, size: sizeof(name), fmt: "DIO%d" , i); |
1002 | device->gpiod[i] = gpiod_get(dev: &device->spi->dev, con_id: name, |
1003 | flags: 0 /*GPIOD_IN*/); |
1004 | |
1005 | if (device->gpiod[i] == ERR_PTR(error: -ENOENT)) { |
1006 | dev_dbg(&device->spi->dev, |
1007 | "Could not find entry for %s. Ignoring.\n" , name); |
1008 | continue; |
1009 | } |
1010 | |
1011 | if (device->gpiod[i] == ERR_PTR(error: -EBUSY)) |
1012 | dev_dbg(&device->spi->dev, "%s is busy.\n" , name); |
1013 | |
1014 | if (IS_ERR(ptr: device->gpiod[i])) { |
1015 | retval = PTR_ERR(ptr: device->gpiod[i]); |
1016 | /* release already allocated gpios */ |
1017 | for (i--; i >= 0; i--) { |
1018 | free_irq(device->irq_num[i], device); |
1019 | gpiod_put(desc: device->gpiod[i]); |
1020 | } |
1021 | return retval; |
1022 | } |
1023 | |
1024 | /* configure the pin */ |
1025 | retval = gpiod_direction_input(desc: device->gpiod[i]); |
1026 | if (retval) |
1027 | return retval; |
1028 | |
1029 | /* configure irq */ |
1030 | device->irq_num[i] = gpiod_to_irq(desc: device->gpiod[i]); |
1031 | if (device->irq_num[i] < 0) { |
1032 | device->gpiod[i] = ERR_PTR(error: -EINVAL); |
1033 | return device->irq_num[i]; |
1034 | } |
1035 | retval = request_irq(irq: device->irq_num[i], |
1036 | handler: DIO_irq_handler[i], |
1037 | flags: 0, /* flags */ |
1038 | name, |
1039 | dev: device); |
1040 | |
1041 | if (retval) |
1042 | return retval; |
1043 | |
1044 | dev_dbg(&device->spi->dev, "%s successfully configured\n" , name); |
1045 | } |
1046 | |
1047 | return 0; |
1048 | } |
1049 | |
1050 | static void free_gpio(struct pi433_device *device) |
1051 | { |
1052 | int i; |
1053 | |
1054 | for (i = 0; i < NUM_DIO; i++) { |
1055 | /* check if gpiod is valid */ |
1056 | if (IS_ERR(ptr: device->gpiod[i])) |
1057 | continue; |
1058 | |
1059 | free_irq(device->irq_num[i], device); |
1060 | gpiod_put(desc: device->gpiod[i]); |
1061 | } |
1062 | } |
1063 | |
1064 | static int pi433_get_minor(struct pi433_device *device) |
1065 | { |
1066 | int retval = -ENOMEM; |
1067 | |
1068 | mutex_lock(&minor_lock); |
1069 | retval = idr_alloc(&pi433_idr, ptr: device, start: 0, N_PI433_MINORS, GFP_KERNEL); |
1070 | if (retval >= 0) { |
1071 | device->minor = retval; |
1072 | retval = 0; |
1073 | } else if (retval == -ENOSPC) { |
1074 | dev_err(&device->spi->dev, "too many pi433 devices\n" ); |
1075 | retval = -EINVAL; |
1076 | } |
1077 | mutex_unlock(lock: &minor_lock); |
1078 | return retval; |
1079 | } |
1080 | |
1081 | static void pi433_free_minor(struct pi433_device *dev) |
1082 | { |
1083 | mutex_lock(&minor_lock); |
1084 | idr_remove(&pi433_idr, id: dev->minor); |
1085 | mutex_unlock(lock: &minor_lock); |
1086 | } |
1087 | |
1088 | /*-------------------------------------------------------------------------*/ |
1089 | |
1090 | static const struct file_operations pi433_fops = { |
1091 | .owner = THIS_MODULE, |
1092 | /* |
1093 | * REVISIT switch to aio primitives, so that userspace |
1094 | * gets more complete API coverage. It'll simplify things |
1095 | * too, except for the locking. |
1096 | */ |
1097 | .write = pi433_write, |
1098 | .read = pi433_read, |
1099 | .unlocked_ioctl = pi433_ioctl, |
1100 | .compat_ioctl = compat_ptr_ioctl, |
1101 | .open = pi433_open, |
1102 | .release = pi433_release, |
1103 | .llseek = no_llseek, |
1104 | }; |
1105 | |
1106 | static int pi433_debugfs_regs_show(struct seq_file *m, void *p) |
1107 | { |
1108 | struct pi433_device *dev; |
1109 | u8 reg_data[114]; |
1110 | int i; |
1111 | char *fmt = "0x%02x, 0x%02x\n" ; |
1112 | int ret; |
1113 | |
1114 | dev = m->private; |
1115 | |
1116 | mutex_lock(&dev->tx_fifo_lock); |
1117 | mutex_lock(&dev->rx_lock); |
1118 | |
1119 | // wait for on-going operations to finish |
1120 | ret = wait_event_interruptible(dev->rx_wait_queue, !dev->tx_active); |
1121 | if (ret) |
1122 | goto out_unlock; |
1123 | |
1124 | ret = wait_event_interruptible(dev->tx_wait_queue, !dev->rx_active); |
1125 | if (ret) |
1126 | goto out_unlock; |
1127 | |
1128 | // skip FIFO register (0x0) otherwise this can affect some of uC ops |
1129 | for (i = 1; i < 0x50; i++) |
1130 | reg_data[i] = rf69_read_reg(spi: dev->spi, addr: i); |
1131 | |
1132 | reg_data[REG_TESTLNA] = rf69_read_reg(spi: dev->spi, REG_TESTLNA); |
1133 | reg_data[REG_TESTPA1] = rf69_read_reg(spi: dev->spi, REG_TESTPA1); |
1134 | reg_data[REG_TESTPA2] = rf69_read_reg(spi: dev->spi, REG_TESTPA2); |
1135 | reg_data[REG_TESTDAGC] = rf69_read_reg(spi: dev->spi, REG_TESTDAGC); |
1136 | reg_data[REG_TESTAFC] = rf69_read_reg(spi: dev->spi, REG_TESTAFC); |
1137 | |
1138 | seq_puts(m, s: "# reg, val\n" ); |
1139 | |
1140 | for (i = 1; i < 0x50; i++) |
1141 | seq_printf(m, fmt, i, reg_data[i]); |
1142 | |
1143 | seq_printf(m, fmt, REG_TESTLNA, reg_data[REG_TESTLNA]); |
1144 | seq_printf(m, fmt, REG_TESTPA1, reg_data[REG_TESTPA1]); |
1145 | seq_printf(m, fmt, REG_TESTPA2, reg_data[REG_TESTPA2]); |
1146 | seq_printf(m, fmt, REG_TESTDAGC, reg_data[REG_TESTDAGC]); |
1147 | seq_printf(m, fmt, REG_TESTAFC, reg_data[REG_TESTAFC]); |
1148 | |
1149 | out_unlock: |
1150 | mutex_unlock(lock: &dev->rx_lock); |
1151 | mutex_unlock(lock: &dev->tx_fifo_lock); |
1152 | |
1153 | return ret; |
1154 | } |
1155 | DEFINE_SHOW_ATTRIBUTE(pi433_debugfs_regs); |
1156 | |
1157 | /*-------------------------------------------------------------------------*/ |
1158 | |
1159 | static int pi433_probe(struct spi_device *spi) |
1160 | { |
1161 | struct pi433_device *device; |
1162 | int retval; |
1163 | struct dentry *entry; |
1164 | |
1165 | /* setup spi parameters */ |
1166 | spi->mode = 0x00; |
1167 | spi->bits_per_word = 8; |
1168 | /* |
1169 | * spi->max_speed_hz = 10000000; |
1170 | * 1MHz already set by device tree overlay |
1171 | */ |
1172 | |
1173 | retval = spi_setup(spi); |
1174 | if (retval) { |
1175 | dev_dbg(&spi->dev, "configuration of SPI interface failed!\n" ); |
1176 | return retval; |
1177 | } |
1178 | |
1179 | dev_dbg(&spi->dev, |
1180 | "spi interface setup: mode 0x%2x, %d bits per word, %dhz max speed\n" , |
1181 | spi->mode, spi->bits_per_word, spi->max_speed_hz); |
1182 | |
1183 | /* read chip version */ |
1184 | retval = rf69_get_version(spi); |
1185 | if (retval < 0) |
1186 | return retval; |
1187 | |
1188 | switch (retval) { |
1189 | case 0x24: |
1190 | dev_dbg(&spi->dev, "found pi433 (ver. 0x%x)\n" , retval); |
1191 | break; |
1192 | default: |
1193 | dev_dbg(&spi->dev, "unknown chip version: 0x%x\n" , retval); |
1194 | return -ENODEV; |
1195 | } |
1196 | |
1197 | /* Allocate driver data */ |
1198 | device = kzalloc(size: sizeof(*device), GFP_KERNEL); |
1199 | if (!device) |
1200 | return -ENOMEM; |
1201 | |
1202 | /* Initialize the driver data */ |
1203 | device->spi = spi; |
1204 | device->rx_active = false; |
1205 | device->tx_active = false; |
1206 | device->interrupt_rx_allowed = false; |
1207 | |
1208 | /* init rx buffer */ |
1209 | device->rx_buffer = kmalloc(MAX_MSG_SIZE, GFP_KERNEL); |
1210 | if (!device->rx_buffer) { |
1211 | retval = -ENOMEM; |
1212 | goto RX_failed; |
1213 | } |
1214 | |
1215 | /* init wait queues */ |
1216 | init_waitqueue_head(&device->tx_wait_queue); |
1217 | init_waitqueue_head(&device->rx_wait_queue); |
1218 | init_waitqueue_head(&device->fifo_wait_queue); |
1219 | |
1220 | /* init fifo */ |
1221 | INIT_KFIFO(device->tx_fifo); |
1222 | |
1223 | /* init mutexes and locks */ |
1224 | mutex_init(&device->tx_fifo_lock); |
1225 | mutex_init(&device->rx_lock); |
1226 | |
1227 | /* setup GPIO (including irq_handler) for the different DIOs */ |
1228 | retval = setup_gpio(device); |
1229 | if (retval) { |
1230 | dev_dbg(&spi->dev, "setup of GPIOs failed\n" ); |
1231 | goto GPIO_failed; |
1232 | } |
1233 | |
1234 | /* setup the radio module */ |
1235 | retval = rf69_set_mode(spi, mode: standby); |
1236 | if (retval < 0) |
1237 | goto minor_failed; |
1238 | retval = rf69_set_data_mode(spi, DATAMODUL_MODE_PACKET); |
1239 | if (retval < 0) |
1240 | goto minor_failed; |
1241 | retval = rf69_enable_amplifier(spi, MASK_PALEVEL_PA0); |
1242 | if (retval < 0) |
1243 | goto minor_failed; |
1244 | retval = rf69_disable_amplifier(spi, MASK_PALEVEL_PA1); |
1245 | if (retval < 0) |
1246 | goto minor_failed; |
1247 | retval = rf69_disable_amplifier(spi, MASK_PALEVEL_PA2); |
1248 | if (retval < 0) |
1249 | goto minor_failed; |
1250 | retval = rf69_set_output_power_level(spi, power_level: 13); |
1251 | if (retval < 0) |
1252 | goto minor_failed; |
1253 | retval = rf69_set_antenna_impedance(spi, antenna_impedance: fifty_ohm); |
1254 | if (retval < 0) |
1255 | goto minor_failed; |
1256 | |
1257 | /* determ minor number */ |
1258 | retval = pi433_get_minor(device); |
1259 | if (retval) { |
1260 | dev_dbg(&spi->dev, "get of minor number failed\n" ); |
1261 | goto minor_failed; |
1262 | } |
1263 | |
1264 | /* create device */ |
1265 | device->devt = MKDEV(MAJOR(pi433_dev), device->minor); |
1266 | device->dev = device_create(cls: &pi433_class, |
1267 | parent: &spi->dev, |
1268 | devt: device->devt, |
1269 | drvdata: device, |
1270 | fmt: "pi433.%d" , |
1271 | device->minor); |
1272 | if (IS_ERR(ptr: device->dev)) { |
1273 | pr_err("pi433: device register failed\n" ); |
1274 | retval = PTR_ERR(ptr: device->dev); |
1275 | goto device_create_failed; |
1276 | } else { |
1277 | dev_dbg(device->dev, |
1278 | "created device for major %d, minor %d\n" , |
1279 | MAJOR(pi433_dev), |
1280 | device->minor); |
1281 | } |
1282 | |
1283 | /* start tx thread */ |
1284 | device->tx_task_struct = kthread_run(pi433_tx_thread, |
1285 | device, |
1286 | "pi433.%d_tx_task" , |
1287 | device->minor); |
1288 | if (IS_ERR(ptr: device->tx_task_struct)) { |
1289 | dev_dbg(device->dev, "start of send thread failed\n" ); |
1290 | retval = PTR_ERR(ptr: device->tx_task_struct); |
1291 | goto send_thread_failed; |
1292 | } |
1293 | |
1294 | /* create cdev */ |
1295 | device->cdev = cdev_alloc(); |
1296 | if (!device->cdev) { |
1297 | dev_dbg(device->dev, "allocation of cdev failed\n" ); |
1298 | retval = -ENOMEM; |
1299 | goto cdev_failed; |
1300 | } |
1301 | device->cdev->owner = THIS_MODULE; |
1302 | cdev_init(device->cdev, &pi433_fops); |
1303 | retval = cdev_add(device->cdev, device->devt, 1); |
1304 | if (retval) { |
1305 | dev_dbg(device->dev, "register of cdev failed\n" ); |
1306 | goto del_cdev; |
1307 | } |
1308 | |
1309 | /* spi setup */ |
1310 | spi_set_drvdata(spi, data: device); |
1311 | |
1312 | entry = debugfs_create_dir(name: dev_name(dev: device->dev), parent: root_dir); |
1313 | debugfs_create_file(name: "regs" , mode: 0400, parent: entry, data: device, fops: &pi433_debugfs_regs_fops); |
1314 | |
1315 | return 0; |
1316 | |
1317 | del_cdev: |
1318 | cdev_del(device->cdev); |
1319 | cdev_failed: |
1320 | kthread_stop(k: device->tx_task_struct); |
1321 | send_thread_failed: |
1322 | device_destroy(cls: &pi433_class, devt: device->devt); |
1323 | device_create_failed: |
1324 | pi433_free_minor(dev: device); |
1325 | minor_failed: |
1326 | free_gpio(device); |
1327 | GPIO_failed: |
1328 | kfree(objp: device->rx_buffer); |
1329 | RX_failed: |
1330 | kfree(objp: device); |
1331 | |
1332 | return retval; |
1333 | } |
1334 | |
1335 | static void pi433_remove(struct spi_device *spi) |
1336 | { |
1337 | struct pi433_device *device = spi_get_drvdata(spi); |
1338 | |
1339 | debugfs_lookup_and_remove(name: dev_name(dev: device->dev), parent: root_dir); |
1340 | |
1341 | /* free GPIOs */ |
1342 | free_gpio(device); |
1343 | |
1344 | /* make sure ops on existing fds can abort cleanly */ |
1345 | device->spi = NULL; |
1346 | |
1347 | kthread_stop(k: device->tx_task_struct); |
1348 | |
1349 | device_destroy(cls: &pi433_class, devt: device->devt); |
1350 | |
1351 | cdev_del(device->cdev); |
1352 | |
1353 | pi433_free_minor(dev: device); |
1354 | |
1355 | kfree(objp: device->rx_buffer); |
1356 | kfree(objp: device); |
1357 | } |
1358 | |
1359 | static const struct of_device_id pi433_dt_ids[] = { |
1360 | { .compatible = "Smarthome-Wolf,pi433" }, |
1361 | {}, |
1362 | }; |
1363 | |
1364 | MODULE_DEVICE_TABLE(of, pi433_dt_ids); |
1365 | |
1366 | static struct spi_driver pi433_spi_driver = { |
1367 | .driver = { |
1368 | .name = "pi433" , |
1369 | .owner = THIS_MODULE, |
1370 | .of_match_table = of_match_ptr(pi433_dt_ids), |
1371 | }, |
1372 | .probe = pi433_probe, |
1373 | .remove = pi433_remove, |
1374 | |
1375 | /* |
1376 | * NOTE: suspend/resume methods are not necessary here. |
1377 | * We don't do anything except pass the requests to/from |
1378 | * the underlying controller. The refrigerator handles |
1379 | * most issues; the controller driver handles the rest. |
1380 | */ |
1381 | }; |
1382 | |
1383 | /*-------------------------------------------------------------------------*/ |
1384 | |
1385 | static int __init pi433_init(void) |
1386 | { |
1387 | int status; |
1388 | |
1389 | /* |
1390 | * If MAX_MSG_SIZE is smaller then FIFO_SIZE, the driver won't |
1391 | * work stable - risk of buffer overflow |
1392 | */ |
1393 | if (MAX_MSG_SIZE < FIFO_SIZE) |
1394 | return -EINVAL; |
1395 | |
1396 | /* |
1397 | * Claim device numbers. Then register a class |
1398 | * that will key udev/mdev to add/remove /dev nodes. |
1399 | * Last, register the driver which manages those device numbers. |
1400 | */ |
1401 | status = alloc_chrdev_region(&pi433_dev, 0, N_PI433_MINORS, "pi433" ); |
1402 | if (status < 0) |
1403 | return status; |
1404 | |
1405 | status = class_register(class: &pi433_class); |
1406 | if (status) { |
1407 | unregister_chrdev(MAJOR(pi433_dev), |
1408 | name: pi433_spi_driver.driver.name); |
1409 | return status; |
1410 | } |
1411 | |
1412 | root_dir = debugfs_create_dir(KBUILD_MODNAME, NULL); |
1413 | |
1414 | status = spi_register_driver(&pi433_spi_driver); |
1415 | if (status < 0) { |
1416 | class_unregister(class: &pi433_class); |
1417 | unregister_chrdev(MAJOR(pi433_dev), |
1418 | name: pi433_spi_driver.driver.name); |
1419 | } |
1420 | |
1421 | return status; |
1422 | } |
1423 | |
1424 | module_init(pi433_init); |
1425 | |
1426 | static void __exit pi433_exit(void) |
1427 | { |
1428 | spi_unregister_driver(sdrv: &pi433_spi_driver); |
1429 | class_unregister(class: &pi433_class); |
1430 | unregister_chrdev(MAJOR(pi433_dev), name: pi433_spi_driver.driver.name); |
1431 | debugfs_remove(dentry: root_dir); |
1432 | } |
1433 | module_exit(pi433_exit); |
1434 | |
1435 | MODULE_AUTHOR("Marcus Wolf, <linux@wolf-entwicklungen.de>" ); |
1436 | MODULE_DESCRIPTION("Driver for Pi433" ); |
1437 | MODULE_LICENSE("GPL" ); |
1438 | MODULE_ALIAS("spi:pi433" ); |
1439 | |