cnss2: add support for multi-exchg wlan devices

Converge dt nodes for wlan chips that share the same PCI slot
into one node.

The items in this node are split into 2 parts: common and chip
specific.

The common part will be parsed during cnss probe, such as basic
power related configuration and bus type, to power on the device
and trigger pci probe;

Chip specific part will be parsed during bus specific probe, this
part includes chip specific power and feature related
configurations.

With this change, cnss2 can support different chips on one pci
slot with the same image.

Change-Id: I08c64b6dc3cc27a479ee6fd07e3c8705cc3ac43d
CRs-Fixed: 2384088

cnss2/bus.c

@@ -22,9 +22,29 @@ enum cnss_dev_bus_type cnss_get_dev_bus_type(struct device *dev)
 		return CNSS_BUS_NONE;
 }
 
-enum cnss_dev_bus_type cnss_get_bus_type(unsigned long device_id)
+enum cnss_dev_bus_type cnss_get_bus_type(struct cnss_plat_data *plat_priv)
 {
-	switch (device_id) {
+	int ret;
+	struct device *dev;
+	u32 bus_type_dt = CNSS_BUS_NONE;
+
+	if (plat_priv->dt_type == CNSS_DTT_MULTIEXCHG) {
+		dev = &plat_priv->plat_dev->dev;
+		ret = of_property_read_u32(dev->of_node, "qcom,bus-type",
+					   &bus_type_dt);
+		if (!ret)
+			if (bus_type_dt < CNSS_BUS_MAX)
+				cnss_pr_dbg("Got bus type[%u] from dt\n",
+					    bus_type_dt);
+			else
+				bus_type_dt = CNSS_BUS_NONE;
+		else
+			cnss_pr_err("No bus type for multi-exchg dt\n");
+
+		return bus_type_dt;
+	}
+
+	switch (plat_priv->device_id) {
 	case QCA6174_DEVICE_ID:
 	case QCA6290_DEVICE_ID:
 	case QCA6390_DEVICE_ID:
@@ -33,7 +53,7 @@ enum cnss_dev_bus_type cnss_get_bus_type(unsigned long device_id)
 	case MANGO_DEVICE_ID:
 		return CNSS_BUS_PCI;
 	default:
-		cnss_pr_err("Unknown device_id: 0x%lx\n", device_id);
+		cnss_pr_err("Unknown device_id: 0x%lx\n", plat_priv->device_id);
 		return CNSS_BUS_NONE;
 	}
 }

cnss2/bus.h

@@ -26,7 +26,7 @@
 #define MANGO_DEVICE_ID			0x110A
 
 enum cnss_dev_bus_type cnss_get_dev_bus_type(struct device *dev);
-enum cnss_dev_bus_type cnss_get_bus_type(unsigned long device_id);
+enum cnss_dev_bus_type cnss_get_bus_type(struct cnss_plat_data *plat_priv);
 void *cnss_bus_dev_to_bus_priv(struct device *dev);
 struct cnss_plat_data *cnss_bus_dev_to_plat_priv(struct device *dev);
 int cnss_bus_init(struct cnss_plat_data *plat_priv);

cnss2/main.c

@@ -1516,7 +1516,7 @@ static int cnss_subsys_powerup(const struct subsys_desc *subsys_desc)
 	}
 
 	if (!plat_priv->driver_state) {
-		cnss_pr_dbg("Powerup is ignored\n");
+		cnss_pr_dbg("subsys powerup is ignored\n");
 		return 0;
 	}
 
@@ -1543,7 +1543,7 @@ static int cnss_subsys_shutdown(const struct subsys_desc *subsys_desc,
 	}
 
 	if (!plat_priv->driver_state) {
-		cnss_pr_dbg("shutdown is ignored\n");
+		cnss_pr_dbg("subsys shutdown is ignored\n");
 		return 0;
 	}
 
@@ -2831,8 +2831,17 @@ static int cnss_register_ramdump_v1(struct cnss_plat_data *plat_priv)
 	dev = &plat_priv->plat_dev->dev;
 	ramdump_info = &plat_priv->ramdump_info;
 
-	if (of_property_read_u32(dev->of_node, "qcom,wlan-ramdump-dynamic",
-				 &ramdump_size) == 0) {
+	if (plat_priv->dt_type != CNSS_DTT_MULTIEXCHG) {
+		/* dt type: legacy or converged */
+		ret = of_property_read_u32(dev->of_node,
+					   "qcom,wlan-ramdump-dynamic",
+					   &ramdump_size);
+	} else {
+		ret = of_property_read_u32(plat_priv->dev_node,
+					   "qcom,wlan-ramdump-dynamic",
+					   &ramdump_size);
+	}
+	if (ret == 0) {
 		ramdump_info->ramdump_va =
 			dma_alloc_coherent(dev, ramdump_size,
 					   &ramdump_info->ramdump_pa,
@@ -2915,8 +2924,17 @@ static int cnss_register_ramdump_v2(struct cnss_plat_data *plat_priv)
 	info_v2 = &plat_priv->ramdump_info_v2;
 	dump_data = &info_v2->dump_data;
 
-	if (of_property_read_u32(dev->of_node, "qcom,wlan-ramdump-dynamic",
-				 &ramdump_size) == 0)
+	if (plat_priv->dt_type != CNSS_DTT_MULTIEXCHG) {
+		/* dt type: legacy or converged */
+		ret = of_property_read_u32(dev->of_node,
+					   "qcom,wlan-ramdump-dynamic",
+					   &ramdump_size);
+	} else {
+		ret = of_property_read_u32(plat_priv->dev_node,
+					   "qcom,wlan-ramdump-dynamic",
+					   &ramdump_size);
+	}
+	if (ret == 0)
 		info_v2->ramdump_size = ramdump_size;
 
 	cnss_pr_dbg("Ramdump size 0x%lx\n", info_v2->ramdump_size);
@@ -3975,7 +3993,7 @@ static int cnss_get_dev_cfg_node(struct cnss_plat_data *plat_priv)
 	u8 gpio_value;
 
 
-	if (!plat_priv->is_converged_dt)
+	if (plat_priv->dt_type != CNSS_DTT_CONVERGED)
 		return 0;
 
 	/* Parses the wlan_sw_ctrl gpio which is used to identify device */
@@ -4031,11 +4049,22 @@ static int cnss_get_dev_cfg_node(struct cnss_plat_data *plat_priv)
 	return -EINVAL;
 }
 
-static inline bool
-cnss_is_converged_dt(struct cnss_plat_data *plat_priv)
+static inline u32
+cnss_dt_type(struct cnss_plat_data *plat_priv)
 {
-	return of_property_read_bool(plat_priv->plat_dev->dev.of_node,
-				     "qcom,converged-dt");
+	bool is_converged_dt = of_property_read_bool(
+		plat_priv->plat_dev->dev.of_node, "qcom,converged-dt");
+	bool is_multi_wlan_xchg;
+
+	if (is_converged_dt)
+		return CNSS_DTT_CONVERGED;
+
+	is_multi_wlan_xchg = of_property_read_bool(
+		plat_priv->plat_dev->dev.of_node, "qcom,multi-wlan-exchg");
+
+	if (is_multi_wlan_xchg)
+		return CNSS_DTT_MULTIEXCHG;
+	return CNSS_DTT_LEGACY;
 }
 
 static int cnss_wlan_device_init(struct cnss_plat_data *plat_priv)
@@ -4130,8 +4159,12 @@ static int cnss_probe(struct platform_device *plat_dev)
 	}
 
 	plat_priv->plat_dev = plat_dev;
+	plat_priv->dev_node = NULL;
 	plat_priv->device_id = device_id->driver_data;
-	plat_priv->is_converged_dt = cnss_is_converged_dt(plat_priv);
+	plat_priv->dt_type = cnss_dt_type(plat_priv);
+	cnss_pr_dbg("Probing platform driver from dt type: %d\n",
+		    plat_priv->dt_type);
+
 	plat_priv->use_fw_path_with_prefix =
 		cnss_use_fw_path_with_prefix(plat_priv);
 
@@ -4141,7 +4174,7 @@ static int cnss_probe(struct platform_device *plat_dev)
 		goto reset_plat_dev;
 	}
 
-	plat_priv->bus_type = cnss_get_bus_type(plat_priv->device_id);
+	plat_priv->bus_type = cnss_get_bus_type(plat_priv);
 	plat_priv->use_nv_mac = cnss_use_nv_mac(plat_priv);
 	plat_priv->driver_mode = CNSS_DRIVER_MODE_MAX;
 	cnss_set_plat_priv(plat_dev, plat_priv);

cnss2/main.h

@@ -20,6 +20,7 @@
 #endif
 #include <linux/mailbox_client.h>
 #include <linux/pm_qos.h>
+#include <linux/of.h>
 #include <linux/platform_device.h>
 #include <linux/time64.h>
 #ifdef CONFIG_CNSS_OUT_OF_TREE
@@ -66,9 +67,16 @@
 				CNSS_EVENT_UNINTERRUPTIBLE)
 #define CNSS_EVENT_SYNC_UNKILLABLE (CNSS_EVENT_SYNC | CNSS_EVENT_UNKILLABLE)
 
+enum cnss_dt_type {
+	CNSS_DTT_LEGACY = 0,
+	CNSS_DTT_CONVERGED = 1,
+	CNSS_DTT_MULTIEXCHG = 2
+};
+
 enum cnss_dev_bus_type {
 	CNSS_BUS_NONE = -1,
 	CNSS_BUS_PCI,
+	CNSS_BUS_MAX
 };
 
 struct cnss_vreg_cfg {
@@ -550,7 +558,7 @@ struct cnss_plat_data {
 	int pdc_init_table_len, vreg_pdc_map_len, pmu_vreg_map_len;
 	bool adsp_pc_enabled;
 	u64 feature_list;
-	u32 is_converged_dt;
+	u32 dt_type;
 	struct kobject *wifi_kobj;
 	u16 hang_event_data_len;
 	u32 hang_data_addr_offset;
@@ -559,6 +567,7 @@ struct cnss_plat_data {
 	enum cnss_driver_mode driver_mode;
 	uint32_t num_shadow_regs_v3;
 	bool sec_peri_feature_disable;
+	struct device_node *dev_node;
 };
 
 #if IS_ENABLED(CONFIG_ARCH_QCOM)
@@ -651,4 +660,5 @@ int cnss_get_feature_list(struct cnss_plat_data *plat_priv,
 			  u64 *feature_list);
 int cnss_get_input_gpio_value(struct cnss_plat_data *plat_priv, int gpio_num);
 bool cnss_check_driver_loading_allowed(void);
+int cnss_dev_specific_power_on(struct cnss_plat_data *plat_priv);
 #endif /* _CNSS_MAIN_H */

cnss2/pci.c

@@ -5860,6 +5860,52 @@ static struct dev_pm_domain cnss_pm_domain = {
 	}
 };
 
+static int cnss_pci_get_dev_cfg_node(struct cnss_plat_data *plat_priv)
+{
+	struct device_node *child;
+	u32 id, i;
+	int id_n, ret;
+
+	if (plat_priv->dt_type != CNSS_DTT_MULTIEXCHG)
+		return 0;
+
+	if (!plat_priv->device_id) {
+		cnss_pr_err("Invalid device id\n");
+		return -EINVAL;
+	}
+
+	for_each_available_child_of_node(plat_priv->plat_dev->dev.of_node,
+					 child) {
+		if (strcmp(child->name, "chip_cfg"))
+			continue;
+
+		id_n = of_property_count_u32_elems(child, "supported-ids");
+		if (id_n <= 0) {
+			cnss_pr_err("Device id is NOT set\n");
+			return -EINVAL;
+		}
+
+		for (i = 0; i < id_n; i++) {
+			ret = of_property_read_u32_index(child,
+							 "supported-ids",
+							 i, &id);
+			if (ret) {
+				cnss_pr_err("Failed to read supported ids\n");
+				return -EINVAL;
+			}
+
+			if (id == plat_priv->device_id) {
+				plat_priv->dev_node = child;
+				cnss_pr_dbg("got node[%s@%d] for device[0x%x]\n",
+					    child->name, i, id);
+				return 0;
+			}
+		}
+	}
+
+	return -EINVAL;
+}
+
 #ifdef CONFIG_CNSS2_CONDITIONAL_POWEROFF
 static bool cnss_should_suspend_pwroff(struct pci_dev *pci_dev)
 {
@@ -5931,6 +5977,16 @@ static int cnss_pci_probe(struct pci_dev *pci_dev,
 	if (plat_priv->use_pm_domain)
 		dev->pm_domain = &cnss_pm_domain;
 
+	ret = cnss_pci_get_dev_cfg_node(plat_priv);
+	if (ret) {
+		cnss_pr_err("Failed to get device cfg node, err = %d\n", ret);
+		goto reset_ctx;
+	}
+
+	ret = cnss_dev_specific_power_on(plat_priv);
+	if (ret)
+		goto reset_ctx;
+
 	cnss_pci_of_reserved_mem_device_init(pci_priv);
 
 	ret = cnss_register_subsys(plat_priv);

cnss2/power.c

@@ -69,6 +69,7 @@ static struct cnss_clk_cfg cnss_clk_list[] = {
 #define WLAN_SW_CTRL_GPIO		"qcom,wlan-sw-ctrl-gpio"
 #define WLAN_EN_ACTIVE			"wlan_en_active"
 #define WLAN_EN_SLEEP			"wlan_en_sleep"
+#define WLAN_VREGS_PROP			"wlan_vregs"
 
 #define BOOTSTRAP_DELAY			1000
 #define WLAN_ENABLE_DELAY		1000
@@ -131,8 +132,11 @@ static int cnss_get_vreg_single(struct cnss_plat_data *plat_priv,
 	const __be32 *prop;
 	char prop_name[MAX_PROP_SIZE] = {0};
 	int len;
+	struct device_node *dt_node;
 
 	dev = &plat_priv->plat_dev->dev;
+	dt_node = (plat_priv->dev_node ? plat_priv->dev_node : dev->of_node);
+
 	reg = devm_regulator_get_optional(dev, vreg->cfg.name);
 	if (IS_ERR(reg)) {
 		ret = PTR_ERR(reg);
@@ -152,7 +156,7 @@ static int cnss_get_vreg_single(struct cnss_plat_data *plat_priv,
 	snprintf(prop_name, MAX_PROP_SIZE, "qcom,%s-config",
 		 vreg->cfg.name);
 
-	prop = of_get_property(dev->of_node, prop_name, &len);
+	prop = of_get_property(dt_node, prop_name, &len);
 	if (!prop || len != (5 * sizeof(__be32))) {
 		cnss_pr_dbg("Property %s %s, use default\n", prop_name,
 			    prop ? "invalid format" : "doesn't exist");
@@ -315,6 +319,16 @@ static struct cnss_vreg_cfg *get_vreg_list(u32 *vreg_list_size,
 	}
 }
 
+/*
+ * For multi-exchg dt node, get the required vregs' names from property
+ * 'wlan_vregs', which is string array;
+ *
+ * if the property is present but no value is set, then no additional wlan
+ * verg is required.
+ *
+ * For non-multi-exchg dt, go through all vregs in the static array
+ * 'cnss_vreg_list'.
+ */
 static int cnss_get_vreg(struct cnss_plat_data *plat_priv,
 			 struct list_head *vreg_list,
 			 struct cnss_vreg_cfg *vreg_cfg,
@@ -324,18 +338,53 @@ static int cnss_get_vreg(struct cnss_plat_data *plat_priv,
 	int i;
 	struct cnss_vreg_info *vreg;
 	struct device *dev = &plat_priv->plat_dev->dev;
+	int id_n;
+	struct device_node *dt_node;
 
-	if (!list_empty(vreg_list)) {
+	if (!list_empty(vreg_list) &&
+	    (plat_priv->dt_type != CNSS_DTT_MULTIEXCHG)) {
 		cnss_pr_dbg("Vregs have already been updated\n");
 		return 0;
 	}
 
-	for (i = 0; i < vreg_list_size; i++) {
+	dt_node = (plat_priv->dev_node ? plat_priv->dev_node : dev->of_node);
+	if (plat_priv->dt_type == CNSS_DTT_MULTIEXCHG) {
+		id_n = of_property_count_strings(dt_node,
+						 WLAN_VREGS_PROP);
+		if (id_n <= 0) {
+			if (id_n == -ENODATA) {
+				cnss_pr_dbg("No additional vregs for: %s:%lx\n",
+					    dt_node->name,
+					    plat_priv->device_id);
+				return 0;
+			}
+
+			cnss_pr_err("property %s is invalid or missed: %s:%lx\n",
+				    WLAN_VREGS_PROP, dt_node->name,
+				    plat_priv->device_id);
+			return -EINVAL;
+		}
+	} else {
+		id_n = vreg_list_size;
+	}
+
+	for (i = 0; i < id_n; i++) {
 		vreg = devm_kzalloc(dev, sizeof(*vreg), GFP_KERNEL);
 		if (!vreg)
 			return -ENOMEM;
 
-		memcpy(&vreg->cfg, &vreg_cfg[i], sizeof(vreg->cfg));
+		if (plat_priv->dt_type == CNSS_DTT_MULTIEXCHG) {
+			ret = of_property_read_string_index(dt_node,
+							    WLAN_VREGS_PROP, i,
+							    &vreg->cfg.name);
+			if (ret) {
+				cnss_pr_err("Failed to read vreg ids\n");
+				return ret;
+			}
+		} else {
+			memcpy(&vreg->cfg, &vreg_cfg[i], sizeof(vreg->cfg));
+		}
+
 		ret = cnss_get_vreg_single(plat_priv, vreg);
 		if (ret != 0) {
 			if (ret == -ENODEV) {
@@ -1690,3 +1739,18 @@ int cnss_enable_int_pow_amp_vreg(struct cnss_plat_data *plat_priv)
 
 	return 0;
 }
+
+int cnss_dev_specific_power_on(struct cnss_plat_data *plat_priv)
+{
+	int ret;
+
+	if (plat_priv->dt_type != CNSS_DTT_MULTIEXCHG)
+		return 0;
+
+	ret = cnss_get_vreg_type(plat_priv, CNSS_VREG_PRIM);
+	if (ret)
+		return ret;
+
+	plat_priv->powered_on = false;
+	return cnss_power_on_device(plat_priv);
+}