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 "../aq_nic.h"
  20 #include "hw_atl_utils.h"
  21 #include "hw_atl_llh.h"
  22
  23 #define HW_ATL_FW2X_MPI_EFUSE_ADDR      0x364
  24 #define HW_ATL_FW2X_MPI_MBOX_ADDR       0x360
  25 #define HW_ATL_FW2X_MPI_RPC_ADDR        0x334
  26
  27 #define HW_ATL_FW2X_MPI_CONTROL_ADDR    0x368
  28 #define HW_ATL_FW2X_MPI_CONTROL2_ADDR   0x36C
  29
  30 #define HW_ATL_FW2X_MPI_STATE_ADDR      0x370
  31 #define HW_ATL_FW2X_MPI_STATE2_ADDR     0x374
  32
  33 #define HW_ATL_FW2X_CAP_PAUSE            BIT(CAPS_HI_PAUSE)
  34 #define HW_ATL_FW2X_CAP_ASYM_PAUSE       BIT(CAPS_HI_ASYMMETRIC_PAUSE)
  35 #define HW_ATL_FW2X_CAP_SLEEP_PROXY      BIT(CAPS_HI_SLEEP_PROXY)
  36 #define HW_ATL_FW2X_CAP_WOL              BIT(CAPS_HI_WOL)
  37
  38 #define HW_ATL_FW2X_CTRL_SLEEP_PROXY      BIT(CTRL_SLEEP_PROXY)
  39 #define HW_ATL_FW2X_CTRL_WOL              BIT(CTRL_WOL)
  40 #define HW_ATL_FW2X_CTRL_LINK_DROP        BIT(CTRL_LINK_DROP)
  41 #define HW_ATL_FW2X_CTRL_PAUSE            BIT(CTRL_PAUSE)
  42 #define HW_ATL_FW2X_CTRL_ASYMMETRIC_PAUSE BIT(CTRL_ASYMMETRIC_PAUSE)
  43 #define HW_ATL_FW2X_CTRL_FORCE_RECONNECT  BIT(CTRL_FORCE_RECONNECT)
  44
  45 #define HW_ATL_FW2X_CAP_EEE_1G_MASK      BIT(CAPS_HI_1000BASET_FD_EEE)
  46 #define HW_ATL_FW2X_CAP_EEE_2G5_MASK     BIT(CAPS_HI_2P5GBASET_FD_EEE)
  47 #define HW_ATL_FW2X_CAP_EEE_5G_MASK      BIT(CAPS_HI_5GBASET_FD_EEE)
  48 #define HW_ATL_FW2X_CAP_EEE_10G_MASK     BIT(CAPS_HI_10GBASET_FD_EEE)
  49
  50 #define HAL_ATLANTIC_WOL_FILTERS_COUNT   8
  51 #define HAL_ATLANTIC_UTILS_FW2X_MSG_WOL  0x0E
  52
  53 struct __packed fw2x_msg_wol_pattern {
  54         u8 mask[16];
  55         u32 crc;
  56 };
  57
  58 struct __packed fw2x_msg_wol {
  59         u32 msg_id;
  60         u8 hw_addr[ETH_ALEN];
  61         u8 magic_packet_enabled;
  62         u8 filter_count;
  63         struct fw2x_msg_wol_pattern filter[HAL_ATLANTIC_WOL_FILTERS_COUNT];
  64         u8 link_up_enabled;
  65         u8 link_down_enabled;
  66         u16 reserved;
  67         u32 link_up_timeout;
  68         u32 link_down_timeout;
  69 };
  70
  71 static int aq_fw2x_set_link_speed(struct aq_hw_s *self, u32 speed);
  72 static int aq_fw2x_set_state(struct aq_hw_s *self,
  73                              enum hal_atl_utils_fw_state_e state);
  74
  75 static int aq_fw2x_init(struct aq_hw_s *self)
  76 {
  77         int err = 0;
  78
  79         /* check 10 times by 1ms */
  80         AQ_HW_WAIT_FOR(0U != (self->mbox_addr =
  81                        aq_hw_read_reg(self, HW_ATL_FW2X_MPI_MBOX_ADDR)),
  82                        1000U, 10U);
  83         AQ_HW_WAIT_FOR(0U != (self->rpc_addr =
  84                        aq_hw_read_reg(self, HW_ATL_FW2X_MPI_RPC_ADDR)),
  85                        1000U, 100U);
  86
  87         return err;
  88 }
  89
  90 static int aq_fw2x_deinit(struct aq_hw_s *self)
  91 {
  92         int err = aq_fw2x_set_link_speed(self, 0);
  93
  94         if (!err)
  95                 err = aq_fw2x_set_state(self, MPI_DEINIT);
  96
  97         return err;
  98 }
  99
 100 static enum hw_atl_fw2x_rate link_speed_mask_2fw2x_ratemask(u32 speed)
 101 {
 102         enum hw_atl_fw2x_rate rate = 0;
 103
 104         if (speed & AQ_NIC_RATE_10G)
 105                 rate |= FW2X_RATE_10G;
 106
 107         if (speed & AQ_NIC_RATE_5G)
 108                 rate |= FW2X_RATE_5G;
 109
 110         if (speed & AQ_NIC_RATE_5GSR)
 111                 rate |= FW2X_RATE_5G;
 112
 113         if (speed & AQ_NIC_RATE_2GS)
 114                 rate |= FW2X_RATE_2G5;
 115
 116         if (speed & AQ_NIC_RATE_1G)
 117                 rate |= FW2X_RATE_1G;
 118
 119         if (speed & AQ_NIC_RATE_100M)
 120                 rate |= FW2X_RATE_100M;
 121
 122         return rate;
 123 }
 124
 125 static u32 fw2x_to_eee_mask(u32 speed)
 126 {
 127         u32 rate = 0;
 128
 129         if (speed & HW_ATL_FW2X_CAP_EEE_10G_MASK)
 130                 rate |= AQ_NIC_RATE_EEE_10G;
 131         if (speed & HW_ATL_FW2X_CAP_EEE_5G_MASK)
 132                 rate |= AQ_NIC_RATE_EEE_5G;
 133         if (speed & HW_ATL_FW2X_CAP_EEE_2G5_MASK)
 134                 rate |= AQ_NIC_RATE_EEE_2GS;
 135         if (speed & HW_ATL_FW2X_CAP_EEE_1G_MASK)
 136                 rate |= AQ_NIC_RATE_EEE_1G;
 137
 138         return rate;
 139 }
 140
 141 static u32 eee_mask_to_fw2x(u32 speed)
 142 {
 143         u32 rate = 0;
 144
 145         if (speed & AQ_NIC_RATE_EEE_10G)
 146                 rate |= HW_ATL_FW2X_CAP_EEE_10G_MASK;
 147         if (speed & AQ_NIC_RATE_EEE_5G)
 148                 rate |= HW_ATL_FW2X_CAP_EEE_5G_MASK;
 149         if (speed & AQ_NIC_RATE_EEE_2GS)
 150                 rate |= HW_ATL_FW2X_CAP_EEE_2G5_MASK;
 151         if (speed & AQ_NIC_RATE_EEE_1G)
 152                 rate |= HW_ATL_FW2X_CAP_EEE_1G_MASK;
 153
 154         return rate;
 155 }
 156
 157 static int aq_fw2x_set_link_speed(struct aq_hw_s *self, u32 speed)
 158 {
 159         u32 val = link_speed_mask_2fw2x_ratemask(speed);
 160
 161         aq_hw_write_reg(self, HW_ATL_FW2X_MPI_CONTROL_ADDR, val);
 162
 163         return 0;
 164 }
 165
 166 static void aq_fw2x_set_mpi_flow_control(struct aq_hw_s *self, u32 *mpi_state)
 167 {
 168         if (self->aq_nic_cfg->flow_control & AQ_NIC_FC_RX)
 169                 *mpi_state |= BIT(CAPS_HI_PAUSE);
 170         else
 171                 *mpi_state &= ~BIT(CAPS_HI_PAUSE);
 172
 173         if (self->aq_nic_cfg->flow_control & AQ_NIC_FC_TX)
 174                 *mpi_state |= BIT(CAPS_HI_ASYMMETRIC_PAUSE);
 175         else
 176                 *mpi_state &= ~BIT(CAPS_HI_ASYMMETRIC_PAUSE);
 177 }
 178
 179 static void aq_fw2x_upd_eee_rate_bits(struct aq_hw_s *self, u32 *mpi_opts,
 180                                       u32 eee_speeds)
 181 {
 182         *mpi_opts &= ~(HW_ATL_FW2X_CAP_EEE_1G_MASK |
 183                        HW_ATL_FW2X_CAP_EEE_2G5_MASK |
 184                        HW_ATL_FW2X_CAP_EEE_5G_MASK |
 185                        HW_ATL_FW2X_CAP_EEE_10G_MASK);
 186
 187         *mpi_opts |= eee_mask_to_fw2x(eee_speeds);
 188 }
 189
 190 static int aq_fw2x_set_state(struct aq_hw_s *self,
 191                              enum hal_atl_utils_fw_state_e state)
 192 {
 193         u32 mpi_state = aq_hw_read_reg(self, HW_ATL_FW2X_MPI_CONTROL2_ADDR);
 194         struct aq_nic_cfg_s *cfg = self->aq_nic_cfg;
 195
 196         switch (state) {
 197         case MPI_INIT:
 198                 mpi_state &= ~BIT(CAPS_HI_LINK_DROP);
 199                 aq_fw2x_upd_eee_rate_bits(self, &mpi_state, cfg->eee_speeds);
 200                 aq_fw2x_set_mpi_flow_control(self, &mpi_state);
 201                 break;
 202         case MPI_DEINIT:
 203                 mpi_state |= BIT(CAPS_HI_LINK_DROP);
 204                 break;
 205         case MPI_RESET:
 206         case MPI_POWER:
 207                 /* No actions */
 208                 break;
 209         }
 210         aq_hw_write_reg(self, HW_ATL_FW2X_MPI_CONTROL2_ADDR, mpi_state);
 211         return 0;
 212 }
 213
 214 static int aq_fw2x_update_link_status(struct aq_hw_s *self)
 215 {
 216         u32 mpi_state = aq_hw_read_reg(self, HW_ATL_FW2X_MPI_STATE_ADDR);
 217         u32 speed = mpi_state & (FW2X_RATE_100M | FW2X_RATE_1G |
 218                                  FW2X_RATE_2G5 | FW2X_RATE_5G | FW2X_RATE_10G);
 219         struct aq_hw_link_status_s *link_status = &self->aq_link_status;
 220
 221         if (speed) {
 222                 if (speed & FW2X_RATE_10G)
 223                         link_status->mbps = 10000;
 224                 else if (speed & FW2X_RATE_5G)
 225                         link_status->mbps = 5000;
 226                 else if (speed & FW2X_RATE_2G5)
 227                         link_status->mbps = 2500;
 228                 else if (speed & FW2X_RATE_1G)
 229                         link_status->mbps = 1000;
 230                 else if (speed & FW2X_RATE_100M)
 231                         link_status->mbps = 100;
 232                 else
 233                         link_status->mbps = 10000;
 234         } else {
 235                 link_status->mbps = 0;
 236         }
 237
 238         return 0;
 239 }
 240
 241 static int aq_fw2x_get_mac_permanent(struct aq_hw_s *self, u8 *mac)
 242 {
 243         int err = 0;
 244         u32 h = 0U;
 245         u32 l = 0U;
 246         u32 mac_addr[2] = { 0 };
 247         u32 efuse_addr = aq_hw_read_reg(self, HW_ATL_FW2X_MPI_EFUSE_ADDR);
 248
 249         if (efuse_addr != 0) {
 250                 err = hw_atl_utils_fw_downld_dwords(self,
 251                                                     efuse_addr + (40U * 4U),
 252                                                     mac_addr,
 253                                                     ARRAY_SIZE(mac_addr));
 254                 if (err)
 255                         return err;
 256                 mac_addr[0] = __swab32(mac_addr[0]);
 257                 mac_addr[1] = __swab32(mac_addr[1]);
 258         }
 259
 260         ether_addr_copy(mac, (u8 *)mac_addr);
 261
 262         if ((mac[0] & 0x01U) || ((mac[0] | mac[1] | mac[2]) == 0x00U)) {
 263                 unsigned int rnd = 0;
 264
 265                 get_random_bytes(&rnd, sizeof(unsigned int));
 266
 267                 l = 0xE3000000U | (0xFFFFU & rnd) | (0x00 << 16);
 268                 h = 0x8001300EU;
 269
 270                 mac[5] = (u8)(0xFFU & l);
 271                 l >>= 8;
 272                 mac[4] = (u8)(0xFFU & l);
 273                 l >>= 8;
 274                 mac[3] = (u8)(0xFFU & l);
 275                 l >>= 8;
 276                 mac[2] = (u8)(0xFFU & l);
 277                 mac[1] = (u8)(0xFFU & h);
 278                 h >>= 8;
 279                 mac[0] = (u8)(0xFFU & h);
 280         }
 281         return err;
 282 }
 283
 284 static int aq_fw2x_update_stats(struct aq_hw_s *self)
 285 {
 286         int err = 0;
 287         u32 mpi_opts = aq_hw_read_reg(self, HW_ATL_FW2X_MPI_CONTROL2_ADDR);
 288         u32 orig_stats_val = mpi_opts & BIT(CAPS_HI_STATISTICS);
 289
 290         /* Toggle statistics bit for FW to update */
 291         mpi_opts = mpi_opts ^ BIT(CAPS_HI_STATISTICS);
 292         aq_hw_write_reg(self, HW_ATL_FW2X_MPI_CONTROL2_ADDR, mpi_opts);
 293
 294         /* Wait FW to report back */
 295         AQ_HW_WAIT_FOR(orig_stats_val !=
 296                        (aq_hw_read_reg(self, HW_ATL_FW2X_MPI_STATE2_ADDR) &
 297                         BIT(CAPS_HI_STATISTICS)),
 298                        1U, 10000U);
 299         if (err)
 300                 return err;
 301
 302         return hw_atl_utils_update_stats(self);
 303 }
 304
 305 static int aq_fw2x_set_sleep_proxy(struct aq_hw_s *self, u8 *mac)
 306 {
 307         struct hw_atl_utils_fw_rpc *rpc = NULL;
 308         struct offload_info *cfg = NULL;
 309         unsigned int rpc_size = 0U;
 310         u32 mpi_opts;
 311         int err = 0;
 312
 313         rpc_size = sizeof(rpc->msg_id) + sizeof(*cfg);
 314
 315         err = hw_atl_utils_fw_rpc_wait(self, &rpc);
 316         if (err < 0)
 317                 goto err_exit;
 318
 319         memset(rpc, 0, rpc_size);
 320         cfg = (struct offload_info *)(&rpc->msg_id + 1);
 321
 322         memcpy(cfg->mac_addr, mac, ETH_ALEN);
 323         cfg->len = sizeof(*cfg);
 324
 325         /* Clear bit 0x36C.23 and 0x36C.22 */
 326         mpi_opts = aq_hw_read_reg(self, HW_ATL_FW2X_MPI_CONTROL2_ADDR);
 327         mpi_opts &= ~HW_ATL_FW2X_CTRL_SLEEP_PROXY;
 328         mpi_opts &= ~HW_ATL_FW2X_CTRL_LINK_DROP;
 329
 330         aq_hw_write_reg(self, HW_ATL_FW2X_MPI_CONTROL2_ADDR, mpi_opts);
 331
 332         err = hw_atl_utils_fw_rpc_call(self, rpc_size);
 333         if (err < 0)
 334                 goto err_exit;
 335
 336         /* Set bit 0x36C.23 */
 337         mpi_opts |= HW_ATL_FW2X_CTRL_SLEEP_PROXY;
 338         aq_hw_write_reg(self, HW_ATL_FW2X_MPI_CONTROL2_ADDR, mpi_opts);
 339
 340         AQ_HW_WAIT_FOR((aq_hw_read_reg(self, HW_ATL_FW2X_MPI_STATE2_ADDR) &
 341                         HW_ATL_FW2X_CTRL_SLEEP_PROXY), 1U, 10000U);
 342
 343 err_exit:
 344         return err;
 345 }
 346
 347 static int aq_fw2x_set_wol_params(struct aq_hw_s *self, u8 *mac)
 348 {
 349         struct hw_atl_utils_fw_rpc *rpc = NULL;
 350         struct fw2x_msg_wol *msg = NULL;
 351         u32 mpi_opts;
 352         int err = 0;
 353
 354         err = hw_atl_utils_fw_rpc_wait(self, &rpc);
 355         if (err < 0)
 356                 goto err_exit;
 357
 358         msg = (struct fw2x_msg_wol *)rpc;
 359
 360         msg->msg_id = HAL_ATLANTIC_UTILS_FW2X_MSG_WOL;
 361         msg->magic_packet_enabled = true;
 362         memcpy(msg->hw_addr, mac, ETH_ALEN);
 363
 364         mpi_opts = aq_hw_read_reg(self, HW_ATL_FW2X_MPI_CONTROL2_ADDR);
 365         mpi_opts &= ~(HW_ATL_FW2X_CTRL_SLEEP_PROXY | HW_ATL_FW2X_CTRL_WOL);
 366
 367         aq_hw_write_reg(self, HW_ATL_FW2X_MPI_CONTROL2_ADDR, mpi_opts);
 368
 369         err = hw_atl_utils_fw_rpc_call(self, sizeof(*msg));
 370         if (err < 0)
 371                 goto err_exit;
 372
 373         /* Set bit 0x36C.24 */
 374         mpi_opts |= HW_ATL_FW2X_CTRL_WOL;
 375         aq_hw_write_reg(self, HW_ATL_FW2X_MPI_CONTROL2_ADDR, mpi_opts);
 376
 377         AQ_HW_WAIT_FOR((aq_hw_read_reg(self, HW_ATL_FW2X_MPI_STATE2_ADDR) &
 378                         HW_ATL_FW2X_CTRL_WOL), 1U, 10000U);
 379
 380 err_exit:
 381         return err;
 382 }
 383
 384 static int aq_fw2x_set_power(struct aq_hw_s *self, unsigned int power_state,
 385                              u8 *mac)
 386 {
 387         int err = 0;
 388
 389         if (self->aq_nic_cfg->wol & AQ_NIC_WOL_ENABLED) {
 390                 err = aq_fw2x_set_sleep_proxy(self, mac);
 391                 if (err < 0)
 392                         goto err_exit;
 393                 err = aq_fw2x_set_wol_params(self, mac);
 394         }
 395
 396 err_exit:
 397         return err;
 398 }
 399
 400 static int aq_fw2x_set_eee_rate(struct aq_hw_s *self, u32 speed)
 401 {
 402         u32 mpi_opts = aq_hw_read_reg(self, HW_ATL_FW2X_MPI_CONTROL2_ADDR);
 403
 404         aq_fw2x_upd_eee_rate_bits(self, &mpi_opts, speed);
 405
 406         aq_hw_write_reg(self, HW_ATL_FW2X_MPI_CONTROL2_ADDR, mpi_opts);
 407
 408         return 0;
 409 }
 410
 411 static int aq_fw2x_get_eee_rate(struct aq_hw_s *self, u32 *rate,
 412                                 u32 *supported_rates)
 413 {
 414         u32 mpi_state;
 415         u32 caps_hi;
 416         int err = 0;
 417         u32 addr = self->mbox_addr + offsetof(struct hw_atl_utils_mbox, info) +
 418                    offsetof(struct hw_aq_info, caps_hi);
 419
 420         err = hw_atl_utils_fw_downld_dwords(self, addr, &caps_hi,
 421                                             sizeof(caps_hi) / sizeof(u32));
 422
 423         if (err)
 424                 return err;
 425
 426         *supported_rates = fw2x_to_eee_mask(caps_hi);
 427
 428         mpi_state = aq_hw_read_reg(self, HW_ATL_FW2X_MPI_STATE2_ADDR);
 429         *rate = fw2x_to_eee_mask(mpi_state);
 430
 431         return err;
 432 }
 433
 434 static int aq_fw2x_renegotiate(struct aq_hw_s *self)
 435 {
 436         u32 mpi_opts = aq_hw_read_reg(self, HW_ATL_FW2X_MPI_CONTROL2_ADDR);
 437
 438         mpi_opts |= BIT(CTRL_FORCE_RECONNECT);
 439
 440         aq_hw_write_reg(self, HW_ATL_FW2X_MPI_CONTROL2_ADDR, mpi_opts);
 441
 442         return 0;
 443 }
 444
 445 static int aq_fw2x_set_flow_control(struct aq_hw_s *self)
 446 {
 447         u32 mpi_state = aq_hw_read_reg(self, HW_ATL_FW2X_MPI_CONTROL2_ADDR);
 448
 449         aq_fw2x_set_mpi_flow_control(self, &mpi_state);
 450
 451         aq_hw_write_reg(self, HW_ATL_FW2X_MPI_CONTROL2_ADDR, mpi_state);
 452
 453         return 0;
 454 }
 455
 456 static u32 aq_fw2x_get_flow_control(struct aq_hw_s *self, u32 *fcmode)
 457 {
 458         u32 mpi_state = aq_hw_read_reg(self, HW_ATL_FW2X_MPI_STATE2_ADDR);
 459
 460         if (mpi_state & HW_ATL_FW2X_CAP_PAUSE)
 461                 if (mpi_state & HW_ATL_FW2X_CAP_ASYM_PAUSE)
 462                         *fcmode = AQ_NIC_FC_RX;
 463                 else
 464                         *fcmode = AQ_NIC_FC_RX | AQ_NIC_FC_TX;
 465         else
 466                 if (mpi_state & HW_ATL_FW2X_CAP_ASYM_PAUSE)
 467                         *fcmode = AQ_NIC_FC_TX;
 468                 else
 469                         *fcmode = 0;
 470
 471         return 0;
 472 }
 473
 474 const struct aq_fw_ops aq_fw_2x_ops = {
 475         .init = aq_fw2x_init,
 476         .deinit = aq_fw2x_deinit,
 477         .reset = NULL,
 478         .renegotiate = aq_fw2x_renegotiate,
 479         .get_mac_permanent = aq_fw2x_get_mac_permanent,
 480         .set_link_speed = aq_fw2x_set_link_speed,
 481         .set_state = aq_fw2x_set_state,
 482         .update_link_status = aq_fw2x_update_link_status,
 483         .update_stats = aq_fw2x_update_stats,
 484         .set_power = aq_fw2x_set_power,
 485         .set_eee_rate = aq_fw2x_set_eee_rate,
 486         .get_eee_rate = aq_fw2x_get_eee_rate,
 487         .set_flow_control = aq_fw2x_set_flow_control,
 488         .get_flow_control = aq_fw2x_get_flow_control
 489 };