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