tools/Master.cpp
changeset 1102 5461894b05ab
parent 1101 f8d13814af03
child 1103 b6998e916d5a
equal deleted inserted replaced
1101:f8d13814af03 1102:5461894b05ab
   692 void Master::siiRead(int slavePosition)
   692 void Master::siiRead(int slavePosition)
   693 {
   693 {
   694     ec_ioctl_slave_sii_t data;
   694     ec_ioctl_slave_sii_t data;
   695     ec_ioctl_slave_t slave;
   695     ec_ioctl_slave_t slave;
   696     unsigned int i;
   696     unsigned int i;
       
   697     const uint16_t *categoryHeader;
       
   698     uint16_t categoryType, categorySize;
       
   699     stringstream err;
   697 
   700 
   698     if (slavePosition < 0) {
   701     if (slavePosition < 0) {
   699         stringstream err;
   702         stringstream err;
   700         err << "'sii_read' requires a slave! Please specify --slave.";
   703         err << "'sii_read' requires a slave! Please specify --slave.";
   701         throw MasterException(err.str());
   704         throw MasterException(err.str());
   718         delete [] data.words;
   721         delete [] data.words;
   719         err << "Failed to read SII: " << strerror(errno);
   722         err << "Failed to read SII: " << strerror(errno);
   720         throw MasterException(err.str());
   723         throw MasterException(err.str());
   721     }
   724     }
   722 
   725 
   723     for (i = 0; i < data.nwords; i++) {
   726     if (verbosity == Verbose) {
   724         uint16_t *w = data.words + i;
   727         cout << "SII Area:" << hex << setfill('0');
   725         cout << *(uint8_t *) w << *((uint8_t *) w + 1);
   728         for (i = 0; i < min(data.nwords, 0x0040U) * 2; i++) {
       
   729             if (i % BreakAfterBytes) {
       
   730                 cout << " ";
       
   731             } else {
       
   732                 cout << endl << "  ";
       
   733             }
       
   734             cout << setw(2) << (unsigned int) *((uint8_t *) data.words + i);
       
   735         }
       
   736         cout << endl;
       
   737 
       
   738         if (data.nwords > 0x0040U) {
       
   739             // cycle through categories
       
   740             categoryHeader = data.words + 0x0040U;
       
   741             categoryType = le16tocpu(*categoryHeader);
       
   742             while (categoryType != 0xffff) {
       
   743                 cout << "SII Category 0x" << hex
       
   744                     << setw(4) << categoryType << flush;
       
   745 
       
   746                 if (categoryHeader + 1 > data.words + data.nwords) {
       
   747                     err << "SII data seem to be corrupted!";
       
   748                     throw MasterException(err.str());
       
   749                 }
       
   750                 categorySize = le16tocpu(*(categoryHeader + 1));
       
   751                 cout << ", " << dec << categorySize << " words" << flush;
       
   752 
       
   753                 if (categoryHeader + 2 + categorySize > data.words + data.nwords) {
       
   754                     err << "SII data seem to be corrupted!";
       
   755                     throw MasterException(err.str());
       
   756                 }
       
   757 
       
   758                 cout << hex;
       
   759                 for (i = 0; i < categorySize * 2U; i++) {
       
   760                     if (i % BreakAfterBytes) {
       
   761                         cout << " ";
       
   762                     } else {
       
   763                         cout << endl << "  ";
       
   764                     }
       
   765                     cout << setw(2) << (unsigned int)
       
   766                         *((uint8_t *) (categoryHeader + 2) + i);
       
   767                 }
       
   768                 cout << endl;
       
   769 
       
   770                 if (categoryHeader + 2 + categorySize + 1
       
   771                         > data.words + data.nwords) {
       
   772                     err << "SII data seem to be corrupted!"; 
       
   773                     throw MasterException(err.str());
       
   774                 }
       
   775                 categoryHeader += 2 + categorySize;
       
   776                 categoryType = le16tocpu(*categoryHeader);
       
   777             }
       
   778         }
       
   779     } else {
       
   780         for (i = 0; i < data.nwords; i++) {
       
   781             uint16_t *w = data.words + i;
       
   782             cout << *(uint8_t *) w << *((uint8_t *) w + 1);
       
   783         }
   726     }
   784     }
   727 
   785 
   728     delete [] data.words;
   786     delete [] data.words;
   729 }
   787 }
   730 
   788 
   793                 << ". Use --force to write anyway.";
   851                 << ". Use --force to write anyway.";
   794             throw MasterException(err.str());
   852             throw MasterException(err.str());
   795         }
   853         }
   796 
   854 
   797         // cycle through categories to detect corruption
   855         // cycle through categories to detect corruption
   798         categoryHeader = data.words + 0x0040;
   856         categoryHeader = data.words + 0x0040U;
   799         categoryType = le16tocpu(*categoryHeader);
   857         categoryType = le16tocpu(*categoryHeader);
   800         while (categoryType != 0xffff) {
   858         while (categoryType != 0xffff) {
   801             if (categoryHeader + 1 > data.words + data.nwords) {
   859             if (categoryHeader + 1 > data.words + data.nwords) {
   802                 err << "SII data seem to be corrupted! "
   860                 err << "SII data seem to be corrupted! "
   803                     << "Use --force to write anyway.";
   861                     << "Use --force to write anyway.";
   804                 throw MasterException(err.str());
   862                 throw MasterException(err.str());
   805             }
   863             }
   806             categorySize = le16tocpu(*(categoryHeader + 1));
   864             categorySize = le16tocpu(*(categoryHeader + 1));
   807             if (categoryHeader + categorySize + 2 > data.words + data.nwords) {
   865             if (categoryHeader + 2 + categorySize + 1
       
   866                     > data.words + data.nwords) {
   808                 err << "SII data seem to be corrupted! "
   867                 err << "SII data seem to be corrupted! "
   809                     "Use --force to write anyway.";
   868                     "Use --force to write anyway.";
   810                 throw MasterException(err.str());
   869                 throw MasterException(err.str());
   811             }
   870             }
   812             categoryHeader += categorySize + 2;
   871             categoryHeader += 2 + categorySize;
   813             categoryType = le16tocpu(*categoryHeader);
   872             categoryType = le16tocpu(*categoryHeader);
   814         }
   873         }
   815     }
   874     }
   816 
   875 
   817     // send data to master
   876     // send data to master