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

Commit fb9b44e7 authored by Venkateshwarlu Domakonda's avatar Venkateshwarlu Domakonda
Browse files

radio: iris: Add snapshot of iris FM radio support 



Files taken from the below 3.14 commits.
8ba5894b5d7740339d18df0237285df3f584d2fb
("Configure the signal blending parameters BlendSinrHi & BlendRmssiHi.")

Change-Id: I917d68a181787de62737cc33c9c638a78b4bc76f
Signed-off-by: default avatarVenkateshwarlu Domakonda <vdomak@codeaurora.org>
parent 8b477bbf

drivers/media/radio/radio-iris-transport.c

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

 *  Qualcomm's FM Shared Memory Transport Driver

 *

 *  FM HCI_SMD ( FM HCI Shared Memory Driver) is Qualcomm's Shared memory driver

 *  for the HCI protocol. This file is based on drivers/bluetooth/hci_vhci.c

 *

 *  Copyright (c) 2000-2001, 2011-2012, 2014 The Linux Foundation.

 *  All rights reserved.

 *

 *  Copyright (C) 2002-2003  Maxim Krasnyansky <maxk@qualcomm.com>

 *  Copyright (C) 2004-2006  Marcel Holtmann <marcel@holtmann.org>

 *

 *  This program is free software; you can redistribute it and/or modify

 *  it under the terms of the GNU General Public License 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/module.h>

#include <linux/kernel.h>

#include <linux/init.h>

#include <linux/errno.h>

#include <linux/string.h>

#include <linux/skbuff.h>

#include <linux/workqueue.h>

#include <soc/qcom/smd.h>

#include <media/radio-iris.h>



struct radio_data {

	struct radio_hci_dev *hdev;

	struct tasklet_struct   rx_task;

	struct smd_channel  *fm_channel;

};

struct radio_data hs;



static struct work_struct *reset_worker;



static void radio_hci_smd_destruct(struct radio_hci_dev *hdev)

{

	radio_hci_unregister_dev(hs.hdev);

}





static void radio_hci_smd_recv_event(unsigned long temp)

{

	int len;

	int rc;

	struct sk_buff *skb;

	unsigned  char *buf;

	struct radio_data *hsmd = &hs;

	len = smd_read_avail(hsmd->fm_channel);



	while (len) {

		skb = alloc_skb(len, GFP_ATOMIC);

		if (!skb) {

			FMDERR("Memory not allocated for the socket");

			return;

		}



		buf = kmalloc(len, GFP_ATOMIC);

		if (!buf) {

			kfree_skb(skb);

			FMDERR("Error in allocating buffer memory");

			return;

		}



		rc = smd_read(hsmd->fm_channel, (void *)buf, len);



		memcpy(skb_put(skb, len), buf, len);



		skb_orphan(skb);

		skb->dev = (struct net_device   *)hs.hdev;



		rc = radio_hci_recv_frame(skb);



		kfree(buf);

		len = smd_read_avail(hsmd->fm_channel);

	}

}



static int radio_hci_smd_send_frame(struct sk_buff *skb)

{

	int len = 0;



	len = smd_write(hs.fm_channel, skb->data, skb->len);

	if (len < skb->len) {

		FMDERR("Failed to write Data %d", len);

		kfree_skb(skb);

		return -ENODEV;

	}

	kfree_skb(skb);

	return 0;

}





static void send_disable_event(struct work_struct *worker)

{

	struct sk_buff *skb;

	unsigned char buf[6] = { 0x0f, 0x04, 0x01, 0x02, 0x4c, 0x00 };

	int len = sizeof(buf);



	skb = alloc_skb(len, GFP_ATOMIC);

	if (!skb) {

		FMDERR("Memory not allocated for the socket");

		kfree(worker);

		return;

	}



	FMDERR("FM INSERT DISABLE Rx Event");



	memcpy(skb_put(skb, len), buf, len);



	skb_orphan(skb);

	skb->dev = (struct net_device   *)hs.hdev;



	radio_hci_recv_frame(skb);

	kfree(worker);

}



static void radio_hci_smd_notify_cmd(void *data, unsigned int event)

{

	struct radio_hci_dev *hdev = hs.hdev;



	if (!hdev) {

		FMDERR("Frame for unknown HCI device (hdev=NULL)");

		return;

	}



	switch (event) {

	case SMD_EVENT_DATA:

		tasklet_schedule(&hs.rx_task);

		break;

	case SMD_EVENT_OPEN:

		break;

	case SMD_EVENT_CLOSE:

		reset_worker = kzalloc(sizeof(*reset_worker), GFP_ATOMIC);

		if (!reset_worker) {

			FMDERR("Out of memory");

			break;

		}

		INIT_WORK(reset_worker, send_disable_event);

		schedule_work(reset_worker);

		break;

	default:

		break;

	}

}



static int radio_hci_smd_register_dev(struct radio_data *hsmd)

{

	struct radio_hci_dev *hdev;

	int rc;



	if (hsmd == NULL)

		return -ENODEV;



	hdev = kmalloc(sizeof(struct radio_hci_dev), GFP_KERNEL);

	if (hdev == NULL)

		return -ENODEV;



	hsmd->hdev = hdev;

	tasklet_init(&hsmd->rx_task, radio_hci_smd_recv_event,

		(unsigned long) hsmd);

	hdev->send  = radio_hci_smd_send_frame;

	hdev->destruct = radio_hci_smd_destruct;



	/* Open the SMD Channel and device and register the callback function */

	rc = smd_named_open_on_edge("APPS_FM", SMD_APPS_WCNSS,

		&hsmd->fm_channel, hdev, radio_hci_smd_notify_cmd);



	if (rc < 0) {

		FMDERR("Cannot open the command channel");

		hsmd->hdev = NULL;

		kfree(hdev);

		return -ENODEV;

	}



	smd_disable_read_intr(hsmd->fm_channel);



	if (radio_hci_register_dev(hdev) < 0) {

		FMDERR("Can't register HCI device");

		smd_close(hsmd->fm_channel);

		hsmd->hdev = NULL;

		kfree(hdev);

		return -ENODEV;

	}



	return 0;

}



static void radio_hci_smd_deregister(void)

{

	smd_close(hs.fm_channel);

	hs.fm_channel = 0;

}



static int radio_hci_smd_init(void)

{

	return radio_hci_smd_register_dev(&hs);

}

module_init(radio_hci_smd_init);



static void __exit radio_hci_smd_exit(void)

{

	radio_hci_smd_deregister();

}

module_exit(radio_hci_smd_exit);



MODULE_DESCRIPTION("Bluetooth SMD driver");

MODULE_AUTHOR("Ankur Nandwani <ankurn@codeaurora.org>");

MODULE_LICENSE("GPL v2");

drivers/media/radio/radio-iris.c

0 → 100644
+5510 −0

File added.

Preview size limit exceeded, changes collapsed.

include/uapi/media/radio-iris-commands.h

0 → 100644
+113 −0
Original line number Diff line number Diff line 
#ifndef __RADIO_IRIS_COMMANDS_H

#define __RADIO_IRIS_COMMANDS_H



#include <linux/skbuff.h>

#include <linux/interrupt.h>

#include <linux/mutex.h>

#include <linux/atomic.h>



enum v4l2_cid_private_iris_t {

	V4L2_CID_PRIVATE_IRIS_SRCHMODE = (0x08000000 + 1),

	V4L2_CID_PRIVATE_IRIS_SCANDWELL,

	V4L2_CID_PRIVATE_IRIS_SRCHON,

	V4L2_CID_PRIVATE_IRIS_STATE,

	V4L2_CID_PRIVATE_IRIS_TRANSMIT_MODE,

	V4L2_CID_PRIVATE_IRIS_RDSGROUP_MASK,

	V4L2_CID_PRIVATE_IRIS_REGION,

	V4L2_CID_PRIVATE_IRIS_SIGNAL_TH,

	V4L2_CID_PRIVATE_IRIS_SRCH_PTY,

	V4L2_CID_PRIVATE_IRIS_SRCH_PI,

	V4L2_CID_PRIVATE_IRIS_SRCH_CNT,

	V4L2_CID_PRIVATE_IRIS_EMPHASIS,

	V4L2_CID_PRIVATE_IRIS_RDS_STD,

	V4L2_CID_PRIVATE_IRIS_SPACING,

	V4L2_CID_PRIVATE_IRIS_RDSON,

	V4L2_CID_PRIVATE_IRIS_RDSGROUP_PROC,

	V4L2_CID_PRIVATE_IRIS_LP_MODE,

	V4L2_CID_PRIVATE_IRIS_ANTENNA,

	V4L2_CID_PRIVATE_IRIS_RDSD_BUF,

	V4L2_CID_PRIVATE_IRIS_PSALL,  /*0x8000014*/



	/*v4l2 Tx controls*/

	V4L2_CID_PRIVATE_IRIS_TX_SETPSREPEATCOUNT,

	V4L2_CID_PRIVATE_IRIS_STOP_RDS_TX_PS_NAME,

	V4L2_CID_PRIVATE_IRIS_STOP_RDS_TX_RT,

	V4L2_CID_PRIVATE_IRIS_IOVERC,

	V4L2_CID_PRIVATE_IRIS_INTDET,

	V4L2_CID_PRIVATE_IRIS_MPX_DCC,

	V4L2_CID_PRIVATE_IRIS_AF_JUMP,

	V4L2_CID_PRIVATE_IRIS_RSSI_DELTA,

	V4L2_CID_PRIVATE_IRIS_HLSI, /*0x800001d*/



	/*Diagnostic commands*/

	V4L2_CID_PRIVATE_IRIS_SOFT_MUTE,

	V4L2_CID_PRIVATE_IRIS_RIVA_ACCS_ADDR,

	V4L2_CID_PRIVATE_IRIS_RIVA_ACCS_LEN,

	V4L2_CID_PRIVATE_IRIS_RIVA_PEEK,

	V4L2_CID_PRIVATE_IRIS_RIVA_POKE,

	V4L2_CID_PRIVATE_IRIS_SSBI_ACCS_ADDR,

	V4L2_CID_PRIVATE_IRIS_SSBI_PEEK,

	V4L2_CID_PRIVATE_IRIS_SSBI_POKE,

	V4L2_CID_PRIVATE_IRIS_TX_TONE,

	V4L2_CID_PRIVATE_IRIS_RDS_GRP_COUNTERS,

	V4L2_CID_PRIVATE_IRIS_SET_NOTCH_FILTER, /* 0x8000028 */

	V4L2_CID_PRIVATE_IRIS_SET_AUDIO_PATH, /* TAVARUA specific command */

	V4L2_CID_PRIVATE_IRIS_DO_CALIBRATION,

	V4L2_CID_PRIVATE_IRIS_SRCH_ALGORITHM, /* TAVARUA specific command */

	V4L2_CID_PRIVATE_IRIS_GET_SINR,

	V4L2_CID_PRIVATE_INTF_LOW_THRESHOLD,

	V4L2_CID_PRIVATE_INTF_HIGH_THRESHOLD,

	V4L2_CID_PRIVATE_SINR_THRESHOLD,

	V4L2_CID_PRIVATE_SINR_SAMPLES,

	V4L2_CID_PRIVATE_SPUR_FREQ,

	V4L2_CID_PRIVATE_SPUR_FREQ_RMSSI,

	V4L2_CID_PRIVATE_SPUR_SELECTION,

	V4L2_CID_PRIVATE_UPDATE_SPUR_TABLE,

	V4L2_CID_PRIVATE_VALID_CHANNEL,

	V4L2_CID_PRIVATE_AF_RMSSI_TH,

	V4L2_CID_PRIVATE_AF_RMSSI_SAMPLES,

	V4L2_CID_PRIVATE_GOOD_CH_RMSSI_TH,

	V4L2_CID_PRIVATE_SRCHALGOTYPE,

	V4L2_CID_PRIVATE_CF0TH12,

	V4L2_CID_PRIVATE_SINRFIRSTSTAGE,

	V4L2_CID_PRIVATE_RMSSIFIRSTSTAGE,

	V4L2_CID_PRIVATE_RXREPEATCOUNT,

	V4L2_CID_PRIVATE_IRIS_RSSI_TH,

	V4L2_CID_PRIVATE_IRIS_AF_JUMP_RSSI_TH,

	V4L2_CID_PRIVATE_BLEND_SINRHI,

	V4L2_CID_PRIVATE_BLEND_RMSSIHI,



	/*using private CIDs under userclass*/

	V4L2_CID_PRIVATE_IRIS_READ_DEFAULT = 0x00980928,

	V4L2_CID_PRIVATE_IRIS_WRITE_DEFAULT,

	V4L2_CID_PRIVATE_IRIS_SET_CALIBRATION,

	V4L2_CID_PRIVATE_IRIS_SET_SPURTABLE = 0x0098092D,

	V4L2_CID_PRIVATE_IRIS_GET_SPUR_TBL  = 0x0098092E,

};



enum iris_evt_t {

	IRIS_EVT_RADIO_READY,

	IRIS_EVT_TUNE_SUCC,

	IRIS_EVT_SEEK_COMPLETE,

	IRIS_EVT_SCAN_NEXT,

	IRIS_EVT_NEW_RAW_RDS,

	IRIS_EVT_NEW_RT_RDS,

	IRIS_EVT_NEW_PS_RDS,

	IRIS_EVT_ERROR,

	IRIS_EVT_BELOW_TH,

	IRIS_EVT_ABOVE_TH,

	IRIS_EVT_STEREO,

	IRIS_EVT_MONO,

	IRIS_EVT_RDS_AVAIL,

	IRIS_EVT_RDS_NOT_AVAIL,

	IRIS_EVT_NEW_SRCH_LIST,

	IRIS_EVT_NEW_AF_LIST,

	IRIS_EVT_TXRDSDAT,

	IRIS_EVT_TXRDSDONE,

	IRIS_EVT_RADIO_DISABLED,

	IRIS_EVT_NEW_ODA,

	IRIS_EVT_NEW_RT_PLUS,

	IRIS_EVT_NEW_ERT,

	IRIS_EVT_SPUR_TBL,

};

#endif /* __RADIO_IRIS_COMMANDS_H */

include/uapi/media/radio-iris.h

0 → 100644
+1121 −0

File added.

Preview size limit exceeded, changes collapsed.