CONFIG_MODULE_UNLOAD=y
CONFIG_MODULE_FORCE_UNLOAD=y
CONFIG_ARCH_RK2928=y
+CONFIG_DDR_FREQ=y
CONFIG_RK_CLOCK_PROC=y
CONFIG_RK_USB_UART=y
CONFIG_MACH_RK2928=y
CONFIG_TABLET_USB_KBTAB=y
CONFIG_TABLET_USB_WACOM=y
CONFIG_INPUT_TOUCHSCREEN=y
+CONFIG_EETI_EGALAX=y
+CONFIG_EETI_EGALAX_MAX_X=1087
+CONFIG_EETI_EGALAX_MAX_Y=800
CONFIG_TOUCHSCREEN_SITRONIX_A720=y
CONFIG_INPUT_MISC=y
CONFIG_INPUT_KEYCHORD=y
CONFIG_INPUT_UINPUT=y
CONFIG_GS_MMA7660=y
+CONFIG_GS_MMA8452=y
CONFIG_SENSOR_DEVICE=y
CONFIG_GSENSOR_DEVICE=y
# CONFIG_SERIO is not set
# CONFIG_HW_RANDOM is not set
CONFIG_I2C=y
# CONFIG_I2C_COMPAT is not set
+CONFIG_I2C_CHARDEV=y
CONFIG_I2C0_CONTROLLER_RK30=y
CONFIG_I2C1_CONTROLLER_RK30=y
CONFIG_I2C2_CONTROLLER_RK30=y
CONFIG_ADC_RK30=y
+CONFIG_GPIO_SYSFS=y
CONFIG_EXPANDED_GPIO_NUM=0
CONFIG_EXPANDED_GPIO_IRQ_NUM=0
CONFIG_SPI_FPGA_GPIO_NUM=0
CONFIG_SPI_FPGA_GPIO_IRQ_NUM=0
CONFIG_POWER_SUPPLY=y
-CONFIG_TEST_POWER=y
+CONFIG_BATTERY_RK30_ADC_FAC=y
+CONFIG_BATTERY_RK30_AC_CHARGE=y
+CONFIG_BATTERY_RK30_VOL3V8=y
+CONFIG_POWER_ON_CHARGER_DISPLAY=y
# CONFIG_HWMON is not set
CONFIG_MFD_TPS65910=y
CONFIG_MFD_TPS65090=y
CONFIG_BACKLIGHT_CLASS_DEVICE=y
# CONFIG_BACKLIGHT_GENERIC is not set
CONFIG_DISPLAY_SUPPORT=y
-CONFIG_LCD_RK2928_A720=y
+CONFIG_LCD_RK2928=y
CONFIG_FB_ROCKCHIP=y
CONFIG_LCDC_RK2928=y
CONFIG_RK_HDMI=y
CONFIG_LOGO=y
# CONFIG_LOGO_LINUX_MONO is not set
# CONFIG_LOGO_LINUX_VGA16 is not set
+# CONFIG_LOGO_LINUX_CLUT224 is not set
+CONFIG_LOGO_LINUX_800x480_CLUT224=y
CONFIG_SOUND=y
CONFIG_SND=y
# CONFIG_SND_SUPPORT_OLD_API is not set
CONFIG_USB_GADGET=y
CONFIG_USB20_HOST=y
CONFIG_USB20_OTG=y
+CONFIG_DWC_OTG_BOTH_HOST_SLAVE=y
CONFIG_MMC=y
CONFIG_MMC_UNSAFE_RESUME=y
CONFIG_MMC_EMBEDDED_SDIO=y
CONFIG_MMC_PARANOID_SD_INIT=y
CONFIG_SDMMC_RK29=y
+CONFIG_SDMMC0_RK29_SDCARD_DET_FROM_GPIO=y
# CONFIG_SDMMC1_RK29 is not set
CONFIG_SWITCH=y
CONFIG_SWITCH_GPIO=y
CONFIG_RTC_CLASS=y
+CONFIG_RTC_HYM8563=y
CONFIG_TPS65910_RTC=y
CONFIG_STAGING=y
CONFIG_ANDROID=y
--- /dev/null
+#if 1
+#define CONFIG_ERR(v, name) do { printk("%s: Invalid parameter: %s(%d)\n", __func__, (name), (v)); } while(0)
+#else
+#define CONFIG_ERR(v, name)
+#endif
+#include <mach/config.h>
+int __sramdata g_pmic_type = 0;
+
+struct pwm_io_config{
+ int id;
+ int gpio;
+ char *mux_name;
+ unsigned int io_mode;
+ unsigned int pwm_mode;
+};
+static struct pwm_io_config pwm_cfg[] = {
+ {
+ .id = 0,
+ .gpio = RK2928_PIN0_PD2,
+ .mux_name = GPIO0D2_PWM_0_NAME,
+ .io_mode = GPIO0D_GPIO0D2,
+ .pwm_mode = GPIO0D_PWM_0,
+ },
+ {
+ .id = 1,
+ .gpio = RK2928_PIN0_PD3,
+ .mux_name = GPIO0D3_PWM_1_NAME,
+ .io_mode = GPIO0D_GPIO0D3,
+ .pwm_mode = GPIO0D_PWM_1,
+ },
+ {
+ .id = 2,
+ .gpio = RK2928_PIN0_PD4,
+ .mux_name = GPIO0D4_PWM_2_NAME,
+ .io_mode = GPIO0D_GPIO0D4,
+ .pwm_mode = GPIO0D_PWM_2,
+ },
+};
+
+/*************************************** parameter ******************************************/
+/* keyboard */
+uint key_adc = DEF_KEY_ADC;
+uint key_val_size = 7;
+uint key_val[] = {DEF_PLAY_KEY, DEF_VOLDN_KEY, DEF_VOLUP_KEY, DEF_MENU_KEY, DEF_ESC_KEY, DEF_HOME_KEY, DEF_CAM_KEY};
+module_param_array(key_val, uint, &key_val_size, 0644);
+
+static inline int check_key_param(void)
+{
+ return 0;
+}
+/* backlight */
+static uint bl_pwm = DEF_BL_PWM;
+module_param(bl_pwm, uint, 0644);
+static uint bl_ref = DEF_BL_REF;
+module_param(bl_ref, uint, 0644);
+static uint bl_min = DEF_BL_MIN;
+module_param(bl_min, uint, 0644);
+static int bl_en = DEF_BL_EN;
+module_param(bl_en, int, 0644);
+
+static inline int check_bl_param(void)
+{
+ if(bl_pwm < 0 || bl_pwm >= ARRAY_SIZE(pwm_cfg)){
+ CONFIG_ERR(bl_pwm, "bl_pwm");
+ return -EINVAL;
+ }
+ if(bl_ref != 0 && bl_ref != 1){
+ CONFIG_ERR(bl_ref, "bl_ref");
+ return -EINVAL;
+ }
+ if(bl_min > 100){
+ CONFIG_ERR(bl_min, "bl_min");
+ return -EINVAL;
+ }
+ return 0;
+}
+
+/* lcd */
+static int lcd_cabc = DEF_LCD_CABC;
+module_param(lcd_cabc, int, 0644);
+static int lcd_en = DEF_LCD_EN;
+module_param(lcd_en, int, 0644);
+static int lcd_std = DEF_LCD_STD;
+module_param(lcd_std, int, 0644);
+
+static inline int check_lcd_param(void)
+{
+ return 0;
+
+}
+
+/* gsensor */
+static int gs_type = DEF_GS_TYPE;
+
+static int gs_i2c = DEF_GS_I2C;
+module_param(gs_i2c, int, 0644);
+static int gs_addr = DEF_GS_ADDR;
+module_param(gs_addr, int, 0644);
+static int gs_irq = DEF_GS_IRQ;
+module_param(gs_irq, int, 0644);
+static int gs_pwr = DEF_GS_PWR;
+module_param(gs_pwr, int, 0644);
+static int gs_orig[9] = DEF_GS_ORIG;
+module_param_array(gs_orig, int, NULL, 0644);
+
+static inline int check_gs_param(void)
+{
+ int i;
+
+ if(gs_type <= GS_TYPE_NONE || gs_type > GS_TYPE_MAX){
+ CONFIG_ERR(gs_type, "gs_type");
+ return -EINVAL;
+ }
+ if(gs_i2c < 0 || gs_i2c > 3){
+ CONFIG_ERR(gs_i2c, "gs_i2c");
+ return -EINVAL;
+ }
+ if(gs_addr < 0 || gs_addr > 0x7f){
+ CONFIG_ERR(gs_i2c, "gs_addr");
+ return -EINVAL;
+ }
+ for(i = 0; i < 9; i++){
+ if(gs_orig[i] != 1 && gs_orig[i] != 0 && gs_orig[i] != -1){
+ CONFIG_ERR(gs_orig[i], "gs_orig[x]");
+ return -EINVAL;
+ }
+ }
+ return 0;
+}
+
+/* pwm regulator */
+static int __sramdata reg_pwm = DEF_REG_PWM;
+module_param(reg_pwm, int, 0644);
+static inline int check_reg_pwm_param(void)
+{
+ if(reg_pwm < 0 || reg_pwm >= ARRAY_SIZE(pwm_cfg)){
+ CONFIG_ERR(reg_pwm, "reg_pwm");
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
+/* pmic */
+static uint pmic_type = DEF_PMIC_TYPE;
+module_param(pmic_type, uint, 0644);
+static __sramdata int pmic_slp = DEF_PMIC_SLP;
+module_param(pmic_slp, int, 0644);
+static int pmic_irq = DEF_PMIC_IRQ;
+module_param(pmic_irq, int, 0644);
+static int pmic_i2c = DEF_PMIC_I2C;
+module_param(pmic_i2c, int, 0644);
+static int pmic_addr = DEF_PMIC_ADDR;
+module_param(pmic_addr, int, 0644);
+
+static inline int check_pmic_param(void)
+{
+ if(pmic_type <= PMIC_TYPE_WM8326 || pmic_type >= PMIC_TYPE_MAX){
+ CONFIG_ERR(pmic_type, "pmic_type");
+ return -EINVAL;
+ }
+ if(pmic_i2c < 0 || pmic_i2c > 3){
+ CONFIG_ERR(pmic_i2c, "pmic_i2c");
+ return -EINVAL;
+ }
+ if(pmic_addr < 0 || pmic_addr > 0x7f){
+ CONFIG_ERR(pmic_i2c, "pmic_addr");
+ return -EINVAL;
+ }
+
+ g_pmic_type = pmic_type;
+
+ return 0;
+}
+/* ion */
+static uint ion_size = DEF_ION_SIZE;
+module_param(ion_size, uint, 0644);
+
+static inline int check_ion_param(void)
+{
+ return 0;
+}
+/* codec */
+static int spk_ctl = DEF_SPK_CTL;
+module_param(spk_ctl, int, 0644);
+static int hp_det = DEF_HP_DET;
+module_param(hp_det, int, 0644);
+static inline int check_codec_param(void)
+{
+ return 0;
+}
+/* sdmmc */
+static int sd_det = -1;
+module_param(sd_det, int, 0644);
+static inline int check_sdmmc_param(void)
+{
+ return 0;
+}
+/* wifi */
+static int wifi_rst = DEF_WIFI_RST;
+module_param(wifi_rst, int, 0644);
+static int wifi_pwr = DEF_WIFI_PWR;
+module_param(wifi_pwr, int, 0644);
+static uint wifi_type = DEF_WIFI_TYPE;
+module_param(wifi_type, uint, 0644);
+static inline int check_wifi_param(void)
+{
+ if(wifi_type != WIFI_NONE){
+ if(wifi_type <= WIFI_USB_NONE || wifi_type >= WIFI_USB_MAX || wifi_type <= WIFI_SDIO_NONE || wifi_type >= WIFI_SDIO_MAX){
+ CONFIG_ERR(wifi_type, "wifi_type");
+ return -EINVAL;
+ }
+ }
+
+ return 0;
+
+}
+/* rtc */
+static int rtc_i2c = DEF_RTC_I2C;
+module_param(rtc_i2c, int, 0644);
+static int rtc_addr = DEF_RTC_ADDR;
+module_param(rtc_addr, int, 0644);
+static int rtc_irq = DEF_RTC_IRQ;
+module_param(rtc_irq, int, 0644);
+static inline int check_rtc_param(void)
+{
+ if(rtc_i2c < 0 || rtc_i2c > 3){
+ CONFIG_ERR(rtc_i2c, "rtc_i2c");
+ return -EINVAL;
+ }
+ if(rtc_addr < 0 || rtc_addr > 0x7f){
+ CONFIG_ERR(rtc_i2c, "rtc_addr");
+ return -EINVAL;
+ }
+ return 0;
+}
+
+/* charge */
+static int chg_adc = DEF_CHG_ADC;
+module_param(chg_adc, int, 0644);
+
+static int dc_det = -1;
+module_param(dc_det, int, 0644);
+static int bat_low = -1;
+module_param(bat_low, int, 0644);
+static int chg_ok = -1;
+module_param(chg_ok, int, 0644);
+static int chg_set = -1;
+module_param(chg_set, int, 0644);
+static int chg_sel = -1;
+module_param(chg_sel, int, 0644);
+static inline int check_charge_param(void)
+{
+ return 0;
+}
+
+/* dvfs */
+static struct dvfs_arm_table dvfs_cpu_logic_table[] = {
+#if defined(RK2926_TB_DEFAULT_CONFIG)
+ {.frequency = 216 * 1000, .cpu_volt = 1200 * 1000, .logic_volt = 1200 * 1000},
+ {.frequency = 312 * 1000, .cpu_volt = 1200 * 1000, .logic_volt = 1200 * 1000},
+ {.frequency = 408 * 1000, .cpu_volt = 1200 * 1000, .logic_volt = 1200 * 1000},
+ {.frequency = 504 * 1000, .cpu_volt = 1200 * 1000, .logic_volt = 1200 * 1000},
+ {.frequency = 600 * 1000, .cpu_volt = 1250 * 1000, .logic_volt = 1200 * 1000},
+ {.frequency = 696 * 1000, .cpu_volt = 1350 * 1000, .logic_volt = 1200 * 1000},
+ {.frequency = 816 * 1000, .cpu_volt = 1400 * 1000, .logic_volt = 1200 * 1000},
+ {.frequency = 912 * 1000, .cpu_volt = 1450 * 1000, .logic_volt = 1200 * 1000},
+ {.frequency = 1008 * 1000,.cpu_volt = 1500 * 1000, .logic_volt = 1200 * 1000},
+#else
+ { .frequency = 216 * 1000, .cpu_volt = 850 * 1000, .logic_volt = 1200 * 1000 },
+ { .frequency = 312 * 1000, .cpu_volt = 900 * 1000, .logic_volt = 1200 * 1000 },
+ { .frequency = 408 * 1000, .cpu_volt = 950 * 1000, .logic_volt = 1200 * 1000 },
+ { .frequency = 504 * 1000, .cpu_volt = 1000 * 1000, .logic_volt = 1200 * 1000 },
+ { .frequency = 600 * 1000, .cpu_volt = 1100 * 1000, .logic_volt = 1200 * 1000 },
+ { .frequency = 696 * 1000, .cpu_volt = 1175 * 1000, .logic_volt = 1200 * 1000 },
+ { .frequency = 816 * 1000, .cpu_volt = 1250 * 1000, .logic_volt = 1200 * 1000 },
+ { .frequency = 912 * 1000, .cpu_volt = 1350 * 1000, .logic_volt = 1200 * 1000 },
+ { .frequency =1008 * 1000, .cpu_volt = 1450 * 1000, .logic_volt = 1200 * 1000 },
+#endif
+ { .frequency = CPUFREQ_TABLE_END },
+};
+static unsigned int dvfs_cpu_logic[ARRAY_SIZE(dvfs_cpu_logic_table) * 3];
+static unsigned int dvfs_cpu_logic_num;
+module_param_array(dvfs_cpu_logic, uint, &dvfs_cpu_logic_num, 0400);
+
+static struct cpufreq_frequency_table dvfs_gpu_table[] = {
+ { .frequency = 266 * 1000, .index = 1050 * 1000 },
+ { .frequency = 400 * 1000, .index = 1275 * 1000 },
+ { .frequency = CPUFREQ_TABLE_END },
+};
+static unsigned int dvfs_gpu[ARRAY_SIZE(dvfs_gpu_table) * 2];
+static unsigned int dvfs_gpu_num;
+module_param_array(dvfs_gpu, uint, &dvfs_gpu_num, 0400);
+
+static struct cpufreq_frequency_table dvfs_ddr_table[] = {
+ {.frequency = 300 * 1000, .index = 1050 * 1000},
+ {.frequency = 400 * 1000, .index = 1125 * 1000},
+ {.frequency = CPUFREQ_TABLE_END},
+};
+static unsigned int dvfs_ddr[ARRAY_SIZE(dvfs_ddr_table) * 2];
+static unsigned int dvfs_ddr_num;
+module_param_array(dvfs_ddr, uint, &dvfs_ddr_num, 0400);
+
+
+/* global */
+static int pwr_on = DEF_PWR_ON;
+module_param(pwr_on, int, 0644);
+
+static inline int rk2928_power_on(void)
+{
+ return port_output_init(pwr_on, 1, "pwr_on");
+}
+static inline void rk2928_power_off(void)
+{
+ port_output_off(pwr_on);
+ port_deinit(pwr_on);
+}
--- /dev/null
+#include <mach/gpio.h>
+#include <plat/key.h>
+
+#define EV_ENCALL KEY_F4
+#define EV_MENU KEY_F1
+
+#define PRESS_LEV_LOW 1
+#define PRESS_LEV_HIGH 0
+
+static struct rk29_keys_button key_button[] = {
+ {
+ .desc = "play",
+ .code = KEY_POWER,
+ .wakeup = 1,
+ },
+ {
+ .desc = "vol-",
+ .code = KEY_VOLUMEDOWN,
+ },
+ {
+ .desc = "vol+",
+ .code = KEY_VOLUMEUP,
+ },
+ {
+ .desc = "menu",
+ .code = EV_MENU,
+ },
+ {
+ .desc = "esc",
+ .code = KEY_BACK,
+ },
+ {
+ .desc = "home",
+ .code = KEY_HOME,
+ },
+ {
+ .desc = "camera",
+ .code = KEY_CAMERA,
+ },
+};
+struct rk29_keys_platform_data rk29_keys_pdata = {
+ .buttons = key_button,
+ .chn = -1, //chn: 0-7, if do not use ADC,set 'chn' -1
+};
+static int __init key_board_init(void)
+{
+ int i;
+ struct port_config port;
+
+ for(i = 0; i < key_val_size; i++){
+ if(key_val[i] & (1<<31)){
+ key_button[i].adc_value = key_val[i] & 0xffff;
+ key_button[i].gpio = INVALID_GPIO;
+ }else{
+ port = get_port_config(key_val[i]);
+ key_button[i].gpio = port.gpio;
+ key_button[i].active_low = port.io.active_low;
+ }
+ }
+ rk29_keys_pdata.nbuttons = key_val_size;
+ rk29_keys_pdata.chn = key_adc;
+
+ return 0;
+}
+
int err = -1;
printk("%s,line=%d\n", __func__,__LINE__);
+#ifdef CONFIG_RK_CONFIG
+ if(sram_gpio_init(get_port_config(pmic_slp).gpio, &pmic_sleep) < 0){
+#else
if(sram_gpio_init(PMU_POWER_SLEEP, &pmic_sleep) < 0){
+#endif
printk(KERN_ERR "PMU_POWER_SLEEP is invalid gpio\n");
return -EINVAL;
}
#include <linux/mfd/tps65910.h>
#include <linux/regulator/act8931.h>
#include <linux/regulator/rk29-pwm-regulator.h>
+
+#include "board-rk2928-config.c"
+
#if defined(CONFIG_HDMI_RK30)
#include "../../../drivers/video/rockchip/hdmi/rk_hdmi.h"
#endif
#include "../../../drivers/spi/rk29_spim.h"
#endif
-#include "board-rk2928-a720-camera.c"
-#include "board-rk2928-a720-key.c"
+#include "board-rk2928-sdk-camera.c"
+#include "board-rk2928-key.c"
-int __sramdata g_pmic_type = 0;
#ifdef CONFIG_THREE_FB_BUFFER
#define RK30_FB0_MEM_SIZE 12*SZ_1M
* rk30 backlight
************************************************************/
#ifdef CONFIG_BACKLIGHT_RK29_BL
-#define PWM_ID 0
-#define PWM_MUX_NAME GPIO0D2_PWM_0_NAME
-#define PWM_MUX_MODE GPIO0D_PWM_0
-#define PWM_MUX_MODE_GPIO GPIO0D_GPIO0D2
-#define PWM_GPIO RK2928_PIN0_PD2
-#define PWM_EFFECT_VALUE 0
-
-#define LCD_DISP_ON_PIN
-
-#ifdef LCD_DISP_ON_PIN
-
-#define BL_EN_PIN RK2928_PIN1_PB0
-#define BL_EN_VALUE GPIO_HIGH
-#endif
static int rk29_backlight_io_init(void)
{
- int ret = 0;
- rk30_mux_api_set(PWM_MUX_NAME, PWM_MUX_MODE);
-#ifdef LCD_DISP_ON_PIN
- // rk30_mux_api_set(BL_EN_MUX_NAME, BL_EN_MUX_MODE);
+ int ret = 0;
+ struct pwm_io_config *cfg = &pwm_cfg[bl_pwm];
- ret = gpio_request(BL_EN_PIN, NULL);
- if (ret != 0) {
- gpio_free(BL_EN_PIN);
- }
+ ret = gpio_request(cfg->gpio, "bl_pwm");
+ if(ret < 0){
+ printk("%s: request gpio(bl_pwm) failed\n", __func__);
+ return ret;
+ }
+ rk30_mux_api_set(cfg->mux_name, cfg->pwm_mode);
+
+ if(bl_en == -1)
+ return 0;
+ ret = port_output_init(bl_en, 0, "bl_en");
+ if(ret < 0){
+ printk("%s: port output init faild\n", __func__);
+ return ret;
+ }
+ port_output_on(bl_en);
- gpio_direction_output(BL_EN_PIN, 0);
- gpio_set_value(BL_EN_PIN, BL_EN_VALUE);
-#endif
- return ret;
+ return 0;
}
-
static int rk29_backlight_io_deinit(void)
{
- int ret = 0;
-#ifdef LCD_DISP_ON_PIN
- gpio_set_value(BL_EN_PIN, !BL_EN_VALUE);
- gpio_free(BL_EN_PIN);
-#endif
- rk30_mux_api_set(PWM_MUX_NAME, PWM_MUX_MODE_GPIO);
- return ret;
+ struct pwm_io_config *cfg = &pwm_cfg[bl_pwm];
+
+ port_output_off(bl_en);
+ if(bl_en != -1)
+ port_deinit(bl_en);
+ rk30_mux_api_set(cfg->mux_name, cfg->io_mode);
+ gpio_free(cfg->gpio);
+
+ return 0;
}
static int rk29_backlight_pwm_suspend(void)
{
- int ret = 0;
- rk30_mux_api_set(PWM_MUX_NAME, PWM_MUX_MODE_GPIO);
- if (gpio_request(PWM_GPIO, NULL)) {
- printk("func %s, line %d: request gpio fail\n", __FUNCTION__, __LINE__);
- return -1;
- }
- #if defined(CONFIG_MFD_TPS65910)
- if(pmic_is_tps65910())
- {
- gpio_direction_output(PWM_GPIO, GPIO_LOW);
- }
- #endif
- #if defined(CONFIG_REGULATOR_ACT8931)
- if(pmic_is_act8931())
- {
- gpio_direction_output(PWM_GPIO, GPIO_HIGH);
- }
- #endif
-#ifdef LCD_DISP_ON_PIN
- gpio_direction_output(BL_EN_PIN, 0);
- gpio_set_value(BL_EN_PIN, !BL_EN_VALUE);
-#endif
+ struct pwm_io_config *cfg = &pwm_cfg[bl_pwm];
- return ret;
+ rk30_mux_api_set(cfg->mux_name, cfg->io_mode);
+
+ gpio_direction_output(cfg->gpio, GPIO_HIGH);
+
+ port_output_off(bl_en);
+
+ return 0;
}
static int rk29_backlight_pwm_resume(void)
{
- gpio_free(PWM_GPIO);
- rk30_mux_api_set(PWM_MUX_NAME, PWM_MUX_MODE);
-#ifdef LCD_DISP_ON_PIN
+ struct pwm_io_config *cfg = &pwm_cfg[bl_pwm];
+
+ rk30_mux_api_set(cfg->mux_name, cfg->pwm_mode);
msleep(30);
- gpio_direction_output(BL_EN_PIN, 1);
- gpio_set_value(BL_EN_PIN, BL_EN_VALUE);
-#endif
+ port_output_on(bl_en);
return 0;
}
static struct rk29_bl_info rk29_bl_info = {
- .pwm_id = PWM_ID,
- .min_brightness = 80,
- .bl_ref = PWM_EFFECT_VALUE,
.io_init = rk29_backlight_io_init,
.io_deinit = rk29_backlight_io_deinit,
.pwm_suspend = rk29_backlight_pwm_suspend,
}
};
-#endif
+static int __init bl_board_init(void)
+{
+ int ret = check_bl_param();
-#ifdef CONFIG_FB_ROCKCHIP
+ if(ret < 0)
+ return ret;
-#define LCD_MUX_NAME GPIO0C2_UART0_RTSN_NAME
-#define LCD_GPIO_MODE GPIO0C_GPIO0C2
+ rk29_bl_info.pwm_id = bl_pwm;
+ rk29_bl_info.bl_ref = bl_ref;
+ rk29_bl_info.min_brightness = bl_min;
-#define LCD_EN RK2928_PIN0_PC2
-#define LCD_EN_VALUE GPIO_LOW
+ return 0;
+}
+#else
+static int __init bl_board_init(void)
+{
+ return 0;
+}
+#endif
+
+#ifdef CONFIG_FB_ROCKCHIP
static int rk_fb_io_init(struct rk29_fb_setting_info *fb_setting)
{
int ret = 0;
- rk30_mux_api_set(LCD_MUX_NAME, LCD_GPIO_MODE);
+ if(lcd_cabc != -1){
+ ret = port_output_init(lcd_en, 0, "lcd_cabc");
+ if(ret < 0)
+ printk("%s: port output init faild\n", __func__);
+ }
+ if(lcd_en == -1)
+ return 0;
+ ret = port_output_init(lcd_en, 1, "lcd_en");
+ if(ret < 0)
+ printk("%s: port output init faild\n", __func__);
- ret = gpio_request(LCD_EN, NULL);
- if (ret != 0)
- {
- gpio_free(LCD_EN);
- printk(KERN_ERR "request lcd en pin fail!\n");
- return -1;
- }
- else
- {
- gpio_direction_output(LCD_EN, LCD_EN_VALUE); //disable
- }
- return 0;
+ return ret;
}
static int rk_fb_io_disable(void)
{
+ if(lcd_en != -1)
+ port_output_off(lcd_en);
- #if 0//defined(CONFIG_REGULATOR_ACT8931)
- if(pmic_is_act8931())
- {
- struct regulator *ldo;
- ldo = regulator_get(NULL, "act_ldo4"); //vcc_lcd
- regulator_disable(ldo);
- regulator_put(ldo);
- udelay(100);
- }
- #endif
- gpio_set_value(LCD_EN, !LCD_EN_VALUE);
return 0;
}
static int rk_fb_io_enable(void)
{
- #if 0//defined(CONFIG_REGULATOR_ACT8931)
- if(pmic_is_act8931())
- {
- struct regulator *ldo;
- ldo = regulator_get(NULL, "act_ldo4"); //vcc_lcd
- regulator_enable(ldo);
- regulator_put(ldo);
- udelay(100);
- msleep(300); // wait for powering on LED circuit
- }
- #endif
-
- gpio_set_value(LCD_EN, LCD_EN_VALUE);
+ if(lcd_en != -1)
+ port_output_on(lcd_en);
return 0;
}
.num_resources = ARRAY_SIZE(resource_fb),
.resource = resource_fb,
};
+
+static int __init lcd_board_init(void)
+{
+ return check_lcd_param();
+}
+#else
+static int __init lcd_board_init(void)
+{
+ return 0;
+}
#endif
//LCDC
#endif
#ifdef CONFIG_ION
-#define ION_RESERVE_SIZE (80 * SZ_1M)
static struct ion_platform_data rk30_ion_pdata = {
.nr = 1,
.heaps = {
.type = ION_HEAP_TYPE_CARVEOUT,
.id = ION_NOR_HEAP_ID,
.name = "norheap",
- .size = ION_RESERVE_SIZE,
}
},
};
.platform_data = &rk30_ion_pdata,
},
};
-#endif
-
-
-#if defined(CONFIG_TOUCHSCREEN_SITRONIX_A720)
-
-#define TOUCH_RESET_PIN RK2928_PIN1_PA3
-#define TOUCH_INT_PIN RK2928_PIN1_PB3
-int ft5306_init_platform_hw(void)
+static int __init ion_board_init(void)
{
+ int ret = check_ion_param();
- //printk("ft5306_init_platform_hw\n");
- if(gpio_request(TOUCH_RESET_PIN,NULL) != 0){
- gpio_free(TOUCH_RESET_PIN);
- printk("ft5306_init_platform_hw gpio_request error\n");
- return -EIO;
- }
+ if(ret < 0)
+ return ret;
+ rk30_ion_pdata.heaps[0].size = ion_size;
- if(gpio_request(TOUCH_INT_PIN,NULL) != 0){
- gpio_free(TOUCH_INT_PIN);
- printk("ift5306_init_platform_hw gpio_request error\n");
- return -EIO;
- }
- gpio_direction_output(TOUCH_RESET_PIN, GPIO_HIGH);
- mdelay(10);
- gpio_set_value(TOUCH_RESET_PIN,GPIO_LOW);
- mdelay(10);
- gpio_set_value(TOUCH_RESET_PIN,GPIO_HIGH);
- msleep(300);
return 0;
-
}
-
-struct ft5x0x_platform_data sitronix_info = {
- .model = 5007,
- .init_platform_hw= ft5306_init_platform_hw,
-};
-
-#endif
-
-
-/*MMA7660 gsensor*/
-#if defined (CONFIG_GS_MMA7660)
-#define MMA7660_INT_PIN RK2928_PIN1_PB1
-
-static int mma7660_init_platform_hw(void)
+#else
+static int __init ion_board_init(void)
{
- rk30_mux_api_set(GPIO1B1_SPI_TXD_UART1_SOUT_NAME, GPIO1B_GPIO1B1);
-
- return 0;
+ return 0;
}
-
-static struct sensor_platform_data mma7660_info = {
- .type = SENSOR_TYPE_ACCEL,
- .irq_enable = 1,
- .poll_delay_ms = 30,
- .init_platform_hw = mma7660_init_platform_hw,
- .orientation = {-1, 0, 0, 0, 0, -1, 0, 1, 0},
-};
#endif
-
#if CONFIG_RK30_PWM_REGULATOR
static int pwm_voltage_map[] = {
1000000, 1025000, 1050000, 1075000, 1100000, 1125000, 1150000, 1175000, 1200000, 1225000, 1250000, 1275000, 1300000, 1325000, 1350000, 1375000, 1400000
static struct pwm_platform_data pwm_regulator_info[1] = {
{
- .pwm_id = 2,
- .pwm_gpio = RK2928_PIN0_PD4,
- .pwm_iomux_name = GPIO0D4_PWM_2_NAME,
- .pwm_iomux_pwm = GPIO0D_PWM_2,
- .pwm_iomux_gpio = GPIO0D_GPIO0D4,
.pwm_voltage = 1200000,
.suspend_voltage = 1050000,
.min_uV = 1000000,
}
},
};
-#endif
+static int __init pwm_reg_board_init(void)
+{
+ struct pwm_io_config *cfg;
+ int ret = check_reg_pwm_param();
+
+ if(ret < 0)
+ return ret;
+
+ cfg = &pwm_cfg[reg_pwm];
+ pwm_regulator_info[0].pwm_id = reg_pwm;
+ pwm_regulator_info[0].pwm_iomux_name = cfg->mux_name;
+ pwm_regulator_info[0].pwm_iomux_pwm = cfg->pwm_mode;
+ pwm_regulator_info[0].pwm_iomux_gpio = cfg->io_mode;
+ pwm_regulator_info[0].pwm_gpio = cfg->gpio;
+
+ return 0;
+}
+#else
+static int __init pwm_reg_board_init(void)
+{
+ return 0;
+}
+#endif
/***********************************************************
* usb wifi
************************************************************/
#if defined(CONFIG_RTL8192CU) || defined(CONFIG_RTL8188EU)
-
static void rkusb_wifi_power(int on) {
struct regulator *ldo = NULL;
+#ifndef RK2926_TB_DEFAULT_CONFIG
#if defined(CONFIG_MFD_TPS65910)
if(pmic_is_tps65910()) {
ldo = regulator_get(NULL, "vmmc"); //vccio_wl
regulator_put(ldo);
udelay(100);
+#endif
}
-
#endif
/**************************************************************************************************
#define RK29SDK_WIFI_SDIO_CARD_DETECT_N RK2928_PIN0_PB2
+#define RK29SDK_SD_CARD_DETECT_N RK2928_PIN2_PA7 //According to your own project to set the value of card-detect-pin.
+#define RK29SDK_SD_CARD_INSERT_LEVEL GPIO_LOW // set the voltage of insert-card. Please pay attention to the default setting.
+
+
#endif //endif ---#ifdef CONFIG_SDMMC_RK29
#ifdef CONFIG_SDMMC0_RK29
{
rk29_sdmmc_set_iomux(0, 0xFFFF);
+#if defined(CONFIG_SDMMC0_RK29_SDCARD_DET_FROM_GPIO)
+ rk30_mux_api_set(GPIO1C1_MMC0_DETN_NAME, GPIO1C_GPIO1C1);
+ // gpio_request(RK29SDK_SD_CARD_DETECT_N, "sd-detect");
+ // gpio_direction_output(RK29SDK_SD_CARD_DETECT_N,GPIO_HIGH);//set mmc0-data1 to high.
+#else
rk30_mux_api_set(GPIO1C1_MMC0_DETN_NAME, GPIO1C_MMC0_DETN);
+#endif
#if defined(CONFIG_SDMMC0_RK29_WRITE_PROTECT)
gpio_request(SDMMC0_WRITE_PROTECT_PIN, "sdmmc-wp");
#else
.use_dma = 0,
#endif
- .detect_irq = RK2928_PIN1_PC1, // INVALID_GPIO
+
+#if defined(CONFIG_SDMMC0_RK29_SDCARD_DET_FROM_GPIO)
+ .detect_irq = RK29SDK_SD_CARD_DETECT_N,
+ .insert_card_level = RK29SDK_SD_CARD_INSERT_LEVEL,
+#else
+ .detect_irq = INVALID_GPIO,
+#endif
+
.enable_sd_wakeup = 0,
#if defined(CONFIG_SDMMC0_RK29_WRITE_PROTECT)
};
#endif // CONFIG_SDMMC0_RK29
+#if defined(CONFIG_SDMMC0_RK29_SDCARD_DET_FROM_GPIO)
+static int __init sdmmc_board_init(void)
+{
+ struct port_config port;
+ int ret = check_sdmmc_param();
+
+ if(ret < 0)
+ return ret;
+ if(sd_det == -1)
+ return 0;
+ port = get_port_config(sd_det);
+
+ default_sdmmc0_data.detect_irq = port.gpio;
+ default_sdmmc0_data.insert_card_level = !port.io.active_low;
+ return 0;
+}
+#else
+static int __init sdmmc_board_init(void)
+{
+ return 0;
+}
+#endif
+
#ifdef CONFIG_SND_SOC_RK2928
static struct resource resources_acodec[] = {
{
.flags = IORESOURCE_MEM,
},
{
- .start = RK2928_PIN1_PA0,
- .end = RK2928_PIN1_PA0,
.flags = IORESOURCE_IO,
},
};
.num_resources = ARRAY_SIZE(resources_acodec),
.resource = resources_acodec,
};
+
+static int __init codec_board_init(void)
+{
+ int gpio;
+ int ret = check_codec_param();
+
+ if(ret < 0)
+ return ret;
+ gpio = get_port_config(spk_ctl).gpio;
+ resources_acodec[1].start = gpio;
+ resources_acodec[1].end = gpio;
+ return 0;
+}
+#else
+static int __init codec_board_init(void)
+{
+ return 0;
+}
+#endif
+#ifdef CONFIG_BATTERY_RK30_ADC_FAC
+#if defined(CONFIG_REGULATOR_ACT8931)
+extern int act8931_charge_det;
+extern int act8931_charge_ok;
+
+int rk30_battery_adc_io_init(void){
+ int ret = 0;
+
+ if(dc_det == -1)
+ return 0;
+
+ ret = port_input_init(dc_det, "dc_det");
+ if (ret) {
+ printk("%s: port(%d) input init faild\n", __func__, dc_det);
+ return ret ;
+ }
+
+ return 0;
+}
+
+int rk30_battery_adc_is_dc_charging( ){
+ return act8931_charge_det ;
+}
+int rk30_battery_adc_charging_ok( ){
+ return act8931_charge_ok ;
+}
+#endif
+
+static struct rk30_adc_battery_platform_data rk30_adc_battery_platdata = {
+ .dc_det_pin = INVALID_GPIO,
+ .batt_low_pin = INVALID_GPIO,
+ .charge_set_pin = INVALID_GPIO,
+ .charge_ok_pin = INVALID_GPIO,
+
+ //.io_init = rk30_battery_adc_io_init,
+ #if defined(CONFIG_REGULATOR_ACT8931)
+ .is_dc_charging = rk30_battery_adc_is_dc_charging,
+ .charging_ok = rk30_battery_adc_charging_ok ,
+ #endif
+
+ .charging_sleep = 0 ,
+ .save_capacity = 1 ,
+ .adc_channel = 0 ,
+};
+
+static struct platform_device rk30_device_adc_battery = {
+ .name = "rk30-battery",
+ .id = -1,
+ .dev = {
+ .platform_data = &rk30_adc_battery_platdata,
+ },
+};
#endif
static struct platform_device *devices[] __initdata = {
#ifdef CONFIG_SND_SOC_RK2928
&device_acodec,
#endif
-};
-//i2c
-#ifdef CONFIG_I2C0_RK30
-#ifdef CONFIG_MFD_TPS65910
-#define TPS65910_HOST_IRQ RK2928_PIN1_PB2
-#include "board-rk2928-a720-tps65910.c"
-#endif
-#ifdef CONFIG_REGULATOR_ACT8931
-#include "board-rk2928-sdk-act8931.c"
+#ifdef CONFIG_BATTERY_RK30_ADC_FAC
+ &rk30_device_adc_battery,
#endif
+};
-static struct i2c_board_info __initdata i2c0_info[] = {
-#if defined (CONFIG_MFD_TPS65910)
- {
- .type = "tps65910",
- .addr = TPS65910_I2C_ID0,
- .flags = 0,
- .irq = TPS65910_HOST_IRQ,
- .platform_data = &tps65910_data,
- },
-#endif
-#if defined (CONFIG_REGULATOR_ACT8931)
- {
- .type = "act8931",
- .addr = 0x5b,
- .flags = 0,
- .platform_data=&act8931_data,
- },
-#endif
+#if defined (CONFIG_MFD_TPS65910) && defined (CONFIG_REGULATOR_ACT8931)
+#define TPS65910_HOST_IRQ INVALID_GPIO
+#include "board-rk2928-sdk-tps65910.c"
+#include "board-rk2928-sdk-act8931.c"
+static struct i2c_board_info __initdata pmic_info = {
+ .flags = 0,
};
-#endif
+static int __init pmic_board_init(void)
+{
+ int ret = 0;
+ struct port_config port;
+
+ ret = check_pmic_param();
+ if(ret < 0)
+ return ret;
+ if(pmic_irq != -1){
+ port = get_port_config(pmic_irq);
+ pmic_info.irq = port.gpio;
+ }
+ if(pmic_type == PMIC_TYPE_TPS65910){
+ strcpy(pmic_info.type, "tps65910");
+ pmic_info.platform_data = &tps65910_data;
-int __sramdata gpio0d4_iomux,gpio0d4_do,gpio0d4_dir;
+ tps65910_data.irq = port.gpio;
+ }
+ if(pmic_type == PMIC_TYPE_ACT8931){
+ strcpy(pmic_info.type, "act8931");
+ pmic_info.platform_data = &act8931_data;
+ }
+ pmic_info.addr = pmic_addr;
+ i2c_register_board_info(pmic_i2c, &pmic_info, 1);
-#ifndef gpio_readl
-#define gpio_readl(offset) readl_relaxed(RK2928_GPIO0_BASE + offset)
-#define gpio_writel(v, offset) do { writel_relaxed(v, RK2928_GPIO0_BASE + offset); dsb(); } while (0)
+ return 0;
+}
+#else
+static int __init pmic_board_init(void)
+{
+ return 0;
+}
#endif
+#define GPIO_SWPORTA_DR 0x0000
+#define GPIO_SWPORTA_DDR 0x0004
+#define PWM_MUX_REG (GRF_GPIO0D_IOMUX)
+#define PWM_DDR_REG (RK2928_GPIO0_BASE + GPIO_SWPORTA_DDR)
+#define PWM_DR_REG (RK2928_GPIO0_BASE + GPIO_SWPORTA_DR)
+
+#define mux_set_gpio_mode(id) do { writel_relaxed( 1 << (20 + (id) * 2), PWM_MUX_REG); dsb(); } while (0)
+#define mux_set_pwm_mode(id) do { writel_relaxed( (1 << (20 + (id) * 2)) | (1 << (4 + (id) * 2)), PWM_MUX_REG); dsb(); } while (0)
+
+#define pwm_output_high(id) do {\
+ writel_relaxed(readl_relaxed(PWM_DDR_REG) | (1 << (26 + (id))), PWM_DDR_REG); \
+ writel_relaxed(readl_relaxed(PWM_DR_REG) | (1 << (26 + (id))), PWM_DR_REG); \
+ dsb(); \
+ } while (0)
+
void __sramfunc rk30_pwm_logic_suspend_voltage(void)
{
#ifdef CONFIG_RK30_PWM_REGULATOR
-// int gpio0d7_iomux,gpio0d7_do,gpio0d7_dir,gpio0d7_en;
sram_udelay(10000);
- gpio0d4_iomux = readl_relaxed(GRF_GPIO0D_IOMUX);
- gpio0d4_do = gpio_readl(GPIO_SWPORTA_DR);
- gpio0d4_dir = gpio_readl(GPIO_SWPORTA_DDR);
-
- writel_relaxed((gpio0d4_iomux |(1<<24)) & (~(1<<8)), GRF_GPIO0D_IOMUX);
- gpio_writel(gpio0d4_dir |(1<<28), GPIO_SWPORTA_DDR);
- gpio_writel(gpio0d4_do |(1<<28), GPIO_SWPORTA_DR);
-
+ mux_set_gpio_mode(reg_pwm);
+ pwm_output_high(reg_pwm);
#endif
}
void __sramfunc rk30_pwm_logic_resume_voltage(void)
{
#ifdef CONFIG_RK30_PWM_REGULATOR
- writel_relaxed((1<<24)|gpio0d4_iomux, GRF_GPIO0D_IOMUX);
- gpio_writel(gpio0d4_dir, GPIO_SWPORTA_DDR);
- gpio_writel(gpio0d4_do, GPIO_SWPORTA_DR);
+ mux_set_pwm_mode(reg_pwm);
sram_udelay(10000);
-
#endif
-
}
+
extern void pwm_suspend_voltage(void);
extern void pwm_resume_voltage(void);
void rk30_pwm_suspend_voltage_set(void)
#endif
}
+//i2c
+#ifdef CONFIG_I2C0_RK30
+static struct i2c_board_info __initdata i2c0_info[] = {
+};
+#endif
#ifdef CONFIG_I2C1_RK30
static struct i2c_board_info __initdata i2c1_info[] = {
-#if defined (CONFIG_GS_MMA7660)
- {
- .type = "gs_mma7660",
- .addr = 0x4c,
- .flags = 0,
- .irq = MMA7660_INT_PIN,
- .platform_data = &mma7660_info,
- },
-#endif
-
};
#endif
#ifdef CONFIG_I2C2_RK30
static struct i2c_board_info __initdata i2c2_info[] = {
-#if defined (CONFIG_TOUCHSCREEN_SITRONIX_A720)
-{
- .type ="sitronix",
- .addr = 0x38,
- .flags = 0,
- .irq = TOUCH_INT_PIN,
- .platform_data = &sitronix_info,
-},
-#endif
};
#endif
#ifdef CONFIG_I2C3_RK30
}
//end of i2c
-#define POWER_ON_PIN RK2928_PIN1_PA2 //power_hold
+/**************** gsensor ****************/
+// kxtik
+static int kxtik_init_platform_hw(void)
+{
+ return 0;
+}
+
+static struct sensor_platform_data kxtik_data = {
+ .type = SENSOR_TYPE_ACCEL,
+ .irq_enable = 1,
+ .poll_delay_ms = 30,
+ .init_platform_hw = kxtik_init_platform_hw,
+};
+struct i2c_board_info __initdata kxtik_info = {
+ .type = "gs_kxtik",
+ .flags = 0,
+ .platform_data = &kxtik_data,
+};
+#if defined (CONFIG_GS_MMA8452)
+static int mma8452_init_platform_hw(void)
+{
+ return 0;
+}
+
+static struct sensor_platform_data mma8452_data = {
+ .type = SENSOR_TYPE_ACCEL,
+ .irq_enable = 1,
+ .poll_delay_ms = 30,
+ .init_platform_hw = mma8452_init_platform_hw,
+};
+struct i2c_board_info __initdata mma8452_info = {
+ .type = "gs_mma8452",
+ .flags = 0,
+ .platform_data = &mma8452_data,
+};
+#endif
+#if defined (CONFIG_GS_MMA7660)
+static int mma7660_init_platform_hw(void)
+{
+ return 0;
+}
+
+static struct sensor_platform_data mma7660_data = {
+ .type = SENSOR_TYPE_ACCEL,
+ .irq_enable = 1,
+ .poll_delay_ms = 30,
+ .init_platform_hw = mma7660_init_platform_hw,
+};
+struct i2c_board_info __initdata mma7660_info = {
+ .type = "gs_mma7660",
+ .flags = 0,
+ .platform_data = &mma7660_data,
+};
+#endif
+static int __init gs_board_init(void)
+{
+ int i;
+ struct port_config port;
+ int ret = check_gs_param();
+
+ if(ret < 0)
+ return ret;
+ port = get_port_config(gs_irq);
+ //kxtik
+ kxtik_info.irq = port.gpio;
+ kxtik_info.addr = gs_addr;
+ for(i = 0; i < 9; i++)
+ kxtik_data.orientation[i] = gs_orig[i];
+ i2c_register_board_info(gs_i2c, &kxtik_info, 1);
+ //mma7660
+#if defined (CONFIG_GS_MMA7660)
+ if(gs_type == GS_TYPE_MMA7660){
+ mma7660_info.irq = port.gpio;
+ mma7660_info.addr = gs_addr;
+ for(i = 0; i < 9; i++)
+ mma7660_data.orientation[i] = gs_orig[i];
+ i2c_register_board_info(gs_i2c, &mma7660_info, 1);
+ }
+#endif
+#if defined (CONFIG_GS_MMA8452)
+ if(gs_type == GS_TYPE_MMA8452){
+ mma8452_info.irq = port.gpio;
+ mma8452_info.addr = gs_addr;
+ for(i = 0; i < 9; i++)
+ mma8452_data.orientation[i] = gs_orig[i];
+ i2c_register_board_info(gs_i2c, &mma8452_info, 1);
+ }
+#endif
+
+ return 0;
+}
+
+#if defined (CONFIG_RTC_HYM8563)
+struct i2c_board_info __initdata rtc_info = {
+ .type = "rtc_hym8563",
+ .flags = 0,
+};
+static int __init rtc_board_init(void)
+{
+ struct port_config port;
+ int ret;
+
+ if(pmic_type == PMIC_TYPE_TPS65910)
+ return 0;
+
+ ret = check_rtc_param();
+ if(ret < 0)
+ return ret;
+ port = get_port_config(rtc_irq);
+ rtc_info.irq = port.gpio;
+ rtc_info.addr = rtc_addr;
+ i2c_register_board_info(rtc_i2c, &rtc_info, 1);
+
+ return 0;
+}
+#else
+static int __init rtc_board_init(void)
+{
+ return 0;
+}
+#endif
+
+static int __init rk2928_config_init(void)
+{
+ int ret = 0;
+
+ ret = key_board_init();
+ if(ret < 0)
+ return ret;
+ ret = bl_board_init();
+ if(ret < 0)
+ return ret;
+ ret = lcd_board_init();
+ if(ret < 0)
+ return ret;
+ ret = ion_board_init();
+ if(ret < 0)
+ return ret;
+ ret = pwm_reg_board_init();
+ if(ret < 0)
+ return ret;
+ ret = gs_board_init();
+ if(ret < 0)
+ return ret;
+ ret = rtc_board_init();
+ if(ret < 0)
+ return ret;
+ ret = pmic_board_init();
+ if(ret < 0)
+ return ret;
+ ret = codec_board_init();
+ if(ret < 0)
+ return ret;
+ ret = sdmmc_board_init();
+ if(ret < 0)
+ return ret;
+ return 0;
+}
+#if defined(CONFIG_REGULATOR_ACT8931)
+extern int act8931_charge_det;
+#endif
static void rk2928_pm_power_off(void)
{
printk(KERN_ERR "rk2928_pm_power_off start...\n");
+ #if defined(CONFIG_REGULATOR_ACT8931)
+ if(pmic_type == PMIC_TYPE_ACT8931)
+ {
+ if(act8931_charge_det)
+ arm_pm_restart(0, NULL);
+ }
+ #endif
#if defined(CONFIG_MFD_TPS65910)
if(pmic_is_tps65910())
tps65910_device_shutdown();//tps65910 shutdown
}
#endif
- gpio_direction_output(POWER_ON_PIN, GPIO_LOW);
+ rk2928_power_off();
};
* @logic_volt : logic voltage arm requests depend on frequency
* comments : min arm/logic voltage
*/
-static struct dvfs_arm_table dvfs_cpu_logic_table[16] = {
- { .frequency = 216 * 1000, .cpu_volt = 1200 * 1000, .logic_volt = 1200 * 1000 },
- { .frequency = 312 * 1000, .cpu_volt = 1200 * 1000, .logic_volt = 1200 * 1000 },
- { .frequency = 408 * 1000, .cpu_volt = 1200 * 1000, .logic_volt = 1200 * 1000 },
- { .frequency = 504 * 1000, .cpu_volt = 1200 * 1000, .logic_volt = 1200 * 1000 },
- { .frequency = 600 * 1000, .cpu_volt = 1200 * 1000, .logic_volt = 1200 * 1000 },
- { .frequency = 696 * 1000, .cpu_volt = 1400 * 1000, .logic_volt = 1200 * 1000 },
- { .frequency = 816 * 1000, .cpu_volt = 1400 * 1000, .logic_volt = 1200 * 1000 },
-// { .frequency = 912 * 1000, .cpu_volt = 1400 * 1000, .logic_volt = 1200 * 1000 },
-// { .frequency =1008 * 1000, .cpu_volt = 1400 * 1000, .logic_volt = 1200 * 1000 },
- { .frequency = CPUFREQ_TABLE_END },
-};
-static unsigned int dvfs_cpu_logic[ARRAY_SIZE(dvfs_cpu_logic_table) * 3];
-static unsigned int dvfs_cpu_logic_num;
-module_param_array(dvfs_cpu_logic, uint, &dvfs_cpu_logic_num, 0400);
-
-static struct cpufreq_frequency_table dvfs_gpu_table[4] = {
- { .frequency = 266 * 1000, .index = 1050 * 1000 },
- { .frequency = 400 * 1000, .index = 1275 * 1000 },
- { .frequency = CPUFREQ_TABLE_END },
-};
-static unsigned int dvfs_gpu[ARRAY_SIZE(dvfs_gpu_table) * 2];
-static unsigned int dvfs_gpu_num;
-module_param_array(dvfs_gpu, uint, &dvfs_gpu_num, 0400);
-
-#if 0
-static struct cpufreq_frequency_table dvfs_ddr_table[4] = {
- { .frequency = 300 * 1000, .index = 1050 * 1000 },
- { .frequency = 400 * 1000, .index = 1125 * 1000 },
- { .frequency = CPUFREQ_TABLE_END },
-};
-static unsigned int dvfs_ddr[ARRAY_SIZE(dvfs_ddr_table) * 2];
-static unsigned int dvfs_ddr_num;
-module_param_array(dvfs_ddr, uint, &dvfs_ddr_num, 0400);
-#endif
-
#define DVFS_CPU_TABLE_SIZE (ARRAY_SIZE(dvfs_cpu_logic_table))
static struct cpufreq_frequency_table cpu_dvfs_table[DVFS_CPU_TABLE_SIZE];
static struct cpufreq_frequency_table dep_cpu2core_table[DVFS_CPU_TABLE_SIZE];
static void __init rk2928_board_init(void)
{
- gpio_request(POWER_ON_PIN, "poweronpin");
- gpio_direction_output(POWER_ON_PIN, GPIO_HIGH);
+ rk2928_power_on();
+ rk2928_config_init();
pm_power_off = rk2928_pm_power_off;
board_init_dvfs();
+
rk30_i2c_register_board_info();
spi_register_board_info(board_spi_devices, ARRAY_SIZE(board_spi_devices));
platform_add_devices(devices, ARRAY_SIZE(devices));
}
-
static void __init rk2928_reserve(void)
{
#ifdef CONFIG_ION
- rk30_ion_pdata.heaps[0].base = board_mem_reserve_add("ion", ION_RESERVE_SIZE);
+ rk30_ion_pdata.heaps[0].base = board_mem_reserve_add("ion", ion_size);
#endif
#ifdef CONFIG_FB_ROCKCHIP
resource_fb[0].start = board_mem_reserve_add("fb0", RK30_FB0_MEM_SIZE);
--- /dev/null
+#ifndef __MACH_CONFIG_H
+#define __MACH_CONFIG_H
+#include <mach/board.h>
+
+#define RK2926_TB_DEFAULT_CONFIG
+
+#if defined(RK2926_TB_DEFAULT_CONFIG)
+/* keyboard */
+enum{
+ DEF_KEY_ADC = 1,
+ DEF_PLAY_KEY = 0x000101a4,
+ DEF_VOLDN_KEY = 0x000102b4,
+ DEF_VOLUP_KEY = 1 | (1<<31),
+ DEF_MENU_KEY = 135 | (1<<31),
+ DEF_ESC_KEY = 334 | (1<<31),
+ DEF_HOME_KEY = 550 | (1<<31),
+ DEF_CAM_KEY = 700 | (1<<31),
+};
+/* backlight */
+enum{
+ DEF_BL_PWM = 0,
+ DEF_BL_REF = 1,
+ DEF_BL_MIN = 60,
+ DEF_BL_EN = 0x000002c1,
+};
+/* lcd */
+enum {
+ DEF_LCD_CABC = 0x000002c3,
+ DEF_LCD_EN = -1,
+ DEF_LCD_STD = -1,
+};
+
+#define DEF_LCD_PARAM {SCREEN_LVDS, OUT_D888_P666, \
+ 65000000, 30000000, \
+ 10, 100, 1024, 210, \
+ 10, 10, 768, 18, \
+ 202, 102, \
+ 1, 0 }
+/* gsensor */
+enum {
+ GS_TYPE_NONE = 0,
+ GS_TYPE_MMA8452,
+ GS_TYPE_MMA7660,
+ GS_TYPE_MAX,
+};
+
+enum {
+ DEF_GS_TYPE = GS_TYPE_MMA8452,
+ DEF_GS_I2C = 0,
+ DEF_GS_ADDR = 0x1d,
+ DEF_GS_IRQ = 0x008001b2,
+ DEF_GS_PWR = -1,
+};
+#define DEF_GS_ORIG {-1, 0, 0, 0, 0, 1, 0,-1, 0}
+/* pwm regulator */
+enum {
+ DEF_REG_PWM = 1,
+};
+/* pmic */
+enum {
+ DEF_PMIC_TYPE = PMIC_TYPE_TPS65910,
+ DEF_PMIC_SLP = 0x000001a1,
+ DEF_PMIC_IRQ = 0x000001b1,
+ DEF_PMIC_I2C = 1,
+ DEF_PMIC_ADDR = 0x2d,
+};
+/* ion */
+enum {
+ DEF_ION_SIZE = 80 * 1024 * 1024,
+};
+/* codec */
+enum {
+ DEF_SPK_CTL = 0x000001a0,
+ DEF_HP_DET = -1,
+};
+/* sdmmc */
+enum {
+ DEF_SD_DET = 0x000102a7,
+};
+/* wifi */
+enum {
+ WIFI_NONE = 0,
+ WIFI_USB_NONE = 1<<4,
+ //here: add usb wifi type
+ WIFI_USB_MAX,
+ WIFI_SDIO_NONE = 1<<8,
+ //here: add sdio wifi type
+ WIFI_SDIO_MAX,
+};
+
+enum {
+ DEF_WIFI_RST = -1,
+ DEF_WIFI_PWR = -1,
+ DEF_WIFI_TYPE = WIFI_NONE,
+};
+/* rtc */
+enum {
+ DEF_RTC_I2C = 0,
+ DEF_RTC_ADDR = 0x51,
+ DEF_RTC_IRQ = -1,
+};
+/* charge */
+enum {
+ DEF_CHG_ADC = 0,
+ DEF_DC_DET = -1,
+ DEF_BAT_LOW = -1,
+ DEF_CHG_OK = -1,
+ DEF_CHG_SET = -1,
+ DEF_CHG_SEL = -1,
+};
+
+/* global */
+enum {
+ DEF_PWR_ON = 0x000001a2,
+};
+#else
+/* keyboard */
+enum{
+ DEF_KEY_ADC = -1,
+ DEF_PLAY_KEY = -1,
+ DEF_VOLDN_KEY = -1,
+ DEF_VOLUP_KEY = 0,
+ DEF_MENU_KEY = 0,
+ DEF_ESC_KEY = 0,
+ DEF_HOME_KEY = 0,
+ DEF_CAM_KEY = 0,
+};
+/* backlight */
+enum{
+ DEF_BL_PWM = -1,
+ DEF_BL_REF = 0,
+ DEF_BL_MIN = 0,
+ DEF_BL_EN = -1,
+};
+/* lcd */
+enum {
+ DEF_LCD_CABC = -1,
+ DEF_LCD_EN = -1,
+ DEF_LCD_STD = -1,
+};
+
+#define DEF_LCD_PARAM {0, 0, \
+ 0, 0, \
+ 0, 0, 0, 0, \
+ 0, 0, 0, 0, \
+ 0, 0, \
+ 0, 0 }
+/* gsensor */
+enum {
+ GS_TYPE_NONE = 0,
+ GS_TYPE_MMA8452,
+ GS_TYPE_MMA7660,
+ GS_TYPE_MAX,
+};
+
+enum {
+ DEF_GS_TYPE = GS_TYPE_NONE,
+ DEF_GS_I2C = -1,
+ DEF_GS_ADDR = -1,
+ DEF_GS_IRQ = -1,
+ DEF_GS_PWR = -1,
+};
+#define DEF_GS_ORIG {0, 0, 0, 0, 0, 0, 0, 0, 0}
+/* pwm regulator */
+enum {
+ DEF_REG_PWM = -1,
+};
+/* pmic */
+enum {
+ DEF_PMIC_TYPE = PMIC_TYPE_NONE,
+ DEF_PMIC_SLP = -1,
+ DEF_PMIC_IRQ = -1,
+ DEF_PMIC_I2C = -1,
+ DEF_PMIC_ADDR = -1,
+};
+/* ion */
+enum {
+ DEF_ION_SIZE = 80 * 1024 * 1024,
+};
+/* codec */
+enum {
+ DEF_SPK_CTL = -1,
+ DEF_HP_DET = -1,
+};
+/* sdmmc */
+enum {
+ DEF_SD_DET = -1,
+};
+/* wifi */
+enum {
+ WIFI_NONE = 0,
+ WIFI_USB_NONE = 1<<4,
+ //here: add usb wifi type
+ WIFI_USB_MAX,
+ WIFI_SDIO_NONE = 1<<8,
+ //here: add sdio wifi type
+ WIFI_SDIO_MAX,
+};
+
+enum {
+ DEF_WIFI_RST = -1,
+ DEF_WIFI_PWR = -1,
+ DEF_WIFI_TYPE = WIFI_NONE,
+};
+/* rtc */
+enum {
+ DEF_RTC_I2C = -1,
+ DEF_RTC_ADDR = -1,
+ DEF_RTC_IRQ = -1,
+};
+/* charge */
+enum {
+ DEF_CHG_ADC = -1,
+ DEF_DC_DET = -1,
+ DEF_BAT_LOW = -1,
+ DEF_CHG_OK = -1,
+ DEF_CHG_SET = -1,
+ DEF_CHG_SEL = -1,
+};
+
+/* global */
+enum {
+ DEF_PWR_ON = -1,
+};
+
+#endif
+
+#endif
ret = gpio_request(port.gpio, name);
if(ret < 0)
return ret;
- gpio_pull_updown(port.gpio, port.io.pull_mode);
+ if(port.io.pull_mode == PULL_MODE_DISABLE)
+ gpio_pull_updown(port.gpio, 0);
+ if(port.io.pull_mode == PULL_MODE_ENABLE)
+ gpio_pull_updown(port.gpio, 1);
gpio_direction_output(port.gpio, (on)? !port.io.active_low: !!port.io.active_low);
return 0;
ret = gpio_request(port.gpio, name);
if(ret < 0)
return ret;
- gpio_pull_updown(port.gpio, port.io.pull_mode);
+ if(port.io.pull_mode == PULL_MODE_DISABLE)
+ gpio_pull_updown(port.gpio, 0);
+ if(port.io.pull_mode == PULL_MODE_ENABLE)
+ gpio_pull_updown(port.gpio, 1);
gpio_direction_input(port.gpio);
return 0;
};
enum {
- PMIC_TYPE_NOE =0,
+ PMIC_TYPE_NONE =0,
PMIC_TYPE_WM8326 =1,
PMIC_TYPE_TPS65910 =2,
PMIC_TYPE_ACT8931 =3,
* gpio = RKXX_PIN(bank)_P(goff)(off)
* e.g. bank=2, goff=A, off=3 ==>gpio is RKXX_PIN2_PA3
*/
+enum {
+ PULL_MODE_NONE = 0,
+ PULL_MODE_DISABLE,
+ PULL_MODE_ENABLE,
+};
struct irq_config{
unsigned int off:4, //bit[3:0]
goff:4,
#include <linux/irq.h>
#include <linux/async.h>
#include <mach/board.h>
+#include <mach/config.h>
#ifdef CONFIG_HAS_EARLYSUSPEND
#include <linux/earlysuspend.h>
#endif
+#define TP_MODULE_NAME "egalax_i2c"
+#ifdef CONFIG_RK_CONFIG
+
+enum {
+#ifdef RK2926_TB_DEFAULT_CONFIG
+ DEF_EN = 1,
+#else
+ DEF_EN = 0,
+#endif
+ DEF_IRQ = 0x008001b0,
+ DEF_RST = 0X000002b0,
+ DEF_I2C = 2,
+ DEF_ADDR = 0x04,
+ DEF_X_MAX = 1087,
+ DEF_Y_MAX = 800,
+};
+static int en = DEF_EN;
+module_param(en, int, 0644);
+
+static int irq = DEF_IRQ;
+module_param(irq, int, 0644);
+static int rst =DEF_RST;
+module_param(rst, int, 0644);
+
+static int i2c = DEF_I2C; // i2c channel
+module_param(i2c, int, 0644);
+static int addr = DEF_ADDR; // i2c addr
+module_param(addr, int, 0644);
+static int x_max = DEF_X_MAX;
+module_param(x_max, int, 0644);
+static int y_max = DEF_Y_MAX;
+module_param(y_max, int, 0644);
+
+static int tp_hw_init(void)
+{
+ int ret = 0;
+
+ ret = gpio_request(get_port_config(irq).gpio, "tp_irq");
+ if(ret < 0){
+ printk("%s: gpio_request(irq gpio) failed\n", __func__);
+ return ret;
+ }
+
+ ret = port_output_init(rst, 0, "tp_rst");
+ if(ret < 0){
+ printk("%s: port(rst) output init faild\n", __func__);
+ return ret;
+ }
+ port_output_on(rst);
+
+ return 0;
+}
+#include "rk_tp.c"
+#endif
+
//#define DEBUG
#ifdef CONFIG_EETI_EGALAX_DEBUG
#define TS_DEBUG(fmt,args...) printk( KERN_DEBUG "[egalax_i2c]: " fmt, ## args)
#define DBG()
#endif
+
//#define _NON_INPUT_DEV // define this to disable register input device
static int global_major = 0; // dynamic major by default
__set_bit(EV_ABS, pInputDev->evbit);
input_mt_init_slots(pInputDev, MAX_SUPPORT_POINT);
+#ifdef CONFIG_RK_CONFIG
+ input_set_abs_params(pInputDev, ABS_MT_POSITION_X, 0, x_max, 0, 0);
+ input_set_abs_params(pInputDev, ABS_MT_POSITION_Y, 0, y_max, 0, 0);
+#else
input_set_abs_params(pInputDev, ABS_MT_POSITION_X, 0, CONFIG_EETI_EGALAX_MAX_X, 0, 0);
input_set_abs_params(pInputDev, ABS_MT_POSITION_Y, 0, CONFIG_EETI_EGALAX_MAX_Y, 0, 0);
+#endif
input_set_abs_params(pInputDev, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
ret = input_register_device(pInputDev);
void egalax_i2c_set_standby(struct i2c_client *client, int enable)
{
+#ifndef CONFIG_RK_CONFIG
struct eeti_egalax_platform_data *mach_info = client->dev.platform_data;
unsigned display_on = mach_info->disp_on_pin;
unsigned lcd_standby = mach_info->standby_pin;
int display_on_pol = mach_info->disp_on_value;
int lcd_standby_pol = mach_info->standby_value;
-#ifndef CONFIG_ARCH_RK2928
printk("%s : %s, enable = %d", __FILE__, __FUNCTION__,enable);
if(display_on != INVALID_GPIO)
{
static int __devinit egalax_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
int ret;
- int gpio = client->irq;
- struct eeti_egalax_platform_data *pdata = pdata = client->dev.platform_data;
+ int gpio;
+#ifdef CONFIG_RK_CONFIG
+ struct port_config irq_cfg = get_port_config(irq);
+ client->irq = irq_cfg.gpio;
+ tp_hw_init();
+#else
+ struct eeti_egalax_platform_data *pdata = pdata = client->dev.platform_data;
+ if (pdata->init_platform_hw)
+ pdata->init_platform_hw();
+#endif
printk(KERN_DEBUG "[egalax_i2c]: start probe\n");
+ gpio = client->irq;
p_egalax_i2c_dev = (struct _egalax_i2c *)kzalloc(sizeof(struct _egalax_i2c), GFP_KERNEL);
if (!p_egalax_i2c_dev)
memset(PointBuf, 0, sizeof(struct point_data)*MAX_SUPPORT_POINT);
#endif //#ifndef _NON_INPUT_DEV
-if (pdata->init_platform_hw)
- pdata->init_platform_hw();
p_egalax_i2c_dev->client = client;
mutex_init(&p_egalax_i2c_dev->mutex_wq);
p_egalax_i2c_dev->work_state = 1;
p_egalax_i2c_dev->irq = gpio_to_irq(client->irq);
-
+#ifdef CONFIG_RK_CONFIG
+ ret = request_irq(p_egalax_i2c_dev->irq, egalax_i2c_interrupt, irq_cfg.irq.irq_flags,
+ client->name, p_egalax_i2c_dev);
+#else
ret = request_irq(p_egalax_i2c_dev->irq, egalax_i2c_interrupt, IRQF_TRIGGER_LOW,
client->name, p_egalax_i2c_dev);
+#endif
if( ret )
{
printk(KERN_ERR "[egalax_i2c]: request irq(%d) failed\n", p_egalax_i2c_dev->irq);
}
static struct i2c_device_id egalax_i2c_idtable[] = {
- { "egalax_i2c", 0 },
+ { TP_MODULE_NAME, 0 },
{ }
};
static struct i2c_driver egalax_i2c_driver = {
.driver = {
- .name = "egalax_i2c",
+ .name = TP_MODULE_NAME,
},
.id_table = egalax_i2c_idtable,
.probe = egalax_i2c_probe,
static int __init egalax_i2c_ts_init(void)
{
+#ifdef CONFIG_RK_CONFIG
+ int ret = tp_board_init();
+
+ if(ret < 0)
+ return ret;
+#endif
async_schedule(egalax_i2c_ts_init_async, NULL);
return 0;
}
--- /dev/null
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/interrupt.h>
+#include <linux/i2c.h>
+
+
+static int check_tp_param(void)
+{
+ if(en == 0 || i2c == -1 || addr == -1 || x_max == -1 || y_max == -1){
+ printk("touchpad: en: %d, i2c: %d, addr: 0x%x, x_max: %d, y_max: %d\n",
+ en, i2c, addr, x_max, y_max);
+ return -EINVAL;
+ }else{
+ return 0;
+ }
+}
+
+struct i2c_board_info __initdata tp_info = {
+ .type = TP_MODULE_NAME,
+ .flags = 0,
+};
+
+static int tp_board_init(void)
+{
+ int ret = 0;
+
+ ret = check_tp_param();
+ if(ret < 0)
+ return ret;
+
+ tp_info.addr = addr;
+ ret = i2c_add_device(i2c, &tp_info);
+
+ return ret;
+}
+
prompt "LCD Panel Select"
config LCD_NULL
bool "NULL"
+config LCD_RK2928
+ bool "RK2928 LCD"
+ depends on MACH_RK2928
config LCD_LG_LP097X02
bool "RGB LCD_LG_LP097X02 1024X768"
config LCD_TD043MGEA1
config LCD_I30_800X480
bool "lcd I30"
-
endchoice
obj-$(CONFIG_LCD_NULL) += lcd_null.o
+obj-$(CONFIG_LCD_RK2928) += lcd_rk2928.o
obj-$(CONFIG_LCD_TD043MGEA1) += lcd_td043mgea1.o
obj-$(CONFIG_LCD_HSD070IDW1) += lcd_hsd800x480.o
--- /dev/null
+#include <linux/fb.h>\r
+#include <linux/delay.h>\r
+#include "../../rk29_fb.h"\r
+#include <mach/gpio.h>\r
+#include <mach/iomux.h>\r
+#include <mach/board.h>\r
+#include <mach/config.h>\r
+#include "../../rockchip/hdmi/rk_hdmi.h"\r
+#include "screen.h"\r
+\r
+enum {\r
+ OUT_TYPE_INDEX = 0,\r
+ OUT_FACE_INDEX,\r
+ OUT_CLK_INDEX,\r
+ LCDC_ACLK_INDEX,\r
+ H_PW_INDEX,\r
+ H_BP_INDEX,\r
+ H_VD_INDEX,\r
+ H_FP_INDEX,\r
+ V_PW_INDEX,\r
+ V_BP_INDEX,\r
+ V_VD_INDEX,\r
+ V_FP_INDEX,\r
+ LCD_WIDTH_INDEX,\r
+ LCD_HEIGHT_INDEX,\r
+ DCLK_POL_INDEX,\r
+ SWAP_RB_INDEX,\r
+ LCD_PARAM_MAX,\r
+};\r
+uint lcd_param[LCD_PARAM_MAX] = DEF_LCD_PARAM;\r
+module_param_array(lcd_param, uint, NULL, 0644);\r
+\r
+#define set_scaler_info NULL\r
+\r
+void set_lcd_info(struct rk29fb_screen *screen, struct rk29lcd_info *lcd_info )\r
+{\r
+ /* screen type & face */\r
+ screen->type = lcd_param[OUT_TYPE_INDEX];\r
+ screen->face = lcd_param[OUT_FACE_INDEX];\r
+ screen->hw_format = 1;\r
+\r
+ /* Screen size */\r
+ screen->x_res = lcd_param[H_VD_INDEX];\r
+ screen->y_res = lcd_param[V_VD_INDEX];\r
+\r
+ screen->width = lcd_param[LCD_WIDTH_INDEX];\r
+ screen->height = lcd_param[LCD_HEIGHT_INDEX];\r
+\r
+ /* Timing */\r
+ screen->lcdc_aclk = lcd_param[LCDC_ACLK_INDEX];\r
+ screen->pixclock = lcd_param[OUT_CLK_INDEX];\r
+ screen->left_margin = lcd_param[H_BP_INDEX];\r
+ screen->right_margin = lcd_param[H_FP_INDEX];\r
+ screen->hsync_len = lcd_param[H_PW_INDEX];\r
+ screen->upper_margin = lcd_param[V_BP_INDEX];\r
+ screen->lower_margin = lcd_param[V_FP_INDEX];\r
+ screen->vsync_len = lcd_param[V_PW_INDEX];\r
+\r
+ /* Pin polarity */\r
+ screen->pin_hsync = 0;\r
+ screen->pin_vsync = 0;\r
+ screen->pin_den = 0;\r
+ screen->pin_dclk = lcd_param[DCLK_POL_INDEX];\r
+\r
+ /* Swap rule */\r
+ screen->swap_rb = lcd_param[SWAP_RB_INDEX];\r
+ screen->swap_rg = 0;\r
+ screen->swap_gb = 0;\r
+ screen->swap_delta = 0;\r
+ screen->swap_dumy = 0;\r
+\r
+ /* Operation function*/\r
+ screen->init = NULL;\r
+ screen->standby = NULL;\r
+}\r
+\r
+\r
+\r
********************************************************************/
/* */
#define OUT_P888 0
-#define OUT_P666 1 //
-#define OUT_P565 2 //
+#define OUT_P666 1
+#define OUT_P565 2
#define OUT_S888x 4
#define OUT_CCIR656 6
#define OUT_S888 8
#define OUT_S888DUMY 12
-#define OUT_P16BPP4 24 //
-#define OUT_D888_P666 0x21 //
-#define OUT_D888_P565 0x22 //
+#define OUT_P16BPP4 24
+#define OUT_D888_P666 0x21
+#define OUT_D888_P565 0x22
/**
projects / firefly-linux-kernel-4.4.55.git / commitdiff