Merge "net: cnss2: Add snapshot of CNSS2 driver" (f02ce0db) · Commits · e / devices / android_kernel_fairphone_FP5

drivers/net/wireless/Kconfig

+2 −0

Original line number	Diff line number	Diff line
		@@ -122,4 +122,6 @@ config VIRT_WIFI
		This option adds support for ethernet connections to appear as if they
		are wifi connections through a special rtnetlink device.

		source "drivers/net/wireless/cnss2/Kconfig"

		endif # WLAN

drivers/net/wireless/Makefile

+2 −0

Original line number	Diff line number	Diff line
		@@ -29,3 +29,5 @@ obj-$(CONFIG_USB_NET_RNDIS_WLAN) += rndis_wlan.o
		obj-$(CONFIG_MAC80211_HWSIM) += mac80211_hwsim.o

		obj-$(CONFIG_VIRT_WIFI) += virt_wifi.o

		obj-$(CONFIG_CNSS2) += cnss2/

drivers/net/wireless/cnss2/Kconfig

0 → 100644

+88 −0

Original line number	Diff line number	Diff line
		# SPDX-License-Identifier: GPL-2.0-only

		config CNSS2
		tristate "CNSS2 Platform Driver for Wi-Fi Module"
		depends on !CNSS && PCI_MSM
		help
		This module adds the support for Connectivity Subsystem (CNSS) used
		for PCIe based Wi-Fi devices with QCA6174/QCA6290 chipsets.
		This driver also adds support to integrate WLAN module to subsystem
		restart framework.

		config CNSS2_DEBUG
		bool "CNSS2 Platform Driver Debug Support"
		depends on CNSS2
		help
		This option is to enable CNSS2 platform driver debug support which
		primarily includes providing additional verbose logs for certain
		features, enabling kernel panic for certain cases to aid the
		debugging, and enabling any other debug mechanisms.

		config CNSS2_QMI
		bool "CNSS2 Platform Driver QMI support"
		depends on CNSS2
		help
		CNSS2 platform driver uses QMI framework to communicate with WLAN
		firmware. It sends and receives boot handshake messages to WLAN
		firmware, which includes hardware and software capabilities and
		configurations. It also sends WLAN on/off control message to
		firmware over QMI channel.

		config CNSS_ASYNC
		bool "Enable/disable CNSS platform driver asynchronous probe"
		depends on CNSS2
		help
		If enabled, CNSS platform driver would do asynchronous probe.
		Using asynchronous probe will allow CNSS platform driver to
		probe in parallel with other device drivers and will help to
		reduce kernel boot time.

		config BUS_AUTO_SUSPEND
		bool "Enable/Disable Runtime PM support for PCIe based WLAN Drivers"
		depends on CNSS2
		depends on PCI
		help
		Runtime Power Management is supported for PCIe based WLAN Drivers.
		The features enable cld wlan driver to suspend pcie bus when APPS
		is awake based on the driver inactivity with the Firmware.
		The Feature uses runtime power management framework from kernel to
		track bus access clients and to synchronize the driver activity
		during system pm.
		This config flag controls the feature per target based. The feature
		requires CNSS driver support.

		config CNSS_QCA6290
		bool "Enable CNSS QCA6290 chipset specific changes"
		depends on CNSS2
		help
		This enables the changes from WLAN host driver that are specific to
		CNSS QCA6290 chipset.
		These changes are needed to support the new hardware architecture
		for CNSS QCA6290 chipset.

		config CNSS_QCA6390
		bool "Enable CNSS QCA6390 chipset specific changes"
		depends on CNSS2
		help
		This enables the changes from WLAN host driver that are specific to
		CNSS QCA6390 chipset.
		These changes are needed to support the new hardware architecture
		for CNSS QCA6390 chipset.

		config CNSS_EMULATION
		bool "Enable specific changes for emulation hardware"
		depends on CNSS2
		help
		This enables the changes from WLAN drivers that are specific to
		emulation hardware.
		These changes are needed for WLAN drivers to support and meet the
		requirement of emulation hardware.

		config CNSS_QCA6490
		bool "Enable CNSS QCA6490 chipset specific changes"
		depends on CNSS2
		help
		This enables the changes from WLAN host driver that are specific to
		CNSS QCA6490 chipset.
		These changes are needed to support the new hardware architecture
		for CNSS QCA6490 chipset.
		No newline at end of file

drivers/net/wireless/cnss2/Makefile

0 → 100644

+11 −0

Original line number	Diff line number	Diff line
		# SPDX-License-Identifier: GPL-2.0-only

		obj-$(CONFIG_CNSS2) += cnss2.o

		cnss2-y := main.o
		cnss2-y += bus.o
		cnss2-y += debug.o
		cnss2-y += pci.o
		cnss2-y += power.o
		cnss2-$(CONFIG_CNSS2_DEBUG) += genl.o
		cnss2-$(CONFIG_CNSS2_QMI) += qmi.o wlan_firmware_service_v01.o coexistence_service_v01.o ip_multimedia_subsystem_private_service_v01.o

drivers/net/wireless/cnss2/bus.c

0 → 100644

+374 −0

Original line number	Diff line number	Diff line
		// SPDX-License-Identifier: GPL-2.0-only
		/* Copyright (c) 2018-2019, The Linux Foundation. All rights reserved. */

		#include "bus.h"
		#include "debug.h"
		#include "pci.h"

		enum cnss_dev_bus_type cnss_get_dev_bus_type(struct device *dev)
		{
		if (!dev)
		return CNSS_BUS_NONE;

		if (!dev->bus)
		return CNSS_BUS_NONE;

		if (memcmp(dev->bus->name, "pci", 3) == 0)
		return CNSS_BUS_PCI;
		else
		return CNSS_BUS_NONE;
		}

		enum cnss_dev_bus_type cnss_get_bus_type(unsigned long device_id)
		{
		switch (device_id) {
		case QCA6174_DEVICE_ID:
		case QCA6290_DEVICE_ID:
		case QCA6390_DEVICE_ID:
		case QCA6490_DEVICE_ID:
		return CNSS_BUS_PCI;
		default:
		cnss_pr_err("Unknown device_id: 0x%lx\n", device_id);
		return CNSS_BUS_NONE;
		}
		}

		void cnss_bus_dev_to_bus_priv(struct device dev)
		{
		if (!dev)
		return NULL;

		switch (cnss_get_dev_bus_type(dev)) {
		case CNSS_BUS_PCI:
		return cnss_get_pci_priv(to_pci_dev(dev));
		default:
		return NULL;
		}
		}

		struct cnss_plat_data cnss_bus_dev_to_plat_priv(struct device dev)
		{
		void *bus_priv;

		if (!dev)
		return cnss_get_plat_priv(NULL);

		bus_priv = cnss_bus_dev_to_bus_priv(dev);
		if (!bus_priv)
		return NULL;

		switch (cnss_get_dev_bus_type(dev)) {
		case CNSS_BUS_PCI:
		return cnss_pci_priv_to_plat_priv(bus_priv);
		default:
		return NULL;
		}
		}

		int cnss_bus_init(struct cnss_plat_data *plat_priv)
		{
		if (!plat_priv)
		return -ENODEV;

		switch (plat_priv->bus_type) {
		case CNSS_BUS_PCI:
		return cnss_pci_init(plat_priv);
		default:
		cnss_pr_err("Unsupported bus type: %d\n",
		plat_priv->bus_type);
		return -EINVAL;
		}
		}

		void cnss_bus_deinit(struct cnss_plat_data *plat_priv)
		{
		if (!plat_priv)
		return;

		switch (plat_priv->bus_type) {
		case CNSS_BUS_PCI:
		cnss_pci_deinit(plat_priv);
		default:
		cnss_pr_err("Unsupported bus type: %d\n",
		plat_priv->bus_type);
		return;
		}
		}

		int cnss_bus_load_m3(struct cnss_plat_data *plat_priv)
		{
		if (!plat_priv)
		return -ENODEV;

		switch (plat_priv->bus_type) {
		case CNSS_BUS_PCI:
		return cnss_pci_load_m3(plat_priv->bus_priv);
		default:
		cnss_pr_err("Unsupported bus type: %d\n",
		plat_priv->bus_type);
		return -EINVAL;
		}
		}

		int cnss_bus_alloc_fw_mem(struct cnss_plat_data *plat_priv)
		{
		if (!plat_priv)
		return -ENODEV;

		switch (plat_priv->bus_type) {
		case CNSS_BUS_PCI:
		return cnss_pci_alloc_fw_mem(plat_priv->bus_priv);
		default:
		cnss_pr_err("Unsupported bus type: %d\n",
		plat_priv->bus_type);
		return -EINVAL;
		}
		}

		int cnss_bus_alloc_qdss_mem(struct cnss_plat_data *plat_priv)
		{
		if (!plat_priv)
		return -ENODEV;

		switch (plat_priv->bus_type) {
		case CNSS_BUS_PCI:
		return cnss_pci_alloc_qdss_mem(plat_priv->bus_priv);
		default:
		cnss_pr_err("Unsupported bus type: %d\n",
		plat_priv->bus_type);
		return -EINVAL;
		}
		}

		void cnss_bus_free_qdss_mem(struct cnss_plat_data *plat_priv)
		{
		if (!plat_priv)
		return;

		switch (plat_priv->bus_type) {
		case CNSS_BUS_PCI:
		cnss_pci_free_qdss_mem(plat_priv->bus_priv);
		return;
		default:
		cnss_pr_err("Unsupported bus type: %d\n",
		plat_priv->bus_type);
		return;
		}
		}

		u32 cnss_bus_get_wake_irq(struct cnss_plat_data *plat_priv)
		{
		if (!plat_priv)
		return -ENODEV;

		switch (plat_priv->bus_type) {
		case CNSS_BUS_PCI:
		return cnss_pci_get_wake_msi(plat_priv->bus_priv);
		default:
		cnss_pr_err("Unsupported bus type: %d\n",
		plat_priv->bus_type);
		return -EINVAL;
		}
		}

		int cnss_bus_force_fw_assert_hdlr(struct cnss_plat_data *plat_priv)
		{
		if (!plat_priv)
		return -ENODEV;

		switch (plat_priv->bus_type) {
		case CNSS_BUS_PCI:
		return cnss_pci_force_fw_assert_hdlr(plat_priv->bus_priv);
		default:
		cnss_pr_err("Unsupported bus type: %d\n",
		plat_priv->bus_type);
		return -EINVAL;
		}
		}

		void cnss_bus_fw_boot_timeout_hdlr(struct timer_list *t)
		{
		struct cnss_plat_data *plat_priv =
		from_timer(plat_priv, t, fw_boot_timer);

		if (!plat_priv)
		return;

		switch (plat_priv->bus_type) {
		case CNSS_BUS_PCI:
		return cnss_pci_fw_boot_timeout_hdlr(plat_priv->bus_priv);
		default:
		cnss_pr_err("Unsupported bus type: %d\n",
		plat_priv->bus_type);
		return;
		}
		}

		void cnss_bus_collect_dump_info(struct cnss_plat_data *plat_priv, bool in_panic)
		{
		if (!plat_priv)
		return;

		switch (plat_priv->bus_type) {
		case CNSS_BUS_PCI:
		return cnss_pci_collect_dump_info(plat_priv->bus_priv,
		in_panic);
		default:
		cnss_pr_err("Unsupported bus type: %d\n",
		plat_priv->bus_type);
		return;
		}
		}

		int cnss_bus_call_driver_probe(struct cnss_plat_data *plat_priv)
		{
		if (!plat_priv)
		return -ENODEV;

		switch (plat_priv->bus_type) {
		case CNSS_BUS_PCI:
		return cnss_pci_call_driver_probe(plat_priv->bus_priv);
		default:
		cnss_pr_err("Unsupported bus type: %d\n",
		plat_priv->bus_type);
		return -EINVAL;
		}
		}

		int cnss_bus_call_driver_remove(struct cnss_plat_data *plat_priv)
		{
		if (!plat_priv)
		return -ENODEV;

		switch (plat_priv->bus_type) {
		case CNSS_BUS_PCI:
		return cnss_pci_call_driver_remove(plat_priv->bus_priv);
		default:
		cnss_pr_err("Unsupported bus type: %d\n",
		plat_priv->bus_type);
		return -EINVAL;
		}
		}

		int cnss_bus_dev_powerup(struct cnss_plat_data *plat_priv)
		{
		if (!plat_priv)
		return -ENODEV;

		switch (plat_priv->bus_type) {
		case CNSS_BUS_PCI:
		return cnss_pci_dev_powerup(plat_priv->bus_priv);
		default:
		cnss_pr_err("Unsupported bus type: %d\n",
		plat_priv->bus_type);
		return -EINVAL;
		}
		}

		int cnss_bus_dev_shutdown(struct cnss_plat_data *plat_priv)
		{
		if (!plat_priv)
		return -ENODEV;

		switch (plat_priv->bus_type) {
		case CNSS_BUS_PCI:
		return cnss_pci_dev_shutdown(plat_priv->bus_priv);
		default:
		cnss_pr_err("Unsupported bus type: %d\n",
		plat_priv->bus_type);
		return -EINVAL;
		}
		}

		int cnss_bus_dev_crash_shutdown(struct cnss_plat_data *plat_priv)
		{
		if (!plat_priv)
		return -ENODEV;

		switch (plat_priv->bus_type) {
		case CNSS_BUS_PCI:
		return cnss_pci_dev_crash_shutdown(plat_priv->bus_priv);
		default:
		cnss_pr_err("Unsupported bus type: %d\n",
		plat_priv->bus_type);
		return -EINVAL;
		}
		}

		int cnss_bus_dev_ramdump(struct cnss_plat_data *plat_priv)
		{
		if (!plat_priv)
		return -ENODEV;

		switch (plat_priv->bus_type) {
		case CNSS_BUS_PCI:
		return cnss_pci_dev_ramdump(plat_priv->bus_priv);
		default:
		cnss_pr_err("Unsupported bus type: %d\n",
		plat_priv->bus_type);
		return -EINVAL;
		}
		}

		int cnss_bus_register_driver_hdlr(struct cnss_plat_data plat_priv, void data)
		{
		if (!plat_priv)
		return -ENODEV;

		switch (plat_priv->bus_type) {
		case CNSS_BUS_PCI:
		return cnss_pci_register_driver_hdlr(plat_priv->bus_priv, data);
		default:
		cnss_pr_err("Unsupported bus type: %d\n",
		plat_priv->bus_type);
		return -EINVAL;
		}
		}

		int cnss_bus_unregister_driver_hdlr(struct cnss_plat_data *plat_priv)
		{
		if (!plat_priv)
		return -ENODEV;

		switch (plat_priv->bus_type) {
		case CNSS_BUS_PCI:
		return cnss_pci_unregister_driver_hdlr(plat_priv->bus_priv);
		default:
		cnss_pr_err("Unsupported bus type: %d\n",
		plat_priv->bus_type);
		return -EINVAL;
		}
		}

		int cnss_bus_call_driver_modem_status(struct cnss_plat_data *plat_priv,
		int modem_current_status)
		{
		if (!plat_priv)
		return -ENODEV;

		switch (plat_priv->bus_type) {
		case CNSS_BUS_PCI:
		return cnss_pci_call_driver_modem_status(plat_priv->bus_priv,
		modem_current_status);
		default:
		cnss_pr_err("Unsupported bus type: %d\n",
		plat_priv->bus_type);
		return -EINVAL;
		}
		}

		int cnss_bus_update_status(struct cnss_plat_data *plat_priv,
		enum cnss_driver_status status)
		{
		if (!plat_priv)
		return -ENODEV;

		switch (plat_priv->bus_type) {
		case CNSS_BUS_PCI:
		return cnss_pci_update_status(plat_priv->bus_priv, status);
		default:
		cnss_pr_err("Unsupported bus type: %d\n",
		plat_priv->bus_type);
		return -EINVAL;
		}
		}