Beispiel #1
0
static void HAL_HW_DONE(bool full)
{
    if ( hal_ops.hal_hw_done && (EINKFB_SUCCESS == EINKFB_LOCK_ENTRY()) )
    {
        hal_ops.hal_hw_done(full);
        EINKFB_LOCK_EXIT();
    }
}
Beispiel #2
0
static void broadsheet_watchdog_thread_body(void)
{
    // Repair us in one way or another if we still should.
    //
    if ( broadsheet_watchdog_timer_active && broadsheet_watchdog_timer_primed )
    {
        broadsheet_watchdog_timer_primed = false;
        
        // Reset Broadsheet if it's not still ready.
        //
        if ( !BS_STILL_READY() && (EINKFB_SUCCESS == EINKFB_LOCK_ENTRY()) )
        {
            // If we were forcing the hardware not to be ready, unforce it now.
            // Forcing the hardware not to be ready is for debugging purposes,
            // and we treat it as a one-shot.
            //
            controller_set_force_hw_not_ready(false);
            
            bs_sw_init(FULL_BRINGUP_CONTROLLER, DONT_BRINGUP_PANEL);
            bs_cmd_ld_img_upd_data(fx_update_partial, UPD_DATA_RESTORE);
            EINKFB_LOCK_EXIT();
            
            // If Broadsheet's still not ready after we've tried to bring it
            // back up, tell the eInk HAL that we're in real trouble.
            //
            if ( !BS_STILL_READY() )
                EINKFB_NEEDS_RESET();
        }
        
        // Do a panel update repair if it hasn't already been done.
        //
        if ( !BS_UPD_REPAIR() && (EINKFB_SUCCESS == EINKFB_LOCK_ENTRY()) )
        {
            bs_cmd_upd_repair();
            EINKFB_LOCK_EXIT();
        }
    }
    
    wait_for_completion_interruptible(&broadsheet_watchdog_thread_complete);
}
Beispiel #3
0
static unsigned long einkfb_set_byte_alignment_y(unsigned long byte_alignment)
{
    if ( hal_ops.hal_byte_alignment_y )
    {
        if ( EINKFB_SUCCESS == EINKFB_LOCK_ENTRY() )
        {
            byte_alignment = hal_ops.hal_byte_alignment_y();
            EINKFB_LOCK_EXIT();
        }
    }

    return ( byte_alignment );
}
Beispiel #4
0
static int hardwarefb_read(char *page, char **start, off_t off, int count, int *eof, void *data)
{
    // Upon first access, dump the hardware's buffer into scratchfb.
    //
    if ( 0 == off )
    {
        if ( EINKFB_SUCCESS == EINKFB_LOCK_ENTRY() )
        {
            broadsheet_read_from_ram(bs_cmd_get_sdr_img_base(), scratchfb, scratchfb_size);
            EINKFB_LOCK_EXIT();
        }
    }
    
    return ( EINKFB_PROC_SYSFS_RW_NO_LOCK(page, start, off, count, eof, scratchfb_size, read_hardwarefb) );
}
Beispiel #5
0
static int eink_ram_write(struct file *file, const char __user *buf, unsigned long count, void *data)
{
    int result = EINKFB_FAILURE;
    
    if ( EINKFB_SUCCESS == EINKFB_LOCK_ENTRY() )
    {
        eink_ram_select_locked = true;
        
        result = EINKFB_PROC_SYSFS_RW_NO_LOCK((char *)buf, NULL, count, 0, NULL, 0, write_eink_ram);
        
        eink_ram_select_locked = false;
        EINKFB_LOCK_EXIT();
    }

    return ( result );
}
Beispiel #6
0
static int eink_ram_read(char *page, char **start, off_t off, int count, int *eof, void *data)
{
    int result = EINKFB_FAILURE;
    
    if ( EINKFB_SUCCESS == EINKFB_LOCK_ENTRY() )
    {
        eink_ram_select_locked = true;
        
        result = EINKFB_PROC_SYSFS_RW_NO_LOCK(page, start, off, count, eof, BROADSHEET_RAM_BANK_SIZE, read_eink_ram);
        
        eink_ram_select_locked = false;
        EINKFB_LOCK_EXIT();
    }

    return ( result );
}
Beispiel #7
0
static int eink_rom_read(char *page, char **start, off_t off, int count, int *eof, void *data)
{
    int result = EINKFB_FAILURE;
    
    if ( EINKFB_SUCCESS == EINKFB_LOCK_ENTRY() )
    {
        eink_rom_select_locked = true;
        
        result = EINKFB_PROC_SYSFS_RW_NO_LOCK(page, start, off, count, eof, broadsheet_flash_size, read_eink_rom);
        
        eink_rom_select_locked = false;
        EINKFB_LOCK_EXIT();
    }

    return ( result );
}
Beispiel #8
0
static bool HAL_HW_INIT(struct fb_info *info, bool bringup_mode)
{
    einkfb_set_reboot_behavior(reboot_screen_clear);
    einkfb_set_sleep_behavior(sleep_behavior_allow_sleep);

    if ( hal_ops.hal_hw_init )
    {
        if ( EINKFB_SUCCESS == EINKFB_LOCK_ENTRY() )
        {
            bringup_mode = hal_ops.hal_hw_init(info, bringup_mode);
            EINKFB_LOCK_EXIT();
        }
    }
    else
        bringup_mode = FULL_BRINGUP;

    return ( bringup_mode );
}
Beispiel #9
0
static int einkfb_reboot(struct notifier_block *self, unsigned long u, void *v)
{
    // Override any power lock-out behavior for reboot.
    //
    POWER_OVERRIDE_BEGIN();

    // Force the display back into portrait mode before rebooting.
    //
    EINKFB_IOCTL(FBIO_EINK_SET_DISPLAY_ORIENTATION, orientation_portrait);

    // Ensure that sleep/off is allowed if applicable.
    //
    einkfb_set_sleep_behavior(sleep_behavior_allow_sleep);

    // Override the requested reboot behavior if we must.
    //
    switch ( u )
    {
    // If we're truly restarting, leave the reboot behavior alone.
    //
    case SYS_RESTART:
        break;

    // On actual shutdowns (or halts), don't put up the splash screen
    // if it's been requested; just clear the screen instead.
    //
    default:
        if ( reboot_screen_splash == einkfb_reboot_behavior )
            einkfb_reboot_behavior = reboot_screen_clear;
        break;
    }

    // If there are hooks, give them a call now.
    //
    if ( einkfb_reboot_hook )
        (*einkfb_reboot_hook)(einkfb_reboot_behavior);

    if ( hal_ops.hal_reboot_hook && (EINKFB_SUCCESS == EINKFB_LOCK_ENTRY()) )
    {
        (*hal_ops.hal_reboot_hook)(einkfb_reboot_behavior);
        EINKFB_LOCK_EXIT();
    }

    // Let any screen updates we've done here complete.
    //
    EINKFB_FSYNC();

    // If getting/setting the power-level is supported, get us either
    // powered off in the screen-clearing case or just suspended in
    // the cases where we're not supposed to clear the screen.
    //
    if ( hal_ops.hal_get_power_level )
    {
        switch ( einkfb_reboot_behavior )
        {
        case reboot_screen_asis:
        case reboot_screen_splash:
            EINKFB_BLANK(FB_BLANK_HSYNC_SUSPEND);
            break;

        case reboot_screen_clear:
            EINKFB_BLANK(FB_BLANK_POWERDOWN);
            break;
        }
    }
    else
    {
        // Otherwise, only clear the screen if we're supposed to.
        //
        if ( einkfb_reboot_behavior )
            einkfb_clear_display(fx_update_full);
    }

    POWER_OVERRIDE_END();

    // Clear all of our hooks, note that the framebuffer is
    // no longer initialized, and clear the ioctl callbacks.
    //
    einkfb_set_reboot_hook(NULL);
    einkfb_set_ioctl_hook(NULL);
    einkfb_set_info_hook(NULL);

    set_fb_init_flag(0);
    set_fb_ioctl(NULL);

    return ( NOTIFY_DONE );
}