ASoC: wcd: remove unused wsa881x-analog codec driver (a571b872) · Commits · e / devices / android_kernel_fairphone_FP3

sound/soc/codecs/Kconfig

+0 −4

Original line number	Diff line number	Diff line
		@@ -912,10 +912,6 @@ config SND_SOC_WSA881X
		depends on REGMAP_SWR
		select MSM_CDC_PINCTRL

		config SND_SOC_WSA881X_ANALOG
		tristate
		select REGMAP_I2C

		config SND_SOC_WCD9XXX
		tristate
		default y if SND_SOC_WCD9335=y \|\| SND_SOC_WCD934X=y

sound/soc/codecs/Makefile

+0 −3

Original line number	Diff line number	Diff line
		@@ -177,8 +177,6 @@ ifneq (,$(filter $(CONFIG_SND_SOC_WCD_MBHC_LEGACY),y m))
		else ifneq (,$(filter $(CONFIG_SND_SOC_WCD_MBHC_ADC),y m))
		snd-soc-wcd-mbhc-objs := wcd-mbhc-v2.o wcd-mbhc-adc.o
		endif
		snd-soc-wsa881x-analog-objs := wsa881x-analog.o wsa881x-tables-analog.o
		snd-soc-wsa881x-analog-objs += wsa881x-regmap-analog.o wsa881x-irq.o
		snd-soc-wcd-spi-objs := wcd-spi.o
		snd-soc-wl1273-objs := wl1273.o
		snd-soc-wm-adsp-objs := wm_adsp.o
		@@ -410,7 +408,6 @@ obj-$(CONFIG_SND_SOC_WCD9XXX) += snd-soc-wcd9xxx.o
		obj-$(CONFIG_SND_SOC_WCD_CPE) += snd-soc-wcd-cpe.o
		obj-$(CONFIG_SND_SOC_WCD_MBHC) += snd-soc-wcd-mbhc.o
		obj-$(CONFIG_SND_SOC_WSA881X) += snd-soc-wsa881x.o
		obj-$(CONFIG_SND_SOC_WSA881X_ANALOG) += snd-soc-wsa881x-analog.o
		obj-$(CONFIG_SND_SOC_WL1273) += snd-soc-wl1273.o
		obj-$(CONFIG_SND_SOC_WCD_SPI) += snd-soc-wcd-spi.o
		obj-$(CONFIG_SND_SOC_WM0010) += snd-soc-wm0010.o

sound/soc/codecs/wsa881x-analog.c

deleted100644 → 0

+0 −1446

File deleted.

Preview size limit exceeded, changes collapsed.

sound/soc/codecs/wsa881x-analog.h

deleted100644 → 0

+0 −50

Original line number	Diff line number	Diff line
		/* Copyright (c) 2015, The Linux Foundation. All rights reserved.
		*
		* This program is free software; you can redistribute it and/or modify
		* it under the terms of the GNU General Public License version 2 and
		* only version 2 as published by the Free Software Foundation
		*
		* This program is distributed in the hope that it will be useful,
		* but WITHOUT ANY WARRANTY; without even the implied warranty of
		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		* GNU General Public License for more details.
		*/

		#ifndef _WSA881X_H
		#define _WSA881X_H

		#include <linux/regmap.h>
		#include "wsa881x-registers-analog.h"
		#include <sound/soc.h>

		#define WSA881X_I2C_SPK0_SLAVE0_ADDR 0x0E
		#define WSA881X_I2C_SPK0_SLAVE1_ADDR 0x44
		#define WSA881X_I2C_SPK1_SLAVE0_ADDR 0x0F
		#define WSA881X_I2C_SPK1_SLAVE1_ADDR 0x45

		#define WSA881X_I2C_SPK0_SLAVE0 0
		#define WSA881X_I2C_SPK1_SLAVE0 1
		#define MAX_WSA881X_DEVICE 2
		#define WSA881X_DIGITAL_SLAVE 0
		#define WSA881X_ANALOG_SLAVE 1

		enum {
		WSA881X_1_X = 0,
		WSA881X_2_0,
		};

		#define WSA881X_IS_2_0(ver) \
		((ver == WSA881X_2_0) ? 1 : 0)

		extern const u8 wsa881x_ana_reg_readable[WSA881X_CACHE_SIZE];
		extern struct reg_default wsa881x_ana_reg_defaults[WSA881X_CACHE_SIZE];
		extern struct regmap_config wsa881x_ana_regmap_config[2];
		int wsa881x_get_client_index(void);
		int wsa881x_get_probing_count(void);
		int wsa881x_get_presence_count(void);
		int wsa881x_set_mclk_callback(
		int (enable_mclk_callback)(struct snd_soc_card , bool));
		void wsa881x_update_reg_defaults_2_0(void);
		void wsa881x_update_regmap_2_0(struct regmap *regmap, int flag);

		#endif /* _WSA881X_H */

sound/soc/codecs/wsa881x-irq.c

deleted100644 → 0

+0 −610

Original line number	Diff line number	Diff line
		/* Copyright (c) 2015, The Linux Foundation. All rights reserved.
		*
		* This program is free software; you can redistribute it and/or modify
		* it under the terms of the GNU General Public License version 2 and
		* only version 2 as published by the Free Software Foundation.
		*
		* This program is distributed in the hope that it will be useful,
		* but WITHOUT ANY WARRANTY; without even the implied warranty of
		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		* GNU General Public License for more details.
		*/

		#include <linux/bitops.h>
		#include <linux/kernel.h>
		#include <linux/module.h>
		#include <linux/sched.h>
		#include <linux/irq.h>
		#include <linux/delay.h>
		#include <linux/of.h>
		#include <linux/of_irq.h>
		#include <linux/slab.h>
		#include <linux/ratelimit.h>
		#include <linux/pm_qos.h>
		#include <soc/qcom/pm.h>
		#include "wsa881x-irq.h"
		#include "wsa881x-registers-analog.h"

		#define BYTE_BIT_MASK(nr) (1UL << ((nr) % BITS_PER_BYTE))
		#define BIT_BYTE(nr) ((nr) / BITS_PER_BYTE)


		#define WSA_MAX_NUM_IRQS 8

		#ifndef NO_IRQ
		#define NO_IRQ (-1)
		#endif

		static int virq_to_phyirq(
		struct wsa_resource *wsa_res, int virq);
		static int phyirq_to_virq(
		struct wsa_resource *wsa_res, int irq);
		static unsigned int wsa_irq_get_upstream_irq(
		struct wsa_resource *wsa_res);
		static void wsa_irq_put_upstream_irq(
		struct wsa_resource *wsa_res);
		static int wsa_map_irq(
		struct wsa_resource *wsa_res, int irq);

		static struct snd_soc_codec *ptr_codec;

		/**
		* wsa_set_codec() - to update codec pointer
		* @codec: codec pointer.
		*
		* To update the codec pointer, which is used to read/write
		* wsa register.
		*
		* Return: void.
		*/
		void wsa_set_codec(struct snd_soc_codec *codec)
		{
		if (codec == NULL) {
		pr_err("%s: codec pointer is NULL\n", __func__);
		ptr_codec = NULL;
		return;
		}
		ptr_codec = codec;
		/* Initialize interrupt mask and level registers */
		snd_soc_write(codec, WSA881X_INTR_LEVEL, 0x8F);
		snd_soc_write(codec, WSA881X_INTR_MASK, 0x8F);
		}

		static void wsa_irq_lock(struct irq_data *data)
		{
		struct wsa_resource *wsa_res =
		irq_data_get_irq_chip_data(data);

		if (wsa_res == NULL) {
		pr_err("%s: wsa_res pointer is NULL\n", __func__);
		return;
		}
		mutex_lock(&wsa_res->irq_lock);
		}

		static void wsa_irq_sync_unlock(struct irq_data *data)
		{
		struct wsa_resource *wsa_res =
		irq_data_get_irq_chip_data(data);

		if (wsa_res == NULL) {
		pr_err("%s: wsa_res pointer is NULL\n", __func__);
		return;
		}
		if (wsa_res->codec == NULL) {
		pr_err("%s: codec pointer not registered\n", __func__);
		if (ptr_codec == NULL) {
		pr_err("%s: did not receive valid codec pointer\n",
		__func__);
		goto unlock;
		} else {
		wsa_res->codec = ptr_codec;
		}
		}

		/*
		* If there's been a change in the mask write it back
		* to the hardware.
		*/
		if (wsa_res->irq_masks_cur !=
		wsa_res->irq_masks_cache) {

		wsa_res->irq_masks_cache =
		wsa_res->irq_masks_cur;
		snd_soc_write(wsa_res->codec,
		WSA881X_INTR_MASK,
		wsa_res->irq_masks_cur);
		}
		unlock:
		mutex_unlock(&wsa_res->irq_lock);
		}

		static void wsa_irq_enable(struct irq_data *data)
		{
		struct wsa_resource *wsa_res =
		irq_data_get_irq_chip_data(data);
		int wsa_irq;

		if (wsa_res == NULL) {
		pr_err("%s: wsa_res pointer is NULL\n", __func__);
		return;
		}
		wsa_irq = virq_to_phyirq(wsa_res, data->irq);
		pr_debug("%s: wsa_irq = %d\n", __func__, wsa_irq);
		wsa_res->irq_masks_cur &=
		~(BYTE_BIT_MASK(wsa_irq));
		}

		static void wsa_irq_disable(struct irq_data *data)
		{
		struct wsa_resource *wsa_res =
		irq_data_get_irq_chip_data(data);
		int wsa_irq;

		if (wsa_res == NULL) {
		pr_err("%s: wsa_res pointer is NULL\n", __func__);
		return;
		}
		wsa_irq = virq_to_phyirq(wsa_res, data->irq);
		pr_debug("%s: wsa_irq = %d\n", __func__, wsa_irq);
		wsa_res->irq_masks_cur
		\|= BYTE_BIT_MASK(wsa_irq);
		}

		static void wsa_irq_ack(struct irq_data *data)
		{
		int wsa_irq = 0;
		struct wsa_resource *wsa_res =
		irq_data_get_irq_chip_data(data);

		if (wsa_res == NULL) {
		pr_err("%s: wsa_res is NULL\n", __func__);
		return;
		}
		wsa_irq = virq_to_phyirq(wsa_res, data->irq);
		pr_debug("%s: IRQ_ACK called for WCD9XXX IRQ: %d\n",
		__func__, wsa_irq);
		}

		static void wsa_irq_mask(struct irq_data *d)
		{
		/* do nothing but required as linux calls irq_mask without NULL check */
		}

		static struct irq_chip wsa_irq_chip = {
		.name = "wsa",
		.irq_bus_lock = wsa_irq_lock,
		.irq_bus_sync_unlock = wsa_irq_sync_unlock,
		.irq_disable = wsa_irq_disable,
		.irq_enable = wsa_irq_enable,
		.irq_mask = wsa_irq_mask,
		.irq_ack = wsa_irq_ack,
		};

		static irqreturn_t wsa_irq_thread(int irq, void *data)
		{
		struct wsa_resource *wsa_res = data;
		int i;
		u8 status;

		if (wsa_res == NULL) {
		pr_err("%s: wsa_res is NULL\n", __func__);
		return IRQ_HANDLED;
		}
		if (wsa_res->codec == NULL) {
		pr_err("%s: codec pointer not registered\n", __func__);
		if (ptr_codec == NULL) {
		pr_err("%s: did not receive valid codec pointer\n",
		__func__);
		return IRQ_HANDLED;
		}
		wsa_res->codec = ptr_codec;
		}
		status = snd_soc_read(wsa_res->codec, WSA881X_INTR_STATUS);
		/* Apply masking */
		status &= ~wsa_res->irq_masks_cur;

		for (i = 0; i < wsa_res->num_irqs; i++) {
		if (status & BYTE_BIT_MASK(i)) {
		mutex_lock(&wsa_res->nested_irq_lock);
		handle_nested_irq(phyirq_to_virq(wsa_res, i));
		mutex_unlock(&wsa_res->nested_irq_lock);
		}
		}

		return IRQ_HANDLED;
		}

		/**
		* wsa_free_irq() - to free an interrupt
		* @irq: interrupt number.
		* @data: pointer to wsa resource.
		*
		* To free already requested interrupt.
		*
		* Return: void.
		*/
		void wsa_free_irq(int irq, void *data)
		{
		struct wsa_resource *wsa_res = data;

		if (wsa_res == NULL) {
		pr_err("%s: wsa_res is NULL\n", __func__);
		return;
		}
		free_irq(phyirq_to_virq(wsa_res, irq), data);
		}

		/**
		* wsa_enable_irq() - to enable an interrupt
		* @wsa_res: pointer to wsa resource.
		* @irq: interrupt number.
		*
		* This function is to enable an interrupt.
		*
		* Return: void.
		*/
		void wsa_enable_irq(struct wsa_resource *wsa_res, int irq)
		{
		if (wsa_res == NULL) {
		pr_err("%s: wsa_res is NULL\n", __func__);
		return;
		}
		enable_irq(phyirq_to_virq(wsa_res, irq));
		}

		/**
		* wsa_disable_irq() - to disable an interrupt
		* @wsa_res: pointer to wsa resource.
		* @irq: interrupt number.
		*
		* To disable an interrupt without waiting for executing
		* handler to complete.
		*
		* Return: void.
		*/
		void wsa_disable_irq(struct wsa_resource *wsa_res, int irq)
		{
		if (wsa_res == NULL) {
		pr_err("%s: wsa_res is NULL\n", __func__);
		return;
		}
		disable_irq_nosync(phyirq_to_virq(wsa_res, irq));
		}

		/**
		* wsa_disable_irq_sync() - to disable an interrupt
		* @wsa_res: pointer to wsa resource.
		* @irq: interrupt number.
		*
		* To disable an interrupt, wait for executing IRQ
		* handler to complete.
		*
		* Return: void.
		*/
		void wsa_disable_irq_sync(
		struct wsa_resource *wsa_res, int irq)
		{
		if (wsa_res == NULL) {
		pr_err("%s: wsa_res is NULL\n", __func__);
		return;
		}
		disable_irq(phyirq_to_virq(wsa_res, irq));
		}

		static int wsa_irq_setup_downstream_irq(struct wsa_resource *wsa_res)
		{
		int irq, virq, ret;

		if (wsa_res == NULL) {
		pr_err("%s: wsa_res is NULL\n", __func__);
		return -EINVAL;
		}
		pr_debug("%s: enter\n", __func__);

		for (irq = 0; irq < wsa_res->num_irqs; irq++) {
		/* Map OF irq */
		virq = wsa_map_irq(wsa_res, irq);
		pr_debug("%s: irq %d -> %d\n", __func__, irq, virq);
		if (virq == NO_IRQ) {
		pr_err("%s, No interrupt specifier for irq %d\n",
		__func__, irq);
		return NO_IRQ;
		}

		ret = irq_set_chip_data(virq, wsa_res);
		if (ret) {
		pr_err("%s: Failed to configure irq %d (%d)\n",
		__func__, irq, ret);
		return ret;
		}

		if (wsa_res->irq_level_high[irq])
		irq_set_chip_and_handler(virq, &wsa_irq_chip,
		handle_level_irq);
		else
		irq_set_chip_and_handler(virq, &wsa_irq_chip,
		handle_edge_irq);

		irq_set_nested_thread(virq, 1);
		}

		pr_debug("%s: leave\n", __func__);

		return 0;
		}

		static int wsa_irq_init(struct wsa_resource *wsa_res)
		{
		int i, ret;

		if (wsa_res == NULL) {
		pr_err("%s: wsa_res is NULL\n", __func__);
		return -EINVAL;
		}
		mutex_init(&wsa_res->irq_lock);
		mutex_init(&wsa_res->nested_irq_lock);

		wsa_res->irq = wsa_irq_get_upstream_irq(wsa_res);
		if (!wsa_res->irq) {
		pr_warn("%s: irq driver is not yet initialized\n", __func__);
		mutex_destroy(&wsa_res->irq_lock);
		mutex_destroy(&wsa_res->nested_irq_lock);
		return -EPROBE_DEFER;
		}
		pr_debug("%s: probed irq %d\n", __func__, wsa_res->irq);

		/* Setup downstream IRQs */
		ret = wsa_irq_setup_downstream_irq(wsa_res);
		if (ret) {
		pr_err("%s: Failed to setup downstream IRQ\n", __func__);
		goto fail_irq_init;
		}

		/* mask all the interrupts */
		for (i = 0; i < wsa_res->num_irqs; i++) {
		wsa_res->irq_masks_cur \|= BYTE_BIT_MASK(i);
		wsa_res->irq_masks_cache \|= BYTE_BIT_MASK(i);
		}

		ret = request_threaded_irq(wsa_res->irq, NULL, wsa_irq_thread,
		IRQF_TRIGGER_HIGH \| IRQF_ONESHOT,
		"wsa", wsa_res);
		if (ret != 0) {
		dev_err(wsa_res->dev, "Failed to request IRQ %d: %d\n",
		wsa_res->irq, ret);
		} else {
		ret = enable_irq_wake(wsa_res->irq);
		if (ret) {
		dev_err(wsa_res->dev,
		"Failed to set wake interrupt on IRQ %d: %d\n",
		wsa_res->irq, ret);
		free_irq(wsa_res->irq, wsa_res);
		}
		}

		if (ret)
		goto fail_irq_init;

		return ret;

		fail_irq_init:
		dev_err(wsa_res->dev,
		"%s: Failed to init wsa irq\n", __func__);
		wsa_irq_put_upstream_irq(wsa_res);
		mutex_destroy(&wsa_res->irq_lock);
		mutex_destroy(&wsa_res->nested_irq_lock);
		return ret;
		}

		/**
		* wsa_request_irq() - to request/register an interrupt
		* @wsa_res: pointer to wsa_resource.
		* @irq: interrupt number.
		* @handler: interrupt handler function pointer.
		* @name: interrupt name.
		* @data: device info.
		*
		* Convert physical irq to virtual irq and then
		* reguest for threaded handler.
		*
		* Return: Retuns success/failure.
		*/
		int wsa_request_irq(struct wsa_resource *wsa_res,
		int irq, irq_handler_t handler,
		const char name, void data)
		{
		int virq;

		if (wsa_res == NULL) {
		pr_err("%s: wsa_res is NULL\n", __func__);
		return -EINVAL;
		}
		virq = phyirq_to_virq(wsa_res, irq);

		/*
		* ARM needs us to explicitly flag the IRQ as valid
		* and will set them noprobe when we do so.
		*/
		#if defined(CONFIG_ARM) \|\| defined(CONFIG_ARM64)
		set_irq_flags(virq, IRQF_VALID);
		#else
		set_irq_noprobe(virq);
		#endif

		return request_threaded_irq(virq, NULL, handler, IRQF_TRIGGER_RISING,
		name, data);
		}

		/**
		* wsa_irq_exit() - to disable/clear interrupt/resources
		* @wsa_res: pointer to wsa_resource
		*
		* Disable and free the interrupts and then release resources.
		*
		* Return: void.
		*/
		void wsa_irq_exit(struct wsa_resource *wsa_res)
		{
		if (wsa_res == NULL) {
		pr_err("%s: wsa_res is NULL\n", __func__);
		return;
		}
		dev_dbg(wsa_res->dev, "%s: Cleaning up irq %d\n", __func__,
		wsa_res->irq);

		if (wsa_res->irq) {
		disable_irq_wake(wsa_res->irq);
		free_irq(wsa_res->irq, wsa_res);
		/* Release parent's of node */
		wsa_irq_put_upstream_irq(wsa_res);
		}
		mutex_destroy(&wsa_res->irq_lock);
		mutex_destroy(&wsa_res->nested_irq_lock);
		}

		static int phyirq_to_virq(struct wsa_resource *wsa_res, int offset)
		{
		if (wsa_res == NULL) {
		pr_err("%s: wsa_res is NULL\n", __func__);
		return -EINVAL;
		}
		return irq_linear_revmap(wsa_res->domain, offset);
		}

		static int virq_to_phyirq(struct wsa_resource *wsa_res, int virq)
		{
		struct irq_data *irq_data = irq_get_irq_data(virq);

		if (unlikely(!irq_data)) {
		pr_err("%s: irq_data is NULL\n", __func__);
		return -EINVAL;
		}
		return irq_data->hwirq;
		}

		static unsigned int wsa_irq_get_upstream_irq(struct wsa_resource *wsa_res)
		{
		if (wsa_res == NULL) {
		pr_err("%s: wsa_res is NULL\n", __func__);
		return -EINVAL;
		}
		return wsa_res->irq;
		}

		static void wsa_irq_put_upstream_irq(struct wsa_resource *wsa_res)
		{
		if (wsa_res == NULL) {
		pr_err("%s: wsa_res is NULL\n", __func__);
		return;
		}
		/* Hold parent's of node */
		of_node_put(wsa_res->dev->of_node);
		}

		static int wsa_map_irq(struct wsa_resource *wsa_res, int irq)
		{
		if (wsa_res == NULL) {
		pr_err("%s: wsa_res is NULL\n", __func__);
		return -EINVAL;
		}
		return of_irq_to_resource(wsa_res->dev->of_node, irq, NULL);
		}

		static int wsa_irq_probe(struct platform_device *pdev)
		{
		int irq;
		struct wsa_resource *wsa_res = NULL;
		int ret = -EINVAL;

		irq = platform_get_irq_byname(pdev, "wsa-int");
		if (irq < 0) {
		dev_err(&pdev->dev, "%s: Couldn't find wsa-int node(%d)\n",
		__func__, irq);
		return -EINVAL;
		}
		pr_debug("%s: node %s\n", __func__, pdev->name);
		wsa_res = kzalloc(sizeof(*wsa_res), GFP_KERNEL);
		if (!wsa_res) {
		pr_err("%s: could not allocate memory\n", __func__);
		return -ENOMEM;
		}
		/*
		* wsa interrupt controller supports N to N irq mapping with
		* single cell binding with irq numbers(offsets) only.
		* Use irq_domain_simple_ops that has irq_domain_simple_map and
		* irq_domain_xlate_onetwocell.
		*/
		wsa_res->dev = &pdev->dev;
		wsa_res->domain = irq_domain_add_linear(wsa_res->dev->of_node,
		WSA_MAX_NUM_IRQS, &irq_domain_simple_ops,
		wsa_res);
		if (!wsa_res->domain) {
		dev_err(&pdev->dev, "%s: domain is NULL\n", __func__);
		ret = -ENOMEM;
		goto err;
		}
		wsa_res->dev = &pdev->dev;

		dev_dbg(&pdev->dev, "%s: virq = %d\n", __func__, irq);
		wsa_res->irq = irq;
		wsa_res->num_irq_regs = 1;
		wsa_res->num_irqs = WSA_NUM_IRQS;
		ret = wsa_irq_init(wsa_res);
		if (ret < 0) {
		dev_err(&pdev->dev, "%s: failed to do irq init %d\n",
		__func__, ret);
		goto err;
		}

		return ret;
		err:
		kfree(wsa_res);
		return ret;
		}

		static int wsa_irq_remove(struct platform_device *pdev)
		{
		struct irq_domain *domain;
		struct wsa_resource *data;

		domain = irq_find_host(pdev->dev.of_node);
		if (unlikely(!domain)) {
		pr_err("%s: domain is NULL\n", __func__);
		return -EINVAL;
		}
		data = (struct wsa_resource *)domain->host_data;
		data->irq = 0;

		return 0;
		}

		static const struct of_device_id of_match[] = {
		{ .compatible = "qcom,wsa-irq" },
		{ }
		};

		static struct platform_driver wsa_irq_driver = {
		.probe = wsa_irq_probe,
		.remove = wsa_irq_remove,
		.driver = {
		.name = "wsa_intc",
		.owner = THIS_MODULE,
		.of_match_table = of_match_ptr(of_match),
		},
		};

		static int wsa_irq_drv_init(void)
		{
		return platform_driver_register(&wsa_irq_driver);
		}
		subsys_initcall(wsa_irq_drv_init);

		static void wsa_irq_drv_exit(void)
		{
		platform_driver_unregister(&wsa_irq_driver);
		}
		module_exit(wsa_irq_drv_exit);

		MODULE_DESCRIPTION("WSA881x IRQ driver");
		MODULE_LICENSE("GPL v2");