Page Menu
Home
FreeBSD
Search
Configure Global Search
Log In
Files
F177845992
D57438.1795417489.diff
No One
Temporary
Actions
View File
Edit File
Delete File
View Transforms
Subscribe
Flag For Later
Award Token
Authored By
Unknown
Size
65 KB
Referenced Files
None
Subscribers
None
D57438.1795417489.diff
View Options
diff --git a/sys/dev/aq/aq_common.h b/sys/dev/aq/aq_common.h
--- a/sys/dev/aq/aq_common.h
+++ b/sys/dev/aq/aq_common.h
@@ -40,24 +40,14 @@
#define BIT(nr) (1UL << (nr))
-#define usec_delay(x) DELAY(x)
-
-#ifndef msec_delay
-#define msec_delay(x) DELAY(x*1000)
-#define msec_delay_irq(x) DELAY(x*1000)
-#endif
-
#define AQ_HW_WAIT_FOR(_B_, _US_, _N_) ({ \
unsigned int _i; \
for (_i = (_N_); !(_B_) && _i; --_i) \
- usec_delay(_US_); \
+ DELAY(_US_); \
(_i == 0) ? ETIMEDOUT : 0; \
})
-#define LOWORD(a) ((uint16_t)(a))
-#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
-
#define AQ_VER "0.0.5"
#endif // _AQ_COMMON_H_
diff --git a/sys/dev/aq/aq_dbg.h b/sys/dev/aq/aq_dbg.h
--- a/sys/dev/aq/aq_dbg.h
+++ b/sys/dev/aq/aq_dbg.h
@@ -88,15 +88,15 @@
#define AQ_DBG_DUMP_DESC(desc)
#endif
-typedef enum aq_debug_level
+enum aq_debug_level
{
lvl_error = LOG_ERR,
lvl_warn = LOG_WARNING,
lvl_trace = LOG_NOTICE,
lvl_detail = LOG_INFO,
-} aq_debug_level;
+};
-typedef enum aq_debug_category
+enum aq_debug_category
{
dbg_init = 1,
dbg_config = 1 << 1,
@@ -104,12 +104,12 @@
dbg_rx = 1 << 3,
dbg_intr = 1 << 4,
dbg_fw = 1 << 5,
-} aq_debug_category;
+};
#define __FILENAME__ (__builtin_strrchr(__FILE__, '/') ? __builtin_strrchr(__FILE__, '/') + 1 : __FILE__)
-extern const aq_debug_level dbg_level_;
+extern const enum aq_debug_level dbg_level_;
extern const uint32_t dbg_categories_;
#define log_base_(_lvl, _fmt, args...) printf( "atlantic: " _fmt "\n", ##args)
@@ -120,7 +120,6 @@
#define trace_base_(_lvl, _cat, _fmt, ...) do {} while (0)
#endif // AQ_CFG_DEBUG_LVL > 0
-#define aq_log_error(_fmt, args...) log_base_(lvl_error, "[!] " _fmt, ##args)
#define aq_log_warn(_fmt, args...) log_base_(lvl_warn, "/!\\ " _fmt, ##args)
#define aq_log(_fmt, args...) log_base_(lvl_trace, _fmt, ##args)
#define aq_log_detail(_fmt, args...) log_base_(lvl_detail, _fmt, ##args)
diff --git a/sys/dev/aq/aq_dbg.c b/sys/dev/aq/aq_dbg.c
--- a/sys/dev/aq/aq_dbg.c
+++ b/sys/dev/aq/aq_dbg.c
@@ -45,7 +45,7 @@
#include "aq_dbg.h"
-const aq_debug_level dbg_level_ = lvl_detail;
+const enum aq_debug_level dbg_level_ = lvl_detail;
const uint32_t dbg_categories_ = dbg_init | dbg_config | dbg_fw;
diff --git a/sys/dev/aq/aq_device.h b/sys/dev/aq/aq_device.h
--- a/sys/dev/aq/aq_device.h
+++ b/sys/dev/aq/aq_device.h
@@ -53,7 +53,7 @@
#define AQ_LINK_ALL (AQ_LINK_100M | AQ_LINK_1G | AQ_LINK_2G5 | AQ_LINK_5G | \
AQ_LINK_10G )
-struct aq_stats_s {
+struct aq_stats {
uint64_t prc;
uint64_t uprc;
uint64_t mprc;
@@ -77,7 +77,7 @@
uint64_t bbtc;
};
-enum aq_dev_state_e {
+enum aq_dev_state {
AQ_DEV_STATE_UNLOAD,
AQ_DEV_STATE_PCI_STOP,
AQ_DEV_STATE_DOWN,
@@ -126,8 +126,8 @@
bool linkup;
int media_active;
- struct aq_hw_stats_s last_stats;
- struct aq_stats_s curr_stats;
+ struct aq_hw_stats last_stats;
+ struct aq_stats curr_stats;
bitstr_t *vlan_tags;
int mcnt;
@@ -136,13 +136,11 @@
uint8_t rss_table[HW_ATL_RSS_INDIRECTION_TABLE_MAX];
};
-typedef struct aq_dev aq_dev_t;
-
-int aq_update_hw_stats(aq_dev_t *aq_dev);
-void aq_initmedia(aq_dev_t *aq_dev);
+int aq_update_hw_stats(struct aq_dev *aq_dev);
+void aq_initmedia(struct aq_dev *aq_dev);
int aq_linkstat_isr(void *arg);
int aq_isr_rx(void *arg);
-void aq_mediastatus_update(aq_dev_t *aq_dev, uint32_t link_speed, const struct aq_hw_fc_info *fc_neg);
+void aq_mediastatus_update(struct aq_dev *aq_dev, uint32_t link_speed, const struct aq_hw_fc_info *fc_neg);
void aq_mediastatus(struct ifnet *ifp, struct ifmediareq *ifmr);
int aq_mediachange(struct ifnet *ifp);
void aq_if_update_admin_status(if_ctx_t ctx);
diff --git a/sys/dev/aq/aq_fw.h b/sys/dev/aq/aq_fw.h
--- a/sys/dev/aq/aq_fw.h
+++ b/sys/dev/aq/aq_fw.h
@@ -36,7 +36,7 @@
struct aq_hw;
-typedef enum aq_fw_link_speed
+enum aq_fw_link_speed
{
aq_fw_none = 0,
aq_fw_100M = (1 << 0),
@@ -44,30 +44,30 @@
aq_fw_2G5 = (1 << 2),
aq_fw_5G = (1 << 3),
aq_fw_10G = (1 << 4),
-} aq_fw_link_speed_t;
+};
-typedef enum aq_fw_link_fc
+enum aq_fw_link_fc
{
aq_fw_fc_none = 0,
aq_fw_fc_ENABLE_RX = BIT(0),
aq_fw_fc_ENABLE_TX = BIT(1),
aq_fw_fc_ENABLE_ALL = aq_fw_fc_ENABLE_RX | aq_fw_fc_ENABLE_TX,
-} aq_fw_link_fc_t;
+};
#define aq_fw_speed_auto \
(aq_fw_100M | aq_fw_1G | aq_fw_2G5 | aq_fw_5G | aq_fw_10G)
struct aq_firmware_ops
{
- int (*reset)(struct aq_hw* hal);
+ int (*reset)(struct aq_hw* hw);
- int (*set_mode)(struct aq_hw* hal, enum aq_hw_fw_mpi_state_e mode, aq_fw_link_speed_t speed);
- int (*get_mode)(struct aq_hw* hal, enum aq_hw_fw_mpi_state_e* mode, aq_fw_link_speed_t* speed, aq_fw_link_fc_t* fc);
+ int (*set_mode)(struct aq_hw* hw, enum aq_hw_fw_mpi_state mode, enum aq_fw_link_speed speed);
+ int (*get_mode)(struct aq_hw* hw, enum aq_hw_fw_mpi_state* mode, enum aq_fw_link_speed* speed, enum aq_fw_link_fc* fc);
- int (*get_mac_addr)(struct aq_hw* hal, uint8_t* mac_addr);
- int (*get_stats)(struct aq_hw* hal, struct aq_hw_stats_s* stats);
+ int (*get_mac_addr)(struct aq_hw* hw, uint8_t* mac_addr);
+ int (*get_stats)(struct aq_hw* hw, struct aq_hw_stats* stats);
- int (*led_control)(struct aq_hw* hal, uint32_t mode);
+ int (*led_control)(struct aq_hw* hw, uint32_t mode);
};
diff --git a/sys/dev/aq/aq_fw.c b/sys/dev/aq/aq_fw.c
--- a/sys/dev/aq/aq_fw.c
+++ b/sys/dev/aq/aq_fw.c
@@ -48,18 +48,17 @@
#include "aq_hw_llh_internal.h"
#include "aq_fw.h"
-#include "aq_common.h"
#include "aq_dbg.h"
-typedef enum aq_fw_bootloader_mode
+enum aq_fw_bootloader_mode
{
boot_mode_unknown = 0,
boot_mode_flb,
boot_mode_rbl_flash,
boot_mode_rbl_host_bootload,
-} aq_fw_bootloader_mode;
+};
#define AQ_CFG_HOST_BOOT_DISABLE 0
@@ -86,13 +85,13 @@
const uint32_t SCRATCHPAD_FW_LOADER_STATUS = (0x40 / sizeof(uint32_t));
-extern struct aq_firmware_ops aq_fw1x_ops;
-extern struct aq_firmware_ops aq_fw2x_ops;
+extern const struct aq_firmware_ops aq_fw1x_ops;
+extern const struct aq_firmware_ops aq_fw2x_ops;
-int mac_soft_reset_(struct aq_hw* hw, aq_fw_bootloader_mode* mode);
+int mac_soft_reset_(struct aq_hw* hw, enum aq_fw_bootloader_mode* mode);
int mac_soft_reset_flb_(struct aq_hw* hw);
-int mac_soft_reset_rbl_(struct aq_hw* hw, aq_fw_bootloader_mode* mode);
+int mac_soft_reset_rbl_(struct aq_hw* hw, enum aq_fw_bootloader_mode* mode);
int wait_init_mac_firmware_(struct aq_hw* hw);
@@ -111,7 +110,7 @@
}
if (k == 1000) {
- aq_log_error("Neither RBL nor FLB started");
+ device_printf(hw->dev, "Neither RBL nor FLB started\n");
return (EBUSY);
}
@@ -131,10 +130,10 @@
return (0);
}
- aq_fw_bootloader_mode mode = boot_mode_unknown;
+ enum aq_fw_bootloader_mode mode = boot_mode_unknown;
int err = mac_soft_reset_(hw, &mode);
if (err != 0) {
- aq_log_error("MAC reset failed: %d", err);
+ device_printf(hw->dev, "MAC reset failed: %d\n", err);
return (err);
}
@@ -150,12 +149,12 @@
return wait_init_mac_firmware_(hw);
case boot_mode_unknown:
- aq_log_error("F/W bootload error: unknown bootloader type");
+ device_printf(hw->dev, "F/W bootload error: unknown bootloader type\n");
return (ENOTSUP);
case boot_mode_rbl_host_bootload:
#if AQ_CFG_HOST_BOOT_DISABLE
- aq_log_error("RBL> Host Bootload mode: this driver does not support Host Boot");
+ device_printf(hw->dev, "RBL> Host Bootload mode: this driver does not support Host Boot\n");
return (ENOTSUP);
#else
trace(dbg_init, "RBL> Host Bootload mode");
@@ -166,7 +165,7 @@
/*
* #todo: Host Boot
*/
- aq_log_error("RBL> F/W Host Bootload not implemented");
+ device_printf(hw->dev, "RBL> F/W Host Bootload not implemented\n");
return (ENOTSUP);
}
@@ -191,14 +190,14 @@
return (0);
}
- aq_log_error("aq_fw_ops_init(): invalid F/W version %#x",
+ device_printf(hw->dev, "aq_fw_ops_init(): invalid F/W version %#x\n",
hw->fw_version.raw);
return (ENOTSUP);
}
int
-mac_soft_reset_(struct aq_hw* hw, aq_fw_bootloader_mode* mode /*= nullptr*/)
+mac_soft_reset_(struct aq_hw* hw, enum aq_fw_bootloader_mode* mode /*= nullptr*/)
{
if (hw->rbl_enabled) {
return mac_soft_reset_rbl_(hw, mode);
@@ -218,7 +217,7 @@
reg_global_ctl2_set(hw, 0x40e1);
// Let Felicity hardware complete SMBUS transaction before Global
// software reset.
- msec_delay(50);
+ DELAY((50) * 1000);
/*
* If SPI burst transaction was interrupted(before running the script),
@@ -228,7 +227,7 @@
reg_glb_nvr_provisioning2_set(hw, 0xa0);
reg_glb_nvr_interface1_set(hw, 0x9f);
reg_glb_nvr_interface1_set(hw, 0x809f);
- msec_delay(50);
+ DELAY((50) * 1000);
reg_glb_standard_ctl1_set(hw, (reg_glb_standard_ctl1_get(hw) & ~glb_reg_res_dis_msk) | glb_soft_res_msk);
@@ -242,7 +241,7 @@
* For the case SPI burst transaction was interrupted (by MCP reset
* above), wait until it is completed by hardware.
*/
- msec_delay(50); // Sleep for 10 ms.
+ DELAY(50 * 1000);
/* MAC Kickstart */
if (!hw->fast_start_enabled) {
@@ -254,7 +253,7 @@
flb_status = reg_glb_daisy_chain_status1_get(hw) & 0x10;
if (flb_status != 0)
break;
- msec_delay(10); // Sleep for 10 ms.
+ DELAY(10 * 1000);
}
if (flb_status == 0) {
@@ -268,7 +267,7 @@
reg_global_ctl2_set(hw, 0x80e0);
// Let Felicity hardware complete SMBUS transaction before
// Global software reset.
- msec_delay(50);
+ DELAY((50) * 1000);
}
reg_glb_cpu_sem_set(hw, 1, 0);
@@ -285,7 +284,7 @@
restart_completed = reg_glb_fw_image_id1_get(hw) != 0;
if (restart_completed)
break;
- msec_delay(10);
+ DELAY((10) * 1000);
}
if (!restart_completed) {
@@ -298,7 +297,7 @@
}
int
-mac_soft_reset_rbl_(struct aq_hw* hw, aq_fw_bootloader_mode* mode)
+mac_soft_reset_rbl_(struct aq_hw* hw, enum aq_fw_bootloader_mode* mode)
{
trace(dbg_init, "RBL> MAC reset STARTED!");
@@ -322,11 +321,11 @@
// Wait for RBL to finish boot process.
uint16_t rbl_status = 0;
for (int k = 0; k < RBL_TIMEOUT_MS; ++k) {
- rbl_status = LOWORD(reg_glb_cpu_no_reset_scratchpad_get(hw, NO_RESET_SCRATCHPAD_RBL_STATUS));
+ rbl_status = ((uint16_t)(reg_glb_cpu_no_reset_scratchpad_get(hw, NO_RESET_SCRATCHPAD_RBL_STATUS)));
if (rbl_status != 0 && rbl_status != 0xDEAD)
break;
- msec_delay(1);
+ DELAY((1) * 1000);
}
if (rbl_status == 0 || rbl_status == 0xDEAD) {
@@ -357,7 +356,7 @@
if ((hw->fw_version.raw = AQ_READ_REG(hw, 0x18)) != 0)
return (0);
- msec_delay(1);
+ DELAY((1) * 1000);
}
trace_error(dbg_init,
diff --git a/sys/dev/aq/aq_fw1x.c b/sys/dev/aq/aq_fw1x.c
--- a/sys/dev/aq/aq_fw1x.c
+++ b/sys/dev/aq/aq_fw1x.c
@@ -49,14 +49,14 @@
#define FW1X_MPI_STATE_ADR 0x36C
-typedef enum fw1x_mode {
+enum fw1x_mode {
FW1X_MPI_DEINIT = 0,
FW1X_MPI_RESERVED = 1,
FW1X_MPI_INIT = 2,
FW1X_MPI_POWER = 4,
-} fw1x_mode;
+};
-typedef enum aq_fw1x_rate {
+enum aq_fw1x_rate {
FW1X_RATE_10G = 1 << 0,
FW1X_RATE_5G = 1 << 1,
FW1X_RATE_5GSR = 1 << 2,
@@ -64,9 +64,9 @@
FW1X_RATE_1G = 1 << 4,
FW1X_RATE_100M = 1 << 5,
FW1X_RATE_INVALID = 1 << 6,
-} aq_fw1x_rate;
+};
-typedef union fw1x_state_reg {
+union fw1x_state_reg {
uint32_t val;
struct {
uint8_t mode;
@@ -77,20 +77,20 @@
uint8_t reserved3 : 2;
uint8_t downshift : 4;
};
-} fw1x_state_reg;
+};
int fw1x_reset(struct aq_hw* hw);
-int fw1x_set_mode(struct aq_hw* hw, enum aq_hw_fw_mpi_state_e mode,
- aq_fw_link_speed_t speed);
-int fw1x_get_mode(struct aq_hw* hw, enum aq_hw_fw_mpi_state_e* mode,
- aq_fw_link_speed_t* speed, aq_fw_link_fc_t* fc);
+int fw1x_set_mode(struct aq_hw* hw, enum aq_hw_fw_mpi_state mode,
+ enum aq_fw_link_speed speed);
+int fw1x_get_mode(struct aq_hw* hw, enum aq_hw_fw_mpi_state* mode,
+ enum aq_fw_link_speed* speed, enum aq_fw_link_fc* fc);
int fw1x_get_mac_addr(struct aq_hw* hw, uint8_t* mac_addr);
-int fw1x_get_stats(struct aq_hw* hw, struct aq_hw_stats_s* stats);
+int fw1x_get_stats(struct aq_hw* hw, struct aq_hw_stats* stats);
-static fw1x_mode
-mpi_mode_to_fw1x_(enum aq_hw_fw_mpi_state_e mode)
+static enum fw1x_mode
+mpi_mode_to_fw1x_(enum aq_hw_fw_mpi_state mode)
{
switch (mode) {
case MPI_DEINIT:
@@ -113,7 +113,7 @@
return (FW1X_MPI_RESERVED);
}
-static aq_fw1x_rate
+static enum aq_fw1x_rate
link_speed_mask_to_fw1x_(uint32_t /*aq_fw_link_speed*/ speed)
{
uint32_t rate = 0;
@@ -134,11 +134,11 @@
if (speed & aq_fw_100M)
rate |= FW1X_RATE_100M;
- return ((aq_fw1x_rate)rate);
+ return ((enum aq_fw1x_rate)rate);
}
-static aq_fw_link_speed_t
-fw1x_rate_to_link_speed_(aq_fw1x_rate rate)
+static enum aq_fw_link_speed
+fw1x_rate_to_link_speed_(enum aq_fw1x_rate rate)
{
switch (rate) {
case FW1X_RATE_10G:
@@ -164,7 +164,7 @@
}
int
-fw1x_reset(struct aq_hw* hal)
+fw1x_reset(struct aq_hw* hw)
{
uint32_t tid0 = ~0u; /*< Initial value of MBOX transactionId. */
struct aq_hw_fw_mbox mbox;
@@ -173,7 +173,7 @@
for (int i = 0; i < retryCount; ++i) {
// Read the beginning of Statistics structure to capture the
// Transaction ID.
- aq_hw_fw_downld_dwords(hal, hal->mbox_addr, (uint32_t*)&mbox,
+ aq_hw_fw_downld_dwords(hw, hw->mbox_addr, (uint32_t*)&mbox,
(uint32_t)((char*)&mbox.stats - (char*)&mbox) / sizeof(uint32_t));
// Successfully read the stats.
@@ -193,7 +193,7 @@
* Transaction ID value haven't changed since last time.
* Try reading the stats again.
*/
- usec_delay(10);
+ DELAY(10);
}
trace_error(dbg_init, "F/W 1.x reset finalize timeout");
@@ -201,8 +201,8 @@
}
int
-fw1x_set_mode(struct aq_hw* hw, enum aq_hw_fw_mpi_state_e mode,
- aq_fw_link_speed_t speed)
+fw1x_set_mode(struct aq_hw* hw, enum aq_hw_fw_mpi_state mode,
+ enum aq_fw_link_speed speed)
{
union fw1x_state_reg state = {0};
state.mode = mpi_mode_to_fw1x_(mode);
@@ -217,15 +217,15 @@
}
int
-fw1x_get_mode(struct aq_hw* hw, enum aq_hw_fw_mpi_state_e* mode,
- aq_fw_link_speed_t* speed, aq_fw_link_fc_t* fc)
+fw1x_get_mode(struct aq_hw* hw, enum aq_hw_fw_mpi_state* mode,
+ enum aq_fw_link_speed* speed, enum aq_fw_link_fc* fc)
{
union fw1x_state_reg state = { .val = AQ_READ_REG(hw, AQ_HW_MPI_STATE_ADR) };
trace(dbg_init, "fw1x> get_mode(): 0x36c -> %x, 0x368 -> %x",
state.val, AQ_READ_REG(hw, AQ_HW_MPI_CONTROL_ADR));
- enum aq_hw_fw_mpi_state_e md = MPI_DEINIT;
+ enum aq_hw_fw_mpi_state md = MPI_DEINIT;
switch (state.mode) {
case FW1X_MPI_DEINIT:
@@ -271,7 +271,7 @@
}
err = aq_hw_fw_downld_dwords(hw, efuse_shadow_addr + (40 * 4),
- mac_addr, ARRAY_SIZE(mac_addr));
+ mac_addr, nitems(mac_addr));
if (err != 0) {
mac_addr[0] = 0;
mac_addr[1] = 0;
@@ -292,7 +292,7 @@
}
int
-fw1x_get_stats(struct aq_hw* hw, struct aq_hw_stats_s* stats)
+fw1x_get_stats(struct aq_hw* hw, struct aq_hw_stats* stats)
{
int err = 0;
@@ -311,7 +311,7 @@
return (err);
}
-struct aq_firmware_ops aq_fw1x_ops =
+const struct aq_firmware_ops aq_fw1x_ops =
{
.reset = fw1x_reset,
diff --git a/sys/dev/aq/aq_fw2x.c b/sys/dev/aq/aq_fw2x.c
--- a/sys/dev/aq/aq_fw2x.c
+++ b/sys/dev/aq/aq_fw2x.c
@@ -51,7 +51,7 @@
#include "aq_dbg.h"
-typedef enum {
+enum fw2x_caps_lo {
CAPS_LO_10BASET_HD = 0x00,
CAPS_LO_10BASET_FD,
CAPS_LO_100BASETX_HD,
@@ -64,9 +64,9 @@
CAPS_LO_2P5GBASET_FD,
CAPS_LO_5GBASET_FD,
CAPS_LO_10GBASET_FD,
-} fw2x_caps_lo;
+};
-typedef enum {
+enum fw2x_caps_hi {
CAPS_HI_RESERVED1 = 0x00,
CAPS_HI_10BASET_EEE,
CAPS_HI_RESERVED2,
@@ -99,19 +99,19 @@
CAPS_HI_WOL_TIMER,
CAPS_HI_STATISTICS,
CAPS_HI_TRANSACTION_ID,
-} fw2x_caps_hi;
+};
-typedef enum aq_fw2x_rate
+enum aq_fw2x_rate
{
FW2X_RATE_100M = 0x20,
FW2X_RATE_1G = 0x100,
FW2X_RATE_2G5 = 0x200,
FW2X_RATE_5G = 0x400,
FW2X_RATE_10G = 0x800,
-} aq_fw2x_rate;
+};
-typedef struct fw2x_msm_statistics
+struct fw2x_msm_statistics
{
uint32_t uprc;
uint32_t mprc;
@@ -129,36 +129,36 @@
uint32_t ubtc;
uint32_t ptc;
uint32_t prc;
-} fw2x_msm_statistics;
+};
-typedef struct fw2x_phy_cable_diag_data
+struct fw2x_phy_cable_diag_data
{
uint32_t lane_data[4];
-} fw2x_phy_cable_diag_data;
+};
-typedef struct fw2x_capabilities {
+struct fw2x_capabilities {
uint32_t caps_lo;
uint32_t caps_hi;
-} fw2x_capabilities;
+};
-typedef struct fw2x_mailbox // struct fwHostInterface
+struct fw2x_mailbox // struct fwHostInterface
{
uint32_t version;
uint32_t transaction_id;
int32_t error;
- fw2x_msm_statistics msm; // msmStatistics_t msm;
+ struct fw2x_msm_statistics msm; // msmStatistics_t msm;
uint16_t phy_h_bit;
uint16_t phy_fault_code;
int16_t phy_temperature;
uint8_t cable_len;
uint8_t reserved1;
- fw2x_phy_cable_diag_data diag_data;
+ struct fw2x_phy_cable_diag_data diag_data;
uint32_t reserved[8];
- fw2x_capabilities caps;
+ struct fw2x_capabilities caps;
/* ... */
-} fw2x_mailbox;
+};
// EEE caps
@@ -195,13 +195,13 @@
// Firmware v2-3.x specific functions.
int fw2x_reset(struct aq_hw* hw);
-int fw2x_set_mode(struct aq_hw* hw, enum aq_hw_fw_mpi_state_e mode,
- aq_fw_link_speed_t speed);
-int fw2x_get_mode(struct aq_hw* hw, enum aq_hw_fw_mpi_state_e* mode,
- aq_fw_link_speed_t* speed, aq_fw_link_fc_t* fc);
+int fw2x_set_mode(struct aq_hw* hw, enum aq_hw_fw_mpi_state mode,
+ enum aq_fw_link_speed speed);
+int fw2x_get_mode(struct aq_hw* hw, enum aq_hw_fw_mpi_state* mode,
+ enum aq_fw_link_speed* speed, enum aq_fw_link_fc* fc);
int fw2x_get_mac_addr(struct aq_hw* hw, uint8_t* mac);
-int fw2x_get_stats(struct aq_hw* hw, struct aq_hw_stats_s* stats);
+int fw2x_get_stats(struct aq_hw* hw, struct aq_hw_stats* stats);
static uint64_t
@@ -242,10 +242,10 @@
int
fw2x_reset(struct aq_hw* hw)
{
- fw2x_capabilities caps = {0};
+ struct fw2x_capabilities caps = {0};
AQ_DBG_ENTER();
int err = aq_hw_fw_downld_dwords(hw,
- hw->mbox_addr + offsetof(fw2x_mailbox, caps),
+ hw->mbox_addr + offsetof(struct fw2x_mailbox, caps),
(uint32_t*)&caps, sizeof caps/sizeof(uint32_t));
if (err == 0) {
hw->fw_caps = caps.caps_lo | ((uint64_t)caps.caps_hi << 32);
@@ -262,7 +262,7 @@
}
-static aq_fw2x_rate
+static enum aq_fw2x_rate
link_speed_mask_to_fw2x_(uint32_t speed)
{
uint32_t rate = 0;
@@ -284,13 +284,13 @@
rate |= FW2X_RATE_100M;
AQ_DBG_EXIT(rate);
- return ((aq_fw2x_rate)rate);
+ return ((enum aq_fw2x_rate)rate);
}
int
-fw2x_set_mode(struct aq_hw* hw, enum aq_hw_fw_mpi_state_e mode,
- aq_fw_link_speed_t speed)
+fw2x_set_mode(struct aq_hw* hw, enum aq_hw_fw_mpi_state mode,
+ enum aq_fw_link_speed speed)
{
uint64_t mpi_ctrl = get_mpi_ctrl_(hw);
@@ -326,8 +326,8 @@
}
int
-fw2x_get_mode(struct aq_hw* hw, enum aq_hw_fw_mpi_state_e* mode,
- aq_fw_link_speed_t* link_speed, aq_fw_link_fc_t* fc)
+fw2x_get_mode(struct aq_hw* hw, enum aq_hw_fw_mpi_state* mode,
+ enum aq_fw_link_speed* link_speed, enum aq_fw_link_fc* fc)
{
uint64_t mpi_state = get_mpi_state_(hw);
uint32_t rates = mpi_state & FW2X_RATE_MASK;
@@ -342,7 +342,7 @@
*mode = MPI_DEINIT;
}
- aq_fw_link_speed_t speed = aq_fw_none;
+ enum aq_fw_link_speed speed = aq_fw_none;
if (rates & FW2X_RATE_10G)
speed = aq_fw_10G;
@@ -382,7 +382,7 @@
}
err = aq_hw_fw_downld_dwords(hw, efuse_shadow_addr + (40 * 4), mac_addr,
- ARRAY_SIZE(mac_addr));
+ nitems(mac_addr));
if (err != 0) {
mac_addr[0] = 0;
mac_addr[1] = 0;
@@ -400,8 +400,8 @@
}
static inline void
-fw2x_stats_to_fw_stats_(struct aq_hw_stats_s* dst,
- const fw2x_msm_statistics* src)
+fw2x_stats_to_fw_stats_(struct aq_hw_stats* dst,
+ const struct fw2x_msm_statistics* src)
{
dst->uprc = src->uprc;
dst->mprc = src->mprc;
@@ -454,7 +454,7 @@
// AQ_DBG_EXIT(true);
return (true);
}
- msec_delay(timeout_ms);
+ DELAY((timeout_ms) * 1000);
}
trace_detail(dbg_fw,
@@ -466,10 +466,10 @@
int
-fw2x_get_stats(struct aq_hw* hw, struct aq_hw_stats_s* stats)
+fw2x_get_stats(struct aq_hw* hw, struct aq_hw_stats* stats)
{
int err = 0;
- fw2x_msm_statistics fw2x_stats = {0};
+ struct fw2x_msm_statistics fw2x_stats = {0};
// AQ_DBG_ENTER();
@@ -486,7 +486,7 @@
}
err = aq_hw_fw_downld_dwords(hw,
- hw->mbox_addr + offsetof(fw2x_mailbox, msm),
+ hw->mbox_addr + offsetof(struct fw2x_mailbox, msm),
(uint32_t*)&fw2x_stats, sizeof fw2x_stats/sizeof(uint32_t));
fw2x_stats_to_fw_stats_(stats, &fw2x_stats);
@@ -506,7 +506,7 @@
AQ_DBG_ENTER();
- aq_hw_fw_version ver_expected = { .raw = FW2X_FW_MIN_VER_LED};
+ struct aq_hw_fw_version ver_expected = { .raw = FW2X_FW_MIN_VER_LED};
if (aq_hw_ver_match(&ver_expected, &hw->fw_version))
AQ_WRITE_REG(hw, FW2X_MPI_LED_ADDR,
(onoff) ? ((FW2X_LED_BLINK) | (FW2X_LED_BLINK << 2) | (FW2X_LED_BLINK << 4)):
@@ -516,7 +516,7 @@
return (err);
}
-struct aq_firmware_ops aq_fw2x_ops =
+const struct aq_firmware_ops aq_fw2x_ops =
{
.reset = fw2x_reset,
diff --git a/sys/dev/aq/aq_hw.h b/sys/dev/aq/aq_hw.h
--- a/sys/dev/aq/aq_hw.h
+++ b/sys/dev/aq/aq_hw.h
@@ -37,6 +37,7 @@
#include <sys/types.h>
#include <sys/cdefs.h>
+#include <sys/bus.h>
#include <machine/atomic.h>
#include <machine/cpufunc.h>
#include <machine/bus.h>
@@ -78,10 +79,6 @@
/* Statistics */
struct aq_hw_stats {
- uint64_t crcerrs;
-};
-
-struct aq_hw_stats_s {
uint32_t uprc;
uint32_t mprc;
uint32_t bprc;
@@ -100,7 +97,7 @@
uint32_t prc;
uint32_t dpc;
uint32_t cprc;
-} __attribute__((__packed__));
+} __packed;
union ip_addr {
struct {
@@ -110,16 +107,16 @@
uint8_t padding[12];
uint8_t addr[4];
} v4;
-} __attribute__((__packed__));
+} __packed;
struct aq_hw_fw_mbox {
uint32_t version;
uint32_t transaction_id;
int error;
- struct aq_hw_stats_s stats;
-} __attribute__((__packed__));
+ struct aq_hw_stats stats;
+} __packed;
-typedef struct aq_hw_fw_version {
+struct aq_hw_fw_version {
union {
struct {
uint16_t build_number;
@@ -128,7 +125,7 @@
};
uint32_t raw;
};
-} aq_hw_fw_version;
+};
enum aq_hw_irq_type {
aq_irq_invalid = 0,
@@ -144,6 +141,7 @@
struct aq_hw {
void *aq_dev;
+ device_t dev;
bus_space_tag_t hw_tag;
bus_space_handle_t hw_handle;
uint32_t regs_size;
@@ -165,7 +163,7 @@
int itr;
/* Firmware-related stuff. */
- aq_hw_fw_version fw_version;
+ struct aq_hw_fw_version fw_version;
const struct aq_firmware_ops* fw_ops;
bool rbl_enabled;
bool fast_start_enabled;
@@ -183,8 +181,6 @@
uint32_t tx_rings_count;
};
-#define aq_hw_s aq_hw
-
#define AQ_HW_MAC 0U
#define AQ_HW_MAC_MIN 1U
#define AQ_HW_MAC_MAX 33U
@@ -320,7 +316,7 @@
#define HW_ATL_GET_REG_LOCATION_FL3L4(location) \
((location) - AQ_RX_FIRST_LOC_FL3L4)
-enum aq_hw_fw_mpi_state_e {
+enum aq_hw_fw_mpi_state {
MPI_DEINIT = 0,
MPI_RESET = 1,
MPI_INIT = 2,
@@ -355,24 +351,24 @@
int aq_hw_deinit(struct aq_hw *hw);
-int aq_hw_ver_match(const aq_hw_fw_version* ver_expected,
- const aq_hw_fw_version* ver_actual);
+int aq_hw_ver_match(const struct aq_hw_fw_version* ver_expected,
+ const struct aq_hw_fw_version* ver_actual);
-void aq_hw_set_promisc(struct aq_hw_s *self, bool l2_promisc, bool vlan_promisc,
+void aq_hw_set_promisc(struct aq_hw *hw, bool l2_promisc, bool vlan_promisc,
bool mc_promisc);
int aq_hw_set_power(struct aq_hw *hw, unsigned int power_state);
int aq_hw_err_from_flags(struct aq_hw *hw);
-int hw_atl_b0_hw_vlan_promisc_set(struct aq_hw_s *self, bool promisc);
+int hw_atl_b0_hw_vlan_promisc_set(struct aq_hw *hw, bool promisc);
-int hw_atl_b0_hw_vlan_set(struct aq_hw_s *self,
+int hw_atl_b0_hw_vlan_set(struct aq_hw *hw,
struct aq_rx_filter_vlan *aq_vlans);
-int aq_hw_rss_hash_set(struct aq_hw_s *self, uint8_t rss_key[HW_ATL_RSS_HASHKEY_SIZE]);
-int aq_hw_rss_hash_get(struct aq_hw_s *self, uint8_t rss_key[HW_ATL_RSS_HASHKEY_SIZE]);
-int aq_hw_rss_set(struct aq_hw_s *self, uint8_t rss_table[HW_ATL_RSS_INDIRECTION_TABLE_MAX]);
-int aq_hw_udp_rss_enable(struct aq_hw_s *self, bool enable);
+int aq_hw_rss_hash_set(struct aq_hw *hw, uint8_t rss_key[HW_ATL_RSS_HASHKEY_SIZE]);
+int aq_hw_rss_hash_get(struct aq_hw *hw, uint8_t rss_key[HW_ATL_RSS_HASHKEY_SIZE]);
+int aq_hw_rss_set(struct aq_hw *hw, uint8_t rss_table[HW_ATL_RSS_INDIRECTION_TABLE_MAX]);
+int aq_hw_udp_rss_enable(struct aq_hw *hw, bool enable);
#endif // _AQ_HW_H_
diff --git a/sys/dev/aq/aq_hw.c b/sys/dev/aq/aq_hw.c
--- a/sys/dev/aq/aq_hw.c
+++ b/sys/dev/aq/aq_hw.c
@@ -37,7 +37,6 @@
#include <sys/endian.h>
#include <sys/socket.h>
#include <machine/cpu.h>
-#include <net/if.h>
#include "aq_hw.h"
#include "aq_dbg.h"
@@ -133,8 +132,8 @@
}
int
-aq_hw_ver_match(const aq_hw_fw_version* ver_expected,
- const aq_hw_fw_version* ver_actual)
+aq_hw_ver_match(const struct aq_hw_fw_version* ver_expected,
+ const struct aq_hw_fw_version* ver_actual)
{
AQ_DBG_ENTER();
@@ -155,14 +154,14 @@
err = aq_fw_reset(hw);
if (err != 0) {
- aq_log_error("aq_hw_init_ucp(): F/W reset failed, err %d", err);
+ device_printf(hw->dev, "aq_hw_init_ucp(): F/W reset failed, err %d\n", err);
return (err);
}
aq_hw_chip_features_init(hw, &hw->chip_features);
err = aq_fw_ops_init(hw);
if (err != 0) {
- aq_log_error("could not initialize F/W ops, err %d", err);
+ device_printf(hw->dev, "could not initialize F/W ops, err %d\n", err);
return (err);
}
@@ -183,9 +182,9 @@
/* check 10 times by 1ms */
err = AQ_HW_WAIT_FOR((hw->mbox_addr = AQ_READ_REG(hw, 0x360)) != 0, 400U, 20);
- aq_hw_fw_version ver_expected = { .raw = AQ_CFG_FW_MIN_VER_EXPECTED };
+ struct aq_hw_fw_version ver_expected = { .raw = AQ_CFG_FW_MIN_VER_EXPECTED };
if (!aq_hw_ver_match(&ver_expected, &hw->fw_version))
- aq_log_error("atlantic: aq_hw_init_ucp(), wrong FW version: expected:%x actual:%x",
+ device_printf(hw->dev, "aq_hw_init_ucp(), wrong FW version: expected:%x actual:%x\n",
AQ_CFG_FW_MIN_VER_EXPECTED, hw->fw_version.raw);
AQ_DBG_EXIT(err);
@@ -210,15 +209,10 @@
int
aq_hw_mpi_read_stats(struct aq_hw *hw, struct aq_hw_fw_mbox *pmbox)
{
- int err = 0;
+ int err;
// AQ_DBG_ENTER();
- if (hw->fw_ops && hw->fw_ops->get_stats) {
- err = hw->fw_ops->get_stats(hw, &pmbox->stats);
- } else {
- err = ENOTSUP;
- aq_log_error("get_stats() not supported by F/W");
- }
+ err = hw->fw_ops->get_stats(hw, &pmbox->stats);
if (err == 0) {
pmbox->stats.dpc = reg_rx_dma_stat_counter7get(hw);
@@ -230,16 +224,12 @@
}
static int
-aq_hw_mpi_set(struct aq_hw *hw, enum aq_hw_fw_mpi_state_e state, uint32_t speed)
+aq_hw_mpi_set(struct aq_hw *hw, enum aq_hw_fw_mpi_state state, uint32_t speed)
{
- int err = ENOTSUP;
+ int err;
AQ_DBG_ENTERA("speed %d", speed);
- if (hw->fw_ops && hw->fw_ops->set_mode) {
- err = hw->fw_ops->set_mode(hw, state, speed);
- } else {
- aq_log_error("set_mode() not supported by F/W");
- }
+ err = hw->fw_ops->set_mode(hw, state, speed);
AQ_DBG_EXIT(err);
return (err);
@@ -258,20 +248,14 @@
// AQ_DBG_ENTER();
- enum aq_hw_fw_mpi_state_e mode;
- aq_fw_link_speed_t speed = aq_fw_none;
- aq_fw_link_fc_t fc;
+ enum aq_hw_fw_mpi_state mode;
+ enum aq_fw_link_speed speed = aq_fw_none;
+ enum aq_fw_link_fc fc;
- if (hw->fw_ops && hw->fw_ops->get_mode) {
- err = hw->fw_ops->get_mode(hw, &mode, &speed, &fc);
- } else {
- aq_log_error("get_mode() not supported by F/W");
- AQ_DBG_EXIT(ENOTSUP);
- return (ENOTSUP);
- }
+ err = hw->fw_ops->get_mode(hw, &mode, &speed, &fc);
if (err != 0) {
- aq_log_error("get_mode() failed, err %d", err);
+ device_printf(hw->dev, "get_mode() failed, err %d\n", err);
AQ_DBG_EXIT(err);
return (err);
}
@@ -310,11 +294,10 @@
int
aq_hw_get_mac_permanent(struct aq_hw *hw, uint8_t *mac)
{
- int err = ENOTSUP;
+ int err;
AQ_DBG_ENTER();
- if (hw->fw_ops && hw->fw_ops->get_mac_addr)
- err = hw->fw_ops->get_mac_addr(hw, mac);
+ err = hw->fw_ops->get_mac_addr(hw, mac);
/* Couldn't get MAC address from HW. Use auto-generated one. */
if ((mac[0] & 1) || ((mac[0] | mac[1] | mac[2]) == 0)) {
@@ -322,8 +305,9 @@
uint32_t h = 0;
uint32_t l = 0;
- printf("atlantic: HW MAC address %x:%x:%x:%x:%x:%x is multicast or empty MAC", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
- printf("atlantic: Use random MAC address");
+ device_printf(hw->dev,
+ "invalid (multicast/empty) HW MAC %6D; using random\n",
+ mac, ":");
rnd = arc4random();
@@ -387,12 +371,11 @@
/* check 10 times by 1ms */
err = AQ_HW_WAIT_FOR(itr_res_irq_get(hw) == 0, 1000, 10);
if (err != 0) {
- printf("atlantic: IRQ reset failed: %d", err);
+ device_printf(hw->dev, "IRQ reset failed: %d\n", err);
goto err_exit;
}
- if (hw->fw_ops && hw->fw_ops->reset)
- hw->fw_ops->reset(hw);
+ hw->fw_ops->reset(hw);
err = aq_hw_err_from_flags(hw);
@@ -462,7 +445,7 @@
static int
aq_hw_offload_set(struct aq_hw *hw)
{
- int err = 0;
+ int err;
AQ_DBG_ENTER();
/* TX checksums offloads*/
@@ -546,7 +529,7 @@
static int
aq_hw_init_rx_path(struct aq_hw *hw)
{
- //struct aq_nic_cfg_s *cfg = hw->aq_nic_cfg;
+ //struct aq_nic_cfg *cfg = hw->aq_nic_cfg;
unsigned int control_reg_val = 0U;
int i;
int err;
@@ -766,63 +749,63 @@
* for the particular vlan ids.
* Note: use this function under vlan promisc mode not to lost the traffic
*
- * @param aq_hw_s
+ * @param aq_hw
* @param aq_rx_filter_vlan VLAN filter configuration
* @return 0 - OK, <0 - error
*/
int
-hw_atl_b0_hw_vlan_set(struct aq_hw_s *self, struct aq_rx_filter_vlan *aq_vlans)
+hw_atl_b0_hw_vlan_set(struct aq_hw *hw, struct aq_rx_filter_vlan *aq_vlans)
{
int i;
for (i = 0; i < AQ_HW_VLAN_MAX_FILTERS; i++) {
- hw_atl_rpf_vlan_flr_en_set(self, 0U, i);
- hw_atl_rpf_vlan_rxq_en_flr_set(self, 0U, i);
+ hw_atl_rpf_vlan_flr_en_set(hw, 0U, i);
+ hw_atl_rpf_vlan_rxq_en_flr_set(hw, 0U, i);
if (aq_vlans[i].enable) {
- hw_atl_rpf_vlan_id_flr_set(self,
+ hw_atl_rpf_vlan_id_flr_set(hw,
aq_vlans[i].vlan_id,
i);
- hw_atl_rpf_vlan_flr_act_set(self, 1U, i);
- hw_atl_rpf_vlan_flr_en_set(self, 1U, i);
+ hw_atl_rpf_vlan_flr_act_set(hw, 1U, i);
+ hw_atl_rpf_vlan_flr_en_set(hw, 1U, i);
if (aq_vlans[i].queue != 0xFF) {
- hw_atl_rpf_vlan_rxq_flr_set(self,
+ hw_atl_rpf_vlan_rxq_flr_set(hw,
aq_vlans[i].queue,
i);
- hw_atl_rpf_vlan_rxq_en_flr_set(self, 1U, i);
+ hw_atl_rpf_vlan_rxq_en_flr_set(hw, 1U, i);
}
}
}
- return aq_hw_err_from_flags(self);
+ return aq_hw_err_from_flags(hw);
}
int
-hw_atl_b0_hw_vlan_promisc_set(struct aq_hw_s *self, bool promisc)
+hw_atl_b0_hw_vlan_promisc_set(struct aq_hw *hw, bool promisc)
{
- hw_atl_rpf_vlan_prom_mode_en_set(self, promisc);
- return aq_hw_err_from_flags(self);
+ hw_atl_rpf_vlan_prom_mode_en_set(hw, promisc);
+ return aq_hw_err_from_flags(hw);
}
void
-aq_hw_set_promisc(struct aq_hw_s *self, bool l2_promisc, bool vlan_promisc,
+aq_hw_set_promisc(struct aq_hw *hw, bool l2_promisc, bool vlan_promisc,
bool mc_promisc)
{
AQ_DBG_ENTERA("promisc %d, vlan_promisc %d, allmulti %d", l2_promisc,
vlan_promisc, mc_promisc);
- rpfl2promiscuous_mode_en_set(self, l2_promisc);
+ rpfl2promiscuous_mode_en_set(hw, l2_promisc);
- hw_atl_b0_hw_vlan_promisc_set(self, l2_promisc | vlan_promisc);
+ hw_atl_b0_hw_vlan_promisc_set(hw, l2_promisc | vlan_promisc);
- rpfl2_accept_all_mc_packets_set(self, mc_promisc);
- rpfl2multicast_flr_en_set(self, mc_promisc, 0);
+ rpfl2_accept_all_mc_packets_set(hw, mc_promisc);
+ rpfl2multicast_flr_en_set(hw, mc_promisc, 0);
AQ_DBG_EXIT(0);
}
int
-aq_hw_rss_hash_set(struct aq_hw_s *self,
+aq_hw_rss_hash_set(struct aq_hw *hw,
uint8_t rss_key[HW_ATL_RSS_HASHKEY_SIZE])
{
uint32_t rss_key_dw[HW_ATL_RSS_HASHKEY_SIZE / 4];
@@ -836,16 +819,16 @@
for (i = 10, addr = 0U; i--; ++addr) {
uint32_t key_data = bswap32(rss_key_dw[i]);
- rpf_rss_key_wr_data_set(self, key_data);
- rpf_rss_key_addr_set(self, addr);
- rpf_rss_key_wr_en_set(self, 1U);
- err = AQ_HW_WAIT_FOR(rpf_rss_key_wr_en_get(self) == 0,
+ rpf_rss_key_wr_data_set(hw, key_data);
+ rpf_rss_key_addr_set(hw, addr);
+ rpf_rss_key_wr_en_set(hw, 1U);
+ err = AQ_HW_WAIT_FOR(rpf_rss_key_wr_en_get(hw) == 0,
1000U, 10U);
if (err != 0)
goto err_exit;
}
- err = aq_hw_err_from_flags(self);
+ err = aq_hw_err_from_flags(hw);
err_exit:
AQ_DBG_EXIT(err);
@@ -853,7 +836,7 @@
}
int
-aq_hw_rss_hash_get(struct aq_hw_s *self,
+aq_hw_rss_hash_get(struct aq_hw *hw,
uint8_t rss_key[HW_ATL_RSS_HASHKEY_SIZE])
{
uint32_t rss_key_dw[HW_ATL_RSS_HASHKEY_SIZE / 4];
@@ -864,19 +847,19 @@
AQ_DBG_ENTER();
for (i = 10, addr = 0U; i--; ++addr) {
- rpf_rss_key_addr_set(self, addr);
- rss_key_dw[i] = bswap32(rpf_rss_key_rd_data_get(self));
+ rpf_rss_key_addr_set(hw, addr);
+ rss_key_dw[i] = bswap32(rpf_rss_key_rd_data_get(hw));
}
memcpy(rss_key, rss_key_dw, HW_ATL_RSS_HASHKEY_SIZE);
- err = aq_hw_err_from_flags(self);
+ err = aq_hw_err_from_flags(hw);
AQ_DBG_EXIT(err);
return (err);
}
int
-aq_hw_rss_set(struct aq_hw_s *self,
+aq_hw_rss_set(struct aq_hw *hw,
uint8_t rss_table[HW_ATL_RSS_INDIRECTION_TABLE_MAX])
{
uint16_t bitary[(HW_ATL_RSS_INDIRECTION_TABLE_MAX *
@@ -895,28 +878,28 @@
bitary[word] |= (uint16_t)field;
if (shift + HW_ATL_RSS_INDIRECTION_ENTRY_BITS > 16U &&
- word + 1U < ARRAY_SIZE(bitary))
+ word + 1U < nitems(bitary))
bitary[word + 1U] |= (uint16_t)(field >> 16);
}
- for (i = ARRAY_SIZE(bitary); i--;) {
- rpf_rss_redir_tbl_wr_data_set(self, bitary[i]);
- rpf_rss_redir_tbl_addr_set(self, i);
- rpf_rss_redir_wr_en_set(self, 1U);
- err = AQ_HW_WAIT_FOR(rpf_rss_redir_wr_en_get(self) == 0,
+ for (i = nitems(bitary); i--;) {
+ rpf_rss_redir_tbl_wr_data_set(hw, bitary[i]);
+ rpf_rss_redir_tbl_addr_set(hw, i);
+ rpf_rss_redir_wr_en_set(hw, 1U);
+ err = AQ_HW_WAIT_FOR(rpf_rss_redir_wr_en_get(hw) == 0,
1000U, 10U);
if (err != 0)
goto err_exit;
}
- err = aq_hw_err_from_flags(self);
+ err = aq_hw_err_from_flags(hw);
err_exit:
return (err);
}
int
-aq_hw_udp_rss_enable(struct aq_hw_s *self, bool enable)
+aq_hw_udp_rss_enable(struct aq_hw *hw, bool enable)
{
int err = 0;
if (!enable) {
@@ -925,17 +908,17 @@
* HW does not track RSS stream for fragmenged UDP,
* 0x5040 control reg does not work.
*/
- hw_atl_rpf_l3_l4_enf_set(self, true, 0);
- hw_atl_rpf_l4_protf_en_set(self, true, 0);
- hw_atl_rpf_l3_l4_rxqf_en_set(self, true, 0);
- hw_atl_rpf_l3_l4_actf_set(self, L2_FILTER_ACTION_HOST, 0);
- hw_atl_rpf_l3_l4_rxqf_set(self, 0, 0);
- hw_atl_rpf_l4_protf_set(self, HW_ATL_RX_UDP, 0);
+ hw_atl_rpf_l3_l4_enf_set(hw, true, 0);
+ hw_atl_rpf_l4_protf_en_set(hw, true, 0);
+ hw_atl_rpf_l3_l4_rxqf_en_set(hw, true, 0);
+ hw_atl_rpf_l3_l4_actf_set(hw, L2_FILTER_ACTION_HOST, 0);
+ hw_atl_rpf_l3_l4_rxqf_set(hw, 0, 0);
+ hw_atl_rpf_l4_protf_set(hw, HW_ATL_RX_UDP, 0);
} else {
- hw_atl_rpf_l3_l4_enf_set(self, false, 0);
+ hw_atl_rpf_l3_l4_enf_set(hw, false, 0);
}
- err = aq_hw_err_from_flags(self);
+ err = aq_hw_err_from_flags(hw);
return (err);
}
diff --git a/sys/dev/aq/aq_hw_llh.c b/sys/dev/aq/aq_hw_llh.c
--- a/sys/dev/aq/aq_hw_llh.c
+++ b/sys/dev/aq/aq_hw_llh.c
@@ -1000,7 +1000,7 @@
void
-hw_atl_rpf_vlan_inner_etht_set(struct aq_hw_s *aq_hw, uint32_t vlan_inner_etht)
+hw_atl_rpf_vlan_inner_etht_set(struct aq_hw *aq_hw, uint32_t vlan_inner_etht)
{
aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_VL_INNER_TPID_ADR,
HW_ATL_RPF_VL_INNER_TPID_MSK,
@@ -1009,7 +1009,7 @@
}
void
-hw_atl_rpf_vlan_outer_etht_set(struct aq_hw_s *aq_hw, uint32_t vlan_outer_etht)
+hw_atl_rpf_vlan_outer_etht_set(struct aq_hw *aq_hw, uint32_t vlan_outer_etht)
{
aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_VL_OUTER_TPID_ADR,
HW_ATL_RPF_VL_OUTER_TPID_MSK,
@@ -1018,7 +1018,7 @@
}
void
-hw_atl_rpf_vlan_prom_mode_en_set(struct aq_hw_s *aq_hw,
+hw_atl_rpf_vlan_prom_mode_en_set(struct aq_hw *aq_hw,
uint32_t vlan_prom_mode_en)
{
aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_VL_PROMIS_MODE_ADR,
@@ -1028,7 +1028,7 @@
}
void
-hw_atl_rpf_vlan_accept_untagged_packets_set(struct aq_hw_s *aq_hw,
+hw_atl_rpf_vlan_accept_untagged_packets_set(struct aq_hw *aq_hw,
uint32_t vlan_acc_untagged_packets)
{
aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_VL_ACCEPT_UNTAGGED_MODE_ADR,
@@ -1038,7 +1038,7 @@
}
void
-hw_atl_rpf_vlan_untagged_act_set(struct aq_hw_s *aq_hw,
+hw_atl_rpf_vlan_untagged_act_set(struct aq_hw *aq_hw,
uint32_t vlan_untagged_act)
{
aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_VL_UNTAGGED_ACT_ADR,
@@ -1048,7 +1048,7 @@
}
void
-hw_atl_rpf_vlan_flr_en_set(struct aq_hw_s *aq_hw, uint32_t vlan_flr_en,
+hw_atl_rpf_vlan_flr_en_set(struct aq_hw *aq_hw, uint32_t vlan_flr_en,
uint32_t filter)
{
aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_VL_EN_F_ADR(filter),
@@ -1058,7 +1058,7 @@
}
void
-hw_atl_rpf_vlan_flr_act_set(struct aq_hw_s *aq_hw, uint32_t vlan_flr_act,
+hw_atl_rpf_vlan_flr_act_set(struct aq_hw *aq_hw, uint32_t vlan_flr_act,
uint32_t filter)
{
aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_VL_ACT_F_ADR(filter),
@@ -1068,7 +1068,7 @@
}
void
-hw_atl_rpf_vlan_id_flr_set(struct aq_hw_s *aq_hw, uint32_t vlan_id_flr,
+hw_atl_rpf_vlan_id_flr_set(struct aq_hw *aq_hw, uint32_t vlan_id_flr,
uint32_t filter)
{
aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_VL_ID_F_ADR(filter),
@@ -1078,7 +1078,7 @@
}
void
-hw_atl_rpf_vlan_rxq_en_flr_set(struct aq_hw_s *aq_hw, uint32_t vlan_rxq_en,
+hw_atl_rpf_vlan_rxq_en_flr_set(struct aq_hw *aq_hw, uint32_t vlan_rxq_en,
uint32_t filter)
{
aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_VL_RXQ_EN_F_ADR(filter),
@@ -1088,7 +1088,7 @@
}
void
-hw_atl_rpf_vlan_rxq_flr_set(struct aq_hw_s *aq_hw, uint32_t vlan_rxq,
+hw_atl_rpf_vlan_rxq_flr_set(struct aq_hw *aq_hw, uint32_t vlan_rxq,
uint32_t filter)
{
aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_VL_RXQ_F_ADR(filter),
@@ -1098,7 +1098,7 @@
};
void
-hw_atl_rpf_etht_flr_en_set(struct aq_hw_s *aq_hw, uint32_t etht_flr_en,
+hw_atl_rpf_etht_flr_en_set(struct aq_hw *aq_hw, uint32_t etht_flr_en,
uint32_t filter)
{
aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_ET_ENF_ADR(filter),
@@ -1107,7 +1107,7 @@
}
void
-hw_atl_rpf_etht_user_priority_en_set(struct aq_hw_s *aq_hw,
+hw_atl_rpf_etht_user_priority_en_set(struct aq_hw *aq_hw,
uint32_t etht_user_priority_en, uint32_t filter)
{
aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_ET_UPFEN_ADR(filter),
@@ -1116,7 +1116,7 @@
}
void
-hw_atl_rpf_etht_rx_queue_en_set(struct aq_hw_s *aq_hw,
+hw_atl_rpf_etht_rx_queue_en_set(struct aq_hw *aq_hw,
uint32_t etht_rx_queue_en, uint32_t filter)
{
aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_ET_RXQFEN_ADR(filter),
@@ -1126,7 +1126,7 @@
}
void
-hw_atl_rpf_etht_user_priority_set(struct aq_hw_s *aq_hw,
+hw_atl_rpf_etht_user_priority_set(struct aq_hw *aq_hw,
uint32_t etht_user_priority, uint32_t filter)
{
aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_ET_UPF_ADR(filter),
@@ -1135,7 +1135,7 @@
}
void
-hw_atl_rpf_etht_rx_queue_set(struct aq_hw_s *aq_hw, uint32_t etht_rx_queue,
+hw_atl_rpf_etht_rx_queue_set(struct aq_hw *aq_hw, uint32_t etht_rx_queue,
uint32_t filter)
{
aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_ET_RXQF_ADR(filter),
@@ -1144,7 +1144,7 @@
}
void
-hw_atl_rpf_etht_mgt_queue_set(struct aq_hw_s *aq_hw, uint32_t etht_mgt_queue,
+hw_atl_rpf_etht_mgt_queue_set(struct aq_hw *aq_hw, uint32_t etht_mgt_queue,
uint32_t filter)
{
aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_ET_MNG_RXQF_ADR(filter),
@@ -1154,7 +1154,7 @@
}
void
-hw_atl_rpf_etht_flr_act_set(struct aq_hw_s *aq_hw, uint32_t etht_flr_act,
+hw_atl_rpf_etht_flr_act_set(struct aq_hw *aq_hw, uint32_t etht_flr_act,
uint32_t filter)
{
aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_ET_ACTF_ADR(filter),
@@ -1163,7 +1163,7 @@
}
void
-hw_atl_rpf_etht_flr_set(struct aq_hw_s *aq_hw, uint32_t etht_flr,
+hw_atl_rpf_etht_flr_set(struct aq_hw *aq_hw, uint32_t etht_flr,
uint32_t filter)
{
aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_ET_VALF_ADR(filter),
@@ -1172,7 +1172,7 @@
}
void
-hw_atl_rpf_l3_l4_enf_set(struct aq_hw_s *aq_hw, uint32_t val, uint32_t filter)
+hw_atl_rpf_l3_l4_enf_set(struct aq_hw *aq_hw, uint32_t val, uint32_t filter)
{
aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_L3_L4_ENF_ADR(filter),
HW_ATL_RPF_L3_L4_ENF_MSK,
@@ -1180,7 +1180,7 @@
}
void
-hw_atl_rpf_l3_v6_enf_set(struct aq_hw_s *aq_hw, uint32_t val, uint32_t filter)
+hw_atl_rpf_l3_v6_enf_set(struct aq_hw *aq_hw, uint32_t val, uint32_t filter)
{
aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_L3_V6_ENF_ADR(filter),
HW_ATL_RPF_L3_V6_ENF_MSK,
@@ -1188,7 +1188,7 @@
}
void
-hw_atl_rpf_l3_saf_en_set(struct aq_hw_s *aq_hw, uint32_t val, uint32_t filter)
+hw_atl_rpf_l3_saf_en_set(struct aq_hw *aq_hw, uint32_t val, uint32_t filter)
{
aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_L3_SAF_EN_ADR(filter),
HW_ATL_RPF_L3_SAF_EN_MSK,
@@ -1196,7 +1196,7 @@
}
void
-hw_atl_rpf_l3_daf_en_set(struct aq_hw_s *aq_hw, uint32_t val, uint32_t filter)
+hw_atl_rpf_l3_daf_en_set(struct aq_hw *aq_hw, uint32_t val, uint32_t filter)
{
aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_L3_DAF_EN_ADR(filter),
HW_ATL_RPF_L3_DAF_EN_MSK,
@@ -1204,7 +1204,7 @@
}
void
-hw_atl_rpf_l4_spf_en_set(struct aq_hw_s *aq_hw, uint32_t val, uint32_t filter)
+hw_atl_rpf_l4_spf_en_set(struct aq_hw *aq_hw, uint32_t val, uint32_t filter)
{
aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_L4_SPF_EN_ADR(filter),
HW_ATL_RPF_L4_SPF_EN_MSK,
@@ -1212,7 +1212,7 @@
}
void
-hw_atl_rpf_l4_dpf_en_set(struct aq_hw_s *aq_hw, uint32_t val, uint32_t filter)
+hw_atl_rpf_l4_dpf_en_set(struct aq_hw *aq_hw, uint32_t val, uint32_t filter)
{
aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_L4_DPF_EN_ADR(filter),
HW_ATL_RPF_L4_DPF_EN_MSK,
@@ -1220,7 +1220,7 @@
}
void
-hw_atl_rpf_l4_protf_en_set(struct aq_hw_s *aq_hw, uint32_t val, uint32_t filter)
+hw_atl_rpf_l4_protf_en_set(struct aq_hw *aq_hw, uint32_t val, uint32_t filter)
{
aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_L4_PROTF_EN_ADR(filter),
HW_ATL_RPF_L4_PROTF_EN_MSK,
@@ -1228,7 +1228,7 @@
}
void
-hw_atl_rpf_l3_arpf_en_set(struct aq_hw_s *aq_hw, uint32_t val, uint32_t filter)
+hw_atl_rpf_l3_arpf_en_set(struct aq_hw *aq_hw, uint32_t val, uint32_t filter)
{
aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_L3_ARPF_EN_ADR(filter),
HW_ATL_RPF_L3_ARPF_EN_MSK,
@@ -1236,7 +1236,7 @@
}
void
-hw_atl_rpf_l3_l4_rxqf_en_set(struct aq_hw_s *aq_hw, uint32_t val,
+hw_atl_rpf_l3_l4_rxqf_en_set(struct aq_hw *aq_hw, uint32_t val,
uint32_t filter)
{
aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_L3_L4_RXQF_EN_ADR(filter),
@@ -1245,7 +1245,7 @@
}
void
-hw_atl_rpf_l3_l4_mng_rxqf_set(struct aq_hw_s *aq_hw, uint32_t val,
+hw_atl_rpf_l3_l4_mng_rxqf_set(struct aq_hw *aq_hw, uint32_t val,
uint32_t filter)
{
aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_L3_L4_MNG_RXQF_ADR(filter),
@@ -1254,7 +1254,7 @@
}
void
-hw_atl_rpf_l3_l4_actf_set(struct aq_hw_s *aq_hw, uint32_t val, uint32_t filter)
+hw_atl_rpf_l3_l4_actf_set(struct aq_hw *aq_hw, uint32_t val, uint32_t filter)
{
aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_L3_L4_ACTF_ADR(filter),
HW_ATL_RPF_L3_L4_ACTF_MSK,
@@ -1262,7 +1262,7 @@
}
void
-hw_atl_rpf_l3_l4_rxqf_set(struct aq_hw_s *aq_hw, uint32_t val, uint32_t filter)
+hw_atl_rpf_l3_l4_rxqf_set(struct aq_hw *aq_hw, uint32_t val, uint32_t filter)
{
aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_L3_L4_RXQF_ADR(filter),
HW_ATL_RPF_L3_L4_RXQF_MSK,
@@ -1270,7 +1270,7 @@
}
void
-hw_atl_rpf_l4_protf_set(struct aq_hw_s *aq_hw, uint32_t val, uint32_t filter)
+hw_atl_rpf_l4_protf_set(struct aq_hw *aq_hw, uint32_t val, uint32_t filter)
{
aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_L4_PROTF_ADR(filter),
HW_ATL_RPF_L4_PROTF_MSK,
@@ -1278,7 +1278,7 @@
}
void
-hw_atl_rpf_l4_spd_set(struct aq_hw_s *aq_hw, uint32_t val, uint32_t filter)
+hw_atl_rpf_l4_spd_set(struct aq_hw *aq_hw, uint32_t val, uint32_t filter)
{
aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_L4_SPD_ADR(filter),
HW_ATL_RPF_L4_SPD_MSK,
@@ -1286,7 +1286,7 @@
}
void
-hw_atl_rpf_l4_dpd_set(struct aq_hw_s *aq_hw, uint32_t val, uint32_t filter)
+hw_atl_rpf_l4_dpd_set(struct aq_hw *aq_hw, uint32_t val, uint32_t filter)
{
aq_hw_write_reg_bit(aq_hw, HW_ATL_RPF_L4_DPD_ADR(filter),
HW_ATL_RPF_L4_DPD_MSK,
@@ -2008,25 +2008,25 @@
}
void
-hw_atl_rpfl3l4_ipv4_dest_addr_clear(struct aq_hw_s *aq_hw, uint8_t location)
+hw_atl_rpfl3l4_ipv4_dest_addr_clear(struct aq_hw *aq_hw, uint8_t location)
{
aq_hw_write_reg(aq_hw, HW_ATL_RX_GET_ADDR_DESTA_FL3L4(location), 0U);
}
void
-hw_atl_rpfl3l4_ipv4_src_addr_clear(struct aq_hw_s *aq_hw, uint8_t location)
+hw_atl_rpfl3l4_ipv4_src_addr_clear(struct aq_hw *aq_hw, uint8_t location)
{
aq_hw_write_reg(aq_hw, HW_ATL_RX_GET_ADDR_SRCA_FL3L4(location), 0U);
}
void
-hw_atl_rpfl3l4_cmd_clear(struct aq_hw_s *aq_hw, uint8_t location)
+hw_atl_rpfl3l4_cmd_clear(struct aq_hw *aq_hw, uint8_t location)
{
aq_hw_write_reg(aq_hw, HW_ATL_RX_GET_ADDR_CTRL_FL3L4(location), 0U);
}
void
-hw_atl_rpfl3l4_ipv6_dest_addr_clear(struct aq_hw_s *aq_hw, uint8_t location)
+hw_atl_rpfl3l4_ipv6_dest_addr_clear(struct aq_hw *aq_hw, uint8_t location)
{
int i;
@@ -2036,7 +2036,7 @@
}
void
-hw_atl_rpfl3l4_ipv6_src_addr_clear(struct aq_hw_s *aq_hw, uint8_t location)
+hw_atl_rpfl3l4_ipv6_src_addr_clear(struct aq_hw *aq_hw, uint8_t location)
{
int i;
@@ -2046,7 +2046,7 @@
}
void
-hw_atl_rpfl3l4_ipv4_dest_addr_set(struct aq_hw_s *aq_hw, uint8_t location,
+hw_atl_rpfl3l4_ipv4_dest_addr_set(struct aq_hw *aq_hw, uint8_t location,
uint32_t ipv4_dest)
{
aq_hw_write_reg(aq_hw, HW_ATL_RX_GET_ADDR_DESTA_FL3L4(location),
@@ -2054,7 +2054,7 @@
}
void
-hw_atl_rpfl3l4_ipv4_src_addr_set(struct aq_hw_s *aq_hw, uint8_t location,
+hw_atl_rpfl3l4_ipv4_src_addr_set(struct aq_hw *aq_hw, uint8_t location,
uint32_t ipv4_src)
{
aq_hw_write_reg(aq_hw, HW_ATL_RX_GET_ADDR_SRCA_FL3L4(location),
@@ -2062,13 +2062,13 @@
}
void
-hw_atl_rpfl3l4_cmd_set(struct aq_hw_s *aq_hw, uint8_t location, uint32_t cmd)
+hw_atl_rpfl3l4_cmd_set(struct aq_hw *aq_hw, uint8_t location, uint32_t cmd)
{
aq_hw_write_reg(aq_hw, HW_ATL_RX_GET_ADDR_CTRL_FL3L4(location), cmd);
}
void
-hw_atl_rpfl3l4_ipv6_src_addr_set(struct aq_hw_s *aq_hw, uint8_t location,
+hw_atl_rpfl3l4_ipv6_src_addr_set(struct aq_hw *aq_hw, uint8_t location,
uint32_t *ipv6_src)
{
int i;
@@ -2079,7 +2079,7 @@
}
void
-hw_atl_rpfl3l4_ipv6_dest_addr_set(struct aq_hw_s *aq_hw, uint8_t location,
+hw_atl_rpfl3l4_ipv6_dest_addr_set(struct aq_hw *aq_hw, uint8_t location,
uint32_t *ipv6_dest)
{
int i;
diff --git a/sys/dev/aq/aq_irq.c b/sys/dev/aq/aq_irq.c
--- a/sys/dev/aq/aq_irq.c
+++ b/sys/dev/aq/aq_irq.c
@@ -42,8 +42,6 @@
#include <sys/socket.h>
#include <net/ethernet.h>
#include <net/if.h>
-#include <net/if_dl.h>
-#include <net/if_media.h>
#include <net/if_var.h>
#include <net/iflib.h>
@@ -55,7 +53,7 @@
#include "aq_hw_llh.h"
int
-aq_update_hw_stats(aq_dev_t *aq_dev)
+aq_update_hw_stats(struct aq_dev *aq_dev)
{
struct aq_hw *hw = &aq_dev->hw;
struct aq_hw_fw_mbox mbox;
@@ -105,7 +103,7 @@
void
aq_if_update_admin_status(if_ctx_t ctx)
{
- aq_dev_t *aq_dev = iflib_get_softc(ctx);
+ struct aq_dev *aq_dev = iflib_get_softc(ctx);
struct aq_hw *hw = &aq_dev->hw;
uint32_t link_speed;
@@ -119,15 +117,6 @@
aq_dev->linkup = 1;
-#if __FreeBSD__ >= 12
- /* Disable TSO if link speed < 1G */
- if (link_speed < 1000 && (iflib_get_softc_ctx(ctx)->isc_capabilities & (IFCAP_TSO4 | IFCAP_TSO6))) {
- iflib_get_softc_ctx(ctx)->isc_capabilities &= ~(IFCAP_TSO4 | IFCAP_TSO6);
- device_printf(aq_dev->dev, "atlantic: TSO disabled for link speed < 1G");
- }else{
- iflib_get_softc_ctx(ctx)->isc_capabilities |= (IFCAP_TSO4 | IFCAP_TSO6);
- }
-#endif
/* turn on/off RX Pause in RPB */
rpb_rx_xoff_en_per_tc_set(hw, fc_neg.fc_rx, 0);
@@ -175,7 +164,7 @@
int
aq_linkstat_isr(void *arg)
{
- aq_dev_t *aq_dev = arg;
+ struct aq_dev *aq_dev = arg;
struct aq_hw *hw = &aq_dev->hw;
itr_irq_status_clearlsw_set(hw, BIT(aq_dev->msix));
diff --git a/sys/dev/aq/aq_main.c b/sys/dev/aq/aq_main.c
--- a/sys/dev/aq/aq_main.c
+++ b/sys/dev/aq/aq_main.c
@@ -42,15 +42,12 @@
#include <sys/param.h>
#include <sys/bitstring.h>
#include <sys/bus.h>
-#include <sys/endian.h>
#include <sys/kernel.h>
#include <sys/malloc.h>
#include <sys/module.h>
-#include <sys/priv.h>
#include <sys/rman.h>
#include <sys/sbuf.h>
#include <sys/socket.h>
-#include <sys/sockio.h>
#include <sys/sysctl.h>
#include <machine/bus.h>
@@ -76,12 +73,6 @@
#include "aq_ring.h"
#include "aq_dbg.h"
-
-#define AQ_XXX_UNIMPLEMENTED_FUNCTION do { \
- printf("atlantic: unimplemented function: %s@%s:%d\n", __func__, \
- __FILE__, __LINE__); \
-} while (0)
-
MALLOC_DEFINE(M_AQ, "aq", "Aquantia");
char aq_driver_version[] = AQ_VER;
@@ -210,13 +201,9 @@
"aq", aq_methods, sizeof(struct aq_dev),
};
-#if __FreeBSD_version >= 1400058
DRIVER_MODULE(atlantic, pci, aq_driver, 0, 0);
-#else
-static devclass_t aq_devclass;
-DRIVER_MODULE(atlantic, pci, aq_driver, aq_devclass, 0, 0);
-#endif
+MODULE_VERSION(atlantic, 1);
MODULE_DEPEND(atlantic, pci, 1, 1, 1);
MODULE_DEPEND(atlantic, ether, 1, 1, 1);
MODULE_DEPEND(atlantic, iflib, 1, 1, 1);
@@ -276,10 +263,8 @@
.isc_q_align = PAGE_SIZE,
.isc_tx_maxsize = HW_ATL_B0_TSO_SIZE,
.isc_tx_maxsegsize = HW_ATL_B0_MTU_JUMBO,
-#if __FreeBSD__ >= 12
.isc_tso_maxsize = HW_ATL_B0_TSO_SIZE,
.isc_tso_maxsegsize = HW_ATL_B0_MTU_JUMBO,
-#endif
.isc_rx_maxsize = HW_ATL_B0_MTU_JUMBO,
.isc_rx_nsegments = 16,
.isc_rx_maxsegsize = PAGE_SIZE,
@@ -297,8 +282,8 @@
.isc_ntxd_min = {HW_ATL_B0_MIN_TXD},
.isc_nrxd_max = {HW_ATL_B0_MAX_RXD},
.isc_ntxd_max = {HW_ATL_B0_MAX_TXD},
- .isc_nrxd_default = {PAGE_SIZE / sizeof(aq_txc_desc_t) * 4},
- .isc_ntxd_default = {PAGE_SIZE / sizeof(aq_txc_desc_t) * 4},
+ .isc_nrxd_default = {PAGE_SIZE / sizeof(volatile union aq_txc_desc) * 4},
+ .isc_ntxd_default = {PAGE_SIZE / sizeof(volatile union aq_txc_desc) * 4},
};
/*
@@ -355,6 +340,7 @@
softc->mmio_size = rman_get_size(softc->mmio_res);
softc->hw.hw_tag = softc->mmio_tag;
softc->hw.hw_handle = softc->mmio_handle;
+ softc->hw.dev = softc->dev;
hw = &softc->hw;
hw->link_rate = aq_fw_speed_auto;
hw->itr = -1;
@@ -365,44 +351,32 @@
/* Look up ops and caps. */
rc = aq_hw_mpi_create(hw);
if (rc != 0) {
- AQ_DBG_ERROR(" %s: aq_hw_mpi_create fail err=%d", __func__, rc);
+ device_printf(softc->dev,
+ "%s: aq_hw_mpi_create failed, err=%d\n", __func__, rc);
goto fail;
}
- if (hw->fast_start_enabled) {
- if (hw->fw_ops && hw->fw_ops->reset)
- hw->fw_ops->reset(hw);
- } else
+ if (hw->fast_start_enabled)
+ hw->fw_ops->reset(hw);
+ else
aq_hw_reset(&softc->hw);
aq_hw_capabilities(softc);
rc = aq_hw_get_mac_permanent(hw, hw->mac_addr);
if (rc != 0) {
- AQ_DBG_ERROR("Unable to get mac addr from hw");
+ device_printf(softc->dev, "unable to get MAC address from HW\n");
goto fail;
}
softc->admin_ticks = 0;
iflib_set_mac(ctx, hw->mac_addr);
-#if __FreeBSD__ < 13
- /* since FreeBSD13 deadlock due to calling iflib_led_func() under CTX_LOCK() */
- iflib_led_create(ctx);
-#endif
scctx->isc_tx_csum_flags = CSUM_IP | CSUM_TCP | CSUM_UDP | CSUM_TSO;
-#if __FreeBSD__ >= 12
scctx->isc_capabilities = IFCAP_RXCSUM | IFCAP_TXCSUM | IFCAP_HWCSUM |
IFCAP_TSO | IFCAP_LRO | IFCAP_JUMBO_MTU | IFCAP_VLAN_HWFILTER |
IFCAP_VLAN_MTU | IFCAP_VLAN_HWTAGGING | IFCAP_VLAN_HWCSUM;
scctx->isc_capenable = scctx->isc_capabilities;
-#else
- if_t ifp;
- ifp = iflib_get_ifp(ctx);
- if_setcapenable(ifp, IFCAP_RXCSUM | IFCAP_TXCSUM | IFCAP_HWCSUM |
- IFCAP_TSO | IFCAP_JUMBO_MTU | IFCAP_VLAN_HWFILTER | IFCAP_VLAN_MTU |
- IFCAP_VLAN_HWTAGGING | IFCAP_VLAN_HWCSUM;
-#endif
- scctx->isc_tx_nsegments = 31,
+ scctx->isc_tx_nsegments = 31;
scctx->isc_tx_tso_segments_max = 31;
scctx->isc_tx_tso_size_max =
HW_ATL_B0_TSO_SIZE - sizeof(struct ether_vlan_header);
@@ -412,8 +386,8 @@
ETHER_VLAN_ENCAP_LEN;
scctx->isc_txrx = &aq_txrx;
- scctx->isc_txqsizes[0] = sizeof(aq_tx_desc_t) * scctx->isc_ntxd[0];
- scctx->isc_rxqsizes[0] = sizeof(aq_rx_desc_t) * scctx->isc_nrxd[0];
+ scctx->isc_txqsizes[0] = sizeof(volatile struct aq_tx_desc) * scctx->isc_ntxd[0];
+ scctx->isc_rxqsizes[0] = sizeof(volatile struct aq_rx_desc) * scctx->isc_nrxd[0];
scctx->isc_ntxqsets_max = HW_ATL_B0_RINGS_MAX;
scctx->isc_nrxqsets_max = HW_ATL_RSS_INDIRECTION_QUEUES_MAX;
@@ -476,7 +450,7 @@
/* RSS */
arc4rand(softc->rss_key, HW_ATL_RSS_HASHKEY_SIZE, 0);
uint32_t rss_qs = MIN(softc->rx_rings_count, HW_ATL_RSS_INDIRECTION_QUEUES_MAX);
- for (int i = ARRAY_SIZE(softc->rss_table); i--;){
+ for (int i = nitems(softc->rss_table); i--;){
softc->rss_table[i] = i % rss_qs;
}
exit:
@@ -600,7 +574,7 @@
device_printf(softc->dev, "atlantic: tx_ring malloc fail\n");
goto fail;
}
- ring->tx_descs = (aq_tx_desc_t*)vaddrs[i];
+ ring->tx_descs = (volatile struct aq_tx_desc*)vaddrs[i];
ring->tx_size = softc->scctx->isc_ntxd[0];
ring->tx_descs_phys = paddrs[i];
ring->tx_head = ring->tx_tail = 0;
@@ -647,23 +621,12 @@
goto fail;
}
- ring->rx_descs = (aq_rx_desc_t*)vaddrs[i];
+ ring->rx_descs = (volatile struct aq_rx_desc*)vaddrs[i];
ring->rx_descs_phys = paddrs[i];
ring->rx_size = softc->scctx->isc_nrxd[0];
ring->index = i;
ring->dev = softc;
- switch (MCLBYTES) {
- case (4 * 1024):
- case (8 * 1024):
- case (16 * 1024):
- ring->rx_max_frame_size = MCLBYTES;
- break;
- default:
- ring->rx_max_frame_size = 2048;
- break;
- }
-
softc->rx_rings_count++;
rc = aq_ring_stats_alloc(ring);
@@ -755,7 +718,7 @@
}
for (i = 0; i < softc->rx_rings_count; i++) {
struct aq_ring *ring = softc->rx_rings[i];
- ring->rx_max_frame_size = iflib_get_rx_mbuf_sz(ctx);
+ ring->rx_buf_size = iflib_get_rx_mbuf_sz(ctx);
err = aq_ring_rx_init(&softc->hw, ring);
if (err) {
device_printf(softc->dev,
@@ -829,7 +792,6 @@
}
}
-#if __FreeBSD_version >= 1300054
static u_int
aq_mc_filter_apply(void *arg, struct sockaddr_dl *dl, u_int count)
{
@@ -846,26 +808,6 @@
aq_log_detail("set %d mc address %6D", count + 1, mac_addr, ":");
return (1);
}
-#else
-static int
-aq_mc_filter_apply(void *arg, struct ifmultiaddr *ifma, int count)
-{
- struct aq_dev *softc = arg;
- struct aq_hw *hw = &softc->hw;
- uint8_t *mac_addr = NULL;
-
- if (ifma->ifma_addr->sa_family != AF_LINK)
- return (0);
- if (count == AQ_HW_MAC_MAX)
- return (0);
-
- mac_addr = LLADDR((struct sockaddr_dl *)ifma->ifma_addr);
- aq_hw_mac_addr_set(hw, mac_addr, count + 1);
-
- aq_log_detail("set %d mc address %6D", count + 1, mac_addr, ":");
- return (1);
-}
-#endif
static bool
aq_is_mc_promisc_required(struct aq_dev *softc)
@@ -880,21 +822,13 @@
if_t ifp = iflib_get_ifp(ctx);
struct aq_hw *hw = &softc->hw;
AQ_DBG_ENTER();
-#if __FreeBSD_version >= 1300054
softc->mcnt = if_llmaddr_count(iflib_get_ifp(ctx));
-#else
- softc->mcnt = if_multiaddr_count(iflib_get_ifp(ctx), AQ_HW_MAC_MAX);
-#endif
if (softc->mcnt >= AQ_HW_MAC_MAX) {
aq_hw_set_promisc(hw, !!(if_getflags(ifp) & IFF_PROMISC),
aq_is_vlan_promisc_required(softc),
!!(if_getflags(ifp) & IFF_ALLMULTI) || aq_is_mc_promisc_required(softc));
} else {
-#if __FreeBSD_version >= 1300054
if_foreach_llmaddr(iflib_get_ifp(ctx), &aq_mc_filter_apply, softc);
-#else
- if_multi_apply(iflib_get_ifp(ctx), aq_mc_filter_apply, softc);
-#endif
}
AQ_DBG_EXIT(0);
}
@@ -1192,7 +1126,7 @@
struct aq_hw *hw = &softc->hw;
AQ_DBG_ENTERA("%d", onoff);
- if (hw->fw_ops && hw->fw_ops->led_control)
+ if (hw->fw_ops->led_control)
hw->fw_ops->led_control(hw, onoff);
AQ_DBG_EXIT(0);
@@ -1366,7 +1300,7 @@
struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(dev);
struct sysctl_oid *tree = device_get_sysctl_tree(dev);
struct sysctl_oid_list *child = SYSCTL_CHILDREN(tree);
- struct aq_stats_s *stats = &softc->curr_stats;
+ struct aq_stats *stats = &softc->curr_stats;
struct sysctl_oid *stat_node, *queue_node;
struct sysctl_oid_list *stat_list, *queue_list;
diff --git a/sys/dev/aq/aq_media.c b/sys/dev/aq/aq_media.c
--- a/sys/dev/aq/aq_media.c
+++ b/sys/dev/aq/aq_media.c
@@ -43,7 +43,6 @@
#include <net/if.h>
#include <net/if_media.h>
#include <net/if_var.h>
-#include <net/if_dl.h>
#include <net/iflib.h>
#include "aq_device.h"
@@ -54,7 +53,7 @@
#define AQ_HW_SUPPORT_SPEED(softc, s) ((softc)->link_speeds & s)
void
-aq_mediastatus_update(aq_dev_t *aq_dev, uint32_t link_speed,
+aq_mediastatus_update(struct aq_dev *aq_dev, uint32_t link_speed,
const struct aq_hw_fc_info *fc_neg)
{
struct aq_hw *hw = &aq_dev->hw;
@@ -94,7 +93,7 @@
void
aq_mediastatus(if_t ifp, struct ifmediareq *ifmr)
{
- aq_dev_t *aq_dev = iflib_get_softc(if_getsoftc(ifp));
+ struct aq_dev *aq_dev = iflib_get_softc(if_getsoftc(ifp));
ifmr->ifm_active = IFM_ETHER;
ifmr->ifm_status = IFM_AVALID;
@@ -108,7 +107,7 @@
int
aq_mediachange(if_t ifp)
{
- aq_dev_t *aq_dev = iflib_get_softc(if_getsoftc(ifp));
+ struct aq_dev *aq_dev = iflib_get_softc(if_getsoftc(ifp));
struct aq_hw *hw = &aq_dev->hw;
int old_media_rate = if_getbaudrate(ifp);
int old_link_speed = hw->link_rate;
@@ -163,7 +162,7 @@
break;
default: // should never happen
- aq_log_error("unknown media: 0x%X", user_media);
+ device_printf(hw->dev, "unknown media: 0x%X\n", user_media);
return (0);
}
hw->fc.fc_rx = (ifm->ifm_media & IFM_ETH_RXPAUSE) ? 1 : 0;
@@ -184,7 +183,7 @@
}
static void
-aq_add_media_types(aq_dev_t *aq_dev, int media_link_speed)
+aq_add_media_types(struct aq_dev *aq_dev, int media_link_speed)
{
ifmedia_add(aq_dev->media, IFM_ETHER | media_link_speed | IFM_FDX, 0,
NULL);
@@ -196,7 +195,7 @@
IFM_ETH_TXPAUSE, 0, NULL);
}
void
-aq_initmedia(aq_dev_t *aq_dev)
+aq_initmedia(struct aq_dev *aq_dev)
{
AQ_DBG_ENTER();
diff --git a/sys/dev/aq/aq_ring.h b/sys/dev/aq/aq_ring.h
--- a/sys/dev/aq/aq_ring.h
+++ b/sys/dev/aq/aq_ring.h
@@ -42,7 +42,7 @@
#define REFILL_THRESHOLD 128
-typedef volatile struct {
+struct aq_rx_wb {
uint32_t rss_type:4;
uint32_t pkt_type:8;
uint32_t rdm_err:1;
@@ -59,9 +59,9 @@
uint16_t pkt_len;
uint16_t next_desp;
uint16_t vlan;
-} __attribute__((__packed__)) aq_rx_wb_t;
+} __packed;
-typedef volatile struct {
+struct aq_rx_desc {
union {
/* HW RX descriptor */
struct __packed {
@@ -70,12 +70,12 @@
} read;
/* HW RX descriptor writeback */
- aq_rx_wb_t wb;
+ struct aq_rx_wb wb;
};
-} __attribute__((__packed__)) aq_rx_desc_t;
+} __packed;
/* Hardware tx descriptor */
-typedef volatile struct {
+struct aq_tx_desc {
uint64_t buf_addr;
union {
@@ -90,10 +90,10 @@
uint32_t ct_idx:1;
uint32_t ct_en:1;
uint32_t pay_len:18;
- } __attribute__((__packed__));
+ } __packed;
uint64_t flags;
};
-} __attribute__((__packed__)) aq_tx_desc_t;
+} __packed;
enum aq_tx_desc_type {
tx_desc_type_desc = 1,
@@ -110,7 +110,7 @@
};
/* Hardware tx context descriptor */
-typedef volatile union {
+union aq_txc_desc {
struct __packed {
uint64_t flags1;
uint64_t flags2;
@@ -129,7 +129,7 @@
uint32_t l4_len:8;
uint32_t mss_len:16;
};
-} __attribute__((__packed__)) aq_txc_desc_t;
+} __packed;
struct aq_ring_stats {
counter_u64_t rx_pkts;
@@ -151,16 +151,16 @@
int msix;
/* RX */
qidx_t rx_size;
- int rx_max_frame_size;
+ int rx_buf_size;
void *rx_desc_area_ptr;
- aq_rx_desc_t *rx_descs;
+ volatile struct aq_rx_desc *rx_descs;
uint64_t rx_descs_phys;
/* TX */
int tx_head, tx_tail;
qidx_t tx_size;
void *tx_desc_area_ptr;
- aq_tx_desc_t *tx_descs;
+ volatile struct aq_tx_desc *tx_descs;
uint64_t tx_descs_phys;
struct aq_ring_stats stats;
diff --git a/sys/dev/aq/aq_ring.c b/sys/dev/aq/aq_ring.c
--- a/sys/dev/aq/aq_ring.c
+++ b/sys/dev/aq/aq_ring.c
@@ -42,8 +42,6 @@
#include <machine/param.h>
#include <net/ethernet.h>
#include <net/if.h>
-#include <net/if_dl.h>
-#include <net/if_media.h>
#include <net/if_var.h>
#include <net/iflib.h>
#include <netinet/in.h>
@@ -107,10 +105,7 @@
rdm_rx_desc_len_set(hw, ring->rx_size / 8U, ring->index);
- device_printf(ring->dev->dev,
- "ring %d: __PAGESIZE=%d MCLBYTES=%d hw->max_frame_size=%d\n",
- ring->index, PAGE_SIZE, MCLBYTES, ring->rx_max_frame_size);
- rdm_rx_desc_data_buff_size_set(hw, ring->rx_max_frame_size / 1024U,
+ rdm_rx_desc_data_buff_size_set(hw, ring->rx_buf_size / 1024U,
ring->index);
rdm_rx_desc_head_buff_size_set(hw, 0U, ring->index);
@@ -143,7 +138,7 @@
{
int err;
uint32_t dma_desc_addr_lsw = (uint32_t)ring->tx_descs_phys & 0xffffffff;
- uint32_t dma_desc_addr_msw = (uint64_t)(ring->tx_descs_phys >> 32);
+ uint32_t dma_desc_addr_msw = (uint32_t)(ring->tx_descs_phys >> 32);
AQ_DBG_ENTERA("[%d]", ring->index);
@@ -236,8 +231,8 @@
static void
aq_ring_rx_refill(void* arg, if_rxd_update_t iru)
{
- aq_dev_t *aq_dev = arg;
- aq_rx_desc_t *rx_desc;
+ struct aq_dev *aq_dev = arg;
+ volatile struct aq_rx_desc *rx_desc;
struct aq_ring *ring;
qidx_t i, pidx;
@@ -248,7 +243,7 @@
pidx = iru->iru_pidx;
for (i = 0; i < iru->iru_count; i++) {
- rx_desc = (aq_rx_desc_t *) &ring->rx_descs[pidx];
+ rx_desc = (volatile struct aq_rx_desc *) &ring->rx_descs[pidx];
rx_desc->read.buf_addr = htole64(iru->iru_paddrs[i]);
rx_desc->read.hdr_addr = 0;
@@ -261,7 +256,7 @@
static void
aq_isc_rxd_flush(void *arg, uint16_t rxqid, uint8_t flid __unused, qidx_t pidx)
{
- aq_dev_t *aq_dev = arg;
+ struct aq_dev *aq_dev = arg;
struct aq_ring *ring = aq_dev->rx_rings[rxqid];
AQ_DBG_ENTERA("[%d] tail=%u", ring->index, pidx);
@@ -272,9 +267,9 @@
static int
aq_isc_rxd_available(void *arg, uint16_t rxqid, qidx_t idx, qidx_t budget)
{
- aq_dev_t *aq_dev = arg;
+ struct aq_dev *aq_dev = arg;
struct aq_ring *ring = aq_dev->rx_rings[rxqid];
- aq_rx_desc_t *rx_desc = (aq_rx_desc_t *) ring->rx_descs;
+ volatile struct aq_rx_desc *rx_desc = (volatile struct aq_rx_desc *) ring->rx_descs;
int cnt, i, iter;
AQ_DBG_ENTERA("[%d] head=%u, budget %d", ring->index, idx, budget);
@@ -286,17 +281,10 @@
if (!rx_desc[i].wb.dd)
break;
- if (rx_desc[i].wb.eop) {
- iter++;
- i = aq_next(i, ring->rx_size - 1);
-
+ if (rx_desc[i].wb.eop)
cnt++;
- } else {
- /* Jumbo frame spans descriptors; advance. */
- iter++;
- i = aq_next(i, ring->rx_size - 1);
- continue;
- }
+ iter++;
+ i = aq_next(i, ring->rx_size - 1);
}
AQ_DBG_EXIT(cnt);
@@ -304,7 +292,7 @@
}
static void
-aq_rx_set_cso_flags(aq_rx_desc_t *rx_desc, if_rxd_info_t ri)
+aq_rx_set_cso_flags(volatile struct aq_rx_desc *rx_desc, if_rxd_info_t ri)
{
if ((rx_desc->wb.pkt_type & 0x3) == 0) { // IPv4
if (rx_desc->wb.rx_cntl & BIT(0)) { // IPv4 csum checked
@@ -337,9 +325,9 @@
static int
aq_isc_rxd_pkt_get(void *arg, if_rxd_info_t ri)
{
- aq_dev_t *aq_dev = arg;
+ struct aq_dev *aq_dev = arg;
struct aq_ring *ring = aq_dev->rx_rings[ri->iri_qsidx];
- aq_rx_desc_t *rx_desc;
+ volatile struct aq_rx_desc *rx_desc;
if_t ifp;
int cidx, rc = 0, i;
size_t len, total_len;
@@ -350,28 +338,26 @@
i = 0;
do {
- if (i >= aq_dev->sctx->isc_rx_nsegments) {
- counter_u64_add(ring->stats.rx_err, 1);
- rc = (EBADMSG);
- goto exit;
- }
+ if (i >= aq_dev->sctx->isc_rx_nsegments)
+ goto rx_err;
- rx_desc = (aq_rx_desc_t *) &ring->rx_descs[cidx];
+ rx_desc = (volatile struct aq_rx_desc *) &ring->rx_descs[cidx];
trace_aq_rx_descr(ring->index, cidx,
(volatile uint64_t *)rx_desc);
- if ((rx_desc->wb.rx_stat & BIT(0)) != 0) {
- counter_u64_add(ring->stats.rx_err, 1);
- rc = (EBADMSG);
- goto exit;
- }
+ if ((rx_desc->wb.rx_stat & BIT(0)) != 0)
+ goto rx_err;
if (!rx_desc->wb.eop) {
- len = ring->rx_max_frame_size;
+ len = ring->rx_buf_size;
} else {
total_len = le32toh(rx_desc->wb.pkt_len);
- len = total_len - (size_t)i * ring->rx_max_frame_size;
+ if (total_len < (size_t)i * ring->rx_buf_size)
+ goto rx_err;
+ len = total_len - (size_t)i * ring->rx_buf_size;
+ if (len > (size_t)ring->rx_buf_size)
+ goto rx_err;
}
ri->iri_frags[i].irf_flid = 0;
ri->iri_frags[i].irf_idx = cidx;
@@ -399,7 +385,11 @@
counter_u64_add(ring->stats.rx_bytes, total_len);
counter_u64_add(ring->stats.rx_pkts, 1);
+ goto exit;
+rx_err:
+ counter_u64_add(ring->stats.rx_err, 1);
+ rc = EBADMSG;
exit:
AQ_DBG_EXIT(rc);
return (rc);
@@ -410,7 +400,7 @@
/*****************************************************************************/
static void
-aq_setup_offloads(aq_dev_t *aq_dev, if_pkt_info_t pi, aq_tx_desc_t *txd,
+aq_setup_offloads(struct aq_dev *aq_dev, if_pkt_info_t pi, volatile struct aq_tx_desc *txd,
uint32_t tx_cmd)
{
AQ_DBG_ENTER();
@@ -425,8 +415,8 @@
}
static int
-aq_ring_tso_setup(aq_dev_t *aq_dev, if_pkt_info_t pi, uint32_t *hdrlen,
- aq_txc_desc_t *txc)
+aq_ring_tso_setup(struct aq_dev *aq_dev, if_pkt_info_t pi, uint32_t *hdrlen,
+ volatile union aq_txc_desc *txc)
{
uint32_t tx_cmd = 0;
@@ -471,10 +461,10 @@
static int
aq_isc_txd_encap(void *arg, if_pkt_info_t pi)
{
- aq_dev_t *aq_dev = arg;
+ struct aq_dev *aq_dev = arg;
struct aq_ring *ring;
- aq_txc_desc_t *txc;
- aq_tx_desc_t *txd = NULL;
+ volatile union aq_txc_desc *txc;
+ volatile struct aq_tx_desc *txd = NULL;
bus_dma_segment_t *segs;
qidx_t pidx;
uint32_t hdrlen=0, pay_len;
@@ -486,7 +476,7 @@
segs = pi->ipi_segs;
pidx = pi->ipi_pidx;
- txc = (aq_txc_desc_t *)&ring->tx_descs[pidx];
+ txc = (volatile union aq_txc_desc *)&ring->tx_descs[pidx];
AQ_DBG_PRINT("txc at 0x%p, txd at 0x%p len %d", txc, txd, pi->ipi_len);
pay_len = pi->ipi_len;
@@ -506,7 +496,7 @@
txd = &ring->tx_descs[pidx];
txd->flags = 0U;
} else {
- txd = (aq_tx_desc_t *)txc;
+ txd = (volatile struct aq_tx_desc *)txc;
}
AQ_DBG_PRINT("txc at 0x%p, txd at 0x%p", txc, txd);
@@ -563,7 +553,7 @@
static void
aq_isc_txd_flush(void *arg, uint16_t txqid, qidx_t pidx)
{
- aq_dev_t *aq_dev = arg;
+ struct aq_dev *aq_dev = arg;
struct aq_ring *ring = aq_dev->tx_rings[txqid];
AQ_DBG_ENTERA("[%d] tail=%d", ring->index, pidx);
@@ -582,7 +572,7 @@
static int
aq_isc_txd_credits_update(void *arg, uint16_t txqid, bool clear)
{
- aq_dev_t *aq_dev = arg;
+ struct aq_dev *aq_dev = arg;
struct aq_ring *ring = aq_dev->tx_rings[txqid];
uint32_t head;
int avail;
File Metadata
Details
Attached
Mime Type
text/plain
Expires
Mon, Nov 23, 7:04 AM (12 h, 44 m)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
41925177
Default Alt Text
D57438.1795417489.diff (65 KB)
Attached To
Mode
D57438: aq(4): modernize and de-Linuxify the vendor driver
Attached
Detach File
Event Timeline