Appendix - notro/fbtft-spindle GitHub Wiki

static int
fbdev_open(int scrnIndex, char *dev, char** namep)
{
	struct	fb_fix_screeninfo fix;
	int    fd;

	/* try argument (from XF86Config) first */
	if (dev) {
	    fd = open(dev,O_RDWR,0);
	} else {
	    /* second: environment variable */
	    dev = getenv("FRAMEBUFFER");
	    if ((NULL == dev) || ((fd = open(dev,O_RDWR,0)) == -1)) {
		/* last try: default device */
		dev = "/dev/fb0";
		fd = open(dev,O_RDWR,0);
	    }
	}

    backlight_cookie[0] = xcb_intern_atom (conn, 1, strlen("Backlight"), "Backlight");
    backlight_cookie[1] = xcb_intern_atom (conn, 1, strlen("BACKLIGHT"), "BACKLIGHT");

    backlight_reply = xcb_intern_atom_reply (conn, backlight_cookie[0], &error);
    backlight_new = backlight_reply->atom;

    backlight_reply = xcb_intern_atom_reply (conn, backlight_cookie[1], &error);
    backlight_legacy = backlight_reply->atom;

    if (backlight_new == XCB_NONE && backlight_legacy == XCB_NONE) {
	fprintf (stderr, "No outputs have backlight property\n");
	exit (1);
    }

int do_poke_blanked_console;
int console_blanked;

static int blankinterval = 10*60;
core_param(consoleblank, blankinterval, int, 0444);


static int __init con_init(void)
{
        if (blankinterval) {
                blank_state = blank_normal_wait;
                mod_timer(&console_timer, jiffies + (blankinterval * HZ));
        }
}
console_initcall(con_init);

static void setterm_command(struct vc_data *vc)
{

        switch(vc->vc_par[0]) {
                case 9: /* set blanking interval */
                        blankinterval = ((vc->vc_par[1] < 60) ? vc->vc_par[1] : 60) * 60;
                        poke_blanked_console();
                        break;
                case 13: /* unblank the screen */
                        poke_blanked_console();
                        break;
        }
}

void poke_blanked_console(void)
{
        if (console_blanked)
                unblank_screen();
        else if (blankinterval) {
                mod_timer(&console_timer, jiffies + (blankinterval * HZ));
                blank_state = blank_normal_wait;
        }
}

void do_blank_screen(int entering_gfx)
{
        blank_state = blank_off;

        i = vc->vc_sw->con_blank(vc, vesa_off_interval ? 1 : (vesa_blank_mode + 1), 0);

        del_timer_sync(&console_timer);
        blank_timer_expired = 0;
}

/*
 * Called by timer as well as from vt_console_driver
 */
void do_unblank_screen(int leaving_gfx)
{
        if (blankinterval) {
                mod_timer(&console_timer, jiffies + (blankinterval * HZ));
                blank_state = blank_normal_wait;
        }

        console_blanked = 0;
        if (vc->vc_sw->con_blank(vc, 0, leaving_gfx) || vt_force_oops_output(vc))
}

static DEFINE_TIMER(console_timer, blank_screen_t, 0, 0);
/*
 * We defer the timer blanking to work queue so it can take the console mutex
 * (console operations can still happen at irq time, but only from printk which
 * has the console mutex. Not perfect yet, but better than no locking
 */
static void blank_screen_t(unsigned long dummy)
{
        blank_timer_expired = 1;
        schedule_work(&console_work);
}

static DECLARE_WORK(console_work, console_callback);
static void console_callback(struct work_struct *ignored)
{
        if (blank_timer_expired) {
                do_blank_screen(0);
                blank_timer_expired = 0;
        }
}

static const struct consw fb_con = {
        .con_blank              = fbcon_blank,
};

static int fbcon_blank(struct vc_data *vc, int blank, int mode_switch)
{
                                if (fb_blank(info, blank))
                                        fbcon_generic_blank(vc, info, blank);
}

static void fbcon_generic_blank(struct vc_data *vc, struct fb_info *info,
                                int blank)
{
        fb_notifier_call_chain(FB_EVENT_CONBLANK, &event);
}

static int fb_notifier_callback(struct notifier_block *self,
                                unsigned long event, void *data)
{
                        if (fb_blank == FB_BLANK_UNBLANK &&
                            !bd->fb_bl_on[node]) {
                                bd->fb_bl_on[node] = true;
                                if (!bd->use_count++) {
                                        bd->props.state &= ~BL_CORE_FBBLANK;
                                        bd->props.fb_blank = FB_BLANK_UNBLANK;
                                        backlight_update_status(bd);
                                }
                        } else if (fb_blank != FB_BLANK_UNBLANK &&
                                   bd->fb_bl_on[node]) {
                                bd->fb_bl_on[node] = false;
                                if (!(--bd->use_count)) {
                                        bd->props.state |= BL_CORE_FBBLANK;
                                        bd->props.fb_blank = fb_blank;
                                        backlight_update_status(bd);
                                }
                        }

int fbtft_backlight_update_status(struct backlight_device *bd)
{
	if ((bd->props.power == FB_BLANK_UNBLANK) && (bd->props.fb_blank == FB_BLANK_UNBLANK))
		gpio_set_value(par->gpio.led[0], polarity);
	else
		gpio_set_value(par->gpio.led[0], !polarity);
}