Changeset 572


Ignore:
Timestamp:
Oct 5, 2018, 12:20:34 AM (3 years ago)
Author:
alain
Message:

Introduce the cluster_info[x][y] in the boot_info.h structure for the TSAR architecture.

Location:
trunk/boot/tsar_mips32
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • trunk/boot/tsar_mips32/Makefile

    r557 r572  
    2323# Objects to be linked for boot.elf generation
    2424BOOT_OBJS       = build/boot.o            \
    25                 build/boot_fat32.o      \
    26                 build/boot_utils.o      \
    27                 build/boot_spi_utils.o \
    28                 build/boot_entry.o      \
    29                 build/boot_tty_driver.o \
    30                 build/boot_hba_driver.o \
    31                 build/boot_bdv_driver.o \
    32                 build/boot_spi_driver.o \
    33                 build/boot_mmc_driver.o
     25              build/boot_fat32.o      \
     26              build/boot_utils.o      \
     27              build/boot_entry.o      \
     28              build/boot_tty_driver.o \
     29              build/boot_hba_driver.o \
     30              build/boot_bdv_driver.o \
     31              build/boot_mmc_driver.o   
    3432
    3533# List of directories to be searched for included files
    3634# when compiling for boot.elf generation
    37 BOOT_INCLUDE = -I.  \
    38                 -I../../tools/arch_info/        \
    39                 -I$(HAL_ARCH)/core   \
    40                 -I../.. \
    41                 -I$(KERNEL) \
     35BOOT_INCLUDE = -I.               \
     36                -I../../tools/arch_info  \
     37                -I$(HAL_ARCH)/core       \
     38                -I../..                  \
     39                -I$(KERNEL)              \
    4240                -I$(KERNEL)/kern
    4341
     
    5856################################################
    5957# Rules to compile boot drivers used by boot.elf
    60 build/boot_tty_driver.o:        boot_tty_driver.c \
    61                                                                 boot_tty_driver.h \
    62                                                                 boot_utils.h      \
    63                                                                 boot_config.h     \
    64                                                                 $(HAL_ARCH)/core/hal_kernel_types.h        \
    65                                                                 ../../hard_config.h
     58build/boot_tty_driver.o: boot_tty_driver.c                  \
     59                         boot_tty_driver.h                  \
     60                         boot_utils.h                        \
     61                         boot_config.h                       \
     62                                                 $(HAL_ARCH)/core/hal_kernel_types.h \
     63                                                 ../../hard_config.h
    6664        $(CC) $(BOOT_INCLUDE) $(CFLAGS) -c -o $@ $<
    6765        $(DU) -D $@ > $@.txt
  • trunk/boot/tsar_mips32/boot.c

    r562 r572  
    22 * boot.c - TSAR bootloader implementation.
    33 *
    4  * Authors :   Alain Greiner / Vu Son  (2016)
     4 * Authors :   Vu Son  (2016)
     5 *             Alain Greiner (2016, 2017,2018)
    56 *
    67 * Copyright (c) UPMC Sorbonne Universites
     
    5556 *      - activate all other cores in the same cluster (CPi).               *
    5657 *      - wait local CPi completion reports on a local barrier.             *
    57  *      - report completion to bscpu on the global barrier.                 *
     58 *      - report completion  on the global barrier.                         *
    5859 *                                                                          *
    5960 * 3) The boot-loader third phase is executed in parallel by all cores.     *
    60  *    After passing the global barrier the bscpu:                           *
    61  *      - activates the CPi of cluster(0),                                  *
     61 *    In each cluster (i) the CP0                                           *
     62 *      - activates the other cores of cluster(i),                          *
    6263 *      - blocks on the local barrier waiting for all local CPi to report   *
    6364 *        completion on the local barrier,                                  *
     
    6566 *        address 0x0, (erasing the preloader code).                        *
    6667 *                                                                          *
    67  * 4) All cores have finished the boot phase, they jump to the kern_init()  *
    68  *    function (maybe not at the same time).                                *
     68 * 4) All cores jump to kern_init() (maybe not at the same time).           *
    6969 ****************************************************************************/
    7070
     
    7777#include <arch_info.h>
    7878#include <boot_info.h>
    79 
    80 #include <cluster_info.h>
    8179
    8280#include <boot_utils.h>
     
    8482#include <boot_bdv_driver.h>
    8583#include <boot_hba_driver.h>
    86 #include <boot_spi_driver.h>
    8784#include <boot_tty_driver.h>
    8885
     
    117114uint32_t                        kernel_entry;    // kernel entry point
    118115
    119 // address used by the WTI to activate remote CP0s
    120 
    121 // Functions called by boot_entry.S must be externs.
     116// Functions called by boot_entry.S
     117
    122118extern void boot_entry( void );    // boot_loader entry point
    123119extern void boot_loader( lid_t lid, cxy_t cxy );
    124120
     121
     122#if DEBUG_BOOT_INFO
    125123/*********************************************************************************
    126  * This function returns the printable string for each device type
     124 * This debug function returns the printable string for each device type.
    127125 ********************************************************************************/
    128 static const char * device_type_str( boot_device_types_t dev_type ) {
    129     switch (dev_type) {
     126static char * device_type_str( enum device_types_e dev_type )
     127{
     128    switch ( dev_type )
     129    {
    130130        case DEV_TYPE_RAM_SCL: return "RAM_SCL";
    131131        case DEV_TYPE_ROM_SCL: return "ROM_SCL";
     
    148148    }
    149149}
     150#endif
    150151
    151152/************************************************************************************
     
    160161    {
    161162        boot_printf("\n[BOOT ERROR]: boot_archinfo_load(): "
    162                     "<%s> file not found\n",
    163                     ARCHINFO_PATHNAME);
     163        "<%s> file not found\n",
     164        ARCHINFO_PATHNAME);
    164165        boot_exit();
    165166    }
     
    168169    {
    169170        boot_printf("\n[BOOT_ERROR]: boot_archinfo_load(): "
    170                     "<%s> file signature should be %x\n",
    171                     ARCHINFO_PATHNAME, ARCHINFO_SIGNATURE);
     171        "<%s> file signature should be %x\n",
     172        ARCHINFO_PATHNAME, ARCHINFO_SIGNATURE);
    172173        boot_exit();
    173174    }
     
    175176#if DEBUG_BOOT_INFO
    176177boot_printf("\n[BOOT INFO] in %s : file %s loaded at address = %x\n",
    177             __FUNCTION__ , ARCHINFO_PATHNAME , ARCHINFO_BASE );
     178__FUNCTION__ , ARCHINFO_PATHNAME , ARCHINFO_BASE );
    178179#endif
    179180
     
    204205#if DEBUG_BOOT_ELF
    205206boot_printf("\n[BOOT INFO] %s enters for file %s at cycle %d\n",
    206             __FUNCTION__ , KERNEL_PATHNAME , boot_get_proctime() );
     207__FUNCTION__ , KERNEL_PATHNAME , boot_get_proctime() );
    207208#endif
    208209
     
    261262#if DEBUG_BOOT_ELF
    262263boot_printf("\n[BOOT INFO] in %s for file %s : found loadable segment\n"
    263             "   base = %x / size = %x\n",
    264             __FUNCTION__ , KERNEL_PATHNAME , seg_paddr , seg_memsz );
     264"   base = %x / size = %x\n",
     265__FUNCTION__ , KERNEL_PATHNAME , seg_paddr , seg_memsz );
    265266#endif
    266267
     
    282283                {
    283284                    boot_printf("\n[BOOT_ERROR] in %s for file %s :\n"
    284                                 "   two kcode segments found\n",
    285                                 __FUNCTION__ , KERNEL_PATHNAME );
     285                    "   two kcode segments found\n",
     286                    __FUNCTION__ , KERNEL_PATHNAME );
    286287                    boot_exit();
    287288                }
     
    296297                {
    297298                    boot_printf("\n[BOOT_ERROR] in %s for file %s :\n"
    298                                 "   two kentry segments found\n",
    299                                 __FUNCTION__ , KERNEL_PATHNAME );
     299                    "   two kentry segments found\n",
     300                    __FUNCTION__ , KERNEL_PATHNAME );
    300301                    boot_exit();
    301302                }
     
    310311                {
    311312                    boot_printf("\n[BOOT_ERROR] in %s for file %s :\n"
    312                                 "   two loadable kdata segments found\n",
    313                                 __FUNCTION__ , KERNEL_PATHNAME );
     313                    "   two kdata segments found\n",
     314                    __FUNCTION__ , KERNEL_PATHNAME );
    314315                    boot_exit();
    315316                }
     
    326327    {
    327328        boot_printf("\n[BOOT_ERROR] in %s for file %s : seg_kcode not found\n",
    328                     __FUNCTION__ , KERNEL_PATHNAME );
     329        __FUNCTION__ , KERNEL_PATHNAME );
    329330        boot_exit();
    330331    }
     
    332333    {
    333334        boot_printf("\n[BOOT_ERROR] in %s for file %s : seg_kentry not found\n",
    334                     __FUNCTION__ , KERNEL_PATHNAME );
     335        __FUNCTION__ , KERNEL_PATHNAME );
    335336        boot_exit();
    336337    }
     
    338339    {
    339340        boot_printf("\n[BOOT_ERROR] in %s for file %s : seg_kdata not found\n",
    340                     __FUNCTION__ , KERNEL_PATHNAME );
     341        __FUNCTION__ , KERNEL_PATHNAME );
    341342        boot_exit();
    342343    }
     
    346347    {
    347348        boot_printf("\n[BOOT_ERROR] in %s for file %s : seg_kentry too large\n",
    348                     __FUNCTION__ , KERNEL_PATHNAME );
     349        __FUNCTION__ , KERNEL_PATHNAME );
    349350        boot_exit();
    350351    }
     
    353354    {
    354355        boot_printf("\n[BOOT_ERROR] in %s for file %s : seg_kcode + seg_kdata too large\n",
    355                     __FUNCTION__ , KERNEL_PATHNAME );
     356        __FUNCTION__ , KERNEL_PATHNAME );
    356357    }
    357358
     
    361362#if DEBUG_BOOT_ELF
    362363boot_printf("\n[BOOT INFO] %s completed for file %s at cycle %d\n",
    363             __FUNCTION__ , KERNEL_PATHNAME , boot_get_proctime() );
     364__FUNCTION__ , KERNEL_PATHNAME , boot_get_proctime() );
    364365#endif
    365366
     
    382383    archinfo_cluster_t * cluster;
    383384    archinfo_cluster_t * my_cluster = NULL;   // target cluster
    384     archinfo_cluster_t * io_cluster = NULL;   // cluster containing ext. peripherals
     385    archinfo_cluster_t * io_cluster = NULL;   // external peripherals cluster
    385386
    386387    archinfo_core_t    * core;
     
    416417    boot_info->kentry_size = seg_kentry_size;
    417418
    418     /* Initialize all clusters as empty for now */
    419     int x, y;
    420     for ( x = 0; x < CONFIG_MAX_CLUSTERS_X; x++)
    421     {
    422         for ( x = 0; x < CONFIG_MAX_CLUSTERS_X; x++)
    423         {
    424             boot_info->cluster_info[x][y] = 0x0;
    425         }
    426     }
    427 
    428     // loop on arch_info clusters to get relevant pointers
     419    // loop on arch_info clusters to build cluster_info[][] array
     420    // and get io_cluster and my_cluster pointers
    429421    for (cluster =  cluster_base;
    430422         cluster < &cluster_base[header->x_size * header->y_size];
     
    433425        int x = cluster->cxy >> Y_WIDTH;
    434426        int y = cluster->cxy & ((1 << Y_WIDTH) - 1);
    435 
    436         if( cluster->cxy  == cxy )            my_cluster = cluster;
    437         if( cluster->cxy  == header->io_cxy ) {
    438             io_cluster = cluster;
    439             boot_info->cluster_info[x][y] |= CINFO_IS_IO;
    440         }
    441         if ( cluster->cores > 0 ) {
    442             boot_info->cluster_info[x][y] |= CINFO_ACTIVE;
    443         }
     427        boot_info->cluster_info[x][y] = (uint8_t)cluster->cores;
     428
     429        if( cluster->cxy == cxy )            my_cluster = cluster;
     430        if( cluster->cxy == header->io_cxy ) io_cluster = cluster;
    444431    }
    445432
     
    447434    {
    448435        boot_printf("\n[ERROR] in %s : cannot found cluster %x in arch_info\n",
    449                     __FUNCTION__ , cxy );
     436        __FUNCTION__ , cxy );
    450437        boot_exit();
    451438    }
     
    454441    {
    455442        boot_printf("\n[ERROR] in %s : cannot found io_cluster %x in arch_info\n",
    456                     __FUNCTION__ , header->io_cxy );
     443        __FUNCTION__ , cxy );
    457444        boot_exit();
    458445    }
     
    463450#if DEBUG_BOOT_INFO
    464451boot_printf("\n[BOOT INFO] %s : external peripherals at cycle %d\n",
    465             __FUNCTION__ , boot_get_proctime() );
     452__FUNCTION__ , boot_get_proctime() );
    466453#endif
    467454
     
    474461        {
    475462            boot_printf("\n[ERROR] in %s : too much external devices in arch_info\n",
    476                         __FUNCTION__ );
     463            __FUNCTION__ );
    477464            boot_exit();
    478465        }
     
    501488#if DEBUG_BOOT_INFO
    502489boot_printf("  - %s : base = %l / size = %l / channels = %d / irqs = %d\n",
    503             device_type_str( device->type ) , device->base , device->size ,
    504             device->channels , device->irqs );   
     490device_type_str(device->type), device->base, device->size, device->channels, device->irqs );
    505491#endif
    506492        }
     
    525511#if DEBUG_BOOT_INFO
    526512boot_printf("    . irq_port = %d / source = %s / channel = %d / is_rx = %d\n",
    527             irq->port , device_type_str( irq->dev_type ) , irq->channel , irq->is_rx );
     513irq->port , device_type_str( irq->dev_type ) , irq->channel , irq->is_rx );
    528514#endif
    529515            }
     
    554540#if DEBUG_BOOT_INFO
    555541boot_printf("  - core_gid = %x : cxy = %x / lid = %d\n",
    556             core->gid , core->cxy , core->lid );
     542core->gid , core->cxy , core->lid );
    557543#endif
    558544        core_id++;
     
    566552
    567553#if DEBUG_BOOT_INFO
    568 boot_printf("\n[BOOT INFO] %s : internal peripherals in cluster %x\n", __FUNCTION__ , cxy );
     554boot_printf("\n[BOOT INFO] %s : internal peripherals in cluster %x\n",
     555__FUNCTION__ , cxy );
    569556#endif
    570557
     
    615602#if DEBUG_BOOT_INFO
    616603boot_printf("  - %s : base = %l / size = %l / channels = %d / irqs = %d\n",
    617             device_type_str( device->type ) , device->base , device->size ,
    618             device->channels , device->irqs );   
     604device_type_str( device->type ) , device->base , device->size ,
     605device->channels , device->irqs );   
    619606#endif
    620607
     
    637624#if DEBUG_BOOT_INFO
    638625boot_printf("    . irq_port = %d / source = %s / channel = %d / is_rx = %d\n",
    639             irq->port , device_type_str( irq->dev_type ) , irq->channel , irq->is_rx );
     626irq->port , device_type_str( irq->dev_type ) , irq->channel , irq->is_rx );
    640627#endif
    641628
     
    656643                 (end >> CONFIG_PPM_PAGE_SHIFT) : (end >> CONFIG_PPM_PAGE_SHIFT) + 1;
    657644
    658     // no reserved sones for TSAR architecture
     645    // no reserved zones for TSAR architecture
    659646    boot_info->rsvd_nr = 0;
    660647
     
    738725#if DEBUG_BOOT_WAKUP
    739726boot_printf("\n[BOOT] core[%x,0] activated at cycle %d\n",
    740             cluster->cxy , boot_get_proctime );
     727cluster->cxy , boot_get_proctime );
    741728#endif
    742729
     
    767754#if DEBUG_BOOT_WAKUP
    768755boot_printf("\n[BOOT] core[%x,%d] activated at cycle %d\n",
    769              boot_info->cxy , core_id , boot_get_proctime() );
     756boot_info->cxy , core_id , boot_get_proctime() );
    770757#endif
    771758        // send an IPI
     
    801788            else if (USE_IOC_HBA) boot_hba_init();
    802789            // else if (USE_IOC_SDC) boot_sdc_init();
    803             else if (USE_IOC_SPI) boot_spi_init();
     790            // else if (USE_IOC_SPI) boot_spi_init();
    804791            else if (!USE_IOC_RDK)
    805792            {
     
    816803
    817804            boot_printf("\n[BOOT] core[%x,%d] loaded kernel at cycle %d\n",
    818                         cxy , lid , boot_get_proctime() );
     805            cxy , lid , boot_get_proctime() );
    819806
    820807            // Load the arch_info.bin file into memory.
    821808            boot_archinfo_load();
     809
     810            boot_printf("\n[BOOT] core[%x,%d] loaded arch_info at cycle %d\n",
     811            cxy , lid , boot_get_proctime() );
    822812
    823813            // Get local boot_info_t structure base address.
     
    827817            // Initialize local boot_info_t structure.
    828818            boot_info_init( boot_info , cxy );
     819
     820            boot_printf("\n[BOOT] core[%x,%d] initialised boot_info at cycle %d\n",
     821            cxy , lid , boot_get_proctime() );
    829822
    830823            // check boot_info signature
     
    832825            {
    833826                boot_printf("\n[BOOT ERROR] in %s reported by core[%x,%d]\n"
    834                             "  illegal boot_info signature / should be %x\n",
    835                             __FUNCTION__ , cxy , lid , BOOT_INFO_SIGNATURE );
     827                "  illegal boot_info signature / should be %x\n",
     828                __FUNCTION__ , cxy , lid , BOOT_INFO_SIGNATURE );
    836829                boot_exit();
    837830            }
    838 
    839             boot_printf("\n[BOOT] core[%x,%d] loaded arch_info at cycle %d\n",
    840                         cxy , lid , boot_get_proctime() );
    841831
    842832            // Check core information.
     
    881871            // from now, it is safe to refer to the boot code global variables
    882872            boot_printf("\n[BOOT] core[%x,%d] replicated boot code at cycle %d\n",
    883                         cxy , lid , boot_get_proctime() );
     873            cxy , lid , boot_get_proctime() );
    884874
    885875                        // switch to the INSTRUCTION local memory space, to avoid contention.
     
    892882
    893883            boot_printf("\n[BOOT] core[%x,%d] replicated arch_info at cycle %d\n",
    894                         cxy , lid , boot_get_proctime() );
     884            cxy , lid , boot_get_proctime() );
    895885
    896886            // Copy the kcode segment into local memory
     
    910900
    911901            boot_printf("\n[BOOT] core[%x,%d] replicated kernel code at cycle %d\n",
    912                         cxy , lid , boot_get_proctime() );
     902            cxy , lid , boot_get_proctime() );
    913903
    914904            // Get local boot_info_t structure base address.
     
    917907            // Initialize local boot_info_t structure.
    918908            boot_info_init( boot_info , cxy );
     909
     910            boot_printf("\n[BOOT] core[%x,%d] initialised boot_info at cycle %d\n",
     911            cxy , lid , boot_get_proctime() );
    919912
    920913            // Check core information.
  • trunk/boot/tsar_mips32/boot.ld

    r544 r572  
    66/* define the boot code base address */
    77
    8 boot_code_base = 0x900000;
     8boot_code_base = 0x100000;
    99
    1010/* Set the entry point of the boot-loader (e_entry field in the "boot.elf" file header) */
  • trunk/boot/tsar_mips32/boot_config.h

    r549 r572  
    2121// Preloader temporary segment
    2222#define PRELOADER_BASE      0x00000000      // 'preloader' physical base address
    23 #define PRELOADER_MAX_SIZE  0x00804000      // 'preloader' max size
     23#define PRELOADER_MAX_SIZE  0x00004000      // 'preloader' max size
    2424
    2525// kentry segment
    26 #define KENTRY_BASE         0x00804000      // 'kentry' segment physical base address       
     26#define KENTRY_BASE         0x00004000      // 'kentry' segment physical base address       
    2727#define KENTRY_MAX_SIZE     0x00004000      // 'kentry' segment max size
    2828
    2929// kcode segment
    30 #define KCODE_BASE          0x00808000      // 'kcode' segment physical base address
     30#define KCODE_BASE          0x00008000      // 'kcode' segment physical base address
    3131#define KCODE_MAX_SIZE      0x000F8000      // 'kcode' + 'kdata' segments max size
    3232
    3333// boot.elf file temporary buffer
    34 #define BOOT_BASE           0x00900000      // 'boot.elf' file physical base address   
     34#define BOOT_BASE           0x00100000      // 'boot.elf' file physical base address   
    3535#define BOOT_MAX_SIZE       0x00010000      // 'boot.elf' file max size
    3636
    3737// arch_info file temporary buffer
    38 #define ARCHINFO_BASE       0x00A00000      // 'arch_info.bin' file physical base address
     38#define ARCHINFO_BASE       0x00200000      // 'arch_info.bin' file physical base address
    3939#define ARCHINFO_MAX_SIZE   0x00010000      // 'arch_info.bin' file max size
    4040
    4141// kernel.elf file temporary buffer
    42 #define KERN_BASE           0x00B00000      // 'kernel.elf' file base address
     42#define KERN_BASE           0x00300000      // 'kernel.elf' file base address
    4343#define KERN_MAX_SIZE       0x00200000      // 'kernel.elf' file max size
    4444
    4545// Temporary stacks segments
    46 #define BOOT_STACK_BASE     0x00D04000      // Boot stack base address
     46#define BOOT_STACK_BASE     0x00504000      // Boot stack base address
    4747#define BOOT_STACK_SIZE     0x00004000      // Boot stack size (16Kb)
    4848
  • trunk/boot/tsar_mips32/boot_fat32.c

    r547 r572  
    66#include <boot_tty_driver.h>
    77#include <boot_bdv_driver.h>
    8 #include <boot_spi_driver.h>
    98#include <boot_hba_driver.h>
    109#include <boot_mmc_driver.h>
    1110
    1211/*
     12#include <boot_spi_driver.h>
    1313#include <boot_sdc_driver.h>
    1414#include <boot_rdk_driver.h>
     
    3737
    3838/****************************************************************************
    39  *                           Internal functions.                            *
    40  ****************************************************************************/
    41 
    42 /****************************************************************************
    43  * This function returns the offset (in bytes) of the field defined by      *
    44  * 'offset' and 'size'.                                                     *
    45  * @ offset : offset of the field from the beginning of the sector (in      *
    46  *            bytes).                                                       *
    47  * @ size   : length of the field (in bytes).                               *
    48  *                                                                          *
    49  * @ returns the field offset.                                              *
    50  ****************************************************************************/
    51 static inline
    52 int get_offset(
    53     int offset,
    54     int size __attribute__ ((unused)))
    55 {
    56     return offset;
    57 } // get_offset()
    58 
    59 /****************************************************************************
    60  * This function returns the length (in bytes) of the field defined by      *
    61  * 'offset' and 'size'.                                                     *
    62  * @ offset : offset of the field from the beginning of the sector (in      *
    63  *            bytes).                                                       *
    64  * @ size   : length of the field (in bytes).                               *
    65  *                                                                          *
    66  * @ returns the field length.                                              *
    67  ****************************************************************************/
    68 static inline
    69 int get_size(
    70     int offset __attribute__ ((unused)),
    71     int size)
    72 {
    73     return size;
    74 } // get_size()
     39 *                           Internal functions & macros.                   *
     40 ****************************************************************************/
     41
     42/****************************************************************************
     43 * These functions return the first or second argument from a couple        *
     44 * of arguments ( offset , size ) used to define a data field               *         
     45 * in a buffer of bytes: offset is the first byte index in buffer,          *
     46 * size is the field length in bytes.                                       *
     47 ****************************************************************************/
     48
     49static inline int get_offset( int offset, int size __attribute__((unused)) ) { return offset; }
     50
     51static inline int get_size( int offset __attribute__((unused)) , int size ) { return size; }
    7552
    7653/****************************************************************************
  • trunk/boot/tsar_mips32/boot_tty_driver.c

    r556 r572  
    4343#endif
    4444
    45 #ifndef TXT_TGT_CLUSTER
    46 # error "The TXT_TGT_CLUSTER value should be defined in the 'hard_config.h' file"
    47 #endif
    48 
    4945/////////////////////////////////////////////////////////////////////////////
    5046// This function returns the value contained in a TTY0 register.
     
    5450static uint32_t boot_tty_get_register( uint32_t reg )
    5551{
    56     cxy_t      cxy = TXT_TGT_CLUSTER;
     52    cxy_t      cxy = (X_IO << Y_WIDTH) + Y_IO;
    5753    uint32_t * ptr = (uint32_t *)SEG_TXT_BASE + reg;
    5854   
     
    6965                                   uint32_t val )
    7066{
    71     cxy_t      cxy = TXT_TGT_CLUSTER;
     67    cxy_t      cxy = (X_IO << Y_WIDTH) + Y_IO;
    7268    uint32_t * ptr = (uint32_t *)SEG_TXT_BASE + reg;
    7369
     
    7672} // boot_tty_set_register()
    7773
    78 //////////////////////////////////
     74/////////////////////////////////////
    7975int boot_tty_write( const char * buf,
    8076                    uint32_t     nbytes )
Note: See TracChangeset for help on using the changeset viewer.