Виснет поток в модуле ядра

#include <linux/mutex.h>
#include <asm/atomic.h>
#include <linux/kernel.h>
#include <linux/kthread.h>
 
#include "kdriver.h"
 
#define FPO_ACTIVE 1
#define FPO_NOT_ACTIVE 2
 
#define SLEEP_TIME 500
 
DECLARE_WAIT_QUEUE_HEAD(concurencyQueue);
static bool concurencyFlag = false;
 
DEFINE_SPINLOCK( concurencySpinLock );
 
void set_concurency_flag(bool flag)
{
    spin_lock(&concurencySpinLock);
    concurencyFlag = flag;
    spin_unlock(&concurencySpinLock);
}
 
bool get_concurency_flag(void)
{
    spin_lock(&concurencySpinLock);
    bool flag = concurencyFlag;
    spin_unlock(&concurencySpinLock);
 
    return flag;
}
 
//--------------------------------------------------
 
static daq_device_t* _dev = NULL;
static struct task_struct* receiveThread = NULL;
 
atomic_t isRunning = ATOMIC_INIT(0);
 
 
static int startKernel(void* emptyName)
{
    static  DIO_RW_PORTS rwPorts;
    static __u8 data[MAX_DIO_PORT_COUNT];
 
    rwPorts.PortStart = 0;
    rwPorts.PortCount = MAX_DIO_PORT_COUNT;
    memset(data, 0, MAX_DIO_PORT_COUNT);
    rwPorts.Data = data;
 
    while(atomic_read(&isRunning))
    {
        set_concurency_flag(false);
        wait_event_timeout (concurencyQueue, concurencyFlag, SLEEP_TIME);
 
        if( ! get_concurency_flag())
        {
            daq_ioctl_do_write_port(_dev, (unsigned long)&rwPorts);
        }
    }
 
    atomic_set(&isRunning, -1);
 
    return 0;
}
 
void createAndStartTimerForDevice(daq_device_t *dev)
{
    _dev = dev;
 
    receiveThread = kthread_run( startKernel, NULL, "dropTimer");
    if (IS_ERR(receiveThread))
    {
        printk(KERN_INFO "Error: unable to start Drop Timer\n");
        receiveThread = NULL;
        _dev = NULL;
    }
    else
    {
        atomic_set(&isRunning, 1);
    }
}
 
void destroyTimer(const daq_device_t* dev)
{
    if(receiveThread != NULL && _dev != NULL && dev == _dev)
    {
        atomic_set(&isRunning, 0);
        wake_up(&concurencyQueue);
 
        while (atomic_read(&isRunning) != -1)
        {
            msleep(40);
        }
 
        receiveThread = NULL;
        _dev = NULL;
    }
}
 
void iAmAlive(void) // нет смысла ориентироваться на конкретный девайс, важно что бы хоть что то присылало
{
        set_concurency_flag(true);
        wakeDroper();
}
 
void wakeDroper(void) // !!!! дергается при чтении
{
    wake_up(&concurencyQueue);
}