arch/mcs51/generic/libs/ulan/ul_l_c2a.c

   1 /*******************************************************************
   2   uLan Communication - version for generic MCS51 core based MCU
   3
   4   ul_l_c2a.c      - C language bindings to low level assembly
   5                     implementation
   6
   7   Copyright holders and originators:
   8       (C) 2002-2003 by Pavel Pisa pisa@cmp.felk.cvut.cz
   9       (C) 2002-2003 by PiKRON Ltd. http://www.pikron.com
  10
  11   The more uLan related information can be foud at next sites
  12             http://cmp.felk.cvut.cz/~pisa/ulan/
  13             http://www.pikron.com/en/chromul_over.html
  14
  15   The uLan for small embedded devices can be used, modified
  16   and redistributed if at least conditions of one of the
  17   following licenses are met
  18      - GPL - General Public License
  19      - LGPL - Lesser General Public License
  20      - MPL - Mozilla Public License
  21      - other license conditions assigned by originators
  22
  23   If significant code contributor disagrees with some of above
  24   licenses, he or she can delete such line/s, but if he deletes
  25   all lines, he is not allowed redistribute code in any binary
  26   or source form.
  27
  28  *******************************************************************/
  29
  30
  31 /*#define  UL_WITH_HANDLE*/
  32
  33 #include "ulan.h"
  34
  35 /*pragma LESS_PEDANTIC*/
  36
  37 #define SDCC_PTR_DATA 0x40
  38 #define SDCC_PTR_XDATA 0x00
  39 #define SDCC_PTR_CODE 0x80
  40
  41 #define KEIL_PTR_DATA 0x00
  42 #define KEIL_PTR_XDATA 0x01
  43 #define KEIL_PTR_CODE 0x02
  44
  45 #ifdef SDCC
  46 #ifndef SDCC_MODEL_LARGE
  47 data int ul_c2a_len;
  48 #endif /* SDCC_MODEL_LARGE */
  49 #endif /*SDCC*/
  50
  51 #ifndef UL_WITH_HANDLE
  52 ul_fd_t ul_fd;
  53 ul_msginfo xdata msginfo;
  54 #endif
  55
  56 ul_fd_t ul_open(const char *dev_name, const char *options)
  57 {
  58   return 1;
  59 }
  60
  61 int ul_close(ul_fd_t ul_fd)
  62 {
  63   return 0;
  64 }
  65
  66 #ifdef SDCC
  67 ul_ssize_t __ul_read_avail() UL_FNC_NAKED
  68 {
  69   _asm
  70         .globl ul_i_l
  71         clr  f0
  72         lcall ul_i_l
  73         mov  dpl,r4
  74         mov  dph,r5
  75     #ifdef UL_WITH_NAKED
  76         ret
  77     #endif /*UL_WITH_NAKED*/
  78   _endasm;
  79 }
  80 #else /* SDCC */
  81
  82 ul_ssize_t __ul_read_avail(void) UL_FNC_NAKED
  83 {
  84   #pragma asm
  85         extrn code(UL_I_L)
  86         clr  f0
  87         call UL_I_L
  88         mov  a,r4
  89         mov  r7,a
  90         mov  a,r5
  91         mov  r6,a
  92   #pragma endasm
  93 }
  94 #endif /* SDCC */
  95
  96
  97 #ifdef SDCC
  98 #ifndef SDCC_MODEL_LARGE
  99 /* ul_read function for small model */
 100 ul_ssize_t __ul_read(void *buffer, ul_size_t size) UL_FNC_NAKED
 101 {
 102   ul_c2a_len=size;
 103   _asm
 104         .globl ul_rd
 105         mov  r4,_ul_c2a_len
 106         mov  r5,_ul_c2a_len+1
 107         clr  f0
 108         jb    b.6,00001$ /*SDCC_PTR_DATA*/
 109         lcall ul_rd
 110         sjmp 00002$
 111 00001$: lcall ul_rdi
 112 00002$: jb   f0,00004$
 113         mov  dpl,_ul_c2a_len
 114         mov  dph,_ul_c2a_len+1
 115 00003$:
 116     #ifdef UL_WITH_NAKED
 117         ret
 118     #else /*UL_WITH_NAKED*/
 119         sjmp 00005$
 120     #endif /*UL_WITH_NAKED*/
 121 00004$:
 122         clr  c
 123         mov  a,_ul_c2a_len
 124         subb a,r4
 125         mov  dpl,a
 126         mov  a,_ul_c2a_len+1
 127         subb a,r5
 128         mov  dph,a
 129     #if 0
 130         orl  a,dpl
 131         jnz  00003$
 132         mov  dptr,#0xffff
 133     #endif
 134     #ifdef UL_WITH_NAKED
 135         ret
 136     #endif /*UL_WITH_NAKED*/
 137 00005$:
 138   _endasm;
 139 }
 140 #else /* SDCC_MODEL_LARGE */
 141 /* For large model
 142  * size   Allocated to stack - offset -4  (the push _bp taken into account)
 143  * buffer Allocated to registers
 144  */
 145 ul_ssize_t __ul_read(void *buffer, ul_size_t size) reentrant UL_FNC_NAKED
 146 {
 147   _asm
 148         .globl ul_rd
 149         mov  a,sp
 150         clr  f0
 151         mov  a,sp
 152     #ifdef UL_WITH_NAKED
 153         add  a,#-3
 154     #else /*UL_WITH_NAKED*/
 155         add  a,#-4
 156     #endif /*UL_WITH_NAKED*/
 157         mov  r0,a
 158         mov  a,@r0
 159         mov  r4,a
 160         mov  r6,a
 161         inc  r0
 162         mov  a,@r0
 163         mov  r5,a
 164         mov  r7,a
 165         jb    b.6,00001$  /*SDCC_PTR_DATA*/
 166         lcall ul_rd
 167         sjmp 00002$
 168 00001$: lcall ul_rdi
 169 00002$: jb   f0,00004$
 170         mov  dpl,r6
 171         mov  dph,r7
 172 00003$:
 173     #ifdef UL_WITH_NAKED
 174         ret
 175     #else /*UL_WITH_NAKED*/
 176         sjmp 00005$
 177     #endif /*UL_WITH_NAKED*/
 178 00004$:
 179         clr  c
 180         mov  a,r6
 181         subb a,r4
 182         mov  dpl,a
 183         mov  a,r7
 184         subb a,r5
 185         mov  dph,a
 186     #if 0
 187         orl  a,dpl
 188         jnz  00003$
 189         mov  dptr,#0xffff
 190     #endif
 191     #ifdef UL_WITH_NAKED
 192         ret
 193     #endif /*UL_WITH_NAKED*/
 194 00005$:
 195   _endasm;
 196 }
 197 #endif /* SDCC_MODEL_LARGE */
 198 #else /* SDCC */
 199
 200 #pragma asm
 201 ;ul_ssize_t __ul_read(void *buffer, ul_size_t size) UL_FNC_NAKED UL_FNC_REENTRANT
 202 ;{
 203         extrn code(UL_RD,UL_RDi)
 204         public ___ul_read
 205 ___ul_read:
 206         mov  dpl,r1     ; buffer address into DPTR
 207         mov  dph,r2
 208         mov  a,r4       ; number of bytes to write
 209         mov  r6,a
 210         xch  a,r5       ; into R45 little endian
 211         mov  r4,a
 212         mov  r7,a
 213         clr  f0
 214         mov  a,R3
 215 /*      cjne A,#KEIL_PTR_XDATA,__ul_read_l1 */
 216         cjne A,#01h,__ul_read_l1
 217         call UL_RD      ; call read => R45 number of remaining
 218         sjmp __ul_read_l2 ; bytes, DPTR moved after read data
 219 __ul_read_l1:
 220         call UL_RDi
 221 __ul_read_l2:
 222         jnb  f0,__ul_read_l3
 223         clr  c
 224         mov  a,r7
 225         subb a,r4
 226         mov  r7,a
 227         mov  a,r6       ; compute number of read bytes => R76
 228         subb a,r5
 229         mov  r6,a
 230     #if 0
 231         orl  a,r7
 232         jnz  __ul_read_l3
 233         dec  r6         ; return -1 if no byte read
 234         dec  r7
 235     #endif
 236 __ul_read_l3:
 237         ret
 238 ;}
 239 #pragma endasm
 240 #endif /* SDCC */
 241
 242 #ifdef SDCC
 243 #ifndef SDCC_MODEL_LARGE
 244 /* ul_write function for small model */
 245 ul_ssize_t __ul_write(const void *buffer, ul_size_t size) UL_FNC_NAKED
 246 {
 247   ul_c2a_len=size;
 248   _asm
 249         .globl ul_wr
 250         .globl ul_wrc
 251         .globl ul_wri
 252         mov  r4,_ul_c2a_len
 253         mov  r5,_ul_c2a_len+1
 254         clr  f0
 255         jnb   b.6,00001$  /*SDCC_PTR_DATA*/
 256         lcall ul_wri
 257         sjmp 00003$
 258 00001$:
 259         jnb   b.7,00002$  /*SDCC_PTR_CODE*/
 260         lcall ul_wrc
 261         sjmp 00003$
 262 00002$:
 263         lcall ul_wr
 264 00003$:
 265         jb   f0,00004$
 266         mov  dpl,_ul_c2a_len
 267         mov  dph,_ul_c2a_len+1
 268     #ifdef UL_WITH_NAKED
 269         ret
 270     #else /*UL_WITH_NAKED*/
 271         sjmp 00005$
 272     #endif /*UL_WITH_NAKED*/
 273 00004$:
 274         mov  dptr,#0xffff
 275     #ifdef UL_WITH_NAKED
 276         ret
 277     #endif /*UL_WITH_NAKED*/
 278 00005$:
 279   _endasm;
 280 }
 281 #else /* SDCC_MODEL_LARGE */
 282 /* For large model
 283  * size   Allocated to stack - offset -4 (the push _bp taken into account)
 284  * buffer Allocated to registers
 285  */
 286 ul_ssize_t __ul_write(const void *buffer, ul_size_t size) reentrant UL_FNC_NAKED
 287 {
 288   _asm
 289         .globl ul_wr
 290         .globl ul_wrc
 291         .globl ul_wri
 292         mov  a,sp
 293         clr  f0
 294         mov  a,sp
 295     #ifdef UL_WITH_NAKED
 296         add  a,#-3
 297     #else /*UL_WITH_NAKED*/
 298         add  a,#-4
 299     #endif /*UL_WITH_NAKED*/
 300         mov  r0,a
 301         mov  a,@r0
 302         mov  r4,a
 303         mov  r6,a
 304         inc  r0
 305         mov  a,@r0
 306         mov  r5,a
 307         mov  r7,a
 308         jnb   b.6,00001$  /*SDCC_PTR_DATA*/
 309         lcall ul_wri
 310         sjmp 00003$
 311 00001$:
 312         jnb   b.7,00002$  /*SDCC_PTR_CODE*/
 313         lcall ul_wrc
 314         sjmp 00003$
 315 00002$:
 316         lcall ul_wr
 317 00003$:
 318         jb   f0,00004$
 319         mov  dpl,r6
 320         mov  dph,r7
 321     #ifdef UL_WITH_NAKED
 322         ret
 323     #else /*UL_WITH_NAKED*/
 324         sjmp 00005$
 325     #endif /*UL_WITH_NAKED*/
 326 00004$:
 327         mov  dptr,#0xffff
 328     #ifdef UL_WITH_NAKED
 329         ret
 330     #endif /*UL_WITH_NAKED*/
 331 00005$:
 332   _endasm;
 333 }
 334 #endif /* SDCC_MODEL_LARGE */
 335 #else /* SDCC */
 336
 337 #pragma asm
 338 ;ul_ssize_t __ul_write(const void *buffer, ul_size_t size) UL_FNC_NAKED UL_FNC_REENTRANT
 339 ;{
 340         extrn code(UL_WR,UL_WRC,UL_WRI)
 341         public ___ul_write
 342 ___ul_write:
 343         mov  dpl,r1     ; buffer address into DPTR
 344         mov  dph,r2
 345         mov  a,r4       ; number of bytes to write
 346         mov  r6,a
 347         xch  a,r5       ; into R45 little endian
 348         mov  r4,a
 349         mov  r7,a
 350         clr  f0         ; call read => R45 number of remaining
 351         mov  a,R3
 352 /*      cjne A,#KEIL_PTR_XDATA,__ul_write_l3 */
 353         cjne A,#01h,__ul_write_l3
 354         call UL_WR      ; bytes, DPTR moved after read data
 355         sjmp __ul_write_l2
 356 __ul_write_l3:
 357 /*      cjne A,#KEIL_PTR_CODE,__ul_write_l4 */
 358         cjne A,#02h,__ul_write_l4
 359         call UL_WRC
 360         sjmp __ul_write_l2
 361 __ul_write_l4:
 362 /*      cjne A,#KEIL_PTR_DATA,__ul_write_l2 */
 363         cjne A,#00h,__ul_write_l2
 364         call UL_WRI
 365 __ul_write_l2:
 366         jnb  f0,__ul_write_l1
 367         mov  r6,#0ffh   ; return -1 if there was problem
 368         mov  r7,#0ffh
 369 __ul_write_l1:
 370         ret
 371 ;}
 372 #pragma endasm
 373 #endif /* SDCC */
 374
 375
 376 #ifdef SDCC
 377 int     __ul_newmsg(const ul_msginfo UL_ARGPTRTYPE  *msginfo) UL_FNC_NAKED
 378 {
 379   /* Dadr R4, Com R5, Status R6, Stamp R7 */
 380   _asm
 381         .globl ul_o_op
 382         .globl ul_o_new
 383         movx a,@dptr    /* dadr */
 384         mov  r4,a
 385         inc  dptr       /* sadr */
 386         /*movx a,@dptr*/
 387         /*uL_ISAD*/
 388         inc  dptr
 389         movx a,@dptr    /* cmd */
 390         mov  r5,a
 391         inc  dptr
 392         movx a,@dptr    /* flg */
 393         mov  r6,a
 394         inc  dptr
 395         movx a,@dptr    /* stamp */
 396         mov  r7,a
 397         clr  f0
 398         lcall ul_o_new
 399         mov  dptr,#0xffff
 400         jb   f0,00020$
 401         inc  dptr
 402 00020$:
 403     #ifdef UL_WITH_NAKED
 404         ret
 405     #endif /*UL_WITH_NAKED*/
 406   _endasm;
 407 }
 408 #else /* SDCC */
 409 #pragma asm
 410 ;int    __ul_newmsg(const ul_msginfo UL_ARGPTRTYPE  *msginfo) UL_FNC_NAKED
 411 ;{
 412 ;  /* Dadr R4, Com R5, Status R6, Stamp R7 */
 413         extrn code(UL_O_OP)
 414         extrn code(UL_O_NEW)
 415         public ___ul_newmsg
 416 ___ul_newmsg:
 417         mov  dpl,r7
 418         mov  dph,r6
 419         movx a,@dptr    ; dadr
 420         mov  r4,a
 421         inc  dptr       ; sadr
 422         inc  dptr
 423         movx a,@dptr    ; cmd
 424         mov  r5,a
 425         inc  dptr
 426         movx a,@dptr    ; flg
 427         mov  r6,a
 428         inc  dptr
 429         movx a,@dptr    ; stamp
 430         mov  r7,a
 431         clr  f0
 432         call UL_O_NEW
 433         clr  a
 434         mov  r7,a
 435         mov  r6,a
 436         jnb  f0,__ul_newmsg_l1
 437         dec  r7
 438         dec  r6
 439 __ul_newmsg_l1:
 440         ret
 441 ;}
 442 #pragma endasm
 443 #endif /* SDCC */
 444
 445 #ifdef SDCC
 446 int     __ul_o_close() UL_FNC_NAKED
 447 {
 448   _asm
 449         .globl ul_o_cl
 450         clr  f0
 451         lcall ul_o_cl
 452         mov  dptr,#0xffff
 453         jb   f0,00020$
 454         inc  dptr
 455 00020$:
 456     #ifdef UL_WITH_NAKED
 457         ret
 458     #endif /*UL_WITH_NAKED*/
 459   _endasm;
 460 }
 461 #else /* SDCC */
 462 #pragma asm
 463 ;int    __ul_o_close(void) UL_FNC_NAKED
 464 ;{
 465         extrn code(UL_O_CL)
 466         public __ul_o_close
 467 __ul_o_close:
 468         clr  f0
 469         call UL_O_CL
 470         clr  a
 471         mov  r7,a
 472         mov  r6,a
 473         jnb  f0,__ul_o_close_l1
 474         dec  r7
 475         dec  r6
 476 __ul_o_close_l1:
 477         ret
 478 ;}
 479 #pragma endasm
 480 #endif /* SDCC */
 481
 482 #ifdef SDCC
 483 int     __ul_i_close() UL_FNC_NAKED
 484 {
 485   _asm
 486         .globl ul_i_cl
 487         clr  f0
 488         lcall ul_i_cl
 489         mov  dptr,#0xffff
 490         jb   f0,00020$
 491         inc  dptr
 492 00020$:
 493     #ifdef UL_WITH_NAKED
 494         ret
 495     #endif /*UL_WITH_NAKED*/
 496   _endasm;
 497 }
 498 #else /* SDCC */
 499 #pragma asm
 500 ;int    __ul_i_close(void) UL_FNC_NAKED
 501 ;{
 502         extrn code(UL_I_CL)
 503         public __ul_i_close
 504 __ul_i_close:
 505         clr  f0
 506         call UL_I_CL
 507         clr  a
 508         mov  r7,a
 509         mov  r6,a
 510         jnb  f0,___ul_i_close_l1
 511         dec  r7
 512         dec  r6
 513 ___ul_i_close_l1:
 514         ret
 515 ;}
 516 #pragma endasm
 517 #endif /* SDCC */
 518
 519 #ifdef SDCC
 520 int     __ul_tailmsg(const ul_msginfo UL_ARGPTRTYPE  *msginfo) UL_FNC_NAKED
 521 {
 522   /* Dadr R4, Com R5, Status R6, Stamp R7 */
 523   _asm
 524         .globl ul_o_op
 525         clr  f0
 526         lcall ul_o_cl   /* close previous output message */
 527         movx a,@dptr    /* dadr */
 528         mov  r4,a
 529         inc  dptr       /* sadr */
 530         /*movx a,@dptr*/
 531         /*uL_ISAD*/
 532         inc  dptr
 533         movx a,@dptr    /* cmd */
 534         mov  r5,a
 535         inc  dptr
 536         movx a,@dptr    /* flg */
 537         mov  r6,a
 538         inc  dptr
 539         movx a,@dptr    /* stamp */
 540         mov  r7,a
 541         lcall ul_o_op
 542         mov  dptr,#0xffff
 543         jb   f0,00020$
 544         inc  dptr
 545 00020$:
 546     #ifdef UL_WITH_NAKED
 547         ret
 548     #endif /*UL_WITH_NAKED*/
 549   _endasm;
 550 }
 551 #else /* SDCC */
 552 #pragma asm
 553 ;int    __ul_tailmsg(const ul_msginfo UL_ARGPTRTYPE  *msginfo) UL_FNC_NAKED
 554 ;{
 555         public ___ul_tailmsg
 556 ___ul_tailmsg:
 557         mov  dpl,r7
 558         mov  dph,r6
 559         call UL_O_CL    ; close previous output message
 560         movx a,@dptr    ; dadr
 561         mov  r4,a
 562         inc  dptr       ; sadr
 563         inc  dptr
 564         movx a,@dptr    ; cmd
 565         mov  r5,a
 566         inc  dptr
 567         movx a,@dptr    ; flg
 568         mov  r6,a
 569         inc  dptr
 570         movx a,@dptr    ; stamp
 571         mov  r7,a
 572         call UL_O_OP
 573         clr  a
 574         mov  r7,a
 575         mov  r6,a
 576         jnb  f0,___ul_tailmsg_l1
 577         dec  r7
 578         dec  r6
 579 ___ul_tailmsg_l1:
 580         ret
 581 ;}
 582 #pragma endasm
 583 #endif /* SDCC */
 584
 585 #ifdef SDCC
 586 int     __ul_freemsg() UL_FNC_NAKED
 587 {
 588   _asm
 589         .globl ul_o_op
 590         clr f0
 591         lcall ul_i_cl   /* close previous input message */
 592         clr f0
 593         lcall ul_o_cl   /* close previous output message */
 594         mov  dptr,#0xffff
 595         jb   f0,00020$
 596         inc  dptr
 597 00020$:
 598     #ifdef UL_WITH_NAKED
 599         ret
 600     #endif /*UL_WITH_NAKED*/
 601   _endasm;
 602 }
 603 #else /* SDCC */
 604 #pragma asm
 605 ;int    __ul_freemsg(void) UL_FNC_NAKED
 606 ;{
 607         public __ul_freemsg
 608 __ul_freemsg:
 609         clr  f0
 610         call UL_I_CL    ; close previous input message
 611         clr  f0
 612         call UL_O_CL    ; close previous output message
 613         clr  a
 614         mov  r7,a
 615         mov  r6,a
 616         jnb  f0,___ul_freemsg_l1
 617         dec  r7
 618         dec  r6
 619 ___ul_freemsg_l1:
 620         ret
 621 ;}
 622 #pragma endasm
 623 #endif /* SDCC */
 624
 625 #ifdef SDCC
 626 int __ul_acceptmsg(ul_msginfo UL_ARGPTRTYPE  *msginfo) UL_FNC_NAKED
 627 {
 628   /* Dadr R4, Com R5, Status R6, Stamp R7 */
 629   _asm
 630         .globl ul_i_op
 631         .globl ul_i_l
 632         clr  f0
 633         lcall ul_i_op
 634         jb   f0,00010$
 635         mov  a,r3
 636         movx @dptr,a    /* dadr */
 637         inc  dptr
 638         mov  a,r4
 639         movx @dptr,a    /* sadr */
 640         inc  dptr
 641         mov  a,r5
 642         movx @dptr,a    /* cmd */
 643         inc  dptr
 644         mov  a,r6
 645         movx @dptr,a    /* flg */
 646         inc  dptr
 647         mov  a,r7
 648         movx @dptr,a    /* stamp */
 649         inc  dptr
 650         lcall ul_i_l    /* read length of data */
 651         mov  a,r4
 652         movx @dptr,a    /* len */
 653         inc  dptr
 654         mov  a,r5
 655         movx @dptr,a
 656         mov  dptr,#0
 657     #ifdef UL_WITH_NAKED
 658         ret
 659     #else /*UL_WITH_NAKED*/
 660         sjmp 00030$
 661     #endif /*UL_WITH_NAKED*/
 662 00010$:
 663         mov  dptr,#0xffff
 664     #ifdef UL_WITH_NAKED
 665         ret
 666     #endif /*UL_WITH_NAKED*/
 667 00030$:
 668   _endasm;
 669 }
 670 #else /* SDCC */
 671 #pragma asm
 672 ;int __ul_acceptmsg(ul_msginfo UL_ARGPTRTYPE  *msginfo) UL_FNC_NAKED
 673 ;{
 674 ;  /* Dadr R4, Com R5, Status R6, Stamp R7 */
 675         extrn code(UL_I_OP)
 676         public ___ul_acceptmsg
 677 ___ul_acceptmsg:
 678         clr  f0
 679         mov  dpl,r7
 680         mov  dph,r6
 681         lcall UL_I_OP
 682         jb   f0,___ul_acceptmsg_l1
 683         mov  a,r3
 684         movx @dptr,a    ; dadr
 685         inc  dptr
 686         mov  a,r4
 687         movx @dptr,a    ; sadr
 688         inc  dptr
 689         mov  a,r5
 690         movx @dptr,a    ; cmd
 691         inc  dptr
 692         mov  a,r6
 693         movx @dptr,a    ; flg
 694         inc  dptr
 695         mov  a,r7
 696         movx @dptr,a    ; stamp
 697         inc  dptr
 698         lcall UL_I_L    ; read length of data
 699         mov  a,r5
 700         movx @dptr,a    ; len is bigendian
 701         inc  dptr
 702         mov  a,r4
 703         movx @dptr,a
 704         clr  a
 705         mov  r7,a
 706         mov  r6,a
 707         ret
 708 ___ul_acceptmsg_l1:
 709         mov  r7,#0ffh
 710         mov  r6,#0ffh
 711         ret
 712 ;}
 713 #pragma endasm
 714 #endif /* SDCC */
 715
 716 int __ul_actailmsg(ul_msginfo UL_ARGPTRTYPE  *msginfo) UL_FNC_NAKED
 717 {
 718   return -1;
 719 }
 720
 721 int __ul_addfilt(const ul_msginfo UL_ARGPTRTYPE  *msginfo)
 722 {
 723   return -1;
 724 }
 725
 726 #ifdef SDCC
 727 int __ul_abortmsg()
 728 {
 729   _asm
 730         .globl ul_o_abrt
 731         lcall ul_i_cl
 732         lcall ul_o_abrt
 733   _endasm;
 734   return 0;
 735 }
 736 #else /* SDCC */
 737 #pragma asm
 738 ;int __ul_abortmsg(void)
 739 ;{
 740         public ___ul_abortmsg
 741 ___ul_abortmsg:
 742         extrn code(UL_O_ABRT)
 743         call UL_I_CL
 744         call UL_O_ABRT
 745         ret
 746 ;}
 747 #pragma endasm
 748 #endif /* SDCC */
 749
 750 #ifdef SDCC
 751 uchar __ul_inepoll() UL_FNC_NAKED
 752 {
 753   _asm
 754         .globl ul_i_ne
 755         lcall ul_i_ne
 756         mov  dptr,#0
 757         jnc  00050$
 758         inc  dptr
 759 00050$:
 760     #ifdef UL_WITH_NAKED
 761         ret
 762     #endif /*UL_WITH_NAKED*/
 763   _endasm;
 764 }
 765 #else /*SDCC*/
 766 #pragma asm
 767 ;uchar __ul_inepoll(void) UL_FNC_NAKED
 768 ;{
 769         extrn code(UL_I_NE)
 770         public __ul_inepoll
 771 __ul_inepoll:
 772         call UL_I_NE
 773         mov  r7,#0
 774         jnc  ___ul_inepoll_l1
 775         inc  r7
 776 ___ul_inepoll_l1:
 777         ret
 778 ;}
 779 #pragma endasm
 780 #endif /*SDCC*/
 781
 782 #ifdef SDCC
 783 char ul_drv_init()
 784 {
 785   _asm
 786         .globl ul_init
 787         mov  r0,#0
 788         mov  r2,#0
 789         lcall ul_fnc    /* Init */
 790   _endasm;
 791   return 0;
 792 }
 793 #else /*SDCC*/
 794 #pragma asm
 795 ;char ul_drv_init()
 796 ;{
 797         extrn code(UL_INIT)
 798         public ul_drv_init
 799 ul_drv_init:
 800         mov  r0,#0
 801         mov  r2,#0
 802         jmp  UL_FNC     ; Init
 803 ;  return 0;
 804 ;}
 805 #pragma endasm
 806 #endif
 807
 808 #ifdef SDCC
 809 char ul_drv_set_adr(uchar addr)
 810 {
 811   _asm
 812         .globl ul_fnc
 813         mov  r0,#2
 814         mov  a,dpl
 815         lcall ul_fnc    /* Address */
 816   _endasm;
 817   return 0;
 818 }
 819 #else /*SDCC*/
 820 #pragma asm
 821 ;char ul_drv_set_adr(uchar addr)
 822 ;{
 823         extrn code(UL_FNC)
 824         public _ul_drv_set_adr
 825 _ul_drv_set_adr:
 826         mov  r0,#2
 827         mov  a,r7
 828         jmp  UL_FNC     ; Address
 829 ;  return 0;
 830 ;}
 831 #pragma endasm
 832 #endif
 833
 834 #ifdef SDCC
 835 char ul_drv_set_bdiv(uchar addr)
 836 {
 837   _asm
 838         .globl ul_fnc
 839         mov  r0,#1      /* 2 => 19200 Bd for 11059 kHz */
 840         mov  a,dpl      /* 5 => 19200 Bd for 18432 kHz */
 841         lcall ul_fnc    /* Baudrate */
 842   _endasm;
 843   return 0;
 844 }
 845 #else /*SDCC*/
 846 #pragma asm
 847 ;char ul_drv_set_bdiv(uchar addr)
 848 ;{
 849         public _ul_drv_set_bdiv
 850 _ul_drv_set_bdiv:
 851         mov  r0,#1      ; 2 => 19200 Bd for 11059 kHz
 852         mov  a,r7       ; 5 => 19200 Bd for 18432 kHz
 853         jmp  UL_FNC     ; Baudrate
 854 ;  return 0;
 855 ;}
 856 #pragma endasm
 857 #endif
 858
 859 #ifndef  UL_WITHOUT_HANDLE
 860
 861 ul_ssize_t ul_read(ul_fd_t ul_fd,void *buffer, ul_size_t size)
 862 {
 863   return __ul_read(buffer, size);
 864 }
 865
 866 ul_ssize_t ul_write(ul_fd_t ul_fd,const void *buffer, ul_size_t size)
 867 {
 868   return __ul_write(buffer, size);
 869 }
 870
 871 int ul_newmsg(ul_fd_t ul_fd,const ul_msginfo UL_ARGPTRTYPE  *msginfo)
 872 {
 873   return __ul_newmsg(msginfo);
 874 }
 875
 876 int ul_tailmsg(ul_fd_t ul_fd,const ul_msginfo UL_ARGPTRTYPE  *msginfo)
 877 {
 878   return __ul_tailmsg(msginfo);
 879 }
 880
 881 int ul_freemsg(ul_fd_t ul_fd)
 882 {
 883   return __ul_freemsg();
 884 }
 885
 886 int ul_acceptmsg(ul_fd_t ul_fd,ul_msginfo UL_ARGPTRTYPE  *msginfo)
 887 {
 888   return __ul_acceptmsg(msginfo);
 889 }
 890
 891 int ul_actailmsg(ul_fd_t ul_fd,ul_msginfo UL_ARGPTRTYPE  *msginfo)
 892 {
 893   return __ul_actailmsg(msginfo);
 894 }
 895
 896 int ul_addfilt(ul_fd_t ul_fd,const ul_msginfo UL_ARGPTRTYPE  *msginfo)
 897 {
 898   return __ul_addfilt(msginfo);
 899 }
 900
 901 int ul_abortmsg(ul_fd_t ul_fd)
 902 {
 903   return __ul_abortmsg();
 904 }
 905
 906 uchar ul_inepoll(ul_fd_t ul_fd)
 907 {
 908   return __ul_inepoll();
 909 }
 910 #endif /*UL_WITHOUT_HANDLE*/
 911
 912 int ul_drv_debflg(ul_fd_t ul_fd,int debug_msk)
 913 {
 914   return 0;
 915 }
 916
 917 int ul_fd_wait(ul_fd_t ul_fd, int wait_sec)
 918 {
 919   return 0;
 920 }
 921
 922 int uloi_con_ulan_set_cmd_fd(uloi_coninfo_t *coninfo, int cmd,
 923                              ul_fd_t rdfd, ul_fd_t wrfd)
 924 {
 925   uloi_con_ulan_t *con_ulan = UL_CONTAINEROF(coninfo, uloi_con_ulan_t, con);
 926   if(!cmd)
 927     cmd=UL_CMD_OISV;
 928   con_ulan->cmd=cmd;
 929   con_ulan->sn=0;
 930   con_ulan->bsn=0;
 931   con_ulan->rdfd=rdfd;
 932   con_ulan->wrfd=wrfd;
 933   return 0;
 934 }
 935
 936
 937 #if 0
 938 int test_fnc(int i)
 939 {
 940   _asm
 941         mov  a,#0xaa
 942         mov  b,#0xbb
 943         mov  r0,#0xc0
 944         mov  r1,#0xc1
 945         mov  r2,#0xc2
 946         mov  r3,#0xc3
 947         mov  r4,#0xc4
 948         mov  r5,#0xc5
 949         mov  r6,#0xc6
 950         mov  r7,#0xc7
 951         mov  dptr,#1
 952     #ifdef UL_WITH_NAKED
 953         ret
 954     #endif /*UL_WITH_NAKED*/
 955   _endasm;
 956 }
 957 #endif