Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit d1f3619b authored by Laxminath Kasam's avatar Laxminath Kasam Committed by Martin Fick
Browse files

audio-lnx: Propagate changes from kernel for wdsp-glink/avtimer 



Pick the WDSP-Glink and avtimer drivers from 4.9 kernel
at below cutoff -

(80be7d6a313 - "msm: ADSPRPC: Fix for NULL pointer dereference")

This changes are done to migrate wdsp-glink/avtimer drivers
to this new audio kernel techpack.
Also remove the CDSP loader from techpack audio as it is
non-audio related.

Change-Id: I4f55429c5cbcd24920fdcb8eb2fe3aec02af320e
Signed-off-by: default avatarLaxminath Kasam <lkasam@codeaurora.org>
parent 605b42f9

dsp/Makefile

+1 −1
Original line number Diff line number Diff line
@@ -5,6 +5,6 @@ obj-$(CONFIG_MSM_ADSP_LOADER) += adsp-loader.o 
obj-$(CONFIG_MSM_QDSP6_SSR) += audio_ssr.o

obj-$(CONFIG_MSM_QDSP6_PDR) += audio_pdr.o

obj-$(CONFIG_MSM_QDSP6_NOTIFIER) += audio_notifier.o

obj-$(CONFIG_MSM_CDSP_LOADER) += cdsp-loader.o

obj-$(CONFIG_MSM_ULTRASOUND) += usf.o usfcdev.o q6usm.o

obj-$(CONFIG_MSM_AVTIMER) += avtimer.o

obj-$(CONFIG_MSM_QDSP6V2_CODECS)  += codecs/

dsp/avtimer.c

0 → 100644
+548 −0
Original line number Diff line number Diff line 
/*

 * Copyright (c) 2012-2015, 2017 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/kernel.h>

#include <linux/module.h>

#include <linux/init.h>

#include <linux/fs.h>

#include <linux/cdev.h>

#include <linux/uaccess.h>

#include <linux/device.h>

#include <linux/io.h>

#include <linux/platform_device.h>

#include <linux/avtimer.h>

#include <linux/slab.h>

#include <linux/of.h>

#include <linux/wait.h>

#include <linux/sched.h>

#include <ipc/apr.h>

#include <dsp/q6core.h>



#define DEVICE_NAME "avtimer"

#define TIMEOUT_MS 1000

#define CORE_CLIENT 1

#define TEMP_PORT ((CORE_CLIENT << 8) | 0x0001)

#define SSR_WAKETIME 1000

#define Q6_READY_RETRY 250

#define Q6_READY_MAX_RETRIES 40



#define AVCS_CMD_REMOTE_AVTIMER_VOTE_REQUEST 0x00012914

#define AVCS_CMD_RSP_REMOTE_AVTIMER_VOTE_REQUEST 0x00012915

#define AVCS_CMD_REMOTE_AVTIMER_RELEASE_REQUEST 0x00012916

#define AVTIMER_REG_CNT 2



struct adsp_avt_timer {

	struct apr_hdr hdr;

	union {

		char client_name[8];

		u32 avtimer_handle;

	};

} __packed;



static int major;



struct avtimer_t {

	struct apr_svc *core_handle_q;

	struct cdev myc;

	struct class *avtimer_class;

	struct mutex avtimer_lock;

	int avtimer_open_cnt;

	struct delayed_work ssr_dwork;

	wait_queue_head_t adsp_resp_wait;

	int enable_timer_resp_received;

	int timer_handle;

	void __iomem *p_avtimer_msw;

	void __iomem *p_avtimer_lsw;

	uint32_t clk_div;

	uint32_t clk_mult;

	atomic_t adsp_ready;

	int num_retries;

};



static struct avtimer_t avtimer;



static int32_t aprv2_core_fn_q(struct apr_client_data *data, void *priv)

{

	uint32_t *payload1;



	if (!data) {

		pr_err("%s: Invalid params\n", __func__);

		return -EINVAL;

	}

	pr_debug("%s: core msg: payload len = %u, apr resp opcode = 0x%X\n",

		__func__, data->payload_size, data->opcode);



	switch (data->opcode) {



	case APR_BASIC_RSP_RESULT:{



		if (!data->payload_size) {

			pr_err("%s: APR_BASIC_RSP_RESULT No Payload ",

					__func__);

			return 0;

		}



		payload1 = data->payload;

		switch (payload1[0]) {

		case AVCS_CMD_REMOTE_AVTIMER_RELEASE_REQUEST:

			pr_debug("%s: Cmd = TIMER RELEASE status[0x%x]\n",

			__func__, payload1[1]);

			break;

		default:

			pr_err("Invalid cmd rsp[0x%x][0x%x]\n",

					payload1[0], payload1[1]);

			break;

		}

		break;

	}



	case RESET_EVENTS:{

		pr_debug("%s: Reset event received in AV timer\n", __func__);

		apr_reset(avtimer.core_handle_q);

		avtimer.core_handle_q = NULL;

		avtimer.avtimer_open_cnt = 0;

		atomic_set(&avtimer.adsp_ready, 0);

		schedule_delayed_work(&avtimer.ssr_dwork,

				  msecs_to_jiffies(SSR_WAKETIME));

		break;

	}



	case AVCS_CMD_RSP_REMOTE_AVTIMER_VOTE_REQUEST:

		payload1 = data->payload;

		pr_debug("%s: RSP_REMOTE_AVTIMER_VOTE_REQUEST handle %x\n",

			__func__, payload1[0]);

		avtimer.timer_handle = payload1[0];

		avtimer.enable_timer_resp_received = 1;

		wake_up(&avtimer.adsp_resp_wait);

		break;

	default:

		pr_err("%s: Message adspcore svc: %d\n",

				__func__, data->opcode);

		break;

	}



	return 0;

}



int avcs_core_open(void)

{

	if (!avtimer.core_handle_q)

		avtimer.core_handle_q = apr_register("ADSP", "CORE",

					aprv2_core_fn_q, TEMP_PORT, NULL);

	pr_debug("%s: Open_q %p\n", __func__, avtimer.core_handle_q);

	if (!avtimer.core_handle_q) {

		pr_err("%s: Unable to register CORE\n", __func__);

		return -EINVAL;

	}

	return 0;

}

EXPORT_SYMBOL(avcs_core_open);



static int avcs_core_disable_avtimer(int timerhandle)

{

	int rc = -EINVAL;

	struct adsp_avt_timer payload;



	if (!timerhandle) {

		pr_err("%s: Invalid timer handle\n", __func__);

		return -EINVAL;

	}

	memset(&payload, 0, sizeof(payload));

	rc = avcs_core_open();

	if (!rc && avtimer.core_handle_q) {

		payload.hdr.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD,

			APR_HDR_LEN(APR_HDR_SIZE), APR_PKT_VER);

		payload.hdr.pkt_size =

			sizeof(struct adsp_avt_timer);

		payload.hdr.src_svc = avtimer.core_handle_q->id;

		payload.hdr.src_domain = APR_DOMAIN_APPS;

		payload.hdr.dest_domain = APR_DOMAIN_ADSP;

		payload.hdr.dest_svc = APR_SVC_ADSP_CORE;

		payload.hdr.src_port = TEMP_PORT;

		payload.hdr.dest_port = TEMP_PORT;

		payload.hdr.token = CORE_CLIENT;

		payload.hdr.opcode = AVCS_CMD_REMOTE_AVTIMER_RELEASE_REQUEST;

		payload.avtimer_handle = timerhandle;

		pr_debug("%s: disable avtimer opcode %x handle %x\n",

			__func__, payload.hdr.opcode, payload.avtimer_handle);

		rc = apr_send_pkt(avtimer.core_handle_q,

						(uint32_t *)&payload);

		if (rc < 0)

			pr_err("%s: Enable AVtimer failed op[0x%x]rc[%d]\n",

				__func__, payload.hdr.opcode, rc);

		else

			rc = 0;

	}

	return rc;

}



static int avcs_core_enable_avtimer(char *client_name)

{

	int rc = -EINVAL, ret = -EINVAL;

	struct adsp_avt_timer payload;



	if (!client_name) {

		pr_err("%s: Invalid params\n", __func__);

		return -EINVAL;

	}

	memset(&payload, 0, sizeof(payload));

	rc = avcs_core_open();

	if (!rc && avtimer.core_handle_q) {

		avtimer.enable_timer_resp_received = 0;

		payload.hdr.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_EVENT,

			APR_HDR_LEN(APR_HDR_SIZE), APR_PKT_VER);

		payload.hdr.pkt_size =

			sizeof(struct adsp_avt_timer);

		payload.hdr.src_svc = avtimer.core_handle_q->id;

		payload.hdr.src_domain = APR_DOMAIN_APPS;

		payload.hdr.dest_domain = APR_DOMAIN_ADSP;

		payload.hdr.dest_svc = APR_SVC_ADSP_CORE;

		payload.hdr.src_port = TEMP_PORT;

		payload.hdr.dest_port = TEMP_PORT;

		payload.hdr.token = CORE_CLIENT;

		payload.hdr.opcode = AVCS_CMD_REMOTE_AVTIMER_VOTE_REQUEST;

		strlcpy(payload.client_name, client_name,

			   sizeof(payload.client_name));

		pr_debug("%s: enable avtimer opcode %x client name %s\n",

			__func__, payload.hdr.opcode, payload.client_name);

		rc = apr_send_pkt(avtimer.core_handle_q,

						(uint32_t *)&payload);

		if (rc < 0) {

			pr_err("%s: Enable AVtimer failed op[0x%x]rc[%d]\n",

				__func__, payload.hdr.opcode, rc);

			goto bail;

		} else

			rc = 0;

		ret = wait_event_timeout(avtimer.adsp_resp_wait,

			(avtimer.enable_timer_resp_received == 1),

			msecs_to_jiffies(TIMEOUT_MS));

		if (!ret) {

			pr_err("%s: wait_event timeout for Enable timer\n",

					__func__);

			rc = -ETIMEDOUT;

		}

		if (rc)

			avtimer.timer_handle = 0;

	}

bail:

	return rc;

}



int avcs_core_disable_power_collapse(int enable)

{

	int rc = 0;



	mutex_lock(&avtimer.avtimer_lock);

	if (enable) {

		if (avtimer.avtimer_open_cnt) {

			avtimer.avtimer_open_cnt++;

			pr_debug("%s: opened avtimer open count=%d\n",

				__func__, avtimer.avtimer_open_cnt);

			rc = 0;

			goto done;

		}

		rc = avcs_core_enable_avtimer("timer");

		if (!rc) {

			avtimer.avtimer_open_cnt++;

			atomic_set(&avtimer.adsp_ready, 1);

		}

	} else {

		if (avtimer.avtimer_open_cnt > 0) {

			avtimer.avtimer_open_cnt--;

			if (!avtimer.avtimer_open_cnt) {

				rc = avcs_core_disable_avtimer(

				avtimer.timer_handle);

				avtimer.timer_handle = 0;

			}

		}

	}

done:

	mutex_unlock(&avtimer.avtimer_lock);

	return rc;

}

EXPORT_SYMBOL(avcs_core_disable_power_collapse);



static void reset_work(struct work_struct *work)

{

	if (q6core_is_adsp_ready()) {

		avcs_core_disable_power_collapse(1);

		avtimer.num_retries = Q6_READY_MAX_RETRIES;

		return;

	}

	pr_debug("%s:Q6 not ready-retry after sometime\n", __func__);

	if (--avtimer.num_retries > 0) {

		schedule_delayed_work(&avtimer.ssr_dwork,

			  msecs_to_jiffies(Q6_READY_RETRY));

	} else {

		pr_err("%s: Q6 failed responding after multiple retries\n",

							__func__);

		avtimer.num_retries = Q6_READY_MAX_RETRIES;

	}

}



int avcs_core_query_timer(uint64_t *avtimer_tick)

{

	uint32_t avtimer_msw = 0, avtimer_lsw = 0;

	uint64_t avtimer_tick_temp;



	if (!atomic_read(&avtimer.adsp_ready)) {

		pr_debug("%s:In SSR, return\n", __func__);

		return -ENETRESET;

	}

	avtimer_lsw = ioread32(avtimer.p_avtimer_lsw);

	avtimer_msw = ioread32(avtimer.p_avtimer_msw);



	avtimer_tick_temp = (uint64_t)((uint64_t)avtimer_msw << 32)

			    | avtimer_lsw;

	*avtimer_tick = mul_u64_u32_div(avtimer_tick_temp, avtimer.clk_mult,

					avtimer.clk_div);

	pr_debug_ratelimited("%s:Avtimer: msw: %u, lsw: %u, tick: %llu\n",

			__func__,

			avtimer_msw, avtimer_lsw, *avtimer_tick);

	return 0;

}

EXPORT_SYMBOL(avcs_core_query_timer);



static int avtimer_open(struct inode *inode, struct file *file)

{

	return avcs_core_disable_power_collapse(1);

}



static int avtimer_release(struct inode *inode, struct file *file)

{

	return avcs_core_disable_power_collapse(0);

}



/*

 * ioctl call provides GET_AVTIMER

 */

static long avtimer_ioctl(struct file *file, unsigned int ioctl_num,

				unsigned long ioctl_param)

{

	switch (ioctl_num) {

	case IOCTL_GET_AVTIMER_TICK:

	{

		uint64_t avtimer_tick = 0;

		int rc;



		rc = avcs_core_query_timer(&avtimer_tick);



		if (rc) {

			pr_err("%s: Error: Invalid AV Timer tick, rc = %d\n",

				__func__, rc);

			return rc;

		}



		pr_debug_ratelimited("%s: AV Timer tick: time %llx\n",

		__func__, avtimer_tick);

		if (copy_to_user((void *) ioctl_param, &avtimer_tick,

		    sizeof(avtimer_tick))) {

			pr_err("%s: copy_to_user failed\n", __func__);

			return -EFAULT;

		}

	}

		break;



	default:

		pr_err("%s: invalid cmd\n", __func__);

		return -EINVAL;

	}

	return 0;

}



static const struct file_operations avtimer_fops = {

	.unlocked_ioctl = avtimer_ioctl,

	.compat_ioctl = avtimer_ioctl,

	.open = avtimer_open,

	.release = avtimer_release

};



static int dev_avtimer_probe(struct platform_device *pdev)

{

	int result = 0;

	dev_t dev = MKDEV(major, 0);

	struct device *device_handle;

	struct resource *reg_lsb = NULL, *reg_msb = NULL;

	uint32_t clk_div_val;

	uint32_t clk_mult_val;



	if (!pdev) {

		pr_err("%s: Invalid params\n", __func__);

		return -EINVAL;

	}

	reg_lsb = platform_get_resource_byname(pdev,

		IORESOURCE_MEM, "avtimer_lsb_addr");

	if (!reg_lsb) {

		dev_err(&pdev->dev, "%s: Looking up %s property",

			"avtimer_lsb_addr", __func__);

		return -EINVAL;

	}

	reg_msb = platform_get_resource_byname(pdev,

		IORESOURCE_MEM, "avtimer_msb_addr");

	if (!reg_msb) {

		dev_err(&pdev->dev, "%s: Looking up %s property",

			"avtimer_msb_addr", __func__);

		return -EINVAL;

	}

	INIT_DELAYED_WORK(&avtimer.ssr_dwork, reset_work);



	avtimer.p_avtimer_lsw = devm_ioremap_nocache(&pdev->dev,

				reg_lsb->start, resource_size(reg_lsb));

	if (!avtimer.p_avtimer_lsw) {

		dev_err(&pdev->dev, "%s: ioremap failed for lsb avtimer register",

			__func__);

		return -ENOMEM;

	}



	avtimer.p_avtimer_msw = devm_ioremap_nocache(&pdev->dev,

				reg_msb->start, resource_size(reg_msb));

	if (!avtimer.p_avtimer_msw) {

		dev_err(&pdev->dev, "%s: ioremap failed for msb avtimer register",

			__func__);

		goto unmap;

	}

	avtimer.num_retries = Q6_READY_MAX_RETRIES;

	/* get the device number */

	if (major)

		result = register_chrdev_region(dev, 1, DEVICE_NAME);

	else {

		result = alloc_chrdev_region(&dev, 0, 1, DEVICE_NAME);

		major = MAJOR(dev);

	}



	if (result < 0) {

		dev_err(&pdev->dev, "%s: Registering avtimer device failed\n",

			__func__);

		goto unmap;

	}



	avtimer.avtimer_class = class_create(THIS_MODULE, "avtimer");

	if (IS_ERR(avtimer.avtimer_class)) {

		result = PTR_ERR(avtimer.avtimer_class);

		dev_err(&pdev->dev, "%s: Error creating avtimer class: %d\n",

			__func__, result);

		goto unregister_chrdev_region;

	}



	cdev_init(&avtimer.myc, &avtimer_fops);

	result = cdev_add(&avtimer.myc, dev, 1);



	if (result < 0) {

		dev_err(&pdev->dev, "%s: Registering file operations failed\n",

			__func__);

		goto class_destroy;

	}



	device_handle = device_create(avtimer.avtimer_class,

			NULL, avtimer.myc.dev, NULL, "avtimer");

	if (IS_ERR(device_handle)) {

		result = PTR_ERR(device_handle);

		pr_err("%s: device_create failed: %d\n", __func__, result);

		goto class_destroy;

	}

	init_waitqueue_head(&avtimer.adsp_resp_wait);

	mutex_init(&avtimer.avtimer_lock);

	avtimer.avtimer_open_cnt = 0;



	pr_debug("%s: Device create done for avtimer major=%d\n",

			__func__, major);



	if (of_property_read_u32(pdev->dev.of_node,

			"qcom,clk-div", &clk_div_val))

		avtimer.clk_div = 1;

	else

		avtimer.clk_div = clk_div_val;



	if (of_property_read_u32(pdev->dev.of_node,

			"qcom,clk-mult", &clk_mult_val))

		avtimer.clk_mult = 1;

	else

		avtimer.clk_mult = clk_mult_val;



	pr_debug("%s: avtimer.clk_div = %d, avtimer.clk_mult = %d\n",

		 __func__, avtimer.clk_div, avtimer.clk_mult);

	return 0;



class_destroy:

	class_destroy(avtimer.avtimer_class);

unregister_chrdev_region:

	unregister_chrdev_region(MKDEV(major, 0), 1);

unmap:

	if (avtimer.p_avtimer_lsw)

		devm_iounmap(&pdev->dev, avtimer.p_avtimer_lsw);

	if (avtimer.p_avtimer_msw)

		devm_iounmap(&pdev->dev, avtimer.p_avtimer_msw);

	avtimer.p_avtimer_lsw = NULL;

	avtimer.p_avtimer_msw = NULL;

	return result;



}



static int dev_avtimer_remove(struct platform_device *pdev)

{

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



	if (avtimer.p_avtimer_lsw)

		devm_iounmap(&pdev->dev, avtimer.p_avtimer_lsw);

	if (avtimer.p_avtimer_msw)

		devm_iounmap(&pdev->dev, avtimer.p_avtimer_msw);

	device_destroy(avtimer.avtimer_class, avtimer.myc.dev);

	cdev_del(&avtimer.myc);

	class_destroy(avtimer.avtimer_class);

	unregister_chrdev_region(MKDEV(major, 0), 1);



	return 0;

}



static const struct of_device_id avtimer_machine_of_match[]  = {

	{ .compatible = "qcom,avtimer", },

	{},

};

static struct platform_driver dev_avtimer_driver = {

	.probe = dev_avtimer_probe,

	.remove = dev_avtimer_remove,

	.driver = {

		.name = "dev_avtimer",

		.of_match_table = avtimer_machine_of_match,

	},

};



static int  __init avtimer_init(void)

{

	s32 rc;



	rc = platform_driver_register(&dev_avtimer_driver);

	if (rc < 0) {

		pr_err("%s: platform_driver_register failed\n", __func__);

		goto error_platform_driver;

	}

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



	return 0;

error_platform_driver:



	pr_err("%s: encounterd error\n", __func__);

	return rc;

}



static void __exit avtimer_exit(void)

{

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

	platform_driver_unregister(&dev_avtimer_driver);

}



module_init(avtimer_init);

module_exit(avtimer_exit);



MODULE_DESCRIPTION("avtimer driver");

MODULE_LICENSE("GPL v2");

dsp/cdsp-loader.c

deleted100644 → 0
+0 −280
Original line number Diff line number Diff line 
/*

 * Copyright (c) 2012-2014, 2017, 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/init.h>

#include <linux/kernel.h>

#include <linux/module.h>

#include <linux/err.h>

#include <linux/delay.h>

#include <linux/platform_device.h>

#include <linux/of_device.h>

#include <linux/sysfs.h>

#include <linux/workqueue.h>



#include <soc/qcom/subsystem_restart.h>



#define BOOT_CMD 1

#define IMAGE_UNLOAD_CMD 0



#define CDSP_SUBSYS_DOWN 0

#define CDSP_SUBSYS_LOADED 1



static ssize_t cdsp_boot_store(struct kobject *kobj,

	struct kobj_attribute *attr,

	const char *buf, size_t count);



struct cdsp_loader_private {

	void *pil_h;

	struct kobject *boot_cdsp_obj;

	struct attribute_group *attr_group;

};



static struct kobj_attribute cdsp_boot_attribute =

	__ATTR(boot, 0220, NULL, cdsp_boot_store);



static struct attribute *attrs[] = {

	&cdsp_boot_attribute.attr,

	NULL,

};



static u32 cdsp_state = CDSP_SUBSYS_DOWN;

static struct platform_device *cdsp_private;

static struct work_struct cdsp_ldr_work;

static void cdsp_loader_unload(struct platform_device *pdev);



static void cdsp_load_fw(struct work_struct *cdsp_ldr_work)

{

	struct platform_device *pdev = cdsp_private;

	struct cdsp_loader_private *priv = NULL;



	int rc = 0;

	const char *img_name;



	if (!pdev) {

		dev_err(&pdev->dev, "%s: Platform device null\n", __func__);

		goto fail;

	}



	if (!pdev->dev.of_node) {

		dev_err(&pdev->dev,

			"%s: Device tree information missing\n", __func__);



		goto fail;

	}



	rc = of_property_read_string(pdev->dev.of_node,

					"qcom,proc-img-to-load",

					&img_name);

	if (rc)

		goto fail;



	if (!strcmp(img_name, "cdsp")) {

		/* cdsp_state always returns "0".*/

		if (cdsp_state == CDSP_SUBSYS_DOWN) {

			priv = platform_get_drvdata(pdev);

			if (!priv) {

				dev_err(&pdev->dev,

				" %s: Private data get failed\n", __func__);

				goto fail;

			}



			priv->pil_h = subsystem_get("cdsp");

			if (IS_ERR(priv->pil_h)) {

				dev_err(&pdev->dev, "%s: pil get failed,\n",

					__func__);

				goto fail;

			}



			/* Set the state of the CDSP.*/

			cdsp_state = CDSP_SUBSYS_LOADED;

		} else if (cdsp_state == CDSP_SUBSYS_LOADED) {

			dev_dbg(&pdev->dev,

			"%s: CDSP state = %x\n", __func__, cdsp_state);

		}



		dev_dbg(&pdev->dev, "%s: CDSP image is loaded\n", __func__);

		return;

	}



fail:

	dev_err(&pdev->dev, "%s: CDSP image loading failed\n", __func__);

}



static void cdsp_loader_do(struct platform_device *pdev)

{

	schedule_work(&cdsp_ldr_work);

}



static ssize_t cdsp_boot_store(struct kobject *kobj,

	struct kobj_attribute *attr,

	const char *buf,

	size_t count)

{

	int boot = 0, ret = 0;



	ret = sscanf(buf, "%du", &boot);



	if (ret != 1)

		pr_debug("%s: invalid arguments for cdsp_loader.\n", __func__);



	if (boot == BOOT_CMD) {

		pr_debug("%s: going to call cdsp_loader_do\n", __func__);

		cdsp_loader_do(cdsp_private);

	} else if (boot == IMAGE_UNLOAD_CMD) {

		pr_debug("%s: going to call cdsp_unloader\n", __func__);

		cdsp_loader_unload(cdsp_private);

	}

	return count;

}



static void cdsp_loader_unload(struct platform_device *pdev)

{

	struct cdsp_loader_private *priv = NULL;



	priv = platform_get_drvdata(pdev);



	if (!priv)

		return;



	if (priv->pil_h) {

		dev_dbg(&pdev->dev, "%s: calling subsystem put\n", __func__);

		subsystem_put(priv->pil_h);

		priv->pil_h = NULL;

	}

}



static int cdsp_loader_init_sysfs(struct platform_device *pdev)

{

	int ret = -EINVAL;

	struct cdsp_loader_private *priv = NULL;



	cdsp_private = NULL;



	priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);

	if (!priv) {

		ret = -ENOMEM;

		return ret;

	}



	platform_set_drvdata(pdev, priv);



	priv->pil_h = NULL;

	priv->boot_cdsp_obj = NULL;

	priv->attr_group = devm_kzalloc(&pdev->dev,

				sizeof(*(priv->attr_group)),

				GFP_KERNEL);

	if (!priv->attr_group) {

		dev_err(&pdev->dev, "%s: malloc attr_group failed\n",

						__func__);

		ret = -ENOMEM;

		goto error_return;

	}



	priv->attr_group->attrs = attrs;



	priv->boot_cdsp_obj = kobject_create_and_add("boot_cdsp", kernel_kobj);

	if (!priv->boot_cdsp_obj) {

		dev_err(&pdev->dev, "%s: sysfs create and add failed\n",

						__func__);

		ret = -ENOMEM;

		goto error_return;

	}



	ret = sysfs_create_group(priv->boot_cdsp_obj, priv->attr_group);

	if (ret) {

		dev_err(&pdev->dev, "%s: sysfs create group failed %d\n",

							__func__, ret);

		goto error_return;

	}



	cdsp_private = pdev;



	return 0;



error_return:



	if (priv->boot_cdsp_obj) {

		kobject_del(priv->boot_cdsp_obj);

		priv->boot_cdsp_obj = NULL;

	}



	return ret;

}



static int cdsp_loader_remove(struct platform_device *pdev)

{

	struct cdsp_loader_private *priv = NULL;



	priv = platform_get_drvdata(pdev);



	if (!priv)

		return 0;



	if (priv->pil_h) {

		subsystem_put(priv->pil_h);

		priv->pil_h = NULL;

	}



	if (priv->boot_cdsp_obj) {

		sysfs_remove_group(priv->boot_cdsp_obj, priv->attr_group);

		kobject_del(priv->boot_cdsp_obj);

		priv->boot_cdsp_obj = NULL;

	}



	return 0;

}



static int cdsp_loader_probe(struct platform_device *pdev)

{

	int ret = cdsp_loader_init_sysfs(pdev);



	if (ret != 0) {

		dev_err(&pdev->dev, "%s: Error in initing sysfs\n", __func__);

		return ret;

	}



	INIT_WORK(&cdsp_ldr_work, cdsp_load_fw);



	return 0;

}



static const struct of_device_id cdsp_loader_dt_match[] = {

	{ .compatible = "qcom,cdsp-loader" },

	{ }

};

MODULE_DEVICE_TABLE(of, cdsp_loader_dt_match);



static struct platform_driver cdsp_loader_driver = {

	.driver = {

		.name = "cdsp-loader",

		.owner = THIS_MODULE,

		.of_match_table = cdsp_loader_dt_match,

	},

	.probe = cdsp_loader_probe,

	.remove = cdsp_loader_remove,

};



static int __init cdsp_loader_init(void)

{

	return platform_driver_register(&cdsp_loader_driver);

}

module_init(cdsp_loader_init);



static void __exit cdsp_loader_exit(void)

{

	platform_driver_unregister(&cdsp_loader_driver);

}

module_exit(cdsp_loader_exit);



MODULE_DESCRIPTION("CDSP Loader module");

MODULE_LICENSE("GPL v2");

ipc/Makefile

+1 −0
Original line number Diff line number Diff line 
obj-$(CONFIG_MSM_QDSP6_APRV2_GLINK) += apr.o apr_v2.o apr_tal_glink.o

obj-$(CONFIG_MSM_QDSP6_APRV3_GLINK) += apr.o apr_v3.o apr_tal_glink.o

obj-$(CONFIG_WCD_DSP_GLINK) += wcd-dsp-glink.o