static uint32_t microSD_stack[DEFAULT_STACK_SIZE / sizeof(uint32_t)];
static struct sigaction signalHandler;
static struct semaphore event_trigger;
//static enum {
//    STATE_NOT_PRESENT,
//    STATE_PRESENT,
//    STATE_UNKNOWN,
//    
//}
static bool microSD_state = false;

bool mount_microSD(void) {
    int ret = mount("/dev/mmcblk0p1", "/mnt/mmc", "vfat", MS_MGC_VAL | MS_SYNCHRONOUS | MS_RELATIME, "iocharset=utf8");
    if (ret < 0) {
        return false;
    }
    return true;
}

bool umount_microSD(void) {
    int ret = umount2("/mnt/mmc", MNT_FORCE);
    if (ret < 0) {
        return false;
    }
    return true;
}

bool microSD_inserted(void) {
    /* Active LOW */
    return (!gpio_control(DEV_CTRL_GPIO_IS_HIGH, GPIO_SD_SENSE, 0, 0));
}

static void microSD_check(int signal)
{
//        printf("signal received!");
//    if (signal == SIGUSR1) {
    semaphore_release(&event_trigger);
//        printf("wait unlocked");
//    }
}

static void NORETURN_ATTR microSD_thread(void)
{
    while (true) {
        /* Indefinitely wait for an event */
        printf("Released! Checking...\n");
        if (microSD_state != microSD_inserted()) {
            /* Something has changed */
            microSD_state = microSD_inserted();
            /* Wait for the kernel to load microSD device */
            if (microSD_state) {
                printf("microsd inserted\n");
                /* Loading microSD takes some time */
                sleep(HZ);
                mount_microSD();
                printf("microSD mounted\n");
                queue_broadcast(SYS_HOTSWAP_INSERTED, 0);
            }
            else {
            queue_broadcast(SYS_HOTSWAP_EXTRACTED, 0);
                printf("microSD removed\n");
                umount_microSD();
                printf("microSD umounted\n");
                
            }

            queue_broadcast(SYS_FS_CHANGED, 0);
        }
        
        semaphore_wait(&event_trigger, TIMEOUT_BLOCK);
        
    }
}

    
/*    
    bool microsd_init = false;
    if (microSD_inserted()) {
        if (!microSD_state) {
            queue_broadcast(SYS_HOTSWAP_INSERTED, 0);
            backlight_on();

            microsd_init = mount_microSD();
            microSD_state = true;
        }
    }
    else {
        if (microSD_state) {
            queue_broadcast(SYS_HOTSWAP_EXTRACTED, 0);
            backlight_on();
            microsd_init = umount_microSD();
            microSD_state = false;
        }
    }
    if (microsd_init)
        queue_broadcast(SYS_FS_CHANGED, 0);
    sleep(HZ);
}
*/

void sdsense_init(void) {
    /* Setup GPIO pin for microSD sense */
    gpio_control(DEV_CTRL_GPIO_SET_MUX, GPIO_SD_SENSE, CONFIG_DEFAULT, 0);
    gpio_control(DEV_CTRL_GPIO_SET_INPUT, GPIO_SD_SENSE, CONFIG_DEFAULT, 0);
    microSD_state = microSD_inserted();
    
    /* Set up the handler, may be invoked also without a hotplug event
     * (very unlikely on a "single-process" environment)
     */
    
    semaphore_init(&event_trigger, 1, 0);
        
    signalHandler.sa_handler = microSD_check;
    signalHandler.sa_flags = 0;
    sigemptyset(&signalHandler.sa_mask);

    create_thread(microSD_thread, microSD_stack, sizeof(microSD_stack), 0, "microSD"
                  IF_PRIO(, PRIORITY_BACKGROUND) IF_COP(, CPU));
    
    /* Now that we are ready, set the in-kernel call */
    char temp[100];
    sprintf(temp, "echo kill -s SIGUSR1 %i > /proc/sys/kernel/hotplug", getpid());
    system(temp);
    
    /**/
    int err = sigaction(SIGUSR1, &signalHandler, NULL);
    printf("Setup done! %i\n", err);
}