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