* [PATCH v2 1/3] remoteproc: qcom: Encapsulate pvt data structure for q6v56 hexagon.
[not found] <1478268057-11847-1-git-send-email-akdwived@codeaurora.org>
@ 2016-11-04 14:00 ` Avaneesh Kumar Dwivedi
2016-11-04 23:51 ` kbuild test robot
2016-11-10 20:30 ` Rob Herring
2016-11-04 14:00 ` [PATCH v2 2/3] remoteproc: qcom: Hexagon version independent resource handling Avaneesh Kumar Dwivedi
2016-11-04 14:00 ` [PATCH v2 3/3] remoteproc: qcom: Adding q6v56 reset sequence in existing reset sequence Avaneesh Kumar Dwivedi
2 siblings, 2 replies; 7+ messages in thread
From: Avaneesh Kumar Dwivedi @ 2016-11-04 14:00 UTC (permalink / raw)
To: bjorn.andersson
Cc: Avaneesh Kumar Dwivedi, Ohad Ben-Cohen, Rob Herring,
Mark Rutland, open list:REMOTE PROCESSOR (REMOTEPROC) SUBSYSTEM,
open list:OPEN FIRMWARE AND FLATTENED DEVICE TREE BINDINGS,
open list
Encapsulate resources specific to each version of hexagon chip to
device node to avoid conditional check for manipulation of those
resources in driver code.
Signed-off-by: Avaneesh Kumar Dwivedi <akdwived@codeaurora.org>
---
.../devicetree/bindings/remoteproc/qcom,q6v5.txt | 1 +
drivers/remoteproc/qcom_q6v5_pil.c | 137 ++++++++++++++++++---
2 files changed, 120 insertions(+), 18 deletions(-)
diff --git a/Documentation/devicetree/bindings/remoteproc/qcom,q6v5.txt b/Documentation/devicetree/bindings/remoteproc/qcom,q6v5.txt
index 57cb49e..cbc165c 100644
--- a/Documentation/devicetree/bindings/remoteproc/qcom,q6v5.txt
+++ b/Documentation/devicetree/bindings/remoteproc/qcom,q6v5.txt
@@ -8,6 +8,7 @@ on the Qualcomm Hexagon core.
Value type: <string>
Definition: must be one of:
"qcom,q6v5-pil"
+ "qcom,q6v56-pil"
- reg:
Usage: required
diff --git a/drivers/remoteproc/qcom_q6v5_pil.c b/drivers/remoteproc/qcom_q6v5_pil.c
index 2e0caaa..3d26199 100644
--- a/drivers/remoteproc/qcom_q6v5_pil.c
+++ b/drivers/remoteproc/qcom_q6v5_pil.c
@@ -30,13 +30,13 @@
#include <linux/reset.h>
#include <linux/soc/qcom/smem.h>
#include <linux/soc/qcom/smem_state.h>
+#include <linux/of_device.h>
#include "remoteproc_internal.h"
#include "qcom_mdt_loader.h"
#include <linux/qcom_scm.h>
-#define MBA_FIRMWARE_NAME "mba.b00"
#define MPSS_FIRMWARE_NAME "modem.mdt"
#define MPSS_CRASH_REASON_SMEM 421
@@ -93,13 +93,32 @@
#define QDSS_BHS_ON BIT(21)
#define QDSS_LDO_BYP BIT(22)
+struct q6_rproc_res {
+ char **proxy_clks;
+ int proxy_clk_cnt;
+ char **active_clks;
+ int active_clk_cnt;
+ char **proxy_regs;
+ int proxy_reg_cnt;
+ char **active_regs;
+ int active_reg_cnt;
+ int **proxy_reg_action;
+ int **active_reg_action;
+ int *proxy_reg_load;
+ int *active_reg_load;
+ int *proxy_reg_voltage;
+ int *active_reg_voltage;
+ char *q6_version;
+ char *q6_mba_image;
+ int (*q6_reset_init)(void *q, void *p);
+};
struct q6v5 {
struct device *dev;
struct rproc *rproc;
void __iomem *reg_base;
void __iomem *rmb_base;
-
+ void __iomem *restart_reg;
struct regmap *halt_map;
u32 halt_q6;
u32 halt_modem;
@@ -111,7 +130,7 @@ struct q6v5 {
unsigned stop_bit;
struct regulator_bulk_data supply[4];
-
+ struct q6_rproc_res *q6_rproc_res;
struct clk *ahb_clk;
struct clk *axi_clk;
struct clk *rom_clk;
@@ -198,7 +217,7 @@ static int q6v5_load(struct rproc *rproc, const struct firmware *fw)
return 0;
}
-static const struct rproc_fw_ops q6v5_fw_ops = {
+static const struct rproc_fw_ops q6_fw_ops = {
.find_rsc_table = qcom_mdt_find_rsc_table,
.load = q6v5_load,
};
@@ -599,7 +618,7 @@ static void *q6v5_da_to_va(struct rproc *rproc, u64 da, int len)
return qproc->mpss_region + offset;
}
-static const struct rproc_ops q6v5_ops = {
+static const struct rproc_ops q6_ops = {
.start = q6v5_start,
.stop = q6v5_stop,
.da_to_va = q6v5_da_to_va,
@@ -736,6 +755,22 @@ static int q6v5_init_reset(struct q6v5 *qproc)
return 0;
}
+static int q6v56_init_reset(void *q, void *p)
+{
+ struct resource *res;
+ struct q6v5 *qproc = q;
+ struct platform_device *pdev = p;
+
+ res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "restart_reg");
+ qproc->restart_reg = devm_ioremap(qproc->dev, res->start,
+ resource_size(res));
+ if (IS_ERR(qproc->restart_reg)) {
+ dev_err(qproc->dev, "failed to get restart_reg\n");
+ return PTR_ERR(qproc->restart_reg);
+ }
+
+ return 0;
+}
static int q6v5_request_irq(struct q6v5 *qproc,
struct platform_device *pdev,
const char *name,
@@ -803,20 +838,25 @@ static int q6v5_alloc_memory_region(struct q6v5 *qproc)
return 0;
}
-static int q6v5_probe(struct platform_device *pdev)
+static int q6_probe(struct platform_device *pdev)
{
struct q6v5 *qproc;
struct rproc *rproc;
+ struct q6_rproc_res *desc;
int ret;
- rproc = rproc_alloc(&pdev->dev, pdev->name, &q6v5_ops,
- MBA_FIRMWARE_NAME, sizeof(*qproc));
+ desc = of_device_get_match_data(&pdev->dev);
+ if (!desc)
+ return -EINVAL;
+
+ rproc = rproc_alloc(&pdev->dev, pdev->name, &q6_ops,
+ desc->q6_mba_image, sizeof(*qproc));
if (!rproc) {
dev_err(&pdev->dev, "failed to allocate rproc\n");
return -ENOMEM;
}
- rproc->fw_ops = &q6v5_fw_ops;
+ rproc->fw_ops = &q6_fw_ops;
qproc = (struct q6v5 *)rproc->priv;
qproc->dev = &pdev->dev;
@@ -826,6 +866,7 @@ static int q6v5_probe(struct platform_device *pdev)
init_completion(&qproc->start_done);
init_completion(&qproc->stop_done);
+ qproc->q6_rproc_res = desc;
ret = q6v5_init_mem(qproc, pdev);
if (ret)
goto free_rproc;
@@ -842,7 +883,7 @@ static int q6v5_probe(struct platform_device *pdev)
if (ret)
goto free_rproc;
- ret = q6v5_init_reset(qproc);
+ ret = qproc->q6_rproc_res->q6_reset_init(qproc, pdev);
if (ret)
goto free_rproc;
@@ -880,7 +921,7 @@ static int q6v5_probe(struct platform_device *pdev)
return ret;
}
-static int q6v5_remove(struct platform_device *pdev)
+static int q6_remove(struct platform_device *pdev)
{
struct q6v5 *qproc = platform_get_drvdata(pdev);
@@ -890,20 +931,80 @@ static int q6v5_remove(struct platform_device *pdev)
return 0;
}
-static const struct of_device_id q6v5_of_match[] = {
- { .compatible = "qcom,q6v5-pil", },
+char *proxy_8x96_reg_str[] = {"mx", "cx", "vdd_pll"};
+int proxy_8x96_reg_action[3][2] = { {0, 1}, {1, 1}, {1, 0} };
+int proxy_8x96_reg_load[] = {0, 100000, 100000};
+int proxy_8x96_reg_min_voltage[] = {1050000, 1250000, 0};
+char *proxy_8x96_clk_str[] = {"xo", "pnoc", "qdss"};
+char *active_8x96_clk_str[] = {"iface", "bus", "mem", "gpll0_mss_clk",
+ "snoc_axi_clk", "mnoc_axi_clk"};
+
+static struct q6_rproc_res msm_8996_res = {
+ .proxy_clks = proxy_8x96_clk_str,
+ .proxy_clk_cnt = 3,
+ .active_clks = active_8x96_clk_str,
+ .active_clk_cnt = 6,
+ .proxy_regs = proxy_8x96_reg_str,
+ .active_regs = NULL,
+ .proxy_reg_action = (int **)proxy_8x96_reg_action,
+ .proxy_reg_load = (int *)proxy_8x96_reg_load,
+ .active_reg_action = NULL,
+ .active_reg_load = NULL,
+ .proxy_reg_voltage = (int *)proxy_8x96_reg_min_voltage,
+ .active_reg_voltage = NULL,
+ .proxy_reg_cnt = 3,
+ .active_reg_cnt = 0,
+ .q6_reset_init = q6v56_init_reset,
+ .q6_version = "v56",
+ .q6_mba_image = "mba.mbn",
+};
+
+char *proxy_8x16_reg_str[] = {"mx", "cx", "pll"};
+char *active_8x16_reg_str[] = {"mss"};
+int proxy_8x16_reg_action[4][2] = { {0, 1}, {1, 0}, {1, 0} };
+int active_8x16_reg_action[1][2] = { {1, 1} };
+int proxy_8x16_reg_load[] = {100000, 0, 100000, 100000};
+int active_8x16_reg_load[] = {100000};
+int proxy_8x16_reg_min_voltage[] = {1050000, 0, 0};
+int active_8x16_reg_min_voltage[] = {1000000};
+char *proxy_8x16_clk_str[] = {"xo"};
+char *active_8x16_clk_str[] = {"iface", "bus", "mem"};
+
+static struct q6_rproc_res msm_8916_res = {
+ .proxy_clks = proxy_8x16_clk_str,
+ .proxy_clk_cnt = 1,
+ .active_clks = active_8x16_clk_str,
+ .active_clk_cnt = 3,
+ .proxy_regs = proxy_8x16_reg_str,
+ .active_regs = active_8x16_reg_str,
+ .proxy_reg_action = (int **)proxy_8x16_reg_action,
+ .proxy_reg_load = (int *)proxy_8x16_reg_load,
+ .active_reg_action = (int **)active_8x16_reg_action,
+ .active_reg_load = (int *)active_8x16_reg_load,
+ .proxy_reg_voltage = (int *)proxy_8x16_reg_min_voltage,
+ .active_reg_voltage = active_8x16_reg_min_voltage,
+ .proxy_reg_cnt = 3,
+ .active_reg_cnt = 1,
+ .q6_reset_init = q6v5_init_reset,
+ .q6_version = "v5",
+ .q6_mba_image = "mba.b00",
+};
+
+static const struct of_device_id q6_of_match[] = {
+ { .compatible = "qcom,q6v5-pil", .data = &msm_8916_res},
+ { .compatible = "qcom,q6v56-pil", .data = &msm_8996_res},
{ },
};
-static struct platform_driver q6v5_driver = {
- .probe = q6v5_probe,
- .remove = q6v5_remove,
+static struct platform_driver q6_driver = {
+ .probe = q6_probe,
+ .remove = q6_remove,
.driver = {
.name = "qcom-q6v5-pil",
- .of_match_table = q6v5_of_match,
+ .of_match_table = q6_of_match,
},
};
-module_platform_driver(q6v5_driver);
+module_platform_driver(q6_driver);
MODULE_DESCRIPTION("Peripheral Image Loader for Hexagon");
MODULE_LICENSE("GPL v2");
--
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum,
a Linux Foundation Collaborative Project
^ permalink raw reply related [flat|nested] 7+ messages in thread
* [PATCH v2 2/3] remoteproc: qcom: Hexagon version independent resource handling
[not found] <1478268057-11847-1-git-send-email-akdwived@codeaurora.org>
2016-11-04 14:00 ` [PATCH v2 1/3] remoteproc: qcom: Encapsulate pvt data structure for q6v56 hexagon Avaneesh Kumar Dwivedi
@ 2016-11-04 14:00 ` Avaneesh Kumar Dwivedi
2016-11-04 14:00 ` [PATCH v2 3/3] remoteproc: qcom: Adding q6v56 reset sequence in existing reset sequence Avaneesh Kumar Dwivedi
2 siblings, 0 replies; 7+ messages in thread
From: Avaneesh Kumar Dwivedi @ 2016-11-04 14:00 UTC (permalink / raw)
To: bjorn.andersson
Cc: Avaneesh Kumar Dwivedi, Ohad Ben-Cohen,
open list:REMOTE PROCESSOR (REMOTEPROC) SUBSYSTEM, open list
Handling of clock and regulator resources as well as reset register
programing differe depending upon version of hexagon chip version as
number of resource to program differ and parameters to program also
differ, hence it is needed to make these functions version independent.
Signed-off-by: Avaneesh Kumar Dwivedi <akdwived@codeaurora.org>
---
drivers/remoteproc/qcom_q6v5_pil.c | 475 +++++++++++++++++++++++++++----------
1 file changed, 348 insertions(+), 127 deletions(-)
diff --git a/drivers/remoteproc/qcom_q6v5_pil.c b/drivers/remoteproc/qcom_q6v5_pil.c
index 3d26199..9db1d4b 100644
--- a/drivers/remoteproc/qcom_q6v5_pil.c
+++ b/drivers/remoteproc/qcom_q6v5_pil.c
@@ -30,6 +30,7 @@
#include <linux/reset.h>
#include <linux/soc/qcom/smem.h>
#include <linux/soc/qcom/smem_state.h>
+#include <linux/mutex.h>
#include <linux/of_device.h>
#include "remoteproc_internal.h"
@@ -93,6 +94,8 @@
#define QDSS_BHS_ON BIT(21)
#define QDSS_LDO_BYP BIT(22)
+#define QDSP6v56_CLAMP_WL BIT(21)
+#define QDSP6v56_CLAMP_QMC_MEM BIT(22)
struct q6_rproc_res {
char **proxy_clks;
int proxy_clk_cnt;
@@ -129,11 +132,11 @@ struct q6v5 {
struct qcom_smem_state *state;
unsigned stop_bit;
- struct regulator_bulk_data supply[4];
struct q6_rproc_res *q6_rproc_res;
- struct clk *ahb_clk;
- struct clk *axi_clk;
- struct clk *rom_clk;
+ struct clk **active_clks;
+ struct clk **proxy_clks;
+ struct regulator **proxy_regs;
+ struct regulator **active_regs;
struct completion start_done;
struct completion stop_done;
@@ -147,73 +150,249 @@ struct q6v5 {
phys_addr_t mpss_reloc;
void *mpss_region;
size_t mpss_size;
+ struct mutex q6_lock;
+ bool proxy_unvote_reg;
+ bool proxy_unvote_clk;
};
-enum {
- Q6V5_SUPPLY_CX,
- Q6V5_SUPPLY_MX,
- Q6V5_SUPPLY_MSS,
- Q6V5_SUPPLY_PLL,
-};
+static int q6_regulator_init(struct q6v5 *qproc)
+{
+ struct regulator **reg_arr;
+ int i;
+
+ if (qproc->q6_rproc_res->proxy_reg_cnt) {
+ reg_arr = devm_kzalloc(qproc->dev,
+ sizeof(reg_arr) * qproc->q6_rproc_res->proxy_reg_cnt,
+ GFP_KERNEL);
+
+ for (i = 0; i < qproc->q6_rproc_res->proxy_reg_cnt; i++) {
+ reg_arr[i] = devm_regulator_get(qproc->dev,
+ qproc->q6_rproc_res->proxy_regs[i]);
+ if (IS_ERR(reg_arr[i]))
+ return PTR_ERR(reg_arr[i]);
+ qproc->proxy_regs = reg_arr;
+ }
+ }
+
+ if (qproc->q6_rproc_res->active_reg_cnt) {
+ reg_arr = devm_kzalloc(qproc->dev,
+ sizeof(reg_arr) * qproc->q6_rproc_res->active_reg_cnt,
+ GFP_KERNEL);
+
+ for (i = 0; i < qproc->q6_rproc_res->active_reg_cnt; i++) {
+ reg_arr[i] = devm_regulator_get(qproc->dev,
+ qproc->q6_rproc_res->active_regs[i]);
+
+ if (IS_ERR(reg_arr[i]))
+ return PTR_ERR(reg_arr[i]);
+ qproc->active_regs = reg_arr;
+ }
+ }
+
+ return 0;
+}
-static int q6v5_regulator_init(struct q6v5 *qproc)
+static int q6_proxy_regulator_enable(struct q6v5 *qproc)
{
- int ret;
+ int i, j, ret = 0;
+ int **reg_loadnvoltsetflag;
+ int *reg_load;
+ int *reg_voltage;
+
+ reg_loadnvoltsetflag = qproc->q6_rproc_res->proxy_reg_action;
+ reg_load = qproc->q6_rproc_res->proxy_reg_load;
+ reg_voltage = qproc->q6_rproc_res->proxy_reg_voltage;
+
+ for (i = 0; i < qproc->q6_rproc_res->proxy_reg_cnt; i++) {
+ for (j = 0; j <= 1; j++) {
+ if (j == 0 && *(reg_loadnvoltsetflag + i*j + j))
+ regulator_set_load(qproc->proxy_regs[i],
+ reg_load[i]);
+ if (j == 1 && *(reg_loadnvoltsetflag + i*j + j))
+ regulator_set_voltage(qproc->proxy_regs[i],
+ reg_voltage[i], INT_MAX);
+ }
+ }
- qproc->supply[Q6V5_SUPPLY_CX].supply = "cx";
- qproc->supply[Q6V5_SUPPLY_MX].supply = "mx";
- qproc->supply[Q6V5_SUPPLY_MSS].supply = "mss";
- qproc->supply[Q6V5_SUPPLY_PLL].supply = "pll";
+ for (i = 0; i < qproc->q6_rproc_res->proxy_reg_cnt; i++) {
+ ret = regulator_enable(qproc->proxy_regs[i]);
+ if (ret) {
+ for (; i > 0; --i) {
+ regulator_disable(qproc->proxy_regs[i]);
+ return ret;
+ }
+ }
+ }
- ret = devm_regulator_bulk_get(qproc->dev,
- ARRAY_SIZE(qproc->supply), qproc->supply);
- if (ret < 0) {
- dev_err(qproc->dev, "failed to get supplies\n");
- return ret;
+ qproc->proxy_unvote_reg = true;
+
+ return 0;
+}
+
+static int q6_active_regulator_enable(struct q6v5 *qproc)
+{
+ int i, j, ret = 0;
+ int **reg_loadnvoltsetflag;
+ int *reg_load;
+ int *reg_voltage;
+
+ reg_loadnvoltsetflag = qproc->q6_rproc_res->active_reg_action;
+ reg_load = qproc->q6_rproc_res->active_reg_load;
+ reg_voltage = qproc->q6_rproc_res->active_reg_voltage;
+
+ for (i = 0; i < qproc->q6_rproc_res->active_reg_cnt; i++) {
+ for (j = 0; j <= 1; j++) {
+ if (j == 0 && *(reg_loadnvoltsetflag + i*j + j))
+ regulator_set_load(qproc->active_regs[i],
+ reg_load[i]);
+ if (j == 1 && *(reg_loadnvoltsetflag + i*j + j))
+ regulator_set_voltage(qproc->active_regs[i],
+ reg_voltage[i], INT_MAX);
+ }
}
- regulator_set_load(qproc->supply[Q6V5_SUPPLY_CX].consumer, 100000);
- regulator_set_load(qproc->supply[Q6V5_SUPPLY_MSS].consumer, 100000);
- regulator_set_load(qproc->supply[Q6V5_SUPPLY_PLL].consumer, 10000);
+ for (i = 0; i < qproc->q6_rproc_res->active_reg_cnt; i++) {
+ ret = regulator_enable(qproc->active_regs[i]);
+ if (ret) {
+ for (; i > 0; --i) {
+ regulator_disable(qproc->active_regs[i]);
+ return ret;
+ }
+ }
+ }
return 0;
}
-static int q6v5_regulator_enable(struct q6v5 *qproc)
+static int q6_regulator_enable(struct q6v5 *qproc)
{
- struct regulator *mss = qproc->supply[Q6V5_SUPPLY_MSS].consumer;
- struct regulator *mx = qproc->supply[Q6V5_SUPPLY_MX].consumer;
int ret;
- /* TODO: Q6V5_SUPPLY_CX is supposed to be set to super-turbo here */
+ if (qproc->q6_rproc_res->proxy_reg_cnt)
+ ret = q6_proxy_regulator_enable(qproc);
- ret = regulator_set_voltage(mx, 1050000, INT_MAX);
- if (ret)
- return ret;
+ if (qproc->q6_rproc_res->active_reg_cnt)
+ ret = q6_active_regulator_enable(qproc);
- regulator_set_voltage(mss, 1000000, 1150000);
+ return ret;
+}
- return regulator_bulk_enable(ARRAY_SIZE(qproc->supply), qproc->supply);
+static int q6_proxy_regulator_disable(struct q6v5 *qproc)
+{
+ int i, j;
+ int **reg_loadnvoltsetflag;
+
+ reg_loadnvoltsetflag = qproc->q6_rproc_res->proxy_reg_action;
+ if (!qproc->proxy_unvote_reg)
+ return 0;
+ for (i = qproc->q6_rproc_res->proxy_reg_cnt-1; i >= 0; i--) {
+ for (j = 0; j <= 1; j++) {
+ if (j == 0 && *(reg_loadnvoltsetflag + i*j + j))
+ regulator_set_load(qproc->proxy_regs[i], 0);
+ if (j == 1 && *(reg_loadnvoltsetflag + i*j + j))
+ regulator_set_voltage(qproc->proxy_regs[i],
+ 0, INT_MAX);
+ }
+ }
+ for (i = qproc->q6_rproc_res->proxy_reg_cnt-1; i >= 0; i--)
+ regulator_disable(qproc->proxy_regs[i]);
+ qproc->proxy_unvote_reg = false;
+ return 0;
}
-static void q6v5_regulator_disable(struct q6v5 *qproc)
+static int q6_active_regulator_disable(struct q6v5 *qproc)
{
- struct regulator *mss = qproc->supply[Q6V5_SUPPLY_MSS].consumer;
- struct regulator *mx = qproc->supply[Q6V5_SUPPLY_MX].consumer;
+ int i, j, ret = 0;
+ int **reg_loadnvoltsetflag;
+
+ reg_loadnvoltsetflag = qproc->q6_rproc_res->active_reg_action;
+
+ for (i = qproc->q6_rproc_res->active_reg_cnt-1; i > 0; i--) {
+ for (j = 0; j <= 1; j++) {
+ if (j == 0 && *(reg_loadnvoltsetflag + i*j + j))
+ regulator_set_load(qproc->active_regs[i], 0);
+ if (j == 1 && *(reg_loadnvoltsetflag + i*j + j))
+ regulator_set_voltage(qproc->active_regs[i],
+ 0, INT_MAX);
+ }
+ }
+ for (i = qproc->q6_rproc_res->active_reg_cnt-1; i >= 0; i--)
+ ret = regulator_disable(qproc->proxy_regs[i]);
+ return 0;
+}
+
+static void q6_regulator_disable(struct q6v5 *qproc)
+{
+ if (qproc->q6_rproc_res->proxy_reg_cnt)
+ q6_proxy_regulator_disable(qproc);
- /* TODO: Q6V5_SUPPLY_CX corner votes should be released */
+ if (qproc->q6_rproc_res->active_reg_cnt)
+ q6_active_regulator_disable(qproc);
+}
- regulator_bulk_disable(ARRAY_SIZE(qproc->supply), qproc->supply);
- regulator_set_voltage(mx, 0, INT_MAX);
- regulator_set_voltage(mss, 0, 1150000);
+static int q6_proxy_clk_enable(struct q6v5 *qproc)
+{
+ int i, ret = 0;
+
+ for (i = 0; i < qproc->q6_rproc_res->proxy_clk_cnt; i++) {
+ ret = clk_prepare_enable(qproc->proxy_clks[i]);
+ if (ret) {
+ for (; i > 0; --i) {
+ clk_disable_unprepare(qproc->proxy_clks[i]);
+ return ret;
+ }
+ }
+ }
+ qproc->proxy_unvote_clk = true;
+ return 0;
}
+static void q6_proxy_clk_disable(struct q6v5 *qproc)
+{
+ int i;
+
+ if (!qproc->proxy_unvote_clk)
+ return;
+ for (i = qproc->q6_rproc_res->proxy_clk_cnt-1; i >= 0; i--)
+ clk_disable_unprepare(qproc->proxy_clks[i]);
+ qproc->proxy_unvote_clk = false;
+}
+
+static int q6_active_clk_enable(struct q6v5 *qproc)
+{
+ int i, ret = 0;
+
+ for (i = 0; i < qproc->q6_rproc_res->active_clk_cnt; i++) {
+ ret = clk_prepare_enable(qproc->active_clks[i]);
+ if (ret) {
+ for (; i > 0; i--) {
+ clk_disable_unprepare(qproc->active_clks[i]);
+ return ret;
+ }
+ }
+ }
+ return 0;
+}
+
+static void q6_active_clk_disable(struct q6v5 *qproc)
+{
+ int i;
+
+ for (i = qproc->q6_rproc_res->active_clk_cnt-1; i >= 0; i--)
+ clk_disable_unprepare(qproc->active_clks[i]);
+}
+
+static void pil_mss_restart_reg(struct q6v5 *qproc, u32 mss_restart)
+{
+ if (qproc->restart_reg) {
+ writel_relaxed(mss_restart, qproc->restart_reg);
+ udelay(2);
+ }
+}
static int q6v5_load(struct rproc *rproc, const struct firmware *fw)
{
struct q6v5 *qproc = rproc->priv;
-
memcpy(qproc->mba_region, fw->data, fw->size);
-
return 0;
}
@@ -366,7 +545,7 @@ static void q6v5proc_halt_axi_port(struct q6v5 *qproc,
regmap_write(halt_map, offset + AXI_HALTREQ_REG, 0);
}
-static int q6v5_mpss_init_image(struct q6v5 *qproc, const struct firmware *fw)
+static int q6_mpss_init_image(struct q6v5 *qproc, const struct firmware *fw)
{
unsigned long dma_attrs = DMA_ATTR_FORCE_CONTIGUOUS;
dma_addr_t phys;
@@ -395,7 +574,7 @@ static int q6v5_mpss_init_image(struct q6v5 *qproc, const struct firmware *fw)
return ret < 0 ? ret : 0;
}
-static int q6v5_mpss_validate(struct q6v5 *qproc, const struct firmware *fw)
+static int q6_mpss_validate(struct q6v5 *qproc, const struct firmware *fw)
{
const struct elf32_phdr *phdrs;
const struct elf32_phdr *phdr;
@@ -451,7 +630,7 @@ static int q6v5_mpss_validate(struct q6v5 *qproc, const struct firmware *fw)
return ret < 0 ? ret : 0;
}
-static int q6v5_mpss_load(struct q6v5 *qproc)
+static int q6_mpss_load(struct q6v5 *qproc)
{
const struct firmware *fw;
phys_addr_t fw_addr;
@@ -476,7 +655,7 @@ static int q6v5_mpss_load(struct q6v5 *qproc)
/* Initialize the RMB validator */
writel(0, qproc->rmb_base + RMB_PMI_CODE_LENGTH_REG);
- ret = q6v5_mpss_init_image(qproc, fw);
+ ret = q6_mpss_init_image(qproc, fw);
if (ret)
goto release_firmware;
@@ -484,7 +663,7 @@ static int q6v5_mpss_load(struct q6v5 *qproc)
if (ret)
goto release_firmware;
- ret = q6v5_mpss_validate(qproc, fw);
+ ret = q6_mpss_validate(qproc, fw);
release_firmware:
release_firmware(fw);
@@ -492,36 +671,41 @@ static int q6v5_mpss_load(struct q6v5 *qproc)
return ret < 0 ? ret : 0;
}
-static int q6v5_start(struct rproc *rproc)
+static int q6_start(struct rproc *rproc)
{
struct q6v5 *qproc = (struct q6v5 *)rproc->priv;
int ret;
- ret = q6v5_regulator_enable(qproc);
+ mutex_lock(&qproc->q6_lock);
+ ret = q6_regulator_enable(qproc);
if (ret) {
- dev_err(qproc->dev, "failed to enable supplies\n");
+ dev_err(qproc->dev, "failed to enable reg supplies\n");
return ret;
}
- ret = reset_control_deassert(qproc->mss_restart);
+ ret = q6_proxy_clk_enable(qproc);
if (ret) {
- dev_err(qproc->dev, "failed to deassert mss restart\n");
- goto disable_vdd;
+ dev_err(qproc->dev, "failed to enable proxy_clk\n");
+ goto err_proxy_clk;
}
- ret = clk_prepare_enable(qproc->ahb_clk);
- if (ret)
- goto assert_reset;
-
- ret = clk_prepare_enable(qproc->axi_clk);
- if (ret)
- goto disable_ahb_clk;
+ ret = q6_active_clk_enable(qproc);
+ if (ret) {
+ dev_err(qproc->dev, "failed to enable active clocks\n");
+ goto err_active_clks;
+ }
- ret = clk_prepare_enable(qproc->rom_clk);
- if (ret)
- goto disable_axi_clk;
+ if (!strcmp(qproc->q6_rproc_res->q6_version, "v56"))
+ pil_mss_restart_reg(qproc, 0);
+ else {
+ ret = reset_control_deassert(qproc->mss_restart);
+ if (ret) {
+ dev_err(qproc->dev, "failed to deassert mss restart\n");
+ goto err_deassert;
+ }
+ }
- writel(qproc->mba_phys, qproc->rmb_base + RMB_MBA_IMAGE_REG);
+ writel_relaxed(qproc->mba_phys, qproc->rmb_base + RMB_MBA_IMAGE_REG);
ret = q6v5proc_reset(qproc);
if (ret)
@@ -539,13 +723,11 @@ static int q6v5_start(struct rproc *rproc)
}
dev_info(qproc->dev, "MBA booted, loading mpss\n");
-
- ret = q6v5_mpss_load(qproc);
+ ret = q6_mpss_load(qproc);
if (ret)
goto halt_axi_ports;
-
ret = wait_for_completion_timeout(&qproc->start_done,
- msecs_to_jiffies(5000));
+ msecs_to_jiffies(10000));
if (ret == 0) {
dev_err(qproc->dev, "start timed out\n");
ret = -ETIMEDOUT;
@@ -553,36 +735,33 @@ static int q6v5_start(struct rproc *rproc)
}
qproc->running = true;
-
/* TODO: All done, release the handover resources */
-
+ q6_proxy_clk_disable(qproc);
+ q6_proxy_regulator_disable(qproc);
+ mutex_unlock(&qproc->q6_lock);
return 0;
halt_axi_ports:
q6v5proc_halt_axi_port(qproc, qproc->halt_map, qproc->halt_q6);
q6v5proc_halt_axi_port(qproc, qproc->halt_map, qproc->halt_modem);
q6v5proc_halt_axi_port(qproc, qproc->halt_map, qproc->halt_nc);
-
- clk_disable_unprepare(qproc->rom_clk);
-disable_axi_clk:
- clk_disable_unprepare(qproc->axi_clk);
-disable_ahb_clk:
- clk_disable_unprepare(qproc->ahb_clk);
-assert_reset:
- reset_control_assert(qproc->mss_restart);
-disable_vdd:
- q6v5_regulator_disable(qproc);
-
+err_deassert:
+ q6_active_clk_disable(qproc);
+err_active_clks:
+ q6_proxy_clk_disable(qproc);
+err_proxy_clk:
+ q6_regulator_disable(qproc);
+ mutex_unlock(&qproc->q6_lock);
return ret;
}
-static int q6v5_stop(struct rproc *rproc)
+static int q6_stop(struct rproc *rproc)
{
struct q6v5 *qproc = (struct q6v5 *)rproc->priv;
int ret;
+ u64 val;
- qproc->running = false;
-
+ mutex_lock(&qproc->q6_lock);
qcom_smem_state_update_bits(qproc->state,
BIT(qproc->stop_bit), BIT(qproc->stop_bit));
@@ -597,16 +776,30 @@ static int q6v5_stop(struct rproc *rproc)
q6v5proc_halt_axi_port(qproc, qproc->halt_map, qproc->halt_modem);
q6v5proc_halt_axi_port(qproc, qproc->halt_map, qproc->halt_nc);
- reset_control_assert(qproc->mss_restart);
- clk_disable_unprepare(qproc->rom_clk);
- clk_disable_unprepare(qproc->axi_clk);
- clk_disable_unprepare(qproc->ahb_clk);
- q6v5_regulator_disable(qproc);
-
+ if (!strcmp(qproc->q6_rproc_res->q6_version, "v56")) {
+ /*
+ * Assert QDSP6 I/O clamp, memory wordline clamp, and compiler
+ * memory clamp as a software workaround to avoid high MX
+ * current during LPASS/MSS restart.
+ */
+
+ val = readl_relaxed(qproc->reg_base + QDSP6SS_PWR_CTL_REG);
+ val |= (Q6SS_CLAMP_IO | QDSP6v56_CLAMP_WL |
+ QDSP6v56_CLAMP_QMC_MEM);
+ writel_relaxed(val, qproc->reg_base + QDSP6SS_PWR_CTL_REG);
+ pil_mss_restart_reg(qproc, 1);
+ } else
+ reset_control_assert(qproc->mss_restart);
+ q6_active_clk_disable(qproc);
+ q6_proxy_clk_disable(qproc);
+ q6_proxy_regulator_disable(qproc);
+ q6_active_regulator_disable(qproc);
+ qproc->running = false;
+ mutex_unlock(&qproc->q6_lock);
return 0;
}
-static void *q6v5_da_to_va(struct rproc *rproc, u64 da, int len)
+static void *q6_da_to_va(struct rproc *rproc, u64 da, int len)
{
struct q6v5 *qproc = rproc->priv;
int offset;
@@ -619,12 +812,12 @@ static void *q6v5_da_to_va(struct rproc *rproc, u64 da, int len)
}
static const struct rproc_ops q6_ops = {
- .start = q6v5_start,
- .stop = q6v5_stop,
- .da_to_va = q6v5_da_to_va,
+ .start = q6_start,
+ .stop = q6_stop,
+ .da_to_va = q6_da_to_va,
};
-static irqreturn_t q6v5_wdog_interrupt(int irq, void *dev)
+static irqreturn_t q6_wdog_interrupt(int irq, void *dev)
{
struct q6v5 *qproc = dev;
size_t len;
@@ -650,7 +843,7 @@ static irqreturn_t q6v5_wdog_interrupt(int irq, void *dev)
return IRQ_HANDLED;
}
-static irqreturn_t q6v5_fatal_interrupt(int irq, void *dev)
+static irqreturn_t q6_fatal_interrupt(int irq, void *dev)
{
struct q6v5 *qproc = dev;
size_t len;
@@ -670,7 +863,7 @@ static irqreturn_t q6v5_fatal_interrupt(int irq, void *dev)
return IRQ_HANDLED;
}
-static irqreturn_t q6v5_handover_interrupt(int irq, void *dev)
+static irqreturn_t q6_handover_interrupt(int irq, void *dev)
{
struct q6v5 *qproc = dev;
@@ -678,7 +871,7 @@ static irqreturn_t q6v5_handover_interrupt(int irq, void *dev)
return IRQ_HANDLED;
}
-static irqreturn_t q6v5_stop_ack_interrupt(int irq, void *dev)
+static irqreturn_t q6_stop_ack_interrupt(int irq, void *dev)
{
struct q6v5 *qproc = dev;
@@ -686,7 +879,7 @@ static irqreturn_t q6v5_stop_ack_interrupt(int irq, void *dev)
return IRQ_HANDLED;
}
-static int q6v5_init_mem(struct q6v5 *qproc, struct platform_device *pdev)
+static int q6_init_mem(struct q6v5 *qproc, struct platform_device *pdev)
{
struct of_phandle_args args;
struct resource *res;
@@ -721,34 +914,58 @@ static int q6v5_init_mem(struct q6v5 *qproc, struct platform_device *pdev)
return 0;
}
-static int q6v5_init_clocks(struct q6v5 *qproc)
+static int q6_init_clocks(struct q6v5 *qproc)
{
- qproc->ahb_clk = devm_clk_get(qproc->dev, "iface");
- if (IS_ERR(qproc->ahb_clk)) {
- dev_err(qproc->dev, "failed to get iface clock\n");
- return PTR_ERR(qproc->ahb_clk);
- }
+ struct clk **clk_arr;
+ int i;
- qproc->axi_clk = devm_clk_get(qproc->dev, "bus");
- if (IS_ERR(qproc->axi_clk)) {
- dev_err(qproc->dev, "failed to get bus clock\n");
- return PTR_ERR(qproc->axi_clk);
+ if (qproc->q6_rproc_res->proxy_clk_cnt) {
+ clk_arr = devm_kzalloc(qproc->dev,
+ sizeof(clk_arr) * qproc->q6_rproc_res->proxy_clk_cnt,
+ GFP_KERNEL);
+
+ for (i = 0; i < qproc->q6_rproc_res->proxy_clk_cnt; i++) {
+ clk_arr[i] = devm_clk_get(qproc->dev,
+ qproc->q6_rproc_res->proxy_clks[i]);
+
+ if (IS_ERR(clk_arr[i])) {
+ dev_err(qproc->dev, "failed to get %s clock\n",
+ qproc->q6_rproc_res->proxy_clks[i]);
+ return PTR_ERR(clk_arr[i]);
+ }
+ qproc->proxy_clks = clk_arr;
+ }
}
- qproc->rom_clk = devm_clk_get(qproc->dev, "mem");
- if (IS_ERR(qproc->rom_clk)) {
- dev_err(qproc->dev, "failed to get mem clock\n");
- return PTR_ERR(qproc->rom_clk);
+ if (qproc->q6_rproc_res->active_clk_cnt) {
+ clk_arr = devm_kzalloc(qproc->dev,
+ sizeof(clk_arr) * qproc->q6_rproc_res->proxy_clk_cnt,
+ GFP_KERNEL);
+
+ for (i = 0; i < qproc->q6_rproc_res->active_clk_cnt; i++) {
+ clk_arr[i] = devm_clk_get(qproc->dev,
+ qproc->q6_rproc_res->active_clks[i]);
+ if (IS_ERR(clk_arr[i])) {
+ dev_err(qproc->dev, "failed to get %s clock\n",
+ qproc->q6_rproc_res->active_clks[i]);
+ return PTR_ERR(clk_arr[i]);
+ }
+
+ qproc->active_clks = clk_arr;
+ }
}
return 0;
}
-static int q6v5_init_reset(struct q6v5 *qproc)
+static int q6v5_init_reset(void *q, void *p)
{
- qproc->mss_restart = devm_reset_control_get(qproc->dev, NULL);
+ struct q6v5 *qproc = q;
+ struct platform_device *pdev = p;
+
+ qproc->mss_restart = devm_reset_control_get(&pdev->dev, NULL);
if (IS_ERR(qproc->mss_restart)) {
- dev_err(qproc->dev, "failed to acquire mss restart\n");
+ dev_err(&pdev->dev, "failed to acquire mss restart\n");
return PTR_ERR(qproc->mss_restart);
}
@@ -771,7 +988,8 @@ static int q6v56_init_reset(void *q, void *p)
return 0;
}
-static int q6v5_request_irq(struct q6v5 *qproc,
+
+static int q6_request_irq(struct q6v5 *qproc,
struct platform_device *pdev,
const char *name,
irq_handler_t thread_fn)
@@ -794,7 +1012,7 @@ static int q6v5_request_irq(struct q6v5 *qproc,
return ret;
}
-static int q6v5_alloc_memory_region(struct q6v5 *qproc)
+static int q6_alloc_memory_region(struct q6v5 *qproc)
{
struct device_node *child;
struct device_node *node;
@@ -867,39 +1085,42 @@ static int q6_probe(struct platform_device *pdev)
init_completion(&qproc->stop_done);
qproc->q6_rproc_res = desc;
- ret = q6v5_init_mem(qproc, pdev);
+
+ ret = q6_init_mem(qproc, pdev);
if (ret)
goto free_rproc;
- ret = q6v5_alloc_memory_region(qproc);
+ ret = q6_alloc_memory_region(qproc);
if (ret)
goto free_rproc;
- ret = q6v5_init_clocks(qproc);
+ ret = q6_init_clocks(qproc);
if (ret)
goto free_rproc;
- ret = q6v5_regulator_init(qproc);
+ ret = qproc->q6_rproc_res->q6_reset_init(qproc, pdev);
if (ret)
goto free_rproc;
- ret = qproc->q6_rproc_res->q6_reset_init(qproc, pdev);
+ ret = q6_regulator_init(qproc);
if (ret)
goto free_rproc;
- ret = q6v5_request_irq(qproc, pdev, "wdog", q6v5_wdog_interrupt);
+ mutex_init(&qproc->q6_lock);
+
+ ret = q6_request_irq(qproc, pdev, "wdog", q6_wdog_interrupt);
if (ret < 0)
goto free_rproc;
- ret = q6v5_request_irq(qproc, pdev, "fatal", q6v5_fatal_interrupt);
+ ret = q6_request_irq(qproc, pdev, "fatal", q6_fatal_interrupt);
if (ret < 0)
goto free_rproc;
- ret = q6v5_request_irq(qproc, pdev, "handover", q6v5_handover_interrupt);
+ ret = q6_request_irq(qproc, pdev, "handover", q6_handover_interrupt);
if (ret < 0)
goto free_rproc;
- ret = q6v5_request_irq(qproc, pdev, "stop-ack", q6v5_stop_ack_interrupt);
+ ret = q6_request_irq(qproc, pdev, "stop-ack", q6_stop_ack_interrupt);
if (ret < 0)
goto free_rproc;
--
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum,
a Linux Foundation Collaborative Project
^ permalink raw reply related [flat|nested] 7+ messages in thread
* [PATCH v2 3/3] remoteproc: qcom: Adding q6v56 reset sequence in existing reset sequence
[not found] <1478268057-11847-1-git-send-email-akdwived@codeaurora.org>
2016-11-04 14:00 ` [PATCH v2 1/3] remoteproc: qcom: Encapsulate pvt data structure for q6v56 hexagon Avaneesh Kumar Dwivedi
2016-11-04 14:00 ` [PATCH v2 2/3] remoteproc: qcom: Hexagon version independent resource handling Avaneesh Kumar Dwivedi
@ 2016-11-04 14:00 ` Avaneesh Kumar Dwivedi
2 siblings, 0 replies; 7+ messages in thread
From: Avaneesh Kumar Dwivedi @ 2016-11-04 14:00 UTC (permalink / raw)
To: bjorn.andersson
Cc: Avaneesh Kumar Dwivedi, Ohad Ben-Cohen,
open list:REMOTE PROCESSOR (REMOTEPROC) SUBSYSTEM, open list
Adding additional steps required specific to q6v56 based on version check
along with some trivial changes in name of local functions.
Signed-off-by: Avaneesh Kumar Dwivedi <akdwived@codeaurora.org>
---
drivers/remoteproc/qcom_q6v5_pil.c | 137 ++++++++++++++++++++++++++-----------
1 file changed, 98 insertions(+), 39 deletions(-)
diff --git a/drivers/remoteproc/qcom_q6v5_pil.c b/drivers/remoteproc/qcom_q6v5_pil.c
index 9db1d4b..aed85ec 100644
--- a/drivers/remoteproc/qcom_q6v5_pil.c
+++ b/drivers/remoteproc/qcom_q6v5_pil.c
@@ -66,6 +66,8 @@
#define QDSP6SS_RESET_REG 0x014
#define QDSP6SS_GFMUX_CTL_REG 0x020
#define QDSP6SS_PWR_CTL_REG 0x030
+#define QDSP6SS_MEM_PWR_CTL 0x0B0
+#define QDSP6SS_STRAP_ACC 0x110
/* AXI Halt Register Offsets */
#define AXI_HALTREQ_REG 0x0
@@ -94,8 +96,14 @@
#define QDSS_BHS_ON BIT(21)
#define QDSS_LDO_BYP BIT(22)
+/* QDSP6v56 parameters */
+#define QDSP6v56_LDO_BYP BIT(25)
+#define QDSP6v56_BHS_ON BIT(24)
#define QDSP6v56_CLAMP_WL BIT(21)
#define QDSP6v56_CLAMP_QMC_MEM BIT(22)
+#define HALT_CHECK_MAX_LOOPS (200)
+#define QDSP6SS_XO_CBCR (0x0038)
+#define QDSP6SS_ACC_OVERRIDE_VAL 0x20
struct q6_rproc_res {
char **proxy_clks;
int proxy_clk_cnt;
@@ -389,7 +397,8 @@ static void pil_mss_restart_reg(struct q6v5 *qproc, u32 mss_restart)
udelay(2);
}
}
-static int q6v5_load(struct rproc *rproc, const struct firmware *fw)
+
+static int q6_load(struct rproc *rproc, const struct firmware *fw)
{
struct q6v5 *qproc = rproc->priv;
memcpy(qproc->mba_region, fw->data, fw->size);
@@ -398,10 +407,10 @@ static int q6v5_load(struct rproc *rproc, const struct firmware *fw)
static const struct rproc_fw_ops q6_fw_ops = {
.find_rsc_table = qcom_mdt_find_rsc_table,
- .load = q6v5_load,
+ .load = q6_load,
};
-static int q6v5_rmb_pbl_wait(struct q6v5 *qproc, int ms)
+static int q6_rmb_pbl_wait(struct q6v5 *qproc, int ms)
{
unsigned long timeout;
s32 val;
@@ -421,7 +430,7 @@ static int q6v5_rmb_pbl_wait(struct q6v5 *qproc, int ms)
return val;
}
-static int q6v5_rmb_mba_wait(struct q6v5 *qproc, u32 status, int ms)
+static int q6_rmb_mba_wait(struct q6v5 *qproc, u32 status, int ms)
{
unsigned long timeout;
@@ -447,40 +456,95 @@ static int q6v5_rmb_mba_wait(struct q6v5 *qproc, u32 status, int ms)
return val;
}
-static int q6v5proc_reset(struct q6v5 *qproc)
+static int q6proc_reset(struct q6v5 *qproc)
{
- u32 val;
- int ret;
+ int ret, i, count;
+ u64 val;
+
+ /* Override the ACC value if required */
+ if (!strcmp(qproc->q6_rproc_res->q6_version, "v56"))
+ writel_relaxed(QDSP6SS_ACC_OVERRIDE_VAL,
+ qproc->reg_base + QDSP6SS_STRAP_ACC);
/* Assert resets, stop core */
- val = readl(qproc->reg_base + QDSP6SS_RESET_REG);
+ val = readl_relaxed(qproc->reg_base + QDSP6SS_RESET_REG);
val |= (Q6SS_CORE_ARES | Q6SS_BUS_ARES_ENABLE | Q6SS_STOP_CORE);
- writel(val, qproc->reg_base + QDSP6SS_RESET_REG);
+ writel_relaxed(val, qproc->reg_base + QDSP6SS_RESET_REG);
+ /* BHS require xo cbcr to be enabled */
+ if (!strcmp(qproc->q6_rproc_res->q6_version, "v56")) {
+ val = readl_relaxed(qproc->reg_base + QDSP6SS_XO_CBCR);
+ val |= 0x1;
+ writel_relaxed(val, qproc->reg_base + QDSP6SS_XO_CBCR);
+ for (count = HALT_CHECK_MAX_LOOPS; count > 0; count--) {
+ val = readl_relaxed(qproc->reg_base + QDSP6SS_XO_CBCR);
+ if (!(val & BIT(31)))
+ break;
+ udelay(1);
+ }
+
+ val = readl_relaxed(qproc->reg_base + QDSP6SS_XO_CBCR);
+ if ((val & BIT(31)))
+ dev_err(qproc->dev, "Failed to enable xo branch clock.\n");
+ }
/* Enable power block headswitch, and wait for it to stabilize */
- val = readl(qproc->reg_base + QDSP6SS_PWR_CTL_REG);
- val |= QDSS_BHS_ON | QDSS_LDO_BYP;
- writel(val, qproc->reg_base + QDSP6SS_PWR_CTL_REG);
+ val = readl_relaxed(qproc->reg_base + QDSP6SS_PWR_CTL_REG);
+ val |= QDSP6v56_BHS_ON;
+ writel_relaxed(val, qproc->reg_base + QDSP6SS_PWR_CTL_REG);
udelay(1);
- /*
- * Turn on memories. L2 banks should be done individually
- * to minimize inrush current.
- */
- val = readl(qproc->reg_base + QDSP6SS_PWR_CTL_REG);
- val |= Q6SS_SLP_RET_N | Q6SS_L2TAG_SLP_NRET_N |
- Q6SS_ETB_SLP_NRET_N | Q6SS_L2DATA_STBY_N;
- writel(val, qproc->reg_base + QDSP6SS_PWR_CTL_REG);
- val |= Q6SS_L2DATA_SLP_NRET_N_2;
- writel(val, qproc->reg_base + QDSP6SS_PWR_CTL_REG);
- val |= Q6SS_L2DATA_SLP_NRET_N_1;
- writel(val, qproc->reg_base + QDSP6SS_PWR_CTL_REG);
- val |= Q6SS_L2DATA_SLP_NRET_N_0;
- writel(val, qproc->reg_base + QDSP6SS_PWR_CTL_REG);
+ /* Put LDO in bypass mode */
+ val |= QDSP6v56_LDO_BYP;
+ writel_relaxed(val, qproc->reg_base + QDSP6SS_PWR_CTL_REG);
+ if (!strcmp(qproc->q6_rproc_res->q6_version, "v56")) {
+ /*
+ * Deassert QDSP6 compiler memory clamp
+ */
+ val = readl_relaxed(qproc->reg_base + QDSP6SS_PWR_CTL_REG);
+ val &= ~QDSP6v56_CLAMP_QMC_MEM;
+ writel_relaxed(val, qproc->reg_base + QDSP6SS_PWR_CTL_REG);
+
+ /* Deassert memory peripheral sleep and L2 memory standby */
+ val |= (Q6SS_L2DATA_STBY_N | Q6SS_SLP_RET_N);
+ writel_relaxed(val, qproc->reg_base + QDSP6SS_PWR_CTL_REG);
+
+ /* Turn on L1, L2, ETB and JU memories 1 at a time */
+ val = readl_relaxed(qproc->reg_base + QDSP6SS_MEM_PWR_CTL);
+ for (i = 19; i >= 0; i--) {
+ val |= BIT(i);
+ writel_relaxed(val, qproc->reg_base +
+ QDSP6SS_MEM_PWR_CTL);
+ /*
+ * Wait for 1us for both memory peripheral and
+ * data array to turn on.
+ */
+ mb();
+ udelay(1);
+ }
+ /* Remove word line clamp */
+ val = readl_relaxed(qproc->reg_base + QDSP6SS_PWR_CTL_REG);
+ val &= ~QDSP6v56_CLAMP_WL;
+ writel_relaxed(val, qproc->reg_base + QDSP6SS_PWR_CTL_REG);
+ } else {
+ /*
+ * Turn on memories. L2 banks should be done individually
+ * to minimize inrush current.
+ */
+ val = readl(qproc->reg_base + QDSP6SS_PWR_CTL_REG);
+ val |= Q6SS_SLP_RET_N | Q6SS_L2TAG_SLP_NRET_N |
+ Q6SS_ETB_SLP_NRET_N | Q6SS_L2DATA_STBY_N;
+ writel(val, qproc->reg_base + QDSP6SS_PWR_CTL_REG);
+ val |= Q6SS_L2DATA_SLP_NRET_N_2;
+ writel(val, qproc->reg_base + QDSP6SS_PWR_CTL_REG);
+ val |= Q6SS_L2DATA_SLP_NRET_N_1;
+ writel(val, qproc->reg_base + QDSP6SS_PWR_CTL_REG);
+ val |= Q6SS_L2DATA_SLP_NRET_N_0;
+ writel(val, qproc->reg_base + QDSP6SS_PWR_CTL_REG);
+ }
/* Remove IO clamp */
val &= ~Q6SS_CLAMP_IO;
- writel(val, qproc->reg_base + QDSP6SS_PWR_CTL_REG);
+ writel_relaxed(val, qproc->reg_base + QDSP6SS_PWR_CTL_REG);
/* Bring core out of reset */
val = readl(qproc->reg_base + QDSP6SS_RESET_REG);
@@ -488,9 +552,9 @@ static int q6v5proc_reset(struct q6v5 *qproc)
writel(val, qproc->reg_base + QDSP6SS_RESET_REG);
/* Turn on core clock */
- val = readl(qproc->reg_base + QDSP6SS_GFMUX_CTL_REG);
+ val = readl_relaxed(qproc->reg_base + QDSP6SS_GFMUX_CTL_REG);
val |= Q6SS_CLK_ENABLE;
- writel(val, qproc->reg_base + QDSP6SS_GFMUX_CTL_REG);
+ writel_relaxed(val, qproc->reg_base + QDSP6SS_GFMUX_CTL_REG);
/* Start core execution */
val = readl(qproc->reg_base + QDSP6SS_RESET_REG);
@@ -498,7 +562,7 @@ static int q6v5proc_reset(struct q6v5 *qproc)
writel(val, qproc->reg_base + QDSP6SS_RESET_REG);
/* Wait for PBL status */
- ret = q6v5_rmb_pbl_wait(qproc, 1000);
+ ret = q6_rmb_pbl_wait(qproc, 1000);
if (ret == -ETIMEDOUT) {
dev_err(qproc->dev, "PBL boot timed out\n");
} else if (ret != RMB_PBL_SUCCESS) {
@@ -519,11 +583,6 @@ static void q6v5proc_halt_axi_port(struct q6v5 *qproc,
unsigned int val;
int ret;
- /* Check if we're already idle */
- ret = regmap_read(halt_map, offset + AXI_IDLE_REG, &val);
- if (!ret && val)
- return;
-
/* Assert halt request */
regmap_write(halt_map, offset + AXI_HALTREQ_REG, 1);
@@ -563,7 +622,7 @@ static int q6_mpss_init_image(struct q6v5 *qproc, const struct firmware *fw)
writel(phys, qproc->rmb_base + RMB_PMI_META_DATA_REG);
writel(RMB_CMD_META_DATA_READY, qproc->rmb_base + RMB_MBA_COMMAND_REG);
- ret = q6v5_rmb_mba_wait(qproc, RMB_MBA_META_DATA_AUTH_SUCCESS, 1000);
+ ret = q6_rmb_mba_wait(qproc, RMB_MBA_META_DATA_AUTH_SUCCESS, 1000);
if (ret == -ETIMEDOUT)
dev_err(qproc->dev, "MPSS header authentication timed out\n");
else if (ret < 0)
@@ -621,7 +680,7 @@ static int q6_mpss_validate(struct q6v5 *qproc, const struct firmware *fw)
writel(size, qproc->rmb_base + RMB_PMI_CODE_LENGTH_REG);
}
- ret = q6v5_rmb_mba_wait(qproc, RMB_MBA_AUTH_COMPLETE, 10000);
+ ret = q6_rmb_mba_wait(qproc, RMB_MBA_AUTH_COMPLETE, 10000);
if (ret == -ETIMEDOUT)
dev_err(qproc->dev, "MPSS authentication timed out\n");
else if (ret < 0)
@@ -707,11 +766,11 @@ static int q6_start(struct rproc *rproc)
writel_relaxed(qproc->mba_phys, qproc->rmb_base + RMB_MBA_IMAGE_REG);
- ret = q6v5proc_reset(qproc);
+ ret = q6proc_reset(qproc);
if (ret)
goto halt_axi_ports;
- ret = q6v5_rmb_mba_wait(qproc, 0, 5000);
+ ret = q6_rmb_mba_wait(qproc, 0, 5000);
if (ret == -ETIMEDOUT) {
dev_err(qproc->dev, "MBA boot timed out\n");
goto halt_axi_ports;
--
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum,
a Linux Foundation Collaborative Project
^ permalink raw reply related [flat|nested] 7+ messages in thread
* Re: [PATCH v2 1/3] remoteproc: qcom: Encapsulate pvt data structure for q6v56 hexagon.
2016-11-04 14:00 ` [PATCH v2 1/3] remoteproc: qcom: Encapsulate pvt data structure for q6v56 hexagon Avaneesh Kumar Dwivedi
@ 2016-11-04 23:51 ` kbuild test robot
2016-11-10 20:30 ` Rob Herring
1 sibling, 0 replies; 7+ messages in thread
From: kbuild test robot @ 2016-11-04 23:51 UTC (permalink / raw)
To: Avaneesh Kumar Dwivedi
Cc: kbuild-all, bjorn.andersson, Avaneesh Kumar Dwivedi,
Ohad Ben-Cohen, Rob Herring, Mark Rutland,
open list:REMOTE PROCESSOR (REMOTEPROC) SUBSYSTEM,
open list:OPEN FIRMWARE AND FLATTENED DEVICE TREE BINDINGS,
open list
[-- Attachment #1: Type: text/plain, Size: 7190 bytes --]
Hi Avaneesh,
[auto build test ERROR on robh/for-next]
[also build test ERROR on v4.9-rc3 next-20161028]
[cannot apply to remoteproc/for-next]
[if your patch is applied to the wrong git tree, please drop us a note to help improve the system]
[Suggest to use git(>=2.9.0) format-patch --base=<commit> (or --base=auto for convenience) to record what (public, well-known) commit your patch series was built on]
[Check https://git-scm.com/docs/git-format-patch for more information]
url: https://github.com/0day-ci/linux/commits/Avaneesh-Kumar-Dwivedi/remoteproc-qcom-Encapsulate-pvt-data-structure-for-q6v56-hexagon/20161104-220712
base: https://git.kernel.org/pub/scm/linux/kernel/git/robh/linux.git for-next
config: arm64-allyesconfig (attached as .config)
compiler: aarch64-linux-gnu-gcc (Debian 6.1.1-9) 6.1.1 20160705
reproduce:
wget https://git.kernel.org/cgit/linux/kernel/git/wfg/lkp-tests.git/plain/sbin/make.cross -O ~/bin/make.cross
chmod +x ~/bin/make.cross
# save the attached .config to linux build tree
make.cross ARCH=arm64
Note: the linux-review/Avaneesh-Kumar-Dwivedi/remoteproc-qcom-Encapsulate-pvt-data-structure-for-q6v56-hexagon/20161104-220712 HEAD 1b4c0b8bb3bb8cd30a996282b7a6aa9f352836a2 builds fine.
It only hurts bisectibility.
All errors (new ones prefixed by >>):
drivers/remoteproc/qcom_q6v5_pil.c: In function 'q6_probe':
drivers/remoteproc/qcom_q6v5_pil.c:848:7: warning: assignment discards 'const' qualifier from pointer target type [-Wdiscarded-qualifiers]
desc = of_device_get_match_data(&pdev->dev);
^
drivers/remoteproc/qcom_q6v5_pil.c: At top level:
>> drivers/remoteproc/qcom_q6v5_pil.c:986:19: error: initialization from incompatible pointer type [-Werror=incompatible-pointer-types]
.q6_reset_init = q6v5_init_reset,
^~~~~~~~~~~~~~~
drivers/remoteproc/qcom_q6v5_pil.c:986:19: note: (near initialization for 'msm_8916_res.q6_reset_init')
cc1: some warnings being treated as errors
vim +986 drivers/remoteproc/qcom_q6v5_pil.c
842 {
843 struct q6v5 *qproc;
844 struct rproc *rproc;
845 struct q6_rproc_res *desc;
846 int ret;
847
> 848 desc = of_device_get_match_data(&pdev->dev);
849 if (!desc)
850 return -EINVAL;
851
852 rproc = rproc_alloc(&pdev->dev, pdev->name, &q6_ops,
853 desc->q6_mba_image, sizeof(*qproc));
854 if (!rproc) {
855 dev_err(&pdev->dev, "failed to allocate rproc\n");
856 return -ENOMEM;
857 }
858
859 rproc->fw_ops = &q6_fw_ops;
860
861 qproc = (struct q6v5 *)rproc->priv;
862 qproc->dev = &pdev->dev;
863 qproc->rproc = rproc;
864 platform_set_drvdata(pdev, qproc);
865
866 init_completion(&qproc->start_done);
867 init_completion(&qproc->stop_done);
868
869 qproc->q6_rproc_res = desc;
870 ret = q6v5_init_mem(qproc, pdev);
871 if (ret)
872 goto free_rproc;
873
874 ret = q6v5_alloc_memory_region(qproc);
875 if (ret)
876 goto free_rproc;
877
878 ret = q6v5_init_clocks(qproc);
879 if (ret)
880 goto free_rproc;
881
882 ret = q6v5_regulator_init(qproc);
883 if (ret)
884 goto free_rproc;
885
886 ret = qproc->q6_rproc_res->q6_reset_init(qproc, pdev);
887 if (ret)
888 goto free_rproc;
889
890 ret = q6v5_request_irq(qproc, pdev, "wdog", q6v5_wdog_interrupt);
891 if (ret < 0)
892 goto free_rproc;
893
894 ret = q6v5_request_irq(qproc, pdev, "fatal", q6v5_fatal_interrupt);
895 if (ret < 0)
896 goto free_rproc;
897
898 ret = q6v5_request_irq(qproc, pdev, "handover", q6v5_handover_interrupt);
899 if (ret < 0)
900 goto free_rproc;
901
902 ret = q6v5_request_irq(qproc, pdev, "stop-ack", q6v5_stop_ack_interrupt);
903 if (ret < 0)
904 goto free_rproc;
905
906 qproc->state = qcom_smem_state_get(&pdev->dev, "stop", &qproc->stop_bit);
907 if (IS_ERR(qproc->state))
908 goto free_rproc;
909
910 ret = rproc_add(rproc);
911 if (ret)
912 goto free_rproc;
913
914 return 0;
915
916 free_rproc:
917 rproc_put(rproc);
918
919 return ret;
920 }
921
922 static int q6_remove(struct platform_device *pdev)
923 {
924 struct q6v5 *qproc = platform_get_drvdata(pdev);
925
926 rproc_del(qproc->rproc);
927 rproc_put(qproc->rproc);
928
929 return 0;
930 }
931
932 char *proxy_8x96_reg_str[] = {"mx", "cx", "vdd_pll"};
933 int proxy_8x96_reg_action[3][2] = { {0, 1}, {1, 1}, {1, 0} };
934 int proxy_8x96_reg_load[] = {0, 100000, 100000};
935 int proxy_8x96_reg_min_voltage[] = {1050000, 1250000, 0};
936 char *proxy_8x96_clk_str[] = {"xo", "pnoc", "qdss"};
937 char *active_8x96_clk_str[] = {"iface", "bus", "mem", "gpll0_mss_clk",
938 "snoc_axi_clk", "mnoc_axi_clk"};
939
940 static struct q6_rproc_res msm_8996_res = {
941 .proxy_clks = proxy_8x96_clk_str,
942 .proxy_clk_cnt = 3,
943 .active_clks = active_8x96_clk_str,
944 .active_clk_cnt = 6,
945 .proxy_regs = proxy_8x96_reg_str,
946 .active_regs = NULL,
947 .proxy_reg_action = (int **)proxy_8x96_reg_action,
948 .proxy_reg_load = (int *)proxy_8x96_reg_load,
949 .active_reg_action = NULL,
950 .active_reg_load = NULL,
951 .proxy_reg_voltage = (int *)proxy_8x96_reg_min_voltage,
952 .active_reg_voltage = NULL,
953 .proxy_reg_cnt = 3,
954 .active_reg_cnt = 0,
955 .q6_reset_init = q6v56_init_reset,
956 .q6_version = "v56",
957 .q6_mba_image = "mba.mbn",
958 };
959
960 char *proxy_8x16_reg_str[] = {"mx", "cx", "pll"};
961 char *active_8x16_reg_str[] = {"mss"};
962 int proxy_8x16_reg_action[4][2] = { {0, 1}, {1, 0}, {1, 0} };
963 int active_8x16_reg_action[1][2] = { {1, 1} };
964 int proxy_8x16_reg_load[] = {100000, 0, 100000, 100000};
965 int active_8x16_reg_load[] = {100000};
966 int proxy_8x16_reg_min_voltage[] = {1050000, 0, 0};
967 int active_8x16_reg_min_voltage[] = {1000000};
968 char *proxy_8x16_clk_str[] = {"xo"};
969 char *active_8x16_clk_str[] = {"iface", "bus", "mem"};
970
971 static struct q6_rproc_res msm_8916_res = {
972 .proxy_clks = proxy_8x16_clk_str,
973 .proxy_clk_cnt = 1,
974 .active_clks = active_8x16_clk_str,
975 .active_clk_cnt = 3,
976 .proxy_regs = proxy_8x16_reg_str,
977 .active_regs = active_8x16_reg_str,
978 .proxy_reg_action = (int **)proxy_8x16_reg_action,
979 .proxy_reg_load = (int *)proxy_8x16_reg_load,
980 .active_reg_action = (int **)active_8x16_reg_action,
981 .active_reg_load = (int *)active_8x16_reg_load,
982 .proxy_reg_voltage = (int *)proxy_8x16_reg_min_voltage,
983 .active_reg_voltage = active_8x16_reg_min_voltage,
984 .proxy_reg_cnt = 3,
985 .active_reg_cnt = 1,
> 986 .q6_reset_init = q6v5_init_reset,
987 .q6_version = "v5",
988 .q6_mba_image = "mba.b00",
989 };
---
0-DAY kernel test infrastructure Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all Intel Corporation
[-- Attachment #2: .config.gz --]
[-- Type: application/gzip, Size: 51385 bytes --]
^ permalink raw reply [flat|nested] 7+ messages in thread
* Re: [PATCH v2 1/3] remoteproc: qcom: Encapsulate pvt data structure for q6v56 hexagon.
2016-11-04 14:00 ` [PATCH v2 1/3] remoteproc: qcom: Encapsulate pvt data structure for q6v56 hexagon Avaneesh Kumar Dwivedi
2016-11-04 23:51 ` kbuild test robot
@ 2016-11-10 20:30 ` Rob Herring
2016-11-16 14:02 ` Avaneesh Kumar Dwivedi
1 sibling, 1 reply; 7+ messages in thread
From: Rob Herring @ 2016-11-10 20:30 UTC (permalink / raw)
To: Avaneesh Kumar Dwivedi
Cc: bjorn.andersson, Ohad Ben-Cohen, Mark Rutland,
open list:REMOTE PROCESSOR (REMOTEPROC) SUBSYSTEM,
open list:OPEN FIRMWARE AND FLATTENED DEVICE TREE BINDINGS,
open list
On Fri, Nov 04, 2016 at 07:30:54PM +0530, Avaneesh Kumar Dwivedi wrote:
> Encapsulate resources specific to each version of hexagon chip to
> device node to avoid conditional check for manipulation of those
> resources in driver code.
>
> Signed-off-by: Avaneesh Kumar Dwivedi <akdwived@codeaurora.org>
> ---
> .../devicetree/bindings/remoteproc/qcom,q6v5.txt | 1 +
> drivers/remoteproc/qcom_q6v5_pil.c | 137 ++++++++++++++++++---
> 2 files changed, 120 insertions(+), 18 deletions(-)
>
> diff --git a/Documentation/devicetree/bindings/remoteproc/qcom,q6v5.txt b/Documentation/devicetree/bindings/remoteproc/qcom,q6v5.txt
> index 57cb49e..cbc165c 100644
> --- a/Documentation/devicetree/bindings/remoteproc/qcom,q6v5.txt
> +++ b/Documentation/devicetree/bindings/remoteproc/qcom,q6v5.txt
> @@ -8,6 +8,7 @@ on the Qualcomm Hexagon core.
> Value type: <string>
> Definition: must be one of:
> "qcom,q6v5-pil"
> + "qcom,q6v56-pil"
Perhaps some explanation in the commit message about what these magic
numbers mean?
Rob
^ permalink raw reply [flat|nested] 7+ messages in thread
* Re: [PATCH v2 1/3] remoteproc: qcom: Encapsulate pvt data structure for q6v56 hexagon.
2016-11-10 20:30 ` Rob Herring
@ 2016-11-16 14:02 ` Avaneesh Kumar Dwivedi
2016-11-18 18:40 ` Bjorn Andersson
0 siblings, 1 reply; 7+ messages in thread
From: Avaneesh Kumar Dwivedi @ 2016-11-16 14:02 UTC (permalink / raw)
To: Rob Herring
Cc: bjorn.andersson, Ohad Ben-Cohen, Mark Rutland,
open list:REMOTE PROCESSOR (REMOTEPROC) SUBSYSTEM,
open list:OPEN FIRMWARE AND FLATTENED DEVICE TREE BINDINGS,
open list
On 11/11/2016 2:00 AM, Rob Herring wrote:
> On Fri, Nov 04, 2016 at 07:30:54PM +0530, Avaneesh Kumar Dwivedi wrote:
>> Encapsulate resources specific to each version of hexagon chip to
>> device node to avoid conditional check for manipulation of those
>> resources in driver code.
>>
>> Signed-off-by: Avaneesh Kumar Dwivedi <akdwived@codeaurora.org>
>> ---
>> .../devicetree/bindings/remoteproc/qcom,q6v5.txt | 1 +
>> drivers/remoteproc/qcom_q6v5_pil.c | 137 ++++++++++++++++++---
>> 2 files changed, 120 insertions(+), 18 deletions(-)
>>
>> diff --git a/Documentation/devicetree/bindings/remoteproc/qcom,q6v5.txt b/Documentation/devicetree/bindings/remoteproc/qcom,q6v5.txt
>> index 57cb49e..cbc165c 100644
>> --- a/Documentation/devicetree/bindings/remoteproc/qcom,q6v5.txt
>> +++ b/Documentation/devicetree/bindings/remoteproc/qcom,q6v5.txt
>> @@ -8,6 +8,7 @@ on the Qualcomm Hexagon core.
>> Value type: <string>
>> Definition: must be one of:
>> "qcom,q6v5-pil"
>> + "qcom,q6v56-pil"
> Perhaps some explanation in the commit message about what these magic
> numbers mean?
"v56" represent class of hexagon chip, which again is
differentiated based on version number. Two
different MSM SOC may use same class of hexagon chip. example is as
below.
msm8974 q6v5 version 5.0.0
msm8916 q6v5 version 5.1.1
>
> Rob
^ permalink raw reply [flat|nested] 7+ messages in thread
* Re: [PATCH v2 1/3] remoteproc: qcom: Encapsulate pvt data structure for q6v56 hexagon.
2016-11-16 14:02 ` Avaneesh Kumar Dwivedi
@ 2016-11-18 18:40 ` Bjorn Andersson
0 siblings, 0 replies; 7+ messages in thread
From: Bjorn Andersson @ 2016-11-18 18:40 UTC (permalink / raw)
To: Avaneesh Kumar Dwivedi
Cc: Rob Herring, Ohad Ben-Cohen, Mark Rutland,
open list:REMOTE PROCESSOR (REMOTEPROC) SUBSYSTEM,
open list:OPEN FIRMWARE AND FLATTENED DEVICE TREE BINDINGS,
open list
On Wed 16 Nov 06:02 PST 2016, Avaneesh Kumar Dwivedi wrote:
>
>
> On 11/11/2016 2:00 AM, Rob Herring wrote:
> >On Fri, Nov 04, 2016 at 07:30:54PM +0530, Avaneesh Kumar Dwivedi wrote:
> >>Encapsulate resources specific to each version of hexagon chip to
> >>device node to avoid conditional check for manipulation of those
> >>resources in driver code.
> >>
> >>Signed-off-by: Avaneesh Kumar Dwivedi <akdwived@codeaurora.org>
> >>---
> >> .../devicetree/bindings/remoteproc/qcom,q6v5.txt | 1 +
> >> drivers/remoteproc/qcom_q6v5_pil.c | 137 ++++++++++++++++++---
> >> 2 files changed, 120 insertions(+), 18 deletions(-)
> >>
> >>diff --git a/Documentation/devicetree/bindings/remoteproc/qcom,q6v5.txt b/Documentation/devicetree/bindings/remoteproc/qcom,q6v5.txt
> >>index 57cb49e..cbc165c 100644
> >>--- a/Documentation/devicetree/bindings/remoteproc/qcom,q6v5.txt
> >>+++ b/Documentation/devicetree/bindings/remoteproc/qcom,q6v5.txt
> >>@@ -8,6 +8,7 @@ on the Qualcomm Hexagon core.
> >> Value type: <string>
> >> Definition: must be one of:
> >> "qcom,q6v5-pil"
> >>+ "qcom,q6v56-pil"
> >Perhaps some explanation in the commit message about what these magic
> >numbers mean?
>
> "v56" represent class of hexagon chip, which again is differentiated
> based on version number. Two
> different MSM SOC may use same class of hexagon chip. example is as
> below.
>
> msm8974 q6v5 version 5.0.0
> msm8916 q6v5 version 5.1.1
But looking at the Qualcomm tree I think I got 8916 wrong, it seems that
it should be "q6v56" and your patches indicates that the 8996 has a
q6v55 - which doesn't make sense to me and in some places there's
comments indicating it's version 6.
I asked you about this but I can't find an answer in any of your
replies.
Regards,
Bjorn
^ permalink raw reply [flat|nested] 7+ messages in thread
end of thread, other threads:[~2016-11-18 18:40 UTC | newest]
Thread overview: 7+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
[not found] <1478268057-11847-1-git-send-email-akdwived@codeaurora.org>
2016-11-04 14:00 ` [PATCH v2 1/3] remoteproc: qcom: Encapsulate pvt data structure for q6v56 hexagon Avaneesh Kumar Dwivedi
2016-11-04 23:51 ` kbuild test robot
2016-11-10 20:30 ` Rob Herring
2016-11-16 14:02 ` Avaneesh Kumar Dwivedi
2016-11-18 18:40 ` Bjorn Andersson
2016-11-04 14:00 ` [PATCH v2 2/3] remoteproc: qcom: Hexagon version independent resource handling Avaneesh Kumar Dwivedi
2016-11-04 14:00 ` [PATCH v2 3/3] remoteproc: qcom: Adding q6v56 reset sequence in existing reset sequence Avaneesh Kumar Dwivedi
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).