drivers/net/ethernet/intel/fm10k/fm10k_mbx.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Copyright(c) 2013 - 2019 Intel Corporation. */
   3
   4 #include "fm10k_common.h"
   5
   6 /**
   7  *  fm10k_fifo_init - Initialize a message FIFO
   8  *  @fifo: pointer to FIFO
   9  *  @buffer: pointer to memory to be used to store FIFO
  10  *  @size: maximum message size to store in FIFO, must be 2^n - 1
  11  **/
  12 static void fm10k_fifo_init(struct fm10k_mbx_fifo *fifo, u32 *buffer, u16 size)
  13 {
  14         fifo->buffer = buffer;
  15         fifo->size = size;
  16         fifo->head = 0;
  17         fifo->tail = 0;
  18 }
  19
  20 /**
  21  *  fm10k_fifo_used - Retrieve used space in FIFO
  22  *  @fifo: pointer to FIFO
  23  *
  24  *  This function returns the number of DWORDs used in the FIFO
  25  **/
  26 static u16 fm10k_fifo_used(struct fm10k_mbx_fifo *fifo)
  27 {
  28         return fifo->tail - fifo->head;
  29 }
  30
  31 /**
  32  *  fm10k_fifo_unused - Retrieve unused space in FIFO
  33  *  @fifo: pointer to FIFO
  34  *
  35  *  This function returns the number of unused DWORDs in the FIFO
  36  **/
  37 static u16 fm10k_fifo_unused(struct fm10k_mbx_fifo *fifo)
  38 {
  39         return fifo->size + fifo->head - fifo->tail;
  40 }
  41
  42 /**
  43  *  fm10k_fifo_empty - Test to verify if FIFO is empty
  44  *  @fifo: pointer to FIFO
  45  *
  46  *  This function returns true if the FIFO is empty, else false
  47  **/
  48 static bool fm10k_fifo_empty(struct fm10k_mbx_fifo *fifo)
  49 {
  50         return fifo->head == fifo->tail;
  51 }
  52
  53 /**
  54  *  fm10k_fifo_head_offset - returns indices of head with given offset
  55  *  @fifo: pointer to FIFO
  56  *  @offset: offset to add to head
  57  *
  58  *  This function returns the indices into the FIFO based on head + offset
  59  **/
  60 static u16 fm10k_fifo_head_offset(struct fm10k_mbx_fifo *fifo, u16 offset)
  61 {
  62         return (fifo->head + offset) & (fifo->size - 1);
  63 }
  64
  65 /**
  66  *  fm10k_fifo_tail_offset - returns indices of tail with given offset
  67  *  @fifo: pointer to FIFO
  68  *  @offset: offset to add to tail
  69  *
  70  *  This function returns the indices into the FIFO based on tail + offset
  71  **/
  72 static u16 fm10k_fifo_tail_offset(struct fm10k_mbx_fifo *fifo, u16 offset)
  73 {
  74         return (fifo->tail + offset) & (fifo->size - 1);
  75 }
  76
  77 /**
  78  *  fm10k_fifo_head_len - Retrieve length of first message in FIFO
  79  *  @fifo: pointer to FIFO
  80  *
  81  *  This function returns the size of the first message in the FIFO
  82  **/
  83 static u16 fm10k_fifo_head_len(struct fm10k_mbx_fifo *fifo)
  84 {
  85         u32 *head = fifo->buffer + fm10k_fifo_head_offset(fifo, 0);
  86
  87         /* verify there is at least 1 DWORD in the fifo so *head is valid */
  88         if (fm10k_fifo_empty(fifo))
  89                 return 0;
  90
  91         /* retieve the message length */
  92         return FM10K_TLV_DWORD_LEN(*head);
  93 }
  94
  95 /**
  96  *  fm10k_fifo_head_drop - Drop the first message in FIFO
  97  *  @fifo: pointer to FIFO
  98  *
  99  *  This function returns the size of the message dropped from the FIFO
 100  **/
 101 static u16 fm10k_fifo_head_drop(struct fm10k_mbx_fifo *fifo)
 102 {
 103         u16 len = fm10k_fifo_head_len(fifo);
 104
 105         /* update head so it is at the start of next frame */
 106         fifo->head += len;
 107
 108         return len;
 109 }
 110
 111 /**
 112  *  fm10k_fifo_drop_all - Drop all messages in FIFO
 113  *  @fifo: pointer to FIFO
 114  *
 115  *  This function resets the head pointer to drop all messages in the FIFO and
 116  *  ensure the FIFO is empty.
 117  **/
 118 static void fm10k_fifo_drop_all(struct fm10k_mbx_fifo *fifo)
 119 {
 120         fifo->head = fifo->tail;
 121 }
 122
 123 /**
 124  *  fm10k_mbx_index_len - Convert a head/tail index into a length value
 125  *  @mbx: pointer to mailbox
 126  *  @head: head index
 127  *  @tail: head index
 128  *
 129  *  This function takes the head and tail index and determines the length
 130  *  of the data indicated by this pair.
 131  **/
 132 static u16 fm10k_mbx_index_len(struct fm10k_mbx_info *mbx, u16 head, u16 tail)
 133 {
 134         u16 len = tail - head;
 135
 136         /* we wrapped so subtract 2, one for index 0, one for all 1s index */
 137         if (len > tail)
 138                 len -= 2;
 139
 140         return len & ((mbx->mbmem_len << 1) - 1);
 141 }
 142
 143 /**
 144  *  fm10k_mbx_tail_add - Determine new tail value with added offset
 145  *  @mbx: pointer to mailbox
 146  *  @offset: length to add to tail offset
 147  *
 148  *  This function takes the local tail index and recomputes it for
 149  *  a given length added as an offset.
 150  **/
 151 static u16 fm10k_mbx_tail_add(struct fm10k_mbx_info *mbx, u16 offset)
 152 {
 153         u16 tail = (mbx->tail + offset + 1) & ((mbx->mbmem_len << 1) - 1);
 154
 155         /* add/sub 1 because we cannot have offset 0 or all 1s */
 156         return (tail > mbx->tail) ? --tail : ++tail;
 157 }
 158
 159 /**
 160  *  fm10k_mbx_tail_sub - Determine new tail value with subtracted offset
 161  *  @mbx: pointer to mailbox
 162  *  @offset: length to add to tail offset
 163  *
 164  *  This function takes the local tail index and recomputes it for
 165  *  a given length added as an offset.
 166  **/
 167 static u16 fm10k_mbx_tail_sub(struct fm10k_mbx_info *mbx, u16 offset)
 168 {
 169         u16 tail = (mbx->tail - offset - 1) & ((mbx->mbmem_len << 1) - 1);
 170
 171         /* sub/add 1 because we cannot have offset 0 or all 1s */
 172         return (tail < mbx->tail) ? ++tail : --tail;
 173 }
 174
 175 /**
 176  *  fm10k_mbx_head_add - Determine new head value with added offset
 177  *  @mbx: pointer to mailbox
 178  *  @offset: length to add to head offset
 179  *
 180  *  This function takes the local head index and recomputes it for
 181  *  a given length added as an offset.
 182  **/
 183 static u16 fm10k_mbx_head_add(struct fm10k_mbx_info *mbx, u16 offset)
 184 {
 185         u16 head = (mbx->head + offset + 1) & ((mbx->mbmem_len << 1) - 1);
 186
 187         /* add/sub 1 because we cannot have offset 0 or all 1s */
 188         return (head > mbx->head) ? --head : ++head;
 189 }
 190
 191 /**
 192  *  fm10k_mbx_head_sub - Determine new head value with subtracted offset
 193  *  @mbx: pointer to mailbox
 194  *  @offset: length to add to head offset
 195  *
 196  *  This function takes the local head index and recomputes it for
 197  *  a given length added as an offset.
 198  **/
 199 static u16 fm10k_mbx_head_sub(struct fm10k_mbx_info *mbx, u16 offset)
 200 {
 201         u16 head = (mbx->head - offset - 1) & ((mbx->mbmem_len << 1) - 1);
 202
 203         /* sub/add 1 because we cannot have offset 0 or all 1s */
 204         return (head < mbx->head) ? ++head : --head;
 205 }
 206
 207 /**
 208  *  fm10k_mbx_pushed_tail_len - Retrieve the length of message being pushed
 209  *  @mbx: pointer to mailbox
 210  *
 211  *  This function will return the length of the message currently being
 212  *  pushed onto the tail of the Rx queue.
 213  **/
 214 static u16 fm10k_mbx_pushed_tail_len(struct fm10k_mbx_info *mbx)
 215 {
 216         u32 *tail = mbx->rx.buffer + fm10k_fifo_tail_offset(&mbx->rx, 0);
 217
 218         /* pushed tail is only valid if pushed is set */
 219         if (!mbx->pushed)
 220                 return 0;
 221
 222         return FM10K_TLV_DWORD_LEN(*tail);
 223 }
 224
 225 /**
 226  *  fm10k_fifo_write_copy - pulls data off of msg and places it in FIFO
 227  *  @fifo: pointer to FIFO
 228  *  @msg: message array to populate
 229  *  @tail_offset: additional offset to add to tail pointer
 230  *  @len: length of FIFO to copy into message header
 231  *
 232  *  This function will take a message and copy it into a section of the
 233  *  FIFO.  In order to get something into a location other than just
 234  *  the tail you can use tail_offset to adjust the pointer.
 235  **/
 236 static void fm10k_fifo_write_copy(struct fm10k_mbx_fifo *fifo,
 237                                   const u32 *msg, u16 tail_offset, u16 len)
 238 {
 239         u16 end = fm10k_fifo_tail_offset(fifo, tail_offset);
 240         u32 *tail = fifo->buffer + end;
 241
 242         /* track when we should cross the end of the FIFO */
 243         end = fifo->size - end;
 244
 245         /* copy end of message before start of message */
 246         if (end < len)
 247                 memcpy(fifo->buffer, msg + end, (len - end) << 2);
 248         else
 249                 end = len;
 250
 251         /* Copy remaining message into Tx FIFO */
 252         memcpy(tail, msg, end << 2);
 253 }
 254
 255 /**
 256  *  fm10k_fifo_enqueue - Enqueues the message to the tail of the FIFO
 257  *  @fifo: pointer to FIFO
 258  *  @msg: message array to read
 259  *
 260  *  This function enqueues a message up to the size specified by the length
 261  *  contained in the first DWORD of the message and will place at the tail
 262  *  of the FIFO.  It will return 0 on success, or a negative value on error.
 263  **/
 264 static s32 fm10k_fifo_enqueue(struct fm10k_mbx_fifo *fifo, const u32 *msg)
 265 {
 266         u16 len = FM10K_TLV_DWORD_LEN(*msg);
 267
 268         /* verify parameters */
 269         if (len > fifo->size)
 270                 return FM10K_MBX_ERR_SIZE;
 271
 272         /* verify there is room for the message */
 273         if (len > fm10k_fifo_unused(fifo))
 274                 return FM10K_MBX_ERR_NO_SPACE;
 275
 276         /* Copy message into FIFO */
 277         fm10k_fifo_write_copy(fifo, msg, 0, len);
 278
 279         /* memory barrier to guarantee FIFO is written before tail update */
 280         wmb();
 281
 282         /* Update Tx FIFO tail */
 283         fifo->tail += len;
 284
 285         return 0;
 286 }
 287
 288 /**
 289  *  fm10k_mbx_validate_msg_size - Validate incoming message based on size
 290  *  @mbx: pointer to mailbox
 291  *  @len: length of data pushed onto buffer
 292  *
 293  *  This function analyzes the frame and will return a non-zero value when
 294  *  the start of a message larger than the mailbox is detected.
 295  **/
 296 static u16 fm10k_mbx_validate_msg_size(struct fm10k_mbx_info *mbx, u16 len)
 297 {
 298         struct fm10k_mbx_fifo *fifo = &mbx->rx;
 299         u16 total_len = 0, msg_len;
 300
 301         /* length should include previous amounts pushed */
 302         len += mbx->pushed;
 303
 304         /* offset in message is based off of current message size */
 305         do {
 306                 u32 *msg;
 307
 308                 msg = fifo->buffer + fm10k_fifo_tail_offset(fifo, total_len);
 309                 msg_len = FM10K_TLV_DWORD_LEN(*msg);
 310                 total_len += msg_len;
 311         } while (total_len < len);
 312
 313         /* message extends out of pushed section, but fits in FIFO */
 314         if ((len < total_len) && (msg_len <= mbx->max_size))
 315                 return 0;
 316
 317         /* return length of invalid section */
 318         return (len < total_len) ? len : (len - total_len);
 319 }
 320
 321 /**
 322  *  fm10k_mbx_write_copy - pulls data off of Tx FIFO and places it in mbmem
 323  *  @hw: pointer to hardware structure
 324  *  @mbx: pointer to mailbox
 325  *
 326  *  This function will take a section of the Tx FIFO and copy it into the
 327  *  mailbox memory.  The offset in mbmem is based on the lower bits of the
 328  *  tail and len determines the length to copy.
 329  **/
 330 static void fm10k_mbx_write_copy(struct fm10k_hw *hw,
 331                                  struct fm10k_mbx_info *mbx)
 332 {
 333         struct fm10k_mbx_fifo *fifo = &mbx->tx;
 334         u32 mbmem = mbx->mbmem_reg;
 335         u32 *head = fifo->buffer;
 336         u16 end, len, tail, mask;
 337
 338         if (!mbx->tail_len)
 339                 return;
 340
 341         /* determine data length and mbmem tail index */
 342         mask = mbx->mbmem_len - 1;
 343         len = mbx->tail_len;
 344         tail = fm10k_mbx_tail_sub(mbx, len);
 345         if (tail > mask)
 346                 tail++;
 347
 348         /* determine offset in the ring */
 349         end = fm10k_fifo_head_offset(fifo, mbx->pulled);
 350         head += end;
 351
 352         /* memory barrier to guarantee data is ready to be read */
 353         rmb();
 354
 355         /* Copy message from Tx FIFO */
 356         for (end = fifo->size - end; len; head = fifo->buffer) {
 357                 do {
 358                         /* adjust tail to match offset for FIFO */
 359                         tail &= mask;
 360                         if (!tail)
 361                                 tail++;
 362
 363                         mbx->tx_mbmem_pulled++;
 364
 365                         /* write message to hardware FIFO */
 366                         fm10k_write_reg(hw, mbmem + tail++, *(head++));
 367                 } while (--len && --end);
 368         }
 369 }
 370
 371 /**
 372  *  fm10k_mbx_pull_head - Pulls data off of head of Tx FIFO
 373  *  @hw: pointer to hardware structure
 374  *  @mbx: pointer to mailbox
 375  *  @head: acknowledgement number last received
 376  *
 377  *  This function will push the tail index forward based on the remote
 378  *  head index.  It will then pull up to mbmem_len DWORDs off of the
 379  *  head of the FIFO and will place it in the MBMEM registers
 380  *  associated with the mailbox.
 381  **/
 382 static void fm10k_mbx_pull_head(struct fm10k_hw *hw,
 383                                 struct fm10k_mbx_info *mbx, u16 head)
 384 {
 385         u16 mbmem_len, len, ack = fm10k_mbx_index_len(mbx, head, mbx->tail);
 386         struct fm10k_mbx_fifo *fifo = &mbx->tx;
 387
 388         /* update number of bytes pulled and update bytes in transit */
 389         mbx->pulled += mbx->tail_len - ack;
 390
 391         /* determine length of data to pull, reserve space for mbmem header */
 392         mbmem_len = mbx->mbmem_len - 1;
 393         len = fm10k_fifo_used(fifo) - mbx->pulled;
 394         if (len > mbmem_len)
 395                 len = mbmem_len;
 396
 397         /* update tail and record number of bytes in transit */
 398         mbx->tail = fm10k_mbx_tail_add(mbx, len - ack);
 399         mbx->tail_len = len;
 400
 401         /* drop pulled messages from the FIFO */
 402         for (len = fm10k_fifo_head_len(fifo);
 403              len && (mbx->pulled >= len);
 404              len = fm10k_fifo_head_len(fifo)) {
 405                 mbx->pulled -= fm10k_fifo_head_drop(fifo);
 406                 mbx->tx_messages++;
 407                 mbx->tx_dwords += len;
 408         }
 409
 410         /* Copy message out from the Tx FIFO */
 411         fm10k_mbx_write_copy(hw, mbx);
 412 }
 413
 414 /**
 415  *  fm10k_mbx_read_copy - pulls data off of mbmem and places it in Rx FIFO
 416  *  @hw: pointer to hardware structure
 417  *  @mbx: pointer to mailbox
 418  *
 419  *  This function will take a section of the mailbox memory and copy it
 420  *  into the Rx FIFO.  The offset is based on the lower bits of the
 421  *  head and len determines the length to copy.
 422  **/
 423 static void fm10k_mbx_read_copy(struct fm10k_hw *hw,
 424                                 struct fm10k_mbx_info *mbx)
 425 {
 426         struct fm10k_mbx_fifo *fifo = &mbx->rx;
 427         u32 mbmem = mbx->mbmem_reg ^ mbx->mbmem_len;
 428         u32 *tail = fifo->buffer;
 429         u16 end, len, head;
 430
 431         /* determine data length and mbmem head index */
 432         len = mbx->head_len;
 433         head = fm10k_mbx_head_sub(mbx, len);
 434         if (head >= mbx->mbmem_len)
 435                 head++;
 436
 437         /* determine offset in the ring */
 438         end = fm10k_fifo_tail_offset(fifo, mbx->pushed);
 439         tail += end;
 440
 441         /* Copy message into Rx FIFO */
 442         for (end = fifo->size - end; len; tail = fifo->buffer) {
 443                 do {
 444                         /* adjust head to match offset for FIFO */
 445                         head &= mbx->mbmem_len - 1;
 446                         if (!head)
 447                                 head++;
 448
 449                         mbx->rx_mbmem_pushed++;
 450
 451                         /* read message from hardware FIFO */
 452                         *(tail++) = fm10k_read_reg(hw, mbmem + head++);
 453                 } while (--len && --end);
 454         }
 455
 456         /* memory barrier to guarantee FIFO is written before tail update */
 457         wmb();
 458 }
 459
 460 /**
 461  *  fm10k_mbx_push_tail - Pushes up to 15 DWORDs on to tail of FIFO
 462  *  @hw: pointer to hardware structure
 463  *  @mbx: pointer to mailbox
 464  *  @tail: tail index of message
 465  *
 466  *  This function will first validate the tail index and size for the
 467  *  incoming message.  It then updates the acknowledgment number and
 468  *  copies the data into the FIFO.  It will return the number of messages
 469  *  dequeued on success and a negative value on error.
 470  **/
 471 static s32 fm10k_mbx_push_tail(struct fm10k_hw *hw,
 472                                struct fm10k_mbx_info *mbx,
 473                                u16 tail)
 474 {
 475         struct fm10k_mbx_fifo *fifo = &mbx->rx;
 476         u16 len, seq = fm10k_mbx_index_len(mbx, mbx->head, tail);
 477
 478         /* determine length of data to push */
 479         len = fm10k_fifo_unused(fifo) - mbx->pushed;
 480         if (len > seq)
 481                 len = seq;
 482
 483         /* update head and record bytes received */
 484         mbx->head = fm10k_mbx_head_add(mbx, len);
 485         mbx->head_len = len;
 486
 487         /* nothing to do if there is no data */
 488         if (!len)
 489                 return 0;
 490
 491         /* Copy msg into Rx FIFO */
 492         fm10k_mbx_read_copy(hw, mbx);
 493
 494         /* determine if there are any invalid lengths in message */
 495         if (fm10k_mbx_validate_msg_size(mbx, len))
 496                 return FM10K_MBX_ERR_SIZE;
 497
 498         /* Update pushed */
 499         mbx->pushed += len;
 500
 501         /* flush any completed messages */
 502         for (len = fm10k_mbx_pushed_tail_len(mbx);
 503              len && (mbx->pushed >= len);
 504              len = fm10k_mbx_pushed_tail_len(mbx)) {
 505                 fifo->tail += len;
 506                 mbx->pushed -= len;
 507                 mbx->rx_messages++;
 508                 mbx->rx_dwords += len;
 509         }
 510
 511         return 0;
 512 }
 513
 514 /* pre-generated data for generating the CRC based on the poly 0xAC9A. */
 515 static const u16 fm10k_crc_16b_table[256] = {
 516         0x0000, 0x7956, 0xF2AC, 0x8BFA, 0xBC6D, 0xC53B, 0x4EC1, 0x3797,
 517         0x21EF, 0x58B9, 0xD343, 0xAA15, 0x9D82, 0xE4D4, 0x6F2E, 0x1678,
 518         0x43DE, 0x3A88, 0xB172, 0xC824, 0xFFB3, 0x86E5, 0x0D1F, 0x7449,
 519         0x6231, 0x1B67, 0x909D, 0xE9CB, 0xDE5C, 0xA70A, 0x2CF0, 0x55A6,
 520         0x87BC, 0xFEEA, 0x7510, 0x0C46, 0x3BD1, 0x4287, 0xC97D, 0xB02B,
 521         0xA653, 0xDF05, 0x54FF, 0x2DA9, 0x1A3E, 0x6368, 0xE892, 0x91C4,
 522         0xC462, 0xBD34, 0x36CE, 0x4F98, 0x780F, 0x0159, 0x8AA3, 0xF3F5,
 523         0xE58D, 0x9CDB, 0x1721, 0x6E77, 0x59E0, 0x20B6, 0xAB4C, 0xD21A,
 524         0x564D, 0x2F1B, 0xA4E1, 0xDDB7, 0xEA20, 0x9376, 0x188C, 0x61DA,
 525         0x77A2, 0x0EF4, 0x850E, 0xFC58, 0xCBCF, 0xB299, 0x3963, 0x4035,
 526         0x1593, 0x6CC5, 0xE73F, 0x9E69, 0xA9FE, 0xD0A8, 0x5B52, 0x2204,
 527         0x347C, 0x4D2A, 0xC6D0, 0xBF86, 0x8811, 0xF147, 0x7ABD, 0x03EB,
 528         0xD1F1, 0xA8A7, 0x235D, 0x5A0B, 0x6D9C, 0x14CA, 0x9F30, 0xE666,
 529         0xF01E, 0x8948, 0x02B2, 0x7BE4, 0x4C73, 0x3525, 0xBEDF, 0xC789,
 530         0x922F, 0xEB79, 0x6083, 0x19D5, 0x2E42, 0x5714, 0xDCEE, 0xA5B8,
 531         0xB3C0, 0xCA96, 0x416C, 0x383A, 0x0FAD, 0x76FB, 0xFD01, 0x8457,
 532         0xAC9A, 0xD5CC, 0x5E36, 0x2760, 0x10F7, 0x69A1, 0xE25B, 0x9B0D,
 533         0x8D75, 0xF423, 0x7FD9, 0x068F, 0x3118, 0x484E, 0xC3B4, 0xBAE2,
 534         0xEF44, 0x9612, 0x1DE8, 0x64BE, 0x5329, 0x2A7F, 0xA185, 0xD8D3,
 535         0xCEAB, 0xB7FD, 0x3C07, 0x4551, 0x72C6, 0x0B90, 0x806A, 0xF93C,
 536         0x2B26, 0x5270, 0xD98A, 0xA0DC, 0x974B, 0xEE1D, 0x65E7, 0x1CB1,
 537         0x0AC9, 0x739F, 0xF865, 0x8133, 0xB6A4, 0xCFF2, 0x4408, 0x3D5E,
 538         0x68F8, 0x11AE, 0x9A54, 0xE302, 0xD495, 0xADC3, 0x2639, 0x5F6F,
 539         0x4917, 0x3041, 0xBBBB, 0xC2ED, 0xF57A, 0x8C2C, 0x07D6, 0x7E80,
 540         0xFAD7, 0x8381, 0x087B, 0x712D, 0x46BA, 0x3FEC, 0xB416, 0xCD40,
 541         0xDB38, 0xA26E, 0x2994, 0x50C2, 0x6755, 0x1E03, 0x95F9, 0xECAF,
 542         0xB909, 0xC05F, 0x4BA5, 0x32F3, 0x0564, 0x7C32, 0xF7C8, 0x8E9E,
 543         0x98E6, 0xE1B0, 0x6A4A, 0x131C, 0x248B, 0x5DDD, 0xD627, 0xAF71,
 544         0x7D6B, 0x043D, 0x8FC7, 0xF691, 0xC106, 0xB850, 0x33AA, 0x4AFC,
 545         0x5C84, 0x25D2, 0xAE28, 0xD77E, 0xE0E9, 0x99BF, 0x1245, 0x6B13,
 546         0x3EB5, 0x47E3, 0xCC19, 0xB54F, 0x82D8, 0xFB8E, 0x7074, 0x0922,
 547         0x1F5A, 0x660C, 0xEDF6, 0x94A0, 0xA337, 0xDA61, 0x519B, 0x28CD };
 548
 549 /**
 550  *  fm10k_crc_16b - Generate a 16 bit CRC for a region of 16 bit data
 551  *  @data: pointer to data to process
 552  *  @seed: seed value for CRC
 553  *  @len: length measured in 16 bits words
 554  *
 555  *  This function will generate a CRC based on the polynomial 0xAC9A and
 556  *  whatever value is stored in the seed variable.  Note that this
 557  *  value inverts the local seed and the result in order to capture all
 558  *  leading and trailing zeros.
 559  */
 560 static u16 fm10k_crc_16b(const u32 *data, u16 seed, u16 len)
 561 {
 562         u32 result = seed;
 563
 564         while (len--) {
 565                 result ^= *(data++);
 566                 result = (result >> 8) ^ fm10k_crc_16b_table[result & 0xFF];
 567                 result = (result >> 8) ^ fm10k_crc_16b_table[result & 0xFF];
 568
 569                 if (!(len--))
 570                         break;
 571
 572                 result = (result >> 8) ^ fm10k_crc_16b_table[result & 0xFF];
 573                 result = (result >> 8) ^ fm10k_crc_16b_table[result & 0xFF];
 574         }
 575
 576         return (u16)result;
 577 }
 578
 579 /**
 580  *  fm10k_fifo_crc - generate a CRC based off of FIFO data
 581  *  @fifo: pointer to FIFO
 582  *  @offset: offset point for start of FIFO
 583  *  @len: number of DWORDS words to process
 584  *  @seed: seed value for CRC
 585  *
 586  *  This function generates a CRC for some region of the FIFO
 587  **/
 588 static u16 fm10k_fifo_crc(struct fm10k_mbx_fifo *fifo, u16 offset,
 589                           u16 len, u16 seed)
 590 {
 591         u32 *data = fifo->buffer + offset;
 592
 593         /* track when we should cross the end of the FIFO */
 594         offset = fifo->size - offset;
 595
 596         /* if we are in 2 blocks process the end of the FIFO first */
 597         if (offset < len) {
 598                 seed = fm10k_crc_16b(data, seed, offset * 2);
 599                 data = fifo->buffer;
 600                 len -= offset;
 601         }
 602
 603         /* process any remaining bits */
 604         return fm10k_crc_16b(data, seed, len * 2);
 605 }
 606
 607 /**
 608  *  fm10k_mbx_update_local_crc - Update the local CRC for outgoing data
 609  *  @mbx: pointer to mailbox
 610  *  @head: head index provided by remote mailbox
 611  *
 612  *  This function will generate the CRC for all data from the end of the
 613  *  last head update to the current one.  It uses the result of the
 614  *  previous CRC as the seed for this update.  The result is stored in
 615  *  mbx->local.
 616  **/
 617 static void fm10k_mbx_update_local_crc(struct fm10k_mbx_info *mbx, u16 head)
 618 {
 619         u16 len = mbx->tail_len - fm10k_mbx_index_len(mbx, head, mbx->tail);
 620
 621         /* determine the offset for the start of the region to be pulled */
 622         head = fm10k_fifo_head_offset(&mbx->tx, mbx->pulled);
 623
 624         /* update local CRC to include all of the pulled data */
 625         mbx->local = fm10k_fifo_crc(&mbx->tx, head, len, mbx->local);
 626 }
 627
 628 /**
 629  *  fm10k_mbx_verify_remote_crc - Verify the CRC is correct for current data
 630  *  @mbx: pointer to mailbox
 631  *
 632  *  This function will take all data that has been provided from the remote
 633  *  end and generate a CRC for it.  This is stored in mbx->remote.  The
 634  *  CRC for the header is then computed and if the result is non-zero this
 635  *  is an error and we signal an error dropping all data and resetting the
 636  *  connection.
 637  */
 638 static s32 fm10k_mbx_verify_remote_crc(struct fm10k_mbx_info *mbx)
 639 {
 640         struct fm10k_mbx_fifo *fifo = &mbx->rx;
 641         u16 len = mbx->head_len;
 642         u16 offset = fm10k_fifo_tail_offset(fifo, mbx->pushed) - len;
 643         u16 crc;
 644
 645         /* update the remote CRC if new data has been received */
 646         if (len)
 647                 mbx->remote = fm10k_fifo_crc(fifo, offset, len, mbx->remote);
 648
 649         /* process the full header as we have to validate the CRC */
 650         crc = fm10k_crc_16b(&mbx->mbx_hdr, mbx->remote, 1);
 651
 652         /* notify other end if we have a problem */
 653         return crc ? FM10K_MBX_ERR_CRC : 0;
 654 }
 655
 656 /**
 657  *  fm10k_mbx_rx_ready - Indicates that a message is ready in the Rx FIFO
 658  *  @mbx: pointer to mailbox
 659  *
 660  *  This function returns true if there is a message in the Rx FIFO to dequeue.
 661  **/
 662 static bool fm10k_mbx_rx_ready(struct fm10k_mbx_info *mbx)
 663 {
 664         u16 msg_size = fm10k_fifo_head_len(&mbx->rx);
 665
 666         return msg_size && (fm10k_fifo_used(&mbx->rx) >= msg_size);
 667 }
 668
 669 /**
 670  *  fm10k_mbx_tx_ready - Indicates that the mailbox is in state ready for Tx
 671  *  @mbx: pointer to mailbox
 672  *  @len: verify free space is >= this value
 673  *
 674  *  This function returns true if the mailbox is in a state ready to transmit.
 675  **/
 676 static bool fm10k_mbx_tx_ready(struct fm10k_mbx_info *mbx, u16 len)
 677 {
 678         u16 fifo_unused = fm10k_fifo_unused(&mbx->tx);
 679
 680         return (mbx->state == FM10K_STATE_OPEN) && (fifo_unused >= len);
 681 }
 682
 683 /**
 684  *  fm10k_mbx_tx_complete - Indicates that the Tx FIFO has been emptied
 685  *  @mbx: pointer to mailbox
 686  *
 687  *  This function returns true if the Tx FIFO is empty.
 688  **/
 689 static bool fm10k_mbx_tx_complete(struct fm10k_mbx_info *mbx)
 690 {
 691         return fm10k_fifo_empty(&mbx->tx);
 692 }
 693
 694 /**
 695  *  fm10k_mbx_deqeueue_rx - Dequeues the message from the head in the Rx FIFO
 696  *  @hw: pointer to hardware structure
 697  *  @mbx: pointer to mailbox
 698  *
 699  *  This function dequeues messages and hands them off to the TLV parser.
 700  *  It will return the number of messages processed when called.
 701  **/
 702 static u16 fm10k_mbx_dequeue_rx(struct fm10k_hw *hw,
 703                                 struct fm10k_mbx_info *mbx)
 704 {
 705         struct fm10k_mbx_fifo *fifo = &mbx->rx;
 706         s32 err;
 707         u16 cnt;
 708
 709         /* parse Rx messages out of the Rx FIFO to empty it */
 710         for (cnt = 0; !fm10k_fifo_empty(fifo); cnt++) {
 711                 err = fm10k_tlv_msg_parse(hw, fifo->buffer + fifo->head,
 712                                           mbx, mbx->msg_data);
 713                 if (err < 0)
 714                         mbx->rx_parse_err++;
 715
 716                 fm10k_fifo_head_drop(fifo);
 717         }
 718
 719         /* shift remaining bytes back to start of FIFO */
 720         memmove(fifo->buffer, fifo->buffer + fifo->tail, mbx->pushed << 2);
 721
 722         /* shift head and tail based on the memory we moved */
 723         fifo->tail -= fifo->head;
 724         fifo->head = 0;
 725
 726         return cnt;
 727 }
 728
 729 /**
 730  *  fm10k_mbx_enqueue_tx - Enqueues the message to the tail of the Tx FIFO
 731  *  @hw: pointer to hardware structure
 732  *  @mbx: pointer to mailbox
 733  *  @msg: message array to read
 734  *
 735  *  This function enqueues a message up to the size specified by the length
 736  *  contained in the first DWORD of the message and will place at the tail
 737  *  of the FIFO.  It will return 0 on success, or a negative value on error.
 738  **/
 739 static s32 fm10k_mbx_enqueue_tx(struct fm10k_hw *hw,
 740                                 struct fm10k_mbx_info *mbx, const u32 *msg)
 741 {
 742         u32 countdown = mbx->timeout;
 743         s32 err;
 744
 745         switch (mbx->state) {
 746         case FM10K_STATE_CLOSED:
 747         case FM10K_STATE_DISCONNECT:
 748                 return FM10K_MBX_ERR_NO_MBX;
 749         default:
 750                 break;
 751         }
 752
 753         /* enqueue the message on the Tx FIFO */
 754         err = fm10k_fifo_enqueue(&mbx->tx, msg);
 755
 756         /* if it failed give the FIFO a chance to drain */
 757         while (err && countdown) {
 758                 countdown--;
 759                 udelay(mbx->udelay);
 760                 mbx->ops.process(hw, mbx);
 761                 err = fm10k_fifo_enqueue(&mbx->tx, msg);
 762         }
 763
 764         /* if we failed treat the error */
 765         if (err) {
 766                 mbx->timeout = 0;
 767                 mbx->tx_busy++;
 768         }
 769
 770         /* begin processing message, ignore errors as this is just meant
 771          * to start the mailbox flow so we are not concerned if there
 772          * is a bad error, or the mailbox is already busy with a request
 773          */
 774         if (!mbx->tail_len)
 775                 mbx->ops.process(hw, mbx);
 776
 777         return 0;
 778 }
 779
 780 /**
 781  *  fm10k_mbx_read - Copies the mbmem to local message buffer
 782  *  @hw: pointer to hardware structure
 783  *  @mbx: pointer to mailbox
 784  *
 785  *  This function copies the message from the mbmem to the message array
 786  **/
 787 static s32 fm10k_mbx_read(struct fm10k_hw *hw, struct fm10k_mbx_info *mbx)
 788 {
 789         /* only allow one reader in here at a time */
 790         if (mbx->mbx_hdr)
 791                 return FM10K_MBX_ERR_BUSY;
 792
 793         /* read to capture initial interrupt bits */
 794         if (fm10k_read_reg(hw, mbx->mbx_reg) & FM10K_MBX_REQ_INTERRUPT)
 795                 mbx->mbx_lock = FM10K_MBX_ACK;
 796
 797         /* write back interrupt bits to clear */
 798         fm10k_write_reg(hw, mbx->mbx_reg,
 799                         FM10K_MBX_REQ_INTERRUPT | FM10K_MBX_ACK_INTERRUPT);
 800
 801         /* read remote header */
 802         mbx->mbx_hdr = fm10k_read_reg(hw, mbx->mbmem_reg ^ mbx->mbmem_len);
 803
 804         return 0;
 805 }
 806
 807 /**
 808  *  fm10k_mbx_write - Copies the local message buffer to mbmem
 809  *  @hw: pointer to hardware structure
 810  *  @mbx: pointer to mailbox
 811  *
 812  *  This function copies the message from the the message array to mbmem
 813  **/
 814 static void fm10k_mbx_write(struct fm10k_hw *hw, struct fm10k_mbx_info *mbx)
 815 {
 816         u32 mbmem = mbx->mbmem_reg;
 817
 818         /* write new msg header to notify recipient of change */
 819         fm10k_write_reg(hw, mbmem, mbx->mbx_hdr);
 820
 821         /* write mailbox to send interrupt */
 822         if (mbx->mbx_lock)
 823                 fm10k_write_reg(hw, mbx->mbx_reg, mbx->mbx_lock);
 824
 825         /* we no longer are using the header so free it */
 826         mbx->mbx_hdr = 0;
 827         mbx->mbx_lock = 0;
 828 }
 829
 830 /**
 831  *  fm10k_mbx_create_connect_hdr - Generate a connect mailbox header
 832  *  @mbx: pointer to mailbox
 833  *
 834  *  This function returns a connection mailbox header
 835  **/
 836 static void fm10k_mbx_create_connect_hdr(struct fm10k_mbx_info *mbx)
 837 {
 838         mbx->mbx_lock |= FM10K_MBX_REQ;
 839
 840         mbx->mbx_hdr = FM10K_MSG_HDR_FIELD_SET(FM10K_MSG_CONNECT, TYPE) |
 841                        FM10K_MSG_HDR_FIELD_SET(mbx->head, HEAD) |
 842                        FM10K_MSG_HDR_FIELD_SET(mbx->rx.size - 1, CONNECT_SIZE);
 843 }
 844
 845 /**
 846  *  fm10k_mbx_create_data_hdr - Generate a data mailbox header
 847  *  @mbx: pointer to mailbox
 848  *
 849  *  This function returns a data mailbox header
 850  **/
 851 static void fm10k_mbx_create_data_hdr(struct fm10k_mbx_info *mbx)
 852 {
 853         u32 hdr = FM10K_MSG_HDR_FIELD_SET(FM10K_MSG_DATA, TYPE) |
 854                   FM10K_MSG_HDR_FIELD_SET(mbx->tail, TAIL) |
 855                   FM10K_MSG_HDR_FIELD_SET(mbx->head, HEAD);
 856         struct fm10k_mbx_fifo *fifo = &mbx->tx;
 857         u16 crc;
 858
 859         if (mbx->tail_len)
 860                 mbx->mbx_lock |= FM10K_MBX_REQ;
 861
 862         /* generate CRC for data in flight and header */
 863         crc = fm10k_fifo_crc(fifo, fm10k_fifo_head_offset(fifo, mbx->pulled),
 864                              mbx->tail_len, mbx->local);
 865         crc = fm10k_crc_16b(&hdr, crc, 1);
 866
 867         /* load header to memory to be written */
 868         mbx->mbx_hdr = hdr | FM10K_MSG_HDR_FIELD_SET(crc, CRC);
 869 }
 870
 871 /**
 872  *  fm10k_mbx_create_disconnect_hdr - Generate a disconnect mailbox header
 873  *  @mbx: pointer to mailbox
 874  *
 875  *  This function returns a disconnect mailbox header
 876  **/
 877 static void fm10k_mbx_create_disconnect_hdr(struct fm10k_mbx_info *mbx)
 878 {
 879         u32 hdr = FM10K_MSG_HDR_FIELD_SET(FM10K_MSG_DISCONNECT, TYPE) |
 880                   FM10K_MSG_HDR_FIELD_SET(mbx->tail, TAIL) |
 881                   FM10K_MSG_HDR_FIELD_SET(mbx->head, HEAD);
 882         u16 crc = fm10k_crc_16b(&hdr, mbx->local, 1);
 883
 884         mbx->mbx_lock |= FM10K_MBX_ACK;
 885
 886         /* load header to memory to be written */
 887         mbx->mbx_hdr = hdr | FM10K_MSG_HDR_FIELD_SET(crc, CRC);
 888 }
 889
 890 /**
 891  *  fm10k_mbx_create_fake_disconnect_hdr - Generate a false disconnect mbox hdr
 892  *  @mbx: pointer to mailbox
 893  *
 894  *  This function creates a fake disconnect header for loading into remote
 895  *  mailbox header. The primary purpose is to prevent errors on immediate
 896  *  start up after mbx->connect.
 897  **/
 898 static void fm10k_mbx_create_fake_disconnect_hdr(struct fm10k_mbx_info *mbx)
 899 {
 900         u32 hdr = FM10K_MSG_HDR_FIELD_SET(FM10K_MSG_DISCONNECT, TYPE) |
 901                   FM10K_MSG_HDR_FIELD_SET(mbx->head, TAIL) |
 902                   FM10K_MSG_HDR_FIELD_SET(mbx->tail, HEAD);
 903         u16 crc = fm10k_crc_16b(&hdr, mbx->local, 1);
 904
 905         mbx->mbx_lock |= FM10K_MBX_ACK;
 906
 907         /* load header to memory to be written */
 908         mbx->mbx_hdr = hdr | FM10K_MSG_HDR_FIELD_SET(crc, CRC);
 909 }
 910
 911 /**
 912  *  fm10k_mbx_create_error_msg - Generate an error message
 913  *  @mbx: pointer to mailbox
 914  *  @err: local error encountered
 915  *
 916  *  This function will interpret the error provided by err, and based on
 917  *  that it may shift the message by 1 DWORD and then place an error header
 918  *  at the start of the message.
 919  **/
 920 static void fm10k_mbx_create_error_msg(struct fm10k_mbx_info *mbx, s32 err)
 921 {
 922         /* only generate an error message for these types */
 923         switch (err) {
 924         case FM10K_MBX_ERR_TAIL:
 925         case FM10K_MBX_ERR_HEAD:
 926         case FM10K_MBX_ERR_TYPE:
 927         case FM10K_MBX_ERR_SIZE:
 928         case FM10K_MBX_ERR_RSVD0:
 929         case FM10K_MBX_ERR_CRC:
 930                 break;
 931         default:
 932                 return;
 933         }
 934
 935         mbx->mbx_lock |= FM10K_MBX_REQ;
 936
 937         mbx->mbx_hdr = FM10K_MSG_HDR_FIELD_SET(FM10K_MSG_ERROR, TYPE) |
 938                        FM10K_MSG_HDR_FIELD_SET(err, ERR_NO) |
 939                        FM10K_MSG_HDR_FIELD_SET(mbx->head, HEAD);
 940 }
 941
 942 /**
 943  *  fm10k_mbx_validate_msg_hdr - Validate common fields in the message header
 944  *  @mbx: pointer to mailbox
 945  *
 946  *  This function will parse up the fields in the mailbox header and return
 947  *  an error if the header contains any of a number of invalid configurations
 948  *  including unrecognized type, invalid route, or a malformed message.
 949  **/
 950 static s32 fm10k_mbx_validate_msg_hdr(struct fm10k_mbx_info *mbx)
 951 {
 952         u16 type, rsvd0, head, tail, size;
 953         const u32 *hdr = &mbx->mbx_hdr;
 954
 955         type = FM10K_MSG_HDR_FIELD_GET(*hdr, TYPE);
 956         rsvd0 = FM10K_MSG_HDR_FIELD_GET(*hdr, RSVD0);
 957         tail = FM10K_MSG_HDR_FIELD_GET(*hdr, TAIL);
 958         head = FM10K_MSG_HDR_FIELD_GET(*hdr, HEAD);
 959         size = FM10K_MSG_HDR_FIELD_GET(*hdr, CONNECT_SIZE);
 960
 961         if (rsvd0)
 962                 return FM10K_MBX_ERR_RSVD0;
 963
 964         switch (type) {
 965         case FM10K_MSG_DISCONNECT:
 966                 /* validate that all data has been received */
 967                 if (tail != mbx->head)
 968                         return FM10K_MBX_ERR_TAIL;
 969
 970                 fallthrough;
 971         case FM10K_MSG_DATA:
 972                 /* validate that head is moving correctly */
 973                 if (!head || (head == FM10K_MSG_HDR_MASK(HEAD)))
 974                         return FM10K_MBX_ERR_HEAD;
 975                 if (fm10k_mbx_index_len(mbx, head, mbx->tail) > mbx->tail_len)
 976                         return FM10K_MBX_ERR_HEAD;
 977
 978                 /* validate that tail is moving correctly */
 979                 if (!tail || (tail == FM10K_MSG_HDR_MASK(TAIL)))
 980                         return FM10K_MBX_ERR_TAIL;
 981                 if (fm10k_mbx_index_len(mbx, mbx->head, tail) < mbx->mbmem_len)
 982                         break;
 983
 984                 return FM10K_MBX_ERR_TAIL;
 985         case FM10K_MSG_CONNECT:
 986                 /* validate size is in range and is power of 2 mask */
 987                 if ((size < FM10K_VFMBX_MSG_MTU) || (size & (size + 1)))
 988                         return FM10K_MBX_ERR_SIZE;
 989
 990                 fallthrough;
 991         case FM10K_MSG_ERROR:
 992                 if (!head || (head == FM10K_MSG_HDR_MASK(HEAD)))
 993                         return FM10K_MBX_ERR_HEAD;
 994                 /* neither create nor error include a tail offset */
 995                 if (tail)
 996                         return FM10K_MBX_ERR_TAIL;
 997
 998                 break;
 999         default:
1000                 return FM10K_MBX_ERR_TYPE;
1001         }
1002
1003         return 0;
1004 }
1005
1006 /**
1007  *  fm10k_mbx_create_reply - Generate reply based on state and remote head
1008  *  @hw: pointer to hardware structure
1009  *  @mbx: pointer to mailbox
1010  *  @head: acknowledgement number
1011  *
1012  *  This function will generate an outgoing message based on the current
1013  *  mailbox state and the remote FIFO head.  It will return the length
1014  *  of the outgoing message excluding header on success, and a negative value
1015  *  on error.
1016  **/
1017 static s32 fm10k_mbx_create_reply(struct fm10k_hw *hw,
1018                                   struct fm10k_mbx_info *mbx, u16 head)
1019 {
1020         switch (mbx->state) {
1021         case FM10K_STATE_OPEN:
1022         case FM10K_STATE_DISCONNECT:
1023                 /* update our checksum for the outgoing data */
1024                 fm10k_mbx_update_local_crc(mbx, head);
1025
1026                 /* as long as other end recognizes us keep sending data */
1027                 fm10k_mbx_pull_head(hw, mbx, head);
1028
1029                 /* generate new header based on data */
1030                 if (mbx->tail_len || (mbx->state == FM10K_STATE_OPEN))
1031                         fm10k_mbx_create_data_hdr(mbx);
1032                 else
1033                         fm10k_mbx_create_disconnect_hdr(mbx);
1034                 break;
1035         case FM10K_STATE_CONNECT:
1036                 /* send disconnect even if we aren't connected */
1037                 fm10k_mbx_create_connect_hdr(mbx);
1038                 break;
1039         case FM10K_STATE_CLOSED:
1040                 /* generate new header based on data */
1041                 fm10k_mbx_create_disconnect_hdr(mbx);
1042         default:
1043                 break;
1044         }
1045
1046         return 0;
1047 }
1048
1049 /**
1050  *  fm10k_mbx_reset_work- Reset internal pointers for any pending work
1051  *  @mbx: pointer to mailbox
1052  *
1053  *  This function will reset all internal pointers so any work in progress
1054  *  is dropped.  This call should occur every time we transition from the
1055  *  open state to the connect state.
1056  **/
1057 static void fm10k_mbx_reset_work(struct fm10k_mbx_info *mbx)
1058 {
1059         u16 len, head, ack;
1060
1061         /* reset our outgoing max size back to Rx limits */
1062         mbx->max_size = mbx->rx.size - 1;
1063
1064         /* update mbx->pulled to account for tail_len and ack */
1065         head = FM10K_MSG_HDR_FIELD_GET(mbx->mbx_hdr, HEAD);
1066         ack = fm10k_mbx_index_len(mbx, head, mbx->tail);
1067         mbx->pulled += mbx->tail_len - ack;
1068
1069         /* now drop any messages which have started or finished transmitting */
1070         while (fm10k_fifo_head_len(&mbx->tx) && mbx->pulled) {
1071                 len = fm10k_fifo_head_drop(&mbx->tx);
1072                 mbx->tx_dropped++;
1073                 if (mbx->pulled >= len)
1074                         mbx->pulled -= len;
1075                 else
1076                         mbx->pulled = 0;
1077         }
1078
1079         /* just do a quick resysnc to start of message */
1080         mbx->pushed = 0;
1081         mbx->pulled = 0;
1082         mbx->tail_len = 0;
1083         mbx->head_len = 0;
1084         mbx->rx.tail = 0;
1085         mbx->rx.head = 0;
1086 }
1087
1088 /**
1089  *  fm10k_mbx_update_max_size - Update the max_size and drop any large messages
1090  *  @mbx: pointer to mailbox
1091  *  @size: new value for max_size
1092  *
1093  *  This function updates the max_size value and drops any outgoing messages
1094  *  at the head of the Tx FIFO if they are larger than max_size. It does not
1095  *  drop all messages, as this is too difficult to parse and remove them from
1096  *  the FIFO. Instead, rely on the checking to ensure that messages larger
1097  *  than max_size aren't pushed into the memory buffer.
1098  **/
1099 static void fm10k_mbx_update_max_size(struct fm10k_mbx_info *mbx, u16 size)
1100 {
1101         u16 len;
1102
1103         mbx->max_size = size;
1104
1105         /* flush any oversized messages from the queue */
1106         for (len = fm10k_fifo_head_len(&mbx->tx);
1107              len > size;
1108              len = fm10k_fifo_head_len(&mbx->tx)) {
1109                 fm10k_fifo_head_drop(&mbx->tx);
1110                 mbx->tx_dropped++;
1111         }
1112 }
1113
1114 /**
1115  *  fm10k_mbx_connect_reset - Reset following request for reset
1116  *  @mbx: pointer to mailbox
1117  *
1118  *  This function resets the mailbox to either a disconnected state
1119  *  or a connect state depending on the current mailbox state
1120  **/
1121 static void fm10k_mbx_connect_reset(struct fm10k_mbx_info *mbx)
1122 {
1123         /* just do a quick resysnc to start of frame */
1124         fm10k_mbx_reset_work(mbx);
1125
1126         /* reset CRC seeds */
1127         mbx->local = FM10K_MBX_CRC_SEED;
1128         mbx->remote = FM10K_MBX_CRC_SEED;
1129
1130         /* we cannot exit connect until the size is good */
1131         if (mbx->state == FM10K_STATE_OPEN)
1132                 mbx->state = FM10K_STATE_CONNECT;
1133         else
1134                 mbx->state = FM10K_STATE_CLOSED;
1135 }
1136
1137 /**
1138  *  fm10k_mbx_process_connect - Process connect header
1139  *  @hw: pointer to hardware structure
1140  *  @mbx: pointer to mailbox
1141  *
1142  *  This function will read an incoming connect header and reply with the
1143  *  appropriate message.  It will return a value indicating the number of
1144  *  data DWORDs on success, or will return a negative value on failure.
1145  **/
1146 static s32 fm10k_mbx_process_connect(struct fm10k_hw *hw,
1147                                      struct fm10k_mbx_info *mbx)
1148 {
1149         const enum fm10k_mbx_state state = mbx->state;
1150         const u32 *hdr = &mbx->mbx_hdr;
1151         u16 size, head;
1152
1153         /* we will need to pull all of the fields for verification */
1154         size = FM10K_MSG_HDR_FIELD_GET(*hdr, CONNECT_SIZE);
1155         head = FM10K_MSG_HDR_FIELD_GET(*hdr, HEAD);
1156
1157         switch (state) {
1158         case FM10K_STATE_DISCONNECT:
1159         case FM10K_STATE_OPEN:
1160                 /* reset any in-progress work */
1161                 fm10k_mbx_connect_reset(mbx);
1162                 break;
1163         case FM10K_STATE_CONNECT:
1164                 /* we cannot exit connect until the size is good */
1165                 if (size > mbx->rx.size) {
1166                         mbx->max_size = mbx->rx.size - 1;
1167                 } else {
1168                         /* record the remote system requesting connection */
1169                         mbx->state = FM10K_STATE_OPEN;
1170
1171                         fm10k_mbx_update_max_size(mbx, size);
1172                 }
1173                 break;
1174         default:
1175                 break;
1176         }
1177
1178         /* align our tail index to remote head index */
1179         mbx->tail = head;
1180
1181         return fm10k_mbx_create_reply(hw, mbx, head);
1182 }
1183
1184 /**
1185  *  fm10k_mbx_process_data - Process data header
1186  *  @hw: pointer to hardware structure
1187  *  @mbx: pointer to mailbox
1188  *
1189  *  This function will read an incoming data header and reply with the
1190  *  appropriate message.  It will return a value indicating the number of
1191  *  data DWORDs on success, or will return a negative value on failure.
1192  **/
1193 static s32 fm10k_mbx_process_data(struct fm10k_hw *hw,
1194                                   struct fm10k_mbx_info *mbx)
1195 {
1196         const u32 *hdr = &mbx->mbx_hdr;
1197         u16 head, tail;
1198         s32 err;
1199
1200         /* we will need to pull all of the fields for verification */
1201         head = FM10K_MSG_HDR_FIELD_GET(*hdr, HEAD);
1202         tail = FM10K_MSG_HDR_FIELD_GET(*hdr, TAIL);
1203
1204         /* if we are in connect just update our data and go */
1205         if (mbx->state == FM10K_STATE_CONNECT) {
1206                 mbx->tail = head;
1207                 mbx->state = FM10K_STATE_OPEN;
1208         }
1209
1210         /* abort on message size errors */
1211         err = fm10k_mbx_push_tail(hw, mbx, tail);
1212         if (err < 0)
1213                 return err;
1214
1215         /* verify the checksum on the incoming data */
1216         err = fm10k_mbx_verify_remote_crc(mbx);
1217         if (err)
1218                 return err;
1219
1220         /* process messages if we have received any */
1221         fm10k_mbx_dequeue_rx(hw, mbx);
1222
1223         return fm10k_mbx_create_reply(hw, mbx, head);
1224 }
1225
1226 /**
1227  *  fm10k_mbx_process_disconnect - Process disconnect header
1228  *  @hw: pointer to hardware structure
1229  *  @mbx: pointer to mailbox
1230  *
1231  *  This function will read an incoming disconnect header and reply with the
1232  *  appropriate message.  It will return a value indicating the number of
1233  *  data DWORDs on success, or will return a negative value on failure.
1234  **/
1235 static s32 fm10k_mbx_process_disconnect(struct fm10k_hw *hw,
1236                                         struct fm10k_mbx_info *mbx)
1237 {
1238         const enum fm10k_mbx_state state = mbx->state;
1239         const u32 *hdr = &mbx->mbx_hdr;
1240         u16 head;
1241         s32 err;
1242
1243         /* we will need to pull the header field for verification */
1244         head = FM10K_MSG_HDR_FIELD_GET(*hdr, HEAD);
1245
1246         /* We should not be receiving disconnect if Rx is incomplete */
1247         if (mbx->pushed)
1248                 return FM10K_MBX_ERR_TAIL;
1249
1250         /* we have already verified mbx->head == tail so we know this is 0 */
1251         mbx->head_len = 0;
1252
1253         /* verify the checksum on the incoming header is correct */
1254         err = fm10k_mbx_verify_remote_crc(mbx);
1255         if (err)
1256                 return err;
1257
1258         switch (state) {
1259         case FM10K_STATE_DISCONNECT:
1260         case FM10K_STATE_OPEN:
1261                 /* state doesn't change if we still have work to do */
1262                 if (!fm10k_mbx_tx_complete(mbx))
1263                         break;
1264
1265                 /* verify the head indicates we completed all transmits */
1266                 if (head != mbx->tail)
1267                         return FM10K_MBX_ERR_HEAD;
1268
1269                 /* reset any in-progress work */
1270                 fm10k_mbx_connect_reset(mbx);
1271                 break;
1272         default:
1273                 break;
1274         }
1275
1276         return fm10k_mbx_create_reply(hw, mbx, head);
1277 }
1278
1279 /**
1280  *  fm10k_mbx_process_error - Process error header
1281  *  @hw: pointer to hardware structure
1282  *  @mbx: pointer to mailbox
1283  *
1284  *  This function will read an incoming error header and reply with the
1285  *  appropriate message.  It will return a value indicating the number of
1286  *  data DWORDs on success, or will return a negative value on failure.
1287  **/
1288 static s32 fm10k_mbx_process_error(struct fm10k_hw *hw,
1289                                    struct fm10k_mbx_info *mbx)
1290 {
1291         const u32 *hdr = &mbx->mbx_hdr;
1292         u16 head;
1293
1294         /* we will need to pull all of the fields for verification */
1295         head = FM10K_MSG_HDR_FIELD_GET(*hdr, HEAD);
1296
1297         switch (mbx->state) {
1298         case FM10K_STATE_OPEN:
1299         case FM10K_STATE_DISCONNECT:
1300                 /* flush any uncompleted work */
1301                 fm10k_mbx_reset_work(mbx);
1302
1303                 /* reset CRC seeds */
1304                 mbx->local = FM10K_MBX_CRC_SEED;
1305                 mbx->remote = FM10K_MBX_CRC_SEED;
1306
1307                 /* reset tail index and size to prepare for reconnect */
1308                 mbx->tail = head;
1309
1310                 /* if open then reset max_size and go back to connect */
1311                 if (mbx->state == FM10K_STATE_OPEN) {
1312                         mbx->state = FM10K_STATE_CONNECT;
1313                         break;
1314                 }
1315
1316                 /* send a connect message to get data flowing again */
1317                 fm10k_mbx_create_connect_hdr(mbx);
1318                 return 0;
1319         default:
1320                 break;
1321         }
1322
1323         return fm10k_mbx_create_reply(hw, mbx, mbx->tail);
1324 }
1325
1326 /**
1327  *  fm10k_mbx_process - Process mailbox interrupt
1328  *  @hw: pointer to hardware structure
1329  *  @mbx: pointer to mailbox
1330  *
1331  *  This function will process incoming mailbox events and generate mailbox
1332  *  replies.  It will return a value indicating the number of DWORDs
1333  *  transmitted excluding header on success or a negative value on error.
1334  **/
1335 static s32 fm10k_mbx_process(struct fm10k_hw *hw,
1336                              struct fm10k_mbx_info *mbx)
1337 {
1338         s32 err;
1339
1340         /* we do not read mailbox if closed */
1341         if (mbx->state == FM10K_STATE_CLOSED)
1342                 return 0;
1343
1344         /* copy data from mailbox */
1345         err = fm10k_mbx_read(hw, mbx);
1346         if (err)
1347                 return err;
1348
1349         /* validate type, source, and destination */
1350         err = fm10k_mbx_validate_msg_hdr(mbx);
1351         if (err < 0)
1352                 goto msg_err;
1353
1354         switch (FM10K_MSG_HDR_FIELD_GET(mbx->mbx_hdr, TYPE)) {
1355         case FM10K_MSG_CONNECT:
1356                 err = fm10k_mbx_process_connect(hw, mbx);
1357                 break;
1358         case FM10K_MSG_DATA:
1359                 err = fm10k_mbx_process_data(hw, mbx);
1360                 break;
1361         case FM10K_MSG_DISCONNECT:
1362                 err = fm10k_mbx_process_disconnect(hw, mbx);
1363                 break;
1364         case FM10K_MSG_ERROR:
1365                 err = fm10k_mbx_process_error(hw, mbx);
1366                 break;
1367         default:
1368                 err = FM10K_MBX_ERR_TYPE;
1369                 break;
1370         }
1371
1372 msg_err:
1373         /* notify partner of errors on our end */
1374         if (err < 0)
1375                 fm10k_mbx_create_error_msg(mbx, err);
1376
1377         /* copy data from mailbox */
1378         fm10k_mbx_write(hw, mbx);
1379
1380         return err;
1381 }
1382
1383 /**
1384  *  fm10k_mbx_disconnect - Shutdown mailbox connection
1385  *  @hw: pointer to hardware structure
1386  *  @mbx: pointer to mailbox
1387  *
1388  *  This function will shut down the mailbox.  It places the mailbox first
1389  *  in the disconnect state, it then allows up to a predefined timeout for
1390  *  the mailbox to transition to close on its own.  If this does not occur
1391  *  then the mailbox will be forced into the closed state.
1392  *
1393  *  Any mailbox transactions not completed before calling this function
1394  *  are not guaranteed to complete and may be dropped.
1395  **/
1396 static void fm10k_mbx_disconnect(struct fm10k_hw *hw,
1397                                  struct fm10k_mbx_info *mbx)
1398 {
1399         int timeout = mbx->timeout ? FM10K_MBX_DISCONNECT_TIMEOUT : 0;
1400
1401         /* Place mbx in ready to disconnect state */
1402         mbx->state = FM10K_STATE_DISCONNECT;
1403
1404         /* trigger interrupt to start shutdown process */
1405         fm10k_write_reg(hw, mbx->mbx_reg, FM10K_MBX_REQ |
1406                                           FM10K_MBX_INTERRUPT_DISABLE);
1407         do {
1408                 udelay(FM10K_MBX_POLL_DELAY);
1409                 mbx->ops.process(hw, mbx);
1410                 timeout -= FM10K_MBX_POLL_DELAY;
1411         } while ((timeout > 0) && (mbx->state != FM10K_STATE_CLOSED));
1412
1413         /* in case we didn't close, just force the mailbox into shutdown and
1414          * drop all left over messages in the FIFO.
1415          */
1416         fm10k_mbx_connect_reset(mbx);
1417         fm10k_fifo_drop_all(&mbx->tx);
1418
1419         fm10k_write_reg(hw, mbx->mbmem_reg, 0);
1420 }
1421
1422 /**
1423  *  fm10k_mbx_connect - Start mailbox connection
1424  *  @hw: pointer to hardware structure
1425  *  @mbx: pointer to mailbox
1426  *
1427  *  This function will initiate a mailbox connection.  It will populate the
1428  *  mailbox with a broadcast connect message and then initialize the lock.
1429  *  This is safe since the connect message is a single DWORD so the mailbox
1430  *  transaction is guaranteed to be atomic.
1431  *
1432  *  This function will return an error if the mailbox has not been initiated
1433  *  or is currently in use.
1434  **/
1435 static s32 fm10k_mbx_connect(struct fm10k_hw *hw, struct fm10k_mbx_info *mbx)
1436 {
1437         /* we cannot connect an uninitialized mailbox */
1438         if (!mbx->rx.buffer)
1439                 return FM10K_MBX_ERR_NO_SPACE;
1440
1441         /* we cannot connect an already connected mailbox */
1442         if (mbx->state != FM10K_STATE_CLOSED)
1443                 return FM10K_MBX_ERR_BUSY;
1444
1445         /* mailbox timeout can now become active */
1446         mbx->timeout = FM10K_MBX_INIT_TIMEOUT;
1447
1448         /* Place mbx in ready to connect state */
1449         mbx->state = FM10K_STATE_CONNECT;
1450
1451         fm10k_mbx_reset_work(mbx);
1452
1453         /* initialize header of remote mailbox */
1454         fm10k_mbx_create_fake_disconnect_hdr(mbx);
1455         fm10k_write_reg(hw, mbx->mbmem_reg ^ mbx->mbmem_len, mbx->mbx_hdr);
1456
1457         /* enable interrupt and notify other party of new message */
1458         mbx->mbx_lock = FM10K_MBX_REQ_INTERRUPT | FM10K_MBX_ACK_INTERRUPT |
1459                         FM10K_MBX_INTERRUPT_ENABLE;
1460
1461         /* generate and load connect header into mailbox */
1462         fm10k_mbx_create_connect_hdr(mbx);
1463         fm10k_mbx_write(hw, mbx);
1464
1465         return 0;
1466 }
1467
1468 /**
1469  *  fm10k_mbx_validate_handlers - Validate layout of message parsing data
1470  *  @msg_data: handlers for mailbox events
1471  *
1472  *  This function validates the layout of the message parsing data.  This
1473  *  should be mostly static, but it is important to catch any errors that
1474  *  are made when constructing the parsers.
1475  **/
1476 static s32 fm10k_mbx_validate_handlers(const struct fm10k_msg_data *msg_data)
1477 {
1478         const struct fm10k_tlv_attr *attr;
1479         unsigned int id;
1480
1481         /* Allow NULL mailboxes that transmit but don't receive */
1482         if (!msg_data)
1483                 return 0;
1484
1485         while (msg_data->id != FM10K_TLV_ERROR) {
1486                 /* all messages should have a function handler */
1487                 if (!msg_data->func)
1488                         return FM10K_ERR_PARAM;
1489
1490                 /* parser is optional */
1491                 attr = msg_data->attr;
1492                 if (attr) {
1493                         while (attr->id != FM10K_TLV_ERROR) {
1494                                 id = attr->id;
1495                                 attr++;
1496                                 /* ID should always be increasing */
1497                                 if (id >= attr->id)
1498                                         return FM10K_ERR_PARAM;
1499                                 /* ID should fit in results array */
1500                                 if (id >= FM10K_TLV_RESULTS_MAX)
1501                                         return FM10K_ERR_PARAM;
1502                         }
1503
1504                         /* verify terminator is in the list */
1505                         if (attr->id != FM10K_TLV_ERROR)
1506                                 return FM10K_ERR_PARAM;
1507                 }
1508
1509                 id = msg_data->id;
1510                 msg_data++;
1511                 /* ID should always be increasing */
1512                 if (id >= msg_data->id)
1513                         return FM10K_ERR_PARAM;
1514         }
1515
1516         /* verify terminator is in the list */
1517         if ((msg_data->id != FM10K_TLV_ERROR) || !msg_data->func)
1518                 return FM10K_ERR_PARAM;
1519
1520         return 0;
1521 }
1522
1523 /**
1524  *  fm10k_mbx_register_handlers - Register a set of handler ops for mailbox
1525  *  @mbx: pointer to mailbox
1526  *  @msg_data: handlers for mailbox events
1527  *
1528  *  This function associates a set of message handling ops with a mailbox.
1529  **/
1530 static s32 fm10k_mbx_register_handlers(struct fm10k_mbx_info *mbx,
1531                                        const struct fm10k_msg_data *msg_data)
1532 {
1533         /* validate layout of handlers before assigning them */
1534         if (fm10k_mbx_validate_handlers(msg_data))
1535                 return FM10K_ERR_PARAM;
1536
1537         /* initialize the message handlers */
1538         mbx->msg_data = msg_data;
1539
1540         return 0;
1541 }
1542
1543 /**
1544  *  fm10k_pfvf_mbx_init - Initialize mailbox memory for PF/VF mailbox
1545  *  @hw: pointer to hardware structure
1546  *  @mbx: pointer to mailbox
1547  *  @msg_data: handlers for mailbox events
1548  *  @id: ID reference for PF as it supports up to 64 PF/VF mailboxes
1549  *
1550  *  This function initializes the mailbox for use.  It will split the
1551  *  buffer provided and use that to populate both the Tx and Rx FIFO by
1552  *  evenly splitting it.  In order to allow for easy masking of head/tail
1553  *  the value reported in size must be a power of 2 and is reported in
1554  *  DWORDs, not bytes.  Any invalid values will cause the mailbox to return
1555  *  error.
1556  **/
1557 s32 fm10k_pfvf_mbx_init(struct fm10k_hw *hw, struct fm10k_mbx_info *mbx,
1558                         const struct fm10k_msg_data *msg_data, u8 id)
1559 {
1560         /* initialize registers */
1561         switch (hw->mac.type) {
1562         case fm10k_mac_vf:
1563                 mbx->mbx_reg = FM10K_VFMBX;
1564                 mbx->mbmem_reg = FM10K_VFMBMEM(FM10K_VFMBMEM_VF_XOR);
1565                 break;
1566         case fm10k_mac_pf:
1567                 /* there are only 64 VF <-> PF mailboxes */
1568                 if (id < 64) {
1569                         mbx->mbx_reg = FM10K_MBX(id);
1570                         mbx->mbmem_reg = FM10K_MBMEM_VF(id, 0);
1571                         break;
1572                 }
1573                 fallthrough;
1574         default:
1575                 return FM10K_MBX_ERR_NO_MBX;
1576         }
1577
1578         /* start out in closed state */
1579         mbx->state = FM10K_STATE_CLOSED;
1580
1581         /* validate layout of handlers before assigning them */
1582         if (fm10k_mbx_validate_handlers(msg_data))
1583                 return FM10K_ERR_PARAM;
1584
1585         /* initialize the message handlers */
1586         mbx->msg_data = msg_data;
1587
1588         /* start mailbox as timed out and let the reset_hw call
1589          * set the timeout value to begin communications
1590          */
1591         mbx->timeout = 0;
1592         mbx->udelay = FM10K_MBX_INIT_DELAY;
1593
1594         /* initialize tail and head */
1595         mbx->tail = 1;
1596         mbx->head = 1;
1597
1598         /* initialize CRC seeds */
1599         mbx->local = FM10K_MBX_CRC_SEED;
1600         mbx->remote = FM10K_MBX_CRC_SEED;
1601
1602         /* Split buffer for use by Tx/Rx FIFOs */
1603         mbx->max_size = FM10K_MBX_MSG_MAX_SIZE;
1604         mbx->mbmem_len = FM10K_VFMBMEM_VF_XOR;
1605
1606         /* initialize the FIFOs, sizes are in 4 byte increments */
1607         fm10k_fifo_init(&mbx->tx, mbx->buffer, FM10K_MBX_TX_BUFFER_SIZE);
1608         fm10k_fifo_init(&mbx->rx, &mbx->buffer[FM10K_MBX_TX_BUFFER_SIZE],
1609                         FM10K_MBX_RX_BUFFER_SIZE);
1610
1611         /* initialize function pointers */
1612         mbx->ops.connect = fm10k_mbx_connect;
1613         mbx->ops.disconnect = fm10k_mbx_disconnect;
1614         mbx->ops.rx_ready = fm10k_mbx_rx_ready;
1615         mbx->ops.tx_ready = fm10k_mbx_tx_ready;
1616         mbx->ops.tx_complete = fm10k_mbx_tx_complete;
1617         mbx->ops.enqueue_tx = fm10k_mbx_enqueue_tx;
1618         mbx->ops.process = fm10k_mbx_process;
1619         mbx->ops.register_handlers = fm10k_mbx_register_handlers;
1620
1621         return 0;
1622 }
1623
1624 /**
1625  *  fm10k_sm_mbx_create_data_hdr - Generate a mailbox header for local FIFO
1626  *  @mbx: pointer to mailbox
1627  *
1628  *  This function returns a data mailbox header
1629  **/
1630 static void fm10k_sm_mbx_create_data_hdr(struct fm10k_mbx_info *mbx)
1631 {
1632         if (mbx->tail_len)
1633                 mbx->mbx_lock |= FM10K_MBX_REQ;
1634
1635         mbx->mbx_hdr = FM10K_MSG_HDR_FIELD_SET(mbx->tail, SM_TAIL) |
1636                        FM10K_MSG_HDR_FIELD_SET(mbx->remote, SM_VER) |
1637                        FM10K_MSG_HDR_FIELD_SET(mbx->head, SM_HEAD);
1638 }
1639
1640 /**
1641  *  fm10k_sm_mbx_create_connect_hdr - Generate a mailbox header for local FIFO
1642  *  @mbx: pointer to mailbox
1643  *  @err: error flags to report if any
1644  *
1645  *  This function returns a connection mailbox header
1646  **/
1647 static void fm10k_sm_mbx_create_connect_hdr(struct fm10k_mbx_info *mbx, u8 err)
1648 {
1649         if (mbx->local)
1650                 mbx->mbx_lock |= FM10K_MBX_REQ;
1651
1652         mbx->mbx_hdr = FM10K_MSG_HDR_FIELD_SET(mbx->tail, SM_TAIL) |
1653                        FM10K_MSG_HDR_FIELD_SET(mbx->remote, SM_VER) |
1654                        FM10K_MSG_HDR_FIELD_SET(mbx->head, SM_HEAD) |
1655                        FM10K_MSG_HDR_FIELD_SET(err, SM_ERR);
1656 }
1657
1658 /**
1659  *  fm10k_sm_mbx_connect_reset - Reset following request for reset
1660  *  @mbx: pointer to mailbox
1661  *
1662  *  This function resets the mailbox to a just connected state
1663  **/
1664 static void fm10k_sm_mbx_connect_reset(struct fm10k_mbx_info *mbx)
1665 {
1666         /* flush any uncompleted work */
1667         fm10k_mbx_reset_work(mbx);
1668
1669         /* set local version to max and remote version to 0 */
1670         mbx->local = FM10K_SM_MBX_VERSION;
1671         mbx->remote = 0;
1672
1673         /* initialize tail and head */
1674         mbx->tail = 1;
1675         mbx->head = 1;
1676
1677         /* reset state back to connect */
1678         mbx->state = FM10K_STATE_CONNECT;
1679 }
1680
1681 /**
1682  *  fm10k_sm_mbx_connect - Start switch manager mailbox connection
1683  *  @hw: pointer to hardware structure
1684  *  @mbx: pointer to mailbox
1685  *
1686  *  This function will initiate a mailbox connection with the switch
1687  *  manager.  To do this it will first disconnect the mailbox, and then
1688  *  reconnect it in order to complete a reset of the mailbox.
1689  *
1690  *  This function will return an error if the mailbox has not been initiated
1691  *  or is currently in use.
1692  **/
1693 static s32 fm10k_sm_mbx_connect(struct fm10k_hw *hw, struct fm10k_mbx_info *mbx)
1694 {
1695         /* we cannot connect an uninitialized mailbox */
1696         if (!mbx->rx.buffer)
1697                 return FM10K_MBX_ERR_NO_SPACE;
1698
1699         /* we cannot connect an already connected mailbox */
1700         if (mbx->state != FM10K_STATE_CLOSED)
1701                 return FM10K_MBX_ERR_BUSY;
1702
1703         /* mailbox timeout can now become active */
1704         mbx->timeout = FM10K_MBX_INIT_TIMEOUT;
1705
1706         /* Place mbx in ready to connect state */
1707         mbx->state = FM10K_STATE_CONNECT;
1708         mbx->max_size = FM10K_MBX_MSG_MAX_SIZE;
1709
1710         /* reset interface back to connect */
1711         fm10k_sm_mbx_connect_reset(mbx);
1712
1713         /* enable interrupt and notify other party of new message */
1714         mbx->mbx_lock = FM10K_MBX_REQ_INTERRUPT | FM10K_MBX_ACK_INTERRUPT |
1715                         FM10K_MBX_INTERRUPT_ENABLE;
1716
1717         /* generate and load connect header into mailbox */
1718         fm10k_sm_mbx_create_connect_hdr(mbx, 0);
1719         fm10k_mbx_write(hw, mbx);
1720
1721         return 0;
1722 }
1723
1724 /**
1725  *  fm10k_sm_mbx_disconnect - Shutdown mailbox connection
1726  *  @hw: pointer to hardware structure
1727  *  @mbx: pointer to mailbox
1728  *
1729  *  This function will shut down the mailbox.  It places the mailbox first
1730  *  in the disconnect state, it then allows up to a predefined timeout for
1731  *  the mailbox to transition to close on its own.  If this does not occur
1732  *  then the mailbox will be forced into the closed state.
1733  *
1734  *  Any mailbox transactions not completed before calling this function
1735  *  are not guaranteed to complete and may be dropped.
1736  **/
1737 static void fm10k_sm_mbx_disconnect(struct fm10k_hw *hw,
1738                                     struct fm10k_mbx_info *mbx)
1739 {
1740         int timeout = mbx->timeout ? FM10K_MBX_DISCONNECT_TIMEOUT : 0;
1741
1742         /* Place mbx in ready to disconnect state */
1743         mbx->state = FM10K_STATE_DISCONNECT;
1744
1745         /* trigger interrupt to start shutdown process */
1746         fm10k_write_reg(hw, mbx->mbx_reg, FM10K_MBX_REQ |
1747                                           FM10K_MBX_INTERRUPT_DISABLE);
1748         do {
1749                 udelay(FM10K_MBX_POLL_DELAY);
1750                 mbx->ops.process(hw, mbx);
1751                 timeout -= FM10K_MBX_POLL_DELAY;
1752         } while ((timeout > 0) && (mbx->state != FM10K_STATE_CLOSED));
1753
1754         /* in case we didn't close just force the mailbox into shutdown */
1755         mbx->state = FM10K_STATE_CLOSED;
1756         mbx->remote = 0;
1757         fm10k_mbx_reset_work(mbx);
1758         fm10k_fifo_drop_all(&mbx->tx);
1759
1760         fm10k_write_reg(hw, mbx->mbmem_reg, 0);
1761 }
1762
1763 /**
1764  *  fm10k_sm_mbx_validate_fifo_hdr - Validate fields in the remote FIFO header
1765  *  @mbx: pointer to mailbox
1766  *
1767  *  This function will parse up the fields in the mailbox header and return
1768  *  an error if the header contains any of a number of invalid configurations
1769  *  including unrecognized offsets or version numbers.
1770  **/
1771 static s32 fm10k_sm_mbx_validate_fifo_hdr(struct fm10k_mbx_info *mbx)
1772 {
1773         const u32 *hdr = &mbx->mbx_hdr;
1774         u16 tail, head, ver;
1775
1776         tail = FM10K_MSG_HDR_FIELD_GET(*hdr, SM_TAIL);
1777         ver = FM10K_MSG_HDR_FIELD_GET(*hdr, SM_VER);
1778         head = FM10K_MSG_HDR_FIELD_GET(*hdr, SM_HEAD);
1779
1780         switch (ver) {
1781         case 0:
1782                 break;
1783         case FM10K_SM_MBX_VERSION:
1784                 if (!head || head > FM10K_SM_MBX_FIFO_LEN)
1785                         return FM10K_MBX_ERR_HEAD;
1786                 if (!tail || tail > FM10K_SM_MBX_FIFO_LEN)
1787                         return FM10K_MBX_ERR_TAIL;
1788                 if (mbx->tail < head)
1789                         head += mbx->mbmem_len - 1;
1790                 if (tail < mbx->head)
1791                         tail += mbx->mbmem_len - 1;
1792                 if (fm10k_mbx_index_len(mbx, head, mbx->tail) > mbx->tail_len)
1793                         return FM10K_MBX_ERR_HEAD;
1794                 if (fm10k_mbx_index_len(mbx, mbx->head, tail) < mbx->mbmem_len)
1795                         break;
1796                 return FM10K_MBX_ERR_TAIL;
1797         default:
1798                 return FM10K_MBX_ERR_SRC;
1799         }
1800
1801         return 0;
1802 }
1803
1804 /**
1805  *  fm10k_sm_mbx_process_error - Process header with error flag set
1806  *  @mbx: pointer to mailbox
1807  *
1808  *  This function is meant to respond to a request where the error flag
1809  *  is set.  As a result we will terminate a connection if one is present
1810  *  and fall back into the reset state with a connection header of version
1811  *  0 (RESET).
1812  **/
1813 static void fm10k_sm_mbx_process_error(struct fm10k_mbx_info *mbx)
1814 {
1815         const enum fm10k_mbx_state state = mbx->state;
1816
1817         switch (state) {
1818         case FM10K_STATE_DISCONNECT:
1819                 /* if there is an error just disconnect */
1820                 mbx->remote = 0;
1821                 break;
1822         case FM10K_STATE_OPEN:
1823                 /* flush any uncompleted work */
1824                 fm10k_sm_mbx_connect_reset(mbx);
1825                 break;
1826         case FM10K_STATE_CONNECT:
1827                 /* try connnecting at lower version */
1828                 if (mbx->remote) {
1829                         while (mbx->local > 1)
1830                                 mbx->local--;
1831                         mbx->remote = 0;
1832                 }
1833                 break;
1834         default:
1835                 break;
1836         }
1837
1838         fm10k_sm_mbx_create_connect_hdr(mbx, 0);
1839 }
1840
1841 /**
1842  *  fm10k_sm_mbx_create_error_msg - Process an error in FIFO header
1843  *  @mbx: pointer to mailbox
1844  *  @err: local error encountered
1845  *
1846  *  This function will interpret the error provided by err, and based on
1847  *  that it may set the error bit in the local message header
1848  **/
1849 static void fm10k_sm_mbx_create_error_msg(struct fm10k_mbx_info *mbx, s32 err)
1850 {
1851         /* only generate an error message for these types */
1852         switch (err) {
1853         case FM10K_MBX_ERR_TAIL:
1854         case FM10K_MBX_ERR_HEAD:
1855         case FM10K_MBX_ERR_SRC:
1856         case FM10K_MBX_ERR_SIZE:
1857         case FM10K_MBX_ERR_RSVD0:
1858                 break;
1859         default:
1860                 return;
1861         }
1862
1863         /* process it as though we received an error, and send error reply */
1864         fm10k_sm_mbx_process_error(mbx);
1865         fm10k_sm_mbx_create_connect_hdr(mbx, 1);
1866 }
1867
1868 /**
1869  *  fm10k_sm_mbx_receive - Take message from Rx mailbox FIFO and put it in Rx
1870  *  @hw: pointer to hardware structure
1871  *  @mbx: pointer to mailbox
1872  *  @tail: tail index of message
1873  *
1874  *  This function will dequeue one message from the Rx switch manager mailbox
1875  *  FIFO and place it in the Rx mailbox FIFO for processing by software.
1876  **/
1877 static s32 fm10k_sm_mbx_receive(struct fm10k_hw *hw,
1878                                 struct fm10k_mbx_info *mbx,
1879                                 u16 tail)
1880 {
1881         /* reduce length by 1 to convert to a mask */
1882         u16 mbmem_len = mbx->mbmem_len - 1;
1883         s32 err;
1884
1885         /* push tail in front of head */
1886         if (tail < mbx->head)
1887                 tail += mbmem_len;
1888
1889         /* copy data to the Rx FIFO */
1890         err = fm10k_mbx_push_tail(hw, mbx, tail);
1891         if (err < 0)
1892                 return err;
1893
1894         /* process messages if we have received any */
1895         fm10k_mbx_dequeue_rx(hw, mbx);
1896
1897         /* guarantee head aligns with the end of the last message */
1898         mbx->head = fm10k_mbx_head_sub(mbx, mbx->pushed);
1899         mbx->pushed = 0;
1900
1901         /* clear any extra bits left over since index adds 1 extra bit */
1902         if (mbx->head > mbmem_len)
1903                 mbx->head -= mbmem_len;
1904
1905         return err;
1906 }
1907
1908 /**
1909  *  fm10k_sm_mbx_transmit - Take message from Tx and put it in Tx mailbox FIFO
1910  *  @hw: pointer to hardware structure
1911  *  @mbx: pointer to mailbox
1912  *  @head: head index of message
1913  *
1914  *  This function will dequeue one message from the Tx mailbox FIFO and place
1915  *  it in the Tx switch manager mailbox FIFO for processing by hardware.
1916  **/
1917 static void fm10k_sm_mbx_transmit(struct fm10k_hw *hw,
1918                                   struct fm10k_mbx_info *mbx, u16 head)
1919 {
1920         struct fm10k_mbx_fifo *fifo = &mbx->tx;
1921         /* reduce length by 1 to convert to a mask */
1922         u16 mbmem_len = mbx->mbmem_len - 1;
1923         u16 tail_len, len = 0;
1924
1925         /* push head behind tail */
1926         if (mbx->tail < head)
1927                 head += mbmem_len;
1928
1929         fm10k_mbx_pull_head(hw, mbx, head);
1930
1931         /* determine msg aligned offset for end of buffer */
1932         do {
1933                 u32 *msg;
1934
1935                 msg = fifo->buffer + fm10k_fifo_head_offset(fifo, len);
1936                 tail_len = len;
1937                 len += FM10K_TLV_DWORD_LEN(*msg);
1938         } while ((len <= mbx->tail_len) && (len < mbmem_len));
1939
1940         /* guarantee we stop on a message boundary */
1941         if (mbx->tail_len > tail_len) {
1942                 mbx->tail = fm10k_mbx_tail_sub(mbx, mbx->tail_len - tail_len);
1943                 mbx->tail_len = tail_len;
1944         }
1945
1946         /* clear any extra bits left over since index adds 1 extra bit */
1947         if (mbx->tail > mbmem_len)
1948                 mbx->tail -= mbmem_len;
1949 }
1950
1951 /**
1952  *  fm10k_sm_mbx_create_reply - Generate reply based on state and remote head
1953  *  @hw: pointer to hardware structure
1954  *  @mbx: pointer to mailbox
1955  *  @head: acknowledgement number
1956  *
1957  *  This function will generate an outgoing message based on the current
1958  *  mailbox state and the remote FIFO head.  It will return the length
1959  *  of the outgoing message excluding header on success, and a negative value
1960  *  on error.
1961  **/
1962 static void fm10k_sm_mbx_create_reply(struct fm10k_hw *hw,
1963                                       struct fm10k_mbx_info *mbx, u16 head)
1964 {
1965         switch (mbx->state) {
1966         case FM10K_STATE_OPEN:
1967         case FM10K_STATE_DISCONNECT:
1968                 /* flush out Tx data */
1969                 fm10k_sm_mbx_transmit(hw, mbx, head);
1970
1971                 /* generate new header based on data */
1972                 if (mbx->tail_len || (mbx->state == FM10K_STATE_OPEN)) {
1973                         fm10k_sm_mbx_create_data_hdr(mbx);
1974                 } else {
1975                         mbx->remote = 0;
1976                         fm10k_sm_mbx_create_connect_hdr(mbx, 0);
1977                 }
1978                 break;
1979         case FM10K_STATE_CONNECT:
1980         case FM10K_STATE_CLOSED:
1981                 fm10k_sm_mbx_create_connect_hdr(mbx, 0);
1982                 break;
1983         default:
1984                 break;
1985         }
1986 }
1987
1988 /**
1989  *  fm10k_sm_mbx_process_reset - Process header with version == 0 (RESET)
1990  *  @hw: pointer to hardware structure
1991  *  @mbx: pointer to mailbox
1992  *
1993  *  This function is meant to respond to a request where the version data
1994  *  is set to 0.  As such we will either terminate the connection or go
1995  *  into the connect state in order to re-establish the connection.  This
1996  *  function can also be used to respond to an error as the connection
1997  *  resetting would also be a means of dealing with errors.
1998  **/
1999 static s32 fm10k_sm_mbx_process_reset(struct fm10k_hw *hw,
2000                                       struct fm10k_mbx_info *mbx)
2001 {
2002         s32 err = 0;
2003         const enum fm10k_mbx_state state = mbx->state;
2004
2005         switch (state) {
2006         case FM10K_STATE_DISCONNECT:
2007                 /* drop remote connections and disconnect */
2008                 mbx->state = FM10K_STATE_CLOSED;
2009                 mbx->remote = 0;
2010                 mbx->local = 0;
2011                 break;
2012         case FM10K_STATE_OPEN:
2013                 /* flush any incomplete work */
2014                 fm10k_sm_mbx_connect_reset(mbx);
2015                 err = FM10K_ERR_RESET_REQUESTED;
2016                 break;
2017         case FM10K_STATE_CONNECT:
2018                 /* Update remote value to match local value */
2019                 mbx->remote = mbx->local;
2020         default:
2021                 break;
2022         }
2023
2024         fm10k_sm_mbx_create_reply(hw, mbx, mbx->tail);
2025
2026         return err;
2027 }
2028
2029 /**
2030  *  fm10k_sm_mbx_process_version_1 - Process header with version == 1
2031  *  @hw: pointer to hardware structure
2032  *  @mbx: pointer to mailbox
2033  *
2034  *  This function is meant to process messages received when the remote
2035  *  mailbox is active.
2036  **/
2037 static s32 fm10k_sm_mbx_process_version_1(struct fm10k_hw *hw,
2038                                           struct fm10k_mbx_info *mbx)
2039 {
2040         const u32 *hdr = &mbx->mbx_hdr;
2041         u16 head, tail;
2042         s32 len;
2043
2044         /* pull all fields needed for verification */
2045         tail = FM10K_MSG_HDR_FIELD_GET(*hdr, SM_TAIL);
2046         head = FM10K_MSG_HDR_FIELD_GET(*hdr, SM_HEAD);
2047
2048         /* if we are in connect and wanting version 1 then start up and go */
2049         if (mbx->state == FM10K_STATE_CONNECT) {
2050                 if (!mbx->remote)
2051                         goto send_reply;
2052                 if (mbx->remote != 1)
2053                         return FM10K_MBX_ERR_SRC;
2054
2055                 mbx->state = FM10K_STATE_OPEN;
2056         }
2057
2058         do {
2059                 /* abort on message size errors */
2060                 len = fm10k_sm_mbx_receive(hw, mbx, tail);
2061                 if (len < 0)
2062                         return len;
2063
2064                 /* continue until we have flushed the Rx FIFO */
2065         } while (len);
2066
2067 send_reply:
2068         fm10k_sm_mbx_create_reply(hw, mbx, head);
2069
2070         return 0;
2071 }
2072
2073 /**
2074  *  fm10k_sm_mbx_process - Process switch manager mailbox interrupt
2075  *  @hw: pointer to hardware structure
2076  *  @mbx: pointer to mailbox
2077  *
2078  *  This function will process incoming mailbox events and generate mailbox
2079  *  replies.  It will return a value indicating the number of DWORDs
2080  *  transmitted excluding header on success or a negative value on error.
2081  **/
2082 static s32 fm10k_sm_mbx_process(struct fm10k_hw *hw,
2083                                 struct fm10k_mbx_info *mbx)
2084 {
2085         s32 err;
2086
2087         /* we do not read mailbox if closed */
2088         if (mbx->state == FM10K_STATE_CLOSED)
2089                 return 0;
2090
2091         /* retrieve data from switch manager */
2092         err = fm10k_mbx_read(hw, mbx);
2093         if (err)
2094                 return err;
2095
2096         err = fm10k_sm_mbx_validate_fifo_hdr(mbx);
2097         if (err < 0)
2098                 goto fifo_err;
2099
2100         if (FM10K_MSG_HDR_FIELD_GET(mbx->mbx_hdr, SM_ERR)) {
2101                 fm10k_sm_mbx_process_error(mbx);
2102                 goto fifo_err;
2103         }
2104
2105         switch (FM10K_MSG_HDR_FIELD_GET(mbx->mbx_hdr, SM_VER)) {
2106         case 0:
2107                 err = fm10k_sm_mbx_process_reset(hw, mbx);
2108                 break;
2109         case FM10K_SM_MBX_VERSION:
2110                 err = fm10k_sm_mbx_process_version_1(hw, mbx);
2111                 break;
2112         }
2113
2114 fifo_err:
2115         if (err < 0)
2116                 fm10k_sm_mbx_create_error_msg(mbx, err);
2117
2118         /* report data to switch manager */
2119         fm10k_mbx_write(hw, mbx);
2120
2121         return err;
2122 }
2123
2124 /**
2125  *  fm10k_sm_mbx_init - Initialize mailbox memory for PF/SM mailbox
2126  *  @hw: pointer to hardware structure
2127  *  @mbx: pointer to mailbox
2128  *  @msg_data: handlers for mailbox events
2129  *
2130  *  This function initializes the PF/SM mailbox for use.  It will split the
2131  *  buffer provided and use that to populate both the Tx and Rx FIFO by
2132  *  evenly splitting it.  In order to allow for easy masking of head/tail
2133  *  the value reported in size must be a power of 2 and is reported in
2134  *  DWORDs, not bytes.  Any invalid values will cause the mailbox to return
2135  *  error.
2136  **/
2137 s32 fm10k_sm_mbx_init(struct fm10k_hw __always_unused *hw,
2138                       struct fm10k_mbx_info *mbx,
2139                       const struct fm10k_msg_data *msg_data)
2140 {
2141         mbx->mbx_reg = FM10K_GMBX;
2142         mbx->mbmem_reg = FM10K_MBMEM_PF(0);
2143
2144         /* start out in closed state */
2145         mbx->state = FM10K_STATE_CLOSED;
2146
2147         /* validate layout of handlers before assigning them */
2148         if (fm10k_mbx_validate_handlers(msg_data))
2149                 return FM10K_ERR_PARAM;
2150
2151         /* initialize the message handlers */
2152         mbx->msg_data = msg_data;
2153
2154         /* start mailbox as timed out and let the reset_hw call
2155          * set the timeout value to begin communications
2156          */
2157         mbx->timeout = 0;
2158         mbx->udelay = FM10K_MBX_INIT_DELAY;
2159
2160         /* Split buffer for use by Tx/Rx FIFOs */
2161         mbx->max_size = FM10K_MBX_MSG_MAX_SIZE;
2162         mbx->mbmem_len = FM10K_MBMEM_PF_XOR;
2163
2164         /* initialize the FIFOs, sizes are in 4 byte increments */
2165         fm10k_fifo_init(&mbx->tx, mbx->buffer, FM10K_MBX_TX_BUFFER_SIZE);
2166         fm10k_fifo_init(&mbx->rx, &mbx->buffer[FM10K_MBX_TX_BUFFER_SIZE],
2167                         FM10K_MBX_RX_BUFFER_SIZE);
2168
2169         /* initialize function pointers */
2170         mbx->ops.connect = fm10k_sm_mbx_connect;
2171         mbx->ops.disconnect = fm10k_sm_mbx_disconnect;
2172         mbx->ops.rx_ready = fm10k_mbx_rx_ready;
2173         mbx->ops.tx_ready = fm10k_mbx_tx_ready;
2174         mbx->ops.tx_complete = fm10k_mbx_tx_complete;
2175         mbx->ops.enqueue_tx = fm10k_mbx_enqueue_tx;
2176         mbx->ops.process = fm10k_sm_mbx_process;
2177         mbx->ops.register_handlers = fm10k_mbx_register_handlers;
2178
2179         return 0;
2180 }