drivers/staging/pi433/pi433_if.c

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