Changeset 1139

Show
Ignore:
Timestamp:
05/08/08 08:11:35 (15 years ago)
Author:
holin
Message:

at least on T.C. Konnekts, strings seem to be stored as little endian quads

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/libffado/src/dice/dice_avdevice.cpp

    r1136 r1139  
    12581258    char namestring[DICE_TX_NAMES_SIZE+1]; 
    12591259 
    1260     if (!readTxRegBlock(i, DICE_REGISTER_TX_NAMES_BASE, 
     1260    if (!readTxRegBlockSwapped(i, DICE_REGISTER_TX_NAMES_BASE, 
    12611261                        (fb_quadlet_t *)namestring, DICE_TX_NAMES_SIZE)) { 
    12621262        debugError("Could not read TX name string \n"); 
     
    12731273    char namestring[DICE_RX_NAMES_SIZE+1]; 
    12741274 
    1275     if (!readRxRegBlock(i, DICE_REGISTER_RX_NAMES_BASE, 
     1275    if (!readRxRegBlockSwapped(i, DICE_REGISTER_RX_NAMES_BASE, 
    12761276                        (fb_quadlet_t *)namestring, DICE_RX_NAMES_SIZE)) { 
    12771277        debugError("Could not read RX name string \n"); 
     
    12881288    char namestring[DICE_CLOCKSOURCENAMES_SIZE+1]; 
    12891289 
    1290     if (!readGlobalRegBlock(DICE_REGISTER_GLOBAL_CLOCKSOURCENAMES, 
    1291                         (fb_quadlet_t *)namestring, DICE_CLOCKSOURCENAMES_SIZE)) { 
     1290    if (!readGlobalRegBlockSwapped(DICE_REGISTER_GLOBAL_CLOCKSOURCENAMES, 
     1291                      (fb_quadlet_t *)namestring, DICE_CLOCKSOURCENAMES_SIZE)) { 
    12921292        debugError("Could not read CLOCKSOURCE name string \n"); 
    12931293        return names; 
     
    13021302    char namestring[DICE_NICK_NAME_SIZE+1]; 
    13031303 
    1304     if (!readGlobalRegBlock(DICE_REGISTER_GLOBAL_NICK_NAME, 
     1304    if (!readGlobalRegBlockSwapped(DICE_REGISTER_GLOBAL_NICK_NAME, 
    13051305                        (fb_quadlet_t *)namestring, DICE_NICK_NAME_SIZE)) { 
    13061306        debugError("Could not read nickname string \n"); 
     
    13171317    strncpy(namestring, name.c_str(), DICE_NICK_NAME_SIZE); 
    13181318 
    1319     if (!writeGlobalRegBlock(DICE_REGISTER_GLOBAL_NICK_NAME, 
     1319    if (!writeGlobalRegBlockSwapped(DICE_REGISTER_GLOBAL_NICK_NAME, 
    13201320                        (fb_quadlet_t *)namestring, DICE_NICK_NAME_SIZE)) { 
    13211321        debugError("Could not write nickname string \n"); 
     
    15431543 
    15441544bool 
     1545DiceAvDevice::readRegBlockSwapped(fb_nodeaddr_t offset, fb_quadlet_t *data, size_t length) { 
     1546    debugOutput(DEBUG_LEVEL_VERY_VERBOSE,"Reading base register offset 0x%08llX, length %u\n", 
     1547        offset, length); 
     1548 
     1549    if(offset >= DICE_INVALID_OFFSET) { 
     1550        debugError("invalid offset: 0x%016llX\n", offset); 
     1551        return false; 
     1552    } 
     1553 
     1554    fb_nodeaddr_t addr=DICE_REGISTER_BASE + offset; 
     1555    fb_nodeid_t nodeId=getNodeId() | 0xFFC0; 
     1556 
     1557    if(!get1394Service().read( nodeId, addr, length/4, data ) ) { 
     1558        debugError("Could not read from node 0x%04X addr 0x%012llX\n", nodeId, addr); 
     1559        return false; 
     1560    } 
     1561 
     1562    for(unsigned int i=0;i<length/4;i++) { 
     1563        *(data+i)=ByteSwap32(*(data+i)); 
     1564    } 
     1565 
     1566    return true; 
     1567} 
     1568 
     1569bool 
     1570DiceAvDevice::writeRegBlockSwapped(fb_nodeaddr_t offset, fb_quadlet_t *data, size_t length) { 
     1571    debugOutput(DEBUG_LEVEL_VERY_VERBOSE,"Writing base register offset 0x%08llX, length: %u\n", 
     1572        offset, length); 
     1573 
     1574    if(offset >= DICE_INVALID_OFFSET) { 
     1575        debugError("invalid offset: 0x%016llX\n", offset); 
     1576        return false; 
     1577    } 
     1578 
     1579    fb_nodeaddr_t addr=DICE_REGISTER_BASE + offset; 
     1580    fb_nodeid_t nodeId=getNodeId() | 0xFFC0; 
     1581 
     1582    fb_quadlet_t data_out[length/4]; 
     1583 
     1584    for(unsigned int i=0;i<length/4;i++) { 
     1585        data_out[i]=ByteSwap32(*(data+i)); 
     1586    } 
     1587 
     1588    if(!get1394Service().write( nodeId, addr, length/4, data_out ) ) { 
     1589        debugError("Could not write to node 0x%04X addr 0x%012llX\n", nodeId, addr); 
     1590        return false; 
     1591    } 
     1592 
     1593    return true; 
     1594} 
     1595 
     1596bool 
    15451597DiceAvDevice::readGlobalReg(fb_nodeaddr_t offset, fb_quadlet_t *result) { 
    15461598    debugOutput(DEBUG_LEVEL_VERY_VERBOSE,"Reading global register offset 0x%04llX\n", offset); 
     
    15751627    fb_nodeaddr_t offset_gl=globalOffsetGen(offset, length); 
    15761628    return writeRegBlock(m_global_reg_offset + offset_gl, data, length); 
     1629} 
     1630 
     1631bool 
     1632DiceAvDevice::readGlobalRegBlockSwapped(fb_nodeaddr_t offset, fb_quadlet_t *data, size_t length) { 
     1633    debugOutput(DEBUG_LEVEL_VERY_VERBOSE,"Reading global register block offset 0x%04llX, length %u bytes\n", 
     1634        offset, length); 
     1635 
     1636    fb_nodeaddr_t offset_gl=globalOffsetGen(offset, length); 
     1637    return readRegBlockSwapped(m_global_reg_offset + offset_gl, data, length); 
     1638} 
     1639 
     1640bool 
     1641DiceAvDevice::writeGlobalRegBlockSwapped(fb_nodeaddr_t offset, fb_quadlet_t *data, size_t length) { 
     1642    debugOutput(DEBUG_LEVEL_VERY_VERBOSE,"Writing global register block offset 0x%04llX, length %u bytes\n", 
     1643        offset, length); 
     1644 
     1645    fb_nodeaddr_t offset_gl=globalOffsetGen(offset, length); 
     1646    return writeRegBlockSwapped(m_global_reg_offset + offset_gl, data, length); 
    15771647} 
    15781648 
     
    16281698    fb_nodeaddr_t offset_tx=txOffsetGen(i, offset, length); 
    16291699    return writeRegBlock(m_tx_reg_offset + offset_tx, data, length); 
     1700} 
     1701 
     1702bool 
     1703DiceAvDevice::readTxRegBlockSwapped(unsigned int i, fb_nodeaddr_t offset, fb_quadlet_t *data, size_t length) { 
     1704    debugOutput(DEBUG_LEVEL_VERY_VERBOSE,"Reading rx register block offset 0x%04llX, length %u bytes\n", 
     1705        offset, length); 
     1706 
     1707    fb_nodeaddr_t offset_tx=txOffsetGen(i, offset, length); 
     1708    return readRegBlockSwapped(m_tx_reg_offset + offset_tx, data, length); 
    16301709} 
    16311710 
     
    16971776} 
    16981777 
     1778bool 
     1779DiceAvDevice::readRxRegBlockSwapped(unsigned int i, fb_nodeaddr_t offset, fb_quadlet_t *data, size_t length) { 
     1780    debugOutput(DEBUG_LEVEL_VERY_VERBOSE,"Reading rx register block offset 0x%04llX, length %u bytes\n", 
     1781        offset, length); 
     1782 
     1783    fb_nodeaddr_t offset_rx=rxOffsetGen(i, offset, length); 
     1784    return readRegBlockSwapped(m_rx_reg_offset + offset_rx, data, length); 
     1785} 
     1786 
    16991787fb_nodeaddr_t 
    17001788DiceAvDevice::rxOffsetGen(unsigned int i, fb_nodeaddr_t offset, size_t length) { 
  • trunk/libffado/src/dice/dice_avdevice.h

    r1134 r1139  
    149149    bool readRegBlock(fb_nodeaddr_t, fb_quadlet_t *, size_t); 
    150150    bool writeRegBlock(fb_nodeaddr_t, fb_quadlet_t *, size_t); 
     151    bool readRegBlockSwapped(fb_nodeaddr_t, fb_quadlet_t *, size_t); 
     152    bool writeRegBlockSwapped(fb_nodeaddr_t, fb_quadlet_t *, size_t); 
    151153 
    152154    bool readGlobalReg(fb_nodeaddr_t, fb_quadlet_t *); 
     
    154156    bool readGlobalRegBlock(fb_nodeaddr_t, fb_quadlet_t *, size_t); 
    155157    bool writeGlobalRegBlock(fb_nodeaddr_t, fb_quadlet_t *, size_t); 
     158    bool readGlobalRegBlockSwapped(fb_nodeaddr_t, fb_quadlet_t *, size_t); 
     159    bool writeGlobalRegBlockSwapped(fb_nodeaddr_t, fb_quadlet_t *, size_t); 
    156160    fb_nodeaddr_t globalOffsetGen(fb_nodeaddr_t, size_t); 
    157161 
     
    160164    bool readTxRegBlock(unsigned int i, fb_nodeaddr_t offset, fb_quadlet_t *data, size_t length); 
    161165    bool writeTxRegBlock(unsigned int i, fb_nodeaddr_t offset, fb_quadlet_t *data, size_t length); 
     166    bool readTxRegBlockSwapped(unsigned int i, fb_nodeaddr_t offset, fb_quadlet_t *data, size_t length); 
    162167    fb_nodeaddr_t txOffsetGen(unsigned int, fb_nodeaddr_t, size_t); 
    163168 
     
    166171    bool readRxRegBlock(unsigned int i, fb_nodeaddr_t offset, fb_quadlet_t *data, size_t length); 
    167172    bool writeRxRegBlock(unsigned int i, fb_nodeaddr_t offset, fb_quadlet_t *data, size_t length); 
     173    bool readRxRegBlockSwapped(unsigned int i, fb_nodeaddr_t offset, fb_quadlet_t *data, size_t length); 
    168174    fb_nodeaddr_t rxOffsetGen(unsigned int, fb_nodeaddr_t, size_t); 
    169175