drivers/staging/pi433/rf69.c

   1 /*
   2  * abstraction of the spi interface of HopeRf rf69 radio module
   3  *
   4  * Copyright (C) 2016 Wolf-Entwicklungen
   5  *      Marcus Wolf <[email protected]>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  */
  17
  18 /* enable prosa debug info */
  19 #undef DEBUG
  20 /* enable print of values on reg access */
  21 #undef DEBUG_VALUES
  22 /* enable print of values on fifo access */
  23 #undef DEBUG_FIFO_ACCESS
  24
  25 #include <linux/types.h>
  26 #include <linux/spi/spi.h>
  27
  28 #include "rf69.h"
  29 #include "rf69_registers.h"
  30
  31 #define F_OSC     32000000 /* in Hz */
  32 #define FIFO_SIZE 66       /* in byte */
  33
  34 /*-------------------------------------------------------------------------*/
  35
  36 static u8 rf69_read_reg(struct spi_device *spi, u8 addr)
  37 {
  38         int retval;
  39
  40         retval = spi_w8r8(spi, addr);
  41
  42 #ifdef DEBUG_VALUES
  43         if (retval < 0)
  44                 /* should never happen, since we already checked,
  45                  * that module is connected. Therefore no error
  46                  * handling, just an optional error message...
  47                  */
  48                 dev_dbg(&spi->dev, "read 0x%x FAILED\n", addr);
  49         else
  50                 dev_dbg(&spi->dev, "read 0x%x from reg 0x%x\n", retval, addr);
  51 #endif
  52
  53         return retval;
  54 }
  55
  56 static int rf69_write_reg(struct spi_device *spi, u8 addr, u8 value)
  57 {
  58         int retval;
  59         char buffer[2];
  60
  61         buffer[0] = addr | WRITE_BIT;
  62         buffer[1] = value;
  63
  64         retval = spi_write(spi, &buffer, 2);
  65
  66 #ifdef DEBUG_VALUES
  67         if (retval < 0)
  68                 /* should never happen, since we already checked,
  69                  * that module is connected. Therefore no error
  70                  * handling, just an optional error message...
  71                  */
  72                 dev_dbg(&spi->dev, "write 0x%x to 0x%x FAILED\n", value, addr);
  73         else
  74                 dev_dbg(&spi->dev, "wrote 0x%x to reg 0x%x\n", value, addr);
  75 #endif
  76
  77         return retval;
  78 }
  79
  80 /*-------------------------------------------------------------------------*/
  81
  82 static int rf69_set_bit(struct spi_device *spi, u8 reg, u8 mask)
  83 {
  84         u8 tmp;
  85
  86         tmp = rf69_read_reg(spi, reg);
  87         tmp = tmp | mask;
  88         return rf69_write_reg(spi, reg, tmp);
  89 }
  90
  91 static int rf69_clear_bit(struct spi_device *spi, u8 reg, u8 mask)
  92 {
  93         u8 tmp;
  94
  95         tmp = rf69_read_reg(spi, reg);
  96         tmp = tmp & ~mask;
  97         return rf69_write_reg(spi, reg, tmp);
  98 }
  99
 100 static inline int rf69_read_mod_write(struct spi_device *spi, u8 reg,
 101                                       u8 mask, u8 value)
 102 {
 103         u8 tmp;
 104
 105         tmp = rf69_read_reg(spi, reg);
 106         tmp = (tmp & ~mask) | value;
 107         return rf69_write_reg(spi, reg, tmp);
 108 }
 109
 110 /*-------------------------------------------------------------------------*/
 111
 112 int rf69_set_mode(struct spi_device *spi, enum mode mode)
 113 {
 114         switch (mode) {
 115         case transmit:
 116                 return rf69_read_mod_write(spi, REG_OPMODE, MASK_OPMODE_MODE,
 117                                            OPMODE_MODE_TRANSMIT);
 118         case receive:
 119                 return rf69_read_mod_write(spi, REG_OPMODE, MASK_OPMODE_MODE,
 120                                            OPMODE_MODE_RECEIVE);
 121         case synthesizer:
 122                 return rf69_read_mod_write(spi, REG_OPMODE, MASK_OPMODE_MODE,
 123                                            OPMODE_MODE_SYNTHESIZER);
 124         case standby:
 125                 return rf69_read_mod_write(spi, REG_OPMODE, MASK_OPMODE_MODE,
 126                                            OPMODE_MODE_STANDBY);
 127         case mode_sleep:
 128                 return rf69_read_mod_write(spi, REG_OPMODE, MASK_OPMODE_MODE,
 129                                            OPMODE_MODE_SLEEP);
 130         default:
 131                 dev_dbg(&spi->dev, "set: illegal input param");
 132                 return -EINVAL;
 133         }
 134
 135         // we are using packet mode, so this check is not really needed
 136         // but waiting for mode ready is necessary when going from sleep because the FIFO may not be immediately available from previous mode
 137         //while (_mode == RF69_MODE_SLEEP && (READ_REG(REG_IRQFLAGS1) & RF_IRQFLAGS1_MODEREADY) == 0x00); // Wait for ModeReady
 138 }
 139
 140 int rf69_set_data_mode(struct spi_device *spi, u8 data_mode)
 141 {
 142         return rf69_read_mod_write(spi, REG_DATAMODUL, MASK_DATAMODUL_MODE,
 143                                    data_mode);
 144 }
 145
 146 int rf69_set_modulation(struct spi_device *spi, enum modulation modulation)
 147 {
 148         switch (modulation) {
 149         case OOK:
 150                 return rf69_read_mod_write(spi, REG_DATAMODUL,
 151                                            MASK_DATAMODUL_MODULATION_TYPE,
 152                                            DATAMODUL_MODULATION_TYPE_OOK);
 153         case FSK:
 154                 return rf69_read_mod_write(spi, REG_DATAMODUL,
 155                                            MASK_DATAMODUL_MODULATION_TYPE,
 156                                            DATAMODUL_MODULATION_TYPE_FSK);
 157         default:
 158                 dev_dbg(&spi->dev, "set: illegal input param");
 159                 return -EINVAL;
 160         }
 161 }
 162
 163 static enum modulation rf69_get_modulation(struct spi_device *spi)
 164 {
 165         u8 modulation_reg;
 166
 167         modulation_reg = rf69_read_reg(spi, REG_DATAMODUL);
 168
 169         switch (modulation_reg & MASK_DATAMODUL_MODULATION_TYPE) {
 170         case DATAMODUL_MODULATION_TYPE_OOK:
 171                 return OOK;
 172         case DATAMODUL_MODULATION_TYPE_FSK:
 173                 return FSK;
 174         default:
 175                 return UNDEF;
 176         }
 177 }
 178
 179 int rf69_set_modulation_shaping(struct spi_device *spi,
 180                                 enum mod_shaping mod_shaping)
 181 {
 182         switch (rf69_get_modulation(spi)) {
 183         case FSK:
 184                 switch (mod_shaping) {
 185                 case SHAPING_OFF:
 186                         return rf69_read_mod_write(spi, REG_DATAMODUL,
 187                                                    MASK_DATAMODUL_MODULATION_SHAPE,
 188                                                    DATAMODUL_MODULATION_SHAPE_NONE);
 189                 case SHAPING_1_0:
 190                         return rf69_read_mod_write(spi, REG_DATAMODUL,
 191                                                    MASK_DATAMODUL_MODULATION_SHAPE,
 192                                                    DATAMODUL_MODULATION_SHAPE_1_0);
 193                 case SHAPING_0_5:
 194                         return rf69_read_mod_write(spi, REG_DATAMODUL,
 195                                                    MASK_DATAMODUL_MODULATION_SHAPE,
 196                                                    DATAMODUL_MODULATION_SHAPE_0_5);
 197                 case SHAPING_0_3:
 198                         return rf69_read_mod_write(spi, REG_DATAMODUL,
 199                                                    MASK_DATAMODUL_MODULATION_SHAPE,
 200                                                    DATAMODUL_MODULATION_SHAPE_0_3);
 201                 default:
 202                         dev_dbg(&spi->dev, "set: illegal input param");
 203                         return -EINVAL;
 204                 }
 205         case OOK:
 206                 switch (mod_shaping) {
 207                 case SHAPING_OFF:
 208                         return rf69_read_mod_write(spi, REG_DATAMODUL,
 209                                                    MASK_DATAMODUL_MODULATION_SHAPE,
 210                                                    DATAMODUL_MODULATION_SHAPE_NONE);
 211                 case SHAPING_BR:
 212                         return rf69_read_mod_write(spi, REG_DATAMODUL,
 213                                                    MASK_DATAMODUL_MODULATION_SHAPE,
 214                                                    DATAMODUL_MODULATION_SHAPE_BR);
 215                 case SHAPING_2BR:
 216                         return rf69_read_mod_write(spi, REG_DATAMODUL,
 217                                                    MASK_DATAMODUL_MODULATION_SHAPE,
 218                                                    DATAMODUL_MODULATION_SHAPE_2BR);
 219                 default:
 220                         dev_dbg(&spi->dev, "set: illegal input param");
 221                         return -EINVAL;
 222                 }
 223         default:
 224                 dev_dbg(&spi->dev, "set: modulation undefined");
 225                 return -EINVAL;
 226         }
 227 }
 228
 229 int rf69_set_bit_rate(struct spi_device *spi, u16 bit_rate)
 230 {
 231         int retval;
 232         u32 bit_rate_min;
 233         u32 bit_rate_reg;
 234         u8 msb;
 235         u8 lsb;
 236
 237         // check input value
 238         bit_rate_min = F_OSC / 8388608; // 8388608 = 2^23;
 239         if (bit_rate < bit_rate_min) {
 240                 dev_dbg(&spi->dev, "setBitRate: illegal input param");
 241                 return -EINVAL;
 242         }
 243
 244         // calculate reg settings
 245         bit_rate_reg = (F_OSC / bit_rate);
 246
 247         msb = (bit_rate_reg & 0xff00) >> 8;
 248         lsb = (bit_rate_reg & 0xff);
 249
 250         // transmit to RF 69
 251         retval = rf69_write_reg(spi, REG_BITRATE_MSB, msb);
 252         if (retval)
 253                 return retval;
 254         retval = rf69_write_reg(spi, REG_BITRATE_LSB, lsb);
 255         if (retval)
 256                 return retval;
 257
 258         return 0;
 259 }
 260
 261 int rf69_set_deviation(struct spi_device *spi, u32 deviation)
 262 {
 263         int retval;
 264         u64 f_reg;
 265         u64 f_step;
 266         u8 msb;
 267         u8 lsb;
 268         u64 factor = 1000000; // to improve precision of calculation
 269
 270         // TODO: Dependency to bitrate
 271         if (deviation < 600 || deviation > 500000) {
 272                 dev_dbg(&spi->dev, "set_deviation: illegal input param");
 273                 return -EINVAL;
 274         }
 275
 276         // calculat f step
 277         f_step = F_OSC * factor;
 278         do_div(f_step, 524288); //  524288 = 2^19
 279
 280         // calculate register settings
 281         f_reg = deviation * factor;
 282         do_div(f_reg, f_step);
 283
 284         msb = (f_reg & 0xff00) >> 8;
 285         lsb = (f_reg & 0xff);
 286
 287         // check msb
 288         if (msb & ~FDEVMASB_MASK) {
 289                 dev_dbg(&spi->dev, "set_deviation: err in calc of msb");
 290                 return -EINVAL;
 291         }
 292
 293         // write to chip
 294         retval = rf69_write_reg(spi, REG_FDEV_MSB, msb);
 295         if (retval)
 296                 return retval;
 297         retval = rf69_write_reg(spi, REG_FDEV_LSB, lsb);
 298         if (retval)
 299                 return retval;
 300
 301         return 0;
 302 }
 303
 304 int rf69_set_frequency(struct spi_device *spi, u32 frequency)
 305 {
 306         int retval;
 307         u32 f_max;
 308         u64 f_reg;
 309         u64 f_step;
 310         u8 msb;
 311         u8 mid;
 312         u8 lsb;
 313         u64 factor = 1000000; // to improve precision of calculation
 314
 315         // calculat f step
 316         f_step = F_OSC * factor;
 317         do_div(f_step, 524288); //  524288 = 2^19
 318
 319         // check input value
 320         f_max = div_u64(f_step * 8388608, factor);
 321         if (frequency > f_max) {
 322                 dev_dbg(&spi->dev, "setFrequency: illegal input param");
 323                 return -EINVAL;
 324         }
 325
 326         // calculate reg settings
 327         f_reg = frequency * factor;
 328         do_div(f_reg, f_step);
 329
 330         msb = (f_reg & 0xff0000) >> 16;
 331         mid = (f_reg & 0xff00)   >>  8;
 332         lsb = (f_reg & 0xff);
 333
 334         // write to chip
 335         retval = rf69_write_reg(spi, REG_FRF_MSB, msb);
 336         if (retval)
 337                 return retval;
 338         retval = rf69_write_reg(spi, REG_FRF_MID, mid);
 339         if (retval)
 340                 return retval;
 341         retval = rf69_write_reg(spi, REG_FRF_LSB, lsb);
 342         if (retval)
 343                 return retval;
 344
 345         return 0;
 346 }
 347
 348 int rf69_enable_amplifier(struct spi_device *spi, u8 amplifier_mask)
 349 {
 350         return rf69_set_bit(spi, REG_PALEVEL, amplifier_mask);
 351 }
 352
 353 int rf69_disable_amplifier(struct spi_device *spi, u8 amplifier_mask)
 354 {
 355         return rf69_clear_bit(spi, REG_PALEVEL, amplifier_mask);
 356 }
 357
 358 int rf69_set_output_power_level(struct spi_device *spi, u8 power_level)
 359 {
 360         // TODO: Dependency to PA0,1,2 setting
 361         power_level += 18;
 362
 363         // check input value
 364         if (power_level > 0x1f) {
 365                 dev_dbg(&spi->dev, "set: illegal input param");
 366                 return -EINVAL;
 367         }
 368
 369         // write value
 370         return rf69_read_mod_write(spi, REG_PALEVEL, MASK_PALEVEL_OUTPUT_POWER,
 371                                    power_level);
 372 }
 373
 374 int rf69_set_pa_ramp(struct spi_device *spi, enum pa_ramp pa_ramp)
 375 {
 376         switch (pa_ramp) {
 377         case ramp3400:
 378                 return rf69_write_reg(spi, REG_PARAMP, PARAMP_3400);
 379         case ramp2000:
 380                 return rf69_write_reg(spi, REG_PARAMP, PARAMP_2000);
 381         case ramp1000:
 382                 return rf69_write_reg(spi, REG_PARAMP, PARAMP_1000);
 383         case ramp500:
 384                 return rf69_write_reg(spi, REG_PARAMP, PARAMP_500);
 385         case ramp250:
 386                 return rf69_write_reg(spi, REG_PARAMP, PARAMP_250);
 387         case ramp125:
 388                 return rf69_write_reg(spi, REG_PARAMP, PARAMP_125);
 389         case ramp100:
 390                 return rf69_write_reg(spi, REG_PARAMP, PARAMP_100);
 391         case ramp62:
 392                 return rf69_write_reg(spi, REG_PARAMP, PARAMP_62);
 393         case ramp50:
 394                 return rf69_write_reg(spi, REG_PARAMP, PARAMP_50);
 395         case ramp40:
 396                 return rf69_write_reg(spi, REG_PARAMP, PARAMP_40);
 397         case ramp31:
 398                 return rf69_write_reg(spi, REG_PARAMP, PARAMP_31);
 399         case ramp25:
 400                 return rf69_write_reg(spi, REG_PARAMP, PARAMP_25);
 401         case ramp20:
 402                 return rf69_write_reg(spi, REG_PARAMP, PARAMP_20);
 403         case ramp15:
 404                 return rf69_write_reg(spi, REG_PARAMP, PARAMP_15);
 405         case ramp12:
 406                 return rf69_write_reg(spi, REG_PARAMP, PARAMP_12);
 407         case ramp10:
 408                 return rf69_write_reg(spi, REG_PARAMP, PARAMP_10);
 409         default:
 410                 dev_dbg(&spi->dev, "set: illegal input param");
 411                 return -EINVAL;
 412         }
 413 }
 414
 415 int rf69_set_antenna_impedance(struct spi_device *spi,
 416                                enum antenna_impedance antenna_impedance)
 417 {
 418         switch (antenna_impedance) {
 419         case fifty_ohm:
 420                 return rf69_clear_bit(spi, REG_LNA, MASK_LNA_ZIN);
 421         case two_hundred_ohm:
 422                 return rf69_set_bit(spi, REG_LNA, MASK_LNA_ZIN);
 423         default:
 424                 dev_dbg(&spi->dev, "set: illegal input param");
 425                 return -EINVAL;
 426         }
 427 }
 428
 429 int rf69_set_lna_gain(struct spi_device *spi, enum lna_gain lna_gain)
 430 {
 431         switch (lna_gain) {
 432         case automatic:
 433                 return rf69_read_mod_write(spi, REG_LNA, MASK_LNA_GAIN,
 434                                            LNA_GAIN_AUTO);
 435         case max:
 436                 return rf69_read_mod_write(spi, REG_LNA, MASK_LNA_GAIN,
 437                                            LNA_GAIN_MAX);
 438         case max_minus_6:
 439                 return rf69_read_mod_write(spi, REG_LNA, MASK_LNA_GAIN,
 440                                            LNA_GAIN_MAX_MINUS_6);
 441         case max_minus_12:
 442                 return rf69_read_mod_write(spi, REG_LNA, MASK_LNA_GAIN,
 443                                            LNA_GAIN_MAX_MINUS_12);
 444         case max_minus_24:
 445                 return rf69_read_mod_write(spi, REG_LNA, MASK_LNA_GAIN,
 446                                            LNA_GAIN_MAX_MINUS_24);
 447         case max_minus_36:
 448                 return rf69_read_mod_write(spi, REG_LNA, MASK_LNA_GAIN,
 449                                            LNA_GAIN_MAX_MINUS_36);
 450         case max_minus_48:
 451                 return rf69_read_mod_write(spi, REG_LNA, MASK_LNA_GAIN,
 452                                            LNA_GAIN_MAX_MINUS_48);
 453         default:
 454                 dev_dbg(&spi->dev, "set: illegal input param");
 455                 return -EINVAL;
 456         }
 457 }
 458
 459 static int rf69_set_bandwidth_intern(struct spi_device *spi, u8 reg,
 460                                      enum mantisse mantisse, u8 exponent)
 461 {
 462         u8 bandwidth;
 463
 464         // check value for mantisse and exponent
 465         if (exponent > 7) {
 466                 dev_dbg(&spi->dev, "set: illegal input param");
 467                 return -EINVAL;
 468         }
 469
 470         if ((mantisse != mantisse16) &&
 471             (mantisse != mantisse20) &&
 472             (mantisse != mantisse24)) {
 473                 dev_dbg(&spi->dev, "set: illegal input param");
 474                 return -EINVAL;
 475         }
 476
 477         // read old value
 478         bandwidth = rf69_read_reg(spi, reg);
 479
 480         // "delete" mantisse and exponent = just keep the DCC setting
 481         bandwidth = bandwidth & MASK_BW_DCC_FREQ;
 482
 483         // add new mantisse
 484         switch (mantisse) {
 485         case mantisse16:
 486                 bandwidth = bandwidth | BW_MANT_16;
 487                 break;
 488         case mantisse20:
 489                 bandwidth = bandwidth | BW_MANT_20;
 490                 break;
 491         case mantisse24:
 492                 bandwidth = bandwidth | BW_MANT_24;
 493                 break;
 494         }
 495
 496         // add new exponent
 497         bandwidth = bandwidth | exponent;
 498
 499         // write back
 500         return rf69_write_reg(spi, reg, bandwidth);
 501 }
 502
 503 int rf69_set_bandwidth(struct spi_device *spi, enum mantisse mantisse,
 504                        u8 exponent)
 505 {
 506         return rf69_set_bandwidth_intern(spi, REG_RXBW, mantisse, exponent);
 507 }
 508
 509 int rf69_set_bandwidth_during_afc(struct spi_device *spi,
 510                                   enum mantisse mantisse,
 511                                   u8 exponent)
 512 {
 513         return rf69_set_bandwidth_intern(spi, REG_AFCBW, mantisse, exponent);
 514 }
 515
 516 int rf69_set_ook_threshold_dec(struct spi_device *spi,
 517                                enum threshold_decrement threshold_decrement)
 518 {
 519         switch (threshold_decrement) {
 520         case dec_every8th:
 521                 return rf69_read_mod_write(spi, REG_OOKPEAK,
 522                                            MASK_OOKPEAK_THRESDEC,
 523                                            OOKPEAK_THRESHDEC_EVERY_8TH);
 524         case dec_every4th:
 525                 return rf69_read_mod_write(spi, REG_OOKPEAK,
 526                                            MASK_OOKPEAK_THRESDEC,
 527                                            OOKPEAK_THRESHDEC_EVERY_4TH);
 528         case dec_every2nd:
 529                 return rf69_read_mod_write(spi, REG_OOKPEAK,
 530                                            MASK_OOKPEAK_THRESDEC,
 531                                            OOKPEAK_THRESHDEC_EVERY_2ND);
 532         case dec_once:
 533                 return rf69_read_mod_write(spi, REG_OOKPEAK,
 534                                            MASK_OOKPEAK_THRESDEC,
 535                                            OOKPEAK_THRESHDEC_ONCE);
 536         case dec_twice:
 537                 return rf69_read_mod_write(spi, REG_OOKPEAK,
 538                                            MASK_OOKPEAK_THRESDEC,
 539                                            OOKPEAK_THRESHDEC_TWICE);
 540         case dec_4times:
 541                 return rf69_read_mod_write(spi, REG_OOKPEAK,
 542                                            MASK_OOKPEAK_THRESDEC,
 543                                            OOKPEAK_THRESHDEC_4_TIMES);
 544         case dec_8times:
 545                 return rf69_read_mod_write(spi, REG_OOKPEAK,
 546                                            MASK_OOKPEAK_THRESDEC,
 547                                            OOKPEAK_THRESHDEC_8_TIMES);
 548         case dec_16times:
 549                 return rf69_read_mod_write(spi, REG_OOKPEAK,
 550                                            MASK_OOKPEAK_THRESDEC,
 551                                            OOKPEAK_THRESHDEC_16_TIMES);
 552         default:
 553                 dev_dbg(&spi->dev, "set: illegal input param");
 554                 return -EINVAL;
 555         }
 556 }
 557
 558 int rf69_set_dio_mapping(struct spi_device *spi, u8 dio_number, u8 value)
 559 {
 560         u8 mask;
 561         u8 shift;
 562         u8 dio_addr;
 563         u8 dio_value;
 564
 565         switch (dio_number) {
 566         case 0:
 567                 mask = MASK_DIO0; shift = SHIFT_DIO0; dio_addr = REG_DIOMAPPING1;
 568                 break;
 569         case 1:
 570                 mask = MASK_DIO1; shift = SHIFT_DIO1; dio_addr = REG_DIOMAPPING1;
 571                 break;
 572         case 2:
 573                 mask = MASK_DIO2; shift = SHIFT_DIO2; dio_addr = REG_DIOMAPPING1;
 574                 break;
 575         case 3:
 576                 mask = MASK_DIO3; shift = SHIFT_DIO3; dio_addr = REG_DIOMAPPING1;
 577                 break;
 578         case 4:
 579                 mask = MASK_DIO4; shift = SHIFT_DIO4; dio_addr = REG_DIOMAPPING2;
 580                 break;
 581         case 5:
 582                 mask = MASK_DIO5; shift = SHIFT_DIO5; dio_addr = REG_DIOMAPPING2;
 583                 break;
 584         default:
 585         dev_dbg(&spi->dev, "set: illegal input param");
 586                 return -EINVAL;
 587         }
 588
 589         // read reg
 590         dio_value = rf69_read_reg(spi, dio_addr);
 591         // delete old value
 592         dio_value = dio_value & ~mask;
 593         // add new value
 594         dio_value = dio_value | value << shift;
 595         // write back
 596         return rf69_write_reg(spi, dio_addr, dio_value);
 597 }
 598
 599 bool rf69_get_flag(struct spi_device *spi, enum flag flag)
 600 {
 601         switch (flag) {
 602         case mode_switch_completed:
 603                 return (rf69_read_reg(spi, REG_IRQFLAGS1) & MASK_IRQFLAGS1_MODE_READY);
 604         case ready_to_receive:
 605                 return (rf69_read_reg(spi, REG_IRQFLAGS1) & MASK_IRQFLAGS1_RX_READY);
 606         case ready_to_send:
 607                 return (rf69_read_reg(spi, REG_IRQFLAGS1) & MASK_IRQFLAGS1_TX_READY);
 608         case pll_locked:
 609                 return (rf69_read_reg(spi, REG_IRQFLAGS1) & MASK_IRQFLAGS1_PLL_LOCK);
 610         case rssi_exceeded_threshold:
 611                 return (rf69_read_reg(spi, REG_IRQFLAGS1) & MASK_IRQFLAGS1_RSSI);
 612         case timeout:
 613                 return (rf69_read_reg(spi, REG_IRQFLAGS1) & MASK_IRQFLAGS1_TIMEOUT);
 614         case automode:
 615                 return (rf69_read_reg(spi, REG_IRQFLAGS1) & MASK_IRQFLAGS1_AUTOMODE);
 616         case sync_address_match:
 617                 return (rf69_read_reg(spi, REG_IRQFLAGS1) & MASK_IRQFLAGS1_SYNC_ADDRESS_MATCH);
 618         case fifo_full:
 619                 return (rf69_read_reg(spi, REG_IRQFLAGS2) & MASK_IRQFLAGS2_FIFO_FULL);
 620 /*      case fifo_not_empty:
 621  *              return (rf69_read_reg(spi, REG_IRQFLAGS2) & MASK_IRQFLAGS2_FIFO_NOT_EMPTY); */
 622         case fifo_empty:
 623                 return !(rf69_read_reg(spi, REG_IRQFLAGS2) & MASK_IRQFLAGS2_FIFO_NOT_EMPTY);
 624         case fifo_level_below_threshold:
 625                 return (rf69_read_reg(spi, REG_IRQFLAGS2) & MASK_IRQFLAGS2_FIFO_LEVEL);
 626         case fifo_overrun:
 627                 return (rf69_read_reg(spi, REG_IRQFLAGS2) & MASK_IRQFLAGS2_FIFO_OVERRUN);
 628         case packet_sent:
 629                 return (rf69_read_reg(spi, REG_IRQFLAGS2) & MASK_IRQFLAGS2_PACKET_SENT);
 630         case payload_ready:
 631                 return (rf69_read_reg(spi, REG_IRQFLAGS2) & MASK_IRQFLAGS2_PAYLOAD_READY);
 632         case crc_ok:
 633                 return (rf69_read_reg(spi, REG_IRQFLAGS2) & MASK_IRQFLAGS2_CRC_OK);
 634         case battery_low:
 635                 return (rf69_read_reg(spi, REG_IRQFLAGS2) & MASK_IRQFLAGS2_LOW_BAT);
 636         default:                         return false;
 637         }
 638 }
 639
 640 int rf69_set_rssi_threshold(struct spi_device *spi, u8 threshold)
 641 {
 642         /* no value check needed - u8 exactly matches register size */
 643
 644         return rf69_write_reg(spi, REG_RSSITHRESH, threshold);
 645 }
 646
 647 int rf69_set_preamble_length(struct spi_device *spi, u16 preamble_length)
 648 {
 649         int retval;
 650         u8 msb, lsb;
 651
 652         /* no value check needed - u16 exactly matches register size */
 653
 654         /* calculate reg settings */
 655         msb = (preamble_length & 0xff00) >> 8;
 656         lsb = (preamble_length & 0xff);
 657
 658         /* transmit to chip */
 659         retval = rf69_write_reg(spi, REG_PREAMBLE_MSB, msb);
 660         if (retval)
 661                 return retval;
 662         retval = rf69_write_reg(spi, REG_PREAMBLE_LSB, lsb);
 663
 664         return retval;
 665 }
 666
 667 int rf69_enable_sync(struct spi_device *spi)
 668 {
 669         return rf69_set_bit(spi, REG_SYNC_CONFIG, MASK_SYNC_CONFIG_SYNC_ON);
 670 }
 671
 672 int rf69_disable_sync(struct spi_device *spi)
 673 {
 674         return rf69_clear_bit(spi, REG_SYNC_CONFIG, MASK_SYNC_CONFIG_SYNC_ON);
 675 }
 676
 677 int rf69_set_fifo_fill_condition(struct spi_device *spi,
 678                                  enum fifo_fill_condition fifo_fill_condition)
 679 {
 680         switch (fifo_fill_condition) {
 681         case always:
 682                 return rf69_set_bit(spi, REG_SYNC_CONFIG,
 683                                     MASK_SYNC_CONFIG_FIFO_FILL_CONDITION);
 684         case after_sync_interrupt:
 685                 return rf69_clear_bit(spi, REG_SYNC_CONFIG,
 686                                       MASK_SYNC_CONFIG_FIFO_FILL_CONDITION);
 687         default:
 688                 dev_dbg(&spi->dev, "set: illegal input param");
 689                 return -EINVAL;
 690         }
 691 }
 692
 693 int rf69_set_sync_size(struct spi_device *spi, u8 sync_size)
 694 {
 695         // check input value
 696         if (sync_size > 0x07) {
 697                 dev_dbg(&spi->dev, "set: illegal input param");
 698                 return -EINVAL;
 699         }
 700
 701         // write value
 702         return rf69_read_mod_write(spi, REG_SYNC_CONFIG,
 703                                    MASK_SYNC_CONFIG_SYNC_SIZE,
 704                                    (sync_size << 3));
 705 }
 706
 707 int rf69_set_sync_values(struct spi_device *spi, u8 sync_values[8])
 708 {
 709         int retval = 0;
 710
 711         retval += rf69_write_reg(spi, REG_SYNCVALUE1, sync_values[0]);
 712         retval += rf69_write_reg(spi, REG_SYNCVALUE2, sync_values[1]);
 713         retval += rf69_write_reg(spi, REG_SYNCVALUE3, sync_values[2]);
 714         retval += rf69_write_reg(spi, REG_SYNCVALUE4, sync_values[3]);
 715         retval += rf69_write_reg(spi, REG_SYNCVALUE5, sync_values[4]);
 716         retval += rf69_write_reg(spi, REG_SYNCVALUE6, sync_values[5]);
 717         retval += rf69_write_reg(spi, REG_SYNCVALUE7, sync_values[6]);
 718         retval += rf69_write_reg(spi, REG_SYNCVALUE8, sync_values[7]);
 719
 720         return retval;
 721 }
 722
 723 int rf69_set_packet_format(struct spi_device *spi,
 724                            enum packet_format packet_format)
 725 {
 726         switch (packet_format) {
 727         case packet_length_var:
 728                 return rf69_set_bit(spi, REG_PACKETCONFIG1,
 729                                     MASK_PACKETCONFIG1_PAKET_FORMAT_VARIABLE);
 730         case packet_length_fix:
 731                 return rf69_clear_bit(spi, REG_PACKETCONFIG1,
 732                                       MASK_PACKETCONFIG1_PAKET_FORMAT_VARIABLE);
 733         default:
 734                 dev_dbg(&spi->dev, "set: illegal input param");
 735                 return -EINVAL;
 736         }
 737 }
 738
 739 int rf69_enable_crc(struct spi_device *spi)
 740 {
 741         return rf69_set_bit(spi, REG_PACKETCONFIG1, MASK_PACKETCONFIG1_CRC_ON);
 742 }
 743
 744 int rf69_disable_crc(struct spi_device *spi)
 745 {
 746         return rf69_clear_bit(spi, REG_PACKETCONFIG1, MASK_PACKETCONFIG1_CRC_ON);
 747 }
 748
 749 int rf69_set_address_filtering(struct spi_device *spi,
 750                                enum address_filtering address_filtering)
 751 {
 752         switch (address_filtering) {
 753         case filtering_off:
 754                 return rf69_read_mod_write(spi, REG_PACKETCONFIG1,
 755                                            MASK_PACKETCONFIG1_ADDRESSFILTERING,
 756                                            PACKETCONFIG1_ADDRESSFILTERING_OFF);
 757         case node_address:
 758                 return rf69_read_mod_write(spi, REG_PACKETCONFIG1,
 759                                            MASK_PACKETCONFIG1_ADDRESSFILTERING,
 760                                            PACKETCONFIG1_ADDRESSFILTERING_NODE);
 761         case node_or_broadcast_address:
 762                 return rf69_read_mod_write(spi, REG_PACKETCONFIG1,
 763                                            MASK_PACKETCONFIG1_ADDRESSFILTERING,
 764                                            PACKETCONFIG1_ADDRESSFILTERING_NODEBROADCAST);
 765         default:
 766                 dev_dbg(&spi->dev, "set: illegal input param");
 767                 return -EINVAL;
 768         }
 769 }
 770
 771 int rf69_set_payload_length(struct spi_device *spi, u8 payload_length)
 772 {
 773         return rf69_write_reg(spi, REG_PAYLOAD_LENGTH, payload_length);
 774 }
 775
 776 int rf69_set_node_address(struct spi_device *spi, u8 node_address)
 777 {
 778         return rf69_write_reg(spi, REG_NODEADRS, node_address);
 779 }
 780
 781 int rf69_set_broadcast_address(struct spi_device *spi, u8 broadcast_address)
 782 {
 783         return rf69_write_reg(spi, REG_BROADCASTADRS, broadcast_address);
 784 }
 785
 786 int rf69_set_tx_start_condition(struct spi_device *spi,
 787                                 enum tx_start_condition tx_start_condition)
 788 {
 789         switch (tx_start_condition) {
 790         case fifo_level:
 791                 return rf69_clear_bit(spi, REG_FIFO_THRESH,
 792                                       MASK_FIFO_THRESH_TXSTART);
 793         case fifo_not_empty:
 794                 return rf69_set_bit(spi, REG_FIFO_THRESH,
 795                                     MASK_FIFO_THRESH_TXSTART);
 796         default:
 797                 dev_dbg(&spi->dev, "set: illegal input param");
 798                 return -EINVAL;
 799         }
 800 }
 801
 802 int rf69_set_fifo_threshold(struct spi_device *spi, u8 threshold)
 803 {
 804         int retval;
 805
 806         /* check input value */
 807         if (threshold & 0x80) {
 808                 dev_dbg(&spi->dev, "set: illegal input param");
 809                 return -EINVAL;
 810         }
 811
 812         /* write value */
 813         retval = rf69_read_mod_write(spi, REG_FIFO_THRESH,
 814                                      MASK_FIFO_THRESH_VALUE,
 815                                      threshold);
 816         if (retval)
 817                 return retval;
 818
 819         /* access the fifo to activate new threshold
 820          * retval (mis-) used as buffer here
 821          */
 822         return rf69_read_fifo(spi, (u8 *)&retval, 1);
 823 }
 824
 825 int rf69_set_dagc(struct spi_device *spi, enum dagc dagc)
 826 {
 827         switch (dagc) {
 828         case normal_mode:
 829                 return rf69_write_reg(spi, REG_TESTDAGC, DAGC_NORMAL);
 830         case improve:
 831                 return rf69_write_reg(spi, REG_TESTDAGC, DAGC_IMPROVED_LOWBETA0);
 832         case improve_for_low_modulation_index:
 833                 return rf69_write_reg(spi, REG_TESTDAGC, DAGC_IMPROVED_LOWBETA1);
 834         default:
 835                 dev_dbg(&spi->dev, "set: illegal input param");
 836                 return -EINVAL;
 837         }
 838 }
 839
 840 /*-------------------------------------------------------------------------*/
 841
 842 int rf69_read_fifo(struct spi_device *spi, u8 *buffer, unsigned int size)
 843 {
 844 #ifdef DEBUG_FIFO_ACCESS
 845         int i;
 846 #endif
 847         struct spi_transfer transfer;
 848         u8 local_buffer[FIFO_SIZE + 1];
 849         int retval;
 850
 851         if (size > FIFO_SIZE) {
 852                 dev_dbg(&spi->dev,
 853                         "read fifo: passed in buffer bigger then internal buffer\n");
 854                 return -EMSGSIZE;
 855         }
 856
 857         /* prepare a bidirectional transfer */
 858         local_buffer[0] = REG_FIFO;
 859         memset(&transfer, 0, sizeof(transfer));
 860         transfer.tx_buf = local_buffer;
 861         transfer.rx_buf = local_buffer;
 862         transfer.len    = size + 1;
 863
 864         retval = spi_sync_transfer(spi, &transfer, 1);
 865
 866 #ifdef DEBUG_FIFO_ACCESS
 867         for (i = 0; i < size; i++)
 868                 dev_dbg(&spi->dev, "%d - 0x%x\n", i, local_buffer[i + 1]);
 869 #endif
 870
 871         memcpy(buffer, &local_buffer[1], size);
 872
 873         return retval;
 874 }
 875
 876 int rf69_write_fifo(struct spi_device *spi, u8 *buffer, unsigned int size)
 877 {
 878 #ifdef DEBUG_FIFO_ACCESS
 879         int i;
 880 #endif
 881         char spi_address = REG_FIFO | WRITE_BIT;
 882         u8 local_buffer[FIFO_SIZE + 1];
 883
 884         if (size > FIFO_SIZE) {
 885                 dev_dbg(&spi->dev,
 886                         "read fifo: passed in buffer bigger then internal buffer\n");
 887                 return -EMSGSIZE;
 888         }
 889
 890         local_buffer[0] = spi_address;
 891         memcpy(&local_buffer[1], buffer, size);
 892
 893 #ifdef DEBUG_FIFO_ACCESS
 894         for (i = 0; i < size; i++)
 895                 dev_dbg(&spi->dev, "0x%x\n", buffer[i]);
 896 #endif
 897
 898         return spi_write(spi, local_buffer, size + 1);
 899 }
 900