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