← Back to branch summary

~ubuntu-branches/ubuntu/trusty/libticalcs/trusty-proposed

« back to all changes in this revision

Viewing changes to src/romdump_9x/romdump.c

  • Committer: Package Import Robot
  • Author(s): Andreas B. Mundt
  • Date: 2013-08-27 19:58:21 UTC
  • mfrom: (2.1.2 sid)
  • Revision ID: package-import@ubuntu.com-20130827195821-biurlicyqb65gj3g
Tags: 1.1.8+dfsg2-2
* Provide original upstream source, but patch away pre-compiled
  binaries to be policy-compliant.
* Remove unnecessary dependency on 'autopoint', use autoreconf.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/romdump_9x/romdump.c
16
16
 *  GNU General Public License for more details.
17
17
 *
18
18
 *  You should have received a copy of the GNU General Public License
19
 
 *  along with this program; if not, write to the Free Software
20
 
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
19
 *  along with this program; if not, write to the Free Software Foundation,
 
20
 *  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21
21
 */
22
22
 
23
23
/*
41
41
 
42
42
// --- Packet Layer
43
43
 
44
 
#define BLK_SIZE        4096
45
 
static uint8_t buf[BLK_SIZE + 3*2];
 
44
#define BLK_SIZE (4096)
46
45
 
47
 
uint16_t CheckSum(uint8_t* data, uint16_t len)
 
46
static uint16_t CheckSum(uint8_t* data, uint16_t len)
48
47
{
49
 
        uint16_t i;     
 
48
        uint16_t i;
50
49
        uint16_t sum = 0;
51
 
        
 
50
 
52
51
        for(i = 0; i < len; i++)
 
52
        {
53
53
                sum += data[i];
54
 
                
55
 
                return sum;
 
54
        }
 
55
 
 
56
        return sum;
56
57
}
57
58
 
58
 
int SendPacket(uint16_t cmd, uint16_t len, uint8_t* data)
 
59
static int SendPacket(uint8_t* buf, uint16_t cmd, uint16_t len, uint8_t* data)
59
60
{
60
61
        short ret;
61
62
        uint16_t sum;
66
67
        buf[2] = LSB(len);
67
68
        buf[3] = MSB(len);
68
69
 
69
 
  ret = LIO_SendData(buf, 4);
70
 
  if(ret) return ret;
 
70
        ret = LIO_SendData(buf, 4);
 
71
        if(ret) return ret;
71
72
 
72
73
        // data
73
74
        ret = LIO_SendData(data, len);
74
 
  if(ret) return ret;
75
 
        
 
75
        if(ret) return ret;
 
76
 
76
77
        // checksum
77
78
        sum = CheckSum(buf, 4) + CheckSum(data, len);
78
79
        buf[0] = LSB(sum);
79
80
        buf[1] = MSB(sum);
80
81
 
81
 
  // send
 
82
        // send
82
83
        ret = LIO_SendData(buf, 2);
83
 
  if(ret) return ret;
84
 
        
 
84
        if(ret) return ret;
 
85
 
85
86
        return 0;
86
87
}
87
88
 
88
 
int RecvPacket(uint16_t* cmd, uint16_t* len, uint8_t* data)
 
89
static int RecvPacket(uint8_t* buf, uint16_t* cmd, uint16_t* len, uint8_t* data)
89
90
{
90
91
        short ret;
91
92
        uint16_t sum, tmp;
92
 
        
 
93
 
93
94
        // default values
94
95
        *cmd = CMD_NONE;
95
96
        *len = 0;
96
 
        
97
 
  // any packet has always at least 4 bytes (cmd, len)
 
97
 
 
98
        // any packet has always at least 4 bytes (cmd, len)
98
99
        ret = LIO_RecvData(buf, 4, TIMEOUT);
99
100
        if(ret) return ret;
100
 
        
101
 
  *cmd = (buf[1] << 8) | buf[0];
 
101
 
 
102
        *cmd = (buf[1] << 8) | buf[0];
102
103
        *len = (buf[3] << 8) | buf[2];
103
 
  tmp = CheckSum(buf, 4);
104
 
        
 
104
        tmp = CheckSum(buf, 4);
 
105
 
105
106
        // data part
106
107
        if(data)
107
108
        {
108
 
                ret = LIO_RecvData(data, *len, TIMEOUT);        
 
109
                ret = LIO_RecvData(data, *len, TIMEOUT);
109
110
                if(ret) return ret;
110
111
        }
111
 
        
 
112
 
112
113
        // checksum
113
 
  ret = LIO_RecvData(buf+*len, 2, TIMEOUT);
 
114
        ret = LIO_RecvData(buf+*len, 2, TIMEOUT);
114
115
        if(ret) return ret;
115
 
        
 
116
 
116
117
        sum = (buf[*len+1] << 8) | buf[*len+0];
117
118
 
118
119
        if (sum != CheckSum(data, *len) + tmp)
123
124
 
124
125
// --- Command Layer
125
126
 
126
 
inline int Send_OK(void)
127
 
{
128
 
        return SendPacket(CMD_OK, 0, NULL);
129
 
}
130
 
 
131
 
inline int Send_KO(void)
132
 
{
133
 
        return SendPacket(CMD_KO, 0, NULL);
134
 
}
135
 
 
136
 
inline int Send_SIZE(uint32_t size)
 
127
static inline int Send_OK(uint8_t* buf)
 
128
{
 
129
        return SendPacket(buf, CMD_OK, 0, NULL);
 
130
}
 
131
 
 
132
static inline int Send_KO(uint8_t* buf)
 
133
{
 
134
        return SendPacket(buf, CMD_KO, 0, NULL);
 
135
}
 
136
 
 
137
static inline int Send_SIZE(uint8_t* buf, uint32_t size)
137
138
{
138
139
        uint32_t le_size = LE_BE(size);
139
 
        
140
 
        return SendPacket(CMD_REQ_SIZE, 4, (uint8_t *)&le_size);
 
140
 
 
141
        return SendPacket(buf, CMD_REQ_SIZE, 4, (uint8_t *)&le_size);
141
142
}
142
143
 
143
 
inline int Send_DATA(uint16_t len, uint8_t* data)
 
144
static inline int Send_DATA(uint8_t* buf, uint16_t len, uint8_t* data)
144
145
{
145
 
        return SendPacket(CMD_DATA1, len, data);
 
146
        return SendPacket(buf, CMD_DATA1, len, data);
146
147
}
147
148
 
148
 
inline int Send_RDATA(uint16_t data)
 
149
static inline int Send_RDATA(uint8_t* buf, uint16_t data)
149
150
{
150
151
        uint8_t tmp[4];
151
 
        
 
152
 
152
153
        tmp[0] = LSB(BLK_SIZE);
153
154
        tmp[1] = MSB(BLK_SIZE);
154
155
        tmp[2] = LSB(data);
155
156
        tmp[3] = MSB(data);
156
 
        
157
 
        return SendPacket(CMD_DATA2, 4, tmp);
158
 
}
159
 
 
160
 
inline int Send_EXIT(void)
161
 
{
162
 
        return SendPacket(CMD_EXIT, 0, NULL);
163
 
}
164
 
 
165
 
inline int Send_ERR(void)
166
 
{
167
 
        return SendPacket(CMD_ERROR, 0, NULL);
 
157
 
 
158
        return SendPacket(buf, CMD_DATA2, 4, tmp);
 
159
}
 
160
 
 
161
static inline int Send_EXIT(uint8_t* buf)
 
162
{
 
163
        return SendPacket(buf, CMD_EXIT, 0, NULL);
 
164
}
 
165
 
 
166
static inline int Send_ERR(uint8_t* buf)
 
167
{
 
168
        return SendPacket(buf, CMD_ERROR, 0, NULL);
168
169
}
169
170
 
170
171
// --- Dumper Layer
171
172
 
172
 
int Dump(void)
 
173
static int Dump(uint8_t* buf)
173
174
{
174
175
        int exit = 0;
175
176
        int ret;
178
179
        char str[30];
179
180
        unsigned int i;
180
181
        uint8_t* ptr;
181
 
        
 
182
 
182
183
        while(!exit)
183
184
        {
184
185
                // wait for command
185
 
                ret = RecvPacket(&cmd, &len, buf);
 
186
                ret = RecvPacket(buf, &cmd, &len, buf);
186
187
                //if(ret) continue;     // pb with ret val
187
 
                
 
188
 
188
189
                // or keypress
189
190
                if(kbhit()) 
190
191
                        exit = !0;
191
 
                                        
 
192
 
192
193
                // and process
193
194
                switch(cmd)
194
195
                {
195
196
                        case CMD_IS_READY: 
196
 
                                Send_OK();
 
197
                                Send_OK(buf);
197
198
                        break;
198
199
                        case CMD_EXIT: 
199
 
                                Send_EXIT();
 
200
                                Send_EXIT(buf);
200
201
                                exit = !0; 
201
202
                        break;
202
203
                        case CMD_REQ_SIZE: 
203
 
                                Send_SIZE(ROM_size);
204
 
                                
 
204
                                Send_SIZE(buf, ROM_size);
 
205
 
205
206
                                sprintf(str, "Size: %lu KB", ROM_size >> 10);
206
 
                                DrawStr(0, 60, str, A_REPLACE   );
 
207
                                DrawStr(0, 60, str, A_REPLACE);
207
208
                        break;
208
209
                        case CMD_REQ_BLOCK: 
209
 
                          addr  = ((uint32_t)buf[0] <<  0); addr |= ((uint32_t)buf[1] <<  8);
210
 
                          addr |= ((uint32_t)buf[2] << 16); addr |= ((uint32_t)buf[3] << 24);
211
 
                                
 
210
                                addr  = ((uint32_t)buf[0] <<  0); addr |= ((uint32_t)buf[1] <<  8);
 
211
                                addr |= ((uint32_t)buf[2] << 16); addr |= ((uint32_t)buf[3] << 24);
 
212
 
212
213
                                if(addr > ROM_size)
213
 
                                        Send_ERR();
 
214
                                        Send_ERR(buf);
214
215
 
215
 
#if 0                           
 
216
#if 0
216
217
                                if(addr >= 0x10000 && addr < 0x12000)   // read protected (certificate)
217
 
                                        addr = 0;       
 
218
                                        addr = 0;
218
219
                                if(addr >= 0x18000 && addr < 0x1A000)   // read protected (certificate)
219
220
                                        addr = 0;
220
221
#endif
221
 
                        
 
222
 
222
223
                                sprintf(str, "Done: %lu/%luKB     ", addr >> 10, ROM_size >> 10);
223
 
                                DrawStr(0, 60, str, A_REPLACE   );
224
 
                                
 
224
                                DrawStr(0, 60, str, A_REPLACE);
 
225
 
225
226
                                // Check for filled blocks (like 0xff)
226
227
                                ptr = (uint8_t *)(ROM_base + addr);
227
228
                                for(i = 0; i < BLK_SIZE; i++)
228
229
                                        if(ptr[i] != ptr[0])
229
230
                                                break;
230
 
                                
 
231
 
231
232
                                if(i == BLK_SIZE)
232
 
                                        Send_RDATA(ptr[0]);
 
233
                                        Send_RDATA(buf, ptr[0]);
233
234
                                else
234
 
                                        Send_DATA(BLK_SIZE, (uint8_t *)(ROM_base + addr));
 
235
                                        Send_DATA(buf, BLK_SIZE, (uint8_t *)(ROM_base + addr));
235
236
                        break;
236
237
                        case CMD_NONE:
237
238
                        break;
238
239
                        default:
239
 
                        break;                  
 
240
                        break;
240
241
                }
241
 
        }       
242
 
        
 
242
        }
 
243
 
243
244
        //OSLinkClose();
244
245
        return 0;
245
246
}
246
247
 
247
248
// --- Main Function
248
249
 
 
250
 
249
251
void _main(void)
250
252
{
251
 
  char str[30];  
252
 
  
 
253
        char str[30];  
 
254
        uint8_t buf[BLK_SIZE + 3*2];
 
255
 
253
256
#ifdef FARGO
254
 
  // Ugly hack to find LIO_SendData and LIO_RecvData...
255
 
  LIO_SendData=(void*)ERD_dialog;
256
 
  while (*(void**)LIO_SendData!=OSLinkTxQueueInquire) LIO_SendData+=2;
257
 
  LIO_RecvData=(void*)LIO_SendData;
258
 
  LIO_SendData-=28;
259
 
  while (*(void**)LIO_RecvData!=OSReadLinkBlock) LIO_RecvData+=2;
260
 
  LIO_RecvData-=150;
 
257
        // Ugly hack to find LIO_SendData and LIO_RecvData...
 
258
        LIO_SendData=(void*)ERD_dialog;
 
259
        while (*(void**)LIO_SendData!=OSLinkTxQueueInquire) LIO_SendData+=2;
 
260
        LIO_RecvData=(void*)LIO_SendData;
 
261
        LIO_SendData-=28;
 
262
        while (*(void**)LIO_RecvData!=OSReadLinkBlock) LIO_RecvData+=2;
 
263
        LIO_RecvData-=150;
261
264
#endif
262
265
 
263
 
  ClrScr ();
264
 
  FontSetSys (F_8x10);
265
 
  
266
 
  sprintf(str, "RomDumper v%s", VERSION);
267
 
  DrawStr(0, 0, str, A_NORMAL);
268
 
  
 
266
        ClrScr ();
 
267
        FontSetSys (F_8x10);
 
268
 
 
269
        sprintf(str, "RomDumper v%s", VERSION);
 
270
        DrawStr(0, 0, str, A_NORMAL);
 
271
 
269
272
#ifdef FARGO
270
 
  sprintf(str, "Type: TI-92 %i", TI92_VERSION);
 
273
        sprintf(str, "Type: TI-92 %i", TI92_VERSION);
271
274
#else
272
 
  sprintf(str, "Type: HW%i", HW_VERSION);
 
275
        sprintf(str, "Type: HW%i", HW_VERSION);
273
276
#endif
274
 
  DrawStr(0, 20, str, A_NORMAL);
275
 
  
276
 
  sprintf(str, "ROM base: 0x%lx", (uint32_t)ROM_base);
277
 
  DrawStr(0, 40, str, A_NORMAL);  
278
 
  
279
 
  sprintf(str, "by The TiLP Team");
280
 
  DrawStr(0, 80, str, A_NORMAL);  
281
 
 
282
 
  Dump();
283
 
  
284
 
  return;
 
277
        DrawStr(0, 20, str, A_NORMAL);
 
278
 
 
279
        sprintf(str, "ROM base: 0x%lx", (uint32_t)ROM_base);
 
280
        DrawStr(0, 40, str, A_NORMAL);  
 
281
 
 
282
        sprintf(str, "by The TiLP Team");
 
283
        DrawStr(0, 80, str, A_NORMAL);  
 
284
 
 
285
        Dump(buf);
 
286
 
 
287
        return;
285
288
}
286
289