This patch adds a new dsaf mode named "single-port" mode for debug port.
This mode only contains one debug port. This patch also changes the
method of distinguishing the port type.
Signed-off-by: Daode Huang <huangdaode@hisilicon.com>
Signed-off-by: Yisen Zhuang <yisen.zhuang@huawei.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
        int q_num = rcb_comm->max_q_per_vf;
        int vf_num = rcb_comm->max_vfn;
 
-       if (common_idx == HNS_DSAF_COMM_SERVICE_NW_IDX)
+       if (!HNS_DSAF_IS_DEBUG(dsaf_dev))
                return &rcb_comm->ring_pair_cb[port * q_num * vf_num];
        else
                return &rcb_comm->ring_pair_cb[0];
 
        struct mac_entry_idx *old_entry;
 
        old_entry = &mac_cb->addr_entry_idx[vmid];
-       if (dsaf_dev) {
+       if (!HNS_DSAF_IS_DEBUG(dsaf_dev)) {
                memcpy(mac_entry.addr, addr, sizeof(mac_entry.addr));
                mac_entry.in_vlan_id = old_entry->vlan_id;
                mac_entry.in_port_num = mac_cb->mac_id;
        struct dsaf_device *dsaf_dev = mac_cb->dsaf_dev;
        struct dsaf_drv_mac_single_dest_entry mac_entry;
 
-       if (dsaf_dev && addr) {
+       if (!HNS_DSAF_IS_DEBUG(dsaf_dev) && addr) {
                memcpy(mac_entry.addr, addr, sizeof(mac_entry.addr));
                mac_entry.in_vlan_id = 0;/*vlan_id;*/
                mac_entry.in_port_num = mac_cb->mac_id;
        if (mac_cb->mac_type == HNAE_PORT_DEBUG)
                return 0;
 
-       if (dsaf_dev) {
+       if (!HNS_DSAF_IS_DEBUG(dsaf_dev)) {
                memcpy(mac_entry.addr, addr, sizeof(mac_entry.addr));
                mac_entry.in_vlan_id = vlan_id;
                mac_entry.in_port_num = mac_cb->mac_id;
 
        uc_mac_entry = &mac_cb->addr_entry_idx[vmid];
 
-       if (dsaf_dev)  {
+       if (!HNS_DSAF_IS_DEBUG(dsaf_dev))  {
                memcpy(mac_entry.addr, addr, sizeof(mac_entry.addr));
                mac_entry.in_vlan_id = uc_mac_entry->vlan_id;
                mac_entry.in_port_num = mac_cb->mac_id;
 
        [DSAF_MODE_DISABLE_2PORT_64VM] = "2port-64vf",
        [DSAF_MODE_DISABLE_6PORT_0VM] = "6port-16rss",
        [DSAF_MODE_DISABLE_6PORT_16VM] = "6port-16vf",
+       [DSAF_MODE_DISABLE_SP] = "single-port",
 };
 
 int hns_dsaf_get_cfg(struct dsaf_device *dsaf_dev)
        u32 q_id, q_num_per_port;
        u32 i;
 
-       hns_rcb_get_queue_mode(dsaf_dev->dsaf_mode,
-                              HNS_DSAF_COMM_SERVICE_NW_IDX,
-                              &max_vfn, &max_q_per_vf);
+       hns_rcb_get_queue_mode(dsaf_dev->dsaf_mode, &max_vfn, &max_q_per_vf);
        q_num_per_port = max_vfn * max_q_per_vf;
 
        for (i = 0, q_id = 0; i < DSAF_SERVICE_NW_NUM; i++) {
        if (AE_IS_VER1(dsaf_dev->dsaf_ver))
                return;
 
-       hns_rcb_get_queue_mode(dsaf_dev->dsaf_mode,
-                              HNS_DSAF_COMM_SERVICE_NW_IDX,
-                              &max_vfn, &max_q_per_vf);
+       hns_rcb_get_queue_mode(dsaf_dev->dsaf_mode, &max_vfn, &max_q_per_vf);
        q_num_per_port = max_vfn * max_q_per_vf;
 
        for (mac_id = 0, q_id = 0; mac_id < DSAF_SERVICE_NW_NUM; mac_id++) {
 
 void hns_dsaf_set_promisc_mode(struct dsaf_device *dsaf_dev, u32 en)
 {
-       dsaf_set_dev_bit(dsaf_dev, DSAF_CFG_0_REG, DSAF_CFG_MIX_MODE_S, !!en);
+       if (!HNS_DSAF_IS_DEBUG(dsaf_dev))
+               dsaf_set_dev_bit(dsaf_dev, DSAF_CFG_0_REG,
+                                DSAF_CFG_MIX_MODE_S, !!en);
 }
 
 void hns_dsaf_set_inner_lb(struct dsaf_device *dsaf_dev, u32 mac_id, u32 en)
        u32 i;
        int ret;
 
+       if (HNS_DSAF_IS_DEBUG(dsaf_dev))
+               return 0;
+
        ret = hns_dsaf_init_hw(dsaf_dev);
        if (ret)
                return ret;
 
 #define DSAF_STATIC_NUM 28
 
 #define DSAF_STATS_READ(p, offset) (*((u64 *)((u8 *)(p) + (offset))))
+#define HNS_DSAF_IS_DEBUG(dev) (dev->dsaf_mode == DSAF_MODE_DISABLE_SP)
 
 enum hal_dsaf_mode {
        HRD_DSAF_NO_DSAF_MODE   = 0x0,
        DSAF_MODE_ENABLE_32VM,  /**< en DSAF-mode, support 32 VM */
        DSAF_MODE_ENABLE_128VM, /**< en DSAF-mode, support 128 VM */
        DSAF_MODE_ENABLE,               /**< before is enable DSAF mode*/
+       DSAF_MODE_DISABLE_SP,   /* <non-dsaf, single port mode */
        DSAF_MODE_DISABLE_FIX,  /**< non-dasf, fixed to queue*/
        DSAF_MODE_DISABLE_2PORT_8VM,    /**< non-dasf, 2port 8VM */
        DSAF_MODE_DISABLE_2PORT_16VM,   /**< non-dasf, 2port 16VM */
 
        if (port >= DSAF_GE_NUM)
                return;
 
-       if (port < DSAF_SERVICE_NW_NUM) {
+       if (!HNS_DSAF_IS_DEBUG(dsaf_dev)) {
                reg_val_1  = 0x1 << port;
                /* there is difference between V1 and V2 in register.*/
                if (AE_IS_VER1(dsaf_dev->dsaf_ver))
        u32 reg_val;
        u32 reg_addr;
 
-       if (comm_index == HNS_DSAF_COMM_SERVICE_NW_IDX) {
+       if (!HNS_DSAF_IS_DEBUG(dsaf_dev)) {
                reg_val = RESET_REQ_OR_DREQ;
                if (val == 0)
                        reg_addr = DSAF_SUB_SC_RCB_PPE_COM_RESET_REQ_REG;
 
 
        int idx = ppe_common->comm_index;
 
-       if (idx == HNS_DSAF_COMM_SERVICE_NW_IDX)
+       if (!HNS_DSAF_IS_DEBUG(ppe_common->dsaf_dev))
                base_addr = ppe_common->dsaf_dev->ppe_base
                        + PPE_COMMON_REG_OFFSET;
        else
        struct ppe_common_cb *ppe_common;
        int ppe_num;
 
-       if (comm_index == HNS_DSAF_COMM_SERVICE_NW_IDX)
+       if (!HNS_DSAF_IS_DEBUG(dsaf_dev))
                ppe_num = HNS_PPE_SERVICE_NW_ENGINE_NUM;
        else
                ppe_num = HNS_PPE_DEBUG_NW_ENGINE_NUM;
        ppe_common->ppe_num = ppe_num;
        ppe_common->dsaf_dev = dsaf_dev;
        ppe_common->comm_index = comm_index;
-       if (comm_index == HNS_DSAF_COMM_SERVICE_NW_IDX)
+       if (!HNS_DSAF_IS_DEBUG(dsaf_dev))
                ppe_common->ppe_mode = PPE_COMMON_MODE_SERVICE;
        else
                ppe_common->ppe_mode = PPE_COMMON_MODE_DEBUG;
 
 
 static int hns_rcb_common_get_port_num(struct rcb_common_cb *rcb_common)
 {
-       if (rcb_common->comm_index == HNS_DSAF_COMM_SERVICE_NW_IDX)
+       if (!HNS_DSAF_IS_DEBUG(rcb_common->dsaf_dev))
                return HNS_RCB_SERVICE_NW_ENGINE_NUM;
        else
                return HNS_RCB_DEBUG_NW_ENGINE_NUM;
 static int hns_rcb_get_port_in_comm(
        struct rcb_common_cb *rcb_common, int ring_idx)
 {
-       int comm_index = rcb_common->comm_index;
        int port;
        int q_num;
 
-       if (comm_index == HNS_DSAF_COMM_SERVICE_NW_IDX) {
+       if (!HNS_DSAF_IS_DEBUG(rcb_common->dsaf_dev)) {
                q_num = (int)rcb_common->max_q_per_vf * rcb_common->max_vfn;
                port = ring_idx / q_num;
        } else {
        int comm_index = rcb_common->comm_index;
        bool is_ver1 = AE_IS_VER1(rcb_common->dsaf_dev->dsaf_ver);
 
-       if (comm_index == HNS_DSAF_COMM_SERVICE_NW_IDX)
+       if (!HNS_DSAF_IS_DEBUG(rcb_common->dsaf_dev))
                return SERVICE_RING_IRQ_IDX(is_ver1);
        else
                return  DEBUG_RING_IRQ_IDX(is_ver1) +
                return 0;
 
        if (AE_IS_VER1(rcb_common->dsaf_dev->dsaf_ver)) {
-               if (rcb_common->comm_index == HNS_DSAF_COMM_SERVICE_NW_IDX) {
+               if (!HNS_DSAF_IS_DEBUG(rcb_common->dsaf_dev)) {
                        dev_err(rcb_common->dsaf_dev->dev,
                                "error: not support coalesce_usecs setting!\n");
                        return -EINVAL;
  *@max_vfn : max vfn number
  *@max_q_per_vf:max ring number per vm
  */
-void hns_rcb_get_queue_mode(enum dsaf_mode dsaf_mode, int comm_index,
-                           u16 *max_vfn, u16 *max_q_per_vf)
+void hns_rcb_get_queue_mode(enum dsaf_mode dsaf_mode, u16 *max_vfn,
+                           u16 *max_q_per_vf)
 {
-       if (comm_index == HNS_DSAF_COMM_SERVICE_NW_IDX) {
-               switch (dsaf_mode) {
-               case DSAF_MODE_DISABLE_6PORT_0VM:
-                       *max_vfn = 1;
-                       *max_q_per_vf = 16;
-                       break;
-               case DSAF_MODE_DISABLE_FIX:
-                       *max_vfn = 1;
-                       *max_q_per_vf = 1;
-                       break;
-               case DSAF_MODE_DISABLE_2PORT_64VM:
-                       *max_vfn = 64;
-                       *max_q_per_vf = 1;
-                       break;
-               case DSAF_MODE_DISABLE_6PORT_16VM:
-                       *max_vfn = 16;
-                       *max_q_per_vf = 1;
-                       break;
-               default:
-                       *max_vfn = 1;
-                       *max_q_per_vf = 16;
-                       break;
-               }
-       } else {
+       switch (dsaf_mode) {
+       case DSAF_MODE_DISABLE_6PORT_0VM:
+               *max_vfn = 1;
+               *max_q_per_vf = 16;
+               break;
+       case DSAF_MODE_DISABLE_FIX:
+       case DSAF_MODE_DISABLE_SP:
                *max_vfn = 1;
                *max_q_per_vf = 1;
+               break;
+       case DSAF_MODE_DISABLE_2PORT_64VM:
+               *max_vfn = 64;
+               *max_q_per_vf = 1;
+               break;
+       case DSAF_MODE_DISABLE_6PORT_16VM:
+               *max_vfn = 16;
+               *max_q_per_vf = 1;
+               break;
+       default:
+               *max_vfn = 1;
+               *max_q_per_vf = 16;
+               break;
        }
 }
 
-int hns_rcb_get_ring_num(struct dsaf_device *dsaf_dev, int comm_index)
+int hns_rcb_get_ring_num(struct dsaf_device *dsaf_dev)
 {
-       if (comm_index == HNS_DSAF_COMM_SERVICE_NW_IDX) {
-               switch (dsaf_dev->dsaf_mode) {
-               case DSAF_MODE_ENABLE_FIX:
-                       return 1;
-
-               case DSAF_MODE_DISABLE_FIX:
-                       return 6;
-
-               case DSAF_MODE_ENABLE_0VM:
-                       return 32;
-
-               case DSAF_MODE_DISABLE_6PORT_0VM:
-               case DSAF_MODE_ENABLE_16VM:
-               case DSAF_MODE_DISABLE_6PORT_2VM:
-               case DSAF_MODE_DISABLE_6PORT_16VM:
-               case DSAF_MODE_DISABLE_6PORT_4VM:
-               case DSAF_MODE_ENABLE_8VM:
-                       return 96;
-
-               case DSAF_MODE_DISABLE_2PORT_16VM:
-               case DSAF_MODE_DISABLE_2PORT_8VM:
-               case DSAF_MODE_ENABLE_32VM:
-               case DSAF_MODE_DISABLE_2PORT_64VM:
-               case DSAF_MODE_ENABLE_128VM:
-                       return 128;
-
-               default:
-                       dev_warn(dsaf_dev->dev,
-                                "get ring num fail,use default!dsaf_mode=%d\n",
-                                dsaf_dev->dsaf_mode);
-                       return 128;
-               }
-       } else {
+       switch (dsaf_dev->dsaf_mode) {
+       case DSAF_MODE_ENABLE_FIX:
+       case DSAF_MODE_DISABLE_SP:
                return 1;
+
+       case DSAF_MODE_DISABLE_FIX:
+               return 6;
+
+       case DSAF_MODE_ENABLE_0VM:
+               return 32;
+
+       case DSAF_MODE_DISABLE_6PORT_0VM:
+       case DSAF_MODE_ENABLE_16VM:
+       case DSAF_MODE_DISABLE_6PORT_2VM:
+       case DSAF_MODE_DISABLE_6PORT_16VM:
+       case DSAF_MODE_DISABLE_6PORT_4VM:
+       case DSAF_MODE_ENABLE_8VM:
+               return 96;
+
+       case DSAF_MODE_DISABLE_2PORT_16VM:
+       case DSAF_MODE_DISABLE_2PORT_8VM:
+       case DSAF_MODE_ENABLE_32VM:
+       case DSAF_MODE_DISABLE_2PORT_64VM:
+       case DSAF_MODE_ENABLE_128VM:
+               return 128;
+
+       default:
+               dev_warn(dsaf_dev->dev,
+                        "get ring num fail,use default!dsaf_mode=%d\n",
+                        dsaf_dev->dsaf_mode);
+               return 128;
        }
 }
 
 {
        void __iomem *base_addr;
 
-       if (comm_index == HNS_DSAF_COMM_SERVICE_NW_IDX)
+       if (!HNS_DSAF_IS_DEBUG(dsaf_dev))
                base_addr = dsaf_dev->ppe_base + RCB_COMMON_REG_OFFSET;
        else
                base_addr = dsaf_dev->sds_base
        u64 size = 0;
        int index = 0;
 
-       if (comm_index == HNS_DSAF_COMM_SERVICE_NW_IDX) {
+       if (!HNS_DSAF_IS_DEBUG(dsaf_dev)) {
                index    = 2;
                addr_offset = RCB_COMMON_REG_OFFSET;
        } else {
        enum dsaf_mode dsaf_mode = dsaf_dev->dsaf_mode;
        u16 max_vfn;
        u16 max_q_per_vf;
-       int ring_num = hns_rcb_get_ring_num(dsaf_dev, comm_index);
+       int ring_num = hns_rcb_get_ring_num(dsaf_dev);
 
        rcb_common =
                devm_kzalloc(dsaf_dev->dev, sizeof(*rcb_common) +
 
        rcb_common->desc_num = dsaf_dev->desc_num;
 
-       hns_rcb_get_queue_mode(dsaf_mode, comm_index, &max_vfn, &max_q_per_vf);
+       hns_rcb_get_queue_mode(dsaf_mode, &max_vfn, &max_q_per_vf);
        rcb_common->max_vfn = max_vfn;
        rcb_common->max_q_per_vf = max_q_per_vf;
 
 {
        u32 *regs = data;
        bool is_ver1 = AE_IS_VER1(rcb_com->dsaf_dev->dsaf_ver);
-       bool is_dbg = (rcb_com->comm_index != HNS_DSAF_COMM_SERVICE_NW_IDX);
+       bool is_dbg = HNS_DSAF_IS_DEBUG(rcb_com->dsaf_dev);
        u32 reg_tmp;
        u32 reg_num_tmp;
        u32 i = 0;
 
 int hns_rcb_common_init_hw(struct rcb_common_cb *rcb_common);
 void hns_rcb_start(struct hnae_queue *q, u32 val);
 void hns_rcb_get_cfg(struct rcb_common_cb *rcb_common);
-void hns_rcb_get_queue_mode(enum dsaf_mode dsaf_mode, int comm_index,
+void hns_rcb_get_queue_mode(enum dsaf_mode dsaf_mode,
                            u16 *max_vfn, u16 *max_q_per_vf);
 
 void hns_rcb_common_init_commit_hw(struct rcb_common_cb *rcb_common);
 
 
 #define DSAF_COMM_DEV_NUM 3
 #define DSAF_PPE_INODE_BASE 6
-#define HNS_DSAF_COMM_SERVICE_NW_IDX 0
 #define DSAF_DEBUG_NW_NUM      2
 #define DSAF_SERVICE_NW_NUM    6
 #define DSAF_COMM_CHN          DSAF_SERVICE_NW_NUM