drivers/staging/pi433/pi433_if.c

   1 /*
   2  * userspace interface for pi433 radio module
   3  *
   4  * Pi433 is a 433MHz radio module for the Raspberry Pi.
   5  * It is based on the HopeRf Module RFM69CW. Therefore inside of this
   6  * driver, you'll find an abstraction of the rf69 chip.
   7  *
   8  * If needed, this driver could be extended, to also support other
   9  * devices, basing on HopeRfs rf69.
  10  *
  11  * The driver can also be extended, to support other modules of
  12  * HopeRf with a similar interace - e. g. RFM69HCW, RFM12, RFM95, ...
  13  *
  14  * Copyright (C) 2016 Wolf-Entwicklungen
  15  *      Marcus Wolf <[email protected]>
  16  *
  17  * This program is free software; you can redistribute it and/or modify
  18  * it under the terms of the GNU General Public License as published by
  19  * the Free Software Foundation; either version 2 of the License, or
  20  * (at your option) any later version.
  21  *
  22  * This program is distributed in the hope that it will be useful,
  23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  25  * GNU General Public License for more details.
  26  */
  27
  28 #undef DEBUG
  29
  30 #include <linux/init.h>
  31 #include <linux/module.h>
  32 #include <linux/idr.h>
  33 #include <linux/ioctl.h>
  34 #include <linux/uaccess.h>
  35 #include <linux/fs.h>
  36 #include <linux/device.h>
  37 #include <linux/cdev.h>
  38 #include <linux/err.h>
  39 #include <linux/kfifo.h>
  40 #include <linux/errno.h>
  41 #include <linux/mutex.h>
  42 #include <linux/of.h>
  43 #include <linux/of_device.h>
  44 #include <linux/interrupt.h>
  45 #include <linux/irq.h>
  46 #include <linux/gpio/consumer.h>
  47 #include <linux/kthread.h>
  48 #include <linux/wait.h>
  49 #include <linux/spi/spi.h>
  50 #ifdef CONFIG_COMPAT
  51 #include <linux/compat.h>
  52 #endif
  53
  54 #include "pi433_if.h"
  55 #include "rf69.h"
  56
  57 #define N_PI433_MINORS                  BIT(MINORBITS) /*32*/   /* ... up to 256 */
  58 #define MAX_MSG_SIZE                    900     /* min: FIFO_SIZE! */
  59 #define MSG_FIFO_SIZE                   65536   /* 65536 = 2^16  */
  60 #define NUM_DIO                         2
  61
  62 static dev_t pi433_dev;
  63 static DEFINE_IDR(pi433_idr);
  64 static DEFINE_MUTEX(minor_lock); /* Protect idr accesses */
  65
  66 static struct class *pi433_class; /* mainly for udev to create /dev/pi433 */
  67
  68 /* tx config is instance specific
  69  * so with each open a new tx config struct is needed
  70  */
  71 /* rx config is device specific
  72  * so we have just one rx config, ebedded in device struct
  73  */
  74 struct pi433_device {
  75         /* device handling related values */
  76         dev_t                   devt;
  77         int                     minor;
  78         struct device           *dev;
  79         struct cdev             *cdev;
  80         struct spi_device       *spi;
  81         unsigned int            users;
  82
  83         /* irq related values */
  84         struct gpio_desc        *gpiod[NUM_DIO];
  85         int                     irq_num[NUM_DIO];
  86         u8                      irq_state[NUM_DIO];
  87
  88         /* tx related values */
  89         STRUCT_KFIFO_REC_1(MSG_FIFO_SIZE) tx_fifo;
  90         struct mutex            tx_fifo_lock; /* serialize userspace writers */
  91         struct task_struct      *tx_task_struct;
  92         wait_queue_head_t       tx_wait_queue;
  93         u8                      free_in_fifo;
  94         char                    buffer[MAX_MSG_SIZE];
  95
  96         /* rx related values */
  97         struct pi433_rx_cfg     rx_cfg;
  98         u8                      *rx_buffer;
  99         unsigned int            rx_buffer_size;
 100         u32                     rx_bytes_to_drop;
 101         u32                     rx_bytes_dropped;
 102         unsigned int            rx_position;
 103         struct mutex            rx_lock;
 104         wait_queue_head_t       rx_wait_queue;
 105
 106         /* fifo wait queue */
 107         struct task_struct      *fifo_task_struct;
 108         wait_queue_head_t       fifo_wait_queue;
 109
 110         /* flags */
 111         bool                    rx_active;
 112         bool                    tx_active;
 113         bool                    interrupt_rx_allowed;
 114 };
 115
 116 struct pi433_instance {
 117         struct pi433_device     *device;
 118         struct pi433_tx_cfg     tx_cfg;
 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_bit_rate(dev->spi, rx_cfg->bit_rate);
 176         if (ret < 0)
 177                 return ret;
 178         ret = rf69_set_modulation(dev->spi, rx_cfg->modulation);
 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_bit_rate(dev->spi, tx_cfg->bit_rate);
 299         if (ret < 0)
 300                 return ret;
 301         ret = rf69_set_modulation(dev->spi, tx_cfg->modulation);
 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_enable_sync(dev->spi);
 331                 if (ret < 0)
 332                         return ret;
 333         } else {
 334                 ret = rf69_disable_sync(dev->spi);
 335                 if (ret < 0)
 336                         return ret;
 337         }
 338
 339         if (tx_cfg->enable_length_byte == OPTION_ON) {
 340                 ret = rf69_set_packet_format(dev->spi, packet_length_var);
 341                 if (ret < 0)
 342                         return ret;
 343         } else {
 344                 ret = rf69_set_packet_format(dev->spi, packet_length_fix);
 345                 if (ret < 0)
 346                         return ret;
 347         }
 348
 349         if (tx_cfg->enable_crc == OPTION_ON) {
 350                 ret = rf69_enable_crc(dev->spi);
 351                 if (ret < 0)
 352                         return ret;
 353         } else {
 354                 ret = rf69_disable_crc(dev->spi);
 355                 if (ret < 0)
 356                         return ret;
 357         }
 358
 359         /* configure sync, if enabled */
 360         if (tx_cfg->enable_sync == OPTION_ON) {
 361                 ret = rf69_set_sync_size(dev->spi, tx_cfg->sync_length);
 362                 if (ret < 0)
 363                         return ret;
 364                 ret = rf69_set_sync_values(dev->spi, tx_cfg->sync_pattern);
 365                 if (ret < 0)
 366                         return ret;
 367         }
 368
 369         return 0;
 370 }
 371
 372 /*-------------------------------------------------------------------------*/
 373
 374 static int
 375 pi433_start_rx(struct pi433_device *dev)
 376 {
 377         int retval;
 378
 379         /* return without action, if no pending read request */
 380         if (!dev->rx_active)
 381                 return 0;
 382
 383         /* setup for receiving */
 384         retval = rf69_set_rx_cfg(dev, &dev->rx_cfg);
 385         if (retval)
 386                 return retval;
 387
 388         /* setup rssi irq */
 389         retval = rf69_set_dio_mapping(dev->spi, DIO0, DIO_RSSI_DIO0);
 390         if (retval < 0)
 391                 return retval;
 392         dev->irq_state[DIO0] = DIO_RSSI_DIO0;
 393         irq_set_irq_type(dev->irq_num[DIO0], IRQ_TYPE_EDGE_RISING);
 394
 395         /* setup fifo level interrupt */
 396         retval = rf69_set_fifo_threshold(dev->spi, FIFO_SIZE - FIFO_THRESHOLD);
 397         if (retval < 0)
 398                 return retval;
 399         retval = rf69_set_dio_mapping(dev->spi, DIO1, DIO_FIFO_LEVEL);
 400         if (retval < 0)
 401                 return retval;
 402         dev->irq_state[DIO1] = DIO_FIFO_LEVEL;
 403         irq_set_irq_type(dev->irq_num[DIO1], IRQ_TYPE_EDGE_RISING);
 404
 405         /* set module to receiving mode */
 406         retval = rf69_set_mode(dev->spi, receive);
 407         if (retval < 0)
 408                 return retval;
 409
 410         return 0;
 411 }
 412
 413 /*-------------------------------------------------------------------------*/
 414
 415 static int
 416 pi433_receive(void *data)
 417 {
 418         struct pi433_device *dev = data;
 419         struct spi_device *spi = dev->spi;
 420         int bytes_to_read, bytes_total;
 421         int retval;
 422
 423         dev->interrupt_rx_allowed = false;
 424
 425         /* wait for any tx to finish */
 426         dev_dbg(dev->dev, "rx: going to wait for any tx to finish");
 427         retval = wait_event_interruptible(dev->rx_wait_queue, !dev->tx_active);
 428         if (retval) {
 429                 /* wait was interrupted */
 430                 dev->interrupt_rx_allowed = true;
 431                 wake_up_interruptible(&dev->tx_wait_queue);
 432                 return retval;
 433         }
 434
 435         /* prepare status vars */
 436         dev->free_in_fifo = FIFO_SIZE;
 437         dev->rx_position = 0;
 438         dev->rx_bytes_dropped = 0;
 439
 440         /* setup radio module to listen for something "in the air" */
 441         retval = pi433_start_rx(dev);
 442         if (retval)
 443                 return retval;
 444
 445         /* now check RSSI, if low wait for getting high (RSSI interrupt) */
 446         while (!rf69_get_flag(dev->spi, rssi_exceeded_threshold)) {
 447                 /* allow tx to interrupt us while waiting for high RSSI */
 448                 dev->interrupt_rx_allowed = true;
 449                 wake_up_interruptible(&dev->tx_wait_queue);
 450
 451                 /* wait for RSSI level to become high */
 452                 dev_dbg(dev->dev, "rx: going to wait for high RSSI level");
 453                 retval = wait_event_interruptible(dev->rx_wait_queue,
 454                                                   rf69_get_flag(dev->spi,
 455                                                                 rssi_exceeded_threshold));
 456                 if (retval) /* wait was interrupted */
 457                         goto abort;
 458                 dev->interrupt_rx_allowed = false;
 459
 460                 /* cross check for ongoing tx */
 461                 if (!dev->tx_active)
 462                         break;
 463         }
 464
 465         /* configure payload ready irq */
 466         retval = rf69_set_dio_mapping(spi, DIO0, DIO_PAYLOAD_READY);
 467         if (retval < 0)
 468                 goto abort;
 469         dev->irq_state[DIO0] = DIO_PAYLOAD_READY;
 470         irq_set_irq_type(dev->irq_num[DIO0], IRQ_TYPE_EDGE_RISING);
 471
 472         /* fixed or unlimited length? */
 473         if (dev->rx_cfg.fixed_message_length != 0) {
 474                 if (dev->rx_cfg.fixed_message_length > dev->rx_buffer_size) {
 475                         retval = -1;
 476                         goto abort;
 477                 }
 478                 bytes_total = dev->rx_cfg.fixed_message_length;
 479                 dev_dbg(dev->dev, "rx: msg len set to %d by fixed length",
 480                         bytes_total);
 481         } else {
 482                 bytes_total = dev->rx_buffer_size;
 483                 dev_dbg(dev->dev, "rx: msg len set to %d as requested by read",
 484                         bytes_total);
 485         }
 486
 487         /* length byte enabled? */
 488         if (dev->rx_cfg.enable_length_byte == OPTION_ON) {
 489                 retval = wait_event_interruptible(dev->fifo_wait_queue,
 490                                                   dev->free_in_fifo < FIFO_SIZE);
 491                 if (retval) /* wait was interrupted */
 492                         goto abort;
 493
 494                 rf69_read_fifo(spi, (u8 *)&bytes_total, 1);
 495                 if (bytes_total > dev->rx_buffer_size) {
 496                         retval = -1;
 497                         goto abort;
 498                 }
 499                 dev->free_in_fifo++;
 500                 dev_dbg(dev->dev, "rx: msg len reset to %d due to length byte",
 501                         bytes_total);
 502         }
 503
 504         /* address byte enabled? */
 505         if (dev->rx_cfg.enable_address_filtering != filtering_off) {
 506                 u8 dummy;
 507
 508                 bytes_total--;
 509
 510                 retval = wait_event_interruptible(dev->fifo_wait_queue,
 511                                                   dev->free_in_fifo < FIFO_SIZE);
 512                 if (retval) /* wait was interrupted */
 513                         goto abort;
 514
 515                 rf69_read_fifo(spi, &dummy, 1);
 516                 dev->free_in_fifo++;
 517                 dev_dbg(dev->dev, "rx: address byte stripped off");
 518         }
 519
 520         /* get payload */
 521         while (dev->rx_position < bytes_total) {
 522                 if (!rf69_get_flag(dev->spi, payload_ready)) {
 523                         retval = wait_event_interruptible(dev->fifo_wait_queue,
 524                                                           dev->free_in_fifo < FIFO_SIZE);
 525                         if (retval) /* wait was interrupted */
 526                                 goto abort;
 527                 }
 528
 529                 /* need to drop bytes or acquire? */
 530                 if (dev->rx_bytes_to_drop > dev->rx_bytes_dropped)
 531                         bytes_to_read = dev->rx_bytes_to_drop -
 532                                         dev->rx_bytes_dropped;
 533                 else
 534                         bytes_to_read = bytes_total - dev->rx_position;
 535
 536                 /* access the fifo */
 537                 if (bytes_to_read > FIFO_SIZE - dev->free_in_fifo)
 538                         bytes_to_read = FIFO_SIZE - dev->free_in_fifo;
 539                 retval = rf69_read_fifo(spi,
 540                                         &dev->rx_buffer[dev->rx_position],
 541                                         bytes_to_read);
 542                 if (retval) /* read failed */
 543                         goto abort;
 544
 545                 dev->free_in_fifo += bytes_to_read;
 546
 547                 /* adjust status vars */
 548                 if (dev->rx_bytes_to_drop > dev->rx_bytes_dropped)
 549                         dev->rx_bytes_dropped += bytes_to_read;
 550                 else
 551                         dev->rx_position += bytes_to_read;
 552         }
 553
 554         /* rx done, wait was interrupted or error occurred */
 555 abort:
 556         dev->interrupt_rx_allowed = true;
 557         if (rf69_set_mode(dev->spi, standby))
 558                 pr_err("rf69_set_mode(): radio module failed to go standby\n");
 559         wake_up_interruptible(&dev->tx_wait_queue);
 560
 561         if (retval)
 562                 return retval;
 563         else
 564                 return bytes_total;
 565 }
 566
 567 static int
 568 pi433_tx_thread(void *data)
 569 {
 570         struct pi433_device *device = data;
 571         struct spi_device *spi = device->spi;
 572         struct pi433_tx_cfg tx_cfg;
 573         size_t size;
 574         bool   rx_interrupted = false;
 575         int    position, repetitions;
 576         int    retval;
 577
 578         while (1) {
 579                 /* wait for fifo to be populated or for request to terminate*/
 580                 dev_dbg(device->dev, "thread: going to wait for new messages");
 581                 wait_event_interruptible(device->tx_wait_queue,
 582                                          (!kfifo_is_empty(&device->tx_fifo) ||
 583                                           kthread_should_stop()));
 584                 if (kthread_should_stop())
 585                         return 0;
 586
 587                 /* get data from fifo in the following order:
 588                  * - tx_cfg
 589                  * - size of message
 590                  * - message
 591                  */
 592                 retval = kfifo_out(&device->tx_fifo, &tx_cfg, sizeof(tx_cfg));
 593                 if (retval != sizeof(tx_cfg)) {
 594                         dev_dbg(device->dev,
 595                                 "reading tx_cfg from fifo failed: got %d byte(s), expected %d",
 596                                 retval, (unsigned int)sizeof(tx_cfg));
 597                         continue;
 598                 }
 599
 600                 retval = kfifo_out(&device->tx_fifo, &size, sizeof(size_t));
 601                 if (retval != sizeof(size_t)) {
 602                         dev_dbg(device->dev,
 603                                 "reading msg size from fifo failed: got %d, expected %d",
 604                                 retval, (unsigned int)sizeof(size_t));
 605                         continue;
 606                 }
 607
 608                 /* use fixed message length, if requested */
 609                 if (tx_cfg.fixed_message_length != 0)
 610                         size = tx_cfg.fixed_message_length;
 611
 612                 /* increase size, if len byte is requested */
 613                 if (tx_cfg.enable_length_byte == OPTION_ON)
 614                         size++;
 615
 616                 /* increase size, if adr byte is requested */
 617                 if (tx_cfg.enable_address_byte == OPTION_ON)
 618                         size++;
 619
 620                 /* prime buffer */
 621                 memset(device->buffer, 0, size);
 622                 position = 0;
 623
 624                 /* add length byte, if requested */
 625                 if (tx_cfg.enable_length_byte  == OPTION_ON)
 626                         /*
 627                          * according to spec, length byte itself must be
 628                          * excluded from the length calculation
 629                          */
 630                         device->buffer[position++] = size - 1;
 631
 632                 /* add adr byte, if requested */
 633                 if (tx_cfg.enable_address_byte == OPTION_ON)
 634                         device->buffer[position++] = tx_cfg.address_byte;
 635
 636                 /* finally get message data from fifo */
 637                 retval = kfifo_out(&device->tx_fifo, &device->buffer[position],
 638                                    sizeof(device->buffer) - position);
 639                 dev_dbg(device->dev,
 640                         "read %d message byte(s) from fifo queue.", retval);
 641
 642                 /* if rx is active, we need to interrupt the waiting for
 643                  * incoming telegrams, to be able to send something.
 644                  * We are only allowed, if currently no reception takes
 645                  * place otherwise we need to  wait for the incoming telegram
 646                  * to finish
 647                  */
 648                 wait_event_interruptible(device->tx_wait_queue,
 649                                          !device->rx_active ||
 650                                           device->interrupt_rx_allowed);
 651
 652                 /* prevent race conditions
 653                  * irq will be reenabled after tx config is set
 654                  */
 655                 disable_irq(device->irq_num[DIO0]);
 656                 device->tx_active = true;
 657
 658                 if (device->rx_active && !rx_interrupted) {
 659                         /* rx is currently waiting for a telegram;
 660                          * we need to set the radio module to standby
 661                          */
 662                         retval = rf69_set_mode(device->spi, standby);
 663                         if (retval < 0)
 664                                 return retval;
 665                         rx_interrupted = true;
 666                 }
 667
 668                 /* clear fifo, set fifo threshold, set payload length */
 669                 retval = rf69_set_mode(spi, standby); /* this clears the fifo */
 670                 if (retval < 0)
 671                         return retval;
 672                 retval = rf69_set_fifo_threshold(spi, FIFO_THRESHOLD);
 673                 if (retval < 0)
 674                         return retval;
 675                 if (tx_cfg.enable_length_byte == OPTION_ON) {
 676                         retval = rf69_set_payload_length(spi, size * tx_cfg.repetitions);
 677                         if (retval < 0)
 678                                 return retval;
 679                 } else {
 680                         retval = rf69_set_payload_length(spi, 0);
 681                         if (retval < 0)
 682                                 return retval;
 683                 }
 684
 685                 /* configure the rf chip */
 686                 retval = rf69_set_tx_cfg(device, &tx_cfg);
 687                 if (retval < 0)
 688                         return retval;
 689
 690                 /* enable fifo level interrupt */
 691                 retval = rf69_set_dio_mapping(spi, DIO1, DIO_FIFO_LEVEL);
 692                 if (retval < 0)
 693                         return retval;
 694                 device->irq_state[DIO1] = DIO_FIFO_LEVEL;
 695                 irq_set_irq_type(device->irq_num[DIO1], IRQ_TYPE_EDGE_FALLING);
 696
 697                 /* enable packet sent interrupt */
 698                 retval = rf69_set_dio_mapping(spi, DIO0, DIO_PACKET_SENT);
 699                 if (retval < 0)
 700                         return retval;
 701                 device->irq_state[DIO0] = DIO_PACKET_SENT;
 702                 irq_set_irq_type(device->irq_num[DIO0], IRQ_TYPE_EDGE_RISING);
 703                 enable_irq(device->irq_num[DIO0]); /* was disabled by rx active check */
 704
 705                 /* enable transmission */
 706                 retval = rf69_set_mode(spi, transmit);
 707                 if (retval < 0)
 708                         return retval;
 709
 710                 /* transfer this msg (and repetitions) to chip fifo */
 711                 device->free_in_fifo = FIFO_SIZE;
 712                 position = 0;
 713                 repetitions = tx_cfg.repetitions;
 714                 while ((repetitions > 0) && (size > position)) {
 715                         if ((size - position) > device->free_in_fifo) {
 716                                 /* msg to big for fifo - take a part */
 717                                 int write_size = device->free_in_fifo;
 718
 719                                 device->free_in_fifo = 0;
 720                                 rf69_write_fifo(spi,
 721                                                 &device->buffer[position],
 722                                                 write_size);
 723                                 position += write_size;
 724                         } else {
 725                                 /* msg fits into fifo - take all */
 726                                 device->free_in_fifo -= size;
 727                                 repetitions--;
 728                                 rf69_write_fifo(spi,
 729                                                 &device->buffer[position],
 730                                                 (size - position));
 731                                 position = 0; /* reset for next repetition */
 732                         }
 733
 734                         retval = wait_event_interruptible(device->fifo_wait_queue,
 735                                                           device->free_in_fifo > 0);
 736                         if (retval) {
 737                                 dev_dbg(device->dev, "ABORT\n");
 738                                 goto abort;
 739                         }
 740                 }
 741
 742                 /* we are done. Wait for packet to get sent */
 743                 dev_dbg(device->dev,
 744                         "thread: wait for packet to get sent/fifo to be empty");
 745                 wait_event_interruptible(device->fifo_wait_queue,
 746                                          device->free_in_fifo == FIFO_SIZE ||
 747                                          kthread_should_stop());
 748                 if (kthread_should_stop())
 749                         dev_dbg(device->dev, "ABORT\n");
 750
 751                 /* STOP_TRANSMISSION */
 752                 dev_dbg(device->dev, "thread: Packet sent. Set mode to stby.");
 753                 retval = rf69_set_mode(spi, standby);
 754                 if (retval < 0)
 755                         return retval;
 756
 757                 /* everything sent? */
 758                 if (kfifo_is_empty(&device->tx_fifo)) {
 759 abort:
 760                         if (rx_interrupted) {
 761                                 rx_interrupted = false;
 762                                 pi433_start_rx(device);
 763                         }
 764                         device->tx_active = false;
 765                         wake_up_interruptible(&device->rx_wait_queue);
 766                 }
 767         }
 768 }
 769
 770 /*-------------------------------------------------------------------------*/
 771
 772 static ssize_t
 773 pi433_read(struct file *filp, char __user *buf, size_t size, loff_t *f_pos)
 774 {
 775         struct pi433_instance   *instance;
 776         struct pi433_device     *device;
 777         int                     bytes_received;
 778         ssize_t                 retval;
 779
 780         /* check, whether internal buffer is big enough for requested size */
 781         if (size > MAX_MSG_SIZE)
 782                 return -EMSGSIZE;
 783
 784         instance = filp->private_data;
 785         device = instance->device;
 786
 787         /* just one read request at a time */
 788         mutex_lock(&device->rx_lock);
 789         if (device->rx_active) {
 790                 mutex_unlock(&device->rx_lock);
 791                 return -EAGAIN;
 792         }
 793
 794         device->rx_active = true;
 795         mutex_unlock(&device->rx_lock);
 796
 797         /* start receiving */
 798         /* will block until something was received*/
 799         device->rx_buffer_size = size;
 800         bytes_received = pi433_receive(device);
 801
 802         /* release rx */
 803         mutex_lock(&device->rx_lock);
 804         device->rx_active = false;
 805         mutex_unlock(&device->rx_lock);
 806
 807         /* if read was successful copy to user space*/
 808         if (bytes_received > 0) {
 809                 retval = copy_to_user(buf, device->rx_buffer, bytes_received);
 810                 if (retval)
 811                         return -EFAULT;
 812         }
 813
 814         return bytes_received;
 815 }
 816
 817 static ssize_t
 818 pi433_write(struct file *filp, const char __user *buf,
 819             size_t count, loff_t *f_pos)
 820 {
 821         struct pi433_instance   *instance;
 822         struct pi433_device     *device;
 823         int                     retval;
 824         unsigned int            required, available, copied;
 825
 826         instance = filp->private_data;
 827         device = instance->device;
 828
 829         /* check, whether internal buffer (tx thread) is big enough for requested size */
 830         if (count > MAX_MSG_SIZE)
 831                 return -EMSGSIZE;
 832
 833         /* write the following sequence into fifo:
 834          * - tx_cfg
 835          * - size of message
 836          * - message
 837          */
 838         mutex_lock(&device->tx_fifo_lock);
 839
 840         required = sizeof(instance->tx_cfg) + sizeof(size_t) + count;
 841         available = kfifo_avail(&device->tx_fifo);
 842         if (required > available) {
 843                 dev_dbg(device->dev, "write to fifo failed: %d bytes required but %d available",
 844                         required, available);
 845                 mutex_unlock(&device->tx_fifo_lock);
 846                 return -EAGAIN;
 847         }
 848
 849         retval = kfifo_in(&device->tx_fifo, &instance->tx_cfg,
 850                           sizeof(instance->tx_cfg));
 851         if (retval != sizeof(instance->tx_cfg))
 852                 goto abort;
 853
 854         retval = kfifo_in(&device->tx_fifo, &count, sizeof(size_t));
 855         if (retval != sizeof(size_t))
 856                 goto abort;
 857
 858         retval = kfifo_from_user(&device->tx_fifo, buf, count, &copied);
 859         if (retval || copied != count)
 860                 goto abort;
 861
 862         mutex_unlock(&device->tx_fifo_lock);
 863
 864         /* start transfer */
 865         wake_up_interruptible(&device->tx_wait_queue);
 866         dev_dbg(device->dev, "write: generated new msg with %d bytes.", copied);
 867
 868         return copied;
 869
 870 abort:
 871         dev_warn(device->dev,
 872                  "write to fifo failed, non recoverable: 0x%x", retval);
 873         mutex_unlock(&device->tx_fifo_lock);
 874         return -EAGAIN;
 875 }
 876
 877 static long
 878 pi433_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 879 {
 880         int                     retval = 0;
 881         struct pi433_instance   *instance;
 882         struct pi433_device     *device;
 883         void __user *argp = (void __user *)arg;
 884
 885         /* Check type and command number */
 886         if (_IOC_TYPE(cmd) != PI433_IOC_MAGIC)
 887                 return -ENOTTY;
 888
 889         /* TODO? guard against device removal before, or while,
 890          * we issue this ioctl. --> device_get()
 891          */
 892         instance = filp->private_data;
 893         device = instance->device;
 894
 895         if (!device)
 896                 return -ESHUTDOWN;
 897
 898         switch (cmd) {
 899         case PI433_IOC_RD_TX_CFG:
 900                 if (copy_to_user(argp, &instance->tx_cfg,
 901                                  sizeof(struct pi433_tx_cfg)))
 902                         return -EFAULT;
 903                 break;
 904         case PI433_IOC_WR_TX_CFG:
 905                 if (copy_from_user(&instance->tx_cfg, argp,
 906                                    sizeof(struct pi433_tx_cfg)))
 907                         return -EFAULT;
 908                 break;
 909         case PI433_IOC_RD_RX_CFG:
 910                 if (copy_to_user(argp, &device->rx_cfg,
 911                                  sizeof(struct pi433_rx_cfg)))
 912                         return -EFAULT;
 913                 break;
 914         case PI433_IOC_WR_RX_CFG:
 915                 mutex_lock(&device->rx_lock);
 916
 917                 /* during pendig read request, change of config not allowed */
 918                 if (device->rx_active) {
 919                         mutex_unlock(&device->rx_lock);
 920                         return -EAGAIN;
 921                 }
 922
 923                 if (copy_from_user(&device->rx_cfg, argp,
 924                                    sizeof(struct pi433_rx_cfg))) {
 925                         mutex_unlock(&device->rx_lock);
 926                         return -EFAULT;
 927                 }
 928
 929                 mutex_unlock(&device->rx_lock);
 930                 break;
 931         default:
 932                 retval = -EINVAL;
 933         }
 934
 935         return retval;
 936 }
 937
 938 #ifdef CONFIG_COMPAT
 939 static long
 940 pi433_compat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 941 {
 942         return pi433_ioctl(filp, cmd, (unsigned long)compat_ptr(arg));
 943 }
 944 #else
 945 #define pi433_compat_ioctl NULL
 946 #endif /* CONFIG_COMPAT */
 947
 948 /*-------------------------------------------------------------------------*/
 949
 950 static int pi433_open(struct inode *inode, struct file *filp)
 951 {
 952         struct pi433_device     *device;
 953         struct pi433_instance   *instance;
 954
 955         mutex_lock(&minor_lock);
 956         device = idr_find(&pi433_idr, iminor(inode));
 957         mutex_unlock(&minor_lock);
 958         if (!device) {
 959                 pr_debug("device: minor %d unknown.\n", iminor(inode));
 960                 return -ENODEV;
 961         }
 962
 963         if (!device->rx_buffer) {
 964                 device->rx_buffer = kmalloc(MAX_MSG_SIZE, GFP_KERNEL);
 965                 if (!device->rx_buffer)
 966                         return -ENOMEM;
 967         }
 968
 969         device->users++;
 970         instance = kzalloc(sizeof(*instance), GFP_KERNEL);
 971         if (!instance) {
 972                 kfree(device->rx_buffer);
 973                 device->rx_buffer = NULL;
 974                 return -ENOMEM;
 975         }
 976
 977         /* setup instance data*/
 978         instance->device = device;
 979         instance->tx_cfg.bit_rate = 4711;
 980         // TODO: fill instance->tx_cfg;
 981
 982         /* instance data as context */
 983         filp->private_data = instance;
 984         nonseekable_open(inode, filp);
 985
 986         return 0;
 987 }
 988
 989 static int pi433_release(struct inode *inode, struct file *filp)
 990 {
 991         struct pi433_instance   *instance;
 992         struct pi433_device     *device;
 993
 994         instance = filp->private_data;
 995         device = instance->device;
 996         kfree(instance);
 997         filp->private_data = NULL;
 998
 999         /* last close? */
1000         device->users--;
1001
1002         if (!device->users) {
1003                 kfree(device->rx_buffer);
1004                 device->rx_buffer = NULL;
1005                 if (!device->spi)
1006                         kfree(device);
1007         }
1008
1009         return 0;
1010 }
1011
1012 /*-------------------------------------------------------------------------*/
1013
1014 static int setup_gpio(struct pi433_device *device)
1015 {
1016         char    name[5];
1017         int     retval;
1018         int     i;
1019         const irq_handler_t DIO_irq_handler[NUM_DIO] = {
1020                 DIO0_irq_handler,
1021                 DIO1_irq_handler
1022         };
1023
1024         for (i = 0; i < NUM_DIO; i++) {
1025                 /* "construct" name and get the gpio descriptor */
1026                 snprintf(name, sizeof(name), "DIO%d", i);
1027                 device->gpiod[i] = gpiod_get(&device->spi->dev, name,
1028                                              0 /*GPIOD_IN*/);
1029
1030                 if (device->gpiod[i] == ERR_PTR(-ENOENT)) {
1031                         dev_dbg(&device->spi->dev,
1032                                 "Could not find entry for %s. Ignoring.", name);
1033                         continue;
1034                 }
1035
1036                 if (device->gpiod[i] == ERR_PTR(-EBUSY))
1037                         dev_dbg(&device->spi->dev, "%s is busy.", name);
1038
1039                 if (IS_ERR(device->gpiod[i])) {
1040                         retval = PTR_ERR(device->gpiod[i]);
1041                         /* release already allocated gpios */
1042                         for (i--; i >= 0; i--) {
1043                                 free_irq(device->irq_num[i], device);
1044                                 gpiod_put(device->gpiod[i]);
1045                         }
1046                         return retval;
1047                 }
1048
1049                 /* configure the pin */
1050                 gpiod_unexport(device->gpiod[i]);
1051                 retval = gpiod_direction_input(device->gpiod[i]);
1052                 if (retval)
1053                         return retval;
1054
1055                 /* configure irq */
1056                 device->irq_num[i] = gpiod_to_irq(device->gpiod[i]);
1057                 if (device->irq_num[i] < 0) {
1058                         device->gpiod[i] = ERR_PTR(-EINVAL);
1059                         return device->irq_num[i];
1060                 }
1061                 retval = request_irq(device->irq_num[i],
1062                                      DIO_irq_handler[i],
1063                                      0, /* flags */
1064                                      name,
1065                                      device);
1066
1067                 if (retval)
1068                         return retval;
1069
1070                 dev_dbg(&device->spi->dev, "%s successfully configured", name);
1071         }
1072
1073         return 0;
1074 }
1075
1076 static void free_gpio(struct pi433_device *device)
1077 {
1078         int i;
1079
1080         for (i = 0; i < NUM_DIO; i++) {
1081                 /* check if gpiod is valid */
1082                 if (IS_ERR(device->gpiod[i]))
1083                         continue;
1084
1085                 free_irq(device->irq_num[i], device);
1086                 gpiod_put(device->gpiod[i]);
1087         }
1088 }
1089
1090 static int pi433_get_minor(struct pi433_device *device)
1091 {
1092         int retval = -ENOMEM;
1093
1094         mutex_lock(&minor_lock);
1095         retval = idr_alloc(&pi433_idr, device, 0, N_PI433_MINORS, GFP_KERNEL);
1096         if (retval >= 0) {
1097                 device->minor = retval;
1098                 retval = 0;
1099         } else if (retval == -ENOSPC) {
1100                 dev_err(&device->spi->dev, "too many pi433 devices\n");
1101                 retval = -EINVAL;
1102         }
1103         mutex_unlock(&minor_lock);
1104         return retval;
1105 }
1106
1107 static void pi433_free_minor(struct pi433_device *dev)
1108 {
1109         mutex_lock(&minor_lock);
1110         idr_remove(&pi433_idr, dev->minor);
1111         mutex_unlock(&minor_lock);
1112 }
1113
1114 /*-------------------------------------------------------------------------*/
1115
1116 static const struct file_operations pi433_fops = {
1117         .owner =        THIS_MODULE,
1118         /* REVISIT switch to aio primitives, so that userspace
1119          * gets more complete API coverage.  It'll simplify things
1120          * too, except for the locking.
1121          */
1122         .write =        pi433_write,
1123         .read =         pi433_read,
1124         .unlocked_ioctl = pi433_ioctl,
1125         .compat_ioctl = pi433_compat_ioctl,
1126         .open =         pi433_open,
1127         .release =      pi433_release,
1128         .llseek =       no_llseek,
1129 };
1130
1131 /*-------------------------------------------------------------------------*/
1132
1133 static int pi433_probe(struct spi_device *spi)
1134 {
1135         struct pi433_device     *device;
1136         int                     retval;
1137
1138         /* setup spi parameters */
1139         spi->mode = 0x00;
1140         spi->bits_per_word = 8;
1141         /* spi->max_speed_hz = 10000000;  1MHz already set by device tree overlay */
1142
1143         retval = spi_setup(spi);
1144         if (retval) {
1145                 dev_dbg(&spi->dev, "configuration of SPI interface failed!\n");
1146                 return retval;
1147         }
1148
1149         dev_dbg(&spi->dev,
1150                 "spi interface setup: mode 0x%2x, %d bits per word, %dhz max speed",
1151                 spi->mode, spi->bits_per_word, spi->max_speed_hz);
1152
1153         /* Ping the chip by reading the version register */
1154         retval = spi_w8r8(spi, 0x10);
1155         if (retval < 0)
1156                 return retval;
1157
1158         switch (retval) {
1159         case 0x24:
1160                 dev_dbg(&spi->dev, "found pi433 (ver. 0x%x)", retval);
1161                 break;
1162         default:
1163                 dev_dbg(&spi->dev, "unknown chip version: 0x%x", retval);
1164                 return -ENODEV;
1165         }
1166
1167         /* Allocate driver data */
1168         device = kzalloc(sizeof(*device), GFP_KERNEL);
1169         if (!device)
1170                 return -ENOMEM;
1171
1172         /* Initialize the driver data */
1173         device->spi = spi;
1174         device->rx_active = false;
1175         device->tx_active = false;
1176         device->interrupt_rx_allowed = false;
1177
1178         /* init wait queues */
1179         init_waitqueue_head(&device->tx_wait_queue);
1180         init_waitqueue_head(&device->rx_wait_queue);
1181         init_waitqueue_head(&device->fifo_wait_queue);
1182
1183         /* init fifo */
1184         INIT_KFIFO(device->tx_fifo);
1185
1186         /* init mutexes and locks */
1187         mutex_init(&device->tx_fifo_lock);
1188         mutex_init(&device->rx_lock);
1189
1190         /* setup GPIO (including irq_handler) for the different DIOs */
1191         retval = setup_gpio(device);
1192         if (retval) {
1193                 dev_dbg(&spi->dev, "setup of GPIOs failed");
1194                 goto GPIO_failed;
1195         }
1196
1197         /* setup the radio module */
1198         retval = rf69_set_mode(spi, standby);
1199         if (retval < 0)
1200                 goto minor_failed;
1201         retval = rf69_set_data_mode(spi, DATAMODUL_MODE_PACKET);
1202         if (retval < 0)
1203                 goto minor_failed;
1204         retval = rf69_enable_amplifier(spi, MASK_PALEVEL_PA0);
1205         if (retval < 0)
1206                 goto minor_failed;
1207         retval = rf69_disable_amplifier(spi, MASK_PALEVEL_PA1);
1208         if (retval < 0)
1209                 goto minor_failed;
1210         retval = rf69_disable_amplifier(spi, MASK_PALEVEL_PA2);
1211         if (retval < 0)
1212                 goto minor_failed;
1213         retval = rf69_set_output_power_level(spi, 13);
1214         if (retval < 0)
1215                 goto minor_failed;
1216         retval = rf69_set_antenna_impedance(spi, fifty_ohm);
1217         if (retval < 0)
1218                 goto minor_failed;
1219
1220         /* determ minor number */
1221         retval = pi433_get_minor(device);
1222         if (retval) {
1223                 dev_dbg(&spi->dev, "get of minor number failed");
1224                 goto minor_failed;
1225         }
1226
1227         /* create device */
1228         device->devt = MKDEV(MAJOR(pi433_dev), device->minor);
1229         device->dev = device_create(pi433_class,
1230                                     &spi->dev,
1231                                     device->devt,
1232                                     device,
1233                                     "pi433.%d",
1234                                     device->minor);
1235         if (IS_ERR(device->dev)) {
1236                 pr_err("pi433: device register failed\n");
1237                 retval = PTR_ERR(device->dev);
1238                 goto device_create_failed;
1239         } else {
1240                 dev_dbg(device->dev,
1241                         "created device for major %d, minor %d\n",
1242                         MAJOR(pi433_dev),
1243                         device->minor);
1244         }
1245
1246         /* start tx thread */
1247         device->tx_task_struct = kthread_run(pi433_tx_thread,
1248                                              device,
1249                                              "pi433.%d_tx_task",
1250                                              device->minor);
1251         if (IS_ERR(device->tx_task_struct)) {
1252                 dev_dbg(device->dev, "start of send thread failed");
1253                 goto send_thread_failed;
1254         }
1255
1256         /* create cdev */
1257         device->cdev = cdev_alloc();
1258         device->cdev->owner = THIS_MODULE;
1259         cdev_init(device->cdev, &pi433_fops);
1260         retval = cdev_add(device->cdev, device->devt, 1);
1261         if (retval) {
1262                 dev_dbg(device->dev, "register of cdev failed");
1263                 goto cdev_failed;
1264         }
1265
1266         /* spi setup */
1267         spi_set_drvdata(spi, device);
1268
1269         return 0;
1270
1271 cdev_failed:
1272         kthread_stop(device->tx_task_struct);
1273 send_thread_failed:
1274         device_destroy(pi433_class, device->devt);
1275 device_create_failed:
1276         pi433_free_minor(device);
1277 minor_failed:
1278         free_gpio(device);
1279 GPIO_failed:
1280         kfree(device);
1281
1282         return retval;
1283 }
1284
1285 static int pi433_remove(struct spi_device *spi)
1286 {
1287         struct pi433_device     *device = spi_get_drvdata(spi);
1288
1289         /* free GPIOs */
1290         free_gpio(device);
1291
1292         /* make sure ops on existing fds can abort cleanly */
1293         device->spi = NULL;
1294
1295         kthread_stop(device->tx_task_struct);
1296
1297         device_destroy(pi433_class, device->devt);
1298
1299         cdev_del(device->cdev);
1300
1301         pi433_free_minor(device);
1302
1303         if (device->users == 0)
1304                 kfree(device);
1305
1306         return 0;
1307 }
1308
1309 static const struct of_device_id pi433_dt_ids[] = {
1310         { .compatible = "Smarthome-Wolf,pi433" },
1311         {},
1312 };
1313
1314 MODULE_DEVICE_TABLE(of, pi433_dt_ids);
1315
1316 static struct spi_driver pi433_spi_driver = {
1317         .driver = {
1318                 .name =         "pi433",
1319                 .owner =        THIS_MODULE,
1320                 .of_match_table = of_match_ptr(pi433_dt_ids),
1321         },
1322         .probe =        pi433_probe,
1323         .remove =       pi433_remove,
1324
1325         /* NOTE:  suspend/resume methods are not necessary here.
1326          * We don't do anything except pass the requests to/from
1327          * the underlying controller.  The refrigerator handles
1328          * most issues; the controller driver handles the rest.
1329          */
1330 };
1331
1332 /*-------------------------------------------------------------------------*/
1333
1334 static int __init pi433_init(void)
1335 {
1336         int status;
1337
1338         /* If MAX_MSG_SIZE is smaller then FIFO_SIZE, the driver won't
1339          * work stable - risk of buffer overflow
1340          */
1341         if (MAX_MSG_SIZE < FIFO_SIZE)
1342                 return -EINVAL;
1343
1344         /* Claim device numbers.  Then register a class
1345          * that will key udev/mdev to add/remove /dev nodes.  Last, register
1346          * Last, register the driver which manages those device numbers.
1347          */
1348         status = alloc_chrdev_region(&pi433_dev, 0, N_PI433_MINORS, "pi433");
1349         if (status < 0)
1350                 return status;
1351
1352         pi433_class = class_create(THIS_MODULE, "pi433");
1353         if (IS_ERR(pi433_class)) {
1354                 unregister_chrdev(MAJOR(pi433_dev),
1355                                   pi433_spi_driver.driver.name);
1356                 return PTR_ERR(pi433_class);
1357         }
1358
1359         status = spi_register_driver(&pi433_spi_driver);
1360         if (status < 0) {
1361                 class_destroy(pi433_class);
1362                 unregister_chrdev(MAJOR(pi433_dev),
1363                                   pi433_spi_driver.driver.name);
1364         }
1365
1366         return status;
1367 }
1368
1369 module_init(pi433_init);
1370
1371 static void __exit pi433_exit(void)
1372 {
1373         spi_unregister_driver(&pi433_spi_driver);
1374         class_destroy(pi433_class);
1375         unregister_chrdev(MAJOR(pi433_dev), pi433_spi_driver.driver.name);
1376 }
1377 module_exit(pi433_exit);
1378
1379 MODULE_AUTHOR("Marcus Wolf, <[email protected]>");
1380 MODULE_DESCRIPTION("Driver for Pi433");
1381 MODULE_LICENSE("GPL");
1382 MODULE_ALIAS("spi:pi433");