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

Commit 9735b91c authored by Sungjun Park's avatar Sungjun Park Committed by Gerrit - the friendly Code Review server
Browse files

bluetooth: Add slimbus driver for WCN3990 



For WCN3990, it supports slimbus slave interface
to receive/send audio data such as FM audio, bluetooth
SCO, bluetooth A2DP data, etc.

Change-Id: I6c64debd0c9b43ea5ebf55a58f1f4b06cdc9bd4e
Signed-off-by: default avatarSungjun Park <sjpark@codeaurora.org>
parent d3068532

Documentation/devicetree/bindings/bluetooth/btfm_slim.txt

0 → 100644
+20 −0
Original line number Diff line number Diff line 
* BTFM Slimbus Slave Driver

BTFM Slimbus Slave driver configure and initialize slimbus slave device.

Bluetooth SCO and FM Audio data is transferred over slimbus interface.



Required properties:

  - compatible: Should be set to one of the following:

     btfmslim_slave

  - qcom,btfm-slim-ifd: BTFM slimbus slave device entry name



Optional properties:

  - qcom,btfm-slim-ifd-elemental-addr: BTFM slimbus slave device enumeration

  address



Example:

  btfmslim_codec: wcn3990 {

    compatible = "qcom,btfmslim_slave";

    elemental-addr = [00 01 20 02 17 02];

    qcom,btfm-slim-ifd = "btfmslim_slave_ifd";

    qcom,btfm-slim-ifd-elemental-addr = [00 00 20 02 17 02];

  };

drivers/bluetooth/Kconfig

+20 −0
Original line number Diff line number Diff line
@@ -262,4 +262,24 @@ config MSM_BT_POWER 
	  Provides a parameter to switch on/off power from PMIC

	  to Bluetooth device.



config BTFM_SLIM

	tristate "MSM Bluetooth/FM Slimbus Driver"

	depends on MSM_BT_POWER

	help

	  This enables BT/FM slimbus driver to get multiple audio channel.

	  This will make use of slimbus platform driver and slimbus codec

	  driver to communicate with slimbus machine driver and LPSS which

	  is Slimbus master.



	  Slimbus slave initialization and configuration will be done through

	  this driver.



config BTFM_SLIM_WCN3990

	tristate "MSM Bluetooth/FM WCN3990 Device"

	depends on BTFM_SLIM

	help

	  This enables specific driver handle for WCN3990 device.

	  It is designed to adapt any future BT/FM device to implement a specific

	  chip initialization process and control.



endmenu

drivers/bluetooth/Makefile

+4 −0
Original line number Diff line number Diff line
@@ -21,6 +21,10 @@ obj-$(CONFIG_BT_MRVL_SDIO) += btmrvl_sdio.o 
obj-$(CONFIG_BT_WILINK)		+= btwilink.o

obj-$(CONFIG_MSM_BT_POWER)	+= bluetooth-power.o



obj-$(CONFIG_BTFM_SLIM)				+= btfm_slim.o

obj-$(CONFIG_BTFM_SLIM)				+= btfm_slim_codec.o

obj-$(CONFIG_BTFM_SLIM_WCN3990)		+= btfm_slim_wcn3990.o



btmrvl-y			:= btmrvl_main.o

btmrvl-$(CONFIG_DEBUG_FS)	+= btmrvl_debugfs.o

drivers/bluetooth/btfm_slim.c

0 → 100644
+559 −0
Original line number Diff line number Diff line 
/* Copyright (c) 2016, 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/of_gpio.h>

#include <linux/delay.h>

#include <linux/gpio.h>

#include <linux/debugfs.h>

#include <linux/ratelimit.h>

#include <linux/slab.h>

#include <sound/pcm.h>

#include <sound/pcm_params.h>

#include <sound/soc.h>

#include <sound/soc-dapm.h>

#include <sound/tlv.h>

#include <btfm_slim.h>

#include <btfm_slim_wcn3990.h>



int btfm_slim_write(struct btfmslim *btfmslim,

		uint16_t reg, int bytes, void *src, uint8_t pgd)

{

	int ret, i;

	struct slim_ele_access msg;

	int slim_write_tries = SLIM_SLAVE_RW_MAX_TRIES;



	BTFMSLIM_DBG("Write to %s", pgd?"PGD":"IFD");

	msg.start_offset = SLIM_SLAVE_REG_OFFSET + reg;

	msg.num_bytes = bytes;

	msg.comp = NULL;



	for ( ; slim_write_tries != 0; slim_write_tries--) {

		mutex_lock(&btfmslim->xfer_lock);

		ret = slim_change_val_element(pgd ? btfmslim->slim_pgd :

			&btfmslim->slim_ifd, &msg, src, bytes);

		mutex_unlock(&btfmslim->xfer_lock);

		if (ret == 0)

			break;

		usleep_range(5000, 5100);

	}



	if (ret) {

		BTFMSLIM_ERR("failed (%d)" , ret);

		return ret;

	}



	for (i = 0; i < bytes; i++)

		BTFMSLIM_DBG("Write 0x%02x to reg 0x%x", ((uint8_t *)src)[i],

			reg + i);

	return 0;

}



int btfm_slim_write_pgd(struct btfmslim *btfmslim,

		uint16_t reg, int bytes, void *src)

{

	return btfm_slim_write(btfmslim, reg, bytes, src, PGD);

}



int btfm_slim_write_inf(struct btfmslim *btfmslim,

		uint16_t reg, int bytes, void *src)

{

	return btfm_slim_write(btfmslim, reg, bytes, src, IFD);

}



int btfm_slim_read(struct btfmslim *btfmslim, unsigned short reg,

				int bytes, void *dest, uint8_t pgd)

{

	int ret, i;

	struct slim_ele_access msg;

	int slim_read_tries = SLIM_SLAVE_RW_MAX_TRIES;



	BTFMSLIM_DBG("Read from %s", pgd?"PGD":"IFD");

	msg.start_offset = SLIM_SLAVE_REG_OFFSET + reg;

	msg.num_bytes = bytes;

	msg.comp = NULL;



	for ( ; slim_read_tries != 0; slim_read_tries--) {

		mutex_lock(&btfmslim->xfer_lock);

		ret = slim_request_val_element(pgd ? btfmslim->slim_pgd :

			&btfmslim->slim_ifd, &msg, dest, bytes);

		mutex_unlock(&btfmslim->xfer_lock);

		if (ret == 0)

			break;

		usleep_range(5000, 5100);

	}



	if (ret)

		BTFMSLIM_ERR("failed (%d)" , ret);



	for (i = 0; i < bytes; i++)

		BTFMSLIM_DBG("Read 0x%02x from reg 0x%x", ((uint8_t *)dest)[i],

			reg + i);



	return 0;

}



int btfm_slim_read_pgd(struct btfmslim *btfmslim,

		uint16_t reg, int bytes, void *dest)

{

	return btfm_slim_read(btfmslim, reg, bytes, dest, PGD);

}



int btfm_slim_read_inf(struct btfmslim *btfmslim,

		uint16_t reg, int bytes, void *dest)

{

	return btfm_slim_read(btfmslim, reg, bytes, dest, IFD);

}



int btfm_slim_enable_ch(struct btfmslim *btfmslim, struct btfmslim_ch *ch,

	uint8_t rxport, uint32_t rates, uint8_t grp, uint8_t nchan)

{

	int ret, i;

	struct slim_ch prop;

	struct btfmslim_ch *chan = ch;

	uint16_t ch_h[2];



	if (!btfmslim || !ch)

		return -EINVAL;



	BTFMSLIM_DBG("port:%d", ch->port);



	/* Define the channel with below parameters */

	prop.prot = SLIM_AUTO_ISO;

	prop.baser = SLIM_RATE_4000HZ;

	prop.dataf = SLIM_CH_DATAF_LPCM_AUDIO;

	prop.auxf = SLIM_CH_AUXF_NOT_APPLICABLE;

	prop.ratem = (rates/4000);

	prop.sampleszbits = 16;



	ch_h[0] = ch->ch_hdl;

	ch_h[1] = (grp) ? (ch+1)->ch_hdl : 0;



	ret = slim_define_ch(btfmslim->slim_pgd, &prop, ch_h, nchan, grp,

			&ch->grph);

	if (ret < 0) {

		BTFMSLIM_ERR("slim_define_ch failed ret[%d]", ret);

		goto error;

	}



	for (i = 0; i < nchan; i++, ch++) {

		/* Enable port through registration setting */

		if (btfmslim->vendor_port_en) {

			ret = btfmslim->vendor_port_en(btfmslim, ch->port,

					rxport, 1);

			if (ret < 0) {

				BTFMSLIM_ERR("vendor_port_en failed ret[%d]",

					ret);

				goto error;

			}

		}



		if (rxport) {

			BTFMSLIM_INFO("slim_connect_sink(port: %d, ch: %d)",

				ch->port, ch->ch);

			/* Connect Port with channel given by Machine driver*/

			ret = slim_connect_sink(btfmslim->slim_pgd,

				&ch->port_hdl, 1, ch->ch_hdl);

			if (ret < 0) {

				BTFMSLIM_ERR("slim_connect_sink failed ret[%d]",

					ret);

				goto remove_channel;

			}



		} else {

			BTFMSLIM_INFO("slim_connect_src(port: %d, ch: %d)",

				ch->port, ch->ch);

			/* Connect Port with channel given by Machine driver*/

			ret = slim_connect_src(btfmslim->slim_pgd, ch->port_hdl,

				ch->ch_hdl);

			if (ret < 0) {

				BTFMSLIM_ERR("slim_connect_src failed ret[%d]",

					ret);

				goto remove_channel;

			}

		}

	}



	/* Activate the channel immediately */

	BTFMSLIM_INFO(

		"port: %d, ch: %d, grp: %d, ch->grph: 0x%x, ch_hdl: 0x%x",

		chan->port, chan->ch, grp, chan->grph, chan->ch_hdl);

	ret = slim_control_ch(btfmslim->slim_pgd, (grp ? chan->grph :

		chan->ch_hdl), SLIM_CH_ACTIVATE, true);

	if (ret < 0) {

		BTFMSLIM_ERR("slim_control_ch failed ret[%d]", ret);

		goto remove_channel;

	}



error:

	return ret;



remove_channel:

	/* Remove the channel immediately*/

	ret = slim_control_ch(btfmslim->slim_pgd, (grp ? ch->grph : ch->ch_hdl),

			SLIM_CH_REMOVE, true);

	if (ret < 0)

		BTFMSLIM_ERR("slim_control_ch failed ret[%d]", ret);



	return ret;

}



int btfm_slim_disable_ch(struct btfmslim *btfmslim, struct btfmslim_ch *ch,

	uint8_t rxport, uint8_t grp, uint8_t nchan)

{

	int ret, i;



	if (!btfmslim || !ch)

		return -EINVAL;



	BTFMSLIM_INFO("port:%d, grp: %d, ch->grph:0x%x, ch->ch_hdl:0x%x ",

		ch->port, grp, ch->grph, ch->ch_hdl);

	/* Remove the channel immediately*/

	ret = slim_control_ch(btfmslim->slim_pgd, (grp ? ch->grph : ch->ch_hdl),

			SLIM_CH_REMOVE, true);

	if (ret < 0) {

		BTFMSLIM_ERR("slim_control_ch failed ret[%d]", ret);

		ret = slim_disconnect_ports(btfmslim->slim_pgd,

			&ch->port_hdl, 1);

		if (ret < 0) {

			BTFMSLIM_ERR("slim_disconnect_ports failed ret[%d]",

				ret);

			goto error;

		}

	}



	/* Disable port through registration setting */

	for (i = 0; i < nchan; i++, ch++) {

		if (btfmslim->vendor_port_en) {

			ret = btfmslim->vendor_port_en(btfmslim, ch->port,

				rxport, 0);

			if (ret < 0) {

				BTFMSLIM_ERR("vendor_port_en failed ret[%d]",

					ret);

				break;

			}

		}

	}

error:

	return ret;

}

static int btfm_slim_get_logical_addr(struct slim_device *slim)

{

	int ret = 0;

	const unsigned long timeout = jiffies +

			      msecs_to_jiffies(SLIM_SLAVE_PRESENT_TIMEOUT);



	do {

		ret = slim_get_logical_addr(slim, slim->e_addr,

			ARRAY_SIZE(slim->e_addr), &slim->laddr);

		if (!ret)  {

			BTFMSLIM_DBG("Assigned l-addr: 0x%x", slim->laddr);

			break;

		}

		/* Give SLIMBUS time to report present and be ready. */

		usleep_range(1000, 1100);

		BTFMSLIM_DBG("retyring get logical addr");

	} while (time_before(jiffies, timeout));



	return ret;

}



static int btfm_slim_alloc_port(struct btfmslim *btfmslim)

{

	int ret = -EINVAL, i;

	struct btfmslim_ch *rx_chs;

	struct btfmslim_ch *tx_chs;



	if (!btfmslim)

		return ret;



	rx_chs = btfmslim->rx_chs;

	tx_chs = btfmslim->tx_chs;



	if (!rx_chs || !tx_chs)

		return ret;



	BTFMSLIM_DBG("Rx: id\tname\tport\thdl\tch\tch_hdl");

	for (i = 0 ; (rx_chs->port != BTFM_SLIM_PGD_PORT_LAST) &&

		(i < BTFM_SLIM_NUM_CODEC_DAIS); i++, rx_chs++) {



		/* Get Rx port handler from slimbus driver based

		  * on port number

		  */

		ret = slim_get_slaveport(btfmslim->slim_pgd->laddr,

			rx_chs->port, &rx_chs->port_hdl, SLIM_SINK);

		if (ret < 0) {

			BTFMSLIM_ERR("slave port failure port#%d - ret[%d]",

				rx_chs->port, SLIM_SINK);

			return ret;

		}

		BTFMSLIM_DBG("    %d\t%s\t%d\t%x\t%d\t%x", rx_chs->id,

			rx_chs->name, rx_chs->port, rx_chs->port_hdl,

			rx_chs->ch, rx_chs->ch_hdl);

	}



	BTFMSLIM_DBG("Tx: id\tname\tport\thdl\tch\tch_hdl");

	for (i = 0; (tx_chs->port != BTFM_SLIM_PGD_PORT_LAST) &&

		(i < BTFM_SLIM_NUM_CODEC_DAIS); i++, tx_chs++) {



		/* Get Tx port handler from slimbus driver based

		  * on port number

		  */

		ret = slim_get_slaveport(btfmslim->slim_pgd->laddr,

			tx_chs->port, &tx_chs->port_hdl, SLIM_SRC);

		if (ret < 0) {

			BTFMSLIM_ERR("slave port failure port#%d - ret[%d]",

				tx_chs->port, SLIM_SRC);

			return ret;

		}

		BTFMSLIM_DBG("    %d\t%s\t%d\t%x\t%d\t%x", tx_chs->id,

			tx_chs->name, tx_chs->port, tx_chs->port_hdl,

			tx_chs->ch, tx_chs->ch_hdl);

	}

	return ret;

}



int btfm_slim_hw_init(struct btfmslim *btfmslim)

{

	int ret;



	BTFMSLIM_DBG("");

	if (!btfmslim)

		return -EINVAL;



	if (btfmslim->enabled) {

		BTFMSLIM_DBG("Already enabled");

		return 0;

	}

	mutex_lock(&btfmslim->io_lock);



	/* Assign Logical Address for PGD (Ported Generic Device)

	  * enumeration address

	  */

	ret = btfm_slim_get_logical_addr(btfmslim->slim_pgd);

	if (ret) {

		BTFMSLIM_ERR("failed to get slimbus %s logical address: %d",

		       btfmslim->slim_pgd->name, ret);

		goto error;

	}



	/* Assign Logical Address for Ported Generic Device

	  * enumeration address

	  */

	ret = btfm_slim_get_logical_addr(&btfmslim->slim_ifd);

	if (ret) {

		BTFMSLIM_ERR("failed to get slimbus %s logical address: %d",

		       btfmslim->slim_ifd.name, ret);

		goto error;

	}



	/* Allocate ports with logical address to get port handler from

	  * slimbus driver

	  */

	ret = btfm_slim_alloc_port(btfmslim);

	if (ret)

		goto error;



	/* Start vendor specific initialization and get port information */

	if (btfmslim->vendor_init)

		ret = btfmslim->vendor_init(btfmslim);



	/* Only when all registers read/write successfully, it set to

	  * enabled status

	  */

	btfmslim->enabled = 1;

error:

	mutex_unlock(&btfmslim->io_lock);

	return ret;

}





int btfm_slim_hw_deinit(struct btfmslim *btfmslim)

{

	int ret = 0;



	if (!btfmslim)

		return -EINVAL;



	if (!btfmslim->enabled) {

		BTFMSLIM_DBG("Already disabled");

		return 0;

	}

	mutex_lock(&btfmslim->io_lock);

	btfmslim->enabled = 0;

	mutex_unlock(&btfmslim->io_lock);

	return ret;

}



static int btfm_slim_get_dt_info(struct btfmslim *btfmslim)

{

	int ret = 0;

	struct slim_device *slim = btfmslim->slim_pgd;

	struct slim_device *slim_ifd = &btfmslim->slim_ifd;

	struct property *prop;



	if (!slim || !slim_ifd)

		return -EINVAL;



	if (slim->dev.of_node) {

		BTFMSLIM_DBG("Platform data from device tree (%s)",

			slim->name);

		ret = of_property_read_string(slim->dev.of_node,

			"qcom,btfm-slim-ifd", &slim_ifd->name);

		if (ret) {

			BTFMSLIM_ERR("Looking up %s property in node %s failed",

				"qcom,btfm-slim-ifd",

				 slim->dev.of_node->full_name);

			return -ENODEV;

		}

		BTFMSLIM_DBG("qcom,btfm-slim-ifd (%s)", slim_ifd->name);



		prop = of_find_property(slim->dev.of_node,

				"qcom,btfm-slim-ifd-elemental-addr", NULL);

		if (!prop) {

			BTFMSLIM_ERR("Looking up %s property in node %s failed",

				"qcom,btfm-slim-ifd-elemental-addr",

				slim->dev.of_node->full_name);

			return -ENODEV;

		} else if (prop->length != 6) {

			BTFMSLIM_ERR(

				"invalid codec slim ifd addr. addr length= %d",

				prop->length);

			return -ENODEV;

		}

		memcpy(slim_ifd->e_addr, prop->value, 6);

		BTFMSLIM_DBG(

			"PGD Enum Addr: %.02x:%.02x:%.02x:%.02x:%.02x: %.02x",

			slim->e_addr[0], slim->e_addr[1], slim->e_addr[2],

			slim->e_addr[3], slim->e_addr[4], slim->e_addr[5]);

		BTFMSLIM_DBG(

			"IFD Enum Addr: %.02x:%.02x:%.02x:%.02x:%.02x: %.02x",

			slim_ifd->e_addr[0], slim_ifd->e_addr[1],

			slim_ifd->e_addr[2], slim_ifd->e_addr[3],

			slim_ifd->e_addr[4], slim_ifd->e_addr[5]);

	} else {

		BTFMSLIM_ERR("Platform data is not valid");

	}



	return ret;

}



static int btfm_slim_probe(struct slim_device *slim)

{

	int ret = 0;

	struct btfmslim *btfm_slim;



	BTFMSLIM_DBG("");

	if (!slim->ctrl)

		return -EINVAL;



	/* Allocation btfmslim data pointer */

	btfm_slim = kzalloc(sizeof(struct btfmslim), GFP_KERNEL);

	if (btfm_slim == NULL) {

		BTFMSLIM_ERR("error, allocation failed");

		return -ENOMEM;

	}

	/* BTFM Slimbus driver control data configuration */

	btfm_slim->slim_pgd = slim;



	/* Assign vendor specific function */

	btfm_slim->rx_chs = SLIM_SLAVE_RXPORT;

	btfm_slim->tx_chs = SLIM_SLAVE_TXPORT;

	btfm_slim->vendor_init = SLIM_SLAVE_INIT;

	btfm_slim->vendor_port_en = SLIM_SLAVE_PORT_EN;



	/* Created Mutex for slimbus data transfer */

	mutex_init(&btfm_slim->io_lock);

	mutex_init(&btfm_slim->xfer_lock);



	/* Get Device tree node for Interface Device enumeration address */

	ret = btfm_slim_get_dt_info(btfm_slim);

	if (ret)

		goto dealloc;



	/* Add Interface Device for slimbus driver */

	ret = slim_add_device(btfm_slim->slim_pgd->ctrl, &btfm_slim->slim_ifd);

	if (ret) {

		BTFMSLIM_ERR("error, adding SLIMBUS device failed");

		goto dealloc;

	}



	/* Platform driver data allocation */

	slim->dev.platform_data = btfm_slim;



	/* Driver specific data allocation */

	btfm_slim->dev = &slim->dev;

	ret = btfm_slim_register_codec(&slim->dev);

	return ret;



dealloc:

	mutex_destroy(&btfm_slim->io_lock);

	mutex_destroy(&btfm_slim->xfer_lock);

	kfree(btfm_slim);

	return ret;

}

static int btfm_slim_remove(struct slim_device *slim)

{

	struct btfmslim *btfm_slim = slim->dev.platform_data;



	BTFMSLIM_DBG("");

	mutex_destroy(&btfm_slim->io_lock);

	mutex_destroy(&btfm_slim->xfer_lock);

	kfree(btfm_slim);

	snd_soc_unregister_codec(&slim->dev);



	BTFMSLIM_DBG("slim_remove_device() - btfm_slim->slim_ifd");

	slim_remove_device(&btfm_slim->slim_ifd);



	BTFMSLIM_DBG("slim_remove_device() - btfm_slim->slim_pgd");

	slim_remove_device(slim);

	return 0;

}



static const struct slim_device_id btfm_slim_id[] = {

	{SLIM_SLAVE_COMPATIBLE_STR, 0},

	{}

};



static struct slim_driver btfm_slim_driver = {

	.driver = {

		.name = "btfmslim-driver",

		.owner = THIS_MODULE,

	},

	.probe = btfm_slim_probe,

	.remove = btfm_slim_remove,

	.id_table = btfm_slim_id

};



static int __init btfm_slim_init(void)

{

	int ret;



	BTFMSLIM_DBG("");

	ret = slim_driver_register(&btfm_slim_driver);

	if (ret)

		BTFMSLIM_ERR("Failed to register slimbus driver: %d", ret);

	return ret;

}



static void __exit btfm_slim_exit(void)

{

	BTFMSLIM_DBG("");

	slim_driver_unregister(&btfm_slim_driver);

}



module_init(btfm_slim_init);

module_exit(btfm_slim_exit);



MODULE_LICENSE("GPL v2");

MODULE_DESCRIPTION("BTFM Slimbus Slave driver");

drivers/bluetooth/btfm_slim.h

0 → 100644
+164 −0
Original line number Diff line number Diff line 
/* Copyright (c) 2016, 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 BTFM_SLIM_H

#define BTFM_SLIM_H

#include <linux/slimbus/slimbus.h>



#define BTFMSLIM_DBG(fmt, arg...)  pr_debug("%s: " fmt "\n" , __func__ , ## arg)

#define BTFMSLIM_INFO(fmt, arg...) pr_info("%s: " fmt "\n" , __func__ , ## arg)

#define BTFMSLIM_ERR(fmt, arg...)  pr_err("%s: " fmt "\n" , __func__ , ## arg)



/* Vendor specific defines

 This should redefines in slimbus slave specific header

*/

#define SLIM_SLAVE_COMPATIBLE_STR	"btfmslim_slave"

#define SLIM_SLAVE_REG_OFFSET		0x0000

#define SLIM_SLAVE_RXPORT		NULL

#define SLIM_SLAVE_TXPORT		NULL

#define SLIM_SLAVE_INIT			NULL

#define SLIM_SLAVE_PORT_EN		NULL



/* Misc defines */

#define SLIM_SLAVE_RW_MAX_TRIES		3

#define SLIM_SLAVE_PRESENT_TIMEOUT	100



#define PGD	1

#define IFD	0





/* Codec driver defines */

enum {

	BTFM_FM_SLIM_TX = 0,

	BTFM_BT_SCO_SLIM_TX,

	BTFM_BT_SCO_SLIM_RX,

	BTFM_BT_SPLIT_A2DP_SLIM_RX,

	BTFM_SLIM_NUM_CODEC_DAIS

};



/* Slimbus Port defines - This should be redefined in specific device file */

#define BTFM_SLIM_PGD_PORT_LAST				0xFF



struct btfmslim_ch {

	int id;

	char *name;

	uint32_t port_hdl;	/* slimbus port handler */

	uint16_t port;		/* slimbus port number */



	uint8_t ch;		/* slimbus channel number */

	uint16_t ch_hdl;	/* slimbus channel handler */

	uint16_t grph;	/* slimbus group channel handler */

};



struct btfmslim {

	struct device *dev;

	struct slim_device *slim_pgd;

	struct slim_device slim_ifd;

	struct mutex io_lock;

	struct mutex xfer_lock;

	uint8_t enabled;



	uint32_t num_rx_port;

	uint32_t num_tx_port;



	struct btfmslim_ch *rx_chs;

	struct btfmslim_ch *tx_chs;



	int (*vendor_init)(struct btfmslim *btfmslim);

	int (*vendor_port_en)(struct btfmslim *btfmslim, uint8_t port_num,

		uint8_t rxport, uint8_t enable);

};



/**

 * btfm_slim_hw_init: Initialize slimbus slave device

 * Returns:

 * 0: Success

 * else: Fail

 */

int btfm_slim_hw_init(struct btfmslim *btfmslim);



/**

 * btfm_slim_hw_deinit: Deinitialize slimbus slave device

 * Returns:

 * 0: Success

 * else: Fail

 */

int btfm_slim_hw_deinit(struct btfmslim *btfmslim);



/**

 * btfm_slim_write: write value to pgd or ifd device

 * @btfmslim: slimbus slave device data pointer.

 * @reg: slimbus slave register address

 * @bytes: length of data

 * @src: data pointer to write

 * @pgd: selection for device: either PGD or IFD

 * Returns:

 * -EINVAL

 * -ETIMEDOUT

 * -ENOMEM

 */

int btfm_slim_write(struct btfmslim *btfmslim,

	uint16_t reg, int bytes, void *src, uint8_t pgd);







/**

 * btfm_slim_read: read value from pgd or ifd device

 * @btfmslim: slimbus slave device data pointer.

 * @reg: slimbus slave register address

 * @bytes: length of data

 * @dest: data pointer to read

 * @pgd: selection for device: either PGD or IFD

 * Returns:

 * -EINVAL

 * -ETIMEDOUT

 * -ENOMEM

 */

int btfm_slim_read(struct btfmslim *btfmslim,

	uint16_t reg, int bytes, void *dest, uint8_t pgd);





/**

 * btfm_slim_enable_ch: enable channel for slimbus slave port

 * @btfmslim: slimbus slave device data pointer.

 * @ch: slimbus slave channel pointer

 * @rxport: rxport or txport

 * Returns:

 * -EINVAL

 * -ETIMEDOUT

 * -ENOMEM

 */

int btfm_slim_enable_ch(struct btfmslim *btfmslim,

	struct btfmslim_ch *ch, uint8_t rxport, uint32_t rates,

	uint8_t grp, uint8_t nchan);



/**

 * btfm_slim_disable_ch: disable channel for slimbus slave port

 * @btfmslim: slimbus slave device data pointer.

 * @ch: slimbus slave channel pointer

 * @rxport: rxport or txport

 * Returns:

 * -EINVAL

 * -ETIMEDOUT

 * -ENOMEM

 */

int btfm_slim_disable_ch(struct btfmslim *btfmslim,

	struct btfmslim_ch *ch, uint8_t rxport, uint8_t grp, uint8_t nchan);



/**

 * btfm_slim_register_codec: Register codec driver in slimbus device node

 * @dev: device node

 * Returns:

 * -ENOMEM

 * 0

*/

int btfm_slim_register_codec(struct device *dev);

#endif /* BTFM_SLIM_H */