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 goto abort; 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 goto abort; 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 goto abort; 669 } else { 670 retval = rf69_set_payload_length(spi, 0); 671 if (retval < 0) 672 goto abort; 673 } 674 675 /* configure the rf chip */ 676 retval = rf69_set_tx_cfg(device, &tx_cfg); 677 if (retval < 0) 678 goto abort; 679 680 /* enable fifo level interrupt */ 681 retval = rf69_set_dio_mapping(spi, DIO1, DIO_FIFO_LEVEL); 682 if (retval < 0) 683 goto abort; 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 goto abort; 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 goto abort; 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 goto abort; 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 struct pi433_instance *instance; 875 struct pi433_device *device; 876 struct pi433_tx_cfg tx_cfg; 877 void __user *argp = (void __user *)arg; 878 879 /* Check type and command number */ 880 if (_IOC_TYPE(cmd) != PI433_IOC_MAGIC) 881 return -ENOTTY; 882 883 instance = filp->private_data; 884 device = instance->device; 885 886 if (!device) 887 return -ESHUTDOWN; 888 889 switch (cmd) { 890 case PI433_IOC_RD_TX_CFG: 891 if (copy_to_user(argp, &instance->tx_cfg, 892 sizeof(struct pi433_tx_cfg))) 893 return -EFAULT; 894 break; 895 case PI433_IOC_WR_TX_CFG: 896 if (copy_from_user(&tx_cfg, argp, sizeof(struct pi433_tx_cfg))) 897 return -EFAULT; 898 mutex_lock(&device->tx_fifo_lock); 899 memcpy(&instance->tx_cfg, &tx_cfg, sizeof(struct pi433_tx_cfg)); 900 mutex_unlock(&device->tx_fifo_lock); 901 break; 902 case PI433_IOC_RD_RX_CFG: 903 if (copy_to_user(argp, &device->rx_cfg, 904 sizeof(struct pi433_rx_cfg))) 905 return -EFAULT; 906 break; 907 case PI433_IOC_WR_RX_CFG: 908 mutex_lock(&device->rx_lock); 909 910 /* during pendig read request, change of config not allowed */ 911 if (device->rx_active) { 912 mutex_unlock(&device->rx_lock); 913 return -EAGAIN; 914 } 915 916 if (copy_from_user(&device->rx_cfg, argp, 917 sizeof(struct pi433_rx_cfg))) { 918 mutex_unlock(&device->rx_lock); 919 return -EFAULT; 920 } 921 922 mutex_unlock(&device->rx_lock); 923 break; 924 default: 925 return -EINVAL; 926 } 927 928 return 0; 929 } 930 931 /*-------------------------------------------------------------------------*/ 932 933 static int pi433_open(struct inode *inode, struct file *filp) 934 { 935 struct pi433_device *device; 936 struct pi433_instance *instance; 937 938 mutex_lock(&minor_lock); 939 device = idr_find(&pi433_idr, iminor(inode)); 940 mutex_unlock(&minor_lock); 941 if (!device) { 942 pr_debug("device: minor %d unknown.\n", iminor(inode)); 943 return -ENODEV; 944 } 945 946 instance = kzalloc(sizeof(*instance), GFP_KERNEL); 947 if (!instance) 948 return -ENOMEM; 949 950 /* setup instance data*/ 951 instance->device = device; 952 instance->tx_cfg.bit_rate = 4711; 953 // TODO: fill instance->tx_cfg; 954 955 /* instance data as context */ 956 filp->private_data = instance; 957 stream_open(inode, filp); 958 959 return 0; 960 } 961 962 static int pi433_release(struct inode *inode, struct file *filp) 963 { 964 struct pi433_instance *instance; 965 966 instance = filp->private_data; 967 kfree(instance); 968 filp->private_data = NULL; 969 970 return 0; 971 } 972 973 /*-------------------------------------------------------------------------*/ 974 975 static int setup_gpio(struct pi433_device *device) 976 { 977 char name[5]; 978 int retval; 979 int i; 980 const irq_handler_t DIO_irq_handler[NUM_DIO] = { 981 DIO0_irq_handler, 982 DIO1_irq_handler 983 }; 984 985 for (i = 0; i < NUM_DIO; i++) { 986 /* "construct" name and get the gpio descriptor */ 987 snprintf(name, sizeof(name), "DIO%d", i); 988 device->gpiod[i] = gpiod_get(&device->spi->dev, name, 989 0 /*GPIOD_IN*/); 990 991 if (device->gpiod[i] == ERR_PTR(-ENOENT)) { 992 dev_dbg(&device->spi->dev, 993 "Could not find entry for %s. Ignoring.", name); 994 continue; 995 } 996 997 if (device->gpiod[i] == ERR_PTR(-EBUSY)) 998 dev_dbg(&device->spi->dev, "%s is busy.", name); 999 1000 if (IS_ERR(device->gpiod[i])) { 1001 retval = PTR_ERR(device->gpiod[i]); 1002 /* release already allocated gpios */ 1003 for (i--; i >= 0; i--) { 1004 free_irq(device->irq_num[i], device); 1005 gpiod_put(device->gpiod[i]); 1006 } 1007 return retval; 1008 } 1009 1010 /* configure the pin */ 1011 gpiod_unexport(device->gpiod[i]); 1012 retval = gpiod_direction_input(device->gpiod[i]); 1013 if (retval) 1014 return retval; 1015 1016 /* configure irq */ 1017 device->irq_num[i] = gpiod_to_irq(device->gpiod[i]); 1018 if (device->irq_num[i] < 0) { 1019 device->gpiod[i] = ERR_PTR(-EINVAL); 1020 return device->irq_num[i]; 1021 } 1022 retval = request_irq(device->irq_num[i], 1023 DIO_irq_handler[i], 1024 0, /* flags */ 1025 name, 1026 device); 1027 1028 if (retval) 1029 return retval; 1030 1031 dev_dbg(&device->spi->dev, "%s successfully configured", name); 1032 } 1033 1034 return 0; 1035 } 1036 1037 static void free_gpio(struct pi433_device *device) 1038 { 1039 int i; 1040 1041 for (i = 0; i < NUM_DIO; i++) { 1042 /* check if gpiod is valid */ 1043 if (IS_ERR(device->gpiod[i])) 1044 continue; 1045 1046 free_irq(device->irq_num[i], device); 1047 gpiod_put(device->gpiod[i]); 1048 } 1049 } 1050 1051 static int pi433_get_minor(struct pi433_device *device) 1052 { 1053 int retval = -ENOMEM; 1054 1055 mutex_lock(&minor_lock); 1056 retval = idr_alloc(&pi433_idr, device, 0, N_PI433_MINORS, GFP_KERNEL); 1057 if (retval >= 0) { 1058 device->minor = retval; 1059 retval = 0; 1060 } else if (retval == -ENOSPC) { 1061 dev_err(&device->spi->dev, "too many pi433 devices\n"); 1062 retval = -EINVAL; 1063 } 1064 mutex_unlock(&minor_lock); 1065 return retval; 1066 } 1067 1068 static void pi433_free_minor(struct pi433_device *dev) 1069 { 1070 mutex_lock(&minor_lock); 1071 idr_remove(&pi433_idr, dev->minor); 1072 mutex_unlock(&minor_lock); 1073 } 1074 1075 /*-------------------------------------------------------------------------*/ 1076 1077 static const struct file_operations pi433_fops = { 1078 .owner = THIS_MODULE, 1079 /* 1080 * REVISIT switch to aio primitives, so that userspace 1081 * gets more complete API coverage. It'll simplify things 1082 * too, except for the locking. 1083 */ 1084 .write = pi433_write, 1085 .read = pi433_read, 1086 .unlocked_ioctl = pi433_ioctl, 1087 .compat_ioctl = compat_ptr_ioctl, 1088 .open = pi433_open, 1089 .release = pi433_release, 1090 .llseek = no_llseek, 1091 }; 1092 1093 /*-------------------------------------------------------------------------*/ 1094 1095 static int pi433_probe(struct spi_device *spi) 1096 { 1097 struct pi433_device *device; 1098 int retval; 1099 1100 /* setup spi parameters */ 1101 spi->mode = 0x00; 1102 spi->bits_per_word = 8; 1103 /* 1104 * spi->max_speed_hz = 10000000; 1105 * 1MHz already set by device tree overlay 1106 */ 1107 1108 retval = spi_setup(spi); 1109 if (retval) { 1110 dev_dbg(&spi->dev, "configuration of SPI interface failed!\n"); 1111 return retval; 1112 } 1113 1114 dev_dbg(&spi->dev, 1115 "spi interface setup: mode 0x%2x, %d bits per word, %dhz max speed", 1116 spi->mode, spi->bits_per_word, spi->max_speed_hz); 1117 1118 /* Ping the chip by reading the version register */ 1119 retval = spi_w8r8(spi, 0x10); 1120 if (retval < 0) 1121 return retval; 1122 1123 switch (retval) { 1124 case 0x24: 1125 dev_dbg(&spi->dev, "found pi433 (ver. 0x%x)", retval); 1126 break; 1127 default: 1128 dev_dbg(&spi->dev, "unknown chip version: 0x%x", retval); 1129 return -ENODEV; 1130 } 1131 1132 /* Allocate driver data */ 1133 device = kzalloc(sizeof(*device), GFP_KERNEL); 1134 if (!device) 1135 return -ENOMEM; 1136 1137 /* Initialize the driver data */ 1138 device->spi = spi; 1139 device->rx_active = false; 1140 device->tx_active = false; 1141 device->interrupt_rx_allowed = false; 1142 1143 /* init rx buffer */ 1144 device->rx_buffer = kmalloc(MAX_MSG_SIZE, GFP_KERNEL); 1145 if (!device->rx_buffer) { 1146 retval = -ENOMEM; 1147 goto RX_failed; 1148 } 1149 1150 /* init wait queues */ 1151 init_waitqueue_head(&device->tx_wait_queue); 1152 init_waitqueue_head(&device->rx_wait_queue); 1153 init_waitqueue_head(&device->fifo_wait_queue); 1154 1155 /* init fifo */ 1156 INIT_KFIFO(device->tx_fifo); 1157 1158 /* init mutexes and locks */ 1159 mutex_init(&device->tx_fifo_lock); 1160 mutex_init(&device->rx_lock); 1161 1162 /* setup GPIO (including irq_handler) for the different DIOs */ 1163 retval = setup_gpio(device); 1164 if (retval) { 1165 dev_dbg(&spi->dev, "setup of GPIOs failed"); 1166 goto GPIO_failed; 1167 } 1168 1169 /* setup the radio module */ 1170 retval = rf69_set_mode(spi, standby); 1171 if (retval < 0) 1172 goto minor_failed; 1173 retval = rf69_set_data_mode(spi, DATAMODUL_MODE_PACKET); 1174 if (retval < 0) 1175 goto minor_failed; 1176 retval = rf69_enable_amplifier(spi, MASK_PALEVEL_PA0); 1177 if (retval < 0) 1178 goto minor_failed; 1179 retval = rf69_disable_amplifier(spi, MASK_PALEVEL_PA1); 1180 if (retval < 0) 1181 goto minor_failed; 1182 retval = rf69_disable_amplifier(spi, MASK_PALEVEL_PA2); 1183 if (retval < 0) 1184 goto minor_failed; 1185 retval = rf69_set_output_power_level(spi, 13); 1186 if (retval < 0) 1187 goto minor_failed; 1188 retval = rf69_set_antenna_impedance(spi, fifty_ohm); 1189 if (retval < 0) 1190 goto minor_failed; 1191 1192 /* determ minor number */ 1193 retval = pi433_get_minor(device); 1194 if (retval) { 1195 dev_dbg(&spi->dev, "get of minor number failed"); 1196 goto minor_failed; 1197 } 1198 1199 /* create device */ 1200 device->devt = MKDEV(MAJOR(pi433_dev), device->minor); 1201 device->dev = device_create(pi433_class, 1202 &spi->dev, 1203 device->devt, 1204 device, 1205 "pi433.%d", 1206 device->minor); 1207 if (IS_ERR(device->dev)) { 1208 pr_err("pi433: device register failed\n"); 1209 retval = PTR_ERR(device->dev); 1210 goto device_create_failed; 1211 } else { 1212 dev_dbg(device->dev, 1213 "created device for major %d, minor %d\n", 1214 MAJOR(pi433_dev), 1215 device->minor); 1216 } 1217 1218 /* start tx thread */ 1219 device->tx_task_struct = kthread_run(pi433_tx_thread, 1220 device, 1221 "pi433.%d_tx_task", 1222 device->minor); 1223 if (IS_ERR(device->tx_task_struct)) { 1224 dev_dbg(device->dev, "start of send thread failed"); 1225 retval = PTR_ERR(device->tx_task_struct); 1226 goto send_thread_failed; 1227 } 1228 1229 /* create cdev */ 1230 device->cdev = cdev_alloc(); 1231 if (!device->cdev) { 1232 dev_dbg(device->dev, "allocation of cdev failed"); 1233 retval = -ENOMEM; 1234 goto cdev_failed; 1235 } 1236 device->cdev->owner = THIS_MODULE; 1237 cdev_init(device->cdev, &pi433_fops); 1238 retval = cdev_add(device->cdev, device->devt, 1); 1239 if (retval) { 1240 dev_dbg(device->dev, "register of cdev failed"); 1241 goto del_cdev; 1242 } 1243 1244 /* spi setup */ 1245 spi_set_drvdata(spi, device); 1246 1247 return 0; 1248 1249 del_cdev: 1250 cdev_del(device->cdev); 1251 cdev_failed: 1252 kthread_stop(device->tx_task_struct); 1253 send_thread_failed: 1254 device_destroy(pi433_class, device->devt); 1255 device_create_failed: 1256 pi433_free_minor(device); 1257 minor_failed: 1258 free_gpio(device); 1259 GPIO_failed: 1260 kfree(device->rx_buffer); 1261 RX_failed: 1262 kfree(device); 1263 1264 return retval; 1265 } 1266 1267 static int pi433_remove(struct spi_device *spi) 1268 { 1269 struct pi433_device *device = spi_get_drvdata(spi); 1270 1271 /* free GPIOs */ 1272 free_gpio(device); 1273 1274 /* make sure ops on existing fds can abort cleanly */ 1275 device->spi = NULL; 1276 1277 kthread_stop(device->tx_task_struct); 1278 1279 device_destroy(pi433_class, device->devt); 1280 1281 cdev_del(device->cdev); 1282 1283 pi433_free_minor(device); 1284 1285 kfree(device->rx_buffer); 1286 kfree(device); 1287 1288 return 0; 1289 } 1290 1291 static const struct of_device_id pi433_dt_ids[] = { 1292 { .compatible = "Smarthome-Wolf,pi433" }, 1293 {}, 1294 }; 1295 1296 MODULE_DEVICE_TABLE(of, pi433_dt_ids); 1297 1298 static struct spi_driver pi433_spi_driver = { 1299 .driver = { 1300 .name = "pi433", 1301 .owner = THIS_MODULE, 1302 .of_match_table = of_match_ptr(pi433_dt_ids), 1303 }, 1304 .probe = pi433_probe, 1305 .remove = pi433_remove, 1306 1307 /* 1308 * NOTE: suspend/resume methods are not necessary here. 1309 * We don't do anything except pass the requests to/from 1310 * the underlying controller. The refrigerator handles 1311 * most issues; the controller driver handles the rest. 1312 */ 1313 }; 1314 1315 /*-------------------------------------------------------------------------*/ 1316 1317 static int __init pi433_init(void) 1318 { 1319 int status; 1320 1321 /* 1322 * If MAX_MSG_SIZE is smaller then FIFO_SIZE, the driver won't 1323 * work stable - risk of buffer overflow 1324 */ 1325 if (MAX_MSG_SIZE < FIFO_SIZE) 1326 return -EINVAL; 1327 1328 /* 1329 * Claim device numbers. Then register a class 1330 * that will key udev/mdev to add/remove /dev nodes. Last, register 1331 * Last, register the driver which manages those device numbers. 1332 */ 1333 status = alloc_chrdev_region(&pi433_dev, 0, N_PI433_MINORS, "pi433"); 1334 if (status < 0) 1335 return status; 1336 1337 pi433_class = class_create(THIS_MODULE, "pi433"); 1338 if (IS_ERR(pi433_class)) { 1339 unregister_chrdev(MAJOR(pi433_dev), 1340 pi433_spi_driver.driver.name); 1341 return PTR_ERR(pi433_class); 1342 } 1343 1344 status = spi_register_driver(&pi433_spi_driver); 1345 if (status < 0) { 1346 class_destroy(pi433_class); 1347 unregister_chrdev(MAJOR(pi433_dev), 1348 pi433_spi_driver.driver.name); 1349 } 1350 1351 return status; 1352 } 1353 1354 module_init(pi433_init); 1355 1356 static void __exit pi433_exit(void) 1357 { 1358 spi_unregister_driver(&pi433_spi_driver); 1359 class_destroy(pi433_class); 1360 unregister_chrdev(MAJOR(pi433_dev), pi433_spi_driver.driver.name); 1361 } 1362 module_exit(pi433_exit); 1363 1364 MODULE_AUTHOR("Marcus Wolf, <linux@wolf-entwicklungen.de>"); 1365 MODULE_DESCRIPTION("Driver for Pi433"); 1366 MODULE_LICENSE("GPL"); 1367 MODULE_ALIAS("spi:pi433"); 1368