Author: arybchik
Date: Sat Nov 24 15:24:47 2018
New Revision: 340880
URL: https://svnweb.freebsd.org/changeset/base/340880

Log:
  sfxge(4): fix coding style
  
  Submitted by:   Andy Moreton <amoreton at solarflare.com>
  Sponsored by:   Solarflare Communications, Inc.
  Differential Revision:  https://reviews.freebsd.org/D18115

Modified:
  head/sys/dev/sfxge/common/ef10_filter.c
  head/sys/dev/sfxge/common/ef10_impl.h
  head/sys/dev/sfxge/common/efx.h
  head/sys/dev/sfxge/common/efx_impl.h
  head/sys/dev/sfxge/common/efx_lic.c
  head/sys/dev/sfxge/common/efx_mcdi.h
  head/sys/dev/sfxge/common/efx_nic.c
  head/sys/dev/sfxge/common/efx_types.h
  head/sys/dev/sfxge/common/medford_nic.c

Modified: head/sys/dev/sfxge/common/ef10_filter.c
==============================================================================
--- head/sys/dev/sfxge/common/ef10_filter.c     Sat Nov 24 15:24:35 2018        
(r340879)
+++ head/sys/dev/sfxge/common/ef10_filter.c     Sat Nov 24 15:24:47 2018        
(r340880)
@@ -1246,8 +1246,8 @@ typedef struct ef10_filter_encap_entry_s {
        uint32_t                inner_frame_match;
 } ef10_filter_encap_entry_t;
 
-#define EF10_ENCAP_FILTER_ENTRY(ipv, encap_type, inner_frame_match)    \
-       { EFX_ETHER_TYPE_##ipv, EFX_TUNNEL_PROTOCOL_##encap_type,               
\
+#define        EF10_ENCAP_FILTER_ENTRY(ipv, encap_type, inner_frame_match)     
\
+       { EFX_ETHER_TYPE_##ipv, EFX_TUNNEL_PROTOCOL_##encap_type,       \
            EFX_FILTER_INNER_FRAME_MATCH_UNKNOWN_##inner_frame_match }
 
 static ef10_filter_encap_entry_t ef10_filter_encap_list[] = {
@@ -1308,8 +1308,8 @@ ef10_filter_insert_encap_filters(
                 */
                if ((mulcst == B_FALSE) &&
                    (encap_filter->inner_frame_match ==
-                    EFX_FILTER_INNER_FRAME_MATCH_UNKNOWN_MCAST_DST))
-                               continue;
+                   EFX_FILTER_INNER_FRAME_MATCH_UNKNOWN_MCAST_DST))
+                       continue;
 
                efx_filter_spec_init_rx(&spec, EFX_FILTER_PRI_AUTO,
                                        filter_flags,

Modified: head/sys/dev/sfxge/common/ef10_impl.h
==============================================================================
--- head/sys/dev/sfxge/common/ef10_impl.h       Sat Nov 24 15:24:35 2018        
(r340879)
+++ head/sys/dev/sfxge/common/ef10_impl.h       Sat Nov 24 15:24:47 2018        
(r340880)
@@ -52,8 +52,9 @@ extern "C" {
  */
 #define        EF10_NVRAM_CHUNK 0x80
 
-/* Alignment requirement for value written to RX WPTR:
- *  the WPTR must be aligned to an 8 descriptor boundary
+/*
+ * Alignment requirement for value written to RX WPTR: the WPTR must be aligned
+ * to an 8 descriptor boundary.
  */
 #define        EF10_RX_WPTR_ALIGN 8
 
@@ -507,8 +508,7 @@ ef10_nvram_buffer_find_item_start(
        __in_bcount(buffer_size)
                                caddr_t bufferp,
        __in                    size_t buffer_size,
-       __out                   uint32_t *startp
-       );
+       __out                   uint32_t *startp);
 
 extern __checkReturn           efx_rc_t
 ef10_nvram_buffer_find_end(
@@ -516,8 +516,7 @@ ef10_nvram_buffer_find_end(
                                caddr_t bufferp,
        __in                    size_t buffer_size,
        __in                    uint32_t offset,
-       __out                   uint32_t *endp
-       );
+       __out                   uint32_t *endp);
 
 extern __checkReturn   __success(return != B_FALSE)    boolean_t
 ef10_nvram_buffer_find_item(
@@ -526,8 +525,7 @@ ef10_nvram_buffer_find_item(
        __in                    size_t buffer_size,
        __in                    uint32_t offset,
        __out                   uint32_t *startp,
-       __out                   uint32_t *lengthp
-       );
+       __out                   uint32_t *lengthp);
 
 extern __checkReturn           efx_rc_t
 ef10_nvram_buffer_get_item(
@@ -539,8 +537,7 @@ ef10_nvram_buffer_get_item(
        __out_bcount_part(item_max_size, *lengthp)
                                caddr_t itemp,
        __in                    size_t item_max_size,
-       __out                   uint32_t *lengthp
-       );
+       __out                   uint32_t *lengthp);
 
 extern __checkReturn           efx_rc_t
 ef10_nvram_buffer_insert_item(
@@ -550,8 +547,7 @@ ef10_nvram_buffer_insert_item(
        __in                    uint32_t offset,
        __in_bcount(length)     caddr_t keyp,
        __in                    uint32_t length,
-       __out                   uint32_t *lengthp
-       );
+       __out                   uint32_t *lengthp);
 
 extern __checkReturn           efx_rc_t
 ef10_nvram_buffer_delete_item(
@@ -560,15 +556,13 @@ ef10_nvram_buffer_delete_item(
        __in                    size_t buffer_size,
        __in                    uint32_t offset,
        __in                    uint32_t length,
-       __in                    uint32_t end
-       );
+       __in                    uint32_t end);
 
 extern __checkReturn           efx_rc_t
 ef10_nvram_buffer_finish(
        __in_bcount(buffer_size)
                                caddr_t bufferp,
-       __in                    size_t buffer_size
-       );
+       __in                    size_t buffer_size);
 
 #endif /* EFSYS_OPT_NVRAM */
 
@@ -797,7 +791,7 @@ ef10_tx_qstats_update(
 
 typedef uint32_t       efx_piobuf_handle_t;
 
-#define        EFX_PIOBUF_HANDLE_INVALID       ((efx_piobuf_handle_t) -1)
+#define        EFX_PIOBUF_HANDLE_INVALID       ((efx_piobuf_handle_t)-1)
 
 extern __checkReturn   efx_rc_t
 ef10_nic_pio_alloc(
@@ -1036,7 +1030,7 @@ typedef struct ef10_filter_entry_s {
  * IPv4 or IPv6 outer frame, VXLAN, GENEVE or NVGRE packet type, and unicast or
  * multicast inner frames.
  */
-#define EFX_EF10_FILTER_ENCAP_FILTERS_MAX      12
+#define        EFX_EF10_FILTER_ENCAP_FILTERS_MAX       12
 
 typedef struct ef10_filter_table_s {
        ef10_filter_entry_t     eft_entry[EFX_EF10_FILTER_TBL_ROWS];
@@ -1203,9 +1197,9 @@ ef10_external_port_mapping(
 /* Minimum space for packet in packed stream mode */
 #define        EFX_RX_PACKED_STREAM_MIN_PACKET_SPACE                \
        P2ROUNDUP(EFX_RX_PACKED_STREAM_RX_PREFIX_SIZE +      \
-                 EFX_MAC_PDU_MIN +                          \
-                 EFX_RX_PACKED_STREAM_ALIGNMENT,            \
-                 EFX_RX_PACKED_STREAM_ALIGNMENT)
+           EFX_MAC_PDU_MIN +                                \
+           EFX_RX_PACKED_STREAM_ALIGNMENT,                  \
+           EFX_RX_PACKED_STREAM_ALIGNMENT)
 
 /* Maximum number of credits */
 #define        EFX_RX_PACKED_STREAM_MAX_CREDITS 127

Modified: head/sys/dev/sfxge/common/efx.h
==============================================================================
--- head/sys/dev/sfxge/common/efx.h     Sat Nov 24 15:24:35 2018        
(r340879)
+++ head/sys/dev/sfxge/common/efx.h     Sat Nov 24 15:24:47 2018        
(r340880)
@@ -44,13 +44,13 @@ extern "C" {
 #endif
 
 #define        EFX_STATIC_ASSERT(_cond)                \
-       ((void)sizeof(char[(_cond) ? 1 : -1]))
+       ((void)sizeof (char[(_cond) ? 1 : -1]))
 
 #define        EFX_ARRAY_SIZE(_array)                  \
-       (sizeof(_array) / sizeof((_array)[0]))
+       (sizeof (_array) / sizeof ((_array)[0]))
 
 #define        EFX_FIELD_OFFSET(_type, _field)         \
-       ((size_t) &(((_type *)0)->_field))
+       ((size_t)&(((_type *)0)->_field))
 
 /* The macro expands divider twice */
 #define        EFX_DIV_ROUND_UP(_n, _d)                (((_n) + (_d) - 1) / 
(_d))
@@ -562,7 +562,7 @@ efx_mac_stats_get_mask(
 
 #define        EFX_MAC_STAT_SUPPORTED(_mask, _stat)    \
        ((_mask)[(_stat) / EFX_MAC_STATS_MASK_BITS_PER_PAGE] &  \
-        (1ULL << ((_stat) & (EFX_MAC_STATS_MASK_BITS_PER_PAGE - 1))))
+           (1ULL << ((_stat) & (EFX_MAC_STATS_MASK_BITS_PER_PAGE - 1))))
 
 #define        EFX_MAC_STATS_SIZE 0x400
 
@@ -912,7 +912,8 @@ typedef enum efx_phy_media_type_e {
        EFX_PHY_MEDIA_NTYPES
 } efx_phy_media_type_t;
 
-/* Get the type of medium currently used.  If the board has ports for
+/*
+ * Get the type of medium currently used.  If the board has ports for
  * modules, a module is present, and we recognise the media type of
  * the module, then this will be the media type of the module.
  * Otherwise it will be the media type of the port.
@@ -1013,7 +1014,7 @@ typedef enum efx_bist_type_e {
        EFX_BIST_TYPE_PHY_CABLE_SHORT,
        EFX_BIST_TYPE_PHY_CABLE_LONG,
        EFX_BIST_TYPE_MC_MEM,   /* Test the MC DMEM and IMEM */
-       EFX_BIST_TYPE_SAT_MEM,  /* Test the DMEM and IMEM of satellite cpus*/
+       EFX_BIST_TYPE_SAT_MEM,  /* Test the DMEM and IMEM of satellite cpus */
        EFX_BIST_TYPE_REG,      /* Test the register memories */
        EFX_BIST_TYPE_NTYPES,
 } efx_bist_type_t;
@@ -1044,8 +1045,10 @@ typedef enum efx_bist_value_e {
        EFX_BIST_PHY_CABLE_STATUS_C,
        EFX_BIST_PHY_CABLE_STATUS_D,
        EFX_BIST_FAULT_CODE,
-       /* Memory BIST specific values. These match to the MC_CMD_BIST_POLL
-        * response. */
+       /*
+        * Memory BIST specific values. These match to the MC_CMD_BIST_POLL
+        * response.
+        */
        EFX_BIST_MEM_TEST,
        EFX_BIST_MEM_ADDR,
        EFX_BIST_MEM_BUS,
@@ -1797,8 +1800,7 @@ typedef __checkReturn     boolean_t
 typedef __checkReturn  boolean_t
 (*efx_mac_stats_ev_t)(
        __in_opt        void *arg,
-       __in            uint32_t generation
-       );
+       __in            uint32_t generation);
 
 #endif /* EFSYS_OPT_MAC_STATS */
 
@@ -2514,8 +2516,7 @@ efx_lic_find_start(
        __in_bcount(buffer_size)
                                caddr_t bufferp,
        __in                    size_t buffer_size,
-       __out                   uint32_t *startp
-       );
+       __out                   uint32_t *startp);
 
 extern __checkReturn           efx_rc_t
 efx_lic_find_end(
@@ -2524,8 +2525,7 @@ efx_lic_find_end(
                                caddr_t bufferp,
        __in                    size_t buffer_size,
        __in                    uint32_t offset,
-       __out                   uint32_t *endp
-       );
+       __out                   uint32_t *endp);
 
 extern __checkReturn   __success(return != B_FALSE)    boolean_t
 efx_lic_find_key(
@@ -2535,15 +2535,13 @@ efx_lic_find_key(
        __in                    size_t buffer_size,
        __in                    uint32_t offset,
        __out                   uint32_t *startp,
-       __out                   uint32_t *lengthp
-       );
+       __out                   uint32_t *lengthp);
 
 extern __checkReturn   __success(return != B_FALSE)    boolean_t
 efx_lic_validate_key(
        __in                    efx_nic_t *enp,
        __in_bcount(length)     caddr_t keyp,
-       __in                    uint32_t length
-       );
+       __in                    uint32_t length);
 
 extern __checkReturn           efx_rc_t
 efx_lic_read_key(
@@ -2556,8 +2554,7 @@ efx_lic_read_key(
        __out_bcount_part(key_max_size, *lengthp)
                                caddr_t keyp,
        __in                    size_t key_max_size,
-       __out                   uint32_t *lengthp
-       );
+       __out                   uint32_t *lengthp);
 
 extern __checkReturn           efx_rc_t
 efx_lic_write_key(
@@ -2568,8 +2565,7 @@ efx_lic_write_key(
        __in                    uint32_t offset,
        __in_bcount(length)     caddr_t keyp,
        __in                    uint32_t length,
-       __out                   uint32_t *lengthp
-       );
+       __out                   uint32_t *lengthp);
 
        __checkReturn           efx_rc_t
 efx_lic_delete_key(
@@ -2580,24 +2576,21 @@ efx_lic_delete_key(
        __in                    uint32_t offset,
        __in                    uint32_t length,
        __in                    uint32_t end,
-       __out                   uint32_t *deltap
-       );
+       __out                   uint32_t *deltap);
 
 extern __checkReturn           efx_rc_t
 efx_lic_create_partition(
        __in                    efx_nic_t *enp,
        __in_bcount(buffer_size)
                                caddr_t bufferp,
-       __in                    size_t buffer_size
-       );
+       __in                    size_t buffer_size);
 
 extern __checkReturn           efx_rc_t
 efx_lic_finish_partition(
        __in                    efx_nic_t *enp,
        __in_bcount(buffer_size)
                                caddr_t bufferp,
-       __in                    size_t buffer_size
-       );
+       __in                    size_t buffer_size);
 
 #endif /* EFSYS_OPT_LICENSING */
 

Modified: head/sys/dev/sfxge/common/efx_impl.h
==============================================================================
--- head/sys/dev/sfxge/common/efx_impl.h        Sat Nov 24 15:24:35 2018        
(r340879)
+++ head/sys/dev/sfxge/common/efx_impl.h        Sat Nov 24 15:24:47 2018        
(r340880)
@@ -1035,8 +1035,7 @@ struct efx_txq_s {
        do {                                                            \
                EFX_CHECK_REG((_enp), (_reg));                          \
                EFSYS_PROBE7(efx_bar_tbl_doorbell_writeo,               \
-                   const char *,                                       \
-                   #_reg,                                              \
+                   const char *, #_reg,                                \
                    uint32_t, (_index),                                 \
                    uint32_t, _reg ## _OFST,                            \
                    uint32_t, (_eop)->eo_u32[3],                        \

Modified: head/sys/dev/sfxge/common/efx_lic.c
==============================================================================
--- head/sys/dev/sfxge/common/efx_lic.c Sat Nov 24 15:24:35 2018        
(r340879)
+++ head/sys/dev/sfxge/common/efx_lic.c Sat Nov 24 15:24:47 2018        
(r340880)
@@ -46,8 +46,7 @@ efx_lic_v1v2_find_start(
        __in_bcount(buffer_size)
                                caddr_t bufferp,
        __in                    size_t buffer_size,
-       __out                   uint32_t *startp
-       );
+       __out                   uint32_t *startp);
 
        __checkReturn           efx_rc_t
 efx_lic_v1v2_find_end(
@@ -56,8 +55,7 @@ efx_lic_v1v2_find_end(
                                caddr_t bufferp,
        __in                    size_t buffer_size,
        __in                    uint32_t offset,
-       __out                   uint32_t *endp
-       );
+       __out                   uint32_t *endp);
 
        __checkReturn   __success(return != B_FALSE)    boolean_t
 efx_lic_v1v2_find_key(
@@ -67,15 +65,13 @@ efx_lic_v1v2_find_key(
        __in                    size_t buffer_size,
        __in                    uint32_t offset,
        __out                   uint32_t *startp,
-       __out                   uint32_t *lengthp
-       );
+       __out                   uint32_t *lengthp);
 
        __checkReturn   __success(return != B_FALSE)    boolean_t
 efx_lic_v1v2_validate_key(
        __in                    efx_nic_t *enp,
        __in_bcount(length)     caddr_t keyp,
-       __in                    uint32_t length
-       );
+       __in                    uint32_t length);
 
        __checkReturn           efx_rc_t
 efx_lic_v1v2_read_key(
@@ -88,8 +84,7 @@ efx_lic_v1v2_read_key(
        __out_bcount_part(key_max_size, *lengthp)
                                caddr_t keyp,
        __in                    size_t key_max_size,
-       __out                   uint32_t *lengthp
-       );
+       __out                   uint32_t *lengthp);
 
        __checkReturn           efx_rc_t
 efx_lic_v1v2_write_key(
@@ -100,8 +95,7 @@ efx_lic_v1v2_write_key(
        __in                    uint32_t offset,
        __in_bcount(length)     caddr_t keyp,
        __in                    uint32_t length,
-       __out                   uint32_t *lengthp
-       );
+       __out                   uint32_t *lengthp);
 
        __checkReturn           efx_rc_t
 efx_lic_v1v2_delete_key(
@@ -112,24 +106,21 @@ efx_lic_v1v2_delete_key(
        __in                    uint32_t offset,
        __in                    uint32_t length,
        __in                    uint32_t end,
-       __out                   uint32_t *deltap
-       );
+       __out                   uint32_t *deltap);
 
        __checkReturn           efx_rc_t
 efx_lic_v1v2_create_partition(
        __in                    efx_nic_t *enp,
        __in_bcount(buffer_size)
                                caddr_t bufferp,
-       __in                    size_t buffer_size
-       );
+       __in                    size_t buffer_size);
 
        __checkReturn           efx_rc_t
 efx_lic_v1v2_finish_partition(
        __in                    efx_nic_t *enp,
        __in_bcount(buffer_size)
                                caddr_t bufferp,
-       __in                    size_t buffer_size
-       );
+       __in                    size_t buffer_size);
 
 #endif /* EFSYS_OPT_HUNTINGTON | EFSYS_OPT_SIENA */
 
@@ -230,8 +221,7 @@ efx_lic_v3_find_start(
        __in_bcount(buffer_size)
                                caddr_t bufferp,
        __in                    size_t buffer_size,
-       __out                   uint32_t *startp
-       );
+       __out                   uint32_t *startp);
 
        __checkReturn           efx_rc_t
 efx_lic_v3_find_end(
@@ -240,8 +230,7 @@ efx_lic_v3_find_end(
                                caddr_t bufferp,
        __in                    size_t buffer_size,
        __in                    uint32_t offset,
-       __out                   uint32_t *endp
-       );
+       __out                   uint32_t *endp);
 
        __checkReturn   __success(return != B_FALSE)    boolean_t
 efx_lic_v3_find_key(
@@ -251,15 +240,13 @@ efx_lic_v3_find_key(
        __in                    size_t buffer_size,
        __in                    uint32_t offset,
        __out                   uint32_t *startp,
-       __out                   uint32_t *lengthp
-       );
+       __out                   uint32_t *lengthp);
 
        __checkReturn   __success(return != B_FALSE)    boolean_t
 efx_lic_v3_validate_key(
        __in                    efx_nic_t *enp,
        __in_bcount(length)     caddr_t keyp,
-       __in                    uint32_t length
-       );
+       __in                    uint32_t length);
 
        __checkReturn           efx_rc_t
 efx_lic_v3_read_key(
@@ -272,8 +259,7 @@ efx_lic_v3_read_key(
        __out_bcount_part(key_max_size, *lengthp)
                                caddr_t keyp,
        __in                    size_t key_max_size,
-       __out                   uint32_t *lengthp
-       );
+       __out                   uint32_t *lengthp);
 
        __checkReturn           efx_rc_t
 efx_lic_v3_write_key(
@@ -284,8 +270,7 @@ efx_lic_v3_write_key(
        __in                    uint32_t offset,
        __in_bcount(length)     caddr_t keyp,
        __in                    uint32_t length,
-       __out                   uint32_t *lengthp
-       );
+       __out                   uint32_t *lengthp);
 
        __checkReturn           efx_rc_t
 efx_lic_v3_delete_key(
@@ -296,31 +281,28 @@ efx_lic_v3_delete_key(
        __in                    uint32_t offset,
        __in                    uint32_t length,
        __in                    uint32_t end,
-       __out                   uint32_t *deltap
-       );
+       __out                   uint32_t *deltap);
 
        __checkReturn           efx_rc_t
 efx_lic_v3_create_partition(
        __in                    efx_nic_t *enp,
        __in_bcount(buffer_size)
                                caddr_t bufferp,
-       __in                    size_t buffer_size
-       );
+       __in                    size_t buffer_size);
 
        __checkReturn           efx_rc_t
 efx_lic_v3_finish_partition(
        __in                    efx_nic_t *enp,
        __in_bcount(buffer_size)
                                caddr_t bufferp,
-       __in                    size_t buffer_size
-       );
+       __in                    size_t buffer_size);
 
 static const efx_lic_ops_t     __efx_lic_v3_ops = {
        efx_mcdi_licensing_v3_update_licenses,  /* elo_update_licenses */
        efx_mcdi_licensing_v3_report_license,   /* elo_get_key_stats */
        efx_mcdi_licensing_v3_app_state,        /* elo_app_state */
        efx_mcdi_licensing_v3_get_id,           /* elo_get_id */
-       efx_lic_v3_find_start,                  /* elo_find_start*/
+       efx_lic_v3_find_start,                  /* elo_find_start */
        efx_lic_v3_find_end,                    /* elo_find_end */
        efx_lic_v3_find_key,                    /* elo_find_key */
        efx_lic_v3_validate_key,                /* elo_validate_key */
@@ -455,8 +437,8 @@ fail1:
  *  Length (L): 16bit - value length in bytes
  *  Value (V):  L bytes - payload
  */
-#define EFX_LICENSE_V1V2_PAYLOAD_LENGTH_MAX    (256)
-#define EFX_LICENSE_V1V2_HEADER_LENGTH         (2 * sizeof(uint16_t))
+#define        EFX_LICENSE_V1V2_PAYLOAD_LENGTH_MAX     (256)
+#define        EFX_LICENSE_V1V2_HEADER_LENGTH          (2 * sizeof (uint16_t))
 
        __checkReturn           efx_rc_t
 efx_lic_v1v2_find_start(
@@ -464,8 +446,7 @@ efx_lic_v1v2_find_start(
        __in_bcount(buffer_size)
                                caddr_t bufferp,
        __in                    size_t buffer_size,
-       __out                   uint32_t *startp
-       )
+       __out                   uint32_t *startp)
 {
        _NOTE(ARGUNUSED(enp, bufferp, buffer_size))
 
@@ -480,8 +461,7 @@ efx_lic_v1v2_find_end(
                                caddr_t bufferp,
        __in                    size_t buffer_size,
        __in                    uint32_t offset,
-       __out                   uint32_t *endp
-       )
+       __out                   uint32_t *endp)
 {
        _NOTE(ARGUNUSED(enp, bufferp, buffer_size))
 
@@ -497,8 +477,7 @@ efx_lic_v1v2_find_key(
        __in                    size_t buffer_size,
        __in                    uint32_t offset,
        __out                   uint32_t *startp,
-       __out                   uint32_t *lengthp
-       )
+       __out                   uint32_t *lengthp)
 {
        boolean_t found;
        uint16_t tlv_type;
@@ -531,8 +510,7 @@ fail1:
 efx_lic_v1v2_validate_key(
        __in                    efx_nic_t *enp,
        __in_bcount(length)     caddr_t keyp,
-       __in                    uint32_t length
-       )
+       __in                    uint32_t length)
 {
        uint16_t tlv_type;
        uint16_t tlv_length;
@@ -582,8 +560,7 @@ efx_lic_v1v2_read_key(
        __out_bcount_part(key_max_size, *lengthp)
                                caddr_t keyp,
        __in                    size_t key_max_size,
-       __out                   uint32_t *lengthp
-       )
+       __out                   uint32_t *lengthp)
 {
        efx_rc_t rc;
 
@@ -616,8 +593,7 @@ efx_lic_v1v2_write_key(
        __in                    uint32_t offset,
        __in_bcount(length)     caddr_t keyp,
        __in                    uint32_t length,
-       __out                   uint32_t *lengthp
-       )
+       __out                   uint32_t *lengthp)
 {
        efx_rc_t rc;
 
@@ -653,8 +629,7 @@ efx_lic_v1v2_delete_key(
        __in                    uint32_t offset,
        __in                    uint32_t length,
        __in                    uint32_t end,
-       __out                   uint32_t *deltap
-       )
+       __out                   uint32_t *deltap)
 {
        uint32_t move_start = offset + length;
        uint32_t move_length = end - move_start;
@@ -675,8 +650,7 @@ efx_lic_v1v2_create_partition(
        __in                    efx_nic_t *enp,
        __in_bcount(buffer_size)
                                caddr_t bufferp,
-       __in                    size_t buffer_size
-       )
+       __in                    size_t buffer_size)
 {
        _NOTE(ARGUNUSED(enp))
        EFSYS_ASSERT(EFX_LICENSE_V1V2_HEADER_LENGTH <= buffer_size);
@@ -692,8 +666,7 @@ efx_lic_v1v2_finish_partition(
        __in                    efx_nic_t *enp,
        __in_bcount(buffer_size)
                                caddr_t bufferp,
-       __in                    size_t buffer_size
-       )
+       __in                    size_t buffer_size)
 {
        _NOTE(ARGUNUSED(enp, bufferp, buffer_size))
 
@@ -1005,7 +978,8 @@ efx_mcdi_licensing_v3_app_state(
                goto fail1;
        }
 
-       if (req.emr_out_length_used < MC_CMD_GET_LICENSED_V3_APP_STATE_OUT_LEN) 
{
+       if (req.emr_out_length_used <
+           MC_CMD_GET_LICENSED_V3_APP_STATE_OUT_LEN) {
                rc = EMSGSIZE;
                goto fail2;
        }
@@ -1055,7 +1029,8 @@ efx_mcdi_licensing_v3_get_id(
                req.emr_in_buf = bufferp;
                req.emr_in_length = MC_CMD_LICENSING_GET_ID_V3_IN_LEN;
                req.emr_out_buf = bufferp;
-               req.emr_out_length = MIN(buffer_size, 
MC_CMD_LICENSING_GET_ID_V3_OUT_LENMAX);
+               req.emr_out_length =
+                   MIN(buffer_size, MC_CMD_LICENSING_GET_ID_V3_OUT_LENMAX);
                (void) memset(bufferp, 0, req.emr_out_length);
        }
 
@@ -1072,12 +1047,14 @@ efx_mcdi_licensing_v3_get_id(
        }
 
        *typep = MCDI_OUT_DWORD(req, LICENSING_GET_ID_V3_OUT_LICENSE_TYPE);
-       *lengthp = MCDI_OUT_DWORD(req, 
LICENSING_GET_ID_V3_OUT_LICENSE_ID_LENGTH);
+       *lengthp =
+           MCDI_OUT_DWORD(req, LICENSING_GET_ID_V3_OUT_LICENSE_ID_LENGTH);
 
        if (bufferp == NULL) {
-               /* modify length requirements to indicate to caller the extra 
buffering
-               ** needed to read the complete output.
-               */
+               /*
+                * Modify length requirements to indicate to caller the extra
+                * buffering needed to read the complete output.
+                */
                *lengthp += MC_CMD_LICENSING_GET_ID_V3_OUT_LENMIN;
        } else {
                /* Shift ID down to start of buffer */
@@ -1099,8 +1076,8 @@ fail1:
 }
 
 /* V3 format uses Huntington TLV format partition. See SF-108797-SW */
-#define EFX_LICENSE_V3_KEY_LENGTH_MIN    (64)
-#define EFX_LICENSE_V3_KEY_LENGTH_MAX    (160)
+#define        EFX_LICENSE_V3_KEY_LENGTH_MIN   (64)
+#define        EFX_LICENSE_V3_KEY_LENGTH_MAX   (160)
 
        __checkReturn           efx_rc_t
 efx_lic_v3_find_start(
@@ -1108,12 +1085,12 @@ efx_lic_v3_find_start(
        __in_bcount(buffer_size)
                                caddr_t bufferp,
        __in                    size_t buffer_size,
-       __out                   uint32_t *startp
-       )
+       __out                   uint32_t *startp)
 {
        _NOTE(ARGUNUSED(enp))
 
-       return ef10_nvram_buffer_find_item_start(bufferp, buffer_size, startp);
+       return (ef10_nvram_buffer_find_item_start(bufferp, buffer_size,
+           startp));
 }
 
        __checkReturn           efx_rc_t
@@ -1123,12 +1100,11 @@ efx_lic_v3_find_end(
                                caddr_t bufferp,
        __in                    size_t buffer_size,
        __in                    uint32_t offset,
-       __out                   uint32_t *endp
-       )
+       __out                   uint32_t *endp)
 {
        _NOTE(ARGUNUSED(enp))
 
-       return ef10_nvram_buffer_find_end(bufferp, buffer_size, offset, endp);
+       return (ef10_nvram_buffer_find_end(bufferp, buffer_size, offset, endp));
 }
 
        __checkReturn   __success(return != B_FALSE)    boolean_t
@@ -1139,8 +1115,7 @@ efx_lic_v3_find_key(
        __in                    size_t buffer_size,
        __in                    uint32_t offset,
        __out                   uint32_t *startp,
-       __out                   uint32_t *lengthp
-       )
+       __out                   uint32_t *lengthp)
 {
        _NOTE(ARGUNUSED(enp))
 
@@ -1152,8 +1127,7 @@ efx_lic_v3_find_key(
 efx_lic_v3_validate_key(
        __in                    efx_nic_t *enp,
        __in_bcount(length)     caddr_t keyp,
-       __in                    uint32_t length
-       )
+       __in                    uint32_t length)
 {
        /* Check key is a valid V3 key */
        uint8_t key_type;
@@ -1203,8 +1177,7 @@ efx_lic_v3_read_key(
        __out_bcount_part(key_max_size, *lengthp)
                                caddr_t keyp,
        __in                    size_t key_max_size,
-       __out                   uint32_t *lengthp
-       )
+       __out                   uint32_t *lengthp)
 {
        _NOTE(ARGUNUSED(enp))
 
@@ -1221,8 +1194,7 @@ efx_lic_v3_write_key(
        __in                    uint32_t offset,
        __in_bcount(length)     caddr_t keyp,
        __in                    uint32_t length,
-       __out                   uint32_t *lengthp
-       )
+       __out                   uint32_t *lengthp)
 {
        _NOTE(ARGUNUSED(enp))
        EFSYS_ASSERT(length <= EFX_LICENSE_V3_KEY_LENGTH_MAX);
@@ -1240,8 +1212,7 @@ efx_lic_v3_delete_key(
        __in                    uint32_t offset,
        __in                    uint32_t length,
        __in                    uint32_t end,
-       __out                   uint32_t *deltap
-       )
+       __out                   uint32_t *deltap)
 {
        efx_rc_t rc;
 
@@ -1267,8 +1238,7 @@ efx_lic_v3_create_partition(
        __in                    efx_nic_t *enp,
        __in_bcount(buffer_size)
                                caddr_t bufferp,
-       __in                    size_t buffer_size
-       )
+       __in                    size_t buffer_size)
 {
        efx_rc_t rc;
 
@@ -1293,8 +1263,7 @@ efx_lic_v3_finish_partition(
        __in                    efx_nic_t *enp,
        __in_bcount(buffer_size)
                                caddr_t bufferp,
-       __in                    size_t buffer_size
-       )
+       __in                    size_t buffer_size)
 {
        efx_rc_t rc;
 
@@ -1386,7 +1355,7 @@ efx_lic_check_support(
        EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_PROBE);
        EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_LIC);
 
-       return enp->en_licensing_supported;
+       return (enp->en_licensing_supported);
 }
 
                                void
@@ -1477,8 +1446,7 @@ efx_lic_get_id(
        __in            size_t buffer_size,
        __out           uint32_t *typep,
        __out           size_t *lengthp,
-       __out_opt       uint8_t *bufferp
-       )
+       __out_opt       uint8_t *bufferp)
 {
        const efx_lic_ops_t *elop = enp->en_elop;
        efx_rc_t rc;
@@ -1501,7 +1469,10 @@ fail1:
        return (rc);
 }
 
-/* Buffer management API - abstracts varying TLV format used for License 
partition */
+/*
+ * Buffer management API - abstracts varying TLV format used for License
+ * partition.
+ */
 
        __checkReturn           efx_rc_t
 efx_lic_find_start(
@@ -1509,8 +1480,7 @@ efx_lic_find_start(
        __in_bcount(buffer_size)
                                caddr_t bufferp,
        __in                    size_t buffer_size,
-       __out                   uint32_t *startp
-       )
+       __out                   uint32_t *startp)
 {
        const efx_lic_ops_t *elop = enp->en_elop;
        efx_rc_t rc;
@@ -1536,8 +1506,7 @@ efx_lic_find_end(
                                caddr_t bufferp,
        __in                    size_t buffer_size,
        __in                    uint32_t offset,
-       __out                   uint32_t *endp
-       )
+       __out                   uint32_t *endp)
 {
        const efx_lic_ops_t *elop = enp->en_elop;
        efx_rc_t rc;
@@ -1545,7 +1514,8 @@ efx_lic_find_end(
        EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
        EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_LIC);
 
-       if ((rc = elop->elo_find_end(enp, bufferp, buffer_size, offset, endp)) 
!= 0)
+       rc = elop->elo_find_end(enp, bufferp, buffer_size, offset, endp);
+       if (rc != 0)
                goto fail1;
 
        return (0);
@@ -1564,8 +1534,7 @@ efx_lic_find_key(
        __in                    size_t buffer_size,
        __in                    uint32_t offset,
        __out                   uint32_t *startp,
-       __out                   uint32_t *lengthp
-       )
+       __out                   uint32_t *lengthp)
 {
        const efx_lic_ops_t *elop = enp->en_elop;
 
@@ -1581,15 +1550,15 @@ efx_lic_find_key(
 }
 
 
-/* Validate that the buffer contains a single key in a recognised format.
-** An empty or terminator buffer is not accepted as a valid key.
-*/
+/*
+ * Validate that the buffer contains a single key in a recognised format.
+ * An empty or terminator buffer is not accepted as a valid key.
+ */
        __checkReturn   __success(return != B_FALSE)    boolean_t
 efx_lic_validate_key(
        __in                    efx_nic_t *enp,
        __in_bcount(length)     caddr_t keyp,
-       __in                    uint32_t length
-       )
+       __in                    uint32_t length)
 {
        const efx_lic_ops_t *elop = enp->en_elop;
        boolean_t rc;
@@ -1619,8 +1588,7 @@ efx_lic_read_key(
        __out_bcount_part(key_max_size, *lengthp)
                                caddr_t keyp,
        __in                    size_t key_max_size,
-       __out                   uint32_t *lengthp
-       )
+       __out                   uint32_t *lengthp)
 {
        const efx_lic_ops_t *elop = enp->en_elop;
        efx_rc_t rc;
@@ -1649,8 +1617,7 @@ efx_lic_write_key(
        __in                    uint32_t offset,
        __in_bcount(length)     caddr_t keyp,
        __in                    uint32_t length,
-       __out                   uint32_t *lengthp
-       )
+       __out                   uint32_t *lengthp)
 {
        const efx_lic_ops_t *elop = enp->en_elop;
        efx_rc_t rc;
@@ -1679,8 +1646,7 @@ efx_lic_delete_key(
        __in                    uint32_t offset,
        __in                    uint32_t length,
        __in                    uint32_t end,
-       __out                   uint32_t *deltap
-       )
+       __out                   uint32_t *deltap)
 {
        const efx_lic_ops_t *elop = enp->en_elop;
        efx_rc_t rc;
@@ -1705,8 +1671,7 @@ efx_lic_create_partition(
        __in                    efx_nic_t *enp,
        __in_bcount(buffer_size)
                                caddr_t bufferp,
-       __in                    size_t buffer_size
-       )
+       __in                    size_t buffer_size)
 {
        const efx_lic_ops_t *elop = enp->en_elop;
        efx_rc_t rc;
@@ -1731,8 +1696,7 @@ efx_lic_finish_partition(
        __in                    efx_nic_t *enp,
        __in_bcount(buffer_size)
                                caddr_t bufferp,
-       __in                    size_t buffer_size
-       )
+       __in                    size_t buffer_size)
 {
        const efx_lic_ops_t *elop = enp->en_elop;
        efx_rc_t rc;

Modified: head/sys/dev/sfxge/common/efx_mcdi.h
==============================================================================
--- head/sys/dev/sfxge/common/efx_mcdi.h        Sat Nov 24 15:24:35 2018        
(r340879)
+++ head/sys/dev/sfxge/common/efx_mcdi.h        Sat Nov 24 15:24:47 2018        
(r340880)
@@ -55,7 +55,7 @@ struct efx_mcdi_req_s {
        unsigned int    emr_cmd;
        uint8_t         *emr_in_buf;
        size_t          emr_in_length;
-       /* Outputs: retcode, buffer, length, and length used*/
+       /* Outputs: retcode, buffer, length, and length used */
        efx_rc_t        emr_rc;
        uint8_t         *emr_out_buf;
        size_t          emr_out_length;

Modified: head/sys/dev/sfxge/common/efx_nic.c
==============================================================================
--- head/sys/dev/sfxge/common/efx_nic.c Sat Nov 24 15:24:35 2018        
(r340879)
+++ head/sys/dev/sfxge/common/efx_nic.c Sat Nov 24 15:24:47 2018        
(r340880)
@@ -642,9 +642,9 @@ efx_nic_get_fw_version(
                goto fail2;
 
        rc = efx_mcdi_get_capabilities(enp, NULL,
-                                      &enfip->enfi_rx_dpcpu_fw_id,
-                                      &enfip->enfi_tx_dpcpu_fw_id,
-                                      NULL, NULL);
+           &enfip->enfi_rx_dpcpu_fw_id,
+           &enfip->enfi_tx_dpcpu_fw_id,
+           NULL, NULL);
        if (rc == 0) {
                enfip->enfi_dpcpu_fw_ids_valid = B_TRUE;
        } else if (rc == ENOTSUP) {
@@ -655,7 +655,8 @@ efx_nic_get_fw_version(
                goto fail3;
        }
 
-       memcpy(enfip->enfi_mc_fw_version, mc_fw_version, sizeof(mc_fw_version));
+       memcpy(enfip->enfi_mc_fw_version, mc_fw_version,
+           sizeof (mc_fw_version));
 
        return (0);
 

Modified: head/sys/dev/sfxge/common/efx_types.h
==============================================================================
--- head/sys/dev/sfxge/common/efx_types.h       Sat Nov 24 15:24:35 2018        
(r340879)
+++ head/sys/dev/sfxge/common/efx_types.h       Sat Nov 24 15:24:47 2018        
(r340880)
@@ -120,7 +120,8 @@ extern "C" {
 #define        EFX_DWORD_3_LBN 96
 #define        EFX_DWORD_3_WIDTH 32
 
-/* There are intentionally no EFX_QWORD_0 or EFX_QWORD_1 field definitions
+/*
+ * There are intentionally no EFX_QWORD_0 or EFX_QWORD_1 field definitions
  * here as the implementaion of EFX_QWORD_FIELD and EFX_OWORD_FIELD do not
  * support field widths larger than 32 bits.
  */

Modified: head/sys/dev/sfxge/common/medford_nic.c
==============================================================================
--- head/sys/dev/sfxge/common/medford_nic.c     Sat Nov 24 15:24:35 2018        
(r340879)
+++ head/sys/dev/sfxge/common/medford_nic.c     Sat Nov 24 15:24:47 2018        
(r340880)
@@ -181,7 +181,8 @@ medford_board_cfg(
        if (EFX_PCI_FUNCTION_IS_PF(encp)) {
                rc = efx_mcdi_get_mac_address_pf(enp, mac_addr);
 #if EFSYS_OPT_ALLOW_UNCONFIGURED_NIC
-               /* Disable static config checking for Medford NICs, ONLY
+               /*
+                * Disable static config checking for Medford NICs, ONLY
                 * for manufacturing test and setup at the factory, to
                 * allow the static config to be installed.
                 */
_______________________________________________
svn-src-head@freebsd.org mailing list
https://lists.freebsd.org/mailman/listinfo/svn-src-head
To unsubscribe, send any mail to "svn-src-head-unsubscr...@freebsd.org"

Reply via email to