Changeset 283 for branch


Ignore:
Timestamp:
Jan 31, 2014, 11:35:57 AM (10 years ago)
Author:
cfuguet
Message:

Introducing branch to test ioc drivers before merging on trunk

Location:
branch
Files:
8 added
13 edited
1 copied

Legend:

Unmodified
Added
Removed

  • branch/giet_vm_ioc_drivers/Makefile

    r272 r283  
    1111### partition sectors    = 524832
    1212
    13 MAP_XML      = mappings/4c_1p_iob_four.xml
     13MAP_XML      = mappings/4c_1p_four.xml
    1414
    1515### Objects to be linked for kernel.elf
    … …  
    2222               build/drivers/icu_driver.o \
    2323               build/drivers/ioc_driver.o \
     24               build/drivers/bdv_driver.o \
     25               build/drivers/sdc_driver.o \
     26               build/drivers/spi_driver.o \
    2427               build/drivers/iob_driver.o \
    2528               build/drivers/mmc_driver.o \
    … …  
    4548               build/drivers/mwr_driver.o \
    4649               build/drivers/ioc_driver.o \
     50               build/drivers/bdv_driver.o \
     51               build/drivers/sdc_driver.o \
     52               build/drivers/spi_driver.o \
    4753               build/drivers/nic_driver.o \
    4854               build/drivers/mmc_driver.o \
    … …  
    8995
    9096
    91 CFLAGS = -Wall -ffreestanding -mno-gpopt -mips32
     97CFLAGS = -Wall -ffreestanding -mno-gpopt -mips32# -O3 -fno-inline
     98
    9299
    93100GIET_INCLUDE = -Igiet_boot    \
    … …  
    183190        $(CC) $(GIET_INCLUDE) $(CFLAGS)  -c -o $@ $<
    184191
     192build/drivers/bdv_driver.o: giet_drivers/bdv_driver.c  \
     193                            giet_drivers/bdv_driver.h  \
     194                            giet_config.h              \
     195                            $(MAP_XML)
     196        $(CC) $(GIET_INCLUDE) $(CFLAGS)  -c -o $@ $<
     197
     198build/drivers/sdc_driver.o: giet_drivers/sdc_driver.c  \
     199                            giet_drivers/sdc_driver.h  \
     200                            giet_config.h              \
     201                            $(MAP_XML)
     202        $(CC) $(GIET_INCLUDE) $(CFLAGS)  -c -o $@ $<
     203
     204build/drivers/spi_driver.o: giet_drivers/spi_driver.c  \
     205                            giet_drivers/spi_driver.h  \
     206                            giet_config.h              \
     207                            $(MAP_XML)
     208        $(CC) $(GIET_INCLUDE) $(CFLAGS)  -c -o $@ $<
     209
    185210build/drivers/iob_driver.o: giet_drivers/iob_driver.c  \
    186211                            giet_drivers/iob_driver.h  \
    … …  
    248273                   giet_common/utils.h       \
    249274                   giet_fat32/fat32.h        \
    250                    giet_common/vmem.h          \
     275                   giet_common/vmem.h        \
    251276                   giet_drivers/tty_driver.h \
    252277                   giet_drivers/ioc_driver.h \

  • branch/giet_vm_ioc_drivers/giet_boot/boot.c

    r276 r283  
    15611561void boot_mapping_init()
    15621562{
    1563     // Initializing the FAT descriptor and files descriptor array
    1564     if ( _fat_init( IOC_BOOT_PA_MODE ) )   
    1565     {
    1566         _puts("[BOOT ERROR] Cannot initialize FAT descriptor fom Boot Sector\n");
    1567         _exit();
    1568     }
    1569 
    1570 #if BOOT_DEBUG_MAPPING
    1571 _puts("\n[BOOT] FAT initialisation completed at cycle ");
    1572 _putd(_get_proctime());
    1573 _puts("\n");
    1574 _fat_print();
    1575 #endif
     1563    _ioc_init( 0 );
    15761564
    15771565    int fd_id = _fat_open( IOC_BOOT_PA_MODE,
    … …  
    19271915                case PERIPH_TYPE_IOC:    // vci_block_device component
    19281916                {
    1929                     _ioc_init();
     1917                    // initialize all channels except channel 0 because it has been
     1918                    // initialize during mapping_info loading
     1919                    for (channel_id = 1; channel_id < channels; channel_id++)
     1920                    {
     1921                        _ioc_init( channel_id );
     1922                    }
    19301923#if BOOT_DEBUG_PERI
    19311924_puts("- IOC / channels = ");
    … …  
    19531946#if BOOT_DEBUG_PERI
    19541947_puts("- FBF / channels = ");
    1955 _putd(channels);
    1956 _puts("\n");
    1957 #endif
    1958                     break;
    1959                 }
    1960                 case PERIPH_TYPE_HBA:    // vci_multi_ahci component
    1961                 {
    1962                     for (channel_id = 0; channel_id < channels; channel_id++)
    1963                     {
    1964                         // TODO
    1965                     }
    1966 #if BOOT_DEBUG_PERI
    1967 _puts("- HBA / channels = ");
    19681948_putd(channels);
    19691949_puts("\n");

  • branch/giet_vm_ioc_drivers/giet_drivers/hba_driver.c

    r258 r283  
    124124{
    125125    volatile unsigned int* hba_address;
    126     hba_address = (unsigned int*)(&seg_hba_base) + (HBA_SPAN*channel);
     126    hba_address = (unsigned int*)(&seg_ioc_base) + (HBA_SPAN*channel);
    127127
    128128    if( channel >= NB_HBA_CHANNELS )
    … …  
    146146{
    147147    volatile unsigned int* hba_address;
    148     hba_address = (unsigned int*)(&seg_hba_base) + (HBA_SPAN*channel);
     148    hba_address = (unsigned int*)(&seg_ioc_base) + (HBA_SPAN*channel);
    149149
    150150    if( channel >= NB_HBA_CHANNELS )
    … …  
    214214
    215215    // get hba device address
    216     hba_address = (unsigned int*)(&seg_hba_base) + (HBA_SPAN * channel_id);
     216    hba_address = (unsigned int*)(&seg_ioc_base) + (HBA_SPAN * channel_id);
    217217
    218218    // get command list status
    … …  
    434434}
    435435//////////////////////////////////////////////////////////////////
    436 // This function initializes for a given channel (k)
     436// This function initializes for a given channel
    437437// - the HBA hardware registers,
    438438// - the command list pointer,
    … …  
    440440// - the command tables physical addresses array,
    441441//////////////////////////////////////////////////////////////////
    442 void _hba_init( unsigned int k )  // k == channel_index
     442void _hba_init( unsigned int channel )
    443443{
    444444    unsigned int ppn;
    … …  
    452452
    453453    // HBA registers
    454     unsigned int*  hba_address = (unsigned int*)(&seg_hba_base) + (HBA_SPAN*k);
    455     hba_address = (unsigned int*)&seg_hba_base + HBA_SPAN * k;
    456 
    457     hba_address[HBA_PXCLB]  = (unsigned int)(&hba_cmd_list[k]);
     454    unsigned int*  hba_address;
     455    hba_address = (unsigned int*)&seg_ioc_base + HBA_SPAN * channel;
     456
     457    hba_address[HBA_PXCLB]  = (unsigned int)(&hba_cmd_list[channel]);
    458458    hba_address[HBA_PXCLBU] = 0;
    459459    hba_address[HBA_PXIE]   = 0x40000001;
    … …  
    463463
    464464    // command list pointer       
    465     hba_cmd_slot[k] = 0;
     465    hba_cmd_slot[channel] = 0;
    466466
    467467    // Command list physical addresse
    468     vbase = (unsigned int)(&hba_cmd_list[k]);
     468    vbase = (unsigned int)(&hba_cmd_list[channel]);
    469469    fail = _v2p_translate( (page_table_t*)pt,
    470470                           vbase>>12,
    … …  
    478478        _exit();
    479479    }
    480     hba_cmd_list_paddr[k] = ((paddr_t)ppn) | (vbase & 0xFFF);
     480    hba_cmd_list_paddr[channel] = ((paddr_t)ppn) | (vbase & 0xFFF);
    481481
    482482    // Command tables physical addresses
    483483    for( c=0 ; c<32 ; c++ )
    484484    {
    485         vbase = (unsigned int)(&hba_cmd_table[k][c]);
     485        vbase = (unsigned int)(&hba_cmd_table[channel][c]);
    486486        fail = _v2p_translate( (page_table_t*)pt,
    487487                               vbase>>12,
    … …  
    495495            _exit();
    496496        }
    497         hba_cmd_table_paddr[k][c] = ((paddr_t)ppn) | (vbase & 0xFFF);
     497        hba_cmd_table_paddr[channel][c] = ((paddr_t)ppn) | (vbase & 0xFFF);
    498498    }
    499499}

  • branch/giet_vm_ioc_drivers/giet_drivers/ioc_driver.c

    r279 r283  
    8787#endif
    8888
     89#if (USE_BDV + USE_SPI + USE_HBA) != 1
     90# error: You must use only one IOC controller (BDV or SPI or HBA)
     91#endif
     92
     93#if USE_BDV
     94# include <bdv_driver.h>
     95#endif
     96
     97#if USE_SPI
     98# include <sdc_driver.h>
     99#endif
     100
     101#if USE_HBA
     102# include <hba_driver.h>
     103#endif
     104
     105
    89106#define in_unckdata __attribute__((section (".unckdata")))
    90107
    91108///////////////////// IOC global variables
    92109
    93 in_unckdata unsigned int          _ioc_lock = 0;
    94 in_unckdata volatile unsigned int _ioc_status = 0;
     110in_unckdata unsigned int _ioc_lock = 0;
     111in_unckdata unsigned int _ioc_status = 0;
    95112in_unckdata volatile unsigned int _ioc_gtid;
    96113in_unckdata volatile unsigned int _ioc_iommu_ix1 = 0;
    … …  
    154171        return 1;
    155172    }
    156 
    157     volatile unsigned int * ioc_address = (unsigned int *) &seg_ioc_base ;
    158173
    159174    unsigned int length = count << 9;  // count * 512 bytes
    … …  
    269284    }
    270285
    271     // get the lock protecting IOC
    272     _get_lock(&_ioc_lock);
    273 
    274     // set the _ioc_status polling variable
    275     _ioc_status = BLOCK_DEVICE_BUSY;
    276 
    277 #if GIET_DEBUG_IOC_DRIVER
    278 _tty_get_lock( 0 );
    279 _puts("\n[IOC DEBUG] _ioc_access() : configure IOC\n");
    280 _puts(" - buf_paddr = ");
    281 _putl( buf_paddr );
    282 _puts("\n");
    283 _puts(" - count     = ");
    284 _putd( count );
    285 _puts("\n");
    286 _puts(" - lba       = ");
    287 _putx( lba );
    288 _puts("\n");
    289 _tty_release_lock( 0 );
    290 #endif
    291 
    292     // send command to IOC   
    293     if ( GIET_USE_IOMMU )
    294     {
    295         ioc_address[BLOCK_DEVICE_BUFFER] = buf_xaddr;
    296         ioc_address[BLOCK_DEVICE_COUNT]  = count;
    297         ioc_address[BLOCK_DEVICE_LBA]    = lba;
    298     }
    299     else
    300     {
    301         ioc_address[BLOCK_DEVICE_BUFFER]     = (unsigned int)buf_paddr;
    302         ioc_address[BLOCK_DEVICE_BUFFER_EXT] = (unsigned int)(buf_paddr>>32);
    303         ioc_address[BLOCK_DEVICE_COUNT]      = count;
    304         ioc_address[BLOCK_DEVICE_LBA]        = lba;
    305     }
    306 
    307     // There is two policies for transfer completion
    308         // detection, depending on the mode argument:
    309 
    310     if ( (mode == IOC_BOOT_PA_MODE) ||    // We poll directly the IOC_STATUS register
    311          (mode == IOC_BOOT_VA_MODE) )     // as IRQs are masked.
    312     {
    313         // Launch transfert
    314         if (to_mem == 0) ioc_address[BLOCK_DEVICE_OP] = BLOCK_DEVICE_WRITE;
    315         else             ioc_address[BLOCK_DEVICE_OP] = BLOCK_DEVICE_READ;
    316 
    317         unsigned int status;
    318         if ( _ioc_get_status(0, &status) ) return 1;
    319 
    320         while( (status != BLOCK_DEVICE_READ_SUCCESS)  &&
    321                (status != BLOCK_DEVICE_READ_ERROR)    &&
    322                (status != BLOCK_DEVICE_WRITE_SUCCESS) &&
    323                (status != BLOCK_DEVICE_WRITE_ERROR) )
    324         {
    325             if ( _ioc_get_status(0, &status) ) return 1;
    326 
    327 #if GIET_DEBUG_IOC_DRIVER
    328 _tty_get_lock( 0 );
    329 _puts("\n[IOC DEBUG] _ioc_access() : ... waiting on IOC_STATUS register ...\n");
    330 _tty_release_lock( 0 );
    331 #endif
    332 
    333         }
    334         // analyse status
    335         error = ( (status == BLOCK_DEVICE_READ_ERROR) ||
    336                   (status == BLOCK_DEVICE_WRITE_ERROR) );
    337 
    338         // release lock
    339         _release_lock(&_ioc_lock);     
    340     }
    341     else                           // in USER or KERNEL mode, we deschedule the task.
    342                                    // When the task is rescheduled by the ISR, we reset
    343                                    // the _ioc_status variable, and release the lock
    344     {
    345         // We need a critical section, because we must reset the RUN bit
    346                 // before to launch the transfer, and we want to avoid to be descheduled
    347                 // between these two operations.
    348 
    349         // Enter critical section
    350         _it_disable();
    351        
    352         // set _ioc_gtid and reset runnable
    353         unsigned int ltid = _get_proc_task_id();
    354         unsigned int pid = _get_procid();
    355         _ioc_gtid = (pid<<16) + ltid;
    356         _set_task_slot( pid, ltid, CTX_RUN_ID, 0 ); 
    357        
    358         // Launch transfert
    359         if (to_mem == 0) ioc_address[BLOCK_DEVICE_OP] = BLOCK_DEVICE_WRITE;
    360         else             ioc_address[BLOCK_DEVICE_OP] = BLOCK_DEVICE_READ;
    361 
    362         // deschedule task
    363         _ctx_switch();                     
    364 
    365         // analyse status
    366         error = ( (_ioc_status == BLOCK_DEVICE_READ_ERROR) ||
    367                   (_ioc_status == BLOCK_DEVICE_WRITE_ERROR) );
    368 
    369         // reset _ioc_status and release lock
    370         _ioc_status = BLOCK_DEVICE_IDLE;
    371         _release_lock(&_ioc_lock);     
    372     }
    373 
    374 #if GIET_DEBUG_IOC_DRIVER
    375 _tty_get_lock( 0 );
    376 _puts("\n[IOC DEBUG] _ioc_access completed at cycle ");
    377 _putd( _get_proctime() );
    378 _puts(" for processor ");
    379 _putd( _get_procid() );
    380 _puts(" : error = ");
    381 _putd( (unsigned int)error );
    382 _puts("\n");
    383 _tty_release_lock( 0 );
     286    if ( GIET_USE_IOMMU ) buf_paddr = (paddr_t) buf_xaddr;
     287
     288#if   USE_BDV
     289    if (to_mem) error = _bdv_read (mode, lba, buf_paddr, count);
     290    else        error = _bdv_write(mode, lba, buf_paddr, count);
     291#elif USE_SPI
     292    if (to_mem) error = _sdc_read (mode, lba, buf_paddr, count);
     293    else        error = _sdc_write(mode, lba, buf_paddr, count);
     294#elif USE_HBA
     295    if (to_mem) error = _hba_read (mode, lba, buf_paddr, count);
     296    else        error = _hba_write(mode, lba, buf_paddr, count);
    384297#endif
    385298
    … …  
    392305// Return 0 for success.
    393306///////////////////////////////////////////////////////////////////////////////
    394 unsigned int _ioc_init()
    395 {
    396     volatile unsigned int * ioc_address = (unsigned int *) &seg_ioc_base ;
    397    
    398     if ( ioc_address[BLOCK_DEVICE_BLOCK_SIZE] != 512 )
    399     {
    400         _puts("\n[GIET ERROR] in _ioc_init() : block size must be 512 bytes\n");
    401         _exit();
    402     }
    403 
    404     ioc_address[BLOCK_DEVICE_IRQ_ENABLE] = 1;
    405     return 0;
     307unsigned int _ioc_init( unsigned int channel )
     308{
     309#if   USE_BDV
     310    return _bdv_init( channel );
     311#elif USE_SPI
     312    return _sdc_init( channel );
     313#elif USE_HBA
     314    return _hba_init( channel );
     315#endif
    406316}
    407317
    … …  
    457367                              unsigned int* status )
    458368{
    459     if ( channel != 0 )
    460     {
    461         _tty_get_lock( 0 );
    462         _puts("\n[GIET ERROR] in _ioc_get_status : illegal channel\n");
    463         _tty_release_lock( 0 );
    464 
    465         return 1;
    466     }
    467 
    468     // get IOC base address
    469     volatile unsigned int * ioc_address = (unsigned int *) &seg_ioc_base;
    470     *status = ioc_address[BLOCK_DEVICE_STATUS];
    471 
    472     return 0;
     369#if   USE_BDV
     370    return _bdv_get_status(channel, status);
     371#elif USE_SPI
     372    return _sdc_get_status(channel, status);
     373#elif USE_HBA
     374    return _hba_get_status(channel, status);
     375#endif
    473376}
    474377
    … …  
    479382unsigned int _ioc_get_block_size()
    480383{
    481     // get IOC base address
    482     volatile unsigned int * ioc_address = (unsigned int *) &seg_ioc_base;
    483    
    484     return  ioc_address[BLOCK_DEVICE_BLOCK_SIZE];
     384#if   USE_BDV
     385    return _bdv_get_block_size();
     386#elif USE_SPI
     387    return _sdc_get_block_size();
     388#elif USE_HBA
     389    return _hba_get_block_size();
     390#endif
    485391}
    486392

  • branch/giet_vm_ioc_drivers/giet_drivers/ioc_driver.h

    r279 r283  
    5353///////////////////////////////////////////////////////////////////////////////////
    5454
    55 extern unsigned int          _ioc_lock;
    56 extern volatile unsigned int _ioc_status;
     55extern unsigned int _ioc_lock;
     56extern unsigned int _ioc_status;
    5757extern volatile unsigned int _ioc_gtid;
    5858extern volatile unsigned int _ioc_iommu_ix1;
    5959extern volatile unsigned int _ioc_iommu_npages;
    6060
    61 extern unsigned int _ioc_init();
     61extern unsigned int _ioc_init( unsigned int channel );
    6262
    6363extern unsigned int _ioc_write( unsigned int mode,

  • branch/giet_vm_ioc_drivers/giet_fat32/fat32.c

    r273 r283  
    871871    if( fat.initialised != FAT_INITIALISED )
    872872    {
    873           _fat_init( mode );
     873        if ( _fat_init( mode ) )
     874        {
     875            _puts("[FAT ERROR] Cannot initialize FAT descriptor fom Boot Sector\n");
     876            _exit();
     877        }
     878
     879#if GIET_DEBUG_FAT
     880_tty_get_lock( 0 );
     881_puts("\n[FAT DEBUG] FAT initialisation completed at cycle ");
     882_putd(_get_proctime());
     883_puts("\n");
     884_fat_print();
     885_tty_release_lock( 0 );
     886#endif
    874887    }
    875888 

  • branch/giet_vm_ioc_drivers/giet_xml/mapping_info.h

    r267 r283  
    120120};
    121121
     122enum periphSubtype
     123{
     124    PERIPH_SUBTYPE_BDV       = 0,
     125    PERIPH_SUBTYPE_HBA       = 1,
     126    PERIPH_SUBTYPE_SPI       = 2,
     127
     128    PERIPH_SUBTYPE_MAX_VALUE = 3,
     129};
    122130
    123131enum mwmrPortDirection
    … …  
    319327{
    320328    unsigned int    type;         
     329    unsigned int    subtype;         // periph specialization
    321330    unsigned int    psegid;          // pseg index in cluster
    322331    unsigned int    channels;        // number of channels

  • branch/giet_vm_ioc_drivers/giet_xml/xml_driver.c

    r263 r283  
    7474        "TTY",
    7575        "XCU",
     76    };
     77
     78    const char * periph_subtype[] =
     79    {
     80        "BDV",
     81        "HBA",
     82        "SPI",
    7683    };
    7784
    … …  
    306313        {
    307314            fprintf(fpout, "            <periph type = \"%s\" ", periph_type[periph[periph_id].type]);
     315
     316            if (periph[periph_id].subtype < PERIPH_SUBTYPE_MAX_VALUE)
     317                fprintf(fpout, " subtype = \"%s\" ", periph_subtype[periph[periph_id].subtype]);
     318
    308319            fprintf(fpout, " psegname = \"%s\" ", pseg[periph[periph_id].psegid].name);
    309320            fprintf(fpout, " channels = \"%d\" />\n",  periph[periph_id].channels);

  • branch/giet_vm_ioc_drivers/giet_xml/xml_parser.c

    r281 r283  
    123123unsigned int use_iob          = 0; // using IOB component
    124124unsigned int use_xcu          = 0; // using XCU (not ICU)
     125
     126// These variables define the IOC peripheral subtype
    125127unsigned int use_hba          = 0; // using HBA
     128unsigned int use_bdv          = 0; // using SoCLIB block device
     129unsigned int use_spi          = 0; // using SD Card-SPI
    126130
    127131
    … …  
    12531257        unsigned int error = 0;
    12541258
     1259        // initialize peripheral subtype
     1260        periph[periph_index]->subtype = 0xFFFFFFFF;
     1261
    12551262        // The CMA, FBF, HBA, IOB, IOC, NIC, ROM, SIM, TTY, peripherals are not
    12561263        // replicated in all clusters but can be replicated in two clusters (fault tolerance)
    … …  
    13371344        {
    13381345            periph[periph_index]->type = PERIPH_TYPE_IOC;
     1346
    13391347            if (header->ioc_cluster == 0xFFFFFFFF)
    13401348            {
    … …  
    13471355            else
    13481356            {
    1349                 error = 1;
     1357                printf("[XML ERROR] At most two copies for non replicated "
     1358                        "peripheral\n");
     1359                exit(1);
     1360            }
     1361
     1362            str = getStringValue(reader, "subtype", &ok);
     1363   
     1364            if (!ok)
     1365            {
     1366                printf("[XML ERROR] IOC peripheral needs a subtype parameter: "
     1367                       "BDV, HBA or SPI\n");
     1368                exit(1);
     1369            }
     1370
     1371            if (strcmp(str, "BDV") == 0)
     1372            {
     1373                periph[periph_index]->subtype = PERIPH_SUBTYPE_BDV;
     1374                use_bdv = 1;
     1375            }
     1376            else if (strcmp(str, "HBA") == 0)
     1377            {
     1378                periph[periph_index]->subtype = PERIPH_SUBTYPE_HBA;
     1379
     1380                if (use_hba == 0)
     1381                {
     1382                    use_hba      = 1;
     1383                    hba_channels = periph[periph_index]->channels;
     1384                }
     1385                else
     1386                {
     1387                    assert( (hba_channels == periph[periph_index]->channels) &&
     1388                    "[XML ERROR] unconsistent non replicated peripheral");
     1389                }
     1390            }
     1391            else if (strcmp(str, "SPI") == 0)
     1392            {
     1393                periph[periph_index]->subtype = PERIPH_SUBTYPE_SPI;
     1394                use_spi = 1;
     1395            }
     1396            else
     1397            {
     1398                printf("[XML ERROR] illegal subtype for IOC peripheral\n");
     1399                exit(1);
    13501400            }
    13511401        }
    … …  
    25672617    def_int_write(fdout, "USE_IOB           ", use_iob);
    25682618    def_int_write(fdout, "USE_HBA           ", use_hba);
     2619    def_int_write(fdout, "USE_BDV           ", use_bdv);
     2620    def_int_write(fdout, "USE_SPI           ", use_spi);
    25692621
    25702622    file_write(fdout, "\n");

  • branch/giet_vm_ioc_drivers/mappings/4c_1p_four.xml

    r281 r283  
    5252            <periph type = "XCU"  psegname = "PSEG_XCU"  channels = "6"  />
    5353            <periph type = "MMC"  psegname = "PSEG_MMC"  channels = "1"  />
    54             <periph type = "IOC"  psegname = "PSEG_IOC"  channels = "1" />
     54            <periph type = "IOC"  psegname = "PSEG_IOC"  channels = "1" subtype = "BDV" />
    5555            <periph type = "TTY"  psegname = "PSEG_TTY"  channels = "8"  />
    5656            <periph type = "NIC"  psegname = "PSEG_NIC"  channels = "2"  />

  • branch/giet_vm_ioc_drivers/mappings/4c_1p_iob_four.xml

    r265 r283  
    7171            <periph type = "XCU"  psegname = "PSEG_XCU"  channels = "1"  />
    7272            <periph type = "MMC"  psegname = "PSEG_MMC"  channels = "1"  />
    73             <periph type = "IOC"  psegname = "PSEG_IOC"  channels = "1" />
     73            <periph type = "IOC"  psegname = "PSEG_IOC"  channels = "1" subtype = "BDV" />
    7474            <periph type = "TTY"  psegname = "PSEG_TTY"  channels = "8"  />
    7575            <periph type = "NIC"  psegname = "PSEG_NIC"  channels = "2"  />

  • branch/giet_vm_ioc_drivers/mappings/4c_1p_iob_sort.xml

    r271 r283  
    7171            <periph type = "XCU"  psegname = "PSEG_XCU"  channels = "1"  />
    7272            <periph type = "MMC"  psegname = "PSEG_MMC"  channels = "1"  />
    73             <periph type = "IOC"  psegname = "PSEG_IOC"  channels = "1"  />
    74             <periph type = "TTY"  psegname = "PSEG_TTY"  channels = "5" />
     73            <periph type = "IOC"  psegname = "PSEG_IOC"  channels = "1"  subtype = "BDV" />
     74            <periph type = "TTY"  psegname = "PSEG_TTY"  channels = "5"  />
    7575            <periph type = "NIC"  psegname = "PSEG_NIC"  channels = "2"  />
    7676            <periph type = "CMA"  psegname = "PSEG_CMA"  channels = "4"  />

  • branch/giet_vm_ioc_drivers/mappings/4c_1p_sort_chiplet.xml

    r271 r283  
    3737            <periph type = "XCU"  psegname = "PSEG_XCU"  channels = "1"  />
    3838            <periph type = "MMC"  psegname = "PSEG_MMC"  channels = "1"  />
    39             <periph type = "IOC"  psegname = "PSEG_IOC"  channels = "1" />
     39            <periph type = "IOC"  psegname = "PSEG_IOC"  channels = "1" subtype = "SPI" />
    4040            <periph type = "TTY"  psegname = "PSEG_TTY"  channels = "1" />
    4141            <periph type = "ROM"  psegname = "PSEG_ROM"  channels = "1"  />
Note: See TracChangeset for help on using the changeset viewer.