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 <linux@wolf-entwicklungen.de>
  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; // TODO: check, whether necessary or obsolete
  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, rx_cfg->bw_exponent);
 191         if (ret < 0)
 192                 return ret;
 193         ret = rf69_set_bandwidth_during_afc(dev->spi, rx_cfg->bw_mantisse, rx_cfg->bw_exponent);
 194         if (ret < 0)
 195                 return ret;
 196         ret = rf69_set_dagc(dev->spi, rx_cfg->dagc);
 197         if (ret < 0)
 198                 return ret;
 199
 200         dev->rx_bytes_to_drop = rx_cfg->bytes_to_drop;
 201
 202         /* packet config */
 203         /* enable */
 204         if (rx_cfg->enable_sync == OPTION_ON) {
 205                 ret = rf69_enable_sync(dev->spi);
 206                 if (ret < 0)
 207                         return ret;
 208
 209                 ret = rf69_set_fifo_fill_condition(dev->spi, afterSyncInterrupt);
 210                 if (ret < 0)
 211                         return ret;
 212         } else {
 213                 ret = rf69_disable_sync(dev->spi);
 214                 if (ret < 0)
 215                         return ret;
 216
 217                 ret = rf69_set_fifo_fill_condition(dev->spi, always);
 218                 if (ret < 0)
 219                         return ret;
 220         }
 221         if (rx_cfg->enable_length_byte == OPTION_ON) {
 222                 ret = rf69_set_packet_format(dev->spi, packetLengthVar);
 223                 if (ret < 0)
 224                         return ret;
 225         } else {
 226                 ret = rf69_set_packet_format(dev->spi, packetLengthFix);
 227                 if (ret < 0)
 228                         return ret;
 229         }
 230         ret = rf69_set_adressFiltering(dev->spi, rx_cfg->enable_address_filtering);
 231         if (ret < 0)
 232                 return ret;
 233
 234         if (rx_cfg->enable_crc == OPTION_ON) {
 235                 ret = rf69_enable_crc(dev->spi);
 236                 if (ret < 0)
 237                         return ret;
 238         } else {
 239                 ret = rf69_disable_crc(dev->spi);
 240                 if (ret < 0)
 241                         return ret;
 242         }
 243
 244         /* lengths */
 245         ret = rf69_set_sync_size(dev->spi, rx_cfg->sync_length);
 246         if (ret < 0)
 247                 return ret;
 248         if (rx_cfg->enable_length_byte == OPTION_ON) {
 249                 ret = rf69_set_payload_length(dev->spi, 0xff);
 250                 if (ret < 0)
 251                         return ret;
 252         } else if (rx_cfg->fixed_message_length != 0) {
 253                 payload_length = rx_cfg->fixed_message_length;
 254                 if (rx_cfg->enable_length_byte  == OPTION_ON)
 255                         payload_length++;
 256                 if (rx_cfg->enable_address_filtering != filteringOff)
 257                         payload_length++;
 258                 ret = rf69_set_payload_length(dev->spi, payload_length);
 259                 if (ret < 0)
 260                         return ret;
 261         } else {
 262                 ret = rf69_set_payload_length(dev->spi, 0);
 263                 if (ret < 0)
 264                         return ret;
 265         }
 266
 267         /* values */
 268         if (rx_cfg->enable_sync == OPTION_ON) {
 269                 ret = rf69_set_sync_values(dev->spi, rx_cfg->sync_pattern);
 270                 if (ret < 0)
 271                         return ret;
 272         }
 273         if (rx_cfg->enable_address_filtering != filteringOff) {
 274                 ret = rf69_set_node_address(dev->spi, rx_cfg->node_address);
 275                 if (ret < 0)
 276                         return ret;
 277                 ret = rf69_set_broadcast_address(dev->spi, rx_cfg->broadcast_address);
 278                 if (ret < 0)
 279                         return ret;
 280         }
 281
 282         return 0;
 283 }
 284
 285 static int
 286 rf69_set_tx_cfg(struct pi433_device *dev, struct pi433_tx_cfg *tx_cfg)
 287 {
 288         int ret;
 289
 290         ret = rf69_set_frequency(dev->spi, tx_cfg->frequency);
 291         if (ret < 0)
 292                 return ret;
 293         ret = rf69_set_bit_rate(dev->spi, tx_cfg->bit_rate);
 294         if (ret < 0)
 295                 return ret;
 296         ret = rf69_set_modulation(dev->spi, tx_cfg->modulation);
 297         if (ret < 0)
 298                 return ret;
 299         ret = rf69_set_deviation(dev->spi, tx_cfg->dev_frequency);
 300         if (ret < 0)
 301                 return ret;
 302         ret = rf69_set_pa_ramp(dev->spi, tx_cfg->pa_ramp);
 303         if (ret < 0)
 304                 return ret;
 305         ret = rf69_set_modulation_shaping(dev->spi, tx_cfg->mod_shaping);
 306         if (ret < 0)
 307                 return ret;
 308         ret = rf69_set_tx_start_condition(dev->spi, tx_cfg->tx_start_condition);
 309         if (ret < 0)
 310                 return ret;
 311
 312         /* packet format enable */
 313         if (tx_cfg->enable_preamble == OPTION_ON) {
 314                 ret = rf69_set_preamble_length(dev->spi, tx_cfg->preamble_length);
 315                 if (ret < 0)
 316                         return ret;
 317         } else {
 318                 ret = rf69_set_preamble_length(dev->spi, 0);
 319                 if (ret < 0)
 320                         return ret;
 321         }
 322
 323         if (tx_cfg->enable_sync == OPTION_ON) {
 324                 ret = rf69_enable_sync(dev->spi);
 325                 if (ret < 0)
 326                         return ret;
 327         } else {
 328                 ret = rf69_disable_sync(dev->spi);
 329                 if (ret < 0)
 330                         return ret;
 331         }
 332
 333         if (tx_cfg->enable_length_byte == OPTION_ON) {
 334                 ret = rf69_set_packet_format(dev->spi, packetLengthVar);
 335                 if (ret < 0)
 336                         return ret;
 337         } else {
 338                 ret = rf69_set_packet_format(dev->spi, packetLengthFix);
 339                 if (ret < 0)
 340                         return ret;
 341         }
 342
 343         if (tx_cfg->enable_crc == OPTION_ON) {
 344                 ret = rf69_enable_crc(dev->spi);
 345                 if (ret < 0)
 346                         return ret;
 347         } else {
 348                 ret = rf69_disable_crc(dev->spi);
 349                 if (ret < 0)
 350                         return ret;
 351         }
 352
 353         /* configure sync, if enabled */
 354         if (tx_cfg->enable_sync == OPTION_ON) {
 355                 ret = rf69_set_sync_size(dev->spi, tx_cfg->sync_length);
 356                 if (ret < 0)
 357                         return ret;
 358                 ret = rf69_set_sync_values(dev->spi, tx_cfg->sync_pattern);
 359                 if (ret < 0)
 360                         return ret;
 361         }
 362
 363         return 0;
 364 }
 365
 366 /*-------------------------------------------------------------------------*/
 367
 368 static int
 369 pi433_start_rx(struct pi433_device *dev)
 370 {
 371         int retval;
 372
 373         /* return without action, if no pending read request */
 374         if (!dev->rx_active)
 375                 return 0;
 376
 377         /* setup for receiving */
 378         retval = rf69_set_rx_cfg(dev, &dev->rx_cfg);
 379         if (retval)
 380                 return retval;
 381
 382         /* setup rssi irq */
 383         retval = rf69_set_dio_mapping(dev->spi, DIO0, DIO_RSSI_DIO0);
 384         if (retval < 0)
 385                 return retval;
 386         dev->irq_state[DIO0] = DIO_RSSI_DIO0;
 387         irq_set_irq_type(dev->irq_num[DIO0], IRQ_TYPE_EDGE_RISING);
 388
 389         /* setup fifo level interrupt */
 390         retval = rf69_set_fifo_threshold(dev->spi, FIFO_SIZE - FIFO_THRESHOLD);
 391         if (retval < 0)
 392                 return retval;
 393         retval = rf69_set_dio_mapping(dev->spi, DIO1, DIO_FIFO_LEVEL);
 394         if (retval < 0)
 395                 return retval;
 396         dev->irq_state[DIO1] = DIO_FIFO_LEVEL;
 397         irq_set_irq_type(dev->irq_num[DIO1], IRQ_TYPE_EDGE_RISING);
 398
 399         /* set module to receiving mode */
 400         retval = rf69_set_mode(dev->spi, receive);
 401         if (retval < 0)
 402                 return retval;
 403
 404         return 0;
 405 }
 406
 407 /*-------------------------------------------------------------------------*/
 408
 409 static int
 410 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");
 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_get_flag(dev->spi, rssiExceededThreshold)) {
 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");
 447                 retval = wait_event_interruptible(dev->rx_wait_queue,
 448                                                   rf69_get_flag(dev->spi,
 449                                                                 rssiExceededThreshold));
 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", bytes_total);
 474         } else {
 475                 bytes_total = dev->rx_buffer_size;
 476                 dev_dbg(dev->dev, "rx: msg len set to %d as requested by read", bytes_total);
 477         }
 478
 479         /* length byte enabled? */
 480         if (dev->rx_cfg.enable_length_byte == OPTION_ON) {
 481                 retval = wait_event_interruptible(dev->fifo_wait_queue,
 482                                                   dev->free_in_fifo < FIFO_SIZE);
 483                 if (retval) /* wait was interrupted */
 484                         goto abort;
 485
 486                 rf69_read_fifo(spi, (u8 *)&bytes_total, 1);
 487                 if (bytes_total > dev->rx_buffer_size) {
 488                         retval = -1;
 489                         goto abort;
 490                 }
 491                 dev->free_in_fifo++;
 492                 dev_dbg(dev->dev, "rx: msg len reset to %d due to length byte", bytes_total);
 493         }
 494
 495         /* address byte enabled? */
 496         if (dev->rx_cfg.enable_address_filtering != filteringOff) {
 497                 u8 dummy;
 498
 499                 bytes_total--;
 500
 501                 retval = wait_event_interruptible(dev->fifo_wait_queue,
 502                                                   dev->free_in_fifo < FIFO_SIZE);
 503                 if (retval) /* wait was interrupted */
 504                         goto abort;
 505
 506                 rf69_read_fifo(spi, &dummy, 1);
 507                 dev->free_in_fifo++;
 508                 dev_dbg(dev->dev, "rx: address byte stripped off");
 509         }
 510
 511         /* get payload */
 512         while (dev->rx_position < bytes_total) {
 513                 if (!rf69_get_flag(dev->spi, payload_ready)) {
 514                         retval = wait_event_interruptible(dev->fifo_wait_queue,
 515                                                           dev->free_in_fifo < FIFO_SIZE);
 516                         if (retval) /* wait was interrupted */
 517                                 goto abort;
 518                 }
 519
 520                 /* need to drop bytes or acquire? */
 521                 if (dev->rx_bytes_to_drop > dev->rx_bytes_dropped)
 522                         bytes_to_read = dev->rx_bytes_to_drop - dev->rx_bytes_dropped;
 523                 else
 524                         bytes_to_read = bytes_total - dev->rx_position;
 525
 526                 /* access the fifo */
 527                 if (bytes_to_read > FIFO_SIZE - dev->free_in_fifo)
 528                         bytes_to_read = FIFO_SIZE - dev->free_in_fifo;
 529                 retval = rf69_read_fifo(spi,
 530                                         &dev->rx_buffer[dev->rx_position],
 531                                         bytes_to_read);
 532                 if (retval) /* read failed */
 533                         goto abort;
 534
 535                 dev->free_in_fifo += bytes_to_read;
 536
 537                 /* adjust status vars */
 538                 if (dev->rx_bytes_to_drop > dev->rx_bytes_dropped)
 539                         dev->rx_bytes_dropped += bytes_to_read;
 540                 else
 541                         dev->rx_position += bytes_to_read;
 542         }
 543
 544         /* rx done, wait was interrupted or error occurred */
 545 abort:
 546         dev->interrupt_rx_allowed = true;
 547         if (rf69_set_mode(dev->spi, standby))
 548                 pr_err("rf69_set_mode(): radio module failed to go standby\n");
 549         wake_up_interruptible(&dev->tx_wait_queue);
 550
 551         if (retval)
 552                 return retval;
 553         else
 554                 return bytes_total;
 555 }
 556
 557 static int
 558 pi433_tx_thread(void *data)
 559 {
 560         struct pi433_device *device = data;
 561         struct spi_device *spi = device->spi;
 562         struct pi433_tx_cfg tx_cfg;
 563         size_t size;
 564         bool   rx_interrupted = false;
 565         int    position, repetitions;
 566         int    retval;
 567
 568         while (1) {
 569                 /* wait for fifo to be populated or for request to terminate*/
 570                 dev_dbg(device->dev, "thread: going to wait for new messages");
 571                 wait_event_interruptible(device->tx_wait_queue,
 572                                          (!kfifo_is_empty(&device->tx_fifo) ||
 573                                           kthread_should_stop()));
 574                 if (kthread_should_stop())
 575                         return 0;
 576
 577                 /* get data from fifo in the following order:
 578                  * - tx_cfg
 579                  * - size of message
 580                  * - message
 581                  */
 582                 mutex_lock(&device->tx_fifo_lock);
 583
 584                 retval = kfifo_out(&device->tx_fifo, &tx_cfg, sizeof(tx_cfg));
 585                 if (retval != sizeof(tx_cfg)) {
 586                         dev_dbg(device->dev, "reading tx_cfg from fifo failed: got %d byte(s), expected %d", retval, (unsigned int)sizeof(tx_cfg));
 587                         mutex_unlock(&device->tx_fifo_lock);
 588                         continue;
 589                 }
 590
 591                 retval = kfifo_out(&device->tx_fifo, &size, sizeof(size_t));
 592                 if (retval != sizeof(size_t)) {
 593                         dev_dbg(device->dev, "reading msg size from fifo failed: got %d, expected %d", retval, (unsigned int)sizeof(size_t));
 594                         mutex_unlock(&device->tx_fifo_lock);
 595                         continue;
 596                 }
 597
 598                 /* use fixed message length, if requested */
 599                 if (tx_cfg.fixed_message_length != 0)
 600                         size = tx_cfg.fixed_message_length;
 601
 602                 /* increase size, if len byte is requested */
 603                 if (tx_cfg.enable_length_byte == OPTION_ON)
 604                         size++;
 605
 606                 /* increase size, if adr byte is requested */
 607                 if (tx_cfg.enable_address_byte == OPTION_ON)
 608                         size++;
 609
 610                 /* prime buffer */
 611                 memset(device->buffer, 0, size);
 612                 position = 0;
 613
 614                 /* add length byte, if requested */
 615                 if (tx_cfg.enable_length_byte  == OPTION_ON)
 616                         device->buffer[position++] = size - 1; /* according to spec length byte itself must be excluded from the length calculation */
 617
 618                 /* add adr byte, if requested */
 619                 if (tx_cfg.enable_address_byte == OPTION_ON)
 620                         device->buffer[position++] = tx_cfg.address_byte;
 621
 622                 /* finally get message data from fifo */
 623                 retval = kfifo_out(&device->tx_fifo, &device->buffer[position], sizeof(device->buffer) - position);
 624                 dev_dbg(device->dev, "read %d message byte(s) from fifo queue.", retval);
 625                 mutex_unlock(&device->tx_fifo_lock);
 626
 627                 /* if rx is active, we need to interrupt the waiting for
 628                  * incoming telegrams, to be able to send something.
 629                  * We are only allowed, if currently no reception takes
 630                  * place otherwise we need to  wait for the incoming telegram
 631                  * to finish
 632                  */
 633                 wait_event_interruptible(device->tx_wait_queue,
 634                                          !device->rx_active ||
 635                                           device->interrupt_rx_allowed);
 636
 637                 /* prevent race conditions
 638                  * irq will be reenabled after tx config is set
 639                  */
 640                 disable_irq(device->irq_num[DIO0]);
 641                 device->tx_active = true;
 642
 643                 if (device->rx_active && !rx_interrupted) {
 644                         /* rx is currently waiting for a telegram;
 645                          * we need to set the radio module to standby
 646                          */
 647                         retval = rf69_set_mode(device->spi, standby);
 648                         if (retval < 0)
 649                                 return retval;
 650                         rx_interrupted = true;
 651                 }
 652
 653                 /* clear fifo, set fifo threshold, set payload length */
 654                 retval = rf69_set_mode(spi, standby); /* this clears the fifo */
 655                 if (retval < 0)
 656                         return retval;
 657                 retval = rf69_set_fifo_threshold(spi, FIFO_THRESHOLD);
 658                 if (retval < 0)
 659                         return retval;
 660                 if (tx_cfg.enable_length_byte == OPTION_ON) {
 661                         retval = rf69_set_payload_length(spi, size * tx_cfg.repetitions);
 662                         if (retval < 0)
 663                                 return retval;
 664                 } else {
 665                         retval = rf69_set_payload_length(spi, 0);
 666                         if (retval < 0)
 667                                 return retval;
 668                 }
 669
 670                 /* configure the rf chip */
 671                 retval = rf69_set_tx_cfg(device, &tx_cfg);
 672                 if (retval < 0)
 673                         return retval;
 674
 675                 /* enable fifo level interrupt */
 676                 retval = rf69_set_dio_mapping(spi, DIO1, DIO_FIFO_LEVEL);
 677                 if (retval < 0)
 678                         return retval;
 679                 device->irq_state[DIO1] = DIO_FIFO_LEVEL;
 680                 irq_set_irq_type(device->irq_num[DIO1], IRQ_TYPE_EDGE_FALLING);
 681
 682                 /* enable packet sent interrupt */
 683                 retval = rf69_set_dio_mapping(spi, DIO0, DIO_PACKET_SENT);
 684                 if (retval < 0)
 685                         return retval;
 686                 device->irq_state[DIO0] = DIO_PACKET_SENT;
 687                 irq_set_irq_type(device->irq_num[DIO0], IRQ_TYPE_EDGE_RISING);
 688                 enable_irq(device->irq_num[DIO0]); /* was disabled by rx active check */
 689
 690                 /* enable transmission */
 691                 retval = rf69_set_mode(spi, transmit);
 692                 if (retval < 0)
 693                         return retval;
 694
 695                 /* transfer this msg (and repetitions) to chip fifo */
 696                 device->free_in_fifo = FIFO_SIZE;
 697                 position = 0;
 698                 repetitions = tx_cfg.repetitions;
 699                 while ((repetitions > 0) && (size > position)) {
 700                         if ((size - position) > device->free_in_fifo) {
 701                                 /* msg to big for fifo - take a part */
 702                                 int temp = device->free_in_fifo;
 703                                 device->free_in_fifo = 0;
 704                                 rf69_write_fifo(spi,
 705                                                 &device->buffer[position],
 706                                                 temp);
 707                                 position += temp;
 708                         } else {
 709                                 /* msg fits into fifo - take all */
 710                                 device->free_in_fifo -= size;
 711                                 repetitions--;
 712                                 rf69_write_fifo(spi,
 713                                                 &device->buffer[position],
 714                                                 (size - position));
 715                                 position = 0; /* reset for next repetition */
 716                         }
 717
 718                         retval = wait_event_interruptible(device->fifo_wait_queue,
 719                                                           device->free_in_fifo > 0);
 720                         if (retval) {
 721                                 dev_dbg(device->dev, "ABORT\n");
 722                                 goto abort;
 723                         }
 724                 }
 725
 726                 /* we are done. Wait for packet to get sent */
 727                 dev_dbg(device->dev, "thread: wait for packet to get sent/fifo to be empty");
 728                 wait_event_interruptible(device->fifo_wait_queue,
 729                                          device->free_in_fifo == FIFO_SIZE ||
 730                                          kthread_should_stop());
 731                 if (kthread_should_stop())
 732                         dev_dbg(device->dev, "ABORT\n");
 733
 734                 /* STOP_TRANSMISSION */
 735                 dev_dbg(device->dev, "thread: Packet sent. Set mode to stby.");
 736                 retval = rf69_set_mode(spi, standby);
 737                 if (retval < 0)
 738                         return retval;
 739
 740                 /* everything sent? */
 741                 if (kfifo_is_empty(&device->tx_fifo)) {
 742 abort:
 743                         if (rx_interrupted) {
 744                                 rx_interrupted = false;
 745                                 pi433_start_rx(device);
 746                         }
 747                         device->tx_active = false;
 748                         wake_up_interruptible(&device->rx_wait_queue);
 749                 }
 750         }
 751 }
 752
 753 /*-------------------------------------------------------------------------*/
 754
 755 static ssize_t
 756 pi433_read(struct file *filp, char __user *buf, size_t size, loff_t *f_pos)
 757 {
 758         struct pi433_instance   *instance;
 759         struct pi433_device     *device;
 760         int                     bytes_received;
 761         ssize_t                 retval;
 762
 763         /* check, whether internal buffer is big enough for requested size */
 764         if (size > MAX_MSG_SIZE)
 765                 return -EMSGSIZE;
 766
 767         instance = filp->private_data;
 768         device = instance->device;
 769
 770         /* just one read request at a time */
 771         mutex_lock(&device->rx_lock);
 772         if (device->rx_active) {
 773                 mutex_unlock(&device->rx_lock);
 774                 return -EAGAIN;
 775         }
 776
 777         device->rx_active = true;
 778         mutex_unlock(&device->rx_lock);
 779
 780         /* start receiving */
 781         /* will block until something was received*/
 782         device->rx_buffer_size = size;
 783         bytes_received = pi433_receive(device);
 784
 785         /* release rx */
 786         mutex_lock(&device->rx_lock);
 787         device->rx_active = false;
 788         mutex_unlock(&device->rx_lock);
 789
 790         /* if read was successful copy to user space*/
 791         if (bytes_received > 0) {
 792                 retval = copy_to_user(buf, device->rx_buffer, bytes_received);
 793                 if (retval)
 794                         return -EFAULT;
 795         }
 796
 797         return bytes_received;
 798 }
 799
 800 static ssize_t
 801 pi433_write(struct file *filp, const char __user *buf,
 802             size_t count, loff_t *f_pos)
 803 {
 804         struct pi433_instance   *instance;
 805         struct pi433_device     *device;
 806         int                     retval;
 807         unsigned int            copied;
 808
 809         instance = filp->private_data;
 810         device = instance->device;
 811
 812         /* check, whether internal buffer (tx thread) is big enough for requested size */
 813         if (count > MAX_MSG_SIZE)
 814                 return -EMSGSIZE;
 815
 816         /* write the following sequence into fifo:
 817          * - tx_cfg
 818          * - size of message
 819          * - message
 820          */
 821         mutex_lock(&device->tx_fifo_lock);
 822         retval = kfifo_in(&device->tx_fifo, &instance->tx_cfg, sizeof(instance->tx_cfg));
 823         if (retval != sizeof(instance->tx_cfg))
 824                 goto abort;
 825
 826         retval = kfifo_in(&device->tx_fifo, &count, sizeof(size_t));
 827         if (retval != sizeof(size_t))
 828                 goto abort;
 829
 830         retval = kfifo_from_user(&device->tx_fifo, buf, count, &copied);
 831         if (retval || copied != count)
 832                 goto abort;
 833
 834         mutex_unlock(&device->tx_fifo_lock);
 835
 836         /* start transfer */
 837         wake_up_interruptible(&device->tx_wait_queue);
 838         dev_dbg(device->dev, "write: generated new msg with %d bytes.", copied);
 839
 840         return copied;
 841
 842 abort:
 843         dev_dbg(device->dev, "write to fifo failed: 0x%x", retval);
 844         kfifo_reset(&device->tx_fifo); // TODO: maybe find a solution, not to discard already stored, valid entries
 845         mutex_unlock(&device->tx_fifo_lock);
 846         return -EAGAIN;
 847 }
 848
 849 static long
 850 pi433_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 851 {
 852         int                     retval = 0;
 853         struct pi433_instance   *instance;
 854         struct pi433_device     *device;
 855         void __user *argp = (void __user *)arg;
 856
 857         /* Check type and command number */
 858         if (_IOC_TYPE(cmd) != PI433_IOC_MAGIC)
 859                 return -ENOTTY;
 860
 861         /* TODO? guard against device removal before, or while,
 862          * we issue this ioctl. --> device_get()
 863          */
 864         instance = filp->private_data;
 865         device = instance->device;
 866
 867         if (!device)
 868                 return -ESHUTDOWN;
 869
 870         switch (cmd) {
 871         case PI433_IOC_RD_TX_CFG:
 872                 if (copy_to_user(argp, &instance->tx_cfg,
 873                                  sizeof(struct pi433_tx_cfg)))
 874                         return -EFAULT;
 875                 break;
 876         case PI433_IOC_WR_TX_CFG:
 877                 if (copy_from_user(&instance->tx_cfg, argp,
 878                                    sizeof(struct pi433_tx_cfg)))
 879                         return -EFAULT;
 880                 break;
 881         case PI433_IOC_RD_RX_CFG:
 882                 if (copy_to_user(argp, &device->rx_cfg,
 883                                  sizeof(struct pi433_rx_cfg)))
 884                         return -EFAULT;
 885                 break;
 886         case PI433_IOC_WR_RX_CFG:
 887                 mutex_lock(&device->rx_lock);
 888
 889                 /* during pendig read request, change of config not allowed */
 890                 if (device->rx_active) {
 891                         mutex_unlock(&device->rx_lock);
 892                         return -EAGAIN;
 893                 }
 894
 895                 if (copy_from_user(&device->rx_cfg, argp,
 896                                    sizeof(struct pi433_rx_cfg))) {
 897                         mutex_unlock(&device->rx_lock);
 898                         return -EFAULT;
 899                 }
 900
 901                 mutex_unlock(&device->rx_lock);
 902                 break;
 903         default:
 904                 retval = -EINVAL;
 905         }
 906
 907         return retval;
 908 }
 909
 910 #ifdef CONFIG_COMPAT
 911 static long
 912 pi433_compat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 913 {
 914         return pi433_ioctl(filp, cmd, (unsigned long)compat_ptr(arg));
 915 }
 916 #else
 917 #define pi433_compat_ioctl NULL
 918 #endif /* CONFIG_COMPAT */
 919
 920 /*-------------------------------------------------------------------------*/
 921
 922 static int pi433_open(struct inode *inode, struct file *filp)
 923 {
 924         struct pi433_device     *device;
 925         struct pi433_instance   *instance;
 926
 927         mutex_lock(&minor_lock);
 928         device = idr_find(&pi433_idr, iminor(inode));
 929         mutex_unlock(&minor_lock);
 930         if (!device) {
 931                 pr_debug("device: minor %d unknown.\n", iminor(inode));
 932                 return -ENODEV;
 933         }
 934
 935         if (!device->rx_buffer) {
 936                 device->rx_buffer = kmalloc(MAX_MSG_SIZE, GFP_KERNEL);
 937                 if (!device->rx_buffer)
 938                         return -ENOMEM;
 939         }
 940
 941         device->users++;
 942         instance = kzalloc(sizeof(*instance), GFP_KERNEL);
 943         if (!instance) {
 944                 kfree(device->rx_buffer);
 945                 device->rx_buffer = NULL;
 946                 return -ENOMEM;
 947         }
 948
 949         /* setup instance data*/
 950         instance->device = device;
 951         instance->tx_cfg.bit_rate = 4711;
 952         // TODO: fill instance->tx_cfg;
 953
 954         /* instance data as context */
 955         filp->private_data = instance;
 956         nonseekable_open(inode, filp);
 957
 958         return 0;
 959 }
 960
 961 static int pi433_release(struct inode *inode, struct file *filp)
 962 {
 963         struct pi433_instance   *instance;
 964         struct pi433_device     *device;
 965
 966         instance = filp->private_data;
 967         device = instance->device;
 968         kfree(instance);
 969         filp->private_data = NULL;
 970
 971         /* last close? */
 972         device->users--;
 973
 974         if (!device->users) {
 975                 kfree(device->rx_buffer);
 976                 device->rx_buffer = NULL;
 977                 if (!device->spi)
 978                         kfree(device);
 979         }
 980
 981         return 0;
 982 }
 983
 984 /*-------------------------------------------------------------------------*/
 985
 986 static int setup_GPIOs(struct pi433_device *device)
 987 {
 988         char    name[5];
 989         int     retval;
 990         int     i;
 991         const irq_handler_t DIO_irq_handler[NUM_DIO] = {
 992                 DIO0_irq_handler,
 993                 DIO1_irq_handler
 994         };
 995
 996         for (i = 0; i < NUM_DIO; i++) {
 997                 /* "construct" name and get the gpio descriptor */
 998                 snprintf(name, sizeof(name), "DIO%d", i);
 999                 device->gpiod[i] = gpiod_get(&device->spi->dev, name, 0 /*GPIOD_IN*/);
1000
1001                 if (device->gpiod[i] == ERR_PTR(-ENOENT)) {
1002                         dev_dbg(&device->spi->dev, "Could not find entry for %s. Ignoring.", name);
1003                         continue;
1004                 }
1005
1006                 if (device->gpiod[i] == ERR_PTR(-EBUSY))
1007                         dev_dbg(&device->spi->dev, "%s is busy.", name);
1008
1009                 if (IS_ERR(device->gpiod[i])) {
1010                         retval = PTR_ERR(device->gpiod[i]);
1011                         /* release already allocated gpios */
1012                         for (i--; i >= 0; i--) {
1013                                 free_irq(device->irq_num[i], device);
1014                                 gpiod_put(device->gpiod[i]);
1015                         }
1016                         return retval;
1017                 }
1018
1019                 /* configure the pin */
1020                 gpiod_unexport(device->gpiod[i]);
1021                 retval = gpiod_direction_input(device->gpiod[i]);
1022                 if (retval)
1023                         return retval;
1024
1025                 /* configure irq */
1026                 device->irq_num[i] = gpiod_to_irq(device->gpiod[i]);
1027                 if (device->irq_num[i] < 0) {
1028                         device->gpiod[i] = ERR_PTR(-EINVAL);//(struct gpio_desc *)device->irq_num[i];
1029                         return device->irq_num[i];
1030                 }
1031                 retval = request_irq(device->irq_num[i],
1032                                      DIO_irq_handler[i],
1033                                      0, /* flags */
1034                                      name,
1035                                      device);
1036
1037                 if (retval)
1038                         return retval;
1039
1040                 dev_dbg(&device->spi->dev, "%s successfully configured", name);
1041         }
1042
1043         return 0;
1044 }
1045
1046 static void free_GPIOs(struct pi433_device *device)
1047 {
1048         int i;
1049
1050         for (i = 0; i < NUM_DIO; i++) {
1051                 /* check if gpiod is valid */
1052                 if (IS_ERR(device->gpiod[i]))
1053                         continue;
1054
1055                 free_irq(device->irq_num[i], device);
1056                 gpiod_put(device->gpiod[i]);
1057         }
1058 }
1059
1060 static int pi433_get_minor(struct pi433_device *device)
1061 {
1062         int retval = -ENOMEM;
1063
1064         mutex_lock(&minor_lock);
1065         retval = idr_alloc(&pi433_idr, device, 0, N_PI433_MINORS, GFP_KERNEL);
1066         if (retval >= 0) {
1067                 device->minor = retval;
1068                 retval = 0;
1069         } else if (retval == -ENOSPC) {
1070                 dev_err(&device->spi->dev, "too many pi433 devices\n");
1071                 retval = -EINVAL;
1072         }
1073         mutex_unlock(&minor_lock);
1074         return retval;
1075 }
1076
1077 static void pi433_free_minor(struct pi433_device *dev)
1078 {
1079         mutex_lock(&minor_lock);
1080         idr_remove(&pi433_idr, dev->minor);
1081         mutex_unlock(&minor_lock);
1082 }
1083
1084 /*-------------------------------------------------------------------------*/
1085
1086 static const struct file_operations pi433_fops = {
1087         .owner =        THIS_MODULE,
1088         /* REVISIT switch to aio primitives, so that userspace
1089          * gets more complete API coverage.  It'll simplify things
1090          * too, except for the locking.
1091          */
1092         .write =        pi433_write,
1093         .read =         pi433_read,
1094         .unlocked_ioctl = pi433_ioctl,
1095         .compat_ioctl = pi433_compat_ioctl,
1096         .open =         pi433_open,
1097         .release =      pi433_release,
1098         .llseek =       no_llseek,
1099 };
1100
1101 /*-------------------------------------------------------------------------*/
1102
1103 static int pi433_probe(struct spi_device *spi)
1104 {
1105         struct pi433_device     *device;
1106         int                     retval;
1107
1108         /* setup spi parameters */
1109         spi->mode = 0x00;
1110         spi->bits_per_word = 8;
1111         /* spi->max_speed_hz = 10000000;  1MHz already set by device tree overlay */
1112
1113         retval = spi_setup(spi);
1114         if (retval) {
1115                 dev_dbg(&spi->dev, "configuration of SPI interface failed!\n");
1116                 return retval;
1117         }
1118
1119         dev_dbg(&spi->dev,
1120                 "spi interface setup: mode 0x%2x, %d bits per word, %dhz max speed",
1121                 spi->mode, spi->bits_per_word, spi->max_speed_hz);
1122
1123         /* Ping the chip by reading the version register */
1124         retval = spi_w8r8(spi, 0x10);
1125         if (retval < 0)
1126                 return retval;
1127
1128         switch (retval) {
1129         case 0x24:
1130                 dev_dbg(&spi->dev, "found pi433 (ver. 0x%x)", retval);
1131                 break;
1132         default:
1133                 dev_dbg(&spi->dev, "unknown chip version: 0x%x", retval);
1134                 return -ENODEV;
1135         }
1136
1137         /* Allocate driver data */
1138         device = kzalloc(sizeof(*device), GFP_KERNEL);
1139         if (!device)
1140                 return -ENOMEM;
1141
1142         /* Initialize the driver data */
1143         device->spi = spi;
1144         device->rx_active = false;
1145         device->tx_active = false;
1146         device->interrupt_rx_allowed = false;
1147
1148         /* init wait queues */
1149         init_waitqueue_head(&device->tx_wait_queue);
1150         init_waitqueue_head(&device->rx_wait_queue);
1151         init_waitqueue_head(&device->fifo_wait_queue);
1152
1153         /* init fifo */
1154         INIT_KFIFO(device->tx_fifo);
1155
1156         /* init mutexes and locks */
1157         mutex_init(&device->tx_fifo_lock);
1158         mutex_init(&device->rx_lock);
1159
1160         /* setup GPIO (including irq_handler) for the different DIOs */
1161         retval = setup_GPIOs(device);
1162         if (retval) {
1163                 dev_dbg(&spi->dev, "setup of GPIOs failed");
1164                 goto GPIO_failed;
1165         }
1166
1167         /* setup the radio module */
1168         retval = rf69_set_mode(spi, standby);
1169         if (retval < 0)
1170                 goto minor_failed;
1171         retval = rf69_set_data_mode(spi, DATAMODUL_MODE_PACKET);
1172         if (retval < 0)
1173                 goto minor_failed;
1174         retval = rf69_enable_amplifier(spi, MASK_PALEVEL_PA0);
1175         if (retval < 0)
1176                 goto minor_failed;
1177         retval = rf69_disable_amplifier(spi, MASK_PALEVEL_PA1);
1178         if (retval < 0)
1179                 goto minor_failed;
1180         retval = rf69_disable_amplifier(spi, MASK_PALEVEL_PA2);
1181         if (retval < 0)
1182                 goto minor_failed;
1183         retval = rf69_set_output_power_level(spi, 13);
1184         if (retval < 0)
1185                 goto minor_failed;
1186         retval = rf69_set_antenna_impedance(spi, fiftyOhm);
1187         if (retval < 0)
1188                 goto minor_failed;
1189
1190         /* determ minor number */
1191         retval = pi433_get_minor(device);
1192         if (retval) {
1193                 dev_dbg(&spi->dev, "get of minor number failed");
1194                 goto minor_failed;
1195         }
1196
1197         /* create device */
1198         device->devt = MKDEV(MAJOR(pi433_dev), device->minor);
1199         device->dev = device_create(pi433_class,
1200                                     &spi->dev,
1201                                     device->devt,
1202                                     device,
1203                                     "pi433.%d",
1204                                     device->minor);
1205         if (IS_ERR(device->dev)) {
1206                 pr_err("pi433: device register failed\n");
1207                 retval = PTR_ERR(device->dev);
1208                 goto device_create_failed;
1209         } else {
1210                 dev_dbg(device->dev,
1211                         "created device for major %d, minor %d\n",
1212                         MAJOR(pi433_dev),
1213                         device->minor);
1214         }
1215
1216         /* start tx thread */
1217         device->tx_task_struct = kthread_run(pi433_tx_thread,
1218                                              device,
1219                                              "pi433.%d_tx_task",
1220                                              device->minor);
1221         if (IS_ERR(device->tx_task_struct)) {
1222                 dev_dbg(device->dev, "start of send thread failed");
1223                 goto send_thread_failed;
1224         }
1225
1226         /* create cdev */
1227         device->cdev = cdev_alloc();
1228         device->cdev->owner = THIS_MODULE;
1229         cdev_init(device->cdev, &pi433_fops);
1230         retval = cdev_add(device->cdev, device->devt, 1);
1231         if (retval) {
1232                 dev_dbg(device->dev, "register of cdev failed");
1233                 goto cdev_failed;
1234         }
1235
1236         /* spi setup */
1237         spi_set_drvdata(spi, device);
1238
1239         return 0;
1240
1241 cdev_failed:
1242         kthread_stop(device->tx_task_struct);
1243 send_thread_failed:
1244         device_destroy(pi433_class, device->devt);
1245 device_create_failed:
1246         pi433_free_minor(device);
1247 minor_failed:
1248         free_GPIOs(device);
1249 GPIO_failed:
1250         kfree(device);
1251
1252         return retval;
1253 }
1254
1255 static int pi433_remove(struct spi_device *spi)
1256 {
1257         struct pi433_device     *device = spi_get_drvdata(spi);
1258
1259         /* free GPIOs */
1260         free_GPIOs(device);
1261
1262         /* make sure ops on existing fds can abort cleanly */
1263         device->spi = NULL;
1264
1265         kthread_stop(device->tx_task_struct);
1266
1267         device_destroy(pi433_class, device->devt);
1268
1269         cdev_del(device->cdev);
1270
1271         pi433_free_minor(device);
1272
1273         if (device->users == 0)
1274                 kfree(device);
1275
1276         return 0;
1277 }
1278
1279 static const struct of_device_id pi433_dt_ids[] = {
1280         { .compatible = "Smarthome-Wolf,pi433" },
1281         {},
1282 };
1283
1284 MODULE_DEVICE_TABLE(of, pi433_dt_ids);
1285
1286 static struct spi_driver pi433_spi_driver = {
1287         .driver = {
1288                 .name =         "pi433",
1289                 .owner =        THIS_MODULE,
1290                 .of_match_table = of_match_ptr(pi433_dt_ids),
1291         },
1292         .probe =        pi433_probe,
1293         .remove =       pi433_remove,
1294
1295         /* NOTE:  suspend/resume methods are not necessary here.
1296          * We don't do anything except pass the requests to/from
1297          * the underlying controller.  The refrigerator handles
1298          * most issues; the controller driver handles the rest.
1299          */
1300 };
1301
1302 /*-------------------------------------------------------------------------*/
1303
1304 static int __init pi433_init(void)
1305 {
1306         int status;
1307
1308         /* If MAX_MSG_SIZE is smaller then FIFO_SIZE, the driver won't
1309          * work stable - risk of buffer overflow
1310          */
1311         if (MAX_MSG_SIZE < FIFO_SIZE)
1312                 return -EINVAL;
1313
1314         /* Claim device numbers.  Then register a class
1315          * that will key udev/mdev to add/remove /dev nodes.  Last, register
1316          * Last, register the driver which manages those device numbers.
1317          */
1318         status = alloc_chrdev_region(&pi433_dev, 0 /*firstminor*/, N_PI433_MINORS /*count*/, "pi433" /*name*/);
1319         if (status < 0)
1320                 return status;
1321
1322         pi433_class = class_create(THIS_MODULE, "pi433");
1323         if (IS_ERR(pi433_class)) {
1324                 unregister_chrdev(MAJOR(pi433_dev),
1325                                   pi433_spi_driver.driver.name);
1326                 return PTR_ERR(pi433_class);
1327         }
1328
1329         status = spi_register_driver(&pi433_spi_driver);
1330         if (status < 0) {
1331                 class_destroy(pi433_class);
1332                 unregister_chrdev(MAJOR(pi433_dev),
1333                                   pi433_spi_driver.driver.name);
1334         }
1335
1336         return status;
1337 }
1338
1339 module_init(pi433_init);
1340
1341 static void __exit pi433_exit(void)
1342 {
1343         spi_unregister_driver(&pi433_spi_driver);
1344         class_destroy(pi433_class);
1345         unregister_chrdev(MAJOR(pi433_dev), pi433_spi_driver.driver.name);
1346 }
1347 module_exit(pi433_exit);
1348
1349 MODULE_AUTHOR("Marcus Wolf, <linux@wolf-entwicklungen.de>");
1350 MODULE_DESCRIPTION("Driver for Pi433");
1351 MODULE_LICENSE("GPL");
1352 MODULE_ALIAS("spi:pi433");