ul_linux.c

linux下的RS485的驱动 值得一看

	  idstr[ln]=0;
          return ulan_setidstr(opdata,idstr);
	}
  #endif /*UL_WITH_IAC*/

   case UL_HWTEST :
        if(current->euid!=0) return -EPERM;
	return ulan_hwtest(opdata,arg);
  };


  return -EINVAL;
};

/* common parameters (struct file *file, const char *buf, 
                      size_t count [, loff_t *ppos]) */
static RWRET ulan_write(WRITE_PARAMETERS)
{
  int cn;
  int len;
  ul_mem_blk *blk;
  ul_opdata *opdata=(ul_opdata*)file->private_data;
  if(opdata->magic!=ULOP_MAGIC) panic("ulan_write : BAD opdata magic !!!");

  if(!opdata->udrv) return -ENODEV;
  if(!opdata->message) return -ENOMSG;

  cn=count;
  while(cn>0)
  {
    while(!ul_di_adjust(&opdata->data))
    {
      if(!(blk=ul_alloc_blk(opdata->udrv))) 
	{count-=cn;cn=0;break;};
      memset(UL_BLK_NDATA(blk),0,UL_BLK_SIZE);
      opdata->data.blk->next=blk;
    };
    len=ul_di_atonce(&opdata->data);
    if(len>cn) len=cn;
    if(kc_copy_from_user(ul_di_byte(&opdata->data),buf,len))
      return -EFAULT;
    ul_di_add(&opdata->data,len);
    buf+=len;
    cn-=len;
  };

  if(opdata->data.pos>UL_BLK_HEAD(opdata->data.head_blk).len)
    UL_BLK_HEAD(opdata->data.head_blk).len=opdata->data.pos;

  return count-cn;
};

/* common parameters (struct file *file, char *buf, 
                      size_t count [, loff_t *ppos]) */
static RWRET ulan_read(READ_PARAMETERS)
{
  int cn;
  int len;
  ul_opdata *opdata=(ul_opdata*)file->private_data;
  if(opdata->magic!=ULOP_MAGIC) panic("ulan_read : BAD opdata magic !!!");

  if(!opdata->udrv) return -ENODEV;
  if(!opdata->message) return -ENOMSG;

  if(opdata->data.pos+count>UL_BLK_HEAD(opdata->data.head_blk).len)
   count=UL_BLK_HEAD(opdata->data.head_blk).len-opdata->data.pos;

  cn=count;
  while(cn>0)
  {
    if(!ul_di_adjust(&opdata->data))
    {
      while(cn--) kc_put_user(0,buf++);
      break;
    };
    len=ul_di_atonce(&opdata->data);
    if(len>cn) len=cn;
    if(kc_copy_to_user(buf,ul_di_byte(&opdata->data),len))
      return -EFAULT;
    ul_di_add(&opdata->data,len);
    buf+=len;
    cn-=len;
  };

  return count-cn;
};

/* common parameters (struct file *file, loff_t pos, int whence) */
static loff_t ulan_lseek(LSEEK_PARAMETERS)
{
  ul_opdata *opdata=(ul_opdata*)file->private_data;
  if(opdata->magic!=ULOP_MAGIC) panic("ulan_lseek : BAD opdata magic !!!");

  if(!opdata->message) return -ENOMSG;

  return ul_di_seek(&opdata->data,pos,whence);
};

static unsigned int ulan_poll(struct file *file, poll_table *wait)
{
  /* POLLIN | POLLOUT | POLLERR | POLLHUP | POLLRDNORM | POLLWRNORM */
  unsigned int mask = 0;
  ul_opdata *opdata=(ul_opdata*)file->private_data;
  if(opdata->magic!=ULOP_MAGIC) panic("ulan_poll : BAD opdata magic !!!");

  kc_poll_wait(file, &opdata->wqrec, wait);

  if (opdata->recchain)
    mask |= (POLLIN | POLLRDNORM);

  if (!opdata->udrv)
    mask |= (POLLIN | POLLOUT | POLLERR);

  return mask;
};

#if defined(UL_WITH_PCI) || defined(UL_WITH_USB)

static int /*__devinit*/ 
 ulan_init_find_minor(char *abus, char *aslot, char *asubdev,
                      int *pminor, int *ppar)
{
  int i;
  int abus_len;
  int aslot_len;
  int sub_offs;
  int minor;
  int par;
  int match=0;
  char *islot;
  abus_len=strlen(abus);
  aslot_len=strlen(aslot);
  sub_offs=abus_len+aslot_len;
  *pminor=*ppar=minor=par=-1;
  for(i=0;i<UL_MINORS;i++){
    islot=slot[i];
    if(islot)
      if(!*islot) islot=NULL;
    switch (match){
      case 0: 
        if(!ul_drv_arr[i]&&!islot){
	  minor=i;match=1;
	  if(par==-1) par=i;
	}
      case 1:
        if(!islot) continue;
        if(!strcmp(islot,abus)){
	  par=i;
	  if(!ul_drv_arr[i]){ minor=i; match=2;}
	}
      case 2:
        if(!islot||!aslot) continue;
        if(!strncmp(islot,abus,abus_len)&&
	   !strcmp(islot+abus_len,aslot)){
	  par=i;
	  if(!ul_drv_arr[i]){ minor=i; match=3;}
        }
      case 3:
        if(!islot||!aslot||!asubdev) continue;
        if(!strncmp(islot,abus,abus_len)&&
	   !strncmp(islot+abus_len,aslot,aslot_len)&&
	   (islot[sub_offs]=='.')&&!strcmp(islot+sub_offs+1,asubdev)){
	  par=i;
	  if(!ul_drv_arr[i]){ minor=i; match=4;}
        }
    }
  }
  *pminor=minor;*ppar=par;
  return match;
}

#endif /*defined(UL_WITH_PCI)||defined(UL_WITH_USB)*/


/*** initialize kernel module ***/
int init_module(void)
{
 #ifdef UL_WITH_DEVFS
  kc_devfs_handle_t devfs_handle;
  char devname[32];
 #endif /* UL_WITH_DEVFS */
  ul_drv* udrv;
  int ret;
  int minor;

  printk(KERN_INFO "uLan v" UL_DRV_VERSION " init_module\n");
  printk(KERN_INFO "Compiled at %s %s\n",__DATE__, __TIME__);

  if(debug!=-1){
    uld_debug_flg=debug;
  }

  ulan_class = kc_class_create(THIS_MODULE, "ulan");

  ret=0;
 #ifdef UL_WITH_UARTS
  for(minor=0;minor<UL_MINORS;minor++)
  {
    if(port[minor]||chip[minor])
    { /* get new ul_drv (port, irq, baud, my_adr); */
      udrv=ul_drv_new(port[minor],irq[minor],
   		      baud[minor],my_adr[minor],chip[minor],baudbase[minor]);
      ul_drv_arr[minor]=udrv;
      if(udrv){
	#ifdef UL_WITH_DEVFS
	  sprintf (devname, "ulan%d", minor);
          devfs_handle=kc_devfs_new_cdev(NULL, MKDEV(ulan_major_dev, minor), 
			S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP, 
			&ulan_fops, udrv, devname);
	  udrv->devfs_handle=devfs_handle;
	#endif /* UL_WITH_DEVFS */
	ret++;
	kc_class_device_create(ulan_class, NULL, MKDEV(ulan_major_dev, minor), NULL, "ulan%d", minor);
      };
    };
  };
 #endif /*UL_WITH_UARTS*/

 #ifdef UL_WITH_PCI
  { int rc;
    rc=pci_register_driver (&ulan_pci_driver);
    ret+=rc;
  }
 #endif  /* UL_WITH_PCI */

 #ifdef UL_WITH_USB
  /* register this driver with the USB subsystem */
  { int rc;
    rc = usb_register(&ul_usb_driver);
    if (rc < 0) {
      printk(KERN_CRIT "usb_register failed for the "__FILE__" driver. Error number %d",
	 rc);
    } else {
      ret++;
    }
  }
 #endif  /* UL_WITH_USB */

  if(!ret)
  { printk(KERN_ERR "uLan module_init : no hardware initialized, aborting !!!\n");
    #ifdef UL_WITH_USB
     usb_deregister(&ul_usb_driver);
    #endif  /* UL_WITH_USB */
    #ifdef UL_WITH_PCI
    pci_unregister_driver (&ulan_pci_driver);
    #endif  /* UL_WITH_PCI */
    return -ENODEV;
  };

 #ifdef UL_WITH_DEVFS
  ret = devfs_register_chrdev(ulan_major_dev, "ulan", &ulan_fops);
 #else /* UL_WITH_DEVFS */
  ret = register_chrdev(ulan_major_dev, "ulan", &ulan_fops);
 #endif /* UL_WITH_DEVFS */
  printk(KERN_INFO "uLan init : called register dev %d and got %d\n",
			 ulan_major_dev,ret);

  if (ret < 0) {
    printk(KERN_ERR "uLan init : unable to grab device #\n");
    ulan_major_dev=0;
    #ifdef UL_WITH_PCI
    pci_unregister_driver (&ulan_pci_driver);
    #endif  /* UL_WITH_PCI */
    for(minor=0;minor<UL_MINORS;minor++)
    { udrv=ul_drv_arr[minor];
      if(udrv)
      { ul_drv_arr[minor]=NULL;
	#ifdef UL_WITH_DEVFS
	if(udrv->devfs_handle) kc_devfs_delete(udrv->devfs_handle);
	#endif /* UL_WITH_DEVFS */
	kc_class_device_destroy(ulan_class, MKDEV(ulan_major_dev, minor));
	ul_drv_free(udrv);
      };
    };
    kc_class_destroy(ulan_class);
    return ret;
  }
  if(!ulan_major_dev) ulan_major_dev=ret;
  printk(KERN_INFO "uLan init : driver succesfully registered as major %d\n",
	          ulan_major_dev);

  #ifdef UL_INT_TST
  udrv=ul_drv_arr[0];
  if(udrv)
  { printk("uLan : geninfoblk\n");
    geninfoblk(udrv);
    printk("uLan : gentestblk\n");
    gentestblk(udrv);
    printk("uLan : uld_timeout\n");
    uld_timeout(udrv);
  };
  #endif /* UL_INT_TST */

  return 0;
}

/*** cleanup kernel module ***/
void cleanup_module(void)
{
  ul_drv* udrv;
  int i;
  int ret;

  if (ulan_major_dev != 0) {
   #ifdef UL_WITH_DEVFS
    ret = devfs_unregister_chrdev(ulan_major_dev, "ulan");
   #else /* UL_WITH_DEVFS */
    ret = unregister_chrdev(ulan_major_dev, "ulan");
   #endif /* UL_WITH_DEVFS */
    if(ret>=0)
      printk(KERN_INFO "uLan cleanup: Unregister  O.K.\n");
    else
      printk(KERN_CRIT "uLan cleanup: Unregister failed\n");
  };

  udrv=ul_drv_arr[0];
  if(udrv)
  { printk("uLan : printudrvbll\n");
    printudrvbll(udrv);
   #ifdef UL_WITH_FRAME_FSM
    printk("uLan : max cycle cnt  %d\n",ul_max_cycle_cnt);
    printk("uLan : max cycle time %d\n",ul_max_cycle_time);
   #endif /*UL_WITH_FRAME_FSM*/
  }

 #ifdef UL_WITH_USB
  usb_deregister(&ul_usb_driver);
 #endif  /* UL_WITH_USB */
 #ifdef UL_WITH_PCI
  pci_unregister_driver (&ulan_pci_driver);
 #endif  /* UL_WITH_PCI */
  for(i=0;i<UL_MINORS;i++)
  { udrv=ul_drv_arr[i];
    ul_drv_arr[i]=NULL;
    if(udrv){
     #ifdef UL_WITH_DEVFS
     if(udrv->devfs_handle) kc_devfs_delete(udrv->devfs_handle);
     #endif /* UL_WITH_DEVFS */
     kc_class_device_destroy(ulan_class, MKDEV(ulan_major_dev, i));
     ul_drv_free(udrv);
    }
  }

  kc_class_destroy(ulan_class);

 #ifdef ENABLE_UL_MEM_CHECK
  UL_PRINTF("MEM_CHECK: malloc-free=%d\n",
		 (int)atomic_read(&ul_mem_check_counter));
 #endif /* ENABLE_UL_MEM_CHECK */
}

#ifdef ENABLE_UL_MEM_CHECK
void * ul_mem_check_malloc(size_t size)
{void *ptr;
 ptr=kmalloc(size,GFP_KERNEL);
 if(ptr) atomic_inc(&ul_mem_check_counter);
 return ptr;
}

void ul_mem_check_free(void *ptr)
{
  if(ptr) atomic_dec(&ul_mem_check_counter);
  kfree(ptr);
}
#endif /* ENABLE_UL_MEM_CHECK */