select PLAT_RK
select CPU_V7
select ARM_GIC
- select PL330
+ select RK_PL330_DMA
select HAVE_SMP
select MIGHT_HAVE_CACHE_L2X0
select ARM_ERRATA_764369
CONFIG_SPI_FPGA_GPIO_IRQ_NUM=0
CONFIG_POWER_SUPPLY=y
CONFIG_TWL6030_BCI_BATTERY=y
+CONFIG_POWER_ON_CHARGER_DISPLAY=y
+CONFIG_TWL60xx_VBAT_LOW_DETECTION=y
# CONFIG_HWMON is not set
CONFIG_TWL4030_CORE=y
CONFIG_TWL6030_POWEROFF=y
.resource_config = twl4030_rconfig,
};
+#ifdef CONFIG_HAS_EARLYSUSPEND
+void twl60xx_pmu_early_suspend(struct regulator_dev *rdev)
+{
+ printk("%s\n", __func__);
+
+ twl_reg_write(0x06,TWL_MODULE_PIH, 0x00);
+}
+void twl60xx_pmu_early_resume(struct regulator_dev *rdev)
+{
+ printk("%s\n", __func__);
+
+ twl_reg_write(0x06,TWL_MODULE_PIH, 0x04);
+}
+#else
+void twl60xx_pmu_early_suspend(struct regulator_dev *rdev)
+{
+}
+void twl60xx_pmu_early_resume(struct regulator_dev *rdev)
+{
+}
+#endif
void __sramfunc board_pmu_suspend(void)
{
return 0;
}
#endif
+
+#define AVS_BASE 172
int wm831x_post_init(struct wm831x *Wm831x)
{
struct regulator *dcdc;
udelay(100);
dcdc = regulator_get(NULL, "vdd_core"); // vdd_log
+
+ /* Read avs value under logic 1.1V*/
+ regulator_set_voltage(dcdc, 1100000, 1100000);
+ avs_init_val_get(1,1100000,"wm8326 init");
+ udelay(600);
+ avs_set_scal_val(AVS_BASE);
+
regulator_set_voltage(dcdc, 1150000, 1150000);
regulator_set_suspend_voltage(dcdc, 1000000);
regulator_enable(dcdc);
#if defined(CONFIG_SPIM_RK29)
#include "../../../drivers/spi/rk29_spim.h"
#endif
+#if defined(CONFIG_MU509)
+#include <linux/mu509.h>
+#endif
+#if defined(CONFIG_MW100)
+#include <linux/mw100.h>
+#endif
+#if defined(CONFIG_MT6229)
+#include <linux/mt6229.h>
+#endif
#if defined(CONFIG_ANDROID_TIMED_GPIO)
#include "../../../drivers/staging/android/timed_gpio.h"
#endif
}
};
#endif
+#if defined(CONFIG_MU509)
+static int mu509_io_init(void)
+{
+
+ rk30_mux_api_set(GPIO2B6_LCDC1DATA14_SMCADDR18_TSSYNC_NAME, GPIO2B_GPIO2B6);
+ rk30_mux_api_set(GPIO4D2_SMCDATA10_TRACEDATA10_NAME, GPIO4D_GPIO4D2);
+ rk30_mux_api_set(GPIO2B7_LCDC1DATA15_SMCADDR19_HSADCDATA7_NAME, GPIO2B_GPIO2B7);
+ rk30_mux_api_set(GPIO2C0_LCDCDATA16_GPSCLK_HSADCCLKOUT_NAME, GPIO2C_GPIO2C0);
+ return 0;
+}
+
+static int mu509_io_deinit(void)
+{
+
+ return 0;
+}
+
+struct rk29_mu509_data rk29_mu509_info = {
+ .io_init = mu509_io_init,
+ .io_deinit = mu509_io_deinit,
+ .modem_power_en = RK30_PIN6_PB2,//RK30_PIN4_PD1,
+ .bp_power = RK30_PIN2_PB6,//RK30_PIN4_PD1,
+ .bp_reset = RK30_PIN4_PD2,
+ .ap_wakeup_bp = RK30_PIN2_PB7,
+ .bp_wakeup_ap = RK30_PIN6_PA0,
+};
+struct platform_device rk29_device_mu509 = {
+ .name = "mu509",
+ .id = -1,
+ .dev = {
+ .platform_data = &rk29_mu509_info,
+ }
+ };
+#endif
+#if defined(CONFIG_MW100)
+static int mw100_io_init(void)
+{
+ rk30_mux_api_set(GPIO2B6_LCDC1DATA14_SMCADDR18_TSSYNC_NAME, GPIO2B_GPIO2B6);
+ rk30_mux_api_set(GPIO4D2_SMCDATA10_TRACEDATA10_NAME, GPIO4D_GPIO4D2);
+ rk30_mux_api_set(GPIO2B7_LCDC1DATA15_SMCADDR19_HSADCDATA7_NAME, GPIO2B_GPIO2B7);
+ rk30_mux_api_set(GPIO2C0_LCDCDATA16_GPSCLK_HSADCCLKOUT_NAME, GPIO2C_GPIO2C0);
+ return 0;
+}
+
+static int mw100_io_deinit(void)
+{
+
+ return 0;
+}
+
+struct rk29_mw100_data rk29_mw100_info = {
+ .io_init = mw100_io_init,
+ .io_deinit = mw100_io_deinit,
+ .modem_power_en = RK30_PIN6_PB2,
+ .bp_power = RK30_PIN2_PB6,
+ .bp_reset = RK30_PIN4_PD2,
+ .ap_wakeup_bp = RK30_PIN2_PB7,
+ .bp_wakeup_ap = RK30_PIN6_PA0,
+};
+struct platform_device rk29_device_mw100 = {
+ .name = "mw100",
+ .id = -1,
+ .dev = {
+ .platform_data = &rk29_mw100_info,
+ }
+ };
+#endif
+#if defined(CONFIG_MT6229)
+static int mt6229_io_init(void)
+{
+ rk30_mux_api_set(GPIO2B6_LCDC1DATA14_SMCADDR18_TSSYNC_NAME, GPIO2B_GPIO2B6);
+ rk30_mux_api_set(GPIO4D2_SMCDATA10_TRACEDATA10_NAME, GPIO4D_GPIO4D2);
+ rk30_mux_api_set(GPIO2B7_LCDC1DATA15_SMCADDR19_HSADCDATA7_NAME, GPIO2B_GPIO2B7);
+ rk30_mux_api_set(GPIO2C0_LCDCDATA16_GPSCLK_HSADCCLKOUT_NAME, GPIO2C_GPIO2C0);
+ return 0;
+}
+
+static int mt6229_io_deinit(void)
+{
+
+ return 0;
+}
+
+struct rk29_mt6229_data rk29_mt6229_info = {
+ .io_init = mt6229_io_init,
+ .io_deinit = mt6229_io_deinit,
+ .modem_power_en = RK30_PIN6_PB2,
+ .bp_power = RK30_PIN2_PB7,//RK30_PIN2_PB6,
+ .bp_reset = RK30_PIN4_PD2,
+ .ap_wakeup_bp = RK30_PIN2_PC0,
+ .bp_wakeup_ap = RK30_PIN6_PA0,
+};
+struct platform_device rk29_device_mt6229 = {
+ .name = "mt6229",
+ .id = -1,
+ .dev = {
+ .platform_data = &rk29_mt6229_info,
+ }
+ };
+#endif
/*MMA8452 gsensor*/
#if defined (CONFIG_GS_MMA8452)
#ifdef CONFIG_RK29_SUPPORT_MODEM
&rk30_device_modem,
#endif
+#if defined(CONFIG_MU509)
+ &rk29_device_mu509,
+#endif
+#if defined(CONFIG_MW100)
+ &rk29_device_mw100,
+#endif
+#if defined(CONFIG_MT6229)
+ &rk29_device_mt6229,
+#endif
#ifdef CONFIG_BATTERY_RK30_ADC
&rk30_device_adc_battery,
#endif
static void __init machine_rk30_board_init(void)
{
+ avs_init();
gpio_request(POWER_ON_PIN, "poweronpin");
gpio_direction_output(POWER_ON_PIN, GPIO_HIGH);
#include <mach/clock.h>\r
#include <linux/regulator/consumer.h>\r
#include <linux/delay.h>\r
+#include <linux/io.h>\r
+#include <linux/hrtimer.h>\r
\r
#define DVFS_DBG(fmt, args...) {while(0);}\r
-#define DVFS_ERR(fmt, args...) pr_err("DVFS ERR:\t"fmt, ##args)\r
-#define DVFS_LOG(fmt, args...) pr_debug(fmt, ##args)\r
-//#define DVFS_LOG(fmt, args...) pr_err(fmt, ##args)\r
+#define DVFS_ERR(fmt, args...) printk("DVFS ERR:\t"fmt, ##args)\r
+#define DVFS_LOG(fmt, args...) printk("DVFS LOG:\t"fmt, ##args)\r
\r
#define dvfs_regulator_get(dev,id) regulator_get((dev),(id))\r
#define dvfs_regulator_put(regu) regulator_put((regu))\r
extern int rk30_clk_notifier_register(struct clk *clk, struct notifier_block *nb);\r
extern int rk30_clk_notifier_unregister(struct clk *clk, struct notifier_block *nb);\r
\r
-// #define DVFS_DUMP_TREE\r
-#ifdef DVFS_DUMP_TREE\r
-static void dump_dbg_map(void);\r
-#endif\r
+static int dump_dbg_map(char* buf);\r
\r
#define PD_ON 1\r
#define PD_OFF 0\r
struct vd_node *vd;\r
struct depend_list *depend;\r
struct clk_node *info;\r
+\r
info = clk_get_dvfs_info(clk);\r
if (!table || !info || !vd_name) {\r
DVFS_ERR("%s :DVFS SET DEPEND TABLE ERROR! table or info or name empty\n", __func__);\r
\r
list_for_each_entry(vd, &rk_dvfs_tree, node) {\r
if (0 == strcmp(vd->name, vd_name)) {\r
- DVFS_LOG("FOUND A MATCH\n");\r
+ DVFS_DBG("FOUND A MATCH\n");\r
mutex_lock(&mutex);\r
list_for_each_entry(depend, &info->depend_list, node2clk) {\r
if (vd == depend->dep_vd && info == depend->dvfs_clk) {\r
}\r
}\r
mutex_unlock(&mutex);\r
-#ifdef DVFS_DUMP_TREE\r
- dump_dbg_map();\r
-#endif\r
return 0;\r
}\r
}\r
}\r
\r
if (!depend->dep_vd->regulator) {\r
- DVFS_LOG("%s regulator empty\n", __func__);\r
+ DVFS_DBG("%s regulator empty\n", __func__);\r
regulator = dvfs_regulator_get(NULL, depend->dep_vd->regulator_name);\r
if (!regulator) {\r
DVFS_ERR("%s get regulator err\n", __func__);\r
\r
if (clk_fv.index == dvfs_regulator_get_voltage(depend->dep_vd->regulator)) {\r
depend->req_volt = clk_fv.index;\r
- DVFS_LOG("%s same voltage\n", __func__);\r
+ DVFS_DBG("%s same voltage\n", __func__);\r
return 0;\r
}\r
\r
depend->req_volt = clk_fv.index;\r
volt = dvfs_vd_get_newvolt_bypd(depend->dep_vd);\r
- DVFS_LOG("%s setting voltage = %d\n", __func__, volt);\r
+ DVFS_DBG("%s setting voltage = %d\n", __func__, volt);\r
ret = dvfs_regulator_set_voltage_readback(depend->dep_vd->regulator, volt, volt);\r
if (0 != ret) {\r
DVFS_ERR("%s set voltage = %d ERROR, ret = %d\n", __func__, volt, ret);\r
return -1;\r
}\r
udelay(200);\r
- DVFS_LOG("%s set voltage = %d OK, ret = %d\n", __func__, volt, ret);\r
+ DVFS_DBG("%s set voltage = %d OK, ret = %d\n", __func__, volt, ret);\r
if (ret != 0) {\r
DVFS_ERR("%s err, ret = %d\n", __func__, ret);\r
return -1;\r
}\r
\r
if (!depend->dep_vd->regulator) {\r
- DVFS_LOG("%s regulator empty\n", __func__);\r
+ DVFS_DBG("%s regulator empty\n", __func__);\r
regulator = dvfs_regulator_get(NULL, depend->dep_vd->regulator_name);\r
if (!regulator) {\r
DVFS_ERR("%s get regulator err\n", __func__);\r
\r
if (clk_fv.index == dvfs_regulator_get_voltage(depend->dep_vd->regulator)) {\r
depend->req_volt = clk_fv.index;\r
- DVFS_LOG("%s same voltage\n", __func__);\r
+ DVFS_DBG("%s same voltage\n", __func__);\r
return 0;\r
}\r
\r
depend->req_volt = clk_fv.index;\r
volt = dvfs_vd_get_newvolt_bypd(depend->dep_vd);\r
- DVFS_LOG("%s setting voltage = %d\n", __func__, volt);\r
+ DVFS_DBG("%s setting voltage = %d\n", __func__, volt);\r
ret = dvfs_regulator_set_voltage_readback(depend->dep_vd->regulator, volt, volt);\r
if (0 != ret) {\r
DVFS_ERR("%s set voltage = %d ERROR, ret = %d\n", __func__, volt, ret);\r
return -1;\r
}\r
udelay(200);\r
- DVFS_LOG("%s set voltage = %d OK, ret = %d\n", __func__, volt, ret);\r
+ DVFS_DBG("%s set voltage = %d OK, ret = %d\n", __func__, volt, ret);\r
if (ret != 0) {\r
DVFS_ERR("%s err, ret = %d\n", __func__, ret);\r
return -1;\r
for (i = 0; i < ARRAY_SIZE(rk30_depends); i++) {\r
rk_regist_depends(&rk30_depends[i]);\r
}\r
-#ifdef DVFS_DUMP_TREE\r
- dump_dbg_map();\r
+ return 0;\r
+}\r
+\r
+/*******************************AVS AREA****************************************/\r
+/*\r
+ * To use AVS function, you must call avs_init in machine_rk30_board_init(void)(board-rk30-sdk.c)\r
+ * And then call(vdd_log):\r
+ * regulator_set_voltage(dcdc, 1100000, 1100000);\r
+ * avs_init_val_get(1,1100000,"wm8326 init");\r
+ * udelay(600);\r
+ * avs_set_scal_val(AVS_BASE);\r
+ * in wm831x_post_init(board-rk30-sdk-wm8326.c)\r
+ * AVS_BASE can use 172\r
+ */\r
+\r
+static int avs_scale_volt = 0;\r
+static int avs_get_scal_val(int vol);\r
+\r
+int dvfs_avs_scale_table(struct clk *clk, char *depend_vd_name)\r
+{\r
+ /* if depend_vd_name == NULL scale clk table\r
+ * else scale clk's depend table, named depend_vd_name\r
+ * */\r
+ struct vd_node *vd;\r
+ struct depend_list *depend;\r
+ struct clk_node *info = clk_get_dvfs_info(clk);\r
+ struct cpufreq_frequency_table *table = NULL;\r
+ int i;\r
+\r
+ if (NULL == depend_vd_name) {\r
+ table = info->dvfs_table;\r
+ } else {\r
+ list_for_each_entry(vd, &rk_dvfs_tree, node) {\r
+ if (0 == strcmp(vd->name, depend_vd_name)) {\r
+ DVFS_DBG("%S FOUND A MATCH vd\n", __func__);\r
+ mutex_lock(&mutex);\r
+ list_for_each_entry(depend, &info->depend_list, node2clk) {\r
+ if (vd == depend->dep_vd && info == depend->dvfs_clk) {\r
+ DVFS_DBG("%S FOUND A MATCH table\n", __func__);\r
+ table = depend->dep_table;\r
+ break;\r
+ }\r
+ }\r
+ mutex_unlock(&mutex);\r
+ }\r
+ }\r
+ }\r
+\r
+ if (table == NULL) {\r
+ DVFS_ERR("%s can not find match table\n", __func__);\r
+ return -1;\r
+ }\r
+ if (avs_scale_volt != 0) {\r
+ DVFS_LOG("AVS scale %s, depend name = %s, voltage = %d\n",\r
+ info->name, depend_vd_name, avs_scale_volt);\r
+ for (i = 0; table[i].frequency != CPUFREQ_TABLE_END; i++) {\r
+ table[i].index = avs_get_scal_val(table[i].index);\r
+ }\r
+ }\r
+ return 0;\r
+}\r
+\r
+static void __iomem *rk30_nandc_base;\r
+\r
+#define nandc_readl(offset) readl_relaxed(rk30_nandc_base + offset)\r
+#define nandc_writel(v, offset) do { writel_relaxed(v, rk30_nandc_base + offset); dsb(); } while (0)\r
+static u8 rk30_get_avs_val(void)\r
+{\r
+ u32 nanc_save_reg[4];\r
+ unsigned long flags;\r
+ u32 paramet = 0;\r
+ u32 count = 100;\r
+ preempt_disable();\r
+ local_irq_save(flags);\r
+\r
+ nanc_save_reg[0] = nandc_readl(0);\r
+ nanc_save_reg[1] = nandc_readl(0x130);\r
+ nanc_save_reg[2] = nandc_readl(0x134);\r
+ nanc_save_reg[3] = nandc_readl(0x158);\r
+\r
+ nandc_writel(nanc_save_reg[0] | 0x1 << 14, 0);\r
+ nandc_writel(0x5, 0x130);\r
+\r
+ nandc_writel(7, 0x158);\r
+ nandc_writel(1, 0x134);\r
+\r
+ while(count--) {\r
+ paramet = nandc_readl(0x138);\r
+ if((paramet & 0x1))\r
+ break;\r
+ udelay(1);\r
+ };\r
+ paramet = (paramet >> 1) & 0xff;\r
+ nandc_writel(nanc_save_reg[0], 0);\r
+ nandc_writel(nanc_save_reg[1], 0x130);\r
+ nandc_writel(nanc_save_reg[2], 0x134);\r
+ nandc_writel(nanc_save_reg[3], 0x158);\r
+\r
+ local_irq_restore(flags);\r
+ preempt_enable();\r
+ return (u8)paramet;\r
+\r
+}\r
+#define init_avs_times 10\r
+#define init_avs_st_num 5\r
+\r
+struct init_avs_st {\r
+ int is_set;\r
+ u8 paramet[init_avs_times];\r
+ int vol;\r
+ char *s;\r
+};\r
+\r
+static struct init_avs_st init_avs_paramet[init_avs_st_num];\r
+\r
+void avs_init_val_get(int index, int vol, char *s)\r
+{\r
+ int i;\r
+ if(index >= init_avs_times)\r
+ return;\r
+ init_avs_paramet[index].vol = vol;\r
+ init_avs_paramet[index].s = s;\r
+ init_avs_paramet[index].is_set++;\r
+ for(i = 0; i < init_avs_times; i++) {\r
+ init_avs_paramet[index].paramet[i] = rk30_get_avs_val();\r
+ mdelay(1);\r
+ }\r
+}\r
+\r
+void avs_init(void)\r
+{\r
+ memset(&init_avs_paramet[0].is_set, 0, sizeof(init_avs_paramet));\r
+ rk30_nandc_base = ioremap(RK30_NANDC_PHYS, RK30_NANDC_SIZE);\r
+ //avs_init_val_get(0,1150000,"board_init");\r
+}\r
+\r
+#define VOL_DYN_STEP (12500) //mv\r
+#define AVS_VAL_PER_STEP (4) //mv\r
+\r
+static u8 avs_init_get_min_val(void)\r
+{\r
+ int i, j;\r
+ u8 min_avs = 0xff;\r
+ for(i = 0; i < init_avs_st_num; i++) {\r
+ if(init_avs_paramet[i].is_set && init_avs_paramet[i].vol == (1100 * 1000)) {\r
+ for(j = 0; j < init_avs_times; j++)\r
+ min_avs = (u8)min(min_avs, init_avs_paramet[i].paramet[j]);\r
+ }\r
+\r
+ }\r
+ return min_avs;\r
+}\r
+\r
+static int avs_get_scal_val(int vol)\r
+{\r
+ vol += avs_scale_volt;\r
+ if(vol < 1000 * 1000)\r
+ vol = 1000 * 1000;\r
+ if(vol > 1400 * 1000)\r
+ vol = 1400 * 1000;\r
+ return vol;\r
+}\r
+#if 0\r
+u8 avs_test_date[] = {172, 175, 176, 179, 171, 168, 165, 162, 199, 0};\r
+u8 avs_test_date_cunt = 0;\r
#endif\r
+int avs_set_scal_val(u8 avs_base)\r
+{\r
+ u8 avs_test = avs_init_get_min_val();\r
+ s8 step = 0;\r
+\r
+ if (avs_base < avs_test) {\r
+ DVFS_LOG("AVS down voltage, ignore\n");\r
+ return 0;\r
+ }\r
+ step = (avs_base - avs_test) / AVS_VAL_PER_STEP;\r
+ step = (avs_base > avs_test) ? (step + 1) : step;\r
+ if (step > 2)\r
+ step += 1;\r
+ avs_scale_volt = (step) * (VOL_DYN_STEP);\r
+\r
+ DVFS_LOG("avs_set_scal_val test=%d,base=%d,step=%d,scale_vol=%d\n",\r
+ avs_test, avs_base, step, avs_scale_volt);\r
return 0;\r
}\r
\r
-#ifdef DVFS_DUMP_TREE\r
+/*************************interface to get avs value and dvfs tree*************************/\r
+#define USE_NORMAL_TIME\r
+#ifdef USE_NORMAL_TIME\r
+static struct timer_list avs_timer;\r
+#else\r
+static struct hrtimer dvfs_hrtimer;\r
+#endif\r
+\r
+static u32 avs_dyn_start = 0;\r
+static u32 avs_dyn_data_cnt;\r
+static u8 *avs_dyn_data = NULL;\r
+static u32 show_line_cnt = 0;\r
+static u8 dly_min;\r
+static u8 dly_max;\r
+\r
+#define val_per_line (30)\r
+#define line_pre_show (30)\r
+#define avs_dyn_data_num (3*1000*1000)\r
+\r
+static u32 print_avs_init(char *buf)\r
+{\r
+ char *s = buf;\r
+ int i, j;\r
+\r
+ for(j = 0; j < init_avs_st_num; j++) {\r
+ if(init_avs_paramet[j].vol <= 0)\r
+ continue;\r
+ s += sprintf(s, "%s ,vol=%d,paramet following\n", \r
+ init_avs_paramet[j].s, init_avs_paramet[j].vol);\r
+ for(i = 0; i < init_avs_times; i++) {\r
+ s += sprintf(s, "%d ", init_avs_paramet[j].paramet[i]);\r
+ }\r
+\r
+ s += sprintf(s, "\n");\r
+ }\r
+ return (s - buf);\r
+}\r
+\r
+static ssize_t avs_init_show(struct kobject *kobj, struct kobj_attribute *attr,\r
+ char *buf)\r
+{\r
+ return print_avs_init(buf);\r
+}\r
+\r
+static ssize_t avs_init_store(struct kobject *kobj, struct kobj_attribute *attr,\r
+ const char *buf, size_t n)\r
+{\r
+\r
+ return n;\r
+}\r
+static ssize_t avs_now_show(struct kobject *kobj, struct kobj_attribute *attr,\r
+ char *buf)\r
+{\r
+ return sprintf(buf, "%d\n", rk30_get_avs_val());\r
+}\r
+\r
+static ssize_t avs_now_store(struct kobject *kobj, struct kobj_attribute *attr,\r
+ const char *buf, size_t n)\r
+{\r
+ return n;\r
+}\r
+static ssize_t avs_dyn_show(struct kobject *kobj, struct kobj_attribute *attr,\r
+ char *buf)\r
+{\r
+ char *s = buf;\r
+ u32 i;\r
+\r
+ if(avs_dyn_start) {\r
+ int start_cnt;\r
+ int end_cnt;\r
+ end_cnt = (avs_dyn_data_cnt ? (avs_dyn_data_cnt - 1) : 0);\r
+ if(end_cnt > (line_pre_show * val_per_line))\r
+ start_cnt = end_cnt - (line_pre_show * val_per_line);\r
+ else\r
+ start_cnt = 0;\r
+\r
+ dly_min = avs_dyn_data[start_cnt];\r
+ dly_max = avs_dyn_data[start_cnt];\r
+\r
+ //s += sprintf(s,"data start=%d\n",i);\r
+ for(i = start_cnt; i <= end_cnt;) {\r
+ s += sprintf(s, "%d", avs_dyn_data[i]);\r
+ dly_min = min(dly_min, avs_dyn_data[i]);\r
+ dly_max = max(dly_max, avs_dyn_data[i]);\r
+ i++;\r
+ if(!(i % val_per_line)) {\r
+ s += sprintf(s, "\n");\r
+ } else\r
+ s += sprintf(s, " ");\r
+ }\r
+\r
+ s += sprintf(s, "\n");\r
+\r
+ s += sprintf(s, "new data is from=%d to %d\n", start_cnt, end_cnt);\r
+ //s += sprintf(s,"\n max=%d,min=%d,totolcnt=%d,line=%d\n",dly_max,dly_min,avs_dyn_data_cnt,show_line_cnt);\r
+\r
+\r
+ } else {\r
+ if(show_line_cnt == 0) {\r
+ dly_min = avs_dyn_data[0];\r
+ dly_max = avs_dyn_data[0];\r
+ }\r
+\r
+\r
+ for(i = show_line_cnt * (line_pre_show * val_per_line); i < avs_dyn_data_cnt;) {\r
+ s += sprintf(s, "%d", avs_dyn_data[i]);\r
+ dly_min = min(dly_min, avs_dyn_data[i]);\r
+ dly_max = max(dly_max, avs_dyn_data[i]);\r
+ i++;\r
+ if(!(i % val_per_line)) {\r
+ s += sprintf(s, "\n");\r
+ } else\r
+ s += sprintf(s, " ");\r
+ if(i >= ((show_line_cnt + 1)*line_pre_show * val_per_line))\r
+ break;\r
+ }\r
+\r
+ s += sprintf(s, "\n");\r
+\r
+ s += sprintf(s, "max=%d,min=%d,totolcnt=%d,line=%d\n", \r
+ dly_max, dly_min, avs_dyn_data_cnt, show_line_cnt);\r
+ show_line_cnt++;\r
+ if(((show_line_cnt * line_pre_show)*val_per_line) >= avs_dyn_data_cnt) {\r
+\r
+ show_line_cnt = 0;\r
+\r
+ s += sprintf(s, "data is over\n");\r
+ }\r
+ }\r
+ return (s - buf);\r
+}\r
+\r
+static ssize_t avs_dyn_store(struct kobject *kobj, struct kobj_attribute *attr,\r
+ const char *buf, size_t n)\r
+{\r
+ const char *pbuf;\r
+\r
+ if((strncmp(buf, "start", strlen("start")) == 0)) {\r
+ pbuf = &buf[strlen("start")];\r
+ avs_dyn_data_cnt = 0;\r
+ show_line_cnt = 0;\r
+ if(avs_dyn_data) {\r
+#ifdef USE_NORMAL_TIME\r
+ mod_timer(&avs_timer, jiffies + msecs_to_jiffies(5));\r
+#else\r
+ hrtimer_start(&dvfs_hrtimer, ktime_set(0, 5 * 1000 * 1000), HRTIMER_MODE_REL);\r
+#endif\r
+ avs_dyn_start = 1;\r
+ }\r
+ //sscanf(pbuf, "%d %d", &number, &voltage);\r
+ //DVFS_LOG("---------ldo %d %d\n", number, voltage);\r
+\r
+ } else if((strncmp(buf, "stop", strlen("stop")) == 0)) {\r
+ pbuf = &buf[strlen("stop")];\r
+ avs_dyn_start = 0;\r
+ show_line_cnt = 0;\r
+ //sscanf(pbuf, "%d %d", &number, &voltage);\r
+ //DVFS_LOG("---------dcdc %d %d\n", number, voltage);\r
+ }\r
+\r
+\r
+\r
+ return n;\r
+}\r
+\r
+static ssize_t dvfs_tree_store(struct kobject *kobj, struct kobj_attribute *attr,\r
+ const char *buf, size_t n)\r
+{\r
+ return n;\r
+}\r
+static ssize_t dvfs_tree_show(struct kobject *kobj, struct kobj_attribute *attr,\r
+ char *buf)\r
+{\r
+ return dump_dbg_map(buf);\r
+\r
+}\r
+\r
+static void avs_timer_fn(unsigned long data)\r
+{\r
+ int i;\r
+ for(i = 0; i < 1; i++) {\r
+ if(avs_dyn_data_cnt >= avs_dyn_data_num)\r
+ return;\r
+ avs_dyn_data[avs_dyn_data_cnt] = rk30_get_avs_val();\r
+ avs_dyn_data_cnt++;\r
+ }\r
+ if(avs_dyn_start)\r
+ mod_timer(&avs_timer, jiffies + msecs_to_jiffies(10));\r
+}\r
+#if 0\r
+struct hrtimer dvfs_hrtimer;\r
+static enum hrtimer_restart dvfs_hrtimer_timer_func(struct hrtimer *timer)\r
+{\r
+ int i;\r
+ for(i = 0; i < 1; i++) {\r
+ if(avs_dyn_data_cnt >= avs_dyn_data_num)\r
+ return HRTIMER_NORESTART;\r
+ avs_dyn_data[avs_dyn_data_cnt] = rk30_get_avs_val();\r
+ avs_dyn_data_cnt++;\r
+ }\r
+ if(avs_dyn_start)\r
+ hrtimer_start(timer, ktime_set(0, 1 * 1000 * 1000), HRTIMER_MODE_REL);\r
+\r
+}\r
+#endif\r
+/*********************************************************************************/\r
+static struct kobject *dvfs_kobj;\r
+struct dvfs_attribute {\r
+ struct attribute attr;\r
+ ssize_t (*show)(struct kobject *kobj, struct kobj_attribute *attr,\r
+ char *buf);\r
+ ssize_t (*store)(struct kobject *kobj, struct kobj_attribute *attr,\r
+ const char *buf, size_t n);\r
+};\r
+\r
+static struct dvfs_attribute dvfs_attrs[] = {\r
+ /* node_name permision show_func store_func */\r
+ __ATTR(dvfs_tree, S_IRUGO | S_IWUSR, dvfs_tree_show, dvfs_tree_store),\r
+ __ATTR(avs_init, S_IRUGO | S_IWUSR, avs_init_show, avs_init_store),\r
+ //__ATTR(avs_dyn, S_IRUGO | S_IWUSR, avs_dyn_show, avs_dyn_store),\r
+ __ATTR(avs_now, S_IRUGO | S_IWUSR, avs_now_show, avs_now_store),\r
+};\r
+\r
+static int __init dvfs_init(void)\r
+{\r
+ int i, ret = 0;\r
+#ifdef USE_NORMAL_TIME\r
+ init_timer(&avs_timer);\r
+ //avs_timer.expires = jiffies+msecs_to_jiffies(1);\r
+ avs_timer.function = avs_timer_fn;\r
+ //mod_timer(&avs_timer,jiffies+msecs_to_jiffies(1));\r
+#else\r
+ hrtimer_init(&dvfs_hrtimer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);\r
+ dvfs_hrtimer.function = dvfs_hrtimer_timer_func;\r
+ //hrtimer_start(&dvfs_hrtimer,ktime_set(0, 5*1000*1000),HRTIMER_MODE_REL);\r
+#endif\r
+ avs_dyn_data = kmalloc(avs_dyn_data_num, GFP_KERNEL);\r
+\r
+ dvfs_kobj = kobject_create_and_add("dvfs", NULL);\r
+ if (!dvfs_kobj)\r
+ return -ENOMEM;\r
+ for (i = 0; i < ARRAY_SIZE(dvfs_attrs); i++) {\r
+ ret = sysfs_create_file(dvfs_kobj, &dvfs_attrs[i].attr);\r
+ if (ret != 0) {\r
+ DVFS_ERR("create index %d error\n", i);\r
+ return ret;\r
+ }\r
+ }\r
+\r
+ return ret;\r
+}\r
+subsys_initcall(dvfs_init);\r
+\r
/**\r
* dump_dbg_map() : Draw all informations of dvfs while debug\r
*/\r
-static void dump_dbg_map(void)\r
+static int dump_dbg_map(char *buf)\r
{\r
int i;\r
struct vd_node *vd;\r
struct clk_list *child;\r
struct clk_node *dvfs_clk;\r
struct depend_list *depend;\r
-\r
- DVFS_LOG("-------------DVFS DEBUG-----------\n\n\n");\r
- DVFS_LOG("RK30 DVFS TREE:\n");\r
+ char* s = buf;\r
+ \r
+ s += sprintf(s, "-------------DVFS TREE-----------\n\n\n");\r
+ s += sprintf(s, "RK30 DVFS TREE:\n");\r
list_for_each_entry(vd, &rk_dvfs_tree, node) {\r
- DVFS_LOG("|\n|- voltage domain:%s\n", vd->name);\r
- DVFS_LOG("|- current voltage:%d\n", vd->cur_volt);\r
+ s += sprintf(s, "|\n|- voltage domain:%s\n", vd->name);\r
+ s += sprintf(s, "|- current voltage:%d\n", vd->cur_volt);\r
list_for_each_entry(depend, &vd->req_volt_list, node2vd) {\r
- DVFS_LOG("|- request voltage:%d, clk:%s\n", depend->req_volt, depend->dvfs_clk->name);\r
+ s += sprintf(s, "|- request voltage:%d, clk:%s\n", depend->req_volt, depend->dvfs_clk->name);\r
}\r
\r
list_for_each_entry(pd, &vd->pd_list, node) {\r
- DVFS_LOG("| |\n| |- power domain:%s, status = %s, current volt = %d\n",\r
+ s += sprintf(s, "| |\n| |- power domain:%s, status = %s, current volt = %d\n",\r
pd->name, (pd->pd_status == PD_ON) ? "ON" : "OFF", pd->cur_volt);\r
\r
list_for_each_entry(child, &pd->clk_list, node) {\r
dvfs_clk = child->dvfs_clk;\r
- DVFS_LOG("| | |\n| | |- clock: %s current: rate %d, volt = %d, enable_dvfs = %s\n",\r
+ s += sprintf(s, "| | |\n| | |- clock: %s current: rate %d, volt = %d, enable_dvfs = %s\n",\r
dvfs_clk->name, dvfs_clk->set_freq, dvfs_clk->set_volt, \r
dvfs_clk->enable_dvfs == 0 ? "DISABLE" : "ENABLE");\r
for (i = 0; dvfs_clk->pds[i].pd != NULL; i++) {\r
clkparent = dvfs_clk->pds[i].pd;\r
- DVFS_LOG("| | | |- clock parents: %s, vd_parent = %s\n", \r
+ s += sprintf(s, "| | | |- clock parents: %s, vd_parent = %s\n", \r
clkparent->name, clkparent->vd->name);\r
}\r
\r
for (i = 0; (dvfs_clk->dvfs_table[i].frequency != CPUFREQ_TABLE_END); i++) {\r
- DVFS_LOG("| | | |- freq = %d, volt = %d\n", \r
+ s += sprintf(s, "| | | |- freq = %d, volt = %d\n", \r
dvfs_clk->dvfs_table[i].frequency, \r
dvfs_clk->dvfs_table[i].index);\r
\r
}\r
\r
list_for_each_entry(depend, &dvfs_clk->depend_list, node2clk) {\r
- DVFS_LOG("| | | | |- DEPEND VD: %s\n", depend->dep_vd->name); \r
+ s += sprintf(s, "| | | | |- DEPEND VD: %s\n", depend->dep_vd->name); \r
for (i = 0; (depend->dep_table[i].frequency != CPUFREQ_TABLE_END); i++) {\r
- DVFS_LOG("| | | | |- freq = %d, req_volt = %d\n", \r
+ s += sprintf(s, "| | | | |- freq = %d, req_volt = %d\n", \r
depend->dep_table[i].frequency, \r
depend->dep_table[i].index);\r
\r
}\r
}\r
}\r
- DVFS_LOG("-------------DVFS DEBUG END------------\n");\r
+ s += sprintf(s, "-------------DVFS TREE END------------\n");\r
+ return s - buf;\r
}\r
-#endif\r
-\r
\r
\r
int dvfs_clk_enable_limit(struct clk *clk, unsigned int min_rate, unsigned max_rate);\r
int dvfs_clk_disable_limit(struct clk *clk);\r
\r
+void avs_init(void);\r
+void avs_init_val_get(int index,int vol,char *s);\r
+int avs_set_scal_val(u8 avs_base);\r
+int dvfs_avs_scale_table(struct clk* clk, char* depend_vd_name);\r
#else\r
static inline int rk30_dvfs_init(void) { return 0; }\r
static inline int is_support_dvfs(struct clk_node *dvfs_info) { return 0; }\r
static inline struct regulator* dvfs_get_regulator(char *regulator_name){ return NULL; }\r
static inline int dvfs_clk_enable_limit(struct clk *clk, unsigned int min_rate, unsigned max_rate){ return 0; }\r
static inline int dvfs_clk_disable_limit(struct clk *clk){ return 0; };\r
+\r
+static inline void avs_init(void){};\r
+static inline void avs_init_val_get(int index, int vol, char *s){};\r
+static inline int avs_set_scal_val(u8 avs_base){ return 0; };\r
+static inline int dvfs_avs_scale_table(struct clk* clk, char* depend_vd_name){ return 0; };\r
#endif\r
\r
#endif\r
, clkgt_regs[5], CRU_CLKGATES_CON(5), 0xffff);
gate_save_soc_clk(0, clkgt_regs[6], CRU_CLKGATES_CON(6), 0xffff);
gate_save_soc_clk(0, clkgt_regs[7], CRU_CLKGATES_CON(7), 0xffff);
- gate_save_soc_clk(0
- | (1 << CLK_GATE_PCLK_GPIO6 % 16)
- , clkgt_regs[8], CRU_CLKGATES_CON(8), 0xffff);
+ gate_save_soc_clk(0 , clkgt_regs[8], CRU_CLKGATES_CON(8), 0x01ff);
gate_save_soc_clk(0
| (1 << CLK_GATE_CLK_L2C % 16)
| (1 << CLK_GATE_PCLK_PUBL % 16)
bool "Sound DMA buffer in internal SRAM"
depends on ARCH_RK30
+config RK_PL330_DMA
+ bool
+ select PL330
+ help
+ DMA API Driver for PL330 DMAC
+
endif
obj-$(CONFIG_RK29_LAST_LOG) += last_log.o
obj-$(CONFIG_USB_GADGET) += usb_detect.o
obj-$(CONFIG_RK29_VPU) += vpu_service.o
-obj-$(CONFIG_ARCH_RK30) += dma-pl330.o
-obj-$(CONFIG_ARCH_RK2928) += dma-pl330.o
+obj-$(CONFIG_RK_PL330_DMA) += dma-pl330.o
obj-$(CONFIG_FIQ) += fiq.o
obj-$(CONFIG_FIQ_DEBUGGER) += rk_fiq_debugger.o
obj-$(CONFIG_RK_EARLY_PRINTK) += early_printk.o ../kernel/debug.o
{
case RK29_CAM_SUBDEV_DEACTIVATE:
{
+ #if CONFIG_SENSOR_Flash //hhb
+ sensor_ioctrl(icd, Sensor_Flash, Flash_Off);
+ #endif
sensor_deactivate(client);
break;
}
#include <linux/i2c/twl.h>
#include "twl-core.h"
+#include <linux/earlysuspend.h>
+#ifdef CONFIG_HAS_EARLYSUSPEND
+static struct early_suspend twl60xx_early_suspend;
+#endif
+
#if defined(CONFIG_ARCH_OMAP2) || defined(CONFIG_ARCH_OMAP3)
#include <plat/cpu.h>
#endif
}
/* NOTE: this driver only handles a single twl4030/tps659x0 chip */
+__weak void twl60xx_pmu_early_suspend(struct regulator_dev *rdev) {}
+__weak void twl60xx_pmu_early_resume(struct regulator_dev *rdev) {}
+
static int __devinit
twl_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
printk(" tps80032 set_init() failed\n");
}
}
+ #ifdef CONFIG_HAS_EARLYSUSPEND
+ twl60xx_early_suspend.level = 0xffff;
+ twl60xx_early_suspend.suspend = twl60xx_pmu_early_suspend;
+ twl60xx_early_suspend.resume = twl60xx_pmu_early_resume;
+ register_early_suspend(&twl60xx_early_suspend);
+ #endif
+
fail:
if (status < 0)
#include "twl-core.h"
+#include <mach/board.h>
/*
* TWL6030 (unlike its predecessors, which had two level interrupt handling)
* three interrupt registers INT_STS_A, INT_STS_B and INT_STS_C.
*/
static irqreturn_t handle_twl6030_vlow(int irq, void *unused)
{
+#ifdef CONFIG_TWL60xx_VBAT_LOW_DETECTION
+ rk28_send_wakeup_key();
+#else
pr_err("twl6030: BAT_VLOW interrupt; threshold=%dmV\n",
2300 + (vbatmin_hi_threshold - 0b110) * 50);
-
#if 1 /* temporary */
pr_err("%s: disabling BAT_VLOW interrupt\n", __func__);
disable_irq_nosync(twl6030_irq_base + TWL_VLOW_INTR_OFFSET);
#else
pr_emerg("handle_twl6030_vlow: kernel_power_off()\n");
kernel_power_off();
+#endif
#endif
return IRQ_HANDLED;
}
config MW100
bool "MW100 modem control driver"
+config MT6229
+ bool "MT6229 modem control driver"
+
config RK29_NEWTON
bool "RK29_NEWTON misc driver"
+++ /dev/null
-#include <linux/module.h>
-#include <linux/kernel.h>
-#include <linux/i2c.h>
-#include <linux/irq.h>
-#include <linux/gpio.h>
-#include <linux/input.h>
-#include <linux/platform_device.h>
-#include <linux/fs.h>
-#include <linux/uaccess.h>
-#include <linux/miscdevice.h>
-#include <linux/circ_buf.h>
-#include <linux/interrupt.h>
-#include <linux/miscdevice.h>
-#include <mach/iomux.h>
-#include <mach/gpio.h>
-#include <linux/delay.h>
-#include <linux/poll.h>
-#include <linux/wait.h>
-#include <linux/wakelock.h>
-#include <linux/workqueue.h>
-#include <linux/mu509.h>
-#include <mach/iomux.h>
-#include<linux/ioctl.h>
-
-MODULE_LICENSE("GPL");
-
-//#define DEBUG
-#ifdef DEBUG
-#define MODEMDBG(x...) printk(x)
-#else
-#define MODEMDBG(fmt,argss...)
-#endif
-
-#define MW100IO 0XA1
-#define MW_IOCTL_RESET _IO(MW100IO,0X01)
-
-#define SLEEP 1
-#define READY 0
-#define MU509_RESET 0x01
-static struct wake_lock modem_wakelock;
-#define IRQ_BB_WAKEUP_AP_TRIGGER IRQF_TRIGGER_RISING
-//#define IRQ_BB_WAKEUP_AP_TRIGGER IRQF_TRIGGER_RISING
-struct rk29_mu509_data *gpdata = NULL;
-static int bp_wakeup_ap_irq = 0;
-
-
-static void ap_wakeup_bp(struct platform_device *pdev, int wake)
-{
- struct rk29_mu509_data *pdata = pdev->dev.platform_data;
- MODEMDBG("ap_wakeup_bp\n");
-
- gpio_set_value(pdata->ap_wakeup_bp, wake);
-
-}
-extern void rk28_send_wakeup_key(void);
-
-static void do_wakeup(struct work_struct *work)
-{
- MODEMDBG("%s[%d]: %s\n", __FILE__, __LINE__, __FUNCTION__);
- rk28_send_wakeup_key();
- enable_irq(bp_wakeup_ap_irq);
-}
-
-static DECLARE_DELAYED_WORK(wakeup_work, do_wakeup);
-static irqreturn_t detect_irq_handler(int irq, void *dev_id)
-{
- disable_irq_nosync( irq);
- printk("%s[%d]: %s\n", __FILE__, __LINE__, __FUNCTION__);
- schedule_delayed_work(&wakeup_work, HZ / 10);
-
- return IRQ_HANDLED;
-}
-int modem_poweron_off(int on_off)
-{
- struct rk29_mu509_data *pdata = gpdata;
- if(on_off)
- {
- MODEMDBG("%s::%d--bruins--\n",__func__,__LINE__);
-/*
- gpio_set_value(pdata->bp_power, GPIO_LOW);
- msleep(1000);
- gpio_set_value(pdata->bp_power, GPIO_HIGH);
- msleep(700);
- gpio_set_value(pdata->ap_wakeup_bp, GPIO_LOW);
-*/
- }
- else
- {
- MODEMDBG("%s::%d--bruins--\n",__func__,__LINE__);
-/*
- gpio_set_value(pdata->bp_power, GPIO_LOW);
- mdelay(2500);
- gpio_set_value(pdata->bp_power, GPIO_HIGH);
-*/
- }
- return 0;
-}
-static int mu509_open(struct inode *inode, struct file *file)
-{
- MODEMDBG("%s::%d--bruins--\n",__func__,__LINE__);
- //modem_poweron_off(1);
- return 0;
-}
-
-static int mu509_release(struct inode *inode, struct file *file)
-{
- MODEMDBG("%s::%d--bruins--\n",__func__,__LINE__);
- //modem_poweron_off(0);
- return 0;
-}
-
-static int mu509_ioctl(struct inode *inode,struct file *file, unsigned int cmd, unsigned long arg)
-{
- struct rk29_mu509_data *pdata = gpdata;
- switch(cmd)
- {
- case MW_IOCTL_RESET:
- printk("%s::%d--bruins--ioctl mw100 reset\n",__func__,__LINE__);
- gpio_direction_output(pdata->bp_reset,GPIO_LOW);
- mdelay(120);
- gpio_set_value(pdata->bp_reset, GPIO_HIGH);
-
- break;
- default:
- break;
- }
- return 0;
-}
-
-static struct file_operations mu509_fops = {
- .owner = THIS_MODULE,
- .open = mu509_open,
- .release = mu509_release,
- .ioctl = mu509_ioctl
-};
-
-static struct miscdevice mu509_misc = {
- .minor = MISC_DYNAMIC_MINOR,
- .name = "mw100",
- .fops = &mu509_fops
-};
-
-static int mu509_probe(struct platform_device *pdev)
-{
- struct rk29_mu509_data *pdata = gpdata = pdev->dev.platform_data;
- struct modem_dev *mu509_data = NULL;
- int result, irq = 0;
-
- gpio_request(pdata->bp_power,"bp_power");
- gpio_request(pdata->bp_reset,"bp_reset");
- gpio_request(pdata->bp_wakeup_ap,"bp_wakeup_ap");
- gpio_request(pdata->ap_wakeup_bp,"ap_wakeup_bp");
-
- rk29_mux_api_set(GPIO6C76_CPUTRACEDATA76_NAME, GPIO4H_GPIO6C76);
-
- gpio_direction_output(pdata->bp_reset,GPIO_LOW);
- mdelay(120);
- gpio_set_value(pdata->bp_reset, GPIO_HIGH);
-
- gpio_set_value(pdata->ap_wakeup_bp, GPIO_HIGH);
- gpio_direction_output(pdata->ap_wakeup_bp,GPIO_HIGH);
-
- gpio_set_value(pdata->bp_power, GPIO_HIGH);
- gpio_direction_output(pdata->bp_power,GPIO_HIGH);
- mdelay(120);
- gpio_set_value(pdata->bp_power, GPIO_LOW);
- gpio_direction_output(pdata->bp_power,GPIO_LOW);
-
-
- //±£Áô
-/* gpio_set_value(pdata->bp_reset, GPIO_LOW);
- gpio_direction_output(pdata->bp_reset,GPIO_LOW);
- mdelay(120);
- gpio_set_value(pdata->bp_reset, GPIO_HIGH);
- gpio_direction_output(pdata->bp_reset,GPIO_HIGH);
-*/
- mu509_data = kzalloc(sizeof(struct modem_dev), GFP_KERNEL);
- if(mu509_data == NULL){
- printk("failed to request mu509_data\n");
- goto err2;
- }
- platform_set_drvdata(pdev, mu509_data);
-
- gpio_direction_input(pdata->bp_wakeup_ap);
- irq = gpio_to_irq(pdata->bp_wakeup_ap);
- if(irq < 0){
- gpio_free(pdata->bp_wakeup_ap);
- printk("failed to request bp_wakeup_ap\n");
- }
-
- bp_wakeup_ap_irq = irq;
-
- result = request_irq(irq, detect_irq_handler, IRQ_BB_WAKEUP_AP_TRIGGER, "bp_wakeup_ap", NULL);
- if (result < 0) {
- printk("%s: request_irq(%d) failed\n", __func__, irq);
- gpio_free(pdata->bp_wakeup_ap);
- goto err0;
- }
-
- enable_irq_wake(bp_wakeup_ap_irq);
-
- result = misc_register(&mu509_misc);
- if(result){
- MODEMDBG("misc_register err\n");
- }
- return result;
-err0:
- gpio_free(pdata->bp_wakeup_ap);
-err1:
- gpio_free(pdata->ap_wakeup_bp);
-err2:
- kfree(mu509_data);
- return 0;
-}
-
-int mu509_suspend(struct platform_device *pdev)
-{
-
- struct rk29_mu509_data *pdata = pdev->dev.platform_data;
- MODEMDBG("%s::%d--\n",__func__,__LINE__);
- gpio_set_value(pdata->ap_wakeup_bp, GPIO_LOW);
- return 0;
-}
-
-int mu509_resume(struct platform_device *pdev)
-{
- struct rk29_mu509_data *pdata = pdev->dev.platform_data;
- MODEMDBG("%s::%d--bruins--\n",__func__,__LINE__);
- gpio_set_value(pdata->ap_wakeup_bp, GPIO_HIGH);
- return 0;
-}
-
-void mu509_shutdown(struct platform_device *pdev, pm_message_t state)
-{
- struct rk29_mu509_data *pdata = pdev->dev.platform_data;
- struct modem_dev *mu509_data = platform_get_drvdata(pdev);
-
- MODEMDBG("%s::%d--bruins--\n",__func__,__LINE__);
- gpio_set_value(pdata->bp_power, GPIO_HIGH);
- mdelay(2010);
-
- gpio_free(pdata->bp_power);
- gpio_free(pdata->bp_reset);
- gpio_free(pdata->ap_wakeup_bp);
- gpio_free(pdata->bp_wakeup_ap);
- kfree(mu509_data);
-}
-
-static struct platform_driver mu509_driver = {
- .probe = mu509_probe,
- .shutdown = mu509_shutdown,
- .suspend = mu509_suspend,
- .resume = mu509_resume,
- .driver = {
- .name = "MW100",
- .owner = THIS_MODULE,
- },
-};
-
-static int __init mu509_init(void)
-{
- MODEMDBG("%s::%d--bruins--\n",__func__,__LINE__);
- return platform_driver_register(&mu509_driver);
-}
-
-static void __exit mu509_exit(void)
-{
- MODEMDBG("%s::%d--bruins--\n",__func__,__LINE__);
- platform_driver_unregister(&mu509_driver);
-}
-
-module_init(mu509_init);
-
-module_exit(mu509_exit);
obj-$(CONFIG_MTK23D) += mtk23d.o
obj-$(CONFIG_FM580X) += fm580x.o
obj-$(CONFIG_MU509) += mu509.o
-obj-$(CONFIG_MW100) += MW100.o
+obj-$(CONFIG_MW100) += mw100.o
+obj-$(CONFIG_MT6229) += mt6229.o
obj-$(CONFIG_STE) += ste.o
obj-$(CONFIG_RK29_SUPPORT_MODEM) += rk29_modem/
obj-$(CONFIG_GPS_GNS7560) += gps/
--- /dev/null
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/i2c.h>
+#include <linux/irq.h>
+#include <linux/gpio.h>
+#include <linux/input.h>
+#include <linux/platform_device.h>
+#include <linux/fs.h>
+#include <linux/uaccess.h>
+#include <linux/miscdevice.h>
+#include <linux/circ_buf.h>
+#include <linux/interrupt.h>
+#include <linux/miscdevice.h>
+#include <mach/iomux.h>
+#include <mach/gpio.h>
+#include <asm/gpio.h>
+#include <linux/delay.h>
+#include <linux/poll.h>
+#include <linux/wait.h>
+#include <linux/wakelock.h>
+#include <linux/workqueue.h>
+#include <linux/mt6229.h>
+#include <linux/slab.h>
+#include <linux/earlysuspend.h>
+
+MODULE_LICENSE("GPL");
+
+#define DEBUG
+#ifdef DEBUG
+#define MODEMDBG(x...) printk(x)
+#else
+#define MODEMDBG(fmt,argss...)
+#endif
+#define SLEEP 1
+#define READY 0
+static struct wake_lock modem_wakelock;
+//#define IRQ_BB_WAKEUP_AP_TRIGGER IRQF_TRIGGER_FALLING
+#define IRQ_BB_WAKEUP_AP_TRIGGER IRQF_TRIGGER_RISING
+#define MT6229_RESET 0x01
+struct rk29_mt6229_data *gpdata = NULL;
+struct class *modem_class = NULL;
+static int do_wakeup_irq = 0;
+static int modem_status;
+int suspend_int =0;
+static void ap_wakeup_bp(struct platform_device *pdev, int wake)
+{
+ struct rk29_mt6229_data *pdata = pdev->dev.platform_data;
+
+ gpio_set_value(pdata->ap_wakeup_bp, wake);
+
+}
+extern void rk28_send_wakeup_key(void);
+
+static void do_wakeup(struct work_struct *work)
+{
+ if(suspend_int)
+ {
+ gpio_set_value(gpdata->ap_wakeup_bp, 0);
+ suspend_int = 0;
+ }
+
+}
+
+static DECLARE_DELAYED_WORK(wakeup_work, do_wakeup);
+static irqreturn_t detect_irq_handler(int irq, void *dev_id)
+{
+ if(do_wakeup_irq)
+ {
+ do_wakeup_irq = 0;
+ // MODEMDBG("%s[%d]: %s\n", __FILE__, __LINE__, __FUNCTION__);
+ wake_lock_timeout(&modem_wakelock, 10 * HZ);
+ schedule_delayed_work(&wakeup_work, 2*HZ);
+ }
+ return IRQ_HANDLED;
+}
+int modem_poweron_off(int on_off)
+{
+ struct rk29_mt6229_data *pdata = gpdata;
+ if(on_off)
+ {
+ MODEMDBG("------------modem_poweron\n");
+ //gpio_set_value(pdata->bp_reset, GPIO_HIGH);
+ //msleep(100);
+ //gpio_set_value(pdata->bp_reset, GPIO_LOW);
+ gpio_set_value(pdata->bp_power, GPIO_LOW);
+ gpio_set_value(pdata->bp_power, GPIO_HIGH);
+ msleep(10);
+ gpio_set_value(pdata->bp_power, GPIO_LOW);
+ gpio_set_value(pdata->ap_wakeup_bp, GPIO_LOW);
+ }
+ else
+ {
+ MODEMDBG("------------modem_poweroff\n");
+ gpio_set_value(pdata->bp_power, GPIO_HIGH);
+ gpio_set_value(pdata->ap_wakeup_bp, GPIO_HIGH);
+ }
+ return 0;
+}
+static int mt6229_open(struct inode *inode, struct file *file)
+{
+ //MODEMDBG("-------------%s\n",__FUNCTION__);
+ struct rk29_mt6229_data *pdata = gpdata;
+// struct platform_data *pdev = container_of(pdata, struct device, platform_data);
+ device_init_wakeup(pdata->dev, 1);
+ return 0;
+}
+
+static int mt6229_release(struct inode *inode, struct file *file)
+{
+ //MODEMDBG("-------------%s\n",__FUNCTION__);
+ return 0;
+}
+
+static long mt6229_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+{
+ struct rk29_mt6229_data *pdata = gpdata;
+ //MODEMDBG("-------------%s\n",__FUNCTION__);
+ switch(cmd)
+ {
+ case MT6229_RESET:
+ //gpio_set_value(pdata->bp_reset, GPIO_HIGH);
+ //msleep(100);
+ //gpio_set_value(pdata->bp_reset, GPIO_LOW);
+ //msleep(100);
+ gpio_set_value(pdata->bp_power, GPIO_LOW);
+ gpio_set_value(pdata->bp_power, GPIO_HIGH);
+ msleep(10);
+ gpio_set_value(pdata->bp_power, GPIO_LOW);
+ gpio_set_value(pdata->ap_wakeup_bp, GPIO_LOW);
+ break;
+ default:
+ break;
+ }
+ return 0;
+}
+
+static struct file_operations mt6229_fops = {
+ .owner = THIS_MODULE,
+ .open = mt6229_open,
+ .release = mt6229_release,
+ .unlocked_ioctl = mt6229_ioctl
+};
+
+static struct miscdevice mt6229_misc = {
+ .minor = MISC_DYNAMIC_MINOR,
+ .name = MODEM_NAME,
+ .fops = &mt6229_fops
+};
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 37))
+static ssize_t modem_status_read(struct class *cls, struct class_attribute *attr, char *_buf)
+#else
+static ssize_t modem_status_read(struct class *cls, char *_buf)
+#endif
+{
+
+ return sprintf(_buf, "%d\n", modem_status);
+
+}
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 37))
+static ssize_t modem_status_write(struct class *cls, struct class_attribute *attr, const char *_buf, size_t _count)
+#else
+static ssize_t modem_status_write(struct class *cls, const char *_buf, size_t _count)
+#endif
+{
+ int new_state = simple_strtoul(_buf, NULL, 16);
+ if(new_state == modem_status) return _count;
+ if (new_state == 1){
+ printk("%s, c(%d), open modem \n", __FUNCTION__, new_state);
+ modem_poweron_off(1);
+ }else if(new_state == 0){
+ printk("%s, c(%d), close modem \n", __FUNCTION__, new_state);
+ modem_poweron_off(0);
+ }else{
+ printk("%s, invalid parameter \n", __FUNCTION__);
+ }
+ modem_status = new_state;
+ return _count;
+}
+static CLASS_ATTR(modem_status, 0777, modem_status_read, modem_status_write);
+static void rk29_early_suspend(struct early_suspend *h)
+{
+ printk("*********************mt6229____suspend\n");
+
+}
+static void rk29_early_resume(struct early_suspend *h)
+{
+ if(suspend_int)
+ {
+ printk("***************mt6229____resume\n");
+ gpio_set_value(gpdata->ap_wakeup_bp, 0);
+ suspend_int = 0;
+ }
+}
+
+static struct early_suspend mt6229_early_suspend = {
+ .suspend = rk29_early_suspend,
+ .resume = rk29_early_resume,
+ .level = EARLY_SUSPEND_LEVEL_DISABLE_FB - 1,
+ };
+static int mt6229_probe(struct platform_device *pdev)
+{
+ struct rk29_mt6229_data *pdata = gpdata = pdev->dev.platform_data;
+ struct modem_dev *mt6229_data = NULL;
+ int result, irq = 0;
+ //MODEMDBG("-------------%s\n",__FUNCTION__);
+
+ pdata->dev = &pdev->dev;
+ if(pdata->io_init)
+ pdata->io_init();
+ gpio_set_value(pdata->modem_power_en, GPIO_HIGH);
+ msleep(1000);
+ modem_poweron_off(1);
+ modem_status = 1;
+
+ register_early_suspend(&mt6229_early_suspend);
+ mt6229_data = kzalloc(sizeof(struct modem_dev), GFP_KERNEL);
+ if(mt6229_data == NULL)
+ {
+ printk("failed to request mt6229_data\n");
+ goto err2;
+ }
+ platform_set_drvdata(pdev, mt6229_data);
+ result = gpio_request(pdata->ap_wakeup_bp, "mt6229");
+ if (result) {
+ printk("failed to request AP_BP_WAKEUP gpio\n");
+ goto err1;
+ }
+ irq = gpio_to_irq(pdata->bp_wakeup_ap);
+ enable_irq_wake(irq);
+ if(irq < 0)
+ {
+ gpio_free(pdata->bp_wakeup_ap);
+ printk("failed to request bp_wakeup_ap\n");
+ }
+ result = gpio_request(pdata->bp_wakeup_ap, "bp_wakeup_ap");
+ if (result < 0) {
+ printk("%s: gpio_request(%d) failed\n", __func__, pdata->bp_wakeup_ap);
+ }
+ wake_lock_init(&modem_wakelock, WAKE_LOCK_SUSPEND, "bp_wakeup_ap");
+ gpio_direction_input(pdata->bp_wakeup_ap);
+ gpio_pull_updown(pdata->bp_wakeup_ap, 1);
+ result = request_irq(irq, detect_irq_handler, IRQ_BB_WAKEUP_AP_TRIGGER, "bp_wakeup_ap", NULL);
+ if (result < 0) {
+ printk("%s: request_irq(%d) failed\n", __func__, irq);
+ gpio_free(pdata->bp_wakeup_ap);
+ goto err0;
+ }
+ enable_irq_wake(gpio_to_irq(pdata->bp_wakeup_ap));
+
+ result = misc_register(&mt6229_misc);
+ if(result)
+ {
+ printk("misc_register err\n");
+ }
+ return result;
+err0:
+ cancel_work_sync(&mt6229_data->work);
+ gpio_free(pdata->bp_wakeup_ap);
+err1:
+ gpio_free(pdata->ap_wakeup_bp);
+err2:
+ kfree(mt6229_data);
+ return 0;
+}
+
+int mt6229_suspend(struct platform_device *pdev, pm_message_t state)
+{
+ suspend_int = 1;
+ do_wakeup_irq = 1;
+ //MODEMDBG("-------------%s\n",__FUNCTION__);
+ ap_wakeup_bp(pdev, 1);
+#if defined(CONFIG_ARCH_RK29)
+ rk29_mux_api_set(GPIO1C1_UART0RTSN_SDMMC1WRITEPRT_NAME, GPIO1H_GPIO1C1);
+ //gpio_direction_output(RK29_PIN1_PC1, 1);
+#endif
+#if defined(CONFIG_ARCH_RK30)
+ rk30_mux_api_set(GPIO1A7_UART1RTSN_SPI0TXD_NAME, GPIO1A_GPIO1A7);
+#endif
+ return 0;
+}
+
+int mt6229_resume(struct platform_device *pdev)
+{
+ //MODEMDBG("-------------%s\n",__FUNCTION__);
+ //ap_wakeup_bp(pdev, 0);
+#if defined(CONFIG_ARCH_RK29)
+ rk29_mux_api_set(GPIO1C1_UART0RTSN_SDMMC1WRITEPRT_NAME, GPIO1H_UART0_RTS_N);
+#endif
+#if defined(CONFIG_ARCH_RK30)
+ rk30_mux_api_set(GPIO1A7_UART1RTSN_SPI0TXD_NAME, GPIO1A_UART1_RTS_N);
+#endif
+ if(gpio_get_value(gpdata->bp_wakeup_ap))
+ {
+ schedule_delayed_work(&wakeup_work, 2*HZ);
+ }
+ return 0;
+}
+
+void mt6229_shutdown(struct platform_device *pdev)
+{
+ struct rk29_mt6229_data *pdata = pdev->dev.platform_data;
+ struct modem_dev *mt6229_data = platform_get_drvdata(pdev);
+
+ //MODEMDBG("-------------%s\n",__FUNCTION__);
+ modem_poweron_off(0);
+
+ if(pdata->io_deinit)
+ pdata->io_deinit();
+ cancel_work_sync(&mt6229_data->work);
+ gpio_free(pdata->modem_power_en);
+ gpio_free(pdata->bp_power);
+ gpio_free(pdata->bp_reset);
+ gpio_free(pdata->ap_wakeup_bp);
+ gpio_free(pdata->bp_wakeup_ap);
+ kfree(mt6229_data);
+}
+
+static struct platform_driver mt6229_driver = {
+ .probe = mt6229_probe,
+ .shutdown = mt6229_shutdown,
+ .suspend = mt6229_suspend,
+ .resume = mt6229_resume,
+ .driver = {
+ .name = "mt6229",
+ .owner = THIS_MODULE,
+ },
+};
+
+static int __init mt6229_init(void)
+{
+ //MODEMDBG("-------------%s\n",__FUNCTION__);
+ int ret ;
+
+
+ modem_class = class_create(THIS_MODULE, "rk291x_modem");
+ ret = class_create_file(modem_class, &class_attr_modem_status);
+ if (ret)
+ {
+ printk("Fail to class rk291x_modem.\n");
+ }
+ return platform_driver_register(&mt6229_driver);
+}
+
+static void __exit mt6229_exit(void)
+{
+ //MODEMDBG("-------------%s\n",__FUNCTION__);
+ platform_driver_unregister(&mt6229_driver);
+ class_remove_file(modem_class, &class_attr_modem_status);
+}
+
+module_init(mt6229_init);
+
+module_exit(mt6229_exit);
static struct wake_lock modem_wakelock;
#define IRQ_BB_WAKEUP_AP_TRIGGER IRQF_TRIGGER_FALLING
//#define IRQ_BB_WAKEUP_AP_TRIGGER IRQF_TRIGGER_RISING
+#if defined(CONFIG_ARCH_RK29)
#define airplane_mode RK29_PIN6_PC1
+#endif
+#if defined(CONFIG_ARCH_RK30)
+#define airplane_mode RK30_PIN2_PC0
+#endif
#define MU509_RESET 0x01
#define AIRPLANE_MODE_OFF 0x03
#define AIRPLANE_MODE_ON 0x00
//MODEMDBG("-------------%s\n",__FUNCTION__);
if(!online)
ap_wakeup_bp(pdev, 1);
+#if defined(CONFIG_ARCH_RK29)
rk29_mux_api_set(GPIO1C1_UART0RTSN_SDMMC1WRITEPRT_NAME, GPIO1H_GPIO1C1);
//gpio_direction_output(RK29_PIN1_PC1, 1);
+#endif
+#if defined(CONFIG_ARCH_RK30)
+ rk30_mux_api_set(GPIO1A7_UART1RTSN_SPI0TXD_NAME, GPIO1A_GPIO1A7);
+#endif
return 0;
}
{
//MODEMDBG("-------------%s\n",__FUNCTION__);
//ap_wakeup_bp(pdev, 0);
+#if defined(CONFIG_ARCH_RK29)
rk29_mux_api_set(GPIO1C1_UART0RTSN_SDMMC1WRITEPRT_NAME, GPIO1H_UART0_RTS_N);
+#endif
+#if defined(CONFIG_ARCH_RK30)
+ rk30_mux_api_set(GPIO1A7_UART1RTSN_SPI0TXD_NAME, GPIO1A_UART1_RTS_N);
+#endif
if(gpio_get_value(gpdata->bp_wakeup_ap))
{
schedule_delayed_work(&wakeup_work, 2*HZ);
--- /dev/null
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/i2c.h>
+#include <linux/irq.h>
+#include <linux/gpio.h>
+#include <linux/input.h>
+#include <linux/platform_device.h>
+#include <linux/fs.h>
+#include <linux/uaccess.h>
+#include <linux/miscdevice.h>
+#include <linux/circ_buf.h>
+#include <linux/interrupt.h>
+#include <linux/miscdevice.h>
+#include <mach/iomux.h>
+#include <mach/gpio.h>
+#include <linux/delay.h>
+#include <linux/poll.h>
+#include <linux/wait.h>
+#include <linux/wakelock.h>
+#include <linux/workqueue.h>
+#include <linux/mw100.h>
+#include <mach/iomux.h>
+#include<linux/ioctl.h>
+
+#include <linux/slab.h>
+
+MODULE_LICENSE("GPL");
+
+//#define DEBUG
+#ifdef DEBUG
+#define MODEMDBG(x...) printk(x)
+#else
+#define MODEMDBG(fmt,argss...)
+#endif
+
+#define MW100IO 0XA1
+#define MW_IOCTL_RESET _IO(MW100IO,0X01)
+
+#define SLEEP 1
+#define READY 0
+#define MW100_RESET 0x01
+#define IRQ_BB_WAKEUP_AP_TRIGGER IRQF_TRIGGER_RISING
+//#define IRQ_BB_WAKEUP_AP_TRIGGER IRQF_TRIGGER_RISING
+struct rk29_mw100_data *gpdata = NULL;
+static int bp_wakeup_ap_irq = 0;
+
+static struct wake_lock bp_wakelock;
+static bool bpstatus_irq_enable = false;
+
+#if 0
+static void ap_wakeup_bp(struct platform_device *pdev, int wake)
+{
+ struct rk29_mw100_data *pdata = pdev->dev.platform_data;
+ MODEMDBG("ap_wakeup_bp\n");
+
+ gpio_set_value(pdata->ap_wakeup_bp, wake);
+}
+#endif
+
+static void do_wakeup(struct work_struct *work)
+{
+ MODEMDBG("%s[%d]: %s\n", __FILE__, __LINE__, __FUNCTION__);
+ enable_irq(bp_wakeup_ap_irq);
+}
+
+static DECLARE_DELAYED_WORK(wakeup_work, do_wakeup);
+static irqreturn_t detect_irq_handler(int irq, void *dev_id)
+{
+ printk("%s[%d]: %s\n", __FILE__, __LINE__, __FUNCTION__);
+ wake_lock_timeout(&bp_wakelock, 10 * HZ);
+
+ return IRQ_HANDLED;
+}
+int modem_poweron_off(int on_off)
+{
+ if(on_off)
+ {
+ MODEMDBG("%s::%d--bruins--\n",__func__,__LINE__);
+ }
+ else
+ {
+ MODEMDBG("%s::%d--bruins--\n",__func__,__LINE__);
+ }
+ return 0;
+}
+
+static int mw100_open(struct inode *inode, struct file *file)
+{
+ MODEMDBG("%s::%d--bruins--\n",__func__,__LINE__);
+ //modem_poweron_off(1);
+ return 0;
+}
+
+static int mw100_release(struct inode *inode, struct file *file)
+{
+ MODEMDBG("%s::%d--bruins--\n",__func__,__LINE__);
+ //modem_poweron_off(0);
+ return 0;
+}
+
+static long mw100_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+{
+ struct rk29_mw100_data *pdata = gpdata;
+ switch(cmd)
+ {
+ case MW_IOCTL_RESET:
+ printk("%s::%d--bruins--ioctl mw100 reset\n",__func__,__LINE__);
+ gpio_direction_output(pdata->bp_reset,GPIO_LOW);
+ mdelay(120);
+ gpio_set_value(pdata->bp_reset, GPIO_HIGH);
+
+ break;
+ default:
+ break;
+ }
+ return 0;
+}
+
+static struct file_operations mw100_fops = {
+ .owner = THIS_MODULE,
+ .open = mw100_open,
+ .release = mw100_release,
+ .unlocked_ioctl = mw100_ioctl
+};
+
+static struct miscdevice mw100_misc = {
+ .minor = MISC_DYNAMIC_MINOR,
+ .name = "mw100",
+ .fops = &mw100_fops
+};
+
+static int mw100_probe(struct platform_device *pdev)
+{
+ struct rk29_mw100_data *pdata = gpdata = pdev->dev.platform_data;
+ struct modem_dev *mw100_data = NULL;
+ int result, irq = 0;
+
+ gpio_request(pdata->bp_power,"bp_power");
+ gpio_request(pdata->bp_reset,"bp_reset");
+ gpio_request(pdata->bp_wakeup_ap,"bp_wakeup_ap");
+ gpio_request(pdata->ap_wakeup_bp,"ap_wakeup_bp");
+ gpio_set_value(pdata->modem_power_en, GPIO_HIGH);
+ msleep(1000);
+#if defined(CONFIG_ARCH_RK29)
+ rk29_mux_api_set(GPIO6C76_CPUTRACEDATA76_NAME, GPIO4H_GPIO6C76);
+#endif
+ gpio_direction_output(pdata->bp_reset,GPIO_LOW);
+ mdelay(120);
+ gpio_set_value(pdata->bp_reset, GPIO_HIGH);
+
+ gpio_set_value(pdata->ap_wakeup_bp, GPIO_HIGH);
+ gpio_direction_output(pdata->ap_wakeup_bp,GPIO_HIGH);
+
+ gpio_set_value(pdata->bp_power, GPIO_HIGH);
+ gpio_direction_output(pdata->bp_power,GPIO_HIGH);
+ mdelay(120);
+ gpio_set_value(pdata->bp_power, GPIO_LOW);
+ gpio_direction_output(pdata->bp_power,GPIO_LOW);
+
+
+ //±£Áô
+/* gpio_set_value(pdata->bp_reset, GPIO_LOW);
+ gpio_direction_output(pdata->bp_reset,GPIO_LOW);
+ mdelay(120);
+ gpio_set_value(pdata->bp_reset, GPIO_HIGH);
+ gpio_direction_output(pdata->bp_reset,GPIO_HIGH);
+*/
+ mw100_data = kzalloc(sizeof(struct modem_dev), GFP_KERNEL);
+ if(mw100_data == NULL){
+ printk("failed to request mw100_data\n");
+ goto err2;
+ }
+ platform_set_drvdata(pdev, mw100_data);
+
+ gpio_direction_input(pdata->bp_wakeup_ap);
+ irq = gpio_to_irq(pdata->bp_wakeup_ap);
+ if(irq < 0){
+ gpio_free(pdata->bp_wakeup_ap);
+ printk("failed to request bp_wakeup_ap\n");
+ }
+
+ bp_wakeup_ap_irq = irq;
+
+ result = request_irq(irq, detect_irq_handler, IRQ_BB_WAKEUP_AP_TRIGGER, "bp_wakeup_ap", NULL);
+ if (result < 0) {
+ printk("%s: request_irq(%d) failed\n", __func__, irq);
+ gpio_free(pdata->bp_wakeup_ap);
+ goto err0;
+ }
+
+ enable_irq_wake(bp_wakeup_ap_irq);
+
+ wake_lock_init(&bp_wakelock, WAKE_LOCK_SUSPEND, "bp_resume");
+
+ result = misc_register(&mw100_misc);
+ if(result){
+ MODEMDBG("misc_register err\n");
+ }
+ return result;
+err0:
+ gpio_free(pdata->bp_wakeup_ap);
+err2:
+ kfree(mw100_data);
+ return 0;
+}
+
+int mw100_suspend(struct platform_device *pdev, pm_message_t state)
+{
+
+ struct rk29_mw100_data *pdata = pdev->dev.platform_data;
+ int irq;
+ MODEMDBG("%s::%d--\n",__func__,__LINE__);
+ gpio_set_value(pdata->ap_wakeup_bp, GPIO_LOW);
+ irq = gpio_to_irq(pdata->bp_wakeup_ap);
+ if (irq < 0) {
+ printk("can't get pdata->bp_statue irq \n");
+ }
+ else
+ {
+ printk("enable pdata->bp_statue irq_wake!! \n");
+ bpstatus_irq_enable = true;
+ enable_irq_wake(irq);
+ }
+ return 0;
+}
+
+int mw100_resume(struct platform_device *pdev)
+{
+ struct rk29_mw100_data *pdata = pdev->dev.platform_data;
+ int irq;
+ MODEMDBG("%s::%d--bruins--\n",__func__,__LINE__);
+ gpio_set_value(pdata->ap_wakeup_bp, GPIO_HIGH);
+ irq = gpio_to_irq(pdata->bp_wakeup_ap);
+ if (irq ) {
+ printk("enable pdata->bp_statue irq_wake!! \n");
+ disable_irq_wake(irq);
+ bpstatus_irq_enable = false;
+ }
+ return 0;
+}
+
+void mw100_shutdown(struct platform_device *pdev)
+{
+ struct rk29_mw100_data *pdata = pdev->dev.platform_data;
+ struct modem_dev *mw100_data = platform_get_drvdata(pdev);
+
+ MODEMDBG("%s::%d--bruins--\n",__func__,__LINE__);
+ gpio_set_value(pdata->bp_power, GPIO_HIGH);
+ mdelay(2010);
+ gpio_free(pdata->modem_power_en);
+ gpio_free(pdata->bp_power);
+ gpio_free(pdata->bp_reset);
+ gpio_free(pdata->ap_wakeup_bp);
+ gpio_free(pdata->bp_wakeup_ap);
+ kfree(mw100_data);
+}
+
+static struct platform_driver mw100_driver = {
+ .probe = mw100_probe,
+ .shutdown = mw100_shutdown,
+ .suspend = mw100_suspend,
+ .resume = mw100_resume,
+ .driver = {
+ .name = "mw100",
+ .owner = THIS_MODULE,
+ },
+};
+
+static int __init mw100_init(void)
+{
+ MODEMDBG("%s::%d--bruins--\n",__func__,__LINE__);
+ return platform_driver_register(&mw100_driver);
+}
+
+static void __exit mw100_exit(void)
+{
+ MODEMDBG("%s::%d--bruins--\n",__func__,__LINE__);
+ platform_driver_unregister(&mw100_driver);
+}
+
+module_init(mw100_init);
+
+module_exit(mw100_exit);
tristate "Support for WM8326 battery voltage detection."
default n
+config TWL60xx_VBAT_LOW_DETECTION
+ tristate "Support for twl60xx low battery detection."
+ default n
+
endif # POWER_SUPPLY
//low power and charging
+#if 0
if((val_capacity.intval < pwr_on_thrsd )&&(val_status.intval == POWER_SUPPLY_STATUS_CHARGING))
{
while((val_capacity.intval < pwr_on_thrsd ))
}
}
-
+#endif
if(val_status.intval == POWER_SUPPLY_STATUS_CHARGING)
{
return 0;
}
-subsys_initcall_sync(start_charge_logo_display);
-
+//subsys_initcall_sync(start_charge_logo_display);
+module_init(start_charge_logo_display);
#define BAT_PULL_DOWN_R 100
static struct batt_vol_cal batt_table[] = {
- {0,6800,7400}, {1,6840,7440}, {2,6880,7480}, {3,6950,7450}, {5,7010,7510}, {7,7050,7550},
+ {0,6800,7400}, {1,6840,7440}, {2,6880,7480}, {3,6950,7450}, {5,7010,7510}, {7,7050,7550},
{9,7080,7580}, {11,7104,7604}, {13,7140,7640}, {15,7160,7660}, {17,7220,7720},
{19,7260,7760}, {21,7280,7780}, {23,7304,7802}, {25,7324,7824}, {27,7344,7844},
{29,7360,7860}, {31,7374,7874}, {33,7386,7886}, {35,7398,7898}, {37,7410,7910},//500
for(i = 0; i < BATT_NUM - 1; i++){
if(((p[i].charge_vol) <= BatVoltage) && (BatVoltage < (p[i+1].charge_vol))){
- capacity = p[i].disp_cal ;
+ capacity = p[i].disp_cal + ((BatVoltage - p[i].charge_vol) * (p[i+1].disp_cal -p[i].disp_cal ))/ (p[i+1].charge_vol- p[i].charge_vol);
break;
}
}
else{
for(i = 0; i < BATT_NUM - 1; i++){
if(((p[i].dis_charge_vol) <= BatVoltage) && (BatVoltage < (p[i+1].dis_charge_vol))){
- capacity = p[i].disp_cal ;
+ capacity = p[i].disp_cal+ ((BatVoltage - p[i].dis_charge_vol) * (p[i+1].disp_cal -p[i].disp_cal ) )/ (p[i+1].dis_charge_vol- p[i].dis_charge_vol) ;
break;
}
}
union power_supply_propval *val)
{
struct twl6030_bci_device_info *di = to_twl6030_bk_bci_device_info(psy);
-
+ val->intval = 0;
switch (psp) {
case POWER_SUPPLY_PROP_VOLTAGE_NOW:
val->intval = di->bk_voltage_mV * 1000;
// kill_urbs_in_qh_list(_hcd, &_hcd->periodic_sched_assigned);
// kill_urbs_in_qh_list(_hcd, &_hcd->periodic_sched_queued);
}
+extern void release_channel(dwc_otg_hcd_t *_hcd,
+ dwc_hc_t *_hc,
+ dwc_otg_qtd_t *_qtd,
+ dwc_otg_halt_status_e _halt_status);
/**
* HCD Callback function for disconnect of the HCD.
dwc_modify_reg32 (&dwc_otg_hcd->core_if->core_global_regs->gintmsk, intr.d32, 0);
dwc_modify_reg32 (&dwc_otg_hcd->core_if->core_global_regs->gintsts, intr.d32, 0);
- del_timers(dwc_otg_hcd);
+// del_timers(dwc_otg_hcd);
/*
* Turn off the vbus power only if the core has transitioned to device
hcchar.b.chdis = 1;
dwc_write_reg32(&hc_regs->hcchar, hcchar.d32);
}
-
+#if 1
+ release_channel(dwc_otg_hcd, channel, NULL, DWC_OTG_HC_XFER_URB_DEQUEUE);
+#else
dwc_otg_hc_cleanup(dwc_otg_hcd->core_if, channel);
list_add_tail(&channel->hc_list_entry,
&dwc_otg_hcd->free_hc_list);
+#endif
}
}
}
*/
static void dwc_otg_hcd_start_connect_timer( dwc_otg_hcd_t *_hcd)
{
- init_timer( &_hcd->conn_timer );
- _hcd->conn_timer.function = dwc_otg_hcd_connect_timeout;
- _hcd->conn_timer.data = (unsigned long)0;
- _hcd->conn_timer.expires = jiffies + (HZ*10);
- add_timer( &_hcd->conn_timer );
+ init_timer( &_hcd->conn_timer );
+ _hcd->conn_timer.function = dwc_otg_hcd_connect_timeout;
+ _hcd->conn_timer.data = (unsigned long)0;
+ _hcd->conn_timer.expires = jiffies + (HZ*10);
+ add_timer( &_hcd->conn_timer );
}
/**
{
dwc_otg_hcd_t *dwc_otg_hcd = hcd_to_dwc_otg_hcd (_p);
DWC_DEBUGPL(DBG_HCDV, "%s(%p)\n", __func__, _p);
- dwc_otg_hcd_start_connect_timer( dwc_otg_hcd );
+// dwc_otg_hcd_start_connect_timer( dwc_otg_hcd );
return 1;
}
DWC_DEBUGPL(DBG_PCDV, "disable usb phy\n");
}
#endif
+#ifdef CONFIG_ARCH_RK30
+ unsigned int * otg_phy_con1 = (unsigned int*)(USBGRF_UOC0_CON2);
+ if(suspend) {
+ *otg_phy_con1 = ((0x01<<2)<<16); // exit suspend.
+ DWC_DEBUGPL(DBG_PCDV, "enable usb phy\n");
+ }
+ else{
+ *otg_phy_con1 = 0x554|(0xfff<<16); // enter suspend.
+ udelay(3);
+ DWC_DEBUGPL(DBG_PCDV, "disable usb phy\n");
+ }
+#endif
return suspend;
}
dwc_otg_hcd->host_enabled = dwc_otg_hcd->host_setenable;
if(dwc_otg_hcd->host_setenable == 0) // enable -> disable
{
- DWC_PRINT("disable host controller\n");
+ DWC_PRINT("%s, disable host controller\n", __func__);
#if 1
if (_core_if->hcd_cb && _core_if->hcd_cb->disconnect) {
_core_if->hcd_cb->disconnect( _core_if->hcd_cb->p );
}
else if(dwc_otg_hcd->host_setenable == 1)
{
- DWC_PRINT("enable host controller\n");
+ DWC_PRINT("%s, enable host controller\n", __func__);
// clk_enable(otg_dev->phyclk);
// clk_enable(otg_dev->ahbclk);
if (_core_if->hcd_cb && _core_if->hcd_cb->suspend) {
local_irq_save(flags);
-// DWC_PRINT("%s %p, grfstatus 0x%x\n", __func__, dwc_otg_hcd, usbgrf_status& (7<<22));
+// DWC_PRINT("%s hprt %x, grfstatus 0x%x\n", __func__, dwc_read_reg32(core_if->host_if->hprt0), usbgrf_status& (7<<22));
if(usbgrf_status & (7<<22)){
// usb device connected
dwc_otg_hcd->host_setenable = 1;
dwc_otg_hcd->host_setenable = 0;
}
- schedule_delayed_work(&dwc_otg_hcd->host_enable_work, jiffies);
+ if(dwc_otg_hcd->host_setenable != dwc_otg_hcd->host_enabled){
+ DWC_PRINT("%s schedule delaywork \n", __func__, dwc_read_reg32(core_if->host_if->hprt0), usbgrf_status& (7<<22));
+ schedule_delayed_work(&dwc_otg_hcd->host_enable_work, 8);
+ }
// dwc_otg_hcd->connect_detect_timer.expires = jiffies + (HZ<<1); /* 1 s */
mod_timer(&dwc_otg_hcd->connect_detect_timer,jiffies + (HZ<<1));
local_irq_restore(flags);
}
/* Initialize the Connection timeout timer. */
- init_timer( &dwc_otg_hcd->conn_timer );
+// init_timer( &dwc_otg_hcd->conn_timer );
/* Initialize reset tasklet. */
reset_tasklet.data = (unsigned long) dwc_otg_hcd;
}
/* Initialize the Connection timeout timer. */
- init_timer( &dwc_otg_hcd->conn_timer );
+// init_timer( &dwc_otg_hcd->conn_timer );
/* Initialize reset tasklet. */
host11_reset_tasklet.data = (unsigned long) dwc_otg_hcd;
}
*otg_phy_con1 = regval;
#endif
+
+#ifdef CONFIG_ARCH_RK30
+ unsigned int * otg_phy_con1 = (unsigned int*)(USBGRF_UOC1_CON2);
+ if(suspend) {
+ *otg_phy_con1 = ((0x01<<2)<<16); // exit suspend.
+ DWC_DEBUGPL(DBG_PCDV, "enable usb phy\n");
+ }
+ else{
+ *otg_phy_con1 = 0x554|(0xfff<<16); // enter suspend.
+ udelay(3);
+ DWC_DEBUGPL(DBG_PCDV, "disable usb phy\n");
+ }
+#endif
return suspend;
}
DWC_DEBUGPL(DBG_HCD, "DWC OTG HCD FREE\n");
- del_timers(dwc_otg_hcd);
+// del_timers(dwc_otg_hcd);
/* Free memory for QH/QTD lists */
qh_list_free(dwc_otg_hcd, &dwc_otg_hcd->non_periodic_sched_inactive);
if (urb_qtd == qh->qtd_in_process) {
/* The QTD is in process (it has been assigned to a channel). */
if (dwc_otg_hcd->flags.b.port_connect_status) {
-
/*
* If still connected (i.e. in host mode), halt the
* channel so it can be used for other transfers. If
/* Process entries in the periodic ready list. */
qh_ptr = _hcd->periodic_sched_inactive.next;
- while (qh_ptr != &_hcd->periodic_sched_inactive) {
+ while ((qh_ptr != &_hcd->periodic_sched_inactive)&&
+ !list_empty(&_hcd->free_hc_list)) {
qh = list_entry(qh_ptr, dwc_otg_qh_t, qh_list_entry);
if(qh->qh_state != QH_READY){
qh_ptr = qh_ptr->next;
hprt0_modify.b.prtconndet = 1;
/* B-Device has connected, Delete the connection timer. */
- del_timer( &_dwc_otg_hcd->conn_timer );
+// del_timer( &_dwc_otg_hcd->conn_timer );
/* The Hub driver asserts a reset when it sees port connect
* status change flag */
* @param _halt_status Reason the channel is being released. This status
* determines the actions taken by this function.
*/
-static void release_channel(dwc_otg_hcd_t *_hcd,
+/*static */
+void release_channel(dwc_otg_hcd_t *_hcd,
dwc_hc_t *_hc,
dwc_otg_qtd_t *_qtd,
dwc_otg_halt_status_e _halt_status)
* deactivated. Don't want to do anything except release the
* host channel and try to queue more transfers.
*/
+ continue_trans = 0;
goto cleanup;
case DWC_OTG_HC_XFER_NO_HALT_STATUS:
DWC_ERROR("%s: No halt_status, channel %d\n", __func__, _hc->hc_num);
static int MU509_USB = 0;
#define MU509_USB_PORT (SERIAL_TTY_MINORS - 10)
#endif
+#ifdef CONFIG_MW100
+static int MW100_USB = 0;
+#define MW100_USB_PORT (SERIAL_TTY_MINORS - 10)
+#endif
+#ifdef CONFIG_MT6229
+static int MT6229_USB = 0;
+#define MT6229_USB_PORT (SERIAL_TTY_MINORS - 10)
+#endif
/* There is no MODULE_DEVICE_TABLE for usbserial.c. Instead
the MODULE_DEVICE_TABLE declarations in each serial driver
#ifdef CONFIG_MU509
if (MU509_USB)
a= MU509_USB_PORT;
+#endif
+#ifdef CONFIG_MW100
+ if (MW100_USB)
+ a= MW100_USB_PORT;
+#endif
+#ifdef CONFIG_MT6229
+ if (MT6229_USB)
+ a= MT6229_USB_PORT;
#endif
for (i = a; i < SERIAL_TTY_MINORS; ++i) {
if (serial_table[i])
else
MU509_USB = 0;
#endif
+#ifdef CONFIG_MW100
+ if ((le16_to_cpu(dev->descriptor.idVendor) == 0x19f5) && (le16_to_cpu(dev->descriptor.idProduct) == 0x9013))
+ MW100_USB =1;
+ else
+ MW100_USB = 0;
+#endif
+#ifdef CONFIG_MT6229
+ if ((le16_to_cpu(dev->descriptor.idVendor) == 0x0E8D) && (le16_to_cpu(dev->descriptor.idProduct) == 0x00A2))
+ MT6229_USB =1;
+ else
+ MT6229_USB = 0;
+#endif
if (get_free_serial(serial, num_ports, &minor) == NULL) {
dev_err(&interface->dev, "No more free serial devices\n");
static void rga_dump(void)\r
{\r
int running;\r
- int num_done;\r
struct rga_reg *reg, *reg_tmp;\r
rga_session *session, *session_tmp;\r
- struct list_head *next;\r
\r
running = atomic_read(&rga_service.total_running);\r
printk("rga total_running %d\n", running);\r
\r
+ #if 0\r
+\r
/* Dump waiting list info */\r
if (!list_empty(&rga_service.waiting))\r
{\r
}\r
while(!list_empty(next));\r
}\r
+ #endif\r
\r
list_for_each_entry_safe(session, session_tmp, &rga_service.session, list_session)\r
{\r
\r
#if 0\r
\r
-#include "320x240_swap0_Y4200.h"\r
-#include "320x240_swap0_U4200.h"\r
-#include "320x240_swap0_V4200.h"\r
-#include "320x240_swap0_UV4200.h"\r
-#include "320x240_swap0_ABGR8888.h"\r
-\r
-\r
extern struct fb_info * rk_get_fb(int fb_id);\r
EXPORT_SYMBOL(rk_get_fb);\r
\r
--- /dev/null
+#include <linux/types.h>
+#include <linux/ioctl.h>
+#include <linux/miscdevice.h>
+
+struct modem_dev
+{
+ const char *name;
+ struct miscdevice miscdev;
+ struct work_struct work;
+};
+
+struct rk29_mt6229_data {
+ struct device *dev;
+ int (*io_init)(void);
+ int (*io_deinit)(void);
+ unsigned int bp_power;
+ unsigned int bp_power_active_low;
+ unsigned int bp_reset;
+ unsigned int bp_reset_active_low;
+ unsigned int bp_wakeup_ap;
+ unsigned int ap_wakeup_bp;
+ unsigned int modem_power_en;
+};
+
+#define MODEM_NAME "mt6229"
--- /dev/null
+#include <linux/types.h>
+#include <linux/ioctl.h>
+#include <linux/miscdevice.h>
+
+struct modem_dev
+{
+ const char *name;
+ struct miscdevice miscdev;
+ struct work_struct work;
+};
+
+struct rk29_mw100_data {
+ struct device *dev;
+ int (*io_init)(void);
+ int (*io_deinit)(void);
+ unsigned int bp_power;
+ unsigned int bp_power_active_low;
+ unsigned int bp_reset;
+ unsigned int bp_reset_active_low;
+ unsigned int bp_wakeup_ap;
+ unsigned int ap_wakeup_bp;
+ unsigned int modem_power_en;
+};
+
+#define MODEM_NAME "mw100"
projects / firefly-linux-kernel-4.4.55.git / commitdiff