1 /* 2 *========================================================================== 3 * 4 * xyzModem.c 5 * 6 * RedBoot stream handler for xyzModem protocol 7 * 8 *========================================================================== 9 *####ECOSGPLCOPYRIGHTBEGIN#### 10 * ------------------------------------------- 11 * This file is part of eCos, the Embedded Configurable Operating System. 12 * Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. 13 * Copyright (C) 2002 Gary Thomas 14 * 15 * eCos is free software; you can redistribute it and/or modify it under 16 * the terms of the GNU General Public License as published by the Free 17 * Software Foundation; either version 2 or (at your option) any later version. 18 * 19 * eCos is distributed in the hope that it will be useful, but WITHOUT ANY 20 * WARRANTY; without even the implied warranty of MERCHANTABILITY or 21 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 22 * for more details. 23 * 24 * You should have received a copy of the GNU General Public License along 25 * with eCos; if not, write to the Free Software Foundation, Inc., 26 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. 27 * 28 * As a special exception, if other files instantiate templates or use macros 29 * or inline functions from this file, or you compile this file and link it 30 * with other works to produce a work based on this file, this file does not 31 * by itself cause the resulting work to be covered by the GNU General Public 32 * License. However the source code for this file must still be made available 33 * in accordance with section (3) of the GNU General Public License. 34 * 35 * This exception does not invalidate any other reasons why a work based on 36 * this file might be covered by the GNU General Public License. 37 * 38 * Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. 39 * at http: *sources.redhat.com/ecos/ecos-license/ 40 * ------------------------------------------- 41 *####ECOSGPLCOPYRIGHTEND#### 42 *========================================================================== 43 *#####DESCRIPTIONBEGIN#### 44 * 45 * Author(s): gthomas 46 * Contributors: gthomas, tsmith, Yoshinori Sato 47 * Date: 2000-07-14 48 * Purpose: 49 * Description: 50 * 51 * This code is part of RedBoot (tm). 52 * 53 *####DESCRIPTIONEND#### 54 * 55 *========================================================================== 56 */ 57 #include <common.h> 58 #include <xyzModem.h> 59 #include <stdarg.h> 60 #include <crc.h> 61 62 /* Assumption - run xyzModem protocol over the console port */ 63 64 /* Values magic to the protocol */ 65 #define SOH 0x01 66 #define STX 0x02 67 #define EOT 0x04 68 #define ACK 0x06 69 #define BSP 0x08 70 #define NAK 0x15 71 #define CAN 0x18 72 #define EOF 0x1A /* ^Z for DOS officionados */ 73 74 #define USE_YMODEM_LENGTH 75 76 /* Data & state local to the protocol */ 77 static struct 78 { 79 #ifdef REDBOOT 80 hal_virtual_comm_table_t *__chan; 81 #else 82 int *__chan; 83 #endif 84 unsigned char pkt[1024], *bufp; 85 unsigned char blk, cblk, crc1, crc2; 86 unsigned char next_blk; /* Expected block */ 87 int len, mode, total_retries; 88 int total_SOH, total_STX, total_CAN; 89 bool crc_mode, at_eof, tx_ack; 90 #ifdef USE_YMODEM_LENGTH 91 unsigned long file_length, read_length; 92 #endif 93 } xyz; 94 95 #define xyzModem_CHAR_TIMEOUT 2000 /* 2 seconds */ 96 #define xyzModem_MAX_RETRIES 20 97 #define xyzModem_MAX_RETRIES_WITH_CRC 10 98 #define xyzModem_CAN_COUNT 3 /* Wait for 3 CAN before quitting */ 99 100 101 #ifndef REDBOOT /*SB */ 102 typedef int cyg_int32; 103 int 104 CYGACC_COMM_IF_GETC_TIMEOUT (char chan, char *c) 105 { 106 #define DELAY 20 107 unsigned long counter = 0; 108 while (!tstc () && (counter < xyzModem_CHAR_TIMEOUT * 1000 / DELAY)) 109 { 110 udelay (DELAY); 111 counter++; 112 } 113 if (tstc ()) 114 { 115 *c = getc (); 116 return 1; 117 } 118 return 0; 119 } 120 121 void 122 CYGACC_COMM_IF_PUTC (char x, char y) 123 { 124 putc (y); 125 } 126 127 /* Validate a hex character */ 128 __inline__ static bool 129 _is_hex (char c) 130 { 131 return (((c >= '0') && (c <= '9')) || 132 ((c >= 'A') && (c <= 'F')) || ((c >= 'a') && (c <= 'f'))); 133 } 134 135 /* Convert a single hex nibble */ 136 __inline__ static int 137 _from_hex (char c) 138 { 139 int ret = 0; 140 141 if ((c >= '0') && (c <= '9')) 142 { 143 ret = (c - '0'); 144 } 145 else if ((c >= 'a') && (c <= 'f')) 146 { 147 ret = (c - 'a' + 0x0a); 148 } 149 else if ((c >= 'A') && (c <= 'F')) 150 { 151 ret = (c - 'A' + 0x0A); 152 } 153 return ret; 154 } 155 156 /* Convert a character to lower case */ 157 __inline__ static char 158 _tolower (char c) 159 { 160 if ((c >= 'A') && (c <= 'Z')) 161 { 162 c = (c - 'A') + 'a'; 163 } 164 return c; 165 } 166 167 /* Parse (scan) a number */ 168 bool 169 parse_num (char *s, unsigned long *val, char **es, char *delim) 170 { 171 bool first = true; 172 int radix = 10; 173 char c; 174 unsigned long result = 0; 175 int digit; 176 177 while (*s == ' ') 178 s++; 179 while (*s) 180 { 181 if (first && (s[0] == '0') && (_tolower (s[1]) == 'x')) 182 { 183 radix = 16; 184 s += 2; 185 } 186 first = false; 187 c = *s++; 188 if (_is_hex (c) && ((digit = _from_hex (c)) < radix)) 189 { 190 /* Valid digit */ 191 #ifdef CYGPKG_HAL_MIPS 192 /* FIXME: tx49 compiler generates 0x2539018 for MUL which */ 193 /* isn't any good. */ 194 if (16 == radix) 195 result = result << 4; 196 else 197 result = 10 * result; 198 result += digit; 199 #else 200 result = (result * radix) + digit; 201 #endif 202 } 203 else 204 { 205 if (delim != (char *) 0) 206 { 207 /* See if this character is one of the delimiters */ 208 char *dp = delim; 209 while (*dp && (c != *dp)) 210 dp++; 211 if (*dp) 212 break; /* Found a good delimiter */ 213 } 214 return false; /* Malformatted number */ 215 } 216 } 217 *val = result; 218 if (es != (char **) 0) 219 { 220 *es = s; 221 } 222 return true; 223 } 224 225 #endif 226 227 #define USE_SPRINTF 228 #ifdef DEBUG 229 #ifndef USE_SPRINTF 230 /* 231 * Note: this debug setup only works if the target platform has two serial ports 232 * available so that the other one (currently only port 1) can be used for debug 233 * messages. 234 */ 235 static int 236 zm_dprintf (char *fmt, ...) 237 { 238 int cur_console; 239 va_list args; 240 241 va_start (args, fmt); 242 #ifdef REDBOOT 243 cur_console = 244 CYGACC_CALL_IF_SET_CONSOLE_COMM 245 (CYGNUM_CALL_IF_SET_COMM_ID_QUERY_CURRENT); 246 CYGACC_CALL_IF_SET_CONSOLE_COMM (1); 247 #endif 248 diag_vprintf (fmt, args); 249 #ifdef REDBOOT 250 CYGACC_CALL_IF_SET_CONSOLE_COMM (cur_console); 251 #endif 252 } 253 254 static void 255 zm_flush (void) 256 { 257 } 258 259 #else 260 /* 261 * Note: this debug setup works by storing the strings in a fixed buffer 262 */ 263 #define FINAL 264 #ifdef FINAL 265 static char *zm_out = (char *) 0x00380000; 266 static char *zm_out_start = (char *) 0x00380000; 267 #else 268 static char zm_buf[8192]; 269 static char *zm_out = zm_buf; 270 static char *zm_out_start = zm_buf; 271 272 #endif 273 static int 274 zm_dprintf (char *fmt, ...) 275 { 276 int len; 277 va_list args; 278 279 va_start (args, fmt); 280 len = diag_vsprintf (zm_out, fmt, args); 281 zm_out += len; 282 return len; 283 } 284 285 static void 286 zm_flush (void) 287 { 288 #ifdef REDBOOT 289 char *p = zm_out_start; 290 while (*p) 291 mon_write_char (*p++); 292 #endif 293 zm_out = zm_out_start; 294 } 295 #endif 296 297 static void 298 zm_dump_buf (void *buf, int len) 299 { 300 #ifdef REDBOOT 301 diag_vdump_buf_with_offset (zm_dprintf, buf, len, 0); 302 #else 303 304 #endif 305 } 306 307 static unsigned char zm_buf[2048]; 308 static unsigned char *zm_bp; 309 310 static void 311 zm_new (void) 312 { 313 zm_bp = zm_buf; 314 } 315 316 static void 317 zm_save (unsigned char c) 318 { 319 *zm_bp++ = c; 320 } 321 322 static void 323 zm_dump (int line) 324 { 325 zm_dprintf ("Packet at line: %d\n", line); 326 zm_dump_buf (zm_buf, zm_bp - zm_buf); 327 } 328 329 #define ZM_DEBUG(x) x 330 #else 331 #define ZM_DEBUG(x) 332 #endif 333 334 /* Wait for the line to go idle */ 335 static void 336 xyzModem_flush (void) 337 { 338 int res; 339 char c; 340 while (true) 341 { 342 res = CYGACC_COMM_IF_GETC_TIMEOUT (*xyz.__chan, &c); 343 if (!res) 344 return; 345 } 346 } 347 348 static int 349 xyzModem_get_hdr (void) 350 { 351 char c; 352 int res; 353 bool hdr_found = false; 354 int i, can_total, hdr_chars; 355 unsigned short cksum; 356 357 ZM_DEBUG (zm_new ()); 358 /* Find the start of a header */ 359 can_total = 0; 360 hdr_chars = 0; 361 362 if (xyz.tx_ack) 363 { 364 CYGACC_COMM_IF_PUTC (*xyz.__chan, ACK); 365 xyz.tx_ack = false; 366 } 367 while (!hdr_found) 368 { 369 res = CYGACC_COMM_IF_GETC_TIMEOUT (*xyz.__chan, &c); 370 ZM_DEBUG (zm_save (c)); 371 if (res) 372 { 373 hdr_chars++; 374 switch (c) 375 { 376 case SOH: 377 xyz.total_SOH++; 378 case STX: 379 if (c == STX) 380 xyz.total_STX++; 381 hdr_found = true; 382 break; 383 case CAN: 384 xyz.total_CAN++; 385 ZM_DEBUG (zm_dump (__LINE__)); 386 if (++can_total == xyzModem_CAN_COUNT) 387 { 388 return xyzModem_cancel; 389 } 390 else 391 { 392 /* Wait for multiple CAN to avoid early quits */ 393 break; 394 } 395 case EOT: 396 /* EOT only supported if no noise */ 397 if (hdr_chars == 1) 398 { 399 CYGACC_COMM_IF_PUTC (*xyz.__chan, ACK); 400 ZM_DEBUG (zm_dprintf ("ACK on EOT #%d\n", __LINE__)); 401 ZM_DEBUG (zm_dump (__LINE__)); 402 return xyzModem_eof; 403 } 404 default: 405 /* Ignore, waiting for start of header */ 406 ; 407 } 408 } 409 else 410 { 411 /* Data stream timed out */ 412 xyzModem_flush (); /* Toss any current input */ 413 ZM_DEBUG (zm_dump (__LINE__)); 414 CYGACC_CALL_IF_DELAY_US ((cyg_int32) 250000); 415 return xyzModem_timeout; 416 } 417 } 418 419 /* Header found, now read the data */ 420 res = CYGACC_COMM_IF_GETC_TIMEOUT (*xyz.__chan, (char *) &xyz.blk); 421 ZM_DEBUG (zm_save (xyz.blk)); 422 if (!res) 423 { 424 ZM_DEBUG (zm_dump (__LINE__)); 425 return xyzModem_timeout; 426 } 427 res = CYGACC_COMM_IF_GETC_TIMEOUT (*xyz.__chan, (char *) &xyz.cblk); 428 ZM_DEBUG (zm_save (xyz.cblk)); 429 if (!res) 430 { 431 ZM_DEBUG (zm_dump (__LINE__)); 432 return xyzModem_timeout; 433 } 434 xyz.len = (c == SOH) ? 128 : 1024; 435 xyz.bufp = xyz.pkt; 436 for (i = 0; i < xyz.len; i++) 437 { 438 res = CYGACC_COMM_IF_GETC_TIMEOUT (*xyz.__chan, &c); 439 ZM_DEBUG (zm_save (c)); 440 if (res) 441 { 442 xyz.pkt[i] = c; 443 } 444 else 445 { 446 ZM_DEBUG (zm_dump (__LINE__)); 447 return xyzModem_timeout; 448 } 449 } 450 res = CYGACC_COMM_IF_GETC_TIMEOUT (*xyz.__chan, (char *) &xyz.crc1); 451 ZM_DEBUG (zm_save (xyz.crc1)); 452 if (!res) 453 { 454 ZM_DEBUG (zm_dump (__LINE__)); 455 return xyzModem_timeout; 456 } 457 if (xyz.crc_mode) 458 { 459 res = CYGACC_COMM_IF_GETC_TIMEOUT (*xyz.__chan, (char *) &xyz.crc2); 460 ZM_DEBUG (zm_save (xyz.crc2)); 461 if (!res) 462 { 463 ZM_DEBUG (zm_dump (__LINE__)); 464 return xyzModem_timeout; 465 } 466 } 467 ZM_DEBUG (zm_dump (__LINE__)); 468 /* Validate the message */ 469 if ((xyz.blk ^ xyz.cblk) != (unsigned char) 0xFF) 470 { 471 ZM_DEBUG (zm_dprintf 472 ("Framing error - blk: %x/%x/%x\n", xyz.blk, xyz.cblk, 473 (xyz.blk ^ xyz.cblk))); 474 ZM_DEBUG (zm_dump_buf (xyz.pkt, xyz.len)); 475 xyzModem_flush (); 476 return xyzModem_frame; 477 } 478 /* Verify checksum/CRC */ 479 if (xyz.crc_mode) 480 { 481 cksum = cyg_crc16 (xyz.pkt, xyz.len); 482 if (cksum != ((xyz.crc1 << 8) | xyz.crc2)) 483 { 484 ZM_DEBUG (zm_dprintf ("CRC error - recvd: %02x%02x, computed: %x\n", 485 xyz.crc1, xyz.crc2, cksum & 0xFFFF)); 486 return xyzModem_cksum; 487 } 488 } 489 else 490 { 491 cksum = 0; 492 for (i = 0; i < xyz.len; i++) 493 { 494 cksum += xyz.pkt[i]; 495 } 496 if (xyz.crc1 != (cksum & 0xFF)) 497 { 498 ZM_DEBUG (zm_dprintf 499 ("Checksum error - recvd: %x, computed: %x\n", xyz.crc1, 500 cksum & 0xFF)); 501 return xyzModem_cksum; 502 } 503 } 504 /* If we get here, the message passes [structural] muster */ 505 return 0; 506 } 507 508 int 509 xyzModem_stream_open (connection_info_t * info, int *err) 510 { 511 #ifdef REDBOOT 512 int console_chan; 513 #endif 514 int stat = 0; 515 int retries = xyzModem_MAX_RETRIES; 516 int crc_retries = xyzModem_MAX_RETRIES_WITH_CRC; 517 518 /* ZM_DEBUG(zm_out = zm_out_start); */ 519 #ifdef xyzModem_zmodem 520 if (info->mode == xyzModem_zmodem) 521 { 522 *err = xyzModem_noZmodem; 523 return -1; 524 } 525 #endif 526 527 #ifdef REDBOOT 528 /* Set up the I/O channel. Note: this allows for using a different port in the future */ 529 console_chan = 530 CYGACC_CALL_IF_SET_CONSOLE_COMM 531 (CYGNUM_CALL_IF_SET_COMM_ID_QUERY_CURRENT); 532 if (info->chan >= 0) 533 { 534 CYGACC_CALL_IF_SET_CONSOLE_COMM (info->chan); 535 } 536 else 537 { 538 CYGACC_CALL_IF_SET_CONSOLE_COMM (console_chan); 539 } 540 xyz.__chan = CYGACC_CALL_IF_CONSOLE_PROCS (); 541 542 CYGACC_CALL_IF_SET_CONSOLE_COMM (console_chan); 543 CYGACC_COMM_IF_CONTROL (*xyz.__chan, __COMMCTL_SET_TIMEOUT, 544 xyzModem_CHAR_TIMEOUT); 545 #else 546 /* TODO: CHECK ! */ 547 int dummy = 0; 548 xyz.__chan = &dummy; 549 #endif 550 xyz.len = 0; 551 xyz.crc_mode = true; 552 xyz.at_eof = false; 553 xyz.tx_ack = false; 554 xyz.mode = info->mode; 555 xyz.total_retries = 0; 556 xyz.total_SOH = 0; 557 xyz.total_STX = 0; 558 xyz.total_CAN = 0; 559 #ifdef USE_YMODEM_LENGTH 560 xyz.read_length = 0; 561 xyz.file_length = 0; 562 #endif 563 564 CYGACC_COMM_IF_PUTC (*xyz.__chan, (xyz.crc_mode ? 'C' : NAK)); 565 566 if (xyz.mode == xyzModem_xmodem) 567 { 568 /* X-modem doesn't have an information header - exit here */ 569 xyz.next_blk = 1; 570 return 0; 571 } 572 573 while (retries-- > 0) 574 { 575 stat = xyzModem_get_hdr (); 576 if (stat == 0) 577 { 578 /* Y-modem file information header */ 579 if (xyz.blk == 0) 580 { 581 #ifdef USE_YMODEM_LENGTH 582 /* skip filename */ 583 while (*xyz.bufp++); 584 /* get the length */ 585 parse_num ((char *) xyz.bufp, &xyz.file_length, NULL, " "); 586 #endif 587 /* The rest of the file name data block quietly discarded */ 588 xyz.tx_ack = true; 589 } 590 xyz.next_blk = 1; 591 xyz.len = 0; 592 return 0; 593 } 594 else if (stat == xyzModem_timeout) 595 { 596 if (--crc_retries <= 0) 597 xyz.crc_mode = false; 598 CYGACC_CALL_IF_DELAY_US (5 * 100000); /* Extra delay for startup */ 599 CYGACC_COMM_IF_PUTC (*xyz.__chan, (xyz.crc_mode ? 'C' : NAK)); 600 xyz.total_retries++; 601 ZM_DEBUG (zm_dprintf ("NAK (%d)\n", __LINE__)); 602 } 603 if (stat == xyzModem_cancel) 604 { 605 break; 606 } 607 } 608 *err = stat; 609 ZM_DEBUG (zm_flush ()); 610 return -1; 611 } 612 613 int 614 xyzModem_stream_read (char *buf, int size, int *err) 615 { 616 int stat, total, len; 617 int retries; 618 619 total = 0; 620 stat = xyzModem_cancel; 621 /* Try and get 'size' bytes into the buffer */ 622 while (!xyz.at_eof && (size > 0)) 623 { 624 if (xyz.len == 0) 625 { 626 retries = xyzModem_MAX_RETRIES; 627 while (retries-- > 0) 628 { 629 stat = xyzModem_get_hdr (); 630 if (stat == 0) 631 { 632 if (xyz.blk == xyz.next_blk) 633 { 634 xyz.tx_ack = true; 635 ZM_DEBUG (zm_dprintf 636 ("ACK block %d (%d)\n", xyz.blk, __LINE__)); 637 xyz.next_blk = (xyz.next_blk + 1) & 0xFF; 638 639 #if defined(xyzModem_zmodem) || defined(USE_YMODEM_LENGTH) 640 if (xyz.mode == xyzModem_xmodem || xyz.file_length == 0) 641 { 642 #else 643 if (1) 644 { 645 #endif 646 /* Data blocks can be padded with ^Z (EOF) characters */ 647 /* This code tries to detect and remove them */ 648 if ((xyz.bufp[xyz.len - 1] == EOF) && 649 (xyz.bufp[xyz.len - 2] == EOF) && 650 (xyz.bufp[xyz.len - 3] == EOF)) 651 { 652 while (xyz.len 653 && (xyz.bufp[xyz.len - 1] == EOF)) 654 { 655 xyz.len--; 656 } 657 } 658 } 659 660 #ifdef USE_YMODEM_LENGTH 661 /* 662 * See if accumulated length exceeds that of the file. 663 * If so, reduce size (i.e., cut out pad bytes) 664 * Only do this for Y-modem (and Z-modem should it ever 665 * be supported since it can fall back to Y-modem mode). 666 */ 667 if (xyz.mode != xyzModem_xmodem && 0 != xyz.file_length) 668 { 669 xyz.read_length += xyz.len; 670 if (xyz.read_length > xyz.file_length) 671 { 672 xyz.len -= (xyz.read_length - xyz.file_length); 673 } 674 } 675 #endif 676 break; 677 } 678 else if (xyz.blk == ((xyz.next_blk - 1) & 0xFF)) 679 { 680 /* Just re-ACK this so sender will get on with it */ 681 CYGACC_COMM_IF_PUTC (*xyz.__chan, ACK); 682 continue; /* Need new header */ 683 } 684 else 685 { 686 stat = xyzModem_sequence; 687 } 688 } 689 if (stat == xyzModem_cancel) 690 { 691 break; 692 } 693 if (stat == xyzModem_eof) 694 { 695 CYGACC_COMM_IF_PUTC (*xyz.__chan, ACK); 696 ZM_DEBUG (zm_dprintf ("ACK (%d)\n", __LINE__)); 697 if (xyz.mode == xyzModem_ymodem) 698 { 699 CYGACC_COMM_IF_PUTC (*xyz.__chan, 700 (xyz.crc_mode ? 'C' : NAK)); 701 xyz.total_retries++; 702 ZM_DEBUG (zm_dprintf ("Reading Final Header\n")); 703 stat = xyzModem_get_hdr (); 704 CYGACC_COMM_IF_PUTC (*xyz.__chan, ACK); 705 ZM_DEBUG (zm_dprintf ("FINAL ACK (%d)\n", __LINE__)); 706 } 707 xyz.at_eof = true; 708 break; 709 } 710 CYGACC_COMM_IF_PUTC (*xyz.__chan, (xyz.crc_mode ? 'C' : NAK)); 711 xyz.total_retries++; 712 ZM_DEBUG (zm_dprintf ("NAK (%d)\n", __LINE__)); 713 } 714 if (stat < 0) 715 { 716 *err = stat; 717 xyz.len = -1; 718 return total; 719 } 720 } 721 /* Don't "read" data from the EOF protocol package */ 722 if (!xyz.at_eof) 723 { 724 len = xyz.len; 725 if (size < len) 726 len = size; 727 memcpy (buf, xyz.bufp, len); 728 size -= len; 729 buf += len; 730 total += len; 731 xyz.len -= len; 732 xyz.bufp += len; 733 } 734 } 735 return total; 736 } 737 738 void 739 xyzModem_stream_close (int *err) 740 { 741 diag_printf 742 ("xyzModem - %s mode, %d(SOH)/%d(STX)/%d(CAN) packets, %d retries\n", 743 xyz.crc_mode ? "CRC" : "Cksum", xyz.total_SOH, xyz.total_STX, 744 xyz.total_CAN, xyz.total_retries); 745 ZM_DEBUG (zm_flush ()); 746 } 747 748 /* Need to be able to clean out the input buffer, so have to take the */ 749 /* getc */ 750 void 751 xyzModem_stream_terminate (bool abort, int (*getc) (void)) 752 { 753 int c; 754 755 if (abort) 756 { 757 ZM_DEBUG (zm_dprintf ("!!!! TRANSFER ABORT !!!!\n")); 758 switch (xyz.mode) 759 { 760 case xyzModem_xmodem: 761 case xyzModem_ymodem: 762 /* The X/YMODEM Spec seems to suggest that multiple CAN followed by an equal */ 763 /* number of Backspaces is a friendly way to get the other end to abort. */ 764 CYGACC_COMM_IF_PUTC (*xyz.__chan, CAN); 765 CYGACC_COMM_IF_PUTC (*xyz.__chan, CAN); 766 CYGACC_COMM_IF_PUTC (*xyz.__chan, CAN); 767 CYGACC_COMM_IF_PUTC (*xyz.__chan, CAN); 768 CYGACC_COMM_IF_PUTC (*xyz.__chan, BSP); 769 CYGACC_COMM_IF_PUTC (*xyz.__chan, BSP); 770 CYGACC_COMM_IF_PUTC (*xyz.__chan, BSP); 771 CYGACC_COMM_IF_PUTC (*xyz.__chan, BSP); 772 /* Now consume the rest of what's waiting on the line. */ 773 ZM_DEBUG (zm_dprintf ("Flushing serial line.\n")); 774 xyzModem_flush (); 775 xyz.at_eof = true; 776 break; 777 #ifdef xyzModem_zmodem 778 case xyzModem_zmodem: 779 /* Might support it some day I suppose. */ 780 #endif 781 break; 782 } 783 } 784 else 785 { 786 ZM_DEBUG (zm_dprintf ("Engaging cleanup mode...\n")); 787 /* 788 * Consume any trailing crap left in the inbuffer from 789 * previous recieved blocks. Since very few files are an exact multiple 790 * of the transfer block size, there will almost always be some gunk here. 791 * If we don't eat it now, RedBoot will think the user typed it. 792 */ 793 ZM_DEBUG (zm_dprintf ("Trailing gunk:\n")); 794 while ((c = (*getc) ()) > -1); 795 ZM_DEBUG (zm_dprintf ("\n")); 796 /* 797 * Make a small delay to give terminal programs like minicom 798 * time to get control again after their file transfer program 799 * exits. 800 */ 801 CYGACC_CALL_IF_DELAY_US ((cyg_int32) 250000); 802 } 803 } 804 805 char * 806 xyzModem_error (int err) 807 { 808 switch (err) 809 { 810 case xyzModem_access: 811 return "Can't access file"; 812 break; 813 case xyzModem_noZmodem: 814 return "Sorry, zModem not available yet"; 815 break; 816 case xyzModem_timeout: 817 return "Timed out"; 818 break; 819 case xyzModem_eof: 820 return "End of file"; 821 break; 822 case xyzModem_cancel: 823 return "Cancelled"; 824 break; 825 case xyzModem_frame: 826 return "Invalid framing"; 827 break; 828 case xyzModem_cksum: 829 return "CRC/checksum error"; 830 break; 831 case xyzModem_sequence: 832 return "Block sequence error"; 833 break; 834 default: 835 return "Unknown error"; 836 break; 837 } 838 } 839 840 /* 841 * RedBoot interface 842 */ 843 #if 0 /* SB */ 844 GETC_IO_FUNCS (xyzModem_io, xyzModem_stream_open, xyzModem_stream_close, 845 xyzModem_stream_terminate, xyzModem_stream_read, 846 xyzModem_error); 847 RedBoot_load (xmodem, xyzModem_io, false, false, xyzModem_xmodem); 848 RedBoot_load (ymodem, xyzModem_io, false, false, xyzModem_ymodem); 849 #endif 850