00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00071 #include "korebot.h"
00072 #include "knet_i2c.h"
00073 #include "knet_rs232.h"
00074
00075 #include "bit_conv_tab.c"
00076
00078 static unsigned int knet_buffer_size = 0;
00079 static char *knet_buffer = NULL;
00081 pthread_mutex_t knet_buffer_lock;
00082
00084 static unsigned int knet_bus_count=0;
00085
00087 static knet_bus_t knet_busses[ KNET_MAX_BUSSES ];
00088
00094 const char * knet_bus_names[] = {
00095 "none" , "i2c" , "spi" , "rs232" , NULL
00096 };
00097
00098
00110 int knet_init( int argc , char * argv[] )
00111 {
00112 int rc;
00113 unsigned int r;
00114 knet_bus_t * bus;
00115
00116 if ( knet_bus_count > 0 ) {
00117
00118 return;
00119 }
00120
00121 for (r=0; r<KNET_MAX_BUSSES; r++)
00122 knet_busses[r].usage_counter = 0;
00123
00124 #ifdef KNET_BUS_I2C
00125 bus = &knet_busses[ KNET_BUS_I2C ];
00126 pthread_mutex_init( &bus->lock , 0 );
00127
00128 if ( (rc=knet_i2c_init( bus , argc , argv )) < 0 )
00129 return rc;
00130
00131 bus->usage_counter = 1;
00132 knet_bus_count++;
00133 #endif
00134
00135 #ifdef KNET_BUS_SPI
00136
00137 #endif
00138
00139 #ifdef KNET_BUS_RS232
00140 bus = &knet_busses[ KNET_BUS_RS232 ];
00141 pthread_mutex_init( &bus->lock , 0 );
00142
00143 if ((rc=knet_rs232_init( bus , argc , argv )) < 0 )
00144 return rc;
00145
00146 bus->usage_counter = 1;
00147 knet_bus_count++;
00148 #endif
00149
00150
00151
00152 knet_buffer_size = 1024;
00153 knet_buffer = kb_alloc( knet_buffer_size );
00154 pthread_mutex_init( &knet_buffer_lock, 0 );
00155
00156 return knet_bus_count;
00157 }
00158
00159
00165 void knet_exit( void )
00166 {
00167 unsigned int r;
00168 knet_bus_t * bus;
00169 knet_dev_t * dev;
00170
00171 for (r=0; r<KNET_MAX_BUSSES; r++) {
00172 bus = &knet_busses[ r ];
00173 if ( bus->usage_counter ) {
00174
00175 while ( bus->devices != NULL ) {
00176 knet_device_destroy( bus->devices );
00177 }
00178
00179 if ( bus->exit != NULL ) bus->exit( bus );
00180 knet_bus_count--;
00181 }
00182 }
00183
00184 kb_free ( knet_buffer );
00185 knet_buffer = NULL;
00186 knet_buffer_size = 0;
00187 }
00188
00189
00201 knet_dev_t *knet_bus_find_device( knet_bus_t * bus ,
00202 knet_ext_t ext_addr ,
00203 knet_mod_t mod_addr )
00204 {
00205 knet_dev_t * dev;
00206
00207 dev = bus->devices;
00208
00209 while ( dev != NULL ) {
00210 if ( dev->ext_addr == ext_addr &&
00211 dev->mod_addr == mod_addr )
00212 return dev;
00213 dev = dev->next;
00214 }
00215 return NULL;
00216 }
00217
00218
00229 knet_dev_t *knet_bus_find_device_by_name( knet_bus_t * bus ,
00230 const char * dev_name )
00231 {
00232 knet_dev_t * dev;
00233
00234 dev = bus->devices;
00235
00236 while ( dev != NULL ) {
00237 if ( !strcmp( dev->name , dev_name ))
00238 return dev;
00239 dev = dev->next;
00240 }
00241 return NULL;
00242 }
00243
00244
00245
00270 knet_dev_t * knet_open( const char * device ,
00271 int preferred_bus ,
00272 int argc , char * argv[] )
00273 {
00274 knet_bus_t * bus = NULL;
00275 knet_dev_t * dev;
00276
00277 knet_mod_t mod_adr;
00278 knet_ext_t ext_adr;
00279 kb_device_config_t * mod;
00280 kb_section_config_t * sec;
00281
00282 char * dev_name;
00283
00284 #if 0
00285 name = KB_ALLOC( char , strlen(device)+1 );
00286
00287 strcpy( name , device );
00288
00289 ext_name = name;
00290 mod_name = strchr( name , '%' );
00291 if ( mod_name != NULL ) {
00292 *mod_name = '\0';
00293 mod_name++;
00294 }
00295
00296 if ((ext = kb_lookup_device( ext_name )) == NULL) {
00297 / kb_error( __FILE__ ,
00298 __LINE__ ,
00299 "knet_open" ,
00300 KB_ERROR_NODEVFOUNDSTR , ext_name );
00301 kb_free(name);
00302 return NULL;
00303 }
00304
00305 if ( mod_name == NULL ) {
00306 mod = ext;
00307 ext = NULL;
00308 }
00309 else {
00310 if ((mod = kb_lookup_device( mod_name )) == NULL) {
00311 kb_error( __FILE__ ,
00312 __LINE__ ,
00313 "knet_open" ,
00314 KB_ERROR_NODEVFOUNDSTR , mod_name );
00315 kb_free( name );
00316 return NULL;
00317 }
00318 }
00319
00320 kb_free(name);
00321 #endif
00322
00323 if ((mod = kb_lookup_device( device )) == NULL) {
00324 KB_ERROR( "knet_open" , KB_ERROR_NODEVFOUNDSTR , device );
00325 return NULL;
00326 }
00327
00328 sec = mod->section;
00329 bus = NULL;
00330
00331
00332 if((mod->kclass[ KB_DEVICE_CLASS_MODULE ].defined && preferred_bus == KNET_BUS_ANY) ||
00333 (sec->module_bus != KNET_BUS_ANY && preferred_bus == sec->module_bus ))
00334 {
00335 if(sec->module_bus == KNET_BUS_ANY) {
00336 KB_ERROR("knet_open",KB_ERROR_NOMODBUS);
00337 return NULL;
00338 }
00339
00340
00341 mod_adr = sec->module_bus_addr;
00342 if(mod_adr < 0) {
00343 KB_ERROR("knet_open",KB_ERROR_NOBUSADDR);
00344 return NULL;
00345 }
00346
00347 #ifdef KNET_BUS_SPI
00348 if(sec->module_bus == KNET_BUS_SPI)
00349 {
00350 bus = &knet_busses[ KNET_BUS_SPI ];
00351 ext_adr = mod->kclass[ KB_DEVICE_CLASS_MODULE].address;
00352 }
00353 #endif
00354
00355 #ifdef KNET_BUS_I2C
00356 if(sec->module_bus == KNET_BUS_I2C)
00357 {
00358 bus = &knet_busses[ KNET_BUS_I2C ];
00359 mod_adr = mod->kclass[ KB_DEVICE_CLASS_MODULE].address;
00360 }
00361 #endif
00362
00363 #ifdef KNET_BUS_RS232
00364 if(sec->module_bus == KNET_BUS_RS232)
00365 {
00366 bus = &knet_busses[ KNET_BUS_RS232 ];
00367 mod_adr = mod->kclass[ KB_DEVICE_CLASS_MODULE].address;
00368 }
00369 #endif
00370 }
00371 else
00372 {
00373
00374 #ifdef KNET_BUS_SPI
00375 if ( (( bus == NULL ) || ( preferred_bus == KNET_BUS_SPI ))
00376 && mod->kclass[ KB_DEVICE_CLASS_SPI ].defined ) {
00377 bus = &knet_busses[ KNET_BUS_SPI ];
00378 mod_adr = mod->kclass[ KB_DEVICE_CLASS_SPI ].address;
00379 ext_adr = 0;
00380 dev_name = NULL;
00381 }
00382 #endif
00383
00384 #ifdef KNET_BUS_I2C
00385 if ( (( bus == NULL ) || ( preferred_bus == KNET_BUS_I2C ))
00386 && mod->kclass[ KB_DEVICE_CLASS_I2C ].defined ) {
00387 bus = &knet_busses[ KNET_BUS_I2C ];
00388 mod_adr = mod->kclass[ KB_DEVICE_CLASS_I2C ].address;
00389 ext_adr = 0;
00390 dev_name = NULL;
00391 }
00392 #endif
00393
00394 #ifdef KNET_BUS_RS232
00395 if ( (( bus == NULL ) || ( preferred_bus == KNET_BUS_RS232 ))
00396 && mod->kclass[ KB_DEVICE_CLASS_RS232 ].defined ) {
00397 bus = &knet_busses[ KNET_BUS_RS232 ];
00398 mod_adr = mod->kclass[ KB_DEVICE_CLASS_RS232 ].address;
00399 ext_adr = 0;
00400 dev_name = mod->kclass[ KB_DEVICE_CLASS_RS232 ].device_name;
00401 }
00402 #endif
00403 }
00404
00405
00406 if ( (bus == NULL) || (bus->usage_counter==0) ) {
00407 kb_error( __FILE__ ,
00408 __LINE__ ,
00409 "knet_open" ,
00410 KB_ERROR_NOBUSFOUND , device );
00411 return NULL;
00412 }
00413
00414
00415 usleep(50000);
00416
00417 pthread_mutex_lock( &bus->lock );
00418 dev = bus->open( bus ,
00419 ext_adr , mod_adr , dev_name ,
00420 argc , argv );
00421 pthread_mutex_unlock ( &bus->lock );
00422
00423 usleep(50000);
00424 return dev;
00425 }
00426
00427
00435 void knet_close( knet_dev_t * dev )
00436 {
00437 knet_bus_t * bus = dev->bus;
00438
00439 pthread_mutex_lock( &bus->lock );
00440 if ( dev->usage_counter > 0 ) {
00441 if ( bus->close != NULL ) bus->close( bus , dev );
00442 dev->usage_counter--;
00443 }
00444 pthread_mutex_unlock( &bus->lock );
00445 }
00446
00447
00482 void knet_set_order( knet_dev_t * dev , unsigned long order )
00483 {
00484 knet_bus_t * bus = dev->bus;
00485
00486 pthread_mutex_lock( &bus->lock );
00487 dev->order = order;
00488 pthread_mutex_unlock( &bus->lock);
00489 }
00490
00491
00504 knet_dev_t * knet_device_create( knet_bus_t * bus ,
00505 knet_ext_t ext_addr ,
00506 knet_mod_t mod_addr ,
00507 const char * name )
00508 {
00509 knet_dev_t * dev = KB_ALLOC( knet_dev_t , 1 );
00510
00511
00512 dev->bus = bus;
00513 dev->order = 0;
00514 dev->next = NULL;
00515 dev->ext_addr = ext_addr;
00516 dev->mod_addr = mod_addr;
00517 dev->usage_counter = 0;
00518
00519
00520 dev->next = bus->devices;
00521 bus->devices = dev;
00522
00523
00524 return dev;
00525 }
00526
00527
00539 int knet_device_destroy( knet_dev_t * dev )
00540 {
00541 knet_bus_t * bus = dev->bus;
00542 knet_dev_t * prev = bus->devices;
00543 int ok;
00544
00545 if ( dev->usage_counter ) {
00546 return kb_error( __FILE__ ,
00547 __LINE__ ,
00548 "knet_device_destroy" ,
00549 KB_ERROR_DEVICEINUSE );
00550 }
00551
00552 pthread_mutex_lock( &bus->lock );
00553
00554 ok = 0;
00555
00556 if ( prev == dev ) {
00557 bus->devices = dev->next;
00558 dev->next = NULL;
00559 ok = 1;
00560 }
00561 else {
00562 while( prev != NULL ) {
00563 if ( prev->next == dev ) {
00564 prev->next = dev->next;
00565 dev->next = NULL;
00566 ok = 1;
00567 break;
00568 }
00569 prev = prev->next;
00570 }
00571 }
00572
00573 pthread_mutex_unlock( &bus->lock );
00574
00575 if ( !ok ) {
00576 return kb_error( __FILE__ ,
00577 __LINE__ ,
00578 "knet_device_destroy" ,
00579 KB_ERROR_UNLINKDEV );
00580 }
00581
00582 kb_free( dev );
00583 return 0;
00584 }
00585
00586
00604 int knet_lltransfer( knet_dev_t * dev ,
00605 const char * write_buf , unsigned int write_len ,
00606 char * read_buf , unsigned int read_len )
00607 {
00608 knet_bus_t * bus;
00609 int rc;
00610
00611 bus = dev->bus;
00612
00613 pthread_mutex_lock( &bus->lock );
00614
00615 if ( bus->transfer == NULL ) {
00616 rc = bus->write( bus , dev , write_buf , write_len );
00617 if ( rc >= 0 )
00618 rc = bus->read( bus , dev , read_buf , read_len );
00619 }
00620 else
00621 rc = bus->transfer( bus , dev , write_buf , write_len , read_buf , read_len );
00622
00623 pthread_mutex_unlock( &bus->lock );
00624
00625 return rc;
00626 }
00627
00628
00643 int knet_llread( knet_dev_t * dev ,
00644 char *buf ,
00645 unsigned int len )
00646 {
00647 knet_bus_t * bus;
00648 int rc;
00649
00650 bus = dev->bus;
00651
00652 pthread_mutex_lock(&bus->lock);
00653 rc = bus->read( bus , dev , buf , len );
00654 pthread_mutex_unlock(&bus->lock);
00655
00656 return rc;
00657 }
00658
00659
00674 int knet_llwrite( knet_dev_t * dev ,
00675 const char * buf ,
00676 unsigned int len )
00677 {
00678 knet_bus_t * bus;
00679 int rc;
00680
00681 bus = dev->bus;
00682
00683 pthread_mutex_lock(&bus->lock);
00684 rc = bus->write( bus , dev , buf , len );
00685 pthread_mutex_unlock(&bus->lock);
00686
00687 return rc;
00688 }
00689
00690
00708 int knet_convert( knet_dev_t * dev , char * buf , unsigned int len , int type )
00709 {
00710 unsigned int pos;
00711 unsigned char tmp;
00712
00713 if ( type != 1 && type != 2 && type != 4 )
00714 return -1;
00715
00716 if ( dev->order & KNET_ORDER_BIT_SWAP ) {
00717 for (pos=0; pos<len; pos++) {
00718 buf[pos] = bit_conv_tab[buf[pos]];
00719 }
00720 }
00721
00722 if ( type > 1 &&
00723 (dev->order & KNET_ORDER_BIG) ) {
00724
00725 if ((len%type)) return -1;
00726
00727 for (pos=0; pos<(len/type); pos++) {
00728 if ( type == 2 ) {
00729 tmp = buf[2*pos];
00730 buf[2*pos] = buf[2*pos+1];
00731 buf[2*pos+1] = tmp;
00732 }
00733 else {
00734 tmp = buf[4*pos];
00735 buf[4*pos] = buf[4*pos+3];
00736 buf[4*pos+3] = tmp;
00737 tmp = buf[4*pos+1];
00738 buf[4*pos+1] = buf[4*pos+2];
00739 buf[4*pos+2] = tmp;
00740 }
00741 }
00742 }
00743 return 0;
00744 }
00745
00746
00760 int knet_read8( knet_dev_t * dev ,
00761 knet_reg_t reg ,
00762 unsigned char * val )
00763 {
00764 int rc;
00765
00766 if ( dev->order & KNET_ORDER_BIT_SWAP )
00767 reg = bit_conv_tab[reg];
00768
00769 rc = knet_lltransfer( dev , ® , 1 , val , 1 );
00770
00771 if ( dev->order & KNET_ORDER_BIT_SWAP )
00772 (*val) = bit_conv_tab[(*val)];
00773
00774 return rc;
00775 }
00776
00777
00792 int knet_read16( knet_dev_t * dev ,
00793 knet_reg_t reg ,
00794 unsigned short * val )
00795 {
00796 int rc;
00797 unsigned char * p = (unsigned char *) val;
00798 unsigned char t , treg[2];
00799
00800
00801
00802 if ( dev->order & KNET_ORDER_BIT_SWAP ) {
00803 treg[0] = bit_conv_tab[reg];
00804 treg[1] = bit_conv_tab[reg+1];
00805 }
00806 else {
00807 treg[0] = reg;
00808 treg[1] = reg+1;
00809 }
00810
00811
00812 if ( dev->order & KNET_ORDER_REP_ADR ) {
00813 unsigned char * p = (unsigned char *)val;
00814
00815
00816 if ( dev->order & KNET_ORDER_MSB_FIRST ) {
00817
00818 if ((rc=knet_lltransfer( dev , &treg[1] , 1 , (char *)&p[1] , 1 )) < 0 )
00819 return rc;
00820
00821 if ((rc=knet_lltransfer( dev , &treg[0] , 1 , (char *)&p[0] , 1 )) < 0 )
00822 return rc;
00823 }
00824
00825 else {
00826
00827 if ((rc=knet_lltransfer( dev , &treg[0] , 1 , (char *)&p[0] , 1 )) < 0 )
00828 return rc;
00829
00830 if ((rc=knet_lltransfer( dev , &treg[1] , 1 , (char *)&p[1] , 1 )) < 0 )
00831 return rc;
00832 }
00833 }
00834 else {
00835 rc = knet_lltransfer( dev , &treg[0] , 1 , (char *)val , 2 );
00836 if ( rc < 0 )
00837 return rc;
00838 }
00839
00840
00841 if ( dev->order & KNET_ORDER_BIG ) {
00842 t = p[0];
00843 p[0] = p[1];
00844 p[1] = t;
00845 }
00846
00847 return rc;
00848 }
00849
00850
00861 int knet_read32( knet_dev_t * dev ,
00862 knet_reg_t reg ,
00863 unsigned long * val )
00864 {
00865 int rc;
00866 unsigned char * p = (unsigned char *) val;
00867 unsigned char t , treg[4];
00868
00869
00870 if ( dev->order & KNET_ORDER_BIT_SWAP ) {
00871 treg[0] = bit_conv_tab[reg];
00872 treg[1] = bit_conv_tab[reg+1];
00873 treg[2] = bit_conv_tab[reg+2];
00874 treg[3] = bit_conv_tab[reg+3];
00875 }
00876 else {
00877 treg[0] = reg;
00878 treg[1] = reg+1;
00879 treg[2] = reg+2;
00880 treg[3] = reg+3;
00881 }
00882
00883
00884 if ( dev->order & KNET_ORDER_REP_ADR ) {
00885 unsigned char * p = (unsigned char *)val;
00886
00887
00888 if ( dev->order & KNET_ORDER_MSB_FIRST ) {
00889
00890 if ((rc=knet_lltransfer( dev , &treg[3] , 1 , &p[3] , 1 )) < 0 )
00891 return rc;
00892
00893 if ((rc=knet_lltransfer( dev , &treg[2] , 1 , &p[2] , 1 )) < 0 )
00894 return rc;
00895
00896 if ((rc=knet_lltransfer( dev , &treg[1] , 1 , &p[1] , 1 )) < 0 )
00897 return rc;
00898
00899 if ((rc=knet_lltransfer( dev , &treg[0] , 1 , &p[0] , 1 )) < 0 )
00900 return rc;
00901
00902 }
00903
00904 else {
00905
00906 if ((rc=knet_lltransfer( dev , &treg[0] , 1 , &p[0] , 1 )) < 0 )
00907 return rc;
00908
00909 if ((rc=knet_lltransfer( dev , &treg[1] , 1 , &p[1] , 1 )) < 0 )
00910 return rc;
00911
00912 if ((rc=knet_lltransfer( dev , &treg[2] , 1 , &p[2] , 1 )) < 0 )
00913 return rc;
00914
00915 if ((rc=knet_lltransfer( dev , &treg[3] , 1 , &p[3] , 1 )) < 0 )
00916 return rc;
00917 }
00918 }
00919 else {
00920 rc = knet_lltransfer( dev , &treg[0] , 1 , (char *)val , 4 );
00921 if ( rc < 0 )
00922 return rc;
00923 }
00924
00925
00926 if ( dev->order & KNET_ORDER_BIG ) {
00927 t = p[0];
00928 p[0] = p[3];
00929 p[3] = t;
00930 t = p[1];
00931 p[1] = p[2];
00932 p[2] = t;
00933 }
00934 }
00935
00936
00948 int knet_readxBytes( knet_dev_t * dev ,
00949 knet_reg_t reg ,
00950 unsigned char * val, unsigned char rx_len )
00951 {
00952 int rc;
00953
00954
00955 if ( dev->order & KNET_ORDER_BIT_SWAP ) {
00956 reg = bit_conv_tab[reg];
00957 }
00958 rc = knet_lltransfer( dev , ® , 1 , val , rx_len );
00959 if(rc < 0)
00960 return rc;
00961
00962
00963
00964 }
00965
00966
00980 int knet_write8( knet_dev_t * dev ,
00981 knet_reg_t reg ,
00982 unsigned char val )
00983 {
00984 unsigned char buf[2];
00985
00986 if ( dev->order & KNET_ORDER_BIT_SWAP ) {
00987 buf[0] = bit_conv_tab[reg];
00988 buf[1] = bit_conv_tab[val];
00989 }
00990 else {
00991 buf[0] = reg;
00992 buf[1] = val;
00993 }
00994
00995 return knet_llwrite( dev , buf , 2 );
00996 }
00997
00998
01012 int knet_write16( knet_dev_t * dev ,
01013 knet_reg_t reg ,
01014 unsigned short val )
01015 {
01016 unsigned char buf[3];
01017 unsigned char *p = (unsigned char *)&val;
01018 unsigned char t , treg[2];
01019 int rc;
01020
01021 if ( dev->order & KNET_ORDER_BIT_SWAP ) {
01022 treg[0] = bit_conv_tab[reg];
01023 treg[1] = bit_conv_tab[reg+1];
01024 }
01025 else {
01026 treg[0] = reg;
01027 treg[1] = reg+1;
01028 }
01029
01030 if ( dev->order & KNET_ORDER_BIG ) {
01031 t = p[0];
01032 p[0] = p[1];
01033 p[1] = t;
01034 }
01035
01036 if ( dev->order & KNET_ORDER_REP_ADR ) {
01037
01038
01039 if ( dev->order & KNET_ORDER_MSB_FIRST ) {
01040
01041 buf[0] = treg[1];
01042 buf[1] = p[1];
01043
01044 if ((rc=knet_llwrite( dev , buf , 2 )) < 0 )
01045 return rc;
01046
01047 buf[0] = treg[0];
01048 buf[1] = p[0];
01049
01050 if ((rc=knet_llwrite( dev , buf , 2 )) < 0 )
01051 return rc;
01052
01053 }
01054 else {
01055
01056 buf[0] = treg[0];
01057 buf[1] = p[0];
01058
01059 if ((rc=knet_llwrite( dev , buf , 2 )) < 0 )
01060 return rc;
01061
01062 buf[0] = treg[1];
01063 buf[1] = p[1];
01064
01065 if ((rc=knet_llwrite( dev , buf , 2 )) < 0 )
01066 return rc;
01067
01068 }
01069 }
01070 else {
01071 rc=knet_llwrite( dev , buf , 3 );
01072 }
01073 return rc;
01074 }
01075
01076
01090 int knet_write32( knet_dev_t * dev ,
01091 knet_reg_t reg ,
01092 unsigned long val )
01093 {
01094 unsigned char buf[5];
01095 unsigned char *p = (unsigned char *)&val;
01096 unsigned char t , treg[4];
01097 int rc;
01098
01099 if ( dev->order & KNET_ORDER_BIT_SWAP ) {
01100 treg[0] = bit_conv_tab[reg];
01101 treg[1] = bit_conv_tab[reg+1];
01102 treg[2] = bit_conv_tab[reg+2];
01103 treg[3] = bit_conv_tab[reg+3];
01104 }
01105 else {
01106 treg[0] = reg;
01107 treg[1] = reg+1;
01108 treg[2] = reg+2;
01109 treg[3] = reg+3;
01110 }
01111
01112 if ( dev->order & KNET_ORDER_BIG ) {
01113 t = p[0];
01114 p[0] = p[3];
01115 p[3] = t;
01116 t = p[1];
01117 p[1] = p[2];
01118 p[2] = t;
01119 }
01120
01121 if ( dev->order & KNET_ORDER_REP_ADR ) {
01122
01123 if ( dev->order & KNET_ORDER_MSB_FIRST ) {
01124
01125 buf[0] = treg[3];
01126 buf[1] = p[3];
01127
01128 if ((rc=knet_llwrite( dev , buf , 2 )) < 0 )
01129 return rc;
01130
01131 buf[0] = treg[2];
01132 buf[1] = p[2];
01133
01134 if ((rc=knet_llwrite( dev , buf , 2 )) < 0 )
01135 return rc;
01136
01137 buf[0] = treg[1];
01138 buf[1] = p[1];
01139
01140 if ((rc=knet_llwrite( dev , buf , 2 )) < 0 )
01141 return rc;
01142
01143 buf[0] = treg[0];
01144 buf[1] = p[0];
01145
01146 if ((rc=knet_llwrite( dev , buf , 2 )) < 0 )
01147 return rc;
01148
01149 }
01150 else {
01151
01152 buf[0] = treg[0];
01153 buf[1] = p[0];
01154
01155 if ((rc=knet_llwrite( dev , buf , 2 )) < 0 )
01156 return rc;
01157
01158 buf[0] = treg[1];
01159 buf[1] = p[1];
01160
01161 if ((rc=knet_llwrite( dev , buf , 2 )) < 0 )
01162 return rc;
01163
01164 buf[0] = treg[2];
01165 buf[1] = p[2];
01166
01167 if ((rc=knet_llwrite( dev , buf , 2 )) < 0 )
01168 return rc;
01169 buf[0] = treg[3];
01170 buf[1] = p[3];
01171
01172 if ((rc=knet_llwrite( dev , buf , 2 )) < 0 )
01173 return rc;
01174 }
01175 }
01176 else {
01177 rc=knet_llwrite( dev , buf , 3 );
01178 }
01179 return rc;
01180 }
01181
01182
01195 int knet_read( knet_dev_t * dev , knet_reg_t reg )
01196 {
01197 unsigned char val;
01198 int rc;
01199
01200 if ((rc = knet_read8( dev , reg , &val )) < 0)
01201 return rc;
01202
01203 return val;
01204 }
01205
01206
01217 int knet_vprintf( knet_dev_t * dev ,
01218 const char * format ,
01219 va_list argptr )
01220 {
01221 int rc;
01222
01223 pthread_mutex_lock(&knet_buffer_lock);
01224 for (;;) {
01225 rc = vsnprintf( knet_buffer , knet_buffer_size , format , argptr );
01226
01227 if ( knet_buffer_size < rc ) {
01228
01229 while ( knet_buffer_size < rc ) {
01230 knet_buffer_size *= 2;
01231 }
01232 knet_buffer = kb_realloc( knet_buffer , knet_buffer_size );
01233 }
01234 else
01235 break;
01236 }
01237 pthread_mutex_unlock(&knet_buffer_lock);
01238
01239 return knet_llwrite( dev , knet_buffer , rc );
01240 }
01241
01242
01252 int knet_printf( knet_dev_t * dev , const char * format , ... )
01253 {
01254 va_list argptr;
01255 int rc;
01256
01257 pthread_mutex_lock(&knet_buffer_lock);
01258 va_start( argptr , format );
01259 for (;;) {
01260 rc = vsnprintf( knet_buffer , knet_buffer_size , format , argptr );
01261
01262 if ( knet_buffer_size < rc ) {
01263
01264 while ( knet_buffer_size < rc ) {
01265 knet_buffer_size *= 2;
01266 }
01267 knet_buffer = kb_realloc( knet_buffer , knet_buffer_size );
01268 }
01269 else
01270 break;
01271 }
01272 va_end( argptr );
01273 pthread_mutex_unlock(&knet_buffer_lock);
01274
01275 return knet_llwrite( dev , knet_buffer , rc );
01276 }
01277
01278
01284 int knet_read_string( knet_dev_t * dev ,
01285 char * buffer ,
01286 unsigned int size ,
01287 unsigned char terminator )
01288 {
01289 unsigned int pos=0;
01290 unsigned char ch;
01291 int rc;
01292
01293 for (;;) {
01294 if ((rc = knet_llread( dev , &ch , 1 )) < 0 )
01295 return rc;
01296 if ( rc > 0 ) {
01297 buffer[pos++] = ch;
01298 buffer[pos] = '\0';
01299
01300 if ( pos == size || ch == terminator )
01301 return pos;
01302 }
01303 }
01304 }