Merge "msm: Increase start voice command timeout"
diff --git a/Documentation/devicetree/bindings/wcnss/wcnss-wlan.txt b/Documentation/devicetree/bindings/wcnss/wcnss-wlan.txt
index 2cb528c..6ef897a 100644
--- a/Documentation/devicetree/bindings/wcnss/wcnss-wlan.txt
+++ b/Documentation/devicetree/bindings/wcnss/wcnss-wlan.txt
@@ -39,7 +39,7 @@
1200 - WCN XO settling time (usec)
1 - WCN RPM power collapse enabled
1 - WCN standalone power collapse enabled
-
+ 6 - GPIO strength value
Example:
@@ -64,5 +64,5 @@
qcom,has-48mhz-xo;
qcom,has-pronto-hw;
qcom,wcnss-adc_tm = <&pm8226_adc_tm>;
- qcom,wcnss-pm = <11 21 1200 1 1>;
+ qcom,wcnss-pm = <11 21 1200 1 1 6>;
};
diff --git a/arch/arm/mach-msm/msm_rtb.c b/arch/arm/mach-msm/msm_rtb.c
index 28b2195..6a71e36 100644
--- a/arch/arm/mach-msm/msm_rtb.c
+++ b/arch/arm/mach-msm/msm_rtb.c
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2013, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2013-2014, 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
@@ -23,7 +23,7 @@
#include <linux/string.h>
#include <linux/atomic.h>
#include <linux/of.h>
-#include <asm/io.h>
+#include <linux/io.h>
#include <asm-generic/sizes.h>
#include <mach/memory.h>
#include <mach/msm_rtb.h>
@@ -38,18 +38,20 @@
/* Write
* 1) 3 bytes sentinel
* 2) 1 bytes of log type
- * 3) 4 bytes of where the caller came from
+ * 3) 8 bytes of where the caller came from
* 4) 4 bytes index
- * 4) 4 bytes extra data from the caller
+ * 4) 8 bytes extra data from the caller
+ * 5) 8 bytes for timestamp
*
- * Total = 16 bytes.
+ * Total = 32 bytes.
*/
struct msm_rtb_layout {
unsigned char sentinel[3];
unsigned char log_type;
- void *caller;
- unsigned long idx;
- void *data;
+ uint32_t idx;
+ uint64_t caller;
+ uint64_t data;
+ uint64_t timestamp;
} __attribute__ ((__packed__));
@@ -70,7 +72,7 @@
static atomic_t msm_rtb_idx;
#endif
-struct msm_rtb_state msm_rtb = {
+static struct msm_rtb_state msm_rtb = {
.filter = 1 << LOGK_LOGBUF,
.enabled = 1,
};
@@ -109,24 +111,29 @@
start->log_type = (char)log_type;
}
-static void msm_rtb_write_caller(void *caller, struct msm_rtb_layout *start)
+static void msm_rtb_write_caller(uint64_t caller, struct msm_rtb_layout *start)
{
start->caller = caller;
}
-static void msm_rtb_write_idx(unsigned long idx,
+static void msm_rtb_write_idx(uint32_t idx,
struct msm_rtb_layout *start)
{
start->idx = idx;
}
-static void msm_rtb_write_data(void *data, struct msm_rtb_layout *start)
+static void msm_rtb_write_data(uint64_t data, struct msm_rtb_layout *start)
{
start->data = data;
}
-static void uncached_logk_pc_idx(enum logk_event_type log_type, void *caller,
- void *data, int idx)
+static void msm_rtb_write_timestamp(struct msm_rtb_layout *start)
+{
+ start->timestamp = sched_clock();
+}
+
+static void uncached_logk_pc_idx(enum logk_event_type log_type, uint64_t caller,
+ uint64_t data, int idx)
{
struct msm_rtb_layout *start;
@@ -137,6 +144,7 @@
msm_rtb_write_caller(caller, start);
msm_rtb_write_idx(idx, start);
msm_rtb_write_data(data, start);
+ msm_rtb_write_timestamp(start);
mb();
return;
@@ -145,13 +153,10 @@
static void uncached_logk_timestamp(int idx)
{
unsigned long long timestamp;
- void *timestamp_upper, *timestamp_lower;
timestamp = sched_clock();
- timestamp_lower = (void *)lower_32_bits(timestamp);
- timestamp_upper = (void *)upper_32_bits(timestamp);
-
- uncached_logk_pc_idx(LOGK_TIMESTAMP|LOGTYPE_NOPC, timestamp_lower,
- timestamp_upper, idx);
+ uncached_logk_pc_idx(LOGK_TIMESTAMP|LOGTYPE_NOPC,
+ (uint64_t)lower_32_bits(timestamp),
+ (uint64_t)upper_32_bits(timestamp), idx);
}
#if defined(CONFIG_MSM_RTB_SEPARATE_CPUS)
@@ -213,7 +218,8 @@
i = msm_rtb_get_idx();
- uncached_logk_pc_idx(log_type, caller, data, i);
+ uncached_logk_pc_idx(log_type, (uint64_t)((unsigned long) caller),
+ (uint64_t)((unsigned long) data), i);
return 1;
}
@@ -225,7 +231,7 @@
}
EXPORT_SYMBOL(uncached_logk);
-int msm_rtb_probe(struct platform_device *pdev)
+static int msm_rtb_probe(struct platform_device *pdev)
{
struct msm_rtb_platform_data *d = pdev->dev.platform_data;
#if defined(CONFIG_MSM_RTB_SEPARATE_CPUS)
@@ -297,7 +303,6 @@
{.compatible = RTB_COMPAT_STR},
{},
};
-EXPORT_COMPAT(RTB_COMPAT_STR);
static struct platform_driver msm_rtb_driver = {
.driver = {
diff --git a/drivers/gpu/msm/adreno_a3xx_snapshot.c b/drivers/gpu/msm/adreno_a3xx_snapshot.c
index 9f5765d..c8f0101 100644
--- a/drivers/gpu/msm/adreno_a3xx_snapshot.c
+++ b/drivers/gpu/msm/adreno_a3xx_snapshot.c
@@ -463,14 +463,23 @@
size = (adreno_is_a330(adreno_dev) ||
adreno_is_a305b(adreno_dev)) ? 0x2E : 0x14;
- snapshot = kgsl_snapshot_indexed_registers(device, snapshot,
- remain, REG_CP_STATE_DEBUG_INDEX,
- REG_CP_STATE_DEBUG_DATA, 0x0, size);
+ /* Skip indexed register dump for these chipsets 8974, 8x26, 8x10 */
+ if (adreno_is_a330(adreno_dev) ||
+ adreno_is_a330v2(adreno_dev) ||
+ adreno_is_a305b(adreno_dev) ||
+ adreno_is_a305c(adreno_dev) ) {
+ KGSL_DRV_ERR(device,
+ "Skipping indexed register dump\n");
+ } else {
+ snapshot = kgsl_snapshot_indexed_registers(device, snapshot,
+ remain, REG_CP_STATE_DEBUG_INDEX,
+ REG_CP_STATE_DEBUG_DATA, 0x0, size);
- /* CP_ME indexed registers */
- snapshot = kgsl_snapshot_indexed_registers(device, snapshot,
- remain, REG_CP_ME_CNTL, REG_CP_ME_STATUS,
- 64, 44);
+ /* CP_ME indexed registers */
+ snapshot = kgsl_snapshot_indexed_registers(device, snapshot,
+ remain, REG_CP_ME_CNTL, REG_CP_ME_STATUS,
+ 64, 44);
+ }
/* VPC memory */
snapshot = kgsl_snapshot_add_section(device,
@@ -482,10 +491,19 @@
KGSL_SNAPSHOT_SECTION_DEBUG, snapshot, remain,
a3xx_snapshot_cp_meq, NULL);
- /* Shader working/shadow memory */
- snapshot = kgsl_snapshot_add_section(device,
+ /* Skip shader memory dump for these chipsets: 8974, 8x26, 8x10 */
+ if (adreno_is_a330(adreno_dev) ||
+ adreno_is_a330v2(adreno_dev) ||
+ adreno_is_a305b(adreno_dev) ||
+ adreno_is_a305c(adreno_dev) ) {
+ KGSL_DRV_ERR(device,
+ "Skipping shader memory dump\n");
+ } else {
+ /* Shader working/shadow memory */
+ snapshot = kgsl_snapshot_add_section(device,
KGSL_SNAPSHOT_SECTION_DEBUG, snapshot, remain,
a3xx_snapshot_shader_memory, NULL);
+ }
/* CP PFP and PM4 */
diff --git a/drivers/gpu/msm/adreno_dispatch.c b/drivers/gpu/msm/adreno_dispatch.c
index bcab791..d79a169 100644
--- a/drivers/gpu/msm/adreno_dispatch.c
+++ b/drivers/gpu/msm/adreno_dispatch.c
@@ -221,13 +221,17 @@
struct adreno_context *drawctxt, struct kgsl_cmdbatch *cmdbatch)
{
unsigned int prev;
+ struct kgsl_device *device;
spin_lock(&drawctxt->lock);
if (kgsl_context_detached(&drawctxt->base) ||
drawctxt->state == ADRENO_CONTEXT_STATE_INVALID) {
spin_unlock(&drawctxt->lock);
+ device = cmdbatch->device;
/* get rid of this cmdbatch since the context is bad */
+ kgsl_mutex_lock(&device->mutex, &device->mutex_owner);
kgsl_cmdbatch_destroy(cmdbatch);
+ kgsl_mutex_unlock(&device->mutex, &device->mutex_owner);
return -EINVAL;
}
@@ -414,7 +418,10 @@
*/
if (cmdbatch->flags & KGSL_CONTEXT_SYNC) {
+ struct kgsl_device *device = cmdbatch->device;
+ kgsl_mutex_lock(&device->mutex, &device->mutex_owner);
kgsl_cmdbatch_destroy(cmdbatch);
+ kgsl_mutex_unlock(&device->mutex, &device->mutex_owner);
continue;
}
@@ -931,11 +938,8 @@
drawctxt->state == ADRENO_CONTEXT_STATE_INVALID) {
replay[i] = NULL;
- kgsl_mutex_lock(&device->mutex, &device->mutex_owner);
kgsl_cancel_events_timestamp(device, cmd->context,
cmd->timestamp);
- kgsl_mutex_unlock(&device->mutex, &device->mutex_owner);
-
kgsl_cmdbatch_destroy(cmd);
}
}
@@ -1084,7 +1088,8 @@
kgsl_device_snapshot(device, 1);
}
- kgsl_mutex_unlock(&device->mutex, &device->mutex_owner);
+ kgsl_mutex_unlock(&device->mutex, &device->mutex_owner);
+
/* Allocate memory to store the inflight commands */
replay = kzalloc(sizeof(*replay) * dispatcher->inflight, GFP_KERNEL);
@@ -1092,6 +1097,7 @@
if (replay == NULL) {
unsigned int ptr = dispatcher->head;
+ kgsl_mutex_lock(&device->mutex, &device->mutex_owner);
/* Recovery failed - mark everybody guilty */
mark_guilty_context(device, 0);
@@ -1111,6 +1117,7 @@
*/
count = 0;
+ kgsl_mutex_unlock(&device->mutex, &device->mutex_owner);
goto replay;
}
@@ -1168,7 +1175,9 @@
cmdbatch->context->id, cmdbatch->timestamp);
mark_guilty_context(device, cmdbatch->context->id);
+ kgsl_mutex_lock(&device->mutex, &device->mutex_owner);
adreno_drawctxt_invalidate(device, cmdbatch->context);
+ kgsl_mutex_unlock(&device->mutex, &device->mutex_owner);
}
/*
@@ -1277,7 +1286,9 @@
mark_guilty_context(device, cmdbatch->context->id);
/* Invalidate the context */
+ kgsl_mutex_lock(&device->mutex, &device->mutex_owner);
adreno_drawctxt_invalidate(device, cmdbatch->context);
+ kgsl_mutex_unlock(&device->mutex, &device->mutex_owner);
replay:
@@ -1296,8 +1307,10 @@
/* If adreno_reset() fails then what hope do we have for the future? */
BUG_ON(ret);
+ kgsl_mutex_lock(&device->mutex, &device->mutex_owner);
/* Remove any pending command batches that have been invalidated */
remove_invalidated_cmdbatches(device, replay, count);
+ kgsl_mutex_unlock(&device->mutex, &device->mutex_owner);
/* Replay the pending command buffers */
for (i = 0; i < count; i++) {
@@ -1339,9 +1352,11 @@
/* Mark this context as guilty (failed recovery) */
mark_guilty_context(device, replay[i]->context->id);
+ kgsl_mutex_lock(&device->mutex, &device->mutex_owner);
adreno_drawctxt_invalidate(device, replay[i]->context);
remove_invalidated_cmdbatches(device, &replay[i],
count - i);
+ kgsl_mutex_unlock(&device->mutex, &device->mutex_owner);
}
}
@@ -1449,8 +1464,10 @@
dispatcher->head = CMDQUEUE_NEXT(dispatcher->head,
ADRENO_DISPATCH_CMDQUEUE_SIZE);
+ kgsl_mutex_lock(&device->mutex, &device->mutex_owner);
/* Destroy the retired command batch */
kgsl_cmdbatch_destroy(cmdbatch);
+ kgsl_mutex_unlock(&device->mutex, &device->mutex_owner);
/* Update the expire time for the next command batch */
@@ -1695,16 +1712,19 @@
void adreno_dispatcher_close(struct adreno_device *adreno_dev)
{
struct adreno_dispatcher *dispatcher = &adreno_dev->dispatcher;
+ struct kgsl_device *device = &adreno_dev->dev;
mutex_lock(&dispatcher->mutex);
del_timer_sync(&dispatcher->timer);
del_timer_sync(&dispatcher->fault_timer);
+ kgsl_mutex_lock(&device->mutex, &device->mutex_owner);
while (dispatcher->head != dispatcher->tail) {
kgsl_cmdbatch_destroy(dispatcher->cmdqueue[dispatcher->head]);
dispatcher->head = (dispatcher->head + 1)
% ADRENO_DISPATCH_CMDQUEUE_SIZE;
}
+ kgsl_mutex_unlock(&device->mutex, &device->mutex_owner);
mutex_unlock(&dispatcher->mutex);
diff --git a/drivers/gpu/msm/kgsl.c b/drivers/gpu/msm/kgsl.c
index 9adede8..a5b25a0 100644
--- a/drivers/gpu/msm/kgsl.c
+++ b/drivers/gpu/msm/kgsl.c
@@ -1807,16 +1807,13 @@
list_for_each_entry_safe(event, tmp, &cancel_synclist, node) {
if (event->type == KGSL_CMD_SYNCPOINT_TYPE_TIMESTAMP) {
- struct kgsl_device *device = cmdbatch->device;
/*
* Timestamp events are guaranteed to signal
* when canceled
*/
- kgsl_mutex_lock(&device->mutex, &device->mutex_owner);
- kgsl_cancel_event(device, event->context,
+ kgsl_cancel_event(cmdbatch->device, event->context,
event->timestamp, kgsl_cmdbatch_sync_func,
event);
- kgsl_mutex_unlock(&device->mutex, &device->mutex_owner);
} else if (event->type == KGSL_CMD_SYNCPOINT_TYPE_FENCE) {
/* Put events that are successfully canceled */
if (kgsl_sync_fence_async_cancel(event->handle))
@@ -2314,8 +2311,11 @@
* -EPROTO is a "success" error - it just tells the user that the
* context had previously faulted
*/
- if (result && result != -EPROTO)
+ if (result && result != -EPROTO) {
+ kgsl_mutex_lock(&device->mutex, &device->mutex_owner);
kgsl_cmdbatch_destroy(cmdbatch);
+ kgsl_mutex_unlock(&device->mutex, &device->mutex_owner);
+ }
done:
kgsl_context_put(context);
@@ -2366,8 +2366,11 @@
* -EPROTO is a "success" error - it just tells the user that the
* context had previously faulted
*/
- if (result && result != -EPROTO)
+ if (result && result != -EPROTO) {
+ kgsl_mutex_lock(&device->mutex, &device->mutex_owner);
kgsl_cmdbatch_destroy(cmdbatch);
+ kgsl_mutex_unlock(&device->mutex, &device->mutex_owner);
+ }
done:
kgsl_context_put(context);
diff --git a/drivers/media/platform/msm/camera_v2/sensor/cci/msm_cci.c b/drivers/media/platform/msm/camera_v2/sensor/cci/msm_cci.c
index 270fb38..e5d82fd 100644
--- a/drivers/media/platform/msm/camera_v2/sensor/cci/msm_cci.c
+++ b/drivers/media/platform/msm/camera_v2/sensor/cci/msm_cci.c
@@ -211,13 +211,23 @@
pr_err("%s failed line %d\n", __func__, __LINE__);
return -EINVAL;
}
- /* assume total size within the max queue */
+
+ reg_addr = i2c_cmd->reg_addr;
while (cmd_size) {
- CDBG("%s cmd_size %d addr 0x%x data 0x%x", __func__,
+ CDBG("%s cmd_size %d addr 0x%x data 0x%x\n", __func__,
cmd_size, i2c_cmd->reg_addr, i2c_cmd->reg_data);
delay = i2c_cmd->delay;
data[i++] = CCI_I2C_WRITE_CMD;
- reg_addr = i2c_cmd->reg_addr;
+
+ /* in case of multiple command
+ * MSM_CCI_I2C_WRITE : address is not continuous, so update
+ * address for a new packet.
+ * MSM_CCI_I2C_WRITE_SEQ : address is continuous, need to keep
+ * the incremented address for a
+ * new packet */
+ if (c_ctrl->cmd == MSM_CCI_I2C_WRITE)
+ reg_addr = i2c_cmd->reg_addr;
+
/* either byte or word addr */
if (i2c_msg->addr_type == MSM_CAMERA_I2C_BYTE_ADDR)
data[i++] = reg_addr;
@@ -226,21 +236,25 @@
data[i++] = reg_addr & 0x00FF;
}
/* max of 10 data bytes */
- if (i2c_msg->data_type == MSM_CAMERA_I2C_BYTE_DATA) {
- data[i++] = i2c_cmd->reg_data;
- reg_addr++;
- } else {
- if ((i + 1) <= 10) {
- data[i++] = (i2c_cmd->reg_data &
- 0xFF00) >> 8; /* MSB */
- data[i++] = i2c_cmd->reg_data &
- 0x00FF; /* LSB */
- reg_addr += 2;
- } else
- break;
- }
- i2c_cmd++;
- --cmd_size;
+ do {
+ if (i2c_msg->data_type == MSM_CAMERA_I2C_BYTE_DATA) {
+ data[i++] = i2c_cmd->reg_data;
+ reg_addr++;
+ } else {
+ if ((i + 1) <= 10) {
+ data[i++] = (i2c_cmd->reg_data &
+ 0xFF00) >> 8; /* MSB */
+ data[i++] = i2c_cmd->reg_data &
+ 0x00FF; /* LSB */
+ reg_addr += 2;
+ } else
+ break;
+ }
+ i2c_cmd++;
+ --cmd_size;
+ } while ((c_ctrl->cmd == MSM_CCI_I2C_WRITE_SEQ) &&
+ (cmd_size > 0) && (i <= 10));
+
data[0] |= ((i-1) << 4);
len = ((i-1)/4) + 1;
rc = msm_cci_validate_queue(cci_dev, len, master, queue);
@@ -789,6 +803,7 @@
rc = msm_cci_i2c_read_bytes(sd, cci_ctrl);
break;
case MSM_CCI_I2C_WRITE:
+ case MSM_CCI_I2C_WRITE_SEQ:
rc = msm_cci_i2c_write(sd, cci_ctrl);
break;
case MSM_CCI_GPIO_WRITE:
diff --git a/drivers/media/platform/msm/camera_v2/sensor/cci/msm_cci.h b/drivers/media/platform/msm/camera_v2/sensor/cci/msm_cci.h
index 44c134e..283bd28 100644
--- a/drivers/media/platform/msm/camera_v2/sensor/cci/msm_cci.h
+++ b/drivers/media/platform/msm/camera_v2/sensor/cci/msm_cci.h
@@ -53,6 +53,7 @@
MSM_CCI_SET_SYNC_CID,
MSM_CCI_I2C_READ,
MSM_CCI_I2C_WRITE,
+ MSM_CCI_I2C_WRITE_SEQ,
MSM_CCI_GPIO_WRITE,
};
diff --git a/drivers/media/platform/msm/camera_v2/sensor/io/msm_camera_cci_i2c.c b/drivers/media/platform/msm/camera_v2/sensor/io/msm_camera_cci_i2c.c
index 8d9274b..6af0cea 100644
--- a/drivers/media/platform/msm/camera_v2/sensor/io/msm_camera_cci_i2c.c
+++ b/drivers/media/platform/msm/camera_v2/sensor/io/msm_camera_cci_i2c.c
@@ -158,7 +158,7 @@
reg_conf_tbl[i].reg_data = data[i];
reg_conf_tbl[i].delay = 0;
}
- cci_ctrl.cmd = MSM_CCI_I2C_WRITE;
+ cci_ctrl.cmd = MSM_CCI_I2C_WRITE_SEQ;
cci_ctrl.cci_info = client->cci_client;
cci_ctrl.cfg.cci_i2c_write_cfg.reg_setting = reg_conf_tbl;
cci_ctrl.cfg.cci_i2c_write_cfg.data_type = MSM_CAMERA_I2C_BYTE_DATA;
diff --git a/drivers/misc/qseecom.c b/drivers/misc/qseecom.c
index 276a6dc..399cea9 100644
--- a/drivers/misc/qseecom.c
+++ b/drivers/misc/qseecom.c
@@ -1115,8 +1115,8 @@
bool found_dead_app = false;
if (!memcmp(data->client.app_name, "keymaste", strlen("keymaste"))) {
- pr_warn("Do not unload keymaster app from tz\n");
- return 0;
+ pr_debug("Do not unload keymaster app from tz\n");
+ goto unload_exit;
}
if (data->client.app_id > 0) {
@@ -1211,6 +1211,7 @@
spin_unlock_irqrestore(&qseecom.registered_app_list_lock,
flags1);
}
+unload_exit:
qseecom_unmap_ion_allocated_memory(data);
data->released = true;
return ret;
diff --git a/drivers/net/wireless/wcnss/wcnss_wlan.c b/drivers/net/wireless/wcnss/wcnss_wlan.c
index 4a4a88c..887bb72 100644
--- a/drivers/net/wireless/wcnss/wcnss_wlan.c
+++ b/drivers/net/wireless/wcnss/wcnss_wlan.c
@@ -1948,13 +1948,13 @@
return;
}
- pr_debug("%s:size=%d: <%d, %d, %d, %d, %d>\n", __func__,
+ pr_debug("%s:size=%d: <%d, %d, %d, %d, %d %d>\n", __func__,
prop_len, *payload, *(payload+1), *(payload+2),
- *(payload+3), *(payload+4));
+ *(payload+3), *(payload+4), *(payload+5));
hdr = (struct smd_msg_hdr *)msg;
hdr->msg_type = WCNSS_PM_CONFIG_REQ;
- hdr->msg_len = sizeof(struct smd_msg_hdr) + prop_len;
+ hdr->msg_len = sizeof(struct smd_msg_hdr) + (prop_len * sizeof(int));
rc = wcnss_smd_tx(msg, hdr->msg_len);
if (rc < 0)
diff --git a/drivers/nfc/nfc-nci.c b/drivers/nfc/nfc-nci.c
index 9ba0a87..b1681f1 100644
--- a/drivers/nfc/nfc-nci.c
+++ b/drivers/nfc/nfc-nci.c
@@ -61,7 +61,7 @@
#define CORE_RESET_RSP_GID (0x60)
#define CORE_RESET_OID (0x00)
#define CORE_RST_NTF_LENGTH (0x02)
-#define WAKE_TIMEOUT (10)
+#define WAKE_TIMEOUT (1000)
#define WAKE_REG (0x10)
#define EFUSE_REG (0xA0)
#define WAKEUP_SRC_TIMEOUT (2000)
@@ -101,6 +101,8 @@
struct workqueue_struct *my_wq;
};
+static int nfcc_reboot(struct notifier_block *notifier, unsigned long val,
+ void *v);
static int nfc_i2c_write(struct i2c_client *client, u8 *buf, int len);
static int nfcc_hw_check(struct i2c_client *client, unsigned short curr_addr);
static int nfcc_initialise(struct i2c_client *client, unsigned short curr_addr,
@@ -124,7 +126,7 @@
unsigned int disable_ctrl;
-bool region2_sent;
+bool region2_sent;
static void qca199x_init_stat(struct qca199x_dev *qca199x_dev)
{
@@ -163,15 +165,16 @@
if (device_may_wakeup(&qca199x_dev->client->dev) &&
(qca199x_dev->client->dev.power.is_suspended == true)) {
dev_dbg(&qca199x_dev->client->dev,
- "NFC:Processor in suspend state device_may_wakeup\n");
+ "%s: NFC:Processor in suspend state device_may_wakeup\n",
+ __func__);
/*
- * Keep system awake long enough to allow userspace
- * to process the packet.
- */
+ * Keep system awake long enough to allow userspace
+ * to process the packet.
+ */
pm_wakeup_event(&qca199x_dev->client->dev, WAKEUP_SRC_TIMEOUT);
} else {
dev_dbg(&qca199x_dev->client->dev,
- "NFC:Processor not in suspend state\n");
+ "%s: NFC:Processor not in suspend state\n", __func__);
}
spin_lock_irqsave(&qca199x_dev->irq_enabled_lock, flags);
@@ -329,7 +332,12 @@
/* READ */
if ((ftm_raw_write_mode == 0) && (ftm_werr_code == 0)) {
ftm_rerr_code = i2c_master_recv(qca199x_dev->client,
- &rd_byte, 1);
+ &rd_byte, sizeof(rd_byte));
+
+ if (ftm_rerr_code != sizeof(rd_byte)) {
+ total = -EMSGSIZE;
+ goto err;
+ }
if (ftm_rerr_code == 0x1)
ftm_rerr_code = 0;
tmp[0] = (unsigned char)ftm_rerr_code;
@@ -388,8 +396,8 @@
if (total > 0) {
if ((total > count) || copy_to_user(buf, tmp, total)) {
dev_err(&qca199x_dev->client->dev,
- "failed to copy to user space, total = %d\n",
- total);
+ "%s: failed to copy to user space, total = %d\n",
+ __func__, total);
total = -EFAULT;
}
}
@@ -438,6 +446,9 @@
ret = i2c_master_recv(qca199x_dev->client, tmp, (length +
PAYLOAD_HEADER_LENGTH));
total = ret;
+ if (ret != (length + PAYLOAD_HEADER_LENGTH))
+ goto leave;
+
}
dev_dbg(&qca199x_dev->client->dev, "%s : NfcNciRx %x %x %x\n",
__func__, tmp[0], tmp[1], tmp[2]);
@@ -456,12 +467,13 @@
int nfcc_buffer = 0;
if (count > MAX_BUFFER_SIZE) {
- dev_err(&qca199x_dev->client->dev, "out of memory\n");
+ dev_err(&qca199x_dev->client->dev, "%s: out of memory\n",
+ __func__);
return -ENOMEM;
}
if (copy_from_user(tmp, buf, count)) {
dev_err(&qca199x_dev->client->dev,
- "nfc-nci write: failed to copy from user space\n");
+ "%s: failed to copy from user space\n", __func__);
return -EFAULT;
}
/*
@@ -477,7 +489,8 @@
/* There has been an error while reading from nfcc */
if (nfcc_buffer < 0) {
dev_err(&qca199x_dev->client->dev,
- "nfc-nci write: error while servicing nfcc read buffer\n");
+ "%s: error while servicing nfcc read buffer\n"
+ , __func__);
}
qca199x_dev->sent_first_nci_write = true;
qca199x_enable_irq(qca199x_dev);
@@ -492,7 +505,7 @@
if (count == 1) {
ftm_raw_write_mode = 0;
ret = i2c_master_send(qca199x_dev->client, tmp, count);
- if (ret == 1)
+ if (ret == count)
ftm_werr_code = 0;
else
ftm_werr_code = ret;
@@ -502,7 +515,7 @@
if (count == 2) {
ftm_raw_write_mode = 1;
ret = i2c_master_send(qca199x_dev->client, tmp, count);
- if (ret == 2)
+ if (ret == count)
ftm_werr_code = 0;
else
ftm_werr_code = ret;
@@ -515,7 +528,7 @@
}
if (ret != count) {
dev_err(&qca199x_dev->client->dev,
- "NFC: failed to write %d\n", ret);
+ "%s: failed to write %d\n", __func__, ret);
ret = -EIO;
}
mutex_unlock(&qca199x_dev->read_mutex);
@@ -549,7 +562,7 @@
qca199x_enable_irq_clk_req(qca199x_dev);
}
dev_dbg(&qca199x_dev->client->dev,
- "%d,%d\n", imajor(inode), iminor(inode));
+ "%s: %d,%d\n", __func__, imajor(inode), iminor(inode));
return ret;
}
@@ -561,17 +574,21 @@
int r = 0;
int time_taken = 0;
unsigned char raw_nci_sleep[] = {0x2F, 0x03, 0x00};
- /* Change slave address to 0xE */
unsigned char raw_nci_wake[] = {0x10, 0x0F};
- unsigned short slave_addr = 0xE;
+ /* Change slave address to 0xE */
+ unsigned short slave_addr = 0xE;
unsigned short curr_addr;
- unsigned char wake_status = WAKE_REG;
+ unsigned char wake_status = WAKE_REG;
struct qca199x_dev *qca199x_dev = filp->private_data;
- dev_dbg(&qca199x_dev->client->dev, "nfcc_wake: %s: info: %p\n",
+ dev_dbg(&qca199x_dev->client->dev, "%s: info: %p\n",
__func__, qca199x_dev);
+ curr_addr = qca199x_dev->client->addr;
if (level == NFCC_SLEEP) {
+ /*
+ * Normal NCI write
+ */
r = i2c_master_send(qca199x_dev->client, &raw_nci_sleep[0],
sizeof(raw_nci_sleep));
@@ -579,57 +596,79 @@
return -EMSGSIZE;
qca199x_dev->state = NFCC_STATE_NORMAL_SLEEP;
} else {
- curr_addr = qca199x_dev->client->addr;
qca199x_dev->client->addr = slave_addr;
r = nfc_i2c_write(qca199x_dev->client, &raw_nci_wake[0],
sizeof(raw_nci_wake));
+ if (r != sizeof(raw_nci_wake)) {
+ r = -EMSGSIZE;
+ dev_err(&qca199x_dev->client->dev,
+ "%s: nci wake write failed. Check hardware\n",
+ __func__);
+ goto leave;
+ }
do {
wake_status = WAKE_REG;
- r = nfc_i2c_write(qca199x_dev->client, &wake_status, 1);
+ r = nfc_i2c_write(qca199x_dev->client, &wake_status,
+ sizeof(wake_status));
+ if (r != sizeof(wake_status)) {
+ r = -EMSGSIZE;
+ dev_err(&qca199x_dev->client->dev,
+ "%s: wake status write fail.Check hardware\n",
+ __func__);
+ goto leave;
+ }
/*
- * NFCC chip needs to be at least
- * 10usec high before make it low
+ * I2C line is low after ~10 usec
*/
usleep_range(10, 15);
r = i2c_master_recv(qca199x_dev->client, &wake_status,
sizeof(wake_status));
+ if (r != sizeof(wake_status)) {
+ r = -EMSGSIZE;
+ dev_err(&qca199x_dev->client->dev,
+ "%s: wake status read fail.Check hardware\n",
+ __func__);
+ goto leave;
+ }
time_taken++;
+ /*
+ * Each NFCC wakeup cycle
+ * takes about 0.5 ms
+ */
if ((wake_status & NCI_WAKE) != 0)
/* NFCC wakeup time is between 0.5 and .52 ms */
- usleep_range(500, 520);
+ usleep_range(500, 550);
} while ((wake_status & NCI_WAKE)
&& (time_taken < WAKE_TIMEOUT));
- /* Restore original NFCC slave I2C address */
-
- qca199x_dev->client->addr = curr_addr;
- if (r != sizeof(wake_status))
- return -EMSGSIZE;
-
if (time_taken >= WAKE_TIMEOUT) {
dev_err(&qca199x_dev->client->dev,
- " %s : TIMED OUT to get WAKEUP bit\n", __func__);
+ "%s: timed out to get wakeup bit\n", __func__);
r = -EIO;
+ goto leave;
}
+ r = 0;
qca199x_dev->state = NFCC_STATE_NORMAL_WAKE;
}
-
+leave:
+ /* Restore original NFCC slave I2C address */
+ qca199x_dev->client->addr = curr_addr;
return r;
}
/*
* Inside nfc_ioctl_power_states
*
- * @brief ioctl functions
+ * @brief ioctl functions
*
*
* Device control
* remove control via ioctl
- * (arg = 0): NFC_DISABLE GPIO = 0
- * (arg = 1): NFC_DISABLE GPIO = 1
- * NOT USED (arg = 2): FW_DL GPIO = 0
- * NOT USED (arg = 3): FW_DL GPIO = 1
+ * (arg = 0): NFC_DISABLE GPIO = 0
+ * (arg = 1): NFC_DISABLE GPIO = 1
+ * NOT USED (arg = 2): FW_DL GPIO = 0
+ * NOT USED (arg = 3): FW_DL GPIO = 1
* (arg = 4): NFCC_WAKE = 1
* (arg = 5): NFCC_WAKE = 0
*
@@ -648,7 +687,7 @@
dev_dbg(&qca199x_dev->client->dev, "gpio_set_value disable: %s: info: %p\n",
__func__, qca199x_dev);
gpio_set_value(qca199x_dev->dis_gpio, 0);
- usleep(1000);
+ usleep_range(1000, 1100);
} else if (arg == 1) {
/*
* We are attempting a hardware reset so let us disable
@@ -670,7 +709,7 @@
dev_dbg(&qca199x_dev->client->dev, "gpio_set_value enable: %s: info: %p\n",
__func__, qca199x_dev);
gpio_set_value(qca199x_dev->dis_gpio, 1);
- /*nfcc needs atleast 100ms for the chip to power cycle*/
+ /* NFCC needs at least 100 ms to power cycle*/
msleep(100);
} else if (arg == 2) {
mutex_lock(&qca199x_dev->read_mutex);
@@ -708,14 +747,14 @@
/*
* Inside nfc_ioctl_nfcc_mode
*
- * @brief nfc_ioctl_nfcc_mode
+ * @brief nfc_ioctl_nfcc_mode
*
* (arg = 0) ; NORMAL_MODE - Standard mode, unsolicited read behaviour
* (arg = 1) ; SOLICITED_MODE - As above but reads are solicited from User Land
* (arg = 2) ; UNSOLICITED_FTM_RAW MODE - NORMAL_MODE but messages from FTM and
- * not NCI Host.
+ * not NCI Host.
* (arg = 2) ; SOLICITED_FTM_RAW_MODE - As SOLICITED_MODE but messages from FTM
- * and not NCI Host.
+ * and not NCI Host.
*
*
*
@@ -762,6 +801,61 @@
}
/*
+ * Inside nfc_ioctl_nfcc_efuse
+ *
+ * @brief nfc_ioctl_nfcc_efuse
+ *
+ *
+ */
+int nfc_ioctl_nfcc_efuse(struct file *filp, unsigned int cmd,
+ unsigned long arg)
+{
+ int r = 0;
+ unsigned short slave_addr = 0xE;
+ unsigned short curr_addr;
+ unsigned char efuse_addr = EFUSE_REG;
+ unsigned char efuse_value = 0xFF;
+
+ struct qca199x_dev *qca199x_dev = filp->private_data;
+
+ curr_addr = qca199x_dev->client->addr;
+ qca199x_dev->client->addr = slave_addr;
+
+ r = nfc_i2c_write(qca199x_dev->client,
+ &efuse_addr, 1);
+ if (r < 0) {
+ /* Restore original NFCC slave I2C address */
+ qca199x_dev->client->addr = curr_addr;
+ dev_err(&qca199x_dev->client->dev,
+ "ERROR_WRITE_FAIL : i2c write fail\n");
+ return -EIO;
+ }
+
+ /*
+ * NFCC chip needs to be at least
+ * 10usec high before make it low
+ */
+ usleep_range(10, 15);
+
+ r = i2c_master_recv(qca199x_dev->client, &efuse_value,
+ sizeof(efuse_value));
+ if (r < 0) {
+ /* Restore original NFCC slave I2C address */
+ qca199x_dev->client->addr = curr_addr;
+ dev_err(&qca199x_dev->client->dev,
+ "ERROR_I2C_RCV_FAIL : i2c recv fail\n");
+ return -EIO;
+ }
+
+ dev_dbg(&qca199x_dev->client->dev, "%s : EFUSE_VALUE %02x\n",
+ __func__, efuse_value);
+
+ /* Restore original NFCC slave I2C address */
+ qca199x_dev->client->addr = curr_addr;
+ return efuse_value;
+}
+
+/*
* Inside nfc_ioctl_nfcc_version
*
* @brief nfc_ioctl_nfcc_version
@@ -772,11 +866,8 @@
unsigned long arg)
{
int r = 0;
- int time_taken = 0;
- unsigned short slave_addr = 0xE;
+ unsigned short slave_addr = 0xE;
unsigned short curr_addr;
- unsigned char raw_nci_wake[] = {0x10, 0x0F};
- unsigned char raw_nci_read;
unsigned char raw_chip_version_addr = 0x00;
unsigned char raw_chip_rev_id_addr = 0x9C;
unsigned char raw_chip_version = 0xFF;
@@ -790,88 +881,56 @@
* Always wake up chip when reading 0x9C, otherwise this
* register is not updated
*/
+ r = nfcc_wake(NFCC_WAKE, filp);
curr_addr = qca199x_dev->client->addr;
qca199x_dev->client->addr = slave_addr;
- r = nfc_i2c_write(qca199x_dev->client, &raw_nci_wake[0],
- sizeof(raw_nci_wake));
- if (r != sizeof(raw_nci_wake))
+
+ if (r) {
dev_err(&qca199x_dev->client->dev,
- "nfc_ioctl_nfcc_version : failed to send wake command\n");
-
- /*
- * After placing the NFCC to sleep by a PROP
- * SLEEP NCI msg (2F 03) and we need to wake
- * it back up to obtain some information (by
- * setting the wake bit).We need to determine
- * when it has in actual fact woken before we
- * can read the required data. We do that by
- * reading back & testing if that wake bit has
- * been cleared.
- */
- do {
- raw_nci_read = 0x10;
- r = nfc_i2c_write(qca199x_dev->client, &raw_nci_read, 1);
- /*
- * NFCC chip needs to be at least
- * 10usec high before make it low
- */
- usleep_range(10, 15);
-
- r = i2c_master_recv(qca199x_dev->client, &raw_nci_read,
- sizeof(raw_nci_read));
-
- if ((raw_nci_read & NCI_WAKE) != 0)
- /* NFCC wakeup time is between 0.5 and .52 ms */
- usleep_range(500, 520);
-
- time_taken++;
-
- } while ((raw_nci_read & NCI_WAKE)
- && (time_taken < WAKE_TIMEOUT));
-
- if (time_taken < WAKE_TIMEOUT)
- qca199x_dev->state = NFCC_STATE_NORMAL_WAKE;
- else
- dev_err(&qca199x_dev->client->dev,
- "nfc_ioctl_nfcc_version : TIMED OUT to get WAKEUP bit\n");
-
-
- if (r != 1) {
- /*
- * r < 0 indicates an error, maybe chip isn't
- * up yet.What should we do??? r = 0 indicates
- * nothing read, maybe chip isn't up yet. (should
- * not happen) r > 1 indicates too many bytes read,
- * maybe ?(should not happen)
- */
- dev_err(&qca199x_dev->client->dev,
- "nfc_ioctl_nfcc_version : i2c error %d\n", r);
+ "%s: nfcc wake failed: %d\n", __func__, r);
+ r = -EIO;
+ goto leave;
}
if (arg == 0) {
r = nfc_i2c_write(qca199x_dev->client,
- &raw_chip_version_addr, 1);
+ &raw_chip_version_addr, sizeof(raw_chip_version_addr));
+ if (r != sizeof(raw_chip_version_addr)) {
+ r = -EMSGSIZE;
+ goto err;
+ }
} else if (arg == 1) {
r = nfc_i2c_write(qca199x_dev->client,
- &raw_chip_rev_id_addr, 1);
+ &raw_chip_rev_id_addr, sizeof(raw_chip_rev_id_addr));
+ if (r != sizeof(raw_chip_version_addr)) {
+ r = -EMSGSIZE;
+ goto err;
+ }
} else {
- /* Restore original NFCC slave I2C address */
- qca199x_dev->client->addr = curr_addr;
- return -EINVAL;
+ r = -EINVAL;
+ goto err;
}
if (r < 0) {
- /* Restore original NFCC slave I2C address */
- qca199x_dev->client->addr = curr_addr;
- dev_err(&qca199x_dev->client->dev,
- "NFCC_INVALID_CHIP_VERSION : i2c write fail\n");
- return -EIO;
+ r = -EIO;
+ goto err;
}
-
- usleep(10);
- r = i2c_master_recv(qca199x_dev->client, &raw_chip_version, 1);
-
+ /*
+ * I2C line is low after ~10 usec
+ */
+ usleep_range(10, 15);
+ r = i2c_master_recv(qca199x_dev->client, &raw_chip_version,
+ sizeof(raw_chip_version));
+ if (r != sizeof(raw_chip_version)) {
+ r = -EMSGSIZE;
+ goto err;
+ }
+ goto leave;
+err:
+ dev_err(&qca199x_dev->client->dev,
+ "%s: i2c access failed\n", __func__);
+leave:
/* Restore original NFCC slave I2C address */
qca199x_dev->client->addr = curr_addr;
return raw_chip_version;
@@ -880,12 +939,12 @@
/*
* Inside nfc_ioctl_kernel_logging
*
- * @brief nfc_ioctl_kernel_logging
+ * @brief nfc_ioctl_kernel_logging
*
* (arg = 0) ; NO_LOGGING
* (arg = 1) ; COMMS_LOGGING - BASIC LOGGING - Mainly just comms over I2C
* (arg = 2) ; FULL_LOGGING - ENABLE ALL - DBG messages for handlers etc.
- * ; ! Be aware as amount of logging could impact behaviour !
+ * ; ! Be aware as amount of logging could impact behaviour !
*
*
*/
@@ -893,19 +952,19 @@
{
int retval = 0;
struct qca199x_dev *qca199x_dev = container_of(filp->private_data,
- struct qca199x_dev,
- qca199x_device);
+ struct qca199x_dev,
+ qca199x_device);
if (arg == 0) {
dev_dbg(&qca199x_dev->client->dev,
- "nfc_ioctl_kernel_logging : level = NO_LOGGING\n");
+ "%s : level = NO_LOGGING\n", __func__);
logging_level = 0;
} else if (arg == 1) {
dev_dbg(&qca199x_dev->client->dev,
- "nfc_ioctl_kernel_logging: level = COMMS_LOGGING only\n");
+ "%s: level = COMMS_LOGGING only\n", __func__);
logging_level = 1;
} else if (arg == 2) {
dev_dbg(&qca199x_dev->client->dev,
- "nfc_ioctl_kernel_logging: level = FULL_LOGGING\n");
+ "%s: level = FULL_LOGGING\n", __func__);
logging_level = 2;
}
return retval;
@@ -914,7 +973,7 @@
/*
* Inside nfc_ioctl_core_reset_ntf
*
- * @brief nfc_ioctl_core_reset_ntf
+ * @brief nfc_ioctl_core_reset_ntf
*
* Allows callers to determine if a CORE_RESET_NTF has arrived
*
@@ -926,22 +985,23 @@
{
struct qca199x_dev *qca199x_dev = filp->private_data;
dev_dbg(&qca199x_dev->client->dev,
- "nfc_ioctl_core_reset_ntf: returning = %d\n",
+ "%s: returning = %d\n",
+ __func__,
qca199x_dev->core_reset_ntf);
return qca199x_dev->core_reset_ntf;
}
-static long nfc_ioctl(struct file *pfile, unsigned int cmd, unsigned long arg)
+static long nfc_ioctl(struct file *pfile, unsigned int cmd,
+ unsigned long arg)
{
int r = 0;
-
+ struct qca199x_dev *qca199x_dev = pfile->private_data;
switch (cmd) {
-
case NFC_SET_PWR:
r = nfc_ioctl_power_states(pfile, cmd, arg);
break;
case NFCC_MODE:
- nfc_ioctl_nfcc_mode(pfile, cmd, arg);
+ r = nfc_ioctl_nfcc_mode(pfile, cmd, arg);
break;
case NFCC_VERSION:
r = nfc_ioctl_nfcc_version(pfile, cmd, arg);
@@ -956,6 +1016,14 @@
case NFCC_INITIAL_CORE_RESET_NTF:
r = nfc_ioctl_core_reset_ntf(pfile, cmd, arg);
break;
+ case NFC_GET_EFUSE:
+ r = nfc_ioctl_nfcc_efuse(pfile, cmd, arg);
+ if (r < 0) {
+ r = 0xFF;
+ dev_err(&qca199x_dev->client->dev,
+ "nfc_ioctl : FAILED TO READ EFUSE TYPE\n");
+ }
+ break;
default:
r = -ENOIOCTLCMD;
}
@@ -988,9 +1056,15 @@
((i > 0xF) && (i < 0x12)) || ((i > 0x39) && (i < 0x4d)) ||
((i > 0x69) && (i < 0x74)) || (i == 0x18) || (i == 0x30) ||
(i == 0x58)) {
- r = nfc_i2c_write(client, &raw_reg_rd, 1);
+ r = nfc_i2c_write(client, &raw_reg_rd,
+ sizeof(raw_reg_rd));
+ if (r != sizeof(raw_reg_rd))
+ break;
msleep(20);
- r = i2c_master_recv(client, &raw_reg_rd, 1);
+ r = i2c_master_recv(client, &raw_reg_rd,
+ sizeof(raw_reg_rd));
+ if (r != sizeof(raw_reg_rd))
+ break;
}
}
client->addr = temp_addr;
@@ -1001,11 +1075,11 @@
int r;
r = i2c_master_send(client, buf, len);
- dev_dbg(&client->dev, "send: %d\n", r);
+ dev_dbg(&client->dev, "%s: send: %d\n", __func__, r);
if (r == -EREMOTEIO) { /* Retry, chip was in standby */
usleep_range(6000, 10000);
r = i2c_master_send(client, buf, len);
- dev_dbg(&client->dev, "send2: %d\n", r);
+ dev_dbg(&client->dev, "%s: send attempt 2: %d\n", __func__, r);
}
if (r != len)
return -EREMOTEIO;
@@ -1021,22 +1095,23 @@
client->addr = curr_addr;
/* Set-up Addr 0. No data written */
- r = i2c_master_send(client, &buf, 1);
+ r = i2c_master_send(client, &buf, sizeof(buf));
if (r < 0)
goto err_presence_check;
buf = 0;
/* Read back from Addr 0 */
- r = i2c_master_recv(client, &buf, 1);
+ r = i2c_master_recv(client, &buf, sizeof(buf));
if (r < 0)
goto err_presence_check;
r = 0;
- return r;
+ goto leave;
err_presence_check:
r = -ENXIO;
dev_err(&client->dev,
- "nfc-nci nfcc_presence check - no NFCC available\n");
+ "%s: - no NFCC available\n", __func__);
+leave:
return r;
}
/* Initialise qca199x_ NFC controller hardware */
@@ -1044,7 +1119,7 @@
struct qca199x_dev *qca199x_dev)
{
int r = 0;
- unsigned char raw_1p8_CONTROL_011[] = {0x11, XTAL_CLOCK};
+ unsigned char raw_1P8_CONTROL_011[] = {0x11, XTAL_CLOCK};
unsigned char raw_1P8_CONTROL_010[] = {0x10, PWR_EN};
unsigned char raw_1P8_X0_0B0[] = {0xB0, (FREQ_SEL)};
unsigned char raw_slave1[] = {0x09, NCI_I2C_SLAVE};
@@ -1061,12 +1136,17 @@
client->addr = curr_addr;
qca199x_dev->core_reset_ntf = DEFAULT_INITIAL_CORE_RESET_NTF;
- r = i2c_master_send(client, &buf, 1);
+ r = i2c_master_send(client, &buf, sizeof(buf));
if (r < 0)
goto err_init;
+ /*
+ * I2C line is low after ~10 usec
+ */
+ usleep_range(10, 15);
+
buf = 0;
- r = i2c_master_recv(client, &buf, 1);
+ r = i2c_master_recv(client, &buf, sizeof(buf));
if (r < 0)
goto err_init;
@@ -1076,36 +1156,37 @@
if (r < 0)
goto err_init;
- usleep(1000);
- RAW(1p8_CONTROL_011, XTAL_CLOCK | 0x01);
+ usleep_range(1000, 1100);
- r = nfc_i2c_write(client, &raw_1p8_CONTROL_011[0],
- sizeof(raw_1p8_CONTROL_011));
+ RAW(1P8_CONTROL_011, XTAL_CLOCK | 0x01);
+
+ r = nfc_i2c_write(client, &raw_1P8_CONTROL_011[0],
+ sizeof(raw_1P8_CONTROL_011));
if (r < 0)
goto err_init;
- usleep(1000);
+ usleep_range(1000, 1100); /* 1 ms wait */
RAW(1P8_CONTROL_010, (0x8));
r = nfc_i2c_write(client, &raw_1P8_CONTROL_010[0],
sizeof(raw_1P8_CONTROL_010));
if (r < 0)
goto err_init;
- usleep(10000); /* 10ms wait */
+ usleep_range(10000, 11000); /* 10 ms wait */
RAW(1P8_CONTROL_010, (0xC));
r = nfc_i2c_write(client, &raw_1P8_CONTROL_010[0],
sizeof(raw_1P8_CONTROL_010));
if (r < 0)
goto err_init;
- usleep(100); /* 100uS wait */
+ usleep_range(100, 110); /* 100 us wait */
RAW(1P8_X0_0B0, (FREQ_SEL_19));
r = nfc_i2c_write(client, &raw_1P8_X0_0B0[0],
sizeof(raw_1P8_X0_0B0));
if (r < 0)
goto err_init;
- usleep(1000);
+ usleep_range(1000, 1100); /* 1 ms wait */
/* PWR_EN = 1 */
RAW(1P8_CONTROL_010, (0xd));
@@ -1115,7 +1196,7 @@
goto err_init;
- usleep(20000); /* 20ms wait */
+ msleep(20); /* 20ms wait */
/* LS_EN = 1 */
RAW(1P8_CONTROL_010, 0xF);
r = nfc_i2c_write(client, &raw_1P8_CONTROL_010[0],
@@ -1123,41 +1204,43 @@
if (r < 0)
goto err_init;
- usleep(20000); /* 20ms wait */
+ msleep(20); /* 20ms wait */
/* Enable the PMIC clock */
RAW(1P8_PAD_CFG_CLK_REQ, (0x1));
r = nfc_i2c_write(client, &raw_1P8_PAD_CFG_CLK_REQ[0],
- sizeof(raw_1P8_PAD_CFG_CLK_REQ));
+ sizeof(raw_1P8_PAD_CFG_CLK_REQ));
if (r < 0)
goto err_init;
- usleep(1000);
+ usleep_range(1000, 1100); /* 1 ms wait */
RAW(1P8_PAD_CFG_PWR_REQ, (0x1));
r = nfc_i2c_write(client, &raw_1P8_PAD_CFG_PWR_REQ[0],
- sizeof(raw_1P8_PAD_CFG_PWR_REQ));
+ sizeof(raw_1P8_PAD_CFG_PWR_REQ));
if (r < 0)
goto err_init;
- usleep(1000);
+ usleep_range(1000, 1100); /* 1 ms wait */
RAW(slave2, 0x10);
r = nfc_i2c_write(client, &raw_slave2[0], sizeof(raw_slave2));
if (r < 0)
goto err_init;
- usleep(1000);
+ usleep_range(1000, 1100); /* 1 ms wait */
RAW(slave1, NCI_I2C_SLAVE);
r = nfc_i2c_write(client, &raw_slave1[0], sizeof(raw_slave1));
if (r < 0)
goto err_init;
- usleep(1000);
+ usleep_range(1000, 1100); /* 1 ms wait */
/* QCA199x NFCC CPU should now boot... */
- r = i2c_master_recv(client, &raw_slave1_rd, 1);
+ r = i2c_master_recv(client, &raw_slave1_rd, sizeof(raw_slave1_rd));
+ if (r < 0)
+ goto err_init;
/* Talk on NCI slave address NCI_I2C_SLAVE 0x2C*/
client->addr = NCI_I2C_SLAVE;
@@ -1166,35 +1249,37 @@
* get a core reset notification - This is time for chip
* & NFCC controller to come-up.
*/
- usleep(15000); /* 15 ms */
+ usleep_range(15000, 16500); /* 15 ms */
do {
- ret = i2c_master_recv(client, rsp, 5);
+ ret = i2c_master_recv(client, rsp, sizeof(rsp));
+ if (ret < 0)
+ goto err_init;
/* Found core reset notification */
- if (((rsp[0] == CORE_RESET_RSP_GID) &&
+ if ((rsp[0] == CORE_RESET_RSP_GID) &&
(rsp[1] == CORE_RESET_OID) &&
- (rsp[2] == CORE_RST_NTF_LENGTH))
- || time_taken == NTF_TIMEOUT) {
+ (rsp[2] == CORE_RST_NTF_LENGTH)) {
dev_dbg(&client->dev,
- "NFC core reset recevd: %s: info: %p\n",
+ "NFC core reset recvd: %s: info: %p\n",
__func__, client);
core_reset_completed = true;
} else {
- usleep(2000); /* 2ms sleep before retry */
+ usleep_range(2000, 2200); /* 2 ms wait before retry */
}
time_taken++;
- } while (!core_reset_completed);
- if (time_taken == NTF_TIMEOUT)
+ } while (!core_reset_completed && (time_taken < NTF_TIMEOUT));
+ if (time_taken >= NTF_TIMEOUT) {
qca199x_dev->core_reset_ntf = TIMEDOUT_INITIAL_CORE_RESET_NTF;
- else
- qca199x_dev->core_reset_ntf = ARRIVED_INITIAL_CORE_RESET_NTF;
+ goto err_init;
+ }
+ qca199x_dev->core_reset_ntf = ARRIVED_INITIAL_CORE_RESET_NTF;
r = 0;
return r;
err_init:
r = 1;
dev_err(&client->dev,
- "nfc-nci nfcc_initialise: failed. Check Hardware\n");
+ "%s: failed. Check Hardware\n", __func__);
return r;
}
/*
@@ -1205,19 +1290,20 @@
int r = 0;
if (!strcmp(qca199x_dev->clk_src_name, "BBCLK2")) {
- qca199x_dev->s_clk =
+ qca199x_dev->s_clk =
clk_get(&qca199x_dev->client->dev, "ref_clk");
if (qca199x_dev->s_clk == NULL)
goto err_invalid_dis_gpio;
} else if (!strcmp(qca199x_dev->clk_src_name, "RFCLK3")) {
- qca199x_dev->s_clk =
+ qca199x_dev->s_clk =
clk_get(&qca199x_dev->client->dev, "ref_clk_rf");
if (qca199x_dev->s_clk == NULL)
goto err_invalid_dis_gpio;
} else if (!strcmp(qca199x_dev->clk_src_name, "GPCLK")) {
if (gpio_is_valid(qca199x_dev->clk_src_gpio)) {
- qca199x_dev->s_clk =
- clk_get(&qca199x_dev->client->dev, "core_clk");
+ qca199x_dev->s_clk =
+ clk_get(&qca199x_dev->client->dev,
+ "core_clk");
if (qca199x_dev->s_clk == NULL)
goto err_invalid_dis_gpio;
} else {
@@ -1225,8 +1311,9 @@
}
} else if (!strcmp(qca199x_dev->clk_src_name, "GPCLK2")) {
if (gpio_is_valid(qca199x_dev->clk_src_gpio)) {
- qca199x_dev->s_clk =
- clk_get(&qca199x_dev->client->dev, "core_clk_pvt");
+ qca199x_dev->s_clk =
+ clk_get(&qca199x_dev->client->dev,
+ "core_clk_pvt");
if (qca199x_dev->s_clk == NULL)
goto err_invalid_dis_gpio;
} else {
@@ -1302,7 +1389,7 @@
}
if ((!strcmp(pdata->clk_src_name, "GPCLK")) ||
- (!strcmp(pdata->clk_src_name, "GPCLK2"))) {
+ (!strcmp(pdata->clk_src_name, "GPCLK2"))) {
pdata->clk_src_gpio = of_get_named_gpio(np,
"qcom,clk-src-gpio", 0);
if ((!gpio_is_valid(pdata->clk_src_gpio)))
@@ -1331,7 +1418,7 @@
sizeof(struct qca199x_platform_data), GFP_KERNEL);
if (!platform_data) {
dev_err(&client->dev,
- "nfc-nci probe: Failed to allocate memory\n");
+ "%s: Failed to allocate memory\n", __func__);
return -ENOMEM;
}
r = nfc_parse_dt(&client->dev, platform_data);
@@ -1343,20 +1430,20 @@
if (!platform_data)
return -EINVAL;
dev_dbg(&client->dev,
- "nfc-nci probe: %s, inside nfc-nci flags = %x\n",
+ "%s, inside nfc-nci flags = %x\n",
__func__, client->flags);
if (platform_data == NULL) {
- dev_err(&client->dev, "nfc-nci probe: failed\n");
+ dev_err(&client->dev, "%s: failed\n", __func__);
return -ENODEV;
}
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
- dev_err(&client->dev, "nfc-nci probe: need I2C_FUNC_I2C\n");
+ dev_err(&client->dev, "%s: need I2C_FUNC_I2C\n", __func__);
return -ENODEV;
}
qca199x_dev = kzalloc(sizeof(*qca199x_dev), GFP_KERNEL);
if (qca199x_dev == NULL) {
dev_err(&client->dev,
- "nfc-nci probe: failed to allocate memory for module data\n");
+ "%s: failed to allocate memory for module data\n", __func__);
return -ENOMEM;
}
qca199x_dev->client = client;
@@ -1374,27 +1461,29 @@
r = gpio_request(platform_data->dis_gpio, "nfc_reset_gpio");
if (r) {
dev_err(&client->dev,
- "NFC: unable to request gpio [%d]\n",
+ "%s: unable to request gpio [%d]\n",
+ __func__,
platform_data->dis_gpio);
goto err_free_dev;
}
r = gpio_direction_output(platform_data->dis_gpio, 1);
if (r) {
dev_err(&client->dev,
- "NFC: unable to set direction for gpio [%d]\n",
+ "%s: unable to set direction for gpio [%d]\n",
+ __func__,
platform_data->dis_gpio);
goto err_dis_gpio;
}
} else {
- dev_err(&client->dev, "dis gpio not provided\n");
+ dev_err(&client->dev, "%s: dis gpio not provided\n", __func__);
goto err_free_dev;
}
/* Guarantee that the NFCC starts in a clean state. */
gpio_set_value(platform_data->dis_gpio, 1);/* HPD */
- usleep(200);
+ usleep_range(200, 220);
gpio_set_value(platform_data->dis_gpio, 0);/* ULPM */
- usleep(200);
+ usleep_range(200, 220);
r = nfcc_hw_check(client, platform_data->reg);
if (r) {
@@ -1406,7 +1495,8 @@
if (gpio_is_valid(platform_data->irq_gpio)) {
r = gpio_request(platform_data->irq_gpio, "nfc_irq_gpio");
if (r) {
- dev_err(&client->dev, "unable to request gpio [%d]\n",
+ dev_err(&client->dev, "%s: unable to request gpio [%d]\n",
+ __func__,
platform_data->irq_gpio);
goto err_dis_gpio;
}
@@ -1414,7 +1504,8 @@
if (r) {
dev_err(&client->dev,
- "unable to set direction for gpio [%d]\n",
+ "%s: unable to set direction for gpio [%d]\n",
+ __func__,
platform_data->irq_gpio);
goto err_irq;
}
@@ -1426,7 +1517,7 @@
client->irq = irqn;
} else {
- dev_err(&client->dev, "irq gpio not provided\n");
+ dev_err(&client->dev, "%s: irq gpio not provided\n", __func__);
goto err_dis_gpio;
}
/* Interrupt from NFCC CLK_REQ to handle REF_CLK
@@ -1437,7 +1528,9 @@
r = gpio_request(platform_data->irq_gpio_clk_req,
"nfc_irq_gpio_clk_en");
if (r) {
- dev_err(&client->dev, "unable to request CLK_EN gpio [%d]\n",
+ dev_err(&client->dev,
+ "%s: unable to request CLK_EN gpio [%d]\n",
+ __func__,
platform_data->irq_gpio_clk_req);
goto err_irq;
}
@@ -1445,8 +1538,8 @@
platform_data->irq_gpio_clk_req);
if (r) {
dev_err(&client->dev,
- "unable to set direction for CLK_EN gpio [%d]\n",
- platform_data->irq_gpio_clk_req);
+ "%s: cannot set direction CLK_EN gpio [%d]\n",
+ __func__, platform_data->irq_gpio_clk_req);
goto err_irq_clk;
}
gpio_to_irq(0);
@@ -1457,7 +1550,8 @@
}
platform_data->clk_req_irq_num = irqn;
} else {
- dev_err(&client->dev, "irq CLK_EN gpio not provided\n");
+ dev_err(&client->dev,
+ "%s: irq CLK_EN gpio not provided\n", __func__);
goto err_irq;
}
}
@@ -1478,19 +1572,21 @@
r = gpio_request(platform_data->clkreq_gpio,
"nfc_clkreq_gpio");
if (r) {
- dev_err(&client->dev, "unable to request gpio [%d]\n",
- platform_data->clkreq_gpio);
+ dev_err(&client->dev,
+ "%s: unable to request gpio [%d]\n",
+ __func__, platform_data->clkreq_gpio);
goto err_clkreq_gpio;
}
r = gpio_direction_input(platform_data->clkreq_gpio);
if (r) {
dev_err(&client->dev,
- "unable to set direction for gpio [%d]\n",
- platform_data->clkreq_gpio);
+ "%s: cannot set direction for gpio [%d]\n",
+ __func__, platform_data->clkreq_gpio);
goto err_clkreq_gpio;
}
} else {
- dev_err(&client->dev, "clkreq gpio not provided\n");
+ dev_err(&client->dev,
+ "%s: clkreq gpio not provided\n", __func__);
goto err_clk;
}
qca199x_dev->clkreq_gpio = platform_data->clkreq_gpio;
@@ -1517,7 +1613,7 @@
r = misc_register(&qca199x_dev->qca199x_device);
if (r) {
- dev_err(&client->dev, "misc_register failed\n");
+ dev_err(&client->dev, "%s: misc_register failed\n", __func__);
goto err_misc_register;
}
@@ -1554,7 +1650,7 @@
r = request_irq(client->irq, qca199x_dev_irq_handler,
IRQF_TRIGGER_RISING, client->name, qca199x_dev);
if (r) {
- dev_err(&client->dev, "nfc-nci probe: request_irq failed\n");
+ dev_err(&client->dev, "%s: request_irq failed\n", __func__);
goto err_request_irq_failed;
}
qca199x_disable_irq(qca199x_dev);
@@ -1567,7 +1663,8 @@
client->name, qca199x_dev);
if (r) {
dev_err(&client->dev,
- "nfc-nci probe: request_irq failed. irq no = %d\n, main irq = %d",
+ "%s: request_irq failed. irq no = %d\n, main irq = %d",
+ __func__,
qca199x_dev->clk_req_irq_num, client->irq);
goto err_request_irq_failed;
}
@@ -1592,13 +1689,13 @@
region2_sent = false;
dev_dbg(&client->dev,
- "nfc-nci probe: %s, probing qca1990 exited successfully\n",
+ "%s: probing qca1990 exited successfully\n",
__func__);
return 0;
err_create_workq:
dev_err(&client->dev,
- "nfc-nci probe: %s, work_queue creation failure\n",
+ "%s: work_queue creation failure\n",
__func__);
free_irq(client->irq, qca199x_dev);
err_nfcc_not_present:
@@ -1616,7 +1713,8 @@
(!strcmp(platform_data->clk_src_name, "GPCLK2"))) {
r = gpio_direction_input(platform_data->irq_gpio_clk_req);
if (r)
- dev_err(&client->dev, "nfc-nci probe: Unable to set direction\n");
+ dev_err(&client->dev,
+ "%s: Unable to set direction\n", __func__);
gpio_free(platform_data->irq_gpio_clk_req);
}
err_irq:
@@ -1690,7 +1788,7 @@
static int nfcc_reboot(struct notifier_block *notifier, unsigned long val,
- void *v)
+ void *v)
{
/*
* Set DISABLE=1 *ONLY* if the NFC service has been disabled.
diff --git a/drivers/nfc/nfc-nci.h b/drivers/nfc/nfc-nci.h
index 8186861..398fa3f 100644
--- a/drivers/nfc/nfc-nci.h
+++ b/drivers/nfc/nfc-nci.h
@@ -60,6 +60,7 @@
#define SET_RX_BLOCK _IOW(0xE9, 0x04, unsigned int)
#define SET_EMULATOR_TEST_POINT _IOW(0xE9, 0x05, unsigned int)
#define NFCC_VERSION _IOW(0xE9, 0x08, unsigned int)
+#define NFC_GET_EFUSE _IOW(0xE9, 0x09, unsigned int)
#define NFCC_INITIAL_CORE_RESET_NTF _IOW(0xE9, 0x10, unsigned int)
#define NFC_MAX_I2C_TRANSFER (0x0400)
diff --git a/drivers/video/msm/mdss/dsi_host_v2.c b/drivers/video/msm/mdss/dsi_host_v2.c
index 592f70e..68c991c 100644
--- a/drivers/video/msm/mdss/dsi_host_v2.c
+++ b/drivers/video/msm/mdss/dsi_host_v2.c
@@ -653,14 +653,25 @@
return rc;
}
+/* MIPI_DSI_MRPS, Maximum Return Packet Size */
+static char max_pktsize[2] = {0x00, 0x00}; /* LSB tx first, 10 bytes */
+
+static struct dsi_cmd_desc pkt_size_cmd = {
+ {DTYPE_MAX_PKTSIZE, 1, 0, 0, 0, sizeof(max_pktsize)},
+ max_pktsize,
+};
+
int msm_dsi_cmd_dma_rx(struct mdss_dsi_ctrl_pdata *ctrl,
struct dsi_buf *rp, int rlen)
{
- u32 *lp, data;
- int i, off, cnt;
+ u32 *lp, data, *temp;
+ int i, j = 0, off, cnt;
unsigned char *ctrl_base = dsi_host_private->dsi_base;
+ char reg[16];
+ int repeated_bytes = 0;
lp = (u32 *)rp->data;
+ temp = (u32 *)reg;
cnt = rlen;
cnt += 3;
cnt >>= 2;
@@ -668,16 +679,52 @@
if (cnt > 4)
cnt = 4; /* 4 x 32 bits registers only */
+ if (rlen == 4)
+ rp->read_cnt = 4;
+ else
+ rp->read_cnt = (max_pktsize[0] + 6);
+
+ if (rp->read_cnt > 16) {
+ int bytes_shifted, data_lost = 0, rem_header_bytes = 0;
+ /* Any data more than 16 bytes will be shifted out */
+ bytes_shifted = rp->read_cnt - rlen;
+ if (bytes_shifted >= 4)
+ data_lost = bytes_shifted - 4; /* remove dcs header */
+ else
+ rem_header_bytes = 4 - bytes_shifted; /* rem header */
+ /*
+ * (rp->len - 4) -> current rx buffer data length.
+ * If data_lost > 0, then ((rp->len - 4) - data_lost) will be
+ * the number of repeating bytes.
+ * If data_lost == 0, then ((rp->len - 4) + rem_header_bytes)
+ * will be the number of bytes repeating in between rx buffer
+ * and the current RDBK_DATA registers. We need to skip the
+ * repeating bytes.
+ */
+ repeated_bytes = (rp->len - 4) - data_lost + rem_header_bytes;
+ }
+
off = DSI_RDBK_DATA0;
off += ((cnt - 1) * 4);
for (i = 0; i < cnt; i++) {
data = (u32)MIPI_INP(ctrl_base + off);
- *lp++ = ntohl(data); /* to network byte order */
+ /* to network byte order */
+ if (!repeated_bytes)
+ *lp++ = ntohl(data);
+ else
+ *temp++ = ntohl(data);
pr_debug("%s: data = 0x%x and ntohl(data) = 0x%x\n",
__func__, data, ntohl(data));
off -= 4;
- rp->len += sizeof(*lp);
+ if (rlen == 4)
+ rp->len += sizeof(*lp);
+ }
+
+ /* Skip duplicates and append other data to the rx buffer */
+ if (repeated_bytes) {
+ for (i = repeated_bytes; i < 16; i++)
+ rp->data[j++] = reg[i];
}
return rlen;
@@ -769,14 +816,6 @@
return rc;
}
-/* MIPI_DSI_MRPS, Maximum Return Packet Size */
-static char max_pktsize[2] = {0x00, 0x00}; /* LSB tx first, 10 bytes */
-
-static struct dsi_cmd_desc pkt_size_cmd = {
- {DTYPE_MAX_PKTSIZE, 1, 0, 0, 0, sizeof(max_pktsize)},
- max_pktsize,
-};
-
static int msm_dsi_set_max_packet_size(struct mdss_dsi_ctrl_pdata *ctrl,
int size)
{
@@ -814,10 +853,23 @@
{
int rc;
struct dsi_buf *tp, *rp;
+ int rx_byte = 0;
+
+ if (rlen <= 2)
+ rx_byte = 4;
+ else
+ rx_byte = DSI_MAX_BYTES_TO_READ;
tp = &ctrl->tx_buf;
rp = &ctrl->rx_buf;
mdss_dsi_buf_init(rp);
+ rc = msm_dsi_set_max_packet_size(ctrl, rlen);
+ if (rc) {
+ pr_err("%s: dsi_set_max_pkt failed\n", __func__);
+ rc = -EINVAL;
+ goto dsi_cmds_rx_1_error;
+ }
+
mdss_dsi_buf_init(tp);
rc = mdss_dsi_cmd_dma_add(tp, cmds);
@@ -840,10 +892,12 @@
}
if (rlen <= DSI_SHORT_PKT_DATA_SIZE) {
- msm_dsi_cmd_dma_rx(ctrl, rp, rlen);
+ msm_dsi_cmd_dma_rx(ctrl, rp, rx_byte);
} else {
- msm_dsi_cmd_dma_rx(ctrl, rp, rlen + DSI_HOST_HDR_SIZE);
- rp->len = rlen + DSI_HOST_HDR_SIZE;
+ msm_dsi_cmd_dma_rx(ctrl, rp, rx_byte);
+ rp->len = rx_byte - 2; /*2 bytes for CRC*/
+ rp->len = rp->len - (DSI_MAX_PKT_SIZE - rlen);
+ rp->data = rp->start + (16 - (rlen + 2 + DSI_HOST_HDR_SIZE));
}
rc = msm_dsi_parse_rx_response(rp);
@@ -860,16 +914,15 @@
{
int rc;
struct dsi_buf *tp, *rp;
- int pkt_size, data_bytes, total;
+ int pkt_size, data_bytes, dlen, end = 0, diff;
tp = &ctrl->tx_buf;
rp = &ctrl->rx_buf;
mdss_dsi_buf_init(rp);
pkt_size = DSI_MAX_PKT_SIZE;
data_bytes = MDSS_DSI_LEN;
- total = 0;
- while (true) {
+ while (!end) {
rc = msm_dsi_set_max_packet_size(ctrl, pkt_size);
if (rc)
break;
@@ -880,7 +933,7 @@
pr_err("%s: dsi_cmd_dma_add failed\n", __func__);
rc = -EINVAL;
break;
- }
+ }
rc = msm_dsi_wait4video_eng_busy(ctrl);
if (rc) {
pr_err("%s: wait4video_eng failed\n", __func__);
@@ -894,19 +947,32 @@
}
msm_dsi_cmd_dma_rx(ctrl, rp, DSI_MAX_BYTES_TO_READ);
+ if (rlen <= data_bytes) {
+ diff = data_bytes - rlen;
+ end = 1;
+ } else {
+ diff = 0;
+ rlen -= data_bytes;
+ }
+ dlen = DSI_MAX_BYTES_TO_READ - 2;
+ dlen -= diff;
+ rp->data += dlen;
+ rp->len += dlen;
- rp->data += DSI_MAX_BYTES_TO_READ - DSI_HOST_HDR_SIZE;
- total += data_bytes;
- if (total >= rlen)
- break;
-
- data_bytes = DSI_MAX_BYTES_TO_READ - DSI_HOST_HDR_SIZE;
- pkt_size += data_bytes;
+ if (!end) {
+ data_bytes = 14;
+ if (rlen < data_bytes)
+ pkt_size += rlen;
+ else
+ pkt_size += data_bytes;
+ }
+ pr_debug("%s: rp data=%x len=%d dlen=%d diff=%d\n",
+ __func__, (int) (unsigned long) rp->data,
+ rp->len, dlen, diff);
}
if (!rc) {
rp->data = rp->start;
- rp->len = rlen + DSI_HOST_HDR_SIZE;
rc = msm_dsi_parse_rx_response(rp);
}
diff --git a/drivers/video/msm/mdss/mdss_dsi_cmd.c b/drivers/video/msm/mdss/mdss_dsi_cmd.c
index 8fc1115c0..6d8f9e9 100644
--- a/drivers/video/msm/mdss/mdss_dsi_cmd.c
+++ b/drivers/video/msm/mdss/mdss_dsi_cmd.c
@@ -1,4 +1,4 @@
-/* Copyright (c) 2012-2013, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2012-2014, 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
@@ -66,6 +66,7 @@
off = 8 - off;
dp->data += off;
dp->len = 0;
+ dp->read_cnt = 0;
return dp->data;
}
@@ -86,6 +87,7 @@
dp->data = dp->start;
dp->len = 0;
+ dp->read_cnt = 0;
return size;
}
@@ -574,6 +576,7 @@
/* strip out dcs type */
rp->data++;
rp->len = 1;
+ rp->read_cnt -= 3;
return rp->len;
}
@@ -585,6 +588,7 @@
/* strip out dcs type */
rp->data++;
rp->len = 2;
+ rp->read_cnt -= 2;
return rp->len;
}
@@ -593,6 +597,7 @@
/* strip out dcs header */
rp->data += 4;
rp->len -= 4;
+ rp->read_cnt -= 6;
return rp->len;
}
diff --git a/drivers/video/msm/mdss/mdss_dsi_cmd.h b/drivers/video/msm/mdss/mdss_dsi_cmd.h
index f806e78..3abe4fc 100644
--- a/drivers/video/msm/mdss/mdss_dsi_cmd.h
+++ b/drivers/video/msm/mdss/mdss_dsi_cmd.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2012-2013, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2012-2014, 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
@@ -30,7 +30,7 @@
#define MDSS_DSI_MRPS 0x04 /* Maximum Return Packet Size */
-#define MDSS_DSI_LEN 8 /* 4 x 4 - 6 - 2, bytes dcs header+crc-align */
+#define MDSS_DSI_LEN 10 /* 4 x 4 - 4 - 2, bytes dcs header+crc-align */
struct dsi_buf {
u32 *hdr; /* dsi host header */
@@ -40,6 +40,7 @@
char *data; /* buffer */
int len; /* data length */
dma_addr_t dmap; /* mapped dma addr */
+ int read_cnt;
};
/* dcs read/write */
diff --git a/drivers/video/msm/mdss/mdss_mdp_intf_cmd.c b/drivers/video/msm/mdss/mdss_mdp_intf_cmd.c
old mode 100644
new mode 100755
index 4c72d28..b6bec08
--- a/drivers/video/msm/mdss/mdss_mdp_intf_cmd.c
+++ b/drivers/video/msm/mdss/mdss_mdp_intf_cmd.c
@@ -32,11 +32,11 @@
struct mdss_mdp_ctl *ctl;
u32 pp_num;
u8 ref_cnt;
- struct completion pp_comp;
struct completion stop_comp;
+ wait_queue_head_t pp_waitq;
struct list_head vsync_handlers;
int panel_on;
- int koff_cnt;
+ atomic_t koff_cnt;
int clk_enabled;
int vsync_enabled;
int rdptr_enabled;
@@ -55,10 +55,14 @@
u32 vclk_line; /* vsync clock per line */
struct mdss_panel_recovery recovery;
bool ulps;
+ struct mdss_mdp_cmd_ctx *sync_ctx; /* for partial update */
+ u32 pp_timeout_report_cnt;
};
struct mdss_mdp_cmd_ctx mdss_mdp_cmd_ctx_list[MAX_SESSIONS];
+static int mdss_mdp_cmd_do_notifier(struct mdss_mdp_cmd_ctx *ctx);
+
static inline u32 mdss_mdp_cmd_line_count(struct mdss_mdp_ctl *ctl)
{
struct mdss_mdp_mixer *mixer;
@@ -287,7 +291,7 @@
ctx->rdptr_enabled--;
/* keep clk on during kickoff */
- if (ctx->rdptr_enabled == 0 && ctx->koff_cnt)
+ if (ctx->rdptr_enabled == 0 && atomic_read(&ctx->koff_cnt))
ctx->rdptr_enabled++;
}
@@ -314,14 +318,13 @@
if (!ctx->ctl)
return;
spin_lock_irqsave(&ctx->clk_lock, flags);
- if (ctx->koff_cnt) {
+ if (atomic_read(&ctx->koff_cnt)) {
mdss_mdp_ctl_reset(ctx->ctl);
pr_debug("%s: intf_num=%d\n", __func__,
ctx->ctl->intf_num);
- ctx->koff_cnt--;
+ atomic_dec(&ctx->koff_cnt);
mdss_mdp_irq_disable_nosync(MDSS_MDP_IRQ_PING_PONG_COMP,
ctx->pp_num);
- complete_all(&ctx->pp_comp);
}
spin_unlock_irqrestore(&ctx->clk_lock, flags);
}
@@ -348,25 +351,27 @@
}
mdss_mdp_irq_disable_nosync(MDSS_MDP_IRQ_PING_PONG_COMP, ctx->pp_num);
- complete_all(&ctx->pp_comp);
MDSS_XLOG(ctl->num, ctx->koff_cnt, ctx->clk_enabled,
ctx->rdptr_enabled);
- if (ctx->koff_cnt) {
- atomic_inc(&ctx->pp_done_cnt);
- schedule_work(&ctx->pp_done_work);
- ctx->koff_cnt--;
- if (ctx->koff_cnt) {
+ if (atomic_add_unless(&ctx->koff_cnt, -1, 0)) {
+ if (atomic_read(&ctx->koff_cnt))
pr_err("%s: too many kickoffs=%d!\n", __func__,
- ctx->koff_cnt);
- ctx->koff_cnt = 0;
+ atomic_read(&ctx->koff_cnt));
+ if (mdss_mdp_cmd_do_notifier(ctx)) {
+ atomic_inc(&ctx->pp_done_cnt);
+ schedule_work(&ctx->pp_done_work);
}
- } else
+ wake_up_all(&ctx->pp_waitq);
+ } else {
pr_err("%s: should not have pingpong interrupt!\n", __func__);
+ }
- trace_mdp_cmd_pingpong_done(ctl, ctx->pp_num, ctx->koff_cnt);
+ trace_mdp_cmd_pingpong_done(ctl, ctx->pp_num,
+ atomic_read(&ctx->koff_cnt));
pr_debug("%s: ctl_num=%d intf_num=%d ctx=%d kcnt=%d\n", __func__,
- ctl->num, ctl->intf_num, ctx->pp_num, ctx->koff_cnt);
+ ctl->num, ctl->intf_num, ctx->pp_num,
+ atomic_read(&ctx->koff_cnt));
spin_unlock(&ctx->clk_lock);
}
@@ -504,7 +509,6 @@
struct mdss_mdp_cmd_ctx *ctx;
struct mdss_panel_data *pdata;
unsigned long flags;
- int need_wait = 0;
int rc = 0;
ctx = (struct mdss_mdp_cmd_ctx *) ctl->priv_data;
@@ -515,11 +519,6 @@
pdata = ctl->panel_data;
- spin_lock_irqsave(&ctx->clk_lock, flags);
- if (ctx->koff_cnt > 0)
- need_wait = 1;
- spin_unlock_irqrestore(&ctx->clk_lock, flags);
-
ctl->roi_bkup.w = ctl->width;
ctl->roi_bkup.h = ctl->height;
@@ -527,33 +526,95 @@
ctx->rdptr_enabled, ctl->roi_bkup.w,
ctl->roi_bkup.h);
- pr_debug("%s: need_wait=%d intf_num=%d ctx=%p\n",
- __func__, need_wait, ctl->intf_num, ctx);
+ pr_debug("%s: intf_num=%d ctx=%p koff_cnt=%d\n", __func__,
+ ctl->intf_num, ctx, atomic_read(&ctx->koff_cnt));
- if (need_wait) {
- rc = wait_for_completion_timeout(
- &ctx->pp_comp, KOFF_TIMEOUT);
+ rc = wait_event_timeout(ctx->pp_waitq,
+ atomic_read(&ctx->koff_cnt) == 0,
+ KOFF_TIMEOUT);
- trace_mdp_cmd_wait_pingpong(ctl->num, ctx->koff_cnt);
+ if (rc <= 0) {
+ u32 status, mask;
- if (rc <= 0) {
- WARN(1, "cmd kickoff timed out (%d) ctl=%d\n",
- rc, ctl->num);
- mdss_dsi_debug_check_te(pdata);
- MDSS_XLOG_TOUT_HANDLER("mdp", "dsi0", "dsi1",
- "edp", "hdmi", "panic");
- rc = -EPERM;
- mdss_mdp_ctl_notify(ctl, MDP_NOTIFY_FRAME_TIMEOUT);
- } else {
- rc = 0;
+ mask = BIT(MDSS_MDP_IRQ_PING_PONG_COMP + ctx->pp_num);
+ status = mask & readl_relaxed(ctl->mdata->mdp_base +
+ MDSS_MDP_REG_INTR_STATUS);
+ if (status) {
+ WARN(1, "pp done but irq not triggered\n");
+ mdss_mdp_irq_clear(ctl->mdata,
+ MDSS_MDP_IRQ_PING_PONG_COMP,
+ ctx->pp_num);
+ local_irq_save(flags);
+ mdss_mdp_cmd_pingpong_done(ctl);
+ local_irq_restore(flags);
+ rc = 1;
}
+
+ rc = atomic_read(&ctx->koff_cnt) == 0;
}
- MDSS_XLOG(ctl->num, ctx->koff_cnt, ctx->clk_enabled,
- ctx->rdptr_enabled, rc);
+ if (rc <= 0) {
+ if (!ctx->pp_timeout_report_cnt) {
+ WARN(1, "cmd kickoff timed out (%d) ctl=%d\n",
+ rc, ctl->num);
+ mdss_dsi_debug_check_te(pdata);
+ MDSS_XLOG_TOUT_HANDLER("mdp", "dsi0", "dsi1",
+ "edp", "hdmi", "panic");
+ }
+ ctx->pp_timeout_report_cnt++;
+ rc = -EPERM;
+ mdss_mdp_ctl_notify(ctl, MDP_NOTIFY_FRAME_TIMEOUT);
+ atomic_add_unless(&ctx->koff_cnt, -1, 0);
+ } else {
+ rc = 0;
+ ctx->pp_timeout_report_cnt = 0;
+ }
+
+ /* signal any pending ping pong done events */
+ while (atomic_add_unless(&ctx->pp_done_cnt, -1, 0))
+ mdss_mdp_ctl_notify(ctx->ctl, MDP_NOTIFY_FRAME_DONE);
+
+ MDSS_XLOG(ctl->num, atomic_read(&ctx->koff_cnt), ctx->clk_enabled,
+ ctx->rdptr_enabled, rc);
+
return rc;
}
+static int mdss_mdp_cmd_do_notifier(struct mdss_mdp_cmd_ctx *ctx)
+{
+ struct mdss_mdp_cmd_ctx *sctx;
+ sctx = ctx->sync_ctx;
+
+ if (!sctx || atomic_read(&sctx->koff_cnt) == 0)
+ return 1;
+
+ return 0;
+}
+
+static void mdss_mdp_cmd_set_sync_ctx(
+ struct mdss_mdp_ctl *ctl, struct mdss_mdp_ctl *sctl)
+{
+ struct mdss_mdp_cmd_ctx *ctx, *sctx;
+
+ ctx = (struct mdss_mdp_cmd_ctx *)ctl->priv_data;
+ if (!sctl) {
+ ctx->sync_ctx = NULL;
+ return;
+ }
+
+ sctx = (struct mdss_mdp_cmd_ctx *)sctl->priv_data;
+
+ if (!sctl->roi.w && !sctl->roi.h) {
+ /* left only */
+ ctx->sync_ctx = NULL;
+ sctx->sync_ctx = NULL;
+ } else {
+ /* left + right */
+ ctx->sync_ctx = sctx;
+ sctx->sync_ctx = ctx;
+ }
+}
+
static int mdss_mdp_cmd_set_partial_roi(struct mdss_mdp_ctl *ctl)
{
int rc = 0;
@@ -572,8 +633,7 @@
int mdss_mdp_cmd_kickoff(struct mdss_mdp_ctl *ctl, void *arg)
{
- struct mdss_mdp_cmd_ctx *ctx;
- unsigned long flags;
+ struct mdss_mdp_cmd_ctx *ctx, *sctx = NULL;
int rc;
ctx = (struct mdss_mdp_cmd_ctx *) ctl->priv_data;
@@ -602,10 +662,11 @@
MDSS_XLOG(ctl->num, ctl->roi.x, ctl->roi.y, ctl->roi.w,
ctl->roi.h);
- spin_lock_irqsave(&ctx->clk_lock, flags);
- ctx->koff_cnt++;
- spin_unlock_irqrestore(&ctx->clk_lock, flags);
- trace_mdp_cmd_kickoff(ctl->num, ctx->koff_cnt);
+ atomic_inc(&ctx->koff_cnt);
+ if (sctx)
+ atomic_inc(&sctx->koff_cnt);
+
+ trace_mdp_cmd_kickoff(ctl->num, atomic_read(&ctx->koff_cnt));
mdss_mdp_cmd_clk_on(ctx);
@@ -615,7 +676,9 @@
* tx dcs command if had any
*/
mdss_mdp_ctl_intf_event(ctl, MDSS_EVENT_DSI_CMDLIST_KOFF, NULL);
- INIT_COMPLETION(ctx->pp_comp);
+
+ mdss_mdp_cmd_set_sync_ctx(ctl, NULL);
+
mdss_mdp_irq_enable(MDSS_MDP_IRQ_PING_PONG_COMP, ctx->pp_num);
mdss_mdp_ctl_write(ctl, MDSS_MDP_REG_CTL_START, 1);
mdss_mdp_ctl_perf_set_transaction_status(ctl,
@@ -754,7 +817,8 @@
ctx->ctl = ctl;
ctx->pp_num = mixer->num;
- init_completion(&ctx->pp_comp);
+ ctx->pp_timeout_report_cnt = 0;
+ init_waitqueue_head(&ctx->pp_waitq);
init_completion(&ctx->stop_comp);
spin_lock_init(&ctx->clk_lock);
mutex_init(&ctx->clk_mtx);
diff --git a/include/sound/Kbuild b/include/sound/Kbuild
index aeccfed..bb8b17b 100644
--- a/include/sound/Kbuild
+++ b/include/sound/Kbuild
@@ -14,3 +14,4 @@
header-y += lsm_params.h
header-y += voice_params.h
header-y += voice_svc.h
+header-y += msmcal-hwdep.h
diff --git a/include/sound/asound.h b/include/sound/asound.h
index 7bf01b6..244bb30 100644
--- a/include/sound/asound.h
+++ b/include/sound/asound.h
@@ -95,9 +95,10 @@
SNDRV_HWDEP_IFACE_SB_RC, /* SB Extigy/Audigy2NX remote control */
SNDRV_HWDEP_IFACE_HDA, /* HD-audio */
SNDRV_HWDEP_IFACE_USB_STREAM, /* direct access to usb stream */
+ SNDRV_HWDEP_IFACE_AUDIO_CODEC, /* codec Audio Control */
/* Don't forget to change the following: */
- SNDRV_HWDEP_IFACE_LAST = SNDRV_HWDEP_IFACE_USB_STREAM
+ SNDRV_HWDEP_IFACE_LAST = SNDRV_HWDEP_IFACE_AUDIO_CODEC
};
struct snd_hwdep_info {
diff --git a/include/sound/msmcal-hwdep.h b/include/sound/msmcal-hwdep.h
new file mode 100644
index 0000000..324b497
--- /dev/null
+++ b/include/sound/msmcal-hwdep.h
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2014, 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 _CALIB_HWDEP_H
+#define _CALIB_HWDEP_H
+
+#define WCD9XXX_CODEC_HWDEP_NODE 1000
+enum wcd_cal_type {
+ WCD9XXX_MIN_CAL,
+ WCD9XXX_ANC_CAL = WCD9XXX_MIN_CAL,
+ WCD9XXX_MAD_CAL,
+ WCD9XXX_MBHC_CAL,
+ WCD9XXX_MAX_CAL,
+};
+
+struct wcdcal_ioctl_buffer {
+ __u32 size;
+ __u8 __user *buffer;
+ enum wcd_cal_type cal_type;
+};
+
+#define SNDRV_CTL_IOCTL_HWDEP_CAL_TYPE \
+ _IOW('U', 0x1, struct wcdcal_ioctl_buffer)
+
+#endif /*_CALIB_HWDEP_H*/
diff --git a/sound/soc/codecs/Makefile b/sound/soc/codecs/Makefile
index a3ed23d..b42599e 100644
--- a/sound/soc/codecs/Makefile
+++ b/sound/soc/codecs/Makefile
@@ -51,8 +51,8 @@
snd-soc-wcd9304-objs := wcd9304.o wcd9304-tables.o
snd-soc-wcd9310-objs := wcd9310.o wcd9310-tables.o
snd-soc-cs8427-objs := cs8427.o
-snd-soc-wcd9320-objs := wcd9xxx-resmgr.o wcd9320.o wcd9320-tables.o wcd9xxx-mbhc.o wcd9xxx-common.o
-snd-soc-wcd9306-objs := wcd9306.o wcd9306-tables.o wcd9xxx-common.o
+snd-soc-wcd9320-objs := wcd9xxx-resmgr.o wcd9320.o wcd9320-tables.o wcd9xxx-mbhc.o wcd9xxx-common.o wcdcal-hwdep.o
+snd-soc-wcd9306-objs := wcd9306.o wcd9306-tables.o wcd9xxx-common.o wcdcal-hwdep.o
snd-soc-msm8x10-wcd-objs := msm8x10-wcd.o msm8x10-wcd-tables.o wcd9xxx-common.o
snd-soc-wl1273-objs := wl1273.o
snd-soc-wm1250-ev1-objs := wm1250-ev1.o
diff --git a/sound/soc/codecs/wcd9320.c b/sound/soc/codecs/wcd9320.c
index ce42a94..1dfd72b 100644
--- a/sound/soc/codecs/wcd9320.c
+++ b/sound/soc/codecs/wcd9320.c
@@ -19,7 +19,6 @@
#include <linux/ratelimit.h>
#include <linux/debugfs.h>
#include <linux/wait.h>
-#include <linux/bitops.h>
#include <linux/mfd/wcd9xxx/core.h>
#include <linux/mfd/wcd9xxx/wcd9xxx_registers.h>
#include <linux/mfd/wcd9xxx/wcd9320_registers.h>
@@ -41,6 +40,8 @@
#include "wcd9320.h"
#include "wcd9xxx-resmgr.h"
#include "wcd9xxx-common.h"
+#include "wcdcal-hwdep.h"
+
#define TAIKO_MAD_SLIMBUS_TX_PORT 12
#define TAIKO_MAD_AUDIO_FIRMWARE_PATH "wcd9320/wcd9320_mad_audio.bin"
@@ -453,6 +454,8 @@
*/
struct list_head reg_save_restore;
struct pm_qos_request pm_qos_req;
+ /* cal info for codec */
+ struct fw_info *fw_data;
};
static const u32 comp_shift[] = {
@@ -2680,8 +2683,11 @@
int ret;
const struct firmware *fw;
struct mad_audio_cal *mad_cal;
+ struct firmware_cal *hwdep_cal = NULL;
+ const void *data;
const char *filename = TAIKO_MAD_AUDIO_FIRMWARE_PATH;
struct taiko_priv *taiko = snd_soc_codec_get_drvdata(codec);
+ size_t cal_size;
pr_debug("%s: enter\n", __func__);
/* wakeup for codec calibration access */
@@ -2690,24 +2696,46 @@
PM_QOS_DEFAULT_VALUE);
pm_qos_update_request(&taiko->pm_qos_req,
msm_cpuidle_get_deep_idle_latency());
- ret = request_firmware(&fw, filename, codec->dev);
- if (ret != 0) {
- pr_err("Failed to acquire MAD firwmare data %s: %d\n", filename,
- ret);
+ if (!taiko->fw_data) {
+ dev_err(codec->dev, "%s: invalid cal data\n",
+ __func__);
return -ENODEV;
}
-
- if (fw->size < sizeof(struct mad_audio_cal)) {
- pr_err("%s: incorrect firmware size %u\n", __func__, fw->size);
- release_firmware(fw);
- return -ENOMEM;
+ hwdep_cal = wcdcal_get_fw_cal(taiko->fw_data, WCD9XXX_MAD_CAL);
+ if (hwdep_cal) {
+ data = hwdep_cal->data;
+ cal_size = hwdep_cal->size;
+ dev_dbg(codec->dev, "%s: using hwdep calibration\n",
+ __func__);
+ } else {
+ ret = request_firmware(&fw, filename, codec->dev);
+ if (ret != 0) {
+ pr_err("Failed to acquire MAD firwmare data %s: %d\n",
+ filename, ret);
+ return -ENODEV;
+ }
+ if (!fw) {
+ dev_err(codec->dev, "failed to get mad fw");
+ return -ENODEV;
+ }
+ data = fw->data;
+ cal_size = fw->size;
+ dev_dbg(codec->dev, "%s: using request_firmware calibration\n",
+ __func__);
+ }
+ if (cal_size < sizeof(struct mad_audio_cal)) {
+ pr_err("%s: incorrect hwdep cal size %zu\n",
+ __func__, cal_size);
+ ret = -ENOMEM;
+ goto err;
}
- mad_cal = (struct mad_audio_cal *)(fw->data);
+ mad_cal = (struct mad_audio_cal *)(data);
if (!mad_cal) {
- pr_err("%s: Invalid calibration data\n", __func__);
- release_firmware(fw);
- return -EINVAL;
+ dev_err(codec->dev, "%s: Invalid calibration data\n",
+ __func__);
+ ret = -EINVAL;
+ goto err;
}
snd_soc_write(codec, TAIKO_A_CDC_MAD_MAIN_CTL_2,
@@ -2757,11 +2785,13 @@
snd_soc_write(codec, TAIKO_A_CDC_MAD_ULTR_CTL_6,
mad_cal->ultrasound_info.rms_threshold_msb);
- release_firmware(fw);
pr_debug("%s: leave ret %d\n", __func__, ret);
pm_qos_update_request(&taiko->pm_qos_req,
PM_QOS_DEFAULT_VALUE);
pm_qos_remove_request(&taiko->pm_qos_req);
+err:
+ if (!hwdep_cal)
+ release_firmware(fw);
return ret;
}
@@ -3318,15 +3348,18 @@
const char *filename;
const struct firmware *fw;
int i;
- int ret;
+ int ret =0;
int num_anc_slots;
struct wcd9xxx_anc_header *anc_head;
struct taiko_priv *taiko = snd_soc_codec_get_drvdata(codec);
+ struct firmware_cal *hwdep_cal = NULL;
u32 anc_writes_size = 0;
int anc_size_remaining;
u32 *anc_ptr;
u16 reg;
u8 mask, val, old_val;
+ size_t cal_size;
+ const void *data;
if (taiko->anc_func == 0)
@@ -3335,38 +3368,53 @@
switch (event) {
case SND_SOC_DAPM_PRE_PMU:
filename = "wcd9320/wcd9320_anc.bin";
+ hwdep_cal = wcdcal_get_fw_cal(taiko->fw_data, WCD9XXX_ANC_CAL);
+ if (hwdep_cal) {
+ data = hwdep_cal->data;
+ cal_size = hwdep_cal->size;
+ dev_dbg(codec->dev, "%s: using hwdep calibration\n",
+ __func__);
+ } else {
+ ret = request_firmware(&fw, filename, codec->dev);
+ if (ret != 0) {
+ dev_err(codec->dev, "Failed to acquire ANC data: %d\n",
+ ret);
+ return -ENODEV;
+ }
+ if (!fw) {
+ dev_err(codec->dev, "failed to get anc fw");
+ return -ENODEV;
+ }
+ data = fw->data;
+ cal_size = fw->size;
+ dev_dbg(codec->dev, "%s: using request_firmware calibration\n",
+ __func__);
- ret = request_firmware(&fw, filename, codec->dev);
- if (ret != 0) {
- dev_err(codec->dev, "Failed to acquire ANC data: %d\n",
- ret);
- return -ENODEV;
}
- if (fw->size < sizeof(struct wcd9xxx_anc_header)) {
+ if (cal_size < sizeof(struct wcd9xxx_anc_header)) {
dev_err(codec->dev, "Not enough data\n");
- release_firmware(fw);
- return -ENOMEM;
+ goto err;
}
/* First number is the number of register writes */
- anc_head = (struct wcd9xxx_anc_header *)(fw->data);
- anc_ptr = (u32 *)((u32)fw->data +
+ anc_head = (struct wcd9xxx_anc_header *)(data);
+ anc_ptr = (u32 *)(data +
sizeof(struct wcd9xxx_anc_header));
- anc_size_remaining = fw->size -
+ anc_size_remaining = cal_size -
sizeof(struct wcd9xxx_anc_header);
num_anc_slots = anc_head->num_anc_slots;
if (taiko->anc_slot >= num_anc_slots) {
dev_err(codec->dev, "Invalid ANC slot selected\n");
- release_firmware(fw);
- return -EINVAL;
+ ret = -EINVAL;
+ goto err;
}
for (i = 0; i < num_anc_slots; i++) {
if (anc_size_remaining < TAIKO_PACKED_REG_SIZE) {
dev_err(codec->dev, "Invalid register format\n");
- release_firmware(fw);
- return -EINVAL;
+ ret = -EINVAL;
+ goto err;
}
anc_writes_size = (u32)(*anc_ptr);
anc_size_remaining -= sizeof(u32);
@@ -3375,8 +3423,8 @@
if (anc_writes_size * TAIKO_PACKED_REG_SIZE
> anc_size_remaining) {
dev_err(codec->dev, "Invalid register format\n");
- release_firmware(fw);
- return -ENOMEM;
+ ret = -EINVAL;
+ goto err;
}
if (taiko->anc_slot == i)
@@ -3388,8 +3436,8 @@
}
if (i == num_anc_slots) {
dev_err(codec->dev, "Selected ANC slot not present\n");
- release_firmware(fw);
- return -ENOMEM;
+ ret = -EINVAL;
+ goto err;
}
for (i = 0; i < anc_writes_size; i++) {
TAIKO_CODEC_UNPACK_ENTRY(anc_ptr[i], reg,
@@ -3399,6 +3447,8 @@
(val & mask));
}
release_firmware(fw);
+ if (!hwdep_cal)
+ release_firmware(fw);
break;
case SND_SOC_DAPM_PRE_PMD:
msleep(40);
@@ -3411,6 +3461,11 @@
break;
}
return 0;
+err:
+ if (!hwdep_cal)
+ release_firmware(fw);
+ return ret;
+
}
static int taiko_hph_pa_event(struct snd_soc_dapm_widget *w,
@@ -6586,6 +6641,27 @@
wcd9xxx_free_irq(core_res, WCD9XXX_IRQ_SLIMBUS, taiko);
}
+static
+struct firmware_cal *taiko_get_hwdep_fw_cal(struct snd_soc_codec *codec,
+ enum wcd_cal_type type)
+{
+ struct taiko_priv *taiko;
+ struct firmware_cal *hwdep_cal;
+
+ if (!codec) {
+ pr_err("%s: NULL codec pointer\n", __func__);
+ return NULL;
+ }
+ taiko = snd_soc_codec_get_drvdata(codec);
+ hwdep_cal = wcdcal_get_fw_cal(taiko->fw_data, type);
+ if (!hwdep_cal) {
+ dev_err(codec->dev, "%s: cal not sent by %d\n",
+ __func__, type);
+ return NULL;
+ }
+
+ return hwdep_cal;
+}
int taiko_hs_detect(struct snd_soc_codec *codec,
struct wcd9xxx_mbhc_config *mbhc_cfg)
@@ -6840,6 +6916,7 @@
.get_cdc_type = taiko_get_cdc_type,
.setup_zdet = taiko_setup_zdet,
.compute_impedance = taiko_compute_impedance,
+ .get_hwdep_fw_cal = taiko_get_hwdep_fw_cal,
};
static const struct wcd9xxx_mbhc_intr cdc_intr_ids = {
@@ -7093,7 +7170,7 @@
WCD9XXX_CDC_TYPE_TAIKO);
if (ret) {
pr_err("%s: wcd9xxx init failed %d\n", __func__, ret);
- goto err_init;
+ goto err_nomem_slimch;
}
taiko->clsh_d.buck_mv = taiko_codec_get_buck_mv(codec);
@@ -7105,7 +7182,20 @@
rco_clk_rate = TAIKO_MCLK_CLK_12P288MHZ;
else
rco_clk_rate = TAIKO_MCLK_CLK_9P6MHZ;
-
+ taiko->fw_data = kzalloc(sizeof(*(taiko->fw_data)), GFP_KERNEL);
+ if (!taiko->fw_data) {
+ dev_err(codec->dev, "Failed to allocate fw_data\n");
+ goto err_nomem_slimch;
+ }
+ set_bit(WCD9XXX_ANC_CAL, taiko->fw_data->cal_bit);
+ set_bit(WCD9XXX_MAD_CAL, taiko->fw_data->cal_bit);
+ set_bit(WCD9XXX_MBHC_CAL, taiko->fw_data->cal_bit);
+ ret = wcd_cal_create_hwdep(taiko->fw_data,
+ WCD9XXX_CODEC_HWDEP_NODE, codec);
+ if (ret < 0) {
+ dev_err(codec->dev, "%s hwdep failed %d\n", __func__, ret);
+ goto err_hwdep;
+ }
/* init and start mbhc */
ret = wcd9xxx_mbhc_init(&taiko->mbhc, &taiko->resmgr, codec,
taiko_enable_mbhc_micbias,
@@ -7113,7 +7203,7 @@
rco_clk_rate, true);
if (ret) {
pr_err("%s: mbhc init failed %d\n", __func__, ret);
- goto err_init;
+ goto err_hwdep;
}
taiko->codec = codec;
@@ -7137,7 +7227,7 @@
ret = taiko_handle_pdata(taiko);
if (IS_ERR_VALUE(ret)) {
pr_err("%s: bad pdata\n", __func__);
- goto err_pdata;
+ goto err_hwdep;
}
taiko->spkdrv_reg = taiko_codec_find_regulator(codec,
@@ -7155,7 +7245,7 @@
if (!ptr) {
pr_err("%s: no mem for slim chan ctl data\n", __func__);
ret = -ENOMEM;
- goto err_nomem_slimch;
+ goto err_hwdep;
}
if (taiko->intf_type == WCD9XXX_INTERFACE_TYPE_I2C) {
@@ -7233,11 +7323,11 @@
err_irq:
taiko_cleanup_irqs(taiko);
-err_pdata:
- kfree(ptr);
+ kfree(ptr);
+err_hwdep:
+ kfree(taiko->fw_data);
err_nomem_slimch:
kfree(taiko);
-err_init:
return ret;
}
static int taiko_codec_remove(struct snd_soc_codec *codec)
@@ -7261,6 +7351,7 @@
taiko->spkdrv_reg = NULL;
+ kfree(taiko->fw_data);
kfree(taiko);
return 0;
}
diff --git a/sound/soc/codecs/wcd9xxx-mbhc.c b/sound/soc/codecs/wcd9xxx-mbhc.c
index 09721e1..1475df2 100644
--- a/sound/soc/codecs/wcd9xxx-mbhc.c
+++ b/sound/soc/codecs/wcd9xxx-mbhc.c
@@ -35,6 +35,7 @@
#include <linux/kernel.h>
#include <linux/gpio.h>
#include <linux/input.h>
+#include "wcdcal-hwdep.h"
#include "wcd9320.h"
#include "wcd9306.h"
#include "wcd9xxx-mbhc.h"
@@ -74,7 +75,7 @@
#define OCP_ATTEMPT 1
#define FW_READ_ATTEMPTS 15
-#define FW_READ_TIMEOUT 2000000
+#define FW_READ_TIMEOUT 4000000
#define BUTTON_POLLING_SUPPORTED true
@@ -2806,35 +2807,39 @@
wcd9xxx_unlock_sleep(core_res);
}
-static bool wcd9xxx_mbhc_fw_validate(const struct firmware *fw)
+static bool wcd9xxx_mbhc_fw_validate(const void *data, size_t size)
{
u32 cfg_offset;
struct wcd9xxx_mbhc_imped_detect_cfg *imped_cfg;
struct wcd9xxx_mbhc_btn_detect_cfg *btn_cfg;
+ struct firmware_cal fw;
- if (fw->size < WCD9XXX_MBHC_CAL_MIN_SIZE)
+ fw.data = (void *)data;
+ fw.size = size;
+
+ if (fw.size < WCD9XXX_MBHC_CAL_MIN_SIZE)
return false;
/*
* Previous check guarantees that there is enough fw data up
* to num_btn
*/
- btn_cfg = WCD9XXX_MBHC_CAL_BTN_DET_PTR(fw->data);
- cfg_offset = (u32) ((void *) btn_cfg - (void *) fw->data);
- if (fw->size < (cfg_offset + WCD9XXX_MBHC_CAL_BTN_SZ(btn_cfg)))
+ btn_cfg = WCD9XXX_MBHC_CAL_BTN_DET_PTR(fw.data);
+ cfg_offset = (u32) ((void *) btn_cfg - (void *) fw.data);
+ if (fw.size < (cfg_offset + WCD9XXX_MBHC_CAL_BTN_SZ(btn_cfg)))
return false;
/*
* Previous check guarantees that there is enough fw data up
* to start of impedance detection configuration
*/
- imped_cfg = WCD9XXX_MBHC_CAL_IMPED_DET_PTR(fw->data);
- cfg_offset = (u32) ((void *) imped_cfg - (void *) fw->data);
+ imped_cfg = WCD9XXX_MBHC_CAL_IMPED_DET_PTR(fw.data);
+ cfg_offset = (u32) ((void *) imped_cfg - (void *) fw.data);
- if (fw->size < (cfg_offset + WCD9XXX_MBHC_CAL_IMPED_MIN_SZ))
+ if (fw.size < (cfg_offset + WCD9XXX_MBHC_CAL_IMPED_MIN_SZ))
return false;
- if (fw->size < (cfg_offset + WCD9XXX_MBHC_CAL_IMPED_SZ(imped_cfg)))
+ if (fw.size < (cfg_offset + WCD9XXX_MBHC_CAL_IMPED_SZ(imped_cfg)))
return false;
return true;
@@ -4171,7 +4176,9 @@
struct wcd9xxx_mbhc *mbhc;
struct snd_soc_codec *codec;
const struct firmware *fw;
+ struct firmware_cal *fw_data = NULL;
int ret = -1, retry = 0;
+ bool use_default_cal = false;
dwork = to_delayed_work(work);
mbhc = container_of(dwork, struct wcd9xxx_mbhc, mbhc_firmware_dwork);
@@ -4179,29 +4186,62 @@
while (retry < FW_READ_ATTEMPTS) {
retry++;
- pr_info("%s:Attempt %d to request MBHC firmware\n",
- __func__, retry);
- ret = request_firmware(&fw, "wcd9320/wcd9320_mbhc.bin",
- codec->dev);
-
- if (ret != 0) {
+ pr_debug("%s:Attempt %d to request MBHC firmware\n",
+ __func__, retry);
+ if (mbhc->mbhc_cb->get_hwdep_fw_cal)
+ fw_data = mbhc->mbhc_cb->get_hwdep_fw_cal(codec,
+ WCD9XXX_MBHC_CAL);
+ if (!fw_data)
+ ret = request_firmware(&fw, "wcd9320/wcd9320_mbhc.bin",
+ codec->dev);
+ /*
+ * if request_firmware and hwdep cal both fail then
+ * retry for few times before bailing out
+ */
+ if ((ret != 0) && !fw_data) {
usleep_range(FW_READ_TIMEOUT, FW_READ_TIMEOUT);
} else {
pr_info("%s: MBHC Firmware read succesful\n", __func__);
break;
}
}
-
- if (ret != 0) {
+ if (!fw_data)
+ pr_debug("%s: using request_firmware\n", __func__);
+ else
+ pr_debug("%s: using hwdep cal\n", __func__);
+ if (ret != 0 && !fw_data) {
pr_err("%s: Cannot load MBHC firmware use default cal\n",
- __func__);
- } else if (wcd9xxx_mbhc_fw_validate(fw) == false) {
- pr_err("%s: Invalid MBHC cal data size use default cal\n",
- __func__);
- release_firmware(fw);
- } else {
- mbhc->mbhc_cfg->calibration = (void *)fw->data;
- mbhc->mbhc_fw = fw;
+ __func__);
+ use_default_cal = true;
+ }
+ if (!use_default_cal) {
+ const void *data;
+ size_t size;
+
+ if (fw_data) {
+ data = fw_data->data;
+ size = fw_data->size;
+ } else {
+ data = fw->data;
+ size = fw->size;
+ }
+ if (wcd9xxx_mbhc_fw_validate(data, size) == false) {
+ pr_err("%s: Invalid MBHC cal data size use default cal\n",
+ __func__);
+ if (!fw_data)
+ release_firmware(fw);
+ } else {
+ if (fw_data) {
+ mbhc->mbhc_cfg->calibration =
+ (void *)fw_data->data;
+ mbhc->mbhc_cal = fw_data;
+ } else {
+ mbhc->mbhc_cfg->calibration =
+ (void *)fw->data;
+ mbhc->mbhc_fw = fw;
+ }
+ }
+
}
(void) wcd9xxx_init_and_calibrate(mbhc);
@@ -4391,15 +4431,16 @@
mbhc->mbhc_cb->enable_clock_gate(mbhc->codec, true);
if (!mbhc->mbhc_cfg->read_fw_bin ||
- (mbhc->mbhc_cfg->read_fw_bin && mbhc->mbhc_fw)) {
+ (mbhc->mbhc_cfg->read_fw_bin && mbhc->mbhc_fw) ||
+ (mbhc->mbhc_cfg->read_fw_bin && mbhc->mbhc_cal)) {
rc = wcd9xxx_init_and_calibrate(mbhc);
} else {
- if (!mbhc->mbhc_fw)
+ if (!mbhc->mbhc_fw || !mbhc->mbhc_cal)
schedule_delayed_work(&mbhc->mbhc_firmware_dwork,
usecs_to_jiffies(FW_READ_TIMEOUT));
else
- pr_debug("%s: Skipping to read mbhc fw, 0x%p\n",
- __func__, mbhc->mbhc_fw);
+ pr_debug("%s: Skipping to read mbhc fw, 0x%p 0x%p\n",
+ __func__, mbhc->mbhc_fw, mbhc->mbhc_cal);
}
pr_debug("%s: leave %d\n", __func__, rc);
@@ -4409,10 +4450,12 @@
void wcd9xxx_mbhc_stop(struct wcd9xxx_mbhc *mbhc)
{
- if (mbhc->mbhc_fw) {
+ if (mbhc->mbhc_fw || mbhc->mbhc_cal) {
cancel_delayed_work_sync(&mbhc->mbhc_firmware_dwork);
- release_firmware(mbhc->mbhc_fw);
+ if (!mbhc->mbhc_cal)
+ release_firmware(mbhc->mbhc_fw);
mbhc->mbhc_fw = NULL;
+ mbhc->mbhc_cal = NULL;
}
}
EXPORT_SYMBOL(wcd9xxx_mbhc_stop);
diff --git a/sound/soc/codecs/wcd9xxx-mbhc.h b/sound/soc/codecs/wcd9xxx-mbhc.h
index 91edaca..7eba649 100644
--- a/sound/soc/codecs/wcd9xxx-mbhc.h
+++ b/sound/soc/codecs/wcd9xxx-mbhc.h
@@ -13,6 +13,7 @@
#define __WCD9XXX_MBHC_H__
#include "wcd9xxx-resmgr.h"
+#include "wcdcal-hwdep.h"
#define WCD9XXX_CFILT_FAST_MODE 0x00
#define WCD9XXX_CFILT_SLOW_MODE 0x40
@@ -285,6 +286,9 @@
int (*enable_mb_source) (struct snd_soc_codec *, bool, bool);
void (*setup_int_rbias) (struct snd_soc_codec *, bool);
void (*pull_mb_to_vddio) (struct snd_soc_codec *, bool);
+ struct firmware_cal * (*get_hwdep_fw_cal) (struct snd_soc_codec *,
+ enum wcd_cal_type);
+
};
struct wcd9xxx_mbhc {
@@ -312,6 +316,7 @@
const struct firmware *mbhc_fw;
struct delayed_work mbhc_insert_dwork;
+ struct firmware_cal *mbhc_cal;
u8 current_plug;
struct work_struct correct_plug_swch;
diff --git a/sound/soc/codecs/wcdcal-hwdep.c b/sound/soc/codecs/wcdcal-hwdep.c
new file mode 100644
index 0000000..1132a3c
--- /dev/null
+++ b/sound/soc/codecs/wcdcal-hwdep.c
@@ -0,0 +1,221 @@
+/*
+ * Copyright (c) 2014, 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/slab.h>
+#include <linux/module.h>
+#include <linux/ioctl.h>
+#include <linux/bitops.h>
+#include <sound/hwdep.h>
+#include <sound/msmcal-hwdep.h>
+#include <sound/soc.h>
+#include "wcdcal-hwdep.h"
+
+const int cal_size_info[WCD9XXX_MAX_CAL] = {
+ [WCD9XXX_ANC_CAL] = 4096,
+ [WCD9XXX_MBHC_CAL] = 4096,
+ [WCD9XXX_MAD_CAL] = 4096,
+};
+
+const char *cal_name_info[WCD9XXX_MAX_CAL] = {
+ [WCD9XXX_ANC_CAL] = "anc",
+ [WCD9XXX_MBHC_CAL] = "mbhc",
+ [WCD9XXX_MAD_CAL] = "mad",
+};
+
+struct firmware_cal *wcdcal_get_fw_cal(struct fw_info *fw_data,
+ enum wcd_cal_type type)
+{
+ if (!fw_data) {
+ pr_err("%s: fw_data is NULL\n", __func__);
+ return NULL;
+ }
+ if (type >= WCD9XXX_MAX_CAL ||
+ type < WCD9XXX_MIN_CAL) {
+ pr_err("%s: wrong cal type sent %d\n", __func__, type);
+ return NULL;
+ }
+ mutex_lock(&fw_data->lock);
+ if (!test_bit(WCDCAL_RECIEVED,
+ &fw_data->wcdcal_state[type])) {
+ pr_err("%s: cal not sent by userspace %d\n",
+ __func__, type);
+ mutex_unlock(&fw_data->lock);
+ return NULL;
+ }
+ mutex_unlock(&fw_data->lock);
+ return fw_data->fw[type];
+}
+EXPORT_SYMBOL(wcdcal_get_fw_cal);
+
+static int wcdcal_hwdep_ioctl_shared(struct snd_hwdep *hw,
+ struct wcdcal_ioctl_buffer fw_user)
+{
+ struct fw_info *fw_data = hw->private_data;
+ struct firmware_cal **fw = fw_data->fw;
+ void *data;
+
+ if (!test_bit(fw_user.cal_type, fw_data->cal_bit)) {
+ pr_err("%s: codec didn't set this %d!!\n",
+ __func__, fw_user.cal_type);
+ return -EFAULT;
+ }
+ if (fw_user.cal_type >= WCD9XXX_MAX_CAL ||
+ fw_user.cal_type < WCD9XXX_MIN_CAL) {
+ pr_err("%s: wrong cal type sent %d\n",
+ __func__, fw_user.cal_type);
+ return -EFAULT;
+ }
+ if (fw_user.size > cal_size_info[fw_user.cal_type] ||
+ fw_user.size <= 0) {
+ pr_err("%s: incorrect firmware size %d for %s\n",
+ __func__, fw_user.size,
+ cal_name_info[fw_user.cal_type]);
+ return -EFAULT;
+ }
+ data = fw[fw_user.cal_type]->data;
+ memcpy(data, fw_user.buffer, fw_user.size);
+ fw[fw_user.cal_type]->size = fw_user.size;
+ mutex_lock(&fw_data->lock);
+ set_bit(WCDCAL_RECIEVED, &fw_data->wcdcal_state[fw_user.cal_type]);
+ mutex_unlock(&fw_data->lock);
+ return 0;
+}
+
+#ifdef CONFIG_COMPAT
+struct wcdcal_ioctl_buffer32 {
+ u32 size;
+ compat_uptr_t buffer;
+ enum wcd_cal_type cal_type;
+};
+
+enum {
+ SNDRV_CTL_IOCTL_HWDEP_CAL_TYPE32 =
+ _IOW('U', 0x1, struct wcdcal_ioctl_buffer32),
+};
+
+static int wcdcal_hwdep_ioctl_compat(struct snd_hwdep *hw, struct file *file,
+ unsigned int cmd, unsigned long arg)
+{
+ struct wcdcal_ioctl_buffer __user *argp = (void __user *)arg;
+ struct wcdcal_ioctl_buffer32 fw_user32;
+ struct wcdcal_ioctl_buffer fw_user_compat;
+
+ if (cmd != SNDRV_CTL_IOCTL_HWDEP_CAL_TYPE32) {
+ pr_err("%s: wrong ioctl command sent %u!\n", __func__, cmd);
+ return -ENOIOCTLCMD;
+ }
+ if (copy_from_user(&fw_user32, argp, sizeof(fw_user32))) {
+ pr_err("%s: failed to copy\n", __func__);
+ return -EFAULT;
+ }
+ fw_user_compat.size = fw_user32.size;
+ fw_user_compat.buffer = compat_ptr(fw_user32.buffer);
+ fw_user_compat.cal_type = fw_user32.cal_type;
+ return wcdcal_hwdep_ioctl_shared(hw, fw_user_compat);
+}
+#else
+#define wcdcal_hwdep_ioctl_compat NULL
+#endif
+
+static int wcdcal_hwdep_ioctl(struct snd_hwdep *hw, struct file *file,
+ unsigned int cmd, unsigned long arg)
+{
+ struct wcdcal_ioctl_buffer __user *argp = (void __user *)arg;
+ struct wcdcal_ioctl_buffer fw_user;
+
+ if (cmd != SNDRV_CTL_IOCTL_HWDEP_CAL_TYPE) {
+ pr_err("%s: wrong ioctl command sent %d!\n", __func__, cmd);
+ return -ENOIOCTLCMD;
+ }
+ if (copy_from_user(&fw_user, argp, sizeof(fw_user))) {
+ pr_err("%s: failed to copy\n", __func__);
+ return -EFAULT;
+ }
+ return wcdcal_hwdep_ioctl_shared(hw, fw_user);
+}
+
+static int wcdcal_hwdep_release(struct snd_hwdep *hw, struct file *file)
+{
+ struct fw_info *fw_data = hw->private_data;
+ mutex_lock(&fw_data->lock);
+ /* clear all the calibrations */
+ memset(fw_data->wcdcal_state, 0,
+ sizeof(fw_data->wcdcal_state));
+ mutex_unlock(&fw_data->lock);
+ return 0;
+}
+
+int wcd_cal_create_hwdep(void *data, int node, struct snd_soc_codec *codec)
+{
+ char hwname[40];
+ struct snd_hwdep *hwdep;
+ struct firmware_cal **fw;
+ struct fw_info *fw_data = data;
+ int err, cal_bit;
+
+ if (!fw_data || !codec) {
+ pr_err("%s: wrong arguments passed\n", __func__);
+ return -EINVAL;
+ }
+
+ fw = fw_data->fw;
+ snprintf(hwname, strlen("Codec %s"), "Codec %s", codec->name);
+ err = snd_hwdep_new(codec->card->snd_card, hwname, node, &hwdep);
+ if (err < 0) {
+ dev_err(codec->dev, "%s: new hwdep failed %d\n",
+ __func__, err);
+ return err;
+ }
+ snprintf(hwdep->name, strlen("Codec %s"), "Codec %s", codec->name);
+ hwdep->iface = SNDRV_HWDEP_IFACE_AUDIO_CODEC;
+ hwdep->private_data = fw_data;
+ hwdep->ops.ioctl_compat = wcdcal_hwdep_ioctl_compat;
+ hwdep->ops.ioctl = wcdcal_hwdep_ioctl;
+ hwdep->ops.release = wcdcal_hwdep_release;
+ mutex_init(&fw_data->lock);
+
+ for_each_set_bit(cal_bit, fw_data->cal_bit, WCD9XXX_MAX_CAL) {
+ set_bit(WCDCAL_UNINITIALISED,
+ &fw_data->wcdcal_state[cal_bit]);
+ fw[cal_bit] = kzalloc(sizeof *(fw[cal_bit]), GFP_KERNEL);
+ if (!fw[cal_bit]) {
+ dev_err(codec->dev, "%s: no memory for %s cal\n",
+ __func__, cal_name_info[cal_bit]);
+ goto end;
+ }
+ }
+ for_each_set_bit(cal_bit, fw_data->cal_bit, WCD9XXX_MAX_CAL) {
+ fw[cal_bit]->data = kzalloc(cal_size_info[cal_bit],
+ GFP_KERNEL);
+ if (!fw[cal_bit]->data) {
+ dev_err(codec->dev, "%s: no memory for %s cal data\n",
+ __func__, cal_name_info[cal_bit]);
+ goto exit;
+ }
+ set_bit(WCDCAL_INITIALISED,
+ &fw_data->wcdcal_state[cal_bit]);
+ }
+ return 0;
+exit:
+ for_each_set_bit(cal_bit, fw_data->cal_bit, WCD9XXX_MAX_CAL) {
+ kfree(fw[cal_bit]->data);
+ fw[cal_bit]->data = NULL;
+ }
+end:
+ for_each_set_bit(cal_bit, fw_data->cal_bit, WCD9XXX_MAX_CAL) {
+ kfree(fw[cal_bit]);
+ fw[cal_bit] = NULL;
+ }
+ return -ENOMEM;
+}
+EXPORT_SYMBOL(wcd_cal_create_hwdep);
diff --git a/sound/soc/codecs/wcdcal-hwdep.h b/sound/soc/codecs/wcdcal-hwdep.h
new file mode 100644
index 0000000..632e2f1
--- /dev/null
+++ b/sound/soc/codecs/wcdcal-hwdep.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2014, 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 __WCD9XXX_HWDEP_H__
+#define __WCD9XXX_HWDEP_H__
+#include <sound/msmcal-hwdep.h>
+
+enum wcd_cal_states {
+ WCDCAL_UNINITIALISED,
+ WCDCAL_INITIALISED,
+ WCDCAL_RECIEVED
+};
+
+struct fw_info {
+ struct firmware_cal *fw[WCD9XXX_MAX_CAL];
+ DECLARE_BITMAP(cal_bit, WCD9XXX_MAX_CAL);
+ /* for calibration tracking */
+ unsigned long wcdcal_state[WCD9XXX_MAX_CAL];
+ struct mutex lock;
+};
+
+struct firmware_cal {
+ u8 *data;
+ size_t size;
+};
+
+struct snd_soc_codec;
+int wcd_cal_create_hwdep(void *fw, int node, struct snd_soc_codec *codec);
+struct firmware_cal *wcdcal_get_fw_cal(struct fw_info *fw_data,
+ enum wcd_cal_type type);
+#endif /* __WCD9XXX_HWDEP_H__ */
diff --git a/sound/soc/msm/Kconfig b/sound/soc/msm/Kconfig
index 86dd840..fbcd953 100644
--- a/sound/soc/msm/Kconfig
+++ b/sound/soc/msm/Kconfig
@@ -183,6 +183,7 @@
select SND_DYNAMIC_MINORS
select AUDIO_OCMEM
select DOLBY_DAP
+ select SND_HWDEP
help
To add support for SoC audio on MSM8974.
This will enable sound soc drivers which
diff --git a/sound/soc/msm/qdsp6v2/msm-compress-q6-v2.c b/sound/soc/msm/qdsp6v2/msm-compress-q6-v2.c
index 4ca5764..ae5c42f 100644
--- a/sound/soc/msm/qdsp6v2/msm-compress-q6-v2.c
+++ b/sound/soc/msm/qdsp6v2/msm-compress-q6-v2.c
@@ -304,6 +304,7 @@
uint32_t sample_rate = 0;
int bytes_available, stream_id;
uint32_t stream_index;
+ unsigned long flags;
pr_debug("%s opcode =%08x\n", __func__, opcode);
switch (opcode) {
@@ -476,12 +477,17 @@
case RESET_EVENTS:
pr_err("%s: Received reset events CB, move to error state",
__func__);
- spin_lock(&prtd->lock);
+ spin_lock_irqsave(&prtd->lock, flags);
snd_compr_fragment_elapsed(cstream);
prtd->copied_total = prtd->bytes_received;
atomic_set(&prtd->error, 1);
wake_up(&prtd->drain_wait);
- spin_unlock(&prtd->lock);
+ if (atomic_read(&prtd->eos)) {
+ pr_debug("%s:unblock eos wait queues", __func__);
+ wake_up(&prtd->eos_wait);
+ atomic_set(&prtd->eos, 0);
+ }
+ spin_unlock_irqrestore(&prtd->lock, flags);
break;
default:
pr_debug("%s: Not Supported Event opcode[0x%x]\n",
@@ -1249,7 +1255,9 @@
/* Wait indefinitely for DRAIN. Flush can also signal this*/
rc = wait_event_interruptible(prtd->eos_wait,
- (prtd->cmd_ack || prtd->cmd_interrupt));
+ (prtd->cmd_ack ||
+ prtd->cmd_interrupt ||
+ atomic_read(&prtd->error)));
if (rc < 0)
pr_err("%s: EOS wait failed\n", __func__);
@@ -1260,6 +1268,11 @@
if (prtd->cmd_interrupt)
rc = -EINTR;
+ if (atomic_read(&prtd->error)) {
+ pr_err("%s: Got RESET EVENTS notification, return\n", __func__);
+ rc = -ENETRESET;
+ }
+
/*FIXME : what if a flush comes while PC is here */
if (rc == 0) {
/*