diff --git a/Makefile b/Makefile index 39516bf..f659dac 100644 --- a/Makefile +++ b/Makefile @@ -3,7 +3,8 @@ PATCHLEVEL = 6 SUBLEVEL = 25 EXTRAVERSION = NAME = Funky Weasel is Jiggy wit it - +ARCH=arm +CROSS_COMPILE=arm-none-linux-gnueabi- # *DOCUMENTATION* # To see a list of typical targets execute "make help" # More info can be located in ./README @@ -559,7 +560,7 @@ endif # Use --build-id when available. LDFLAGS_BUILD_ID = $(patsubst -Wl$(comma)%,%,\ - $(call ld-option, -Wl$(comma)--build-id,)) + $(call ld-option, -Wl$(comma)--build-id=none,)) LDFLAGS_MODULE += $(LDFLAGS_BUILD_ID) LDFLAGS_vmlinux += $(LDFLAGS_BUILD_ID) diff --git a/arch/arm/mach-msm/Kconfig b/arch/arm/mach-msm/Kconfig index 326d9e6..770ba86 100644 --- a/arch/arm/mach-msm/Kconfig +++ b/arch/arm/mach-msm/Kconfig @@ -28,6 +28,36 @@ config MACH_HALIBUT help Support for the Qualcomm SURF7200A eval board. +config MACH_HTCVOGUE + depends on ARCH_MSM7X00A + default y + bool "HTC Vogue Phone" + help + Support for HTC Vogue phone. + +config HTCKAISER + depends on MACH_HTCVOGUE + default n + bool "HTC Kaiser Phone" + help + Basic Support for HTC Kaiser phone. + +config VOGUE_TS + depends on MACH_HTCVOGUE + default y + bool "Vogue Touchscreen" + help + Enable Vogue Touchscreen. + +config MSM_VOGUESMD + tristate "MSM Vogue SMD Drivers" + depends on MACH_HTCVOGUE + default y + help + Support for shared memory interface to the ARM9 "Modem" processor + on Vogue. Needed for access to many services, including power + and clock control, cellular voice and data network access, etc. + choice prompt "MSM Low-Level Debug UART" depends on ARCH_MSM7X00A @@ -210,7 +240,7 @@ config MSM_SMD and clock control, cellular voice and data network access, etc. config MSM_ONCRPCROUTER - depends on MSM_SMD + depends on ARCH_MSM7X00A default y bool "MSM ONCRPC router support" help diff --git a/arch/arm/mach-msm/Makefile b/arch/arm/mach-msm/Makefile index a6e4270..0158d84 100644 --- a/arch/arm/mach-msm/Makefile +++ b/arch/arm/mach-msm/Makefile @@ -1,13 +1,16 @@ -obj-y += io.o idle.o irq.o timer.o dma.o clock.o clock-7x00a.o memory.o -obj-y += vreg.o +obj-y += io.o idle.o timer.o dma.o clock-7x00a.o memory.o obj-y += gpio.o generic_gpio.o -obj-y += proc_comm.o +#obj-y += proc_comm.o # Common code for board init obj-y += common.o nand_partitions.o obj-$(CONFIG_MSM_FIQ_SUPPORT) += fiq_glue.o -obj-$(CONFIG_MACH_HALIBUT) += board-halibut.o board-halibut-keypad.o +obj-$(CONFIG_VOGUE_TS) += vogue-ts.o +obj-$(CONFIG_MACH_HTCVOGUE) += board-htcvogue.o vogueirq.o vogue-hw.o clock-7x00.o +obj-$(CONFIG_MSM_VOGUESMD) += vogue-smd.o smd_tty.o vogue_rpc.o +# vogue_rpc_device.o +obj-$(CONFIG_MACH_HALIBUT) += board-halibut.o board-halibut-keypad.o irq.o vreg.o obj-$(CONFIG_MSM_SMD) += smd.o smd_tty.o smd_qmi.o obj-$(CONFIG_MSM_ONCRPCROUTER) += smd_rpcrouter.o obj-$(CONFIG_MSM_ONCRPCROUTER) += smd_rpcrouter_device.o @@ -21,3 +24,4 @@ obj-$(CONFIG_MSM_ADSP) += adsp.o adsp_driver.o $(obj-adsp-y) obj-$(CONFIG_MSM_HW3D) += hw3d.o obj-$(CONFIG_MSM_PERF) += perf.o obj-$(CONFIG_PM) += pm.o +#was vogue-pm.o diff --git a/arch/arm/mach-msm/adsp.c b/arch/arm/mach-msm/adsp.c index d952cb6..7ec274b 100644 --- a/arch/arm/mach-msm/adsp.c +++ b/arch/arm/mach-msm/adsp.c @@ -86,7 +86,9 @@ static int rpc_adsp_rtos_app_to_modem(uint32_t cmd, uint32_t module, { int rc; struct rpc_adsp_rtos_app_to_modem_args_t rpc_req; - struct rpc_reply_hdr *rpc_rsp; + int buffer[1024]; + struct rpc_reply_hdr *rpc_rsp=(struct rpc_reply_hdr *)buffer; + // return 0;// added while rpc not working MJ msm_rpc_setup_req(&rpc_req.hdr, RPC_ADSP_RTOS_ATOM_PROG, @@ -97,14 +99,13 @@ static int rpc_adsp_rtos_app_to_modem(uint32_t cmd, uint32_t module, rpc_req.cmd = cpu_to_be32(cmd); rpc_req.proc_id = cpu_to_be32(RPC_ADSP_RTOS_PROC_APPS); rpc_req.module = cpu_to_be32(module); - rc = msm_rpc_write(adsp_module->rpc_client, &rpc_req, sizeof(rpc_req)); + rc = msm_rpc_write_command(&rpc_req, sizeof(rpc_req)); if (rc < 0) { pr_err("adsp: could not send RPC request: %d\n", rc); return rc; } - rc = msm_rpc_read(adsp_module->rpc_client, - (void **)&rpc_rsp, -1, (5*HZ)); + rc = msm_rpc_read_reply(rpc_rsp, -1); if (rc < 0) { pr_err("adsp: error receiving RPC reply: %d (%d)\n", rc, -ERESTARTSYS); @@ -113,7 +114,6 @@ static int rpc_adsp_rtos_app_to_modem(uint32_t cmd, uint32_t module, if (be32_to_cpu(rpc_rsp->reply_stat) != RPCMSG_REPLYSTAT_ACCEPTED) { pr_err("adsp: RPC call was denied!\n"); - kfree(rpc_rsp); return -EPERM; } @@ -121,11 +121,9 @@ static int rpc_adsp_rtos_app_to_modem(uint32_t cmd, uint32_t module, RPC_ACCEPTSTAT_SUCCESS) { pr_err("adsp error: RPC call was not successful (%d)\n", be32_to_cpu(rpc_rsp->data.acc_hdr.accept_stat)); - kfree(rpc_rsp); return -EINVAL; } - kfree(rpc_rsp); return 0; } @@ -151,6 +149,7 @@ static struct msm_adsp_module *find_adsp_module_by_name( static int adsp_rpc_init(struct msm_adsp_module *adsp_module) { + return 0; // added while rpc not working MJ adsp_module->rpc_client = msm_rpc_connect( RPC_ADSP_RTOS_ATOM_PROG, RPC_ADSP_RTOS_ATOM_VERS, @@ -177,7 +176,7 @@ int msm_adsp_get(const char *name, struct msm_adsp_module **out, return -ENODEV; mutex_lock(&module->lock); - pr_info("adsp: opening module %s\n", module->name); + pr_info("adsp: opening module %s id:%d\n", module->name,module->id); if (module->open_count++ == 0 && module->clk) clk_enable(module->clk); @@ -250,7 +249,7 @@ void msm_adsp_put(struct msm_adsp_module *module) msm_adsp_disable_locked(module); } - msm_rpc_close(module->rpc_client); + // msm_rpc_close(module->rpc_client); module->rpc_client = 0; if (--adsp_open_count == 0) { disable_irq(INT_ADSP); @@ -270,6 +269,8 @@ static int rpc_send_accepted_void_reply(struct msm_rpc_endpoint *client, int rc = 0; uint8_t reply_buf[sizeof(struct rpc_reply_hdr)]; struct rpc_reply_hdr *reply = (struct rpc_reply_hdr *)reply_buf; + + // return 0; // added while rpc not working MJ reply->xid = cpu_to_be32(xid); reply->type = cpu_to_be32(1); /* reply */ @@ -279,7 +280,7 @@ static int rpc_send_accepted_void_reply(struct msm_rpc_endpoint *client, reply->data.acc_hdr.verf_flavor = 0; reply->data.acc_hdr.verf_length = 0; - rc = msm_rpc_write(rpc_cb_server_client, reply_buf, sizeof(reply_buf)); + rc = msm_rpc_write_reply(reply, sizeof(reply_buf)); if (rc < 0) pr_err("adsp: could not write RPC response: %d\n", rc); return rc; @@ -510,12 +511,13 @@ static int handle_adsp_rtos_mtoa(struct rpc_request_hdr *req) /* this should be common code with rpc_servers.c */ static int adsp_rpc_thread(void *data) { - void *buffer; + int buf[1024]; + void *buffer=buf; struct rpc_request_hdr *req; int rc, exit = 0; do { - rc = msm_rpc_read(rpc_cb_server_client, &buffer, -1, -1); + rc = msm_rpc_read_command(buffer, -1); if (rc < 0) { pr_err("adsp: could not read rpc: %d\n", rc); break; @@ -539,12 +541,10 @@ static int adsp_rpc_thread(void *data) goto bad_rpc; handle_adsp_rtos_mtoa(req); - kfree(buffer); continue; bad_rpc: pr_err("adsp: bogus rpc from modem\n"); - kfree(buffer); } while (!exit); do_exit(0); } @@ -846,9 +846,9 @@ static int msm_adsp_probe(struct platform_device *pdev) pr_err("adsp: could not register callback server (%d)\n", rc); goto fail_rpc_register; } - +*/ /* start the kernel thread to process the callbacks */ - kthread_run(adsp_rpc_thread, NULL, "kadspd"); + // kthread_run(adsp_rpc_thread, NULL, "kadspd"); for (i = 0; i < count; i++) { struct msm_adsp_module *mod = adsp_modules + i; @@ -857,12 +857,13 @@ static int msm_adsp_probe(struct platform_device *pdev) mod->info = &adsp_info; mod->name = adsp_info.module[i].name; mod->id = adsp_info.module[i].id; - if (adsp_info.module[i].clk_name) + /* if (adsp_info.module[i].clk_name) mod->clk = clk_get(NULL, adsp_info.module[i].clk_name); else mod->clk = NULL; if (mod->clk && adsp_info.module[i].clk_rate) clk_set_rate(mod->clk, adsp_info.module[i].clk_rate); + */ mod->pdev.name = adsp_info.module[i].pdev_name; mod->pdev.id = -1; adsp_info.id_to_module[mod->id] = mod; @@ -874,7 +875,7 @@ static int msm_adsp_probe(struct platform_device *pdev) return 0; fail_rpc_register: - msm_rpc_close(rpc_cb_server_client); + // msm_rpc_close(rpc_cb_server_client); rpc_cb_server_client = NULL; fail_rpc_open: enable_irq(INT_ADSP); diff --git a/arch/arm/mach-msm/adsp.h b/arch/arm/mach-msm/adsp.h index d0a3580..eee9769 100644 --- a/arch/arm/mach-msm/adsp.h +++ b/arch/arm/mach-msm/adsp.h @@ -65,9 +65,13 @@ struct adsp_info { #define RPC_ADSP_RTOS_MTOA_PROG 0x3000000b #define RPC_ADSP_RTOS_ATOM_NULL_PROC 0 #define RPC_ADSP_RTOS_MTOA_NULL_PROC 0 -#define RPC_ADSP_RTOS_APP_TO_MODEM_PROC 2 -#define RPC_ADSP_RTOS_MODEM_TO_APP_PROC 2 +// changed for vogue .. MJ +#define RPC_ADSP_RTOS_APP_TO_MODEM_PROC 1 +#define RPC_ADSP_RTOS_MODEM_TO_APP_PROC 1 +#define RPC_ADSP_RTOS_ATOM_VERS 0 +#define RPC_ADSP_RTOS_MTOA_VERS 0 +/* #if CONFIG_MSM_AMSS_VERSION == 6210 #define RPC_ADSP_RTOS_ATOM_VERS 0x20f17fd3 #define RPC_ADSP_RTOS_MTOA_VERS 0x75babbd6 @@ -77,6 +81,7 @@ struct adsp_info { #else #error "Unknown AMSS version" #endif +*/ enum rpc_adsp_rtos_proc_type { RPC_ADSP_RTOS_PROC_NONE = 0, diff --git a/arch/arm/mach-msm/clock.c b/arch/arm/mach-msm/clock.c index fde1e66..6560a7e 100644 --- a/arch/arm/mach-msm/clock.c +++ b/arch/arm/mach-msm/clock.c @@ -66,6 +66,23 @@ static int acpuclk_enable(struct clk *clk); static void acpuclk_disable(struct clk *clk); static unsigned long acpuclk_get_rate(struct clk *clk); int acpuclk_set_rate(struct clk *clk, unsigned long rate, int for_power_collapse); + struct clock_params { + unsigned freq,a0val,a4val; + }; + + struct clock_params sd_clock_parameters[]={ + {2000000,0x40000-0x65,0xff9e0b78}, + {4000000,0x20000-0xc1,0xff400b69}, + {8000000,0x20000-0x61,0xffa00b69}, + {12000000,0x20000-0x31,0xffd00b69}, + {19000000,0x20000-0x21,0xffe00b69}, + {23000000,0x20000-0xb,0xfff60b79}, + {24000000,0x70000-0x65,0xffa10b69}, + {32000000,0x20000-0x11,0xfff00b69}, + {48000000,0x20000-0xd,0xfff40b69}, + {64000000,0x20000-0x9,0xfff80b69} + }; + extern struct clkctl_acpu_speed acpu_freq_tbl[]; @@ -78,55 +95,114 @@ static void init_lpj(const struct clkctl_acpu_speed *base_clk) { acpu_freq_tbl[i].a11clk_khz); } } + int sdcc_host_clock=0; + int set_sdcc_host_clock(unsigned freq) { + int n; + sdcc_host_clock=freq; + for(n=0;n>7)&1; + if(id==SDC1_PCLK) + return 1; + return 0; +// if (msm_proc_comm(PCOM_CLKCTL_RPC_ENABLED, &id, 0)) +// return 0; +// else +// return id; } static int pc_pll_request(unsigned id, unsigned on) { + return 0; int res; on = !!on; @@ -161,8 +237,8 @@ int clk_register(struct clk *clk) mutex_lock(&clocks_mutex); spin_lock_init(&clk->lock); list_add_tail(&clk->list, &clocks); - if (clk->id == ACPU_CLK) - acpuclk_init(clk); + // if (clk->id == ACPU_CLK) + // acpuclk_init(clk); mutex_unlock(&clocks_mutex); return 0; } @@ -173,7 +249,7 @@ int clk_register(struct clk *clk) struct clk *clk_get(struct device *dev, const char *id) { struct clk *c_clk; - + printk("clk_get %s\n",id); mutex_lock(&clocks_mutex); list_for_each_entry(c_clk, &clocks, list) { if (!strcmp(id, c_clk->name) && try_module_get(c_clk->owner)) { @@ -188,6 +264,7 @@ struct clk *clk_get(struct device *dev, const char *id) int clk_enable(struct clk *clk) { unsigned long flags; + if(!clk) return; if (clk->id == ACPU_CLK) return acpuclk_enable(clk); spin_lock_irqsave(&clk->lock, flags); @@ -201,6 +278,7 @@ int clk_enable(struct clk *clk) void clk_disable(struct clk *clk) { unsigned long flags; + if(!clk) return; if (clk->id == ACPU_CLK) return acpuclk_disable(clk); spin_lock_irqsave(&clk->lock, flags); @@ -213,19 +291,27 @@ void clk_disable(struct clk *clk) unsigned long clk_get_rate(struct clk *clk) { + if(!clk) return 0; + printk("clk_disable %d\n",clk->id); + unsigned int rate; + if(!clk) return 0; if (clk->id == ACPU_CLK) return acpuclk_get_rate(clk); - return pc_clk_get_rate(clk->id); + rate=pc_clk_get_rate(clk->id); + printk("clk_get_rate %d:%d\n",clk->id,rate); + return rate; } void clk_put(struct clk *clk) { + if(!clk) return; module_put(clk->owner); } int clk_set_rate(struct clk *clk, unsigned long rate) { int ret; + if(!clk) return 0; if (clk->id == ACPU_CLK) return acpuclk_set_rate(clk, rate, 0); if (clk->flags & CLKFLAG_USE_MIN_MAX_TO_SET) { @@ -287,7 +373,7 @@ static void acpuclk_disable(struct clk *clk) static int acpuclk_set_vdd_level(int vdd) { uint32_t current_vdd; - + return 0; current_vdd = readl(A11S_VDD_SVS_PLEVEL_ADDR) & 0x07; #if PERF_SWITCH_DEBUG @@ -387,6 +473,7 @@ int acpuclk_set_rate(struct clk *clk, unsigned long rate, int for_power_collapse struct cpufreq_freqs freqs; #endif + return 0; strt_s = cur_s = drv_state.current_speed; if (rate == (cur_s->a11clk_khz * 1000)) diff --git a/arch/arm/mach-msm/common.c b/arch/arm/mach-msm/common.c index eb7ee13..7268b35 100644 --- a/arch/arm/mach-msm/common.c +++ b/arch/arm/mach-msm/common.c @@ -95,21 +95,25 @@ void __init msm_add_devices(void) } static struct resource msm_sdc1_resources[] = { + { .start = MSM_SDC1_BASE, .end = MSM_SDC1_BASE + MSM_SDC1_SIZE -1, .flags = IORESOURCE_MEM, }, + { .start = INT_SDC1_0, .end = INT_SDC1_1, .flags = IORESOURCE_IRQ, }, + { .start = 8, .end = 8, .flags = IORESOURCE_DMA, }, + }; static struct platform_device msm_sdc1_device = { @@ -121,7 +125,7 @@ static struct platform_device msm_sdc1_device = { .coherent_dma_mask = 0xffffffff, }, }; - +/* static struct resource msm_sdc2_resources[] = { { .start = MSM_SDC2_BASE, @@ -138,6 +142,7 @@ static struct resource msm_sdc2_resources[] = { .end = 8, .flags = IORESOURCE_DMA, }, + }; static struct platform_device msm_sdc2_device = { @@ -205,19 +210,19 @@ static struct platform_device msm_sdc4_device = { .coherent_dma_mask = 0xffffffff, }, }; - +*/ static struct platform_device *msm_sdcc_devices[] __initdata = { &msm_sdc1_device, - &msm_sdc2_device, - &msm_sdc3_device, - &msm_sdc4_device, + // &msm_sdc2_device, +// &msm_sdc3_device, +// &msm_sdc4_device, }; int __init msm_add_sdcc(unsigned int controller, struct mmc_platform_data *plat) { struct platform_device *pdev; - if (controller < 1 || controller > 4) + if (controller < 1 || controller > 2) return -EINVAL; pdev = msm_sdcc_devices[controller-1]; diff --git a/arch/arm/mach-msm/dma.c b/arch/arm/mach-msm/dma.c index 582945f..ffb4605 100644 --- a/arch/arm/mach-msm/dma.c +++ b/arch/arm/mach-msm/dma.c @@ -15,6 +15,7 @@ #include #include +#include #include #define MSM_DMOV_CHANNEL_COUNT 16 @@ -30,6 +31,7 @@ static unsigned int channel_active; static struct list_head ready_commands[MSM_DMOV_CHANNEL_COUNT]; static struct list_head active_commands[MSM_DMOV_CHANNEL_COUNT]; unsigned int msm_dmov_print_mask = MSM_DMOV_PRINT_ERRORS; +//| MSM_DMOV_PRINT_IO | MSM_DMOV_PRINT_FLOW ; #define MSM_DMOV_DPRINTF(mask, format, args...) \ do { \ @@ -135,6 +137,8 @@ static irqreturn_t msm_datamover_irq_handler(int irq, void *dev_id) spin_lock_irqsave(&msm_dmov_lock, irq_flags); + udelay(200); + int_status = readl(DMOV_ISR); /* read and clear interrupt */ PRINT_FLOW("msm_datamover_irq_handler: DMOV_ISR %x\n", int_status); diff --git a/arch/arm/mach-msm/gpio.c b/arch/arm/mach-msm/gpio.c index 4ea2dcf..9e4849a 100644 --- a/arch/arm/mach-msm/gpio.c +++ b/arch/arm/mach-msm/gpio.c @@ -176,6 +176,7 @@ struct msm_gpio_chip msm_gpio_chips[] = { .clear_detect_status = msm_gpio_clear_detect_status } }, +/* { .regs = { .out = GPIO_OUT_5, @@ -198,6 +199,7 @@ struct msm_gpio_chip msm_gpio_chips[] = { .clear_detect_status = msm_gpio_clear_detect_status } } + */ }; static void msm_gpio_update_both_edge_detect(struct msm_gpio_chip *msm_chip) @@ -375,6 +377,7 @@ static void msm_gpio_irq_handler(unsigned int irq, struct irq_desc *desc) int i, j, m; unsigned v; + //printk("g:%x.",irq); for (i = 0; i < ARRAY_SIZE(msm_gpio_chips); i++) { struct msm_gpio_chip *msm_chip = &msm_gpio_chips[i]; v = readl(msm_chip->regs.int_status); @@ -382,7 +385,7 @@ static void msm_gpio_irq_handler(unsigned int irq, struct irq_desc *desc) while (v) { m = v & -v; j = fls(m) - 1; - /* printk("msm_gpio_irq_handler %08x %08x bit %d gpio %d irq %d\n", v, m, j, msm_chip->chip.start + j, NR_MSM_IRQS + msm_chip->chip.start + j); */ + // printk("msm_gpio_irq_handler %08x %08x bit %d gpio %d irq %d\n", v, m, j, msm_chip->chip.start + j, NR_MSM_IRQS + msm_chip->chip.start + j); v &= ~m; generic_handle_irq(NR_MSM_IRQS + msm_chip->chip.start + j); } @@ -399,21 +402,29 @@ static struct irq_chip msm_gpio_irq_chip = { .set_type = msm_gpio_irq_set_type, }; -#define NUM_GPIO_INT_REGISTERS 6 +#define NUM_GPIO_INT_REGISTERS 5 #define GPIO_SMEM_NUM_GROUPS 2 #define GPIO_SMEM_MAX_PC_INTERRUPTS 8 struct tramp_gpio_smem { + uint32_t unknown[2]; + uint32_t enabled[NUM_GPIO_INT_REGISTERS]; + uint32_t unknown1[8]; + uint32_t fired[NUM_GPIO_INT_REGISTERS]; + uint32_t unknown2[2]; + /* uint16_t num_fired[GPIO_SMEM_NUM_GROUPS]; uint16_t fired[GPIO_SMEM_NUM_GROUPS][GPIO_SMEM_MAX_PC_INTERRUPTS]; uint32_t enabled[NUM_GPIO_INT_REGISTERS]; uint32_t detection[NUM_GPIO_INT_REGISTERS]; uint32_t polarity[NUM_GPIO_INT_REGISTERS]; + */ }; static void msm_gpio_sleep_int(unsigned long arg) { int i, j; + int m; struct tramp_gpio_smem *smem_gpio; BUILD_BUG_ON(ARRAY_SIZE(msm_gpio_chips) != ARRAY_SIZE(smem_gpio->enabled)); @@ -421,72 +432,134 @@ static void msm_gpio_sleep_int(unsigned long arg) smem_gpio = smem_alloc(SMEM_GPIO_INT, sizeof(*smem_gpio)); if (smem_gpio == NULL) return; - - for(i = 0; i < GPIO_SMEM_NUM_GROUPS; i++) { - int count = smem_gpio->num_fired[i]; - for(j = 0; j < count; j++) { - /* TODO: Check mask */ - generic_handle_irq(MSM_GPIO_TO_INT(smem_gpio->fired[i][j])); + for(i = 0; i < ARRAY_SIZE(msm_gpio_chips); i++) { + struct msm_gpio_chip *msm_chip = &msm_gpio_chips[i]; + uint32_t v=smem_gpio->fired[i]; + int j; + while(v) { + m = v & -v; + j=fls(m) -1; + printk("msm_gpio_sleep_int handle_irq(%d)\n",j+msm_chip->chip.start); + generic_handle_irq(MSM_GPIO_TO_INT(j+msm_chip->chip.start)); + v&=~m; } } } static DECLARE_TASKLET(msm_gpio_sleep_int_tasklet, msm_gpio_sleep_int, 0); -void msm_gpio_enter_sleep(int from_idle) -{ +void printsavedgpios(unsigned * gp) { int i; + printk("saved gpios:\n"); + for(i=0;i<22;i++) + printk("%d: %8x\n",i,gp[i]); +} + +void msm_gpio_enter_sleep(int from_idle) { + + + int i; + int *p; + struct tramp_gpio_smem *smem_gpio; BUILD_BUG_ON(ARRAY_SIZE(msm_gpio_chips) != ARRAY_SIZE(smem_gpio->enabled)); smem_gpio = smem_alloc(SMEM_GPIO_INT, sizeof(*smem_gpio)); + p=(int *)smem_gpio; if (smem_gpio) { - for (i = 0; i < ARRAY_SIZE(smem_gpio->enabled); i++) { +/* for (i = 0; i < ARRAY_SIZE(smem_gpio->enabled); i++) { smem_gpio->enabled[i] = 0; - smem_gpio->detection[i] = 0; - smem_gpio->polarity[i] = 0; + smem_gpio->fired[i] = 0; } - } +a818=0 +a824=2008 +a828=0 +a82c=8 +a830=20040 +a834=20040 +a838=0 +a83c=0 +a848=0 +a868=0 +*/ + p[0]=0; // 18 + p[1]=0; // 1c + p[2]=0; // 20 + p[3]=0x2008; // 24 + p[4]=0; // 28 + p[5]=8; // 2c + p[6]=0x20040; // 30 + p[7]=0x20040; // 34 + p[8]=0; // 38 + p[9]=0; // 3c + p[10]=0; // 40 + p[11]=0; // 44 + p[12]=0; // 48 + p[13]=0; // 4c + p[14]=0; // 50 + p[15]=0; // 54 + p[16]=0; // 58 + p[17]=0; // 5c + p[18]=0; // 60 + p[19]=0; // 64 + p[20]=0; // 68 +} for (i = 0; i < ARRAY_SIZE(msm_gpio_chips); i++) { - writel(msm_gpio_chips[i].int_enable[!from_idle], msm_gpio_chips[i].regs.int_en); - if (smem_gpio) { - uint32_t tmp; - int start, index, shiftl, shiftr; - start = msm_gpio_chips[i].chip.start; - index = start / 32; - shiftl = start % 32; - shiftr = 32 - shiftl; - tmp = msm_gpio_chips[i].int_enable[!from_idle]; - smem_gpio->enabled[index] |= tmp << shiftl; - smem_gpio->enabled[index+1] |= tmp >> shiftr; - smem_gpio->detection[index] |= readl(msm_gpio_chips[i].regs.int_edge) << shiftl; - smem_gpio->detection[index+1] |= readl(msm_gpio_chips[i].regs.int_edge) >> shiftr; - smem_gpio->polarity[index] |= readl(msm_gpio_chips[i].regs.int_pos) << shiftl; - smem_gpio->polarity[index+1] |= readl(msm_gpio_chips[i].regs.int_pos) >> shiftr; - } + writel(0, msm_gpio_chips[i].regs.int_en); + //writel(msm_gpio_chips[i].int_enable[!from_idle], msm_gpio_chips[i].regs.int_en); + // writel(0, msm_gpio_chips[i].regs.int_en); + + // if (smem_gpio) { + // smem_gpio->enabled[i] = msm_gpio_chips[i].int_enable[!from_idle]; + //} } + // allow power btn to wake up + writel(msm_gpio_chips[1].int_enable[!from_idle] | 1<<13, msm_gpio_chips[1].regs.int_en); +// writel(readl(msm_gpio_chips[1].regs.int_en) & ~0x6f8000,msm_gpio_chips[1].regs.int_en); + /* if (smem_gpio) { if (msm_gpio_debug_mask & GPIO_DEBUG_SLEEP) for (i = 0; i < ARRAY_SIZE(smem_gpio->enabled); i++) { - printk("msm_gpio_enter_sleep gpio %d-%d: enable" - " %08x, edge %08x, polarity %08x\n", - i * 32, i * 32 + 31, - smem_gpio->enabled[i], - smem_gpio->detection[i], - smem_gpio->polarity[i]); + printk("msm_gpio_enter_sleep gpio: enable" + "%x %08x\n", + i, + smem_gpio->enabled[i]); } - for(i = 0; i < GPIO_SMEM_NUM_GROUPS; i++) - smem_gpio->num_fired[i] = 0; } + + printsavedgpios((unsigned *)smem_gpio); +*/ +} +int gpios_setup=0; +void msm_button_enable(int en) { + unsigned i; + return; // mj + int gpios[]={31,32,33,34,35,41,42,99,19}; + if(!gpios_setup) + return; + for(i=0;ienabled)); @@ -495,12 +568,14 @@ void msm_gpio_exit_sleep(void) for (i = 0; i < ARRAY_SIZE(msm_gpio_chips); i++) { writel(msm_gpio_chips[i].int_enable[0], msm_gpio_chips[i].regs.int_en); + if(smem_gpio) + fired|=smem_gpio->fired[i]; } - if (smem_gpio && (smem_gpio->num_fired[0] || smem_gpio->num_fired[1])) { + + if (smem_gpio && fired) { if (msm_gpio_debug_mask & GPIO_DEBUG_SLEEP) - printk(KERN_INFO "gpio: fired %x %x\n", - smem_gpio->num_fired[0], smem_gpio->num_fired[1]); + printsavedgpios((unsigned *)smem_gpio); tasklet_schedule(&msm_gpio_sleep_int_tasklet); } } diff --git a/arch/arm/mach-msm/io.c b/arch/arm/mach-msm/io.c index edc638f..045d4cb 100644 --- a/arch/arm/mach-msm/io.c +++ b/arch/arm/mach-msm/io.c @@ -59,8 +59,6 @@ static struct map_desc msm_io_desc[] __initdata = { }, MSM_DEVICE(SDC1), MSM_DEVICE(SDC2), - MSM_DEVICE(SDC3), - MSM_DEVICE(SDC4), }; void __init msm_map_common_io(void) diff --git a/arch/arm/mach-msm/pm.c b/arch/arm/mach-msm/pm.c index 75f1704..83856d5 100644 --- a/arch/arm/mach-msm/pm.c +++ b/arch/arm/mach-msm/pm.c @@ -27,6 +27,7 @@ #include #include #include +#include "vogue-hw.h" #include "smd_private.h" #include "clock.h" @@ -44,7 +45,7 @@ enum { MSM_PM_DEBUG_SMSM_STATE = 1U << 5, MSM_PM_DEBUG_IDLE = 1U << 6, }; -static int msm_pm_debug_mask; +static int msm_pm_debug_mask=0x37; module_param_named(debug_mask, msm_pm_debug_mask, int, S_IRUGO | S_IWUSR | S_IWGRP); enum { @@ -144,6 +145,10 @@ msm_pm_wait_state(uint32_t wait_state_all_set, uint32_t wait_state_all_clear, int i; uint32_t state; + state = smsm_get_state(); + printk("msm_pm_wait_state(%x, %x, %x, %x) %x\n", + wait_state_all_set, wait_state_all_clear, + wait_state_any_set, wait_state_any_clear, state); for (i = 0; i < 100000; i++) { state = smsm_get_state(); if (((state & wait_state_all_set) == wait_state_all_set) && @@ -157,11 +162,16 @@ msm_pm_wait_state(uint32_t wait_state_all_set, uint32_t wait_state_all_clear, wait_state_any_set, wait_state_any_clear, state); return -ETIMEDOUT; } +int onlysleeponce=0; static int msm_sleep(int sleep_mode, uint32_t sleep_delay, int from_idle) { + int i,secs; uint32_t saved_vector[2]; int collapsed; + if(onlysleeponce) return 0; + + onlysleeponce=1; void msm_irq_enter_sleep1(bool arm9_wake, int from_idle); int msm_irq_enter_sleep2(bool arm9_wake, int from_idle); void msm_irq_exit_sleep1(void); @@ -178,15 +188,24 @@ static int msm_sleep(int sleep_mode, uint32_t sleep_delay, int from_idle) uint32_t exit_wait_set = 0; int ret; int rv = -EINTR; - + void msm_button_enable(int); + void set_audio_parameters(char *name1,char *name2,char *name3); + extern int gpios_setup; +/* + if(!from_idle) { + gpios_setup=1; + msm_button_enable(0); + } +*/ if (msm_pm_debug_mask & MSM_PM_DEBUG_SUSPEND) - printk(KERN_INFO "msm_sleep(): mode %d delay %u idle %d\n", + printk(KERN_ERR "msm_sleep(): mode %d delay %u idle %d\n", sleep_mode, sleep_delay, from_idle); switch (sleep_mode) { case MSM_PM_SLEEP_MODE_POWER_COLLAPSE: enter_state = SMSM_PWRC; enter_wait_set = SMSM_RSA; + // enter_wait_clear = SMSM_RUN; //mj exit_state = SMSM_WFPI; exit_wait_clear = SMSM_RSA; break; @@ -206,12 +225,26 @@ static int msm_sleep(int sleep_mode, uint32_t sleep_delay, int from_idle) exit_state = 0; } + vogue_set_egpio(1,3,1); + vogue_set_egpio(1,4,1); + vogue_set_egpio(1,5,0); // green + printk(KERN_ERR "msm_sleep():irq_enter_sleep1\n"); msm_irq_enter_sleep1(!!enter_state, from_idle); + vogue_set_egpio(1,4,1); + vogue_set_egpio(1,5,1); // amber + + printk(KERN_ERR "msm_sleep():gpio_enter_sleep\n"); msm_gpio_enter_sleep(from_idle); + // vogue_set_egpio(1,4,0); + //vogue_set_egpio(1,5,0); // off + + set_audio_parameters("OFF","CE_SYS","CE_PLAYBACK_HEADSET_RING"); + msm_proc_comm(0x119,0x63,0); if (enter_state) { - if (sleep_delay == 0 && sleep_mode >= MSM_PM_SLEEP_MODE_APPS_SLEEP) - sleep_delay = 192000*5; /* APPS_SLEEP does not allow infinite timeout */ + //if (sleep_delay == 0 && sleep_mode >= MSM_PM_SLEEP_MODE_APPS_SLEEP) + // sleep_delay = 192000*5; /* APPS_SLEEP does not allow infinite timeout */ + sleep_delay = 0x2d91;//192000*5; smsm_set_sleep_duration(sleep_delay); ret = smsm_change_state(SMSM_RUN, enter_state); if (ret) { @@ -221,22 +254,30 @@ static int msm_sleep(int sleep_mode, uint32_t sleep_delay, int from_idle) } ret = msm_pm_wait_state(enter_wait_set, enter_wait_clear, 0, 0); if (ret) { - printk(KERN_INFO "msm_sleep(): msm_pm_wait_state failed, %x\n", smsm_get_state()); + printk(KERN_ERR "msm_sleep(): msm_pm_wait_state failed, %x\n", smsm_get_state()); goto enter_failed; } } + + printk(KERN_ERR "msm_sleep():irq_enter_sleep2\n"); if (msm_irq_enter_sleep2(!!enter_state, from_idle)) goto enter_failed; if (enter_state) { - writel(0x1f, A11S_CLK_SLEEP_EN); + // secs=msm_proc_comm(0x181,0,0); + //msm_proc_comm(0x184,secs+60,0); + for(i=0;i<7;i++) + writel(1< " + printk(KERN_ERR "msm_sleep(): vector %x %x -> " "%x %x\n", saved_vector[0], saved_vector[1], msm_pm_reset_vector[0], msm_pm_reset_vector[1]); - collapsed = msm_pm_collapse(); + vogue_set_egpio(1,3,1); // no flash + vogue_set_egpio(1,4,1); // amber + vogue_set_egpio(1,5,1); + vogue_set_egpio(1,4,0); // red + vogue_set_egpio(1,5,1); + + msm_proc_comm_noirq(1,0,0); + printk(KERN_ERR "msm_sleep():pm_collapse\n"); + msm_pm_collapse(); + collapsed = 1;//msm_pm_collapse(); + vogue_set_egpio(1,4,1); // green + vogue_set_egpio(1,5,0); + /* + while(1) { + vogue_set_egpio(1,4,1); + vogue_set_egpio(1,5,0); + vogue_set_egpio(1,3,1); // green + for(i=0;i<100000;i++); + vogue_set_egpio(1,4,0); // red + vogue_set_egpio(1,5,1); + for(i=0;i<100000;i++); + vogue_set_egpio(1,4,1); + vogue_set_egpio(1,5,0); + vogue_set_egpio(1,3,1); // green + } + */ msm_pm_reset_vector[0] = saved_vector[0]; msm_pm_reset_vector[1] = saved_vector[1]; if (collapsed) { @@ -274,7 +340,17 @@ static int msm_sleep(int sleep_mode, uint32_t sleep_delay, int from_idle) if (msm_pm_debug_mask & MSM_PM_DEBUG_SMSM_STATE) smsm_print_sleep_info(); } else { + vogue_set_egpio(1,4,0); + vogue_set_egpio(1,5,1); + writel(0x1f, A11S_CLK_SLEEP_EN); + writel(0, A11S_PWRDOWN); // should be 1 for pc + writel(0, A11S_STANDBY_CTL); + writel(0, A11RAMBACKBIAS); msm_arch_idle(); + vogue_set_egpio(1,4,1); + vogue_set_egpio(1,5,0); + writel(0x00, A11S_CLK_SLEEP_EN); + writel(0, A11S_PWRDOWN); rv = 0; } @@ -352,6 +428,7 @@ void arch_idle(void) printk(KERN_INFO "arch_idle: sleep time %llu, allow_sleep %d\n", sleep_time, allow_sleep); spin = msm_pm_idle_spin_time >> 10; +/* while (spin-- > 0) { if (msm_irq_pending()) { #ifdef CONFIG_MSM_IDLE_STATS @@ -361,20 +438,21 @@ void arch_idle(void) } udelay(1); } +MJ */ if (sleep_time < msm_pm_idle_sleep_min_time || !allow_sleep) { unsigned long saved_rate; saved_rate = clk_get_rate(acpu_clk); if (msm_pm_debug_mask & MSM_PM_DEBUG_CLOCK) printk(KERN_DEBUG "arch_idle: clk %ld -> swfi\n", saved_rate); - acpuclk_wait_for_irq(); +// acpuclk_wait_for_irq(); MJ msm_arch_idle(); if (msm_pm_debug_mask & MSM_PM_DEBUG_CLOCK) printk(KERN_DEBUG "msm_sleep: clk swfi -> %ld\n", saved_rate); - if (acpuclk_set_rate(acpu_clk, saved_rate, 1) < 0) - printk(KERN_ERR "msm_sleep(): clk_set_rate %ld " - "failed\n", saved_rate); +// if (acpuclk_set_rate(acpu_clk, saved_rate, 1) < 0) +// printk(KERN_ERR "msm_sleep(): clk_set_rate %ld " +// "failed\n", saved_rate); #ifdef CONFIG_MSM_IDLE_STATS exit_stat = MSM_PM_STAT_IDLE_WFI; #endif @@ -416,8 +494,8 @@ static uint32_t restart_reason = 0x776655AA; static void msm_pm_power_off(void) { - msm_proc_comm(PCOM_POWER_DOWN, 0, 0); - for (;;) ; +// msm_proc_comm(PCOM_POWER_DOWN, 0, 0); +// for (;;) ; } static void msm_pm_restart(char str) @@ -426,12 +504,14 @@ static void msm_pm_restart(char str) * is the default, prefer that to the (slower) proc_comm * reset command. */ +/* if ((restart_reason == 0x776655AA) && msm_reset_hook) { msm_reset_hook(str); } else { msm_proc_comm(PCOM_RESET_CHIP, &restart_reason, 0); } for (;;) ; +*/ } static int msm_reboot_call(struct notifier_block *this, unsigned long code, void *_cmd) diff --git a/arch/arm/mach-msm/proc_comm.h b/arch/arm/mach-msm/proc_comm.h index 0426841..f2d3f23 100644 --- a/arch/arm/mach-msm/proc_comm.h +++ b/arch/arm/mach-msm/proc_comm.h @@ -103,6 +103,7 @@ enum { (((pull) & 0x3) << 15) | \ (((drvstr) & 0xF) << 17)) -int msm_proc_comm(unsigned cmd, unsigned *data1, unsigned *data2); +int msm_proc_comm(unsigned cmd, unsigned data1, unsigned data2); +int msm_proc_comm_noirq(unsigned cmd, unsigned data1, unsigned data2); #endif diff --git a/arch/arm/mach-msm/smd.c b/arch/arm/mach-msm/smd.c index efa9bf8..0029b45 100644 --- a/arch/arm/mach-msm/smd.c +++ b/arch/arm/mach-msm/smd.c @@ -61,6 +61,12 @@ static inline void notify_other_smsm(void) writel(1, MSM_A2M_INT(5)); } +static inline void vogue_notify_other_smd(int ch) +{ + if(ch==0 || ch==1) + writel(1, MSM_A2M_INT(3+ch)); +} + static inline void notify_other_smd(void) { writel(1, MSM_A2M_INT(0)); @@ -125,6 +131,7 @@ static int check_for_modem_crash(void) #define SMD_HEADER_SIZE 20 + /* the spinlock is used to synchronize between the ** irq handler and code that mutates the channel ** list or fiddles with channel state diff --git a/arch/arm/mach-msm/smd_private.h b/arch/arm/mach-msm/smd_private.h index c0eb3de..b2b839e 100644 --- a/arch/arm/mach-msm/smd_private.h +++ b/arch/arm/mach-msm/smd_private.h @@ -66,7 +66,7 @@ struct smsm_shared struct smsm_interrupt_info { uint32_t aArm_en_mask; - uint32_t aArm_interrupts_pending; + // uint32_t aArm_interrupts_pending; uint32_t aArm_wakeup_reason; }; @@ -111,27 +111,25 @@ void smsm_print_sleep_info(void); typedef enum { /* fixed items */ - SMEM_PROC_COMM = 0, - SMEM_HEAP_INFO, + // SMEM_PROC_COMM = 0, + // SMEM_HEAP_INFO, + SMEM_0_40=0, + SMEM_40_80, + SMEM_c0_8, + SMEM_c8_4, + SMEM_cc_c8, + SMEM_194_20, // spinlock array? + SMEM_1b4_4, + SMEM_1b8_10, SMEM_ALLOCATION_TABLE, - SMEM_VERSION_INFO, - SMEM_HW_RESET_DETECT, - SMEM_AARM_WARM_BOOT, - SMEM_DIAG_ERR_MESSAGE, - SMEM_SPINLOCK_ARRAY, - SMEM_MEMORY_BARRIER_LOCATION, - - /* dynamic items */ - SMEM_AARM_PARTITION_TABLE, - SMEM_AARM_BAD_BLOCK_TABLE, - SMEM_RESERVE_BAD_BLOCKS, - SMEM_WM_UUID, - SMEM_CHANNEL_ALLOC_TBL, + SMEM_9c8_1d0, + UNUSED1, + UNUSED2, + UNUSED3, + SMEM_SMD_BASE_ID, SMEM_SMEM_LOG_IDX = SMEM_SMD_BASE_ID + SMEM_NUM_SMD_CHANNELS, SMEM_SMEM_LOG_EVENTS, - SMEM_SMEM_STATIC_LOG_IDX, - SMEM_SMEM_STATIC_LOG_EVENTS, SMEM_SMEM_SLOW_CLOCK_SYNC, SMEM_SMEM_SLOW_CLOCK_VALUE, SMEM_BIO_LED_BUF, diff --git a/arch/arm/mach-msm/smd_rpcrouter.c b/arch/arm/mach-msm/smd_rpcrouter.c index 495cbf5..ebf287a 100644 --- a/arch/arm/mach-msm/smd_rpcrouter.c +++ b/arch/arm/mach-msm/smd_rpcrouter.c @@ -577,6 +577,7 @@ static void do_read_data(struct work_struct *work) uint32_t pm, mid; unsigned long flags; + /* if (rr_read(&hdr, sizeof(hdr))) goto fail_io; @@ -601,15 +602,17 @@ static void do_read_data(struct work_struct *work) process_control_msg((void*) r2r_buf, hdr.size); goto done; } - + + if (hdr.size < sizeof(pm)) { DIAG("runt packet (no pacmark)\n"); goto fail_data; } + */ if (rr_read(&pm, sizeof(pm))) goto fail_io; - hdr.size -= sizeof(pm); + hdr.size=PACMARK_LEN(pm); //-= sizeof(pm); frag = rr_malloc(hdr.size + sizeof(*frag)); frag->next = NULL; diff --git a/arch/arm/mach-msm/smd_tty.c b/arch/arm/mach-msm/smd_tty.c index 724b6b3..020cb58 100644 --- a/arch/arm/mach-msm/smd_tty.c +++ b/arch/arm/mach-msm/smd_tty.c @@ -79,15 +79,16 @@ static int smd_tty_open(struct tty_struct *tty, struct file *f) int res = 0; int n = tty->index; struct smd_tty_info *info; - const char *name; + //const char *name; - if (n == 0) { + /* if (n == 0) { name = "SMD_DS"; } else if (n == 27) { name = "SMD_GPSNMEA"; } else { return -ENODEV; } + */ info = smd_tty + n; @@ -99,7 +100,7 @@ static int smd_tty_open(struct tty_struct *tty, struct file *f) if (info->ch) { smd_kick(info->ch); } else { - res = smd_open(name, &info->ch, info, smd_tty_notify); + res = smd_open(n, &info->ch, info, smd_tty_notify); } } mutex_unlock(&smd_tty_lock); @@ -200,6 +201,7 @@ static int __init smd_tty_init(void) /* this should be dynamic */ tty_register_device(smd_tty_driver, 0, 0); + tty_register_device(smd_tty_driver, 1, 0); tty_register_device(smd_tty_driver, 27, 0); return 0; diff --git a/arch/arm/mach-msm/timer.c b/arch/arm/mach-msm/timer.c index 9e225da..d5965db 100644 --- a/arch/arm/mach-msm/timer.c +++ b/arch/arm/mach-msm/timer.c @@ -80,10 +80,15 @@ enum { static struct msm_clock msm_clocks[]; static struct msm_clock *msm_active_clock; +void check_for_smd_data(); static irqreturn_t msm_timer_interrupt(int irq, void *dev_id) { struct clock_event_device *evt = dev_id; evt->event_handler(evt); + // this is a horrible hack but it looks like sometimes the A9 doesn't interrupt us when smd data is ready. + // writel(0,MSM_CSR_BASE+0x440); + //writel(1,MSM_SHARED_RAM_BASE+0x0bc0); + //check_for_smd_data(); return IRQ_HANDLED; } @@ -194,7 +199,8 @@ static uint32_t msm_timer_sync_smem_clock(int exit_sleep) uint32_t last_state; uint32_t state; uint32_t new_offset; - + return 0; + /* smem_clock = smem_alloc(SMEM_SMEM_SLOW_CLOCK_VALUE, sizeof(uint32_t)); @@ -265,6 +271,7 @@ static uint32_t msm_timer_sync_smem_clock(int exit_sleep) "clock %u in %lld ns\n", state, *smem_clock, ktime_to_ns(ktime_get()) - entry_time); return smem_clock_val; + */ } static void msm_timer_reactivate_alarm(struct msm_clock *clock) @@ -307,7 +314,7 @@ void msm_timer_exit_idle(int low_power) { struct msm_clock *clock = msm_active_clock; uint32_t smem_clock; - + return; if (!low_power || clock != &msm_clocks[MSM_CLOCK_GPT]) return; diff --git a/arch/arm/tools/mach-types b/arch/arm/tools/mach-types index 7ed58c0..787e340 100644 --- a/arch/arm/tools/mach-types +++ b/arch/arm/tools/mach-types @@ -387,7 +387,7 @@ s5c7375 ARCH_S5C7375 S5C7375 369 spearhead ARCH_SPEARHEAD SPEARHEAD 370 pantera ARCH_PANTERA PANTERA 371 prayoglite ARCH_PRAYOGLITE PRAYOGLITE 372 -gumstix ARCH_GUMSTIK GUMSTIK 373 +gumstix ARCH_GUMSTIX GUMSTIX 373 rcube ARCH_RCUBE RCUBE 374 rea_olv ARCH_REA_OLV REA_OLV 375 pxa_iphone ARCH_PXA_IPHONE PXA_IPHONE 376 @@ -1611,3 +1611,4 @@ kb9263 MACH_KB9263 KB9263 1612 mt7108 MACH_MT7108 MT7108 1613 smtr2440 MACH_SMTR2440 SMTR2440 1614 manao MACH_MANAO MANAO 1615 +htcvogue MACH_HTCVOGUE HTCVOGUE 1667 diff --git a/drivers/android/power.c b/drivers/android/power.c index 6c773ab..be2baab 100644 --- a/drivers/android/power.c +++ b/drivers/android/power.c @@ -32,6 +32,9 @@ #include #include #include +#include +int msm_proc_comm(unsigned cmd, unsigned data1, unsigned data2); + #ifdef CONFIG_ANDROID_POWER_STAT #include #endif @@ -1057,6 +1060,7 @@ static ssize_t release_wake_lock_show(struct kobject *kobj, struct kobj_attribut spin_unlock_irqrestore(&g_list_lock, irqflags); return (s - buf); } +static int g_battery_level; static ssize_t release_wake_lock_store(struct kobject *kobj, struct kobj_attribute *attr, const char * buf, size_t n) { @@ -1080,6 +1084,47 @@ static ssize_t release_wake_lock_store(struct kobject *kobj, struct kobj_attribu android_unlock_suspend(&g_user_wake_locks[i].suspend_lock); return n; } +static int g_battery_level_low; +static int g_battery_level_scale = 5; +static int g_battery_low_level = 10; +static int g_battery_shutdown_level = 5; +static android_charging_state_t g_charging_state = ANDROID_CHARGING_STATE_DISCHARGE; + +static void update_battery_low_level(void); + +static int scale_battery_level(int level, int scale) +{ + return (level * scale + 50) / 100; +} + +static ssize_t charging_state_show(struct kobject *kobj, struct kobj_attribute *attr, char * buf) +{ + const char *state_str[] = { + [ANDROID_CHARGING_STATE_UNKNOWN] = "Unknown", + [ANDROID_CHARGING_STATE_DISCHARGE] = "Discharging", + [ANDROID_CHARGING_STATE_MAINTAIN] = "Maintaining", + [ANDROID_CHARGING_STATE_SLOW] = "Slow", + [ANDROID_CHARGING_STATE_NORMAL] = "Normal", + [ANDROID_CHARGING_STATE_FAST] = "Fast", + [ANDROID_CHARGING_STATE_OVERHEAT] = "Overheat" + }; + char * s = buf; + s += sprintf(s, "%s\n", state_str[g_charging_state]); + return (s - buf); +} +static int get_battery_level(void) { + int v; + int *values=(int *)(MSM_SHARED_RAM_BASE+0xfc140); + msm_proc_comm(0x18a,0,0); + v=((values[2]-0xd00)*100)/(0xfff-0xd00); + if(v<0) v=0; + return v; +} +static ssize_t battery_level_raw_show(struct kobject *kobj, struct kobj_attribute *attr, char * buf) +{ + return sprintf(buf,"%d\n",get_battery_level()); +} + #ifndef CONFIG_FRAMEBUFFER_CONSOLE @@ -1170,6 +1215,58 @@ static struct attribute_group attr_group = { .attrs = g, }; +static void set_set_battery_level_low(int state) +{ + int ret; + int old_state = g_battery_level_low; + if(old_state == state) + return; + g_battery_level_low = state; + printk("android_power_set_battery_level low state %d -> %d\n", old_state, state); +} + +static void update_battery_low_level(void) +{ + if(g_battery_level < g_battery_shutdown_level) + set_set_battery_level_low(2); + else if(g_battery_level < g_battery_low_level) + set_set_battery_level_low(1); + else + set_set_battery_level_low(0); +} +/* +void android_power_set_battery_level(int level) +{ + int ret; + int old_level; + int scale; + unsigned long irqflags; + + spin_lock_irqsave(&g_list_lock, irqflags); + old_level = g_battery_level; + g_battery_level = level; + scale = g_battery_level_scale; + spin_unlock_irqrestore(&g_list_lock, irqflags); + if(level != old_level) { + //printk("android_power_set_battery_level raw %d -> %d\n", old_level, level); + } + if(scale_battery_level(level, scale) != scale_battery_level(old_level, scale)) { + printk("android_power_set_battery_level scaled %d -> %d (scale %d)\n", scale_battery_level(old_level, scale), scale_battery_level(level, scale), scale); + } +} +*/ +void android_power_set_charging_state(android_charging_state_t state) +{ + int ret; + android_charging_state_t old_state; + old_state = g_charging_state; + if(old_state == state) + return; + g_charging_state = state; + + printk("android_power_set_charging_state %d > %d\n", old_state, state); +} + #if 0 // test code when there is no platform suspend diff --git a/drivers/i2c/busses/i2c-msm.c b/drivers/i2c/busses/i2c-msm.c index 663a0ff..5113f53 100644 --- a/drivers/i2c/busses/i2c-msm.c +++ b/drivers/i2c/busses/i2c-msm.c @@ -31,11 +31,11 @@ #define DEBUG 0 enum { - I2C_WRITE_DATA = 0x00, - I2C_CLK_CTL = 0x04, - I2C_STATUS = 0x08, - I2C_READ_DATA = 0x0c, - I2C_INTERFACE_SELECT = 0x10, + I2C_WRITE_DATA = 0x100, + I2C_CLK_CTL = 0x104, + I2C_STATUS = 0x108, + I2C_READ_DATA = 0x10c, + I2C_INTERFACE_SELECT = 0x110, I2C_WRITE_DATA_DATA_BYTE = 0xff, I2C_WRITE_DATA_ADDR_BYTE = 1U << 8, @@ -64,7 +64,7 @@ struct msm_i2c_dev { struct device *dev; void __iomem *base; /* virtual */ int irq; - struct clk *clk; +// struct clk *clk; struct i2c_adapter adapter; spinlock_t lock; @@ -340,7 +340,7 @@ msm_i2c_probe(struct platform_device *pdev) int i2c_clk; int clk_ctl; int target_clk; - struct clk *clk; +// struct clk *clk; printk(KERN_INFO "msm_i2c_probe\n"); @@ -362,12 +362,15 @@ msm_i2c_probe(struct platform_device *pdev) dev_err(&pdev->dev, "I2C region already claimed\n"); return -EBUSY; } + writel((1U << 11) | (1U << 9), MSM_CLK_CTL_BASE + 0x64); // was 0x68 thanks cr2 +/* clk = clk_get(&pdev->dev, "i2c_clk"); if (IS_ERR(clk)) { dev_err(&pdev->dev, "Could not get clock\n"); ret = PTR_ERR(clk); goto err_clk_get_failed; } +*/ dev = kzalloc(sizeof(struct msm_i2c_dev), GFP_KERNEL); if (!dev) { @@ -377,12 +380,12 @@ msm_i2c_probe(struct platform_device *pdev) dev->dev = &pdev->dev; dev->irq = irq->start; - dev->clk = clk; +// dev->clk = clk; dev->base = (void __iomem *)(size_t)mem->start; spin_lock_init(&dev->lock); platform_set_drvdata(pdev, dev); - clk_enable(clk); +// clk_enable(clk); /* I2C_HS_CLK = I2C_CLK/(3*(HS_DIVIDER_VALUE+1) */ /* I2C_FS_CLK = I2C_CLK/(2*(FS_DIVIDER_VALUE+3) */ @@ -422,10 +425,10 @@ msm_i2c_probe(struct platform_device *pdev) err_request_irq_failed: i2c_del_adapter(&dev->adapter); err_i2c_add_adapter_failed: - clk_disable(clk); +// clk_disable(clk); kfree(dev); err_alloc_dev_failed: - clk_put(clk); +// clk_put(clk); err_clk_get_failed: release_mem_region(mem->start, (mem->end - mem->start) + 1); return ret; @@ -440,8 +443,8 @@ msm_i2c_remove(struct platform_device *pdev) platform_set_drvdata(pdev, NULL); free_irq(dev->irq, dev); i2c_del_adapter(&dev->adapter); - clk_disable(dev->clk); - clk_put(dev->clk); +// clk_disable(dev->clk); +// clk_put(dev->clk); kfree(dev); mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); release_mem_region(mem->start, (mem->end - mem->start) + 1); @@ -451,16 +454,16 @@ msm_i2c_remove(struct platform_device *pdev) static int msm_i2c_suspend(struct platform_device *pdev, pm_message_t state) { struct msm_i2c_dev *dev = platform_get_drvdata(pdev); - if (dev) - clk_disable(dev->clk); +// if (dev) +// clk_disable(dev->clk); return 0; } static int msm_i2c_resume(struct platform_device *pdev) { struct msm_i2c_dev *dev = platform_get_drvdata(pdev); - if (dev) - clk_enable(dev->clk); +// if (dev) +// clk_enable(dev->clk); return 0; } diff --git a/drivers/input/misc/gpio_input.c b/drivers/input/misc/gpio_input.c index 423714c..7712b1d 100644 --- a/drivers/input/misc/gpio_input.c +++ b/drivers/input/misc/gpio_input.c @@ -132,8 +132,8 @@ static enum hrtimer_restart gpio_event_input_timer_func(struct hrtimer *timer) hrtimer_start(timer, ds->info->poll_time, HRTIMER_MODE_REL); } #ifdef CONFIG_ANDROID_POWER - else - android_unlock_suspend(&ds->suspend_lock); + // else + // android_unlock_suspend(&ds->suspend_lock); #endif return HRTIMER_NORESTART; @@ -152,7 +152,7 @@ static irqreturn_t gpio_event_input_irq_handler(int irq, void *dev_id) ks->debounce_state = GPIO_KEY_DEBOUNCE_STATE_UNSTABLE; if (atomic_inc_return(&ds->debounce_active_count) == 1) { #ifdef CONFIG_ANDROID_POWER - android_lock_suspend(&ds->suspend_lock); + // android_lock_suspend(&ds->suspend_lock); #endif hrtimer_start(&ds->timer, ds->info->debounce_time, HRTIMER_MODE_REL); } @@ -188,6 +188,7 @@ static int gpio_event_input_request_irqs(struct gpio_input_state *ds) } disable_irq(irq); enable_irq_wake(irq); + //disable_irq_wake(irq); } local_irq_restore(irq_flags); return 0; diff --git a/drivers/mfd/Kconfig b/drivers/mfd/Kconfig index 0c886c8..1c6a79f 100644 --- a/drivers/mfd/Kconfig +++ b/drivers/mfd/Kconfig @@ -22,6 +22,29 @@ config MFD_ASIC3 This driver supports the ASIC3 multifunction chip found on many PDAs (mainly iPAQ and HTC based ones) +config MFD_ASIC3 + bool "Support for Compaq ASIC3" + depends on GENERIC_HARDIRQS && ARM + ---help--- + This driver supports the ASIC3 multifunction chip found on many + PDAs (mainly iPAQ and HTC based ones) + +config HTC_EGPIO + bool "HTC EGPIO support" + depends on GENERIC_HARDIRQS + help + This driver supports the CPLD egpio chip present on + several HTC phones. It provides basic support for input + pins, output pins, and irqs. + +config HTC_PASIC3 + tristate "HTC PASIC3 LED/DS1WM chip support" + help + This core driver provides register access for the LED/DS1WM + chips labeled "AIC2" and "AIC3", found on HTC Blueangel and + HTC Magician devices, respectively. Actual functionality is + handled by the leds-pasic3 and ds1wm drivers. + endmenu menu "Multimedia Capabilities Port drivers" diff --git a/drivers/mmc/card/block.c b/drivers/mmc/card/block.c index 0e88e82..ef34746 100644 --- a/drivers/mmc/card/block.c +++ b/drivers/mmc/card/block.c @@ -650,7 +650,7 @@ static int __init mmc_blk_init(void) { int res = -ENOMEM; - mmcblk_dbg_logenable = 1; +// mmcblk_dbg_logenable = 1; res = register_blkdev(MMC_BLOCK_MAJOR, "mmc"); if (res) diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c index b898b82..6a84c83 100644 --- a/drivers/mmc/core/core.c +++ b/drivers/mmc/core/core.c @@ -157,14 +157,12 @@ mmc_start_request(struct mmc_host *host, struct mmc_request *mrq) BUG_ON(mrq->data->blocks > host->max_blk_count); BUG_ON(mrq->data->blocks * mrq->data->blksz > host->max_req_size); - #ifdef CONFIG_MMC_DEBUG sz = 0; for (i = 0;i < mrq->data->sg_len;i++) sz += mrq->data->sg[i].length; BUG_ON(sz != mrq->data->blocks * mrq->data->blksz); #endif - mrq->cmd->data = mrq->data; mrq->data->error = 0; mrq->data->mrq = mrq; diff --git a/drivers/mmc/host/msm_sdcc.c b/drivers/mmc/host/msm_sdcc.c index 482d8f4..9786080 100644 --- a/drivers/mmc/host/msm_sdcc.c +++ b/drivers/mmc/host/msm_sdcc.c @@ -458,7 +458,7 @@ msmsdcc_start_command(struct msmsdcc_host *host, struct mmc_command *cmd, u32 c) c |= MCI_CSPM_MCIABORT; host->cmd = cmd; - + writel(cmd->arg, base + MMCIARGUMENT); writel(c, base + MMCICOMMAND); } @@ -499,9 +499,10 @@ msmsdcc_irq(int irq, void *dev_id) void __iomem *base = host->base; u32 status; int ret = 0; - spin_lock(&host->lock); + udelay(200); // this is horrible but it won't work without it.. MJ! + do { struct mmc_command *cmd; struct mmc_data *data; @@ -841,6 +842,7 @@ msmsdcc_do_polling_request(struct msmsdcc_host *host, struct mmc_request *mrq) uint32_t status; int rc; + // while(readl(host->base + MMCISTATUS) & 0x018007FF) writel(0x018007FF, host->base + MMCICLEAR); msmsdcc_start_command(host, cmd, 0); @@ -971,6 +973,7 @@ msmsdcc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios) clk |= (1 << 12); /* FLOW_ENA */ clk |= (1 << 15); /* feedback clock */ + if (host->plat->translate_vdd) pwr |= host->plat->translate_vdd(mmc_dev(mmc), ios->vdd); @@ -988,9 +991,7 @@ msmsdcc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios) if (ios->bus_mode == MMC_BUSMODE_OPENDRAIN) pwr |= MCI_OD; - writel(clk, host->base + MMCICLOCK); - if (host->pwr != pwr) { host->pwr = pwr; writel(pwr, host->base + MMCIPOWER); @@ -1178,6 +1179,7 @@ msmsdcc_probe(struct platform_device *pdev) host->irqres = irqres; host->memres = memres; host->dmares = dmares; + host->eject = 0; spin_lock_init(&host->lock); #ifdef CONFIG_MMC_EMBEDDED_SDIO @@ -1247,8 +1249,8 @@ msmsdcc_probe(struct platform_device *pdev) mmc->max_phys_segs = NR_SG; mmc->max_hw_segs = NR_SG; - mmc->max_blk_size = 4096; /* MCI_DATA_CTL BLOCKSIZE up to 4096 */ - mmc->max_blk_count = 65536; + mmc->max_blk_size = 512; /* MCI_DATA_CTL BLOCKSIZE up to 4096 */ + mmc->max_blk_count = 127;//65536; mmc->max_req_size = 33554432; /* MCI_DATA_LENGTH is 25 bits */ mmc->max_seg_size = mmc->max_req_size; @@ -1264,6 +1266,7 @@ msmsdcc_probe(struct platform_device *pdev) memset(&host->timer, 0, sizeof(host->timer)); + if (plat->status_irq) { ret = request_irq(plat->status_irq, msmsdcc_platform_status_irq, diff --git a/drivers/rtc/Kconfig b/drivers/rtc/Kconfig index 7bdf26f..336dc73 100644 --- a/drivers/rtc/Kconfig +++ b/drivers/rtc/Kconfig @@ -547,6 +547,12 @@ config RTC_DRV_MSM7X00A tristate "MSM7X00A" depends on RTC_CLASS help + RTC driver for Qualcomm MSM7KA chipsets + +config RTC_DRV_MSM7X00 + tristate "MSM7X00" + depends on RTC_CLASS + help RTC driver for Qualcomm MSM7K chipsets endif # RTC_CLASS diff --git a/drivers/rtc/Makefile b/drivers/rtc/Makefile index 416014b..59ce7a6 100644 --- a/drivers/rtc/Makefile +++ b/drivers/rtc/Makefile @@ -56,3 +56,4 @@ obj-$(CONFIG_RTC_DRV_V3020) += rtc-v3020.o obj-$(CONFIG_RTC_DRV_VR41XX) += rtc-vr41xx.o obj-$(CONFIG_RTC_DRV_X1205) += rtc-x1205.o obj-$(CONFIG_RTC_DRV_MSM7X00A) += rtc-msm7x00a.o +obj-$(CONFIG_RTC_DRV_MSM7X00) += rtc-msm7x00.o diff --git a/drivers/video/msm/mddi.c b/drivers/video/msm/mddi.c index e4a2631..f5f7621 100644 --- a/drivers/video/msm/mddi.c +++ b/drivers/video/msm/mddi.c @@ -388,7 +388,7 @@ static void mddi_init_registers(struct mddi_info *mddi) mddi_writel(MDDI_HOST_TA2_LEN, TA2_LEN); mddi_writel(0x0096, DRIVE_HI); /* 0x32 normal, 0x50 for Toshiba display */ - mddi_writel(0x0050, DRIVE_LO); + mddi_writel(0x0032, DRIVE_LO); mddi_writel(0x003C, DISP_WAKE); /* wakeup counter */ mddi_writel(MDDI_HOST_REV_RATE_DIV, REV_RATE_DIV); @@ -509,6 +509,7 @@ static int __init mddi_init(struct mddi_info *mddi, const char *name, if (pd->has_vsync_irq) mddi->flags |= FLAG_HAS_VSYNC_IRQ; } +/* mddi->clk = clk_get(&mddi->panel_pdev.dev, clk_name); if (IS_ERR(mddi->clk)) { ret = PTR_ERR(mddi->clk); @@ -523,7 +524,7 @@ static int __init mddi_init(struct mddi_info *mddi, const char *name, mddi->clk_rate, clk_get_rate(mddi->clk)); goto fail0; } - +*/ dma = dma_alloc_coherent(NULL, 0x1000, &dma_addr, GFP_KERNEL); if (dma == 0) { ret = -ENOMEM; @@ -565,8 +566,8 @@ static int __init mddi_init(struct mddi_info *mddi, const char *name, if (mddi->version < 0x20) { printk(KERN_INFO "%s: unsupported version 0x%x\n", mddi->name, mddi->version); - ret = -ENODEV; - goto fail2; +// ret = -ENODEV; +// goto fail2; } /* clear any stale interrupts */ @@ -664,7 +665,7 @@ fail2: fail1: dma_free_coherent(NULL, 0x1000, dma, dma_addr); fail0: - clk_put(mddi->clk); +// clk_put(mddi->clk); fail: printk(KERN_INFO "%s: mddi_init() failed (%d)\n", name, ret); return ret; @@ -731,7 +732,8 @@ void mddi_remote_write(struct mddi_info *mddi, unsigned val, unsigned reg) ll->data_count = 4; ll->data = mddi->reg_write_addr + offsetof(struct mddi_llentry, u.r.register_data_list); - ll->next = 0; +// ll->next = 0; + ll->next = (ll->data)>>16; // different on 7x00 ll->reserved = 0; /* s = mddi_readl(STAT); */ @@ -873,6 +875,7 @@ static int __init mddi_probe(struct platform_device *pdev) { struct msm_mddi_platform_data *pd = pdev->dev.platform_data; + printk("mddi_probe"); switch (pdev->id) { case 0: return mddi_init(&mddi_pmdh, "mddi_pmdh", "pmdh_clk", @@ -924,6 +927,7 @@ static struct platform_driver mddi_driver = { static int __init _mddi_init(void) { + printk("mddi init"); return platform_driver_register(&mddi_driver); } diff --git a/drivers/video/msm/mddi_client_toshiba.c b/drivers/video/msm/mddi_client_toshiba.c index 268ed76..3e82daf 100644 --- a/drivers/video/msm/mddi_client_toshiba.c +++ b/drivers/video/msm/mddi_client_toshiba.c @@ -24,7 +24,6 @@ static DECLARE_WAIT_QUEUE_HEAD(toshiba_vsync_wait); static volatile int toshiba_got_int; -static struct msmfb_callback *toshiba_callback; static void dummy_function(struct mddi_panel_info *panel) { @@ -57,17 +56,6 @@ static void dummy_function(struct mddi_panel_info *panel) #define GPIOSEL (BASE7 + 0x00) #define GPIOSEL_VWAKEINT (1U << 0) -static void toshiba_request_vsync(struct mddi_panel_info *pi, - struct msmfb_callback *callback) -{ - toshiba_callback = callback; - - if (toshiba_got_int) { - toshiba_got_int = 0; - mddi_activate_link(pi->mddi); /* clears interrupt */ - } -} - static void toshiba_wait_vsync(struct mddi_panel_info *pi) { if (toshiba_got_int) { @@ -84,17 +72,13 @@ static void toshiba_wait_vsync(struct mddi_panel_info *pi) static struct mddi_panel_ops toshiba_panel_ops = { .enable = dummy_function, .disable = dummy_function, - .wait_vsync = toshiba_wait_vsync, - .request_vsync = toshiba_request_vsync + .wait_vsync = toshiba_wait_vsync }; -irqreturn_t toshiba_vsync_interrupt(int irq, void *data) +irqreturn_t toshiba_vsync_interrupt(int irq, void *_mddi) { + /* struct mddi_info *mddi = _mddi; */ toshiba_got_int = 1; - if (toshiba_callback) { - toshiba_callback->func(toshiba_callback); - toshiba_callback = 0; - } wake_up(&toshiba_vsync_wait); return IRQ_HANDLED; } @@ -122,8 +106,7 @@ static int mddi_toshiba_setup_vsync(struct mddi_info *mddi, int init) if (ret < 0) goto err_get_irq_num_failed; - ret = request_irq(irq, toshiba_vsync_interrupt, IRQF_TRIGGER_RISING, - "vsync", NULL); + ret = request_irq(irq, toshiba_vsync_interrupt, IRQF_TRIGGER_RISING, "vsync", mddi); if (ret) goto err_request_irq_failed; printk(KERN_INFO "vsync on gpio %d now %d\n", diff --git a/drivers/video/msm/msm_fb.c b/drivers/video/msm/msm_fb.c index d6764cc..1d950de 100644 --- a/drivers/video/msm/msm_fb.c +++ b/drivers/video/msm/msm_fb.c @@ -28,6 +28,7 @@ #include #include #include +#include #include #include #include @@ -93,6 +94,7 @@ struct msmfb_info { struct msmfb_callback vsync_callback; struct hrtimer fake_vsync; }; +short *msm_display_base=0; static int msmfb_open(struct fb_info *info, int user) { @@ -139,12 +141,17 @@ static void msmfb_handle_dma_interrupt(struct msmfb_callback *callback) wake_up(&par->frame_wq); } +extern msm_copy_keyboard(short *c,int i); + +int lasty=0; +int lasty1=0; static int msmfb_start_dma(struct msmfb_info *par) { uint32_t x, y, w, h; unsigned addr; unsigned long irq_flags; uint32_t yoffset; + struct mddi_panel_info *pi = par->panel_info; spin_lock_irqsave(&par->update_lock, irq_flags); @@ -168,10 +175,31 @@ static int msmfb_start_dma(struct msmfb_info *par) goto error; } spin_unlock_irqrestore(&par->update_lock, irq_flags); + if(onscreen_keyboard==1) { + y=(y+h-85); + if(y>(319-85)) + y=319-85; + if((y!=lasty) && (lasty==lasty1)) { + lasty1=y; + y=lasty; + lasty=y; + } else { + lasty1=lasty; + lasty=y; + } + msm_copy_keyboard(240*par->yoffset + msm_display_base,y); + + addr=480*320*2 + par->fb_info->fix.smem_start; + } + else addr=480*par->yoffset + par->fb_info->fix.smem_start; + mdp_dma_to_mddi(addr, + 480,240,320,0,0, &par->dma_callback); +/* addr = ((pi->width * (yoffset + y) + x) * 2); mdp_dma_to_mddi(addr + par->fb_info->fix.smem_start, pi->width * 2, w, h, x, y, &par->dma_callback); +*/ return 0; error: spin_unlock_irqrestore(&par->update_lock, irq_flags); @@ -197,6 +225,7 @@ static enum hrtimer_restart msmfb_fake_vsync(struct hrtimer *timer) msmfb_start_dma(par); return HRTIMER_NORESTART; } +struct fb_info *msm_info=0; static void msmfb_pan_update(struct fb_info *info, uint32_t left, uint32_t top, uint32_t eright, uint32_t ebottom, uint32_t yoffset, @@ -204,6 +233,7 @@ static void msmfb_pan_update(struct fb_info *info, uint32_t left, uint32_t top, { struct msmfb_info *par = info->par; struct mddi_panel_info *pi = par->panel_info; + unsigned long irq_flags; int sleeping; #if PRINT_FPS @@ -310,7 +340,13 @@ restart: static void msmfb_update(struct fb_info *info, uint32_t left, uint32_t top, uint32_t eright, uint32_t ebottom) { + msm_info=info; msmfb_pan_update(info, left, top, eright, ebottom, 0, 0); +//msmfb_pan_update(info, 0, 0, 240, 320, 0, 0); +} +void msm_update_screen(void) { + if(msm_info) + msmfb_update(msm_info,0,0,240,320); } static void power_on_panel(struct work_struct *work) @@ -567,6 +603,8 @@ static int msmfb_probe(struct platform_device *pdev) fbram = ioremap(pi->fb_base, pi->fb_size); + msm_display_base= (short *)fbram; + if (fbram == 0) { printk(KERN_ERR "cannot allocate fbram!\n"); return -ENOMEM; diff --git a/include/asm-arm/arch-msm/entry-macro.S b/include/asm-arm/arch-msm/entry-macro.S index ee24aec..1340e09 100644 --- a/include/asm-arm/arch-msm/entry-macro.S +++ b/include/asm-arm/arch-msm/entry-macro.S @@ -29,10 +29,34 @@ .endm .macro get_irqnr_and_base, irqnr, irqstat, base, tmp - @ 0xD0 has irq# or old irq# if the irq has been handled - @ 0xD4 has irq# or -1 if none pending *but* if you just - @ read 0xD4 you never get the first irq for some reason - ldr \irqnr, [\base, #0xD0] - ldr \irqnr, [\base, #0xD4] - cmp \irqnr, #0xffffffff + ldr \irqstat, [\base] @ NOTIFY0 + ldr \irqnr, [\base, #0x10] @ Real value so only trigger on rising (i think) +@ eor \irqnr,\irqnr,#0x01000000 @ For negative triggering of SD1 + ands \irqstat, \irqstat, \irqnr + movne \irqnr, #0 + bne 1001f + ldr \irqstat, [\base,#4] @ NOTIFY1 + movs \irqnr, \irqstat + beq 1002f + mov \irqnr, #32 +1001: + tst \irqstat, #0xff + moveq \irqstat, \irqstat, lsr #8 + addeq \irqnr, \irqnr, #8 + tsteq \irqstat, #0xff + moveq \irqstat, \irqstat, lsr #8 + addeq \irqnr, \irqnr, #8 + tsteq \irqstat, #0xff + moveq \irqstat, \irqstat, lsr #8 + addeq \irqnr, \irqnr, #8 + tst \irqstat, #0x0f + moveq \irqstat, \irqstat, lsr #4 + addeq \irqnr, \irqnr, #4 + tst \irqstat, #0x03 + moveq \irqstat, \irqstat, lsr #2 + addeq \irqnr, \irqnr, #2 + tst \irqstat, #0x01 + addeqs \irqnr, \irqnr, #1 +1002: + .endm diff --git a/include/asm-arm/arch-msm/msm_iomap.h b/include/asm-arm/arch-msm/msm_iomap.h index b41389f..1a8243f 100644 --- a/include/asm-arm/arch-msm/msm_iomap.h +++ b/include/asm-arm/arch-msm/msm_iomap.h @@ -78,8 +78,8 @@ #define MSM_GPIO2_SIZE SZ_4K #define MSM_HSUSB_BASE 0xE0009000 -#define MSM_HSUSB_PHYS 0xA0800000 -#define MSM_HSUSB_SIZE SZ_4K +#define MSM_HSUSB_PHYS 0xA9800000 +#define MSM_HSUSB_SIZE SZ_1M #define MSM_CLK_CTL_BASE 0xE000A000 #define MSM_CLK_CTL_PHYS 0xA8600000 @@ -106,11 +106,11 @@ #define MSM_AD5_SIZE (SZ_1M*13) #define MSM_SDC1_BASE 0xE1000000 -#define MSM_SDC1_PHYS 0xA0400000 +#define MSM_SDC1_PHYS 0xA0300000 #define MSM_SDC1_SIZE SZ_4K #define MSM_SDC2_BASE 0xE1001000 -#define MSM_SDC2_PHYS 0xA0500000 +#define MSM_SDC2_PHYS 0xA0400000 #define MSM_SDC2_SIZE SZ_4K #define MSM_SDC3_BASE 0xE1002000 diff --git a/include/asm-arm/arch-msm/msm_rpcrouter.h b/include/asm-arm/arch-msm/msm_rpcrouter.h index 8f53d2d..c7ddefc 100644 --- a/include/asm-arm/arch-msm/msm_rpcrouter.h +++ b/include/asm-arm/arch-msm/msm_rpcrouter.h @@ -102,10 +102,14 @@ struct msm_rpc_endpoint *msm_rpc_open(void); struct msm_rpc_endpoint *msm_rpc_connect(uint32_t prog, uint32_t vers, unsigned flags); int msm_rpc_close(struct msm_rpc_endpoint *ept); -int msm_rpc_write(struct msm_rpc_endpoint *ept, +int msm_rpc_write_command( void *data, int len); -int msm_rpc_read(struct msm_rpc_endpoint *ept, - void **data, unsigned len, long timeout); +int msm_rpc_write_reply( + void *data, int len); +int msm_rpc_read_reply( + void *data, unsigned len ); +int msm_rpc_read_command( + void *data, unsigned len ); void msm_rpc_setup_req(struct rpc_request_hdr *hdr, uint32_t prog, uint32_t vers, uint32_t proc); int msm_rpc_register_server(struct msm_rpc_endpoint *ept, @@ -120,12 +124,12 @@ int msm_rpc_unregister_server(struct msm_rpc_endpoint *ept, * * reply provides a buffer for replies of reply_max_size */ -int msm_rpc_call_reply(struct msm_rpc_endpoint *ept, uint32_t proc, - void *request, int request_size, - void *reply, int reply_max_size, +int msm_rpc_call_reply( uint32_t proc,uint32_t prog, + struct rpc_request_hdr *req, int request_size, + struct rpc_reply_hdr *reply, int reply_max_size, long timeout); -int msm_rpc_call(struct msm_rpc_endpoint *ept, uint32_t proc, - void *request, int request_size, +int msm_rpc_call( uint32_t proc, uint32_t prog, + struct rpc_request_hdr *req, int request_size, long timeout); struct msm_rpc_server diff --git a/include/asm-arm/arch-msm/msm_smd.h b/include/asm-arm/arch-msm/msm_smd.h index bdf7731..6542e11 100644 --- a/include/asm-arm/arch-msm/msm_smd.h +++ b/include/asm-arm/arch-msm/msm_smd.h @@ -20,7 +20,7 @@ typedef struct smd_channel smd_channel_t; /* warning: notify() may be called before open returns */ -int smd_open(const char *name, smd_channel_t **ch, void *priv, +int smd_open(int id,/*const char *name,*/ smd_channel_t **ch, void *priv, void (*notify)(void *priv, unsigned event)); #define SMD_EVENT_DATA 1 diff --git a/include/asm-arm/arch-msm/uncompress.h b/include/asm-arm/arch-msm/uncompress.h index c511878..1499a92 100644 --- a/include/asm-arm/arch-msm/uncompress.h +++ b/include/asm-arm/arch-msm/uncompress.h @@ -19,16 +19,123 @@ #include #include +#include +#include "../drivers/video/console/font_mini_4x6.c" +//#include +//#include +//#include -static void putc(int c) +#define MSM_FB_PHYS 0x00000000 +#define MSM_FB_BASE 0xea000000 + +//#ifdef CONFIG_VOGUE_PRINTK +void msm_display(void) { + volatile unsigned *BYPASS33=(volatile unsigned *)(MSM_MDP_BASE+0x10184); + volatile unsigned *BYPASS34=(volatile unsigned *)(MSM_MDP_BASE+0x10188); + volatile unsigned *BYPASS35=(volatile unsigned *)(MSM_MDP_BASE+0x1018c); + volatile unsigned *BYPASS37=(volatile unsigned *)(MSM_MDP_BASE+0x10194); + volatile unsigned *BYPASS40=(volatile unsigned *)(MSM_MDP_BASE+0x101a0); + volatile unsigned *BYPASS41=(volatile unsigned *)(MSM_MDP_BASE+0x101a4); + volatile unsigned *DMACONFIG=(volatile unsigned *)(MSM_MDP_BASE+0x10180); + volatile unsigned *VSYNC=(volatile unsigned *)(MSM_MDP_BASE+0x0008c); + volatile unsigned *DMASTART=(volatile unsigned *)(MSM_MDP_BASE+0x10044); + volatile unsigned *INTSTATUS=(volatile unsigned *)(MSM_MDP_BASE+0x00024); + volatile unsigned *INTCLEAR=(volatile unsigned *)(MSM_MDP_BASE+0x00028); + + while (*INTSTATUS) + *INTCLEAR=*INTSTATUS; + *BYPASS33=0x014000f0; + *BYPASS34=MSM_FB_PHYS; + *BYPASS35=0x000001e0; + *BYPASS37=0; + *BYPASS40=0; + *BYPASS41=0x566600c3; + *DMACONFIG=0x0032616a; + *VSYNC=0; + *DMASTART=0; + while((*INTSTATUS)==0); + while(*INTSTATUS) + *INTCLEAR=*INTSTATUS; + + // while((MSMGPIO1[0xc20/4]&(1<<17))==0); +} +extern int MSMCONFIGURED; + +static int msmx=0,msmy=0; +static void putc(int ch) { -#if defined(MSM_DEBUG_UART_PHYS) - unsigned base = MSM_DEBUG_UART_PHYS; - while (!(readl(base + 0x08) & 0x04)) ; - writel(c, base + 0x0c); -#endif + /* + int x,y; + unsigned char c; + unsigned char* VIDBUF=(unsigned char*)MSM_FB_BASE; + unsigned *pgdir; + unsigned cr; + unsigned char *font=(char *)(font_mini_4x6.data); + spin_lock_irqsave(); + + asm("mrc p15, 0, %0, c1, c0, 0\n" : "=r" (cr)); + + if((cr&1)==0) return; // mmu is off + + asm("mrc p15, 0, %0, c2, c0, 0\n" : "=r" (pgdir)); + + pgdir=(unsigned *)((unsigned)pgdir&0xfffff000); + + pgdir[(unsigned)MSM_MDP_BASE>>20]=MSM_MDP_PHYS+0x2c02; + pgdir[(unsigned)MSM_FB_BASE>>20]=MSM_FB_PHYS+0xc02; + + + asm volatile (" mcr p15, 0, %0, c7, c14, 0\n\ + mcr p15, 0, %0, c7, c5, 0\n\ + mcr p15, 0, %0, c7, c15, 0\n\ + mcr p15, 0, %0, c7, c10, 4\n\ + mcr p15, 0, %0, c7, c5, 4\n\ + "::"r"(0)); + + + if(msmx==0 && msmy==0) { + memset((char *)VIDBUF,0,240*320*2); + // msm_display(); + } + + if(ch>31) { + for(y=0;y<6;y++) { + c=font[((ch & 0xff)*6)+y]; + for(x=0;x<4;x++) { + if((c&0x8)==0x8) { + VIDBUF[(msmx+x)*2+(msmy+y)*480]=255; + VIDBUF[(msmx+x)*2+(msmy+y)*480+1]=255; + } + else { + VIDBUF[(msmx+x)*2+(msmy+y)*480]=0; + VIDBUF[(msmx+x)*2+(msmy+y)*480+1]=0; + } + c=c<<1; + } + } + } + msmx+=4; + if(msmx==240 || ch==10) { + msmx=0; + msmy+=6; + if(msmy==318) { + msmy=312; + memcpy((char *)VIDBUF,(char *)VIDBUF+240*2*6,240*2*312); + memset((char *)VIDBUF+240*2*312,0,240*6*2); + } + } + if(ch=='.') + msm_display(); + */ } +/* +#else + +static void putc(int i) { +} +#endif +*/ static inline void flush(void) { }