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
00272 knet_dev_t * knet_open( const char * device ,
00273 int preferred_bus ,
00274 int argc , char * argv[] )
00275 {
00276 knet_bus_t * bus = NULL;
00277 knet_dev_t * dev;
00278
00279 knet_mod_t mod_adr;
00280 knet_ext_t ext_adr;
00281 kb_device_config_t * mod;
00282 kb_section_config_t * sec;
00283
00284 char * dev_name;
00285
00286 #if 0
00287 name = KB_ALLOC( char , strlen(device)+1 );
00288
00289 strcpy( name , device );
00290
00291 ext_name = name;
00292 mod_name = strchr( name , '%' );
00293 if ( mod_name != NULL ) {
00294 *mod_name = '\0';
00295 mod_name++;
00296 }
00297
00298 if ((ext = kb_lookup_device( ext_name )) == NULL) {
00299 / kb_error( __FILE__ ,
00300 __LINE__ ,
00301 "knet_open" ,
00302 KB_ERROR_NODEVFOUNDSTR , ext_name );
00303 kb_free(name);
00304 return NULL;
00305 }
00306
00307 if ( mod_name == NULL ) {
00308 mod = ext;
00309 ext = NULL;
00310 }
00311 else {
00312 if ((mod = kb_lookup_device( mod_name )) == NULL) {
00313 kb_error( __FILE__ ,
00314 __LINE__ ,
00315 "knet_open" ,
00316 KB_ERROR_NODEVFOUNDSTR , mod_name );
00317 kb_free( name );
00318 return NULL;
00319 }
00320 }
00321
00322 kb_free(name);
00323 #endif
00324
00325 if ((mod = kb_lookup_device( device )) == NULL) {
00326 KB_ERROR( "knet_open" , KB_ERROR_NODEVFOUNDSTR , device );
00327 return NULL;
00328 }
00329
00330 sec = mod->section;
00331 bus = NULL;
00332
00333
00334 if((mod->kclass[ KB_DEVICE_CLASS_MODULE ].defined && preferred_bus == KNET_BUS_ANY) ||
00335 (sec->module_bus != KNET_BUS_ANY && preferred_bus == sec->module_bus ))
00336 {
00337 if(sec->module_bus == KNET_BUS_ANY) {
00338 KB_ERROR("knet_open",KB_ERROR_NOMODBUS);
00339 return NULL;
00340 }
00341
00342
00343 mod_adr = sec->module_bus_addr;
00344 if(mod_adr < 0) {
00345 KB_ERROR("knet_open",KB_ERROR_NOBUSADDR);
00346 return NULL;
00347 }
00348
00349 #ifdef KNET_BUS_SPI
00350 if(sec->module_bus == KNET_BUS_SPI)
00351 {
00352 bus = &knet_busses[ KNET_BUS_SPI ];
00353 ext_adr = mod->kclass[ KB_DEVICE_CLASS_MODULE].address;
00354 }
00355 #endif
00356
00357 #ifdef KNET_BUS_I2C
00358 if(sec->module_bus == KNET_BUS_I2C)
00359 {
00360 bus = &knet_busses[ KNET_BUS_I2C ];
00361 mod_adr = mod->kclass[ KB_DEVICE_CLASS_MODULE].address;
00362 }
00363 #endif
00364
00365 #ifdef KNET_BUS_RS232
00366 if(sec->module_bus == KNET_BUS_RS232)
00367 {
00368 bus = &knet_busses[ KNET_BUS_RS232 ];
00369 mod_adr = mod->kclass[ KB_DEVICE_CLASS_MODULE].address;
00370 }
00371 #endif
00372 }
00373 else
00374 {
00375
00376 #ifdef KNET_BUS_SPI
00377 if ( (( bus == NULL ) || ( preferred_bus == KNET_BUS_SPI ))
00378 && mod->kclass[ KB_DEVICE_CLASS_SPI ].defined ) {
00379 bus = &knet_busses[ KNET_BUS_SPI ];
00380 mod_adr = mod->kclass[ KB_DEVICE_CLASS_SPI ].address;
00381 ext_adr = 0;
00382 dev_name = NULL;
00383 }
00384 #endif
00385
00386 #ifdef KNET_BUS_I2C
00387 if ( (( bus == NULL ) || ( preferred_bus == KNET_BUS_I2C ))
00388 && mod->kclass[ KB_DEVICE_CLASS_I2C ].defined ) {
00389 bus = &knet_busses[ KNET_BUS_I2C ];
00390 mod_adr = mod->kclass[ KB_DEVICE_CLASS_I2C ].address;
00391 ext_adr = 0;
00392 dev_name = NULL;
00393 }
00394 #endif
00395
00396 #ifdef KNET_BUS_RS232
00397 if ( (( bus == NULL ) || ( preferred_bus == KNET_BUS_RS232 ))
00398 && mod->kclass[ KB_DEVICE_CLASS_RS232 ].defined ) {
00399 bus = &knet_busses[ KNET_BUS_RS232 ];
00400 mod_adr = mod->kclass[ KB_DEVICE_CLASS_RS232 ].address;
00401 ext_adr = 0;
00402 dev_name = mod->kclass[ KB_DEVICE_CLASS_RS232 ].device_name;
00403 }
00404 #endif
00405 }
00406
00407
00408 if ( (bus == NULL) || (bus->usage_counter==0) ) {
00409 kb_error( __FILE__ ,
00410 __LINE__ ,
00411 "knet_open" ,
00412 KB_ERROR_NOBUSFOUND , device );
00413 return NULL;
00414 }
00415
00416
00417 usleep(50000);
00418
00419 pthread_mutex_lock( &bus->lock );
00420 dev = bus->open( bus ,
00421 ext_adr , mod_adr , dev_name ,
00422 argc , argv );
00423 pthread_mutex_unlock ( &bus->lock );
00424
00425 usleep(50000);
00426 return dev;
00427 }
00428
00429
00437 void knet_close( knet_dev_t * dev )
00438 {
00439 knet_bus_t * bus = dev->bus;
00440
00441 pthread_mutex_lock( &bus->lock );
00442 if ( dev->usage_counter > 0 ) {
00443 if ( bus->close != NULL ) bus->close( bus , dev );
00444 dev->usage_counter--;
00445 }
00446 pthread_mutex_unlock( &bus->lock );
00447 }
00448
00449
00484 void knet_set_order( knet_dev_t * dev , unsigned long order )
00485 {
00486 knet_bus_t * bus = dev->bus;
00487
00488 pthread_mutex_lock( &bus->lock );
00489 dev->order = order;
00490 pthread_mutex_unlock( &bus->lock);
00491 }
00492
00493
00506 knet_dev_t * knet_device_create( knet_bus_t * bus ,
00507 knet_ext_t ext_addr ,
00508 knet_mod_t mod_addr ,
00509 const char * name )
00510 {
00511 knet_dev_t * dev = KB_ALLOC( knet_dev_t , 1 );
00512
00513
00514 dev->bus = bus;
00515 dev->order = 0;
00516 dev->next = NULL;
00517 dev->ext_addr = ext_addr;
00518 dev->mod_addr = mod_addr;
00519 dev->usage_counter = 0;
00520
00521
00522 dev->next = bus->devices;
00523 bus->devices = dev;
00524
00525
00526 return dev;
00527 }
00528
00529
00541 int knet_device_destroy( knet_dev_t * dev )
00542 {
00543 knet_bus_t * bus = dev->bus;
00544 knet_dev_t * prev = bus->devices;
00545 int ok;
00546
00547 if ( dev->usage_counter ) {
00548 return kb_error( __FILE__ ,
00549 __LINE__ ,
00550 "knet_device_destroy" ,
00551 KB_ERROR_DEVICEINUSE );
00552 }
00553
00554 pthread_mutex_lock( &bus->lock );
00555
00556 ok = 0;
00557
00558 if ( prev == dev ) {
00559 bus->devices = dev->next;
00560 dev->next = NULL;
00561 ok = 1;
00562 }
00563 else {
00564 while( prev != NULL ) {
00565 if ( prev->next == dev ) {
00566 prev->next = dev->next;
00567 dev->next = NULL;
00568 ok = 1;
00569 break;
00570 }
00571 prev = prev->next;
00572 }
00573 }
00574
00575 pthread_mutex_unlock( &bus->lock );
00576
00577 if ( !ok ) {
00578 return kb_error( __FILE__ ,
00579 __LINE__ ,
00580 "knet_device_destroy" ,
00581 KB_ERROR_UNLINKDEV );
00582 }
00583
00584 kb_free( dev );
00585 return 0;
00586 }
00587
00588
00606 int knet_lltransfer( knet_dev_t * dev ,
00607 const char * write_buf , unsigned int write_len ,
00608 char * read_buf , unsigned int read_len )
00609 {
00610 knet_bus_t * bus;
00611 int rc;
00612
00613 bus = dev->bus;
00614
00615 pthread_mutex_lock( &bus->lock );
00616
00617 if ( bus->transfer == NULL ) {
00618 rc = bus->write( bus , dev , write_buf , write_len );
00619 if ( rc >= 0 )
00620 rc = bus->read( bus , dev , read_buf , read_len );
00621 }
00622 else
00623 rc = bus->transfer( bus , dev , write_buf , write_len , read_buf , read_len );
00624
00625 pthread_mutex_unlock( &bus->lock );
00626
00627 return rc;
00628 }
00629
00630
00645 int knet_llread( knet_dev_t * dev ,
00646 char *buf ,
00647 unsigned int len )
00648 {
00649 knet_bus_t * bus;
00650 int rc;
00651
00652 bus = dev->bus;
00653
00654 pthread_mutex_lock(&bus->lock);
00655 rc = bus->read( bus , dev , buf , len );
00656 pthread_mutex_unlock(&bus->lock);
00657
00658 return rc;
00659 }
00660
00661
00676 int knet_llwrite( knet_dev_t * dev ,
00677 const char * buf ,
00678 unsigned int len )
00679 {
00680 knet_bus_t * bus;
00681 int rc;
00682
00683 bus = dev->bus;
00684
00685 pthread_mutex_lock(&bus->lock);
00686 rc = bus->write( bus , dev , buf , len );
00687 pthread_mutex_unlock(&bus->lock);
00688
00689 return rc;
00690 }
00691
00692
00710 int knet_convert( knet_dev_t * dev , char * buf , unsigned int len , int type )
00711 {
00712 unsigned int pos;
00713 unsigned char tmp;
00714
00715 if ( type != 1 && type != 2 && type != 4 )
00716 return -1;
00717
00718 if ( dev->order & KNET_ORDER_BIT_SWAP ) {
00719 for (pos=0; pos<len; pos++) {
00720 buf[pos] = bit_conv_tab[buf[pos]];
00721 }
00722 }
00723
00724 if ( type > 1 &&
00725 (dev->order & KNET_ORDER_BIG) ) {
00726
00727 if ((len%type)) return -1;
00728
00729 for (pos=0; pos<(len/type); pos++) {
00730 if ( type == 2 ) {
00731 tmp = buf[2*pos];
00732 buf[2*pos] = buf[2*pos+1];
00733 buf[2*pos+1] = tmp;
00734 }
00735 else {
00736 tmp = buf[4*pos];
00737 buf[4*pos] = buf[4*pos+3];
00738 buf[4*pos+3] = tmp;
00739 tmp = buf[4*pos+1];
00740 buf[4*pos+1] = buf[4*pos+2];
00741 buf[4*pos+2] = tmp;
00742 }
00743 }
00744 }
00745 return 0;
00746 }
00747
00748
00762 int knet_read8( knet_dev_t * dev ,
00763 knet_reg_t reg ,
00764 unsigned char * val )
00765 {
00766 int rc;
00767
00768 if ( dev->order & KNET_ORDER_BIT_SWAP )
00769 reg = bit_conv_tab[reg];
00770
00771 rc = knet_lltransfer( dev , ® , 1 , val , 1 );
00772
00773 if ( dev->order & KNET_ORDER_BIT_SWAP )
00774 (*val) = bit_conv_tab[(*val)];
00775
00776 return rc;
00777 }
00778
00779
00794 int knet_read16( knet_dev_t * dev ,
00795 knet_reg_t reg ,
00796 unsigned short * val )
00797 {
00798 int rc;
00799 unsigned char * p = (unsigned char *) val;
00800 unsigned char t , treg[2];
00801
00802
00803
00804 if ( dev->order & KNET_ORDER_BIT_SWAP ) {
00805 treg[0] = bit_conv_tab[reg];
00806 treg[1] = bit_conv_tab[reg+1];
00807 }
00808 else {
00809 treg[0] = reg;
00810 treg[1] = reg+1;
00811 }
00812
00813
00814 if ( dev->order & KNET_ORDER_REP_ADR ) {
00815 unsigned char * p = (unsigned char *)val;
00816
00817
00818 if ( dev->order & KNET_ORDER_MSB_FIRST ) {
00819
00820 if ((rc=knet_lltransfer( dev , &treg[1] , 1 , (char *)&p[1] , 1 )) < 0 )
00821 return rc;
00822
00823 if ((rc=knet_lltransfer( dev , &treg[0] , 1 , (char *)&p[0] , 1 )) < 0 )
00824 return rc;
00825 }
00826
00827 else {
00828
00829 if ((rc=knet_lltransfer( dev , &treg[0] , 1 , (char *)&p[0] , 1 )) < 0 )
00830 return rc;
00831
00832 if ((rc=knet_lltransfer( dev , &treg[1] , 1 , (char *)&p[1] , 1 )) < 0 )
00833 return rc;
00834 }
00835 }
00836 else {
00837 rc = knet_lltransfer( dev , &treg[0] , 1 , (char *)val , 2 );
00838 if ( rc < 0 )
00839 return rc;
00840 }
00841
00842
00843 if ( dev->order & KNET_ORDER_BIG ) {
00844 t = p[0];
00845 p[0] = p[1];
00846 p[1] = t;
00847 }
00848
00849 return rc;
00850 }
00851
00852
00863 int knet_read32( knet_dev_t * dev ,
00864 knet_reg_t reg ,
00865 unsigned long * val )
00866 {
00867 int rc;
00868 unsigned char * p = (unsigned char *) val;
00869 unsigned char t , treg[4];
00870
00871
00872 if ( dev->order & KNET_ORDER_BIT_SWAP ) {
00873 treg[0] = bit_conv_tab[reg];
00874 treg[1] = bit_conv_tab[reg+1];
00875 treg[2] = bit_conv_tab[reg+2];
00876 treg[3] = bit_conv_tab[reg+3];
00877 }
00878 else {
00879 treg[0] = reg;
00880 treg[1] = reg+1;
00881 treg[2] = reg+2;
00882 treg[3] = reg+3;
00883 }
00884
00885
00886 if ( dev->order & KNET_ORDER_REP_ADR ) {
00887 unsigned char * p = (unsigned char *)val;
00888
00889
00890 if ( dev->order & KNET_ORDER_MSB_FIRST ) {
00891
00892 if ((rc=knet_lltransfer( dev , &treg[3] , 1 , &p[3] , 1 )) < 0 )
00893 return rc;
00894
00895 if ((rc=knet_lltransfer( dev , &treg[2] , 1 , &p[2] , 1 )) < 0 )
00896 return rc;
00897
00898 if ((rc=knet_lltransfer( dev , &treg[1] , 1 , &p[1] , 1 )) < 0 )
00899 return rc;
00900
00901 if ((rc=knet_lltransfer( dev , &treg[0] , 1 , &p[0] , 1 )) < 0 )
00902 return rc;
00903
00904 }
00905
00906 else {
00907
00908 if ((rc=knet_lltransfer( dev , &treg[0] , 1 , &p[0] , 1 )) < 0 )
00909 return rc;
00910
00911 if ((rc=knet_lltransfer( dev , &treg[1] , 1 , &p[1] , 1 )) < 0 )
00912 return rc;
00913
00914 if ((rc=knet_lltransfer( dev , &treg[2] , 1 , &p[2] , 1 )) < 0 )
00915 return rc;
00916
00917 if ((rc=knet_lltransfer( dev , &treg[3] , 1 , &p[3] , 1 )) < 0 )
00918 return rc;
00919 }
00920 }
00921 else {
00922 rc = knet_lltransfer( dev , &treg[0] , 1 , (char *)val , 4 );
00923 if ( rc < 0 )
00924 return rc;
00925 }
00926
00927
00928 if ( dev->order & KNET_ORDER_BIG ) {
00929 t = p[0];
00930 p[0] = p[3];
00931 p[3] = t;
00932 t = p[1];
00933 p[1] = p[2];
00934 p[2] = t;
00935 }
00936 }
00937
00938
00950 int knet_readxBytes( knet_dev_t * dev ,
00951 knet_reg_t reg ,
00952 unsigned char * val, unsigned char rx_len )
00953 {
00954 int rc;
00955
00956
00957 if ( dev->order & KNET_ORDER_BIT_SWAP ) {
00958 reg = bit_conv_tab[reg];
00959 }
00960 rc = knet_lltransfer( dev , ® , 1 , val , rx_len );
00961 if(rc < 0)
00962 return rc;
00963
00964
00965
00966 }
00967
00968
00982 int knet_write8( knet_dev_t * dev ,
00983 knet_reg_t reg ,
00984 unsigned char val )
00985 {
00986 unsigned char buf[2];
00987
00988 if ( dev->order & KNET_ORDER_BIT_SWAP ) {
00989 buf[0] = bit_conv_tab[reg];
00990 buf[1] = bit_conv_tab[val];
00991 }
00992 else {
00993 buf[0] = reg;
00994 buf[1] = val;
00995 }
00996
00997 return knet_llwrite( dev , buf , 2 );
00998 }
00999
01000
01014 int knet_write16( knet_dev_t * dev ,
01015 knet_reg_t reg ,
01016 unsigned short val )
01017 {
01018 unsigned char buf[3];
01019 unsigned char *p = (unsigned char *)&val;
01020 unsigned char t , treg[2];
01021 int rc;
01022
01023 if ( dev->order & KNET_ORDER_BIT_SWAP ) {
01024 treg[0] = bit_conv_tab[reg];
01025 treg[1] = bit_conv_tab[reg+1];
01026 }
01027 else {
01028 treg[0] = reg;
01029 treg[1] = reg+1;
01030 }
01031
01032 if ( dev->order & KNET_ORDER_BIG ) {
01033 t = p[0];
01034 p[0] = p[1];
01035 p[1] = t;
01036 }
01037
01038 if ( dev->order & KNET_ORDER_REP_ADR ) {
01039
01040
01041 if ( dev->order & KNET_ORDER_MSB_FIRST ) {
01042
01043 buf[0] = treg[1];
01044 buf[1] = p[1];
01045
01046 if ((rc=knet_llwrite( dev , buf , 2 )) < 0 )
01047 return rc;
01048
01049 buf[0] = treg[0];
01050 buf[1] = p[0];
01051
01052 if ((rc=knet_llwrite( dev , buf , 2 )) < 0 )
01053 return rc;
01054
01055 }
01056 else {
01057
01058 buf[0] = treg[0];
01059 buf[1] = p[0];
01060
01061 if ((rc=knet_llwrite( dev , buf , 2 )) < 0 )
01062 return rc;
01063
01064 buf[0] = treg[1];
01065 buf[1] = p[1];
01066
01067 if ((rc=knet_llwrite( dev , buf , 2 )) < 0 )
01068 return rc;
01069
01070 }
01071 }
01072 else {
01073 rc=knet_llwrite( dev , buf , 3 );
01074 }
01075 return rc;
01076 }
01077
01078
01092 int knet_write32( knet_dev_t * dev ,
01093 knet_reg_t reg ,
01094 unsigned long val )
01095 {
01096 unsigned char buf[5];
01097 unsigned char *p = (unsigned char *)&val;
01098 unsigned char t , treg[4];
01099 int rc;
01100
01101 if ( dev->order & KNET_ORDER_BIT_SWAP ) {
01102 treg[0] = bit_conv_tab[reg];
01103 treg[1] = bit_conv_tab[reg+1];
01104 treg[2] = bit_conv_tab[reg+2];
01105 treg[3] = bit_conv_tab[reg+3];
01106 }
01107 else {
01108 treg[0] = reg;
01109 treg[1] = reg+1;
01110 treg[2] = reg+2;
01111 treg[3] = reg+3;
01112 }
01113
01114 if ( dev->order & KNET_ORDER_BIG ) {
01115 t = p[0];
01116 p[0] = p[3];
01117 p[3] = t;
01118 t = p[1];
01119 p[1] = p[2];
01120 p[2] = t;
01121 }
01122
01123 if ( dev->order & KNET_ORDER_REP_ADR ) {
01124
01125 if ( dev->order & KNET_ORDER_MSB_FIRST ) {
01126
01127 buf[0] = treg[3];
01128 buf[1] = p[3];
01129
01130 if ((rc=knet_llwrite( dev , buf , 2 )) < 0 )
01131 return rc;
01132
01133 buf[0] = treg[2];
01134 buf[1] = p[2];
01135
01136 if ((rc=knet_llwrite( dev , buf , 2 )) < 0 )
01137 return rc;
01138
01139 buf[0] = treg[1];
01140 buf[1] = p[1];
01141
01142 if ((rc=knet_llwrite( dev , buf , 2 )) < 0 )
01143 return rc;
01144
01145 buf[0] = treg[0];
01146 buf[1] = p[0];
01147
01148 if ((rc=knet_llwrite( dev , buf , 2 )) < 0 )
01149 return rc;
01150
01151 }
01152 else {
01153
01154 buf[0] = treg[0];
01155 buf[1] = p[0];
01156
01157 if ((rc=knet_llwrite( dev , buf , 2 )) < 0 )
01158 return rc;
01159
01160 buf[0] = treg[1];
01161 buf[1] = p[1];
01162
01163 if ((rc=knet_llwrite( dev , buf , 2 )) < 0 )
01164 return rc;
01165
01166 buf[0] = treg[2];
01167 buf[1] = p[2];
01168
01169 if ((rc=knet_llwrite( dev , buf , 2 )) < 0 )
01170 return rc;
01171 buf[0] = treg[3];
01172 buf[1] = p[3];
01173
01174 if ((rc=knet_llwrite( dev , buf , 2 )) < 0 )
01175 return rc;
01176 }
01177 }
01178 else {
01179 rc=knet_llwrite( dev , buf , 3 );
01180 }
01181 return rc;
01182 }
01183
01184
01197 int knet_read( knet_dev_t * dev , knet_reg_t reg )
01198 {
01199 unsigned char val;
01200 int rc;
01201
01202 if ((rc = knet_read8( dev , reg , &val )) < 0)
01203 return rc;
01204
01205 return val;
01206 }
01207
01208
01219 int knet_vprintf( knet_dev_t * dev ,
01220 const char * format ,
01221 va_list argptr )
01222 {
01223 int rc;
01224
01225 pthread_mutex_lock(&knet_buffer_lock);
01226 for (;;) {
01227 rc = vsnprintf( knet_buffer , knet_buffer_size , format , argptr );
01228
01229 if ( knet_buffer_size < rc ) {
01230
01231 while ( knet_buffer_size < rc ) {
01232 knet_buffer_size *= 2;
01233 }
01234 knet_buffer = kb_realloc( knet_buffer , knet_buffer_size );
01235 }
01236 else
01237 break;
01238 }
01239 pthread_mutex_unlock(&knet_buffer_lock);
01240
01241 return knet_llwrite( dev , knet_buffer , rc );
01242 }
01243
01244
01254 int knet_printf( knet_dev_t * dev , const char * format , ... )
01255 {
01256 va_list argptr;
01257 int rc;
01258
01259 pthread_mutex_lock(&knet_buffer_lock);
01260 va_start( argptr , format );
01261 for (;;) {
01262 rc = vsnprintf( knet_buffer , knet_buffer_size , format , argptr );
01263
01264 if ( knet_buffer_size < rc ) {
01265
01266 while ( knet_buffer_size < rc ) {
01267 knet_buffer_size *= 2;
01268 }
01269 knet_buffer = kb_realloc( knet_buffer , knet_buffer_size );
01270 }
01271 else
01272 break;
01273 }
01274 va_end( argptr );
01275 pthread_mutex_unlock(&knet_buffer_lock);
01276
01277 return knet_llwrite( dev , knet_buffer , rc );
01278 }
01279
01280
01286 int knet_read_string( knet_dev_t * dev ,
01287 char * buffer ,
01288 unsigned int size ,
01289 unsigned char terminator )
01290 {
01291 unsigned int pos=0;
01292 unsigned char ch;
01293 int rc;
01294
01295 for (;;) {
01296 if ((rc = knet_llread( dev , &ch , 1 )) < 0 )
01297 return rc;
01298 if ( rc > 0 ) {
01299 buffer[pos++] = ch;
01300 buffer[pos] = '\0';
01301
01302 if ( pos == size || ch == terminator )
01303 return pos;
01304 }
01305 }
01306 }