Branch data     Line data    Source code

       1                 :            : // SPDX-License-Identifier: GPL-2.0-only
       2                 :            : /*
       3                 :            :  * aQuantia Corporation Network Driver
       4                 :            :  * Copyright (C) 2014-2017 aQuantia Corporation. All rights reserved
       5                 :            :  */
       6                 :            : 
       7                 :            : /* File aq_hw_utils.c: Definitions of helper functions used across
       8                 :            :  * hardware layer.
       9                 :            :  */
      10                 :            : 
      11                 :            : #include "aq_hw_utils.h"
      12                 :            : #include "aq_hw.h"
      13                 :            : #include "aq_nic.h"
      14                 :            : 
      15                 :      15478 : void aq_hw_write_reg_bit(struct aq_hw_s *aq_hw, u32 addr, u32 msk,
      16                 :            :                          u32 shift, u32 val)
      17                 :            : {
      18         [ +  - ]:      15478 :         if (msk ^ ~0) {
      19                 :      15478 :                 u32 reg_old, reg_new;
      20                 :            : 
      21                 :      15478 :                 reg_old = aq_hw_read_reg(aq_hw, addr);
      22                 :      15478 :                 reg_new = (reg_old & (~msk)) | (val << shift);
      23                 :            : 
      24         [ +  + ]:      15478 :                 if (reg_old != reg_new)
      25                 :       8910 :                         aq_hw_write_reg(aq_hw, addr, reg_new);
      26                 :            :         } else {
      27                 :          0 :                 aq_hw_write_reg(aq_hw, addr, val);
      28                 :            :         }
      29                 :      15478 : }
      30                 :            : 
      31                 :       5897 : u32 aq_hw_read_reg_bit(struct aq_hw_s *aq_hw, u32 addr, u32 msk, u32 shift)
      32                 :            : {
      33                 :       5897 :         return ((aq_hw_read_reg(aq_hw, addr) & msk) >> shift);
      34                 :            : }
      35                 :            : 
      36                 :     686647 : u32 aq_hw_read_reg(struct aq_hw_s *hw, u32 reg)
      37                 :            : {
      38                 :     686647 :         u32 value = readl(hw->mmio + reg);
      39                 :            : 
      40   [ +  +  +  + ]:     687018 :         if ((~0U) == value &&
      41                 :        371 :             (~0U) == readl(hw->mmio +
      42                 :        371 :                            hw->aq_nic_cfg->aq_hw_caps->hw_alive_check_addr))
      43                 :          1 :                 aq_utils_obj_set(&hw->flags, AQ_HW_FLAG_ERR_UNPLUG);
      44                 :            : 
      45                 :     686647 :         return value;
      46                 :            : }
      47                 :            : 
      48                 :      27899 : void aq_hw_write_reg(struct aq_hw_s *hw, u32 reg, u32 value)
      49                 :            : {
      50                 :      27899 :         writel(value, hw->mmio + reg);
      51                 :       8910 : }
      52                 :            : 
      53                 :            : /* Most of 64-bit registers are in LSW, MSW form.
      54                 :            :    Counters are normally implemented by HW as latched pairs:
      55                 :            :    reading LSW first locks MSW, to overcome LSW overflow
      56                 :            :  */
      57                 :        468 : u64 aq_hw_read_reg64(struct aq_hw_s *hw, u32 reg)
      58                 :            : {
      59                 :        468 :         u64 value = aq_hw_read_reg(hw, reg);
      60                 :            : 
      61                 :        468 :         value |= (u64)aq_hw_read_reg(hw, reg + 4) << 32;
      62                 :            : 
      63                 :        468 :         return value;
      64                 :            : }
      65                 :            : 
      66                 :      14808 : int aq_hw_err_from_flags(struct aq_hw_s *hw)
      67                 :            : {
      68                 :      14808 :         int err = 0;
      69                 :            : 
      70         [ -  + ]:      14808 :         if (aq_utils_obj_test(&hw->flags, AQ_HW_FLAG_ERR_UNPLUG)) {
      71                 :          0 :                 err = -ENXIO;
      72                 :          0 :                 goto err_exit;
      73                 :            :         }
      74         [ +  - ]:      14808 :         if (aq_utils_obj_test(&hw->flags, AQ_HW_FLAG_ERR_HW)) {
      75                 :          0 :                 err = -EIO;
      76                 :          0 :                 goto err_exit;
      77                 :            :         }
      78                 :            : 
      79                 :      14808 : err_exit:
      80                 :      14808 :         return err;
      81                 :            : }