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