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