Пример #1
0
static int hva40wv1_get_power(struct lcd_device *ld)
{
	struct hva40wv1_lcd *lcd = lcd_get_data(ld);
	int power;

	switch (lcd->ddev->power_mode) {
	case MCDE_DISPLAY_PM_OFF:
		power = FB_BLANK_POWERDOWN;
		break;
	case MCDE_DISPLAY_PM_STANDBY:
		power = FB_BLANK_NORMAL;
		break;
	case MCDE_DISPLAY_PM_ON:
		power = FB_BLANK_UNBLANK;
		break;
	default:
		power = -1;
		break;
	}
	return power;
}
Пример #2
0
static int l4f00242t03_lcd_power_set(struct lcd_device *ld, int power)
{
    struct l4f00242t03_priv *priv = lcd_get_data(ld);
    struct spi_device *spi = priv->spi;

    const u16 slpout = 0x11;
    const u16 dison = 0x29;

    const u16 slpin = 0x10;
    const u16 disoff = 0x28;

    if (power) {
        if (priv->lcd_on)
            return 0;

        dev_dbg(&spi->dev, "turning on LCD\n");

        spi_write(spi, (const u8 *)&slpout, sizeof(u16));
        msleep(60);
        spi_write(spi, (const u8 *)&dison, sizeof(u16));

        priv->lcd_on = 1;
    } else {
        if (!priv->lcd_on)
            return 0;

        dev_dbg(&spi->dev, "turning off LCD\n");

        spi_write(spi, (const u8 *)&disoff, sizeof(u16));
        msleep(60);
        spi_write(spi, (const u8 *)&slpin, sizeof(u16));

        priv->lcd_on = 0;
    }

    return 0;
}
Пример #3
0
static int picolcd_check_lcd_fb(struct lcd_device *ldev, struct fb_info *fb)
{
	return fb && fb == picolcd_fbinfo((struct picolcd_data *)lcd_get_data(ldev));
}
Пример #4
0
/*
 * lcd class device
 */
static int picolcd_get_contrast(struct lcd_device *ldev)
{
	struct picolcd_data *data = lcd_get_data(ldev);
	return data->lcd_contrast;
}
static int ws2401_get_power(struct lcd_device *ld)
{
	struct ws2401_lcd *lcd = lcd_get_data(ld);

	return lcd->power;
}
Пример #6
0
static int l4f00242t03_lcd_power_get(struct lcd_device *ld)
{
	struct l4f00242t03_priv *priv = lcd_get_data(ld);

	return priv->lcd_state;
}
static inline struct ili9320 *to_our_lcd(struct lcd_device *lcd)
{
	return lcd_get_data(lcd);
}
static int ana38401_get_power(struct lcd_device *ld)
{
	struct lcd_info *lcd = lcd_get_data(ld);

	return lcd->power;
}
Пример #9
0
static int crd080ti01_40nm01_get_power(struct lcd_device *lcd)
{
	struct crd080ti01_40nm01_data *dev= lcd_get_data(lcd);

	return dev->lcd_power;
}
Пример #10
0
static int ili922x_get_power(struct lcd_device *ld)
{
	struct ili922x *ili = lcd_get_data(ld);

	return ili->power;
}
Пример #11
0
static int ili922x_set_power(struct lcd_device *ld, int power)
{
	struct ili922x *ili = lcd_get_data(ld);

	return ili922x_lcd_power(ili, power);
}
Пример #12
0
static int lcd_pwrctrl_check_fb(struct lcd_device *lcd, struct fb_info *info)
{
	struct lcd_pwrctrl *lp = lcd_get_data(lcd);
	return lp->dev->parent == info->device;
}
Пример #13
0
static int lcd_pwrctrl_get_power(struct lcd_device *lcd)
{
	struct lcd_pwrctrl *lp = lcd_get_data(lcd);
	return lp->power;
}
Пример #14
0
static int dove_lcd_get_power(struct lcd_device *ld)
{
    struct dove_backlight *bl = lcd_get_data(ld);

    return bl->lcd_powermode;
}
Пример #15
0
static int lvds_lcd_get_power(struct lcd_device *ld)
{
	struct s6c1372_lcd *lcd = lcd_get_data(ld);

	return lcd->power;
}
Пример #16
0
static int truly_tft240240_get_power(struct lcd_device *lcd)
{
	struct truly_tft240240_data *dev= lcd_get_data(lcd);

	return dev->lcd_power;
}
Пример #17
0
static int auo_a043fl01v2_get_power(struct lcd_device *lcd)
{
	struct auo_a043fl01v2_data *dev= lcd_get_data(lcd);

	return dev->lcd_power;
}
Пример #18
0
static inline struct platform_lcd *to_our_lcd(struct lcd_device *lcd)
{
	return lcd_get_data(lcd);
}
Пример #19
0
static int hx8357_lcd_init(struct lcd_device *lcdev)
{
	struct hx8357_data *lcd = lcd_get_data(lcdev);
	int ret;

	/*
	 * Set the interface selection pins to SPI mode, with three
	 * wires
	 */
	if (lcd->use_im_pins) {
		gpio_set_value_cansleep(lcd->im_pins[0], 1);
		gpio_set_value_cansleep(lcd->im_pins[1], 0);
		gpio_set_value_cansleep(lcd->im_pins[2], 1);
	}

	ret = hx8357_spi_write_array(lcdev, hx8357_seq_power,
				ARRAY_SIZE(hx8357_seq_power));
	if (ret < 0)
		return ret;

	ret = hx8357_spi_write_array(lcdev, hx8357_seq_vcom,
				ARRAY_SIZE(hx8357_seq_vcom));
	if (ret < 0)
		return ret;

	ret = hx8357_spi_write_array(lcdev, hx8357_seq_power_normal,
				ARRAY_SIZE(hx8357_seq_power_normal));
	if (ret < 0)
		return ret;

	ret = hx8357_spi_write_array(lcdev, hx8357_seq_panel_driving,
				ARRAY_SIZE(hx8357_seq_panel_driving));
	if (ret < 0)
		return ret;

	ret = hx8357_spi_write_array(lcdev, hx8357_seq_display_frame,
				ARRAY_SIZE(hx8357_seq_display_frame));
	if (ret < 0)
		return ret;

	ret = hx8357_spi_write_array(lcdev, hx8357_seq_panel_related,
				ARRAY_SIZE(hx8357_seq_panel_related));
	if (ret < 0)
		return ret;

	ret = hx8357_spi_write_array(lcdev, hx8357_seq_undefined1,
				ARRAY_SIZE(hx8357_seq_undefined1));
	if (ret < 0)
		return ret;

	ret = hx8357_spi_write_array(lcdev, hx8357_seq_undefined2,
				ARRAY_SIZE(hx8357_seq_undefined2));
	if (ret < 0)
		return ret;

	ret = hx8357_spi_write_array(lcdev, hx8357_seq_gamma,
				ARRAY_SIZE(hx8357_seq_gamma));
	if (ret < 0)
		return ret;

	ret = hx8357_spi_write_array(lcdev, hx8357_seq_address_mode,
				ARRAY_SIZE(hx8357_seq_address_mode));
	if (ret < 0)
		return ret;

	ret = hx8357_spi_write_array(lcdev, hx8357_seq_pixel_format,
				ARRAY_SIZE(hx8357_seq_pixel_format));
	if (ret < 0)
		return ret;

	ret = hx8357_spi_write_array(lcdev, hx8357_seq_column_address,
				ARRAY_SIZE(hx8357_seq_column_address));
	if (ret < 0)
		return ret;

	ret = hx8357_spi_write_array(lcdev, hx8357_seq_page_address,
				ARRAY_SIZE(hx8357_seq_page_address));
	if (ret < 0)
		return ret;

	ret = hx8357_spi_write_array(lcdev, hx8357_seq_rgb,
				ARRAY_SIZE(hx8357_seq_rgb));
	if (ret < 0)
		return ret;

	ret = hx8357_spi_write_array(lcdev, hx8357_seq_display_mode,
				ARRAY_SIZE(hx8357_seq_display_mode));
	if (ret < 0)
		return ret;

	ret = hx8357_spi_write_byte(lcdev, HX8357_EXIT_SLEEP_MODE);
	if (ret < 0)
		return ret;

	/*
	 * The controller needs 120ms to fully recover from exiting sleep mode
	 */
	msleep(120);

	ret = hx8357_spi_write_byte(lcdev, HX8357_SET_DISPLAY_ON);
	if (ret < 0)
		return ret;

	usleep_range(5000, 7000);

	ret = hx8357_spi_write_byte(lcdev, HX8357_WRITE_MEMORY_START);
	if (ret < 0)
		return ret;

	return 0;
}
static int s6e8ax0_get_power(struct lcd_device *ld)
{
	struct lcd_info *lcd = lcd_get_data(ld);

	return lcd->power;
}
Пример #21
0
static int hx8357_get_power(struct lcd_device *lcdev)
{
	struct hx8357_data *lcd = lcd_get_data(lcdev);

	return lcd->state;
}
Пример #22
0
static int ea8061_get_power(struct lcd_device *ld)
{
	struct ea8061 *lcd = lcd_get_data(ld);

	return lcd->power;
}
static int corgi_lcd_get_power(struct lcd_device *ld)
{
	struct corgi_lcd *lcd = lcd_get_data(ld);

	return lcd->power;
}