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