Merge "msm_fb: [HDMI_COMPLIANCE] Reset DDC control logic upon failure" into msm-3.0
diff --git a/arch/arm/configs/msm7627a-perf_defconfig b/arch/arm/configs/msm7627a-perf_defconfig
index 8c0bb5f..342aad6 100644
--- a/arch/arm/configs/msm7627a-perf_defconfig
+++ b/arch/arm/configs/msm7627a-perf_defconfig
@@ -104,6 +104,7 @@
CONFIG_NF_CONNTRACK_SIP=y
CONFIG_NF_CONNTRACK_TFTP=y
CONFIG_NF_CT_NETLINK=y
+CONFIG_NETFILTER_TPROXY=y
CONFIG_NETFILTER_XT_TARGET_CLASSIFY=y
CONFIG_NETFILTER_XT_TARGET_CONNMARK=y
CONFIG_NETFILTER_XT_TARGET_MARK=y
@@ -119,10 +120,11 @@
CONFIG_NETFILTER_XT_MATCH_LIMIT=y
CONFIG_NETFILTER_XT_MATCH_MAC=y
CONFIG_NETFILTER_XT_MATCH_MARK=y
-CONFIG_NETFILTER_XT_MATCH_OWNER=y
CONFIG_NETFILTER_XT_MATCH_POLICY=y
CONFIG_NETFILTER_XT_MATCH_PKTTYPE=y
+CONFIG_NETFILTER_XT_MATCH_QTAGUID=y
CONFIG_NETFILTER_XT_MATCH_QUOTA=y
+CONFIG_NETFILTER_XT_MATCH_SOCKET=y
CONFIG_NETFILTER_XT_MATCH_STATE=y
CONFIG_NETFILTER_XT_MATCH_STATISTIC=y
CONFIG_NETFILTER_XT_MATCH_STRING=y
@@ -140,9 +142,11 @@
CONFIG_IP_NF_TARGET_MASQUERADE=y
CONFIG_IP_NF_TARGET_NETMAP=y
CONFIG_IP_NF_TARGET_REDIRECT=y
+CONFIG_IP_NF_MANGLE=y
CONFIG_IP_NF_ARPTABLES=y
CONFIG_IP_NF_ARPFILTER=y
CONFIG_IP_NF_ARP_MANGLE=y
+CONFIG_IP6_NF_IPTABLES=y
CONFIG_BT=y
CONFIG_BT_L2CAP=y
CONFIG_BT_SCO=y
diff --git a/arch/arm/configs/msm7627a_defconfig b/arch/arm/configs/msm7627a_defconfig
index 8b1df40..c524759 100644
--- a/arch/arm/configs/msm7627a_defconfig
+++ b/arch/arm/configs/msm7627a_defconfig
@@ -102,6 +102,7 @@
CONFIG_NF_CONNTRACK_SIP=y
CONFIG_NF_CONNTRACK_TFTP=y
CONFIG_NF_CT_NETLINK=y
+CONFIG_NETFILTER_TPROXY=y
CONFIG_NETFILTER_XT_TARGET_CLASSIFY=y
CONFIG_NETFILTER_XT_TARGET_CONNMARK=y
CONFIG_NETFILTER_XT_TARGET_MARK=y
@@ -117,10 +118,11 @@
CONFIG_NETFILTER_XT_MATCH_LIMIT=y
CONFIG_NETFILTER_XT_MATCH_MAC=y
CONFIG_NETFILTER_XT_MATCH_MARK=y
-CONFIG_NETFILTER_XT_MATCH_OWNER=y
CONFIG_NETFILTER_XT_MATCH_POLICY=y
CONFIG_NETFILTER_XT_MATCH_PKTTYPE=y
+CONFIG_NETFILTER_XT_MATCH_QTAGUID=y
CONFIG_NETFILTER_XT_MATCH_QUOTA=y
+CONFIG_NETFILTER_XT_MATCH_SOCKET=y
CONFIG_NETFILTER_XT_MATCH_STATE=y
CONFIG_NETFILTER_XT_MATCH_STATISTIC=y
CONFIG_NETFILTER_XT_MATCH_STRING=y
@@ -138,9 +140,11 @@
CONFIG_IP_NF_TARGET_MASQUERADE=y
CONFIG_IP_NF_TARGET_NETMAP=y
CONFIG_IP_NF_TARGET_REDIRECT=y
+CONFIG_IP_NF_MANGLE=y
CONFIG_IP_NF_ARPTABLES=y
CONFIG_IP_NF_ARPFILTER=y
CONFIG_IP_NF_ARP_MANGLE=y
+CONFIG_IP6_NF_IPTABLES=y
CONFIG_BT=y
CONFIG_BT_L2CAP=y
CONFIG_BT_SCO=y
diff --git a/arch/arm/configs/msm7630-perf_defconfig b/arch/arm/configs/msm7630-perf_defconfig
index c997547..e5fec35 100644
--- a/arch/arm/configs/msm7630-perf_defconfig
+++ b/arch/arm/configs/msm7630-perf_defconfig
@@ -99,6 +99,7 @@
CONFIG_NF_CONNTRACK_SIP=y
CONFIG_NF_CONNTRACK_TFTP=y
CONFIG_NF_CT_NETLINK=y
+CONFIG_NETFILTER_TPROXY=y
CONFIG_NETFILTER_XT_TARGET_CLASSIFY=y
CONFIG_NETFILTER_XT_TARGET_CONNMARK=y
CONFIG_NETFILTER_XT_TARGET_MARK=y
@@ -115,10 +116,11 @@
CONFIG_NETFILTER_XT_MATCH_MAC=y
CONFIG_NETFILTER_XT_MATCH_MARK=y
CONFIG_NETFILTER_XT_MATCH_MULTIPORT=y
-CONFIG_NETFILTER_XT_MATCH_OWNER=y
CONFIG_NETFILTER_XT_MATCH_POLICY=y
CONFIG_NETFILTER_XT_MATCH_PKTTYPE=y
+CONFIG_NETFILTER_XT_MATCH_QTAGUID=y
CONFIG_NETFILTER_XT_MATCH_QUOTA=y
+CONFIG_NETFILTER_XT_MATCH_SOCKET=y
CONFIG_NETFILTER_XT_MATCH_STATE=y
CONFIG_NETFILTER_XT_MATCH_STATISTIC=y
CONFIG_NETFILTER_XT_MATCH_STRING=y
diff --git a/arch/arm/configs/msm7630_defconfig b/arch/arm/configs/msm7630_defconfig
index ef8bd76..6e3290b 100644
--- a/arch/arm/configs/msm7630_defconfig
+++ b/arch/arm/configs/msm7630_defconfig
@@ -98,6 +98,7 @@
CONFIG_NF_CONNTRACK_SIP=y
CONFIG_NF_CONNTRACK_TFTP=y
CONFIG_NF_CT_NETLINK=y
+CONFIG_NETFILTER_TPROXY=y
CONFIG_NETFILTER_XT_TARGET_CLASSIFY=y
CONFIG_NETFILTER_XT_TARGET_CONNMARK=y
CONFIG_NETFILTER_XT_TARGET_MARK=y
@@ -114,10 +115,11 @@
CONFIG_NETFILTER_XT_MATCH_MAC=y
CONFIG_NETFILTER_XT_MATCH_MARK=y
CONFIG_NETFILTER_XT_MATCH_MULTIPORT=y
-CONFIG_NETFILTER_XT_MATCH_OWNER=y
CONFIG_NETFILTER_XT_MATCH_POLICY=y
CONFIG_NETFILTER_XT_MATCH_PKTTYPE=y
+CONFIG_NETFILTER_XT_MATCH_QTAGUID=y
CONFIG_NETFILTER_XT_MATCH_QUOTA=y
+CONFIG_NETFILTER_XT_MATCH_SOCKET=y
CONFIG_NETFILTER_XT_MATCH_STATE=y
CONFIG_NETFILTER_XT_MATCH_STATISTIC=y
CONFIG_NETFILTER_XT_MATCH_STRING=y
diff --git a/arch/arm/configs/msm8660-perf_defconfig b/arch/arm/configs/msm8660-perf_defconfig
index 1e6e664..01150aa 100644
--- a/arch/arm/configs/msm8660-perf_defconfig
+++ b/arch/arm/configs/msm8660-perf_defconfig
@@ -133,6 +133,7 @@
CONFIG_NF_CONNTRACK_SIP=y
CONFIG_NF_CONNTRACK_TFTP=y
CONFIG_NF_CT_NETLINK=y
+CONFIG_NETFILTER_TPROXY=y
CONFIG_NETFILTER_XT_TARGET_CLASSIFY=y
CONFIG_NETFILTER_XT_TARGET_CONNMARK=y
CONFIG_NETFILTER_XT_TARGET_MARK=y
@@ -150,10 +151,11 @@
CONFIG_NETFILTER_XT_MATCH_MAC=y
CONFIG_NETFILTER_XT_MATCH_MARK=y
CONFIG_NETFILTER_XT_MATCH_MULTIPORT=y
-CONFIG_NETFILTER_XT_MATCH_OWNER=y
CONFIG_NETFILTER_XT_MATCH_POLICY=y
CONFIG_NETFILTER_XT_MATCH_PKTTYPE=y
+CONFIG_NETFILTER_XT_MATCH_QTAGUID=y
CONFIG_NETFILTER_XT_MATCH_QUOTA=y
+CONFIG_NETFILTER_XT_MATCH_SOCKET=y
CONFIG_NETFILTER_XT_MATCH_STATE=y
CONFIG_NETFILTER_XT_MATCH_STATISTIC=y
CONFIG_NETFILTER_XT_MATCH_STRING=y
diff --git a/arch/arm/configs/msm8660_defconfig b/arch/arm/configs/msm8660_defconfig
index 7f123a1..7b2fede 100644
--- a/arch/arm/configs/msm8660_defconfig
+++ b/arch/arm/configs/msm8660_defconfig
@@ -123,6 +123,7 @@
CONFIG_NF_CONNTRACK_SIP=y
CONFIG_NF_CONNTRACK_TFTP=y
CONFIG_NF_CT_NETLINK=y
+CONFIG_NETFILTER_TPROXY=y
CONFIG_NETFILTER_XT_TARGET_CLASSIFY=y
CONFIG_NETFILTER_XT_TARGET_CONNMARK=y
CONFIG_NETFILTER_XT_TARGET_MARK=y
@@ -140,10 +141,11 @@
CONFIG_NETFILTER_XT_MATCH_MAC=y
CONFIG_NETFILTER_XT_MATCH_MARK=y
CONFIG_NETFILTER_XT_MATCH_MULTIPORT=y
-CONFIG_NETFILTER_XT_MATCH_OWNER=y
CONFIG_NETFILTER_XT_MATCH_POLICY=y
CONFIG_NETFILTER_XT_MATCH_PKTTYPE=y
+CONFIG_NETFILTER_XT_MATCH_QTAGUID=y
CONFIG_NETFILTER_XT_MATCH_QUOTA=y
+CONFIG_NETFILTER_XT_MATCH_SOCKET=y
CONFIG_NETFILTER_XT_MATCH_STATE=y
CONFIG_NETFILTER_XT_MATCH_STATISTIC=y
CONFIG_NETFILTER_XT_MATCH_STRING=y
diff --git a/arch/arm/configs/msm8960_defconfig b/arch/arm/configs/msm8960_defconfig
index 3dff4e3..83d012c 100644
--- a/arch/arm/configs/msm8960_defconfig
+++ b/arch/arm/configs/msm8960_defconfig
@@ -26,6 +26,7 @@
CONFIG_EMBEDDED=y
CONFIG_PROFILING=y
CONFIG_OPROFILE=y
+CONFIG_KPROBES=y
CONFIG_MODULES=y
CONFIG_MODULE_UNLOAD=y
CONFIG_MODULE_FORCE_UNLOAD=y
@@ -82,6 +83,7 @@
CONFIG_AEABI=y
CONFIG_HIGHMEM=y
CONFIG_VMALLOC_RESERVE=0x19000000
+CONFIG_CP_ACCESS=y
CONFIG_CPU_FREQ=y
CONFIG_CPU_FREQ_GOV_POWERSAVE=y
CONFIG_CPU_FREQ_GOV_USERSPACE=y
@@ -133,6 +135,7 @@
CONFIG_NF_CONNTRACK_SIP=y
CONFIG_NF_CONNTRACK_TFTP=y
CONFIG_NF_CT_NETLINK=y
+CONFIG_NETFILTER_TPROXY=y
CONFIG_NETFILTER_XT_TARGET_CLASSIFY=y
CONFIG_NETFILTER_XT_TARGET_CONNMARK=y
CONFIG_NETFILTER_XT_TARGET_MARK=y
@@ -149,10 +152,11 @@
CONFIG_NETFILTER_XT_MATCH_MAC=y
CONFIG_NETFILTER_XT_MATCH_MARK=y
CONFIG_NETFILTER_XT_MATCH_MULTIPORT=y
-CONFIG_NETFILTER_XT_MATCH_OWNER=y
CONFIG_NETFILTER_XT_MATCH_POLICY=y
CONFIG_NETFILTER_XT_MATCH_PKTTYPE=y
+CONFIG_NETFILTER_XT_MATCH_QTAGUID=y
CONFIG_NETFILTER_XT_MATCH_QUOTA=y
+CONFIG_NETFILTER_XT_MATCH_SOCKET=y
CONFIG_NETFILTER_XT_MATCH_STATE=y
CONFIG_NETFILTER_XT_MATCH_STATISTIC=y
CONFIG_NETFILTER_XT_MATCH_STRING=y
@@ -397,7 +401,6 @@
CONFIG_NLS_ISO8859_1=y
CONFIG_PRINTK_TIME=y
CONFIG_MAGIC_SYSRQ=y
-CONFIG_DEBUG_FS=y
CONFIG_DEBUG_KERNEL=y
CONFIG_LOCKUP_DETECTOR=y
# CONFIG_SCHED_DEBUG is not set
@@ -411,6 +414,7 @@
CONFIG_DEBUG_MEMORY_INIT=y
CONFIG_DEBUG_LIST=y
CONFIG_DEBUG_PAGEALLOC=y
+CONFIG_ENABLE_DEFAULT_TRACERS=y
CONFIG_DYNAMIC_DEBUG=y
CONFIG_DEBUG_USER=y
CONFIG_CRYPTO_SHA256=y
diff --git a/arch/arm/mach-msm/Makefile b/arch/arm/mach-msm/Makefile
index 7e29383..05f4ab4 100644
--- a/arch/arm/mach-msm/Makefile
+++ b/arch/arm/mach-msm/Makefile
@@ -103,7 +103,7 @@
endif
endif
endif
-obj-$(CONFIG_MSM_SDIO_TTY) += sdio_tty.o sdio_tty_ciq.o
+obj-$(CONFIG_MSM_SDIO_TTY) += sdio_tty.o
obj-$(CONFIG_MSM_SMD_TTY) += smd_tty.o
obj-$(CONFIG_MSM_SMD_QMI) += smd_qmi.o
obj-$(CONFIG_MSM_SMD_PKT) += smd_pkt.o
diff --git a/arch/arm/mach-msm/acpuclock-8960.c b/arch/arm/mach-msm/acpuclock-8960.c
index 659c292..143fb86 100644
--- a/arch/arm/mach-msm/acpuclock-8960.c
+++ b/arch/arm/mach-msm/acpuclock-8960.c
@@ -140,7 +140,7 @@
.hfpll_base = MSM_HFPLL_BASE + 0x200,
.aux_clk_sel = MSM_ACC0_BASE + 0x014,
.l2cpmr_iaddr = L2CPUCPMR_IADDR,
- .vreg[VREG_CORE] = { "krait0", 1150000 },
+ .vreg[VREG_CORE] = { "krait0", 1300000 },
.vreg[VREG_MEM] = { "krait0_mem", 1150000,
RPM_VREG_VOTER1,
RPM_VREG_ID_PM8921_L24 },
@@ -158,7 +158,7 @@
.hfpll_base = MSM_HFPLL_BASE + 0x300,
.aux_clk_sel = MSM_ACC1_BASE + 0x014,
.l2cpmr_iaddr = L2CPUCPMR_IADDR,
- .vreg[VREG_CORE] = { "krait1", 1150000 },
+ .vreg[VREG_CORE] = { "krait1", 1300000 },
.vreg[VREG_MEM] = { "krait0_mem", 1150000,
RPM_VREG_VOTER2,
RPM_VREG_ID_PM8921_L24 },
@@ -287,8 +287,8 @@
static uint32_t bus_perf_client;
/* TODO: Update vdd_dig and vdd_mem when voltage data is available. */
-#define L2(x) (&l2_freq_tbl_8960[(x)])
-static struct l2_level l2_freq_tbl_8960[] = {
+#define L2(x) (&l2_freq_tbl_8960_kraitv1[(x)])
+static struct l2_level l2_freq_tbl_8960_kraitv1[] = {
[0] = { {STBY_KHZ, QSB, 0, 0, 0x00 }, 1050000, 1050000, 0 },
[1] = { { 384000, PLL_8, 0, 2, 0x00 }, 1050000, 1050000, 1 },
[2] = { { 432000, HFPLL, 2, 0, 0x20 }, 1050000, 1050000, 1 },
@@ -303,7 +303,7 @@
[11] = { { 918000, HFPLL, 1, 0, 0x22 }, 1150000, 1150000, 3 },
};
-static struct acpu_level acpu_freq_tbl_8960[] = {
+static struct acpu_level acpu_freq_tbl_8960_kraitv1[] = {
{ 0, {STBY_KHZ, QSB, 0, 0, 0x00 }, L2(0), 950000 },
{ 1, { 384000, PLL_8, 0, 2, 0x00 }, L2(1), 950000 },
{ 1, { 432000, HFPLL, 2, 0, 0x20 }, L2(6), 950000 },
@@ -319,6 +319,55 @@
{ 0, { 0 } }
};
+#undef L2
+#define L2(x) (&l2_freq_tbl_8960_kraitv2[(x)])
+static struct l2_level l2_freq_tbl_8960_kraitv2[] = {
+ [0] = { {STBY_KHZ, QSB, 0, 0, 0x00 }, 1050000, 1050000, 0 },
+ [1] = { { 384000, PLL_8, 0, 2, 0x00 }, 1050000, 1050000, 1 },
+ [2] = { { 432000, HFPLL, 2, 0, 0x20 }, 1050000, 1050000, 1 },
+ [3] = { { 486000, HFPLL, 2, 0, 0x24 }, 1050000, 1050000, 1 },
+ [4] = { { 540000, HFPLL, 2, 0, 0x28 }, 1050000, 1050000, 1 },
+ [5] = { { 594000, HFPLL, 1, 0, 0x16 }, 1050000, 1050000, 2 },
+ [6] = { { 648000, HFPLL, 1, 0, 0x18 }, 1050000, 1050000, 2 },
+ [7] = { { 702000, HFPLL, 1, 0, 0x1A }, 1050000, 1050000, 2 },
+ [8] = { { 756000, HFPLL, 1, 0, 0x1C }, 1150000, 1150000, 2 },
+ [9] = { { 810000, HFPLL, 1, 0, 0x1E }, 1150000, 1150000, 3 },
+ [10] = { { 864000, HFPLL, 1, 0, 0x20 }, 1150000, 1150000, 3 },
+ [11] = { { 918000, HFPLL, 1, 0, 0x22 }, 1150000, 1150000, 3 },
+ [12] = { { 972000, HFPLL, 1, 0, 0x24 }, 1150000, 1150000, 4 },
+ [13] = { { 1026000, HFPLL, 1, 0, 0x26 }, 1150000, 1150000, 4 },
+ [14] = { { 1080000, HFPLL, 1, 0, 0x28 }, 1150000, 1150000, 4 },
+ [15] = { { 1134000, HFPLL, 1, 0, 0x2A }, 1150000, 1150000, 4 },
+ [16] = { { 1188000, HFPLL, 1, 0, 0x2C }, 1150000, 1150000, 4 },
+};
+
+static struct acpu_level acpu_freq_tbl_8960_kraitv2[] = {
+ { 0, { STBY_KHZ, QSB, 0, 0, 0x00 }, L2(0), 950000 },
+ { 1, { 384000, PLL_8, 0, 2, 0x00 }, L2(1), 950000 },
+ { 1, { 432000, HFPLL, 2, 0, 0x20 }, L2(6), 950000 },
+ { 1, { 486000, HFPLL, 2, 0, 0x24 }, L2(6), 962500 },
+ { 1, { 540000, HFPLL, 2, 0, 0x28 }, L2(6), 962500 },
+ { 1, { 594000, HFPLL, 1, 0, 0x16 }, L2(6), 987500 },
+ { 1, { 648000, HFPLL, 1, 0, 0x18 }, L2(6), 1000000 },
+ { 1, { 702000, HFPLL, 1, 0, 0x1A }, L2(6), 1025000 },
+ { 1, { 756000, HFPLL, 1, 0, 0x1C }, L2(11), 1050000 },
+ { 1, { 810000, HFPLL, 1, 0, 0x1E }, L2(11), 1087500 },
+ { 1, { 864000, HFPLL, 1, 0, 0x20 }, L2(11), 1125000 },
+ { 1, { 918000, HFPLL, 1, 0, 0x22 }, L2(11), 1137500 },
+ { 1, { 972000, HFPLL, 1, 0, 0x24 }, L2(16), 1300000 },
+ { 1, { 1026000, HFPLL, 1, 0, 0x26 }, L2(16), 1300000 },
+ { 1, { 1080000, HFPLL, 1, 0, 0x28 }, L2(16), 1300000 },
+ { 1, { 1134000, HFPLL, 1, 0, 0x2A }, L2(16), 1300000 },
+ { 1, { 1188000, HFPLL, 1, 0, 0x2C }, L2(16), 1300000 },
+ { 1, { 1242000, HFPLL, 1, 0, 0x2E }, L2(16), 1300000 },
+ { 1, { 1296000, HFPLL, 1, 0, 0x30 }, L2(16), 1300000 },
+ { 1, { 1350000, HFPLL, 1, 0, 0x32 }, L2(16), 1300000 },
+ { 1, { 1404000, HFPLL, 1, 0, 0x34 }, L2(16), 1300000 },
+ { 1, { 1458000, HFPLL, 1, 0, 0x36 }, L2(16), 1300000 },
+ { 1, { 1512000, HFPLL, 1, 0, 0x38 }, L2(16), 1300000 },
+ { 0, { 0 } }
+};
+
/* TODO: Update vdd_dig and vdd_mem when voltage data is available. */
#undef L2
#define L2(x) (&l2_freq_tbl_8064[(x)])
@@ -1051,9 +1100,15 @@
/* TODO: Select tables based on PVS data. */
scalable = scalable_8960;
- acpu_freq_tbl = acpu_freq_tbl_8960;
- l2_freq_tbl = l2_freq_tbl_8960;
- l2_freq_tbl_size = ARRAY_SIZE(l2_freq_tbl_8960);
+ if (cpu_is_krait_v1()) {
+ acpu_freq_tbl = acpu_freq_tbl_8960_kraitv1;
+ l2_freq_tbl = l2_freq_tbl_8960_kraitv1;
+ l2_freq_tbl_size = ARRAY_SIZE(l2_freq_tbl_8960_kraitv1);
+ } else {
+ acpu_freq_tbl = acpu_freq_tbl_8960_kraitv2;
+ l2_freq_tbl = l2_freq_tbl_8960_kraitv2;
+ l2_freq_tbl_size = ARRAY_SIZE(l2_freq_tbl_8960_kraitv2);
+ }
} else if (cpu_is_apq8064()) {
scalable = scalable_8064;
acpu_freq_tbl = acpu_freq_tbl_8064;
diff --git a/arch/arm/mach-msm/board-8960-regulator.c b/arch/arm/mach-msm/board-8960-regulator.c
index 53fe93e..7bc3ca5 100644
--- a/arch/arm/mach-msm/board-8960-regulator.c
+++ b/arch/arm/mach-msm/board-8960-regulator.c
@@ -449,9 +449,9 @@
/* SAW regulator constraints */
struct regulator_init_data msm_saw_regulator_pdata_s5 =
/* ID vreg_name min_uV max_uV */
- SAW_VREG_INIT(S5, "8921_s5", 950000, 1150000);
+ SAW_VREG_INIT(S5, "8921_s5", 950000, 1300000);
struct regulator_init_data msm_saw_regulator_pdata_s6 =
- SAW_VREG_INIT(S6, "8921_s6", 950000, 1150000);
+ SAW_VREG_INIT(S6, "8921_s6", 950000, 1300000);
/* PM8921 regulator constraints */
struct pm8921_regulator_platform_data
diff --git a/arch/arm/mach-msm/board-msm7x27a.c b/arch/arm/mach-msm/board-msm7x27a.c
index 6b3cad3..5de5ea3 100644
--- a/arch/arm/mach-msm/board-msm7x27a.c
+++ b/arch/arm/mach-msm/board-msm7x27a.c
@@ -3023,7 +3023,6 @@
gpio_tlmm_config(GPIO_CFG(ATMEL_TS_GPIO_IRQ, 0,
GPIO_CFG_INPUT, GPIO_CFG_NO_PULL,
GPIO_CFG_2MA), GPIO_CFG_DISABLE);
- regulator_bulk_disable(ARRAY_SIZE(regs_atmel), regs_atmel);
regulator_bulk_free(ARRAY_SIZE(regs_atmel), regs_atmel);
return 0;
}
diff --git a/arch/arm/mach-msm/clock-7x30.c b/arch/arm/mach-msm/clock-7x30.c
index a478b6f..100689b 100644
--- a/arch/arm/mach-msm/clock-7x30.c
+++ b/arch/arm/mach-msm/clock-7x30.c
@@ -2316,7 +2316,7 @@
static DEFINE_CLK_PCOM(p_grp_2d_clk, GRP_2D_CLK, CLKFLAG_SKIP_AUTO_OFF);
static DEFINE_CLK_PCOM(p_grp_2d_p_clk, GRP_2D_P_CLK, CLKFLAG_SKIP_AUTO_OFF);
static DEFINE_CLK_PCOM(p_hdmi_clk, HDMI_CLK, CLKFLAG_SKIP_AUTO_OFF);
-static DEFINE_CLK_PCOM(p_jpeg_clk, JPEG_CLK, 0);
+static DEFINE_CLK_PCOM(p_jpeg_clk, JPEG_CLK, CLKFLAG_MIN);
static DEFINE_CLK_PCOM(p_jpeg_p_clk, JPEG_P_CLK, 0);
static DEFINE_CLK_PCOM(p_lpa_codec_clk, LPA_CODEC_CLK, CLKFLAG_SKIP_AUTO_OFF);
static DEFINE_CLK_PCOM(p_lpa_core_clk, LPA_CORE_CLK, CLKFLAG_SKIP_AUTO_OFF);
@@ -2386,7 +2386,7 @@
static DEFINE_CLK_PCOM(p_csi0_clk, CSI0_CLK, CLKFLAG_SKIP_AUTO_OFF);
static DEFINE_CLK_PCOM(p_csi0_vfe_clk, CSI0_VFE_CLK, CLKFLAG_SKIP_AUTO_OFF);
static DEFINE_CLK_PCOM(p_csi0_p_clk, CSI0_P_CLK, CLKFLAG_SKIP_AUTO_OFF);
-static DEFINE_CLK_PCOM(p_mdp_clk, MDP_CLK, 0);
+static DEFINE_CLK_PCOM(p_mdp_clk, MDP_CLK, CLKFLAG_MIN);
static DEFINE_CLK_PCOM(p_mfc_clk, MFC_CLK, CLKFLAG_SKIP_AUTO_OFF);
static DEFINE_CLK_PCOM(p_mfc_div2_clk, MFC_DIV2_CLK, CLKFLAG_SKIP_AUTO_OFF);
static DEFINE_CLK_PCOM(p_mfc_p_clk, MFC_P_CLK, CLKFLAG_SKIP_AUTO_OFF);
diff --git a/arch/arm/mach-msm/clock-pcom-lookup.c b/arch/arm/mach-msm/clock-pcom-lookup.c
index d1a257d..dd31bd7 100644
--- a/arch/arm/mach-msm/clock-pcom-lookup.c
+++ b/arch/arm/mach-msm/clock-pcom-lookup.c
@@ -87,7 +87,7 @@
static DEFINE_CLK_PCOM(icodec_tx_clk, ICODEC_TX_CLK, CLKFLAG_SKIP_AUTO_OFF);
static DEFINE_CLK_PCOM(imem_clk, IMEM_CLK, 0);
static DEFINE_CLK_PCOM(mdc_clk, MDC_CLK, CLKFLAG_SKIP_AUTO_OFF);
-static DEFINE_CLK_PCOM(mdp_clk, MDP_CLK, 0);
+static DEFINE_CLK_PCOM(mdp_clk, MDP_CLK, CLKFLAG_MIN);
static DEFINE_CLK_PCOM(mdp_lcdc_pad_pclk_clk, MDP_LCDC_PAD_PCLK_CLK,
CLKFLAG_SKIP_AUTO_OFF);
static DEFINE_CLK_PCOM(mdp_lcdc_pclk_clk, MDP_LCDC_PCLK_CLK,
diff --git a/arch/arm/mach-msm/footswitch-8x60.c b/arch/arm/mach-msm/footswitch-8x60.c
index 98447fa..a8e2449 100644
--- a/arch/arm/mach-msm/footswitch-8x60.c
+++ b/arch/arm/mach-msm/footswitch-8x60.c
@@ -256,6 +256,14 @@
udelay(RESET_DELAY_US);
/*
+ * Return clocks to their state before this function. For robustness
+ * if memory-retention across collapses is required, clocks should
+ * be disabled before asserting the clamps. Assuming clocks were off
+ * before entering footswitch_disable(), this will be true.
+ */
+ restore_clocks(fs);
+
+ /*
* Clamp the I/O ports of the core to ensure the values
* remain fixed while the core is collapsed.
*/
@@ -266,9 +274,6 @@
regval &= ~ENABLE_BIT;
writel_relaxed(regval, fs->gfs_ctl_reg);
- /* Return clocks to their state before this function. */
- restore_clocks(fs);
-
fs->is_enabled = false;
return rc;
diff --git a/arch/arm/mach-msm/include/mach/camera.h b/arch/arm/mach-msm/include/mach/camera.h
index 1745f26..b41398e 100644
--- a/arch/arm/mach-msm/include/mach/camera.h
+++ b/arch/arm/mach-msm/include/mach/camera.h
@@ -635,7 +635,6 @@
void msm_camio_clk_rate_set(int rate);
int msm_camio_vfe_clk_rate_set(int rate);
void msm_camio_clk_rate_set_2(struct clk *clk, int rate);
-void msm_camio_clk_set_min_rate(struct clk *clk, int rate);
void msm_camio_clk_axi_rate_set(int rate);
void msm_disable_io_gpio_clk(struct platform_device *);
diff --git a/arch/arm/mach-msm/include/mach/sdio_tty.h b/arch/arm/mach-msm/include/mach/sdio_tty.h
deleted file mode 100644
index 86746b3..0000000
--- a/arch/arm/mach-msm/include/mach/sdio_tty.h
+++ /dev/null
@@ -1,48 +0,0 @@
-/* Copyright (c) 2011, Code Aurora Forum. All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 and
- * only version 2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- */
-
-/*
- * SDIO TTY interface.
- */
-
-#ifndef __SDIO_TTY__
-#define __SDIO_TTY__
-
-/**
- * sdio_tty_init_tty - Initialize the SDIO TTY driver.
- *
- * @tty_name: tty name - identify the tty device.
- * @sdio_ch_name: channel name - identify the channel.
- * @return sdio_tty handle on success, NULL on error.
- *
- */
-void *sdio_tty_init_tty(char *tty_name, char* sdio_ch_name);
-
-/**
- * sdio_tty_uninit_tty - Uninitialize the SDIO TTY driver.
- *
- * @sdio_tty_handle: sdio_tty handle.
- * @return 0 on success, negative value on error.
- */
-int sdio_tty_uninit_tty(void *sdio_tty_handle);
-
-/**
- * sdio_tty_enable_debug_msg - Enable/Disable sdio_tty debug
- * messages.
- *
- * @enable: A flag to indicate if to enable or disable the debug
- * messages.
- * @return 0 on success, negative value on error.
- */
-void sdio_tty_enable_debug_msg(void *sdio_tty_handle, int enable);
-
-#endif /* __SDIO_TTY__ */
diff --git a/arch/arm/mach-msm/modem-8960.c b/arch/arm/mach-msm/modem-8960.c
index f0aa13c..7345a89 100644
--- a/arch/arm/mach-msm/modem-8960.c
+++ b/arch/arm/mach-msm/modem-8960.c
@@ -149,9 +149,58 @@
smsm_reset_modem(SMSM_RESET);
}
-int modem_ramdump(int enable, const struct subsys_data *subsys)
+/* FIXME: Get address, size from PIL */
+static struct ramdump_segment modemsw_segments[] = {
+ {0x89000000, 0x8D400000 - 0x89000000},
+};
+
+static struct ramdump_segment modemfw_segments[] = {
+ {0x8D400000, 0x8DA00000 - 0x8D400000},
+};
+
+static struct ramdump_segment smem_segments[] = {
+ {0x80000000, 0x00200000},
+};
+
+static void *modemfw_ramdump_dev;
+static void *modemsw_ramdump_dev;
+static void *smem_ramdump_dev;
+
+static int modem_ramdump(int enable,
+ const struct subsys_data *crashed_subsys)
{
- return 0;
+ int ret = 0;
+
+ if (enable) {
+ ret = do_ramdump(modemsw_ramdump_dev, modemsw_segments,
+ ARRAY_SIZE(modemsw_segments));
+
+ if (ret < 0) {
+ pr_err("Unable to dump modem sw memory (rc = %d).\n",
+ ret);
+ goto out;
+ }
+
+ ret = do_ramdump(modemfw_ramdump_dev, modemfw_segments,
+ ARRAY_SIZE(modemfw_segments));
+
+ if (ret < 0) {
+ pr_err("Unable to dump modem fw memory (rc = %d).\n",
+ ret);
+ goto out;
+ }
+
+ ret = do_ramdump(smem_ramdump_dev, smem_segments,
+ ARRAY_SIZE(smem_segments));
+
+ if (ret < 0) {
+ pr_err("Unable to dump smem memory (rc = %d).\n", ret);
+ goto out;
+ }
+ }
+
+out:
+ return ret;
}
static irqreturn_t modem_wdog_bite_irq(int irq, void *dev_id)
@@ -263,6 +312,33 @@
goto out;
}
+ modemfw_ramdump_dev = create_ramdump_device("modem_fw");
+
+ if (!modemfw_ramdump_dev) {
+ pr_err("%s: Unable to create modem fw ramdump device. (%d)\n",
+ __func__, -ENOMEM);
+ ret = -ENOMEM;
+ goto out;
+ }
+
+ modemsw_ramdump_dev = create_ramdump_device("modem_sw");
+
+ if (!modemsw_ramdump_dev) {
+ pr_err("%s: Unable to create modem sw ramdump device. (%d)\n",
+ __func__, -ENOMEM);
+ ret = -ENOMEM;
+ goto out;
+ }
+
+ smem_ramdump_dev = create_ramdump_device("smem");
+
+ if (!smem_ramdump_dev) {
+ pr_err("%s: Unable to create smem ramdump device. (%d)\n",
+ __func__, -ENOMEM);
+ ret = -ENOMEM;
+ goto out;
+ }
+
ret = modem_debugfs_init();
pr_info("%s: modem fatal driver init'ed.\n", __func__);
diff --git a/arch/arm/mach-msm/sdio_al_test.c b/arch/arm/mach-msm/sdio_al_test.c
index 8b9abcf..a71aae3 100644
--- a/arch/arm/mach-msm/sdio_al_test.c
+++ b/arch/arm/mach-msm/sdio_al_test.c
@@ -298,6 +298,7 @@
uint32_t smem_counter;
struct platform_device *ciq_app_pdev;
+ struct platform_device *csvt_app_pdev;
wait_queue_head_t wait_q;
int test_completed;
@@ -6162,7 +6163,7 @@
int ret;
pr_debug(TEST_MODULE_NAME ":%s.\n", __func__);
- pr_info(TEST_MODULE_NAME ": init test cahnnel %s.\n", name);
+ pr_info(TEST_MODULE_NAME ": init test channel %s.\n", name);
ch_id = channel_name_to_id(name);
pr_debug(TEST_MODULE_NAME ":id = %d.\n", ch_id);
@@ -6324,6 +6325,35 @@
return sdio_test_channel_remove(pdev);
}
+static int sdio_test_channel_csvt_probe(struct platform_device *pdev)
+{
+ int ret = 0;
+
+ if (!pdev)
+ return -ENODEV;
+
+ test_ctx->csvt_app_pdev = platform_device_alloc("SDIO_CSVT_TEST_APP",
+ -1);
+ ret = platform_device_add(test_ctx->csvt_app_pdev);
+ if (ret) {
+ pr_err(MODULE_NAME ":platform_device_add failed, "
+ "ret=%d\n", ret);
+ return ret;
+ }
+
+ return sdio_test_channel_probe(pdev);
+}
+
+static int sdio_test_channel_csvt_remove(struct platform_device *pdev)
+{
+ if (!pdev)
+ return -ENODEV;
+
+ platform_device_unregister(test_ctx->csvt_app_pdev);
+
+ return sdio_test_channel_remove(pdev);
+}
+
static struct platform_driver sdio_rpc_drv = {
.probe = sdio_test_channel_probe,
.remove = sdio_test_channel_remove,
@@ -6388,8 +6418,8 @@
};
static struct platform_driver sdio_csvt_drv = {
- .probe = sdio_test_channel_probe,
- .remove = sdio_test_channel_remove,
+ .probe = sdio_test_channel_csvt_probe,
+ .remove = sdio_test_channel_csvt_remove,
.driver = {
.name = "SDIO_CSVT_TEST",
.owner = THIS_MODULE,
diff --git a/arch/arm/mach-msm/sdio_tty.c b/arch/arm/mach-msm/sdio_tty.c
index fca88d8..e249d06 100644
--- a/arch/arm/mach-msm/sdio_tty.c
+++ b/arch/arm/mach-msm/sdio_tty.c
@@ -17,6 +17,7 @@
#include <linux/platform_device.h>
#include <linux/tty.h>
#include <linux/tty_flip.h>
+#include <linux/module.h>
#include <mach/sdio_al.h>
#define INPUT_SPEED 4800
@@ -24,6 +25,19 @@
#define SDIO_TTY_MODULE_NAME "sdio_tty"
#define SDIO_TTY_MAX_PACKET_SIZE 4096
#define MAX_SDIO_TTY_DRV 1
+#define MAX_SDIO_TTY_DEVS 2
+#define MAX_SDIO_TTY_DEV_NAME_SIZE 25
+
+/* Configurations per channel device */
+/* CIQ */
+#define SDIO_TTY_CIQ_DEV "sdio_tty_ciq_0"
+#define SDIO_TTY_CIQ_TEST_DEV "sdio_tty_ciq_test_0"
+#define SDIO_TTY_CH_CIQ "SDIO_CIQ"
+
+/* CSVT */
+#define SDIO_TTY_CSVT_DEV "sdio_tty_csvt_0"
+#define SDIO_TTY_CSVT_TEST_DEV "sdio_tty_csvt_test_0"
+#define SDIO_TTY_CH_CSVT "SDIO_CSVT"
enum sdio_tty_state {
TTY_INITIAL = 0,
@@ -32,9 +46,27 @@
TTY_CLOSED = 3,
};
+enum sdio_tty_devices {
+ SDIO_CIQ,
+ SDIO_CIQ_TEST_APP,
+ SDIO_CSVT,
+ SDIO_CSVT_TEST_APP,
+};
+
+static const struct platform_device_id sdio_tty_id_table[] = {
+ { "SDIO_CIQ", SDIO_CIQ },
+ { "SDIO_CIQ_TEST_APP", SDIO_CIQ_TEST_APP },
+ { "SDIO_CSVT", SDIO_CSVT },
+ { "SDIO_CSVT_TEST_APP", SDIO_CSVT_TEST_APP },
+ { },
+};
+MODULE_DEVICE_TABLE(platform, sdio_tty_id_table);
+
struct sdio_tty {
struct sdio_channel *ch;
char *sdio_ch_name;
+ char tty_dev_name[MAX_SDIO_TTY_DEV_NAME_SIZE];
+ int device_id;
struct workqueue_struct *workq;
struct work_struct work_read;
wait_queue_head_t waitq;
@@ -44,11 +76,21 @@
char *read_buf;
enum sdio_tty_state sdio_tty_state;
int is_sdio_open;
+ int tty_open_count;
};
-static struct sdio_tty *sdio_tty;
+static struct sdio_tty *sdio_tty[MAX_SDIO_TTY_DEVS];
-#define DEBUG_MSG(sdio_tty, x...) if (sdio_tty->debug_msg_on) pr_info(x)
+#define DEBUG_MSG(sdio_tty_drv, x...) if (sdio_tty_drv->debug_msg_on) pr_info(x)
+
+/*
+ * Enable sdio_tty debug messages
+ * By default the sdio_tty debug messages are turned off
+ */
+static int ciq_debug_msg_on;
+module_param(ciq_debug_msg_on, int, 0);
+static int csvt_debug_msg_on;
+module_param(csvt_debug_msg_on, int, 0);
static void sdio_tty_read(struct work_struct *work)
{
@@ -62,30 +104,30 @@
sdio_tty_drv = container_of(work, struct sdio_tty, work_read);
if (!sdio_tty_drv) {
- pr_err(SDIO_TTY_MODULE_NAME ": %s: NULL sdio_tty",
- __func__);
+ pr_err(SDIO_TTY_MODULE_NAME ": %s: NULL sdio_tty", __func__);
return ;
}
if (sdio_tty_drv->sdio_tty_state != TTY_OPENED) {
pr_err(SDIO_TTY_MODULE_NAME ": %s: sdio_tty_state = %d",
- __func__, sdio_tty_drv->sdio_tty_state);
+ __func__, sdio_tty_drv->sdio_tty_state);
return;
}
if (!sdio_tty_drv->read_buf) {
- pr_err(SDIO_TTY_MODULE_NAME ": %s: NULL read_buf", __func__);
+ pr_err(SDIO_TTY_MODULE_NAME ": %s: NULL read_buf for dev %s",
+ __func__, sdio_tty_drv->tty_dev_name);
return;
}
- /* Read the data from teh SDIO channel as long as there is available
+ /* Read the data from the SDIO channel as long as there is available
data */
while (1) {
if (test_bit(TTY_THROTTLED, &sdio_tty_drv->tty_str->flags)) {
- DEBUG_MSG(sdio_tty_drv,
- SDIO_TTY_MODULE_NAME ": %s: TTY_THROTTLED bit"
- " is set, exit",
- __func__);
+ DEBUG_MSG(sdio_tty_drv, SDIO_TTY_MODULE_NAME
+ ": %s: TTY_THROTTLED bit is set for "
+ "dev %s, exit", __func__,
+ sdio_tty_drv->tty_dev_name);
return;
}
@@ -93,20 +135,22 @@
read_avail = sdio_read_avail(sdio_tty_drv->ch);
DEBUG_MSG(sdio_tty_drv, SDIO_TTY_MODULE_NAME
- ": %s: read_avail is %d", __func__,
- read_avail);
+ ": %s: read_avail is %d for dev %s", __func__,
+ read_avail, sdio_tty_drv->tty_dev_name);
if (read_avail == 0) {
- DEBUG_MSG(sdio_tty_drv,
- SDIO_TTY_MODULE_NAME ": %s: read_avail is 0",
- __func__);
+ DEBUG_MSG(sdio_tty_drv, SDIO_TTY_MODULE_NAME
+ ": %s: read_avail is 0 for dev %s",
+ __func__, sdio_tty_drv->tty_dev_name);
return;
}
if (read_avail > SDIO_TTY_MAX_PACKET_SIZE) {
pr_err(SDIO_TTY_MODULE_NAME ": %s: read_avail(%d) is "
- "bigger than SDIO_TTY_MAX_PACKET_SIZE(%d)",
- __func__, read_avail, SDIO_TTY_MAX_PACKET_SIZE);
+ "bigger than SDIO_TTY_MAX_PACKET_SIZE(%d) "
+ "for dev %s", __func__, read_avail,
+ SDIO_TTY_MAX_PACKET_SIZE,
+ sdio_tty_drv->tty_dev_name);
return;
}
@@ -114,8 +158,9 @@
sdio_tty_drv->read_buf,
read_avail);
if (ret < 0) {
- pr_err(SDIO_TTY_MODULE_NAME ": %s: sdio_read error(%d)",
- __func__, ret);
+ pr_err(SDIO_TTY_MODULE_NAME ": %s: sdio_read error(%d) "
+ "for dev %s", __func__, ret,
+ sdio_tty_drv->tty_dev_name);
return;
}
@@ -132,15 +177,17 @@
if (total_push != read_avail) {
pr_err(SDIO_TTY_MODULE_NAME ": %s: failed, total_push"
- "(%d) != read_avail(%d)\n",
- __func__, total_push, read_avail);
+ "(%d) != read_avail(%d) for dev %s\n",
+ __func__, total_push, read_avail,
+ sdio_tty_drv->tty_dev_name);
}
tty_flip_buffer_push(sdio_tty_drv->tty_str);
- DEBUG_MSG(sdio_tty_drv,
- SDIO_TTY_MODULE_NAME ": %s: End of read %d bytes",
- __func__, read_avail);
+ DEBUG_MSG(sdio_tty_drv, SDIO_TTY_MODULE_NAME
+ ": %s: End of read %d bytes for dev %s",
+ __func__, read_avail,
+ sdio_tty_drv->tty_dev_name);
}
}
@@ -159,27 +206,26 @@
struct sdio_tty *sdio_tty_drv = NULL;
if (!tty) {
- pr_err(SDIO_TTY_MODULE_NAME ": %s: NULL tty",
- __func__);
+ pr_err(SDIO_TTY_MODULE_NAME ": %s: NULL tty", __func__);
return -ENODEV;
}
sdio_tty_drv = tty->driver_data;
if (!sdio_tty_drv) {
pr_err(SDIO_TTY_MODULE_NAME ": %s: NULL sdio_tty_drv",
- __func__);
+ __func__);
return -ENODEV;
}
if (sdio_tty_drv->sdio_tty_state != TTY_OPENED) {
pr_err(SDIO_TTY_MODULE_NAME ": %s: sdio_tty_state = %d",
- __func__, sdio_tty_drv->sdio_tty_state);
+ __func__, sdio_tty_drv->sdio_tty_state);
return -EPERM;
}
write_avail = sdio_write_avail(sdio_tty_drv->ch);
- DEBUG_MSG(sdio_tty_drv,
- SDIO_TTY_MODULE_NAME ": %s: write_avail=%d",
- __func__, write_avail);
+ DEBUG_MSG(sdio_tty_drv, SDIO_TTY_MODULE_NAME ": %s: write_avail=%d "
+ "for dev %s", __func__, write_avail,
+ sdio_tty_drv->tty_dev_name);
return write_avail;
}
@@ -205,60 +251,60 @@
struct sdio_tty *sdio_tty_drv = NULL;
if (!tty) {
- pr_err(SDIO_TTY_MODULE_NAME ": %s: NULL tty",
- __func__);
+ pr_err(SDIO_TTY_MODULE_NAME ": %s: NULL tty", __func__);
return -ENODEV;
}
sdio_tty_drv = tty->driver_data;
if (!sdio_tty_drv) {
pr_err(SDIO_TTY_MODULE_NAME ": %s: NULL sdio_tty_drv",
- __func__);
+ __func__);
return -ENODEV;
}
if (sdio_tty_drv->sdio_tty_state != TTY_OPENED) {
pr_err(SDIO_TTY_MODULE_NAME ": %s: sdio_tty_state = %d",
- __func__, sdio_tty_drv->sdio_tty_state);
+ __func__, sdio_tty_drv->sdio_tty_state);
return -EPERM;
}
- DEBUG_MSG(sdio_tty_drv,
- SDIO_TTY_MODULE_NAME ": %s: WRITING CALLBACK CALLED WITH "
- "%d bytes\n",
- __func__, count);
+ DEBUG_MSG(sdio_tty_drv, SDIO_TTY_MODULE_NAME ": %s: Write Callback "
+ "called with %d bytes for dev %s\n", __func__, count,
+ sdio_tty_drv->tty_dev_name);
write_avail = sdio_write_avail(sdio_tty_drv->ch);
if (write_avail == 0) {
- DEBUG_MSG(sdio_tty_drv,
- SDIO_TTY_MODULE_NAME ": %s: write_avail is 0\n",
- __func__);
+ DEBUG_MSG(sdio_tty_drv, SDIO_TTY_MODULE_NAME ": %s: "
+ "write_avail is 0 for dev %s\n",
+ __func__, sdio_tty_drv->tty_dev_name);
return 0;
}
if (write_avail > SDIO_TTY_MAX_PACKET_SIZE) {
- DEBUG_MSG(sdio_tty_drv,
- SDIO_TTY_MODULE_NAME ": %s: write_avail(%d) is "
- "bigger than max packet size,(%d), setting to "
- "max_packet_size\n",
- __func__, write_avail, SDIO_TTY_MAX_PACKET_SIZE);
+ DEBUG_MSG(sdio_tty_drv, SDIO_TTY_MODULE_NAME ": %s: "
+ "write_avail(%d) is bigger than max packet "
+ "size(%d) for dev %s, setting to "
+ "max_packet_size\n", __func__, write_avail,
+ SDIO_TTY_MAX_PACKET_SIZE,
+ sdio_tty_drv->tty_dev_name);
write_avail = SDIO_TTY_MAX_PACKET_SIZE;
}
if (write_avail < count) {
- DEBUG_MSG(sdio_tty_drv,
- SDIO_TTY_MODULE_NAME ": %s: write_avail(%d) is "
- "smaller than "
- "required(%d), writing only %d bytes\n",
- __func__, write_avail, count, write_avail);
+ DEBUG_MSG(sdio_tty_drv, SDIO_TTY_MODULE_NAME ": %s: "
+ "write_avail(%d) is smaller than required(%d) "
+ "for dev %s, writing only %d bytes\n",
+ __func__, write_avail, count,
+ sdio_tty_drv->tty_dev_name, write_avail);
len = write_avail;
}
ret = sdio_write(sdio_tty_drv->ch, buf, len);
if (ret) {
- pr_err(SDIO_TTY_MODULE_NAME ": %s: sdio_write failed, ret=%d\n",
- __func__, ret);
+ pr_err(SDIO_TTY_MODULE_NAME ": %s: sdio_write failed for "
+ "dev %s, ret=%d\n", __func__,
+ sdio_tty_drv->tty_dev_name, ret);
return 0;
}
- DEBUG_MSG(sdio_tty_drv,
- SDIO_TTY_MODULE_NAME ": %s: End of function, len=%d bytes\n",
- __func__, len);
+ DEBUG_MSG(sdio_tty_drv, SDIO_TTY_MODULE_NAME ": %s: End of function, "
+ "dev=%s, len=%d bytes\n", __func__,
+ sdio_tty_drv->tty_dev_name, len);
return len;
}
@@ -269,18 +315,18 @@
if (!sdio_tty_drv) {
pr_err(SDIO_TTY_MODULE_NAME ": %s: NULL sdio_tty_drv",
- __func__);
+ __func__);
}
if (sdio_tty_drv->sdio_tty_state != TTY_OPENED) {
pr_err(SDIO_TTY_MODULE_NAME ": %s: sdio_tty_state = %d",
- __func__, sdio_tty_drv->sdio_tty_state);
+ __func__, sdio_tty_drv->sdio_tty_state);
return;
}
- DEBUG_MSG(sdio_tty_drv,
- SDIO_TTY_MODULE_NAME ": %s: event %d received\n", __func__,
- event);
+ DEBUG_MSG(sdio_tty_drv, SDIO_TTY_MODULE_NAME ": %s: event %d "
+ "received for dev %s\n", __func__, event,
+ sdio_tty_drv->tty_dev_name);
if (event == SDIO_EVENT_DATA_READ_AVAIL)
queue_work(sdio_tty_drv->workq, &sdio_tty_drv->work_read);
@@ -298,20 +344,37 @@
static int sdio_tty_open(struct tty_struct *tty, struct file *file)
{
int ret = 0;
+ int i = 0;
struct sdio_tty *sdio_tty_drv = NULL;
if (!tty) {
- pr_err(SDIO_TTY_MODULE_NAME ": %s: NULL tty",
- __func__);
+ pr_err(SDIO_TTY_MODULE_NAME ": %s: NULL tty", __func__);
return -ENODEV;
}
- sdio_tty_drv = sdio_tty;
+
+ for (i = 0; i < MAX_SDIO_TTY_DEVS; i++) {
+ if (sdio_tty[i] == NULL)
+ continue;
+ if (!strncmp(sdio_tty[i]->tty_dev_name, tty->name,
+ MAX_SDIO_TTY_DEV_NAME_SIZE)) {
+ sdio_tty_drv = sdio_tty[i];
+ break;
+ }
+ }
+
if (!sdio_tty_drv) {
pr_err(SDIO_TTY_MODULE_NAME ": %s: NULL sdio_tty_drv",
__func__);
return -ENODEV;
}
+ sdio_tty_drv->tty_open_count++;
+ if (sdio_tty_drv->sdio_tty_state == TTY_OPENED) {
+ pr_err(SDIO_TTY_MODULE_NAME ": %s: tty dev(%s) is already open",
+ __func__, sdio_tty_drv->tty_dev_name);
+ return -EBUSY;
+ }
+
tty->driver_data = sdio_tty_drv;
sdio_tty_drv->tty_str = tty;
@@ -321,36 +384,31 @@
sdio_tty_drv->read_buf = kzalloc(SDIO_TTY_MAX_PACKET_SIZE, GFP_KERNEL);
if (sdio_tty_drv->read_buf == NULL) {
- pr_err(SDIO_TTY_MODULE_NAME ": %s: failed to allocate read_buf",
- __func__);
+ pr_err(SDIO_TTY_MODULE_NAME ": %s: failed to allocate read_buf "
+ "for dev %s", __func__, sdio_tty_drv->tty_dev_name);
return -ENOMEM;
}
sdio_tty_drv->workq = create_singlethread_workqueue("sdio_tty_read");
if (!sdio_tty_drv->workq) {
- pr_err(SDIO_TTY_MODULE_NAME ": %s: failed to create workq",
- __func__);
+ pr_err(SDIO_TTY_MODULE_NAME ": %s: failed to create workq "
+ "for dev %s", __func__, sdio_tty_drv->tty_dev_name);
return -ENOMEM;
}
- if (sdio_tty_drv->sdio_tty_state == TTY_OPENED) {
- pr_err(SDIO_TTY_MODULE_NAME ": %s: tty is already open",
- __func__);
- return -EBUSY;
- }
-
if (!sdio_tty_drv->is_sdio_open) {
ret = sdio_open(sdio_tty_drv->sdio_ch_name, &sdio_tty_drv->ch,
sdio_tty_drv, sdio_tty_notify);
if (ret < 0) {
- pr_err(SDIO_TTY_MODULE_NAME ": %s: sdio_open err=%d\n",
- __func__, ret);
+ pr_err(SDIO_TTY_MODULE_NAME ": %s: sdio_open err=%d "
+ "for dev %s\n", __func__, ret,
+ sdio_tty_drv->tty_dev_name);
destroy_workqueue(sdio_tty_drv->workq);
return ret;
}
- pr_info(SDIO_TTY_MODULE_NAME ": %s: SDIO_TTY channel opened\n",
- __func__);
+ pr_info(SDIO_TTY_MODULE_NAME ": %s: SDIO_TTY channel(%s) opened "
+ "\n", __func__, sdio_tty_drv->sdio_ch_name);
sdio_tty_drv->is_sdio_open = 1;
} else {
@@ -363,8 +421,8 @@
sdio_tty_drv->sdio_tty_state = TTY_OPENED;
- pr_info(SDIO_TTY_MODULE_NAME ": %s: TTY device opened\n",
- __func__);
+ pr_info(SDIO_TTY_MODULE_NAME ": %s: TTY device(%s) opened\n",
+ __func__, sdio_tty_drv->tty_dev_name);
return ret;
}
@@ -385,8 +443,7 @@
struct sdio_tty *sdio_tty_drv = NULL;
if (!tty) {
- pr_err(SDIO_TTY_MODULE_NAME ": %s: NULL tty",
- __func__);
+ pr_err(SDIO_TTY_MODULE_NAME ": %s: NULL tty", __func__);
return;
}
sdio_tty_drv = tty->driver_data;
@@ -397,10 +454,11 @@
}
if (sdio_tty_drv->sdio_tty_state != TTY_OPENED) {
pr_err(SDIO_TTY_MODULE_NAME ": %s: trying to close a "
- "TTY device that was not opened\n",
- __func__);
+ "TTY device that was not opened\n", __func__);
return;
}
+ if (--sdio_tty_drv->tty_open_count != 0)
+ return;
flush_workqueue(sdio_tty_drv->workq);
destroy_workqueue(sdio_tty_drv->workq);
@@ -410,8 +468,8 @@
sdio_tty_drv->sdio_tty_state = TTY_CLOSED;
- pr_info(SDIO_TTY_MODULE_NAME ": %s: SDIO_TTY channel closed\n",
- __func__);
+ pr_info(SDIO_TTY_MODULE_NAME ": %s: SDIO_TTY device(%s) closed\n",
+ __func__, sdio_tty_drv->tty_dev_name);
}
static void sdio_tty_unthrottle(struct tty_struct *tty)
@@ -419,8 +477,7 @@
struct sdio_tty *sdio_tty_drv = NULL;
if (!tty) {
- pr_err(SDIO_TTY_MODULE_NAME ": %s: NULL tty",
- __func__);
+ pr_err(SDIO_TTY_MODULE_NAME ": %s: NULL tty", __func__);
return;
}
sdio_tty_drv = tty->driver_data;
@@ -448,33 +505,53 @@
.unthrottle = sdio_tty_unthrottle,
};
-void *sdio_tty_init_tty(char *tty_name, char *sdio_ch_name)
+int sdio_tty_init_tty(char *tty_name, char *sdio_ch_name,
+ enum sdio_tty_devices device_id, int debug_msg_on)
{
int ret = 0;
- struct device *tty_dev;
- struct sdio_tty *sdio_tty_drv;
-
- pr_info(SDIO_TTY_MODULE_NAME ": %s\n", __func__);
+ int i = 0;
+ struct device *tty_dev = NULL;
+ struct sdio_tty *sdio_tty_drv = NULL;
sdio_tty_drv = kzalloc(sizeof(struct sdio_tty), GFP_KERNEL);
if (sdio_tty_drv == NULL) {
- pr_err(SDIO_TTY_MODULE_NAME "%s: failed to allocate sdio_tty",
- __func__);
- return NULL;
+ pr_err(SDIO_TTY_MODULE_NAME ": %s: failed to allocate sdio_tty "
+ "for dev %s", __func__, tty_name);
+ return -ENOMEM;
}
- sdio_tty = sdio_tty_drv;
+ for (i = 0; i < MAX_SDIO_TTY_DEVS; i++) {
+ if (sdio_tty[i] == NULL) {
+ sdio_tty[i] = sdio_tty_drv;
+ break;
+ }
+ }
+
+ if (i == MAX_SDIO_TTY_DEVS) {
+ pr_err(SDIO_TTY_MODULE_NAME ": %s: tty dev(%s) creation failed,"
+ " max limit(%d) reached.", __func__, tty_name,
+ MAX_SDIO_TTY_DEVS);
+ kfree(sdio_tty_drv);
+ return -ENODEV;
+ }
+
+ snprintf(sdio_tty_drv->tty_dev_name, MAX_SDIO_TTY_DEV_NAME_SIZE,
+ "%s%d", tty_name, 0);
sdio_tty_drv->sdio_ch_name = sdio_ch_name;
+ sdio_tty_drv->device_id = device_id;
+ pr_info(SDIO_TTY_MODULE_NAME ": %s: dev=%s, id=%d, channel=%s\n",
+ __func__, sdio_tty_drv->tty_dev_name, sdio_tty_drv->device_id,
+ sdio_tty_drv->sdio_ch_name);
INIT_WORK(&sdio_tty_drv->work_read, sdio_tty_read);
sdio_tty_drv->tty_drv = alloc_tty_driver(MAX_SDIO_TTY_DRV);
if (!sdio_tty_drv->tty_drv) {
- pr_err(SDIO_TTY_MODULE_NAME ": %s - tty_drv is NULL",
- __func__);
+ pr_err(SDIO_TTY_MODULE_NAME ": %s - tty_drv is NULL for dev %s",
+ __func__, sdio_tty_drv->tty_dev_name);
kfree(sdio_tty_drv);
- return NULL;
+ return -ENODEV;
}
sdio_tty_drv->tty_drv->name = tty_name;
@@ -500,31 +577,38 @@
if (ret) {
put_tty_driver(sdio_tty_drv->tty_drv);
pr_err(SDIO_TTY_MODULE_NAME ": %s: tty_register_driver() "
- "failed\n", __func__);
+ "failed for dev %s\n", __func__,
+ sdio_tty_drv->tty_dev_name);
sdio_tty_drv->tty_drv = NULL;
kfree(sdio_tty_drv);
- return NULL;
+ return -ENODEV;
}
tty_dev = tty_register_device(sdio_tty_drv->tty_drv, 0, NULL);
if (IS_ERR(tty_dev)) {
pr_err(SDIO_TTY_MODULE_NAME ": %s: tty_register_device() "
- "failed\n", __func__);
+ "failed for dev %s\n", __func__,
+ sdio_tty_drv->tty_dev_name);
tty_unregister_driver(sdio_tty_drv->tty_drv);
put_tty_driver(sdio_tty_drv->tty_drv);
kfree(sdio_tty_drv);
- return NULL;
+ return -ENODEV;
}
sdio_tty_drv->sdio_tty_state = TTY_REGISTERED;
- return sdio_tty_drv;
+ if (debug_msg_on) {
+ pr_info(SDIO_TTY_MODULE_NAME ": %s: turn on debug msg for %s",
+ __func__, sdio_tty_drv->tty_dev_name);
+ sdio_tty_drv->debug_msg_on = debug_msg_on;
+ }
+ return 0;
}
-EXPORT_SYMBOL(sdio_tty_init_tty);
int sdio_tty_uninit_tty(void *sdio_tty_handle)
{
int ret = 0;
+ int i = 0;
struct sdio_tty *sdio_tty_drv = sdio_tty_handle;
if (!sdio_tty_drv) {
@@ -546,51 +630,151 @@
ret = tty_unregister_driver(sdio_tty_drv->tty_drv);
if (ret) {
pr_err(SDIO_TTY_MODULE_NAME ": %s: "
- "tty_unregister_driver() failed\n", __func__);
+ "tty_unregister_driver() failed for dev %s\n",
+ __func__, sdio_tty_drv->tty_dev_name);
}
put_tty_driver(sdio_tty_drv->tty_drv);
sdio_tty_drv->sdio_tty_state = TTY_INITIAL;
sdio_tty_drv->tty_drv = NULL;
}
- pr_info(SDIO_TTY_MODULE_NAME ": %s: Freeing sdio_tty structure",
- __func__);
+ for (i = 0; i < MAX_SDIO_TTY_DEVS; i++) {
+ if (sdio_tty[i] == NULL)
+ continue;
+ if (sdio_tty[i]->device_id == sdio_tty_drv->device_id) {
+ sdio_tty[i] = NULL;
+ break;
+ }
+ }
+
+ DEBUG_MSG(sdio_tty_drv, SDIO_TTY_MODULE_NAME ": %s: Freeing sdio_tty "
+ "structure, dev=%s", __func__,
+ sdio_tty_drv->tty_dev_name);
kfree(sdio_tty_drv);
return 0;
}
-EXPORT_SYMBOL(sdio_tty_uninit_tty);
-
-void sdio_tty_enable_debug_msg(void *sdio_tty_handle, int enable)
+static int sdio_tty_probe(struct platform_device *pdev)
{
- struct sdio_tty *sdio_tty_drv = sdio_tty_handle;
+ const struct platform_device_id *id = platform_get_device_id(pdev);
+ enum sdio_tty_devices device_id = id->driver_data;
+ char *device_name = NULL;
+ char *channel_name = NULL;
+ int debug_msg_on = 0;
+ int ret = 0;
+
+ pr_debug(SDIO_TTY_MODULE_NAME ": %s for %s", __func__, pdev->name);
+
+ switch (device_id) {
+ case SDIO_CIQ:
+ device_name = SDIO_TTY_CIQ_DEV;
+ channel_name = SDIO_TTY_CH_CIQ;
+ debug_msg_on = ciq_debug_msg_on;
+ break;
+ case SDIO_CIQ_TEST_APP:
+ device_name = SDIO_TTY_CIQ_TEST_DEV;
+ channel_name = SDIO_TTY_CH_CIQ;
+ debug_msg_on = ciq_debug_msg_on;
+ break;
+ case SDIO_CSVT:
+ device_name = SDIO_TTY_CSVT_DEV;
+ channel_name = SDIO_TTY_CH_CSVT;
+ debug_msg_on = csvt_debug_msg_on;
+ break;
+ case SDIO_CSVT_TEST_APP:
+ device_name = SDIO_TTY_CSVT_TEST_DEV;
+ channel_name = SDIO_TTY_CH_CSVT;
+ debug_msg_on = csvt_debug_msg_on;
+ break;
+ default:
+ pr_err(SDIO_TTY_MODULE_NAME ": %s Invalid device:%s, id:%d",
+ __func__, pdev->name, device_id);
+ ret = -ENODEV;
+ break;
+ }
+
+ if (device_name) {
+ ret = sdio_tty_init_tty(device_name, channel_name,
+ device_id, debug_msg_on);
+ if (ret) {
+ pr_err(SDIO_TTY_MODULE_NAME ": %s: sdio_tty_init_tty "
+ "failed for dev:%s", __func__, device_name);
+ }
+ }
+ return ret;
+}
+
+static int sdio_tty_remove(struct platform_device *pdev)
+{
+ const struct platform_device_id *id = platform_get_device_id(pdev);
+ enum sdio_tty_devices device_id = id->driver_data;
+ struct sdio_tty *sdio_tty_drv = NULL;
+ int i = 0;
+ int ret = 0;
+
+ pr_debug(SDIO_TTY_MODULE_NAME ": %s for %s", __func__, pdev->name);
+
+ for (i = 0; i < MAX_SDIO_TTY_DEVS; i++) {
+ if (sdio_tty[i] == NULL)
+ continue;
+ if (sdio_tty[i]->device_id == device_id) {
+ sdio_tty_drv = sdio_tty[i];
+ break;
+ }
+ }
if (!sdio_tty_drv) {
pr_err(SDIO_TTY_MODULE_NAME ": %s: NULL sdio_tty_drv",
__func__);
- return;
+ return -ENODEV;
}
- pr_info(SDIO_TTY_MODULE_NAME ": %s: setting debug_msg_on to %d",
- __func__, enable);
- sdio_tty_drv->debug_msg_on = enable;
+
+ ret = sdio_tty_uninit_tty(sdio_tty_drv);
+ if (ret) {
+ pr_err(SDIO_TTY_MODULE_NAME ": %s: sdio_tty_uninit_tty "
+ "failed for %s", __func__, pdev->name);
+ }
+ return ret;
}
-EXPORT_SYMBOL(sdio_tty_enable_debug_msg);
+static struct platform_driver sdio_tty_pdrv = {
+ .probe = sdio_tty_probe,
+ .remove = sdio_tty_remove,
+ .id_table = sdio_tty_id_table,
+ .driver = {
+ .name = "SDIO_TTY",
+ .owner = THIS_MODULE,
+ },
+};
+/*
+ * Module Init.
+ *
+ * Register SDIO TTY driver.
+ *
+ */
static int __init sdio_tty_init(void)
{
- return 0;
+ int ret = 0;
+
+ ret = platform_driver_register(&sdio_tty_pdrv);
+ if (ret) {
+ pr_err(SDIO_TTY_MODULE_NAME ": %s: platform_driver_register "
+ "failed", __func__);
+ }
+ return ret;
};
/*
* Module Exit.
*
- * Unregister SDIO driver.
+ * Unregister SDIO TTY driver.
*
*/
static void __exit sdio_tty_exit(void)
{
+ platform_driver_unregister(&sdio_tty_pdrv);
}
module_init(sdio_tty_init);
diff --git a/arch/arm/mach-msm/sdio_tty_ciq.c b/arch/arm/mach-msm/sdio_tty_ciq.c
deleted file mode 100644
index 64b772d..0000000
--- a/arch/arm/mach-msm/sdio_tty_ciq.c
+++ /dev/null
@@ -1,134 +0,0 @@
-/* Copyright (c) 2011, Code Aurora Forum. All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 and
- * only version 2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- */
-
-#include <linux/slab.h>
-#include <linux/platform_device.h>
-#include <linux/debugfs.h>
-#include <mach/sdio_al.h>
-#include <mach/sdio_tty.h>
-
-#define SDIO_TTY_DEV "sdio_tty_ciq_0"
-#define SDIO_CIQ "sdio_ciq"
-#define SDIO_TTY_DEV_TEST "sdio_tty_ciq_test_0"
-#define TTY_CIQ_MODULE_NAME "sdio_tty_ciq"
-
-struct sdio_tty_ciq {
- void *sdio_tty_handle;
-};
-
-static struct sdio_tty_ciq sdio_tty_ciq;
-
-/*
- * Enable sdio_tty debug messages
- * By default the sdio_tty debug messages are turned off
- */
-static int debug_msg_on;
-module_param(debug_msg_on, int, 0);
-
-static int sdio_tty_probe(struct platform_device *pdev)
-{
- sdio_tty_ciq.sdio_tty_handle = sdio_tty_init_tty(SDIO_TTY_DEV,
- "SDIO_CIQ");
- if (!sdio_tty_ciq.sdio_tty_handle) {
- pr_err(TTY_CIQ_MODULE_NAME ": %s: NULL sdio_tty_handle",
- __func__);
- return -ENODEV;
- }
-
- if (debug_msg_on)
- sdio_tty_enable_debug_msg(sdio_tty_ciq.sdio_tty_handle,
- debug_msg_on);
-
- return 0;
-}
-
-static int sdio_tty_test_probe(struct platform_device *pdev)
-{
- sdio_tty_ciq.sdio_tty_handle = sdio_tty_init_tty(SDIO_TTY_DEV_TEST,
- "SDIO_CIQ");
- if (!sdio_tty_ciq.sdio_tty_handle) {
- pr_err(TTY_CIQ_MODULE_NAME ": %s: NULL sdio_tty_handle",
- __func__);
- return -ENODEV;
- }
-
- if (debug_msg_on)
- sdio_tty_enable_debug_msg(sdio_tty_ciq.sdio_tty_handle,
- debug_msg_on);
-
- return 0;
-}
-
-static int sdio_tty_remove(struct platform_device *pdev)
-{
- int ret = 0;
-
- pr_info(TTY_CIQ_MODULE_NAME ": %s", __func__);
- ret = sdio_tty_uninit_tty(sdio_tty_ciq.sdio_tty_handle);
- if (ret) {
- pr_err(TTY_CIQ_MODULE_NAME ": %s: sdio_tty_uninit_tty failed",
- __func__);
- return ret;
- }
-
- return 0;
-}
-
-static struct platform_driver sdio_tty_pdrv = {
- .probe = sdio_tty_probe,
- .remove = sdio_tty_remove,
- .driver = {
- .name = "SDIO_CIQ",
- .owner = THIS_MODULE,
- },
-};
-
-static struct platform_driver sdio_tty_test_pdrv = {
- .probe = sdio_tty_test_probe,
- .remove = sdio_tty_remove,
- .driver = {
- .name = "SDIO_CIQ_TEST_APP",
- .owner = THIS_MODULE,
- },
-};
-
-static int __init sdio_tty_ciq_init(void)
-{
- int ret = 0;
-
- ret = platform_driver_register(&sdio_tty_pdrv);
- if (ret) {
- pr_err(TTY_CIQ_MODULE_NAME ": %s: platform_driver_register "
- "failed", __func__);
- return ret;
- }
- return platform_driver_register(&sdio_tty_test_pdrv);
-};
-
-/*
- * Module Exit.
- *
- * Unregister SDIO driver.
- *
- */
-static void __exit sdio_tty_ciq_exit(void)
-{
- platform_driver_unregister(&sdio_tty_pdrv);
- platform_driver_unregister(&sdio_tty_test_pdrv);
-}
-
-module_init(sdio_tty_ciq_init);
-module_exit(sdio_tty_ciq_exit);
-
-MODULE_DESCRIPTION("SDIO TTY CIQ");
-MODULE_LICENSE("GPL v2");
-MODULE_AUTHOR("Maya Erez <merez@codeaurora.org>");
diff --git a/arch/arm/mm/init.c b/arch/arm/mm/init.c
index 5739a34..e5e3486 100644
--- a/arch/arm/mm/init.c
+++ b/arch/arm/mm/init.c
@@ -637,6 +637,9 @@
extern u32 dtcm_end;
extern u32 itcm_end;
#endif
+#ifdef CONFIG_FIX_MOVABLE_ZONE
+ struct zone *zone;
+#endif
max_mapnr = pfn_to_page(max_pfn + PHYS_PFN_OFFSET) - mem_map;
@@ -682,6 +685,14 @@
#endif
}
+#ifdef CONFIG_FIX_MOVABLE_ZONE
+ for_each_zone(zone) {
+ if (zone_idx(zone) == ZONE_MOVABLE)
+ total_unmovable_pages = totalram_pages -
+ zone->spanned_pages;
+ }
+#endif
+
/*
* Since our memory may not be contiguous, calculate the
* real number of pages we have in this system
@@ -784,6 +795,7 @@
void free_initmem(void)
{
+ unsigned long reclaimed_initmem;
#ifdef CONFIG_HAVE_TCM
extern char __tcm_start, __tcm_end;
@@ -792,10 +804,15 @@
"TCM link");
#endif
- if (!machine_is_integrator() && !machine_is_cintegrator())
- totalram_pages += free_area(__phys_to_pfn(__pa(__init_begin)),
+ if (!machine_is_integrator() && !machine_is_cintegrator()) {
+ reclaimed_initmem = free_area(__phys_to_pfn(__pa(__init_begin)),
__phys_to_pfn(__pa(__init_end)),
"init");
+ totalram_pages += reclaimed_initmem;
+#ifdef CONFIG_FIX_MOVABLE_ZONE
+ total_unmovable_pages += reclaimed_initmem;
+#endif
+ }
}
#ifdef CONFIG_MEMORY_HOTPLUG
@@ -831,10 +848,16 @@
void free_initrd_mem(unsigned long start, unsigned long end)
{
- if (!keep_initrd)
- totalram_pages += free_area(__phys_to_pfn(__pa(start)),
+ unsigned long reclaimed_initrd_mem;
+ if (!keep_initrd) {
+ reclaimed_initrd_mem = free_area(__phys_to_pfn(__pa(start)),
__phys_to_pfn(__pa(end)),
"initrd");
+ totalram_pages += reclaimed_initrd_mem;
+#ifdef CONFIG_FIX_MOVABLE_ZONE
+ total_unmovable_pages += reclaimed_initrd_mem;
+#endif
+ }
}
static int __init keepinitrd_setup(char *__unused)
diff --git a/drivers/gpu/ion/ion.c b/drivers/gpu/ion/ion.c
index 40bea8d..e659df5 100644
--- a/drivers/gpu/ion/ion.c
+++ b/drivers/gpu/ion/ion.c
@@ -978,7 +978,6 @@
struct rb_node **p;
struct rb_node *parent = NULL;
struct ion_client *entry;
- char debug_name[64];
pid_t pid;
get_task_struct(current->group_leader);
@@ -1048,8 +1047,8 @@
rb_insert_color(&client->node, &dev->kernel_clients);
}
- snprintf(debug_name, 64, "%u", client->pid);
- client->debug_root = debugfs_create_file(debug_name, 0664,
+
+ client->debug_root = debugfs_create_file(name, 0664,
dev->debug_root, client,
&debug_client_fops);
mutex_unlock(&dev->lock);
@@ -1497,9 +1496,11 @@
struct miscdevice *miscdev = file->private_data;
struct ion_device *dev = container_of(miscdev, struct ion_device, dev);
struct ion_client *client;
+ char debug_name[64];
pr_debug("%s: %d\n", __func__, __LINE__);
- client = ion_client_create(dev, -1, "user");
+ snprintf(debug_name, 64, "%u", task_pid_nr(current->group_leader));
+ client = ion_client_create(dev, -1, debug_name);
if (IS_ERR_OR_NULL(client))
return PTR_ERR(client);
file->private_data = client;
diff --git a/drivers/gpu/ion/ion_carveout_heap.c b/drivers/gpu/ion/ion_carveout_heap.c
index b03fa23..9cb338a 100644
--- a/drivers/gpu/ion/ion_carveout_heap.c
+++ b/drivers/gpu/ion/ion_carveout_heap.c
@@ -139,7 +139,8 @@
container_of(heap, struct ion_carveout_heap, heap);
if (atomic_inc_return(&carveout_heap->map_count) == 1)
- carveout_heap->request_region(carveout_heap->bus_id);
+ if (carveout_heap->request_region)
+ carveout_heap->request_region(carveout_heap->bus_id);
if (ION_IS_CACHED(flags))
return ioremap_cached(buffer->priv_phys, buffer->size);
@@ -157,7 +158,8 @@
buffer->vaddr = NULL;
if (atomic_dec_and_test(&carveout_heap->map_count))
- carveout_heap->release_region(carveout_heap->bus_id);
+ if (carveout_heap->release_region)
+ carveout_heap->release_region(carveout_heap->bus_id);
return;
}
@@ -169,7 +171,8 @@
container_of(heap, struct ion_carveout_heap, heap);
if (atomic_inc_return(&carveout_heap->map_count) == 1)
- carveout_heap->request_region(carveout_heap->bus_id);
+ if (carveout_heap->request_region)
+ carveout_heap->request_region(carveout_heap->bus_id);
if (ION_IS_CACHED(flags))
return remap_pfn_range(vma, vma->vm_start,
@@ -190,7 +193,8 @@
container_of(heap, struct ion_carveout_heap, heap);
if (atomic_dec_and_test(&carveout_heap->map_count))
- carveout_heap->release_region(carveout_heap->bus_id);
+ if (carveout_heap->release_region)
+ carveout_heap->release_region(carveout_heap->bus_id);
}
int ion_carveout_cache_ops(struct ion_heap *heap, struct ion_buffer *buffer,
@@ -379,9 +383,12 @@
carveout_heap->heap.type = ION_HEAP_TYPE_CARVEOUT;
carveout_heap->allocated_bytes = 0;
carveout_heap->total_size = heap_data->size;
- carveout_heap->bus_id = heap_data->setup_region();
- carveout_heap->request_region = heap_data->request_region;
- carveout_heap->release_region = heap_data->release_region;
+ if (heap_data->setup_region)
+ carveout_heap->bus_id = heap_data->setup_region();
+ if (heap_data->request_region)
+ carveout_heap->request_region = heap_data->request_region;
+ if (heap_data->release_region)
+ carveout_heap->release_region = heap_data->release_region;
return &carveout_heap->heap;
}
diff --git a/drivers/gpu/msm/adreno.c b/drivers/gpu/msm/adreno.c
index 0379a6a..d7c11db 100644
--- a/drivers/gpu/msm/adreno.c
+++ b/drivers/gpu/msm/adreno.c
@@ -937,29 +937,27 @@
return status;
}
-uint8_t *kgsl_sharedmem_convertaddr(struct kgsl_device *device,
- unsigned int pt_base, unsigned int gpuaddr, unsigned int *size)
+const struct kgsl_memdesc *adreno_find_region(struct kgsl_device *device,
+ unsigned int pt_base,
+ unsigned int gpuaddr,
+ unsigned int size)
{
- uint8_t *result = NULL;
+ struct kgsl_memdesc *result = NULL;
struct kgsl_mem_entry *entry;
struct kgsl_process_private *priv;
struct adreno_device *adreno_dev = ADRENO_DEVICE(device);
struct adreno_ringbuffer *ringbuffer = &adreno_dev->ringbuffer;
+ struct kgsl_context *context;
+ int next = 0;
- if (kgsl_gpuaddr_in_memdesc(&ringbuffer->buffer_desc, gpuaddr)) {
- return kgsl_gpuaddr_to_vaddr(&ringbuffer->buffer_desc,
- gpuaddr, size);
- }
+ if (kgsl_gpuaddr_in_memdesc(&ringbuffer->buffer_desc, gpuaddr, size))
+ return &ringbuffer->buffer_desc;
- if (kgsl_gpuaddr_in_memdesc(&ringbuffer->memptrs_desc, gpuaddr)) {
- return kgsl_gpuaddr_to_vaddr(&ringbuffer->memptrs_desc,
- gpuaddr, size);
- }
+ if (kgsl_gpuaddr_in_memdesc(&ringbuffer->memptrs_desc, gpuaddr, size))
+ return &ringbuffer->memptrs_desc;
- if (kgsl_gpuaddr_in_memdesc(&device->memstore, gpuaddr)) {
- return kgsl_gpuaddr_to_vaddr(&device->memstore,
- gpuaddr, size);
- }
+ if (kgsl_gpuaddr_in_memdesc(&device->memstore, gpuaddr, size))
+ return &device->memstore;
mutex_lock(&kgsl_driver.process_mutex);
list_for_each_entry(priv, &kgsl_driver.process_list, list) {
@@ -969,8 +967,7 @@
entry = kgsl_sharedmem_find_region(priv, gpuaddr,
sizeof(unsigned int));
if (entry) {
- result = kgsl_gpuaddr_to_vaddr(&entry->memdesc,
- gpuaddr, size);
+ result = &entry->memdesc;
spin_unlock(&priv->mem_lock);
mutex_unlock(&kgsl_driver.process_mutex);
return result;
@@ -981,14 +978,52 @@
BUG_ON(!mutex_is_locked(&device->mutex));
list_for_each_entry(entry, &device->memqueue, list) {
- if (kgsl_gpuaddr_in_memdesc(&entry->memdesc, gpuaddr)) {
- result = kgsl_gpuaddr_to_vaddr(&entry->memdesc,
- gpuaddr, size);
- break;
+ if (kgsl_gpuaddr_in_memdesc(&entry->memdesc, gpuaddr, size)) {
+ result = &entry->memdesc;
+ return result;
}
}
- return result;
+
+ while (1) {
+ struct adreno_context *adreno_context = NULL;
+ struct kgsl_memdesc *gpustate;
+ struct kgsl_memdesc *gmemshadow;
+ context = idr_get_next(&device->context_idr, &next);
+ if (context == NULL)
+ break;
+
+ adreno_context = (struct adreno_context *)context->devctxt;
+
+ if (!kgsl_mmu_pt_equal(adreno_context->pagetable, pt_base))
+ continue;
+
+ gpustate = &adreno_context->gpustate;
+ if (kgsl_gpuaddr_in_memdesc(gpustate, gpuaddr, size)) {
+ result = gpustate;
+ return result;
+ }
+ gmemshadow = &adreno_context->context_gmem_shadow.gmemshadow;
+ if (kgsl_gpuaddr_in_memdesc(gmemshadow, gpuaddr, size)) {
+ result = gmemshadow;
+ return result;
+ }
+
+ next = next + 1;
+ }
+
+ return NULL;
+
+}
+
+uint8_t *adreno_convertaddr(struct kgsl_device *device, unsigned int pt_base,
+ unsigned int gpuaddr, unsigned int size)
+{
+ const struct kgsl_memdesc *memdesc;
+
+ memdesc = adreno_find_region(device, pt_base, gpuaddr, size);
+
+ return memdesc ? kgsl_gpuaddr_to_vaddr(memdesc, gpuaddr) : NULL;
}
void adreno_regread(struct kgsl_device *device, unsigned int offsetwords,
diff --git a/drivers/gpu/msm/adreno.h b/drivers/gpu/msm/adreno.h
index 0776a24..3043fd2 100644
--- a/drivers/gpu/msm/adreno.h
+++ b/drivers/gpu/msm/adreno.h
@@ -93,8 +93,13 @@
void adreno_regwrite(struct kgsl_device *device, unsigned int offsetwords,
unsigned int value);
-uint8_t *kgsl_sharedmem_convertaddr(struct kgsl_device *device,
- unsigned int pt_base, unsigned int gpuaddr, unsigned int *size);
+const struct kgsl_memdesc *adreno_find_region(struct kgsl_device *device,
+ unsigned int pt_base,
+ unsigned int gpuaddr,
+ unsigned int size);
+
+uint8_t *adreno_convertaddr(struct kgsl_device *device,
+ unsigned int pt_base, unsigned int gpuaddr, unsigned int size);
static inline int adreno_is_a200(struct adreno_device *adreno_dev)
{
diff --git a/drivers/gpu/msm/adreno_postmortem.c b/drivers/gpu/msm/adreno_postmortem.c
index cc69360..c6b850e 100644
--- a/drivers/gpu/msm/adreno_postmortem.c
+++ b/drivers/gpu/msm/adreno_postmortem.c
@@ -247,9 +247,8 @@
static void dump_ib(struct kgsl_device *device, char* buffId, uint32_t pt_base,
uint32_t base_offset, uint32_t ib_base, uint32_t ib_size, bool dump)
{
- unsigned int memsize;
- uint8_t *base_addr = kgsl_sharedmem_convertaddr(device, pt_base,
- ib_base, &memsize);
+ uint8_t *base_addr = adreno_convertaddr(device, pt_base,
+ ib_base, ib_size*sizeof(uint32_t));
if (base_addr && dump)
print_hex_dump(KERN_ERR, buffId, DUMP_PREFIX_OFFSET,
@@ -277,14 +276,13 @@
int i, j;
uint32_t value;
uint32_t *ib1_addr;
- unsigned int memsize;
dump_ib(device, "IB1:", pt_base, base_offset, ib1_base,
ib1_size, dump);
/* fetch virtual address for given IB base */
- ib1_addr = (uint32_t *)kgsl_sharedmem_convertaddr(device, pt_base,
- ib1_base, &memsize);
+ ib1_addr = (uint32_t *)adreno_convertaddr(device, pt_base,
+ ib1_base, ib1_size*sizeof(uint32_t));
if (!ib1_addr)
return;
@@ -466,7 +464,7 @@
const uint32_t *rb_vaddr;
int num_item = 0;
int read_idx, write_idx;
- unsigned int ts_processed, rb_memsize;
+ unsigned int ts_processed;
static struct ib_list ib_list;
@@ -681,11 +679,16 @@
KGSL_LOG_DUMP(device, "RB: rd_addr:%8.8x rb_size:%d num_item:%d\n",
cp_rb_base, rb_count<<2, num_item);
- rb_vaddr = (const uint32_t *)kgsl_sharedmem_convertaddr(device,
- cur_pt_base, cp_rb_base, &rb_memsize);
+
+ if (adreno_dev->ringbuffer.buffer_desc.gpuaddr != cp_rb_base)
+ KGSL_LOG_POSTMORTEM_WRITE(device,
+ "rb address mismatch, should be 0x%08x\n",
+ adreno_dev->ringbuffer.buffer_desc.gpuaddr);
+
+ rb_vaddr = adreno_dev->ringbuffer.buffer_desc.hostptr;
if (!rb_vaddr) {
KGSL_LOG_POSTMORTEM_WRITE(device,
- "Can't fetch vaddr for CP_RB_BASE\n");
+ "rb has no kernel mapping!\n");
goto error_vfree;
}
diff --git a/drivers/gpu/msm/kgsl.c b/drivers/gpu/msm/kgsl.c
index bf1d223..7a42dcd 100644
--- a/drivers/gpu/msm/kgsl.c
+++ b/drivers/gpu/msm/kgsl.c
@@ -774,9 +774,7 @@
BUG_ON(private == NULL);
list_for_each_entry(entry, &private->mem_list, list) {
- if (gpuaddr >= entry->memdesc.gpuaddr &&
- ((gpuaddr + size) <=
- (entry->memdesc.gpuaddr + entry->memdesc.size))) {
+ if (kgsl_gpuaddr_in_memdesc(&entry->memdesc, gpuaddr, size)) {
result = entry;
break;
}
@@ -786,20 +784,6 @@
}
EXPORT_SYMBOL(kgsl_sharedmem_find_region);
-uint8_t *kgsl_gpuaddr_to_vaddr(const struct kgsl_memdesc *memdesc,
- unsigned int gpuaddr, unsigned int *size)
-{
- BUG_ON(memdesc->hostptr == NULL);
-
- if (memdesc->gpuaddr == 0 || (gpuaddr < memdesc->gpuaddr ||
- gpuaddr >= memdesc->gpuaddr + memdesc->size))
- return NULL;
-
- *size = memdesc->size - (gpuaddr - memdesc->gpuaddr);
- return memdesc->hostptr + (gpuaddr - memdesc->gpuaddr);
-}
-EXPORT_SYMBOL(kgsl_gpuaddr_to_vaddr);
-
/*call all ioctl sub functions with driver locked*/
static long kgsl_ioctl_device_getproperty(struct kgsl_device_private *dev_priv,
unsigned int cmd, void *data)
@@ -1680,11 +1664,6 @@
result = -EINVAL;
goto done;
}
- if (!entry->memdesc.hostptr)
- entry->memdesc.hostptr =
- kgsl_gpuaddr_to_vaddr(&entry->memdesc,
- param->gpuaddr, &entry->memdesc.size);
-
if (!entry->memdesc.hostptr) {
KGSL_CORE_ERR("invalid hostptr with gpuaddr %08x\n",
param->gpuaddr);
diff --git a/drivers/gpu/msm/kgsl.h b/drivers/gpu/msm/kgsl.h
index 3bb722d..1135adb 100644
--- a/drivers/gpu/msm/kgsl.h
+++ b/drivers/gpu/msm/kgsl.h
@@ -145,8 +145,6 @@
#endif
void kgsl_mem_entry_destroy(struct kref *kref);
-uint8_t *kgsl_gpuaddr_to_vaddr(const struct kgsl_memdesc *memdesc,
- unsigned int gpuaddr, unsigned int *size);
struct kgsl_mem_entry *kgsl_sharedmem_find_region(
struct kgsl_process_private *private, unsigned int gpuaddr,
size_t size);
@@ -175,14 +173,24 @@
#endif
static inline int kgsl_gpuaddr_in_memdesc(const struct kgsl_memdesc *memdesc,
- unsigned int gpuaddr)
+ unsigned int gpuaddr, unsigned int size)
{
- if (gpuaddr >= memdesc->gpuaddr && (gpuaddr + sizeof(unsigned int)) <=
- (memdesc->gpuaddr + memdesc->size)) {
+ if (gpuaddr >= memdesc->gpuaddr &&
+ ((gpuaddr + size) <= (memdesc->gpuaddr + memdesc->size))) {
return 1;
}
return 0;
}
+static inline uint8_t *kgsl_gpuaddr_to_vaddr(const struct kgsl_memdesc *memdesc,
+ unsigned int gpuaddr)
+{
+ if (memdesc->hostptr == NULL || memdesc->gpuaddr == 0 ||
+ (gpuaddr < memdesc->gpuaddr ||
+ gpuaddr >= memdesc->gpuaddr + memdesc->size))
+ return NULL;
+
+ return memdesc->hostptr + (gpuaddr - memdesc->gpuaddr);
+}
static inline int timestamp_cmp(unsigned int new, unsigned int old)
{
diff --git a/drivers/gpu/msm/kgsl_cffdump.c b/drivers/gpu/msm/kgsl_cffdump.c
index 437d6f5..e9455cb 100644
--- a/drivers/gpu/msm/kgsl_cffdump.c
+++ b/drivers/gpu/msm/kgsl_cffdump.c
@@ -391,7 +391,6 @@
bool clean_cache)
{
const void *src;
- uint host_size;
if (!kgsl_cff_dump_enable)
return;
@@ -411,12 +410,9 @@
}
memdesc = &entry->memdesc;
}
- BUG_ON(memdesc->gpuaddr == 0);
- BUG_ON(gpuaddr == 0);
-
- src = kgsl_gpuaddr_to_vaddr(memdesc, gpuaddr, &host_size);
- if (src == NULL || host_size < sizebytes) {
- KGSL_CORE_ERR("did not find mapping for "
+ src = (uint *)kgsl_gpuaddr_to_vaddr(memdesc, gpuaddr);
+ if (memdesc->hostptr == NULL) {
+ KGSL_CORE_ERR("no kernel mapping for "
"gpuaddr: 0x%08x, m->host: 0x%p, phys: 0x%08x\n",
gpuaddr, memdesc->hostptr, memdesc->physaddr);
return;
@@ -561,7 +557,6 @@
{
static uint level; /* recursion level */
bool ret = true;
- uint host_size;
uint *hostaddr, *hoststart;
int dwords_left = sizedwords; /* dwords left in the current command
buffer */
@@ -582,10 +577,9 @@
}
memdesc = &entry->memdesc;
}
-
- hostaddr = (uint *)kgsl_gpuaddr_to_vaddr(memdesc, gpuaddr, &host_size);
+ hostaddr = (uint *)kgsl_gpuaddr_to_vaddr(memdesc, gpuaddr);
if (hostaddr == NULL) {
- KGSL_CORE_ERR("did not find mapping for "
+ KGSL_CORE_ERR("no kernel mapping for "
"gpuaddr: 0x%08x\n", gpuaddr);
return true;
}
diff --git a/drivers/media/radio/radio-iris.c b/drivers/media/radio/radio-iris.c
index 0ab22f8..9a4a28c 100644
--- a/drivers/media/radio/radio-iris.c
+++ b/drivers/media/radio/radio-iris.c
@@ -648,6 +648,15 @@
return radio_hci_send_cmd(hdev, opcode, 0, NULL);
}
+static int hci_get_fm_trans_conf_req(struct radio_hci_dev *hdev,
+ unsigned long param)
+{
+ u16 opcode = 0;
+
+ opcode = hci_opcode_pack(HCI_OGF_FM_TRANS_CTRL_CMD_REQ,
+ HCI_OCF_FM_GET_TRANS_CONF_REQ);
+ return radio_hci_send_cmd(hdev, opcode, 0, NULL);
+}
static int hci_set_fm_recv_conf_req(struct radio_hci_dev *hdev,
unsigned long param)
{
@@ -1474,6 +1483,10 @@
msecs_to_jiffies(RADIO_HCI_TIMEOUT));
break;
+ case HCI_FM_GET_TX_CONFIG:
+ ret = radio_hci_request(hdev, hci_get_fm_trans_conf_req, arg,
+ msecs_to_jiffies(RADIO_HCI_TIMEOUT));
+ break;
default:
ret = -EINVAL;
break;
@@ -1502,6 +1515,7 @@
if (status)
return;
+
radio_hci_req_complete(hdev, status);
}
@@ -1531,6 +1545,19 @@
radio_hci_req_complete(hdev, rsp->status);
}
+static void hci_cc_fm_trans_get_conf_rsp(struct radio_hci_dev *hdev,
+ struct sk_buff *skb)
+{
+ struct hci_fm_get_trans_conf_rsp *rsp = (void *)skb->data;
+ struct iris_device *radio = video_get_drvdata(video_get_dev());
+
+ if (rsp->status)
+ return;
+ memcpy((void *)&radio->trans_conf, (void*)&rsp->trans_conf_rsp,
+ sizeof(rsp->trans_conf_rsp));
+ radio_hci_req_complete(hdev, rsp->status);
+}
+
static void hci_cc_fm_enable_rsp(struct radio_hci_dev *hdev,
struct sk_buff *skb)
{
@@ -1863,6 +1890,9 @@
hci_cc_do_calibration_rsp(hdev, skb);
break;
+ case hci_trans_ctrl_cmd_op_pack(HCI_OCF_FM_GET_TRANS_CONF_REQ):
+ hci_cc_fm_trans_get_conf_rsp(hdev, skb);
+ break;
default:
FMDERR("%s opcode 0x%x", hdev->name, opcode);
break;
@@ -2646,6 +2676,8 @@
retval = radio_hci_request(radio->fm_hdev,
hci_fm_tone_generator, arg,
msecs_to_jiffies(RADIO_HCI_TIMEOUT));
+ if (retval < 0)
+ FMDERR("Error while setting the tone %d", retval);
break;
case V4L2_CID_AUDIO_VOLUME:
break;
@@ -2673,12 +2705,12 @@
case FM_RECV:
retval = hci_cmd(HCI_FM_ENABLE_RECV_CMD,
radio->fm_hdev);
-
- radio->mode = FM_RECV;
-
- if (retval < 0)
+ if (retval < 0) {
FMDERR("Error while enabling RECV FM"
" %d\n", retval);
+ return retval;
+ }
+ radio->mode = FM_RECV;
radio->mute_mode.soft_mute = CTRL_ON;
retval = hci_set_fm_mute_mode(
&radio->mute_mode,
@@ -2715,10 +2747,14 @@
retval = hci_cmd(HCI_FM_ENABLE_TRANS_CMD,
radio->fm_hdev);
radio->mode = FM_TRANS;
-
- if (retval < 0)
+ if (retval < 0) {
FMDERR("Error while enabling TRANS FM"
" %d\n", retval);
+ return retval;
+ }
+ retval = hci_cmd(HCI_FM_GET_TX_CONFIG, radio->fm_hdev);
+ if (retval < 0)
+ FMDERR("get frequency failed %d\n", retval);
break;
case FM_OFF:
switch (radio->mode) {
@@ -2978,19 +3014,37 @@
if (tuner->index > 0)
return -EINVAL;
- retval = hci_cmd(HCI_FM_GET_STATION_PARAM_CMD, radio->fm_hdev);
- if (retval < 0)
- return retval;
+ if (radio->mode == FM_RECV) {
+ retval = hci_cmd(HCI_FM_GET_STATION_PARAM_CMD, radio->fm_hdev);
+ if (retval < 0) {
+ FMDERR("Failed to Get station params");
+ return retval;
+ }
+ tuner->type = V4L2_TUNER_RADIO;
+ tuner->rangelow =
+ radio->recv_conf.band_low_limit * TUNE_PARAM;
+ tuner->rangehigh =
+ radio->recv_conf.band_high_limit * TUNE_PARAM;
+ tuner->rxsubchans = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
+ tuner->capability = V4L2_TUNER_CAP_LOW;
+ tuner->signal = radio->fm_st_rsp.station_rsp.rssi;
+ tuner->audmode = radio->fm_st_rsp.station_rsp.stereo_prg;
+ tuner->afc = 0;
+ } else if (radio->mode == FM_TRANS) {
+ retval = hci_cmd(HCI_FM_GET_TX_CONFIG, radio->fm_hdev);
+ if (retval < 0) {
+ FMDERR("get Tx config failed %d\n", retval);
+ return retval;
+ } else {
+ tuner->type = V4L2_TUNER_RADIO;
+ tuner->rangelow =
+ radio->trans_conf.band_low_limit * TUNE_PARAM;
+ tuner->rangehigh =
+ radio->trans_conf.band_high_limit * TUNE_PARAM;
+ }
- tuner->type = V4L2_TUNER_RADIO;
- tuner->rangelow = radio->recv_conf.band_low_limit * TUNE_PARAM;
- tuner->rangehigh = radio->recv_conf.band_high_limit * TUNE_PARAM;
- tuner->rxsubchans = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
- tuner->capability = V4L2_TUNER_CAP_LOW;
- tuner->signal = radio->fm_st_rsp.station_rsp.rssi;
- tuner->audmode = radio->fm_st_rsp.station_rsp.stereo_prg;
- tuner->afc = 0;
-
+ } else
+ return -EINVAL;
return 0;
}
@@ -3020,16 +3074,13 @@
if (retval < 0)
FMDERR(": set tuner failed with %d\n", retval);
return retval;
- } else {
- if (radio->mode == FM_TRANS) {
+ } else if (radio->mode == FM_TRANS) {
radio->trans_conf.band_low_limit =
tuner->rangelow / TUNE_PARAM;
radio->trans_conf.band_high_limit =
tuner->rangehigh / TUNE_PARAM;
- } else {
- return -EINVAL;
- }
- }
+ } else
+ return -EINVAL;
return retval;
}
diff --git a/drivers/media/radio/radio-tavarua.c b/drivers/media/radio/radio-tavarua.c
index 0597308..d09f89f 100644
--- a/drivers/media/radio/radio-tavarua.c
+++ b/drivers/media/radio/radio-tavarua.c
@@ -118,6 +118,7 @@
int pi;
/*PS repeatcount for PS Tx */
int ps_repeatcount;
+ int enable_optimized_srch_alg;
};
/**************************************************************************
@@ -1162,6 +1163,169 @@
return 0;
}
+static int optimized_search_algorithm(struct tavarua_device *radio,
+ int region)
+{
+ unsigned char adie_type_bahma;
+ int retval = 0;
+ unsigned int rdsMask = 0;
+ unsigned char value;
+
+ adie_type_bahma = is_bahama();
+
+ switch (region) {
+ case TAVARUA_REGION_US:
+ /*
+ Radio band for all the 200KHz channel-spaced regions
+ coming under EUROPE too, have been set as TAVARUA_REGION_US.
+ */
+ FMDBG("%s: The region selected from APP is"
+ " : TAVARUA_REGION_US", __func__);
+ break;
+ case TAVARUA_REGION_EU:
+ /*
+ Radio band for all the 50KHz channel-spaced regions
+ coming under EUROPE, have been set as TAVARUA_REGION_EU.
+ */
+ FMDBG("%s: The region selected from APP is : "
+ "TAVARUA_REGION_EU", __func__);
+ break;
+ case TAVARUA_REGION_JAPAN:
+ /*
+ Radio band for the 100KHz channel-spaced JAPAN region
+ has been set as TAVARUA_REGION_JAPAN.
+ */
+ FMDBG("%s: The region selected from APP is"
+ " : TAVARUA_REGION_JAPAN", __func__);
+ break;
+ case TAVARUA_REGION_JAPAN_WIDE:
+ /*
+ Radio band for the 50KHz channel-spaced JAPAN WIDE region
+ has been set as TAVARUA_REGION_JAPAN_WIDE.
+ */
+ FMDBG("%s: The region selected from APP is"
+ " : TAVARUA_REGION_JAPAN_WIDE", __func__);
+ break;
+ case TAVARUA_REGION_OTHER:
+ /*
+ Radio band for all the 100KHz channel-spaced regions
+ including those coming under EUROPE have been set as
+ TAVARUA_REGION_OTHER.
+ */
+ FMDBG("%s: The region selected from APP is"
+ " : TAVARUA_REGION_OTHER", __func__);
+ break;
+ default:
+ pr_err("%s: Should not reach here.", __func__);
+ break;
+
+ }
+
+ /* Enable or Disable the 200KHz enforcer */
+ switch (region) {
+ case TAVARUA_REGION_US:
+ case TAVARUA_REGION_JAPAN:
+ case TAVARUA_REGION_OTHER:
+ /*
+ These are the 3 bands for which we need to enable the
+ 200KHz enforcer in ADVCTL reg.
+ */
+ if (adie_type_bahma) {
+ FMDBG("Adie type : Bahama\n");
+ FMDBG("%s: Enabling the 200KHz enforcer for"
+ " Region : %d", __func__, region);
+ /*Enable the 200KHz enforcer*/
+ retval = tavarua_read_registers(radio,
+ ADVCTRL, 1);
+ if (retval >= 0) {
+ rdsMask = radio->registers[ADVCTRL];
+ SET_REG_FIELD(rdsMask, ENF_SRCH200khz,
+ SRCH200KHZ_OFFSET, SRCH_MASK);
+ retval = tavarua_write_register(radio,
+ ADVCTRL, rdsMask);
+ } else
+ return retval;
+ } /* if Marimba do nothing */
+ break;
+ case TAVARUA_REGION_EU:
+ case TAVARUA_REGION_JAPAN_WIDE:
+ /*
+ These are the 2 bands for which we need to disable the
+ 200KHz enforcer in ADVCTL reg.
+ Radio band for all the 50KHz channel-spaced regions
+ coming under EUROPE have been set as TAVARUA_REGION_EU.
+ */
+ if (adie_type_bahma) {
+ FMDBG("Adie type : Bahama\n");
+ FMDBG("%s: Disabling the 200KHz enforcer for"
+ " Region : %d", __func__, region);
+ /*
+ Disable 200KHz enforcer for all 50 KHz
+ spaced regions.
+ */
+ retval = tavarua_read_registers(radio,
+ ADVCTRL, 1);
+ if (retval >= 0) {
+ rdsMask = radio->registers[ADVCTRL];
+ SET_REG_FIELD(rdsMask, NO_SRCH200khz,
+ SRCH200KHZ_OFFSET, SRCH_MASK);
+ retval = tavarua_write_register(radio,
+ ADVCTRL, rdsMask);
+ } else
+ return retval;
+ } /* if Marimba do nothing */
+ break;
+ default:
+ FMDBG("%s: Defaulting in case of Enabling/Disabling"
+ "the 200KHz Enforcer", __func__);
+ break;
+ }
+
+ /* Set channel spacing */
+ switch (region) {
+ case TAVARUA_REGION_US:
+ if (adie_type_bahma) {
+ FMDBG("Adie type : Bahama\n");
+ /*
+ Configuring all 200KHZ spaced regions as 100KHz due to
+ change in the new Bahma FM SoC search algorithm.
+ */
+ value = FM_CH_SPACE_100KHZ;
+ } else {
+ FMDBG("Adie type : Marimba\n");
+ value = FM_CH_SPACE_200KHZ;
+ }
+ break;
+ case TAVARUA_REGION_JAPAN:
+ case TAVARUA_REGION_OTHER:
+ if (adie_type_bahma) {
+ FMDBG("Adie type : Bahama\n");
+ FMDBG("%s: Configuring the channel-spacing as 50KHz"
+ "for the Region : %d", __func__, region);
+ /*
+ Configuring all 100KHZ spaced regions as 50KHz due to
+ change in the new Bahma FM SoC search algorithm.
+ */
+ value = FM_CH_SPACE_50KHZ;
+ } else {
+ FMDBG("Adie type : Marimba\n");
+ value = FM_CH_SPACE_100KHZ;
+ }
+ break;
+ case TAVARUA_REGION_EU:
+ case TAVARUA_REGION_JAPAN_WIDE:
+ value = FM_CH_SPACE_50KHZ;
+ break;
+ default:
+ FMDBG("%s: Defualting in case of Channel-Spacing", __func__);
+ break;
+ }
+
+ SET_REG_FIELD(radio->registers[RDCTRL], value,
+ RDCTRL_CHSPACE_OFFSET, RDCTRL_CHSPACE_MASK);
+
+ return retval;
+}
/*************************************************************************
* fops/IOCTL helper functions
************************************************************************/
@@ -1255,14 +1419,11 @@
switch (region) {
case TAVARUA_REGION_US:
case TAVARUA_REGION_EU:
- case TAVARUA_REGION_JAPAN_WIDE:
SET_REG_FIELD(radio->registers[RDCTRL], 0,
RDCTRL_BAND_OFFSET, RDCTRL_BAND_MASK);
break;
+ case TAVARUA_REGION_JAPAN_WIDE:
case TAVARUA_REGION_JAPAN:
- SET_REG_FIELD(radio->registers[RDCTRL], 1,
- RDCTRL_BAND_OFFSET, RDCTRL_BAND_MASK);
- break;
default:
retval = sync_read_xfr(radio, RADIO_CONFIG, xfr_buf);
if (retval < 0) {
@@ -1286,85 +1447,6 @@
break;
}
- /* Enable/Disable the 200KHz enforcer for respectiver regions */
- switch (region) {
- case TAVARUA_REGION_US:
- if (adie_type_bahma) {
- FMDBG("Adie type : Bahama\n");
- /*Enable the 200KHz enforcer*/
- retval = tavarua_read_registers(radio,
- ADVCTRL, 1);
- if (retval >= 0) {
- rdsMask = radio->registers[ADVCTRL];
- SET_REG_FIELD(rdsMask, ENF_SRCH200khz,
- SRCH200KHZ_OFFSET, SRCH_MASK);
- msleep(TAVARUA_DELAY);
- retval = tavarua_write_register(radio,
- ADVCTRL, rdsMask);
- } else
- return retval;
- } /* if Marimba do nothing */
- break;
- case TAVARUA_REGION_EU:
- case TAVARUA_REGION_JAPAN:
- case TAVARUA_REGION_JAPAN_WIDE:
- default:
- if (adie_type_bahma) {
- FMDBG("Adie type : Bahama\n");
- /*
- Disable 200KHz enforcer for all 100/50 KHz
- spaced regions.
- */
- retval = tavarua_read_registers(radio,
- ADVCTRL, 1);
- if (retval >= 0) {
- rdsMask = radio->registers[ADVCTRL];
- SET_REG_FIELD(rdsMask, NO_SRCH200khz,
- SRCH200KHZ_OFFSET, SRCH_MASK);
- msleep(TAVARUA_DELAY);
- retval = tavarua_write_register(radio,
- ADVCTRL, rdsMask);
- } else
- return retval;
- } /* if Marimba do nothing */
- break;
- }
-
- /* Set channel spacing */
- switch (region) {
- case TAVARUA_REGION_US:
- if (adie_type_bahma) {
- FMDBG("Adie type : Bahama\n");
- /*
- Configuring all 200KHZ spaced regions as
- 100KHz due to change in the new Bahma
- FM SoC search algorithm.
- */
- value = FM_CH_SPACE_100KHZ;
- } else {
- FMDBG("Adie type : Marimba\n");
- value = FM_CH_SPACE_200KHZ;
- }
- break;
- case TAVARUA_REGION_EU:
- case TAVARUA_REGION_JAPAN:
- value = FM_CH_SPACE_100KHZ;
- break;
- case TAVARUA_REGION_JAPAN_WIDE:
- value = FM_CH_SPACE_50KHZ;
- break;
- default:
- /*
- Set the channel spacing as configured from
- the upper layers.
- */
- value = radio->region_params.spacing;
- break;
- }
-
- SET_REG_FIELD(radio->registers[RDCTRL], value,
- RDCTRL_CHSPACE_OFFSET, RDCTRL_CHSPACE_MASK);
-
/* Set De-emphasis and soft band range*/
switch (region) {
case TAVARUA_REGION_US:
@@ -1403,13 +1485,6 @@
if (retval < 0)
return retval;
- FMDBG("RDCTRL: %x\n", radio->registers[RDCTRL]);
- retval = tavarua_write_register(radio, RDCTRL,
- radio->registers[RDCTRL]);
- if (retval < 0) {
- FMDERR("Could not set region in rdctrl\n");
- return retval;
- }
/* setting soft band */
switch (region) {
@@ -1430,6 +1505,101 @@
break;
}
radio->region_params.region = region;
+
+ /* Check for the FM Algorithm used */
+ if (radio->enable_optimized_srch_alg) {
+ FMDBG("Optimized Srch Algorithm!!!");
+ optimized_search_algorithm(radio, region);
+ } else {
+ FMDBG("Native Srch Algorithm!!!");
+ /* Enable/Disable the 200KHz enforcer */
+ switch (region) {
+ case TAVARUA_REGION_US:
+ if (adie_type_bahma) {
+ FMDBG("Adie type : Bahama\n");
+ /*Enable the 200KHz enforcer*/
+ retval = tavarua_read_registers(radio,
+ ADVCTRL, 1);
+ if (retval >= 0) {
+ rdsMask = radio->registers[ADVCTRL];
+ SET_REG_FIELD(rdsMask, ENF_SRCH200khz,
+ SRCH200KHZ_OFFSET, SRCH_MASK);
+ retval = tavarua_write_register(radio,
+ ADVCTRL, rdsMask);
+ } else
+ return retval;
+ } /* if Marimba do nothing */
+ break;
+ case TAVARUA_REGION_EU:
+ case TAVARUA_REGION_JAPAN:
+ case TAVARUA_REGION_JAPAN_WIDE:
+ default:
+ if (adie_type_bahma) {
+ FMDBG("Adie type : Bahama\n");
+ /*
+ Disable 200KHz enforcer for all 100/50 KHz
+ spaced regions.
+ */
+ retval = tavarua_read_registers(radio,
+ ADVCTRL, 1);
+ if (retval >= 0) {
+ rdsMask = radio->registers[ADVCTRL];
+ SET_REG_FIELD(rdsMask, NO_SRCH200khz,
+ SRCH200KHZ_OFFSET, SRCH_MASK);
+ retval = tavarua_write_register(radio,
+ ADVCTRL, rdsMask);
+ } else
+ return retval;
+ } /* if Marimba do nothing */
+ break;
+ }
+
+ /* Set channel spacing */
+ switch (region) {
+ case TAVARUA_REGION_US:
+ if (adie_type_bahma) {
+ FMDBG("Adie type : Bahama\n");
+ /*
+ Configuring all 200KHZ spaced regions as
+ 100KHz due to change in the new Bahma
+ FM SoC search algorithm.
+ */
+ value = FM_CH_SPACE_100KHZ;
+ } else {
+ FMDBG("Adie type : Marimba\n");
+ value = FM_CH_SPACE_200KHZ;
+ }
+ break;
+ case TAVARUA_REGION_JAPAN:
+ value = FM_CH_SPACE_100KHZ;
+ break;
+ case TAVARUA_REGION_EU:
+ case TAVARUA_REGION_JAPAN_WIDE:
+ value = FM_CH_SPACE_50KHZ;
+ break;
+ default:
+ /*
+ Set the channel spacing as configured from
+ the upper layers.
+ */
+ value = radio->region_params.spacing;
+ break;
+ }
+
+ SET_REG_FIELD(radio->registers[RDCTRL], value,
+ RDCTRL_CHSPACE_OFFSET, RDCTRL_CHSPACE_MASK);
+
+ }
+
+ /* Write the config values into RDCTL register */
+ FMDBG("RDCTRL: %x\n", radio->registers[RDCTRL]);
+ retval = tavarua_write_register(radio, RDCTRL,
+ radio->registers[RDCTRL]);
+ if (retval < 0) {
+ FMDERR("Could not set region in rdctrl\n");
+ return retval;
+ }
+
return retval;
}
@@ -2839,6 +3009,11 @@
}
}
break;
+ case V4L2_CID_PRIVATE_TAVARUA_SRCH_ALGORITHM:
+ radio->enable_optimized_srch_alg = ctrl->value;
+ FMDBG("V4L2_CID_PRIVATE_TAVARUA_SRCH_ALGORITHM : %d",
+ radio->enable_optimized_srch_alg);
+ break;
case V4L2_CID_PRIVATE_TAVARUA_REGION:
retval = tavarua_set_region(radio, ctrl->value);
break;
diff --git a/drivers/media/video/msm/csi/msm_csiphy.c b/drivers/media/video/msm/csi/msm_csiphy.c
index b62ec84..109b3dd 100644
--- a/drivers/media/video/msm/csi/msm_csiphy.c
+++ b/drivers/media/video/msm/csi/msm_csiphy.c
@@ -79,7 +79,7 @@
msm_io_w(0x1, csiphybase + MIPI_CSIPHY_T_WAKEUP_CFG0_ADDR);
for (i = 0; i < csiphy_params->lane_cnt; i++) {
- msm_io_w(0x10, csiphybase + MIPI_CSIPHY_LNn_CFG1_ADDR + 0x40*i);
+ msm_io_w(0x00, csiphybase + MIPI_CSIPHY_LNn_CFG1_ADDR + 0x40*i);
msm_io_w(0x5F, csiphybase + MIPI_CSIPHY_LNn_CFG2_ADDR + 0x40*i);
msm_io_w(csiphy_params->settle_cnt,
csiphybase + MIPI_CSIPHY_LNn_CFG3_ADDR + 0x40*i);
diff --git a/drivers/media/video/msm/msm_io_7x27a.c b/drivers/media/video/msm/msm_io_7x27a.c
index b1f9532..7a83721 100644
--- a/drivers/media/video/msm/msm_io_7x27a.c
+++ b/drivers/media/video/msm/msm_io_7x27a.c
@@ -288,11 +288,6 @@
clk_set_rate(clk, rate);
}
-void msm_camio_clk_set_min_rate(struct clk *clk, int rate)
-{
- clk_set_min_rate(clk, rate);
-}
-
static irqreturn_t msm_io_csi_irq(int irq_num, void *data)
{
uint32_t irq;
diff --git a/drivers/media/video/msm/msm_io_8960.c b/drivers/media/video/msm/msm_io_8960.c
index 1293c7b..ec18a93 100644
--- a/drivers/media/video/msm/msm_io_8960.c
+++ b/drivers/media/video/msm/msm_io_8960.c
@@ -346,7 +346,7 @@
case CAMIO_JPEG_CLK:
camio_jpeg_clk =
clk = clk_get(NULL, "ijpeg_clk");
- clk_set_min_rate(clk, 144000000);
+ clk_set_rate(clk, 153600000);
break;
case CAMIO_JPEG_PCLK:
@@ -414,11 +414,6 @@
clk_set_rate(clk, rate);
}
-void msm_camio_clk_set_min_rate(struct clk *clk, int rate)
-{
- clk_set_min_rate(clk, rate);
-}
-
int msm_camio_jpeg_clk_disable(void)
{
int rc = 0;
diff --git a/drivers/media/video/msm/msm_io_8x60.c b/drivers/media/video/msm/msm_io_8x60.c
index 2262aa4..9620d8b 100644
--- a/drivers/media/video/msm/msm_io_8x60.c
+++ b/drivers/media/video/msm/msm_io_8x60.c
@@ -344,7 +344,8 @@
case CAMIO_VPE_CLK:
camio_vpe_clk =
clk = clk_get(NULL, "vpe_clk");
- msm_camio_clk_set_min_rate(camio_vpe_clk, vpe_clk_rate);
+ vpe_clk_rate = clk_round_rate(camio_vpe_clk, vpe_clk_rate);
+ clk_set_rate(camio_vpe_clk, vpe_clk_rate);
break;
case CAMIO_VPE_PCLK:
@@ -457,11 +458,6 @@
clk_set_rate(clk, rate);
}
-void msm_camio_clk_set_min_rate(struct clk *clk, int rate)
-{
- clk_set_min_rate(clk, rate);
-}
-
static irqreturn_t msm_io_csi_irq(int irq_num, void *data)
{
uint32_t irq;
diff --git a/drivers/media/video/msm/msm_io_vfe31.c b/drivers/media/video/msm/msm_io_vfe31.c
index f770ce9..91dbc8f 100644
--- a/drivers/media/video/msm/msm_io_vfe31.c
+++ b/drivers/media/video/msm/msm_io_vfe31.c
@@ -117,6 +117,7 @@
static struct resource *camifpadio, *csiio;
void __iomem *camifpadbase, *csibase;
static uint32_t vpe_clk_rate;
+static uint32_t jpeg_clk_rate;
static struct regulator_bulk_data regs[] = {
{ .supply = "gp2", .min_uV = 2600000, .max_uV = 2600000 },
@@ -317,7 +318,8 @@
case CAMIO_JPEG_CLK:
camio_jpeg_clk =
clk = clk_get(NULL, "jpeg_clk");
- clk_set_min_rate(clk, 144000000);
+ jpeg_clk_rate = clk_round_rate(clk, 144000000);
+ clk_set_rate(clk, jpeg_clk_rate);
break;
case CAMIO_JPEG_PCLK:
camio_jpeg_pclk =
@@ -326,7 +328,8 @@
case CAMIO_VPE_CLK:
camio_vpe_clk =
clk = clk_get(NULL, "vpe_clk");
- msm_camio_clk_set_min_rate(clk, vpe_clk_rate);
+ vpe_clk_rate = clk_round_rate(clk, vpe_clk_rate);
+ clk_set_rate(clk, vpe_clk_rate);
break;
default:
break;
@@ -420,11 +423,6 @@
clk_set_rate(clk, rate);
}
-void msm_camio_clk_set_min_rate(struct clk *clk, int rate)
-{
- clk_set_min_rate(clk, rate);
-}
-
static irqreturn_t msm_io_csi_irq(int irq_num, void *data)
{
uint32_t irq;
diff --git a/drivers/usb/gadget/android.c b/drivers/usb/gadget/android.c
index c880799..af6f351 100644
--- a/drivers/usb/gadget/android.c
+++ b/drivers/usb/gadget/android.c
@@ -1090,6 +1090,32 @@
/*-------------------------------------------------------------------------*/
/* /sys/class/android_usb/android%d/ interface */
+static ssize_t remote_wakeup_show(struct device *pdev,
+ struct device_attribute *attr, char *buf)
+{
+ return snprintf(buf, PAGE_SIZE, "%d\n",
+ !!(android_config_driver.bmAttributes &
+ USB_CONFIG_ATT_WAKEUP));
+}
+
+static ssize_t remote_wakeup_store(struct device *pdev,
+ struct device_attribute *attr, const char *buff, size_t size)
+{
+ int enable = 0;
+
+ sscanf(buff, "%d", &enable);
+
+ pr_debug("android_usb: %s remote wakeup\n",
+ enable ? "enabling" : "disabling");
+
+ if (enable)
+ android_config_driver.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
+ else
+ android_config_driver.bmAttributes &= ~USB_CONFIG_ATT_WAKEUP;
+
+ return size;
+}
+
static ssize_t
functions_show(struct device *pdev, struct device_attribute *attr, char *buf)
{
@@ -1245,6 +1271,8 @@
static DEVICE_ATTR(functions, S_IRUGO | S_IWUSR, functions_show, functions_store);
static DEVICE_ATTR(enable, S_IRUGO | S_IWUSR, enable_show, enable_store);
static DEVICE_ATTR(state, S_IRUGO, state_show, NULL);
+static DEVICE_ATTR(remote_wakeup, S_IRUGO | S_IWUSR,
+ remote_wakeup_show, remote_wakeup_store);
static struct device_attribute *android_usb_attributes[] = {
&dev_attr_idVendor,
@@ -1259,6 +1287,7 @@
&dev_attr_functions,
&dev_attr_enable,
&dev_attr_state,
+ &dev_attr_remote_wakeup,
NULL
};
diff --git a/drivers/usb/otg/msm_otg.c b/drivers/usb/otg/msm_otg.c
index dcb670a..ec922f1 100644
--- a/drivers/usb/otg/msm_otg.c
+++ b/drivers/usb/otg/msm_otg.c
@@ -39,6 +39,7 @@
#include <linux/mfd/pm8xxx/pm8921-charger.h>
#include <mach/clk.h>
+#include <mach/msm_xo.h>
#define MSM_USB_BASE (motg->regs)
#define DRIVER_NAME "msm_otg"
@@ -569,6 +570,7 @@
int cnt = 0;
bool session_active;
u32 phy_ctrl_val = 0;
+ unsigned ret;
if (atomic_read(&motg->in_lpm))
return 0;
@@ -662,6 +664,12 @@
if (!IS_ERR(motg->pclk_src))
clk_disable(motg->pclk_src);
+ /* usb phy no more require TCXO clock, hence vote for TCXO disable */
+ ret = msm_xo_mode_vote(motg->xo_handle, MSM_XO_MODE_OFF);
+ if (ret)
+ dev_err(otg->dev, "%s failed to devote for "
+ "TCXO D0 buffer%d\n", __func__, ret);
+
if (motg->caps & ALLOW_PHY_POWER_COLLAPSE && !session_active) {
msm_hsusb_ldo_enable(motg, 0);
motg->lpm_flags |= PHY_PWR_COLLAPSED;
@@ -696,11 +704,19 @@
int cnt = 0;
unsigned temp;
u32 phy_ctrl_val = 0;
+ unsigned ret;
if (!atomic_read(&motg->in_lpm))
return 0;
wake_lock(&motg->wlock);
+
+ /* Vote for TCXO when waking up the phy */
+ ret = msm_xo_mode_vote(motg->xo_handle, MSM_XO_MODE_ON);
+ if (ret)
+ dev_err(otg->dev, "%s failed to vote for "
+ "TCXO D0 buffer%d\n", __func__, ret);
+
if (!IS_ERR(motg->pclk_src))
clk_enable(motg->pclk_src);
@@ -2283,12 +2299,27 @@
goto free_regs;
}
+ motg->xo_handle = msm_xo_get(MSM_XO_TCXO_D0, "usb");
+ if (IS_ERR(motg->xo_handle)) {
+ dev_err(&pdev->dev, "%s not able to get the handle "
+ "to vote for TCXO D0 buffer\n", __func__);
+ ret = PTR_ERR(motg->xo_handle);
+ goto free_regs;
+ }
+
+ ret = msm_xo_mode_vote(motg->xo_handle, MSM_XO_MODE_ON);
+ if (ret) {
+ dev_err(&pdev->dev, "%s failed to vote for TCXO "
+ "D0 buffer%d\n", __func__, ret);
+ goto free_xo_handle;
+ }
+
clk_enable(motg->pclk);
ret = msm_hsusb_init_vddcx(motg, 1);
if (ret) {
dev_err(&pdev->dev, "hsusb vddcx init failed\n");
- goto free_regs;
+ goto devote_xo_handle;
}
ret = msm_hsusb_config_vddcx(1);
@@ -2404,6 +2435,10 @@
msm_hsusb_ldo_init(motg, 0);
free_init_vddcx:
msm_hsusb_init_vddcx(motg, 0);
+devote_xo_handle:
+ msm_xo_mode_vote(motg->xo_handle, MSM_XO_MODE_OFF);
+free_xo_handle:
+ msm_xo_put(motg->xo_handle);
free_regs:
iounmap(motg->regs);
put_core_clk:
@@ -2483,6 +2518,7 @@
clk_disable(motg->pclk_src);
clk_put(motg->pclk_src);
}
+ msm_xo_put(motg->xo_handle);
msm_hsusb_ldo_enable(motg, 0);
msm_hsusb_ldo_init(motg, 0);
msm_hsusb_init_vddcx(motg, 0);
diff --git a/drivers/video/msm/mddi.c b/drivers/video/msm/mddi.c
index 9b9ee94..c6f9fb2 100644
--- a/drivers/video/msm/mddi.c
+++ b/drivers/video/msm/mddi.c
@@ -241,7 +241,8 @@
#ifdef ENABLE_FWD_LINK_SKEW_CALIBRATION
if (mddi_client_type < 2) {
/* For skew calibration, clock should be less than 50MHz */
- if (!clk_set_min_rate(mddi_clk, 49000000)) {
+ clk_rate = clk_round_rate(mddi_clk, 49000000);
+ if (!clk_set_rate(mddi_clk, clk_rate)) {
stat_reg = mddi_host_reg_in(STAT);
printk(KERN_DEBUG "\n stat_reg = 0x%x", stat_reg);
mddi_host_reg_out(CMD, MDDI_CMD_HIBERNATE);
@@ -253,7 +254,7 @@
mddi_host_reg_out(CMD, MDDI_CMD_SEND_RTD);
mddi_host_reg_out(CMD, MDDI_CMD_HIBERNATE | 1);
} else {
- printk(KERN_ERR "%s: clk_set_min_rate failed\n",
+ printk(KERN_ERR "%s: clk_set_rate failed\n",
__func__);
}
}
@@ -269,8 +270,9 @@
"%s: can't select mddi io clk targate rate = %d\n",
__func__, clk_rate);
- if (clk_set_min_rate(mddi_clk, clk_rate) < 0)
- printk(KERN_ERR "%s: clk_set_min_rate failed\n",
+ clk_rate = clk_round_rate(mddi_clk, clk_rate);
+ if (clk_set_rate(mddi_clk, clk_rate) < 0)
+ printk(KERN_ERR "%s: clk_set_rate failed\n",
__func__);
#ifdef CONFIG_MSM_BUS_SCALING
@@ -449,9 +451,6 @@
mddi_pad_ctrl = mddi_host_reg_in(PAD_CTL);
mddi_host_reg_out(PAD_CTL, 0x0);
- if (clk_set_min_rate(mddi_clk, 0) < 0)
- printk(KERN_ERR "%s: clk_set_min_rate failed\n", __func__);
-
pmdh_clk_disable();
if (mddi_pdata && mddi_pdata->mddi_power_save)
@@ -477,9 +476,6 @@
mddi_pad_ctrl = mddi_host_reg_in(PAD_CTL);
mddi_host_reg_out(PAD_CTL, 0x0);
- if (clk_set_min_rate(mddi_clk, 0) < 0)
- printk(KERN_ERR "%s: clk_set_min_rate failed\n", __func__);
-
pmdh_clk_disable();
return 0;
@@ -551,6 +547,7 @@
static int __init mddi_driver_init(void)
{
int ret;
+ unsigned long rate;
pmdh_clk_status = 0;
mddi_clk = clk_get(NULL, "mddi_clk");
@@ -558,9 +555,10 @@
printk(KERN_ERR "can't find mddi_clk\n");
return PTR_ERR(mddi_clk);
}
- ret = clk_set_min_rate(mddi_clk, 49000000);
+ rate = clk_round_rate(mddi_clk, 49000000);
+ ret = clk_set_rate(mddi_clk, rate);
if (ret)
- printk(KERN_ERR "Can't set mddi_clk min rate to 49000000\n");
+ printk(KERN_ERR "Can't set mddi_clk min rate to %lu\n", rate);
printk(KERN_INFO "mddi_clk init rate is %lu\n",
clk_get_rate(mddi_clk));
diff --git a/drivers/video/msm/mddi_ext.c b/drivers/video/msm/mddi_ext.c
index 0ecd593..677b46c 100644
--- a/drivers/video/msm/mddi_ext.c
+++ b/drivers/video/msm/mddi_ext.c
@@ -126,8 +126,9 @@
"%s: can't select mddi io clk targate rate = %d\n",
__func__, clk_rate);
- if (clk_set_min_rate(mddi_ext_clk, clk_rate) < 0)
- printk(KERN_ERR "%s: clk_set_min_rate failed\n",
+ clk_rate = clk_round_rate(mddi_ext_clk, clk_rate);
+ if (clk_set_rate(mddi_ext_clk, clk_rate) < 0)
+ printk(KERN_ERR "%s: clk_set_rate failed\n",
__func__);
mddi_host_start_ext_display();
@@ -265,9 +266,6 @@
mddi_ext_is_in_suspend = 1;
- if (clk_set_min_rate(mddi_ext_clk, 0) < 0)
- printk(KERN_ERR "%s: clk_set_min_rate failed\n", __func__);
-
clk_disable(mddi_ext_clk);
if (mddi_ext_pclk)
clk_disable(mddi_ext_pclk);
diff --git a/drivers/video/msm/mdp.c b/drivers/video/msm/mdp.c
index dd81243..989b154 100644
--- a/drivers/video/msm/mdp.c
+++ b/drivers/video/msm/mdp.c
@@ -1106,11 +1106,10 @@
{
uint8 count;
uint32 current_rate;
- if (mdp_clk && mdp_pdata
- && mdp_pdata->mdp_core_clk_table) {
- if (clk_set_min_rate(mdp_clk,
- min_clk_rate) < 0)
- printk(KERN_ERR "%s: clk_set_min_rate failed\n",
+ if (mdp_clk && mdp_pdata && mdp_pdata->mdp_core_clk_table) {
+ min_clk_rate = clk_round_rate(mdp_clk, min_clk_rate);
+ if (clk_set_rate(mdp_clk, min_clk_rate) < 0)
+ printk(KERN_ERR "%s: clk_set_rate failed\n",
__func__);
else {
count = 0;
diff --git a/include/linux/clk.h b/include/linux/clk.h
index 1d37f42..7213b52 100644
--- a/include/linux/clk.h
+++ b/include/linux/clk.h
@@ -11,6 +11,8 @@
#ifndef __LINUX_CLK_H
#define __LINUX_CLK_H
+#include <linux/kernel.h>
+
struct device;
/*
@@ -41,11 +43,31 @@
struct clk *clk_get(struct device *dev, const char *id);
/**
+ * clk_prepare - prepare a clock source
+ * @clk: clock source
+ *
+ * This prepares the clock source for use.
+ *
+ * Must not be called from within atomic context.
+ */
+#ifdef CONFIG_HAVE_CLK_PREPARE
+int clk_prepare(struct clk *clk);
+#else
+static inline int clk_prepare(struct clk *clk)
+{
+ might_sleep();
+ return 0;
+}
+#endif
+
+/**
* clk_enable - inform the system when the clock source should be running.
* @clk: clock source
*
* If the clock can not be enabled/disabled, this should return success.
*
+ * May be called from atomic contexts.
+ *
* Returns success (0) or negative errno.
*/
int clk_enable(struct clk *clk);
@@ -57,6 +79,8 @@
* Inform the system that a clock source is no longer required by
* a driver and may be shut down.
*
+ * May be called from atomic contexts.
+ *
* Implementation detail: if the clock source is shared between
* multiple drivers, clk_enable() calls must be balanced by the
* same number of clk_disable() calls for the clock source to be
@@ -64,6 +88,25 @@
*/
void clk_disable(struct clk *clk);
+
+/**
+ * clk_unprepare - undo preparation of a clock source
+ * @clk: clock source
+ *
+ * This undoes a previously prepared clock. The caller must balance
+ * the number of prepare and unprepare calls.
+ *
+ * Must not be called from within atomic context.
+ */
+#ifdef CONFIG_HAVE_CLK_PREPARE
+void clk_unprepare(struct clk *clk);
+#else
+static inline void clk_unprepare(struct clk *clk)
+{
+ might_sleep();
+}
+#endif
+
/**
* clk_get_rate - obtain the current clock rate (in Hz) for a clock source.
* This is only valid once the clock source has been enabled.
diff --git a/include/linux/mm.h b/include/linux/mm.h
index 07890ac..c73fdf8 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -28,6 +28,9 @@
extern unsigned long num_physpages;
extern unsigned long totalram_pages;
+#ifdef CONFIG_FIX_MOVABLE_ZONE
+extern unsigned long total_unmovable_pages;
+#endif
extern void * high_memory;
extern int page_cluster;
diff --git a/include/linux/usb/msm_hsusb.h b/include/linux/usb/msm_hsusb.h
index 4c01f5b..a2251fe 100644
--- a/include/linux/usb/msm_hsusb.h
+++ b/include/linux/usb/msm_hsusb.h
@@ -189,6 +189,7 @@
* connected.
* @mA_port: The amount of current drawn by the attached B-device.
* @id_timer: The timer used for polling ID line to detect ACA states.
+ * @xo_handle: TCXO buffer handle
*/
struct msm_otg {
struct otg_transceiver otg;
@@ -220,6 +221,7 @@
unsigned mA_port;
struct timer_list id_timer;
unsigned long caps;
+ struct msm_xo_voter *xo_handle;
/*
* Allowing PHY power collpase turns off the HSUSB 3.3v and 1.8v
* analog regulators while going to low power mode.
diff --git a/include/media/radio-iris.h b/include/media/radio-iris.h
index dbdb651..130bc3d 100644
--- a/include/media/radio-iris.h
+++ b/include/media/radio-iris.h
@@ -198,6 +198,7 @@
#define HCI_FM_STATION_DBG_PARAM_CMD 12
#define HCI_FM_ENABLE_TRANS_CMD 13
#define HCI_FM_DISABLE_TRANS_CMD 14
+#define HCI_FM_GET_TX_CONFIG 15
/* Defines for FM TX*/
@@ -241,14 +242,6 @@
__u8 rt_data[TX_RT_DATA_LENGTH];
} __packed;
-struct hci_fm_get_trans_conf_rsp {
- __u8 status;
- __u8 emphasis;
- __u8 rds_std;
- __u32 band_low_limit;
- __u32 band_high_limit;
-} __packed;
-
struct hci_fm_mute_mode_req {
__u8 hard_mute;
__u8 soft_mute;
@@ -428,6 +421,10 @@
struct hci_fm_recv_conf_req recv_conf_rsp;
} __packed;
+struct hci_fm_get_trans_conf_rsp {
+ __u8 status;
+ struct hci_fm_trans_conf_req_struct trans_conf_rsp;
+} __packed;
struct hci_fm_sig_threshold_rsp {
__u8 status;
__u8 sig_threshold;
diff --git a/include/media/tavarua.h b/include/media/tavarua.h
index 43ce153..d40829e 100644
--- a/include/media/tavarua.h
+++ b/include/media/tavarua.h
@@ -148,13 +148,14 @@
V4L2_CID_PRIVATE_TAVARUA_RSSI_DELTA,
V4L2_CID_PRIVATE_TAVARUA_HLSI,
/*
- * Here We have IOCTl's that are specifici to IRIS
- * (V4L2_CID_PRIVATE_BASE+0x1D--V4L2_CID_PRIVATE_BASE+0x27)
+ * Here we have IOCTl's that are specific to IRIS
+ * (V4L2_CID_PRIVATE_BASE + 0x1E to V4L2_CID_PRIVATE_BASE + 0x27)
*/
V4L2_CID_PRIVATE_TAVARUA_SET_NOTCH_FILTER =
- V4L2_CID_PRIVATE_BASE + 0x28,
+ V4L2_CID_PRIVATE_BASE + 0x28, /* IRIS specific command */
V4L2_CID_PRIVATE_TAVARUA_SET_AUDIO_PATH,
- /*0x800002a is used for iris specific ioctl*/
+ V4L2_CID_PRIVATE_TAVARUA_DO_CALIBRATION, /* IRIS specific command */
+ V4L2_CID_PRIVATE_TAVARUA_SRCH_ALGORITHM,
V4L2_CID_PRIVATE_TAVARUA_ON_CHANNEL_THRESHOLD =
V4L2_CTRL_CLASS_USER + 0x92B,
diff --git a/mm/memory_hotplug.c b/mm/memory_hotplug.c
index faf318e..70ea0df 100644
--- a/mm/memory_hotplug.c
+++ b/mm/memory_hotplug.c
@@ -379,6 +379,10 @@
unsigned long pfn = page_to_pfn(page);
totalram_pages++;
+#ifdef CONFIG_FIX_MOVABLE_ZONE
+ if (zone_idx(page_zone(page)) != ZONE_MOVABLE)
+ total_unmovable_pages++;
+#endif
if (pfn >= num_physpages)
num_physpages = pfn + 1;
@@ -965,6 +969,10 @@
zone->zone_pgdat->node_present_pages -= offlined_pages;
totalram_pages -= offlined_pages;
+#ifdef CONFIG_FIX_MOVABLE_ZONE
+ if (zone_idx(zone) != ZONE_MOVABLE)
+ total_unmovable_pages -= offlined_pages;
+#endif
init_per_zone_wmark_min();
if (!node_present_pages(node)) {
diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index 5489c43..60ad5e9 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -96,6 +96,9 @@
unsigned long totalram_pages __read_mostly;
unsigned long totalreserve_pages __read_mostly;
+#ifdef CONFIG_FIX_MOVABLE_ZONE
+unsigned long total_unmovable_pages __read_mostly;
+#endif
int percpu_pagelist_fraction;
gfp_t gfp_allowed_mask __read_mostly = GFP_BOOT_MASK;
@@ -174,6 +177,9 @@
};
EXPORT_SYMBOL(totalram_pages);
+#ifdef CONFIG_FIX_MOVABLE_ZONE
+EXPORT_SYMBOL(total_unmovable_pages);
+#endif
static char * const zone_names[MAX_NR_ZONES] = {
#ifdef CONFIG_ZONE_DMA
diff --git a/mm/vmalloc.c b/mm/vmalloc.c
index 45ece89..c33d2ae 100644
--- a/mm/vmalloc.c
+++ b/mm/vmalloc.c
@@ -1611,9 +1611,14 @@
struct vm_struct *area;
void *addr;
unsigned long real_size = size;
+#ifdef CONFIG_FIX_MOVABLE_ZONE
+ unsigned long total_pages = total_unmovable_pages;
+#else
+ unsigned long total_pages = totalram_pages;
+#endif
size = PAGE_ALIGN(size);
- if (!size || (size >> PAGE_SHIFT) > totalram_pages)
+ if (!size || (size >> PAGE_SHIFT) > total_pages)
return NULL;
area = __get_vm_area_node(size, align, VM_ALLOC, start, end, node,
diff --git a/net/bluetooth/l2cap_core.c b/net/bluetooth/l2cap_core.c
index 9ab0199..4c50713 100644
--- a/net/bluetooth/l2cap_core.c
+++ b/net/bluetooth/l2cap_core.c
@@ -3749,9 +3749,9 @@
/* Initialize rfc in case no rfc option is received */
rfc.mode = pi->mode;
- rfc.retrans_timeout = L2CAP_DEFAULT_RETRANS_TO;
- rfc.monitor_timeout = L2CAP_DEFAULT_MONITOR_TO;
- rfc.max_pdu_size = L2CAP_DEFAULT_MAX_PDU_SIZE;
+ rfc.retrans_timeout = cpu_to_le16(L2CAP_DEFAULT_RETRANS_TO);
+ rfc.monitor_timeout = cpu_to_le16(L2CAP_DEFAULT_MONITOR_TO);
+ rfc.max_pdu_size = cpu_to_le16(L2CAP_DEFAULT_MAX_PDU_SIZE);
while (len >= L2CAP_CONF_OPT_SIZE) {
len -= l2cap_get_conf_opt(&rsp, &type, &olen, &val);
@@ -3849,9 +3849,9 @@
/* Initialize rfc in case no rfc option is received */
rfc.mode = pi->mode;
- rfc.retrans_timeout = L2CAP_DEFAULT_RETRANS_TO;
- rfc.monitor_timeout = L2CAP_DEFAULT_MONITOR_TO;
- rfc.max_pdu_size = L2CAP_DEFAULT_MAX_PDU_SIZE;
+ rfc.retrans_timeout = cpu_to_le16(L2CAP_DEFAULT_RETRANS_TO);
+ rfc.monitor_timeout = cpu_to_le16(L2CAP_DEFAULT_MONITOR_TO);
+ rfc.max_pdu_size = cpu_to_le16(L2CAP_DEFAULT_MAX_PDU_SIZE);
if ((pi->mode != L2CAP_MODE_ERTM) && (pi->mode != L2CAP_MODE_STREAMING))
return;