drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_utils_fw2x.c

   1 /*
   2  * aQuantia Corporation Network Driver
   3  * Copyright (C) 2014-2017 aQuantia Corporation. All rights reserved
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms and conditions of the GNU General Public License,
   7  * version 2, as published by the Free Software Foundation.
   8  */
   9
  10 /* File hw_atl_utils_fw2x.c: Definition of firmware 2.x functions for
  11  * Atlantic hardware abstraction layer.
  12  */
  13
  14 #include "../aq_hw.h"
  15 #include "../aq_hw_utils.h"
  16 #include "../aq_pci_func.h"
  17 #include "../aq_ring.h"
  18 #include "../aq_vec.h"
  19 #include "hw_atl_utils.h"
  20 #include "hw_atl_llh.h"
  21
  22 #define HW_ATL_FW2X_MPI_EFUSE_ADDR      0x364
  23 #define HW_ATL_FW2X_MPI_MBOX_ADDR       0x360
  24 #define HW_ATL_FW2X_MPI_RPC_ADDR        0x334
  25
  26 #define HW_ATL_FW2X_MPI_CONTROL_ADDR    0x368
  27 #define HW_ATL_FW2X_MPI_CONTROL2_ADDR   0x36C
  28
  29 #define HW_ATL_FW2X_MPI_STATE_ADDR      0x370
  30 #define HW_ATL_FW2X_MPI_STATE2_ADDR     0x374
  31
  32 static int aq_fw2x_set_link_speed(struct aq_hw_s *self, u32 speed);
  33 static int aq_fw2x_set_state(struct aq_hw_s *self,
  34                              enum hal_atl_utils_fw_state_e state);
  35
  36 static int aq_fw2x_init(struct aq_hw_s *self)
  37 {
  38         int err = 0;
  39
  40         /* check 10 times by 1ms */
  41         AQ_HW_WAIT_FOR(0U != (self->mbox_addr =
  42                         aq_hw_read_reg(self, HW_ATL_FW2X_MPI_MBOX_ADDR)),
  43                        1000U, 10U);
  44         AQ_HW_WAIT_FOR(0U != (self->rpc_addr =
  45                        aq_hw_read_reg(self, HW_ATL_FW2X_MPI_RPC_ADDR)),
  46                        1000U, 100U);
  47
  48         return err;
  49 }
  50
  51 static int aq_fw2x_deinit(struct aq_hw_s *self)
  52 {
  53         int err = aq_fw2x_set_link_speed(self, 0);
  54
  55         if (!err)
  56                 err = aq_fw2x_set_state(self, MPI_DEINIT);
  57
  58         return err;
  59 }
  60
  61 static enum hw_atl_fw2x_rate link_speed_mask_2fw2x_ratemask(u32 speed)
  62 {
  63         enum hw_atl_fw2x_rate rate = 0;
  64
  65         if (speed & AQ_NIC_RATE_10G)
  66                 rate |= FW2X_RATE_10G;
  67
  68         if (speed & AQ_NIC_RATE_5G)
  69                 rate |= FW2X_RATE_5G;
  70
  71         if (speed & AQ_NIC_RATE_5GSR)
  72                 rate |= FW2X_RATE_5G;
  73
  74         if (speed & AQ_NIC_RATE_2GS)
  75                 rate |= FW2X_RATE_2G5;
  76
  77         if (speed & AQ_NIC_RATE_1G)
  78                 rate |= FW2X_RATE_1G;
  79
  80         if (speed & AQ_NIC_RATE_100M)
  81                 rate |= FW2X_RATE_100M;
  82
  83         return rate;
  84 }
  85
  86 static int aq_fw2x_set_link_speed(struct aq_hw_s *self, u32 speed)
  87 {
  88         u32 val = link_speed_mask_2fw2x_ratemask(speed);
  89
  90         aq_hw_write_reg(self, HW_ATL_FW2X_MPI_CONTROL_ADDR, val);
  91
  92         return 0;
  93 }
  94
  95 static void aq_fw2x_set_mpi_flow_control(struct aq_hw_s *self, u32 *mpi_state)
  96 {
  97         if (self->aq_nic_cfg->flow_control & AQ_NIC_FC_RX)
  98                 *mpi_state |= BIT(CAPS_HI_PAUSE);
  99         else
 100                 *mpi_state &= ~BIT(CAPS_HI_PAUSE);
 101
 102         if (self->aq_nic_cfg->flow_control & AQ_NIC_FC_TX)
 103                 *mpi_state |= BIT(CAPS_HI_ASYMMETRIC_PAUSE);
 104         else
 105                 *mpi_state &= ~BIT(CAPS_HI_ASYMMETRIC_PAUSE);
 106 }
 107
 108 static int aq_fw2x_set_state(struct aq_hw_s *self,
 109                              enum hal_atl_utils_fw_state_e state)
 110 {
 111         u32 mpi_state = aq_hw_read_reg(self, HW_ATL_FW2X_MPI_CONTROL2_ADDR);
 112
 113         switch (state) {
 114         case MPI_INIT:
 115                 mpi_state &= ~BIT(CAPS_HI_LINK_DROP);
 116                 aq_fw2x_set_mpi_flow_control(self, &mpi_state);
 117                 break;
 118         case MPI_DEINIT:
 119                 mpi_state |= BIT(CAPS_HI_LINK_DROP);
 120                 break;
 121         case MPI_RESET:
 122         case MPI_POWER:
 123                 /* No actions */
 124                 break;
 125         }
 126         aq_hw_write_reg(self, HW_ATL_FW2X_MPI_CONTROL2_ADDR, mpi_state);
 127         return 0;
 128 }
 129
 130 static int aq_fw2x_update_link_status(struct aq_hw_s *self)
 131 {
 132         u32 mpi_state = aq_hw_read_reg(self, HW_ATL_FW2X_MPI_STATE_ADDR);
 133         u32 speed = mpi_state & (FW2X_RATE_100M | FW2X_RATE_1G |
 134                                 FW2X_RATE_2G5 | FW2X_RATE_5G | FW2X_RATE_10G);
 135         struct aq_hw_link_status_s *link_status = &self->aq_link_status;
 136
 137         if (speed) {
 138                 if (speed & FW2X_RATE_10G)
 139                         link_status->mbps = 10000;
 140                 else if (speed & FW2X_RATE_5G)
 141                         link_status->mbps = 5000;
 142                 else if (speed & FW2X_RATE_2G5)
 143                         link_status->mbps = 2500;
 144                 else if (speed & FW2X_RATE_1G)
 145                         link_status->mbps = 1000;
 146                 else if (speed & FW2X_RATE_100M)
 147                         link_status->mbps = 100;
 148                 else
 149                         link_status->mbps = 10000;
 150         } else {
 151                 link_status->mbps = 0;
 152         }
 153
 154         return 0;
 155 }
 156
 157 static int aq_fw2x_get_mac_permanent(struct aq_hw_s *self, u8 *mac)
 158 {
 159         int err = 0;
 160         u32 h = 0U;
 161         u32 l = 0U;
 162         u32 mac_addr[2] = { 0 };
 163         u32 efuse_addr = aq_hw_read_reg(self, HW_ATL_FW2X_MPI_EFUSE_ADDR);
 164
 165         if (efuse_addr != 0) {
 166                 err = hw_atl_utils_fw_downld_dwords(self,
 167                                                     efuse_addr + (40U * 4U),
 168                                                     mac_addr,
 169                                                     ARRAY_SIZE(mac_addr));
 170                 if (err)
 171                         return err;
 172                 mac_addr[0] = __swab32(mac_addr[0]);
 173                 mac_addr[1] = __swab32(mac_addr[1]);
 174         }
 175
 176         ether_addr_copy(mac, (u8 *)mac_addr);
 177
 178         if ((mac[0] & 0x01U) || ((mac[0] | mac[1] | mac[2]) == 0x00U)) {
 179                 unsigned int rnd = 0;
 180
 181                 get_random_bytes(&rnd, sizeof(unsigned int));
 182
 183                 l = 0xE3000000U
 184                         | (0xFFFFU & rnd)
 185                         | (0x00 << 16);
 186                 h = 0x8001300EU;
 187
 188                 mac[5] = (u8)(0xFFU & l);
 189                 l >>= 8;
 190                 mac[4] = (u8)(0xFFU & l);
 191                 l >>= 8;
 192                 mac[3] = (u8)(0xFFU & l);
 193                 l >>= 8;
 194                 mac[2] = (u8)(0xFFU & l);
 195                 mac[1] = (u8)(0xFFU & h);
 196                 h >>= 8;
 197                 mac[0] = (u8)(0xFFU & h);
 198         }
 199         return err;
 200 }
 201
 202 static int aq_fw2x_update_stats(struct aq_hw_s *self)
 203 {
 204         int err = 0;
 205         u32 mpi_opts = aq_hw_read_reg(self, HW_ATL_FW2X_MPI_CONTROL2_ADDR);
 206         u32 orig_stats_val = mpi_opts & BIT(CAPS_HI_STATISTICS);
 207
 208         /* Toggle statistics bit for FW to update */
 209         mpi_opts = mpi_opts ^ BIT(CAPS_HI_STATISTICS);
 210         aq_hw_write_reg(self, HW_ATL_FW2X_MPI_CONTROL2_ADDR, mpi_opts);
 211
 212         /* Wait FW to report back */
 213         AQ_HW_WAIT_FOR(orig_stats_val !=
 214                        (aq_hw_read_reg(self, HW_ATL_FW2X_MPI_STATE2_ADDR) &
 215                                        BIT(CAPS_HI_STATISTICS)),
 216                        1U, 10000U);
 217         if (err)
 218                 return err;
 219
 220         return hw_atl_utils_update_stats(self);
 221 }
 222
 223 static int aq_fw2x_renegotiate(struct aq_hw_s *self)
 224 {
 225         u32 mpi_opts = aq_hw_read_reg(self, HW_ATL_FW2X_MPI_CONTROL2_ADDR);
 226
 227         mpi_opts |= BIT(CTRL_FORCE_RECONNECT);
 228
 229         aq_hw_write_reg(self, HW_ATL_FW2X_MPI_CONTROL2_ADDR, mpi_opts);
 230
 231         return 0;
 232 }
 233
 234 static int aq_fw2x_set_flow_control(struct aq_hw_s *self)
 235 {
 236         u32 mpi_state = aq_hw_read_reg(self, HW_ATL_FW2X_MPI_CONTROL2_ADDR);
 237
 238         aq_fw2x_set_mpi_flow_control(self, &mpi_state);
 239
 240         aq_hw_write_reg(self, HW_ATL_FW2X_MPI_CONTROL2_ADDR, mpi_state);
 241
 242         return 0;
 243 }
 244
 245 const struct aq_fw_ops aq_fw_2x_ops = {
 246         .init = aq_fw2x_init,
 247         .deinit = aq_fw2x_deinit,
 248         .reset = NULL,
 249         .renegotiate = aq_fw2x_renegotiate,
 250         .get_mac_permanent = aq_fw2x_get_mac_permanent,
 251         .set_link_speed = aq_fw2x_set_link_speed,
 252         .set_state = aq_fw2x_set_state,
 253         .update_link_status = aq_fw2x_update_link_status,
 254         .update_stats = aq_fw2x_update_stats,
 255         .set_flow_control   = aq_fw2x_set_flow_control,
 256 };