1 /* 2 * (C) Copyright 2007 Semihalf 3 * 4 * Written by: Rafal Jaworowski <raj@semihalf.com> 5 * 6 * See file CREDITS for list of people who contributed to this 7 * project. 8 * 9 * This program is free software; you can redistribute it and/or 10 * modify it under the terms of the GNU General Public License as 11 * published by the Free Software Foundation; either version 2 of 12 * the License, or (at your option) any later version. 13 * 14 * This program is distributed in the hope that it will be useful, 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 * GNU General Public License for more details. 18 * 19 * You should have received a copy of the GNU General Public License 20 * along with this program; if not, write to the Free Software 21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, 22 * MA 02111-1307 USA 23 * 24 */ 25 26 #include <config.h> 27 #include <command.h> 28 #include <common.h> 29 #include <malloc.h> 30 #include <environment.h> 31 #include <linux/types.h> 32 #include <api_public.h> 33 34 #include "api_private.h" 35 36 #define DEBUG 37 #undef DEBUG 38 39 /***************************************************************************** 40 * 41 * This is the API core. 42 * 43 * API_ functions are part of U-Boot code and constitute the lowest level 44 * calls: 45 * 46 * - they know what values they need as arguments 47 * - their direct return value pertains to the API_ "shell" itself (0 on 48 * success, some error code otherwise) 49 * - if the call returns a value it is buried within arguments 50 * 51 ****************************************************************************/ 52 53 #ifdef DEBUG 54 #define debugf(fmt, args...) do { printf("%s(): ", __func__); printf(fmt, ##args); } while (0) 55 #else 56 #define debugf(fmt, args...) 57 #endif 58 59 typedef int (*cfp_t)(va_list argp); 60 61 static int calls_no; 62 63 /* 64 * pseudo signature: 65 * 66 * int API_getc(int *c) 67 */ 68 static int API_getc(va_list ap) 69 { 70 int *c; 71 72 if ((c = (int *)va_arg(ap, u_int32_t)) == NULL) 73 return API_EINVAL; 74 75 *c = getc(); 76 return 0; 77 } 78 79 /* 80 * pseudo signature: 81 * 82 * int API_tstc(int *c) 83 */ 84 static int API_tstc(va_list ap) 85 { 86 int *t; 87 88 if ((t = (int *)va_arg(ap, u_int32_t)) == NULL) 89 return API_EINVAL; 90 91 *t = tstc(); 92 return 0; 93 } 94 95 /* 96 * pseudo signature: 97 * 98 * int API_putc(char *ch) 99 */ 100 static int API_putc(va_list ap) 101 { 102 char *c; 103 104 if ((c = (char *)va_arg(ap, u_int32_t)) == NULL) 105 return API_EINVAL; 106 107 putc(*c); 108 return 0; 109 } 110 111 /* 112 * pseudo signature: 113 * 114 * int API_puts(char **s) 115 */ 116 static int API_puts(va_list ap) 117 { 118 char *s; 119 120 if ((s = (char *)va_arg(ap, u_int32_t)) == NULL) 121 return API_EINVAL; 122 123 puts(s); 124 return 0; 125 } 126 127 /* 128 * pseudo signature: 129 * 130 * int API_reset(void) 131 */ 132 static int API_reset(va_list ap) 133 { 134 do_reset(NULL, 0, 0, NULL); 135 136 /* NOT REACHED */ 137 return 0; 138 } 139 140 /* 141 * pseudo signature: 142 * 143 * int API_get_sys_info(struct sys_info *si) 144 * 145 * fill out the sys_info struct containing selected parameters about the 146 * machine 147 */ 148 static int API_get_sys_info(va_list ap) 149 { 150 struct sys_info *si; 151 152 si = (struct sys_info *)va_arg(ap, u_int32_t); 153 if (si == NULL) 154 return API_ENOMEM; 155 156 return (platform_sys_info(si)) ? 0 : API_ENODEV; 157 } 158 159 /* 160 * pseudo signature: 161 * 162 * int API_udelay(unsigned long *udelay) 163 */ 164 static int API_udelay(va_list ap) 165 { 166 unsigned long *d; 167 168 if ((d = (unsigned long *)va_arg(ap, u_int32_t)) == NULL) 169 return API_EINVAL; 170 171 udelay(*d); 172 return 0; 173 } 174 175 /* 176 * pseudo signature: 177 * 178 * int API_get_timer(unsigned long *current, unsigned long *base) 179 */ 180 static int API_get_timer(va_list ap) 181 { 182 unsigned long *base, *cur; 183 184 cur = (unsigned long *)va_arg(ap, u_int32_t); 185 if (cur == NULL) 186 return API_EINVAL; 187 188 base = (unsigned long *)va_arg(ap, u_int32_t); 189 if (base == NULL) 190 return API_EINVAL; 191 192 *cur = get_timer(*base); 193 return 0; 194 } 195 196 197 /***************************************************************************** 198 * 199 * pseudo signature: 200 * 201 * int API_dev_enum(struct device_info *) 202 * 203 * 204 * cookies uniqely identify the previously enumerated device instance and 205 * provide a hint for what to inspect in current enum iteration: 206 * 207 * - net: ð_device struct address from list pointed to by eth_devices 208 * 209 * - storage: block_dev_desc_t struct address from &ide_dev_desc[n], 210 * &scsi_dev_desc[n] and similar tables 211 * 212 ****************************************************************************/ 213 214 static int API_dev_enum(va_list ap) 215 { 216 struct device_info *di; 217 218 /* arg is ptr to the device_info struct we are going to fill out */ 219 di = (struct device_info *)va_arg(ap, u_int32_t); 220 if (di == NULL) 221 return API_EINVAL; 222 223 if (di->cookie == NULL) { 224 /* start over - clean up enumeration */ 225 dev_enum_reset(); /* XXX shouldn't the name contain 'stor'? */ 226 debugf("RESTART ENUM\n"); 227 228 /* net device enumeration first */ 229 if (dev_enum_net(di)) 230 return 0; 231 } 232 233 /* 234 * The hidden assumption is there can only be one active network 235 * device and it is identified upon enumeration (re)start, so there's 236 * no point in trying to find network devices in other cases than the 237 * (re)start and hence the 'next' device can only be storage 238 */ 239 if (!dev_enum_storage(di)) 240 /* make sure we mark there are no more devices */ 241 di->cookie = NULL; 242 243 return 0; 244 } 245 246 247 static int API_dev_open(va_list ap) 248 { 249 struct device_info *di; 250 int err = 0; 251 252 /* arg is ptr to the device_info struct */ 253 di = (struct device_info *)va_arg(ap, u_int32_t); 254 if (di == NULL) 255 return API_EINVAL; 256 257 /* Allow only one consumer of the device at a time */ 258 if (di->state == DEV_STA_OPEN) 259 return API_EBUSY; 260 261 if (di->cookie == NULL) 262 return API_ENODEV; 263 264 if (di->type & DEV_TYP_STOR) 265 err = dev_open_stor(di->cookie); 266 267 else if (di->type & DEV_TYP_NET) 268 err = dev_open_net(di->cookie); 269 else 270 err = API_ENODEV; 271 272 if (!err) 273 di->state = DEV_STA_OPEN; 274 275 return err; 276 } 277 278 279 static int API_dev_close(va_list ap) 280 { 281 struct device_info *di; 282 int err = 0; 283 284 /* arg is ptr to the device_info struct */ 285 di = (struct device_info *)va_arg(ap, u_int32_t); 286 if (di == NULL) 287 return API_EINVAL; 288 289 if (di->state == DEV_STA_CLOSED) 290 return 0; 291 292 if (di->cookie == NULL) 293 return API_ENODEV; 294 295 if (di->type & DEV_TYP_STOR) 296 err = dev_close_stor(di->cookie); 297 298 else if (di->type & DEV_TYP_NET) 299 err = dev_close_net(di->cookie); 300 else 301 /* 302 * In case of unknown device we cannot change its state, so 303 * only return error code 304 */ 305 err = API_ENODEV; 306 307 if (!err) 308 di->state = DEV_STA_CLOSED; 309 310 return err; 311 } 312 313 314 /* 315 * Notice: this is for sending network packets only, as U-Boot does not 316 * support writing to storage at the moment (12.2007) 317 * 318 * pseudo signature: 319 * 320 * int API_dev_write( 321 * struct device_info *di, 322 * void *buf, 323 * int *len 324 * ) 325 * 326 * buf: ptr to buffer from where to get the data to send 327 * 328 * len: length of packet to be sent (in bytes) 329 * 330 */ 331 static int API_dev_write(va_list ap) 332 { 333 struct device_info *di; 334 void *buf; 335 int *len; 336 int err = 0; 337 338 /* 1. arg is ptr to the device_info struct */ 339 di = (struct device_info *)va_arg(ap, u_int32_t); 340 if (di == NULL) 341 return API_EINVAL; 342 343 /* XXX should we check if device is open? i.e. the ->state ? */ 344 345 if (di->cookie == NULL) 346 return API_ENODEV; 347 348 /* 2. arg is ptr to buffer from where to get data to write */ 349 buf = (void *)va_arg(ap, u_int32_t); 350 if (buf == NULL) 351 return API_EINVAL; 352 353 /* 3. arg is length of buffer */ 354 len = (int *)va_arg(ap, u_int32_t); 355 if (len == NULL) 356 return API_EINVAL; 357 if (*len <= 0) 358 return API_EINVAL; 359 360 if (di->type & DEV_TYP_STOR) 361 /* 362 * write to storage is currently not supported by U-Boot: 363 * no storage device implements block_write() method 364 */ 365 return API_ENODEV; 366 367 else if (di->type & DEV_TYP_NET) 368 err = dev_write_net(di->cookie, buf, *len); 369 else 370 err = API_ENODEV; 371 372 return err; 373 } 374 375 376 /* 377 * pseudo signature: 378 * 379 * int API_dev_read( 380 * struct device_info *di, 381 * void *buf, 382 * size_t *len, 383 * unsigned long *start 384 * size_t *act_len 385 * ) 386 * 387 * buf: ptr to buffer where to put the read data 388 * 389 * len: ptr to length to be read 390 * - network: len of packet to read (in bytes) 391 * - storage: # of blocks to read (can vary in size depending on define) 392 * 393 * start: ptr to start block (only used for storage devices, ignored for 394 * network) 395 * 396 * act_len: ptr to where to put the len actually read 397 */ 398 static int API_dev_read(va_list ap) 399 { 400 struct device_info *di; 401 void *buf; 402 lbasize_t *len_stor, *act_len_stor; 403 lbastart_t *start; 404 int *len_net, *act_len_net; 405 406 /* 1. arg is ptr to the device_info struct */ 407 di = (struct device_info *)va_arg(ap, u_int32_t); 408 if (di == NULL) 409 return API_EINVAL; 410 411 /* XXX should we check if device is open? i.e. the ->state ? */ 412 413 if (di->cookie == NULL) 414 return API_ENODEV; 415 416 /* 2. arg is ptr to buffer from where to put the read data */ 417 buf = (void *)va_arg(ap, u_int32_t); 418 if (buf == NULL) 419 return API_EINVAL; 420 421 if (di->type & DEV_TYP_STOR) { 422 /* 3. arg - ptr to var with # of blocks to read */ 423 len_stor = (lbasize_t *)va_arg(ap, u_int32_t); 424 if (!len_stor) 425 return API_EINVAL; 426 if (*len_stor <= 0) 427 return API_EINVAL; 428 429 /* 4. arg - ptr to var with start block */ 430 start = (lbastart_t *)va_arg(ap, u_int32_t); 431 432 /* 5. arg - ptr to var where to put the len actually read */ 433 act_len_stor = (lbasize_t *)va_arg(ap, u_int32_t); 434 if (!act_len_stor) 435 return API_EINVAL; 436 437 *act_len_stor = dev_read_stor(di->cookie, buf, *len_stor, *start); 438 439 } else if (di->type & DEV_TYP_NET) { 440 441 /* 3. arg points to the var with length of packet to read */ 442 len_net = (int *)va_arg(ap, u_int32_t); 443 if (!len_net) 444 return API_EINVAL; 445 if (*len_net <= 0) 446 return API_EINVAL; 447 448 /* 4. - ptr to var where to put the len actually read */ 449 act_len_net = (int *)va_arg(ap, u_int32_t); 450 if (!act_len_net) 451 return API_EINVAL; 452 453 *act_len_net = dev_read_net(di->cookie, buf, *len_net); 454 455 } else 456 return API_ENODEV; 457 458 return 0; 459 } 460 461 462 /* 463 * pseudo signature: 464 * 465 * int API_env_get(const char *name, char **value) 466 * 467 * name: ptr to name of env var 468 */ 469 static int API_env_get(va_list ap) 470 { 471 char *name, **value; 472 473 if ((name = (char *)va_arg(ap, u_int32_t)) == NULL) 474 return API_EINVAL; 475 if ((value = (char **)va_arg(ap, u_int32_t)) == NULL) 476 return API_EINVAL; 477 478 *value = getenv(name); 479 480 return 0; 481 } 482 483 /* 484 * pseudo signature: 485 * 486 * int API_env_set(const char *name, const char *value) 487 * 488 * name: ptr to name of env var 489 * 490 * value: ptr to value to be set 491 */ 492 static int API_env_set(va_list ap) 493 { 494 char *name, *value; 495 496 if ((name = (char *)va_arg(ap, u_int32_t)) == NULL) 497 return API_EINVAL; 498 if ((value = (char *)va_arg(ap, u_int32_t)) == NULL) 499 return API_EINVAL; 500 501 setenv(name, value); 502 503 return 0; 504 } 505 506 /* 507 * pseudo signature: 508 * 509 * int API_env_enum(const char *last, char **next) 510 * 511 * last: ptr to name of env var found in last iteration 512 */ 513 static int API_env_enum(va_list ap) 514 { 515 int i, n; 516 char *last, **next; 517 518 last = (char *)va_arg(ap, u_int32_t); 519 520 if ((next = (char **)va_arg(ap, u_int32_t)) == NULL) 521 return API_EINVAL; 522 523 if (last == NULL) 524 /* start over */ 525 *next = ((char *)env_get_addr(0)); 526 else { 527 *next = last; 528 529 for (i = 0; env_get_char(i) != '\0'; i = n + 1) { 530 for (n = i; env_get_char(n) != '\0'; ++n) { 531 if (n >= CONFIG_ENV_SIZE) { 532 /* XXX shouldn't we set *next = NULL?? */ 533 return 0; 534 } 535 } 536 537 if (envmatch((uchar *)last, i) < 0) 538 continue; 539 540 /* try to get next name */ 541 i = n + 1; 542 if (env_get_char(i) == '\0') { 543 /* no more left */ 544 *next = NULL; 545 return 0; 546 } 547 548 *next = ((char *)env_get_addr(i)); 549 return 0; 550 } 551 } 552 553 return 0; 554 } 555 556 /* 557 * pseudo signature: 558 * 559 * int API_display_get_info(int type, struct display_info *di) 560 */ 561 static int API_display_get_info(va_list ap) 562 { 563 int type; 564 struct display_info *di; 565 566 type = va_arg(ap, int); 567 di = va_arg(ap, struct display_info *); 568 569 return display_get_info(type, di); 570 } 571 572 /* 573 * pseudo signature: 574 * 575 * int API_display_draw_bitmap(ulong bitmap, int x, int y) 576 */ 577 static int API_display_draw_bitmap(va_list ap) 578 { 579 ulong bitmap; 580 int x, y; 581 582 bitmap = va_arg(ap, ulong); 583 x = va_arg(ap, int); 584 y = va_arg(ap, int); 585 586 return display_draw_bitmap(bitmap, x, y); 587 } 588 589 /* 590 * pseudo signature: 591 * 592 * void API_display_clear(void) 593 */ 594 static int API_display_clear(va_list ap) 595 { 596 display_clear(); 597 return 0; 598 } 599 600 static cfp_t calls_table[API_MAXCALL] = { NULL, }; 601 602 /* 603 * The main syscall entry point - this is not reentrant, only one call is 604 * serviced until finished. 605 * 606 * e.g. syscall(1, int *, u_int32_t, u_int32_t, u_int32_t, u_int32_t); 607 * 608 * call: syscall number 609 * 610 * retval: points to the return value placeholder, this is the place the 611 * syscall puts its return value, if NULL the caller does not 612 * expect a return value 613 * 614 * ... syscall arguments (variable number) 615 * 616 * returns: 0 if the call not found, 1 if serviced 617 */ 618 int syscall(int call, int *retval, ...) 619 { 620 va_list ap; 621 int rv; 622 623 if (call < 0 || call >= calls_no) { 624 debugf("invalid call #%d\n", call); 625 return 0; 626 } 627 628 if (calls_table[call] == NULL) { 629 debugf("syscall #%d does not have a handler\n", call); 630 return 0; 631 } 632 633 va_start(ap, retval); 634 rv = calls_table[call](ap); 635 if (retval != NULL) 636 *retval = rv; 637 638 return 1; 639 } 640 641 void api_init(void) 642 { 643 struct api_signature *sig = NULL; 644 645 /* TODO put this into linker set one day... */ 646 calls_table[API_RSVD] = NULL; 647 calls_table[API_GETC] = &API_getc; 648 calls_table[API_PUTC] = &API_putc; 649 calls_table[API_TSTC] = &API_tstc; 650 calls_table[API_PUTS] = &API_puts; 651 calls_table[API_RESET] = &API_reset; 652 calls_table[API_GET_SYS_INFO] = &API_get_sys_info; 653 calls_table[API_UDELAY] = &API_udelay; 654 calls_table[API_GET_TIMER] = &API_get_timer; 655 calls_table[API_DEV_ENUM] = &API_dev_enum; 656 calls_table[API_DEV_OPEN] = &API_dev_open; 657 calls_table[API_DEV_CLOSE] = &API_dev_close; 658 calls_table[API_DEV_READ] = &API_dev_read; 659 calls_table[API_DEV_WRITE] = &API_dev_write; 660 calls_table[API_ENV_GET] = &API_env_get; 661 calls_table[API_ENV_SET] = &API_env_set; 662 calls_table[API_ENV_ENUM] = &API_env_enum; 663 calls_table[API_DISPLAY_GET_INFO] = &API_display_get_info; 664 calls_table[API_DISPLAY_DRAW_BITMAP] = &API_display_draw_bitmap; 665 calls_table[API_DISPLAY_CLEAR] = &API_display_clear; 666 calls_no = API_MAXCALL; 667 668 debugf("API initialized with %d calls\n", calls_no); 669 670 dev_stor_init(); 671 672 /* 673 * Produce the signature so the API consumers can find it 674 */ 675 sig = malloc(sizeof(struct api_signature)); 676 if (sig == NULL) { 677 printf("API: could not allocate memory for the signature!\n"); 678 return; 679 } 680 681 debugf("API sig @ 0x%08x\n", sig); 682 memcpy(sig->magic, API_SIG_MAGIC, 8); 683 sig->version = API_SIG_VERSION; 684 sig->syscall = &syscall; 685 sig->checksum = 0; 686 sig->checksum = crc32(0, (unsigned char *)sig, 687 sizeof(struct api_signature)); 688 debugf("syscall entry: 0x%08x\n", sig->syscall); 689 } 690 691 void platform_set_mr(struct sys_info *si, unsigned long start, unsigned long size, 692 int flags) 693 { 694 int i; 695 696 if (!si->mr || !size || (flags == 0)) 697 return; 698 699 /* find free slot */ 700 for (i = 0; i < si->mr_no; i++) 701 if (si->mr[i].flags == 0) { 702 /* insert new mem region */ 703 si->mr[i].start = start; 704 si->mr[i].size = size; 705 si->mr[i].flags = flags; 706 return; 707 } 708 } 709