sci.c

/*==========================================================
             MultiCAN - CAN Bus support for EPICS
                          module SCI
  ==========================================================
 
Copyright 2025 Helmholtz-Zentrum Berlin für Materialien und Energie GmbH
<https://www.helmholtz-berlin.de>
 
Author: Goetz Pfeiffer <Goetz.Pfeiffer@helmholtz-berlin.de>
 
This file is part of SCI, the simple CAN interface which is part of MultiCAN.
 
MultiCAN is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
 
MultiCAN is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with MultiCAN.  If not, see <https://www.gnu.org/licenses/>.
*/
 
/*
summary:
  This is the Simple CAN Interface, a library that provides types and
  functions to work with a CAN bus interface in a hardware independent way.
*/
 
/* ----------------------------------------------
 * includes
 * ---------------------------------------------- */
 
#include <stdlib.h>
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
 
/* threads, mutexes: */
#include <pthread.h>
 
/* nanosleep: */
#include <time.h>
 
#include <socan.h>
 
#include <sci.h>
 
/* ----------------------------------------------
 * macros
 * ---------------------------------------------- */
 
#define SCI_ERR(errcode) (SCI_ERROR | ((errcode)<<16))
 
#define SCI_ERR_RC(rc,errcode) (SCI_ERROR | ((errcode)<<16) | (rc))
 
/* ----------------------------------------------
 * types
 * ---------------------------------------------- */
 
struct sci_struc_s
  {
    socan_hdl     hdl;
    sci_Errcode   errcode;
  };
 
typedef struct
  { int real_port;
    sci_Plug_Func h2l;       /* sci to CAN plug-function */
    sci_Plug_Func l2h;       /* CAN to sci plug-function */
    sci_Plug_Lencalc lcalc; /* calc CAN-length from user-length */
  } sci_plug_struc;
 
struct sci_object_s
  {
    void           *userp;
    unsigned char  port;     /* When plugin is defined, the *logical* port, not
                                the real port */
    unsigned char  realport; /* When plugin is defined, the *real* port */
    unsigned short cob;
    unsigned char  length;
    unsigned char  reallength;
    struct sci_object_s *child;
  };
 
/* ----------------------------------------------
 * variables
 * ---------------------------------------------- */
 
static pthread_mutex_t global_semaphore;
 
static sci_plug_struc sci_plug_in[SCI_MAX_PLUGPORTS];
 
/* ----------------------------------------------
 * functions
 * ---------------------------------------------- */
 
/* ----------------------------------------------
 * time module
 * ---------------------------------------------- */
 
static void mldelay(long milliseconds)
/* millisecond-delay, works without "dirty tricks"
   warning: the actual resolution may be smaller, e.g 1/60th of a second*/
  { struct timespec rq,rt;
 
    /* POSIX-conform wait */
    if (milliseconds >= 1000L)
      { rq.tv_sec = milliseconds / 1000L;
        rq.tv_nsec= (milliseconds-1000L*rq.tv_sec) * 1000000L;
      }
    else
      { rq.tv_sec = 0;
        rq.tv_nsec= milliseconds * 1000000L;
      };
    nanosleep( &rq, &rt);
  }
 
/* ----------------------------------------------
 * init
 * ---------------------------------------------- */
 
static bool mutex_init(pthread_mutex_t *mutex)
  /* initialize mutex with PTHREAD_PRIO_INHERIT */
  {
    int rc;
 
    pthread_mutexattr_t mutexattr;
 
    rc= pthread_mutexattr_init(&mutexattr);
    if (rc!=0)
      {
        return false;
      }
    rc= pthread_mutexattr_setprotocol(&mutexattr, PTHREAD_PRIO_INHERIT);
    if (rc!=0)
      {
        return false;
      }
    rc= pthread_mutex_init(mutex, &mutexattr);
    if (rc!=0)
      {
        return false;
      }
    return true;
  }
 
_Atomic static int _lock= 0;
 
static int initialized= 0;
/*  0: not initialized
 *  1: initialized
 * -1: error */
 
static bool init_sci_lib(void)
  {
    int i;
    sci_plug_struc *ps;
 
    if (initialized==1)
      return true;
    if (initialized<0)
      return false;
 
    /* reading and writing to _lock is atomic: */
    if (_lock++)
      {
        /* some other thread is initializing, check every 10ms if it is
         * finished */
        while (initialized==0)
          mldelay(10);
        if (initialized==1)
          return true;
        if (initialized<0)
          return false;
      }
 
    if (!mutex_init(&global_semaphore))
      {
        initialized= -1;
        return false;
      }
    for(i=0; i<SCI_MAX_PLUGPORTS; i++)
      {
        ps= &(sci_plug_in[i]);
        ps->real_port= -1;
        ps->h2l= NULL;
        ps->l2h= NULL;
        ps->lcalc= NULL;
      }
    initialized= 1;
    return true;
  }
 
/* ----------------------------------------------
 * socan_rc mapping
 * ---------------------------------------------- */
 
static bool map_socan_rc(socan_rc rc,
                         sci_Return *sci_rc,
                         sci_Errcode *sci_err)
  /* returns true when there is no error, otherwise false */
  {
    *sci_rc= SCI_NOTHING;
    *sci_err= SCI_NO_ERR;
    switch(rc)
      {
        case SOCAN_OK:
          return true;
        case SOCAN_TIMEOUT:
          *sci_rc= SCI_TMOUT;
          return true;
        case SOCAN_OLD:
          *sci_rc= SCI_OLD_DATA;
          return true;
        case SOCAN_LOST:
          *sci_rc= SCI_LOST;
          return true;
        case SOCAN_WAIT:
          *sci_rc= SCI_WAIT;
          return true;
        case SOCAN_EXISTS:
          *sci_rc= SCI_EXISTS;
          return true;
        case SOCAN_LENGTH_ERR:
          *sci_rc= SCI_ERROR;
          *sci_err= SCI_LENGTH_ERR;
          return false;
        case SOCAN_PORT_ERR:
          *sci_rc= SCI_ERROR;
          *sci_err= SCI_PORT_ERR;
          return false;
        case SOCAN_COB_ERR:
          *sci_rc= SCI_ERROR;
          *sci_err= SCI_ID_ERR;
          return false;
        case SOCAN_NOT_RO_ERR:
        case SOCAN_NOT_WO_ERR:
        case SOCAN_TYPE_ERR:
          *sci_rc= SCI_ERROR;
          *sci_err= SCI_MODE_ERR;
          return false;
        case SOCAN_NOT_EXISTS_ERR:
          *sci_rc= SCI_ERROR;
          *sci_err= SCI_OBJ_UNDEF_ERR;
          return false;
        case SOCAN_NOT_OWNED_ERR:
          *sci_rc= SCI_ERROR;
          *sci_err= SCI_ACCESS_ERR;
          return false;
        case SOCAN_EXISTS_ERR:
          *sci_rc= SCI_ERROR;
          *sci_err= SCI_ACCESS_ERR;
          return false;
        case SOCAN_ERROR:
          *sci_rc= SCI_ERROR;
          *sci_err= SCI_ERR_GENERAL;
          return false;
        default:
          /* shouldn't happen */
          fprintf(stderr, "%s line %d: internal error\n", __FILE__, __LINE__);
          *sci_rc= SCI_ERROR;
          *sci_err= SCI_ERR_GENERAL;
          return false;
      }
  }
 
/* ----------------------------------------------
 * socan_obj_type mapping
 * ---------------------------------------------- */
 
static bool map_socan_type(socan_obj_type stype, sci_Object_Type *type)
  {
    switch(stype)
      {
        case SOCAN_READ:
          *type= SCI_READ;
          return true;
        case SOCAN_WRITE:
          *type= SCI_WRITE;
          return true;
        case SOCAN_READ_RTR:
          *type= SCI_REMOTE_READ;
          return true;
        case SOCAN_WRITE_RTR:
          *type= SCI_REMOTE_WRITE;
          return true;
        default:
          fprintf(stderr, "%s line %d: internal error\n", __FILE__, __LINE__);
          *type= SCI_READ;
          return false;
      }
  }
 
static bool map_sci_type(sci_Object_Type type, socan_obj_type *stype)
  {
    switch(type)
      {
        case SCI_READ:
          *stype= SOCAN_READ;
          return true;
        case SCI_WRITE:
          *stype= SOCAN_WRITE;
          return true;
        case SCI_REMOTE_READ:
          *stype= SOCAN_READ_RTR;
          return true;
        case SCI_REMOTE_WRITE:
          *stype= SOCAN_WRITE_RTR;
          return true;
        default:
          fprintf(stderr, "%s line %d: internal error\n", __FILE__, __LINE__);
          *stype= SOCAN_READ;
          return false;
      }
  }
 
/* ----------------------------------------------
 * printing the status and error code
 * ---------------------------------------------- */
 
#define CCODE(x) if (val==x) return(#x)
 
char *sci_str_status(sci_Return val)
  {
    CCODE(SCI_NOTHING);
    CCODE(SCI_OLD_DATA);
    CCODE(SCI_LOST);
    CCODE(SCI_TMOUT);
    CCODE(SCI_RESETTED);
    CCODE(SCI_INCONSISTENT);
    CCODE(SCI_EXISTS);
    CCODE(SCI_WAIT);
    CCODE(SCI_ERROR);
    fprintf(stderr, "%s line %d: unknown status code\n", __FILE__, __LINE__);
    return("UNKNOWN STATUS!");
  }
 
void sci_print_status(sci_Return flag)
  {
    puts(sci_str_status(flag)); 
  }
 
char *sci_str_err(sci_Errcode val)
  {
    CCODE(SCI_NO_ERR);
    CCODE(SCI_PORT_ERR);
    CCODE(SCI_ID_ERR);
    CCODE(SCI_TYPE_ERR);
    CCODE(SCI_BITRATE_ERR);
    CCODE(SCI_SET_CALLB_ERR);
    CCODE(SCI_MODE_ERR);
    CCODE(SCI_LENGTH_ERR);
    CCODE(SCI_ACCESS_ERR);
    CCODE(SCI_TIMEOUT_ERR);
    CCODE(SCI_TIMEOUT_VAL_ERR);
    CCODE(SCI_OFF_BUS_ERR);
    CCODE(SCI_BUS_ERR);
    CCODE(SCI_AUTHORIZE_ERR);
    CCODE(SCI_DVR_OPEN_ERR);
    CCODE(SCI_DVR_ACCESS_ERR);
    CCODE(SCI_HW_INIT_ERR);
    CCODE(SCI_RESET_ERR);
    CCODE(SCI_CHIP_CONF_ERR);
    CCODE(SCI_ENV_ERR);
    CCODE(SCI_PLUGPORT_ERR);
    CCODE(SCI_PLUG_DEF_ERR);
    CCODE(SCI_OBJ_UNDEF_ERR);
    CCODE(SCI_ERR_GENERAL);
    fprintf(stderr, "%s line %d: unknown error code\n", __FILE__, __LINE__);
    return("UNKNOWN ERROR CODE!");
  }
 
void sci_print_err(sci_Errcode err)
  {
    puts(sci_str_err(err)); 
  }
 
/* ----------------------------------------------
 * sci plugin
 * ---------------------------------------------- */
 
static bool plug_get(unsigned short port, sci_plug_struc **ps)
  /* returns:
   *   false: an error occured
   *   true : no error occured
   * Note: *ps is NULL if there is no plugin
   */
  {
    unsigned short plug;
    *ps=NULL;
 
    if (port < SCI_PLUGPORT_START)
      return true; /* no plugin */
    plug= port - SCI_PLUGPORT_START;
    if (plug>=SCI_MAX_PLUGPORTS)
      {
        fprintf(stderr, "%s line %d: internal error\n", __FILE__, __LINE__);
        return false;
      }
    *ps= &(sci_plug_in[plug]);
    if ((*ps)->real_port==-1)
      {
        fprintf(stderr, "%s line %d: internal error\n", __FILE__, __LINE__);
        return false;
      }
    return true;
  }
 
static bool plug_real_port(unsigned short port, unsigned short *realport)
  /* return the *real* can port 
   * returns:
   *   false: an error occured
   *   true : no error occured
   */
  {
    sci_plug_struc *ps;
 
    *realport= port;
    if (!plug_get(port, &ps))
      return false;
    if (ps==NULL)
      return true;
    *realport= ps->real_port;
    return true;
  }
 
sci_Return sci_def_plug_in(unsigned short plug_port, 
               unsigned short real_port,
                           sci_Plug_Func h2l, sci_Plug_Func l2h,
                           sci_Plug_Lencalc lcalc,
                           sci_Errcode *err)
  { sci_plug_struc *ps;
 
    if (!init_sci_lib()) /* actually initialization is only done once */
      {
        if (err!=NULL)
      *err= SCI_ERR_GENERAL;
        return SCI_ERR(SCI_ERR_GENERAL);
      };
    if ((plug_port<SCI_PLUGPORT_START) || 
        (plug_port>=SCI_PLUGPORT_START+SCI_MAX_PLUGPORTS))
      { if (err!=NULL)
          *err= SCI_PLUGPORT_ERR;
        return SCI_ERR(SCI_PLUGPORT_ERR);
      }; 
    pthread_mutex_lock(&global_semaphore);
    ps= &(sci_plug_in[plug_port-SCI_PLUGPORT_START]);
    if (ps->real_port!=-1) /* that plug-port was already defined */
      { if (err!=NULL)
          *err= SCI_PLUG_DEF_ERR;
        pthread_mutex_unlock(&global_semaphore);
        return SCI_ERR(SCI_PLUG_DEF_ERR);
      }; 
    ps->real_port= real_port;
    ps->h2l= h2l;
    ps->l2h= l2h;
    ps->lcalc= lcalc;
    pthread_mutex_unlock(&global_semaphore);
    return SCI_NOTHING;
  }
 
/* ----------------------------------------------
 * open/close
 * ---------------------------------------------- */
 
sci_Return sci_open(sci_Struc **s_struc, const char *app_name,
                    sci_Errcode *err)
  /* note: app_name is *ignored* in this implementation. */
  {
    socan_hdl hdl;
    struct sci_struc_s *scistruc_p;
 
    if (s_struc!=NULL)
      *s_struc= NULL;
    if (err!=NULL)
      *err= SCI_NO_ERR;
    if (!init_sci_lib()) /* actually initialization is only done once */
      {
        if (err!=NULL)
      *err= SCI_ERR_GENERAL;
        return(SCI_ERR(SCI_ERR_GENERAL));
      };
    pthread_mutex_lock(&global_semaphore);
    hdl= socan_open();
    if (hdl==NULL)
      {
        pthread_mutex_unlock(&global_semaphore);
        if (err!=NULL)
          *err= SCI_DVR_OPEN_ERR;
        return SCI_ERR(SCI_DVR_OPEN_ERR);
      }
 
    scistruc_p= calloc(1, sizeof(struct sci_struc_s));
    scistruc_p->hdl= hdl;
    scistruc_p->errcode= SCI_NO_ERR;
    *s_struc= scistruc_p;
    pthread_mutex_unlock(&global_semaphore);
    return SCI_NOTHING;
  }
 
sci_Return sci_close(sci_Struc **s_struc)
  {
    sci_Return rc= SCI_NOTHING;
 
    if (!socan_close( (*((struct sci_struc_s**)s_struc))->hdl))
      rc= SCI_ERROR;
    pthread_mutex_lock(&global_semaphore);
    free(*s_struc);
    *s_struc= NULL;
    pthread_mutex_unlock(&global_semaphore);
    return rc;
  }
 
/* ----------------------------------------------
 * sci_init : not implemented
 * ---------------------------------------------- */
 
#if 0
sci_Return sci_init(sci_Struc *s_struc, 
            unsigned short port, sci_Bitrate bitrate)
#endif
 
/* ----------------------------------------------
 * sci_reset : not implemented
 * ---------------------------------------------- */
 
#if 0
sci_Return sci_reset(sci_Struc *s_struc, unsigned short port)
#endif
 
/* ----------------------------------------------
 * get bitrate
 * ---------------------------------------------- */
 
sci_Return sci_get_bitrate(sci_Struc *s_struc,
                   unsigned short port, sci_Bitrate *bitrate)
  {
    socan_rc rc;
    sci_Return sci_rc;
    sci_Errcode sci_err;
    unsigned int br;
 
    if (!plug_real_port(port, &port))
      {
        s_struc->errcode= SCI_PLUGPORT_ERR;
        return SCI_ERR(s_struc->errcode);
      };
 
    rc= socan_port_bitrate((unsigned char)port, &br);
    if (!map_socan_rc(rc, &sci_rc, &sci_err))
      {
        s_struc->errcode= sci_err;
        return SCI_ERR_RC(sci_rc, sci_err);
      }
 
    switch (br)
      { case 1000000:
             *bitrate= SCI_1000KB;
             break;
        case 500000:
             *bitrate= SCI_500KB;
             break;
        case 250000:
             *bitrate= SCI_250KB;
             break;
        case 125000:
             *bitrate= SCI_125KB;
             break;
        case 100000:
             *bitrate= SCI_100KB;
             break;
        case 66000:
             *bitrate= SCI_66KB;
             break;
        case 66600:
             *bitrate= SCI_66KB;
             break;
        case 66666:
             *bitrate= SCI_66KB;
             break;
        case 50000:
             *bitrate= SCI_50KB;
             break;
        case 20000:
             *bitrate= SCI_20KB;
             break;
        default:
             s_struc->errcode= SCI_ERR_GENERAL;
             return SCI_ERR(s_struc->errcode);
      };
    return SCI_NOTHING;
  }
 
/* ----------------------------------------------
 * get errcode
 * ---------------------------------------------- */
 
sci_Return sci_get_errcode(sci_Struc *s_struc, sci_Errcode *errcode)
  /* similar to the traditional "errno" */
  {
    *errcode= s_struc->errcode;
    return SCI_NOTHING;
  }
 
/* ----------------------------------------------
 * get object
 * ---------------------------------------------- */
 
sci_Return sci_get_object(sci_Struc *s_struc, sci_Object **object,
              unsigned short port, int id)
  /* return sci_Object for a given port and id,
   * returns SCI_OBJ_UNDEF_ERR if the sci_Object is not defined.
   */
  {
    socan_rc rc;
    sci_Return sci_rc;
    sci_Errcode sci_err;
    void *ptr;
 
    if (!plug_real_port(port, &port))
      {
        s_struc->errcode= SCI_PLUGPORT_ERR;
        return SCI_ERR(s_struc->errcode);
      };
 
    rc= socan_user_area(port, id, &ptr);
    if (!map_socan_rc(rc, &sci_rc, &sci_err))
      {
        s_struc->errcode= sci_err;
        return SCI_ERR_RC(sci_rc, sci_err);
      }
    if (ptr==NULL)
      {
        fprintf(stderr, "%s line %d: internal error\n", __FILE__, __LINE__);
        return SCI_ERR(SCI_ERR_GENERAL);
      }
    *object= (sci_Object *)ptr;
    return SCI_NOTHING;
  }
 
/* ----------------------------------------------
 * get user part
 * ---------------------------------------------- */
 
void *sci_get_user(sci_Object *object)
  {
    return (object->userp);
  }
 
/* ----------------------------------------------
 * get object properties
 * ---------------------------------------------- */
 
sci_Return sci_get_info(sci_Struc *s_struc, sci_Object *object,
            unsigned short *port, int *id, int *length, 
            int *timeout, sci_Object_Type *type)
  {
    unsigned char l;
    unsigned int tmo;
    socan_obj_type tp;
    sci_Return sci_rc;
    sci_Errcode sci_err;
 
    socan_rc rc= socan_obj_info(s_struc->hdl, object->realport,
                                object->cob, &l, &tmo, &tp);
    if (!map_socan_rc(rc, &sci_rc, &sci_err))
      {
        s_struc->errcode= sci_err;
        return SCI_ERR_RC(sci_rc, sci_err);
      }
    *port= object->port;
    *id= object->cob;
    *length= object->length;
    *timeout= tmo;
    if (map_socan_type(tp, type))
      {
        s_struc->errcode= SCI_ERR_GENERAL;
        return SCI_ERR_RC(rc, s_struc->errcode);
      }
    return sci_rc;
  }
 
/* ----------------------------------------------
 * get object timestamp
 * ---------------------------------------------- */
 
sci_Return sci_get_timestamp(sci_Struc *s_struc, sci_Object *object,
                             unsigned long long *pstamp, int *pvalid,
                             unsigned char *mode, unsigned char *irq_cnt)
  {
    socan_rc rc;
    sci_Return sci_rc;
    sci_Errcode sci_err;
    unsigned long ts;
 
    rc= socan_obj_ts(object->realport, object->cob, &ts);
    if (!map_socan_rc(rc, &sci_rc, &sci_err))
      {
        s_struc->errcode= sci_err;
        return SCI_ERR_RC(sci_rc, sci_err);
      }
    *pstamp= ts;
    *pvalid= 1;
    *mode= 0; /* not implemented in socan */
    *irq_cnt=0; /* not exported by socan */
    return SCI_NOTHING;
  }
 
/* ----------------------------------------------
 * dump object
 * ---------------------------------------------- */
 
sci_Return sci_obj_dump_buf(char *buf, 
                            sci_Struc *s_struc, sci_Object *object)
  {
    sci_Return sci_rc;
    unsigned short port;
    int id;
    int length;
    int timeout;
    sci_Object_Type type;
    const char *str= "UNKNOWN TYPE!";
 
    sci_rc= sci_get_info(s_struc, object, &port, &id, &length,
                         &timeout, &type);
    if (sci_rc & SCI_ERROR)
      { sprintf(buf, "sci_obj_dump_buf: sci_get_info failed\n");
        return sci_rc;
      };
    switch(type)
      { case SCI_READ: str= "SCI_READ"; break;
    case SCI_WRITE: str= "SCI_WRITE"; break;
    case SCI_REMOTE_READ: str= "SCI_REMOTE_READ"; break;
    case SCI_REMOTE_WRITE: str="SCI_REMOTE_WRITE"; break;
      };
    sprintf(buf,"id:%d length:%d tmout:%d port:%d type:%s\n",
        id,length,timeout,port,str);
 
    return sci_rc;
  }
 
#if 0
sci_Return sci_obj_dump(sci_Struc *s_struc, sci_Object *object)
#endif
 
/* ----------------------------------------------
 * init object
 * ---------------------------------------------- */
 
sci_Return sci_init_object(sci_Struc *s_struc, sci_Object **object,
               unsigned short port, int id, int length, 
               int timeout, sci_Object_Type type, void *userp)
  {
    /* duplicates object if it already exists */
    socan_rc rc;
    sci_Return sci_rc;
    sci_Errcode sci_err;
    sci_plug_struc *ps;
    unsigned short realport= port;
    unsigned char reallength= (unsigned char)length;
    struct sci_object_s *obj;
    sci_Object *root, *parent, *new;
    socan_obj_type stype;
 
    if (!plug_get(port, &ps))
      {
        s_struc->errcode= SCI_PLUGPORT_ERR;
        return SCI_ERR(s_struc->errcode);
      }
    if (ps!=NULL)
      { 
        int l;
        /* plugin defined */
        realport= ps->real_port;
        if (!(ps->lcalc)(length, &l))
          {
            s_struc->errcode= SCI_LENGTH_ERR;
            return SCI_ERR(s_struc->errcode);
          }
        reallength= (unsigned char)l;
      }
    if (!map_sci_type(type, &stype))
      {
        s_struc->errcode= SCI_TYPE_ERR;
        return SCI_ERR(s_struc->errcode);
      }
 
    rc= socan_add_obj(s_struc->hdl, realport,
                      id, reallength,
                      (unsigned int)timeout, stype);
    if (!map_socan_rc(rc, &sci_rc, &sci_err))
      {
        s_struc->errcode= sci_err;
        return SCI_ERR_RC(sci_rc, sci_err);
      }
    if (rc==SOCAN_EXISTS)
      { /* CAN object exists, must duplicate */
        pthread_mutex_lock(&global_semaphore);
        rc= socan_user_area(realport, id, (void**)(&root));
        if (!map_socan_rc(rc, &sci_rc, &sci_err))
          {
            s_struc->errcode= sci_err;
            pthread_mutex_unlock(&global_semaphore);
            return SCI_ERR_RC(sci_rc, sci_err);
          }
        if (root==NULL)
          {
            fprintf(stderr, "%s line %d: internal error\n", __FILE__, __LINE__);
            s_struc->errcode= SCI_ERR_GENERAL;
            pthread_mutex_unlock(&global_semaphore);
            return SCI_ERR(s_struc->errcode);
          }
        for(parent= root; parent->child!=NULL; parent= parent->child);
        new= calloc(1, sizeof(struct sci_object_s));
        new->userp= userp;
        new->port= parent->port;
        new->realport= parent->realport;
        new->cob= parent->cob;
        new->length= parent->length;
        new->reallength= parent->reallength;
        *object= new;
        pthread_mutex_unlock(&global_semaphore);
        return SCI_NOTHING;
      }
 
    rc= socan_new_user_area(realport, id, sizeof(struct sci_object_s),
                            (void**)(&obj));
    if (!map_socan_rc(rc, &sci_rc, &sci_err))
      {
        s_struc->errcode= sci_err;
        return SCI_ERR_RC(sci_rc, sci_err);
      }
    obj->userp= userp;
    obj->port= port;
    obj->realport= realport;
    obj->cob= id;
    obj->length= (unsigned char)length;
    obj->reallength= reallength;
    obj->child= NULL;
    *object= obj;
    return SCI_NOTHING;
  }
 
/* ----------------------------------------------
 * dup object
 * ---------------------------------------------- */
 
#if 0
sci_Return sci_dup_object(sci_Struc *s_struc, sci_Object **dup_object,
              sci_Object *object, void *userp)
#endif
  
/* ----------------------------------------------
 * delete object
 * ---------------------------------------------- */
 
sci_Return sci_delete_object(sci_Struc *s_struc, sci_Object **object)
  {
    socan_rc rc;
    sci_Return sci_rc;
    sci_Errcode sci_err;
    sci_Object *root, *parent;
 
    rc= socan_user_area((*object)->realport, (*object)->cob, (void**)(&root));
    if (!map_socan_rc(rc, &sci_rc, &sci_err))
      {
        s_struc->errcode= sci_err;
        return SCI_ERR_RC(sci_rc, sci_err);
      }
    if (root==NULL)
      {
        s_struc->errcode= SCI_ERR_GENERAL;
        return SCI_ERR(s_struc->errcode);
      }
    pthread_mutex_lock(&global_semaphore);
    if (root==(*object))
      {
        if ((*object)->child != NULL)
          {
            rc= socan_set_user_area((*object)->realport, (*object)->cob,
                                    (*object)->child);
            if (!map_socan_rc(rc, &sci_rc, &sci_err))
              {
                fprintf(stderr, "%s line %d: internal error\n",
                        __FILE__, __LINE__);
                s_struc->errcode= sci_err;
                pthread_mutex_unlock(&global_semaphore);
                return SCI_ERR_RC(sci_rc, sci_err);
              }
            free(*object);
            *object= NULL;
            pthread_mutex_unlock(&global_semaphore);
            return SCI_NOTHING;
          }
        /* continue deleting object...*/
      }
    else
      {
        for(parent= root;
            (parent->child!=(*object)) && (parent->child!=NULL);
            parent= parent->child);
        if (parent->child != (*object))
          { /* not found */
            fprintf(stderr, "%s line %d: internal error\n", __FILE__, __LINE__);
            s_struc->errcode= SCI_ERR_GENERAL;
            pthread_mutex_unlock(&global_semaphore);
            return SCI_ERR(s_struc->errcode);
          }
        parent->child= (*object)->child;
        free(*object);
        *object= NULL;
        pthread_mutex_unlock(&global_semaphore);
        return SCI_NOTHING;
      }
 
    rc= socan_del_obj((*object)->realport, (*object)->cob);
    if (!map_socan_rc(rc, &sci_rc, &sci_err))
      {
        s_struc->errcode= sci_err;
        pthread_mutex_unlock(&global_semaphore);
        return SCI_ERR_RC(sci_rc, sci_err);
      }
    *object= NULL;
    pthread_mutex_unlock(&global_semaphore);
    return sci_rc;
  }
 
 
/* ----------------------------------------------
 * link object
 * ---------------------------------------------- */
 
#if 0
sci_Return sci_link_object(sci_Struc *s_struc,
               unsigned short read_port , int read_id, 
                           unsigned short write_port, int write_id, 
               int length, int timeout,
                           void *read_user, void *write_user)
#endif
 
/* ----------------------------------------------
 * set inhibit
 * ---------------------------------------------- */
 
sci_Return sci_set_inhibit(sci_Struc *s_struc, sci_Object *object,
               unsigned long inhibit_time)
  {
    socan_rc rc;
    sci_Return sci_rc;
    sci_Errcode sci_err;
 
    rc= socan_set_inhibit(object->realport, object->cob, inhibit_time);
    if (!map_socan_rc(rc, &sci_rc, &sci_err))
      {
        s_struc->errcode= sci_err;
        return SCI_ERR_RC(sci_rc, sci_err);
      }
    return sci_rc;
  }
 
/* ----------------------------------------------
 * set callback
 * ---------------------------------------------- */
 
sci_Return sci_set_callback(sci_Struc *s_struc, sci_Object *object,
                void *f)
/* f must always be NULL */
  {
    socan_rc rc;
    sci_Return sci_rc;
    sci_Errcode sci_err;
 
    rc= socan_use_queue(object->realport, object->cob);
    if (!map_socan_rc(rc, &sci_rc, &sci_err))
      {
        s_struc->errcode= sci_err;
        return SCI_ERR_RC(sci_rc, sci_err);
      }
    return sci_rc;
  }
 
 
/* ----------------------------------------------
 * write object
 * ---------------------------------------------- */
 
static sci_Return can_write(sci_Struc *s_struc, sci_Object *object, 
                    char *data, unsigned long *rest_time)
  {
    socan_rc rc;
    sci_Return sci_rc;
    sci_Errcode sci_err;
    sci_plug_struc *ps;
    char buf[SOCAN_FRAME_LENGTH];
 
    if (!plug_get(object->port, &ps))
      {
        s_struc->errcode= SCI_PLUGPORT_ERR;
        return SCI_ERR(s_struc->errcode);
      }
    if (ps!=NULL)
      { 
        /* plugin defined */
        /* convert data: */
        (ps->h2l)(object->reallength, buf, object->length, data);
        data= buf;
      }
 
    if (rest_time==NULL)
      rc= socan_writelater(s_struc->hdl, object->realport, object->cob, data);
    else
      rc= socan_write_inhibit(s_struc->hdl, object->realport, object->cob,
                              data, rest_time);
 
    if (!map_socan_rc(rc, &sci_rc, &sci_err))
      {
        s_struc->errcode= sci_err;
        return SCI_ERR_RC(sci_rc, sci_err);
      }
    return sci_rc;
  }
 
sci_Return sci_write(sci_Struc *s_struc, sci_Object *object, 
             char *data)
  {
    return can_write(s_struc, object, data, NULL);
  }
 
sci_Return sci_write_inhibit(sci_Struc *s_struc, sci_Object *object, 
                     char *data, unsigned long *rest_time)
  
  {
    return can_write(s_struc, object, data, rest_time);
  }
 
/* ----------------------------------------------
 * read
 * ---------------------------------------------- */
 
static sci_Return can_read(sci_Struc *s_struc, sci_Object *object, 
                   char *data, bool read_now)
  {
    socan_rc rc;
    sci_Return sci_rc;
    sci_Errcode sci_err;
    sci_plug_struc *ps;
    char buf[SOCAN_FRAME_LENGTH];
 
    if (!plug_get(object->port, &ps))
      {
        s_struc->errcode= SCI_PLUGPORT_ERR;
        return SCI_ERR(s_struc->errcode);
      }
    if (read_now)
      rc= socan_readnow(s_struc->hdl, object->realport, object->cob, data);
    else
      rc= socan_read(s_struc->hdl, object->realport, object->cob, data);
 
    if (!map_socan_rc(rc, &sci_rc, &sci_err))
      {
        s_struc->errcode= sci_err;
        return SCI_ERR_RC(sci_rc, sci_err);
      }
    if (ps!=NULL)
      { 
        /* plugin defined */
        /* convert data: */
        (ps->l2h)(object->reallength, data, object->length, buf);
        memcpy(data, buf, object->length);
      }
    return sci_rc;
  }
 
sci_Return sci_read_now(sci_Struc *s_struc, sci_Object *object, 
                char *data)
  {
    return can_read(s_struc, object, data, true);
  }
 
#if 0
sci_Return sci_read_new(sci_Struc *s_struc, sci_Object *object, 
                char *data)
#endif
 
sci_Return sci_read(sci_Struc *s_struc, sci_Object *object, 
            char *data)
  {
    return can_read(s_struc, object, data, false);
  }
 
/* ----------------------------------------------
 * queue read
 * ---------------------------------------------- */
 
sci_Return sci_queue_read(sci_Struc *s_struc, sci_Object **object,
              char *data)
  {
    socan_rc rc;
    sci_Return sci_rc;
    sci_Errcode sci_err;
    unsigned short cob;
    unsigned char port;
    sci_plug_struc *ps;
    struct sci_object_s *obj;
 
    *object= NULL;
    rc= socan_queue_read(s_struc->hdl, &port, &cob, data);
    if (!map_socan_rc(rc, &sci_rc, &sci_err))
      {
        s_struc->errcode= sci_err;
        return SCI_ERR_RC(sci_rc, sci_err);
      }
    rc= socan_user_area(port, cob, (void**)(&obj));
    if (!map_socan_rc(rc, &sci_rc, &sci_err))
      {
        s_struc->errcode= sci_err;
        return SCI_ERR_RC(sci_rc, sci_err);
      }
    if (obj==NULL)
      {
        fprintf(stderr, "%s line %d: internal error\n", __FILE__, __LINE__);
        return SCI_ERR(SCI_ERR_GENERAL);
      }
    if (!plug_get(obj->port, &ps))
      {
        s_struc->errcode= SCI_PLUGPORT_ERR;
        return SCI_ERR_RC(sci_rc, sci_err);
      }
    if (ps!=NULL)
      { 
        /* plugin defined */
        /* convert data: */
        char buf[SOCAN_FRAME_LENGTH];
        (ps->l2h)(obj->reallength, data, obj->length, buf);
        memcpy(data, buf, obj->length);
      }
    *object= obj;
    return sci_rc;
  }