Mercurial > ecos
annotate packages/hal/powerpc/cogent/current/src/hal_diag.c @ 66:bf00f99aec69 ecos-sw-2000-02-02
Merge from eCos master repository on 2000-02-02-19:16:44-GMT
| author | jlarmour |
|---|---|
| date | Wed, 02 Feb 2000 19:57:02 +0000 |
| parents | c38311975d4f |
| children | f74b2666b30d |
| rev | line source |
|---|---|
| 0 | 1 //============================================================================= |
| 2 // | |
| 3 // hal_diag.c | |
| 4 // | |
| 5 // HAL diagnostic output code | |
| 6 // | |
| 7 //============================================================================= | |
| 8 //####COPYRIGHTBEGIN#### | |
|
64
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
2
diff
changeset
|
9 // |
|
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
2
diff
changeset
|
10 // ------------------------------------------- |
|
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
2
diff
changeset
|
11 // The contents of this file are subject to the Red Hat eCos Public License |
|
66
bf00f99aec69
Merge from eCos master repository on 2000-02-02-19:16:44-GMT
jlarmour
parents:
64
diff
changeset
|
12 // Version 1.1 (the "License"); you may not use this file except in |
|
64
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
2
diff
changeset
|
13 // compliance with the License. You may obtain a copy of the License at |
|
66
bf00f99aec69
Merge from eCos master repository on 2000-02-02-19:16:44-GMT
jlarmour
parents:
64
diff
changeset
|
14 // http://www.redhat.com/ |
|
64
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
2
diff
changeset
|
15 // |
|
66
bf00f99aec69
Merge from eCos master repository on 2000-02-02-19:16:44-GMT
jlarmour
parents:
64
diff
changeset
|
16 // Software distributed under the License is distributed on an "AS IS" |
|
64
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
2
diff
changeset
|
17 // basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the |
|
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
2
diff
changeset
|
18 // License for the specific language governing rights and limitations under |
|
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
2
diff
changeset
|
19 // the License. |
|
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
2
diff
changeset
|
20 // |
|
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
2
diff
changeset
|
21 // The Original Code is eCos - Embedded Configurable Operating System, |
|
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
2
diff
changeset
|
22 // released September 30, 1998. |
|
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
2
diff
changeset
|
23 // |
|
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
2
diff
changeset
|
24 // The Initial Developer of the Original Code is Red Hat. |
|
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
2
diff
changeset
|
25 // Portions created by Red Hat are |
|
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
2
diff
changeset
|
26 // Copyright (C) 1998, 1999, 2000 Red Hat, Inc. |
|
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
2
diff
changeset
|
27 // All Rights Reserved. |
|
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
2
diff
changeset
|
28 // ------------------------------------------- |
|
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
2
diff
changeset
|
29 // |
| 0 | 30 //####COPYRIGHTEND#### |
| 31 //============================================================================= | |
| 32 //#####DESCRIPTIONBEGIN#### | |
| 33 // | |
| 2 | 34 // Author(s): nickg, jskov |
| 35 // Contributors: nickg, jskov | |
| 36 // Date: 1999-03-23 | |
| 37 // Purpose: HAL diagnostic output | |
| 38 // Description: Implementations of HAL diagnostic output support. | |
| 0 | 39 // |
| 40 //####DESCRIPTIONEND#### | |
| 41 // | |
| 42 //============================================================================= | |
| 43 | |
| 44 #include <pkgconf/hal.h> | |
| 2 | 45 #include <pkgconf/hal_powerpc_cogent.h> // CYGHWR_HAL_POWERPC_COGENT_DIAG_PORT |
| 0 | 46 |
| 2 | 47 #include <cyg/hal/hal_diag.h> // our header. |
| 0 | 48 |
| 49 #if defined(CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS) | |
| 2 | 50 #include <cyg/hal/hal_stub.h> // hal_output_gdb_string |
| 0 | 51 #endif |
| 52 | |
| 2 | 53 #include <cyg/infra/cyg_type.h> // base types, externC |
| 54 #include <cyg/hal/hal_io.h> // IO macros | |
| 55 #include <cyg/hal/hal_intr.h> // Interrupt macros | |
| 0 | 56 |
| 57 //----------------------------------------------------------------------------- | |
| 58 // Select default diag channel to use | |
| 59 | |
| 60 //#define CYG_KERNEL_DIAG_ROMART | |
| 61 //#define CYG_KERNEL_DIAG_LCD | |
| 62 //#define CYG_KERNEL_DIAG_SERIAL | |
| 63 | |
| 64 #if !defined(CYG_KERNEL_DIAG_SERIAL) && \ | |
| 65 !defined(CYG_KERNEL_DIAG_LCD) && \ | |
| 66 !defined(CYG_KERNEL_DIAG_ROMART) | |
| 67 | |
| 68 #define CYG_KERNEL_DIAG_SERIAL | |
| 69 | |
| 70 #endif | |
| 71 | |
| 2 | 72 // Always use LCD when building a GDB stub ROM. |
| 73 #ifdef CYG_HAL_STARTUP_STUBS | |
| 74 #undef CYG_KERNEL_DIAG_SERIAL | |
| 75 #undef CYG_KERNEL_DIAG_ROMART | |
| 0 | 76 |
| 2 | 77 #define CYG_KERNEL_DIAG_LCD |
| 78 #endif | |
| 0 | 79 |
| 2 | 80 // Assumption: all diagnostic output must be GDB packetized unless |
| 81 // this is a ROM (i.e. totally stand-alone) system. | |
| 82 #ifdef CYG_HAL_STARTUP_ROM | |
| 83 #define HAL_DIAG_USES_HARDWARE | |
| 84 #endif | |
| 0 | 85 |
| 86 | |
| 2 | 87 //----------------------------------------------------------------------------- |
| 88 // Serial diag functions. | |
| 89 #ifdef CYG_KERNEL_DIAG_SERIAL | |
| 0 | 90 |
| 2 | 91 // Include the serial driver. |
| 92 #define CYG_CMA_PORT CYGHWR_HAL_POWERPC_COGENT_DIAG_PORT | |
| 93 #include <cma_ser.inl> | |
| 0 | 94 |
| 2 | 95 #ifdef HAL_DIAG_USES_HARDWARE |
| 0 | 96 |
| 97 void hal_diag_init(void) | |
| 98 { | |
| 2 | 99 hal_cma_init_serial(); |
| 0 | 100 } |
| 101 | |
| 2 | 102 void hal_diag_write_char(char __c) |
| 0 | 103 { |
| 2 | 104 hal_cma_put_char(__c); |
| 0 | 105 } |
| 106 | |
| 107 void hal_diag_read_char(char *c) | |
| 108 { | |
| 2 | 109 *c = (char) hal_cma_get_char(); |
| 110 } | |
| 111 | |
| 112 #else // ifdef HAL_DIAG_USES_HARDWARE | |
| 113 | |
| 114 // Initialize diag port | |
| 115 void hal_diag_init(void) | |
| 116 { | |
| 117 #ifdef CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS | |
| 118 // assume GDB channel is already set up. | |
| 119 if (0) hal_cma_init_serial(); // avoids compiler warning | |
| 120 #else | |
| 121 hal_cma_init_serial(); | |
| 122 #endif | |
| 123 | |
| 124 } | |
| 125 | |
| 126 void | |
| 127 hal_diag_write_char_serial( char c ) | |
| 128 { | |
| 129 unsigned long __state; | |
| 130 HAL_DISABLE_INTERRUPTS(__state); | |
| 131 hal_cma_put_char(c); | |
| 132 HAL_RESTORE_INTERRUPTS(__state); | |
| 133 } | |
| 134 | |
| 135 void | |
| 136 hal_diag_read_char(char *c) | |
| 137 { | |
| 138 *c = (char) hal_cma_get_char(); | |
| 139 } | |
| 140 | |
| 141 void | |
| 142 hal_diag_write_char(char c) | |
| 143 { | |
| 144 | |
| 145 static char line[100]; | |
| 146 static int pos = 0; | |
| 147 | |
| 148 // No need to send CRs | |
| 149 if( c == '\r' ) return; | |
| 150 | |
| 151 line[pos++] = c; | |
| 152 | |
| 153 if( c == '\n' || pos == sizeof(line) ) | |
| 154 { | |
| 155 CYG_INTERRUPT_STATE old; | |
| 0 | 156 |
| 2 | 157 // Disable interrupts. This prevents GDB trying to interrupt us |
| 158 // while we are in the middle of sending a packet. The serial | |
| 159 // receive interrupt will be seen when we re-enable interrupts | |
| 160 // later. | |
| 161 | |
| 162 HAL_DISABLE_INTERRUPTS(old); | |
| 163 | |
| 164 while(1) | |
| 165 { | |
| 166 char c1; | |
| 167 static char hex[] = "0123456789ABCDEF"; | |
| 168 cyg_uint8 csum = 0; | |
| 169 int i; | |
| 170 | |
| 171 hal_diag_write_char_serial('$'); | |
| 172 hal_diag_write_char_serial('O'); | |
| 173 csum += 'O'; | |
| 174 for( i = 0; i < pos; i++ ) | |
| 175 { | |
| 176 char ch = line[i]; | |
| 177 char h = hex[(ch>>4)&0xF]; | |
| 178 char l = hex[ch&0xF]; | |
| 179 hal_diag_write_char_serial(h); | |
| 180 hal_diag_write_char_serial(l); | |
| 181 csum += h; | |
| 182 csum += l; | |
| 183 } | |
| 184 hal_diag_write_char_serial('#'); | |
| 185 hal_diag_write_char_serial(hex[(csum>>4)&0xF]); | |
| 186 hal_diag_write_char_serial(hex[csum&0xF]); | |
| 0 | 187 |
| 2 | 188 // Wait for the ACK character '+' from GDB here and handle |
| 189 // receiving a ^C instead. | |
| 190 hal_diag_read_char(&c1); | |
| 191 | |
| 192 if( c1 == '+' ) | |
| 193 break; // a good acknowledge | |
| 194 | |
| 195 #ifdef CYGDBG_HAL_DEBUG_GDB_BREAK_SUPPORT | |
| 196 if( 3 == c1 ) { | |
| 197 // Ctrl-C: breakpoint. | |
| 198 cyg_hal_gdb_interrupt( | |
| 199 (target_register_t)__builtin_return_address(0)); | |
| 200 break; | |
| 201 } | |
| 202 #endif | |
| 203 // otherwise, loop round again | |
| 204 } | |
| 205 | |
| 206 pos = 0; | |
| 207 | |
| 208 // And re-enable interrupts | |
| 209 HAL_RESTORE_INTERRUPTS(old); | |
| 210 | |
| 211 } | |
| 0 | 212 } |
| 2 | 213 |
| 214 #endif // ifdef HAL_DIAG_USES_HARDWARE | |
| 215 | |
| 216 #endif // ifdef CYG_KERNEL_DIAG_SERIAL | |
| 0 | 217 |
| 218 //----------------------------------------------------------------------------- | |
| 219 // Cogent board specific LCD code | |
| 220 | |
| 221 #if defined(CYG_KERNEL_DIAG_LCD) | |
| 222 | |
| 223 // FEMA 162B 16 character x 2 line LCD | |
| 224 // base addresses and register offsets * | |
| 225 | |
| 226 #define MBD_BASE 0 | |
| 227 | |
| 228 #define LCD_BASE (MBD_BASE + 0xEB00007) | |
| 229 | |
| 230 #define LCD_DATA (LCD_BASE + 0x00) // read/write lcd data | |
| 231 #define LCD_STAT (LCD_BASE + 0x08) // read lcd busy status | |
| 232 #define LCD_CMD (LCD_BASE + 0x08) // write lcd command | |
| 233 | |
| 234 // status register bit definitions | |
| 235 #define LCD_STAT_BUSY 0x80 // 1 = display busy | |
| 236 #define LCD_STAT_ADD 0x7F // bits 0-6 return current display address | |
| 237 | |
| 238 // command register definitions | |
| 239 #define LCD_CMD_RST 0x01 // clear entire display and reset display address | |
| 240 #define LCD_CMD_HOME 0x02 // reset display address and reset any shifting | |
| 241 #define LCD_CMD_ECL 0x04 // move cursor left one position on next data write | |
| 242 #define LCD_CMD_ESL 0x05 // shift display left one position on next data write | |
| 243 #define LCD_CMD_ECR 0x06 // move cursor right one position on next data write | |
| 244 #define LCD_CMD_ESR 0x07 // shift display right one position on next data write | |
| 245 #define LCD_CMD_DOFF 0x08 // display off, cursor off, blinking off | |
| 246 #define LCD_CMD_BL 0x09 // blink character at current cursor position | |
| 247 #define LCD_CMD_CUR 0x0A // enable cursor on | |
| 248 #define LCD_CMD_DON 0x0C // turn display on | |
| 249 #define LCD_CMD_CL 0x10 // move cursor left one position | |
| 250 #define LCD_CMD_SL 0x14 // shift display left one position | |
| 251 #define LCD_CMD_CR 0x18 // move cursor right one position | |
| 252 #define LCD_CMD_SR 0x1C // shift display right one position | |
| 253 #define LCD_CMD_MODE 0x38 // sets 8 bits, 2 lines, 5x7 characters | |
| 254 #define LCD_CMD_ACG 0x40 // bits 0-5 sets the character generator address | |
| 255 #define LCD_CMD_ADD 0x80 // bits 0-6 sets the display data address to line 1 + | |
| 256 | |
| 257 // LCD status values | |
| 258 #define LCD_OK 0x00 | |
| 259 #define LCD_ERR 0x01 | |
| 260 | |
| 261 #define LCD_LINE0 0x00 | |
| 262 #define LCD_LINE1 0x40 | |
| 263 | |
| 264 #define LCD_LINE_LENGTH 16 | |
| 265 | |
| 266 static char lcd_line0[LCD_LINE_LENGTH+1]; | |
| 267 static char lcd_line1[LCD_LINE_LENGTH+1]; | |
| 268 static char *lcd_line[2] = { lcd_line0, lcd_line1 }; | |
| 269 static int lcd_curline = 0; | |
| 270 static int lcd_linepos = 0; | |
| 271 | |
| 272 | |
| 273 static void lcd_dis(int add, char *string); | |
| 274 | |
| 2 | 275 externC void diag_write_string (const char*); |
| 276 | |
| 0 | 277 void hal_diag_init() |
| 278 { | |
| 279 cyg_uint8 stat; | |
| 280 int i; | |
| 281 | |
| 282 // wait for not busy | |
| 2 | 283 // Note: It seems that the LCD isn't quite ready to process commands |
| 284 // when it clears the BUSY flag. Reading the status address an extra | |
| 285 // time seems to give it enough breathing room. | |
| 0 | 286 do { HAL_READ_UINT8 (LCD_STAT, stat); } while (stat & LCD_STAT_BUSY); |
| 2 | 287 HAL_READ_UINT8 (LCD_STAT, stat); |
| 0 | 288 |
| 289 // configure the lcd for 8 bits/char, 2 lines | |
| 290 // and 5x7 dot matrix | |
| 291 HAL_WRITE_UINT8 (LCD_CMD, LCD_CMD_MODE); | |
| 292 | |
| 293 // wait for not busy | |
| 294 do { HAL_READ_UINT8 (LCD_STAT, stat); } while (stat & LCD_STAT_BUSY); | |
| 2 | 295 HAL_READ_UINT8 (LCD_STAT, stat); |
| 0 | 296 |
| 297 // turn the LCD display on | |
| 298 HAL_WRITE_UINT8 (LCD_CMD, LCD_CMD_DON); | |
| 299 | |
| 300 lcd_curline = 0; | |
| 301 lcd_linepos = 0; | |
| 302 | |
| 303 for( i = 0; i < LCD_LINE_LENGTH; i++ ) | |
| 304 lcd_line[0][i] = lcd_line[1][i] = ' '; | |
| 305 | |
| 306 lcd_line[0][LCD_LINE_LENGTH] = lcd_line[1][LCD_LINE_LENGTH] = 0; | |
| 307 | |
| 308 lcd_dis( LCD_LINE0, lcd_line[0] ); | |
| 309 lcd_dis( LCD_LINE1, lcd_line[1] ); | |
| 310 | |
| 311 | |
| 2 | 312 #ifdef CYG_HAL_STARTUP_STUBS |
| 0 | 313 // It's handy to have the LCD initialized at reset when using it |
| 2 | 314 // for debugging output. |
| 0 | 315 { |
| 2 | 316 diag_write_string ("eCos ROM " __TIME__ "\n"); |
| 0 | 317 diag_write_string (__DATE__ "\n"); |
| 318 } | |
| 319 #endif | |
| 320 } | |
| 321 | |
| 322 // this routine writes the string to the LCD | |
| 323 // display after setting the address to add | |
| 324 static void lcd_dis(int add, char *string) | |
| 325 { | |
| 326 cyg_uint8 stat; | |
| 327 int i; | |
| 328 | |
| 2 | 329 // wait for not busy (see Note in hal_diag_init above) |
| 330 do { HAL_READ_UINT8 (LCD_STAT, stat); } while (stat & LCD_STAT_BUSY); | |
| 331 HAL_READ_UINT8 (LCD_STAT, stat); | |
| 332 | |
| 333 // write the address | |
| 334 HAL_WRITE_UINT8 (LCD_CMD, (LCD_CMD_ADD + add)); | |
| 335 | |
| 0 | 336 // write the string out to the display stopping when we reach 0 |
| 337 for (i = 0; *string != '\0'; i++) | |
| 338 { | |
| 339 // wait for not busy | |
| 340 do { HAL_READ_UINT8 (LCD_STAT, stat); } while (stat & LCD_STAT_BUSY); | |
| 2 | 341 HAL_READ_UINT8 (LCD_STAT, stat); |
| 0 | 342 |
| 343 // write the data | |
| 344 HAL_WRITE_UINT8 (LCD_DATA, *string++); | |
| 345 } | |
| 346 } | |
| 347 | |
| 348 void hal_diag_write_char(char c) | |
| 349 { | |
| 2 | 350 unsigned long __state; |
| 0 | 351 int i; |
| 352 | |
| 353 // ignore CR | |
| 354 if( c == '\r' ) return; | |
| 355 | |
| 2 | 356 HAL_DISABLE_INTERRUPTS(__state) |
| 0 | 357 if( c == '\n' ) |
| 358 { | |
| 359 lcd_dis( LCD_LINE0, &lcd_line[lcd_curline^1][0] ); | |
| 360 lcd_dis( LCD_LINE1, &lcd_line[lcd_curline][0] ); | |
| 361 | |
| 362 // Do a line feed | |
| 363 lcd_curline ^= 1; | |
| 364 lcd_linepos = 0; | |
| 365 | |
| 366 for( i = 0; i < LCD_LINE_LENGTH; i++ ) | |
| 367 lcd_line[lcd_curline][i] = ' '; | |
| 368 | |
| 2 | 369 HAL_RESTORE_INTERRUPTS(__state); |
| 0 | 370 return; |
| 371 } | |
| 372 | |
| 2 | 373 // Only allow to be output if there is room on the LCD line |
| 374 if( lcd_linepos < LCD_LINE_LENGTH ) | |
| 375 lcd_line[lcd_curline][lcd_linepos++] = c; | |
| 0 | 376 |
| 2 | 377 HAL_RESTORE_INTERRUPTS(__state); |
| 0 | 378 } |
| 379 | |
| 2 | 380 void hal_diag_read_char(char* c) {} |
| 0 | 381 |
| 382 #endif | |
| 383 | |
| 384 | |
| 385 //---------------------------------------------------------------------------*/ | |
| 386 // PromICE AI interface | |
| 387 | |
| 388 | |
| 389 #if defined(CYG_KERNEL_DIAG_ROMART) | |
| 390 | |
| 391 #ifdef CYG_HAL_POWERPC_COGENT | |
| 392 #define PROMICE_AILOC 0xfff00020 | |
| 393 #endif | |
| 394 | |
| 395 // Add this to the LoadICE config file: ailoc 20 19200 | |
| 2 | 396 // Note: I couldn't get this to work. jskov |
| 0 | 397 |
| 398 #define PROMICE_BUS_SIZE 16 | |
| 399 #define PROMICE_BURST_SIZE 1 | |
| 400 | |
| 401 #if PROMICE_BUS_SIZE == 16 | |
| 402 | |
| 403 typedef volatile struct | |
| 404 { | |
| 405 volatile cyg_uint16 zero; | |
| 406 // cyg_uint16 pad1[PROMICE_BURST_SIZE]; | |
| 407 volatile cyg_uint16 one; | |
| 408 // cyg_uint16 pad2[PROMICE_BURST_SIZE]; | |
| 409 volatile cyg_uint16 data; | |
| 410 // cyg_uint16 pad3[PROMICE_BURST_SIZE]; | |
| 411 volatile cyg_uint16 status; | |
| 412 | |
| 413 } AISTRUCT; | |
| 414 | |
| 415 #endif | |
| 416 | |
| 417 AISTRUCT *AI = (AISTRUCT *)PROMICE_AILOC; | |
| 418 | |
| 419 #define PROMICE_STATUS_TDA 0x01 | |
| 420 #define PROMICE_STATUS_HDA 0x02 | |
| 421 #define PROMICE_STATUS_OVR 0x04 | |
| 422 | |
| 423 void hal_diag_init() | |
| 424 { | |
| 425 volatile cyg_uint8 junk; | |
| 426 | |
| 427 while( AI->status == 0xCC ) | |
| 428 continue; | |
| 429 | |
| 430 junk = AI->data; | |
| 431 } | |
| 432 | |
| 433 static void ai_write_char(cyg_uint8 data) | |
| 434 { | |
| 435 volatile cyg_uint8 junk; | |
| 436 int i; | |
| 2 | 437 unsigned long __state; |
| 0 | 438 |
| 2 | 439 HAL_DISABLE_INTERRUPTS(__state) |
| 440 | |
| 0 | 441 // Wait for tda == 0 |
| 442 while( (AI->status & PROMICE_STATUS_TDA) == PROMICE_STATUS_TDA ) | |
| 443 continue; | |
| 444 | |
| 445 // Send start bit | |
| 446 junk = AI->one; | |
| 447 | |
| 448 for( i = 0; i < 8; i++ ) | |
| 449 { | |
| 450 // send ls bit of data | |
| 451 if( (data & 1) == 1 ) | |
| 452 junk = AI->one; | |
| 453 else | |
| 454 junk = AI->zero; | |
| 455 | |
| 456 // shift down for next bit | |
| 457 data >>= 1; | |
| 458 } | |
| 459 | |
| 460 // Send stop bit | |
| 461 junk = AI->one; | |
| 462 | |
| 2 | 463 HAL_RESTORE_INTERRUPTS(__state); |
| 464 | |
| 0 | 465 // all done |
| 466 } | |
| 467 | |
| 468 void hal_diag_write_char(char c) | |
| 469 { | |
| 470 ai_write_char((cyg_uint8)c); | |
| 471 } | |
| 472 | |
| 473 #endif | |
| 474 | |
| 475 //----------------------------------------------------------------------------- | |
| 476 // End of hal_diag.c |