1 /* Remote serial interface using Hitachi E7000 PC ISA card in a PC 2 3 Copyright 1994 Free Software Foundation, Inc. 4 5 This file is part of GDB. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 2 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program; if not, write to the Free Software 19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ 20 21 #if defined(__GO32__) || defined(__WIN32__) 22 #if defined(__WIN32__) 23 //#define KERNEL 24 //#define STRICT 25 //#include <windows.h> 26 /* we define the 32-bit calls which thunk to 16-bit dll calls 27 */ 28 #include "win-e7kpc.h" 29 /* msvc uses strnicmp instead */ 30 #define strncasecmp strnicmp 31 #else 32 #include <sys/dos.h> 33 #include "defs.h" 34 #endif 35 #include "serial.h" 36 37 38 static int e7000pc_open PARAMS ((serial_t scb, const char *name)); 39 static void e7000pc_raw PARAMS ((serial_t scb)); 40 static int e7000pc_readchar PARAMS ((serial_t scb, int timeout)); 41 static int e7000pc_setbaudrate PARAMS ((serial_t scb, int rate)); 42 static int e7000pc_write PARAMS ((serial_t scb, const char *str, int len)); 43 static void e7000pc_close PARAMS ((serial_t scb)); 44 static serial_ttystate e7000pc_get_tty_state PARAMS ((serial_t scb)); 45 static int e7000pc_set_tty_state PARAMS ((serial_t scb, serial_ttystate state)); 46 static char *aptr PARAMS ((short p)); 47 48 static int dos_async_init PARAMS ((int port)); 49 static void dos_async_tx PARAMS ((const char c)); 50 static int dos_async_rx PARAMS (()); 51 52 53 54 #define OFF_DPD 0x0000 55 #define OFF_DDP 0x1000 56 #define OFF_CPD 0x2000 57 #define OFF_CDP 0x2400 58 #define OFF_FA 0x3000 59 #define OFF_FB 0x3002 60 #define OFF_FC 0x3004 61 #define OFF_IRQTOD 0x3008 62 #define OFF_IRQTOP 0x300a 63 #define OFF_READY 0x300c 64 #define OFF_PON 0x300e 65 66 #define IDLE 0x0000 67 #define CMD_CI 0x4349 68 #define CMD_CO 0x434f 69 #define CMD_LO 0x4c4f 70 #define CMD_LS 0x4c53 71 #define CMD_SV 0x5356 72 #define CMD_SS 0x5353 73 #define CMD_OK 0x4f4b 74 #define CMD_ER 0x4552 75 #define CMD_NF 0x4e46 76 #define CMD_AB 0x4142 77 #define CMD_ED 0x4544 78 #define CMD_CE 0x4345 79 80 static unsigned long fa; 81 static unsigned long irqtod; 82 static unsigned long ready; 83 static unsigned long fb; 84 static unsigned long cpd ; 85 static unsigned long cdp ; 86 static unsigned long ready; 87 static unsigned long pon; 88 static unsigned long irqtop; 89 static unsigned long board_at; 90 91 #ifdef __WIN32__ 92 // These routines are normally part of the go32 dos extender. 93 // We redefine them here to be calls into their Windoze equivs. 94 static void dosmemget(int offset, int length, void *buffer); 95 static void dosmemput(const void *buffer, int length, int offset); 96 97 void dosmemget(int offset, int length, void *buffer) 98 { 99 win_mem_get(buffer, length, offset); 100 } 101 void dosmemput(const void *buffer, int length, int offset) 102 { 103 win_mem_put (buffer, length, offset); 104 } 105 106 #endif 107 108 #define SET_BYTE(x,y) { char _buf = y;dosmemput(&_buf,1, x);} 109 #define SET_WORD(x,y) { short _buf = y;dosmemput(&_buf,2, x);} 110 #define GET_BYTE(x) ( dosmemget(x,1,&bb), bb) 111 #define GET_WORD(x) ( dosmemget(x,2,&sb), sb) 112 113 static unsigned char bb; 114 static unsigned short sb; 115 116 117 static struct sw 118 { 119 int sw; 120 int addr; 121 } sigs[] = { 122 {0x14, 0xd0000}, 123 {0x15, 0xd4000}, 124 {0x16, 0xd8000}, 125 {0x17, 0xdc000}, 126 0}; 127 128 static int 129 e7000pc_init () 130 { 131 /* Look around in memory for the board's signature */ 132 133 int try; 134 135 for (try = 0; sigs[try].sw; try++) 136 137 { 138 int val; 139 board_at = sigs[try].addr; 140 fa = board_at + OFF_FA; 141 fb = board_at + OFF_FB; 142 cpd = board_at + OFF_CPD; 143 cdp = board_at + OFF_CDP; 144 ready =board_at + OFF_READY; 145 pon = board_at + OFF_PON; 146 irqtop = board_at + OFF_IRQTOP; 147 irqtod = board_at + OFF_IRQTOD; 148 149 val = GET_WORD (ready); 150 151 if (val == (0xaaa0 | sigs[try].sw)) 152 { 153 if (GET_BYTE (pon) & 0xf) 154 { 155 SET_BYTE(fa, 0); 156 SET_BYTE (fb, 0); 157 158 SET_BYTE (irqtop, 1); /* Disable interrupts from e7000 */ 159 SET_WORD (ready, 1); 160 printf_filtered ("\nConnected to the E7000PC at address 0x%x\n", 161 sigs[try].addr); 162 return 1; 163 } 164 error ("The E7000 PC board is working, but the E7000 is turned off.\n"); 165 return 0; 166 } 167 } 168 169 error ("GDB cannot connect to the E7000 PC board, check that it is installed\n\ 170 and that the switch settings are correct. Some other DOS programs can \n\ 171 stop the board from working. Try starting from a very minimal boot, \n\ 172 perhaps you need to disable EMM386 over the region where the board has\n\ 173 its I/O space, remove other unneeded cards, etc etc\n"); 174 return 0; 175 176 } 177 178 static int pbuf_size; 179 static int pbuf_index; 180 181 static 182 int 183 e7000_get () 184 { 185 static char pbuf[1000]; 186 char tmp[1000]; 187 int x; 188 if (pbuf_index < pbuf_size) 189 { 190 x = pbuf[pbuf_index++]; 191 } 192 else if ((GET_BYTE (fb) & 1)) 193 { 194 int i; 195 pbuf_size = GET_WORD(cdp + 2); 196 197 dosmemget (cdp + 8, pbuf_size + 1, tmp); 198 199 /* Tell the E7000 we've eaten */ 200 SET_BYTE(fb,0); 201 /* Swap it around */ 202 for (i = 0; i < pbuf_size; i++) 203 { 204 pbuf[i] = tmp[i^1]; 205 } 206 pbuf_index = 0; 207 x = pbuf[pbuf_index++]; 208 } 209 else 210 { 211 x = -1; 212 } 213 return x; 214 } 215 216 static int 217 dosasync_read (fd, buf, len, timeout) 218 int fd; 219 char *buf; 220 int len; 221 int timeout; 222 223 { 224 long now; 225 long then; 226 int i = 0; 227 int p; 228 229 /* Then look for some more if we're still hungry */ 230 time (&now); 231 then = now + timeout; 232 while (i < len) 233 { 234 int ch = e7000_get(); 235 236 /* While there's room in the buffer, and we've already 237 read the stuff in, suck it over */ 238 if (ch != -1) 239 { 240 buf[i++] = ch; 241 while (i < len && pbuf_index < pbuf_size ) 242 { 243 ch = e7000_get(); 244 if (ch == -1) 245 break; 246 buf[i++] = ch; 247 } 248 } 249 250 time (&now); 251 252 if (timeout == 0) 253 return i; 254 if (now >= then && timeout > 0) 255 { 256 return i; 257 } 258 } 259 return len; 260 } 261 262 263 static int 264 dosasync_write (fd, buf, len) 265 int fd; 266 const char *buf; 267 int len; 268 { 269 int i; 270 char dummy[1000]; 271 272 273 /* Construct copy locally */ 274 ((short *)dummy)[0] = CMD_CI; 275 ((short *)dummy)[1] = len; 276 ((short *)dummy)[2] = 0; 277 ((short *)dummy)[3] = 0; 278 for (i = 0; i < len ; i++) 279 { 280 dummy[8 + i ^ 1] = buf[i]; 281 } 282 283 /* Wait for the card to get ready */ 284 while ((GET_BYTE(fa) & 1) != 0) 285 ; 286 287 /* Blast onto the ISA card */ 288 dosmemput (dummy, 8 + len + 1, cpd); 289 290 SET_BYTE(fa, 1); 291 SET_BYTE(irqtod, 1); /* Interrupt the E7000 */ 292 293 return len; 294 } 295 296 static int 297 e7000pc_open (scb, name) 298 serial_t scb; 299 const char *name; 300 { 301 if (strncasecmp (name, "pc", 2) != 0) 302 { 303 errno = ENOENT; 304 return -1; 305 } 306 #ifdef __WIN32__ 307 if (win_load_e7kpc () != 0) 308 { 309 errno = ENOENT; 310 return -1; 311 } 312 #endif 313 scb->fd = e7000pc_init (); 314 315 if (!scb->fd) 316 return -1; 317 318 return 0; 319 } 320 321 static int 322 e7000pc_noop (scb) 323 serial_t scb; 324 { 325 return 0; 326 } 327 328 static void 329 e7000pc_raw (scb) 330 serial_t scb; 331 { 332 /* Always in raw mode */ 333 } 334 335 static int 336 e7000pc_readchar (scb, timeout) 337 serial_t scb; 338 int timeout; 339 { 340 char buf; 341 342 top: 343 344 if (dosasync_read (scb->fd, &buf, 1, timeout)) 345 { 346 if (buf == 0) goto top; 347 return buf; 348 } 349 else 350 return SERIAL_TIMEOUT; 351 } 352 353 struct e7000pc_ttystate { 354 int dummy; 355 }; 356 357 /* e7000pc_{get set}_tty_state() are both dummys to fill out the function 358 vector. Someday, they may do something real... */ 359 360 static serial_ttystate 361 e7000pc_get_tty_state (scb) 362 serial_t scb; 363 { 364 struct e7000pc_ttystate *state; 365 366 state = (struct e7000pc_ttystate *) xmalloc (sizeof *state); 367 368 return (serial_ttystate) state; 369 } 370 371 static int 372 e7000pc_set_tty_state (scb, ttystate) 373 serial_t scb; 374 serial_ttystate ttystate; 375 { 376 return 0; 377 } 378 379 static int 380 e7000pc_noflush_set_tty_state (scb, new_ttystate, old_ttystate) 381 serial_t scb; 382 serial_ttystate new_ttystate; 383 serial_ttystate old_ttystate; 384 { 385 return 0; 386 } 387 388 static void 389 e7000pc_print_tty_state (scb, ttystate) 390 serial_t scb; 391 serial_ttystate ttystate; 392 { 393 /* Nothing to print. */ 394 return; 395 } 396 397 static int 398 e7000pc_setbaudrate (scb, rate) 399 serial_t scb; 400 int rate; 401 { 402 return 0; 403 } 404 405 static int 406 e7000pc_write (scb, str, len) 407 serial_t scb; 408 const char *str; 409 int len; 410 { 411 dosasync_write (scb->fd, str, len); 412 413 return 0; 414 } 415 416 static void 417 e7000pc_close (scb) 418 serial_t scb; 419 { 420 #ifdef __WIN32__ 421 win_unload_e7kpc (); 422 #endif 423 } 424 425 static struct serial_ops e7000pc_ops = 426 { 427 "pc", 428 0, 429 e7000pc_open, 430 e7000pc_close, 431 e7000pc_readchar, 432 e7000pc_write, 433 e7000pc_noop, /* flush output */ 434 e7000pc_noop, /* flush input */ 435 e7000pc_noop, /* send break -- currently used only for nindy */ 436 e7000pc_raw, 437 e7000pc_get_tty_state, 438 e7000pc_set_tty_state, 439 e7000pc_print_tty_state, 440 e7000pc_noflush_set_tty_state, 441 e7000pc_setbaudrate, 442 }; 443 444 void 445 _initialize_ser_e7000pc () 446 { 447 serial_add_interface (&e7000pc_ops); 448 } 449 #else 450 451 void 452 _initialize_ser_e7000pc () 453 { 454 455 } 456 #endif 457