Re: wait_event_interruptible and wake_up_interruptible

[Mohammad M Molla <merajul_i@xxxxxxxxx>]

can you post the error messages? 

tanbiao <tanbiao@xxxxxxxxxxxxx> wrote:

I want to use wait_event_interruptible and wake_up_interruptible to
some jobs,but some error ouccor when wake_up_interruptible. Attach is
the code.please help me.
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include

#include
#include
#include
#include

#include "ir.h"
#include "hi_gpio.h"

#define IR_PORT GPIO_1_BASE
#define Irq_1 7

DECLARE_WAIT_QUEUE_HEAD(ir_wait_q);

struct semaphore ir_sem;
unsigned char sleep_flag=0;

void gpio_init(void);



/**************************receive*******************************/
void gpio_init(void)
{
unsigned int tmp;
/*set gpio1 dir:out 3 in 2 */
gpio_dirgetbyte(1,&tmp);
tmp=tmp&0xfb;
tmp=tmp|0x08;
gpio_dirsetbyte(1,tmp);

/*set gpio1 interrupt:raise edge interrpt 2bit*/
gpio_interruptsenseset(1,2,SENSE_EDGE);
gpio_interruptsenseboth(1,2,SENSE_SINGLE);
gpio_interruptevenset(1,2,EVENT_RISING_EDGE);

/*disable gpio1_2 interrupt*/
tmp=0x04;
gpio_interruptdisable_byte(1,tmp);

/*clear data gpio1_3*/
gpio_writebit(1,3,0);

/*clear interrupt:gpio1_2*/
gpio_interruptclear(1,2);

/*enable interrupt gpio1_2*/
/*tmp=0x04;
gpio_interruptenable_byte(1,tmp);*/
}

int ir_save_stream(void)
{
unsigned char current_irq;
unsigned char flag;
unsigned int tmp;
unsigned int count;
unsigned int i;

i=1;
flag=1;

current_irq=readw(IR_PORT+GPIO_RIS);
if(!(current_irq&0x4))
{
printk("this is not ir_in_irq\n");
return -1;
}

udelay(250);
gpio_readbit(1,2,&tmp);
if (tmp!=1) // false irq;
{
printk("false ir_irq\n") ;
return -1;
}
else
{
count=5;
}

while(count<250&&i<128)
{
udelay(50);
gpio_readbit(1,2,&tmp);
if(tmp==1) //high level
{
if(flag==1) //1 rising;0 falling
{
count=count+1;
}
else
{
ir_receive_stream[i].high_low=0;
ir_receive_stream[i].counter_time=count;
i++;
count=1;
flag=1;
}
}
else //low level
{
if(flag==0)
{
count=count+1;
}
else
{
ir_receive_stream[i].high_low=1;
ir_receive_stream[i].counter_time=count;
i++;
count=1;
flag=0;
}
}

if(i>127)
{
printk("ir_receive_stream buffer full!\n");
}
if(count>=250)
{
printk("count biger than count!\n");
}

}

printk("ir save stream finished\n");
sleep_flag=1;
printk("wake up ir_wait_q\n");
wake_up_interruptible(&ir_wait_q);
return 0;
}

int ir_send_stream(void)
{
unsigned char i;
unsigned char level;
unsigned char count_delay;

for(i=1;i<128;i++)
{
level=ir_temp_stream[i].high_low;
count_delay=ir_temp_stream[i].counter_time;

gpio_writebit(1,3,level);
further_delay_n50us(count_delay);

}
return 0;
}
static irqreturn_t ir_in_irq(int irq,void *dev_id,struct pt_regs *reg)
{
unsigned int tmp;
int handled=0;

tmp=0x04;
gpio_interruptdisable_byte(1,tmp);

ir_save_stream();

//gpio_interruptenable_byte(1,0x04);
return IRQ_RETVAL(handled);

}

/***************************************************************************
**************************************************************************/

static int ir_open(struct inode *inode,struct file *file)
{
int i;
for(i=0;i<128;i++)
{
ir_receive_stream[i].high_low=0;
ir_receive_stream[i].counter_time=0;
}
gpio_interruptenable_byte(1,0x04);
printk("ir_irq enable\n");
sleep_flag=0;
return 0;
}

static int ir_close(struct inode *inode,struct file *file)
{
gpio_interruptdisable_byte(1,0x04);
printk("ir_irq disable\n");
return 0;
}

static int ir_read(struct file *file,char __user *buffer,size_t count,loff_t *ppos)
{
struct ir_stream *user_buf;
int ret;

user_buf=(struct ir_stream *)buffer;

printk("process %i(%s) going to sleep\n",current->pid,current->comm);

wait_event_interruptible(ir_wait_q,sleep_flag!=0);

printk("process %i(%s) awoken\n",current->pid,current->comm);

ret=copy_to_user(user_buf,(struct ir_stream *)ir_receive_stream,128*sizeof(struct ir_stream));
if(ret)
{
printk("IR_error:error_val is %lu\n",ret);
}
else
{
printk("get ir stream success\n");
printk("copy_return val is %lu\n",ret);
}

sleep_flag=0;
return 0;
}

static int ir_write(struct file *file,char __user *buffer,size_t count,loff_t *ppos)
{
struct ir_stream *user_buf;
int ret;

user_buf=(struct ir_stream *)buffer;

ret=copy_from_user((struct ir_stream *)ir_temp_stream,user_buf,128*sizeof(struct ir_stream));
if(ret)
{
printk("IR_error:cpy_error_val is %lu\n",ret);
}
else
{
printk("get stream from user success\n");
printk("copy_return val is %lu\n",ret);
}
ir_send_stream();
return 0;
}

static int ir_ioctl(struct inode *inode,struct file *file,unsigned int cmd,unsigned long arg)
{
void __user *argp=(void __user *)arg;
switch(cmd)
{
case IR_GET_STREAM:
{
break;
}
default:
return -EINVAL;
}
}

static struct file_operations ir_fops=
{
.owner=THIS_MODULE,
.open =ir_open,
.release=ir_close,
.ioctl=ir_ioctl,
.read=ir_read,
.write=ir_write,
};

static struct miscdevice ir_dev=
{
MISC_DYNAMIC_MINOR,
"irdev",
&ir_fops,
};

static int __init ir_init(void)
{
int ret;
ret=misc_register(&ir_dev);
if(ret)
{
printk("could not register ir devices.\n");
return ret;
}

gpio_remap();

ret=request_irq(Irq_1,&ir_in_irq,0,"irdev",NULL);
if(ret)
{
misc_deregister(&ir_dev);
printk("can't request irq 7\n");
return ret;
}

gpio_init();

return 0;
}

static void __exit ir_exit(void)
{
misc_deregister(&ir_dev);
free_irq(Irq_1,NULL);
gpio_unmap();
}

module_init(ir_init);
module_exit(ir_exit);

MODULE_LICENSE("GPL");

__________________________________________________
Do You Yahoo!?
Tired of spam? Yahoo! Mail has the best spam protection around
http://mail.yahoo.com