Merge "mmc: msm_sdcc: don't print the timeout errors for BKOPs"
diff --git a/arch/arm/Kconfig b/arch/arm/Kconfig
index 53fd3b2..23181d9 100644
--- a/arch/arm/Kconfig
+++ b/arch/arm/Kconfig
@@ -1808,7 +1808,7 @@
config OABI_COMPAT
bool "Allow old ABI binaries to run with this kernel (EXPERIMENTAL)"
depends on AEABI && EXPERIMENTAL && !THUMB2_KERNEL
- default y
+ default y if !SMP
help
This option preserves the old syscall interface along with the
new (ARM EABI) one. It also provides a compatibility layer to
diff --git a/arch/arm/boot/dts/msm8226.dtsi b/arch/arm/boot/dts/msm8226.dtsi
index b54d2446..36bcdd7 100644
--- a/arch/arm/boot/dts/msm8226.dtsi
+++ b/arch/arm/boot/dts/msm8226.dtsi
@@ -152,6 +152,164 @@
qcom,adsp-state = <0>;
};
+ sound {
+ compatible = "qcom,msm8226-audio-tapan";
+ qcom,model = "msm8226-tapan-snd-card";
+
+ qcom,audio-routing =
+ "RX_BIAS", "MCLK",
+ "LDO_H", "MCLK",
+ "AMIC1", "MIC BIAS1 Internal1",
+ "MIC BIAS1 Internal1", "Handset Mic",
+ "AMIC2", "MIC BIAS2 External",
+ "MIC BIAS2 External", "Headset Mic",
+ "AMIC3", "MIC BIAS2 External",
+ "MIC BIAS2 External", "ANCRight Headset Mic",
+ "AMIC4", "MIC BIAS2 External",
+ "MIC BIAS2 External", "ANCLeft Headset Mic",
+ "DMIC1", "MIC BIAS1 External",
+ "MIC BIAS1 External", "Digital Mic1",
+ "DMIC2", "MIC BIAS1 External",
+ "MIC BIAS1 External", "Digital Mic2",
+ "DMIC3", "MIC BIAS3 External",
+ "MIC BIAS3 External", "Digital Mic3",
+ "DMIC4", "MIC BIAS3 External",
+ "MIC BIAS3 External", "Digital Mic4",
+ "DMIC5", "MIC BIAS4 External",
+ "MIC BIAS4 External", "Digital Mic5",
+ "DMIC6", "MIC BIAS4 External",
+ "MIC BIAS4 External", "Digital Mic6";
+ qcom,tapan-mclk-clk-freq = <9600000>;
+ };
+
+ qcom,msm-pcm {
+ compatible = "qcom,msm-pcm-dsp";
+ };
+
+ qcom,msm-pcm-routing {
+ compatible = "qcom,msm-pcm-routing";
+ };
+
+ qcom,msm-pcm-lpa {
+ compatible = "qcom,msm-pcm-lpa";
+ };
+
+ qcom,msm-compr-dsp {
+ compatible = "qcom,msm-compr-dsp";
+ };
+
+ qcom,msm-voip-dsp {
+ compatible = "qcom,msm-voip-dsp";
+ };
+
+ qcom,msm-pcm-voice {
+ compatible = "qcom,msm-pcm-voice";
+ };
+
+ qcom,msm-stub-codec {
+ compatible = "qcom,msm-stub-codec";
+ };
+
+ qcom,msm-dai-fe {
+ compatible = "qcom,msm-dai-fe";
+ };
+
+ qcom,msm-pcm-afe {
+ compatible = "qcom,msm-pcm-afe";
+ };
+
+ qcom,msm-dai-q6-hdmi {
+ compatible = "qcom,msm-dai-q6-hdmi";
+ qcom,msm-dai-q6-dev-id = <8>;
+ };
+
+ qcom,msm-dai-q6 {
+ compatible = "qcom,msm-dai-q6";
+ qcom,msm-dai-q6-sb-0-rx {
+ compatible = "qcom,msm-dai-q6-dev";
+ qcom,msm-dai-q6-dev-id = <16384>;
+ };
+
+ qcom,msm-dai-q6-sb-0-tx {
+ compatible = "qcom,msm-dai-q6-dev";
+ qcom,msm-dai-q6-dev-id = <16385>;
+ };
+
+ qcom,msm-dai-q6-sb-1-rx {
+ compatible = "qcom,msm-dai-q6-dev";
+ qcom,msm-dai-q6-dev-id = <16386>;
+ };
+
+ qcom,msm-dai-q6-sb-1-tx {
+ compatible = "qcom,msm-dai-q6-dev";
+ qcom,msm-dai-q6-dev-id = <16387>;
+ };
+
+ qcom,msm-dai-q6-sb-3-rx {
+ compatible = "qcom,msm-dai-q6-dev";
+ qcom,msm-dai-q6-dev-id = <16390>;
+ };
+
+ qcom,msm-dai-q6-sb-3-tx {
+ compatible = "qcom,msm-dai-q6-dev";
+ qcom,msm-dai-q6-dev-id = <16391>;
+ };
+
+ qcom,msm-dai-q6-sb-4-rx {
+ compatible = "qcom,msm-dai-q6-dev";
+ qcom,msm-dai-q6-dev-id = <16392>;
+ };
+
+ qcom,msm-dai-q6-sb-4-tx {
+ compatible = "qcom,msm-dai-q6-dev";
+ qcom,msm-dai-q6-dev-id = <16393>;
+ };
+
+ qcom,msm-dai-q6-bt-sco-rx {
+ compatible = "qcom,msm-dai-q6-dev";
+ qcom,msm-dai-q6-dev-id = <12288>;
+ };
+
+ qcom,msm-dai-q6-bt-sco-tx {
+ compatible = "qcom,msm-dai-q6-dev";
+ qcom,msm-dai-q6-dev-id = <12289>;
+ };
+
+ qcom,msm-dai-q6-int-fm-rx {
+ compatible = "qcom,msm-dai-q6-dev";
+ qcom,msm-dai-q6-dev-id = <12292>;
+ };
+
+ qcom,msm-dai-q6-int-fm-tx {
+ compatible = "qcom,msm-dai-q6-dev";
+ qcom,msm-dai-q6-dev-id = <12293>;
+ };
+
+ qcom,msm-dai-q6-be-afe-pcm-rx {
+ compatible = "qcom,msm-dai-q6-dev";
+ qcom,msm-dai-q6-dev-id = <224>;
+ };
+
+ qcom,msm-dai-q6-be-afe-pcm-tx {
+ compatible = "qcom,msm-dai-q6-dev";
+ qcom,msm-dai-q6-dev-id = <225>;
+ };
+
+ qcom,msm-dai-q6-afe-proxy-rx {
+ compatible = "qcom,msm-dai-q6-dev";
+ qcom,msm-dai-q6-dev-id = <241>;
+ };
+
+ qcom,msm-dai-q6-afe-proxy-tx {
+ compatible = "qcom,msm-dai-q6-dev";
+ qcom,msm-dai-q6-dev-id = <240>;
+ };
+ };
+
+ qcom,msm-pcm-hostless {
+ compatible = "qcom,msm-pcm-hostless";
+ };
+
qcom,wdt@f9017000 {
compatible = "qcom,msm-watchdog";
reg = <0xf9017000 0x1000>;
diff --git a/arch/arm/configs/msm8910_defconfig b/arch/arm/configs/msm8910_defconfig
index bf163e0..4b1e3f2 100644
--- a/arch/arm/configs/msm8910_defconfig
+++ b/arch/arm/configs/msm8910_defconfig
@@ -36,6 +36,7 @@
CONFIG_ARCH_MSM=y
CONFIG_ARCH_MSM8910=y
CONFIG_ARCH_MSM8226=y
+CONFIG_SND_SOC_MSM8226=y
# CONFIG_MSM_STACKED_MEMORY is not set
CONFIG_CPU_HAS_L2_PMU=y
# CONFIG_MSM_FIQ_SUPPORT is not set
@@ -45,6 +46,7 @@
# CONFIG_MSM_HW3D is not set
CONFIG_MSM_DIRECT_SCLK_ACCESS=y
CONFIG_MSM_WATCHDOG_V2=y
+CONFIG_MSM_ADSP_LOADER=m
CONFIG_NO_HZ=y
CONFIG_HIGH_RES_TIMERS=y
CONFIG_SMP=y
@@ -104,8 +106,12 @@
CONFIG_SPMI=y
CONFIG_SPMI_MSM_PMIC_ARB=y
CONFIG_MSM_QPNP_INT=y
+CONFIG_SLIMBUS=y
+CONFIG_SLIMBUS_MSM_NGD=y
CONFIG_DEBUG_GPIO=y
CONFIG_GPIO_SYSFS=y
+CONFIG_I2C=y
+CONFIG_WCD9306_CODEC=y
# CONFIG_HWMON is not set
CONFIG_REGULATOR=y
CONFIG_REGULATOR_STUB=y
@@ -130,7 +136,6 @@
CONFIG_MMC_BLOCK_MINORS=32
CONFIG_MMC_TEST=m
CONFIG_MMC_MSM=y
-CONFIG_MMC_MSM_SPS_SUPPORT=y
CONFIG_STAGING=y
CONFIG_ANDROID=y
CONFIG_ANDROID_BINDER_IPC=y
@@ -138,9 +143,10 @@
CONFIG_ANDROID_RAM_CONSOLE=y
CONFIG_ANDROID_TIMED_GPIO=y
CONFIG_ANDROID_LOW_MEMORY_KILLER=y
+CONFIG_MSM_IOMMU=y
CONFIG_SPS=y
CONFIG_SPS_SUPPORT_NDP_BAM=y
-CONFIG_MSM_IOMMU=y
+CONFIG_MMC_MSM_SPS_SUPPORT=y
CONFIG_EXT2_FS=y
CONFIG_EXT2_FS_XATTR=y
CONFIG_EXT3_FS=y
diff --git a/arch/arm/mach-msm/board-8064-display.c b/arch/arm/mach-msm/board-8064-display.c
index b717973..b0dc20b 100644
--- a/arch/arm/mach-msm/board-8064-display.c
+++ b/arch/arm/mach-msm/board-8064-display.c
@@ -818,12 +818,13 @@
return 0;
/* TBD: PM8921 regulator instead of 8901 */
- if (!reg_ext_3p3v) {
+ if (!reg_ext_3p3v &&
+ (!(machine_is_mpq8064_hrd() || machine_is_mpq8064_dtv()))) {
reg_ext_3p3v = regulator_get(&hdmi_msm_device.dev,
- "hdmi_mux_vdd");
+ "hdmi_mux_vdd");
if (IS_ERR_OR_NULL(reg_ext_3p3v)) {
pr_err("could not get reg_ext_3p3v, rc = %ld\n",
- PTR_ERR(reg_ext_3p3v));
+ PTR_ERR(reg_ext_3p3v));
reg_ext_3p3v = NULL;
return -ENODEV;
}
@@ -831,7 +832,7 @@
if (!reg_8921_lvs7) {
reg_8921_lvs7 = regulator_get(&hdmi_msm_device.dev,
- "hdmi_vdda");
+ "hdmi_vdda");
if (IS_ERR(reg_8921_lvs7)) {
pr_err("could not get reg_8921_lvs7, rc = %ld\n",
PTR_ERR(reg_8921_lvs7));
@@ -841,7 +842,7 @@
}
if (!reg_8921_s4) {
reg_8921_s4 = regulator_get(&hdmi_msm_device.dev,
- "hdmi_lvl_tsl");
+ "hdmi_lvl_tsl");
if (IS_ERR(reg_8921_s4)) {
pr_err("could not get reg_8921_s4, rc = %ld\n",
PTR_ERR(reg_8921_s4));
@@ -860,17 +861,22 @@
* Configure 3P3V_BOOST_EN as GPIO, 8mA drive strength,
* pull none, out-high
*/
- rc = regulator_set_optimum_mode(reg_ext_3p3v, 290000);
- if (rc < 0) {
- pr_err("set_optimum_mode ext_3p3v failed, rc=%d\n", rc);
- return -EINVAL;
+ if (!(machine_is_mpq8064_hrd() || machine_is_mpq8064_dtv())) {
+ rc = regulator_set_optimum_mode(reg_ext_3p3v, 290000);
+ if (rc < 0) {
+ pr_err("set_optimum_mode ext_3p3v failed," \
+ "rc=%d\n", rc);
+ return -EINVAL;
+ }
+
+ rc = regulator_enable(reg_ext_3p3v);
+ if (rc) {
+ pr_err("enable reg_ext_3p3v failed, rc=%d\n",
+ rc);
+ return rc;
+ }
}
- rc = regulator_enable(reg_ext_3p3v);
- if (rc) {
- pr_err("enable reg_ext_3p3v failed, rc=%d\n", rc);
- return rc;
- }
rc = regulator_enable(reg_8921_lvs7);
if (rc) {
pr_err("'%s' regulator enable failed, rc=%d\n",
@@ -885,11 +891,15 @@
}
pr_debug("%s(on): success\n", __func__);
} else {
- rc = regulator_disable(reg_ext_3p3v);
- if (rc) {
- pr_err("disable reg_ext_3p3v failed, rc=%d\n", rc);
- return -ENODEV;
+ if (!(machine_is_mpq8064_hrd() || machine_is_mpq8064_dtv())) {
+ rc = regulator_disable(reg_ext_3p3v);
+ if (rc) {
+ pr_err("disable reg_ext_3p3v failed, rc=%d\n",
+ rc);
+ return -ENODEV;
+ }
}
+
rc = regulator_disable(reg_8921_lvs7);
if (rc) {
pr_err("disable reg_8921_l23 failed, rc=%d\n", rc);
@@ -910,7 +920,8 @@
error2:
regulator_disable(reg_8921_lvs7);
error1:
- regulator_disable(reg_ext_3p3v);
+ if (!(machine_is_mpq8064_hrd() || machine_is_mpq8064_dtv()))
+ regulator_disable(reg_ext_3p3v);
return rc;
}
diff --git a/arch/arm/mach-msm/board-8226-gpiomux.c b/arch/arm/mach-msm/board-8226-gpiomux.c
index 2b5399f..7a53b24 100644
--- a/arch/arm/mach-msm/board-8226-gpiomux.c
+++ b/arch/arm/mach-msm/board-8226-gpiomux.c
@@ -17,6 +17,57 @@
#include <mach/gpio.h>
#include <mach/gpiomux.h>
+#define KS8851_IRQ_GPIO 75
+
+#if defined(CONFIG_KS8851) || defined(CONFIG_KS8851_MODULE)
+static struct gpiomux_setting gpio_eth_config = {
+ .pull = GPIOMUX_PULL_UP,
+ .drv = GPIOMUX_DRV_2MA,
+ .func = GPIOMUX_FUNC_GPIO,
+};
+static struct gpiomux_setting gpio_spi_config = {
+ .func = GPIOMUX_FUNC_1,
+ .drv = GPIOMUX_DRV_8MA,
+ .pull = GPIOMUX_PULL_NONE,
+};
+
+static struct msm_gpiomux_config msm_eth_configs[] = {
+ {
+ .gpio = KS8851_IRQ_GPIO,
+ .settings = {
+ [GPIOMUX_SUSPENDED] = &gpio_eth_config,
+ }
+ },
+};
+
+static struct msm_gpiomux_config msm_blsp_configs[] __initdata = {
+ {
+ .gpio = 0, /* BLSP1 QUP2 SPI_DATA_MOSI */
+ .settings = {
+ [GPIOMUX_SUSPENDED] = &gpio_spi_config,
+ },
+ },
+ {
+ .gpio = 1, /* BLSP1 QUP2 SPI_DATA_MISO */
+ .settings = {
+ [GPIOMUX_SUSPENDED] = &gpio_spi_config,
+ },
+ },
+ {
+ .gpio = 2, /* BLSP1 QUP2 SPI_CS_N */
+ .settings = {
+ [GPIOMUX_SUSPENDED] = &gpio_spi_config,
+ },
+ },
+ {
+ .gpio = 3, /* BLSP1 QUP2 SPI_CLK */
+ .settings = {
+ [GPIOMUX_SUSPENDED] = &gpio_spi_config,
+ },
+ },
+};
+#endif
+
void __init msm8226_init_gpiomux(void)
{
int rc;
@@ -26,4 +77,8 @@
pr_err("%s failed %d\n", __func__, rc);
return;
}
+#if defined(CONFIG_KS8851) || defined(CONFIG_KS8851_MODULE)
+ msm_gpiomux_install(msm_eth_configs, ARRAY_SIZE(msm_eth_configs));
+ msm_gpiomux_install(msm_blsp_configs, ARRAY_SIZE(msm_blsp_configs));
+#endif
}
diff --git a/arch/arm/mach-msm/board-8226.c b/arch/arm/mach-msm/board-8226.c
index a5cb481..2f2eb2c 100644
--- a/arch/arm/mach-msm/board-8226.c
+++ b/arch/arm/mach-msm/board-8226.c
@@ -73,6 +73,8 @@
CLK_DUMMY("iface_clk", NULL, "msm_sdcc.2", OFF),
CLK_DUMMY("core_clk", NULL, "msm_sdcc.2", OFF),
CLK_DUMMY("bus_clk", NULL, "msm_sdcc.2", OFF),
+ CLK_DUMMY("core_clk", NULL, "f9928000.spi", OFF),
+ CLK_DUMMY("iface_clk", NULL, "f9928000.spi", OFF),
};
static struct clock_init_data msm_dummy_clock_init_data __initdata = {
diff --git a/arch/arm/mach-msm/clock-9625.c b/arch/arm/mach-msm/clock-9625.c
index 3b1df2e..f4c045c 100644
--- a/arch/arm/mach-msm/clock-9625.c
+++ b/arch/arm/mach-msm/clock-9625.c
@@ -2101,8 +2101,7 @@
CLK_LOOKUP("phy_clk", gcc_usb_hsic_clk.c, "f9a15000.hsic"),
CLK_LOOKUP("cal_clk", gcc_usb_hsic_io_cal_clk.c, "f9a15000.hsic"),
CLK_LOOKUP("core_clk", gcc_usb_hsic_system_clk.c, "f9a15000.hsic"),
- CLK_LOOKUP("alt_core_clk", gcc_usb_hsic_xcvr_fs_clk.c,
- "f9a15000.hsic"),
+ CLK_LOOKUP("alt_core_clk", gcc_usb_hsic_xcvr_fs_clk.c, ""),
CLK_LOOKUP("core_clk", gcc_ce1_clk.c, "fd400000.qcom,qcedev"),
CLK_LOOKUP("iface_clk", gcc_ce1_ahb_clk.c, "fd400000.qcom,qcedev"),
diff --git a/drivers/bluetooth/hci_smd.c b/drivers/bluetooth/hci_smd.c
index 6030520..9b60bda 100644
--- a/drivers/bluetooth/hci_smd.c
+++ b/drivers/bluetooth/hci_smd.c
@@ -44,6 +44,19 @@
#define RX_Q_MONITOR (500) /* 500 milli second */
#define HCI_REGISTER_SET 0
+/* SSR state machine to take care of back to back SSR requests
+ * and handling the incomming BT on/off,Airplane mode toggling and
+ * also spuriour SMD open notification while one SSr is in progress
+ */
+#define STATE_SSR_ON 0x1
+#define STATE_SSR_START 0x02
+#define STATE_SSR_CHANNEL_OPEN_PENDING 0x04
+#define STATE_SSR_PENDING_INIT 0x08
+#define STATE_SSR_COMPLETE 0x00
+#define STATE_SSR_OFF STATE_SSR_COMPLETE
+
+static int ssr_state = STATE_SSR_OFF;
+
static int hcismd_set;
static DEFINE_SEMAPHORE(hci_smd_enable);
@@ -341,25 +354,47 @@
break;
case SMD_EVENT_OPEN:
BT_INFO("opening HCI-SMD channel :%s", EVENT_CHANNEL);
- hci_smd_open(hdev);
- open_worker = kzalloc(sizeof(*open_worker), GFP_ATOMIC);
- if (!open_worker) {
- BT_ERR("Out of memory");
- break;
+ BT_DBG("SSR state is : %x", ssr_state);
+ if ((ssr_state == STATE_SSR_OFF) ||
+ (ssr_state == STATE_SSR_CHANNEL_OPEN_PENDING)) {
+
+ hci_smd_open(hdev);
+ open_worker = kzalloc(sizeof(*open_worker), GFP_ATOMIC);
+ if (!open_worker) {
+ BT_ERR("Out of memory");
+ break;
+ }
+ if (ssr_state == STATE_SSR_CHANNEL_OPEN_PENDING) {
+ ssr_state = STATE_SSR_PENDING_INIT;
+ BT_INFO("SSR state is : %x", ssr_state);
+ }
+ INIT_WORK(open_worker, hci_dev_smd_open);
+ schedule_work(open_worker);
+
}
- INIT_WORK(open_worker, hci_dev_smd_open);
- schedule_work(open_worker);
break;
case SMD_EVENT_CLOSE:
BT_INFO("Closing HCI-SMD channel :%s", EVENT_CHANNEL);
- hci_smd_close(hdev);
- reset_worker = kzalloc(sizeof(*reset_worker), GFP_ATOMIC);
- if (!reset_worker) {
- BT_ERR("Out of memory");
- break;
+ BT_DBG("SSR state is : %x", ssr_state);
+ if ((ssr_state == STATE_SSR_OFF) ||
+ (ssr_state == (STATE_SSR_PENDING_INIT))) {
+
+ hci_smd_close(hdev);
+ reset_worker = kzalloc(sizeof(*reset_worker),
+ GFP_ATOMIC);
+ if (!reset_worker) {
+ BT_ERR("Out of memory");
+ break;
+ }
+ ssr_state = STATE_SSR_ON;
+ BT_INFO("SSR state is : %x", ssr_state);
+ INIT_WORK(reset_worker, hci_dev_restart);
+ schedule_work(reset_worker);
+
+ } else if (ssr_state & STATE_SSR_ON) {
+ BT_ERR("SSR state is : %x", ssr_state);
}
- INIT_WORK(reset_worker, hci_dev_restart);
- schedule_work(reset_worker);
+
break;
default:
break;
@@ -403,19 +438,37 @@
{
struct hci_dev *hdev;
- hdev = hsmd->hdev;
- if (test_and_set_bit(HCI_REGISTER_SET, &hsmd->flags)) {
- BT_ERR("HCI device registered already");
+ if (hsmd->hdev)
+ hdev = hsmd->hdev;
+ else {
+ BT_ERR("hdev is NULL");
return 0;
- } else
- BT_INFO("HCI device registration is starting");
- if (hci_register_dev(hdev) < 0) {
- BT_ERR("Can't register HCI device");
- hci_free_dev(hdev);
- hsmd->hdev = NULL;
- clear_bit(HCI_REGISTER_SET, &hsmd->flags);
- return -ENODEV;
}
+ /* Allow the incomming SSR even the prev one at PENDING INIT STATE
+ * since clenup need to be started again from the beging and ignore
+ * or bypass the prev one
+ */
+ if ((ssr_state == STATE_SSR_OFF) ||
+ (ssr_state == STATE_SSR_PENDING_INIT)) {
+
+ if (test_and_set_bit(HCI_REGISTER_SET, &hsmd->flags)) {
+ BT_ERR("HCI device registered already");
+ return 0;
+ } else
+ BT_INFO("HCI device registration is starting");
+ if (hci_register_dev(hdev) < 0) {
+ BT_ERR("Can't register HCI device");
+ hci_free_dev(hdev);
+ hsmd->hdev = NULL;
+ clear_bit(HCI_REGISTER_SET, &hsmd->flags);
+ return -ENODEV;
+ }
+ if (ssr_state == STATE_SSR_PENDING_INIT) {
+ ssr_state = STATE_SSR_COMPLETE;
+ BT_INFO("SSR state is : %x", ssr_state);
+ }
+ } else if (ssr_state)
+ BT_ERR("Registration called in invalid context");
return 0;
}
@@ -449,7 +502,10 @@
*/
setup_timer(&hsmd->rx_q_timer, schedule_timer,
(unsigned long) hsmd->hdev);
-
+ if (ssr_state == STATE_SSR_START) {
+ ssr_state = STATE_SSR_CHANNEL_OPEN_PENDING;
+ BT_INFO("SSR state is : %x", ssr_state);
+ }
/* Open the SMD Channel and device and register the callback function */
rc = smd_named_open_on_edge(EVENT_CHANNEL, SMD_APPS_WCNSS,
&hsmd->event_channel, hdev, hci_smd_notify_event);
@@ -478,21 +534,25 @@
static void hci_smd_deregister_dev(struct hci_smd_data *hsmd)
{
tasklet_kill(&hs.rx_task);
-
+ if (ssr_state)
+ BT_DBG("SSR state is : %x", ssr_state);
+ /* Though the hci_smd driver is not registered with the hci
+ * need to close the opened channels as a part of cleaup
+ */
if (!test_and_clear_bit(HCI_REGISTER_SET, &hsmd->flags)) {
BT_ERR("HCI device un-registered already");
- return;
- } else
+ } else {
BT_INFO("HCI device un-registration going on");
- if (hsmd->hdev) {
- if (hci_unregister_dev(hsmd->hdev) < 0)
- BT_ERR("Can't unregister HCI device %s",
- hsmd->hdev->name);
- hci_free_dev(hsmd->hdev);
- hsmd->hdev = NULL;
+ if (hsmd->hdev) {
+ if (hci_unregister_dev(hsmd->hdev) < 0)
+ BT_ERR("Can't unregister HCI device %s",
+ hsmd->hdev->name);
+
+ hci_free_dev(hsmd->hdev);
+ hsmd->hdev = NULL;
+ }
}
-
smd_close(hs.event_channel);
smd_close(hs.data_channel);
@@ -513,23 +573,47 @@
{
down(&hci_smd_enable);
restart_in_progress = 1;
+ BT_DBG("SSR state is : %x", ssr_state);
+
+ if (ssr_state == STATE_SSR_ON) {
+ ssr_state = STATE_SSR_START;
+ BT_INFO("SSR state is : %x", ssr_state);
+ } else {
+ BT_ERR("restart triggered in wrong context");
+ up(&hci_smd_enable);
+ kfree(worker);
+ return;
+ }
hci_smd_deregister_dev(&hs);
hci_smd_register_smd(&hs);
up(&hci_smd_enable);
kfree(worker);
+
}
static void hci_dev_smd_open(struct work_struct *worker)
{
down(&hci_smd_enable);
+ if (ssr_state)
+ BT_DBG("SSR state is : %x", ssr_state);
+
+ if ((ssr_state != STATE_SSR_OFF) &&
+ (ssr_state != (STATE_SSR_PENDING_INIT))) {
+ up(&hci_smd_enable);
+ kfree(worker);
+ return;
+ }
+
if (restart_in_progress == 1) {
/* Allow wcnss to initialize */
restart_in_progress = 0;
msleep(10000);
}
+
hci_smd_hci_register_dev(&hs);
up(&hci_smd_enable);
kfree(worker);
+
}
static int hcismd_set_enable(const char *val, struct kernel_param *kp)
@@ -545,14 +629,23 @@
if (ret)
goto done;
+ /* Ignore the all incomming register de-register requests in case of
+ * SSR is in-progress
+ */
switch (hcismd_set) {
case 1:
- if (hs.hdev == NULL)
+ if ((hs.hdev == NULL) && (ssr_state == STATE_SSR_OFF))
hci_smd_register_smd(&hs);
+ else if (ssr_state)
+ BT_ERR("SSR is in progress,state is : %x", ssr_state);
+
break;
case 0:
- hci_smd_deregister_dev(&hs);
+ if (ssr_state == STATE_SSR_OFF)
+ hci_smd_deregister_dev(&hs);
+ else if (ssr_state)
+ BT_ERR("SSR is in progress,state is : %x", ssr_state);
break;
default:
ret = -EFAULT;
@@ -569,6 +662,7 @@
wake_lock_init(&hs.wake_lock_tx, WAKE_LOCK_SUSPEND,
"msm_smd_Tx");
restart_in_progress = 0;
+ ssr_state = STATE_SSR_OFF;
hs.hdev = NULL;
return 0;
}
diff --git a/drivers/char/diag/diag_masks.c b/drivers/char/diag/diag_masks.c
index 2a85a00..e8567db 100644
--- a/drivers/char/diag/diag_masks.c
+++ b/drivers/char/diag/diag_masks.c
@@ -26,6 +26,9 @@
#define ALL_SSID -1
#define MAX_SSID_PER_RANGE 100
+#define FEATURE_MASK_LEN_BYTES 1
+#define APPS_RESPOND_LOG_ON_DEMAND 0x04
+
struct mask_info {
int equip_id;
int num_items;
@@ -309,6 +312,7 @@
smd_info->peripheral);
diag_send_log_mask_update(smd_info->ch, ALL_EQUIP_ID);
diag_send_event_mask_update(smd_info->ch, diag_event_num_bytes);
+ diag_send_feature_mask_update(smd_info->ch, smd_info->peripheral);
smd_info->notify_context = 0;
}
@@ -461,6 +465,42 @@
mutex_unlock(&driver->diag_cntl_mutex);
}
+void diag_send_feature_mask_update(smd_channel_t *ch, int proc)
+{
+ void *buf = driver->buf_feature_mask_update;
+ int header_size = sizeof(struct diag_ctrl_feature_mask);
+ int wr_size = -ENOMEM, retry_count = 0, timer;
+ uint8_t feature_byte = 0;
+
+ mutex_lock(&driver->diag_cntl_mutex);
+ /* send feature mask update */
+ driver->feature_mask->ctrl_pkt_id = DIAG_CTRL_MSG_FEATURE;
+ driver->feature_mask->ctrl_pkt_data_len = 4 + FEATURE_MASK_LEN_BYTES;
+ driver->feature_mask->feature_mask_len = FEATURE_MASK_LEN_BYTES;
+ memcpy(buf, driver->feature_mask, header_size);
+ feature_byte |= APPS_RESPOND_LOG_ON_DEMAND;
+ memcpy(buf+header_size, &feature_byte, FEATURE_MASK_LEN_BYTES);
+
+ if (ch) {
+ while (retry_count < 3) {
+ wr_size = smd_write(ch, buf, header_size +
+ FEATURE_MASK_LEN_BYTES);
+ if (wr_size == -ENOMEM) {
+ retry_count++;
+ for (timer = 0; timer < 5; timer++)
+ udelay(2000);
+ } else
+ break;
+ }
+ if (wr_size != header_size + FEATURE_MASK_LEN_BYTES)
+ pr_err("diag: proc %d fail feature update %d, tried %d",
+ proc, wr_size, header_size + FEATURE_MASK_LEN_BYTES);
+ } else
+ pr_err("diag: ch invalid, feature update on proc %d\n", proc);
+ mutex_unlock(&driver->diag_cntl_mutex);
+
+}
+
int diag_process_apps_masks(unsigned char *buf, int len)
{
int packet_type = 1;
@@ -671,6 +711,16 @@
return 0;
}
#endif
+ } else if (*buf == 0x78) {
+ if (!(driver->smd_cntl[MODEM_DATA].ch) ||
+ (driver->log_on_demand_support)) {
+ driver->apps_rsp_buf[0] = 0x78;
+ /* Copy log code received */
+ *(uint16_t *)(driver->apps_rsp_buf+1) =
+ *(uint16_t *)buf;
+ driver->apps_rsp_buf[3] = 0x1;/* Unknown */
+ encode_rsp_and_send(3);
+ }
}
return packet_type;
@@ -727,6 +777,21 @@
goto err;
kmemleak_not_leak(driver->msg_masks);
}
+ if (driver->buf_feature_mask_update == NULL) {
+ driver->buf_feature_mask_update = kzalloc(sizeof(
+ struct diag_ctrl_feature_mask) +
+ FEATURE_MASK_LEN_BYTES, GFP_KERNEL);
+ if (driver->buf_feature_mask_update == NULL)
+ goto err;
+ kmemleak_not_leak(driver->buf_feature_mask_update);
+ }
+ if (driver->feature_mask == NULL) {
+ driver->feature_mask = kzalloc(sizeof(
+ struct diag_ctrl_feature_mask), GFP_KERNEL);
+ if (driver->feature_mask == NULL)
+ goto err;
+ kmemleak_not_leak(driver->feature_mask);
+ }
diag_create_msg_mask_table();
diag_event_num_bytes = 0;
if (driver->log_masks == NULL) {
@@ -751,6 +816,8 @@
kfree(driver->msg_masks);
kfree(driver->log_masks);
kfree(driver->event_masks);
+ kfree(driver->feature_mask);
+ kfree(driver->buf_feature_mask_update);
}
void diag_masks_exit(void)
@@ -761,4 +828,6 @@
kfree(driver->msg_masks);
kfree(driver->log_masks);
kfree(driver->event_masks);
+ kfree(driver->feature_mask);
+ kfree(driver->buf_feature_mask_update);
}
diff --git a/drivers/char/diag/diag_masks.h b/drivers/char/diag/diag_masks.h
index f144774..53f72e8 100644
--- a/drivers/char/diag/diag_masks.h
+++ b/drivers/char/diag/diag_masks.h
@@ -21,6 +21,7 @@
int ssid_last, int proc);
void diag_send_log_mask_update(smd_channel_t *, int);
void diag_mask_update_fn(struct work_struct *work);
+void diag_send_feature_mask_update(smd_channel_t *ch, int proc);
int diag_process_apps_masks(unsigned char *buf, int len);
void diag_masks_init(void);
void diag_masks_exit(void);
diff --git a/drivers/char/diag/diagchar.h b/drivers/char/diag/diagchar.h
index 8c46a5d..0b395c5 100644
--- a/drivers/char/diag/diagchar.h
+++ b/drivers/char/diag/diagchar.h
@@ -231,6 +231,7 @@
struct diag_ctrl_event_mask *event_mask;
struct diag_ctrl_log_mask *log_mask;
struct diag_ctrl_msg_mask *msg_mask;
+ struct diag_ctrl_feature_mask *feature_mask;
/* State for diag forwarding */
struct diag_smd_info smd_data[NUM_SMD_DATA_CHANNELS];
struct diag_smd_info smd_cntl[NUM_SMD_CONTROL_CHANNELS];
@@ -242,6 +243,7 @@
unsigned char *buf_msg_mask_update;
unsigned char *buf_log_mask_update;
unsigned char *buf_event_mask_update;
+ unsigned char *buf_feature_mask_update;
int read_len_legacy;
unsigned char *hdlc_buf;
unsigned hdlc_count;
@@ -259,6 +261,7 @@
uint8_t *log_masks;
int log_masks_length;
uint8_t *event_masks;
+ uint8_t log_on_demand_support;
struct diag_master_table *table;
uint8_t *pkt_buf;
int pkt_length;
diff --git a/drivers/char/diag/diagfwd_cntl.c b/drivers/char/diag/diagfwd_cntl.c
index a900d97..acac2fb 100644
--- a/drivers/char/diag/diagfwd_cntl.c
+++ b/drivers/char/diag/diagfwd_cntl.c
@@ -44,6 +44,7 @@
int total_recd)
{
int data_len = 0, type = -1, count_bytes = 0, j, flag = 0;
+ int feature_mask_len;
struct bindpkt_params_per_process *pkt_params =
kzalloc(sizeof(struct bindpkt_params_per_process), GFP_KERNEL);
struct diag_ctrl_msg *msg;
@@ -115,6 +116,11 @@
pr_err("diag: drop reg proc %d\n",
smd_info->peripheral);
kfree(temp);
+ } else if ((type == DIAG_CTRL_MSG_FEATURE) &&
+ (smd_info->peripheral == MODEM_DATA)) {
+ feature_mask_len = *(int *)(buf + 8);
+ driver->log_on_demand_support = (*(uint8_t *)
+ (buf + 12)) & 0x04;
} else if (type != DIAG_CTRL_MSG_REG) {
flag = 1;
}
@@ -209,6 +215,7 @@
reg_dirty = 0;
driver->polling_reg_flag = 0;
+ driver->log_on_demand_support = 1;
driver->diag_cntl_wq = create_singlethread_workqueue("diag_cntl_wq");
success = diag_smd_constructor(&driver->smd_cntl[MODEM_DATA],
diff --git a/drivers/char/diag/diagfwd_cntl.h b/drivers/char/diag/diagfwd_cntl.h
index aeb4ba1..8d262c4 100644
--- a/drivers/char/diag/diagfwd_cntl.h
+++ b/drivers/char/diag/diagfwd_cntl.h
@@ -77,6 +77,13 @@
/* Copy msg mask here */
} __packed;
+struct diag_ctrl_feature_mask {
+ uint32_t ctrl_pkt_id;
+ uint32_t ctrl_pkt_data_len;
+ uint32_t feature_mask_len;
+ /* Copy feature mask here */
+} __packed;
+
void diagfwd_cntl_init(void);
void diagfwd_cntl_exit(void);
void diag_read_smd_cntl_work_fn(struct work_struct *);
diff --git a/drivers/hwmon/qpnp-adc-common.c b/drivers/hwmon/qpnp-adc-common.c
index 440dc42..bde18d4 100644
--- a/drivers/hwmon/qpnp-adc-common.c
+++ b/drivers/hwmon/qpnp-adc-common.c
@@ -130,175 +130,6 @@
{790, 203}
};
-static const struct qpnp_vadc_map_pt adcmap_ntcg_104ef_104fb[] = {
- {696483, -40960},
- {649148, -39936},
- {605368, -38912},
- {564809, -37888},
- {527215, -36864},
- {492322, -35840},
- {460007, -34816},
- {429982, -33792},
- {402099, -32768},
- {376192, -31744},
- {352075, -30720},
- {329714, -29696},
- {308876, -28672},
- {289480, -27648},
- {271417, -26624},
- {254574, -25600},
- {238903, -24576},
- {224276, -23552},
- {210631, -22528},
- {197896, -21504},
- {186007, -20480},
- {174899, -19456},
- {164521, -18432},
- {154818, -17408},
- {145744, -16384},
- {137265, -15360},
- {129307, -14336},
- {121866, -13312},
- {114896, -12288},
- {108365, -11264},
- {102252, -10240},
- {96499, -9216},
- {91111, -8192},
- {86055, -7168},
- {81308, -6144},
- {76857, -5120},
- {72660, -4096},
- {68722, -3072},
- {65020, -2048},
- {61538, -1024},
- {58261, 0},
- {55177, 1024},
- {52274, 2048},
- {49538, 3072},
- {46962, 4096},
- {44531, 5120},
- {42243, 6144},
- {40083, 7168},
- {38045, 8192},
- {36122, 9216},
- {34308, 10240},
- {32592, 11264},
- {30972, 12288},
- {29442, 13312},
- {27995, 14336},
- {26624, 15360},
- {25333, 16384},
- {24109, 17408},
- {22951, 18432},
- {21854, 19456},
- {20807, 20480},
- {19831, 21504},
- {18899, 22528},
- {18016, 23552},
- {17178, 24576},
- {16384, 25600},
- {15631, 26624},
- {14916, 27648},
- {14237, 28672},
- {13593, 29696},
- {12976, 30720},
- {12400, 31744},
- {11848, 32768},
- {11324, 33792},
- {10825, 34816},
- {10354, 35840},
- {9900, 36864},
- {9471, 37888},
- {9062, 38912},
- {8674, 39936},
- {8306, 40960},
- {7951, 41984},
- {7616, 43008},
- {7296, 44032},
- {6991, 45056},
- {6701, 46080},
- {6424, 47104},
- {6160, 48128},
- {5908, 49152},
- {5667, 50176},
- {5439, 51200},
- {5219, 52224},
- {5010, 53248},
- {4810, 54272},
- {4619, 55296},
- {4440, 56320},
- {4263, 57344},
- {4097, 58368},
- {3938, 59392},
- {3785, 60416},
- {3637, 61440},
- {3501, 62464},
- {3368, 63488},
- {3240, 64512},
- {3118, 65536},
- {2998, 66560},
- {2889, 67584},
- {2782, 68608},
- {2680, 69632},
- {2581, 70656},
- {2490, 71680},
- {2397, 72704},
- {2310, 73728},
- {2227, 74752},
- {2147, 75776},
- {2064, 76800},
- {1998, 77824},
- {1927, 78848},
- {1860, 79872},
- {1795, 80896},
- {1736, 81920},
- {1673, 82944},
- {1615, 83968},
- {1560, 84992},
- {1507, 86016},
- {1456, 87040},
- {1407, 88064},
- {1360, 89088},
- {1314, 90112},
- {1271, 91136},
- {1228, 92160},
- {1189, 93184},
- {1150, 94208},
- {1112, 95232},
- {1076, 96256},
- {1042, 97280},
- {1008, 98304},
- {976, 99328},
- {945, 100352},
- {915, 101376},
- {886, 102400},
- {859, 103424},
- {832, 104448},
- {807, 105472},
- {782, 106496},
- {756, 107520},
- {735, 108544},
- {712, 109568},
- {691, 110592},
- {670, 111616},
- {650, 112640},
- {631, 113664},
- {612, 114688},
- {594, 115712},
- {577, 116736},
- {560, 117760},
- {544, 118784},
- {528, 119808},
- {513, 120832},
- {498, 121856},
- {483, 122880},
- {470, 123904},
- {457, 124928},
- {444, 125952},
- {431, 126976},
- {419, 128000}
-};
-
/* Voltage to temperature */
static const struct qpnp_vadc_map_pt adcmap_100k_104ef_104fb[] = {
{1758, -40},
@@ -553,9 +384,9 @@
xo_thm = qpnp_adc_scale_ratiometric_calib(adc_code,
adc_properties, chan_properties);
- xo_thm <<= 4;
- qpnp_adc_map_voltage_temp(adcmap_ntcg_104ef_104fb,
- ARRAY_SIZE(adcmap_ntcg_104ef_104fb),
+
+ qpnp_adc_map_voltage_temp(adcmap_100k_104ef_104fb,
+ ARRAY_SIZE(adcmap_100k_104ef_104fb),
xo_thm, &adc_chan_result->physical);
return 0;
diff --git a/drivers/hwmon/qpnp-adc-current.c b/drivers/hwmon/qpnp-adc-current.c
index 0290335..c28c61d 100644
--- a/drivers/hwmon/qpnp-adc-current.c
+++ b/drivers/hwmon/qpnp-adc-current.c
@@ -789,7 +789,7 @@
return 0;
fail:
- adc_qpnp = NULL;
+ qpnp_iadc = NULL;
return rc;
}
diff --git a/drivers/media/dvb/mpq/demux/mpq_dmx_plugin_common.c b/drivers/media/dvb/mpq/demux/mpq_dmx_plugin_common.c
index 1587068..aff1046 100644
--- a/drivers/media/dvb/mpq/demux/mpq_dmx_plugin_common.c
+++ b/drivers/media/dvb/mpq/demux/mpq_dmx_plugin_common.c
@@ -1,4 +1,4 @@
-/* Copyright (c) 2012, Code Aurora Forum. All rights reserved.
+/* Copyright (c) 2012, 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
@@ -39,10 +39,14 @@
static int mpq_demux_device_num = CONFIG_DVB_MPQ_NUM_DMX_DEVICES;
module_param(mpq_demux_device_num, int, S_IRUGO);
-/* ION heap ID to be used when calling ion_alloc for video decoder buffer */
-static int video_ion_alloc_heap = ION_CP_MM_HEAP_ID;
-module_param(video_ion_alloc_heap, int, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(video_ion_alloc_heap, "ION heap ID for allocation");
+/* ION heap IDs used for allocating video output buffer */
+static int video_secure_ion_heap = ION_CP_MM_HEAP_ID;
+module_param(video_secure_ion_heap , int, S_IRUGO | S_IWUSR);
+MODULE_PARM_DESC(video_secure_ion_heap, "ION heap for secure video buffer allocation");
+
+static int video_nonsecure_ion_heap = ION_IOMMU_HEAP_ID;
+module_param(video_nonsecure_ion_heap, int, S_IRUGO | S_IWUSR);
+MODULE_PARM_DESC(video_nonsecure_ion_heap, "ION heap for non-secure video buffer allocation");
static int generate_es_events;
module_param(generate_es_events, int, S_IRUGO | S_IWUSR);
@@ -1033,7 +1037,9 @@
actual_buffer_size &= ~(SZ_4K - 1);
temp_handle = ion_alloc(client, actual_buffer_size, SZ_4K,
- ION_HEAP(video_ion_alloc_heap), ION_FLAG_CACHED);
+ ION_HEAP(video_secure_ion_heap) |
+ ION_HEAP(video_nonsecure_ion_heap),
+ ION_FLAG_CACHED);
if (IS_ERR_OR_NULL(temp_handle)) {
ret = PTR_ERR(temp_handle);
@@ -2601,27 +2607,18 @@
const struct ts_packet_header *ts_header;
const struct ts_adaptation_field *adaptation_field;
- /*
- * When we play from front-end, we configure HW
- * to output the extra timestamp, if we are playing
- * from DVR, make sure the format is 192 packet.
- */
- if ((mpq_demux->source >= DMX_SOURCE_DVR0) &&
- (mpq_demux->demux.tsp_format != DMX_TSP_FORMAT_192_TAIL)) {
- MPQ_DVB_ERR_PRINT(
- "%s: invalid packet format %d for PCR extraction\n",
- __func__,
- mpq_demux->demux.tsp_format);
-
- return -EINVAL;
- }
-
ts_header = (const struct ts_packet_header *)buf;
/* Make sure this TS packet has a adaptation field */
if ((ts_header->sync_byte != 0x47) ||
(ts_header->adaptation_field_control == 0) ||
- (ts_header->adaptation_field_control == 1)) {
+ (ts_header->adaptation_field_control == 1) ||
+ ts_header->transport_error_indicator) {
+ MPQ_DVB_DBG_PRINT(
+ "%s: PCR packet dropped, AFC %d, TEI %d\n",
+ __func__,
+ ts_header->adaptation_field_control,
+ ts_header->transport_error_indicator);
return 0;
}
@@ -2642,10 +2639,21 @@
(((u64)adaptation_field->program_clock_reference_ext_1) << 8) +
adaptation_field->program_clock_reference_ext_2;
- stc = buf[190] << 16;
- stc += buf[189] << 8;
- stc += buf[188];
- stc *= 256; /* convert from 105.47 KHZ to 27MHz */
+ /*
+ * When we play from front-end, we configure HW
+ * to output the extra timestamp, if we are playing
+ * from DVR, we don't have a timestamp if the packet
+ * format is not 192-tail.
+ */
+ if ((mpq_demux->source >= DMX_SOURCE_DVR0) &&
+ (mpq_demux->demux.tsp_format != DMX_TSP_FORMAT_192_TAIL)) {
+ stc = 0;
+ } else {
+ stc = buf[190] << 16;
+ stc += buf[189] << 8;
+ stc += buf[188];
+ stc *= 256; /* convert from 105.47 KHZ to 27MHz */
+ }
data.data_length = 0;
data.pcr.pcr = pcr;
diff --git a/drivers/media/video/msm_vidc/hfi_response_handler.c b/drivers/media/video/msm_vidc/hfi_response_handler.c
index 37605f9..50970cb 100644
--- a/drivers/media/video/msm_vidc/hfi_response_handler.c
+++ b/drivers/media/video/msm_vidc/hfi_response_handler.c
@@ -18,7 +18,7 @@
#include "vidc_hfi_io.h"
#include "msm_vidc_debug.h"
-static enum vidc_status vidc_map_hal_err_status(int hfi_err)
+static enum vidc_status hfi_map_err_status(int hfi_err)
{
enum vidc_status vidc_err;
switch (hfi_err) {
@@ -75,7 +75,7 @@
return vidc_err;
}
-void hal_process_sess_evt_seq_changed(struct hal_device *device,
+static void hfi_process_sess_evt_seq_changed(struct venus_hfi_device *device,
struct hfi_msg_event_notify_packet *pkt)
{
struct msm_vidc_cb_cmd_done cmd_done;
@@ -138,7 +138,7 @@
cmd_done.data = &event_notify;
device->callback(VIDC_EVENT_CHANGE, &cmd_done);
}
-static void hal_process_sys_watchdog_timeout(struct hal_device *device)
+static void hfi_process_sys_watchdog_timeout(struct venus_hfi_device *device)
{
struct msm_vidc_cb_cmd_done cmd_done;
device->intr_status &= ~VIDC_WRAPPER_INTR_STATUS_A2HWD_BMSK;
@@ -146,14 +146,14 @@
cmd_done.device_id = device->device_id;
device->callback(SYS_WATCHDOG_TIMEOUT, &cmd_done);
}
-static void hal_process_sys_error(struct hal_device *device)
+static void hfi_process_sys_error(struct venus_hfi_device *device)
{
struct msm_vidc_cb_cmd_done cmd_done;
memset(&cmd_done, 0, sizeof(struct msm_vidc_cb_cmd_done));
cmd_done.device_id = device->device_id;
device->callback(SYS_ERROR, &cmd_done);
}
-static void hal_process_session_error(struct hal_device *device,
+static void hfi_process_session_error(struct venus_hfi_device *device,
struct hfi_msg_event_notify_packet *pkt)
{
struct msm_vidc_cb_cmd_done cmd_done;
@@ -163,7 +163,7 @@
session_id;
device->callback(SESSION_ERROR, &cmd_done);
}
-static void hal_process_event_notify(struct hal_device *device,
+static void hfi_process_event_notify(struct venus_hfi_device *device,
struct hfi_msg_event_notify_packet *pkt)
{
dprintk(VIDC_DBG, "RECVD:EVENT_NOTIFY");
@@ -178,15 +178,15 @@
case HFI_EVENT_SYS_ERROR:
dprintk(VIDC_ERR, "HFI_EVENT_SYS_ERROR: %d\n",
pkt->event_data1);
- hal_process_sys_error(device);
+ hfi_process_sys_error(device);
break;
case HFI_EVENT_SESSION_ERROR:
dprintk(VIDC_ERR, "HFI_EVENT_SESSION_ERROR");
- hal_process_session_error(device, pkt);
+ hfi_process_session_error(device, pkt);
break;
case HFI_EVENT_SESSION_SEQUENCE_CHANGED:
dprintk(VIDC_INFO, "HFI_EVENT_SESSION_SEQUENCE_CHANGED");
- hal_process_sess_evt_seq_changed(device, pkt);
+ hfi_process_sess_evt_seq_changed(device, pkt);
break;
case HFI_EVENT_SESSION_PROPERTY_CHANGED:
dprintk(VIDC_INFO, "HFI_EVENT_SESSION_PROPERTY_CHANGED");
@@ -196,7 +196,7 @@
break;
}
}
-static void hal_process_sys_init_done(struct hal_device *device,
+static void hfi_process_sys_init_done(struct venus_hfi_device *device,
struct hfi_msg_sys_init_done_packet *pkt)
{
struct msm_vidc_cb_cmd_done cmd_done;
@@ -213,7 +213,7 @@
return;
}
- status = vidc_map_hal_err_status((u32)pkt->error_type);
+ status = hfi_map_err_status((u32)pkt->error_type);
if (!status) {
if (pkt->num_properties == 0) {
@@ -281,7 +281,7 @@
device->callback(SYS_INIT_DONE, &cmd_done);
}
-static void hal_process_sys_rel_resource_done(struct hal_device *device,
+static void hfi_process_sys_rel_resource_done(struct venus_hfi_device *device,
struct hfi_msg_sys_release_resource_done_packet *pkt)
{
struct msm_vidc_cb_cmd_done cmd_done;
@@ -296,7 +296,7 @@
pkt->size);
return;
}
- status = vidc_map_hal_err_status((u32)pkt->error_type);
+ status = hfi_map_err_status((u32)pkt->error_type);
cmd_done.device_id = device->device_id;
cmd_done.session_id = 0;
cmd_done.status = (u32) status;
@@ -305,14 +305,14 @@
device->callback(RELEASE_RESOURCE_DONE, &cmd_done);
}
-enum vidc_status vidc_hal_process_sess_init_done_prop_read(
+enum vidc_status hfi_process_sess_init_done_prop_read(
struct hfi_msg_sys_session_init_done_packet *pkt,
struct msm_vidc_cb_cmd_done *cmddone)
{
return VIDC_ERR_NONE;
}
-static void hal_process_sess_get_prop_buf_req(
+static void hfi_process_sess_get_prop_buf_req(
struct hfi_msg_session_property_info_packet *prop,
struct buffer_requirements *buffreq)
{
@@ -408,7 +408,7 @@
}
}
-static void hal_process_session_prop_info(struct hal_device *device,
+static void hfi_process_session_prop_info(struct venus_hfi_device *device,
struct hfi_msg_session_property_info_packet *pkt)
{
struct msm_vidc_cb_cmd_done cmd_done;
@@ -432,7 +432,7 @@
switch (pkt->rg_property_data[0]) {
case HFI_PROPERTY_CONFIG_BUFFER_REQUIREMENTS:
- hal_process_sess_get_prop_buf_req(pkt, &buff_req);
+ hfi_process_sess_get_prop_buf_req(pkt, &buff_req);
cmd_done.device_id = device->device_id;
cmd_done.session_id =
((struct hal_session *) pkt->session_id)->session_id;
@@ -449,7 +449,7 @@
}
}
-static void hal_process_session_init_done(struct hal_device *device,
+static void hfi_process_session_init_done(struct venus_hfi_device *device,
struct hfi_msg_sys_session_init_done_packet *pkt)
{
struct msm_vidc_cb_cmd_done cmd_done;
@@ -469,17 +469,17 @@
cmd_done.device_id = device->device_id;
cmd_done.session_id =
((struct hal_session *) pkt->session_id)->session_id;
- cmd_done.status = vidc_map_hal_err_status((u32)pkt->error_type);
+ cmd_done.status = hfi_map_err_status((u32)pkt->error_type);
cmd_done.data = &session_init_done;
if (!cmd_done.status) {
- cmd_done.status = vidc_hal_process_sess_init_done_prop_read(
+ cmd_done.status = hfi_process_sess_init_done_prop_read(
pkt, &cmd_done);
}
cmd_done.size = sizeof(struct vidc_hal_session_init_done);
device->callback(SESSION_INIT_DONE, &cmd_done);
}
-static void hal_process_session_load_res_done(struct hal_device *device,
+static void hfi_process_session_load_res_done(struct venus_hfi_device *device,
struct hfi_msg_session_load_resources_done_packet *pkt)
{
struct msm_vidc_cb_cmd_done cmd_done;
@@ -497,13 +497,13 @@
cmd_done.device_id = device->device_id;
cmd_done.session_id =
((struct hal_session *) pkt->session_id)->session_id;
- cmd_done.status = vidc_map_hal_err_status((u32)pkt->error_type);
+ cmd_done.status = hfi_map_err_status((u32)pkt->error_type);
cmd_done.data = NULL;
cmd_done.size = 0;
device->callback(SESSION_LOAD_RESOURCE_DONE, &cmd_done);
}
-static void hal_process_session_flush_done(struct hal_device *device,
+static void hfi_process_session_flush_done(struct venus_hfi_device *device,
struct hfi_msg_session_flush_done_packet *pkt)
{
struct msm_vidc_cb_cmd_done cmd_done;
@@ -520,13 +520,13 @@
cmd_done.device_id = device->device_id;
cmd_done.session_id =
((struct hal_session *) pkt->session_id)->session_id;
- cmd_done.status = vidc_map_hal_err_status((u32)pkt->error_type);
+ cmd_done.status = hfi_map_err_status((u32)pkt->error_type);
cmd_done.data = (void *) pkt->flush_type;
cmd_done.size = sizeof(u32);
device->callback(SESSION_FLUSH_DONE, &cmd_done);
}
-static void hal_process_session_etb_done(struct hal_device *device,
+static void hfi_process_session_etb_done(struct venus_hfi_device *device,
struct hfi_msg_session_empty_buffer_done_packet *pkt)
{
struct msm_vidc_cb_data_done data_done;
@@ -544,7 +544,7 @@
data_done.device_id = device->device_id;
data_done.session_id =
((struct hal_session *) pkt->session_id)->session_id;
- data_done.status = vidc_map_hal_err_status((u32) pkt->error_type);
+ data_done.status = hfi_map_err_status((u32) pkt->error_type);
data_done.size = sizeof(struct msm_vidc_cb_data_done);
data_done.clnt_data = (void *)pkt->input_tag;
data_done.input_done.offset = pkt->offset;
@@ -553,7 +553,7 @@
device->callback(SESSION_ETB_DONE, &data_done);
}
-static void hal_process_session_ftb_done(struct hal_device *device,
+static void hfi_process_session_ftb_done(struct venus_hfi_device *device,
void *msg_hdr)
{
struct msm_vidc_cb_data_done data_done;
@@ -592,7 +592,7 @@
data_done.device_id = device->device_id;
data_done.session_id = (u32) session;
- data_done.status = vidc_map_hal_err_status((u32)
+ data_done.status = hfi_map_err_status((u32)
pkt->error_type);
data_done.size = sizeof(struct msm_vidc_cb_data_done);
data_done.clnt_data = (void *) pkt->input_tag;
@@ -626,7 +626,7 @@
data_done.device_id = device->device_id;
data_done.session_id = (u32) session;
- data_done.status = vidc_map_hal_err_status((u32)
+ data_done.status = hfi_map_err_status((u32)
pkt->error_type);
data_done.size = sizeof(struct msm_vidc_cb_data_done);
data_done.clnt_data = (void *)pkt->input_tag;
@@ -660,7 +660,7 @@
device->callback(SESSION_FTB_DONE, &data_done);
}
-static void hal_process_session_start_done(struct hal_device *device,
+static void hfi_process_session_start_done(struct venus_hfi_device *device,
struct hfi_msg_session_start_done_packet *pkt)
{
struct msm_vidc_cb_cmd_done cmd_done;
@@ -678,13 +678,13 @@
cmd_done.device_id = device->device_id;
cmd_done.session_id =
((struct hal_session *) pkt->session_id)->session_id;
- cmd_done.status = vidc_map_hal_err_status((u32)pkt->error_type);
+ cmd_done.status = hfi_map_err_status((u32)pkt->error_type);
cmd_done.data = NULL;
cmd_done.size = 0;
device->callback(SESSION_START_DONE, &cmd_done);
}
-static void hal_process_session_stop_done(struct hal_device *device,
+static void hfi_process_session_stop_done(struct venus_hfi_device *device,
struct hfi_msg_session_stop_done_packet *pkt)
{
struct msm_vidc_cb_cmd_done cmd_done;
@@ -702,13 +702,13 @@
cmd_done.device_id = device->device_id;
cmd_done.session_id =
((struct hal_session *) pkt->session_id)->session_id;
- cmd_done.status = vidc_map_hal_err_status((u32)pkt->error_type);
+ cmd_done.status = hfi_map_err_status((u32)pkt->error_type);
cmd_done.data = NULL;
cmd_done.size = 0;
device->callback(SESSION_STOP_DONE, &cmd_done);
}
-static void hal_process_session_rel_res_done(struct hal_device *device,
+static void hfi_process_session_rel_res_done(struct venus_hfi_device *device,
struct hfi_msg_session_release_resources_done_packet *pkt)
{
struct msm_vidc_cb_cmd_done cmd_done;
@@ -726,13 +726,13 @@
cmd_done.device_id = device->device_id;
cmd_done.session_id =
((struct hal_session *) pkt->session_id)->session_id;
- cmd_done.status = vidc_map_hal_err_status((u32)pkt->error_type);
+ cmd_done.status = hfi_map_err_status((u32)pkt->error_type);
cmd_done.data = NULL;
cmd_done.size = 0;
device->callback(SESSION_RELEASE_RESOURCE_DONE, &cmd_done);
}
-static void hal_process_session_rel_buf_done(struct hal_device *device,
+static void hfi_process_session_rel_buf_done(struct venus_hfi_device *device,
struct hfi_msg_session_release_buffers_done_packet *pkt)
{
struct msm_vidc_cb_cmd_done cmd_done;
@@ -747,7 +747,7 @@
cmd_done.size = sizeof(struct msm_vidc_cb_cmd_done);
cmd_done.session_id =
((struct hal_session *) pkt->session_id)->session_id;
- cmd_done.status = vidc_map_hal_err_status((u32)pkt->error_type);
+ cmd_done.status = hfi_map_err_status((u32)pkt->error_type);
if (pkt->rg_buffer_info) {
cmd_done.data = (void *) &pkt->rg_buffer_info;
cmd_done.size = sizeof(struct hfi_buffer_info);
@@ -757,7 +757,7 @@
device->callback(SESSION_RELEASE_BUFFER_DONE, &cmd_done);
}
-static void hal_process_session_end_done(struct hal_device *device,
+static void hfi_process_session_end_done(struct venus_hfi_device *device,
struct hfi_msg_sys_session_end_done_packet *pkt)
{
struct msm_vidc_cb_cmd_done cmd_done;
@@ -782,13 +782,14 @@
cmd_done.device_id = device->device_id;
cmd_done.session_id =
((struct hal_session *) pkt->session_id)->session_id;
- cmd_done.status = vidc_map_hal_err_status((u32)pkt->error_type);
+ cmd_done.status = hfi_map_err_status((u32)pkt->error_type);
cmd_done.data = NULL;
cmd_done.size = 0;
device->callback(SESSION_END_DONE, &cmd_done);
}
-static void hal_process_session_get_seq_hdr_done(struct hal_device *device,
+static void hfi_process_session_get_seq_hdr_done(
+ struct venus_hfi_device *device,
struct hfi_msg_session_get_sequence_header_done_packet *pkt)
{
struct msm_vidc_cb_data_done data_done;
@@ -803,7 +804,7 @@
data_done.size = sizeof(struct msm_vidc_cb_data_done);
data_done.session_id =
((struct hal_session *) pkt->session_id)->session_id;
- data_done.status = vidc_map_hal_err_status((u32)pkt->error_type);
+ data_done.status = hfi_map_err_status((u32)pkt->error_type);
data_done.output_done.packet_buffer1 = pkt->sequence_header;
data_done.output_done.filled_len1 = pkt->header_len;
dprintk(VIDC_INFO, "seq_hdr: %p, Length: %d",
@@ -811,7 +812,7 @@
device->callback(SESSION_GET_SEQ_HDR_DONE, &data_done);
}
-static void hal_process_msg_packet(struct hal_device *device,
+static void hfi_process_msg_packet(struct venus_hfi_device *device,
struct vidc_hal_msg_pkt_hdr *msg_hdr)
{
if (!device || !msg_hdr || msg_hdr->size <
@@ -824,80 +825,80 @@
dprintk(VIDC_INFO, "Received: 0x%x in ", msg_hdr->packet);
if ((device->intr_status & VIDC_WRAPPER_INTR_CLEAR_A2HWD_BMSK)) {
dprintk(VIDC_ERR, "Received: Watchdog timeout %s", __func__);
- hal_process_sys_watchdog_timeout(device);
+ hfi_process_sys_watchdog_timeout(device);
return;
}
switch (msg_hdr->packet) {
case HFI_MSG_EVENT_NOTIFY:
- hal_process_event_notify(device,
+ hfi_process_event_notify(device,
(struct hfi_msg_event_notify_packet *) msg_hdr);
break;
case HFI_MSG_SYS_INIT_DONE:
- hal_process_sys_init_done(device,
+ hfi_process_sys_init_done(device,
(struct hfi_msg_sys_init_done_packet *)
msg_hdr);
break;
case HFI_MSG_SYS_SESSION_INIT_DONE:
- hal_process_session_init_done(device,
+ hfi_process_session_init_done(device,
(struct hfi_msg_sys_session_init_done_packet *)
msg_hdr);
break;
case HFI_MSG_SYS_SESSION_END_DONE:
- hal_process_session_end_done(device,
+ hfi_process_session_end_done(device,
(struct hfi_msg_sys_session_end_done_packet *)
msg_hdr);
break;
case HFI_MSG_SESSION_LOAD_RESOURCES_DONE:
- hal_process_session_load_res_done(device,
+ hfi_process_session_load_res_done(device,
(struct hfi_msg_session_load_resources_done_packet *)
msg_hdr);
break;
case HFI_MSG_SESSION_START_DONE:
- hal_process_session_start_done(device,
+ hfi_process_session_start_done(device,
(struct hfi_msg_session_start_done_packet *)
msg_hdr);
break;
case HFI_MSG_SESSION_STOP_DONE:
- hal_process_session_stop_done(device,
+ hfi_process_session_stop_done(device,
(struct hfi_msg_session_stop_done_packet *)
msg_hdr);
break;
case HFI_MSG_SESSION_EMPTY_BUFFER_DONE:
- hal_process_session_etb_done(device,
+ hfi_process_session_etb_done(device,
(struct hfi_msg_session_empty_buffer_done_packet *)
msg_hdr);
break;
case HFI_MSG_SESSION_FILL_BUFFER_DONE:
- hal_process_session_ftb_done(device, msg_hdr);
+ hfi_process_session_ftb_done(device, msg_hdr);
break;
case HFI_MSG_SESSION_FLUSH_DONE:
- hal_process_session_flush_done(device,
+ hfi_process_session_flush_done(device,
(struct hfi_msg_session_flush_done_packet *)
msg_hdr);
break;
case HFI_MSG_SESSION_PROPERTY_INFO:
- hal_process_session_prop_info(device,
+ hfi_process_session_prop_info(device,
(struct hfi_msg_session_property_info_packet *)
msg_hdr);
break;
case HFI_MSG_SESSION_RELEASE_RESOURCES_DONE:
- hal_process_session_rel_res_done(device,
+ hfi_process_session_rel_res_done(device,
(struct hfi_msg_session_release_resources_done_packet *)
msg_hdr);
break;
case HFI_MSG_SYS_RELEASE_RESOURCE:
- hal_process_sys_rel_resource_done(device,
+ hfi_process_sys_rel_resource_done(device,
(struct hfi_msg_sys_release_resource_done_packet *)
msg_hdr);
break;
case HFI_MSG_SESSION_GET_SEQUENCE_HEADER_DONE:
- hal_process_session_get_seq_hdr_done(device, (struct
+ hfi_process_session_get_seq_hdr_done(device, (struct
hfi_msg_session_get_sequence_header_done_packet
*) msg_hdr);
break;
case HFI_MSG_SESSION_RELEASE_BUFFERS_DONE:
- hal_process_session_rel_buf_done(device, (struct
+ hfi_process_session_rel_buf_done(device, (struct
hfi_msg_session_release_buffers_done_packet
*) msg_hdr);
break;
@@ -907,17 +908,17 @@
}
}
-void vidc_hal_response_handler(struct hal_device *device)
+void hfi_response_handler(struct venus_hfi_device *device)
{
u8 packet[VIDC_IFACEQ_MED_PKT_SIZE];
dprintk(VIDC_INFO, "#####vidc_hal_response_handler#####\n");
if (device) {
- while (!vidc_hal_iface_msgq_read(device, packet)) {
- hal_process_msg_packet(device,
+ while (!venus_hfi_iface_msgq_read(device, packet)) {
+ hfi_process_msg_packet(device,
(struct vidc_hal_msg_pkt_hdr *) packet);
}
- while (!vidc_hal_iface_dbgq_read(device, packet)) {
+ while (!venus_hfi_iface_dbgq_read(device, packet)) {
struct hfi_msg_sys_debug_packet *pkt =
(struct hfi_msg_sys_debug_packet *) packet;
dprintk(VIDC_FW, "FW-SAYS: %s", pkt->rg_msg_data);
diff --git a/drivers/media/video/msm_vidc/msm_v4l2_vidc.c b/drivers/media/video/msm_vidc/msm_v4l2_vidc.c
index 36ee792..e51896c 100644
--- a/drivers/media/video/msm_vidc/msm_v4l2_vidc.c
+++ b/drivers/media/video/msm_vidc/msm_v4l2_vidc.c
@@ -29,411 +29,9 @@
#include "msm_vidc_debug.h"
#include "vidc_hfi_api.h"
#include "msm_smem.h"
+#include "venus_hfi.h"
#define BASE_DEVICE_NUMBER 32
-#define SHARED_QSIZE 0x1000000
-
-static struct msm_bus_vectors enc_ocmem_init_vectors[] = {
- {
- .src = MSM_BUS_MASTER_VIDEO_P0_OCMEM,
- .dst = MSM_BUS_SLAVE_OCMEM,
- .ab = 0,
- .ib = 0,
- },
-};
-
-static struct msm_bus_vectors enc_ocmem_perf1_vectors[] = {
- {
- .src = MSM_BUS_MASTER_VIDEO_P0_OCMEM,
- .dst = MSM_BUS_SLAVE_OCMEM,
- .ab = 138200000,
- .ib = 1222000000,
- },
-};
-
-static struct msm_bus_vectors enc_ocmem_perf2_vectors[] = {
- {
- .src = MSM_BUS_MASTER_VIDEO_P0_OCMEM,
- .dst = MSM_BUS_SLAVE_OCMEM,
- .ab = 414700000,
- .ib = 1222000000,
- },
-};
-
-static struct msm_bus_vectors enc_ocmem_perf3_vectors[] = {
- {
- .src = MSM_BUS_MASTER_VIDEO_P0_OCMEM,
- .dst = MSM_BUS_SLAVE_OCMEM,
- .ab = 940000000,
- .ib = 2444000000U,
- },
-};
-
-static struct msm_bus_vectors enc_ocmem_perf4_vectors[] = {
- {
- .src = MSM_BUS_MASTER_VIDEO_P0_OCMEM,
- .dst = MSM_BUS_SLAVE_OCMEM,
- .ab = 1880000000,
- .ib = 2444000000U,
- },
-};
-
-static struct msm_bus_vectors enc_ocmem_perf5_vectors[] = {
- {
- .src = MSM_BUS_MASTER_VIDEO_P0_OCMEM,
- .dst = MSM_BUS_SLAVE_OCMEM,
- .ab = 3008000000U,
- .ib = 3910400000U,
- },
-};
-
-static struct msm_bus_vectors enc_ocmem_perf6_vectors[] = {
- {
- .src = MSM_BUS_MASTER_VIDEO_P0_OCMEM,
- .dst = MSM_BUS_SLAVE_OCMEM,
- .ab = 3760000000U,
- .ib = 4888000000ULL,
- },
-};
-
-static struct msm_bus_vectors dec_ocmem_init_vectors[] = {
- {
- .src = MSM_BUS_MASTER_VIDEO_P0_OCMEM,
- .dst = MSM_BUS_SLAVE_OCMEM,
- .ab = 0,
- .ib = 0,
- },
-};
-
-static struct msm_bus_vectors dec_ocmem_perf1_vectors[] = {
- {
- .src = MSM_BUS_MASTER_VIDEO_P0_OCMEM,
- .dst = MSM_BUS_SLAVE_OCMEM,
- .ab = 176900000,
- .ib = 1556640000,
- },
-};
-
-static struct msm_bus_vectors dec_ocmem_perf2_vectors[] = {
- {
- .src = MSM_BUS_MASTER_VIDEO_P0_OCMEM,
- .dst = MSM_BUS_SLAVE_OCMEM,
- .ab = 456200000,
- .ib = 1556640000,
- },
-};
-
-static struct msm_bus_vectors dec_ocmem_perf3_vectors[] = {
- {
- .src = MSM_BUS_MASTER_VIDEO_P0_OCMEM,
- .dst = MSM_BUS_SLAVE_OCMEM,
- .ab = 864800000,
- .ib = 1556640000,
- },
-};
-
-static struct msm_bus_vectors dec_ocmem_perf4_vectors[] = {
- {
- .src = MSM_BUS_MASTER_VIDEO_P0_OCMEM,
- .dst = MSM_BUS_SLAVE_OCMEM,
- .ab = 1729600000,
- .ib = 3113280000U,
- },
-};
-
-static struct msm_bus_vectors dec_ocmem_perf5_vectors[] = {
- {
- .src = MSM_BUS_MASTER_VIDEO_P0_OCMEM,
- .dst = MSM_BUS_SLAVE_OCMEM,
- .ab = 2767360000U,
- .ib = 4981248000ULL,
- },
-};
-
-static struct msm_bus_vectors dec_ocmem_perf6_vectors[] = {
- {
- .src = MSM_BUS_MASTER_VIDEO_P0_OCMEM,
- .dst = MSM_BUS_SLAVE_OCMEM,
- .ab = 3459200000U,
- .ib = 6226560000ULL,
- },
-};
-
-static struct msm_bus_paths enc_ocmem_perf_vectors[] = {
- {
- ARRAY_SIZE(enc_ocmem_init_vectors),
- enc_ocmem_init_vectors,
- },
- {
- ARRAY_SIZE(enc_ocmem_perf1_vectors),
- enc_ocmem_perf1_vectors,
- },
- {
- ARRAY_SIZE(enc_ocmem_perf2_vectors),
- enc_ocmem_perf2_vectors,
- },
- {
- ARRAY_SIZE(enc_ocmem_perf3_vectors),
- enc_ocmem_perf3_vectors,
- },
- {
- ARRAY_SIZE(enc_ocmem_perf4_vectors),
- enc_ocmem_perf4_vectors,
- },
- {
- ARRAY_SIZE(enc_ocmem_perf5_vectors),
- enc_ocmem_perf5_vectors,
- },
- {
- ARRAY_SIZE(enc_ocmem_perf6_vectors),
- enc_ocmem_perf6_vectors,
- },
-};
-
-static struct msm_bus_paths dec_ocmem_perf_vectors[] = {
- {
- ARRAY_SIZE(dec_ocmem_init_vectors),
- dec_ocmem_init_vectors,
- },
- {
- ARRAY_SIZE(dec_ocmem_perf1_vectors),
- dec_ocmem_perf1_vectors,
- },
- {
- ARRAY_SIZE(dec_ocmem_perf2_vectors),
- dec_ocmem_perf2_vectors,
- },
- {
- ARRAY_SIZE(dec_ocmem_perf3_vectors),
- dec_ocmem_perf3_vectors,
- },
- {
- ARRAY_SIZE(dec_ocmem_perf4_vectors),
- dec_ocmem_perf4_vectors,
- },
- {
- ARRAY_SIZE(dec_ocmem_perf5_vectors),
- dec_ocmem_perf5_vectors,
- },
- {
- ARRAY_SIZE(dec_ocmem_perf6_vectors),
- dec_ocmem_perf6_vectors,
- },
-};
-
-
-static struct msm_bus_scale_pdata enc_ocmem_bus_data = {
- .usecase = enc_ocmem_perf_vectors,
- .num_usecases = ARRAY_SIZE(enc_ocmem_perf_vectors),
- .name = "msm_vidc_enc_ocmem",
-};
-
-static struct msm_bus_scale_pdata dec_ocmem_bus_data = {
- .usecase = dec_ocmem_perf_vectors,
- .num_usecases = ARRAY_SIZE(dec_ocmem_perf_vectors),
- .name = "msm_vidc_dec_ocmem",
-};
-
-static struct msm_bus_vectors enc_ddr_init_vectors[] = {
- {
- .src = MSM_BUS_MASTER_VIDEO_P0,
- .dst = MSM_BUS_SLAVE_EBI_CH0,
- .ab = 0,
- .ib = 0,
- },
-};
-
-
-static struct msm_bus_vectors enc_ddr_perf1_vectors[] = {
- {
- .src = MSM_BUS_MASTER_VIDEO_P0,
- .dst = MSM_BUS_SLAVE_EBI_CH0,
- .ab = 60000000,
- .ib = 664950000,
- },
-};
-
-static struct msm_bus_vectors enc_ddr_perf2_vectors[] = {
- {
- .src = MSM_BUS_MASTER_VIDEO_P0,
- .dst = MSM_BUS_SLAVE_EBI_CH0,
- .ab = 181000000,
- .ib = 664950000,
- },
-};
-
-static struct msm_bus_vectors enc_ddr_perf3_vectors[] = {
- {
- .src = MSM_BUS_MASTER_VIDEO_P0,
- .dst = MSM_BUS_SLAVE_EBI_CH0,
- .ab = 403000000,
- .ib = 664950000,
- },
-};
-
-static struct msm_bus_vectors enc_ddr_perf4_vectors[] = {
- {
- .src = MSM_BUS_MASTER_VIDEO_P0,
- .dst = MSM_BUS_SLAVE_EBI_CH0,
- .ab = 806000000,
- .ib = 1329900000,
- },
-};
-
-static struct msm_bus_vectors enc_ddr_perf5_vectors[] = {
- {
- .src = MSM_BUS_MASTER_VIDEO_P0,
- .dst = MSM_BUS_SLAVE_EBI_CH0,
- .ab = 1289600000,
- .ib = 2127840000U,
- },
-};
-
-static struct msm_bus_vectors enc_ddr_perf6_vectors[] = {
- {
- .src = MSM_BUS_MASTER_VIDEO_P0,
- .dst = MSM_BUS_SLAVE_EBI_CH0,
- .ab = 161200000,
- .ib = 6400000000ULL,
- },
-};
-
-static struct msm_bus_vectors dec_ddr_init_vectors[] = {
- {
- .src = MSM_BUS_MASTER_VIDEO_P0,
- .dst = MSM_BUS_SLAVE_EBI_CH0,
- .ab = 0,
- .ib = 0,
- },
-};
-
-static struct msm_bus_vectors dec_ddr_perf1_vectors[] = {
- {
- .src = MSM_BUS_MASTER_VIDEO_P0,
- .dst = MSM_BUS_SLAVE_EBI_CH0,
- .ab = 110000000,
- .ib = 909000000,
- },
-};
-
-static struct msm_bus_vectors dec_ddr_perf2_vectors[] = {
- {
- .src = MSM_BUS_MASTER_VIDEO_P0,
- .dst = MSM_BUS_SLAVE_EBI_CH0,
- .ab = 268000000,
- .ib = 909000000,
- },
-};
-
-static struct msm_bus_vectors dec_ddr_perf3_vectors[] = {
- {
- .src = MSM_BUS_MASTER_VIDEO_P0,
- .dst = MSM_BUS_SLAVE_EBI_CH0,
- .ab = 505000000,
- .ib = 909000000,
- },
-};
-
-static struct msm_bus_vectors dec_ddr_perf4_vectors[] = {
- {
- .src = MSM_BUS_MASTER_VIDEO_P0,
- .dst = MSM_BUS_SLAVE_EBI_CH0,
- .ab = 1010000000,
- .ib = 1818000000,
- },
-};
-
-static struct msm_bus_vectors dec_ddr_perf5_vectors[] = {
- {
- .src = MSM_BUS_MASTER_VIDEO_P0,
- .dst = MSM_BUS_SLAVE_EBI_CH0,
- .ab = 1616000000,
- .ib = 2908800000U,
- },
-};
-
-static struct msm_bus_vectors dec_ddr_perf6_vectors[] = {
- {
- .src = MSM_BUS_MASTER_VIDEO_P0,
- .dst = MSM_BUS_SLAVE_EBI_CH0,
- .ab = 2020000000U,
- .ib = 6400000000ULL,
- },
-};
-
-static struct msm_bus_paths enc_ddr_perf_vectors[] = {
- {
- ARRAY_SIZE(enc_ddr_init_vectors),
- enc_ddr_init_vectors,
- },
- {
- ARRAY_SIZE(enc_ddr_perf1_vectors),
- enc_ddr_perf1_vectors,
- },
- {
- ARRAY_SIZE(enc_ddr_perf2_vectors),
- enc_ddr_perf2_vectors,
- },
- {
- ARRAY_SIZE(enc_ddr_perf3_vectors),
- enc_ddr_perf3_vectors,
- },
- {
- ARRAY_SIZE(enc_ddr_perf4_vectors),
- enc_ddr_perf4_vectors,
- },
- {
- ARRAY_SIZE(enc_ddr_perf5_vectors),
- enc_ddr_perf5_vectors,
- },
- {
- ARRAY_SIZE(enc_ddr_perf6_vectors),
- enc_ddr_perf6_vectors,
- },
-};
-
-static struct msm_bus_paths dec_ddr_perf_vectors[] = {
- {
- ARRAY_SIZE(dec_ddr_init_vectors),
- dec_ddr_init_vectors,
- },
- {
- ARRAY_SIZE(dec_ddr_perf1_vectors),
- dec_ddr_perf1_vectors,
- },
- {
- ARRAY_SIZE(dec_ddr_perf2_vectors),
- dec_ddr_perf2_vectors,
- },
- {
- ARRAY_SIZE(dec_ddr_perf3_vectors),
- dec_ddr_perf3_vectors,
- },
- {
- ARRAY_SIZE(dec_ddr_perf4_vectors),
- dec_ddr_perf4_vectors,
- },
- {
- ARRAY_SIZE(dec_ddr_perf5_vectors),
- dec_ddr_perf5_vectors,
- },
- {
- ARRAY_SIZE(dec_ddr_perf6_vectors),
- dec_ddr_perf6_vectors,
- },
-};
-
-static struct msm_bus_scale_pdata enc_ddr_bus_data = {
- .usecase = enc_ddr_perf_vectors,
- .num_usecases = ARRAY_SIZE(enc_ddr_perf_vectors),
- .name = "msm_vidc_enc_ddr",
-};
-
-static struct msm_bus_scale_pdata dec_ddr_bus_data = {
- .usecase = dec_ddr_perf_vectors,
- .num_usecases = ARRAY_SIZE(dec_ddr_perf_vectors),
- .name = "msm_vidc_dec_ddr",
-};
struct msm_vidc_drv *vidc_driver;
@@ -757,8 +355,16 @@
int i, rc = 0;
int smem_flags = 0;
int domain;
+ struct venus_hfi_device *device;
vidc_inst = get_vidc_inst(file, fh);
v4l2_inst = get_v4l2_inst(file, fh);
+ if (!v4l2_inst || !vidc_inst || !vidc_inst->core
+ || !vidc_inst->core->device) {
+ rc = -EINVAL;
+ goto exit;
+ }
+
+ device = vidc_inst->core->device;
if (!v4l2_inst->mem_client) {
dprintk(VIDC_ERR, "Failed to get memory client\n");
rc = -ENOMEM;
@@ -798,11 +404,9 @@
&& (!EXTRADATA_IDX(b->length)
|| (i != EXTRADATA_IDX(b->length)))) {
smem_flags |= SMEM_SECURE;
- domain =
- vidc_inst->core->resources.io_map[CP_MAP].domain;
+ domain = venus_hfi_get_domain(device, CP_MAP);
} else
- domain =
- vidc_inst->core->resources.io_map[NS_MAP].domain;
+ domain = venus_hfi_get_domain(device, NS_MAP);
if (b->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
smem_flags |= SMEM_INPUT;
@@ -1063,270 +667,24 @@
{
}
-static size_t read_u32_array(struct platform_device *pdev,
- char *name, u32 *arr, size_t size)
-{
- int len;
- size_t sz = 0;
- struct device_node *np = pdev->dev.of_node;
- if (!of_get_property(np, name, &len)) {
- dprintk(VIDC_ERR, "Failed to read %s from device tree\n",
- name);
- goto fail_read;
- }
- sz = len / sizeof(u32);
- if (sz <= 0) {
- dprintk(VIDC_ERR, "%s not specified in device tree\n",
- name);
- goto fail_read;
- }
- if (sz > size) {
- dprintk(VIDC_ERR, "Not enough memory to store %s values\n",
- name);
- goto fail_read;
- }
- if (of_property_read_u32_array(np, name, arr, sz)) {
- dprintk(VIDC_ERR,
- "error while reading %s from device tree\n",
- name);
- goto fail_read;
- }
- return sz;
-fail_read:
- sz = 0;
- return sz;
-}
-
-static int register_iommu_domains(struct platform_device *pdev,
- struct msm_vidc_core *core)
-{
- size_t len;
- struct msm_iova_partition partition[2];
- struct msm_iova_layout layout;
- int rc = 0;
- int i;
- struct msm_vidc_iommu_info *io_map = core->resources.io_map;
- strlcpy(io_map[CP_MAP].name, "vidc-cp-map",
- sizeof(io_map[CP_MAP].name));
- strlcpy(io_map[CP_MAP].ctx, "venus_cp",
- sizeof(io_map[CP_MAP].ctx));
- strlcpy(io_map[NS_MAP].name, "vidc-ns-map",
- sizeof(io_map[NS_MAP].name));
- strlcpy(io_map[NS_MAP].ctx, "venus_ns",
- sizeof(io_map[NS_MAP].ctx));
-
- for (i = 0; i < MAX_MAP; i++) {
- len = read_u32_array(pdev, io_map[i].name,
- io_map[i].addr_range,
- (sizeof(io_map[i].addr_range)/sizeof(u32)));
- if (!len) {
- dprintk(VIDC_ERR,
- "Error in reading cp address range\n");
- rc = -EINVAL;
- break;
- }
- partition[0].start = io_map[i].addr_range[0];
- if (i == NS_MAP) {
- partition[0].size =
- io_map[i].addr_range[1] - SHARED_QSIZE;
- partition[1].start =
- partition[0].start + io_map[i].addr_range[1]
- - SHARED_QSIZE;
- partition[1].size = SHARED_QSIZE;
- layout.npartitions = 2;
- layout.is_secure = 0;
- } else {
- partition[0].size = io_map[i].addr_range[1];
- layout.npartitions = 1;
- layout.is_secure = 1;
- }
- layout.partitions = &partition[0];
- layout.client_name = io_map[i].name;
- layout.domain_flags = 0;
- dprintk(VIDC_DBG, "Registering domain 1 with: %lx, %lx, %s\n",
- partition[0].start, partition[0].size,
- layout.client_name);
- dprintk(VIDC_DBG, "Registering domain 2 with: %lx, %lx, %s\n",
- partition[1].start, partition[1].size,
- layout.client_name);
- io_map[i].domain = msm_register_domain(&layout);
- if (io_map[i].domain < 0) {
- dprintk(VIDC_ERR, "Failed to register cp domain\n");
- rc = -EINVAL;
- break;
- }
- }
- /* There is no api provided as msm_unregister_domain, so
- * we are not able to unregister the previously
- * registered domains if any domain registration fails.*/
- BUG_ON(i < MAX_MAP);
- return rc;
-}
-
-static inline int msm_vidc_init_clocks(struct platform_device *pdev,
- struct msm_vidc_core *core)
-{
- struct core_clock *cl;
- int i;
- int rc = 0;
- struct core_clock *clock;
- if (!core) {
- dprintk(VIDC_ERR, "Invalid params: %p\n", core);
- return -EINVAL;
- }
- clock = core->resources.clock;
- strlcpy(clock[VCODEC_CLK].name, "core_clk",
- sizeof(clock[VCODEC_CLK].name));
- strlcpy(clock[VCODEC_AHB_CLK].name, "iface_clk",
- sizeof(clock[VCODEC_AHB_CLK].name));
- strlcpy(clock[VCODEC_AXI_CLK].name, "bus_clk",
- sizeof(clock[VCODEC_AXI_CLK].name));
- strlcpy(clock[VCODEC_OCMEM_CLK].name, "mem_clk",
- sizeof(clock[VCODEC_OCMEM_CLK].name));
-
- clock[VCODEC_CLK].count = read_u32_array(pdev,
- "load-freq-tbl", (u32 *)clock[VCODEC_CLK].load_freq_tbl,
- (sizeof(clock[VCODEC_CLK].load_freq_tbl)/sizeof(u32)));
- clock[VCODEC_CLK].count /= 2;
- dprintk(VIDC_DBG, "count = %d\n", clock[VCODEC_CLK].count);
- if (!clock[VCODEC_CLK].count) {
- dprintk(VIDC_ERR, "Failed to read clock frequency\n");
- goto fail_init_clocks;
- }
- for (i = 0; i < clock[VCODEC_CLK].count; i++) {
- dprintk(VIDC_DBG,
- "load = %d, freq = %d\n",
- clock[VCODEC_CLK].load_freq_tbl[i].load,
- clock[VCODEC_CLK].load_freq_tbl[i].freq
- );
- }
-
- for (i = 0; i < VCODEC_MAX_CLKS; i++) {
- cl = &core->resources.clock[i];
- if (!cl->clk) {
- cl->clk = devm_clk_get(&pdev->dev, cl->name);
- if (IS_ERR_OR_NULL(cl->clk)) {
- dprintk(VIDC_ERR,
- "Failed to get clock: %s\n", cl->name);
- rc = PTR_ERR(cl->clk);
- break;
- }
- }
- }
-
- if (i < VCODEC_MAX_CLKS) {
- for (--i; i >= 0; i--) {
- cl = &core->resources.clock[i];
- clk_put(cl->clk);
- }
- }
-fail_init_clocks:
- return rc;
-}
-
-static inline void msm_vidc_deinit_clocks(struct msm_vidc_core *core)
-{
- int i;
- if (!core) {
- dprintk(VIDC_ERR, "Invalid args\n");
- return;
- }
- for (i = 0; i < VCODEC_MAX_CLKS; i++)
- clk_put(core->resources.clock[i].clk);
-}
-
static int msm_vidc_initialize_core(struct platform_device *pdev,
struct msm_vidc_core *core)
{
- struct resource *res;
int i = 0;
int rc = 0;
- struct on_chip_mem *ocmem;
if (!core)
return -EINVAL;
- res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
- if (!res) {
- dprintk(VIDC_ERR, "Failed to get IORESOURCE_MEM\n");
- rc = -ENODEV;
- goto core_init_failed;
- }
- core->register_base = res->start;
- core->register_size = resource_size(res);
- res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
- if (!res) {
- dprintk(VIDC_ERR, "Failed to get IORESOURCE_IRQ\n");
- rc = -ENODEV;
- goto core_init_failed;
- }
- core->irq = res->start;
+
INIT_LIST_HEAD(&core->instances);
mutex_init(&core->sync_lock);
spin_lock_init(&core->lock);
- core->base_addr = 0x0;
+
core->state = VIDC_CORE_UNINIT;
for (i = SYS_MSG_INDEX(SYS_MSG_START);
i <= SYS_MSG_INDEX(SYS_MSG_END); i++) {
init_completion(&core->completions[i]);
}
- rc = msm_vidc_init_clocks(pdev, core);
- if (rc) {
- dprintk(VIDC_ERR, "Failed to init clocks\n");
- rc = -ENODEV;
- goto core_init_failed;
- }
- core->resources.bus_info.ddr_handle[MSM_VIDC_ENCODER] =
- msm_bus_scale_register_client(&enc_ddr_bus_data);
- if (!core->resources.bus_info.ddr_handle[MSM_VIDC_ENCODER]) {
- dprintk(VIDC_ERR, "Failed to register bus scale client\n");
- goto fail_register_enc_ddr_bus;
- }
- core->resources.bus_info.ddr_handle[MSM_VIDC_DECODER] =
- msm_bus_scale_register_client(&dec_ddr_bus_data);
- if (!core->resources.bus_info.ddr_handle[MSM_VIDC_DECODER]) {
- dprintk(VIDC_ERR, "Failed to register bus scale client\n");
- goto fail_register_dec_ddr_bus;
- }
- core->resources.bus_info.ocmem_handle[MSM_VIDC_ENCODER] =
- msm_bus_scale_register_client(&enc_ocmem_bus_data);
- if (!core->resources.bus_info.ocmem_handle[MSM_VIDC_ENCODER]) {
- dprintk(VIDC_ERR, "Failed to register bus scale client\n");
- goto fail_register_enc_ocmem;
- }
- core->resources.bus_info.ocmem_handle[MSM_VIDC_DECODER] =
- msm_bus_scale_register_client(&dec_ocmem_bus_data);
- if (!core->resources.bus_info.ocmem_handle[MSM_VIDC_DECODER]) {
- dprintk(VIDC_ERR, "Failed to register bus scale client\n");
- goto fail_register_dec_ocmem;
- }
- rc = register_iommu_domains(pdev, core);
- if (rc) {
- dprintk(VIDC_ERR, "Failed to register iommu domains: %d\n", rc);
- goto fail_register_domains;
- }
- ocmem = &core->resources.ocmem;
- ocmem->vidc_ocmem_nb.notifier_call = msm_vidc_ocmem_notify_handler;
- ocmem->handle =
- ocmem_notifier_register(OCMEM_VIDEO, &ocmem->vidc_ocmem_nb);
- if (!ocmem->handle) {
- dprintk(VIDC_WARN, "Failed to register OCMEM notifier.");
- dprintk(VIDC_INFO, " Performance will be impacted\n");
- }
- return rc;
-fail_register_domains:
- msm_bus_scale_unregister_client(
- core->resources.bus_info.ocmem_handle[MSM_VIDC_DECODER]);
-fail_register_dec_ocmem:
- msm_bus_scale_unregister_client(
- core->resources.bus_info.ocmem_handle[MSM_VIDC_ENCODER]);
-fail_register_enc_ocmem:
- msm_bus_scale_unregister_client(
- core->resources.bus_info.ddr_handle[MSM_VIDC_DECODER]);
-fail_register_dec_ddr_bus:
- msm_bus_scale_unregister_client(
- core->resources.bus_info.ddr_handle[MSM_VIDC_ENCODER]);
-fail_register_enc_ddr_bus:
- msm_vidc_deinit_clocks(core);
-core_init_failed:
+
return rc;
}
@@ -1377,11 +735,11 @@
goto err_enc_register;
}
video_set_drvdata(&core->vdev[MSM_VIDC_ENCODER].vdev, core);
- core->device = vidc_hal_add_device(core->id, core->base_addr,
- core->register_base, core->register_size, core->irq,
- &handle_cmd_response);
+
+ core->device =
+ venus_hfi_get_device(core->id, pdev, &handle_cmd_response);
if (!core->device) {
- dprintk(VIDC_ERR, "Failed to create interrupt handler");
+ dprintk(VIDC_ERR, "Failed to create HFI device\n");
goto err_cores_exceeded;
}
@@ -1417,20 +775,12 @@
{
int rc = 0;
struct msm_vidc_core *core = pdev->dev.platform_data;
- int i;
- for (i = 0; i < MSM_VIDC_MAX_DEVICES; ++i) {
- msm_bus_scale_unregister_client(
- core->resources.bus_info.ddr_handle[i]);
- msm_bus_scale_unregister_client(
- core->resources.bus_info.ocmem_handle[i]);
- }
- vidc_hal_delete_device(core->device);
+
+ venus_hfi_delete_device(core->device);
video_unregister_device(&core->vdev[MSM_VIDC_ENCODER].vdev);
video_unregister_device(&core->vdev[MSM_VIDC_DECODER].vdev);
v4l2_device_unregister(&core->v4l2_dev);
- if (core->resources.ocmem.handle)
- ocmem_notifier_unregister(core->resources.ocmem.handle,
- &core->resources.ocmem.vidc_ocmem_nb);
+
kfree(core);
return rc;
}
diff --git a/drivers/media/video/msm_vidc/msm_vdec.c b/drivers/media/video/msm_vidc/msm_vdec.c
index bc94f45..525bad8 100644
--- a/drivers/media/video/msm_vidc/msm_vdec.c
+++ b/drivers/media/video/msm_vidc/msm_vdec.c
@@ -415,8 +415,8 @@
buffer_info.extradata_addr = 0;
buffer_info.extradata_size = 0;
}
- rc = vidc_hal_session_set_buffers((void *)inst->session,
- &buffer_info);
+ rc = venus_hfi_session_set_buffers(
+ (void *)inst->session, &buffer_info);
if (rc)
dprintk(VIDC_ERR,
"vidc_hal_session_set_buffers failed");
@@ -484,7 +484,7 @@
else
buffer_info.extradata_addr = 0;
buffer_info.response_required = false;
- rc = vidc_hal_session_release_buffers(
+ rc = venus_hfi_session_release_buffers(
(void *)inst->session, &buffer_info);
if (rc)
dprintk(VIDC_ERR,
@@ -851,7 +851,7 @@
new_buf_count.buffer_type = HAL_BUFFER_OUTPUT;
new_buf_count.buffer_count_actual = *num_buffers;
- rc = vidc_hal_session_set_property(inst->session,
+ rc = venus_hfi_session_set_property(inst->session,
property_id, &new_buf_count);
}
@@ -1166,7 +1166,7 @@
property_id,
msm_vdec_ctrls[control_idx].id,
control.value);
- rc = vidc_hal_session_set_property((void *)
+ rc = venus_hfi_session_set_property((void *)
inst->session, property_id,
pdata);
}
diff --git a/drivers/media/video/msm_vidc/msm_venc.c b/drivers/media/video/msm_vidc/msm_venc.c
index 0ba216c..341e06f 100644
--- a/drivers/media/video/msm_vidc/msm_venc.c
+++ b/drivers/media/video/msm_vidc/msm_venc.c
@@ -648,7 +648,7 @@
property_id = HAL_PARAM_BUFFER_COUNT_ACTUAL;
new_buf_count.buffer_type = HAL_BUFFER_INPUT;
new_buf_count.buffer_count_actual = *num_buffers;
- rc = vidc_hal_session_set_property(inst->session,
+ rc = venus_hfi_session_set_property(inst->session,
property_id, &new_buf_count);
dprintk(VIDC_DBG, "size = %d, alignment = %d, count = %d\n",
inst->buff_req.buffer[0].buffer_size,
@@ -1405,7 +1405,7 @@
dprintk(VIDC_DBG, "Control: HAL property=%d,ctrl_value=%d\n",
property_id,
ctrl->val);
- rc = vidc_hal_session_set_property((void *)inst->session,
+ rc = venus_hfi_session_set_property((void *)inst->session,
property_id, pdata);
}
@@ -1597,7 +1597,7 @@
frame_rate.frame_rate = inst->prop.fps * (0x1<<16);
frame_rate.buffer_type = HAL_BUFFER_OUTPUT;
pdata = &frame_rate;
- rc = vidc_hal_session_set_property((void *)inst->session,
+ rc = venus_hfi_session_set_property((void *)inst->session,
property_id, pdata);
if (rc) {
dprintk(VIDC_WARN,
@@ -1638,7 +1638,7 @@
frame_sz.height = inst->prop.height;
dprintk(VIDC_DBG, "width = %d, height = %d\n",
frame_sz.width, frame_sz.height);
- rc = vidc_hal_session_set_property((void *)inst->session,
+ rc = venus_hfi_session_set_property((void *)inst->session,
HAL_PARAM_FRAME_SIZE, &frame_sz);
if (rc) {
dprintk(VIDC_ERR,
@@ -1646,7 +1646,7 @@
goto exit;
}
frame_sz.buffer_type = HAL_BUFFER_OUTPUT;
- rc = vidc_hal_session_set_property((void *)inst->session,
+ rc = venus_hfi_session_set_property((void *)inst->session,
HAL_PARAM_FRAME_SIZE, &frame_sz);
if (rc) {
dprintk(VIDC_ERR,
@@ -1769,8 +1769,8 @@
b->m.planes[i].m.userptr;
buffer_info.extradata_size = 0;
buffer_info.extradata_addr = 0;
- rc = vidc_hal_session_set_buffers((void *)inst->session,
- &buffer_info);
+ rc = venus_hfi_session_set_buffers(
+ (void *)inst->session, &buffer_info);
if (rc)
dprintk(VIDC_ERR,
"vidc_hal_session_set_buffers failed");
@@ -1814,7 +1814,7 @@
buffer_info.extradata_size = 0;
buffer_info.extradata_addr = 0;
buffer_info.response_required = false;
- rc = vidc_hal_session_release_buffers(
+ rc = venus_hfi_session_release_buffers(
(void *)inst->session, &buffer_info);
if (rc)
dprintk(VIDC_ERR,
diff --git a/drivers/media/video/msm_vidc/msm_vidc.c b/drivers/media/video/msm_vidc/msm_vidc.c
index 136d4e5..b9f1508 100644
--- a/drivers/media/video/msm_vidc/msm_vidc.c
+++ b/drivers/media/video/msm_vidc/msm_vidc.c
@@ -21,6 +21,7 @@
#include "msm_vidc_common.h"
#include "msm_smem.h"
#include <linux/delay.h>
+#include "venus_hfi.h"
#define MAX_EVENTS 30
@@ -85,15 +86,11 @@
struct msm_vidc_iommu_info maps[MAX_MAP])
{
struct msm_vidc_inst *inst = instance;
- int c = 0;
- if (!inst || !maps)
+ if (!inst || !maps || !inst->core)
return -EINVAL;
- for (c = 0; c < MAX_MAP; ++c)
- maps[c] = inst->core->resources.io_map[c];
-
- return 0;
+ return venus_hfi_iommu_get_map(inst->core->device, maps);
}
int msm_vidc_querycap(void *instance, struct v4l2_capability *cap)
diff --git a/drivers/media/video/msm_vidc/msm_vidc_common.c b/drivers/media/video/msm_vidc/msm_vidc_common.c
index 042b14c..eac715f 100644
--- a/drivers/media/video/msm_vidc/msm_vidc_common.c
+++ b/drivers/media/video/msm_vidc/msm_vidc_common.c
@@ -13,17 +13,14 @@
#include <linux/sched.h>
#include <linux/slab.h>
-#include <linux/iommu.h>
#include <asm/div64.h>
-#include <mach/iommu.h>
-#include <mach/iommu_domains.h>
#include <mach/subsystem_restart.h>
-#include <mach/scm.h>
#include "msm_vidc_common.h"
#include "vidc_hfi_api.h"
#include "msm_smem.h"
#include "msm_vidc_debug.h"
+#include "venus_hfi.h"
#define HW_RESPONSE_TIMEOUT (5 * 60 * 1000)
@@ -50,42 +47,8 @@
__mbs;\
})
-#define TZBSP_MEM_PROTECT_VIDEO_VAR 0x8
-struct tzbsp_memprot {
- u32 cp_start;
- u32 cp_size;
- u32 cp_nonpixel_start;
- u32 cp_nonpixel_size;
-};
-
-struct tzbsp_resp {
- int ret;
-};
-
#define TIME_DIFF_THRESHOLD 200
-static const u32 bus_table[] = {
- 36000,
- 110400,
- 244800,
- 489000,
- 783360,
- 979200,
-};
-
-static int get_bus_vector(int load)
-{
- int num_rows = sizeof(bus_table)/(sizeof(u32));
- int i;
- for (i = 0; i < num_rows; i++) {
- if (load <= bus_table[i])
- break;
- }
- i++;
- dprintk(VIDC_DBG, "Required bus = %d\n", i);
- return i;
-}
-
static int msm_comm_get_load(struct msm_vidc_core *core,
enum session_type type)
{
@@ -109,47 +72,22 @@
return num_mbs_per_sec;
}
-static unsigned long get_clock_rate(struct core_clock *clock,
- int num_mbs_per_sec)
-{
- int num_rows = clock->count;
- struct load_freq_table *table = clock->load_freq_tbl;
- unsigned long ret = table[num_rows-1].freq;
- int i;
- for (i = 0; i < num_rows; i++) {
- if (num_mbs_per_sec > table[i].load)
- break;
- ret = table[i].freq;
- }
- dprintk(VIDC_DBG, "Required clock rate = %lu\n", ret);
- return ret;
-}
-
static int msm_comm_scale_bus(struct msm_vidc_core *core,
enum session_type type, enum mem_type mtype)
{
int load;
int rc = 0;
- u32 handle = 0;
+
if (!core || type >= MSM_VIDC_MAX_DEVICES) {
dprintk(VIDC_ERR, "Invalid args: %p, %d\n", core, type);
return -EINVAL;
}
load = msm_comm_get_load(core, type);
- if (mtype & DDR_MEM)
- handle = core->resources.bus_info.ddr_handle[type];
- if (mtype & OCMEM_MEM)
- handle = core->resources.bus_info.ocmem_handle[type];
- if (handle) {
- rc = msm_bus_scale_client_update_request(
- handle, get_bus_vector(load));
- if (rc)
- dprintk(VIDC_ERR, "Failed to scale bus: %d\n", rc);
- } else {
- dprintk(VIDC_ERR, "Failed to scale bus, mtype: %d\n",
- mtype);
- rc = -EINVAL;
- }
+
+ rc = venus_hfi_scale_bus(core->device, load, type, mtype);
+ if (rc)
+ dprintk(VIDC_ERR, "Failed to scale bus: %d\n", rc);
+
return rc;
}
@@ -159,47 +97,18 @@
int i;
for (i = 0; i < MSM_VIDC_MAX_DEVICES; i++) {
if ((mtype & DDR_MEM) &&
- msm_bus_scale_client_update_request(
- core->resources.bus_info.ddr_handle[i],
- 0)) {
+ venus_hfi_scale_bus(core->device, 0, i, DDR_MEM)) {
dprintk(VIDC_WARN,
"Failed to unvote for DDR accesses\n");
}
if ((mtype & OCMEM_MEM) &&
- msm_bus_scale_client_update_request(
- core->resources.bus_info.ocmem_handle[i],
- 0)) {
+ venus_hfi_scale_bus(core->device, 0, i, OCMEM_MEM)) {
dprintk(VIDC_WARN,
"Failed to unvote for OCMEM accesses\n");
}
}
}
-static int protect_cp_mem(struct msm_vidc_core *core)
-{
- struct tzbsp_memprot memprot;
- unsigned int resp = 0;
- int rc = 0;
- struct msm_vidc_iommu_info *io_map = core->resources.io_map;
- if (!io_map) {
- dprintk(VIDC_ERR, "invalid params: %p\n", io_map);
- return -EINVAL;
- }
- memprot.cp_start = 0x0;
- memprot.cp_size = io_map[CP_MAP].addr_range[0] +
- io_map[CP_MAP].addr_range[1];
- memprot.cp_nonpixel_start = 0;
- memprot.cp_nonpixel_size = 0;
-
- rc = scm_call(SCM_SVC_CP, TZBSP_MEM_PROTECT_VIDEO_VAR, &memprot,
- sizeof(memprot), &resp, sizeof(resp));
- if (rc)
- dprintk(VIDC_ERR,
- "Failed to protect memory , rc is :%d, response : %d\n",
- rc, resp);
- return rc;
-}
-
struct msm_vidc_core *get_vidc_core(int core_id)
{
struct msm_vidc_core *core;
@@ -222,62 +131,6 @@
return NULL;
}
-static int msm_comm_iommu_attach(struct msm_vidc_core *core)
-{
- int rc;
- struct iommu_domain *domain;
- int i;
- struct msm_vidc_iommu_info *io_map;
- struct device *dev;
- for (i = 0; i < MAX_MAP; i++) {
- io_map = &core->resources.io_map[i];
- dev = msm_iommu_get_ctx(io_map->ctx);
- domain = msm_get_iommu_domain(io_map->domain);
- if (IS_ERR_OR_NULL(domain)) {
- dprintk(VIDC_ERR,
- "Failed to get domain: %s\n", io_map->name);
- rc = PTR_ERR(domain);
- break;
- }
- rc = iommu_attach_device(domain, dev);
- if (rc) {
- dprintk(VIDC_ERR,
- "IOMMU attach failed: %s\n", io_map->name);
- break;
- }
- }
- if (i < MAX_MAP) {
- i--;
- for (; i >= 0; i--) {
- io_map = &core->resources.io_map[i];
- dev = msm_iommu_get_ctx(io_map->ctx);
- domain = msm_get_iommu_domain(io_map->domain);
- if (dev && domain)
- iommu_detach_device(domain, dev);
- }
- }
- return rc;
-}
-
-static void msm_comm_iommu_detach(struct msm_vidc_core *core)
-{
- struct device *dev;
- struct iommu_domain *domain;
- struct msm_vidc_iommu_info *io_map;
- int i;
- if (!core) {
- dprintk(VIDC_ERR, "Invalid paramter: %p\n", core);
- return;
- }
- for (i = 0; i < MAX_MAP; i++) {
- io_map = &core->resources.io_map[i];
- dev = msm_iommu_get_ctx(io_map->ctx);
- domain = msm_get_iommu_domain(io_map->domain);
- if (dev && domain)
- iommu_detach_device(domain, dev);
- }
-}
-
const struct msm_vidc_format *msm_comm_get_pixel_fmt_index(
const struct msm_vidc_format fmt[], int size, int index, int fmt_type)
{
@@ -1029,60 +882,18 @@
}
num_mbs_per_sec = msm_comm_get_load(core, MSM_VIDC_ENCODER);
num_mbs_per_sec += msm_comm_get_load(core, MSM_VIDC_DECODER);
+
dprintk(VIDC_INFO, "num_mbs_per_sec = %d\n", num_mbs_per_sec);
- rc = clk_set_rate(core->resources.clock[VCODEC_CLK].clk,
- get_clock_rate(&core->resources.clock[VCODEC_CLK],
- num_mbs_per_sec));
+ rc = venus_hfi_scale_clocks(core->device, num_mbs_per_sec);
if (rc)
dprintk(VIDC_ERR, "Failed to set clock rate: %d\n", rc);
return rc;
}
-static inline int msm_comm_enable_clks(struct msm_vidc_core *core)
-{
- int i;
- struct core_clock *cl;
- int rc = 0;
- if (!core) {
- dprintk(VIDC_ERR, "Invalid params: %p\n", core);
- return -EINVAL;
- }
- for (i = 0; i < VCODEC_MAX_CLKS; i++) {
- cl = &core->resources.clock[i];
- rc = clk_prepare_enable(cl->clk);
- if (rc) {
- dprintk(VIDC_ERR, "Failed to enable clocks\n");
- goto fail_clk_enable;
- } else {
- dprintk(VIDC_DBG, "Clock: %s enabled\n", cl->name);
- }
- }
- return rc;
-fail_clk_enable:
- for (; i >= 0; i--) {
- cl = &core->resources.clock[i];
- clk_disable_unprepare(cl->clk);
- }
- return rc;
-}
-
-static inline void msm_comm_disable_clks(struct msm_vidc_core *core)
-{
- int i;
- struct core_clock *cl;
- if (!core) {
- dprintk(VIDC_ERR, "Invalid params: %p\n", core);
- return;
- }
- for (i = 0; i < VCODEC_MAX_CLKS; i++) {
- cl = &core->resources.clock[i];
- clk_disable_unprepare(cl->clk);
- }
-}
-
void msm_comm_scale_clocks_and_bus(struct msm_vidc_inst *inst)
{
struct msm_vidc_core *core = inst->core;
+
if (!inst) {
dprintk(VIDC_WARN, "Invalid params\n");
return;
@@ -1095,7 +906,7 @@
dprintk(VIDC_WARN,
"Failed to scale DDR bus. Performance might be impacted\n");
}
- if (core->resources.ocmem.buf) {
+ if (venus_hfi_is_ocmem_present(core->device)) {
if (msm_comm_scale_bus(core, inst->session_type,
OCMEM_MEM))
dprintk(VIDC_WARN,
@@ -1103,64 +914,6 @@
}
}
-static int msm_comm_load_fw(struct msm_vidc_core *core)
-{
- int rc = 0;
- if (!core) {
- dprintk(VIDC_ERR, "Invalid paramter: %p\n", core);
- return -EINVAL;
- }
- if (!core->resources.fw.cookie)
- core->resources.fw.cookie = subsystem_get("venus");
-
- if (IS_ERR_OR_NULL(core->resources.fw.cookie)) {
- dprintk(VIDC_ERR, "Failed to download firmware\n");
- rc = -ENOMEM;
- goto fail_load_fw;
- }
- /*Clocks can be enabled only after pil_get since
- * gdsc is turned-on in pil_get*/
- rc = msm_comm_enable_clks(core);
- if (rc) {
- dprintk(VIDC_ERR, "Failed to enable clocks: %d\n", rc);
- goto fail_enable_clks;
- }
-
- rc = protect_cp_mem(core);
- if (rc) {
- dprintk(VIDC_ERR, "Failed to protect memory\n");
- goto fail_iommu_attach;
- }
-
- rc = msm_comm_iommu_attach(core);
- if (rc) {
- dprintk(VIDC_ERR, "Failed to attach iommu");
- goto fail_iommu_attach;
- }
- return rc;
-fail_iommu_attach:
- msm_comm_disable_clks(core);
-fail_enable_clks:
- subsystem_put(core->resources.fw.cookie);
- core->resources.fw.cookie = NULL;
-fail_load_fw:
- return rc;
-}
-
-static void msm_comm_unload_fw(struct msm_vidc_core *core)
-{
- if (!core) {
- dprintk(VIDC_ERR, "Invalid paramter: %p\n", core);
- return;
- }
- if (core->resources.fw.cookie) {
- msm_comm_iommu_detach(core);
- msm_comm_disable_clks(core);
- subsystem_put(core->resources.fw.cookie);
- core->resources.fw.cookie = NULL;
- }
-}
-
static inline unsigned long get_ocmem_requirement(u32 height, u32 width)
{
int num_mbs = 0;
@@ -1170,48 +923,19 @@
return 512 * 1024;
}
-static int msm_comm_set_ocmem(struct msm_vidc_core *core,
- struct ocmem_buf *ocmem)
-{
- struct vidc_resource_hdr rhdr;
- int rc = 0;
- if (!core || !ocmem) {
- dprintk(VIDC_ERR, "Invalid params, core:%p, ocmem: %p\n",
- core, ocmem);
- return -EINVAL;
- }
- rhdr.resource_id = VIDC_RESOURCE_OCMEM;
- rhdr.resource_handle = (u32) &core->resources.ocmem;
- rhdr.size = ocmem->len;
- rc = vidc_hal_core_set_resource(core->device, &rhdr, ocmem);
- if (rc) {
- dprintk(VIDC_ERR, "Failed to set OCMEM on driver\n");
- goto ocmem_set_failed;
- }
- dprintk(VIDC_DBG, "OCMEM set, addr = %lx, size: %ld\n",
- ocmem->addr, ocmem->len);
-ocmem_set_failed:
- return rc;
-}
-
static int msm_comm_unset_ocmem(struct msm_vidc_core *core)
{
- struct vidc_resource_hdr rhdr;
int rc = 0;
- if (!core || !core->resources.ocmem.buf) {
- dprintk(VIDC_ERR, "Invalid params, core:%p\n", core);
- return -EINVAL;
- }
if (core->state == VIDC_CORE_INVALID) {
dprintk(VIDC_ERR,
"Core is in bad state. Cannot unset ocmem\n");
return -EIO;
}
- rhdr.resource_id = VIDC_RESOURCE_OCMEM;
- rhdr.resource_handle = (u32) &core->resources.ocmem;
+
init_completion(
&core->completions[SYS_MSG_INDEX(RELEASE_RESOURCE_DONE)]);
- rc = vidc_hal_core_release_resource(core->device, &rhdr);
+
+ rc = venus_hfi_unset_ocmem(core->device);
if (rc) {
dprintk(VIDC_ERR, "Failed to set OCMEM on driver\n");
goto release_ocmem_failed;
@@ -1222,67 +946,18 @@
if (!rc) {
dprintk(VIDC_ERR, "Wait interrupted or timeout: %d\n", rc);
rc = -EIO;
- goto release_ocmem_failed;
}
release_ocmem_failed:
return rc;
}
-static int msm_comm_alloc_ocmem(struct msm_vidc_core *core,
- unsigned long size)
-{
- int rc = 0;
- struct ocmem_buf *ocmem_buffer;
- mutex_lock(&core->sync_lock);
- if (!core || !size) {
- dprintk(VIDC_ERR,
- "Invalid param, core: %p, size: %lu\n", core, size);
- return -EINVAL;
- }
- ocmem_buffer = core->resources.ocmem.buf;
- if (!ocmem_buffer ||
- ocmem_buffer->len < size) {
- ocmem_buffer = ocmem_allocate_nb(OCMEM_VIDEO, size);
- if (IS_ERR_OR_NULL(ocmem_buffer)) {
- dprintk(VIDC_ERR,
- "ocmem_allocate_nb failed: %d\n",
- (u32) ocmem_buffer);
- rc = -ENOMEM;
- }
- core->resources.ocmem.buf = ocmem_buffer;
- rc = msm_comm_set_ocmem(core, ocmem_buffer);
- if (rc) {
- dprintk(VIDC_ERR, "Failed to set ocmem: %d\n", rc);
- goto ocmem_set_failed;
- }
- } else
- dprintk(VIDC_DBG,
- "OCMEM is enough. reqd: %lu, available: %lu\n",
- size, ocmem_buffer->len);
-
-ocmem_set_failed:
- mutex_unlock(&core->sync_lock);
- return rc;
-}
-
-static int msm_comm_free_ocmem(struct msm_vidc_core *core)
-{
- int rc = 0;
- if (core->resources.ocmem.buf) {
- rc = ocmem_free(OCMEM_VIDEO, core->resources.ocmem.buf);
- if (rc)
- dprintk(VIDC_ERR, "Failed to free ocmem\n");
- }
- core->resources.ocmem.buf = NULL;
- return rc;
-}
-
int msm_vidc_ocmem_notify_handler(struct notifier_block *this,
unsigned long event, void *data)
{
struct ocmem_buf *buff = data;
struct msm_vidc_core *core;
- struct msm_vidc_resources *resources;
+ struct venus_hfi_device *device;
+ struct venus_resources *resources;
struct on_chip_mem *ocmem;
int rc = NOTIFY_DONE;
if (event == OCMEM_ALLOC_GROW) {
@@ -1293,10 +968,12 @@
goto bad_notfier;
}
resources = container_of(ocmem,
- struct msm_vidc_resources, ocmem);
- core = container_of(resources,
- struct msm_vidc_core, resources);
- if (msm_comm_set_ocmem(core, buff)) {
+ struct venus_resources, ocmem);
+ device = container_of(resources,
+ struct venus_hfi_device, resources);
+ core = container_of((void *)device,
+ struct msm_vidc_core, device);
+ if (venus_hfi_set_ocmem(core->device, buff)) {
dprintk(VIDC_ERR, "Failed to set ocmem: %d\n", rc);
goto ocmem_set_failed;
}
@@ -1345,6 +1022,12 @@
int rc = 0;
struct msm_vidc_core *core = inst->core;
unsigned long flags;
+ struct venus_hfi_device *device;
+
+ if (!core || !core->device)
+ return -EINVAL;
+ device = core->device;
+
mutex_lock(&core->sync_lock);
if (core->state >= VIDC_CORE_INIT) {
dprintk(VIDC_INFO, "Video core: %d is already in state: %d\n",
@@ -1358,7 +1041,7 @@
goto fail_scale_bus;
}
- rc = msm_comm_load_fw(core);
+ rc = venus_hfi_load_fw(core->device);
if (rc) {
dprintk(VIDC_ERR, "Failed to load video firmware\n");
goto fail_load_fw;
@@ -1370,8 +1053,7 @@
}
init_completion(&core->completions[SYS_MSG_INDEX(SYS_INIT_DONE)]);
- rc = vidc_hal_core_init(core->device,
- core->resources.io_map[NS_MAP].domain);
+ rc = venus_hfi_core_init(core->device);
if (rc) {
dprintk(VIDC_ERR, "Failed to init core, id = %d\n", core->id);
goto fail_core_init;
@@ -1384,7 +1066,7 @@
mutex_unlock(&core->sync_lock);
return rc;
fail_core_init:
- msm_comm_unload_fw(core);
+ venus_hfi_unload_fw(core->device);
fail_load_fw:
msm_comm_unvote_buses(core, DDR_MEM);
fail_scale_bus:
@@ -1406,9 +1088,9 @@
msm_comm_scale_clocks_and_bus(inst);
if (list_empty(&core->instances)) {
msm_comm_unset_ocmem(core);
- msm_comm_free_ocmem(core);
+ venus_hfi_free_ocmem(core->device);
dprintk(VIDC_DBG, "Calling vidc_hal_core_release\n");
- rc = vidc_hal_core_release(core->device);
+ rc = venus_hfi_core_release(core->device);
if (rc) {
dprintk(VIDC_ERR, "Failed to release core, id = %d\n",
core->id);
@@ -1417,7 +1099,7 @@
spin_lock_irqsave(&core->lock, flags);
core->state = VIDC_CORE_UNINIT;
spin_unlock_irqrestore(&core->lock, flags);
- msm_comm_unload_fw(core);
+ venus_hfi_unload_fw(core->device);
msm_comm_unvote_buses(core, DDR_MEM|OCMEM_MEM);
}
core_already_uninited:
@@ -1515,7 +1197,7 @@
}
init_completion(
&inst->completions[SESSION_MSG_INDEX(SESSION_INIT_DONE)]);
- inst->session = vidc_hal_session_init(inst->core->device, (u32) inst,
+ inst->session = venus_hfi_session_init(inst->core->device, (u32) inst,
get_hal_domain(inst->session_type),
get_hal_codec_type(fourcc));
if (!inst->session) {
@@ -1544,7 +1226,9 @@
ocmem_sz = get_ocmem_requirement(inst->prop.height, inst->prop.width);
rc = msm_comm_scale_bus(inst->core, inst->session_type, OCMEM_MEM);
if (!rc) {
- rc = msm_comm_alloc_ocmem(inst->core, ocmem_sz);
+ mutex_lock(&inst->core->sync_lock);
+ rc = venus_hfi_alloc_ocmem(inst->core->device, ocmem_sz);
+ mutex_unlock(&inst->core->sync_lock);
if (rc) {
dprintk(VIDC_WARN,
"Failed to allocate OCMEM. Performance will be impacted\n");
@@ -1554,7 +1238,7 @@
dprintk(VIDC_WARN,
"Failed to vote for OCMEM BW. Performance will be impacted\n");
}
- rc = vidc_hal_session_load_res((void *) inst->session);
+ rc = venus_hfi_session_load_res((void *) inst->session);
if (rc) {
dprintk(VIDC_ERR,
"Failed to send load resources\n");
@@ -1576,7 +1260,7 @@
}
init_completion(
&inst->completions[SESSION_MSG_INDEX(SESSION_START_DONE)]);
- rc = vidc_hal_session_start((void *) inst->session);
+ rc = venus_hfi_session_start((void *) inst->session);
if (rc) {
dprintk(VIDC_ERR,
"Failed to send start\n");
@@ -1599,7 +1283,7 @@
dprintk(VIDC_DBG, "Send Stop to hal\n");
init_completion(
&inst->completions[SESSION_MSG_INDEX(SESSION_STOP_DONE)]);
- rc = vidc_hal_session_stop((void *) inst->session);
+ rc = venus_hfi_session_stop((void *) inst->session);
if (rc) {
dprintk(VIDC_ERR, "Failed to send stop\n");
goto exit;
@@ -1622,7 +1306,7 @@
"Send release res to hal\n");
init_completion(
&inst->completions[SESSION_MSG_INDEX(SESSION_RELEASE_RESOURCE_DONE)]);
- rc = vidc_hal_session_release_res((void *) inst->session);
+ rc = venus_hfi_session_release_res((void *) inst->session);
if (rc) {
dprintk(VIDC_ERR,
"Failed to send release resources\n");
@@ -1646,7 +1330,7 @@
"Send session close to hal\n");
init_completion(
&inst->completions[SESSION_MSG_INDEX(SESSION_END_DONE)]);
- rc = vidc_hal_session_end((void *) inst->session);
+ rc = venus_hfi_session_end((void *) inst->session);
if (rc) {
dprintk(VIDC_ERR,
"Failed to send close\n");
@@ -1850,7 +1534,7 @@
dprintk(VIDC_DBG,
"Sending etb to hal: Alloc: %d :filled: %d\n",
frame_data.alloc_len, frame_data.filled_len);
- rc = vidc_hal_session_etb((void *) inst->session,
+ rc = venus_hfi_session_etb((void *) inst->session,
&frame_data);
if (!rc)
msm_vidc_debugfs_update(inst,
@@ -1880,7 +1564,7 @@
seq_hdr.seq_hdr = (u8 *) vb->v4l2_planes[0].
m.userptr;
seq_hdr.seq_hdr_len = vb->v4l2_planes[0].length;
- rc = vidc_hal_session_get_seq_hdr((void *)
+ rc = venus_hfi_session_get_seq_hdr((void *)
inst->session, &seq_hdr);
if (!rc) {
inst->vb2_seq_hdr = vb;
@@ -1888,7 +1572,7 @@
inst->vb2_seq_hdr);
}
} else {
- rc = vidc_hal_session_ftb((void *)
+ rc = venus_hfi_session_ftb((void *)
inst->session, &frame_data);
if (!rc)
msm_vidc_debugfs_update(inst,
@@ -1920,7 +1604,7 @@
}
init_completion(
&inst->completions[SESSION_MSG_INDEX(SESSION_PROPERTY_INFO)]);
- rc = vidc_hal_session_get_buf_req((void *) inst->session);
+ rc = venus_hfi_session_get_buf_req((void *) inst->session);
if (rc) {
dprintk(VIDC_ERR, "Failed to get property\n");
goto exit;
@@ -1975,7 +1659,7 @@
init_completion(
&inst->completions[SESSION_MSG_INDEX
(SESSION_RELEASE_BUFFER_DONE)]);
- rc = vidc_hal_session_release_buffers(
+ rc = venus_hfi_session_release_buffers(
(void *) inst->session,
&buffer_info);
if (rc)
@@ -2035,7 +1719,7 @@
init_completion(
&inst->completions[SESSION_MSG_INDEX
(SESSION_RELEASE_BUFFER_DONE)]);
- rc = vidc_hal_session_release_buffers(
+ rc = venus_hfi_session_release_buffers(
(void *) inst->session,
&buffer_info);
if (rc)
@@ -2073,7 +1757,7 @@
rc = -EAGAIN;
goto exit;
}
- rc = vidc_hal_session_set_property((void *)inst->session,
+ rc = venus_hfi_session_set_property((void *)inst->session,
ptype, pdata);
if (rc)
dprintk(VIDC_ERR, "Failed to set hal property for framesize\n");
@@ -2091,9 +1775,16 @@
unsigned long flags;
int domain;
unsigned long smem_flags = 0;
- struct hal_buffer_requirements *scratch_buf =
- &inst->buff_req.buffer[HAL_BUFFER_INTERNAL_SCRATCH];
+ struct hal_buffer_requirements *scratch_buf;
int i;
+ struct venus_hfi_device *device;
+
+ if (!inst || !inst->core || !inst->core->device)
+ return -EINVAL;
+
+ device = inst->core->device;
+ scratch_buf =
+ &inst->buff_req.buffer[HAL_BUFFER_INTERNAL_SCRATCH];
dprintk(VIDC_DBG,
"scratch: num = %d, size = %d\n",
scratch_buf->buffer_count_actual,
@@ -2101,10 +1792,10 @@
if (msm_comm_release_scratch_buffers(inst))
dprintk(VIDC_WARN, "Failed to release scratch buffers\n");
if (inst->mode == VIDC_SECURE) {
- domain = inst->core->resources.io_map[CP_MAP].domain;
+ domain = venus_hfi_get_domain(device, CP_MAP);
smem_flags |= SMEM_SECURE;
} else
- domain = inst->core->resources.io_map[NS_MAP].domain;
+ domain = venus_hfi_get_domain(device, NS_MAP);
if (scratch_buf->buffer_size) {
for (i = 0; i < scratch_buf->buffer_count_actual;
@@ -2131,7 +1822,7 @@
buffer_info.align_device_addr = handle->device_addr;
dprintk(VIDC_DBG, "Scratch buffer address: %x",
buffer_info.align_device_addr);
- rc = vidc_hal_session_set_buffers(
+ rc = venus_hfi_session_set_buffers(
(void *) inst->session, &buffer_info);
if (rc) {
dprintk(VIDC_ERR,
@@ -2161,9 +1852,17 @@
unsigned long flags;
unsigned long smem_flags = 0;
int domain;
- struct hal_buffer_requirements *persist_buf =
- &inst->buff_req.buffer[HAL_BUFFER_INTERNAL_PERSIST];
+ struct hal_buffer_requirements *persist_buf;
int i;
+ struct venus_hfi_device *device;
+
+ if (!inst || !inst->core || !inst->core->device)
+ return -EINVAL;
+
+ device = inst->core->device;
+
+ persist_buf =
+ &inst->buff_req.buffer[HAL_BUFFER_INTERNAL_PERSIST];
dprintk(VIDC_DBG,
"persist: num = %d, size = %d\n",
persist_buf->buffer_count_actual,
@@ -2175,10 +1874,10 @@
}
if (inst->mode == VIDC_SECURE) {
- domain = inst->core->resources.io_map[CP_MAP].domain;
+ domain = venus_hfi_get_domain(device, CP_MAP);
flags |= SMEM_SECURE;
} else
- domain = inst->core->resources.io_map[NS_MAP].domain;
+ domain = venus_hfi_get_domain(device, NS_MAP);
if (persist_buf->buffer_size) {
for (i = 0; i < persist_buf->buffer_count_actual; i++) {
@@ -2204,7 +1903,7 @@
buffer_info.align_device_addr = handle->device_addr;
dprintk(VIDC_DBG, "Persist buffer address: %x",
buffer_info.align_device_addr);
- rc = vidc_hal_session_set_buffers(
+ rc = venus_hfi_session_set_buffers(
(void *) inst->session, &buffer_info);
if (rc) {
dprintk(VIDC_ERR,
@@ -2315,7 +2014,7 @@
dprintk(VIDC_WARN,
"FLUSH BUG: Pending q not empty! It should be empty\n");
}
- rc = vidc_hal_session_flush(inst->session,
+ rc = venus_hfi_session_flush(inst->session,
HAL_FLUSH_OUTPUT);
} else {
if (!list_empty(&inst->pendingq)) {
@@ -2336,7 +2035,7 @@
kfree(temp);
}
}
- rc = vidc_hal_session_flush(inst->session,
+ rc = venus_hfi_session_flush(inst->session,
HAL_FLUSH_ALL);
}
mutex_unlock(&inst->sync_lock);
diff --git a/drivers/media/video/msm_vidc/msm_vidc_debug.c b/drivers/media/video/msm_vidc/msm_vidc_debug.c
index 133bfb5..bdf146e 100644
--- a/drivers/media/video/msm_vidc/msm_vidc_debug.c
+++ b/drivers/media/video/msm_vidc/msm_vidc_debug.c
@@ -12,10 +12,11 @@
*/
#include "msm_vidc_debug.h"
+#include "venus_hfi.h"
#define MAX_DBG_BUF_SIZE 4096
-int msm_vidc_debug;
-int msm_fw_debug;
+int msm_vidc_debug = 0x3;
+int msm_fw_debug = 0x18;
struct debug_buffer {
char ptr[MAX_DBG_BUF_SIZE];
@@ -52,20 +53,22 @@
size_t count, loff_t *ppos)
{
struct msm_vidc_core *core = file->private_data;
+ struct venus_hfi_device *device;
int i = 0;
- if (!core) {
+ if (!core || !core->device) {
dprintk(VIDC_ERR, "Invalid params, core: %p\n", core);
return 0;
}
+ device = core->device;
INIT_DBG_BUF(dbg_buf);
write_str(&dbg_buf, "===============================\n");
write_str(&dbg_buf, "CORE %d: 0x%p\n", core->id, core);
write_str(&dbg_buf, "===============================\n");
write_str(&dbg_buf, "state: %d\n", core->state);
- write_str(&dbg_buf, "base addr: 0x%x\n", core->base_addr);
- write_str(&dbg_buf, "register_base: 0x%x\n", core->register_base);
- write_str(&dbg_buf, "register_size: %u\n", core->register_size);
- write_str(&dbg_buf, "irq: %u\n", core->irq);
+ write_str(&dbg_buf, "base addr: 0x%x\n", device->base_addr);
+ write_str(&dbg_buf, "register_base: 0x%x\n", device->register_base);
+ write_str(&dbg_buf, "register_size: %u\n", device->register_size);
+ write_str(&dbg_buf, "irq: %u\n", device->irq);
for (i = SYS_MSG_START; i < SYS_MSG_END; i++) {
write_str(&dbg_buf, "completions[%d]: %s\n", i,
completion_done(&core->completions[SYS_MSG_INDEX(i)]) ?
@@ -89,8 +92,7 @@
dprintk(VIDC_ERR, "Invalid params, core: %p\n", core);
goto failed_create_dir;
}
- msm_vidc_debug = 0;
- msm_fw_debug = 0;
+
snprintf(debugfs_name, MAX_DEBUGFS_NAME, "core%d", core->id);
dir = debugfs_create_dir(debugfs_name, parent);
if (!dir) {
@@ -106,13 +108,11 @@
dprintk(VIDC_ERR, "debugfs_create_file: fail\n");
goto failed_create_dir;
}
- msm_vidc_debug = 0x3;
if (!debugfs_create_u32("fw_level", S_IRUGO | S_IWUSR,
parent, &msm_fw_debug)) {
dprintk(VIDC_ERR, "debugfs_create_file: fail\n");
goto failed_create_dir;
}
- msm_fw_debug = 0x18;
failed_create_dir:
return dir;
}
diff --git a/drivers/media/video/msm_vidc/msm_vidc_internal.h b/drivers/media/video/msm_vidc/msm_vidc_internal.h
index d8a3304..14cef1e 100644
--- a/drivers/media/video/msm_vidc/msm_vidc_internal.h
+++ b/drivers/media/video/msm_vidc/msm_vidc_internal.h
@@ -18,7 +18,6 @@
#include <linux/spinlock.h>
#include <linux/types.h>
#include <linux/completion.h>
-#include <linux/clk.h>
#include <linux/wait.h>
#include <mach/msm_bus.h>
#include <mach/msm_bus_board.h>
@@ -117,54 +116,6 @@
struct video_device vdev;
};
-struct msm_vidc_fw {
- void *cookie;
-};
-
-enum vidc_clocks {
- VCODEC_CLK,
- VCODEC_AHB_CLK,
- VCODEC_AXI_CLK,
- VCODEC_OCMEM_CLK,
- VCODEC_MAX_CLKS
-};
-
-struct load_freq_table {
- u32 load;
- u32 freq;
-};
-
-enum mem_type {
- DDR_MEM = 0x1,
- OCMEM_MEM = 0x2,
-};
-
-struct core_clock {
- char name[MAX_NAME_LENGTH];
- struct clk *clk;
- u32 count;
- struct load_freq_table load_freq_tbl[8];
-};
-
-struct vidc_bus_info {
- u32 ddr_handle[MSM_VIDC_MAX_DEVICES];
- u32 ocmem_handle[MSM_VIDC_MAX_DEVICES];
-};
-
-struct on_chip_mem {
- struct ocmem_buf *buf;
- struct notifier_block vidc_ocmem_nb;
- void *handle;
-};
-
-struct msm_vidc_resources {
- struct msm_vidc_fw fw;
- struct msm_vidc_iommu_info io_map[MAX_MAP];
- struct core_clock clock[VCODEC_MAX_CLKS];
- struct vidc_bus_info bus_info;
- struct on_chip_mem ocmem;
-};
-
struct session_prop {
u32 width;
u32 height;
@@ -224,12 +175,7 @@
spinlock_t lock;
struct list_head instances;
struct dentry *debugfs_root;
- u32 base_addr;
- u32 register_base;
- u32 register_size;
- u32 irq;
enum vidc_core_state state;
- struct msm_vidc_resources resources;
struct completion completions[SYS_MSG_END - SYS_MSG_START + 1];
};
diff --git a/drivers/media/video/msm_vidc/venus_hfi.c b/drivers/media/video/msm_vidc/venus_hfi.c
index 4a5f340..8f0902f 100644
--- a/drivers/media/video/msm_vidc/venus_hfi.c
+++ b/drivers/media/video/msm_vidc/venus_hfi.c
@@ -16,8 +16,13 @@
#include <linux/interrupt.h>
#include <linux/io.h>
#include <linux/delay.h>
+#include <linux/of.h>
+#include <linux/iommu.h>
+#include <mach/iommu.h>
+#include <mach/iommu_domains.h>
#include <mach/ocmem.h>
-
+#include <mach/scm.h>
+#include <mach/subsystem_restart.h>
#include <asm/memory.h>
#include "hfi_packetization.h"
#include "venus_hfi.h"
@@ -27,12 +32,428 @@
#define FIRMWARE_SIZE 0X00A00000
#define REG_ADDR_OFFSET_BITMASK 0x000FFFFF
-/*Workaround for virtio */
-#define HFI_VIRTIO_FW_BIAS 0x0
+/*Workaround for simulator */
+#define HFI_SIM_FW_BIAS 0x0
+
+#define SHARED_QSIZE 0x1000000
struct hal_device_data hal_ctxt;
-static void hal_virtio_modify_cmd_packet(u8 *packet)
+static struct msm_bus_vectors enc_ocmem_init_vectors[] = {
+ {
+ .src = MSM_BUS_MASTER_VIDEO_P0_OCMEM,
+ .dst = MSM_BUS_SLAVE_OCMEM,
+ .ab = 0,
+ .ib = 0,
+ },
+};
+
+static struct msm_bus_vectors enc_ocmem_perf1_vectors[] = {
+ {
+ .src = MSM_BUS_MASTER_VIDEO_P0_OCMEM,
+ .dst = MSM_BUS_SLAVE_OCMEM,
+ .ab = 138200000,
+ .ib = 1222000000,
+ },
+};
+
+static struct msm_bus_vectors enc_ocmem_perf2_vectors[] = {
+ {
+ .src = MSM_BUS_MASTER_VIDEO_P0_OCMEM,
+ .dst = MSM_BUS_SLAVE_OCMEM,
+ .ab = 414700000,
+ .ib = 1222000000,
+ },
+};
+
+static struct msm_bus_vectors enc_ocmem_perf3_vectors[] = {
+ {
+ .src = MSM_BUS_MASTER_VIDEO_P0_OCMEM,
+ .dst = MSM_BUS_SLAVE_OCMEM,
+ .ab = 940000000,
+ .ib = 2444000000U,
+ },
+};
+
+static struct msm_bus_vectors enc_ocmem_perf4_vectors[] = {
+ {
+ .src = MSM_BUS_MASTER_VIDEO_P0_OCMEM,
+ .dst = MSM_BUS_SLAVE_OCMEM,
+ .ab = 1880000000,
+ .ib = 2444000000U,
+ },
+};
+
+static struct msm_bus_vectors enc_ocmem_perf5_vectors[] = {
+ {
+ .src = MSM_BUS_MASTER_VIDEO_P0_OCMEM,
+ .dst = MSM_BUS_SLAVE_OCMEM,
+ .ab = 3008000000U,
+ .ib = 3910400000U,
+ },
+};
+
+static struct msm_bus_vectors enc_ocmem_perf6_vectors[] = {
+ {
+ .src = MSM_BUS_MASTER_VIDEO_P0_OCMEM,
+ .dst = MSM_BUS_SLAVE_OCMEM,
+ .ab = 3760000000U,
+ .ib = 4888000000ULL,
+ },
+};
+
+static struct msm_bus_vectors dec_ocmem_init_vectors[] = {
+ {
+ .src = MSM_BUS_MASTER_VIDEO_P0_OCMEM,
+ .dst = MSM_BUS_SLAVE_OCMEM,
+ .ab = 0,
+ .ib = 0,
+ },
+};
+
+static struct msm_bus_vectors dec_ocmem_perf1_vectors[] = {
+ {
+ .src = MSM_BUS_MASTER_VIDEO_P0_OCMEM,
+ .dst = MSM_BUS_SLAVE_OCMEM,
+ .ab = 176900000,
+ .ib = 1556640000,
+ },
+};
+
+static struct msm_bus_vectors dec_ocmem_perf2_vectors[] = {
+ {
+ .src = MSM_BUS_MASTER_VIDEO_P0_OCMEM,
+ .dst = MSM_BUS_SLAVE_OCMEM,
+ .ab = 456200000,
+ .ib = 1556640000,
+ },
+};
+
+static struct msm_bus_vectors dec_ocmem_perf3_vectors[] = {
+ {
+ .src = MSM_BUS_MASTER_VIDEO_P0_OCMEM,
+ .dst = MSM_BUS_SLAVE_OCMEM,
+ .ab = 864800000,
+ .ib = 1556640000,
+ },
+};
+
+static struct msm_bus_vectors dec_ocmem_perf4_vectors[] = {
+ {
+ .src = MSM_BUS_MASTER_VIDEO_P0_OCMEM,
+ .dst = MSM_BUS_SLAVE_OCMEM,
+ .ab = 1729600000,
+ .ib = 3113280000U,
+ },
+};
+
+static struct msm_bus_vectors dec_ocmem_perf5_vectors[] = {
+ {
+ .src = MSM_BUS_MASTER_VIDEO_P0_OCMEM,
+ .dst = MSM_BUS_SLAVE_OCMEM,
+ .ab = 2767360000U,
+ .ib = 4981248000ULL,
+ },
+};
+
+static struct msm_bus_vectors dec_ocmem_perf6_vectors[] = {
+ {
+ .src = MSM_BUS_MASTER_VIDEO_P0_OCMEM,
+ .dst = MSM_BUS_SLAVE_OCMEM,
+ .ab = 3459200000U,
+ .ib = 6226560000ULL,
+ },
+};
+
+static struct msm_bus_paths enc_ocmem_perf_vectors[] = {
+ {
+ ARRAY_SIZE(enc_ocmem_init_vectors),
+ enc_ocmem_init_vectors,
+ },
+ {
+ ARRAY_SIZE(enc_ocmem_perf1_vectors),
+ enc_ocmem_perf1_vectors,
+ },
+ {
+ ARRAY_SIZE(enc_ocmem_perf2_vectors),
+ enc_ocmem_perf2_vectors,
+ },
+ {
+ ARRAY_SIZE(enc_ocmem_perf3_vectors),
+ enc_ocmem_perf3_vectors,
+ },
+ {
+ ARRAY_SIZE(enc_ocmem_perf4_vectors),
+ enc_ocmem_perf4_vectors,
+ },
+ {
+ ARRAY_SIZE(enc_ocmem_perf5_vectors),
+ enc_ocmem_perf5_vectors,
+ },
+ {
+ ARRAY_SIZE(enc_ocmem_perf6_vectors),
+ enc_ocmem_perf6_vectors,
+ },
+};
+
+static struct msm_bus_paths dec_ocmem_perf_vectors[] = {
+ {
+ ARRAY_SIZE(dec_ocmem_init_vectors),
+ dec_ocmem_init_vectors,
+ },
+ {
+ ARRAY_SIZE(dec_ocmem_perf1_vectors),
+ dec_ocmem_perf1_vectors,
+ },
+ {
+ ARRAY_SIZE(dec_ocmem_perf2_vectors),
+ dec_ocmem_perf2_vectors,
+ },
+ {
+ ARRAY_SIZE(dec_ocmem_perf3_vectors),
+ dec_ocmem_perf3_vectors,
+ },
+ {
+ ARRAY_SIZE(dec_ocmem_perf4_vectors),
+ dec_ocmem_perf4_vectors,
+ },
+ {
+ ARRAY_SIZE(dec_ocmem_perf5_vectors),
+ dec_ocmem_perf5_vectors,
+ },
+ {
+ ARRAY_SIZE(dec_ocmem_perf6_vectors),
+ dec_ocmem_perf6_vectors,
+ },
+};
+
+
+static struct msm_bus_scale_pdata enc_ocmem_bus_data = {
+ .usecase = enc_ocmem_perf_vectors,
+ .num_usecases = ARRAY_SIZE(enc_ocmem_perf_vectors),
+ .name = "msm_vidc_enc_ocmem",
+};
+
+static struct msm_bus_scale_pdata dec_ocmem_bus_data = {
+ .usecase = dec_ocmem_perf_vectors,
+ .num_usecases = ARRAY_SIZE(dec_ocmem_perf_vectors),
+ .name = "msm_vidc_dec_ocmem",
+};
+
+static struct msm_bus_vectors enc_ddr_init_vectors[] = {
+ {
+ .src = MSM_BUS_MASTER_VIDEO_P0,
+ .dst = MSM_BUS_SLAVE_EBI_CH0,
+ .ab = 0,
+ .ib = 0,
+ },
+};
+
+
+static struct msm_bus_vectors enc_ddr_perf1_vectors[] = {
+ {
+ .src = MSM_BUS_MASTER_VIDEO_P0,
+ .dst = MSM_BUS_SLAVE_EBI_CH0,
+ .ab = 60000000,
+ .ib = 664950000,
+ },
+};
+
+static struct msm_bus_vectors enc_ddr_perf2_vectors[] = {
+ {
+ .src = MSM_BUS_MASTER_VIDEO_P0,
+ .dst = MSM_BUS_SLAVE_EBI_CH0,
+ .ab = 181000000,
+ .ib = 664950000,
+ },
+};
+
+static struct msm_bus_vectors enc_ddr_perf3_vectors[] = {
+ {
+ .src = MSM_BUS_MASTER_VIDEO_P0,
+ .dst = MSM_BUS_SLAVE_EBI_CH0,
+ .ab = 403000000,
+ .ib = 664950000,
+ },
+};
+
+static struct msm_bus_vectors enc_ddr_perf4_vectors[] = {
+ {
+ .src = MSM_BUS_MASTER_VIDEO_P0,
+ .dst = MSM_BUS_SLAVE_EBI_CH0,
+ .ab = 806000000,
+ .ib = 1329900000,
+ },
+};
+
+static struct msm_bus_vectors enc_ddr_perf5_vectors[] = {
+ {
+ .src = MSM_BUS_MASTER_VIDEO_P0,
+ .dst = MSM_BUS_SLAVE_EBI_CH0,
+ .ab = 1289600000,
+ .ib = 2127840000U,
+ },
+};
+
+static struct msm_bus_vectors enc_ddr_perf6_vectors[] = {
+ {
+ .src = MSM_BUS_MASTER_VIDEO_P0,
+ .dst = MSM_BUS_SLAVE_EBI_CH0,
+ .ab = 161200000,
+ .ib = 6400000000ULL,
+ },
+};
+
+static struct msm_bus_vectors dec_ddr_init_vectors[] = {
+ {
+ .src = MSM_BUS_MASTER_VIDEO_P0,
+ .dst = MSM_BUS_SLAVE_EBI_CH0,
+ .ab = 0,
+ .ib = 0,
+ },
+};
+
+static struct msm_bus_vectors dec_ddr_perf1_vectors[] = {
+ {
+ .src = MSM_BUS_MASTER_VIDEO_P0,
+ .dst = MSM_BUS_SLAVE_EBI_CH0,
+ .ab = 110000000,
+ .ib = 909000000,
+ },
+};
+
+static struct msm_bus_vectors dec_ddr_perf2_vectors[] = {
+ {
+ .src = MSM_BUS_MASTER_VIDEO_P0,
+ .dst = MSM_BUS_SLAVE_EBI_CH0,
+ .ab = 268000000,
+ .ib = 909000000,
+ },
+};
+
+static struct msm_bus_vectors dec_ddr_perf3_vectors[] = {
+ {
+ .src = MSM_BUS_MASTER_VIDEO_P0,
+ .dst = MSM_BUS_SLAVE_EBI_CH0,
+ .ab = 505000000,
+ .ib = 909000000,
+ },
+};
+
+static struct msm_bus_vectors dec_ddr_perf4_vectors[] = {
+ {
+ .src = MSM_BUS_MASTER_VIDEO_P0,
+ .dst = MSM_BUS_SLAVE_EBI_CH0,
+ .ab = 1010000000,
+ .ib = 1818000000,
+ },
+};
+
+static struct msm_bus_vectors dec_ddr_perf5_vectors[] = {
+ {
+ .src = MSM_BUS_MASTER_VIDEO_P0,
+ .dst = MSM_BUS_SLAVE_EBI_CH0,
+ .ab = 1616000000,
+ .ib = 2908800000U,
+ },
+};
+
+static struct msm_bus_vectors dec_ddr_perf6_vectors[] = {
+ {
+ .src = MSM_BUS_MASTER_VIDEO_P0,
+ .dst = MSM_BUS_SLAVE_EBI_CH0,
+ .ab = 2020000000U,
+ .ib = 6400000000ULL,
+ },
+};
+
+static struct msm_bus_paths enc_ddr_perf_vectors[] = {
+ {
+ ARRAY_SIZE(enc_ddr_init_vectors),
+ enc_ddr_init_vectors,
+ },
+ {
+ ARRAY_SIZE(enc_ddr_perf1_vectors),
+ enc_ddr_perf1_vectors,
+ },
+ {
+ ARRAY_SIZE(enc_ddr_perf2_vectors),
+ enc_ddr_perf2_vectors,
+ },
+ {
+ ARRAY_SIZE(enc_ddr_perf3_vectors),
+ enc_ddr_perf3_vectors,
+ },
+ {
+ ARRAY_SIZE(enc_ddr_perf4_vectors),
+ enc_ddr_perf4_vectors,
+ },
+ {
+ ARRAY_SIZE(enc_ddr_perf5_vectors),
+ enc_ddr_perf5_vectors,
+ },
+ {
+ ARRAY_SIZE(enc_ddr_perf6_vectors),
+ enc_ddr_perf6_vectors,
+ },
+};
+
+static struct msm_bus_paths dec_ddr_perf_vectors[] = {
+ {
+ ARRAY_SIZE(dec_ddr_init_vectors),
+ dec_ddr_init_vectors,
+ },
+ {
+ ARRAY_SIZE(dec_ddr_perf1_vectors),
+ dec_ddr_perf1_vectors,
+ },
+ {
+ ARRAY_SIZE(dec_ddr_perf2_vectors),
+ dec_ddr_perf2_vectors,
+ },
+ {
+ ARRAY_SIZE(dec_ddr_perf3_vectors),
+ dec_ddr_perf3_vectors,
+ },
+ {
+ ARRAY_SIZE(dec_ddr_perf4_vectors),
+ dec_ddr_perf4_vectors,
+ },
+ {
+ ARRAY_SIZE(dec_ddr_perf5_vectors),
+ dec_ddr_perf5_vectors,
+ },
+ {
+ ARRAY_SIZE(dec_ddr_perf6_vectors),
+ dec_ddr_perf6_vectors,
+ },
+};
+
+static struct msm_bus_scale_pdata enc_ddr_bus_data = {
+ .usecase = enc_ddr_perf_vectors,
+ .num_usecases = ARRAY_SIZE(enc_ddr_perf_vectors),
+ .name = "msm_vidc_enc_ddr",
+};
+
+static struct msm_bus_scale_pdata dec_ddr_bus_data = {
+ .usecase = dec_ddr_perf_vectors,
+ .num_usecases = ARRAY_SIZE(dec_ddr_perf_vectors),
+ .name = "msm_vidc_dec_ddr",
+};
+
+#define TZBSP_MEM_PROTECT_VIDEO_VAR 0x8
+struct tzbsp_memprot {
+ u32 cp_start;
+ u32 cp_size;
+ u32 cp_nonpixel_start;
+ u32 cp_nonpixel_size;
+};
+
+struct tzbsp_resp {
+ int ret;
+};
+
+static void venus_hfi_sim_modify_cmd_packet(u8 *packet)
{
struct hfi_cmd_sys_session_init_packet *sys_init;
struct hal_session *sess;
@@ -52,21 +473,21 @@
*pkt = (struct
hfi_cmd_session_empty_buffer_compressed_packet
*) packet;
- pkt->packet_buffer -= HFI_VIRTIO_FW_BIAS;
+ pkt->packet_buffer -= HFI_SIM_FW_BIAS;
} else {
struct
hfi_cmd_session_empty_buffer_uncompressed_plane0_packet
*pkt = (struct
hfi_cmd_session_empty_buffer_uncompressed_plane0_packet
*) packet;
- pkt->packet_buffer -= HFI_VIRTIO_FW_BIAS;
+ pkt->packet_buffer -= HFI_SIM_FW_BIAS;
}
break;
case HFI_CMD_SESSION_FILL_BUFFER:
{
struct hfi_cmd_session_fill_buffer_packet *pkt =
(struct hfi_cmd_session_fill_buffer_packet *)packet;
- pkt->packet_buffer -= HFI_VIRTIO_FW_BIAS;
+ pkt->packet_buffer -= HFI_SIM_FW_BIAS;
break;
}
case HFI_CMD_SESSION_SET_BUFFERS:
@@ -77,11 +498,11 @@
(pkt->buffer_type == HFI_BUFFER_OUTPUT2)) {
struct hfi_buffer_info *buff;
buff = (struct hfi_buffer_info *) pkt->rg_buffer_info;
- buff->buffer_addr -= HFI_VIRTIO_FW_BIAS;
- buff->extra_data_addr -= HFI_VIRTIO_FW_BIAS;
+ buff->buffer_addr -= HFI_SIM_FW_BIAS;
+ buff->extra_data_addr -= HFI_SIM_FW_BIAS;
} else {
for (i = 0; i < pkt->num_buffers; i++)
- pkt->rg_buffer_info[i] -= HFI_VIRTIO_FW_BIAS;
+ pkt->rg_buffer_info[i] -= HFI_SIM_FW_BIAS;
}
break;
}
@@ -93,11 +514,11 @@
(pkt->buffer_type == HFI_BUFFER_OUTPUT2)) {
struct hfi_buffer_info *buff;
buff = (struct hfi_buffer_info *) pkt->rg_buffer_info;
- buff->buffer_addr -= HFI_VIRTIO_FW_BIAS;
- buff->extra_data_addr -= HFI_VIRTIO_FW_BIAS;
+ buff->buffer_addr -= HFI_SIM_FW_BIAS;
+ buff->extra_data_addr -= HFI_SIM_FW_BIAS;
} else {
for (i = 0; i < pkt->num_buffers; i++)
- pkt->rg_buffer_info[i] -= HFI_VIRTIO_FW_BIAS;
+ pkt->rg_buffer_info[i] -= HFI_SIM_FW_BIAS;
}
break;
}
@@ -106,7 +527,7 @@
struct hfi_cmd_session_parse_sequence_header_packet *pkt =
(struct hfi_cmd_session_parse_sequence_header_packet *)
packet;
- pkt->packet_buffer -= HFI_VIRTIO_FW_BIAS;
+ pkt->packet_buffer -= HFI_SIM_FW_BIAS;
break;
}
case HFI_CMD_SESSION_GET_SEQUENCE_HEADER:
@@ -114,7 +535,7 @@
struct hfi_cmd_session_get_sequence_header_packet *pkt =
(struct hfi_cmd_session_get_sequence_header_packet *)
packet;
- pkt->packet_buffer -= HFI_VIRTIO_FW_BIAS;
+ pkt->packet_buffer -= HFI_SIM_FW_BIAS;
break;
}
default:
@@ -122,7 +543,7 @@
}
}
-static int write_queue(void *info, u8 *packet, u32 *rx_req_is_set)
+static int venus_hfi_write_queue(void *info, u8 *packet, u32 *rx_req_is_set)
{
struct hfi_queue_header *queue;
u32 packet_size_in_words, new_write_idx;
@@ -136,7 +557,7 @@
}
qinfo = (struct vidc_iface_q_info *) info;
- hal_virtio_modify_cmd_packet(packet);
+ venus_hfi_sim_modify_cmd_packet(packet);
queue = (struct hfi_queue_header *) qinfo->q_hdr;
@@ -188,7 +609,7 @@
return 0;
}
-static void hal_virtio_modify_msg_packet(u8 *packet)
+static void venus_hfi_hal_sim_modify_msg_packet(u8 *packet)
{
struct hfi_msg_sys_session_init_done_packet *sys_idle;
struct hal_session *sess;
@@ -209,21 +630,21 @@
*pkt_uc = (struct
hfi_msg_session_fbd_uncompressed_plane0_packet
*) packet;
- pkt_uc->packet_buffer += HFI_VIRTIO_FW_BIAS;
+ pkt_uc->packet_buffer += HFI_SIM_FW_BIAS;
} else {
struct
hfi_msg_session_fill_buffer_done_compressed_packet
*pkt = (struct
hfi_msg_session_fill_buffer_done_compressed_packet
*) packet;
- pkt->packet_buffer += HFI_VIRTIO_FW_BIAS;
+ pkt->packet_buffer += HFI_SIM_FW_BIAS;
}
break;
case HFI_MSG_SESSION_EMPTY_BUFFER_DONE:
{
struct hfi_msg_session_empty_buffer_done_packet *pkt =
(struct hfi_msg_session_empty_buffer_done_packet *)packet;
- pkt->packet_buffer += HFI_VIRTIO_FW_BIAS;
+ pkt->packet_buffer += HFI_SIM_FW_BIAS;
break;
}
case HFI_MSG_SESSION_GET_SEQUENCE_HEADER_DONE:
@@ -233,7 +654,7 @@
*pkt =
(struct hfi_msg_session_get_sequence_header_done_packet *)
packet;
- pkt->sequence_header += HFI_VIRTIO_FW_BIAS;
+ pkt->sequence_header += HFI_SIM_FW_BIAS;
break;
}
default:
@@ -241,7 +662,7 @@
}
}
-static int read_queue(void *info, u8 *packet, u32 *pb_tx_req_is_set)
+static int venus_hfi_read_queue(void *info, u8 *packet, u32 *pb_tx_req_is_set)
{
struct hfi_queue_header *queue;
u32 packet_size_in_words, new_read_idx;
@@ -299,13 +720,13 @@
queue->qhdr_rx_req = 1;
*pb_tx_req_is_set = (1 == queue->qhdr_tx_req) ? 1 : 0;
- hal_virtio_modify_msg_packet(packet);
+ venus_hfi_hal_sim_modify_msg_packet(packet);
dprintk(VIDC_DBG, "Out : ");
return 0;
}
-static int vidc_hal_alloc(void *mem, void *clnt, u32 size, u32 align, u32 flags,
- int domain)
+static int venus_hfi_alloc(void *mem, void *clnt, u32 size, u32 align,
+ u32 flags, int domain)
{
struct vidc_mem_addr *vmem;
struct msm_smem *alloc;
@@ -330,7 +751,7 @@
dprintk(VIDC_ERR, "NOTE: Failed to clean caches\n");
goto fail_clean_cache;
}
- dprintk(VIDC_DBG, "vidc_hal_alloc:ptr=%p,size=%d",
+ dprintk(VIDC_DBG, "venus_hfi_alloc:ptr=%p,size=%d",
alloc->kvaddr, size);
vmem->mem_size = alloc->size;
vmem->mem_data = alloc;
@@ -343,12 +764,13 @@
return rc;
}
-static void vidc_hal_free(struct smem_client *clnt, struct msm_smem *mem)
+static void venus_hfi_free(struct smem_client *clnt, struct msm_smem *mem)
{
msm_smem_free(clnt, mem);
}
-static void write_register(u8 *base_addr, u32 reg, u32 value, u8 *vaddr)
+static void venus_hfi_write_register(u8 *base_addr, u32 reg,
+ u32 value, u8 *vaddr)
{
u32 hwiosymaddr = reg;
@@ -360,14 +782,14 @@
(struct hfi_queue_table_header *)vaddr;
qhdr = VIDC_IFACEQ_GET_QHDR_START_ADDR(qtbl_hdr, 0);
- qhdr->qhdr_start_addr -= HFI_VIRTIO_FW_BIAS;
+ qhdr->qhdr_start_addr -= HFI_SIM_FW_BIAS;
qhdr = VIDC_IFACEQ_GET_QHDR_START_ADDR(qtbl_hdr, 1);
- qhdr->qhdr_start_addr -= HFI_VIRTIO_FW_BIAS;
+ qhdr->qhdr_start_addr -= HFI_SIM_FW_BIAS;
qhdr = VIDC_IFACEQ_GET_QHDR_START_ADDR(qtbl_hdr, 2);
- qhdr->qhdr_start_addr -= HFI_VIRTIO_FW_BIAS;
- value -= HFI_VIRTIO_FW_BIAS;
+ qhdr->qhdr_start_addr -= HFI_SIM_FW_BIAS;
+ value -= HFI_SIM_FW_BIAS;
}
hwiosymaddr = ((u32)base_addr + (hwiosymaddr));
@@ -377,14 +799,15 @@
wmb();
}
-static int read_register(u8 *base_addr, u32 reg)
+static int venus_hfi_read_register(u8 *base_addr, u32 reg)
{
int rc = readl_relaxed((u32)base_addr + reg);
rmb();
return rc;
}
-static int vidc_hal_iface_cmdq_write(struct hal_device *device, void *pkt)
+static int venus_hfi_iface_cmdq_write(struct venus_hfi_device *device,
+ void *pkt)
{
u32 rx_req_is_set = 0;
struct vidc_iface_q_info *q_info;
@@ -402,21 +825,22 @@
goto err_q_write;
}
- if (!write_queue(q_info, (u8 *)pkt, &rx_req_is_set)) {
+ if (!venus_hfi_write_queue(q_info, (u8 *)pkt, &rx_req_is_set)) {
if (rx_req_is_set)
- write_register(device->hal_data->register_base_addr,
+ venus_hfi_write_register(
+ device->hal_data->register_base_addr,
VIDC_CPU_IC_SOFTINT,
1 << VIDC_CPU_IC_SOFTINT_H2A_SHFT, 0);
result = 0;
} else {
- dprintk(VIDC_ERR, "vidc_hal_iface_cmdq_write:queue_full");
+ dprintk(VIDC_ERR, "venus_hfi_iface_cmdq_write:queue_full");
}
err_q_write:
spin_unlock(&device->write_lock);
return result;
}
-int vidc_hal_iface_msgq_read(struct hal_device *device, void *pkt)
+int venus_hfi_iface_msgq_read(struct venus_hfi_device *device, void *pkt)
{
u32 tx_req_is_set = 0;
int rc = 0;
@@ -435,14 +859,15 @@
}
q_info = &device->iface_queues[VIDC_IFACEQ_MSGQ_IDX];
- if (!read_queue(q_info, (u8 *)pkt, &tx_req_is_set)) {
+ if (!venus_hfi_read_queue(q_info, (u8 *)pkt, &tx_req_is_set)) {
if (tx_req_is_set)
- write_register(device->hal_data->register_base_addr,
+ venus_hfi_write_register(
+ device->hal_data->register_base_addr,
VIDC_CPU_IC_SOFTINT,
1 << VIDC_CPU_IC_SOFTINT_H2A_SHFT, 0);
rc = 0;
} else {
- dprintk(VIDC_INFO, "vidc_hal_iface_msgq_read:queue_empty");
+ dprintk(VIDC_INFO, "venus_hfi_iface_msgq_read:queue_empty");
rc = -ENODATA;
}
read_error:
@@ -450,7 +875,7 @@
return rc;
}
-int vidc_hal_iface_dbgq_read(struct hal_device *device, void *pkt)
+int venus_hfi_iface_dbgq_read(struct venus_hfi_device *device, void *pkt)
{
u32 tx_req_is_set = 0;
int rc = 0;
@@ -468,14 +893,15 @@
goto dbg_error;
}
q_info = &device->iface_queues[VIDC_IFACEQ_DBGQ_IDX];
- if (!read_queue(q_info, (u8 *)pkt, &tx_req_is_set)) {
+ if (!venus_hfi_read_queue(q_info, (u8 *)pkt, &tx_req_is_set)) {
if (tx_req_is_set)
- write_register(device->hal_data->register_base_addr,
- VIDC_CPU_IC_SOFTINT,
- 1 << VIDC_CPU_IC_SOFTINT_H2A_SHFT, 0);
+ venus_hfi_write_register(
+ device->hal_data->register_base_addr,
+ VIDC_CPU_IC_SOFTINT,
+ 1 << VIDC_CPU_IC_SOFTINT_H2A_SHFT, 0);
rc = 0;
} else {
- dprintk(VIDC_INFO, "vidc_hal_iface_dbgq_read:queue_empty");
+ dprintk(VIDC_INFO, "venus_hfi_iface_dbgq_read:queue_empty");
rc = -ENODATA;
}
dbg_error:
@@ -483,7 +909,7 @@
return rc;
}
-static void vidc_hal_set_queue_hdr_defaults(struct hfi_queue_header *q_hdr)
+static void venus_hfi_set_queue_hdr_defaults(struct hfi_queue_header *q_hdr)
{
q_hdr->qhdr_status = 0x1;
q_hdr->qhdr_type = VIDC_IFACEQ_DFLT_QHDR;
@@ -499,11 +925,11 @@
q_hdr->qhdr_write_idx = 0x0;
}
-static void vidc_hal_interface_queues_release(struct hal_device *device)
+static void venus_hfi_interface_queues_release(struct venus_hfi_device *device)
{
int i;
- vidc_hal_free(device->hal_client, device->mem_addr.mem_data);
+ venus_hfi_free(device->hal_client, device->mem_addr.mem_data);
for (i = 0; i < VIDC_IFACEQ_NUMQ; i++) {
device->iface_queues[i].q_hdr = NULL;
@@ -527,7 +953,8 @@
device->hal_client = NULL;
}
-static int vidc_hal_interface_queues_init(struct hal_device *dev, int domain)
+static int venus_hfi_interface_queues_init(struct venus_hfi_device *dev,
+ int domain)
{
struct hfi_queue_table_header *q_tbl_hdr;
struct hfi_queue_header *q_hdr;
@@ -540,7 +967,7 @@
int size_1m = 1024 * 1024;
int uc_size = (UC_SIZE + size_1m - 1) & (~(size_1m - 1));
mem_addr = &dev->mem_addr;
- rc = vidc_hal_alloc((void *) mem_addr,
+ rc = venus_hfi_alloc((void *) mem_addr,
dev->hal_client, uc_size, 1,
0, domain);
if (rc) {
@@ -564,7 +991,7 @@
offset += iface_q->q_array.mem_size;
iface_q->q_hdr = VIDC_IFACEQ_GET_QHDR_START_ADDR(
dev->iface_q_table.align_virtual_addr, i);
- vidc_hal_set_queue_hdr_defaults(iface_q->q_hdr);
+ venus_hfi_set_queue_hdr_defaults(iface_q->q_hdr);
}
dev->qdss.align_device_addr = mem_addr->align_device_addr + offset;
@@ -608,43 +1035,43 @@
iface_q->q_array.align_device_addr;
q_hdr->qhdr_type |= HFI_Q_ID_CTRL_TO_HOST_DEBUG_Q;
- write_register(dev->hal_data->register_base_addr,
+ venus_hfi_write_register(dev->hal_data->register_base_addr,
VIDC_UC_REGION_ADDR,
(u32) mem_addr->align_device_addr, 0);
- write_register(dev->hal_data->register_base_addr,
+ venus_hfi_write_register(dev->hal_data->register_base_addr,
VIDC_UC_REGION_SIZE, mem_addr->mem_size, 0);
- write_register(dev->hal_data->register_base_addr,
+ venus_hfi_write_register(dev->hal_data->register_base_addr,
VIDC_CPU_CS_SCIACMDARG2,
(u32) dev->iface_q_table.align_device_addr,
dev->iface_q_table.align_virtual_addr);
- write_register(dev->hal_data->register_base_addr,
+ venus_hfi_write_register(dev->hal_data->register_base_addr,
VIDC_CPU_CS_SCIACMDARG1, 0x01,
dev->iface_q_table.align_virtual_addr);
- write_register(dev->hal_data->register_base_addr,
+ venus_hfi_write_register(dev->hal_data->register_base_addr,
VIDC_MMAP_ADDR,
(u32) dev->qdss.align_device_addr, 0);
vsfr = (struct hfi_sfr_struct *) dev->sfr.align_virtual_addr;
vsfr->bufSize = SFR_SIZE;
- write_register(dev->hal_data->register_base_addr,
+ venus_hfi_write_register(dev->hal_data->register_base_addr,
VIDC_SFR_ADDR, (u32)dev->sfr.align_device_addr , 0);
return 0;
}
-static int vidc_hal_core_start_cpu(struct hal_device *device)
+static int venus_hfi_core_start_cpu(struct venus_hfi_device *device)
{
u32 ctrl_status = 0, count = 0, rc = 0;
int max_tries = 100;
- write_register(device->hal_data->register_base_addr,
+ venus_hfi_write_register(device->hal_data->register_base_addr,
VIDC_WRAPPER_INTR_MASK, 0x8, 0);
- write_register(device->hal_data->register_base_addr,
+ venus_hfi_write_register(device->hal_data->register_base_addr,
VIDC_CPU_CS_SCIACMDARG3, 1, 0);
while (!ctrl_status && count < max_tries) {
- ctrl_status = read_register(
- device->hal_data->register_base_addr,
- VIDC_CPU_CS_SCIACMDARG0);
+ ctrl_status = venus_hfi_read_register(
+ device->hal_data->register_base_addr,
+ VIDC_CPU_CS_SCIACMDARG0);
if ((ctrl_status & 0xFE) == 0x4) {
dprintk(VIDC_ERR, "invalid setting for UC_REGION\n");
break;
@@ -657,50 +1084,50 @@
return rc;
}
-static void set_vbif_registers(struct hal_device *device)
+static void venus_hfi_set_vbif_registers(struct venus_hfi_device *device)
{
/*Disable Dynamic clock gating for Venus VBIF*/
- write_register(device->hal_data->register_base_addr,
+ venus_hfi_write_register(device->hal_data->register_base_addr,
VIDC_VENUS_VBIF_CLK_ON, 1, 0);
- write_register(device->hal_data->register_base_addr,
+ venus_hfi_write_register(device->hal_data->register_base_addr,
VIDC_VBIF_OUT_AXI_AOOO_EN, 0x00001FFF, 0);
- write_register(device->hal_data->register_base_addr,
+ venus_hfi_write_register(device->hal_data->register_base_addr,
VIDC_VBIF_OUT_AXI_AOOO, 0x1FFF1FFF, 0);
- write_register(device->hal_data->register_base_addr,
+ venus_hfi_write_register(device->hal_data->register_base_addr,
VIDC_VBIF_IN_RD_LIM_CONF0, 0x10101001, 0);
- write_register(device->hal_data->register_base_addr,
+ venus_hfi_write_register(device->hal_data->register_base_addr,
VIDC_VBIF_IN_RD_LIM_CONF1, 0x10101010, 0);
- write_register(device->hal_data->register_base_addr,
+ venus_hfi_write_register(device->hal_data->register_base_addr,
VIDC_VBIF_IN_RD_LIM_CONF2, 0x10101010, 0);
- write_register(device->hal_data->register_base_addr,
+ venus_hfi_write_register(device->hal_data->register_base_addr,
VIDC_VBIF_IN_RD_LIM_CONF3, 0x00000010, 0);
- write_register(device->hal_data->register_base_addr,
+ venus_hfi_write_register(device->hal_data->register_base_addr,
VIDC_VBIF_IN_WR_LIM_CONF0, 0x1010100f, 0);
- write_register(device->hal_data->register_base_addr,
+ venus_hfi_write_register(device->hal_data->register_base_addr,
VIDC_VBIF_IN_WR_LIM_CONF1, 0x10101010, 0);
- write_register(device->hal_data->register_base_addr,
+ venus_hfi_write_register(device->hal_data->register_base_addr,
VIDC_VBIF_IN_WR_LIM_CONF2, 0x10101010, 0);
- write_register(device->hal_data->register_base_addr,
+ venus_hfi_write_register(device->hal_data->register_base_addr,
VIDC_VBIF_IN_WR_LIM_CONF3, 0x00000010, 0);
- write_register(device->hal_data->register_base_addr,
+ venus_hfi_write_register(device->hal_data->register_base_addr,
VIDC_VBIF_OUT_RD_LIM_CONF0, 0x00001010, 0);
- write_register(device->hal_data->register_base_addr,
+ venus_hfi_write_register(device->hal_data->register_base_addr,
VIDC_VBIF_OUT_WR_LIM_CONF0, 0x00001010, 0);
- write_register(device->hal_data->register_base_addr,
+ venus_hfi_write_register(device->hal_data->register_base_addr,
VIDC_VBIF_ARB_CTL, 0x00000030, 0);
- write_register(device->hal_data->register_base_addr,
+ venus_hfi_write_register(device->hal_data->register_base_addr,
VIDC_VENUS_VBIF_DDR_OUT_MAX_BURST, 0x00000707, 0);
- write_register(device->hal_data->register_base_addr,
+ venus_hfi_write_register(device->hal_data->register_base_addr,
VIDC_VENUS_VBIF_OCMEM_OUT_MAX_BURST, 0x00000707, 0);
- write_register(device->hal_data->register_base_addr,
+ venus_hfi_write_register(device->hal_data->register_base_addr,
VIDC_VENUS_VBIF_ROUND_ROBIN_QOS_ARB, 0x00000001, 0);
- write_register(device->hal_data->register_base_addr,
+ venus_hfi_write_register(device->hal_data->register_base_addr,
VIDC_VENUS0_WRAPPER_VBIF_REQ_PRIORITY, 0x5555556, 0);
- write_register(device->hal_data->register_base_addr,
+ venus_hfi_write_register(device->hal_data->register_base_addr,
VIDC_VENUS0_WRAPPER_VBIF_PRIORITY_LEVEL, 0, 0);
}
-static int vidc_hal_sys_set_debug(struct hal_device *device, int debug)
+static int venus_hfi_sys_set_debug(struct venus_hfi_device *device, int debug)
{
struct hfi_debug_config *hfi;
u8 packet[VIDC_IFACEQ_VAR_SMALL_PKT_SIZE];
@@ -714,16 +1141,16 @@
hfi = (struct hfi_debug_config *) &pkt->rg_property_data[1];
hfi->debug_config = debug;
hfi->debug_mode = HFI_DEBUG_MODE_QUEUE;
- if (vidc_hal_iface_cmdq_write(device, pkt))
+ if (venus_hfi_iface_cmdq_write(device, pkt))
return -ENOTEMPTY;
return 0;
}
-int vidc_hal_core_init(void *device, int domain)
+int venus_hfi_core_init(void *device)
{
struct hfi_cmd_sys_init_packet pkt;
int rc = 0;
- struct hal_device *dev;
+ struct venus_hfi_device *dev;
if (device) {
dev = device;
@@ -731,12 +1158,13 @@
dprintk(VIDC_ERR, "Invalid device");
return -ENODEV;
}
+
dev->intr_status = 0;
enable_irq(dev->hal_data->irq);
INIT_LIST_HEAD(&dev->sess_head);
spin_lock_init(&dev->read_lock);
spin_lock_init(&dev->write_lock);
- set_vbif_registers(dev);
+ venus_hfi_set_vbif_registers(dev);
if (!dev->hal_client) {
dev->hal_client = msm_smem_new_client(SMEM_ION);
@@ -750,7 +1178,8 @@
dev->hal_data->device_base_addr,
(u32) dev->hal_data->register_base_addr);
- rc = vidc_hal_interface_queues_init(dev, domain);
+ rc = venus_hfi_interface_queues_init(dev,
+ dev->resources.io_map[NS_MAP].domain);
if (rc) {
dprintk(VIDC_ERR, "failed to init queues");
rc = -ENOMEM;
@@ -761,9 +1190,9 @@
rc = -EEXIST;
goto err_core_init;
}
- write_register(dev->hal_data->register_base_addr,
+ venus_hfi_write_register(dev->hal_data->register_base_addr,
VIDC_CTRL_INIT, 0x1, 0);
- rc = vidc_hal_core_start_cpu(dev);
+ rc = venus_hfi_core_start_cpu(dev);
if (rc) {
dprintk(VIDC_ERR, "Failed to start core");
rc = -ENODEV;
@@ -775,7 +1204,7 @@
dprintk(VIDC_ERR, "Failed to create sys init pkt");
goto err_core_init;
}
- if (vidc_hal_iface_cmdq_write(dev, &pkt)) {
+ if (venus_hfi_iface_cmdq_write(dev, &pkt)) {
rc = -ENOTEMPTY;
goto err_core_init;
}
@@ -785,9 +1214,9 @@
return rc;
}
-int vidc_hal_core_release(void *device)
+int venus_hfi_core_release(void *device)
{
- struct hal_device *dev;
+ struct venus_hfi_device *dev;
if (device) {
dev = device;
} else {
@@ -795,20 +1224,20 @@
return -ENODEV;
}
if (dev->hal_client) {
- write_register(dev->hal_data->register_base_addr,
+ venus_hfi_write_register(dev->hal_data->register_base_addr,
VIDC_CPU_CS_SCIACMDARG3, 0, 0);
disable_irq_nosync(dev->hal_data->irq);
- vidc_hal_interface_queues_release(dev);
+ venus_hfi_interface_queues_release(dev);
}
dprintk(VIDC_INFO, "HAL exited\n");
return 0;
}
-int vidc_hal_core_pc_prep(void *device)
+int venus_hfi_core_pc_prep(void *device)
{
struct hfi_cmd_sys_pc_prep_packet pkt;
int rc = 0;
- struct hal_device *dev;
+ struct venus_hfi_device *dev;
if (device) {
dev = device;
@@ -823,23 +1252,23 @@
goto err_create_pkt;
}
- if (vidc_hal_iface_cmdq_write(dev, &pkt))
+ if (venus_hfi_iface_cmdq_write(dev, &pkt))
rc = -ENOTEMPTY;
err_create_pkt:
return rc;
}
-static void vidc_hal_core_clear_interrupt(struct hal_device *device)
+static void venus_hfi_core_clear_interrupt(struct venus_hfi_device *device)
{
u32 intr_status = 0;
if (!device->callback)
return;
- intr_status = read_register(
- device->hal_data->register_base_addr,
- VIDC_WRAPPER_INTR_STATUS);
+ intr_status = venus_hfi_read_register(
+ device->hal_data->register_base_addr,
+ VIDC_WRAPPER_INTR_STATUS);
if ((intr_status & VIDC_WRAPPER_INTR_STATUS_A2H_BMSK) ||
(intr_status & VIDC_WRAPPER_INTR_STATUS_A2HWD_BMSK)) {
@@ -852,20 +1281,20 @@
"times: %d interrupt_status: %d",
(u32) device, ++device->spur_count, intr_status);
}
- write_register(device->hal_data->register_base_addr,
+ venus_hfi_write_register(device->hal_data->register_base_addr,
VIDC_CPU_CS_A2HSOFTINTCLR, 1, 0);
- write_register(device->hal_data->register_base_addr,
+ venus_hfi_write_register(device->hal_data->register_base_addr,
VIDC_WRAPPER_INTR_CLEAR, intr_status, 0);
dprintk(VIDC_DBG, "Cleared WRAPPER/A2H interrupt");
}
-int vidc_hal_core_set_resource(void *device,
+int venus_hfi_core_set_resource(void *device,
struct vidc_resource_hdr *resource_hdr, void *resource_value)
{
struct hfi_cmd_sys_set_resource_packet *pkt;
u8 packet[VIDC_IFACEQ_VAR_SMALL_PKT_SIZE];
int rc = 0;
- struct hal_device *dev;
+ struct venus_hfi_device *dev;
if (!device || !resource_hdr || !resource_value) {
dprintk(VIDC_ERR, "set_res: Invalid Params");
@@ -877,24 +1306,24 @@
pkt = (struct hfi_cmd_sys_set_resource_packet *) packet;
rc = create_pkt_set_cmd_sys_resource(pkt, resource_hdr,
- resource_value);
+ resource_value);
if (rc) {
dprintk(VIDC_ERR, "set_res: failed to create packet");
goto err_create_pkt;
}
- if (vidc_hal_iface_cmdq_write(dev, pkt))
+ if (venus_hfi_iface_cmdq_write(dev, pkt))
rc = -ENOTEMPTY;
err_create_pkt:
return rc;
}
-int vidc_hal_core_release_resource(void *device,
+int venus_hfi_core_release_resource(void *device,
struct vidc_resource_hdr *resource_hdr)
{
struct hfi_cmd_sys_release_resource_packet pkt;
int rc = 0;
- struct hal_device *dev;
+ struct venus_hfi_device *dev;
if (!device || !resource_hdr) {
dprintk(VIDC_ERR, "Inv-Params in rel_res");
@@ -909,18 +1338,18 @@
goto err_create_pkt;
}
- if (vidc_hal_iface_cmdq_write(dev, &pkt))
+ if (venus_hfi_iface_cmdq_write(dev, &pkt))
rc = -ENOTEMPTY;
err_create_pkt:
return rc;
}
-int vidc_hal_core_ping(void *device)
+int venus_hfi_core_ping(void *device)
{
struct hfi_cmd_sys_ping_packet pkt;
int rc = 0;
- struct hal_device *dev;
+ struct venus_hfi_device *dev;
if (device) {
dev = device;
@@ -935,14 +1364,14 @@
goto err_create_pkt;
}
- if (vidc_hal_iface_cmdq_write(dev, &pkt))
+ if (venus_hfi_iface_cmdq_write(dev, &pkt))
rc = -ENOTEMPTY;
err_create_pkt:
return rc;
}
-int vidc_hal_session_set_property(void *sess,
+int venus_hfi_session_set_property(void *sess,
enum hal_property ptype, void *pdata)
{
u8 packet[VIDC_IFACEQ_VAR_LARGE_PKT_SIZE];
@@ -966,13 +1395,13 @@
return -EINVAL;
}
- if (vidc_hal_iface_cmdq_write(session->device, pkt))
+ if (venus_hfi_iface_cmdq_write(session->device, pkt))
return -ENOTEMPTY;
return rc;
}
-int vidc_hal_session_get_property(void *sess,
+int venus_hfi_session_get_property(void *sess,
enum hal_property ptype, void *pdata)
{
struct hal_session *session;
@@ -1095,12 +1524,12 @@
return 0;
}
-void *vidc_hal_session_init(void *device, u32 session_id,
+void *venus_hfi_session_init(void *device, u32 session_id,
enum hal_domain session_type, enum hal_video_codec codec_type)
{
struct hfi_cmd_sys_session_init_packet pkt;
struct hal_session *new_session;
- struct hal_device *dev;
+ struct venus_hfi_device *dev;
if (device) {
dev = device;
@@ -1125,9 +1554,9 @@
goto err_session_init_fail;
}
- if (vidc_hal_iface_cmdq_write(dev, &pkt))
+ if (venus_hfi_iface_cmdq_write(dev, &pkt))
goto err_session_init_fail;
- if (vidc_hal_sys_set_debug(dev, msm_fw_debug))
+ if (venus_hfi_sys_set_debug(dev, msm_fw_debug))
dprintk(VIDC_ERR, "Setting fw_debug msg ON failed");
return (void *) new_session;
@@ -1136,7 +1565,7 @@
return NULL;
}
-static int vidc_hal_send_session_cmd(void *session_id,
+static int venus_hfi_send_session_cmd(void *session_id,
int pkt_type)
{
struct vidc_hal_session_cmd_pkt pkt;
@@ -1156,26 +1585,26 @@
goto err_create_pkt;
}
- if (vidc_hal_iface_cmdq_write(session->device, &pkt))
+ if (venus_hfi_iface_cmdq_write(session->device, &pkt))
rc = -ENOTEMPTY;
err_create_pkt:
return rc;
}
-int vidc_hal_session_end(void *session)
+int venus_hfi_session_end(void *session)
{
- return vidc_hal_send_session_cmd(session,
+ return venus_hfi_send_session_cmd(session,
HFI_CMD_SYS_SESSION_END);
}
-int vidc_hal_session_abort(void *session)
+int venus_hfi_session_abort(void *session)
{
- return vidc_hal_send_session_cmd(session,
+ return venus_hfi_send_session_cmd(session,
HFI_CMD_SYS_SESSION_ABORT);
}
-int vidc_hal_session_set_buffers(void *sess,
+int venus_hfi_session_set_buffers(void *sess,
struct vidc_buffer_addr_info *buffer_info)
{
struct hfi_cmd_session_set_buffers_packet *pkt;
@@ -1203,13 +1632,13 @@
}
dprintk(VIDC_INFO, "set buffers: 0x%x", buffer_info->buffer_type);
- if (vidc_hal_iface_cmdq_write(session->device, pkt))
+ if (venus_hfi_iface_cmdq_write(session->device, pkt))
rc = -ENOTEMPTY;
err_create_pkt:
return rc;
}
-int vidc_hal_session_release_buffers(void *sess,
+int venus_hfi_session_release_buffers(void *sess,
struct vidc_buffer_addr_info *buffer_info)
{
struct hfi_cmd_session_release_buffer_packet *pkt;
@@ -1237,49 +1666,49 @@
}
dprintk(VIDC_INFO, "Release buffers: 0x%x", buffer_info->buffer_type);
- if (vidc_hal_iface_cmdq_write(session->device, pkt))
+ if (venus_hfi_iface_cmdq_write(session->device, pkt))
rc = -ENOTEMPTY;
err_create_pkt:
return rc;
}
-int vidc_hal_session_load_res(void *sess)
+int venus_hfi_session_load_res(void *sess)
{
- return vidc_hal_send_session_cmd(sess,
+ return venus_hfi_send_session_cmd(sess,
HFI_CMD_SESSION_LOAD_RESOURCES);
}
-int vidc_hal_session_release_res(void *sess)
+int venus_hfi_session_release_res(void *sess)
{
- return vidc_hal_send_session_cmd(sess,
+ return venus_hfi_send_session_cmd(sess,
HFI_CMD_SESSION_RELEASE_RESOURCES);
}
-int vidc_hal_session_start(void *sess)
+int venus_hfi_session_start(void *sess)
{
- return vidc_hal_send_session_cmd(sess,
+ return venus_hfi_send_session_cmd(sess,
HFI_CMD_SESSION_START);
}
-int vidc_hal_session_stop(void *sess)
+int venus_hfi_session_stop(void *sess)
{
- return vidc_hal_send_session_cmd(sess,
+ return venus_hfi_send_session_cmd(sess,
HFI_CMD_SESSION_STOP);
}
-int vidc_hal_session_suspend(void *sess)
+int venus_hfi_session_suspend(void *sess)
{
- return vidc_hal_send_session_cmd(sess,
+ return venus_hfi_send_session_cmd(sess,
HFI_CMD_SESSION_SUSPEND);
}
-int vidc_hal_session_resume(void *sess)
+int venus_hfi_session_resume(void *sess)
{
- return vidc_hal_send_session_cmd(sess,
+ return venus_hfi_send_session_cmd(sess,
HFI_CMD_SESSION_RESUME);
}
-int vidc_hal_session_etb(void *sess, struct vidc_frame_data *input_frame)
+int venus_hfi_session_etb(void *sess, struct vidc_frame_data *input_frame)
{
int rc = 0;
struct hal_session *session;
@@ -1302,7 +1731,7 @@
goto err_create_pkt;
}
dprintk(VIDC_DBG, "Q DECODER INPUT BUFFER");
- if (vidc_hal_iface_cmdq_write(session->device, &pkt))
+ if (venus_hfi_iface_cmdq_write(session->device, &pkt))
rc = -ENOTEMPTY;
} else {
struct hfi_cmd_session_empty_buffer_uncompressed_plane0_packet
@@ -1316,14 +1745,14 @@
goto err_create_pkt;
}
dprintk(VIDC_DBG, "Q ENCODER INPUT BUFFER");
- if (vidc_hal_iface_cmdq_write(session->device, &pkt))
+ if (venus_hfi_iface_cmdq_write(session->device, &pkt))
rc = -ENOTEMPTY;
}
err_create_pkt:
return rc;
}
-int vidc_hal_session_ftb(void *sess,
+int venus_hfi_session_ftb(void *sess,
struct vidc_frame_data *output_frame)
{
struct hfi_cmd_session_fill_buffer_packet pkt;
@@ -1343,13 +1772,13 @@
goto err_create_pkt;
}
- if (vidc_hal_iface_cmdq_write(session->device, &pkt))
+ if (venus_hfi_iface_cmdq_write(session->device, &pkt))
rc = -ENOTEMPTY;
err_create_pkt:
return rc;
}
-int vidc_hal_session_parse_seq_hdr(void *sess,
+int venus_hfi_session_parse_seq_hdr(void *sess,
struct vidc_seq_hdr *seq_hdr)
{
struct hfi_cmd_session_parse_sequence_header_packet *pkt;
@@ -1374,13 +1803,13 @@
goto err_create_pkt;
}
- if (vidc_hal_iface_cmdq_write(session->device, pkt))
+ if (venus_hfi_iface_cmdq_write(session->device, pkt))
rc = -ENOTEMPTY;
err_create_pkt:
return rc;
}
-int vidc_hal_session_get_seq_hdr(void *sess,
+int venus_hfi_session_get_seq_hdr(void *sess,
struct vidc_seq_hdr *seq_hdr)
{
struct hfi_cmd_session_get_sequence_header_packet *pkt;
@@ -1402,13 +1831,13 @@
goto err_create_pkt;
}
- if (vidc_hal_iface_cmdq_write(session->device, pkt))
+ if (venus_hfi_iface_cmdq_write(session->device, pkt))
rc = -ENOTEMPTY;
err_create_pkt:
return rc;
}
-int vidc_hal_session_get_buf_req(void *sess)
+int venus_hfi_session_get_buf_req(void *sess)
{
struct hfi_cmd_session_get_property_packet pkt;
int rc = 0;
@@ -1427,13 +1856,13 @@
goto err_create_pkt;
}
- if (vidc_hal_iface_cmdq_write(session->device, &pkt))
+ if (venus_hfi_iface_cmdq_write(session->device, &pkt))
rc = -ENOTEMPTY;
err_create_pkt:
return rc;
}
-int vidc_hal_session_flush(void *sess, enum hal_flush flush_mode)
+int venus_hfi_session_flush(void *sess, enum hal_flush flush_mode)
{
struct hfi_cmd_session_flush_packet pkt;
int rc = 0;
@@ -1452,22 +1881,23 @@
goto err_create_pkt;
}
- if (vidc_hal_iface_cmdq_write(session->device, &pkt))
+ if (venus_hfi_iface_cmdq_write(session->device, &pkt))
rc = -ENOTEMPTY;
err_create_pkt:
return rc;
}
-static int vidc_hal_check_core_registered(
+static int venus_hfi_check_core_registered(
struct hal_device_data core, u32 fw_addr,
u32 reg_addr, u32 reg_size, u32 irq)
{
- struct hal_device *device;
+ struct venus_hfi_device *device;
struct list_head *curr, *next;
if (core.dev_count) {
list_for_each_safe(curr, next, &core.dev_head) {
- device = list_entry(curr, struct hal_device, list);
+ device = list_entry(curr,
+ struct venus_hfi_device, list);
if (device && device->hal_data->irq == irq &&
(CONTAINS(device->hal_data->
device_base_addr,
@@ -1507,10 +1937,10 @@
return -EINVAL;
}
-static void vidc_hal_core_work_handler(struct work_struct *work)
+static void venus_hfi_core_work_handler(struct work_struct *work)
{
- struct hal_device *device = list_first_entry(
- &hal_ctxt.dev_head, struct hal_device, list);
+ struct venus_hfi_device *device = list_first_entry(
+ &hal_ctxt.dev_head, struct venus_hfi_device, list);
dprintk(VIDC_INFO, " GOT INTERRUPT () ");
if (!device->callback) {
@@ -1518,75 +1948,825 @@
device);
return;
}
- vidc_hal_core_clear_interrupt(device);
- vidc_hal_response_handler(device);
+ venus_hfi_core_clear_interrupt(device);
+ hfi_response_handler(device);
enable_irq(device->hal_data->irq);
}
-static DECLARE_WORK(vidc_hal_work, vidc_hal_core_work_handler);
+static DECLARE_WORK(venus_hfi_work, venus_hfi_core_work_handler);
-static irqreturn_t vidc_hal_isr(int irq, void *dev)
+static irqreturn_t venus_hfi_isr(int irq, void *dev)
{
- struct hal_device *device = dev;
+ struct venus_hfi_device *device = dev;
dprintk(VIDC_INFO, "vidc_hal_isr() %d ", irq);
disable_irq_nosync(irq);
- queue_work(device->vidc_workq, &vidc_hal_work);
+ queue_work(device->vidc_workq, &venus_hfi_work);
dprintk(VIDC_INFO, "vidc_hal_isr() %d ", irq);
return IRQ_HANDLED;
}
-void *vidc_hal_add_device(u32 device_id, u32 fw_base_addr, u32 reg_base,
- u32 reg_size, u32 irq,
- void (*callback) (enum command_response cmd, void *data))
+static int venus_hfi_init_regs_and_interrupts(
+ struct venus_hfi_device *device, struct platform_device *pdev)
{
- struct hal_device *hdevice = NULL;
struct hal_data *hal = NULL;
int rc = 0;
+ struct resource *res;
- if (device_id || !reg_base || !reg_size ||
- !irq || !callback) {
+ device->base_addr = 0x0;
+
+ res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+ if (!res) {
+ dprintk(VIDC_ERR, "Failed to get IORESOURCE_MEM\n");
+ rc = -ENODEV;
+ goto err_core_init;
+ }
+ device->register_base = res->start;
+ device->register_size = resource_size(res);
+
+ res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
+ if (!res) {
+ dprintk(VIDC_ERR, "Failed to get IORESOURCE_IRQ\n");
+ rc = -ENODEV;
+ goto err_core_init;
+ }
+ device->irq = res->start;
+
+ rc = venus_hfi_check_core_registered(hal_ctxt, device->base_addr,
+ device->register_base, device->register_size,
+ device->irq);
+ if (!rc) {
+ dprintk(VIDC_ERR, "Core present/Already added");
+ rc = -EEXIST;
+ goto err_core_init;
+ }
+
+ dprintk(VIDC_DBG, "HAL_DATA will be assigned now");
+ hal = (struct hal_data *)
+ kzalloc(sizeof(struct hal_data), GFP_KERNEL);
+ if (!hal) {
+ dprintk(VIDC_ERR, "Failed to alloc");
+ rc = -ENOMEM;
+ goto err_core_init;
+ }
+ hal->irq = device->irq;
+ hal->device_base_addr = device->base_addr;
+ hal->register_base_addr =
+ ioremap_nocache(device->register_base, device->register_size);
+ if (!hal->register_base_addr) {
+ dprintk(VIDC_ERR,
+ "could not map reg addr %d of size %d",
+ device->register_base, device->register_size);
+ goto error_irq_fail;
+ }
+
+ device->hal_data = hal;
+ rc = request_irq(device->irq, venus_hfi_isr, IRQF_TRIGGER_HIGH,
+ "msm_vidc", device);
+ if (unlikely(rc)) {
+ dprintk(VIDC_ERR, "() :request_irq failed\n");
+ goto error_irq_fail;
+ }
+ disable_irq_nosync(device->irq);
+ return rc;
+
+error_irq_fail:
+ kfree(hal);
+err_core_init:
+ return rc;
+
+}
+
+static size_t read_u32_array(struct platform_device *pdev,
+ char *name, u32 *arr, size_t size)
+{
+ int len;
+ size_t sz = 0;
+ struct device_node *np = pdev->dev.of_node;
+ if (!of_get_property(np, name, &len)) {
+ dprintk(VIDC_ERR, "Failed to read %s from device tree\n",
+ name);
+ goto fail_read;
+ }
+ sz = len / sizeof(u32);
+ if (sz <= 0) {
+ dprintk(VIDC_ERR, "%s not specified in device tree\n",
+ name);
+ goto fail_read;
+ }
+ if (sz > size) {
+ dprintk(VIDC_ERR, "Not enough memory to store %s values\n",
+ name);
+ goto fail_read;
+ }
+ if (of_property_read_u32_array(np, name, arr, sz)) {
+ dprintk(VIDC_ERR,
+ "error while reading %s from device tree\n",
+ name);
+ goto fail_read;
+ }
+ return sz;
+fail_read:
+ sz = 0;
+ return sz;
+}
+
+static inline int venus_hfi_init_clocks(struct platform_device *pdev,
+ struct venus_hfi_device *device)
+{
+ struct venus_core_clock *cl;
+ int i;
+ int rc = 0;
+ struct venus_core_clock *clock;
+ if (!device) {
+ dprintk(VIDC_ERR, "Invalid params: %p\n", device);
+ return -EINVAL;
+ }
+ clock = device->resources.clock;
+ strlcpy(clock[VCODEC_CLK].name, "core_clk",
+ sizeof(clock[VCODEC_CLK].name));
+ strlcpy(clock[VCODEC_AHB_CLK].name, "iface_clk",
+ sizeof(clock[VCODEC_AHB_CLK].name));
+ strlcpy(clock[VCODEC_AXI_CLK].name, "bus_clk",
+ sizeof(clock[VCODEC_AXI_CLK].name));
+ strlcpy(clock[VCODEC_OCMEM_CLK].name, "mem_clk",
+ sizeof(clock[VCODEC_OCMEM_CLK].name));
+
+ clock[VCODEC_CLK].count = read_u32_array(pdev,
+ "load-freq-tbl", (u32 *)clock[VCODEC_CLK].load_freq_tbl,
+ (sizeof(clock[VCODEC_CLK].load_freq_tbl)/sizeof(u32)));
+ clock[VCODEC_CLK].count /= 2;
+ dprintk(VIDC_DBG, "count = %d\n", clock[VCODEC_CLK].count);
+ if (!clock[VCODEC_CLK].count) {
+ dprintk(VIDC_ERR, "Failed to read clock frequency\n");
+ goto fail_init_clocks;
+ }
+ for (i = 0; i < clock[VCODEC_CLK].count; i++) {
+ dprintk(VIDC_DBG,
+ "load = %d, freq = %d\n",
+ clock[VCODEC_CLK].load_freq_tbl[i].load,
+ clock[VCODEC_CLK].load_freq_tbl[i].freq
+ );
+ }
+
+ for (i = 0; i < VCODEC_MAX_CLKS; i++) {
+ cl = &device->resources.clock[i];
+ if (!cl->clk) {
+ cl->clk = devm_clk_get(&pdev->dev, cl->name);
+ if (IS_ERR_OR_NULL(cl->clk)) {
+ dprintk(VIDC_ERR,
+ "Failed to get clock: %s\n", cl->name);
+ rc = PTR_ERR(cl->clk);
+ break;
+ }
+ }
+ }
+
+ if (i < VCODEC_MAX_CLKS) {
+ for (--i; i >= 0; i--) {
+ cl = &device->resources.clock[i];
+ clk_put(cl->clk);
+ }
+ }
+fail_init_clocks:
+ return rc;
+}
+
+static inline void venus_hfi_deinit_clocks(struct venus_hfi_device *device)
+{
+ int i;
+ if (!device) {
+ dprintk(VIDC_ERR, "Invalid args\n");
+ return;
+ }
+ for (i = 0; i < VCODEC_MAX_CLKS; i++)
+ clk_put(device->resources.clock[i].clk);
+}
+
+static unsigned long venus_hfi_get_clock_rate(struct venus_core_clock *clock,
+ int num_mbs_per_sec)
+{
+ int num_rows = clock->count;
+ struct load_freq_table *table = clock->load_freq_tbl;
+ unsigned long ret = table[num_rows-1].freq;
+ int i;
+ for (i = 0; i < num_rows; i++) {
+ if (num_mbs_per_sec > table[i].load)
+ break;
+ ret = table[i].freq;
+ }
+ dprintk(VIDC_DBG, "Required clock rate = %lu\n", ret);
+ return ret;
+}
+
+int venus_hfi_scale_clocks(struct venus_hfi_device *device, int load)
+{
+ int rc = 0;
+ if (!device) {
+ dprintk(VIDC_ERR, "Invalid args: %p\n", device);
+ return -EINVAL;
+ }
+
+ rc = clk_set_rate(device->resources.clock[VCODEC_CLK].clk,
+ venus_hfi_get_clock_rate(&device->resources.clock[VCODEC_CLK],
+ load));
+ if (rc)
+ dprintk(VIDC_ERR, "Failed to set clock rate: %d\n", rc);
+ return rc;
+}
+
+static inline int venus_hfi_enable_clks(struct venus_hfi_device *device)
+{
+ int i;
+ struct venus_core_clock *cl;
+ int rc = 0;
+ if (!device) {
+ dprintk(VIDC_ERR, "Invalid params: %p\n", device);
+ return -EINVAL;
+ }
+ for (i = 0; i < VCODEC_MAX_CLKS; i++) {
+ cl = &device->resources.clock[i];
+ rc = clk_prepare_enable(cl->clk);
+ if (rc) {
+ dprintk(VIDC_ERR, "Failed to enable clocks\n");
+ goto fail_clk_enable;
+ } else {
+ dprintk(VIDC_DBG, "Clock: %s enabled\n", cl->name);
+ }
+ }
+ return rc;
+fail_clk_enable:
+ for (; i >= 0; i--) {
+ cl = &device->resources.clock[i];
+ clk_disable_unprepare(cl->clk);
+ }
+ return rc;
+}
+
+static inline void venus_hfi_disable_clks(struct venus_hfi_device *device)
+{
+ int i;
+ struct venus_core_clock *cl;
+ if (!device) {
+ dprintk(VIDC_ERR, "Invalid params: %p\n", device);
+ return;
+ }
+ for (i = 0; i < VCODEC_MAX_CLKS; i++) {
+ cl = &device->resources.clock[i];
+ clk_disable_unprepare(cl->clk);
+ }
+}
+
+static int venus_hfi_register_iommu_domains(struct venus_hfi_device *device,
+ struct platform_device *pdev)
+{
+ size_t len;
+ struct msm_iova_partition partition[2];
+ struct msm_iova_layout layout;
+ int rc = 0;
+ int i;
+ struct msm_vidc_iommu_info *io_map;
+
+ if (!device)
+ return -EINVAL;
+
+ io_map = device->resources.io_map;
+
+ strlcpy(io_map[CP_MAP].name, "vidc-cp-map",
+ sizeof(io_map[CP_MAP].name));
+ strlcpy(io_map[CP_MAP].ctx, "venus_cp",
+ sizeof(io_map[CP_MAP].ctx));
+ strlcpy(io_map[NS_MAP].name, "vidc-ns-map",
+ sizeof(io_map[NS_MAP].name));
+ strlcpy(io_map[NS_MAP].ctx, "venus_ns",
+ sizeof(io_map[NS_MAP].ctx));
+
+ for (i = 0; i < MAX_MAP; i++) {
+ len = read_u32_array(pdev, io_map[i].name,
+ io_map[i].addr_range,
+ (sizeof(io_map[i].addr_range)/sizeof(u32)));
+ if (!len) {
+ dprintk(VIDC_ERR,
+ "Error in reading cp address range\n");
+ rc = -EINVAL;
+ break;
+ }
+ partition[0].start = io_map[i].addr_range[0];
+ if (i == NS_MAP) {
+ partition[0].size =
+ io_map[i].addr_range[1] - SHARED_QSIZE;
+ partition[1].start =
+ partition[0].start + io_map[i].addr_range[1]
+ - SHARED_QSIZE;
+ partition[1].size = SHARED_QSIZE;
+ layout.npartitions = 2;
+ layout.is_secure = 0;
+ } else {
+ partition[0].size = io_map[i].addr_range[1];
+ layout.npartitions = 1;
+ layout.is_secure = 1;
+ }
+ layout.partitions = &partition[0];
+ layout.client_name = io_map[i].name;
+ layout.domain_flags = 0;
+ dprintk(VIDC_DBG, "Registering domain 1 with: %lx, %lx, %s\n",
+ partition[0].start, partition[0].size,
+ layout.client_name);
+ dprintk(VIDC_DBG, "Registering domain 2 with: %lx, %lx, %s\n",
+ partition[1].start, partition[1].size,
+ layout.client_name);
+ io_map[i].domain = msm_register_domain(&layout);
+ if (io_map[i].domain < 0) {
+ dprintk(VIDC_ERR, "Failed to register cp domain\n");
+ rc = -EINVAL;
+ break;
+ }
+ }
+ /* There is no api provided as msm_unregister_domain, so
+ * we are not able to unregister the previously
+ * registered domains if any domain registration fails.*/
+ BUG_ON(i < MAX_MAP);
+ return rc;
+}
+
+static void venus_hfi_deinit_bus(struct venus_hfi_device *device)
+{
+ struct venus_bus_info *bus_info;
+ int i = 0;
+
+ if (!device)
+ return;
+
+ bus_info = &device->resources.bus_info;
+
+ for (i = 0; i < MSM_VIDC_MAX_DEVICES; i++) {
+ if (bus_info->ddr_handle[i]) {
+ msm_bus_scale_unregister_client(
+ bus_info->ddr_handle[i]);
+ bus_info->ddr_handle[i] = 0;
+ }
+
+ if (bus_info->ocmem_handle[i]) {
+ msm_bus_scale_unregister_client(
+ bus_info->ocmem_handle[i]);
+ bus_info->ocmem_handle[i] = 0;
+ }
+ }
+}
+
+static int venus_hfi_init_bus(struct venus_hfi_device *device)
+{
+ struct venus_bus_info *bus_info;
+ int rc = 0;
+ if (!device)
+ return -EINVAL;
+
+ bus_info = &device->resources.bus_info;
+
+ bus_info->ddr_handle[MSM_VIDC_ENCODER] =
+ msm_bus_scale_register_client(&enc_ddr_bus_data);
+ if (!bus_info->ddr_handle[MSM_VIDC_ENCODER]) {
+ dprintk(VIDC_ERR, "Failed to register bus scale client\n");
+ goto err_init_bus;
+ }
+ bus_info->ddr_handle[MSM_VIDC_DECODER] =
+ msm_bus_scale_register_client(&dec_ddr_bus_data);
+ if (!bus_info->ddr_handle[MSM_VIDC_DECODER]) {
+ dprintk(VIDC_ERR, "Failed to register bus scale client\n");
+ goto err_init_bus;
+ }
+ bus_info->ocmem_handle[MSM_VIDC_ENCODER] =
+ msm_bus_scale_register_client(&enc_ocmem_bus_data);
+ if (!bus_info->ocmem_handle[MSM_VIDC_ENCODER]) {
+ dprintk(VIDC_ERR, "Failed to register bus scale client\n");
+ goto err_init_bus;
+ }
+ bus_info->ocmem_handle[MSM_VIDC_DECODER] =
+ msm_bus_scale_register_client(&dec_ocmem_bus_data);
+ if (!bus_info->ocmem_handle[MSM_VIDC_DECODER]) {
+ dprintk(VIDC_ERR, "Failed to register bus scale client\n");
+ goto err_init_bus;
+ }
+ return rc;
+err_init_bus:
+ venus_hfi_deinit_bus(device);
+ return -EINVAL;
+}
+
+
+static const u32 venus_hfi_bus_table[] = {
+ 36000,
+ 110400,
+ 244800,
+ 489000,
+ 783360,
+ 979200,
+};
+
+static int venus_hfi_get_bus_vector(int load)
+{
+ int num_rows = sizeof(venus_hfi_bus_table)/(sizeof(u32));
+ int i;
+ for (i = 0; i < num_rows; i++) {
+ if (load <= venus_hfi_bus_table[i])
+ break;
+ }
+ i++;
+ dprintk(VIDC_DBG, "Required bus = %d\n", i);
+ return i;
+}
+
+int venus_hfi_scale_bus(struct venus_hfi_device *device, int load,
+ enum session_type type, enum mem_type mtype)
+{
+ int rc = 0;
+ u32 handle = 0;
+
+ if (mtype & DDR_MEM)
+ handle = device->resources.bus_info.ddr_handle[type];
+ if (mtype & OCMEM_MEM)
+ handle = device->resources.bus_info.ocmem_handle[type];
+
+ if (handle) {
+ rc = msm_bus_scale_client_update_request(
+ handle, venus_hfi_get_bus_vector(load));
+ if (rc)
+ dprintk(VIDC_ERR, "Failed to scale bus: %d\n", rc);
+ } else {
+ dprintk(VIDC_ERR, "Failed to scale bus, mtype: %d\n",
+ mtype);
+ rc = -EINVAL;
+ }
+
+ return rc;
+}
+
+static void venus_hfi_ocmem_init(struct venus_hfi_device *device)
+{
+ struct on_chip_mem *ocmem;
+
+ ocmem = &device->resources.ocmem;
+ ocmem->vidc_ocmem_nb.notifier_call = msm_vidc_ocmem_notify_handler;
+ ocmem->handle =
+ ocmem_notifier_register(OCMEM_VIDEO, &ocmem->vidc_ocmem_nb);
+ if (!ocmem->handle) {
+ dprintk(VIDC_WARN, "Failed to register OCMEM notifier.");
+ dprintk(VIDC_INFO, " Performance will be impacted\n");
+ }
+}
+
+int venus_hfi_set_ocmem(struct venus_hfi_device *device,
+ struct ocmem_buf *ocmem)
+{
+ struct vidc_resource_hdr rhdr;
+ int rc = 0;
+ if (!device || !ocmem) {
+ dprintk(VIDC_ERR, "Invalid params, core:%p, ocmem: %p\n",
+ device, ocmem);
+ return -EINVAL;
+ }
+ rhdr.resource_id = VIDC_RESOURCE_OCMEM;
+ rhdr.resource_handle = (u32) &device->resources.ocmem;
+ rhdr.size = ocmem->len;
+ rc = venus_hfi_core_set_resource(device, &rhdr, ocmem);
+ if (rc) {
+ dprintk(VIDC_ERR, "Failed to set OCMEM on driver\n");
+ goto ocmem_set_failed;
+ }
+ dprintk(VIDC_DBG, "OCMEM set, addr = %lx, size: %ld\n",
+ ocmem->addr, ocmem->len);
+ocmem_set_failed:
+ return rc;
+}
+
+int venus_hfi_unset_ocmem(struct venus_hfi_device *device)
+{
+ struct vidc_resource_hdr rhdr;
+ int rc = 0;
+ if (!device || !device->resources.ocmem.buf) {
+ dprintk(VIDC_ERR, "Invalid params, device:%p\n", device);
+ return -EINVAL;
+ }
+ rhdr.resource_id = VIDC_RESOURCE_OCMEM;
+ rhdr.resource_handle = (u32) &device->resources.ocmem;
+ rc = venus_hfi_core_release_resource(device, &rhdr);
+ if (rc)
+ dprintk(VIDC_ERR, "Failed to set OCMEM on driver\n");
+
+ return rc;
+}
+
+int venus_hfi_alloc_ocmem(struct venus_hfi_device *device,
+ unsigned long size)
+{
+ int rc = 0;
+ struct ocmem_buf *ocmem_buffer;
+
+ if (!device || !size) {
+ dprintk(VIDC_ERR,
+ "Invalid param, core: %p, size: %lu\n", device, size);
+ return -EINVAL;
+ }
+ ocmem_buffer = device->resources.ocmem.buf;
+ if (!ocmem_buffer ||
+ ocmem_buffer->len < size) {
+ ocmem_buffer = ocmem_allocate_nb(OCMEM_VIDEO, size);
+ if (IS_ERR_OR_NULL(ocmem_buffer)) {
+ dprintk(VIDC_ERR,
+ "ocmem_allocate_nb failed: %d\n",
+ (u32) ocmem_buffer);
+ rc = -ENOMEM;
+ }
+ device->resources.ocmem.buf = ocmem_buffer;
+ rc = venus_hfi_set_ocmem(device, ocmem_buffer);
+ if (rc) {
+ dprintk(VIDC_ERR, "Failed to set ocmem: %d\n", rc);
+ goto ocmem_set_failed;
+ }
+ } else
+ dprintk(VIDC_DBG,
+ "OCMEM is enough. reqd: %lu, available: %lu\n",
+ size, ocmem_buffer->len);
+
+ocmem_set_failed:
+ return rc;
+}
+
+int venus_hfi_free_ocmem(struct venus_hfi_device *device)
+{
+ int rc = 0;
+
+ if (device->resources.ocmem.buf) {
+ rc = ocmem_free(OCMEM_VIDEO, device->resources.ocmem.buf);
+ if (rc)
+ dprintk(VIDC_ERR, "Failed to free ocmem\n");
+ }
+ device->resources.ocmem.buf = NULL;
+ return rc;
+}
+
+int venus_hfi_is_ocmem_present(struct venus_hfi_device *device)
+{
+ return device->resources.ocmem.buf ? 1 : 0;
+}
+
+static void venus_hfi_deinit_ocmem(struct venus_hfi_device *device)
+{
+ if (device->resources.ocmem.handle)
+ ocmem_notifier_unregister(device->resources.ocmem.handle,
+ &device->resources.ocmem.vidc_ocmem_nb);
+}
+
+static int venus_hfi_init_resources(struct venus_hfi_device *device,
+ struct platform_device *pdev)
+{
+ int rc = 0;
+
+ rc = venus_hfi_init_clocks(pdev, device);
+ if (rc) {
+ dprintk(VIDC_ERR, "Failed to init clocks\n");
+ rc = -ENODEV;
+ goto err_init_clocks;
+ }
+
+ rc = venus_hfi_init_bus(device);
+ if (rc) {
+ dprintk(VIDC_ERR, "Failed to init bus: %d\n", rc);
+ goto err_init_bus;
+ }
+
+ rc = venus_hfi_register_iommu_domains(device, pdev);
+ if (rc) {
+ dprintk(VIDC_ERR, "Failed to register iommu domains: %d\n", rc);
+ goto err_register_iommu_domain;
+ }
+
+ venus_hfi_ocmem_init(device);
+ return rc;
+
+err_register_iommu_domain:
+ venus_hfi_deinit_bus(device);
+err_init_bus:
+ venus_hfi_deinit_clocks(device);
+err_init_clocks:
+ return rc;
+}
+
+static void venus_hfi_deinit_resources(struct venus_hfi_device *device)
+{
+ venus_hfi_deinit_ocmem(device);
+ venus_hfi_deinit_bus(device);
+ venus_hfi_deinit_clocks(device);
+}
+
+static int venus_hfi_iommu_attach(struct venus_hfi_device *device)
+{
+ int rc;
+ struct iommu_domain *domain;
+ int i;
+ struct msm_vidc_iommu_info *io_map;
+ struct device *dev;
+
+ if (!device)
+ return -EINVAL;
+
+ for (i = 0; i < MAX_MAP; i++) {
+ io_map = &device->resources.io_map[i];
+ dev = msm_iommu_get_ctx(io_map->ctx);
+ domain = msm_get_iommu_domain(io_map->domain);
+ if (IS_ERR_OR_NULL(domain)) {
+ dprintk(VIDC_ERR,
+ "Failed to get domain: %s\n", io_map->name);
+ rc = PTR_ERR(domain);
+ break;
+ }
+ rc = iommu_attach_device(domain, dev);
+ if (rc) {
+ dprintk(VIDC_ERR,
+ "IOMMU attach failed: %s\n", io_map->name);
+ break;
+ }
+ }
+ if (i < MAX_MAP) {
+ i--;
+ for (; i >= 0; i--) {
+ io_map = &device->resources.io_map[i];
+ dev = msm_iommu_get_ctx(io_map->ctx);
+ domain = msm_get_iommu_domain(io_map->domain);
+ if (dev && domain)
+ iommu_detach_device(domain, dev);
+ }
+ }
+ return rc;
+}
+
+static void venus_hfi_iommu_detach(struct venus_hfi_device *device)
+{
+ struct device *dev;
+ struct iommu_domain *domain;
+ struct msm_vidc_iommu_info *io_map;
+ int i;
+
+ if (!device) {
+ dprintk(VIDC_ERR, "Invalid paramter: %p\n", device);
+ return;
+ }
+
+ for (i = 0; i < MAX_MAP; i++) {
+ io_map = &device->resources.io_map[i];
+ dev = msm_iommu_get_ctx(io_map->ctx);
+ domain = msm_get_iommu_domain(io_map->domain);
+ if (dev && domain)
+ iommu_detach_device(domain, dev);
+ }
+}
+
+int venus_hfi_get_domain(struct venus_hfi_device *device,
+ enum msm_vidc_io_maps iomap)
+{
+ if (!device || iomap < CP_MAP || iomap >= MAX_MAP) {
+ dprintk(VIDC_ERR, "%s: Invalid parameter: %p iomap: %d\n",
+ __func__, device, iomap);
+ return -EINVAL;
+ }
+ return device->resources.io_map[iomap].domain;
+}
+
+int venus_hfi_iommu_get_map(struct venus_hfi_device *device,
+ struct msm_vidc_iommu_info maps[MAX_MAP])
+{
+ int i = 0;
+
+ if (!device || !maps) {
+ dprintk(VIDC_ERR, "%s: Invalid param device: %p maps: %p\n",
+ __func__, device, maps);
+ return -EINVAL;
+ }
+
+ for (i = 0; i < MAX_MAP; i++)
+ maps[i] = device->resources.io_map[i];
+
+ return 0;
+}
+
+static int protect_cp_mem(struct venus_hfi_device *device)
+{
+ struct tzbsp_memprot memprot;
+ unsigned int resp = 0;
+ int rc = 0;
+ struct msm_vidc_iommu_info *io_map;
+
+ if (!device)
+ return -EINVAL;
+
+ io_map = device->resources.io_map;
+ if (!io_map) {
+ dprintk(VIDC_ERR, "invalid params: %p\n", io_map);
+ return -EINVAL;
+ }
+ memprot.cp_start = 0x0;
+ memprot.cp_size = io_map[CP_MAP].addr_range[0] +
+ io_map[CP_MAP].addr_range[1];
+ memprot.cp_nonpixel_start = 0;
+ memprot.cp_nonpixel_size = 0;
+
+ rc = scm_call(SCM_SVC_CP, TZBSP_MEM_PROTECT_VIDEO_VAR, &memprot,
+ sizeof(memprot), &resp, sizeof(resp));
+ if (rc)
+ dprintk(VIDC_ERR,
+ "Failed to protect memory , rc is :%d, response : %d\n",
+ rc, resp);
+ return rc;
+}
+
+int venus_hfi_load_fw(struct venus_hfi_device *device)
+{
+ int rc = 0;
+
+ if (!device) {
+ dprintk(VIDC_ERR, "Invalid paramter: %p\n", device);
+ return -EINVAL;
+ }
+
+ if (!device->resources.fw.cookie)
+ device->resources.fw.cookie = subsystem_get("venus");
+
+ if (IS_ERR_OR_NULL(device->resources.fw.cookie)) {
+ dprintk(VIDC_ERR, "Failed to download firmware\n");
+ rc = -ENOMEM;
+ goto fail_load_fw;
+ }
+ /*Clocks can be enabled only after pil_get since
+ * gdsc is turned-on in pil_get*/
+ rc = venus_hfi_enable_clks(device);
+ if (rc) {
+ dprintk(VIDC_ERR, "Failed to enable clocks: %d\n", rc);
+ goto fail_enable_clks;
+ }
+
+ rc = protect_cp_mem(device);
+ if (rc) {
+ dprintk(VIDC_ERR, "Failed to protect memory\n");
+ goto fail_iommu_attach;
+ }
+
+ rc = venus_hfi_iommu_attach(device);
+ if (rc) {
+ dprintk(VIDC_ERR, "Failed to attach iommu");
+ goto fail_iommu_attach;
+ }
+ return rc;
+fail_iommu_attach:
+ venus_hfi_disable_clks(device);
+fail_enable_clks:
+ subsystem_put(device->resources.fw.cookie);
+ device->resources.fw.cookie = NULL;
+fail_load_fw:
+ return rc;
+}
+
+void venus_hfi_unload_fw(struct venus_hfi_device *device)
+{
+ if (!device) {
+ dprintk(VIDC_ERR, "Invalid paramter: %p\n", device);
+ return;
+ }
+ if (device->resources.fw.cookie) {
+ venus_hfi_iommu_detach(device);
+ venus_hfi_disable_clks(device);
+ subsystem_put(device->resources.fw.cookie);
+ device->resources.fw.cookie = NULL;
+ }
+}
+
+static void *venus_hfi_add_device(u32 device_id, struct platform_device *pdev,
+ void (*callback) (enum command_response cmd, void *data))
+{
+ struct venus_hfi_device *hdevice = NULL;
+ int rc = 0;
+
+ if (device_id || !pdev || !callback) {
dprintk(VIDC_ERR, "Invalid Paramters");
return NULL;
- } else {
- dprintk(VIDC_INFO, "entered , device_id: %d", device_id);
}
- if (vidc_hal_check_core_registered(hal_ctxt, fw_base_addr,
- reg_base, reg_size, irq)) {
- dprintk(VIDC_DBG, "HAL_DATA will be assigned now");
- hal = (struct hal_data *)
- kzalloc(sizeof(struct hal_data), GFP_KERNEL);
- if (!hal) {
- dprintk(VIDC_ERR, "Failed to alloc");
- return NULL;
- }
- hal->irq = irq;
- hal->device_base_addr = fw_base_addr;
- hal->register_base_addr =
- ioremap_nocache(reg_base, reg_size);
- if (!hal->register_base_addr) {
- dprintk(VIDC_ERR,
- "could not map reg addr %d of size %d",
- reg_base, reg_size);
- goto err_map;
- }
- INIT_LIST_HEAD(&hal_ctxt.dev_head);
- } else {
- dprintk(VIDC_ERR, "Core present/Already added");
- return NULL;
- }
+ dprintk(VIDC_INFO, "entered , device_id: %d", device_id);
- hdevice = (struct hal_device *)
- kzalloc(sizeof(struct hal_device), GFP_KERNEL);
+ hdevice = (struct venus_hfi_device *)
+ kzalloc(sizeof(struct venus_hfi_device), GFP_KERNEL);
if (!hdevice) {
dprintk(VIDC_ERR, "failed to allocate new device");
- goto err_map;
+ goto err_alloc;
}
+ rc = venus_hfi_init_regs_and_interrupts(hdevice, pdev);
+ if (rc)
+ goto err_init_regs;
+
+ INIT_LIST_HEAD(&hal_ctxt.dev_head);
INIT_LIST_HEAD(&hdevice->list);
list_add_tail(&hdevice->list, &hal_ctxt.dev_head);
hal_ctxt.dev_count++;
hdevice->device_id = device_id;
- hdevice->hal_data = hal;
+
hdevice->callback = callback;
hdevice->vidc_workq = create_singlethread_workqueue(
@@ -1596,30 +2776,53 @@
goto error_createq;
}
- rc = request_irq(irq, vidc_hal_isr, IRQF_TRIGGER_HIGH,
- "msm_vidc", hdevice);
- if (unlikely(rc)) {
- dprintk(VIDC_ERR, "() :request_irq failed\n");
- goto error_irq_fail;
- }
- disable_irq_nosync(irq);
return (void *) hdevice;
-error_irq_fail:
- destroy_workqueue(hdevice->vidc_workq);
error_createq:
hal_ctxt.dev_count--;
list_del(&hal_ctxt.dev_head);
-err_map:
- kfree(hal);
+err_init_regs:
+ kfree(hdevice);
+err_alloc:
return NULL;
}
-void vidc_hal_delete_device(void *device)
+void *venus_hfi_get_device(u32 device_id,
+ struct platform_device *pdev,
+ void (*callback) (enum command_response cmd, void *data))
{
- struct hal_device *close, *dev;
+ struct venus_hfi_device *device;
+ int rc = 0;
+
+ if (!pdev || !callback) {
+ dprintk(VIDC_ERR, "Invalid params: %p %p\n", pdev, callback);
+ return NULL;
+ }
+
+ device = venus_hfi_add_device(device_id, pdev, &handle_cmd_response);
+ if (!device) {
+ dprintk(VIDC_ERR, "Failed to create HFI device\n");
+ return NULL;
+ }
+
+ rc = venus_hfi_init_resources(device, pdev);
+ if (rc) {
+ dprintk(VIDC_ERR, "Failed to init resources: %d\n", rc);
+ goto err_fail_init_res;
+ }
+ return device;
+
+err_fail_init_res:
+ venus_hfi_delete_device(device);
+ return NULL;
+}
+
+void venus_hfi_delete_device(void *device)
+{
+ struct venus_hfi_device *close, *dev;
if (device) {
- dev = (struct hal_device *) device;
+ venus_hfi_deinit_resources(device);
+ dev = (struct venus_hfi_device *) device;
list_for_each_entry(close, &hal_ctxt.dev_head, list) {
if (close->hal_data->irq == dev->hal_data->irq) {
hal_ctxt.dev_count--;
diff --git a/drivers/media/video/msm_vidc/venus_hfi.h b/drivers/media/video/msm_vidc/venus_hfi.h
index 6b904fd..93b9ae3 100644
--- a/drivers/media/video/msm_vidc/venus_hfi.h
+++ b/drivers/media/video/msm_vidc/venus_hfi.h
@@ -14,8 +14,12 @@
#ifndef __H_VENUS_HFI_H__
#define __H_VENUS_HFI_H__
-#include <linux/spinlock.h>
+#include <linux/clk.h>
#include <linux/mutex.h>
+#include <linux/platform_device.h>
+#include <linux/spinlock.h>
+#include <mach/ocmem.h>
+#include <media/msm_vidc.h>
#include "vidc_hfi_api.h"
#include "msm_smem.h"
#include "vidc_hfi_helper.h"
@@ -45,6 +49,8 @@
#define VIDC_IFACE_MAX_PARALLEL_CLNTS 16
#define VIDC_IFACEQ_DFLT_QHDR 0x01010000
+#define VIDC_MAX_NAME_LENGTH 64
+
struct hfi_queue_table_header {
u32 qtbl_version;
u32 qtbl_size;
@@ -907,7 +913,55 @@
u8 *register_base_addr;
};
-struct hal_device {
+enum vidc_clocks {
+ VCODEC_CLK,
+ VCODEC_AHB_CLK,
+ VCODEC_AXI_CLK,
+ VCODEC_OCMEM_CLK,
+ VCODEC_MAX_CLKS
+};
+
+enum mem_type {
+ DDR_MEM = 0x1,
+ OCMEM_MEM = 0x2,
+};
+
+struct load_freq_table {
+ u32 load;
+ u32 freq;
+};
+
+struct msm_vidc_fw {
+ void *cookie;
+};
+
+struct venus_core_clock {
+ char name[VIDC_MAX_NAME_LENGTH];
+ struct clk *clk;
+ u32 count;
+ struct load_freq_table load_freq_tbl[8];
+};
+
+struct venus_bus_info {
+ u32 ddr_handle[MSM_VIDC_MAX_DEVICES];
+ u32 ocmem_handle[MSM_VIDC_MAX_DEVICES];
+};
+
+struct on_chip_mem {
+ struct ocmem_buf *buf;
+ struct notifier_block vidc_ocmem_nb;
+ void *handle;
+};
+
+struct venus_resources {
+ struct msm_vidc_fw fw;
+ struct msm_vidc_iommu_info io_map[MAX_MAP];
+ struct venus_core_clock clock[VCODEC_MAX_CLKS];
+ struct venus_bus_info bus_info;
+ struct on_chip_mem ocmem;
+};
+
+struct venus_hfi_device {
struct list_head list;
struct list_head sess_head;
u32 intr_status;
@@ -925,13 +979,18 @@
struct workqueue_struct *vidc_workq;
int spur_count;
int reg_count;
+ u32 base_addr;
+ u32 register_base;
+ u32 register_size;
+ u32 irq;
+ struct venus_resources resources;
};
struct hal_session {
struct list_head list;
u32 session_id;
u32 is_decoder;
- struct hal_device *device;
+ struct venus_hfi_device *device;
};
struct hal_device_data {
@@ -941,10 +1000,35 @@
extern struct hal_device_data hal_ctxt;
-int vidc_hal_iface_msgq_read(struct hal_device *device, void *pkt);
-int vidc_hal_iface_dbgq_read(struct hal_device *device, void *pkt);
+int venus_hfi_iface_msgq_read(struct venus_hfi_device *device, void *pkt);
+int venus_hfi_iface_dbgq_read(struct venus_hfi_device *device, void *pkt);
/* Interrupt Processing:*/
-void vidc_hal_response_handler(struct hal_device *device);
+void hfi_response_handler(struct venus_hfi_device *device);
+
+void venus_hfi_delete_device(void *device);
+
+int venus_hfi_scale_clocks(struct venus_hfi_device *device, int load);
+
+void *venus_hfi_get_device(u32 device_id,
+ struct platform_device *pdev,
+ void (*callback) (enum command_response cmd, void *data));
+
+int venus_hfi_scale_bus(struct venus_hfi_device *device, int load,
+ enum session_type type, enum mem_type mtype);
+int venus_hfi_set_ocmem(struct venus_hfi_device *device,
+ struct ocmem_buf *ocmem);
+int venus_hfi_unset_ocmem(struct venus_hfi_device *device);
+int venus_hfi_alloc_ocmem(struct venus_hfi_device *device,
+ unsigned long size);
+int venus_hfi_free_ocmem(struct venus_hfi_device *device);
+int venus_hfi_is_ocmem_present(struct venus_hfi_device *device);
+
+int venus_hfi_get_domain(struct venus_hfi_device *device,
+ enum msm_vidc_io_maps iomap);
+int venus_hfi_iommu_get_map(struct venus_hfi_device *device,
+ struct msm_vidc_iommu_info maps[MAX_MAP]);
+int venus_hfi_load_fw(struct venus_hfi_device *device);
+void venus_hfi_unload_fw(struct venus_hfi_device *device);
#endif
diff --git a/drivers/media/video/msm_vidc/vidc_hfi_api.h b/drivers/media/video/msm_vidc/vidc_hfi_api.h
index 02f474c..79fee90 100644
--- a/drivers/media/video/msm_vidc/vidc_hfi_api.h
+++ b/drivers/media/video/msm_vidc/vidc_hfi_api.h
@@ -980,47 +980,43 @@
};
/* VIDC_HAL CORE API's */
-int vidc_hal_core_init(void *device, int domain);
-int vidc_hal_core_release(void *device);
-int vidc_hal_core_pc_prep(void *device);
-int vidc_hal_core_set_resource(void *device,
+int venus_hfi_core_init(void *device);
+int venus_hfi_core_release(void *device);
+int venus_hfi_core_pc_prep(void *device);
+int venus_hfi_core_set_resource(void *device,
struct vidc_resource_hdr *resource_hdr, void *resource_value);
-int vidc_hal_core_release_resource(void *device,
+int venus_hfi_core_release_resource(void *device,
struct vidc_resource_hdr *resource_hdr);
-int vidc_hal_core_ping(void *device);
+int venus_hfi_core_ping(void *device);
/* VIDC_HAL SESSION API's */
-void *vidc_hal_session_init(void *device, u32 session_id,
+void *venus_hfi_session_init(void *device, u32 session_id,
enum hal_domain session_type, enum hal_video_codec codec_type);
-int vidc_hal_session_end(void *session);
-int vidc_hal_session_abort(void *session);
-int vidc_hal_session_set_buffers(void *sess,
+int venus_hfi_session_end(void *session);
+int venus_hfi_session_abort(void *session);
+int venus_hfi_session_set_buffers(void *sess,
struct vidc_buffer_addr_info *buffer_info);
-int vidc_hal_session_release_buffers(void *sess,
+int venus_hfi_session_release_buffers(void *sess,
struct vidc_buffer_addr_info *buffer_info);
-int vidc_hal_session_load_res(void *sess);
-int vidc_hal_session_release_res(void *sess);
-int vidc_hal_session_start(void *sess);
-int vidc_hal_session_stop(void *sess);
-int vidc_hal_session_suspend(void *sess);
-int vidc_hal_session_resume(void *sess);
-int vidc_hal_session_etb(void *sess,
+int venus_hfi_session_load_res(void *sess);
+int venus_hfi_session_release_res(void *sess);
+int venus_hfi_session_start(void *sess);
+int venus_hfi_session_stop(void *sess);
+int venus_hfi_session_suspend(void *sess);
+int venus_hfi_session_resume(void *sess);
+int venus_hfi_session_etb(void *sess,
struct vidc_frame_data *input_frame);
-int vidc_hal_session_ftb(void *sess,
+int venus_hfi_session_ftb(void *sess,
struct vidc_frame_data *output_frame);
-int vidc_hal_session_parse_seq_hdr(void *sess,
+int venus_hfi_session_parse_seq_hdr(void *sess,
struct vidc_seq_hdr *seq_hdr);
-int vidc_hal_session_get_seq_hdr(void *sess,
+int venus_hfi_session_get_seq_hdr(void *sess,
struct vidc_seq_hdr *seq_hdr);
-int vidc_hal_session_get_buf_req(void *sess);
-int vidc_hal_session_flush(void *sess, enum hal_flush flush_mode);
-int vidc_hal_session_set_property(void *sess, enum hal_property ptype,
+int venus_hfi_session_get_buf_req(void *sess);
+int venus_hfi_session_flush(void *sess, enum hal_flush flush_mode);
+int venus_hfi_session_set_property(void *sess, enum hal_property ptype,
void *pdata);
-int vidc_hal_session_get_property(void *sess, enum hal_property ptype,
+int venus_hfi_session_get_property(void *sess, enum hal_property ptype,
void *pdata);
-void *vidc_hal_add_device(u32 device_id, u32 base_addr,
- u32 reg_base, u32 reg_size, u32 irq,
- void (*callback) (enum command_response cmd, void *data));
-void vidc_hal_delete_device(void *device);
#endif /*__VIDC_HFI_API_H__ */
diff --git a/drivers/mmc/host/msm_sdcc.c b/drivers/mmc/host/msm_sdcc.c
index 96f29e3..f1ba8ad 100644
--- a/drivers/mmc/host/msm_sdcc.c
+++ b/drivers/mmc/host/msm_sdcc.c
@@ -6206,6 +6206,11 @@
mmc_add_host(mmc);
+ mmc->clk_scaling.up_threshold = 35;
+ mmc->clk_scaling.down_threshold = 5;
+ mmc->clk_scaling.polling_delay_ms = 100;
+ mmc->caps2 |= MMC_CAP2_CLK_SCALE;
+
#ifdef CONFIG_HAS_EARLYSUSPEND
host->early_suspend.suspend = msmsdcc_early_suspend;
host->early_suspend.resume = msmsdcc_late_resume;
diff --git a/drivers/platform/msm/ipa/ipa.c b/drivers/platform/msm/ipa/ipa.c
index 288de52..d673e5a 100644
--- a/drivers/platform/msm/ipa/ipa.c
+++ b/drivers/platform/msm/ipa/ipa.c
@@ -929,23 +929,30 @@
static void ipa_set_aggregation_params(void)
{
struct ipa_ep_cfg_aggr agg_params;
+ struct ipa_ep_cfg_hdr hdr_params;
u32 producer_hdl = 0;
u32 consumer_hdl = 0;
rmnet_bridge_get_client_handles(&producer_hdl, &consumer_hdl);
+ /* configure aggregation on producer */
+ memset(&agg_params, 0, sizeof(struct ipa_ep_cfg_aggr));
+ agg_params.aggr_en = IPA_ENABLE_AGGR;
agg_params.aggr = ipa_ctx->aggregation_type;
agg_params.aggr_byte_limit = ipa_ctx->aggregation_byte_limit;
agg_params.aggr_time_limit = ipa_ctx->aggregation_time_limit;
-
- /* configure aggregation on producer */
- agg_params.aggr_en = IPA_ENABLE_AGGR;
ipa_cfg_ep_aggr(producer_hdl, &agg_params);
- /* configure deaggregation on consumer */
- agg_params.aggr_en = IPA_ENABLE_DEAGGR;
- ipa_cfg_ep_aggr(consumer_hdl, &agg_params);
+ /* configure header on producer */
+ memset(&hdr_params, 0, sizeof(struct ipa_ep_cfg_hdr));
+ hdr_params.hdr_len = 1;
+ ipa_cfg_ep_hdr(producer_hdl, &hdr_params);
+ /* configure deaggregation on consumer */
+ memset(&agg_params, 0, sizeof(struct ipa_ep_cfg_aggr));
+ agg_params.aggr_en = IPA_ENABLE_DEAGGR;
+ agg_params.aggr = ipa_ctx->aggregation_type;
+ ipa_cfg_ep_aggr(consumer_hdl, &agg_params);
}
/*
@@ -1340,6 +1347,22 @@
result = -ENODEV;
goto fail_init_hw;
}
+
+ /* setup chicken bits */
+ result = ipa_set_single_ndp_per_mbim(true);
+ if (result) {
+ IPAERR(":failed to set single ndp per mbim.\n");
+ result = -EFAULT;
+ goto fail_init_hw;
+ }
+
+ result = ipa_set_hw_timer_fix_for_mbim_aggr(true);
+ if (result) {
+ IPAERR(":failed to set HW timer fix for MBIM aggregation.\n");
+ result = -EFAULT;
+ goto fail_init_hw;
+ }
+
/* read how much SRAM is available for SW use */
ipa_ctx->smem_sz = ipa_read_reg(ipa_ctx->mmio,
IPA_SHARED_MEM_SIZE_OFST);
diff --git a/drivers/platform/msm/ipa/ipa_i.h b/drivers/platform/msm/ipa/ipa_i.h
index 3be2369..4172371 100644
--- a/drivers/platform/msm/ipa/ipa_i.h
+++ b/drivers/platform/msm/ipa/ipa_i.h
@@ -654,6 +654,8 @@
int ipa_generate_hdr_hw_tbl(struct ipa_mem_buffer *mem);
int ipa_generate_rt_hw_tbl(enum ipa_ip_type ip, struct ipa_mem_buffer *mem);
int ipa_generate_flt_hw_tbl(enum ipa_ip_type ip, struct ipa_mem_buffer *mem);
+int ipa_set_single_ndp_per_mbim(bool);
+int ipa_set_hw_timer_fix_for_mbim_aggr(bool);
void ipa_debugfs_init(void);
void ipa_debugfs_remove(void);
diff --git a/drivers/platform/msm/ipa/ipa_reg.h b/drivers/platform/msm/ipa/ipa_reg.h
index 61913b6..ca67e35 100644
--- a/drivers/platform/msm/ipa/ipa_reg.h
+++ b/drivers/platform/msm/ipa/ipa_reg.h
@@ -213,6 +213,8 @@
#define IPA_AGGREGATION_QCNCM_SIG_BMSK 0xff000000
#define IPA_AGGREGATION_SINGLE_NDP_MSK 0x1
#define IPA_AGGREGATION_SINGLE_NDP_BMSK 0xfffffffe
+#define IPA_AGGREGATION_HW_TIMER_FIX_MBIM_AGGR_SHFT 2
+#define IPA_AGGREGATION_HW_TIMER_FIX_MBIM_AGGR_BMSK 0x4
#define IPA_SRAM_DIRECT_ACCESS_n_OFST(n) (0x00004000 + 0x4 * (n))
#define IPA_SRAM_DIRECT_ACCESS_n_RMSK 0xffffffff
diff --git a/drivers/platform/msm/ipa/ipa_utils.c b/drivers/platform/msm/ipa/ipa_utils.c
index d5d5566..7cdde4a 100644
--- a/drivers/platform/msm/ipa/ipa_utils.c
+++ b/drivers/platform/msm/ipa/ipa_utils.c
@@ -1323,6 +1323,24 @@
EXPORT_SYMBOL(ipa_set_single_ndp_per_mbim);
/**
+ * ipa_set_hw_timer_fix_for_mbim_aggr() - Enable/disable HW timer fix
+ * for MBIM aggregation.
+ * @enable: [in] true for enable HW fix; false otherwise
+ *
+ * Returns: 0 on success
+ */
+int ipa_set_hw_timer_fix_for_mbim_aggr(bool enable)
+{
+ u32 reg_val;
+ reg_val = ipa_read_reg(ipa_ctx->mmio, IPA_AGGREGATION_SPARE_REG_1_OFST);
+ ipa_write_reg(ipa_ctx->mmio, IPA_AGGREGATION_SPARE_REG_1_OFST,
+ (enable << IPA_AGGREGATION_HW_TIMER_FIX_MBIM_AGGR_SHFT) |
+ (reg_val & ~IPA_AGGREGATION_HW_TIMER_FIX_MBIM_AGGR_BMSK));
+ return 0;
+}
+EXPORT_SYMBOL(ipa_set_hw_timer_fix_for_mbim_aggr);
+
+/**
* ipa_straddle_boundary() - Checks whether a memory buffer straddles a boundary
* @start: start address of the memory buffer
* @end: end address of the memory buffer
diff --git a/drivers/power/pm8921-bms.c b/drivers/power/pm8921-bms.c
index 070fb62..f6591c3d 100644
--- a/drivers/power/pm8921-bms.c
+++ b/drivers/power/pm8921-bms.c
@@ -134,6 +134,7 @@
int rconn_mohm;
struct mutex last_ocv_uv_mutex;
int last_ocv_uv;
+ int last_ocv_temp_decidegc;
int pon_ocv_uv;
int last_cc_uah;
unsigned long tm_sec;
@@ -730,7 +731,8 @@
#define CC_RAW_5MAH 0x00110000
#define MIN_OCV_UV 2000000
static int read_soc_params_raw(struct pm8921_bms_chip *chip,
- struct pm8921_soc_params *raw)
+ struct pm8921_soc_params *raw,
+ int batt_temp_decidegc)
{
int usb_chg;
int est_ocv_uv;
@@ -783,12 +785,14 @@
raw->cc = 0;
}
}
+ chip->last_ocv_temp_decidegc = batt_temp_decidegc;
pr_debug("PON_OCV_UV = %d\n", chip->last_ocv_uv);
} else if (chip->prev_last_good_ocv_raw != raw->last_good_ocv_raw) {
chip->prev_last_good_ocv_raw = raw->last_good_ocv_raw;
convert_vbatt_raw_to_uv(chip, usb_chg,
raw->last_good_ocv_raw, &raw->last_good_ocv_uv);
chip->last_ocv_uv = raw->last_good_ocv_uv;
+ chip->last_ocv_temp_decidegc = batt_temp_decidegc;
/* forget the old cc value upon ocv */
chip->last_cc_uah = 0;
} else {
@@ -806,6 +810,7 @@
*/
raw->last_good_ocv_uv = chip->max_voltage_uv;
chip->last_ocv_uv = chip->max_voltage_uv;
+ chip->last_ocv_temp_decidegc = batt_temp_decidegc;
}
pr_debug("0p625 = %duV\n", chip->xoadc_v0625);
pr_debug("1p25 = %duV\n", chip->xoadc_v125);
@@ -908,18 +913,19 @@
}
static int calculate_pc(struct pm8921_bms_chip *chip, int ocv_uv,
- int batt_temp, int chargecycles)
+ int batt_temp_decidegc, int chargecycles)
{
int pc, scalefactor;
pc = interpolate_pc(chip->pc_temp_ocv_lut,
- batt_temp / 10, ocv_uv / 1000);
+ batt_temp_decidegc / 10, ocv_uv / 1000);
pr_debug("pc = %u for ocv = %dmicroVolts batt_temp = %d\n",
- pc, ocv_uv, batt_temp);
+ pc, ocv_uv, batt_temp_decidegc);
scalefactor = interpolate_scalingfactor(chip->pc_sf_lut,
chargecycles, pc);
- pr_debug("scalefactor = %u batt_temp = %d\n", scalefactor, batt_temp);
+ pr_debug("scalefactor = %u batt_temp = %d\n",
+ scalefactor, batt_temp_decidegc);
/* Multiply the initial FCC value by the scale factor. */
pc = (pc * scalefactor) / 100;
@@ -1216,10 +1222,11 @@
int fcc_uah, int batt_temp,
int chargecycles)
{
- int ocv, pc;
+ int ocv, pc, batt_temp_decidegc;
ocv = raw->last_good_ocv_uv;
- pc = calculate_pc(chip, ocv, batt_temp, chargecycles);
+ batt_temp_decidegc = chip->last_ocv_temp_decidegc;
+ pc = calculate_pc(chip, ocv, batt_temp_decidegc, chargecycles);
pr_debug("ocv = %d pc = %d\n", ocv, pc);
return (fcc_uah * pc) / 100;
}
@@ -1562,16 +1569,18 @@
last_soc_est = soc_est;
pc = calculate_pc(chip, chip->last_ocv_uv,
- batt_temp, last_chargecycles);
+ chip->last_ocv_temp_decidegc, last_chargecycles);
if (pc > 0) {
pc_new = calculate_pc(chip, chip->last_ocv_uv - (++m * 1000),
- batt_temp, last_chargecycles);
+ chip->last_ocv_temp_decidegc,
+ last_chargecycles);
while (pc_new == pc) {
/* start taking 10mV steps */
m = m + 10;
pc_new = calculate_pc(chip,
chip->last_ocv_uv - (m * 1000),
- batt_temp, last_chargecycles);
+ chip->last_ocv_temp_decidegc,
+ last_chargecycles);
}
} else {
/*
@@ -1604,7 +1613,7 @@
/* calculate the soc based on this new ocv */
pc_new = calculate_pc(chip, chip->last_ocv_uv,
- batt_temp, last_chargecycles);
+ chip->last_ocv_temp_decidegc, last_chargecycles);
rc_new_uah = (fcc_uah * pc_new) / 100;
soc_new = (rc_new_uah - cc_uah - uuc_uah)*100 / (fcc_uah - uuc_uah);
soc_new = bound_soc(soc_new);
@@ -2041,7 +2050,7 @@
get_batt_temp(chip, &batt_temp);
mutex_lock(&chip->last_ocv_uv_mutex);
- read_soc_params_raw(chip, &raw);
+ read_soc_params_raw(chip, &raw, batt_temp);
soc = calculate_state_of_charge(chip, &raw,
batt_temp, last_chargecycles);
@@ -2253,7 +2262,7 @@
mutex_lock(&the_chip->last_ocv_uv_mutex);
- read_soc_params_raw(the_chip, &raw);
+ read_soc_params_raw(the_chip, &raw, batt_temp);
calculate_soc_params(the_chip, &raw, batt_temp, last_chargecycles,
&fcc_uah,
@@ -2292,9 +2301,12 @@
void pm8921_bms_charging_began(void)
{
struct pm8921_soc_params raw;
+ int batt_temp;
+
+ get_batt_temp(the_chip, &batt_temp);
mutex_lock(&the_chip->last_ocv_uv_mutex);
- read_soc_params_raw(the_chip, &raw);
+ read_soc_params_raw(the_chip, &raw, batt_temp);
mutex_unlock(&the_chip->last_ocv_uv_mutex);
the_chip->start_percent = report_state_of_charge(the_chip);
@@ -2327,7 +2339,7 @@
mutex_lock(&the_chip->last_ocv_uv_mutex);
- read_soc_params_raw(the_chip, &raw);
+ read_soc_params_raw(the_chip, &raw, batt_temp);
calculate_cc_uah(the_chip, raw.cc, &bms_end_cc_uah);
@@ -2720,7 +2732,7 @@
int ibat_ua, vbat_uv;
struct pm8921_soc_params raw;
- read_soc_params_raw(the_chip, &raw);
+ read_soc_params_raw(the_chip, &raw, 300);
*val = 0;
@@ -2786,7 +2798,7 @@
struct pm8921_soc_params raw;
mutex_lock(&the_chip->bms_output_lock);
- read_soc_params_raw(the_chip, &raw);
+ read_soc_params_raw(the_chip, &raw, 300);
mutex_unlock(&the_chip->bms_output_lock);
*val = 0;
diff --git a/drivers/power/pm8921-charger.c b/drivers/power/pm8921-charger.c
index 1ca0728..c86ba9e 100644
--- a/drivers/power/pm8921-charger.c
+++ b/drivers/power/pm8921-charger.c
@@ -293,6 +293,7 @@
int btc_override_hot_decidegc;
int btc_delay_ms;
bool btc_panic_if_cant_stop_chg;
+ int stop_chg_upon_expiry;
};
/* user space parameter to limit usb current */
@@ -2733,9 +2734,11 @@
struct pm8921_chg_chip *chip = data;
int ret;
- ret = pm_chg_failed_clear(chip, 1);
- if (ret)
- pr_err("Failed to write CHG_FAILED_CLEAR bit\n");
+ if (!chip->stop_chg_upon_expiry) {
+ ret = pm_chg_failed_clear(chip, 1);
+ if (ret)
+ pr_err("Failed to write CHG_FAILED_CLEAR bit\n");
+ }
pr_err("batt_present = %d, batt_temp_ok = %d, state_changed_to=%d\n",
get_prop_batt_present(chip),
@@ -3237,7 +3240,6 @@
struct pm8921_chg_chip *chip = container_of(dwork,
struct pm8921_chg_chip, update_heartbeat_work);
- pm_chg_failed_clear(chip, 1);
power_supply_changed(&chip->batt_psy);
if (chip->recent_reported_soc <= 20)
schedule_delayed_work(&chip->update_heartbeat_work,
@@ -3670,8 +3672,6 @@
int ichg_meas_ua, ichg_meas_ma;
int vbat_batt_terminal_uv;
- pm_chg_failed_clear(chip, 1);
-
pm8921_bms_get_simultaneous_battery_voltage_and_current(
&ichg_meas_ua, &vbat_meas_uv);
vbat_meas_mv = vbat_meas_uv / 1000;
@@ -4736,6 +4736,8 @@
if (chip->btc_override)
pm8921_chg_btc_override_init(chip);
+ chip->stop_chg_upon_expiry = pdata->stop_chg_upon_expiry;
+
chip->usb_psy.name = "usb",
chip->usb_psy.type = POWER_SUPPLY_TYPE_USB,
chip->usb_psy.supplied_to = pm_power_supplied_to,
diff --git a/drivers/thermal/qpnp-adc-tm.c b/drivers/thermal/qpnp-adc-tm.c
index 20481ac..4818941 100644
--- a/drivers/thermal/qpnp-adc-tm.c
+++ b/drivers/thermal/qpnp-adc-tm.c
@@ -1488,7 +1488,7 @@
return 0;
fail:
- adc_qpnp = NULL;
+ qpnp_adc_tm = NULL;
return rc;
}
diff --git a/drivers/video/msm/mdss/mdss_mdp_pp.c b/drivers/video/msm/mdss/mdss_mdp_pp.c
index c90ae82..1482935 100644
--- a/drivers/video/msm/mdss/mdss_mdp_pp.c
+++ b/drivers/video/msm/mdss/mdss_mdp_pp.c
@@ -420,19 +420,19 @@
pp_sts = &mdss_pp_res->pp_dspp_sts[dspp_num];
if (flags & PP_FLAGS_DIRTY_PA) {
pa_config = &mdss_pp_res->pa_disp_cfg[disp_num];
- if (pa_config->flags & MDP_PP_OPS_WRITE) {
+ if (pa_config->pa_data.flags & MDP_PP_OPS_WRITE) {
offset = base + MDSS_MDP_REG_DSPP_PA_BASE;
- MDSS_MDP_REG_WRITE(offset, pa_config->hue_adj);
+ MDSS_MDP_REG_WRITE(offset, pa_config->pa_data.hue_adj);
offset += 4;
- MDSS_MDP_REG_WRITE(offset, pa_config->sat_adj);
+ MDSS_MDP_REG_WRITE(offset, pa_config->pa_data.sat_adj);
offset += 4;
- MDSS_MDP_REG_WRITE(offset, pa_config->val_adj);
+ MDSS_MDP_REG_WRITE(offset, pa_config->pa_data.val_adj);
offset += 4;
- MDSS_MDP_REG_WRITE(offset, pa_config->cont_adj);
+ MDSS_MDP_REG_WRITE(offset, pa_config->pa_data.cont_adj);
}
- if (pa_config->flags & MDP_PP_OPS_DISABLE)
+ if (pa_config->pa_data.flags & MDP_PP_OPS_DISABLE)
pp_sts->pa_sts &= ~PP_STS_ENABLE;
- else if (pa_config->flags & MDP_PP_OPS_ENABLE)
+ else if (pa_config->pa_data.flags & MDP_PP_OPS_ENABLE)
pp_sts->pa_sts |= PP_STS_ENABLE;
}
if (pp_sts->pa_sts & PP_STS_ENABLE)
@@ -636,7 +636,7 @@
mutex_lock(&mdss_pp_mutex);
disp_num = config->block - MDP_LOGICAL_BLOCK_DISP_0;
- if (config->flags & MDP_PP_OPS_READ) {
+ if (config->pa_data.flags & MDP_PP_OPS_READ) {
ret = pp_get_dspp_num(disp_num, &dspp_num);
if (ret) {
pr_err("%s, no dspp connects to disp %d",
@@ -646,13 +646,13 @@
mdss_mdp_clk_ctrl(MDP_BLOCK_POWER_ON, false);
pa_offset = MDSS_MDP_REG_DSPP_OFFSET(dspp_num) +
MDSS_MDP_REG_DSPP_PA_BASE;
- config->hue_adj = MDSS_MDP_REG_READ(pa_offset);
+ config->pa_data.hue_adj = MDSS_MDP_REG_READ(pa_offset);
pa_offset += 4;
- config->sat_adj = MDSS_MDP_REG_READ(pa_offset);
+ config->pa_data.sat_adj = MDSS_MDP_REG_READ(pa_offset);
pa_offset += 4;
- config->val_adj = MDSS_MDP_REG_READ(pa_offset);
+ config->pa_data.val_adj = MDSS_MDP_REG_READ(pa_offset);
pa_offset += 4;
- config->cont_adj = MDSS_MDP_REG_READ(pa_offset);
+ config->pa_data.cont_adj = MDSS_MDP_REG_READ(pa_offset);
*copyback = 1;
mdss_mdp_clk_ctrl(MDP_BLOCK_POWER_OFF, false);
} else {
diff --git a/drivers/video/msm/vidc/1080p/ddl/vcd_ddl.c b/drivers/video/msm/vidc/1080p/ddl/vcd_ddl.c
index f8c26ff..91cf3ae 100644
--- a/drivers/video/msm/vidc/1080p/ddl/vcd_ddl.c
+++ b/drivers/video/msm/vidc/1080p/ddl/vcd_ddl.c
@@ -88,7 +88,7 @@
ddl_context->dram_base_a.align_virtual_addr;
}
if (!status) {
- ddl_context->metadata_shared_input.mem_type = DDL_FW_MEM;
+ ddl_context->metadata_shared_input.mem_type = DDL_CMD_MEM;
ptr = ddl_pmem_alloc(&ddl_context->metadata_shared_input,
DDL_METADATA_TOTAL_INPUTBUFSIZE,
DDL_LINEAR_BUFFER_ALIGN_BYTES);
diff --git a/drivers/video/msm/vidc/1080p/ddl/vcd_ddl.h b/drivers/video/msm/vidc/1080p/ddl/vcd_ddl.h
index 0404e82..248ad57 100644
--- a/drivers/video/msm/vidc/1080p/ddl/vcd_ddl.h
+++ b/drivers/video/msm/vidc/1080p/ddl/vcd_ddl.h
@@ -205,6 +205,7 @@
struct ddl_buf_addr h264_nb_ip;
struct ddl_buf_addr context;
struct ddl_buf_addr extnuserdata;
+ struct ddl_buf_addr meta_hdr[DDL_MAX_BUFFER_COUNT];
};
struct ddl_enc_buffer_size{
u32 sz_cur_y;
diff --git a/drivers/video/msm/vidc/1080p/ddl/vcd_ddl_helper.c b/drivers/video/msm/vidc/1080p/ddl/vcd_ddl_helper.c
index 15b37a1b..729fb2e 100644
--- a/drivers/video/msm/vidc/1080p/ddl/vcd_ddl_helper.c
+++ b/drivers/video/msm/vidc/1080p/ddl/vcd_ddl_helper.c
@@ -781,7 +781,7 @@
}
}
if (buf_size.sz_extnuserdata > 0) {
- dec_bufs->extnuserdata.mem_type = DDL_FW_MEM;
+ dec_bufs->extnuserdata.mem_type = DDL_CMD_MEM;
ptr = ddl_pmem_alloc(&dec_bufs->extnuserdata,
buf_size.sz_extnuserdata, DDL_KILO_BYTE(2));
if (!ptr)
diff --git a/drivers/video/msm/vidc/1080p/ddl/vcd_ddl_metadata.c b/drivers/video/msm/vidc/1080p/ddl/vcd_ddl_metadata.c
index 1aee3d9..803af02 100644
--- a/drivers/video/msm/vidc/1080p/ddl/vcd_ddl_metadata.c
+++ b/drivers/video/msm/vidc/1080p/ddl/vcd_ddl_metadata.c
@@ -165,7 +165,8 @@
if (ddl->decoding) {
flag |= (VCD_METADATA_CONCEALMB | VCD_METADATA_PASSTHROUGH |
- VCD_METADATA_QPARRAY);
+ VCD_METADATA_QPARRAY |
+ VCD_METADATA_SEPARATE_BUF);
if (codec == VCD_CODEC_H264)
flag |= (VCD_METADATA_SEI | VCD_METADATA_VUI);
else if (codec == VCD_CODEC_VC1 ||
@@ -260,6 +261,9 @@
DDL_METADATA_ALIGNSIZE(suffix);
decoder->suffix = suffix;
output_buf_req->sz += suffix;
+ output_buf_req->meta_buffer_size = suffix;
+ output_buf_req->meta_buffer_size =
+ (output_buf_req->meta_buffer_size + 8191) & (~8191);
decoder->meta_data_offset = 0;
DDL_MSG_LOW("metadata output buf size : %d", suffix);
}
@@ -481,13 +485,14 @@
void ddl_vidc_decode_set_metadata_output(struct ddl_decoder_data *decoder)
{
struct ddl_context *ddl_context;
- u32 loopc, yuv_size;
+ u32 loopc, yuv_size, dpb;
u32 *buffer;
-
+ struct ddl_dec_buffers *dec_buffers = &decoder->hw_bufs;
if (!decoder->meta_data_enable_flag) {
decoder->meta_data_offset = 0;
return;
}
+ dpb = decoder->dp_buf.no_of_dec_pic_buf;
ddl_context = ddl_get_context();
yuv_size = ddl_get_yuv_buffer_size(&decoder->client_frame_size,
&decoder->buf_format, !decoder->progressive_only,
@@ -495,15 +500,22 @@
decoder->meta_data_offset = DDL_ALIGN_SIZE(yuv_size,
DDL_LINEAR_BUF_ALIGN_GUARD_BYTES, DDL_LINEAR_BUF_ALIGN_MASK);
buffer = (u32 *) decoder->meta_data_input.align_virtual_addr;
- *buffer++ = decoder->suffix;
DDL_MSG_LOW("Metadata offset & size : %d/%d",
decoder->meta_data_offset, decoder->suffix);
- for (loopc = 0; loopc < decoder->dp_buf.no_of_dec_pic_buf;
- ++loopc) {
- *buffer++ = (u32)(decoder->meta_data_offset + (u8 *)
+ if (!(decoder->meta_data_enable_flag & VCD_METADATA_SEPARATE_BUF)) {
+ *buffer++ = decoder->suffix;
+ for (loopc = 0; loopc < dpb; ++loopc) {
+ *buffer++ = (u32)(decoder->meta_data_offset + (u8 *)
DDL_OFFSET(ddl_context->dram_base_a.
align_physical_addr, decoder->dp_buf.
dec_pic_buffers[loopc].vcd_frm.physical));
+ }
+ } else {
+ *buffer++ = decoder->actual_output_buf_req.meta_buffer_size;
+ for (loopc = 0; loopc < dpb; ++loopc) {
+ *buffer++ = DDL_ADDR_OFFSET(ddl_context->dram_base_a,
+ dec_buffers->meta_hdr[loopc]);
+ }
}
}
@@ -627,7 +639,8 @@
DDL_MSG_LOW("data_len/metadata_offset : %d/%d",
output_frame->data_len, decoder->meta_data_offset);
output_frame->flags |= VCD_FRAME_FLAG_EXTRADATA;
- if (output_frame->data_len != decoder->meta_data_offset) {
+ if (!(decoder->meta_data_enable_flag & VCD_METADATA_SEPARATE_BUF)
+ && (output_frame->data_len != decoder->meta_data_offset)) {
qfiller = (u32 *)((u32)((output_frame->data_len +
output_frame->offset +
(u8 *) output_frame->virtual) + 3) & ~3);
diff --git a/drivers/video/msm/vidc/1080p/ddl/vcd_ddl_properties.c b/drivers/video/msm/vidc/1080p/ddl/vcd_ddl_properties.c
index 94ec12e..95f4bf0 100644
--- a/drivers/video/msm/vidc/1080p/ddl/vcd_ddl_properties.c
+++ b/drivers/video/msm/vidc/1080p/ddl/vcd_ddl_properties.c
@@ -341,6 +341,61 @@
}
}
break;
+ case VCD_I_SET_EXT_METABUFFER:
+ {
+ int index, buffer_size;
+ u8 *phys_addr;
+ u8 *virt_addr;
+ struct vcd_property_meta_buffer *meta_buffer =
+ (struct vcd_property_meta_buffer *) property_value;
+ DDL_MSG_LOW("Entered VCD_I_SET_EXT_METABUFFER Virt: %p,"\
+ "Phys %p, fd: %d size: %d count: %d",
+ meta_buffer->kernel_virtual_addr,
+ meta_buffer->physical_addr,
+ meta_buffer->pmem_fd,
+ meta_buffer->size, meta_buffer->count);
+ if ((property_hdr->sz == sizeof(struct
+ vcd_property_meta_buffer)) &&
+ (DDLCLIENT_STATE_IS(ddl,
+ DDL_CLIENT_WAIT_FOR_INITCODEC) ||
+ DDLCLIENT_STATE_IS(ddl, DDL_CLIENT_WAIT_FOR_DPB) ||
+ DDLCLIENT_STATE_IS(ddl, DDL_CLIENT_OPEN))) {
+ phys_addr = meta_buffer->dev_addr;
+ virt_addr = meta_buffer->kernel_virtual_addr;
+ buffer_size = meta_buffer->size/meta_buffer->count;
+
+ for (index = 0; index < meta_buffer->count; index++) {
+ ddl->codec_data.decoder.hw_bufs.
+ meta_hdr[index].align_physical_addr
+ = phys_addr;
+ ddl->codec_data.decoder.hw_bufs.
+ meta_hdr[index].align_virtual_addr
+ = virt_addr;
+ ddl->codec_data.decoder.hw_bufs.
+ meta_hdr[index].buffer_size
+ = buffer_size;
+ ddl->codec_data.decoder.hw_bufs.
+ meta_hdr[index].physical_base_addr
+ = phys_addr;
+ ddl->codec_data.decoder.hw_bufs.
+ meta_hdr[index].virtual_base_addr
+ = virt_addr;
+
+ DDL_MSG_LOW("Meta Buffer: "\
+ "Assigned %d buffer for "
+ "virt: %p, phys %p for "
+ "meta_buffers "
+ "of size: %d\n",
+ index, virt_addr,
+ phys_addr, buffer_size);
+
+ phys_addr += buffer_size;
+ virt_addr += buffer_size;
+ }
+ vcd_status = VCD_S_SUCCESS;
+ }
+ }
+ break;
case VCD_I_H264_MV_BUFFER:
{
int index, buffer_size;
@@ -401,6 +456,13 @@
vcd_status = VCD_S_SUCCESS;
}
break;
+ case VCD_I_FREE_EXT_METABUFFER:
+ {
+ memset(&decoder->hw_bufs.meta_hdr, 0, sizeof(struct
+ ddl_buf_addr) * DDL_MAX_BUFFER_COUNT);
+ vcd_status = VCD_S_SUCCESS;
+ }
+ break;
case VCD_I_OUTPUT_ORDER:
{
if (sizeof(u32) == property_hdr->sz &&
diff --git a/drivers/video/msm/vidc/common/dec/vdec.c b/drivers/video/msm/vidc/common/dec/vdec.c
index 59e19b7..48f127a 100644
--- a/drivers/video/msm/vidc/common/dec/vdec.c
+++ b/drivers/video/msm/vidc/common/dec/vdec.c
@@ -271,6 +271,38 @@
&phy_addr, &pmem_fd, &file,
&buffer_index) ||
(vcd_frame_data->flags & VCD_FRAME_FLAG_EOS)) {
+
+ if (res_trk_check_for_sec_session() &&
+ event == VCD_EVT_RESP_OUTPUT_DONE) {
+ DBG("Buffer Index = %d", buffer_index);
+ if (buffer_index != -1) {
+ if (client_ctx->meta_addr_table[buffer_index].
+ kernel_vir_addr_iommu &&
+ client_ctx->
+ meta_addr_table[buffer_index].
+ kernel_vir_addr) {
+
+ memcpy(client_ctx->
+ meta_addr_table[buffer_index].
+ kernel_vir_addr_iommu,
+ client_ctx->
+ meta_addr_table[buffer_index].
+ kernel_vir_addr,
+ client_ctx->meta_buf_size);
+ DBG("Copying Meta Buffer from "\
+ "secure memory"
+ "kernel_virt_iommu = %p "
+ "kernel_virt = %p",
+ client_ctx->
+ meta_addr_table[buffer_index].
+ kernel_vir_addr_iommu,
+ client_ctx->
+ meta_addr_table[buffer_index].
+ kernel_vir_addr);
+ }
+ }
+ }
+
/* Buffer address in user space */
vdec_msg->vdec_msg_info.msgdata.output_frame.bufferaddr =
(u8 *) user_vaddr;
@@ -838,7 +870,263 @@
return false;
return true;
}
+static u32 vid_dec_set_meta_buffers(struct video_client_ctx *client_ctx,
+ struct vdec_meta_buffers *meta_buffers)
+{
+ struct vcd_property_hdr vcd_property_hdr;
+ struct vcd_property_meta_buffer *vcd_meta_buffer = NULL;
+ struct msm_mapped_buffer *mapped_buffer = NULL;
+ struct msm_mapped_buffer *mapped_buffer_iommu = NULL;
+ u32 vcd_status = VCD_ERR_FAIL;
+ u32 len = 0, flags = 0, len_iommu = 0, flags_iommu = 0, buf_size = 0;
+ struct file *file, *file_iommu;
+ int rc = 0;
+ unsigned long ionflag = 0, ionflag_iommu = 0;
+ unsigned long buffer_size = 0, buffer_size_iommu = 0;
+ unsigned long iova = 0, iova_iommu = 0;
+ int index = -1, num_buffers = 0;
+ u8 *ker_vir_addr = NULL, *ker_vir_addr_iommu = NULL;
+ if (!client_ctx || !meta_buffers)
+ return false;
+
+ vcd_property_hdr.prop_id = VCD_I_SET_EXT_METABUFFER;
+ vcd_property_hdr.sz = sizeof(struct vcd_property_meta_buffer);
+ vcd_meta_buffer = &client_ctx->vcd_meta_buffer;
+
+ memset(&client_ctx->vcd_meta_buffer, 0,
+ sizeof(struct vcd_property_meta_buffer));
+ vcd_meta_buffer->size = meta_buffers->size;
+ vcd_meta_buffer->count = meta_buffers->count;
+ vcd_meta_buffer->pmem_fd = meta_buffers->pmem_fd;
+ vcd_meta_buffer->offset = meta_buffers->offset;
+ vcd_meta_buffer->pmem_fd_iommu = meta_buffers->pmem_fd_iommu;
+
+ if (!vcd_get_ion_status()) {
+ if (get_pmem_file(vcd_meta_buffer->pmem_fd,
+ (unsigned long *) (&(vcd_meta_buffer->
+ physical_addr)),
+ (unsigned long *) (&vcd_meta_buffer->
+ kernel_virtual_addr),
+ (unsigned long *) (&len), &file)) {
+ ERR("%s(): get_pmem_file failed\n", __func__);
+ return false;
+ }
+ put_pmem_file(file);
+ flags = MSM_SUBSYSTEM_MAP_IOVA;
+ mapped_buffer = msm_subsystem_map_buffer(
+ (unsigned long)vcd_meta_buffer->physical_addr,
+ len, flags, vidc_mmu_subsystem,
+ sizeof(vidc_mmu_subsystem)/
+ sizeof(unsigned int));
+ if (IS_ERR(mapped_buffer)) {
+ pr_err("buffer map failed");
+ return false;
+ }
+ vcd_meta_buffer->client_data = (void *) mapped_buffer;
+ vcd_meta_buffer->dev_addr =
+ (u8 *)mapped_buffer->iova[0];
+
+ if (get_pmem_file(vcd_meta_buffer->pmem_fd_iommu,
+ (unsigned long *) (&(vcd_meta_buffer->
+ physical_addr_iommu)),
+ (unsigned long *) (&vcd_meta_buffer->
+ kernel_virt_addr_iommu),
+ (unsigned long *) (&len_iommu), &file_iommu)) {
+ ERR("%s(): get_pmem_file failed\n", __func__);
+ return false;
+ }
+ put_pmem_file(file_iommu);
+ flags_iommu = MSM_SUBSYSTEM_MAP_IOVA;
+ mapped_buffer_iommu = msm_subsystem_map_buffer(
+ (unsigned long)vcd_meta_buffer->physical_addr_iommu,
+ len_iommu, flags_iommu, vidc_mmu_subsystem,
+ sizeof(vidc_mmu_subsystem)/
+ sizeof(unsigned int));
+ if (IS_ERR(mapped_buffer_iommu)) {
+ pr_err("buffer map failed");
+ return false;
+ }
+ vcd_meta_buffer->client_data_iommu =
+ (void *) mapped_buffer_iommu;
+ vcd_meta_buffer->dev_addr_iommu =
+ (u8 *)mapped_buffer_iommu->iova[0];
+ } else {
+ client_ctx->meta_buffer_ion_handle = ion_import_dma_buf(
+ client_ctx->user_ion_client,
+ vcd_meta_buffer->pmem_fd);
+ if (IS_ERR_OR_NULL(client_ctx->meta_buffer_ion_handle)) {
+ ERR("%s(): get_ION_handle failed\n", __func__);
+ goto import_ion_error;
+ }
+ rc = ion_handle_get_flags(client_ctx->user_ion_client,
+ client_ctx->meta_buffer_ion_handle,
+ &ionflag);
+ if (rc) {
+ ERR("%s():get_ION_flags fail\n",
+ __func__);
+ goto import_ion_error;
+ }
+ vcd_meta_buffer->kernel_virtual_addr =
+ (u8 *) ion_map_kernel(
+ client_ctx->user_ion_client,
+ client_ctx->meta_buffer_ion_handle);
+ if (!vcd_meta_buffer->kernel_virtual_addr) {
+ ERR("%s(): get_ION_kernel virtual addr failed\n",
+ __func__);
+ goto import_ion_error;
+ }
+ if (res_trk_check_for_sec_session() ||
+ (res_trk_get_core_type() == (u32)VCD_CORE_720P)) {
+ rc = ion_phys(client_ctx->user_ion_client,
+ client_ctx->meta_buffer_ion_handle,
+ (unsigned long *) (&(vcd_meta_buffer->
+ physical_addr)), &len);
+ if (rc) {
+ ERR("%s():get_ION_kernel physical addr fail\n",
+ __func__);
+ goto ion_map_error;
+ }
+ vcd_meta_buffer->client_data = NULL;
+ vcd_meta_buffer->dev_addr = (u8 *)
+ vcd_meta_buffer->physical_addr;
+ } else {
+ rc = ion_map_iommu(client_ctx->user_ion_client,
+ client_ctx->meta_buffer_ion_handle,
+ VIDEO_DOMAIN, VIDEO_MAIN_POOL,
+ SZ_4K, 0, (unsigned long *)&iova,
+ (unsigned long *)&buffer_size,
+ 0, 0);
+ if (rc || !iova) {
+ ERR("%s():get_ION_kernel physical addr fail,"\
+ " rc = %d iova = 0x%lx\n",
+ __func__, rc, iova);
+ goto ion_map_error;
+ }
+ vcd_meta_buffer->physical_addr = (u8 *) iova;
+ vcd_meta_buffer->client_data = NULL;
+ vcd_meta_buffer->dev_addr = (u8 *) iova;
+ }
+
+ client_ctx->meta_buffer_iommu_ion_handle = ion_import_dma_buf(
+ client_ctx->user_ion_client,
+ vcd_meta_buffer->pmem_fd_iommu);
+ if (IS_ERR_OR_NULL(client_ctx->meta_buffer_iommu_ion_handle)) {
+ ERR("%s(): get_ION_handle failed\n", __func__);
+ goto import_ion_error;
+ }
+ rc = ion_handle_get_flags(client_ctx->user_ion_client,
+ client_ctx->
+ meta_buffer_iommu_ion_handle,
+ &ionflag_iommu);
+ if (rc) {
+ ERR("%s():get_ION_flags fail\n",
+ __func__);
+ goto import_ion_error;
+ }
+ vcd_meta_buffer->kernel_virt_addr_iommu =
+ (u8 *) ion_map_kernel(
+ client_ctx->user_ion_client,
+ client_ctx->meta_buffer_iommu_ion_handle);
+ if (!vcd_meta_buffer->kernel_virt_addr_iommu) {
+ ERR("%s(): get_ION_kernel virtual addr failed\n",
+ __func__);
+ goto import_ion_error;
+ }
+ if (res_trk_get_core_type() == (u32)VCD_CORE_720P) {
+ rc = ion_phys(client_ctx->user_ion_client,
+ client_ctx->meta_buffer_iommu_ion_handle,
+ (unsigned long *) (&(vcd_meta_buffer->
+ physical_addr_iommu)), &len_iommu);
+ if (rc) {
+ ERR("%s():get_ION_kernel physical addr fail\n",
+ __func__);
+ goto ion_map_error_iommu;
+ }
+ vcd_meta_buffer->client_data_iommu = NULL;
+ vcd_meta_buffer->dev_addr_iommu = (u8 *)
+ vcd_meta_buffer->physical_addr_iommu;
+ } else {
+ rc = ion_map_iommu(client_ctx->user_ion_client,
+ client_ctx->meta_buffer_iommu_ion_handle,
+ VIDEO_DOMAIN, VIDEO_MAIN_POOL,
+ SZ_4K, 0, (unsigned long *)&iova_iommu,
+ (unsigned long *)&buffer_size_iommu,
+ 0, 0);
+ if (rc || !iova_iommu) {
+ ERR("%s():get_ION_kernel physical addr fail, "\
+ "rc = %d iova = 0x%lx\n",
+ __func__, rc, iova);
+ goto ion_map_error_iommu;
+ }
+ vcd_meta_buffer->physical_addr_iommu =
+ (u8 *) iova_iommu;
+ vcd_meta_buffer->client_data_iommu = NULL;
+ vcd_meta_buffer->dev_addr_iommu = (u8 *) iova_iommu;
+ }
+ }
+
+ /*fill the meta addr table*/
+ num_buffers = vcd_meta_buffer->count;
+ buf_size = vcd_meta_buffer->size/num_buffers;
+ ker_vir_addr = vcd_meta_buffer->kernel_virtual_addr;
+ ker_vir_addr_iommu = vcd_meta_buffer->kernel_virt_addr_iommu;
+ client_ctx->meta_buf_size = buf_size;
+ for (index = 0; index < num_buffers; index++) {
+ client_ctx->meta_addr_table[index].kernel_vir_addr =
+ ker_vir_addr;
+ client_ctx->meta_addr_table[index].kernel_vir_addr_iommu =
+ ker_vir_addr_iommu;
+ DBG("[%d] kernel_virtual = %p kernel_vir_iommu = %p",
+ index, ker_vir_addr, ker_vir_addr_iommu);
+ ker_vir_addr += buf_size;
+ ker_vir_addr_iommu += buf_size;
+ }
+
+ DBG("Meta Buffer: Virt: %p, Phys %p, fd: %d",
+ vcd_meta_buffer->kernel_virtual_addr,
+ vcd_meta_buffer->physical_addr,
+ vcd_meta_buffer->pmem_fd);
+ DBG("IOMMU Meta Buffer: Virt: %p, Phys %p, fd: %d",
+ vcd_meta_buffer->kernel_virt_addr_iommu,
+ vcd_meta_buffer->physical_addr_iommu,
+ vcd_meta_buffer->pmem_fd_iommu);
+ DBG("Meta_buffer: Dev addr %p", vcd_meta_buffer->dev_addr);
+ DBG("IOMMU Meta_buffer: Dev addr %p",
+ vcd_meta_buffer->dev_addr_iommu);
+ vcd_status = vcd_set_property(client_ctx->vcd_handle,
+ &vcd_property_hdr,
+ vcd_meta_buffer);
+
+ if (vcd_status)
+ return false;
+ else
+ return true;
+ion_map_error_iommu:
+ if (vcd_meta_buffer->kernel_virt_addr_iommu) {
+ ion_unmap_kernel(client_ctx->user_ion_client,
+ client_ctx->meta_buffer_iommu_ion_handle);
+ vcd_meta_buffer->kernel_virt_addr_iommu = NULL;
+ }
+ if (!IS_ERR_OR_NULL(client_ctx->meta_buffer_iommu_ion_handle)) {
+ ion_free(client_ctx->user_ion_client,
+ client_ctx->meta_buffer_iommu_ion_handle);
+ client_ctx->meta_buffer_iommu_ion_handle = NULL;
+ }
+ion_map_error:
+ if (vcd_meta_buffer->kernel_virtual_addr) {
+ ion_unmap_kernel(client_ctx->user_ion_client,
+ client_ctx->meta_buffer_ion_handle);
+ vcd_meta_buffer->kernel_virtual_addr = NULL;
+ }
+ if (!IS_ERR_OR_NULL(client_ctx->meta_buffer_ion_handle)) {
+ ion_free(client_ctx->user_ion_client,
+ client_ctx->meta_buffer_ion_handle);
+ client_ctx->meta_buffer_ion_handle = NULL;
+ }
+import_ion_error:
+ return false;
+}
static u32 vid_dec_set_h264_mv_buffers(struct video_client_ctx *client_ctx,
struct vdec_h264_mv *mv_data)
{
@@ -1018,6 +1306,65 @@
return true;
}
+static u32 vid_dec_free_meta_buffers(struct video_client_ctx *client_ctx)
+{
+ struct vcd_property_hdr vcd_property_hdr;
+ struct vcd_property_buffer_size meta_buffer_size;
+ u32 vcd_status = VCD_ERR_FAIL;
+
+ if (!client_ctx)
+ return false;
+ if (client_ctx->vcd_meta_buffer.client_data)
+ msm_subsystem_unmap_buffer((struct msm_mapped_buffer *)
+ client_ctx->vcd_meta_buffer.client_data);
+
+ if (client_ctx->vcd_meta_buffer.client_data_iommu)
+ msm_subsystem_unmap_buffer((struct msm_mapped_buffer *)
+ client_ctx->vcd_meta_buffer.client_data_iommu);
+
+ vcd_property_hdr.prop_id = VCD_I_FREE_EXT_METABUFFER;
+ vcd_property_hdr.sz = sizeof(struct vcd_property_buffer_size);
+
+ vcd_status = vcd_set_property(client_ctx->vcd_handle,
+ &vcd_property_hdr, &meta_buffer_size);
+
+ if (!IS_ERR_OR_NULL(client_ctx->meta_buffer_ion_handle)) {
+ ion_unmap_kernel(client_ctx->user_ion_client,
+ client_ctx->meta_buffer_ion_handle);
+ if (!res_trk_check_for_sec_session() &&
+ (res_trk_get_core_type() != (u32)VCD_CORE_720P)) {
+ ion_unmap_iommu(client_ctx->user_ion_client,
+ client_ctx->meta_buffer_ion_handle,
+ VIDEO_DOMAIN,
+ VIDEO_MAIN_POOL);
+ }
+ ion_free(client_ctx->user_ion_client,
+ client_ctx->meta_buffer_ion_handle);
+ client_ctx->meta_buffer_ion_handle = NULL;
+ }
+
+ if (!IS_ERR_OR_NULL(client_ctx->meta_buffer_iommu_ion_handle)) {
+ ion_unmap_kernel(client_ctx->user_ion_client,
+ client_ctx->meta_buffer_iommu_ion_handle);
+ if (res_trk_check_for_sec_session() &&
+ (res_trk_get_core_type() != (u32)VCD_CORE_720P)) {
+ ion_unmap_iommu(client_ctx->user_ion_client,
+ client_ctx->meta_buffer_iommu_ion_handle,
+ VIDEO_DOMAIN,
+ VIDEO_MAIN_POOL);
+ }
+ ion_free(client_ctx->user_ion_client,
+ client_ctx->meta_buffer_iommu_ion_handle);
+ client_ctx->meta_buffer_iommu_ion_handle = NULL;
+ }
+
+ if (vcd_status)
+ return false;
+ else
+ return true;
+}
+
+
static u32 vid_dec_free_h264_mv_buffers(struct video_client_ctx *client_ctx)
{
struct vcd_property_hdr vcd_property_hdr;
@@ -1085,6 +1432,7 @@
vdec_buf_req->buffer_size = vcd_buf_req.sz;
vdec_buf_req->alignment = vcd_buf_req.align;
vdec_buf_req->buf_poolid = vcd_buf_req.buf_pool_id;
+ vdec_buf_req->meta_buffer_size = vcd_buf_req.meta_buffer_size;
return true;
}
@@ -1977,6 +2325,29 @@
return -EIO;
break;
}
+ case VDEC_IOCTL_SET_META_BUFFERS:
+ {
+ struct vdec_meta_buffers meta_buffers;
+ DBG("VDEC_IOCTL_SET_META_BUFFERS\n");
+ if (copy_from_user(&vdec_msg, arg, sizeof(vdec_msg)))
+ return -EFAULT;
+ if (copy_from_user(&meta_buffers, vdec_msg.in,
+ sizeof(meta_buffers)))
+ return -EFAULT;
+ result = vid_dec_set_meta_buffers(client_ctx, &meta_buffers);
+
+ if (!result)
+ return -EIO;
+ break;
+ }
+ case VDEC_IOCTL_FREE_META_BUFFERS:
+ {
+ DBG("VDEC_IOCTL_FREE_META_BUFFERS\n");
+ result = vid_dec_free_meta_buffers(client_ctx);
+ if (!result)
+ return -EIO;
+ break;
+ }
case VDEC_IOCTL_SET_H264_MV_BUFFER:
{
struct vdec_h264_mv mv_data;
diff --git a/include/linux/mfd/pm8xxx/pm8921-charger.h b/include/linux/mfd/pm8xxx/pm8921-charger.h
index 44f8538..ab52309 100644
--- a/include/linux/mfd/pm8xxx/pm8921-charger.h
+++ b/include/linux/mfd/pm8xxx/pm8921-charger.h
@@ -138,6 +138,10 @@
* driver couldn't stop charging when battery
* temperature is out of bounds. Used only if
* btc_override = 1
+ * stop_chg_upon_expiry: flag to indicate that the charger driver should
+ * stop charging the battery when the safety timer
+ * expires. If not set the charger driver will
+ * restart charging upon expiry.
*/
struct pm8921_charger_platform_data {
struct pm8xxx_charger_core_data charger_cdata;
@@ -183,6 +187,7 @@
int btc_override_hot_degc;
int btc_delay_ms;
int btc_panic_if_cant_stop_chg;
+ int stop_chg_upon_expiry;
};
enum pm8921_charger_source {
diff --git a/include/linux/msm_mdp.h b/include/linux/msm_mdp.h
index abd4f3a..aa2d948 100644
--- a/include/linux/msm_mdp.h
+++ b/include/linux/msm_mdp.h
@@ -298,6 +298,7 @@
#define MDP_OVERLAY_PP_CSC_CFG 0x1
#define MDP_OVERLAY_PP_QSEED_CFG 0x2
+#define MDP_OVERLAY_PP_PA_CFG 0x4
#define MDP_CSC_FLAG_ENABLE 0x1
#define MDP_CSC_FLAG_YUV_IN 0x2
@@ -318,10 +319,19 @@
struct mdp_csc_cfg csc_data;
};
+struct mdp_pa_cfg {
+ uint32_t flags;
+ uint32_t hue_adj;
+ uint32_t sat_adj;
+ uint32_t val_adj;
+ uint32_t cont_adj;
+};
+
struct mdp_overlay_pp_params {
uint32_t config_ops;
struct mdp_csc_cfg csc_cfg;
struct mdp_qseed_cfg qseed_cfg[2];
+ struct mdp_pa_cfg pa_cfg;
};
struct mdp_overlay {
@@ -486,11 +496,7 @@
struct mdp_pa_cfg_data {
uint32_t block;
- uint32_t flags;
- uint32_t hue_adj;
- uint32_t sat_adj;
- uint32_t val_adj;
- uint32_t cont_adj;
+ struct mdp_pa_cfg pa_data;
};
struct mdp_dither_cfg_data {
@@ -511,6 +517,12 @@
uint16_t *b_tbl[MDP_GAMUT_TABLE_NUM];
};
+struct mdp_calib_config_data {
+ uint32_t ops;
+ uint32_t addr;
+ uint32_t data;
+};
+
enum {
mdp_op_pcc_cfg,
mdp_op_csc_cfg,
@@ -520,6 +532,7 @@
mdp_op_pa_cfg,
mdp_op_dither_cfg,
mdp_op_gamut_cfg,
+ mdp_op_calib_cfg,
mdp_op_max,
};
@@ -534,6 +547,7 @@
struct mdp_pa_cfg_data pa_cfg_data;
struct mdp_dither_cfg_data dither_cfg_data;
struct mdp_gamut_cfg_data gamut_cfg_data;
+ struct mdp_calib_config_data calib_cfg;
} data;
};
diff --git a/include/linux/msm_vidc_dec.h b/include/linux/msm_vidc_dec.h
index 3c99562..cc864f0 100644
--- a/include/linux/msm_vidc_dec.h
+++ b/include/linux/msm_vidc_dec.h
@@ -78,6 +78,7 @@
#define VDEC_EXTRADATA_EXT_DATA 0x0800
#define VDEC_EXTRADATA_USER_DATA 0x1000
+#define VDEC_EXTRADATA_EXT_BUFFER 0x2000
#define VDEC_CMDBASE 0x800
#define VDEC_CMD_SET_INTF_VERSION (VDEC_CMDBASE)
@@ -213,6 +214,12 @@
#define VDEC_IOCTL_SET_PERF_CLK \
_IOR(VDEC_IOCTL_MAGIC, 38, struct vdec_ioctl_msg)
+#define VDEC_IOCTL_SET_META_BUFFERS \
+ _IOW(VDEC_IOCTL_MAGIC, 39, struct vdec_ioctl_msg)
+
+#define VDEC_IOCTL_FREE_META_BUFFERS \
+ _IO(VDEC_IOCTL_MAGIC, 40)
+
enum vdec_picture {
PICTURE_TYPE_I,
PICTURE_TYPE_P,
@@ -236,6 +243,7 @@
size_t buffer_size;
uint32_t alignment;
uint32_t buf_poolid;
+ size_t meta_buffer_size;
};
struct vdec_bufferpayload {
@@ -526,6 +534,11 @@
uint32_t par_height;
};
+struct vdec_sep_metadatainfo {
+ void __user *metabufaddr;
+ uint32_t size;
+};
+
struct vdec_output_frameinfo {
void __user *bufferaddr;
size_t offset;
@@ -538,6 +551,7 @@
struct vdec_framesize framesize;
enum vdec_interlaced_format interlaced_format;
struct vdec_aspectratioinfo aspect_ratio_info;
+ struct vdec_sep_metadatainfo metadata_info;
};
union vdec_msgdata {
@@ -571,4 +585,12 @@
int alignment;
};
+struct vdec_meta_buffers {
+ size_t size;
+ int count;
+ int pmem_fd;
+ int pmem_fd_iommu;
+ int offset;
+};
+
#endif /* end of macro _VDECDECODER_H_ */
diff --git a/include/media/msm/vcd_api.h b/include/media/msm/vcd_api.h
index 7104028..e668544 100644
--- a/include/media/msm/vcd_api.h
+++ b/include/media/msm/vcd_api.h
@@ -100,6 +100,7 @@
size_t sz;
u32 align;
u32 buf_pool_id;
+ size_t meta_buffer_size;
};
struct vcd_init_config {
diff --git a/include/media/msm/vcd_property.h b/include/media/msm/vcd_property.h
index ed9bffb..85b28e2 100644
--- a/include/media/msm/vcd_property.h
+++ b/include/media/msm/vcd_property.h
@@ -64,6 +64,8 @@
#define VCD_I_LTR_USE (VCD_START_BASE + 0x30)
#define VCD_I_CAPABILITY_LTR_COUNT (VCD_START_BASE + 0x31)
#define VCD_I_LTR_MARK (VCD_START_BASE + 0x32)
+#define VCD_I_SET_EXT_METABUFFER (VCD_START_BASE + 0x33)
+#define VCD_I_FREE_EXT_METABUFFER (VCD_START_BASE + 0x34)
#define VCD_START_REQ (VCD_START_BASE + 0x1000)
#define VCD_I_REQ_IFRAME (VCD_START_REQ + 0x1)
@@ -122,8 +124,10 @@
#define VCD_METADATA_PASSTHROUGH 0x080
#define VCD_METADATA_ENC_SLICE 0x100
#define VCD_METADATA_LTR_INFO 0x200
+
#define VCD_METADATA_EXT_DATA 0x0800
#define VCD_METADATA_USER_DATA 0x1000
+#define VCD_METADATA_SEPARATE_BUF 0x2000
struct vcd_property_meta_data_enable {
@@ -425,4 +429,19 @@
u32 ltr_frames;
};
+struct vcd_property_meta_buffer {
+ u8 *kernel_virtual_addr;
+ u8 *physical_addr;
+ u32 size;
+ u32 count;
+ int pmem_fd;
+ u32 offset;
+ u8 *dev_addr;
+ void *client_data;
+ u8 *kernel_virt_addr_iommu;
+ u8 *physical_addr_iommu;
+ int pmem_fd_iommu;
+ u8 *dev_addr_iommu;
+ void *client_data_iommu;
+};
#endif
diff --git a/include/media/msm/vidc_init.h b/include/media/msm/vidc_init.h
index f7d4e58..aff231d 100644
--- a/include/media/msm/vidc_init.h
+++ b/include/media/msm/vidc_init.h
@@ -19,6 +19,7 @@
#define VIDC_MAX_NUM_CLIENTS 4
#define MAX_VIDEO_NUM_OF_BUFF 100
+#define MAX_META_BUFFERS 32
enum buffer_dir {
BUFFER_TYPE_INPUT,
@@ -37,6 +38,11 @@
void *client_data;
};
+struct meta_buffer_addr_table {
+ u8 *kernel_vir_addr;
+ u8 *kernel_vir_addr_iommu;
+};
+
struct video_client_ctx {
void *vcd_handle;
u32 num_of_input_buffers;
@@ -49,17 +55,22 @@
wait_queue_head_t msg_wait;
struct completion event;
struct vcd_property_h264_mv_buffer vcd_h264_mv_buffer;
+ struct vcd_property_meta_buffer vcd_meta_buffer;
struct vcd_property_enc_recon_buffer recon_buffer[4];
u32 event_status;
u32 seq_header_set;
u32 stop_msg;
u32 stop_called;
u32 stop_sync_cb;
+ size_t meta_buf_size;
struct ion_client *user_ion_client;
struct ion_handle *seq_hdr_ion_handle;
struct ion_handle *h264_mv_ion_handle;
struct ion_handle *recon_buffer_ion_handle[4];
+ struct ion_handle *meta_buffer_ion_handle;
+ struct ion_handle *meta_buffer_iommu_ion_handle;
u32 dmx_disable;
+ struct meta_buffer_addr_table meta_addr_table[MAX_META_BUFFERS];
};
void __iomem *vidc_get_ioaddr(void);
diff --git a/net/bluetooth/hci_event.c b/net/bluetooth/hci_event.c
index 3b59e4e..15d3585 100644
--- a/net/bluetooth/hci_event.c
+++ b/net/bluetooth/hci_event.c
@@ -1,6 +1,6 @@
/*
BlueZ - Bluetooth protocol stack for Linux
- Copyright (c) 2000-2001, 2010-2012, Code Aurora Forum. All rights reserved.
+ Copyright (c) 2000-2001, 2010-2012 The Linux Foundation. All rights reserved.
Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
@@ -2669,12 +2669,6 @@
BT_DBG("Conn pending sec level is %d, ssp is %d, key len is %d",
conn->pending_sec_level, conn->ssp_mode, key->pin_len);
}
- if (conn && (conn->ssp_mode == 0) &&
- (conn->pending_sec_level == BT_SECURITY_HIGH) &&
- (key->pin_len != 16)) {
- BT_DBG("Security is high ignoring this key");
- goto not_found;
- }
if (key->key_type == 0x04 && conn && conn->auth_type != 0xff &&
(conn->auth_type & 0x01)) {