stepperfunction.txt

嵌入式linux学习之uclinux步进电机驱动实例（测试平台S3C44B0X,uclinux系统）

static struct file_operations stepper_fops{
	llseek: stepper_lseek,
	read: stepper_read,
	write: stepper_write,
	ioctl: stepper_ioctl,
	open: stepper_open,
	release: stepper_release,
};


int init_module(void)
{
	int rc;
	ring_buffer_init(&read_buffer);
	ring_buffer_init(&write_buffer);
	read_is_sleeping = 0;
	write_is_sleeping = 0;
	if(register_chrdev(major, "step", &stepper_fops)<0){
		printf("stepper: unable to get major device\n");
		return(-EIO);
	}
	if(check_region(base, 4)){
		printf("stepper: port in use\n");
		unregister_chrdev(major, "step");
		return;
	}
	request_region(base, 4);
	if(irq && (!interrupts_are_enabled)){
		
		rc = request_irq(irq, interrupt_hander, 0, "stepper", NULL);
		if(rc){
			printf("stepper: request irq return %d\n", rc);
		}else{
			printf("stepper: enable irq");
			interrupts_are_enabled = 1;
			word = irq_enable_bit;
			verbose_outb( (word >> 8), base + 2);

		}
	}
	if(!irq){
		using_jiffies = 1;
		queue_task(&tick_queue_entry, &tq_timer);
	}
	xdest = ydest = zdest = 400;
	return(0);
}

void cleanup_module(void)
{
	abort_write = 1;
	if(write_is_sleeping) wake_up_interruptible(&write_wait);
	abort_read = 1;
	if(read_is_sleeping) wake_up_interruptible(&read_wait);


	release_region(base, 4);
	if(unregister_chrdev(major, "step")){
		printf("stepper: unregister_chrdev() failed.\n");
	}
	if(interrupts_are_enable){
		//disable irq on card
		word &= ~irq_enable_bit;
		verbose_outb((word >> 8), base + 2); 
		free_irq(irq, NULL);
	}
	if(using_jiffies){
		sleep_on(&tick_die_wait_queue);
	}
}


static int stepper_lseek(struct inode *inode, struct file *file, off_t offset, int orig)
{	
	return(file->f_pos = 0);
}

static int stepper_open(struct inode *inode, struct file *file)
{
	int rc;
	int minor;
	
	minor = MINOR(inode->i_rdev);
	printf("file open mode is %d\n", file->f_mode);
	if(minor != 0){
		MOD_INC_USE_COUNT;
		return(0);
	}
	if(autostart) stepper_start();
	if(file->f_mode == 1){
		if(read_is_open){
			printf("stepper_open: read busy\n");
			return(-EBUSY);
		}else{
			read_is_open = 1;
			abort_read = 0;
			MOD_INC_USE_COUNT;
		}
	}else if(file->f_mode == 2){
		if(write_is_open){
			printf("stepper_open: write busy\n");
			return(-EBUSY);
		}else{
			write_is_open = 1;
			abort_write = 0;
			MOD_INC_USE_COUNT;
		}
	}else{
		printf("stepper_open: unknown mode\n");
	}
	return(0);
}

void stepper_release(struct inode *inode, struct file *file)
{
	int minor;
	
	minor = MINOR(inode->i_rdev);
	printf("file open mode is %d\n", file->f_mode);

	if(minor != 0){
		MOD_INC_USE_COUNT;
		return(0);
	}
	
	if(file->f_mode == 1){
		if(read_is_open){
			abort_read = 1;
			if(read_is_sleeping){
				wake_up_interruptible(&read_wait);
			}
			read_is_open = 0;
			MOD_DEC_USE_COUNT;
		}else{
			printf("stepper_release: unexpect read\n");
		}
	}else if(file->f_mode == 2){
		if(write_is_open){
			abort_write = 1;
			if(write_is_sleeping){
				wake_up_interruptible(&write_wait);
			}
			write_is_open = 0;
			MOD_DEC_USE_COUNT;
		}else{
			printf("stepper_release: unexpect write\n");
		}
	}else{
		printf("stepper_release: unknown mode");
	}
	return(0);
}

static int stepper_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
{
	switch(cmd){
		case(STEPPER_SET_SKIPTICKS):
			skipticks = arg;
			break;

		case(STEPPER_SET_VERBOSE_IO):
			verbose_io = arg;
			break;

		case(STEPPER_START):
			printf("stepper_ioctl: stepper_start\n");
			break;

		case(STEPPER_CLEAR_BUFFERS):
			printf("clear buffers\n");
			ring_buffer_init(&read_buffer);
			ring_buffer_init(&write_buffer);
			break;

		default:
			break;

	}
}

static int stepper_read(struct inode *inode, struct file *file, char *buf, int count)
{
	int rc;
	int bytes_transferred = 0;
	char xferbuf;
	char *i_buf;
	i_buf = buf;
	if(!read_is_open){
		printf("the file has not open\n");
		return(0);
	}
	for(i=0; i<count; i++){
		while(1){
			rc = ring_buffer_read(&read_buffer, &xferbuf, 1);
			if(rc == 1){
				bytes_transferred++;
				*i_buf++ = xferbuf;
				break;	
			}
			read_is_sleeping = 1;
			interruptible_sleep_on(&read_wait);
			read_is_sleeping = 0;
			if(abort_read) return(0);
		}
	}
	if(write_is_sleeping) wake_up_interruptible(&write_wait);	
	
}

static int stepper_write(struct inode *inode, struct file *file, char *buf, int count)
{
	int rc;
	int bytes_transferred = 0;
	char xferbuf;
	char *i_buf;
	i_buf = buf;
	if(!write_is_open){
		printf("the file has not open\n");
		return(0);
	}
	for(i=0; i<count; i++){
		while(1){
		       xferbuf = *i_buf++;

			rc = ring_buffer_write(&write_buffer, &xferbuf, 1);
			if(rc == 1){
				bytes_transferred++;
				break;	
			}
			write_is_sleeping = 1;
			interruptible_sleep_on(&write_wait);
			write_is_sleeping = 0;
			if(abort_write) return(0);
		}
	}
	if(read_is_sleeping) wake_up_interruptible(&read_wait);	
	
}