1/* Intel Ethernet Switch Host Interface Driver
   2 * Copyright(c) 2013 - 2015 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}