stepper.c

JXARM9-2410实验箱步进电机Linux驱动代码.rar

/*  leddrv.c - Create an input/output character device
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/errno.h> 	/* for -EBUSY */
#include <linux/ioport.h>	/* for verify_area */
#include <linux/init.h>		/* for module_init */
#include <asm/uaccess.h>  	/* for get_user and put_user */
#include <asm-arm/arch-s3c2410/S3C2410.h>

#include "stepper.h"

#define 	DEVICE_NAME 	"char_dev"

static struct timer_list ttimer;

static int 	Device_Open = 0;

static int num=2;  /*used to control the speed of the stepper*/
static enum{off,clockwise,anticlockwise} status=off; /*used to indicate and set the status of the stepper*/

static int row=0;
unsigned char pulse_table[] = 
{
	0x05, 0x09, 0x0a, 0x06,
};

int	device_ioctl(struct inode *,struct file *,unsigned int ,unsigned long ); 	

static void time_tick(unsigned long data)
{
	static int i=0;

//	printk("time_tick\n");

	switch(status)
	{
	  case off:
		  break;
	  case clockwise:
		  if(++i==num){
			  i=0;
			  if( row == 4 ) row = 0;
			  (*(char *)0xd3000006)=pulse_table[row++];
		  }
		  ttimer.expires=jiffies+5;
		  add_timer(&ttimer);
		  break;
	  case anticlockwise:
		  if(++i==num){
		      i=0;
			   if( row == -1 ) row = 3;
			  (*(char *)0xd3000006)=pulse_table[row--];
		  }
		  ttimer.expires=jiffies+5;
		  add_timer(&ttimer);
		  break;
	  default:
		  break;
	}
}

/* This function is called whenever a process attempts 
 * to open the device file */
static int device_open(struct inode *inode, struct file *file)
{
  printk("Device Open\n");

  /* We don't want to talk to two processes at the 
   * same time */
  if (Device_Open) return -EBUSY;

  Device_Open++;
  
  MOD_INC_USE_COUNT;

  return 0;
}

/* This function is called when a process closes the 
 * device file. It doesn't have a return value because 
 * it cannot fail. Regardless of what else happens, you 
 * should always be able to close a device (in 2.0, a 2.2
 * device file could be impossible to close).
 */
static int device_release(struct inode *inode, struct file *file)
{
  printk(("Device Release\n"));

  /* We're now ready for our next caller */
  Device_Open --;

  MOD_DEC_USE_COUNT;

  return 0;
}

/* This function is called whenever a process which 
 * has already opened the device file attempts to 
 * read from it. */
static ssize_t device_read(
    struct file *file,
    char *buffer, 		/* The buffer to fill with the data */   
    size_t length,     	/* The length of the buffer */
    loff_t *offset) 	/* offset to the file */
{
	return 0;
}


/* This function is called when somebody tries to 
 * write into our device file. */ 
static ssize_t device_write(struct file *file, const char *buffer, size_t length, loff_t *offset)
{
	return 0;
};

/* This function is called whenever a process tries to 
 * do an ioctl on our device file. We get two extra 
 * parameters (additional to the inode and file 
 * structures, which all device functions get): the number
 * of the ioctl called and the parameter given to the 
 * ioctl function.
 *
 * If the ioctl is write or read/write (meaning output 
 * is returned to the calling process), the ioctl call 
 * returns the output of this function.
 */
int device_ioctl(
    struct inode *inode,
    struct file *file,
    unsigned int ioctl_num,/* The number of the ioctl */
    unsigned long ioctl_param) /* The parameter to it */
{
  struct stepper * s;

  printk(("Device Ioctl\n"));
  
  /* Switch according to the ioctl called */
  switch (ioctl_num) 
  {
    case IOCTL_SET_MSG:
      /* Receive a pointer to a message (in user space) 
       * and set that to be the device's message. */ 

      /* Get the parameter given to ioctl by the process */
      
	  s = (struct stepper*) ioctl_param;
	  printk("CmdID=%d\n",s->CmdID);

   	  switch (s->CmdID)
   	  {
	    case 0:       /*start*/
		  status=clockwise;
		  ttimer.expires=jiffies+1;  //start the timer
		  add_timer(&ttimer);
		  printk("clockwise\n");
		  break;
	    case 1:       /*stop*/
		  status=off;    //change the status of the stepper
		  printk("off\n");
		  break;
	    case 2:       /*reverse*/
		  if(status==clockwise){
			  status=anticlockwise;		//change the status of the stepper	  
			  printk("anticlockwise\n");
		  }
		  else if(status==anticlockwise){
			  status=clockwise;
			  printk("clockwise\n");
		  }
		  break;
	    case 3:       /*speed up*/
		  if(num!=1)num--;
		  break;
	    case 4:       /*speed down*/
		  num++;
		  break;
       }      
       break;
	
    case IOCTL_GET_MSG:
    
      printk(("Device Ioctl GET_MSG\n"));

      break;
  }

  return 0;
};

/* Module Declarations *************************** */
/* This structure will hold the functions to be called 
 * when a process does something to the device we 
 * created. Since a pointer to this structure is kept in 
 * the devices table, it can't be local to
 * init_module. NULL is for unimplemented functions. */
struct file_operations Fops = {
	.read 		= device_read, 
	.write 		= device_write,
	.open 		= device_open,
	.release 	= device_release,
	.ioctl		= device_ioctl
	};

/* Initialize the module - Register the character device */
static int __init stepper_module_init( void )
{
  int ret_val;
  
  /* Register the character device (atleast try) */
  ret_val = register_chrdev(MAJOR_NUM, DEVICE_NAME, &Fops);

  /* Negative values signify an error */
  if (ret_val < 0) {
    printk ("%s failed with %d.\n",
            "Sorry, registering the character device ",
            ret_val);
    return ret_val;
  }
  
  printk ("%s The major device number is %d.\n",
          "Registeration is a success.", 
          MAJOR_NUM);
          
  printk ("If you want to talk to the device driver,\n");
  printk ("you'll have to create a device file. \n");
  printk ("We suggest you use:\n");
  printk ("mknod /dev/%s c %d 0\n", DEVICE_FILE_NAME,MAJOR_NUM);
  printk ("The device file name is important, because\n");
  printk ("the ioctl program assumes that's the\n");
  printk ("file you'll use.\n");

  if(check_region(0x28000006, 1))
  {
      printk("The stepper port is used by another module.\n");
      return -1;
  }
  
  request_region(0x28000006, 1, DEVICE_NAME);

  init_timer(&ttimer);
  ttimer.function=time_tick;

  return 0;
};

/* Cleanup - unregister the appropriate file from /proc */
static void __exit stepper_module_cleanup(void)
{
  int ret;

  release_region(0x28000006,1);

  /* Unregister the device */
  ret = unregister_chrdev(MAJOR_NUM, DEVICE_NAME);
 
  /* If there's an error, report it */ 
  if (ret < 0)
    printk("Error in module_unregister_chrdev: %d\n", ret);
};

module_init(stepper_module_init);
module_exit(stepper_module_cleanup);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Cvtech Co., Ltd <http://www.cvtech.com.cn>");
MODULE_DESCRIPTION("LED char driver");