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