drivers/staging/pi433/pi433_if.c

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