ipc: Add support for GPR

Add support for GPR and Audio-pkt drivers for AudioReach.

Change-Id: I4813ec1e3696900ebd426caa3017eae623b3a6c9
Signed-off-by: Taha Azzaoui <tazzaoui@codeaurora.org>

ipc/audio-pkt.c

@@ -0,0 +1,523 @@
+/* Copyright (c) 2019-2020, 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/platform_device.h>
+#include <linux/of_platform.h>
+#include <linux/ipc_logging.h>
+#include <linux/refcount.h>
+#include <linux/device.h>
+#include <linux/module.h>
+#include <linux/skbuff.h>
+#include <linux/cdev.h>
+#include <linux/slab.h>
+#include <linux/poll.h>
+#include <linux/idr.h>
+#include <linux/of.h>
+#include <linux/fs.h>
+#include <linux/uaccess.h>
+#include <linux/termios.h>
+#include <ipc/gpr-lite.h>
+#include <dsp/msm_audio_ion.h>
+
+/* Define IPC Logging Macros */
+#define AUDIO_PKT_IPC_LOG_PAGE_CNT 2
+static void *audio_pkt_ilctxt;
+
+static int audio_pkt_debug_mask;
+module_param_named(debug_mask, audio_pkt_debug_mask, int, 0664);
+
+#define APM_CMD_SHARED_MEM_MAP_REGIONS		0x0100100C
+#define APM_MEMORY_MAP_BIT_MASK_IS_OFFSET_MODE	0x00000004UL
+enum {
+	AUDIO_PKT_INFO = 1U << 0,
+};
+
+#define AUDIO_PKT_INFO(x, ...)						\
+do {									\
+	if (audio_pkt_debug_mask & AUDIO_PKT_INFO) {			\
+		ipc_log_string(audio_pkt_ilctxt,			\
+			"[%s]: "x, __func__, ##__VA_ARGS__);		\
+	}								\
+} while (0)
+
+#define AUDIO_PKT_ERR(x, ...)						      \
+do {									      \
+	pr_err_ratelimited("[%s]: "x, __func__, ##__VA_ARGS__);		      \
+	ipc_log_string(audio_pkt_ilctxt, "[%s]: "x, __func__, ##__VA_ARGS__); \
+} while (0)
+
+
+#define MODULE_NAME "audio-pkt"
+#define MINOR_NUMBER_COUNT 1
+#define AUDPKT_DRIVER_NAME "aud_pasthru_adsp"
+#define CHANNEL_NAME "to_apps"
+
+/**
+ * struct audio_pkt - driver context, relates rpdev to cdev
+ * @adev:	gpr device node
+ * @dev:	audio pkt device
+ * @cdev:	cdev for the audio pkt device
+ * @lock:	synchronization of @rpdev
+ * @queue_lock:	synchronization of @queue operations
+ * @queue:	incoming message queue
+ * @readq:	wait object for incoming queue
+ * @dev_name:	/dev/@dev_name for audio_pkt device
+ * @ch_name:	audio channel to match to
+ * @audio_pkt_major: Major number of audio pkt driver
+ * @audio_pkt_class: audio pkt class pointer
+ */
+struct audio_pkt_device {
+	struct gpr_device *adev;
+	struct device *dev;
+	struct cdev cdev;
+
+	struct mutex lock;
+
+	spinlock_t queue_lock;
+	struct sk_buff_head queue;
+	wait_queue_head_t readq;
+
+	char dev_name[20];
+	char ch_name[20];
+
+	dev_t audio_pkt_major;
+	struct class *audio_pkt_class;
+};
+
+struct audio_pkt_apm_cmd_shared_mem_map_regions_t {
+	uint16_t mem_pool_id;
+	uint16_t num_regions;
+	uint32_t property_flag;
+
+};
+
+struct audio_pkt_apm_shared_map_region_payload_t {
+	uint32_t shm_addr_lsw;
+	uint32_t shm_addr_msw;
+	uint32_t mem_size_bytes;
+};
+
+struct audio_pkt_apm_mem_map {
+	struct audio_pkt_apm_cmd_shared_mem_map_regions_t mmap_header;
+	struct audio_pkt_apm_shared_map_region_payload_t mmap_payload;
+};
+
+struct audio_gpr_pkt {
+	struct gpr_hdr audpkt_hdr;
+	struct audio_pkt_apm_mem_map audpkt_mem_map;
+};
+
+typedef void (*audio_pkt_clnt_cb_fn)(void *buf, int len, void *priv);
+
+struct audio_pkt_clnt_ch {
+	int client_id;
+	audio_pkt_clnt_cb_fn func;
+};
+
+#define dev_to_audpkt_dev(_dev) container_of(_dev, struct audio_pkt_device, dev)
+#define cdev_to_audpkt_dev(_cdev) container_of(_cdev, struct audio_pkt_device, cdev)
+
+/**
+ * audio_pkt_open() - open() syscall for the audio_pkt device
+ * inode:	Pointer to the inode structure.
+ * file:	Pointer to the file structure.
+ *
+ * This function is used to open the audio pkt device when
+ * userspace client do a open() system call. All input arguments are
+ * validated by the virtual file system before calling this function.
+ */
+int audio_pkt_open(struct inode *inode, struct file *file)
+{
+	struct audio_pkt_device *audpkt_dev = cdev_to_audpkt_dev(inode->i_cdev);
+	struct device *dev = audpkt_dev->dev;
+
+	AUDIO_PKT_ERR("for %s\n", audpkt_dev->ch_name);
+
+	get_device(dev);
+	file->private_data = audpkt_dev;
+
+	return 0;
+}
+
+/**
+ * audio_pkt_release() - release operation on audio_pkt device
+ * inode:	Pointer to the inode structure.
+ * file:	Pointer to the file structure.
+ *
+ * This function is used to release the audio pkt device when
+ * userspace client do a close() system call. All input arguments are
+ * validated by the virtual file system before calling this function.
+ */
+int audio_pkt_release(struct inode *inode, struct file *file)
+{
+	struct audio_pkt_device *audpkt_dev = cdev_to_audpkt_dev(inode->i_cdev);
+	struct device *dev = audpkt_dev->dev;
+	struct sk_buff *skb;
+	unsigned long flags;
+
+	AUDIO_PKT_INFO("for %s \n", audpkt_dev->ch_name);
+	spin_lock_irqsave(&audpkt_dev->queue_lock, flags);
+
+	/* Discard all SKBs */
+	while (!skb_queue_empty(&audpkt_dev->queue)) {
+		skb = skb_dequeue(&audpkt_dev->queue);
+		kfree_skb(skb);
+	}
+	wake_up_interruptible(&audpkt_dev->readq);
+	spin_unlock_irqrestore(&audpkt_dev->queue_lock, flags);
+
+	put_device(dev);
+	file->private_data = NULL;
+
+	return 0;
+}
+
+/**
+ * audio_pkt_read() - read() syscall for the audio_pkt device
+ * file:	Pointer to the file structure.
+ * buf:		Pointer to the userspace buffer.
+ * count:	Number bytes to read from the file.
+ * ppos:	Pointer to the position into the file.
+ *
+ * This function is used to Read the data from audio pkt device when
+ * userspace client do a read() system call. All input arguments are
+ * validated by the virtual file system before calling this function.
+ */
+ssize_t audio_pkt_read(struct file *file, char __user *buf,
+		       size_t count, loff_t *ppos)
+{
+	struct audio_pkt_device *audpkt_dev = file->private_data;
+	unsigned long flags;
+	struct sk_buff *skb;
+	int use;
+	uint32_t *temp;
+
+	if (!audpkt_dev) {
+		AUDIO_PKT_ERR("invalid device handle\n");
+		return -EINVAL;
+	}
+
+	spin_lock_irqsave(&audpkt_dev->queue_lock, flags);
+	/* Wait for data in the queue */
+	if (skb_queue_empty(&audpkt_dev->queue)) {
+		spin_unlock_irqrestore(&audpkt_dev->queue_lock, flags);
+
+		if (file->f_flags & O_NONBLOCK)
+			return -EAGAIN;
+
+		/* Wait until we get data or the endpoint goes away */
+		if (wait_event_interruptible(audpkt_dev->readq,
+					!skb_queue_empty(&audpkt_dev->queue)))
+			return -ERESTARTSYS;
+
+		spin_lock_irqsave(&audpkt_dev->queue_lock, flags);
+	}
+
+	skb = skb_dequeue(&audpkt_dev->queue);
+	spin_unlock_irqrestore(&audpkt_dev->queue_lock, flags);
+	if (!skb)
+		return -EFAULT;
+
+	use = min_t(size_t, count, skb->len);
+	if (copy_to_user(buf, skb->data, use))
+		use = -EFAULT;
+	temp = (uint32_t *) skb->data;
+	kfree_skb(skb);
+
+	return use;
+}
+
+/**
+ * audpkt_update_physical_addr - Update physical address
+ * audpkt_hdr:	Pointer to the file structure.
+ */
+int audpkt_chk_and_update_physical_addr(struct audio_gpr_pkt *gpr_pkt)
+{
+	int ret = 0;
+
+	dma_addr_t paddr;
+	if (gpr_pkt->audpkt_mem_map.mmap_header.property_flag &
+				APM_MEMORY_MAP_BIT_MASK_IS_OFFSET_MODE) {
+		ret = msm_audio_get_phy_addr(
+			(int) gpr_pkt->audpkt_mem_map.mmap_payload.shm_addr_lsw,
+			&paddr);
+		if (ret < 0) {
+			AUDIO_PKT_ERR("%s Get phy. address failed, ret %d\n",
+					__func__, ret);
+			return ret;
+		}
+		AUDIO_PKT_INFO("%s physical address %pK", __func__,
+				(void *) paddr);
+		gpr_pkt->audpkt_mem_map.mmap_payload.shm_addr_lsw = (uint32_t) paddr;
+		gpr_pkt->audpkt_mem_map.mmap_payload.shm_addr_msw = (uint64_t) paddr >> 32;
+	}
+	return ret;
+}
+
+/**
+ * audio_pkt_write() - write() syscall for the audio_pkt device
+ * file:	Pointer to the file structure.
+ * buf:		Pointer to the userspace buffer.
+ * count:	Number bytes to read from the file.
+ * ppos:	Pointer to the position into the file.
+ *
+ * This function is used to write the data to audio pkt device when
+ * userspace client do a write() system call. All input arguments are
+ * validated by the virtual file system before calling this function.
+ */
+ssize_t audio_pkt_write(struct file *file, const char __user *buf,
+			size_t count, loff_t *ppos)
+{
+	struct audio_pkt_device *audpkt_dev = file->private_data;
+	struct gpr_hdr *audpkt_hdr = NULL;
+	void *kbuf;
+	int ret;
+
+	if (!audpkt_dev)  {
+		AUDIO_PKT_ERR("invalid device handle\n");
+		return -EINVAL;
+	}
+
+	kbuf = memdup_user(buf, count);
+	if (IS_ERR(kbuf))
+		return PTR_ERR(kbuf);
+
+	audpkt_hdr = (struct gpr_hdr *) kbuf;
+	if (audpkt_hdr->opcode == APM_CMD_SHARED_MEM_MAP_REGIONS) {
+		ret = audpkt_chk_and_update_physical_addr((struct audio_gpr_pkt *) audpkt_hdr);
+		if (ret < 0) {
+			AUDIO_PKT_ERR("Update Physical Address Failed -%d\n", ret);
+		        return ret;
+		}
+	}
+
+	if (mutex_lock_interruptible(&audpkt_dev->lock)) {
+		ret = -ERESTARTSYS;
+		goto free_kbuf;
+	}
+	ret = gpr_send_pkt(audpkt_dev->adev,(struct gpr_pkt *) kbuf);
+	if (ret < 0) {
+		AUDIO_PKT_ERR("APR Send Packet Failed ret -%d\n", ret);
+		return ret;
+	}
+	mutex_unlock(&audpkt_dev->lock);
+
+free_kbuf:
+	kfree(kbuf);
+	return ret < 0 ? ret : count;
+}
+
+/**
+ * audio_pkt_poll() - poll() syscall for the audio_pkt device
+ * file:	Pointer to the file structure.
+ * wait:	pointer to Poll table.
+ *
+ * This function is used to poll on the audio pkt device when
+ * userspace client do a poll() system call. All input arguments are
+ * validated by the virtual file system before calling this function.
+ */
+static unsigned int audio_pkt_poll(struct file *file, poll_table *wait)
+{
+	struct audio_pkt_device *audpkt_dev = file->private_data;
+	unsigned int mask = 0;
+	unsigned long flags;
+
+	audpkt_dev = file->private_data;
+	if (!audpkt_dev) {
+		AUDIO_PKT_ERR("invalid device handle\n");
+		return POLLERR;
+	}
+
+	poll_wait(file, &audpkt_dev->readq, wait);
+
+	mutex_lock(&audpkt_dev->lock);
+
+	spin_lock_irqsave(&audpkt_dev->queue_lock, flags);
+	if (!skb_queue_empty(&audpkt_dev->queue))
+		mask |= POLLIN | POLLRDNORM;
+
+	spin_unlock_irqrestore(&audpkt_dev->queue_lock, flags);
+
+	mutex_unlock(&audpkt_dev->lock);
+
+	return mask;
+}
+
+static const struct file_operations audio_pkt_fops = {
+	.owner = THIS_MODULE,
+	.open = audio_pkt_open,
+	.release = audio_pkt_release,
+	.read = audio_pkt_read,
+	.write = audio_pkt_write,
+	.poll = audio_pkt_poll,
+};
+
+/**
+ * audio_pkt_srvc_callback() - Callback from gpr driver
+ * adev:	pointer to the gpr device of this audio packet device
+ * data:	APR response data packet
+ *
+ * return:	0 for success, Standard Linux errors
+ */
+static int audio_pkt_srvc_callback(struct gpr_device *adev,
+				void *data)
+{
+	struct audio_pkt_device *audpkt_dev = dev_get_drvdata(&adev->dev);
+	unsigned long flags;
+	struct sk_buff *skb;
+	struct gpr_hdr *hdr = (struct gpr_hdr *)data;
+	uint16_t hdr_size, pkt_size;
+	hdr_size = GPR_PKT_GET_HEADER_BYTE_SIZE(hdr->header);
+	pkt_size = GPR_PKT_GET_PACKET_BYTE_SIZE(hdr->header);
+
+        AUDIO_PKT_INFO("header %d packet %d \n",hdr_size, pkt_size);
+
+	skb = alloc_skb(pkt_size, GFP_ATOMIC);
+	if (!skb)
+		return -ENOMEM;
+
+	skb_put_data(skb, data, pkt_size);
+
+	spin_lock_irqsave(&audpkt_dev->queue_lock, flags);
+	skb_queue_tail(&audpkt_dev->queue, skb);
+	spin_unlock_irqrestore(&audpkt_dev->queue_lock, flags);
+
+	/* wake up any blocking processes, waiting for new data */
+	wake_up_interruptible(&audpkt_dev->readq);
+	return 0;
+}
+
+/**
+ * audio_pkt_probe() - Probe a AUDIO packet device
+ *
+ * adev:	Pointer to gpr device.
+ *
+ * return:	0 on success, standard Linux error codes on error.
+ *
+ * This function is called when the underlying device tree driver registers
+ * a gpr device, mapped to a Audio packet device.
+ */
+static int audio_pkt_probe(struct gpr_device *adev)
+{
+	struct audio_pkt_device *audpkt_dev;
+	struct device *dev = &adev->dev;
+	int ret;
+
+	audpkt_dev = devm_kzalloc(dev, sizeof(*audpkt_dev), GFP_KERNEL);
+	if (!audpkt_dev)
+		return -ENOMEM;
+
+	ret = alloc_chrdev_region(&audpkt_dev->audio_pkt_major, 0,
+				  MINOR_NUMBER_COUNT,AUDPKT_DRIVER_NAME);
+	if (ret < 0) {
+		AUDIO_PKT_ERR("alloc_chrdev_region failed ret:%d\n", ret);
+		goto err_chrdev;
+	}
+
+	audpkt_dev->audio_pkt_class = class_create(THIS_MODULE,
+						   AUDPKT_DRIVER_NAME);
+	if (IS_ERR(audpkt_dev->audio_pkt_class)) {
+		ret = PTR_ERR(audpkt_dev->audio_pkt_class);
+		AUDIO_PKT_ERR("class_create failed ret:%ld\n",
+			      PTR_ERR(audpkt_dev->audio_pkt_class));
+		goto err_class;
+	}
+
+	audpkt_dev->dev = device_create(audpkt_dev->audio_pkt_class, NULL,
+					audpkt_dev->audio_pkt_major, NULL,
+					AUDPKT_DRIVER_NAME);
+	if (IS_ERR(audpkt_dev->dev)) {
+		ret = PTR_ERR(audpkt_dev->dev);
+		AUDIO_PKT_ERR("device_create failed ret:%ld\n",
+			      PTR_ERR(audpkt_dev->dev));
+		goto err_device;
+	}
+	strlcpy(audpkt_dev->dev_name, CHANNEL_NAME, 20);
+	strlcpy(audpkt_dev->ch_name, CHANNEL_NAME, 20);
+	dev_set_name(audpkt_dev->dev, audpkt_dev->dev_name);
+
+	mutex_init(&audpkt_dev->lock);
+
+	spin_lock_init(&audpkt_dev->queue_lock);
+	skb_queue_head_init(&audpkt_dev->queue);
+	init_waitqueue_head(&audpkt_dev->readq);
+
+	audpkt_dev->adev = adev;
+	dev_set_drvdata(dev, audpkt_dev);
+
+	cdev_init(&audpkt_dev->cdev, &audio_pkt_fops);
+	audpkt_dev->cdev.owner = THIS_MODULE;
+
+	ret = cdev_add(&audpkt_dev->cdev, audpkt_dev->audio_pkt_major,
+		       MINOR_NUMBER_COUNT);
+	if (ret) {
+		AUDIO_PKT_ERR("cdev_add failed for %s ret:%d\n",
+			      audpkt_dev->dev_name, ret);
+		goto free_dev;
+	}
+
+	AUDIO_PKT_INFO("Audio Packet Port Driver Initialized\n");
+
+	return of_platform_populate(dev->of_node, NULL, NULL, dev);
+
+free_dev:
+	put_device(dev);
+	device_destroy(audpkt_dev->audio_pkt_class,audpkt_dev->audio_pkt_major);
+err_device:
+	class_destroy(audpkt_dev->audio_pkt_class);
+err_class:
+	unregister_chrdev_region(MAJOR(audpkt_dev->audio_pkt_major),
+				 MINOR_NUMBER_COUNT);
+err_chrdev:
+	kfree(audpkt_dev);
+	return ret;
+
+}
+
+/**
+ * audio_pkt_remove() - Remove a AUDIO packet device
+ *
+ * adev:	Pointer to gpr device.
+ *
+ * return:	0 on success, standard Linux error codes on error.
+ *
+ * This function is called when the underlying device tree driver
+ * removeds a gpr device, mapped to a Audio packet device.
+ */
+static int audio_pkt_remove(struct gpr_device *adev)
+{
+	of_platform_depopulate(&adev->dev);
+	AUDIO_PKT_INFO("Audio Packet Port Driver Removed\n");
+
+	return 0;
+
+}
+static const struct of_device_id audio_pkt_match_table[] = {
+	{ .compatible = "qcom,audio-pkt" },
+	{},
+};
+MODULE_DEVICE_TABLE(of, audio_pkt_match_table);
+
+static struct gpr_driver audio_pkt_driver = {
+	.probe = audio_pkt_probe,
+	.remove = audio_pkt_remove,
+	.callback = audio_pkt_srvc_callback,
+	.driver = {
+		.name = MODULE_NAME,
+		.of_match_table = of_match_ptr(audio_pkt_match_table),
+	 },
+};
+
+module_gpr_driver(audio_pkt_driver);
+MODULE_DESCRIPTION("MSM Audio Packet Driver");
+MODULE_LICENSE("GPL v2");