eibdrv.c

欧洲安装总线系统的USB串口接口驱动c程序源代码.软件代码由西门子公司提供

   if ((new_buf=eib_get_wpbuf(new_size))==NULL) return -ENOMEM;

   old_buf=(*buf);
   if (new_size>old_buf->size)
   {  memcpy(new_buf,old_buf,sizeof(Eib_wpbuf)+old_buf->size*sizeof(Eib_wproc));
      new_buf->mem=(Eib_wproc *)(new_buf+1);
      new_buf->size=new_size;
   }
   else if (new_size<old_buf->size)
   {  if ((old_buf->count>new_size)||(new_size==0)) 
      {  eib_return_wpbuf(new_buf);
         return -ESIZE;
      }
      proc=old_buf->mem+(old_buf->first-1);
      new_proc=new_buf->mem;
      j=old_buf->first;
      for (i=1;i<=old_buf->count;i++)
      {  new_proc->pid=proc->pid;
         new_proc->flags=proc->flags;
         new_proc->result=proc->result;
         new_proc->next=i+1;
         new_proc->prev=i-1;
         if (old_buf->next_result==j) new_buf->next_result=i;
         new_proc++;
         proc=old_buf->mem+(proc->next-1);
         j=proc->next;
      }
      new_buf->first=1;
      new_buf->last=old_buf->count;
      (new_buf->mem)->prev=0;
      (new_buf->mem+(new_buf->last-1))->next=0;
      new_buf->count=old_buf->count;
      if (old_buf->next_result==0)
         new_buf->next_result=0;
   }
   else 
   {  eib_return_wpbuf(new_buf);
      return 0;
   }
   
   eib_return_wpbuf(*buf);
   *buf=new_buf;
   return 0;
}

unsigned long eib_countinst_wpbuf(Eib_wpbuf *buf,pid_t pid)
{  Eib_wproc *proc;
   unsigned long count=0;
   unsigned long i;
   
   for(i=0,proc=buf->mem;i<buf->size;i++,proc++)
      if ((proc->flags!=0)&&(proc->pid==pid))
         count++;
   return count;
}      

unsigned long eib_get_wpbuf_count(Eib_wpbuf *buf) 
{  return buf->count;  
}

unsigned long eib_get_wpbuf_size (Eib_wpbuf *buf) 
{  return buf->size;    
}

void eib_init_wpbuf(Eib_wpbuf *buf)
{  int i;
   Eib_wproc proc={0,0,0,0};
   
   buf->first=0;
   buf->last=0;
   buf->next_result=0;
   buf->count=0;
   for (i=0;i<buf->size;i++)
      *(buf->mem+i)=proc;
}

void eib_display_wpbuf(Eib_wpbuf *buf)
{  unsigned long i;
   Eib_wproc *proc;
   
   if (buf->count==0) return;
      
   proc=buf->mem+(buf->first-1);
   for (i=0;i<buf->count;i++)
   {  printk(KERN_WARNING "eibdrv: Prozess-ID %li  %x  %i  %li  %li\n",
         (long)proc->pid,proc->flags,proc->result,proc->prev,proc->next);
      proc=buf->mem+(proc->next-1);
   }
}

   
/*  --------------------------------------------------------------------------- */


Eib_rpbuf *eib_get_rpbuf(unsigned long size,unsigned long msgbuf_size)
{  Eib_rpbuf *buf;
   
   if ((buf=(Eib_rpbuf *)kmalloc(sizeof(Eib_rpbuf)+size*(sizeof(Eib_rproc)+
               sizeof(Eib_buf)+msgbuf_size*(EIB_BUF_ELEMENT_SIZE+1)*
               sizeof(unsigned char)),GFP_KERNEL))==NULL)
      return NULL;
   
   buf->mem=(Eib_rproc *)(buf+1);
   buf->size=size;
   buf->msgbuf_size=msgbuf_size;
   eib_init_rpbuf(buf);
   
   return buf;
}

void eib_init_rpbuf(Eib_rpbuf *buf)
{  int i;
   unsigned char *charbuf;
   Eib_rproc *proc;
   Eib_buf *msgbuf;
   
   msgbuf=(Eib_buf *)(buf->mem+buf->size);
   charbuf=(unsigned char *)(msgbuf+buf->size);
  
   buf->count=0;
   for (i=0,proc=buf->mem;i<buf->size;i++,proc++)
   {  proc->filp=NULL;
      proc->flags=0;
      proc->wmode=FT_WRITE_STANDARD;
      proc->msgbuf=msgbuf+i;
      proc->msgbuf->mem=charbuf+i*(buf->msgbuf_size*(EIB_BUF_ELEMENT_SIZE+1));
      proc->msgbuf->size=buf->msgbuf_size;
      eib_init_buf(proc->msgbuf);
   }      
}

void eib_return_rpbuf(Eib_rpbuf *buf)  
{  kfree(buf);  
}

Eib_rproc *eib_find_rproc(Eib_rpbuf *buf,struct file *filp)
{  unsigned long i;
   Eib_rproc *proc;
   
   for (i=0,proc=buf->mem;i<buf->size;i++,proc++)
      if (((proc->flags&FT_PROC_OPEN)==FT_PROC_OPEN)&&(proc->filp==filp))
         return proc;
   return NULL;
}

int eib_ins_rpbuf(Eib_rpbuf *buf,struct file *filp,int flags)
{  Eib_rproc *proc;

   if (buf->count==buf->size) return -ENOBUFS;
   if (eib_find_rproc(buf,filp)!=NULL) return -EDEVISOPEN;
   proc=buf->mem;
   while ((proc->flags&FT_PROC_OPEN)==FT_PROC_OPEN)
      proc++;
   proc->filp=filp;
   proc->flags=flags|FT_PROC_OPEN;
   proc->wmode=FT_WRITE_STANDARD;
   buf->count++;
   eib_init_buf(proc->msgbuf);
   return 0;
}

int eib_rm_rpbuf(Eib_rpbuf *buf,struct file *filp)
{  Eib_rproc *proc;
   
   if (buf->count==0) return -ENOPROC;
   if ((proc=eib_find_rproc(buf,filp))!=NULL)
   {  proc->flags-=FT_PROC_OPEN;
      buf->count--;
      return 0;
   }
   return -ENOPROC;
}

int eib_wmsg_rpbuf(Eib_rpbuf *buf,unsigned char *element,int len)
{  int result=0;
   unsigned long i;
   Eib_rproc *proc;
   
   if (buf->count==0) return 0;
   
   for (i=0,proc=buf->mem;i<buf->size;i++,proc++)
     if ((proc->flags&FT_PROC_OPEN)==FT_PROC_OPEN)
        if (eib_write_buf(proc->msgbuf,element,len)==-ENOBUFS)
           result=-ENOBUFS;
   return result;
}

int eib_rmsg_rpbuf(Eib_rpbuf *buf,struct file *filp,unsigned char *element)
{   Eib_rproc *proc;
    
   if (buf->count==0) return 0;
   if ((proc=eib_find_rproc(buf,filp))!=NULL)
      return eib_read_buf(proc->msgbuf,element);
   return 0;
}

int eib_resize_rpbuf(Eib_rpbuf **buf,unsigned long new_size,unsigned long new_msgbuf_size)
{  unsigned long i;
   Eib_rpbuf *old_buf,*new_buf;
   Eib_rproc *old_proc,*new_proc;
   
   if ((new_buf=eib_get_rpbuf(new_size,new_msgbuf_size))==NULL) return -ENOMEM;

   old_buf=(*buf);
   if ((old_buf->size==new_size)&&(old_buf->msgbuf_size==new_msgbuf_size)) 
   {  eib_return_rpbuf(new_buf);
      return 0;
   }
   if ((new_size==0)||(new_msgbuf_size==0)) 
   {  eib_return_rpbuf(new_buf);
      return -ESIZE;
   }
   if (new_size<old_buf->count) 
   {  eib_return_rpbuf(new_buf);
      return -ESIZE;
   }
   for (i=0,old_proc=old_buf->mem;i<old_buf->size;i++,old_proc++)
      if (((old_proc->flags&FT_PROC_OPEN)==FT_PROC_OPEN)&&(new_msgbuf_size<old_proc->msgbuf->count))
      {  eib_return_rpbuf(new_buf);
         return -ESIZE;
      }
   
   if (old_buf->count>0)
   {  new_buf->count=old_buf->count;
      new_proc=new_buf->mem;
      for (i=0,old_proc=old_buf->mem;i<old_buf->size;i++,old_proc++)
      {  if ((old_proc->flags&FT_PROC_OPEN)==FT_PROC_OPEN)
         {  new_proc->filp=old_proc->filp;
            new_proc->flags=old_proc->flags;
            if (old_proc->msgbuf->count>0)
               eib_copymem_buf(old_proc->msgbuf,new_proc->msgbuf);
            new_proc++;
         }
      }
   }
   
   eib_return_rpbuf(*buf);
   *buf=new_buf;
   return 0;
}

unsigned long eib_get_rpbuf_msgcount(Eib_rpbuf *buf,struct file *filp)
{  Eib_rproc *proc;
   
   if (buf->count==0) return -ENOPROC;
   if ((proc=eib_find_rproc(buf,filp))!=NULL)
      return proc->msgbuf->count;
   return -ENOPROC;
}

unsigned long eib_get_rpbuf_count(Eib_rpbuf *buf)  
{  return buf->count;  
}

unsigned long eib_get_rpbuf_size(Eib_rpbuf *buf)
{  return buf->size;
}

unsigned long eib_get_rpbuf_msgbuf_size(Eib_rpbuf *buf)
{  return buf->msgbuf_size;
}

int eib_set_rpbuf_wmode(Eib_rpbuf *buf,struct file *filp,int wmode)
{  Eib_rproc *proc;
   
   if (buf->count==0) return -ENOPROC;
   if ((proc=eib_find_rproc(buf,filp))!=NULL)
   {  proc->wmode=wmode;
      return 0;
   }
   return -ENOPROC;
}

int eib_get_rpbuf_wmode(Eib_rpbuf *buf,struct file *filp)
{  Eib_rproc *proc;
   
   if (buf->count==0) return -ENOPROC;
   if ((proc=eib_find_rproc(buf,filp))!=NULL)
      return proc->wmode;
   return -ENOPROC;
}


void eib_display_rpbuf(Eib_rpbuf *buf)
{  unsigned long i;
   Eib_rproc *proc;
   
   if (buf->count==0) return;
   for (i=0,proc=buf->mem;i<buf->size;i++,proc++)
      if ((proc->flags&FT_PROC_OPEN)==FT_PROC_OPEN)
      {  printk(KERN_WARNING "eibdrv: Prozess flags %x\n",proc->flags);
         eib_display_buf(proc->msgbuf);
      }
}  

/*  --------------------------------------------------------------------------- */

struct timeval sum_timeval(struct timeval a,struct timeval b)
{  a.tv_sec+=b.tv_sec;
   a.tv_usec+=b.tv_usec;
   if (a.tv_usec>=1000000)
   {  a.tv_sec+=1;
      a.tv_usec-=1000000;
   }
   return a;
}


struct timeval diff_timeval(struct timeval a,struct timeval b)
{  struct timeval t={0,0};
   
   if ((a.tv_sec>b.tv_sec)||((a.tv_sec==b.tv_sec)&&(a.tv_usec>=b.tv_usec)))
   {  a.tv_sec-=b.tv_sec;
      a.tv_usec-=b.tv_usec;
      if (a.tv_usec<0)
      {  a.tv_sec-=1;
         a.tv_usec+=1000000;
      }
      return a;
   }
   else
      return t;
}


unsigned long timeval_to_jiffies(struct timeval t)
{  unsigned long j;
   
   j=t.tv_sec*HZ+t.tv_usec/(1000000/HZ);
   if ((t.tv_usec%(1000000/HZ))!=0)
      j++;
   return j;
}


struct timeval jiffies_to_timeval(unsigned long j)
{  struct timeval t;
   
   t.tv_sec=j/HZ;
   t.tv_usec=(j%HZ)*(1000000/HZ);
   return t;
}

void lock(sv *key)
{  while (key->val==0)
      interruptible_sleep_on(&key->wq);
   key->val--;
}                  
 
void unlock(sv *key)
{  key->val++;
   wake_up_interruptible(&key->wq);
}                   

int check_lock(sv *key)
{  return key->val;
}

void reset_statistics()
{  int i;

   ftstation.stat.outbuf_count=0;
   ftstation.stat.wpbuf_count=0;
   ftstation.stat.rpbuf_count=0;   
   for(i=0;i<4;i++) ftstation.stat.write[i]=0;
   for(i=0;i<3;i++) ftstation.stat.read[i]=0;
   ftstation.stat.total_w1time.tv_sec=0;
   ftstation.stat.total_w1time.tv_usec=0;
   ftstation.stat.overflow=0;
   
   ftstation.rrepeat=-1;
}

void line_idle_delay(void)
{  struct timeval t;
   time_t delay_sec;
   suseconds_t delay_usec;
   
   do_gettimeofday(&t);
   
   if ((delay_sec=t.tv_sec-ftstation.last_seract.tv_sec) > ftstation.line_idle_timeout_sec) 
      return;

   delay_usec=delay_sec*1000000+t.tv_usec-ftstation.last_seract.tv_usec;
   
   if (delay_usec >= ftstation.line_idle_timeout_usec) return;
   udelay(ftstation.line_idle_timeout_usec-delay_usec);
}

int immediate_read(unsigned char *buf) 
{
#if LINUX_VERSION_CODE >= VERSION_CODE(2,1,0)      
   if  (ftstation.port.filp->f_op->read(ftstation.port.filp,buf,1,
                      &ftstation.port.filp->f_pos)==0)
#else