ice: Get switch config, scheduler config and device capabilities

This patch adds to the initialization flow by getting switch
configuration, scheduler configuration and device capabilities.

Switch configuration:
On boot, an L2 switch element is created in the firmware per physical
function. Each physical function is also mapped to a port, to which its
switch element is connected. In other words, this switch can be visualized
as an embedded vSwitch that can connect a physical function's virtual
station interfaces (VSIs) to the egress/ingress port. Egress/ingress
filters will be eventually created and applied on this switch element.
As part of the initialization flow, the driver gets configuration data
from this switch element and stores it.

Scheduler configuration:
The Tx scheduler is a subsystem responsible for setting and enforcing QoS.
As part of the initialization flow, the driver queries and stores the
default scheduler configuration for the given physical function.

Device capabilities:
As part of initialization, the driver has to determine what the device is
capable of (ex. max queues, VSIs, etc). This information is obtained from
the firmware and stored by the driver.

CC: Shannon Nelson <shannon.nelson@oracle.com>
Signed-off-by: Anirudh Venkataramanan <anirudh.venkataramanan@intel.com>
Acked-by: Shannon Nelson <shannon.nelson@oracle.com>
Tested-by: Tony Brelinski <tonyx.brelinski@intel.com>
Signed-off-by: Jeff Kirsher <jeffrey.t.kirsher@intel.com>

1 files changed, 340 insertions, 0 deletions

diff --git a/drivers/net/ethernet/intel/ice/ice_sched.c b/drivers/net/ethernet/intel/ice/ice_sched.c
new file mode 100644
index 000000000000..ce4edf61ec8e
--- /dev/null
+++ b/drivers/net/ethernet/intel/ice/ice_sched.c
@@ -0,0 +1,340 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright (c) 2018, Intel Corporation. */
+
+#include "ice_sched.h"
+
+/**
+ * ice_aq_delete_sched_elems - delete scheduler elements
+ * @hw: pointer to the hw struct
+ * @grps_req: number of groups to delete
+ * @buf: pointer to buffer
+ * @buf_size: buffer size in bytes
+ * @grps_del: returns total number of elements deleted
+ * @cd: pointer to command details structure or NULL
+ *
+ * Delete scheduling elements (0x040F)
+ */
+static enum ice_status
+ice_aq_delete_sched_elems(struct ice_hw *hw, u16 grps_req,
+                          struct ice_aqc_delete_elem *buf, u16 buf_size,
+                          u16 *grps_del, struct ice_sq_cd *cd)
+{
+        struct ice_aqc_add_move_delete_elem *cmd;
+        struct ice_aq_desc desc;
+        enum ice_status status;
+
+        cmd = &desc.params.add_move_delete_elem;
+        ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_delete_sched_elems);
+        desc.flags |= cpu_to_le16(ICE_AQ_FLAG_RD);
+        cmd->num_grps_req = cpu_to_le16(grps_req);
+
+        status = ice_aq_send_cmd(hw, &desc, buf, buf_size, cd);
+        if (!status && grps_del)
+                *grps_del = le16_to_cpu(cmd->num_grps_updated);
+
+        return status;
+}
+
+/**
+ * ice_sched_remove_elems - remove nodes from hw
+ * @hw: pointer to the hw struct
+ * @parent: pointer to the parent node
+ * @num_nodes: number of nodes
+ * @node_teids: array of node teids to be deleted
+ *
+ * This function remove nodes from hw
+ */
+static enum ice_status
+ice_sched_remove_elems(struct ice_hw *hw, struct ice_sched_node *parent,
+                       u16 num_nodes, u32 *node_teids)
+{
+        struct ice_aqc_delete_elem *buf;
+        u16 i, num_groups_removed = 0;
+        enum ice_status status;
+        u16 buf_size;
+
+        buf_size = sizeof(*buf) + sizeof(u32) * (num_nodes - 1);
+        buf = devm_kzalloc(ice_hw_to_dev(hw), buf_size, GFP_KERNEL);
+        if (!buf)
+                return ICE_ERR_NO_MEMORY;
+        buf->hdr.parent_teid = parent->info.node_teid;
+        buf->hdr.num_elems = cpu_to_le16(num_nodes);
+        for (i = 0; i < num_nodes; i++)
+                buf->teid[i] = cpu_to_le32(node_teids[i]);
+        status = ice_aq_delete_sched_elems(hw, 1, buf, buf_size,
+                                           &num_groups_removed, NULL);
+        if (status || num_groups_removed != 1)
+                ice_debug(hw, ICE_DBG_SCHED, "remove elements failed\n");
+        devm_kfree(ice_hw_to_dev(hw), buf);
+        return status;
+}
+
+/**
+ * ice_sched_get_first_node - get the first node of the given layer
+ * @hw: pointer to the hw struct
+ * @parent: pointer the base node of the subtree
+ * @layer: layer number
+ *
+ * This function retrieves the first node of the given layer from the subtree
+ */
+static struct ice_sched_node *
+ice_sched_get_first_node(struct ice_hw *hw, struct ice_sched_node *parent,
+                         u8 layer)
+{
+        u8 i;
+
+        if (layer < hw->sw_entry_point_layer)
+                return NULL;
+        for (i = 0; i < parent->num_children; i++) {
+                struct ice_sched_node *node = parent->children[i];
+
+                if (node) {
+                        if (node->tx_sched_layer == layer)
+                                return node;
+                        /* this recursion is intentional, and wouldn't
+                         * go more than 9 calls
+                         */
+                        return ice_sched_get_first_node(hw, node, layer);
+                }
+        }
+        return NULL;
+}
+
+/**
+ * ice_sched_get_tc_node - get pointer to TC node
+ * @pi: port information structure
+ * @tc: TC number
+ *
+ * This function returns the TC node pointer
+ */
+struct ice_sched_node *ice_sched_get_tc_node(struct ice_port_info *pi, u8 tc)
+{
+        u8 i;
+
+        if (!pi)
+                return NULL;
+        for (i = 0; i < pi->root->num_children; i++)
+                if (pi->root->children[i]->tc_num == tc)
+                        return pi->root->children[i];
+        return NULL;
+}
+
+/**
+ * ice_free_sched_node - Free a Tx scheduler node from SW DB
+ * @pi: port information structure
+ * @node: pointer to the ice_sched_node struct
+ *
+ * This function frees up a node from SW DB as well as from HW
+ *
+ * This function needs to be called with the port_info->sched_lock held
+ */
+void ice_free_sched_node(struct ice_port_info *pi, struct ice_sched_node *node)
+{
+        struct ice_sched_node *parent;
+        struct ice_hw *hw = pi->hw;
+        u8 i, j;
+
+        /* Free the children before freeing up the parent node
+         * The parent array is updated below and that shifts the nodes
+         * in the array. So always pick the first child if num children > 0
+         */
+        while (node->num_children)
+                ice_free_sched_node(pi, node->children[0]);
+
+        /* Leaf, TC and root nodes can't be deleted by SW */
+        if (node->tx_sched_layer >= hw->sw_entry_point_layer &&
+            node->info.data.elem_type != ICE_AQC_ELEM_TYPE_TC &&
+            node->info.data.elem_type != ICE_AQC_ELEM_TYPE_ROOT_PORT &&
+            node->info.data.elem_type != ICE_AQC_ELEM_TYPE_LEAF) {
+                u32 teid = le32_to_cpu(node->info.node_teid);
+                enum ice_status status;
+
+                status = ice_sched_remove_elems(hw, node->parent, 1, &teid);
+                if (status)
+                        ice_debug(hw, ICE_DBG_SCHED,
+                                  "remove element failed %d\n", status);
+        }
+        parent = node->parent;
+        /* root has no parent */
+        if (parent) {
+                struct ice_sched_node *p, *tc_node;
+
+                /* update the parent */
+                for (i = 0; i < parent->num_children; i++)
+                        if (parent->children[i] == node) {
+                                for (j = i + 1; j < parent->num_children; j++)
+                                        parent->children[j - 1] =
+                                                parent->children[j];
+                                parent->num_children--;
+                                break;
+                        }
+
+                /* search for previous sibling that points to this node and
+                 * remove the reference
+                 */
+                tc_node = ice_sched_get_tc_node(pi, node->tc_num);
+                if (!tc_node) {
+                        ice_debug(hw, ICE_DBG_SCHED,
+                                  "Invalid TC number %d\n", node->tc_num);
+                        goto err_exit;
+                }
+                p = ice_sched_get_first_node(hw, tc_node, node->tx_sched_layer);
+                while (p) {
+                        if (p->sibling == node) {
+                                p->sibling = node->sibling;
+                                break;
+                        }
+                        p = p->sibling;
+                }
+        }
+err_exit:
+        /* leaf nodes have no children */
+        if (node->children)
+                devm_kfree(ice_hw_to_dev(hw), node->children);
+        devm_kfree(ice_hw_to_dev(hw), node);
+}
+
+/**
+ * ice_aq_query_sched_res - query scheduler resource
+ * @hw: pointer to the hw struct
+ * @buf_size: buffer size in bytes
+ * @buf: pointer to buffer
+ * @cd: pointer to command details structure or NULL
+ *
+ * Query scheduler resource allocation (0x0412)
+ */
+static enum ice_status
+ice_aq_query_sched_res(struct ice_hw *hw, u16 buf_size,
+                       struct ice_aqc_query_txsched_res_resp *buf,
+                       struct ice_sq_cd *cd)
+{
+        struct ice_aq_desc desc;
+
+        ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_query_sched_res);
+        return ice_aq_send_cmd(hw, &desc, buf, buf_size, cd);
+}
+
+/**
+ * ice_sched_clear_tx_topo - clears the schduler tree nodes
+ * @pi: port information structure
+ *
+ * This function removes all the nodes from HW as well as from SW DB.
+ */
+static void ice_sched_clear_tx_topo(struct ice_port_info *pi)
+{
+        struct ice_sched_agg_info *agg_info;
+        struct ice_sched_vsi_info *vsi_elem;
+        struct ice_sched_agg_info *atmp;
+        struct ice_sched_vsi_info *tmp;
+        struct ice_hw *hw;
+
+        if (!pi)
+                return;
+
+        hw = pi->hw;
+
+        list_for_each_entry_safe(agg_info, atmp, &pi->agg_list, list_entry) {
+                struct ice_sched_agg_vsi_info *agg_vsi_info;
+                struct ice_sched_agg_vsi_info *vtmp;
+
+                list_for_each_entry_safe(agg_vsi_info, vtmp,
+                                         &agg_info->agg_vsi_list, list_entry) {
+                        list_del(&agg_vsi_info->list_entry);
+                        devm_kfree(ice_hw_to_dev(hw), agg_vsi_info);
+                }
+        }
+
+        /* remove the vsi list */
+        list_for_each_entry_safe(vsi_elem, tmp, &pi->vsi_info_list,
+                                 list_entry) {
+                list_del(&vsi_elem->list_entry);
+                devm_kfree(ice_hw_to_dev(hw), vsi_elem);
+        }
+
+        if (pi->root) {
+                ice_free_sched_node(pi, pi->root);
+                pi->root = NULL;
+        }
+}
+
+/**
+ * ice_sched_clear_port - clear the scheduler elements from SW DB for a port
+ * @pi: port information structure
+ *
+ * Cleanup scheduling elements from SW DB
+ */
+static void ice_sched_clear_port(struct ice_port_info *pi)
+{
+        if (!pi || pi->port_state != ICE_SCHED_PORT_STATE_READY)
+                return;
+
+        pi->port_state = ICE_SCHED_PORT_STATE_INIT;
+        mutex_lock(&pi->sched_lock);
+        ice_sched_clear_tx_topo(pi);
+        mutex_unlock(&pi->sched_lock);
+        mutex_destroy(&pi->sched_lock);
+}
+
+/**
+ * ice_sched_cleanup_all - cleanup scheduler elements from SW DB for all ports
+ * @hw: pointer to the hw struct
+ *
+ * Cleanup scheduling elements from SW DB for all the ports
+ */
+void ice_sched_cleanup_all(struct ice_hw *hw)
+{
+        if (!hw || !hw->port_info)
+                return;
+
+        if (hw->layer_info)
+                devm_kfree(ice_hw_to_dev(hw), hw->layer_info);
+
+        ice_sched_clear_port(hw->port_info);
+
+        hw->num_tx_sched_layers = 0;
+        hw->num_tx_sched_phys_layers = 0;
+        hw->flattened_layers = 0;
+        hw->max_cgds = 0;
+}
+
+/**
+ * ice_sched_query_res_alloc - query the FW for num of logical sched layers
+ * @hw: pointer to the HW struct
+ *
+ * query FW for allocated scheduler resources and store in HW struct
+ */
+enum ice_status ice_sched_query_res_alloc(struct ice_hw *hw)
+{
+        struct ice_aqc_query_txsched_res_resp *buf;
+        enum ice_status status = 0;
+
+        if (hw->layer_info)
+                return status;
+
+        buf = devm_kzalloc(ice_hw_to_dev(hw), sizeof(*buf), GFP_KERNEL);
+        if (!buf)
+                return ICE_ERR_NO_MEMORY;
+
+        status = ice_aq_query_sched_res(hw, sizeof(*buf), buf, NULL);
+        if (status)
+                goto sched_query_out;
+
+        hw->num_tx_sched_layers = le16_to_cpu(buf->sched_props.logical_levels);
+        hw->num_tx_sched_phys_layers =
+                le16_to_cpu(buf->sched_props.phys_levels);
+        hw->flattened_layers = buf->sched_props.flattening_bitmap;
+        hw->max_cgds = buf->sched_props.max_pf_cgds;
+
+         hw->layer_info = devm_kmemdup(ice_hw_to_dev(hw), buf->layer_props,
+                                       (hw->num_tx_sched_layers *
+                                        sizeof(*hw->layer_info)),
+                                       GFP_KERNEL);
+        if (!hw->layer_info) {
+                status = ICE_ERR_NO_MEMORY;
+                goto sched_query_out;
+        }
+
+sched_query_out:
+        devm_kfree(ice_hw_to_dev(hw), buf);
+        return status;
+}