imx6开关机/亮屏逻辑笔记

最新推荐文章于 2022-12-18 20:47:52 发布
最新推荐文章于 2022-12-18 20:47:52 发布
阅读量1.1k 收藏
点赞数
分类专栏： 开关机屏幕控制 文章标签： 开关机屏幕控制
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BGK112358/article/details/80091831
版权

点亮屏幕是由mcu控制，但是arm要在开机初始化framebuffer后通过一个lcd_ready脚来通知mcu点亮屏幕

关机/休眠的灭屏与掉电要等mcu发出关机/休眠信号，通知hmi保存重要数据后，消息中心才执行关机命令，关机后通过lcd_ready脚点平通知mcu允许掉电


开机亮屏部分，这部分比较容易定义一个io引脚，放到framebuffer初始化完成的的驱动代码中，代码如下，基于linux3.14.28

引入一个io引脚定义

power-gpios = <&gpio1 11 GPIO_ACTIVE_LOW>;
mxcfb1: fb@0 {
    compatible = "fsl,mxc_sdc_fb";
    disp_dev = "ldb";
    interface_pix_fmt = "RGB24";
    default_bpp = <24>;
    int_clk = <0>;
    late_init = <0>;
    power-gpios = <&gpio1 11 GPIO_ACTIVE_LOW>;
    status = "disabled";
};

在显示驱动里调用io引脚函数，开机显示就绪后拉低io，mcu检测到引脚拉低后点亮屏幕背光

struct power_gpios {
    int power_gpios_gpio;
    unsigned long gpio_level;   // 0: on  1: off
    int g_first_ldb;
};

static struct power_gpios g_power_gpios = {0,0,1};

g_power_gpios.power_gpios_gpio = of_get_named_gpio_flags(np, "power-gpios", 0, &flags);
if (gpio_is_valid(g_power_gpios.power_gpios_gpio))
{
	printk("[power_gpios] mxcfb_probe gpio_is_valid, ret = %d \n", gpio_is_valid(g_power_gpios.power_gpios_gpio));

	if(!gpio_request(g_power_gpios.power_gpios_gpio, "power_gpios"))
	{
		printk("[power_gpios] mxcfb_probe gpio_request \n");
		gpio_direction_output(g_power_gpios.power_gpios_gpio, 1);
		gpio_set_value(g_power_gpios.power_gpios_gpio, 0);

		g_power_gpios.gpio_level = 0;
	}
}

通知关机的部分相对坑多，在开部分已经被坑了，只是不影响功能所以看不出来

关机逻辑是为了应对在没有只读文件系统的前提下频繁掉电引起的emmc程序丢失，数据损坏的问题

mcu发出关机命令后，系统进行关机，关机完成后对lcd_ready引脚拉高电平，mcu检测到高电平后方可给arm断电

这里采用了增加属性节点的方式来进行io引脚的控制

加入了class属性的节点，这部分没有保留就拿了一个类似的写在文章里

#include <linux/miscdevice.h>
#include <linux/input.h>
#include <linux/clk.h>
#include <linux/delay.h>
#include <asm/io.h>
#include <asm/uaccess.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/of_gpio.h>
#include <linux/gpio.h>
#include <linux/of_platform.h>
#include <linux/device.h>

struct shutdown_io {
	int shutdown_io_gpio;
	unsigned long gpio_level;	// 0:PA mute on  1:PA mute off
};

static struct shutdown_io g_shutdown_io;
static struct class *shutdown_io_class;

static ssize_t enable_store(struct class *class, struct class_attribute *attr,
			const char *buf, size_t count)
{
	int rc;
	unsigned long gpio_level = 0;

	rc = kstrtoul(buf, 0, &gpio_level);
	if (rc)
		return rc;

	if (gpio_is_valid(g_shutdown_io.shutdown_io_gpio))
	{
		gpio_direction_output(g_shutdown_io.shutdown_io_gpio, 1);
		gpio_set_value(g_shutdown_io.shutdown_io_gpio, gpio_level);

		g_shutdown_io.gpio_level = gpio_level;

		//printk("[bgk] 43 shutdown_io enable_store, gpio_level = %ld \n", gpio_level);
	}
	else
	{
		printk("[bgk] 46 shutdown_io gpio_is_valid failed \n");
	}

	return count;
}

static ssize_t enable_show(struct class *class, struct class_attribute *attr, char *buf)
{
	if (gpio_is_valid(g_shutdown_io.shutdown_io_gpio))
	{
		//printk("[bgk] 34 shutdown_io enable_show, gpio_level = %ld \n", g_shutdown_io.gpio_level);
	}
	else
	{
		printk("[bgk] 35 shutdown_io gpio_is_valid failed \n");
		return -1;
	}

	return sprintf(buf, "%ld\n", g_shutdown_io.gpio_level);
}

static CLASS_ATTR(enable, 0755, enable_show, enable_store);


static int shutdown_io_probe(struct platform_device *pdev)
{
	int ret = -1;
	enum of_gpio_flags flag;
	struct device_node *shutdown_io_node = pdev->dev.of_node;
	g_shutdown_io.shutdown_io_gpio = of_get_named_gpio_flags(shutdown_io_node, "enable-gpios", 0, &flag);
	//printk("[bgk] 8001 shutdown_io_probe, get gpio id successful \n");

	if(!gpio_is_valid(g_shutdown_io.shutdown_io_gpio))
	{
		printk("[bgk] 8002 invalid shutdown_io-gpios: %d\n", g_shutdown_io.shutdown_io_gpio);
		return -1;
	}

	if(gpio_request(g_shutdown_io.shutdown_io_gpio, "shutdown_io_gpio"))
	{
		printk("[bgk] 8003 shutdown_io gpio request failed! \n");
		return ret; 
	}

	gpio_direction_output(g_shutdown_io.shutdown_io_gpio, 1);
	gpio_set_value(g_shutdown_io.shutdown_io_gpio, 1);

	g_shutdown_io.gpio_level = 1;

	shutdown_io_class = class_create(THIS_MODULE, "shutdown_io");
	if (IS_ERR(shutdown_io_class)) {
		pr_warn("Unable to create backlight class; errno = %ld\n",
			PTR_ERR(shutdown_io_class));
		return PTR_ERR(shutdown_io_class);
	}


	ret = class_create_file(shutdown_io_class, &class_attr_enable);
	if(ret < 0)
	{
		printk("[bgk] 8004 shutdown_io class_create_file failed! \n");
		return -ENOMEM;
	}

	return 0;
}

static int shutdown_io_remove(struct platform_device *pdev)
{
	if(!gpio_is_valid(g_shutdown_io.shutdown_io_gpio))
	{
		printk("[bgk] 8005 invalid shutdown_io-gpios: %d\n", g_shutdown_io.shutdown_io_gpio); 
		return -1;
	}
	gpio_set_value(g_shutdown_io.shutdown_io_gpio, 0);
	gpio_free(g_shutdown_io.shutdown_io_gpio);

	class_remove_file(shutdown_io_class, &class_attr_enable);
	class_destroy(shutdown_io_class);

	return 0;
}

static struct of_device_id shutdown_io_of_match[] = {
		{ .compatible = "shutdown_io" },
		{ }
};
MODULE_DEVICE_TABLE(of, shutdown_io_of_match);


static struct platform_driver shutdown_io_driver = {
		.driver	= {
			.name		= "shutdown_io",
			.owner		= THIS_MODULE,
			.of_match_table = of_match_ptr(shutdown_io_of_match),
		},
		.probe			= shutdown_io_probe,
		.remove			= shutdown_io_remove,
};

module_platform_driver(shutdown_io_driver);

MODULE_DESCRIPTION("shutdown_io Driver");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:shutdown_io");

这部分代码加在了drivers/video/mxc/mxc_ipuv3_fb.c的mxcfb_probe函数中最末尾

信心满满去验证属性节点，结果当头一棒，运行提示权限不足运行失败

怀疑是属性节点的使用条件问题，多次检测属性节点的使用条件，在平台驱动里调用，打印返回值也都是正确的，就是在应用层访问属性节点的时候提示权限问题，但这个提示显然不是因为创建属性节点时指定的权限问题

static CLASS_ATTR(enable, 0755, enable_show, enable_store);
很是迷茫，百度这个函数，竟然没有任何收获，倒是看源码得出正确时返回0，这是也确实返回0 
class_create_file

在mxc_ipuv3_fb.c里看到有引用了device_create_file，设备属性节点的创建，而且能正确运转，于是将class属性节点更换为device属性节点

struct power_gpios {
    int power_gpios_gpio;
    unsigned long gpio_level;   // 0: on  1: off
    int g_first_ldb;
};

static struct power_gpios g_power_gpios = {0,0,1};
static struct class *power_gpios_class;

static ssize_t enable_show(struct device *dev,
                struct device_attribute *attr, char *buf)
{
    printk("[power_gpios] enable_show, power_gpios_gpio = %d \n", g_power_gpios.power_gpios_gpio);
    if (gpio_is_valid(g_power_gpios.power_gpios_gpio))
    {
        printk("[bgk] 34 power_gpios enable_show, gpio_level = %ld \n", g_power_gpios.gpio_level);
    }
    else
    {
        printk("[bgk] 35 power_gpios gpio_is_valid failed, ret = %d \n", gpio_is_valid(g_power_gpios.power_gpios_gpio));
        return -1;
    }

    return sprintf(buf, "%ld\n", g_power_gpios.gpio_level);
}

static ssize_t enable_store(struct device *dev,
                    struct device_attribute *attr,
                    const char *buf, size_t count)
{

    int rc;
    unsigned long gpio_level = 0;
    printk("[power_gpios] enable_store, power_gpios_gpio = %d \n", g_power_gpios.power_gpios_gpio);

    rc = kstrtoul(buf, 0, &gpio_level);
    if (rc)
        return rc;

    if (gpio_is_valid(g_power_gpios.power_gpios_gpio))
    {
        gpio_direction_output(g_power_gpios.power_gpios_gpio, 1);
        gpio_set_value(g_power_gpios.power_gpios_gpio, gpio_level);

        g_power_gpios.gpio_level = gpio_level;

        printk("[bgk] 43 power_gpios enable_store, gpio_level = %ld \n", gpio_level);
    }
    else
    {
        printk("[bgk] 35 power_gpios gpio_is_valid failed, ret = %d \n", gpio_is_valid(g_power_gpios.power_gpios_gpio));
    }

    return count;
}

static DEVICE_ATTR(lcd_power, S_IWUSR | S_IRUGO, enable_show, enable_store);

ret = device_create_file(fbi->dev, &dev_attr_lcd_power);
			printk("[bgk] device_create_file ret = %d \n", ret);
			if (ret)
			dev_err(&pdev->dev, "Error %d on creating fdev_attr_enable "
					" device propety\n", ret);

更换完之后出了属性节点的路径不同，无法读取节点的现象是一样的，故排除了class属性节点或者device属性节点的原因，问题定位到enbale_show和enable_store这两个函数

static DEVICE_ATTR(lcd_power, S_IWUSR | S_IRUGO, enable_show, enable_store);

将这两个函数留空后，正确运行，定位到操作io的函数，通过打印发现drivers/video/mxc/mxc_ipuv3_fb.c的mxcfb_probe函数被执行了3次，说明有3个设备被找到并进行了注册，这个是导致IO引脚运行一场的根本原因

mxcfb1: fb@0 {
    compatible = "fsl,mxc_sdc_fb";
    disp_dev = "ldb";
    interface_pix_fmt = "RGB24";
    default_bpp = <24>;
    int_clk = <0>;
    late_init = <0>;
    power-gpios = <&gpio1 11 GPIO_ACTIVE_LOW>;
    status = "disabled";
};
// modified-end by xiongqin.bi for 720p

mxcfb2: fb@1 {
    compatible = "fsl,mxc_sdc_fb";
    disp_dev = "hdmi";
    interface_pix_fmt = "RGB24";
    mode_str ="1920x1080M@60";
    default_bpp = <24>;
    int_clk = <0>;
    late_init = <0>;
    status = "disabled";
};

mxcfb3: fb@2 {
    compatible = "fsl,mxc_sdc_fb";
    disp_dev = "lcd";
    interface_pix_fmt = "RGB565";
    mode_str ="CLAA-WVGA";
    default_bpp = <16>;
    int_clk = <0>;
    late_init = <0>;
    status = "disabled";
};

mxcfb4: fb@3 {
    compatible = "fsl,mxc_sdc_fb";
    disp_dev = "ldb";
    interface_pix_fmt = "RGB666";
    default_bpp = <16>;
    int_clk = <0>;
    late_init = <0>;
    status = "disabled";
};
将dts中的显示设备遍历到驱动里在mxcfb_dispdrv_init函数进行，disp_dev数组则是存放着每次注册的显示设备 
static int mxcfb_dispdrv_init(struct platform_device *pdev,
		struct fb_info *fbi)
{
	struct ipuv3_fb_platform_data *plat_data = pdev->dev.platform_data;
	struct mxcfb_info *mxcfbi = (struct mxcfb_info *)fbi->par;
	struct mxc_dispdrv_setting setting;
	char disp_dev[32], *default_dev = "lcd";
	int ret = 0;

	setting.if_fmt = plat_data->interface_pix_fmt;
	setting.dft_mode_str = plat_data->mode_str;
	setting.default_bpp = plat_data->default_bpp;
	if (!setting.default_bpp)
		setting.default_bpp = 16;
	setting.fbi = fbi;
	if (!strlen(plat_data->disp_dev)) {
		memcpy(disp_dev, default_dev, strlen(default_dev));
		disp_dev[strlen(default_dev)] = '\0';
	} else {
		memcpy(disp_dev, plat_data->disp_dev,
				strlen(plat_data->disp_dev));
		disp_dev[strlen(plat_data->disp_dev)] = '\0';
	}

	mxcfbi->dispdrv = mxc_dispdrv_gethandle(disp_dev, &setting);
	if (IS_ERR(mxcfbi->dispdrv)) {
		ret = PTR_ERR(mxcfbi->dispdrv);
		dev_err(&pdev->dev, "NO mxc display driver found!\n");
		return ret;
	} else {
		/* fix-up  */
		mxcfbi->ipu_di_pix_fmt = setting.if_fmt;
		mxcfbi->default_bpp = setting.default_bpp;

		ret = mxcfb_get_crtc(&pdev->dev, mxcfbi, setting.crtc);
		if (ret)
			return ret;

		dev_dbg(&pdev->dev, "di_pixfmt:0x%x, bpp:0x%x, di:%d, ipu:%d\n",
				setting.if_fmt, setting.default_bpp,
				mxcfbi->ipu_di, mxcfbi->ipu_id);
	}

	dev_info(&pdev->dev, "registered mxc display driver %s\n", disp_dev);

	return ret;
}

定位到原因之后就做过滤，只在注册ldb驱动的时候创建和调用属性节点

struct power_gpios {
    int power_gpios_gpio;
    unsigned long gpio_level;   // 0: on  1: off
    int g_first_ldb;
};

static struct power_gpios g_power_gpios = {0,0,1};
static struct class *power_gpios_class;

static ssize_t enable_show(struct device *dev,
                struct device_attribute *attr, char *buf)
{
    printk("[power_gpios] enable_show, power_gpios_gpio = %d \n", g_power_gpios.power_gpios_gpio);
    if (gpio_is_valid(g_power_gpios.power_gpios_gpio))
    {
        printk("[bgk] 34 power_gpios enable_show, gpio_level = %ld \n", g_power_gpios.gpio_level);
    }
    else
    {
        printk("[bgk] 35 power_gpios gpio_is_valid failed, ret = %d \n", gpio_is_valid(g_power_gpios.power_gpios_gpio));
        return -1;
    }

    return sprintf(buf, "%ld\n", g_power_gpios.gpio_level);
}

static ssize_t enable_store(struct device *dev,
                    struct device_attribute *attr,
                    const char *buf, size_t count)
{

    int rc;
    unsigned long gpio_level = 0;
    printk("[power_gpios] enable_store, power_gpios_gpio = %d \n", g_power_gpios.power_gpios_gpio);

    rc = kstrtoul(buf, 0, &gpio_level);
    if (rc)
        return rc;

    if (gpio_is_valid(g_power_gpios.power_gpios_gpio))
    {
        gpio_direction_output(g_power_gpios.power_gpios_gpio, 1);
        gpio_set_value(g_power_gpios.power_gpios_gpio, gpio_level);

        g_power_gpios.gpio_level = gpio_level;

        printk("[bgk] 43 power_gpios enable_store, gpio_level = %ld \n", gpio_level);
    }
    else
    {
        printk("[bgk] 35 power_gpios gpio_is_valid failed, ret = %d \n", gpio_is_valid(g_power_gpios.power_gpios_gpio));
    }

    return count;
}

static DEVICE_ATTR(lcd_power, S_IWUSR | S_IRUGO, enable_show, enable_store);

static int mxcfb_probe(struct platform_device *pdev)
{
    // int lcd_ready;
    enum of_gpio_flags flags;
    struct device_node *np = pdev->dev.of_node;

    struct ipuv3_fb_platform_data *plat_data;
    struct fb_info *fbi;
    struct mxcfb_info *mxcfbi;
    struct resource *res;
    int ret = 0;

    dev_dbg(&pdev->dev, "%s enter\n", __func__);
    pdev->id = of_alias_get_id(pdev->dev.of_node, "mxcfb");
    if (pdev->id < 0) {
        dev_err(&pdev->dev, "can not get alias id\n");
        return pdev->id;
    }

    plat_data = devm_kzalloc(&pdev->dev, sizeof(struct
                    ipuv3_fb_platform_data), GFP_KERNEL);
    if (!plat_data)
        return -ENOMEM;
    pdev->dev.platform_data = plat_data;

    ret = mxcfb_get_of_property(pdev, plat_data);
    if (ret < 0) {
        dev_err(&pdev->dev, "get mxcfb of property fail\n");
        return ret;
    }

    /* Initialize FB structures */
    fbi = mxcfb_init_fbinfo(&pdev->dev, &mxcfb_ops);
    if (!fbi) {
        ret = -ENOMEM;
        goto init_fbinfo_failed;
    }

    ret = mxcfb_option_setup(pdev, fbi);
    if (ret)
        goto get_fb_option_failed;

    mxcfbi = (struct mxcfb_info *)fbi->par;
    mxcfbi->ipu_int_clk = plat_data->int_clk;
    mxcfbi->late_init = plat_data->late_init;
    mxcfbi->first_set_par = true;
    ret = mxcfb_dispdrv_init(pdev, fbi);
    if (ret < 0)
        goto init_dispdrv_failed;

    ret = ipu_test_set_usage(mxcfbi->ipu_id, mxcfbi->ipu_di);
    if (ret < 0) {
        dev_err(&pdev->dev, "ipu%d-di%d already in use\n",
                mxcfbi->ipu_id, mxcfbi->ipu_di);
        goto ipu_in_busy;
    }

    res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
    if (res && res->start && res->end) {
        fbi->fix.smem_len = res->end - res->start + 1;
        fbi->fix.smem_start = res->start;
        fbi->screen_base = ioremap(fbi->fix.smem_start, fbi->fix.smem_len);
        /* Do not clear the fb content drawn in bootloader. */
        if (!mxcfbi->late_init)
            memset(fbi->screen_base, 0, fbi->fix.smem_len);
    }

    mxcfbi->ipu = ipu_get_soc(mxcfbi->ipu_id);
    if (IS_ERR(mxcfbi->ipu)) {
        ret = -ENODEV;
        goto get_ipu_failed;
    }

    /* first user uses DP with alpha feature */
    if (!g_dp_in_use[mxcfbi->ipu_id]) {
        mxcfbi->ipu_ch_irq = IPU_IRQ_BG_SYNC_EOF;
        mxcfbi->ipu_ch_nf_irq = IPU_IRQ_BG_SYNC_NFACK;
        mxcfbi->ipu_alp_ch_irq = IPU_IRQ_BG_ALPHA_SYNC_EOF;
        mxcfbi->ipu_ch = MEM_BG_SYNC;
        /* Unblank the primary fb only by default */
        if (pdev->id == 0)
            mxcfbi->cur_blank = mxcfbi->next_blank = FB_BLANK_UNBLANK;
        else
            mxcfbi->cur_blank = mxcfbi->next_blank = FB_BLANK_POWERDOWN;

        ret = mxcfb_register(fbi);
        if (ret < 0)
            goto mxcfb_register_failed;

        ipu_disp_set_global_alpha(mxcfbi->ipu, mxcfbi->ipu_ch,
                      true, 0x80);
        ipu_disp_set_color_key(mxcfbi->ipu, mxcfbi->ipu_ch, false, 0);

        res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
        ret = mxcfb_setup_overlay(pdev, fbi, res);

        if (ret < 0) {
            mxcfb_unregister(fbi);
            goto mxcfb_setupoverlay_failed;
        }

        g_dp_in_use[mxcfbi->ipu_id] = true;

        ret = device_create_file(mxcfbi->ovfbi->dev,
                     &dev_attr_fsl_disp_property);
        if (ret)
            dev_err(mxcfbi->ovfbi->dev, "Error %d on creating "
                            "file for disp property\n",
                            ret);

        ret = device_create_file(mxcfbi->ovfbi->dev,
                     &dev_attr_fsl_disp_dev_property);
        if (ret)
            dev_err(mxcfbi->ovfbi->dev, "Error %d on creating "
                            "file for disp device "
                            "propety\n", ret);
    } else {
        mxcfbi->ipu_ch_irq = IPU_IRQ_DC_SYNC_EOF;
        mxcfbi->ipu_ch_nf_irq = IPU_IRQ_DC_SYNC_NFACK;
        mxcfbi->ipu_alp_ch_irq = -1;
        mxcfbi->ipu_ch = MEM_DC_SYNC;
        mxcfbi->cur_blank = mxcfbi->next_blank = FB_BLANK_POWERDOWN;

        ret = mxcfb_register(fbi);
        if (ret < 0)
            goto mxcfb_register_failed;
    }

    platform_set_drvdata(pdev, fbi);

    ret = device_create_file(fbi->dev, &dev_attr_fsl_disp_property);
    if (ret)
        dev_err(&pdev->dev, "Error %d on creating file for disp "
                    "property\n", ret);

    ret = device_create_file(fbi->dev, &dev_attr_fsl_disp_dev_property);
    if (ret)
        dev_err(&pdev->dev, "Error %d on creating file for disp "
                    " device propety\n", ret);

    // add bi.xiongqin
    printk("[bgk] pdev->dev.platform_data->disp_dev = %s \n ", plat_data->disp_dev);
    if (!strcmp(plat_data->disp_dev, "ldb"))
    {
        printk("[bgk] g_first_ldb = %d \n ", g_power_gpios.g_first_ldb);
        if (g_power_gpios.g_first_ldb == true)
        {
            g_power_gpios.g_first_ldb = false;

            ret = device_create_file(fbi->dev, &dev_attr_lcd_power);
            printk("[bgk] device_create_file ret = %d \n", ret);
            if (ret)
            dev_err(&pdev->dev, "Error %d on creating fdev_attr_enable "
                    " device propety\n", ret);

            g_power_gpios.power_gpios_gpio = of_get_named_gpio_flags(np, "power-gpios", 0, &flags);
            printk("[power_gpios] gpio_is_valid, power_gpios_gpio = %d \n", g_power_gpios.power_gpios_gpio);
            if (gpio_is_valid(g_power_gpios.power_gpios_gpio))
            {
                printk("[power_gpios] mxcfb_probe gpio_is_valid, ret = %d \n", gpio_is_valid(g_power_gpios.power_gpios_gpio));

                if(!gpio_request(g_power_gpios.power_gpios_gpio, "power_gpios"))
                {
                    printk("[power_gpios] mxcfb_probe gpio_request \n");
                    gpio_direction_output(g_power_gpios.power_gpios_gpio, 1);
                    gpio_set_value(g_power_gpios.power_gpios_gpio, 0);

                    g_power_gpios.gpio_level = 0;
                }
            }
        }
    }
    // end bi.xiongqin

    return 0;

mxcfb_setupoverlay_failed:
mxcfb_register_failed:
get_ipu_failed:
    ipu_clear_usage(mxcfbi->ipu_id, mxcfbi->ipu_di);
ipu_in_busy:
init_dispdrv_failed:
    fb_dealloc_cmap(&fbi->cmap);
    framebuffer_release(fbi);
get_fb_option_failed:
init_fbinfo_failed:
    return ret;
}

static int mxcfb_remove(struct platform_device *pdev)
{
    struct fb_info *fbi = platform_get_drvdata(pdev);
    struct mxcfb_info *mxc_fbi = fbi->par;

    if (!fbi)
        return 0;

    device_remove_file(fbi->dev, &dev_attr_fsl_disp_dev_property);
    device_remove_file(fbi->dev, &dev_attr_fsl_disp_property);
    mxcfb_blank(FB_BLANK_POWERDOWN, fbi);
    mxcfb_unregister(fbi);
    mxcfb_unmap_video_memory(fbi);

    if (mxc_fbi->ovfbi) {
        device_remove_file(mxc_fbi->ovfbi->dev,
                   &dev_attr_fsl_disp_dev_property);
        device_remove_file(mxc_fbi->ovfbi->dev,
                   &dev_attr_fsl_disp_property);
        mxcfb_blank(FB_BLANK_POWERDOWN, mxc_fbi->ovfbi);
        mxcfb_unsetup_overlay(fbi);
        mxcfb_unmap_video_memory(mxc_fbi->ovfbi);
    }

    ipu_clear_usage(mxc_fbi->ipu_id, mxc_fbi->ipu_di);
    if (&fbi->cmap)
        fb_dealloc_cmap(&fbi->cmap);
    framebuffer_release(fbi);

    // add bi.xiongqin
    if(!gpio_is_valid(g_power_gpios.power_gpios_gpio))
    { 
        printk("[bgk] 8005 invalid power_gpios-gpios: %d\n", g_power_gpios.power_gpios_gpio); 
        return -1; 
    }
    gpio_set_value(g_power_gpios.power_gpios_gpio, 0);
    gpio_free(g_power_gpios.power_gpios_gpio);

    device_remove_file(fbi->dev, &dev_attr_lcd_power);
    // add bi.xiongqin

    return 0;
}

最后还要在关机的时候调用该属性节点，增加/etc/rc0.d下在S40umountfs之前脚本S34power_gpios.sh

#!/bin/bash
echo 1 > /sys/class/graphics/fb0/lcd_power







BGK112358
关注
专栏目录
imx6调试Lvds屏幕技术笔记
qq_45147279的博客
09-24 1598
打开相对应的设备树文件 mxcfb1: fb@0 { compatible = "fsl,mxc_sdc_fb"; disp_dev = "ldb";//显示设备 interface_pix_fmt = "RGB24";//格式 default_bpp = <32>; int_clk = <0>; late_init = <0>; status = "okay"; }; &ldb { status = "okay"; dual
iMX6从uboot到linux启动完成一直保持LOGO不变
10-11
u-boot启动后会运行液晶初始化程序并显示启动LOGO，但进入linux系统之后，又重新初始化一次，而且uboot与linux定义的显存地址也不一致，导致会有短暂的白屏闪烁。此补丁解决从uboot到linux启动完成一直保持LOGO不变，且中间不闪烁不闪屏。
用C/汇编代码实现imx6ull点灯
weixin_49840285的博客
04-26 1357
一、GPIO的操作方法（参考） 二、看原理图找到一个led灯，确定引脚（搜索led） 如图所示： ① 将GPIO5_3设置为输出引脚，输出低电平有压差灯就亮，输出高电平就灭 ② 将GPIO5_3设置为GPIO模式需要操作的寄存器是SNVS_TAMPER3 三、查看imx6ull的芯片手册 1.打开CCM (clock controller module) ：其中各种子模块中有GPIO模块 上图所示：控制每组GPIO是否使能的寄存器（imx6ull默认都是使能的） 其中CCGP1[CG15]控制的是
IMX6ULL开发板驱动LED灯的代码分析
qq_32089315的博客
12-18 354
IMX6ULL开发板驱动LED灯的代码分析
IMX6ULL裸机开发之配置eLCDIF点亮RGB液晶屏分析及配置过程
qq_43940175的博客
04-21 1483
裸机配置RGB液晶屏显示接口 eLCDIF主要特性 总线主接口到源帧缓冲区数据进行显示刷新。这个接口也可以用于驱动显示器的数据。 PIO接口，以管理显示器和SoC之间的数据传输。 8/16/18/24位LCD数据总线支持可用，具体取决于I/Omux选项。 可编程定时和参数的MPU、VSYNC和DOTCLKLCD接口，以支持多种显示器。 外部接口 LCD_DATA0~LCD_DATA23：24根数据线，用来传输数据。双向IO口。 LCD_BUSY：忙信号线。 LCD_CLK：时钟信号线。 LCD_CS：
[IMX6Q][Android4.4] LCD参数匹配过程分析
Kris Fei's blog
12-25 6672
Platform: IMX6Q OS: Android 4.4 本例只讨论lvds接口的是lcd参数匹配的过程，mipi dsi以及其他接口部分会有一点差异。 重要参数说明： fb_find_mode 用于匹配最佳的lcd时序参数，其中有三部分重要参数。 1. ldb.c中的 ldb_modedb static struct fb_videomode ldb_
IMX219 / IMX291 / IMX307 / IMX385 / IMX334 / IMX335 / IMX415数据手册
02-23
6. **IMX334**：IMX334是一款中等分辨率的传感器，适用于需要平衡性能和成本的应用，如网络摄像头和低端监控设备。 7. **IMX335**：此型号是IMX334的升级版，可能提供了更高的性能指标，比如更高的灵敏度、更快的...
IMX6 Dual/Quad 芯片手册
02-01
根据提供的文件信息，IMX6 Dual/Quad 芯片手册包含了一系列针对该处理器的详细技术描述和参考信息。IMX6 Dual/Quad是NXP（原飞思卡尔半导体）生产的一款应用处理器系列，具有高性能、低功耗的特点，适用于各种嵌入式...
IMX6D&IMX6Q官方技术文档合集
03-30
包括ARMV7架构技术手册、Cortext A9核心技术手册、IMX6D\6Q应用处理器技术手册、具体芯片数据手册等资料。具体参见https://blog.csdn.net/junqiyu/article/details/123856259
天嵌 IMX6Q/E9 TN92 Goodix GT911 Linux 触摸驱动
04-12
在这个场景中，我们关注的是针对天嵌科技IMX6Q/E9开发板上的TN92触摸屏，以及Goodix GT911触摸控制器的Linux驱动程序。Goodix是一家知名的触摸解决方案提供商，其GT911芯片广泛应用于各种智能设备的触控面板。 IMX6...
与LCD移植相关的概念
Qing的专栏
11-21 2273
1. N bit的 LCD 指的是什么意思？我们常常会说18bit 的LCD， 24 bit 的LCD， 是什么意思呢？ 18/24 bit 指的是LCD 数据总线的宽度。 如下图RGB的数据总线： 搞清楚这个是很简单的，但如果你在配置设备树时遇到这样的情况， 往往很容易混淆： mxcfb1: fb@0 { compatible = “fsl,mxc_sdc_fb”
imx6 修改HDMI屏幕自动休眠
smile_5me的博客
05-04 1984
imx6不管是lcd还是hdmi都会在10分钟后自动休眠，但有些时候我们却不希望自动休眠，这个时候我们有两种方法。 一个是修改文件系统的环境变量，但这个方法我不会…………有大神的话可以底下留言。 另外一个就是修改内核vim linux/driver/tty/vt/vt.c在这里找到blank_screen_t()函数 直接return,在编译烧写，屏幕休眠就解决了。
android4.2.2 surfaceflinger,[imx6 ]Android4.4.3--surfaceflinger导致系统起不来，ldb显示问题...
weixin_35717941的博客
05-29 393
我们板子参照sabresd设计的。之前使用系统android4.2.2，现在移植官网BSP android4.4.3目前surfaceflinger导致系统启动失败。一直打印如下红色显示的信息。request_suspend_state: wakeup (3->0) at 7437213333 (1970-01-01 00:00:04.592911333 UTC)130|root@sabre...
4-6q环视之显示,fb的注册
openCpu
11-24 2909
1.硬件规范 2.协议 3.驱动
hud项目lcd调试过程的一些见解
weixin_30674525的博客
07-11 380
1.帧缓冲(FrameBuffer)设备驱动帧缓冲设备为标准的字符型设备，在Linux中主设备号29，定义在/include/uapi/linux/major.h中的FB_MAJOR，次设备号定义帧缓冲的个数，最大允许有32个FrameBuffer，定义在/include/linux/fb.h中的FB_MAX，对应于文件系统下/dev/fb%d设备文件 我们从上面这幅图看，帧...
imx6 framebuffer 分析
weixin_33753845的博客
08-31 474
分析imx6 framebuffer设备和驱动的注册过程。 　　　　　　　　　　　　　　　　　　　　　　　　　　Tony Liu, 2016-8-31, Shenzhen 相关文件： 　　arch/arm/mach-mx6/board-mx6q_sabresd.c 　　kernel/video/mxc/mxc_ipuv3_fb.c 　　mm/memblock.c | 　　drivers/video...
i.MX6ULL驱动开发 | 35 - NXP LCD控制器Framebuffer驱动浅读
Mculover666的博客（嵌入式）
09-08 798
获取更简洁清爽的阅读体验，请移步我的个人博客网站：i.MX6ULL驱动开发 | 35 - NXP LCD控制器Framebuffer驱动浅读。Framebuffer为帧缓存，或者也可以叫做显存，开辟于RAM中。如下图所示，LCD控制器周而复始的从Framebuffer中逐一取出每个像素的颜色值并发送给LCD，所以用户只需要操作Framebuffer即可。基于Framebuffer的显示系统整体架构如下图：Framebuffer框架整体架构如下图：imx6ull开发板的lcdif节点描述如下： NXP原厂的描
S3C2416 中不同LCD尺寸适配
ucas_123的博客
02-16 842
在内核下面/arch/arm/mach-s3c2416/mach-smdk2416.c进行修改。大概在148行，有这样一个结构体 struct s3c_fb_pd_win smdk2416_fb_win[] = { [0] = { /* think this is the same as the smdk6410 */
天嵌TQ_E9卡片电脑移植飞思卡尔yocto L4.1.15_1.0.0_ga 第五篇 LCD+触摸屏移植
zxr1521904712的博客
02-12 1422
经过前面的移植，我们的板子已经可以成功进入linux，但是这个时候看不到画面的，还需要进一步调通LCD显示和触摸屏驱动。 1.uboot环境变量。 为了LCD能显示需要如下设置uboot变量:      $setenv mynetargs 'setenv bootargs console=${console},${baudrate} ${smp} video=${myvideo} root=
IMX6D6A/IMX6Q6A
最新发布
03-19
IMX6D6A和IMX6Q6A是NXP公司推出的两款嵌入式处理器。它们都基于ARM架构，采用了Cortex-A9内核，并且集成了丰富的外设和接口，适用于广泛的应用领域。 IMX6D6A和IMX6Q6A在硬件配置上有一些差异。IMX6D6A是单核处理器...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值