IAmChrisAMA
/
iBoot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
iBoot/drivers/display/summit/summit.c

775 lines
22 KiB
C
Raw Permalink Blame History

/*
* Copyright (C) 2013 Apple Inc. All rights reserved.
*
* This document is the property of Apple Inc.
* It is considered confidential and proprietary.
*
* This document may not be reproduced or transmitted in any form,
* in whole or in part, without the express written permission of
* Apple Inc.
*/
#include <debug.h>
#include <drivers/display.h>
#include <drivers/mipi.h>
#include <drivers/power.h>
#include <platform/gpio.h>
#include <platform/gpiodef.h>
#include <lib/env.h>
#include <lib/paint.h>
#include <sys/task.h>
#include <target.h>
#ifdef WITH_HW_DISPLAY_PMU
#include <drivers/display_pmu.h>
#endif //WITH_HW_DISPLAY_PMU
#include "summit.h"
#define SUMMIT_DISABLE_DSI_PROTOCOL_ERROR_WA 1
static u_int32_t summit_panel_id;
static u_int32_t summit_dot_pitch;
static u_int32_t summit_default_color;
static u_int32_t summit_ldo_voltage;
static u_int32_t summit_boost_voltage;
static u_int32_t summit_backlight_cal;
static u_int8_t summit_raw_panel_id[15];
static uint32_t summit_sram_address[4]; //COL:start and end
//Page:start and end
static void summit_enable_reset(bool enable);
static void summit_enable_power(bool enable);
static void summit_set_brightness(uint16_t level);
static void summit_enable_brightness_control(bool enable);
static void summit_set_packet_length(uint16_t length);
static void summit_sram_update(struct display_timing *timing);
#ifdef SUMMIT_DISABLE_DSI_PROTOCOL_ERROR_WA
static void summit_disable_dsi_protocol_error_wa(bool lock_mcs);
#endif
struct display_timing *mipi_timing;
static int panel_id_2_class(u_int32_t panel_id)
{
int driver, panel_class = 1;
driver = panel_id & 0x3f;
if (driver > DISP_IC_SUMMIT_A0)
panel_class = 2;
return panel_class;
}
static void summit_read_panel_id(void)
{
u_int32_t length;
int result;
int panel_class, driver;
if (summit_panel_id == 0) {
summit_panel_id = env_get_uint("summit-panel-id", 0);
}
if (summit_panel_id == 0) {
// read the panel ID
length = sizeof(summit_raw_panel_id);
summit_raw_panel_id[0] = DSIM_CMD_DEVICE_ID;
result = mipi_dsim_read_long_command(DSIM_TYPE_GEN_READ_1P, summit_raw_panel_id, &length);
if ((result != 0) || (length < 3)) {
dprintf(DEBUG_CRITICAL, "summit_init(): read of summit panel id failed\n");
return;
} else {
summit_panel_id = summit_raw_panel_id[0] << 24; // Build ID
summit_panel_id |= summit_raw_panel_id[1] << 16; // Panel Vendor ID
summit_panel_id |= (summit_raw_panel_id[3] & 0xF0) << 8; // Program ID
summit_panel_id |= (summit_raw_panel_id[2] & 0xF0) << 4; //
summit_panel_id |= (summit_raw_panel_id[3] & 0x07) << 3; // Driver Vendor ID
summit_panel_id |= (summit_raw_panel_id[2] & 0x07) << 0; //
summit_panel_id |= (summit_raw_panel_id[2] & 0x08) << 4; // Auto Boot Bit
summit_panel_id |= (summit_raw_panel_id[3] & 0x08) << 3; // Default Color Bit
summit_default_color = ((summit_raw_panel_id[3] >> 3) & 1) ? 0x00000000 : 0x00FFFFFF;
summit_ldo_voltage = summit_raw_panel_id[4];
summit_boost_voltage = summit_raw_panel_id[5];
}
}
driver = summit_panel_id & 0x3f;
panel_class = panel_id_2_class(summit_panel_id);
dprintf(DEBUG_CRITICAL, "summit_init(): summit_panel_id: 0x%08x\n", summit_panel_id);
dprintf(DEBUG_CRITICAL, "summit_init(): summit_default_color: 0x%08x\n", summit_default_color);
dprintf(DEBUG_CRITICAL, "summit_init(): summit_ldo_voltage: 0x%08x\n", summit_ldo_voltage);
dprintf(DEBUG_CRITICAL, "summit_init(): summit_boost_voltage: 0x%08x\n", summit_boost_voltage);
}
static void summit_enable_reset(bool enable)
{
#ifdef GPIO_PMU_LCD_RST
power_gpio_configure(GPIO_PMU_LCD_RST, enable ? 0 : 0x38);
#else
gpio_write(GPIO_LCD_RST, enable ^ GPIO_LCD_RST_POLARITY ^ 1);
#endif
}
static void summit_enable_power(bool enable)
{
#ifdef GPIO_PMU_LCD_PWR_EN
power_set_gpio(GPIO_PMU_LCD_PWR_EN, 1, 1);
#endif
#ifdef PMU_LCD_PWR_DVDD
#ifdef PMU_LCD_PWR_VCI
if (enable) {
power_enable_ldo(PMU_LCD_PWR_DVDD, enable);
power_enable_ldo(PMU_LCD_PWR_VCI, enable);
} else {
power_enable_ldo(PMU_LCD_PWR_VCI, enable);
spin(54 * 1000);
power_enable_ldo(PMU_LCD_PWR_DVDD, enable);
}
#endif // PMU_LCD_PWR_VCI
#endif // PMU_LCD_PWR_DVDD
#ifdef GPIO_LCD_PWR_EN
gpio_write(GPIO_LCD_PWR_EN, enable);
#endif
}
static int summit_init_video_mode(struct display_timing *timing, enum colorspace color, u_int32_t *display_id)
{
utime_t start_time;
int panel_driver;
UInt8 data[26] = "";
uint16_t brightness_level = 0xff03;
// Reset the display, and make sure it has power
summit_enable_reset(true);
summit_enable_power(true);
// initialize MIPI-DSI while waiting T1
// Offset mipi_dsim_init giving the panel 100us to see the reset
// This is important for the iBoot -> iBEC transition
start_time = system_time();
spin(100);
mipi_dsim_init(timing, color);
while (!time_has_elapsed(start_time, 10 * 1000)) task_yield();
// Release the display from reset and wait T2.
summit_enable_reset(false);
task_sleep(7 * 1000);
// T4 and T5 are underway, since PWREN is trigger from reset on these drivers.
// Enable the high speed clock and wait T6, latch the start time for T7.
// Note that T6 technically ends when the panel ID read reaches the display driver,
// but we're being conservative and measuring until we queue the LP command.
mipi_dsim_enable_high_speed(true);
start_time = system_time();
task_sleep(25 * 1000);
// set packet length
summit_set_packet_length(0x20);
spin(1 * 1000);
// Read the panel ID from the display chip. If we don't have a valid panel ID, we
// run the quiesce sequence and bail out.
summit_read_panel_id();
if (summit_panel_id == 0) {
mipi_dsim_quiesce();
return -1;
}
panel_driver = summit_panel_id & 0x3f;
if (panel_driver == DISP_IC_SUMMIT_A0) {
summit_set_brightness(brightness_level);
summit_enable_brightness_control(true);
mipi_dsim_send_short_command(DSIM_TYPE_DSC_WRITE, DSIM_CMD_EXIT_SLEEP, 0x00);
spin(5 * 1000);
//Unlock MCS registers
mipi_dsim_send_short_command(DSIM_TYPE_DSC_WRITE_1P, 0xB0, 0xAC);
spin(1 * 1000);
//6. Set to internal oscillator
data[0] = 0xC9;
data[1] = 0xF7;
data[2] = 0xF8;
data[3] = 0x02;
data[4] = 0x02;
data[5] = 0x02;
mipi_dsim_send_long_command(DSIM_TYPE_GEN_LONG_WRITE, data, 6);
spin(5 * 1000);
#if SUMMIT_DISABLE_DSI_PROTOCOL_ERROR_WA
summit_disable_dsi_protocol_error_wa(false);
#endif //SUMMIT_DISABLE_DSI_PROTOCOL_ERROR_WA
// Paint the panel's native color, enable the CLCD and wait 100us
display_set_enable(true, &summit_default_color);
spin(32*1000);
// Finish waiting for T7 then send display-on command
//while (!time_has_elapsed(start_time, 100 * 1000)) task_yield();
mipi_dsim_send_short_command(DSIM_TYPE_DSC_WRITE, DSIM_CMD_DISPLAY_ON, 0x00);
//8. Set up some more MCS registers that weren't programmed correctly in OTP
data[0] = 0xCE;
data[1] = 0x00;
data[2] = 0x10;
data[3] = 0x10;
data[4] = 0x10;
mipi_dsim_send_long_command(DSIM_TYPE_GEN_LONG_WRITE, data, 5);
spin(1 * 1000);
data[0] = 0xCF;
data[1] = 0x15;
mipi_dsim_send_long_command(DSIM_TYPE_GEN_LONG_WRITE, data, 2);
//lock MCS registers
mipi_dsim_send_short_command(DSIM_TYPE_DSC_WRITE_1P, 0xB0, 0xCA);
// We can now enable video data after all LP commands are sent.
mipi_dsim_enable_video(true);
// Now the native color is transmitting to the display. We should guarantee a couple
// frames of native color before we switch to the black background that we want
// the user to see. This delay is part of T9, and we'll do the overlapping T8
// delay after setting the background to black.
display_delay_frames(3);
// Draw black, wait T8 (and the final two frames of T9) before we allow backlight enable.
paint_set_bgcolor(0, 0, 0);
paint_update_image();
display_delay_frames(2);
#ifdef GPIO_LCD_CHKSUM
// Turn off pull-down on LCD_CHKSUM
gpio_configure_pupdn(GPIO_LCD_CHKSUM, GPIO_NO_PUPDN);
#endif
} else {
#ifdef WITH_HW_DISPLAY_PMU
display_pmu_init();
#endif // WITH_HW_DISPLAY_PMU
// We can now enable video data after all LP commands are sent.
mipi_dsim_enable_video(true);
// Paint the panel's native color, enable the CLCD and wait 100us
display_set_enable(true, &summit_default_color);
display_delay_frames(1);
mipi_dsim_send_short_command(DSIM_TYPE_DSC_WRITE, DSIM_CMD_EXIT_SLEEP, 0x00);
spin(5 * 1000);
summit_set_brightness(brightness_level);
summit_enable_brightness_control(true);
#if SUMMIT_DISABLE_DSI_PROTOCOL_ERROR_WA
summit_disable_dsi_protocol_error_wa(true);
#endif //SUMMIT_DISABLE_DSI_PROTOCOL_ERROR_WA
// Paint the panel's native color, enable the CLCD and wait 100us
display_set_enable(true, &summit_default_color);
spin(32*1000);
// Finish waiting for T7 then send display-on command
//while (!time_has_elapsed(start_time, 100 * 1000)) task_yield();
display_delay_frames(5);
mipi_dsim_send_short_command(DSIM_TYPE_DSC_WRITE, DSIM_CMD_DISPLAY_ON, 0x00);
// Now the native color is transmitting to the display. We should guarantee a couple
// frames of native color before we switch to the black background that we want
// the user to see. This delay is part of T9, and we'll do the overlapping T8
// delay after setting the background to black.
display_delay_frames(1);
// Draw black, wait T8 (and the final two frames of T9) before we allow backlight enable.
paint_set_bgcolor(0, 0, 0);
paint_update_image();
display_delay_frames(2);
#ifdef GPIO_LCD_CHKSUM
// Turn off pull-down on LCD_CHKSUM
gpio_configure_pupdn(GPIO_LCD_CHKSUM, GPIO_NO_PUPDN);
#endif
}
*display_id = summit_panel_id;
return 0;
}
static int summit_do_panel_calibration()
{
UInt8 data[] = { 0x51, 0xff, 0x3};
return mipi_dsim_send_long_command(DSIM_TYPE_GEN_LUT_WRITE, data, 3);
}
static int summit_init_cmd_mode(struct display_timing *timing, enum colorspace color, u_int32_t *display_id)
{
utime_t start_time;
uint32_t brightness_level;
mipi_timing = timing;
// Reset the display, and make sure it has power
summit_enable_reset(true);
summit_enable_power(true);
// initialize MIPI-DSI while waiting T1
// Offset mipi_dsim_init giving the panel 1.5 ms to see the reset
start_time = system_time();
mipi_dsim_init(timing, color);
while (!time_has_elapsed(start_time, 15 * 100)) task_yield();
// Release the display from reset and wait T2.
summit_enable_reset(false);
task_sleep(5 * 1000);
// Enable the high speed clock and latch the start time for T4.
// Note that T4 technically ends when the panel ID read reaches the display driver,
// but we're being conservative and measuring until we queue the LP command.
mipi_dsim_enable_high_speed(true);
start_time = system_time();
// set packet length
summit_set_packet_length(0x20);
spin(1 * 1000);
// Read the panel ID from the display chip. If we don't have a valid panel ID, we
// run the quiesce sequence and bail out.
summit_read_panel_id();
if (summit_panel_id == 0) {
mipi_dsim_quiesce();
return -1;
}
#ifdef WITH_HW_DISPLAY_PMU
display_pmu_init();
#endif // WITH_HW_DISPLAY_PMU
//Wait for T4 to complete
while (!time_has_elapsed(start_time, 5 * 1000)) task_yield();
summit_sram_update(timing);
//summit based panels set brightness vs backlight.
//brightness_level = env_get_uint("backlight-level", 0xffff);
brightness_level = 0xff03;
summit_set_brightness(brightness_level);
summit_enable_brightness_control(true);
//Sleep out and latch for T5a
start_time = system_time();
mipi_dsim_send_short_command(DSIM_TYPE_DSC_WRITE, DSIM_CMD_EXIT_SLEEP, 0x00);
while (!time_has_elapsed(start_time, 5 * 1000)) task_yield();
// Finish waiting for T5 then send display-on command
while (!time_has_elapsed(start_time, 108 * 1000)) task_yield();
#if SUMMIT_DISABLE_DSI_PROTOCOL_ERROR_WA
summit_disable_dsi_protocol_error_wa(true);
#endif //SUMMIT_DISABLE_DSI_PROTOCOL_ERROR_WA
//Display On
mipi_dsim_send_short_command(DSIM_TYPE_DSC_WRITE, DSIM_CMD_DISPLAY_ON, 0x00);
// We can now enable video data after all LP commands are sent.
mipi_dsim_enable_video(true);
// Paint the panel's native color, enable adp/adbe
display_set_enable(true, &summit_default_color);
paint_set_bgcolor(0, 0, 0);
paint_update_image();
display_delay_frames(1);
*display_id = summit_panel_id;
return 0;
}
static void summit_set_brightness(uint16_t level)
{
UInt8 data[3] = "";
data[0] = 0x51;
data[1] = (level >> 2) & 0xff;
data[2] = (level & 0x3);
mipi_dsim_send_long_command(DSIM_TYPE_GEN_LUT_WRITE, data, 3);
}
static void summit_enable_brightness_control(bool enable)
{
mipi_dsim_send_short_command(DSIM_TYPE_DSC_WRITE_1P, 0x53, enable ? 0x20 : 0);
}
static void summit_set_packet_length(uint16_t length)
{
mipi_dsim_send_short_command(0x37, length & 0xff, (length >> 8) & 0xff);
}
#define SUMMIT_STARTING_COLUMN_ADDRESS 0x0
#define SUMMIT_STARTING_PAGE_ADDRESS 0x0
static void summit_sram_update(struct display_timing *timing)
{
uint8_t data[5] = "";
uint16_t sram_start_addr, sram_end_addr;
sram_end_addr = (timing->h_active - 1);
sram_start_addr = SUMMIT_STARTING_COLUMN_ADDRESS;
summit_sram_address[0] = sram_start_addr;
summit_sram_address[1] = sram_end_addr;
data[0] = 0x2a;
data[1] = ((sram_start_addr >> 8) & 0xff);
data[2] = ((sram_start_addr >> 0) & 0xff);
data[3] = ((sram_end_addr >> 8) & 0xff);
data[4] = ((sram_end_addr >> 0) & 0xff);
mipi_dsim_send_long_command(0x39, data, sizeof(data));
sram_end_addr = (timing->v_active - 1);
sram_start_addr = SUMMIT_STARTING_COLUMN_ADDRESS;
summit_sram_address[2] = sram_start_addr;
summit_sram_address[3] = sram_end_addr;
data[0] = 0x2b;
data[1] = ((sram_start_addr >> 8) & 0xff);
data[2] = ((sram_start_addr >> 0) & 0xff);
data[3] = ((sram_end_addr >> 8) & 0xff);
data[4] = ((sram_end_addr >> 0) & 0xff);
mipi_dsim_send_long_command(0x39, data, sizeof(data));
data[0] = 0x2c;
data[1] = 0xff;
mipi_dsim_send_long_command(0x39, data, 2);
}
//
//Global functions
//
int summit_init(struct display_timing *timing, enum colorspace color, u_int32_t *display_id)
{
bool is_video_mode = true;
#ifdef TARGET_DISP_VIDEO_MODE
is_video_mode = TARGET_DISP_VIDEO_MODE;
#endif //TARGET_DISP_VIDEO_MODE
dprintf(DEBUG_CRITICAL, "summit_init %s mode()\n", is_video_mode ? "video" : "command");
// Save the display's dot pitch
summit_dot_pitch = timing->dot_pitch;
if (is_video_mode) {
return summit_init_video_mode(timing, color, display_id);
} else {
return summit_init_cmd_mode(timing, color, display_id);
}
}
int summit_quiesce(void)
{
// send display-off and wait T7
mipi_dsim_send_short_command(DSIM_TYPE_DSC_WRITE, DSIM_CMD_DISPLAY_OFF, 0x00);
spin(18 * 1000);
mipi_dsim_send_short_command(DSIM_TYPE_DSC_WRITE, DSIM_CMD_ENTER_SLEEP, 0x00);
// Wait for T8 then stop clock, reset MIPI and display driver
display_delay_frames(6);
// Because of LP transmission uncertainty of up to 2 frames, we need to pad the
// delay. We only do it for Type 2 displays because Type 1 is frozen.
display_delay_frames(2);
mipi_dsim_enable_high_speed(false);
mipi_dsim_quiesce();
summit_enable_reset(true);
summit_enable_power(false);
return 0;
}
#ifdef SUMMIT_DISABLE_DSI_PROTOCOL_ERROR_WA
static void summit_disable_dsi_protocol_error_wa(bool lock_mcs)
{
uint8_t data1[6] = "";
uint32_t length;
if (lock_mcs) {
//Unlock MCS registers
mipi_dsim_send_short_command(DSIM_TYPE_DSC_WRITE_1P, 0xB0, 0xAC);
spin(1 * 1000);
}
data1[0] = 0xd4;
data1[1] = 0x07;
data1[2] = 0xc0;
data1[3] = 0x80;
data1[4] = 0x00;
data1[5] = 0x80;
length = sizeof(data1);
mipi_dsim_send_long_command(DSIM_TYPE_GEN_LONG_WRITE, data1, length);
if (lock_mcs) {
//lock MCS registers
mipi_dsim_send_short_command(DSIM_TYPE_DSC_WRITE_1P, 0xB0, 0xCA);
}
}
#endif
int8_t summit_get_raw_panel_id(uint8_t *raw_panel_id, size_t raw_panel_id_length)
{
RELEASE_ASSERT(raw_panel_id != NULL);
RELEASE_ASSERT(raw_panel_id_length >= sizeof(summit_raw_panel_id));
bcopy(summit_raw_panel_id, raw_panel_id, sizeof(summit_raw_panel_id));
return 0;
}
#if WITH_DEVICETREE
#include <lib/devicetree.h>
int summit_update_device_tree(DTNode *summit_node, DTNode *clcd_node, DTNode *backlight_node)
{
u_int32_t propSize;
char *propName;
void *propData;
char *PropNameFuncDisable = "function-backlight_inval";
char *PropNameFuncEnable = "function-backlight_enable";
char *PropNameFuncUpdate = "function-backlight_update";
char *PropNameFuncNoUpdate = "function-backlight_noupdate";
if (summit_panel_id == 0) return -1;
propName = "lcd-panel-id";
if (FindProperty(summit_node, &propName, &propData, &propSize)) {
((u_int32_t *)propData)[0] = summit_panel_id;
}
propName = "raw-panel-id";
if (FindProperty(summit_node, &propName, &propData, &propSize)) {
if (propSize > sizeof(summit_raw_panel_id)) propSize = sizeof(summit_raw_panel_id);
memcpy(propData, summit_raw_panel_id, propSize);
}
#ifdef TARGET_DISP_VIDEO_MODE
//tell the os if video or command mode
propName = "video-mode";
if (FindProperty(summit_node, &propName, &propData, &propSize)) {
((u_int32_t *)propData)[0] = TARGET_DISP_VIDEO_MODE;
}
#endif //TARGET_DISP_VIDEO_MODE
propName = "sram-addresses";
if (FindProperty(summit_node, &propName, &propData, &propSize)) {
memcpy(propData, summit_sram_address, sizeof(summit_sram_address));
}
if (clcd_node != NULL) {
propName = "display-default-color";
if (FindProperty(clcd_node, &propName, &propData, &propSize)) {
((u_int32_t *)propData)[0] = summit_default_color;
}
propName = "dot-pitch";
if (FindProperty(clcd_node, &propName, &propData, &propSize)) {
((u_int32_t *)propData)[0] = summit_dot_pitch;
}
#ifdef TARGET_DISP_VIDEO_MODE
//tell the os if video or command mode
propName = "video-mode";
if (FindProperty(clcd_node, &propName, &propData, &propSize)) {
((u_int32_t *)propData)[0] = TARGET_DISP_VIDEO_MODE;
}
#endif //TARGET_DISP_VIDEO_MODE
}
if (backlight_node != NULL) {
propName = "function-backlight_enable";
if (FindProperty(backlight_node, &propName, &propData, &propSize)) {
memset(propName, 0, strlen(propName));
strlcpy(propName, PropNameFuncDisable, strlen(PropNameFuncDisable) + 1);
}
propName = "function-backlight_enable-sum";
if (FindProperty(backlight_node, &propName, &propData, &propSize)) {
memset(propName, 0, strlen(propName));
strlcpy(propName, PropNameFuncEnable, strlen(PropNameFuncEnable) + 1);
}
propName = "function-backlight_update";
if (FindProperty(backlight_node, &propName, &propData, &propSize)) {
memset(propName, 0, strlen(propName));
strlcpy(propName, PropNameFuncNoUpdate, strlen(PropNameFuncNoUpdate) + 1);
}
propName = "function-backlight_update-sum";
if (FindProperty(backlight_node, &propName, &propData, &propSize)) {
memset(propName, 0, strlen(propName));
strlcpy(propName, PropNameFuncUpdate, strlen(PropNameFuncUpdate) + 1);
}
propName = "display-backlight-calibration";
if (FindProperty(backlight_node, &propName, &propData, &propSize)) {
((u_int32_t *)propData)[0] = summit_backlight_cal;
}
propName = "backlight-id";
if (FindProperty(backlight_node, &propName, &propData, &propSize)) {
if (((u_int32_t *)propData)[0] == 0xffffffff) {
((u_int32_t *)propData)[0] = (summit_panel_id >> 8) & 0xff;
}
}
}
return 0;
}
#endif
//FOR DEBUG ONLY WHEN NEEDED
#if 0
static int32_t panelFill(uint32_t width, uint32_t height, uint8_t red, uint8_t green, uint8_t blue )
{
int32_t err;
uint32_t x, y;
uint8_t *ptr;
uint8_t *dummyLine;
uint32_t lineBytes;
printf("width %d height %d red 0x%x green 0x%x blue 0x%x\n", width, height, red, green, blue);
lineBytes = width * 3;
dummyLine = (uint8_t *) malloc(lineBytes + 1);
if (dummyLine == NULL ) return -1;
ptr = &dummyLine[1];
printf("%s %d\n", __FUNCTION__, __LINE__);
for (x = 0; x < width; x++) {
*ptr++ = red;
*ptr++ = green;
*ptr++ = blue;
}
printf("%s %d\n", __FUNCTION__, __LINE__);
#define MIPI_DSI_LONG_DCS_WRITE 0x39
#define MIPI_DCS_COMMAND_WRITE_MEMORY_START 0x2C
#define MIPI_DCS_COMMAND_WRITE_MEMORY_CONTINUE 0x3C
for (y = 0; y < height; y++) {
if (y == 0) {
dummyLine[0] = MIPI_DCS_COMMAND_WRITE_MEMORY_START;
err = mipi_dsim_send_long_command( MIPI_DSI_LONG_DCS_WRITE, dummyLine, lineBytes + 1 );
if (err)
goto PANEL_FILL_ERROR;
} else {
dummyLine[0] = MIPI_DCS_COMMAND_WRITE_MEMORY_CONTINUE;
err = mipi_dsim_send_long_command( MIPI_DSI_LONG_DCS_WRITE, dummyLine, lineBytes + 1 );
if (err)
goto PANEL_FILL_ERROR;
}
spin(1000);
}
PANEL_FILL_ERROR:
free( dummyLine);
return err;
}
#include <sys/menu.h>
static int do_mipi(int argc, struct cmd_arg *args)
{
if (argc < 3) {
puts("not enough arguments.\n");
usage:
printf("%s readshort <cmd>\n", args[0].str);
printf("%s readlong <cmd> <length>\n", args[0].str);
printf("%s writeshort <cmd> <data0> <data1>\n", args[0].str);
printf("%s writelong <cmd> <data0> <data1> ...\n", args[0].str);
printf("%s fill <r> <g> <b> \n", args[0].str);
return -1;
}
int cmd = args[2].u;
if (!strcmp("readshort", args[1].str)) {
uint8_t data[32];
int err;
err = mipi_dsim_read_short_command(cmd, data);
if (err < 0) {
printf("error %d reading from mipi\n", err);
} else {
hexdump(data, sizeof(data));
}
} else if (!strcmp("readlong", args[1].str)) {
uint8_t data[16];
int err;
uint32_t len = 32;
data[0] = args[3].u;
printf("reading from reg 0x%x length %d\n", data[0], len);
err = mipi_dsim_read_long_command(cmd, data, &len);
if (err < 0) {
printf("error %d reading from mipi\n", err);
} else {
hexdump(data, len);
}
} else if (!strcmp("writeshort", args[1].str)) {
u_int8_t data[2];
int err;
data[0] = args[3].u;
data[1] = args[4].u;
printf("writing cmd 0x%x data0 0x%x data1 0x%x\n", cmd, data[0], data[1]);
err = mipi_dsim_send_short_command(cmd, data[0], data[1]);
} else if (!strcmp("writelong", args[1].str)) {
u_int8_t data[64];
size_t len, i;
int err;
len = argc - 3;
if (len > sizeof(data)) len = sizeof(data);
for (i = 0; i < len; i++) {
data[i] = args[i+3].u;
printf("data[%d]=0x%x\n", i, data[i]);
}
printf("writing %d bytes of data\n", len);
err = mipi_dsim_send_long_command(cmd, data, len);
if (err < 0)
printf("error %d writing to mipi\n", err);
} else if (!strcmp("fill", args[1].str)) {
int err;
printf("filling width %d height %d r 0x%x g 0%x b 0x%x\n", args[2].u, args[3].u, args[4].u, args[5].u, args[6].u);
err = panelFill(args[2].u, args[3].u, args[4].u, args[5].u, args[6].u);
if (err < 0) {
printf("error %d reading from mipi\n", err);
}
} else if (!strcmp("writeshort", args[1].str)) {
} else {
puts("unrecognized command.\n");
goto usage;
}
return 0;
}
#if WITH_RECOVERY_MODE
MENU_COMMAND_DEBUG(mipi, do_mipi, "[read/write] mipi commands", NULL);
#endif
#endif
Reference in New Issue View Git Blame Copy Permalink