/* LCD 调试等级， * 0只打印错误， * 1打印错误和警告， * 2全部内容都调试内容打印 */ #define SPI_LCD_DEBUG_ENABLE 0 #include "includes.h" #include "app_config.h" #include "ui/ui_api.h" #include "system/includes.h" #include "system/timer.h" #include "asm/spi.h" #include "clock_cfg.h" #include "asm/mcpwm.h" #if (TCFG_UI_ENABLE && (TCFG_SPI_LCD_ENABLE || TCFG_SIMPLE_LCD_ENABLE)) #include "ui/ui_sys_param.h" /* 选择SPIx模块作为推屏通道，0、1、2 */ /* 但SPI0通常作为外部falsh使用，一般不用SPI0 */ #define SPI_MODULE_CHOOSE TCFG_TFT_LCD_DEV_SPI_HW_NUM /* 中断使能，一般推屏不需要 */ #ifndef LCD_SPI_INTERRUPT_ENABLE #define LCD_SPI_INTERRUPT_ENABLE 1 #endif #if LCD_SPI_INTERRUPT_ENABLE #if SPI_MODULE_CHOOSE == 0 #define IRQ_SPI_IDX IRQ_SPI0_IDX #elif SPI_MODULE_CHOOSE == 1 #define IRQ_SPI_IDX IRQ_SPI1_IDX #elif SPI_MODULE_CHOOSE == 2 #define IRQ_SPI_IDX IRQ_SPI2_IDX #else #error "error! SPI_MODULE_CHOOSE defien error!" #endif #endif int clk_get(const char *name); int clk_set(const char *name, int clk); void spi_clear_pending(spi_dev spi); u8 spi_get_pending(spi_dev spi); void spi_dma_set_addr_for_isr(spi_dev spi, void *buf, u32 len, u8 rw);; void spi_dma_wait_finish(); void wdt_clear(); static int __lcd_backlight_ctrl(u8 on); /* 屏幕驱动的接口 */ extern struct spi_lcd_init dev_drive; struct lcd_spi_platform_data *spi_dat = NULL; static int spi_pnd = false; static u8 backlight_status = 0; static u8 lcd_sleep_in = 0; static volatile u8 is_lcd_busy = 0; #define __this (&dev_drive) #if LCD_SPI_INTERRUPT_ENABLE /* SPI中断函数 */ // 注：dma模式在发送数据时内部已经清理中断pnd __attribute__((interrupt(""))) static void spi_isr() { if (spi_get_pending(spi_dat->spi_cfg)) { /* printf("spi_isr\n"); */ /* spi_clear_pending(spi_dat->spi_cfg); */ if (is_lcd_busy) { is_lcd_busy = 0; } spi_set_ie(spi_dat->spi_cfg, 0); } } #endif static void clock_critical_enter() { } static void clock_critical_exit() { if (spi_dat && spi_dat->spi_cfg) { spi_set_baud(spi_dat->spi_cfg, spi_get_baud(spi_dat->spi_cfg)); } } CLOCK_CRITICAL_HANDLE_REG(spi_lcd, clock_critical_enter, clock_critical_exit); static void spi_init(int spi_cfg) { int err; // spi gpio init err = spi_open(spi_cfg); if (err < 0) { lcd_e("open spi falid\n"); } #if LCD_SPI_INTERRUPT_ENABLE // 配置中断优先级，中断函数 /* spi_set_ie(spi_cfg, 1); */ request_irq(IRQ_SPI_IDX, 3, spi_isr, 0); #endif } // io口操作 void lcd_reset_l() { gpio_direction_output((u32)spi_dat->pin_reset, 0); } void lcd_reset_h() { gpio_direction_output((u32)spi_dat->pin_reset, 1); } void lcd_cs_l() { gpio_direction_output((u32)spi_dat->pin_cs, 0); } void lcd_cs_h() { gpio_direction_output((u32)spi_dat->pin_cs, 1); } void lcd_rs_l() { gpio_direction_output((u32)spi_dat->pin_rs, 0); } void lcd_rs_h() { gpio_direction_output((u32)spi_dat->pin_rs, 1); } void lcd_bl_l() { gpio_direction_output((u32)spi_dat->pin_bl, 0); } void lcd_bl_h() { gpio_direction_output((u32)spi_dat->pin_bl, 1); } u8 lcd_bl_io() { return spi_dat->pin_bl; } void spi_dma_wait_finish() { if (spi_pnd) { while (!spi_get_pending(spi_dat->spi_cfg)) { /* delay(10); */ extern void wdt_clear(); wdt_clear(); } spi_clear_pending(spi_dat->spi_cfg); spi_pnd = false; } } int __spi_dma_send(spi_dev spi, void *buf, u32 len, u8 wait) { int err = 0; if (!wait || spi_pnd) { spi_dma_wait_finish(); } spi_dma_set_addr_for_isr(spi_dat->spi_cfg, buf, len, 0); spi_pnd = true; asm("csync"); if (wait) { spi_dma_wait_finish(); } return err; } void spi_dma_send_byte(u8 dat) { int err = 0; u32 _dat __attribute__((aligned(4))) = 0; ((u8 *)(&_dat))[0] = dat; if (spi_dat) { err = __spi_dma_send(spi_dat->spi_cfg, &_dat, 1, 1); } if (err < 0) { lcd_e("spi dma send byte timeout\n"); } } u8 lcd_spi_recv_byte() { int err; int ret; #if 0 ret = spi_recv_byte_for_isr(spi_dat->spi_cfg); asm("csync"); spi_pnd = true; spi_dma_wait_finish(); #else ret = spi_recv_byte(spi_dat->spi_cfg, &err); spi_pnd = false; #endif return ret; } int lcd_spi_send_byte(u8 byte) { int ret; #if 0 spi_send_byte_for_isr(spi_dat->spi_cfg, byte); asm("csync"); spi_pnd = true; spi_dma_wait_finish(); #else ret = spi_send_byte(spi_dat->spi_cfg, byte); spi_pnd = false; #endif return 0; } void lcd_spi_set_bit_mode(int mode) { spi_set_bit_mode(spi_dat->spi_cfg, mode); } void lcd_spi_dma_send_wait(u8 *map, u32 size) { int err = 0; if (spi_dat) { err = __spi_dma_send(spi_dat->spi_cfg, map, size, 1); } if (err < 0) { lcd_e("spi dma send map timeout\n"); } } void spi_dma_send_map(u8 *map, u32 size) { int err = 0; if (spi_dat) { err = __spi_dma_send(spi_dat->spi_cfg, map, size, 0); } if (err < 0) { lcd_e("spi dma send map timeout\n"); } } void spi_dma_recv_data(u8 *buf, u32 size) { int err = 0; if (spi_dat) { err = spi_dma_recv(spi_dat->spi_cfg, buf, size); } if (err < 0) { lcd_e("spi dma recv timeout\n"); } } static void spi_init_code(const InitCode *code, u8 cnt) { u8 i, j; for (i = 0; i < cnt; i++) { if (code[i].cmd == REGFLAG_DELAY) { extern void wdt_clear(void); wdt_clear(); delay2ms(code[i].cnt / 2); } else { __this->WriteComm(code[i].cmd); lcd_d("cmd:%x ", code[i].cmd); for (j = 0; j < code[i].cnt; j++) { __this->WriteData(code[i].dat[j]); lcd_d("%02x ", code[i].dat[j]); } lcd_d("\n"); } } } static void lcd_dev_init(void *p) { struct ui_devices_cfg *cfg = (struct ui_devices_cfg *)p; int err = 0; spi_dat = (struct lcd_spi_platform_data *)cfg->private_data; ASSERT(spi_dat, "Error! spi io not config"); printf("spi pin rest:%d, cs:%d, rs:%d, spi:%d\n", spi_dat->pin_reset, spi_dat->pin_cs, spi_dat->pin_rs, spi_dat->spi_cfg); if (spi_dat->pin_reset != -1) { gpio_direction_output((u32)spi_dat->pin_reset, 1); } gpio_direction_output((u32)spi_dat->pin_cs, 1); gpio_direction_output((u32)spi_dat->pin_rs, 1); if (!__this->soft_spi) { spi_init(spi_dat->spi_cfg); } if (__this->Reset) { // 如果有硬件复位 __this->Reset(); } if (__this->initcode && __this->initcode_cnt) { spi_init_code(__this->initcode, __this->initcode_cnt); // 初始化屏幕 } else if (__this->Init) { __this->Init(); } } static int lcd_init(void *p) { printf("lcd_init ...\n"); lcd_dev_init(p); return 0; } static int lcd_get_screen_info(struct lcd_info *info) { info->width = __this->lcd_width; info->height = __this->lcd_height; info->color_format = __this->color_format; info->interface = __this->interface; info->col_align = __this->column_addr_align; info->row_align = __this->row_addr_align; info->bl_status = backlight_status; ASSERT(info->col_align, " = 0, lcd driver column address align error, default value is 1"); ASSERT(info->row_align, " = 0, lcd driver row address align error, default value is 1"); return 0; } static int lcd_buffer_malloc(u8 **buf, u32 *size) { *buf = __this->dispbuf; *size = __this->bufsize; return 0; } static int lcd_buffer_free(u8 *buf) { return 0; } static int lcd_set_draw_area(u16 xs, u16 xe, u16 ys, u16 ye) { if ((is_lcd_busy == 0x11) || lcd_sleep_in) { return 0; } is_lcd_busy = 1; spi_set_ie(spi_dat->spi_cfg, 0); spi_dma_wait_finish(); __this->SetDrawArea(xs, xe, ys, ye); /* is_lcd_busy = 0; */ return 0; } static int lcd_draw(u8 *buf, u32 len, u8 wait) { if ((is_lcd_busy == 0x11) || lcd_sleep_in) { return 0; } /* is_lcd_busy = 1; */ /* int clk = clk_get("sys"); */ /* if (clk != 192000000) { */ /* clk_set("sys", 192000000L); */ /* } */ if (wait) { __this->WriteMap(buf, len); #if LCD_SPI_INTERRUPT_ENABLE spi_set_ie(spi_dat->spi_cfg, 1); #else is_lcd_busy = 0; #endif } else { __this->WriteMap(buf, len); is_lcd_busy = 0; } return 0; } static int lcd_draw_gage(u8 *buf, u8 page_star, u8 page_len) { if ((is_lcd_busy == 0x11) || lcd_sleep_in) { return 0; } __this->WritePAGE(buf, page_star, page_len); is_lcd_busy = 0; return 0; } static int lcd_clear_screen(u16 color) { int i; int buffer_lines; int remain; int draw_line; int y; if (__this->color_format == LCD_COLOR_RGB565) { buffer_lines = __this->bufsize / __this->lcd_width / 2; for (i = 0; i < buffer_lines * __this->lcd_width; i++) { __this->dispbuf[2 * i] = color >> 8; __this->dispbuf[2 * i + 1] = color; } y = 0; remain = __this->lcd_height; while (remain) { draw_line = buffer_lines > remain ? remain : buffer_lines; lcd_set_draw_area(0, __this->lcd_width - 1, y, y + draw_line - 1); lcd_draw(__this->dispbuf, draw_line * __this->lcd_width * 2, 0); remain -= draw_line; y += draw_line; } spi_dma_wait_finish(); } else if (__this->color_format == LCD_COLOR_MONO) { __this->SetDrawArea(0, -1, 0, -1); memset(__this->dispbuf, 0x00, __this->lcd_width * __this->lcd_height / 8); __this->WriteMap(__this->dispbuf, __this->lcd_width * __this->lcd_height / 8); } else { ASSERT(0, "the color_format %d not support yet!", __this->color_format); } return 0; } int lcd_backlight_ctrl(u8 on) { while (is_lcd_busy); is_lcd_busy = 0x11; __lcd_backlight_ctrl(on); is_lcd_busy = 0; return 0; } int lcd_sleep_ctrl(u8 enter) { if ((!!enter) == lcd_sleep_in) { return -1; } while (is_lcd_busy); is_lcd_busy = 0x11; if (enter) { if (__this->EnterSleep) { __this->EnterSleep(); } lcd_sleep_in = true; } else { if (__this->ExitSleep) { __this->ExitSleep(); } clock_add_set(LCD_UI_CLK); lcd_sleep_in = false; } is_lcd_busy = 0; return 0; } static int __lcd_backlight_ctrl(u8 on) { static u8 first_power_on = true; if (on) { #if (TCFG_SPI_LCD_ENABLE) on = get_backlight_brightness() & 0xff; #else on = 100; #endif } if (first_power_on) { backlight_status = true; lcd_clear_screen(0x0000); backlight_status = false; //os_time_dly(6); first_power_on = false; } if (__this->BackLightCtrl) { if (on) { clock_add_set(LCD_UI_CLK); if (__this->ExitSleep) { __this->ExitSleep(); } __this->BackLightCtrl(on); } else { __this->BackLightCtrl(false); if (__this->EnterSleep) { __this->EnterSleep(); } clock_remove_set(LCD_UI_CLK); } lcd_sleep_in = !!!on; backlight_status = on; } return 0; } int lcd_backlight_status() { return backlight_status; } struct lcd_interface *lcd_get_hdl() { struct lcd_interface *p; ASSERT(lcd_interface_begin != lcd_interface_end, "don't find lcd interface!"); for (p = lcd_interface_begin; p < lcd_interface_end; p++) { return p; } return NULL; } /* * 注意，MCPWM的输出IO可以是固定的硬件IO或者是映射到任何一个IO，但由于映射到非硬件IO需要占用一个OUTPUT_CHANNEL, * 因此建议设计是尽量使用带MCPWM输出的硬件IO。硬件IO一共有六组，分别是 * (IO_PORTA_00, IO_PORTA_01) * (IO_PORTB_00, IO_PORTB_02) * (IO_PORTB_04, IO_PORTB_06) * (IO_PORTB_09, IO_PORTB_10) * (IO_PORTA_09, IO_PORTA_10) * (IO_PORTC_04, IO_PORTC_05) * 上述五组分别对应ch0、ch1、ch2、ch3、ch4、ch5。使用对应硬件IO时，pwm_p_data.pwm_ch_num和pwm_p_data.pwm_timer_num需要改成对应的值， * 详细请参考mcpwm.c中的mcpwm_test */ struct pwm_platform_data lcd_pwm_p_data; void lcd_mcpwm_init() { extern void mcpwm_init(struct pwm_platform_data * arg); lcd_pwm_p_data.pwm_aligned_mode = pwm_edge_aligned; //边沿对齐 lcd_pwm_p_data.frequency = 10000; //KHz lcd_pwm_p_data.pwm_ch_num = pwm_ch0; //通道0 lcd_pwm_p_data.pwm_timer_num = pwm_timer0; //时基选择通道0 lcd_pwm_p_data.duty = 0; //占空比50% //hw lcd_pwm_p_data.h_pin = -1;//IO_PORTA_00; //没有则填 -1。h_pin_output_ch_num无效，可不配置 lcd_pwm_p_data.l_pin = lcd_bl_io();//TCFG_BACKLIGHT_PWM_IO; //硬件引脚，l_pin_output_ch_num无效，可不配置 //output_channel /* pwm_p_data.h_pin_output_ch_num = 0; //output channel0 非硬件PWM_IO时需要打开*/ lcd_pwm_p_data.l_pin_output_ch_num = 1; //output channel1 非硬件PWM_IO时需要打开 lcd_pwm_p_data.complementary_en = 1; //两个引脚的波形, 1: 互补, 0: 同步; mcpwm_init(&lcd_pwm_p_data); } REGISTER_LCD_INTERFACE(lcd) = { .init = lcd_init, .get_screen_info = lcd_get_screen_info, .buffer_malloc = lcd_buffer_malloc, .buffer_free = lcd_buffer_free, .draw = lcd_draw, .set_draw_area = lcd_set_draw_area, .clear_screen = lcd_clear_screen, .backlight_ctrl = __lcd_backlight_ctrl, .draw_page = lcd_draw_gage, }; static u8 lcd_idle_query(void) { return !is_lcd_busy; } REGISTER_LP_TARGET(lcd_lp_target) = { .name = "lcd", .is_idle = lcd_idle_query, }; #endif