fm10k/base: fix TLV structures alignment
[dpdk.git] / drivers / net / fm10k / base / fm10k_tlv.c
1 /*******************************************************************************
2
3 Copyright (c) 2013 - 2015, Intel Corporation
4 All rights reserved.
5
6 Redistribution and use in source and binary forms, with or without
7 modification, are permitted provided that the following conditions are met:
8
9  1. Redistributions of source code must retain the above copyright notice,
10     this list of conditions and the following disclaimer.
11
12  2. Redistributions in binary form must reproduce the above copyright
13     notice, this list of conditions and the following disclaimer in the
14     documentation and/or other materials provided with the distribution.
15
16  3. Neither the name of the Intel Corporation nor the names of its
17     contributors may be used to endorse or promote products derived from
18     this software without specific prior written permission.
19
20 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
21 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
24 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 POSSIBILITY OF SUCH DAMAGE.
31
32 ***************************************************************************/
33
34 #include "fm10k_tlv.h"
35
36 /**
37  *  fm10k_tlv_msg_init - Initialize message block for TLV data storage
38  *  @msg: Pointer to message block
39  *  @msg_id: Message ID indicating message type
40  *
41  *  This function return success if provided with a valid message pointer
42  **/
43 s32 fm10k_tlv_msg_init(u32 *msg, u16 msg_id)
44 {
45         DEBUGFUNC("fm10k_tlv_msg_init");
46
47         /* verify pointer is not NULL */
48         if (!msg)
49                 return FM10K_ERR_PARAM;
50
51         *msg = (FM10K_TLV_FLAGS_MSG << FM10K_TLV_FLAGS_SHIFT) | msg_id;
52
53         return FM10K_SUCCESS;
54 }
55
56 /**
57  *  fm10k_tlv_attr_put_null_string - Place null terminated string on message
58  *  @msg: Pointer to message block
59  *  @attr_id: Attribute ID
60  *  @string: Pointer to string to be stored in attribute
61  *
62  *  This function will reorder a string to be CPU endian and store it in
63  *  the attribute buffer.  It will return success if provided with a valid
64  *  pointers.
65  **/
66 static s32 fm10k_tlv_attr_put_null_string(u32 *msg, u16 attr_id,
67                                           const unsigned char *string)
68 {
69         u32 attr_data = 0, len = 0;
70         u32 *attr;
71
72         DEBUGFUNC("fm10k_tlv_attr_put_null_string");
73
74         /* verify pointers are not NULL */
75         if (!string || !msg)
76                 return FM10K_ERR_PARAM;
77
78         attr = &msg[FM10K_TLV_DWORD_LEN(*msg)];
79
80         /* copy string into local variable and then write to msg */
81         do {
82                 /* write data to message */
83                 if (len && !(len % 4)) {
84                         attr[len / 4] = attr_data;
85                         attr_data = 0;
86                 }
87
88                 /* record character to offset location */
89                 attr_data |= (u32)(*string) << (8 * (len % 4));
90                 len++;
91
92                 /* test for NULL and then increment */
93         } while (*(string++));
94
95         /* write last piece of data to message */
96         attr[(len + 3) / 4] = attr_data;
97
98         /* record attribute header, update message length */
99         len <<= FM10K_TLV_LEN_SHIFT;
100         attr[0] = len | attr_id;
101
102         /* add header length to length */
103         len += FM10K_TLV_HDR_LEN << FM10K_TLV_LEN_SHIFT;
104         *msg += FM10K_TLV_LEN_ALIGN(len);
105
106         return FM10K_SUCCESS;
107 }
108
109 /**
110  *  fm10k_tlv_attr_get_null_string - Get null terminated string from attribute
111  *  @attr: Pointer to attribute
112  *  @string: Pointer to location of destination string
113  *
114  *  This function pulls the string back out of the attribute and will place
115  *  it in the array pointed by by string.  It will return success if provided
116  *  with a valid pointers.
117  **/
118 static s32 fm10k_tlv_attr_get_null_string(u32 *attr, unsigned char *string)
119 {
120         u32 len;
121
122         DEBUGFUNC("fm10k_tlv_attr_get_null_string");
123
124         /* verify pointers are not NULL */
125         if (!string || !attr)
126                 return FM10K_ERR_PARAM;
127
128         len = *attr >> FM10K_TLV_LEN_SHIFT;
129         attr++;
130
131         while (len--)
132                 string[len] = (u8)(attr[len / 4] >> (8 * (len % 4)));
133
134         return FM10K_SUCCESS;
135 }
136
137 /**
138  *  fm10k_tlv_attr_put_mac_vlan - Store MAC/VLAN attribute in message
139  *  @msg: Pointer to message block
140  *  @attr_id: Attribute ID
141  *  @mac_addr: MAC address to be stored
142  *
143  *  This function will reorder a MAC address to be CPU endian and store it
144  *  in the attribute buffer.  It will return success if provided with a
145  *  valid pointers.
146  **/
147 s32 fm10k_tlv_attr_put_mac_vlan(u32 *msg, u16 attr_id,
148                                 const u8 *mac_addr, u16 vlan)
149 {
150         u32 len = ETH_ALEN << FM10K_TLV_LEN_SHIFT;
151         u32 *attr;
152
153         DEBUGFUNC("fm10k_tlv_attr_put_mac_vlan");
154
155         /* verify pointers are not NULL */
156         if (!msg || !mac_addr)
157                 return FM10K_ERR_PARAM;
158
159         attr = &msg[FM10K_TLV_DWORD_LEN(*msg)];
160
161         /* record attribute header, update message length */
162         attr[0] = len | attr_id;
163
164         /* copy value into local variable and then write to msg */
165         attr[1] = FM10K_LE32_TO_CPU(*(const __le32 *)&mac_addr[0]);
166         attr[2] = FM10K_LE16_TO_CPU(*(const __le16 *)&mac_addr[4]);
167         attr[2] |= (u32)vlan << 16;
168
169         /* add header length to length */
170         len += FM10K_TLV_HDR_LEN << FM10K_TLV_LEN_SHIFT;
171         *msg += FM10K_TLV_LEN_ALIGN(len);
172
173         return FM10K_SUCCESS;
174 }
175
176 /**
177  *  fm10k_tlv_attr_get_mac_vlan - Get MAC/VLAN stored in attribute
178  *  @attr: Pointer to attribute
179  *  @attr_id: Attribute ID
180  *  @mac_addr: location of buffer to store MAC address
181  *
182  *  This function pulls the MAC address back out of the attribute and will
183  *  place it in the array pointed by by mac_addr.  It will return success
184  *  if provided with a valid pointers.
185  **/
186 s32 fm10k_tlv_attr_get_mac_vlan(u32 *attr, u8 *mac_addr, u16 *vlan)
187 {
188         DEBUGFUNC("fm10k_tlv_attr_get_mac_vlan");
189
190         /* verify pointers are not NULL */
191         if (!mac_addr || !attr)
192                 return FM10K_ERR_PARAM;
193
194         *(__le32 *)&mac_addr[0] = FM10K_CPU_TO_LE32(attr[1]);
195         *(__le16 *)&mac_addr[4] = FM10K_CPU_TO_LE16((u16)(attr[2]));
196         *vlan = (u16)(attr[2] >> 16);
197
198         return FM10K_SUCCESS;
199 }
200
201 /**
202  *  fm10k_tlv_attr_put_bool - Add header indicating value "true"
203  *  @msg: Pointer to message block
204  *  @attr_id: Attribute ID
205  *
206  *  This function will simply add an attribute header, the fact
207  *  that the header is here means the attribute value is true, else
208  *  it is false.  The function will return success if provided with a
209  *  valid pointers.
210  **/
211 s32 fm10k_tlv_attr_put_bool(u32 *msg, u16 attr_id)
212 {
213         DEBUGFUNC("fm10k_tlv_attr_put_bool");
214
215         /* verify pointers are not NULL */
216         if (!msg)
217                 return FM10K_ERR_PARAM;
218
219         /* record attribute header */
220         msg[FM10K_TLV_DWORD_LEN(*msg)] = attr_id;
221
222         /* add header length to length */
223         *msg += FM10K_TLV_HDR_LEN << FM10K_TLV_LEN_SHIFT;
224
225         return FM10K_SUCCESS;
226 }
227
228 /**
229  *  fm10k_tlv_attr_put_value - Store integer value attribute in message
230  *  @msg: Pointer to message block
231  *  @attr_id: Attribute ID
232  *  @value: Value to be written
233  *  @len: Size of value
234  *
235  *  This function will place an integer value of up to 8 bytes in size
236  *  in a message attribute.  The function will return success provided
237  *  that msg is a valid pointer, and len is 1, 2, 4, or 8.
238  **/
239 s32 fm10k_tlv_attr_put_value(u32 *msg, u16 attr_id, s64 value, u32 len)
240 {
241         u32 *attr;
242
243         DEBUGFUNC("fm10k_tlv_attr_put_value");
244
245         /* verify non-null msg and len is 1, 2, 4, or 8 */
246         if (!msg || !len || len > 8 || (len & (len - 1)))
247                 return FM10K_ERR_PARAM;
248
249         attr = &msg[FM10K_TLV_DWORD_LEN(*msg)];
250
251         if (len < 4) {
252                 attr[1] = (u32)value & (BIT(8 * len) - 1);
253         } else {
254                 attr[1] = (u32)value;
255                 if (len > 4)
256                         attr[2] = (u32)(value >> 32);
257         }
258
259         /* record attribute header, update message length */
260         len <<= FM10K_TLV_LEN_SHIFT;
261         attr[0] = len | attr_id;
262
263         /* add header length to length */
264         len += FM10K_TLV_HDR_LEN << FM10K_TLV_LEN_SHIFT;
265         *msg += FM10K_TLV_LEN_ALIGN(len);
266
267         return FM10K_SUCCESS;
268 }
269
270 /**
271  *  fm10k_tlv_attr_get_value - Get integer value stored in attribute
272  *  @attr: Pointer to attribute
273  *  @value: Pointer to destination buffer
274  *  @len: Size of value
275  *
276  *  This function will place an integer value of up to 8 bytes in size
277  *  in the offset pointed to by value.  The function will return success
278  *  provided that pointers are valid and the len value matches the
279  *  attribute length.
280  **/
281 s32 fm10k_tlv_attr_get_value(u32 *attr, void *value, u32 len)
282 {
283         DEBUGFUNC("fm10k_tlv_attr_get_value");
284
285         /* verify pointers are not NULL */
286         if (!attr || !value)
287                 return FM10K_ERR_PARAM;
288
289         if ((*attr >> FM10K_TLV_LEN_SHIFT) != len)
290                 return FM10K_ERR_PARAM;
291
292         if (len == 8)
293                 *(u64 *)value = ((u64)attr[2] << 32) | attr[1];
294         else if (len == 4)
295                 *(u32 *)value = attr[1];
296         else if (len == 2)
297                 *(u16 *)value = (u16)attr[1];
298         else
299                 *(u8 *)value = (u8)attr[1];
300
301         return FM10K_SUCCESS;
302 }
303
304 /**
305  *  fm10k_tlv_attr_put_le_struct - Store little endian structure in message
306  *  @msg: Pointer to message block
307  *  @attr_id: Attribute ID
308  *  @le_struct: Pointer to structure to be written
309  *  @len: Size of le_struct
310  *
311  *  This function will place a little endian structure value in a message
312  *  attribute.  The function will return success provided that all pointers
313  *  are valid and length is a non-zero multiple of 4.
314  **/
315 s32 fm10k_tlv_attr_put_le_struct(u32 *msg, u16 attr_id,
316                                  const void *le_struct, u32 len)
317 {
318         const __le32 *le32_ptr = (const __le32 *)le_struct;
319         u32 *attr;
320         u32 i;
321
322         DEBUGFUNC("fm10k_tlv_attr_put_le_struct");
323
324         /* verify non-null msg and len is in 32 bit words */
325         if (!msg || !len || (len % 4))
326                 return FM10K_ERR_PARAM;
327
328         attr = &msg[FM10K_TLV_DWORD_LEN(*msg)];
329
330         /* copy le32 structure into host byte order at 32b boundaries */
331         for (i = 0; i < (len / 4); i++)
332                 attr[i + 1] = FM10K_LE32_TO_CPU(le32_ptr[i]);
333
334         /* record attribute header, update message length */
335         len <<= FM10K_TLV_LEN_SHIFT;
336         attr[0] = len | attr_id;
337
338         /* add header length to length */
339         len += FM10K_TLV_HDR_LEN << FM10K_TLV_LEN_SHIFT;
340         *msg += FM10K_TLV_LEN_ALIGN(len);
341
342         return FM10K_SUCCESS;
343 }
344
345 /**
346  *  fm10k_tlv_attr_get_le_struct - Get little endian struct form attribute
347  *  @attr: Pointer to attribute
348  *  @le_struct: Pointer to structure to be written
349  *  @len: Size of structure
350  *
351  *  This function will place a little endian structure in the buffer
352  *  pointed to by le_struct.  The function will return success
353  *  provided that pointers are valid and the len value matches the
354  *  attribute length.
355  **/
356 s32 fm10k_tlv_attr_get_le_struct(u32 *attr, void *le_struct, u32 len)
357 {
358         __le32 *le32_ptr = (__le32 *)le_struct;
359         u32 i;
360
361         DEBUGFUNC("fm10k_tlv_attr_get_le_struct");
362
363         /* verify pointers are not NULL */
364         if (!le_struct || !attr)
365                 return FM10K_ERR_PARAM;
366
367         if ((*attr >> FM10K_TLV_LEN_SHIFT) != len)
368                 return FM10K_ERR_PARAM;
369
370         attr++;
371
372         for (i = 0; len; i++, len -= 4)
373                 le32_ptr[i] = FM10K_CPU_TO_LE32(attr[i]);
374
375         return FM10K_SUCCESS;
376 }
377
378 /**
379  *  fm10k_tlv_attr_nest_start - Start a set of nested attributes
380  *  @msg: Pointer to message block
381  *  @attr_id: Attribute ID
382  *
383  *  This function will mark off a new nested region for encapsulating
384  *  a given set of attributes.  The idea is if you wish to place a secondary
385  *  structure within the message this mechanism allows for that.  The
386  *  function will return NULL on failure, and a pointer to the start
387  *  of the nested attributes on success.
388  **/
389 static u32 *fm10k_tlv_attr_nest_start(u32 *msg, u16 attr_id)
390 {
391         u32 *attr;
392
393         DEBUGFUNC("fm10k_tlv_attr_nest_start");
394
395         /* verify pointer is not NULL */
396         if (!msg)
397                 return NULL;
398
399         attr = &msg[FM10K_TLV_DWORD_LEN(*msg)];
400
401         attr[0] = attr_id;
402
403         /* return pointer to nest header */
404         return attr;
405 }
406
407 /**
408  *  fm10k_tlv_attr_nest_stop - Stop a set of nested attributes
409  *  @msg: Pointer to message block
410  *
411  *  This function closes off an existing set of nested attributes.  The
412  *  message pointer should be pointing to the parent of the nest.  So in
413  *  the case of a nest within the nest this would be the outer nest pointer.
414  *  This function will return success provided all pointers are valid.
415  **/
416 static s32 fm10k_tlv_attr_nest_stop(u32 *msg)
417 {
418         u32 *attr;
419         u32 len;
420
421         DEBUGFUNC("fm10k_tlv_attr_nest_stop");
422
423         /* verify pointer is not NULL */
424         if (!msg)
425                 return FM10K_ERR_PARAM;
426
427         /* locate the nested header and retrieve its length */
428         attr = &msg[FM10K_TLV_DWORD_LEN(*msg)];
429         len = (attr[0] >> FM10K_TLV_LEN_SHIFT) << FM10K_TLV_LEN_SHIFT;
430
431         /* only include nest if data was added to it */
432         if (len) {
433                 len += FM10K_TLV_HDR_LEN << FM10K_TLV_LEN_SHIFT;
434                 *msg += len;
435         }
436
437         return FM10K_SUCCESS;
438 }
439
440 /**
441  *  fm10k_tlv_attr_validate - Validate attribute metadata
442  *  @attr: Pointer to attribute
443  *  @tlv_attr: Type and length info for attribute
444  *
445  *  This function does some basic validation of the input TLV.  It
446  *  verifies the length, and in the case of null terminated strings
447  *  it verifies that the last byte is null.  The function will
448  *  return FM10K_ERR_PARAM if any attribute is malformed, otherwise
449  *  it returns 0.
450  **/
451 STATIC s32 fm10k_tlv_attr_validate(u32 *attr,
452                                    const struct fm10k_tlv_attr *tlv_attr)
453 {
454         u32 attr_id = *attr & FM10K_TLV_ID_MASK;
455         u16 len = *attr >> FM10K_TLV_LEN_SHIFT;
456
457         DEBUGFUNC("fm10k_tlv_attr_validate");
458
459         /* verify this is an attribute and not a message */
460         if (*attr & (FM10K_TLV_FLAGS_MSG << FM10K_TLV_FLAGS_SHIFT))
461                 return FM10K_ERR_PARAM;
462
463         /* search through the list of attributes to find a matching ID */
464         while (tlv_attr->id < attr_id)
465                 tlv_attr++;
466
467         /* if didn't find a match then we should exit */
468         if (tlv_attr->id != attr_id)
469                 return FM10K_NOT_IMPLEMENTED;
470
471         /* move to start of attribute data */
472         attr++;
473
474         switch (tlv_attr->type) {
475         case FM10K_TLV_NULL_STRING:
476                 if (!len ||
477                     (attr[(len - 1) / 4] & (0xFF << (8 * ((len - 1) % 4)))))
478                         return FM10K_ERR_PARAM;
479                 if (len > tlv_attr->len)
480                         return FM10K_ERR_PARAM;
481                 break;
482         case FM10K_TLV_MAC_ADDR:
483                 if (len != ETH_ALEN)
484                         return FM10K_ERR_PARAM;
485                 break;
486         case FM10K_TLV_BOOL:
487                 if (len)
488                         return FM10K_ERR_PARAM;
489                 break;
490         case FM10K_TLV_UNSIGNED:
491         case FM10K_TLV_SIGNED:
492                 if (len != tlv_attr->len)
493                         return FM10K_ERR_PARAM;
494                 break;
495         case FM10K_TLV_LE_STRUCT:
496                 /* struct must be 4 byte aligned */
497                 if ((len % 4) || len != tlv_attr->len)
498                         return FM10K_ERR_PARAM;
499                 break;
500         case FM10K_TLV_NESTED:
501                 /* nested attributes must be 4 byte aligned */
502                 if (len % 4)
503                         return FM10K_ERR_PARAM;
504                 break;
505         default:
506                 /* attribute id is mapped to bad value */
507                 return FM10K_ERR_PARAM;
508         }
509
510         return FM10K_SUCCESS;
511 }
512
513 /**
514  *  fm10k_tlv_attr_parse - Parses stream of attribute data
515  *  @attr: Pointer to attribute list
516  *  @results: Pointer array to store pointers to attributes
517  *  @tlv_attr: Type and length info for attributes
518  *
519  *  This function validates a stream of attributes and parses them
520  *  up into an array of pointers stored in results.  The function will
521  *  return FM10K_ERR_PARAM on any input or message error,
522  *  FM10K_NOT_IMPLEMENTED for any attribute that is outside of the array
523  *  and 0 on success.
524  **/
525 static s32 fm10k_tlv_attr_parse(u32 *attr, u32 **results,
526                                 const struct fm10k_tlv_attr *tlv_attr)
527 {
528         u32 i, attr_id, offset = 0;
529         s32 err = 0;
530         u16 len;
531
532         DEBUGFUNC("fm10k_tlv_attr_parse");
533
534         /* verify pointers are not NULL */
535         if (!attr || !results)
536                 return FM10K_ERR_PARAM;
537
538         /* initialize results to NULL */
539         for (i = 0; i < FM10K_TLV_RESULTS_MAX; i++)
540                 results[i] = NULL;
541
542         /* pull length from the message header */
543         len = *attr >> FM10K_TLV_LEN_SHIFT;
544
545         /* no attributes to parse if there is no length */
546         if (!len)
547                 return FM10K_SUCCESS;
548
549         /* no attributes to parse, just raw data, message becomes attribute */
550         if (!tlv_attr) {
551                 results[0] = attr;
552                 return FM10K_SUCCESS;
553         }
554
555         /* move to start of attribute data */
556         attr++;
557
558         /* run through list parsing all attributes */
559         while (offset < len) {
560                 attr_id = *attr & FM10K_TLV_ID_MASK;
561
562                 if (attr_id < FM10K_TLV_RESULTS_MAX)
563                         err = fm10k_tlv_attr_validate(attr, tlv_attr);
564                 else
565                         err = FM10K_NOT_IMPLEMENTED;
566
567                 if (err < 0)
568                         return err;
569                 if (!err)
570                         results[attr_id] = attr;
571
572                 /* update offset */
573                 offset += FM10K_TLV_DWORD_LEN(*attr) * 4;
574
575                 /* move to next attribute */
576                 attr = &attr[FM10K_TLV_DWORD_LEN(*attr)];
577         }
578
579         /* we should find ourselves at the end of the list */
580         if (offset != len)
581                 return FM10K_ERR_PARAM;
582
583         return FM10K_SUCCESS;
584 }
585
586 /**
587  *  fm10k_tlv_msg_parse - Parses message header and calls function handler
588  *  @hw: Pointer to hardware structure
589  *  @msg: Pointer to message
590  *  @mbx: Pointer to mailbox information structure
591  *  @func: Function array containing list of message handling functions
592  *
593  *  This function should be the first function called upon receiving a
594  *  message.  The handler will identify the message type and call the correct
595  *  handler for the given message.  It will return the value from the function
596  *  call on a recognized message type, otherwise it will return
597  *  FM10K_NOT_IMPLEMENTED on an unrecognized type.
598  **/
599 s32 fm10k_tlv_msg_parse(struct fm10k_hw *hw, u32 *msg,
600                         struct fm10k_mbx_info *mbx,
601                         const struct fm10k_msg_data *data)
602 {
603         u32 *results[FM10K_TLV_RESULTS_MAX];
604         u32 msg_id;
605         s32 err;
606
607         DEBUGFUNC("fm10k_tlv_msg_parse");
608
609         /* verify pointer is not NULL */
610         if (!msg || !data)
611                 return FM10K_ERR_PARAM;
612
613         /* verify this is a message and not an attribute */
614         if (!(*msg & (FM10K_TLV_FLAGS_MSG << FM10K_TLV_FLAGS_SHIFT)))
615                 return FM10K_ERR_PARAM;
616
617         /* grab message ID */
618         msg_id = *msg & FM10K_TLV_ID_MASK;
619
620         while (data->id < msg_id)
621                 data++;
622
623         /* if we didn't find it then pass it up as an error */
624         if (data->id != msg_id) {
625                 while (data->id != FM10K_TLV_ERROR)
626                         data++;
627         }
628
629         /* parse the attributes into the results list */
630         err = fm10k_tlv_attr_parse(msg, results, data->attr);
631         if (err < 0)
632                 return err;
633
634         return data->func(hw, results, mbx);
635 }
636
637 /**
638  *  fm10k_tlv_msg_error - Default handler for unrecognized TLV message IDs
639  *  @hw: Pointer to hardware structure
640  *  @results: Pointer array to message, results[0] is pointer to message
641  *  @mbx: Unused mailbox pointer
642  *
643  *  This function is a default handler for unrecognized messages.  At a
644  *  a minimum it just indicates that the message requested was
645  *  unimplemented.
646  **/
647 s32 fm10k_tlv_msg_error(struct fm10k_hw *hw, u32 **results,
648                         struct fm10k_mbx_info *mbx)
649 {
650         UNREFERENCED_3PARAMETER(hw, results, mbx);
651         DEBUGOUT1("Unknown message ID %u\n", **results & FM10K_TLV_ID_MASK);
652         return FM10K_NOT_IMPLEMENTED;
653 }
654
655 STATIC const unsigned char test_str[] = "fm10k";
656 STATIC const unsigned char test_mac[ETH_ALEN] = { 0x12, 0x34, 0x56,
657                                                   0x78, 0x9a, 0xbc };
658 STATIC const u16 test_vlan = 0x0FED;
659 STATIC const u64 test_u64 = 0xfedcba9876543210ull;
660 STATIC const u32 test_u32 = 0x87654321;
661 STATIC const u16 test_u16 = 0x8765;
662 STATIC const u8  test_u8  = 0x87;
663 STATIC const s64 test_s64 = -0x123456789abcdef0ll;
664 STATIC const s32 test_s32 = -0x1235678;
665 STATIC const s16 test_s16 = -0x1234;
666 STATIC const s8  test_s8  = -0x12;
667 STATIC const __le32 test_le[2] = { FM10K_CPU_TO_LE32(0x12345678),
668                                    FM10K_CPU_TO_LE32(0x9abcdef0)};
669
670 /* The message below is meant to be used as a test message to demonstrate
671  * how to use the TLV interface and to test the types.  Normally this code
672  * be compiled out by stripping the code wrapped in FM10K_TLV_TEST_MSG
673  */
674 const struct fm10k_tlv_attr fm10k_tlv_msg_test_attr[] = {
675         FM10K_TLV_ATTR_NULL_STRING(FM10K_TEST_MSG_STRING, 80),
676         FM10K_TLV_ATTR_MAC_ADDR(FM10K_TEST_MSG_MAC_ADDR),
677         FM10K_TLV_ATTR_U8(FM10K_TEST_MSG_U8),
678         FM10K_TLV_ATTR_U16(FM10K_TEST_MSG_U16),
679         FM10K_TLV_ATTR_U32(FM10K_TEST_MSG_U32),
680         FM10K_TLV_ATTR_U64(FM10K_TEST_MSG_U64),
681         FM10K_TLV_ATTR_S8(FM10K_TEST_MSG_S8),
682         FM10K_TLV_ATTR_S16(FM10K_TEST_MSG_S16),
683         FM10K_TLV_ATTR_S32(FM10K_TEST_MSG_S32),
684         FM10K_TLV_ATTR_S64(FM10K_TEST_MSG_S64),
685         FM10K_TLV_ATTR_LE_STRUCT(FM10K_TEST_MSG_LE_STRUCT, 8),
686         FM10K_TLV_ATTR_NESTED(FM10K_TEST_MSG_NESTED),
687         FM10K_TLV_ATTR_S32(FM10K_TEST_MSG_RESULT),
688         FM10K_TLV_ATTR_LAST
689 };
690
691 /**
692  *  fm10k_tlv_msg_test_generate_data - Stuff message with data
693  *  @msg: Pointer to message
694  *  @attr_flags: List of flags indicating what attributes to add
695  *
696  *  This function is meant to load a message buffer with attribute data
697  **/
698 STATIC void fm10k_tlv_msg_test_generate_data(u32 *msg, u32 attr_flags)
699 {
700         DEBUGFUNC("fm10k_tlv_msg_test_generate_data");
701
702         if (attr_flags & BIT(FM10K_TEST_MSG_STRING))
703                 fm10k_tlv_attr_put_null_string(msg, FM10K_TEST_MSG_STRING,
704                                                test_str);
705         if (attr_flags & BIT(FM10K_TEST_MSG_MAC_ADDR))
706                 fm10k_tlv_attr_put_mac_vlan(msg, FM10K_TEST_MSG_MAC_ADDR,
707                                             test_mac, test_vlan);
708         if (attr_flags & BIT(FM10K_TEST_MSG_U8))
709                 fm10k_tlv_attr_put_u8(msg, FM10K_TEST_MSG_U8,  test_u8);
710         if (attr_flags & BIT(FM10K_TEST_MSG_U16))
711                 fm10k_tlv_attr_put_u16(msg, FM10K_TEST_MSG_U16, test_u16);
712         if (attr_flags & BIT(FM10K_TEST_MSG_U32))
713                 fm10k_tlv_attr_put_u32(msg, FM10K_TEST_MSG_U32, test_u32);
714         if (attr_flags & BIT(FM10K_TEST_MSG_U64))
715                 fm10k_tlv_attr_put_u64(msg, FM10K_TEST_MSG_U64, test_u64);
716         if (attr_flags & BIT(FM10K_TEST_MSG_S8))
717                 fm10k_tlv_attr_put_s8(msg, FM10K_TEST_MSG_S8,  test_s8);
718         if (attr_flags & BIT(FM10K_TEST_MSG_S16))
719                 fm10k_tlv_attr_put_s16(msg, FM10K_TEST_MSG_S16, test_s16);
720         if (attr_flags & BIT(FM10K_TEST_MSG_S32))
721                 fm10k_tlv_attr_put_s32(msg, FM10K_TEST_MSG_S32, test_s32);
722         if (attr_flags & BIT(FM10K_TEST_MSG_S64))
723                 fm10k_tlv_attr_put_s64(msg, FM10K_TEST_MSG_S64, test_s64);
724         if (attr_flags & BIT(FM10K_TEST_MSG_LE_STRUCT))
725                 fm10k_tlv_attr_put_le_struct(msg, FM10K_TEST_MSG_LE_STRUCT,
726                                              test_le, 8);
727 }
728
729 /**
730  *  fm10k_tlv_msg_test_create - Create a test message testing all attributes
731  *  @msg: Pointer to message
732  *  @attr_flags: List of flags indicating what attributes to add
733  *
734  *  This function is meant to load a message buffer with all attribute types
735  *  including a nested attribute.
736  **/
737 void fm10k_tlv_msg_test_create(u32 *msg, u32 attr_flags)
738 {
739         u32 *nest = NULL;
740
741         DEBUGFUNC("fm10k_tlv_msg_test_create");
742
743         fm10k_tlv_msg_init(msg, FM10K_TLV_MSG_ID_TEST);
744
745         fm10k_tlv_msg_test_generate_data(msg, attr_flags);
746
747         /* check for nested attributes */
748         attr_flags >>= FM10K_TEST_MSG_NESTED;
749
750         if (attr_flags) {
751                 nest = fm10k_tlv_attr_nest_start(msg, FM10K_TEST_MSG_NESTED);
752
753                 fm10k_tlv_msg_test_generate_data(nest, attr_flags);
754
755                 fm10k_tlv_attr_nest_stop(msg);
756         }
757 }
758
759 /**
760  *  fm10k_tlv_msg_test - Validate all results on test message receive
761  *  @hw: Pointer to hardware structure
762  *  @results: Pointer array to attributes in the message
763  *  @mbx: Pointer to mailbox information structure
764  *
765  *  This function does a check to verify all attributes match what the test
766  *  message placed in the message buffer.  It is the default handler
767  *  for TLV test messages.
768  **/
769 s32 fm10k_tlv_msg_test(struct fm10k_hw *hw, u32 **results,
770                        struct fm10k_mbx_info *mbx)
771 {
772         u32 *nest_results[FM10K_TLV_RESULTS_MAX];
773         unsigned char result_str[80];
774         unsigned char result_mac[ETH_ALEN];
775         s32 err = FM10K_SUCCESS;
776         __le32 result_le[2];
777         u16 result_vlan;
778         u64 result_u64;
779         u32 result_u32;
780         u16 result_u16;
781         u8  result_u8;
782         s64 result_s64;
783         s32 result_s32;
784         s16 result_s16;
785         s8  result_s8;
786         u32 reply[3];
787
788         DEBUGFUNC("fm10k_tlv_msg_test");
789
790         /* retrieve results of a previous test */
791         if (!!results[FM10K_TEST_MSG_RESULT])
792                 return fm10k_tlv_attr_get_s32(results[FM10K_TEST_MSG_RESULT],
793                                               &mbx->test_result);
794
795 parse_nested:
796         if (!!results[FM10K_TEST_MSG_STRING]) {
797                 err = fm10k_tlv_attr_get_null_string(
798                                         results[FM10K_TEST_MSG_STRING],
799                                         result_str);
800                 if (!err && memcmp(test_str, result_str, sizeof(test_str)))
801                         err = FM10K_ERR_INVALID_VALUE;
802                 if (err)
803                         goto report_result;
804         }
805         if (!!results[FM10K_TEST_MSG_MAC_ADDR]) {
806                 err = fm10k_tlv_attr_get_mac_vlan(
807                                         results[FM10K_TEST_MSG_MAC_ADDR],
808                                         result_mac, &result_vlan);
809                 if (!err && memcmp(test_mac, result_mac, ETH_ALEN))
810                         err = FM10K_ERR_INVALID_VALUE;
811                 if (!err && test_vlan != result_vlan)
812                         err = FM10K_ERR_INVALID_VALUE;
813                 if (err)
814                         goto report_result;
815         }
816         if (!!results[FM10K_TEST_MSG_U8]) {
817                 err = fm10k_tlv_attr_get_u8(results[FM10K_TEST_MSG_U8],
818                                             &result_u8);
819                 if (!err && test_u8 != result_u8)
820                         err = FM10K_ERR_INVALID_VALUE;
821                 if (err)
822                         goto report_result;
823         }
824         if (!!results[FM10K_TEST_MSG_U16]) {
825                 err = fm10k_tlv_attr_get_u16(results[FM10K_TEST_MSG_U16],
826                                              &result_u16);
827                 if (!err && test_u16 != result_u16)
828                         err = FM10K_ERR_INVALID_VALUE;
829                 if (err)
830                         goto report_result;
831         }
832         if (!!results[FM10K_TEST_MSG_U32]) {
833                 err = fm10k_tlv_attr_get_u32(results[FM10K_TEST_MSG_U32],
834                                              &result_u32);
835                 if (!err && test_u32 != result_u32)
836                         err = FM10K_ERR_INVALID_VALUE;
837                 if (err)
838                         goto report_result;
839         }
840         if (!!results[FM10K_TEST_MSG_U64]) {
841                 err = fm10k_tlv_attr_get_u64(results[FM10K_TEST_MSG_U64],
842                                              &result_u64);
843                 if (!err && test_u64 != result_u64)
844                         err = FM10K_ERR_INVALID_VALUE;
845                 if (err)
846                         goto report_result;
847         }
848         if (!!results[FM10K_TEST_MSG_S8]) {
849                 err = fm10k_tlv_attr_get_s8(results[FM10K_TEST_MSG_S8],
850                                             &result_s8);
851                 if (!err && test_s8 != result_s8)
852                         err = FM10K_ERR_INVALID_VALUE;
853                 if (err)
854                         goto report_result;
855         }
856         if (!!results[FM10K_TEST_MSG_S16]) {
857                 err = fm10k_tlv_attr_get_s16(results[FM10K_TEST_MSG_S16],
858                                              &result_s16);
859                 if (!err && test_s16 != result_s16)
860                         err = FM10K_ERR_INVALID_VALUE;
861                 if (err)
862                         goto report_result;
863         }
864         if (!!results[FM10K_TEST_MSG_S32]) {
865                 err = fm10k_tlv_attr_get_s32(results[FM10K_TEST_MSG_S32],
866                                              &result_s32);
867                 if (!err && test_s32 != result_s32)
868                         err = FM10K_ERR_INVALID_VALUE;
869                 if (err)
870                         goto report_result;
871         }
872         if (!!results[FM10K_TEST_MSG_S64]) {
873                 err = fm10k_tlv_attr_get_s64(results[FM10K_TEST_MSG_S64],
874                                              &result_s64);
875                 if (!err && test_s64 != result_s64)
876                         err = FM10K_ERR_INVALID_VALUE;
877                 if (err)
878                         goto report_result;
879         }
880         if (!!results[FM10K_TEST_MSG_LE_STRUCT]) {
881                 err = fm10k_tlv_attr_get_le_struct(
882                                         results[FM10K_TEST_MSG_LE_STRUCT],
883                                         result_le,
884                                         sizeof(result_le));
885                 if (!err && memcmp(test_le, result_le, sizeof(test_le)))
886                         err = FM10K_ERR_INVALID_VALUE;
887                 if (err)
888                         goto report_result;
889         }
890
891         if (!!results[FM10K_TEST_MSG_NESTED]) {
892                 /* clear any pointers */
893                 memset(nest_results, 0, sizeof(nest_results));
894
895                 /* parse the nested attributes into the nest results list */
896                 err = fm10k_tlv_attr_parse(results[FM10K_TEST_MSG_NESTED],
897                                            nest_results,
898                                            fm10k_tlv_msg_test_attr);
899                 if (err)
900                         goto report_result;
901
902                 /* loop back through to the start */
903                 results = nest_results;
904                 goto parse_nested;
905         }
906
907 report_result:
908         /* generate reply with test result */
909         fm10k_tlv_msg_init(reply, FM10K_TLV_MSG_ID_TEST);
910         fm10k_tlv_attr_put_s32(reply, FM10K_TEST_MSG_RESULT, err);
911
912         /* load onto outgoing mailbox */
913         return mbx->ops.enqueue_tx(hw, mbx, reply);
914 }