drivers/mfd/rave-sp.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2
   3 /*
   4  * Multifunction core driver for Zodiac Inflight Innovations RAVE
   5  * Supervisory Processor(SP) MCU that is connected via dedicated UART
   6  * port
   7  *
   8  * Copyright (C) 2017 Zodiac Inflight Innovations
   9  */
  10
  11 #include <linux/atomic.h>
  12 #include <linux/crc-ccitt.h>
  13 #include <linux/delay.h>
  14 #include <linux/export.h>
  15 #include <linux/init.h>
  16 #include <linux/slab.h>
  17 #include <linux/kernel.h>
  18 #include <linux/mfd/rave-sp.h>
  19 #include <linux/module.h>
  20 #include <linux/of.h>
  21 #include <linux/of_device.h>
  22 #include <linux/sched.h>
  23 #include <linux/serdev.h>
  24 #include <asm/unaligned.h>
  25
  26 /*
  27  * UART protocol using following entities:
  28  *  - message to MCU => ACK response
  29  *  - event from MCU => event ACK
  30  *
  31  * Frame structure:
  32  * <STX> <DATA> <CHECKSUM> <ETX>
  33  * Where:
  34  * - STX - is start of transmission character
  35  * - ETX - end of transmission
  36  * - DATA - payload
  37  * - CHECKSUM - checksum calculated on <DATA>
  38  *
  39  * If <DATA> or <CHECKSUM> contain one of control characters, then it is
  40  * escaped using <DLE> control code. Added <DLE> does not participate in
  41  * checksum calculation.
  42  */
  43 #define RAVE_SP_STX                     0x02
  44 #define RAVE_SP_ETX                     0x03
  45 #define RAVE_SP_DLE                     0x10
  46
  47 #define RAVE_SP_MAX_DATA_SIZE           64
  48 #define RAVE_SP_CHECKSUM_8B2C           1
  49 #define RAVE_SP_CHECKSUM_CCITT          2
  50 #define RAVE_SP_CHECKSUM_SIZE           RAVE_SP_CHECKSUM_CCITT
  51 /*
  52  * We don't store STX, ETX and unescaped bytes, so Rx is only
  53  * DATA + CSUM
  54  */
  55 #define RAVE_SP_RX_BUFFER_SIZE                          \
  56         (RAVE_SP_MAX_DATA_SIZE + RAVE_SP_CHECKSUM_SIZE)
  57
  58 #define RAVE_SP_STX_ETX_SIZE            2
  59 /*
  60  * For Tx we have to have space for everything, STX, EXT and
  61  * potentially stuffed DATA + CSUM data + csum
  62  */
  63 #define RAVE_SP_TX_BUFFER_SIZE                          \
  64         (RAVE_SP_STX_ETX_SIZE + 2 * RAVE_SP_RX_BUFFER_SIZE)
  65
  66 /**
  67  * enum rave_sp_deframer_state - Possible state for de-framer
  68  *
  69  * @RAVE_SP_EXPECT_SOF:          Scanning input for start-of-frame marker
  70  * @RAVE_SP_EXPECT_DATA:         Got start of frame marker, collecting frame
  71  * @RAVE_SP_EXPECT_ESCAPED_DATA: Got escape character, collecting escaped byte
  72  */
  73 enum rave_sp_deframer_state {
  74         RAVE_SP_EXPECT_SOF,
  75         RAVE_SP_EXPECT_DATA,
  76         RAVE_SP_EXPECT_ESCAPED_DATA,
  77 };
  78
  79 /**
  80  * struct rave_sp_deframer - Device protocol deframer
  81  *
  82  * @state:  Current state of the deframer
  83  * @data:   Buffer used to collect deframed data
  84  * @length: Number of bytes de-framed so far
  85  */
  86 struct rave_sp_deframer {
  87         enum rave_sp_deframer_state state;
  88         unsigned char data[RAVE_SP_RX_BUFFER_SIZE];
  89         size_t length;
  90 };
  91
  92 /**
  93  * struct rave_sp_reply - Reply as per RAVE device protocol
  94  *
  95  * @length:     Expected reply length
  96  * @data:       Buffer to store reply payload in
  97  * @code:       Expected reply code
  98  * @ackid:      Expected reply ACK ID
  99  * @completion: Successful reply reception completion
 100  */
 101 struct rave_sp_reply {
 102         size_t length;
 103         void  *data;
 104         u8     code;
 105         u8     ackid;
 106         struct completion received;
 107 };
 108
 109 /**
 110  * struct rave_sp_checksum - Variant specific checksum implementation details
 111  *
 112  * @length:     Calculated checksum length
 113  * @subroutine: Utilized checksum algorithm implementation
 114  */
 115 struct rave_sp_checksum {
 116         size_t length;
 117         void (*subroutine)(const u8 *, size_t, u8 *);
 118 };
 119
 120 struct rave_sp_version {
 121         u8     hardware;
 122         __le16 major;
 123         u8     minor;
 124         u8     letter[2];
 125 } __packed;
 126
 127 struct rave_sp_status {
 128         struct rave_sp_version bootloader_version;
 129         struct rave_sp_version firmware_version;
 130         u16 rdu_eeprom_flag;
 131         u16 dds_eeprom_flag;
 132         u8  pic_flag;
 133         u8  orientation;
 134         u32 etc;
 135         s16 temp[2];
 136         u8  backlight_current[3];
 137         u8  dip_switch;
 138         u8  host_interrupt;
 139         u16 voltage_28;
 140         u8  i2c_device_status;
 141         u8  power_status;
 142         u8  general_status;
 143         u8  deprecated1;
 144         u8  power_led_status;
 145         u8  deprecated2;
 146         u8  periph_power_shutoff;
 147 } __packed;
 148
 149 /**
 150  * struct rave_sp_variant_cmds - Variant specific command routines
 151  *
 152  * @translate:  Generic to variant specific command mapping routine
 153  * @get_status: Variant specific implementation of CMD_GET_STATUS
 154  */
 155 struct rave_sp_variant_cmds {
 156         int (*translate)(enum rave_sp_command);
 157         int (*get_status)(struct rave_sp *sp, struct rave_sp_status *);
 158 };
 159
 160 /**
 161  * struct rave_sp_variant - RAVE supervisory processor core variant
 162  *
 163  * @checksum:   Variant specific checksum implementation
 164  * @cmd:        Variant specific command pointer table
 165  *
 166  */
 167 struct rave_sp_variant {
 168         const struct rave_sp_checksum *checksum;
 169         struct rave_sp_variant_cmds cmd;
 170 };
 171
 172 /**
 173  * struct rave_sp - RAVE supervisory processor core
 174  *
 175  * @serdev:                     Pointer to underlying serdev
 176  * @deframer:                   Stored state of the protocol deframer
 177  * @ackid:                      ACK ID used in last reply sent to the device
 178  * @bus_lock:                   Lock to serialize access to the device
 179  * @reply_lock:                 Lock protecting @reply
 180  * @reply:                      Pointer to memory to store reply payload
 181  *
 182  * @variant:                    Device variant specific information
 183  * @event_notifier_list:        Input event notification chain
 184  *
 185  * @part_number_firmware:       Firmware version
 186  * @part_number_bootloader:     Bootloader version
 187  */
 188 struct rave_sp {
 189         struct serdev_device *serdev;
 190         struct rave_sp_deframer deframer;
 191         atomic_t ackid;
 192         struct mutex bus_lock;
 193         struct mutex reply_lock;
 194         struct rave_sp_reply *reply;
 195
 196         const struct rave_sp_variant *variant;
 197         struct blocking_notifier_head event_notifier_list;
 198
 199         const char *part_number_firmware;
 200         const char *part_number_bootloader;
 201 };
 202
 203 static bool rave_sp_id_is_event(u8 code)
 204 {
 205         return (code & 0xF0) == RAVE_SP_EVNT_BASE;
 206 }
 207
 208 static void rave_sp_unregister_event_notifier(struct device *dev, void *res)
 209 {
 210         struct rave_sp *sp = dev_get_drvdata(dev->parent);
 211         struct notifier_block *nb = *(struct notifier_block **)res;
 212         struct blocking_notifier_head *bnh = &sp->event_notifier_list;
 213
 214         WARN_ON(blocking_notifier_chain_unregister(bnh, nb));
 215 }
 216
 217 int devm_rave_sp_register_event_notifier(struct device *dev,
 218                                          struct notifier_block *nb)
 219 {
 220         struct rave_sp *sp = dev_get_drvdata(dev->parent);
 221         struct notifier_block **rcnb;
 222         int ret;
 223
 224         rcnb = devres_alloc(rave_sp_unregister_event_notifier,
 225                             sizeof(*rcnb), GFP_KERNEL);
 226         if (!rcnb)
 227                 return -ENOMEM;
 228
 229         ret = blocking_notifier_chain_register(&sp->event_notifier_list, nb);
 230         if (!ret) {
 231                 *rcnb = nb;
 232                 devres_add(dev, rcnb);
 233         } else {
 234                 devres_free(rcnb);
 235         }
 236
 237         return ret;
 238 }
 239 EXPORT_SYMBOL_GPL(devm_rave_sp_register_event_notifier);
 240
 241 static void csum_8b2c(const u8 *buf, size_t size, u8 *crc)
 242 {
 243         *crc = *buf++;
 244         size--;
 245
 246         while (size--)
 247                 *crc += *buf++;
 248
 249         *crc = 1 + ~(*crc);
 250 }
 251
 252 static void csum_ccitt(const u8 *buf, size_t size, u8 *crc)
 253 {
 254         const u16 calculated = crc_ccitt_false(0xffff, buf, size);
 255
 256         /*
 257          * While the rest of the wire protocol is little-endian,
 258          * CCITT-16 CRC in RDU2 device is sent out in big-endian order.
 259          */
 260         put_unaligned_be16(calculated, crc);
 261 }
 262
 263 static void *stuff(unsigned char *dest, const unsigned char *src, size_t n)
 264 {
 265         while (n--) {
 266                 const unsigned char byte = *src++;
 267
 268                 switch (byte) {
 269                 case RAVE_SP_STX:
 270                 case RAVE_SP_ETX:
 271                 case RAVE_SP_DLE:
 272                         *dest++ = RAVE_SP_DLE;
 273                         /* FALLTHROUGH */
 274                 default:
 275                         *dest++ = byte;
 276                 }
 277         }
 278
 279         return dest;
 280 }
 281
 282 static int rave_sp_write(struct rave_sp *sp, const u8 *data, u8 data_size)
 283 {
 284         const size_t checksum_length = sp->variant->checksum->length;
 285         unsigned char frame[RAVE_SP_TX_BUFFER_SIZE];
 286         unsigned char crc[RAVE_SP_CHECKSUM_SIZE];
 287         unsigned char *dest = frame;
 288         size_t length;
 289
 290         if (WARN_ON(checksum_length > sizeof(crc)))
 291                 return -ENOMEM;
 292
 293         if (WARN_ON(data_size > sizeof(frame)))
 294                 return -ENOMEM;
 295
 296         sp->variant->checksum->subroutine(data, data_size, crc);
 297
 298         *dest++ = RAVE_SP_STX;
 299         dest = stuff(dest, data, data_size);
 300         dest = stuff(dest, crc, checksum_length);
 301         *dest++ = RAVE_SP_ETX;
 302
 303         length = dest - frame;
 304
 305         print_hex_dump_debug("rave-sp tx: ", DUMP_PREFIX_NONE,
 306                              16, 1, frame, length, false);
 307
 308         return serdev_device_write(sp->serdev, frame, length, HZ);
 309 }
 310
 311 static u8 rave_sp_reply_code(u8 command)
 312 {
 313         /*
 314          * There isn't a single rule that describes command code ->
 315          * ACK code transformation, but, going through various
 316          * versions of ICDs, there appear to be three distinct groups
 317          * that can be described by simple transformation.
 318          */
 319         switch (command) {
 320         case 0xA0 ... 0xBE:
 321                 /*
 322                  * Commands implemented by firmware found in RDU1 and
 323                  * older devices all seem to obey the following rule
 324                  */
 325                 return command + 0x20;
 326         case 0xE0 ... 0xEF:
 327                 /*
 328                  * Events emitted by all versions of the firmare use
 329                  * least significant bit to get an ACK code
 330                  */
 331                 return command | 0x01;
 332         default:
 333                 /*
 334                  * Commands implemented by firmware found in RDU2 are
 335                  * similar to "old" commands, but they use slightly
 336                  * different offset
 337                  */
 338                 return command + 0x40;
 339         }
 340 }
 341
 342 int rave_sp_exec(struct rave_sp *sp,
 343                  void *__data,  size_t data_size,
 344                  void *reply_data, size_t reply_data_size)
 345 {
 346         struct rave_sp_reply reply = {
 347                 .data     = reply_data,
 348                 .length   = reply_data_size,
 349                 .received = COMPLETION_INITIALIZER_ONSTACK(reply.received),
 350         };
 351         unsigned char *data = __data;
 352         int command, ret = 0;
 353         u8 ackid;
 354
 355         command = sp->variant->cmd.translate(data[0]);
 356         if (command < 0)
 357                 return command;
 358
 359         ackid       = atomic_inc_return(&sp->ackid);
 360         reply.ackid = ackid;
 361         reply.code  = rave_sp_reply_code((u8)command),
 362
 363         mutex_lock(&sp->bus_lock);
 364
 365         mutex_lock(&sp->reply_lock);
 366         sp->reply = &reply;
 367         mutex_unlock(&sp->reply_lock);
 368
 369         data[0] = command;
 370         data[1] = ackid;
 371
 372         rave_sp_write(sp, data, data_size);
 373
 374         if (!wait_for_completion_timeout(&reply.received, HZ)) {
 375                 dev_err(&sp->serdev->dev, "Command timeout\n");
 376                 ret = -ETIMEDOUT;
 377
 378                 mutex_lock(&sp->reply_lock);
 379                 sp->reply = NULL;
 380                 mutex_unlock(&sp->reply_lock);
 381         }
 382
 383         mutex_unlock(&sp->bus_lock);
 384         return ret;
 385 }
 386 EXPORT_SYMBOL_GPL(rave_sp_exec);
 387
 388 static void rave_sp_receive_event(struct rave_sp *sp,
 389                                   const unsigned char *data, size_t length)
 390 {
 391         u8 cmd[] = {
 392                 [0] = rave_sp_reply_code(data[0]),
 393                 [1] = data[1],
 394         };
 395
 396         rave_sp_write(sp, cmd, sizeof(cmd));
 397
 398         blocking_notifier_call_chain(&sp->event_notifier_list,
 399                                      rave_sp_action_pack(data[0], data[2]),
 400                                      NULL);
 401 }
 402
 403 static void rave_sp_receive_reply(struct rave_sp *sp,
 404                                   const unsigned char *data, size_t length)
 405 {
 406         struct device *dev = &sp->serdev->dev;
 407         struct rave_sp_reply *reply;
 408         const  size_t payload_length = length - 2;
 409
 410         mutex_lock(&sp->reply_lock);
 411         reply = sp->reply;
 412
 413         if (reply) {
 414                 if (reply->code == data[0] && reply->ackid == data[1] &&
 415                     payload_length >= reply->length) {
 416                         /*
 417                          * We are relying on memcpy(dst, src, 0) to be a no-op
 418                          * when handling commands that have a no-payload reply
 419                          */
 420                         memcpy(reply->data, &data[2], reply->length);
 421                         complete(&reply->received);
 422                         sp->reply = NULL;
 423                 } else {
 424                         dev_err(dev, "Ignoring incorrect reply\n");
 425                         dev_dbg(dev, "Code:   expected = 0x%08x received = 0x%08x\n",
 426                                 reply->code, data[0]);
 427                         dev_dbg(dev, "ACK ID: expected = 0x%08x received = 0x%08x\n",
 428                                 reply->ackid, data[1]);
 429                         dev_dbg(dev, "Length: expected = %zu received = %zu\n",
 430                                 reply->length, payload_length);
 431                 }
 432         }
 433
 434         mutex_unlock(&sp->reply_lock);
 435 }
 436
 437 static void rave_sp_receive_frame(struct rave_sp *sp,
 438                                   const unsigned char *data,
 439                                   size_t length)
 440 {
 441         const size_t checksum_length = sp->variant->checksum->length;
 442         const size_t payload_length  = length - checksum_length;
 443         const u8 *crc_reported       = &data[payload_length];
 444         struct device *dev           = &sp->serdev->dev;
 445         u8 crc_calculated[RAVE_SP_CHECKSUM_SIZE];
 446
 447         if (unlikely(checksum_length > sizeof(crc_calculated))) {
 448                 dev_warn(dev, "Checksum too long, dropping\n");
 449                 return;
 450         }
 451
 452         print_hex_dump_debug("rave-sp rx: ", DUMP_PREFIX_NONE,
 453                              16, 1, data, length, false);
 454
 455         if (unlikely(length <= checksum_length)) {
 456                 dev_warn(dev, "Dropping short frame\n");
 457                 return;
 458         }
 459
 460         sp->variant->checksum->subroutine(data, payload_length,
 461                                           crc_calculated);
 462
 463         if (memcmp(crc_calculated, crc_reported, checksum_length)) {
 464                 dev_warn(dev, "Dropping bad frame\n");
 465                 return;
 466         }
 467
 468         if (rave_sp_id_is_event(data[0]))
 469                 rave_sp_receive_event(sp, data, length);
 470         else
 471                 rave_sp_receive_reply(sp, data, length);
 472 }
 473
 474 static int rave_sp_receive_buf(struct serdev_device *serdev,
 475                                const unsigned char *buf, size_t size)
 476 {
 477         struct device *dev = &serdev->dev;
 478         struct rave_sp *sp = dev_get_drvdata(dev);
 479         struct rave_sp_deframer *deframer = &sp->deframer;
 480         const unsigned char *src = buf;
 481         const unsigned char *end = buf + size;
 482
 483         while (src < end) {
 484                 const unsigned char byte = *src++;
 485
 486                 switch (deframer->state) {
 487                 case RAVE_SP_EXPECT_SOF:
 488                         if (byte == RAVE_SP_STX)
 489                                 deframer->state = RAVE_SP_EXPECT_DATA;
 490                         break;
 491
 492                 case RAVE_SP_EXPECT_DATA:
 493                         /*
 494                          * Treat special byte values first
 495                          */
 496                         switch (byte) {
 497                         case RAVE_SP_ETX:
 498                                 rave_sp_receive_frame(sp,
 499                                                       deframer->data,
 500                                                       deframer->length);
 501                                 /*
 502                                  * Once we extracted a complete frame
 503                                  * out of a stream, we call it done
 504                                  * and proceed to bailing out while
 505                                  * resetting the framer to initial
 506                                  * state, regardless if we've consumed
 507                                  * all of the stream or not.
 508                                  */
 509                                 goto reset_framer;
 510                         case RAVE_SP_STX:
 511                                 dev_warn(dev, "Bad frame: STX before ETX\n");
 512                                 /*
 513                                  * If we encounter second "start of
 514                                  * the frame" marker before seeing
 515                                  * corresponding "end of frame", we
 516                                  * reset the framer and ignore both:
 517                                  * frame started by first SOF and
 518                                  * frame started by current SOF.
 519                                  *
 520                                  * NOTE: The above means that only the
 521                                  * frame started by third SOF, sent
 522                                  * after this one will have a chance
 523                                  * to get throught.
 524                                  */
 525                                 goto reset_framer;
 526                         case RAVE_SP_DLE:
 527                                 deframer->state = RAVE_SP_EXPECT_ESCAPED_DATA;
 528                                 /*
 529                                  * If we encounter escape sequence we
 530                                  * need to skip it and collect the
 531                                  * byte that follows. We do it by
 532                                  * forcing the next iteration of the
 533                                  * encompassing while loop.
 534                                  */
 535                                 continue;
 536                         }
 537                         /*
 538                          * For the rest of the bytes, that are not
 539                          * speical snoflakes, we do the same thing
 540                          * that we do to escaped data - collect it in
 541                          * deframer buffer
 542                          */
 543
 544                         /* FALLTHROUGH */
 545
 546                 case RAVE_SP_EXPECT_ESCAPED_DATA:
 547                         if (deframer->length == sizeof(deframer->data)) {
 548                                 dev_warn(dev, "Bad frame: Too long\n");
 549                                 /*
 550                                  * If the amount of data we've
 551                                  * accumulated for current frame so
 552                                  * far starts to exceed the capacity
 553                                  * of deframer's buffer, there's
 554                                  * nothing else we can do but to
 555                                  * discard that data and start
 556                                  * assemblying a new frame again
 557                                  */
 558                                 goto reset_framer;
 559                         }
 560
 561                         deframer->data[deframer->length++] = byte;
 562
 563                         /*
 564                          * We've extracted out special byte, now we
 565                          * can go back to regular data collecting
 566                          */
 567                         deframer->state = RAVE_SP_EXPECT_DATA;
 568                         break;
 569                 }
 570         }
 571
 572         /*
 573          * The only way to get out of the above loop and end up here
 574          * is throught consuming all of the supplied data, so here we
 575          * report that we processed it all.
 576          */
 577         return size;
 578
 579 reset_framer:
 580         /*
 581          * NOTE: A number of codepaths that will drop us here will do
 582          * so before consuming all 'size' bytes of the data passed by
 583          * serdev layer. We rely on the fact that serdev layer will
 584          * re-execute this handler with the remainder of the Rx bytes
 585          * once we report actual number of bytes that we processed.
 586          */
 587         deframer->state  = RAVE_SP_EXPECT_SOF;
 588         deframer->length = 0;
 589
 590         return src - buf;
 591 }
 592
 593 static int rave_sp_rdu1_cmd_translate(enum rave_sp_command command)
 594 {
 595         if (command >= RAVE_SP_CMD_STATUS &&
 596             command <= RAVE_SP_CMD_CONTROL_EVENTS)
 597                 return command;
 598
 599         return -EINVAL;
 600 }
 601
 602 static int rave_sp_rdu2_cmd_translate(enum rave_sp_command command)
 603 {
 604         if (command >= RAVE_SP_CMD_GET_FIRMWARE_VERSION &&
 605             command <= RAVE_SP_CMD_GET_GPIO_STATE)
 606                 return command;
 607
 608         if (command == RAVE_SP_CMD_REQ_COPPER_REV) {
 609                 /*
 610                  * As per RDU2 ICD 3.4.47 CMD_GET_COPPER_REV code is
 611                  * different from that for RDU1 and it is set to 0x28.
 612                  */
 613                 return 0x28;
 614         }
 615
 616         return rave_sp_rdu1_cmd_translate(command);
 617 }
 618
 619 static int rave_sp_default_cmd_translate(enum rave_sp_command command)
 620 {
 621         /*
 622          * All of the following command codes were taken from "Table :
 623          * Communications Protocol Message Types" in section 3.3
 624          * "MESSAGE TYPES" of Rave PIC24 ICD.
 625          */
 626         switch (command) {
 627         case RAVE_SP_CMD_GET_FIRMWARE_VERSION:
 628                 return 0x11;
 629         case RAVE_SP_CMD_GET_BOOTLOADER_VERSION:
 630                 return 0x12;
 631         case RAVE_SP_CMD_BOOT_SOURCE:
 632                 return 0x14;
 633         case RAVE_SP_CMD_SW_WDT:
 634                 return 0x1C;
 635         case RAVE_SP_CMD_PET_WDT:
 636                 return 0x1D;
 637         case RAVE_SP_CMD_RESET:
 638                 return 0x1E;
 639         case RAVE_SP_CMD_RESET_REASON:
 640                 return 0x1F;
 641         case RAVE_SP_CMD_RMB_EEPROM:
 642                 return 0x20;
 643         default:
 644                 return -EINVAL;
 645         }
 646 }
 647
 648 static const char *devm_rave_sp_version(struct device *dev,
 649                                         struct rave_sp_version *version)
 650 {
 651         /*
 652          * NOTE: The format string below uses %02d to display u16
 653          * intentionally for the sake of backwards compatibility with
 654          * legacy software.
 655          */
 656         return devm_kasprintf(dev, GFP_KERNEL, "%02d%02d%02d.%c%c\n",
 657                               version->hardware,
 658                               le16_to_cpu(version->major),
 659                               version->minor,
 660                               version->letter[0],
 661                               version->letter[1]);
 662 }
 663
 664 static int rave_sp_rdu1_get_status(struct rave_sp *sp,
 665                                    struct rave_sp_status *status)
 666 {
 667         u8 cmd[] = {
 668                 [0] = RAVE_SP_CMD_STATUS,
 669                 [1] = 0
 670         };
 671
 672         return rave_sp_exec(sp, cmd, sizeof(cmd), status, sizeof(*status));
 673 }
 674
 675 static int rave_sp_emulated_get_status(struct rave_sp *sp,
 676                                        struct rave_sp_status *status)
 677 {
 678         u8 cmd[] = {
 679                 [0] = RAVE_SP_CMD_GET_FIRMWARE_VERSION,
 680                 [1] = 0,
 681         };
 682         int ret;
 683
 684         ret = rave_sp_exec(sp, cmd, sizeof(cmd), &status->firmware_version,
 685                            sizeof(status->firmware_version));
 686         if (ret)
 687                 return ret;
 688
 689         cmd[0] = RAVE_SP_CMD_GET_BOOTLOADER_VERSION;
 690         return rave_sp_exec(sp, cmd, sizeof(cmd), &status->bootloader_version,
 691                             sizeof(status->bootloader_version));
 692 }
 693
 694 static int rave_sp_get_status(struct rave_sp *sp)
 695 {
 696         struct device *dev = &sp->serdev->dev;
 697         struct rave_sp_status status;
 698         const char *version;
 699         int ret;
 700
 701         ret = sp->variant->cmd.get_status(sp, &status);
 702         if (ret)
 703                 return ret;
 704
 705         version = devm_rave_sp_version(dev, &status.firmware_version);
 706         if (!version)
 707                 return -ENOMEM;
 708
 709         sp->part_number_firmware = version;
 710
 711         version = devm_rave_sp_version(dev, &status.bootloader_version);
 712         if (!version)
 713                 return -ENOMEM;
 714
 715         sp->part_number_bootloader = version;
 716
 717         return 0;
 718 }
 719
 720 static const struct rave_sp_checksum rave_sp_checksum_8b2c = {
 721         .length     = 1,
 722         .subroutine = csum_8b2c,
 723 };
 724
 725 static const struct rave_sp_checksum rave_sp_checksum_ccitt = {
 726         .length     = 2,
 727         .subroutine = csum_ccitt,
 728 };
 729
 730 static const struct rave_sp_variant rave_sp_legacy = {
 731         .checksum = &rave_sp_checksum_ccitt,
 732         .cmd = {
 733                 .translate = rave_sp_default_cmd_translate,
 734                 .get_status = rave_sp_emulated_get_status,
 735         },
 736 };
 737
 738 static const struct rave_sp_variant rave_sp_rdu1 = {
 739         .checksum = &rave_sp_checksum_8b2c,
 740         .cmd = {
 741                 .translate = rave_sp_rdu1_cmd_translate,
 742                 .get_status = rave_sp_rdu1_get_status,
 743         },
 744 };
 745
 746 static const struct rave_sp_variant rave_sp_rdu2 = {
 747         .checksum = &rave_sp_checksum_ccitt,
 748         .cmd = {
 749                 .translate = rave_sp_rdu2_cmd_translate,
 750                 .get_status = rave_sp_emulated_get_status,
 751         },
 752 };
 753
 754 static const struct of_device_id rave_sp_dt_ids[] = {
 755         { .compatible = "zii,rave-sp-niu",  .data = &rave_sp_legacy },
 756         { .compatible = "zii,rave-sp-mezz", .data = &rave_sp_legacy },
 757         { .compatible = "zii,rave-sp-esb",  .data = &rave_sp_legacy },
 758         { .compatible = "zii,rave-sp-rdu1", .data = &rave_sp_rdu1   },
 759         { .compatible = "zii,rave-sp-rdu2", .data = &rave_sp_rdu2   },
 760         { /* sentinel */ }
 761 };
 762
 763 static const struct serdev_device_ops rave_sp_serdev_device_ops = {
 764         .receive_buf  = rave_sp_receive_buf,
 765         .write_wakeup = serdev_device_write_wakeup,
 766 };
 767
 768 static int rave_sp_probe(struct serdev_device *serdev)
 769 {
 770         struct device *dev = &serdev->dev;
 771         const char *unknown = "unknown\n";
 772         struct rave_sp *sp;
 773         u32 baud;
 774         int ret;
 775
 776         if (of_property_read_u32(dev->of_node, "current-speed", &baud)) {
 777                 dev_err(dev,
 778                         "'current-speed' is not specified in device node\n");
 779                 return -EINVAL;
 780         }
 781
 782         sp = devm_kzalloc(dev, sizeof(*sp), GFP_KERNEL);
 783         if (!sp)
 784                 return -ENOMEM;
 785
 786         sp->serdev = serdev;
 787         dev_set_drvdata(dev, sp);
 788
 789         sp->variant = of_device_get_match_data(dev);
 790         if (!sp->variant)
 791                 return -ENODEV;
 792
 793         mutex_init(&sp->bus_lock);
 794         mutex_init(&sp->reply_lock);
 795         BLOCKING_INIT_NOTIFIER_HEAD(&sp->event_notifier_list);
 796
 797         serdev_device_set_client_ops(serdev, &rave_sp_serdev_device_ops);
 798         ret = devm_serdev_device_open(dev, serdev);
 799         if (ret)
 800                 return ret;
 801
 802         serdev_device_set_baudrate(serdev, baud);
 803         serdev_device_set_flow_control(serdev, false);
 804
 805         ret = serdev_device_set_parity(serdev, SERDEV_PARITY_NONE);
 806         if (ret) {
 807                 dev_err(dev, "Failed to set parity\n");
 808                 return ret;
 809         }
 810
 811         ret = rave_sp_get_status(sp);
 812         if (ret) {
 813                 dev_warn(dev, "Failed to get firmware status: %d\n", ret);
 814                 sp->part_number_firmware   = unknown;
 815                 sp->part_number_bootloader = unknown;
 816         }
 817
 818         /*
 819          * Those strings already have a \n embedded, so there's no
 820          * need to have one in format string.
 821          */
 822         dev_info(dev, "Firmware version: %s",   sp->part_number_firmware);
 823         dev_info(dev, "Bootloader version: %s", sp->part_number_bootloader);
 824
 825         return devm_of_platform_populate(dev);
 826 }
 827
 828 MODULE_DEVICE_TABLE(of, rave_sp_dt_ids);
 829
 830 static struct serdev_device_driver rave_sp_drv = {
 831         .probe                  = rave_sp_probe,
 832         .driver = {
 833                 .name           = "rave-sp",
 834                 .of_match_table = rave_sp_dt_ids,
 835         },
 836 };
 837 module_serdev_device_driver(rave_sp_drv);
 838
 839 MODULE_LICENSE("GPL");
 840 MODULE_AUTHOR("Andrey Vostrikov <andrey.vostrikov@cogentembedded.com>");
 841 MODULE_AUTHOR("Nikita Yushchenko <nikita.yoush@cogentembedded.com>");
 842 MODULE_AUTHOR("Andrey Smirnov <andrew.smirnov@gmail.com>");
 843 MODULE_DESCRIPTION("RAVE SP core driver");