« back to all changes in this revision
Viewing changes to src/dusb_cmd.c
- browse files at revision 5
- compare with another revision
- download diff
- download tarball
- view history from revision 5
- 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.
binaries to be policy-compliant.
* Remove unnecessary dependency on 'autopoint', use autoreconf.
- files added:
- .pc
- .pc/ticalcs2-external-rom-dumpers.patch
- .pc/ticalcs2-external-rom-dumpers.patch/src
- debian/patches
- debian/source
- m4
- src/romdump_84p_usb
- files removed:
- build/fedora
- files modified:
- ABOUT-NLS
added
removed
src/dusb_cmd.c
1
/* Hey EMACS -*- linux-c -*- */
2
/* $Id: cmd84p.c 2077 2006-03-31 21:16:19Z roms $ */
3
4
/* libticalcs - Ti Calculator library, a part of the TiLP project
5
* Copyright (C) 1999-2005 Romain Li�vin
6
*
7
* This program is free software; you can redistribute it and/or modify
8
* it under the terms of the GNU General Public License as published by
9
* the Free Software Foundation; either version 2 of the License, or
10
* (at your option) any later version.
11
*
12
* This program is distributed in the hope that it will be useful,
13
* but WITHOUT ANY WARRANTY; without even the implied warranty of
14
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15
* GNU General Public License for more details.
16
*
17
* You should have received a copy of the GNU General Public License
18
* along with this program; if not, write to the Free Software
19
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
20
*/
21
22
/*
23
This unit handles virtual packet types (commands) thru DirectLink.
24
*/
25
26
// Some functions should be renamed or re-organized...
27
28
#include <stdlib.h>
29
#include <string.h>
30
31
#include "ticalcs.h"
32
#include "logging.h"
33
#include "error.h"
34
#include "macros.h"
35
#include "pause.h"
36
37
#include "dusb_vpkt.h"
38
#include "dusb_cmd.h"
39
40
// Helpers
41
42
GList *cpca_list = NULL;
43
44
CalcParam* cp_new(uint16_t id, uint16_t size)
45
{
46
CalcParam* cp = g_malloc0(sizeof(CalcParam));
47
48
cp->id = id;
49
cp->size = size;
50
cp->data = g_malloc0(size);
51
52
cpca_list = g_list_append(cpca_list, cp);
53
return cp;
54
}
55
56
void cp_del(CalcParam* cp)
57
{
58
cpca_list = g_list_remove(cpca_list, cp);
59
60
g_free(cp->data);
61
g_free(cp);
62
}
63
64
CalcParam** cp_new_array(int size)
65
{
66
CalcParam** array = g_malloc0((size+1) * sizeof(CalcParam *));
67
return array;
68
}
69
70
void cp_del_array(int size, CalcParam **params)
71
{
72
int i;
73
74
for(i = 0; i < size && params[i]; i++)
75
cp_del(params[i]);
76
g_free(params);
77
}
78
79
/////////////----------------
80
81
CalcAttr* ca_new(uint16_t id, uint16_t size)
82
{
83
CalcAttr* cp = g_malloc0(sizeof(CalcAttr));
84
85
cp->id = id;
86
cp->size = size;
87
cp->data = g_malloc0(size);
88
89
cpca_list = g_list_append(cpca_list, cp);
90
return cp;
91
}
92
93
void ca_del(CalcAttr* cp)
94
{
95
cpca_list = g_list_remove(cpca_list, cp);
96
97
g_free(cp->data);
98
g_free(cp);
99
}
100
101
CalcAttr** ca_new_array(int size)
102
{
103
CalcAttr** array = g_malloc0((size+1) * sizeof(CalcParam *));
104
return array;
105
}
106
107
void ca_del_array(int size, CalcAttr **attrs)
108
{
109
int i;
110
111
for(i = 0; i < size && attrs[i]; i++)
112
ca_del(attrs[i]);
113
g_free(attrs);
114
}
115
116
void cpca_purge(void)
117
{
118
//printf("cpca_purge: %p %i\n", cpca_list, g_list_length(cpca_list));
119
g_list_foreach(cpca_list, (GFunc)ca_del, NULL);
120
g_list_free(cpca_list);
121
cpca_list = NULL;
122
}
123
124
/////////////----------------
125
126
static void byteswap(uint8_t *data, uint32_t len)
127
{/*
128
if(len == 2)
129
{
130
uint8_t tmp;
131
132
tmp = data[0];
133
data[0] = data[1];
134
data[1] = tmp;
135
}
136
else if(len == 4)
137
{
138
uint8_t tmp;
139
140
tmp = data[0];
141
data[0] = data[3];
142
data[3] = tmp;
143
144
tmp = data[1];
145
data[1] = data[2];
146
data[2] = tmp;
147
}
148
*/
149
}
150
151
/////////////----------------
152
153
static uint16_t usb_errors[] = {
154
0x0004, 0x0006, 0x0008, 0x0009, 0x000c, 0x000d, 0x000e,
155
0x0011, 0x0012, 0x001c, 0x001d, 0x0022, 0x0029, 0x002b,
156
0x0034 };
157
158
static int err_code(VirtualPacket *pkt)
159
{
160
int i;
161
int code = (pkt->data[0] << 8) | pkt->data[1];
162
163
for(i = 0; i < sizeof(usb_errors) / sizeof(uint16_t); i++)
164
if(usb_errors[i] == code)
165
return i+1;
166
167
ticalcs_warning("USB error code not found in list. Please report it at <tilp-devel@lists.sf.net>.");
168
169
return 0;
170
}
171
172
/////////////----------------
173
174
extern const VtlPktName vpkt_types[];
175
176
#define CATCH_DELAY() \
177
if(pkt->type == VPKT_DELAY_ACK) \
178
{ \
179
uint32_t delay = (pkt->data[0] << 24) | (pkt->data[1] << 16) | (pkt->data[2] << 8) | (pkt->data[3] << 0); \
180
ticalcs_info(" delay = %u\n", delay); \
181
\
182
PAUSE(delay/1000); \
183
\
184
dusb_vtl_pkt_del(pkt); \
185
pkt = dusb_vtl_pkt_new(0, 0); \
186
TRYF(dusb_recv_data(h, pkt)); \
187
}
188
189
// 0x0001: set mode or ping
190
int cmd_s_mode_set(CalcHandle *h, ModeSet mode)
191
{
192
VirtualPacket* pkt;
193
194
TRYF(dusb_send_buf_size_request(h, DUSB_DFL_BUF_SIZE));
195
TRYF(dusb_recv_buf_size_alloc(h, NULL));
196
197
pkt = dusb_vtl_pkt_new(sizeof(mode), VPKT_PING);
198
pkt->data[0] = MSB(mode.arg1);
199
pkt->data[1] = LSB(mode.arg1);
200
pkt->data[2] = MSB(mode.arg2);
201
pkt->data[3] = LSB(mode.arg2);
202
pkt->data[4] = MSB(mode.arg3);
203
pkt->data[5] = LSB(mode.arg3);
204
pkt->data[6] = MSB(mode.arg4);
205
pkt->data[7] = LSB(mode.arg4);
206
pkt->data[8] = MSB(mode.arg5);
207
pkt->data[9] = LSB(mode.arg5);
208
TRYF(dusb_send_data(h, pkt));
209
210
dusb_vtl_pkt_del(pkt);
211
ticalcs_info(" %04x %04x %04x %04x %04x", mode.arg1, mode.arg2, mode.arg3, mode.arg4, mode.arg5);
212
213
return 0;
214
}
215
216
// 0x0002: begin OS transfer
217
int cmd_s_os_begin(CalcHandle *h, uint32_t size)
218
{
219
VirtualPacket* pkt;
220
221
pkt = dusb_vtl_pkt_new(11, VPKT_OS_BEGIN);
222
pkt->data[7] = MSB(MSW(size));
223
pkt->data[8] = LSB(MSW(size));
224
pkt->data[9] = MSB(LSW(size));
225
pkt->data[10]= LSB(LSW(size));
226
TRYF(dusb_send_data(h, pkt));
227
228
dusb_vtl_pkt_del(pkt);
229
ticalcs_info(" size = %08x (%i)", size, size);
230
231
return 0;
232
}
233
234
// 0x0003: acknowledgement of OS transfer
235
int cmd_r_os_ack(CalcHandle *h, uint32_t *size)
236
{
237
VirtualPacket* pkt;
238
239
pkt = dusb_vtl_pkt_new(0, 0);
240
TRYF(dusb_recv_data(h, pkt));
241
242
CATCH_DELAY();
243
244
if(pkt->type == VPKT_ERROR)
245
return ERR_CALC_ERROR2 + err_code(pkt);
246
else if(pkt->type != VPKT_OS_ACK)
247
return ERR_INVALID_PACKET;
248
249
*size = (pkt->data[0] << 24) | (pkt->data[1] << 16) | (pkt->data[2] << 8) | (pkt->data[3] << 0);
250
251
dusb_vtl_pkt_del(pkt);
252
ticalcs_info(" size = %08x (%i)", *size, *size);
253
254
return 0;
255
}
256
257
static int s_os(uint8_t type, CalcHandle *h, uint16_t addr, uint8_t page, uint8_t flag, uint32_t size, uint8_t *data)
258
{
259
VirtualPacket* pkt;
260
261
pkt = dusb_vtl_pkt_new(4 + size, type);
262
263
pkt->data[0] = MSB(addr);
264
pkt->data[1] = LSB(addr);
265
pkt->data[2] = page;
266
pkt->data[3] = flag;
267
memcpy(pkt->data+4, data, size);
268
TRYF(dusb_send_data(h, pkt));
269
270
dusb_vtl_pkt_del(pkt);
271
ticalcs_info(" addr=%04x, page=%02x, flag=%02x, size=%04x", addr, page, flag, size);
272
273
return 0;
274
}
275
276
// 0x0004: OS header
277
int cmd_s_os_header(CalcHandle *h, uint16_t addr, uint8_t page, uint8_t flag, uint32_t size, uint8_t *data)
278
{
279
return s_os(VPKT_OS_HEADER, h, addr, page, flag, size, data);
280
}
281
282
// 0x0005: OS data
283
int cmd_s_os_data(CalcHandle *h, uint16_t addr, uint8_t page, uint8_t flag, uint32_t size, uint8_t *data)
284
{
285
return s_os(VPKT_OS_DATA, h, addr, page, flag, size, data);
286
}
287
288
// 0x0004: OS header
289
int cmd_s_os_header_89(CalcHandle *h, uint32_t size, uint8_t *data)
290
{
291
VirtualPacket* pkt;
292
293
pkt = dusb_vtl_pkt_new(size, VPKT_OS_HEADER);
294
memcpy(pkt->data, data, size);
295
TRYF(dusb_send_data(h, pkt));
296
297
dusb_vtl_pkt_del(pkt);
298
ticalcs_info(" size = %08x (%i)", size, size);
299
300
return 0;
301
}
302
303
// 0x0005: OS data
304
int cmd_s_os_data_89(CalcHandle *h, uint32_t size, uint8_t *data)
305
{
306
VirtualPacket* pkt;
307
308
pkt = dusb_vtl_pkt_new(size, VPKT_OS_DATA);
309
memcpy(pkt->data, data, size);
310
TRYF(dusb_send_data(h, pkt));
311
312
dusb_vtl_pkt_del(pkt);
313
ticalcs_info(" size = %08x (%i)", size, size);
314
315
return 0;
316
}
317
318
// 0x0006: acknowledgement of EOT
319
int cmd_r_eot_ack(CalcHandle *h)
320
{
321
VirtualPacket* pkt;
322
323
pkt = dusb_vtl_pkt_new(0, 0);
324
TRYF(dusb_recv_data(h, pkt));
325
326
CATCH_DELAY();
327
328
if(pkt->type == VPKT_ERROR)
329
return ERR_CALC_ERROR2 + err_code(pkt);
330
else if(pkt->type != VPKT_EOT_ACK)
331
return ERR_INVALID_PACKET;
332
333
dusb_vtl_pkt_del(pkt);
334
335
return 0;
336
}
337
338
// 0x0007: parameter request
339
int cmd_s_param_request(CalcHandle *h, int npids, uint16_t *pids)
340
{
341
VirtualPacket* pkt;
342
int i;
343
344
pkt = dusb_vtl_pkt_new((npids + 1) * sizeof(uint16_t), VPKT_PARM_REQ);
345
346
pkt->data[0] = MSB(npids);
347
pkt->data[1] = LSB(npids);
348
349
for(i = 0; i < npids; i++)
350
{
351
pkt->data[2*(i+1) + 0] = MSB(pids[i]);
352
pkt->data[2*(i+1) + 1] = LSB(pids[i]);
353
}
354
355
TRYF(dusb_send_data(h, pkt));
356
357
dusb_vtl_pkt_del(pkt);
358
ticalcs_info(" npids=%i", npids);
359
360
return 0;
361
}
362
363
// 0x0008: parameter data
364
int cmd_r_param_data(CalcHandle *h, int nparams, CalcParam **params)
365
{
366
VirtualPacket* pkt;
367
int i, j;
368
369
pkt = dusb_vtl_pkt_new(0, 0);
370
TRYF(dusb_recv_data(h, pkt));
371
372
CATCH_DELAY();
373
374
if(pkt->type == VPKT_ERROR)
375
return ERR_CALC_ERROR2 + err_code(pkt);
376
else if(pkt->type != VPKT_PARM_DATA)
377
return ERR_INVALID_PACKET;
378
379
if(((pkt->data[j=0] << 8) | pkt->data[j=1]) != nparams)
380
return ERR_INVALID_PACKET;
381
382
for(i = 0, j = 2; i < nparams; i++)
383
{
384
CalcParam *s = params[i] = cp_new(0, 0);
385
386
s->id = pkt->data[j++] << 8; s->id |= pkt->data[j++];
387
s->ok = !pkt->data[j++];
388
if(s->ok)
389
{
390
s->size = pkt->data[j++] << 8; s->size |= pkt->data[j++];
391
s->data = (uint8_t *)g_malloc0(s->size);
392
memcpy(s->data, &pkt->data[j], s->size);
393
j += s->size;
394
}
395
}
396
397
dusb_vtl_pkt_del(pkt);
398
ticalcs_info(" nparams=%i", nparams);
399
400
return 0;
401
}
402
403
// 0x0009: request directory listing
404
int cmd_s_dirlist_request(CalcHandle *h, int naids, uint16_t *aids)
405
{
406
VirtualPacket* pkt;
407
int i;
408
int j = 0;
409
410
pkt = dusb_vtl_pkt_new(4 + 2*naids + 7, VPKT_DIR_REQ);
411
412
pkt->data[j++] = MSB(MSW(naids));
413
pkt->data[j++] = LSB(MSW(naids));
414
pkt->data[j++] = MSB(LSW(naids));
415
pkt->data[j++] = LSB(LSW(naids));
416
417
for(i = 0; i < naids; i++)
418
{
419
pkt->data[j++] = MSB(aids[i]);
420
pkt->data[j++] = LSB(aids[i]);
421
}
422
423
pkt->data[j++] = 0x00; pkt->data[j++] = 0x01;
424
pkt->data[j++] = 0x00; pkt->data[j++] = 0x01;
425
pkt->data[j++] = 0x00; pkt->data[j++] = 0x01;
426
pkt->data[j++] = 0x01;
427
428
TRYF(dusb_send_data(h, pkt));
429
430
dusb_vtl_pkt_del(pkt);
431
ticalcs_info(" naids=%i", naids);
432
433
return 0;
434
}
435
436
// 0x000A: variable header (name is utf-8)
437
// beware: attr array contents is allocated by function
438
int cmd_r_var_header(CalcHandle *h, char *folder, char *name, CalcAttr **attr)
439
{
440
VirtualPacket* pkt;
441
uint8_t fld_len;
442
uint8_t var_len;
443
int nattr;
444
int i, j;
445
446
pkt = dusb_vtl_pkt_new(0, 0);
447
TRYF(dusb_recv_data(h, pkt));
448
449
CATCH_DELAY();
450
451
if(pkt->type == VPKT_EOT)
452
{
453
dusb_vtl_pkt_del(pkt);
454
return ERR_EOT;
455
}
456
else if(pkt->type == VPKT_ERROR)
457
return ERR_CALC_ERROR2 + err_code(pkt);
458
else if(pkt->type != VPKT_VAR_HDR)
459
return ERR_INVALID_PACKET;
460
461
j = 0;
462
fld_len = pkt->data[j++];
463
strcpy(folder, "");
464
if(fld_len)
465
{
466
memcpy(folder, &pkt->data[j], fld_len+1);
467
j += fld_len+1;
468
}
469
var_len = pkt->data[j++];
470
strcpy(name, "");
471
if(var_len)
472
{
473
memcpy(name, &pkt->data[j], var_len+1);
474
j += var_len+1;
475
}
476
477
nattr = (pkt->data[j+0] << 8) | pkt->data[j+1];
478
j += 2;
479
480
for(i = 0; i < nattr; i++)
481
{
482
CalcAttr *s = attr[i] = ca_new(0, 0);
483
484
s->id = pkt->data[j++] << 8; s->id |= pkt->data[j++];
485
s->ok = !pkt->data[j++];
486
if(s->ok)
487
{
488
s->size = pkt->data[j++] << 8; s->size |= pkt->data[j++];
489
s->data = (uint8_t *)g_malloc0(s->size);
490
memcpy(s->data, &pkt->data[j], s->size);
491
j += s->size;
492
}
493
}
494
495
dusb_vtl_pkt_del(pkt);
496
ticalcs_info(" folder=%s, name=%s", folder, name);
497
498
return 0;
499
}
500
501
// 0x000B: request to send
502
int cmd_s_rts(CalcHandle *h, const char *folder, const char *name, uint32_t size, int nattrs, const CalcAttr **attrs)
503
{
504
VirtualPacket* pkt;
505
int pks;
506
int i;
507
int j = 0;
508
509
pks = 2 + strlen(name)+1 + 5 + 2;
510
if(strlen(folder))
511
pks += strlen(folder)+1;
512
for(i = 0; i < nattrs; i++) pks += 4 + attrs[i]->size;
513
pkt = dusb_vtl_pkt_new(pks, VPKT_RTS);
514
515
if(strlen(folder))
516
{
517
pkt->data[j++] = strlen(folder);
518
memcpy(pkt->data + j, folder, strlen(folder)+1);
519
j += strlen(folder)+1;
520
}
521
else
522
pkt->data[j++] = 0;
523
524
pkt->data[j++] = strlen(name);
525
memcpy(pkt->data + j, name, strlen(name)+1);
526
j += strlen(name)+1;
527
528
pkt->data[j++] = MSB(MSW(size));
529
pkt->data[j++] = LSB(MSW(size));
530
pkt->data[j++] = MSB(LSW(size));
531
pkt->data[j++] = LSB(LSW(size));
532
pkt->data[j++] = 0x01;
533
534
pkt->data[j++] = MSB(nattrs);
535
pkt->data[j++] = LSB(nattrs);
536
for(i = 0; i < nattrs; i++)
537
{
538
pkt->data[j++] = MSB(attrs[i]->id);
539
pkt->data[j++] = LSB(attrs[i]->id);
540
pkt->data[j++] = MSB(attrs[i]->size);
541
pkt->data[j++] = LSB(attrs[i]->size);
542
memcpy(pkt->data + j, attrs[i]->data, attrs[i]->size);
543
byteswap(pkt->data + j, attrs[i]->size);
544
j += attrs[i]->size;
545
}
546
547
TRYF(dusb_send_data(h, pkt));
548
549
dusb_vtl_pkt_del(pkt);
550
ticalcs_info(" folder=%s, name=%s, size=%i, nattrs=%i", folder, name, size, nattrs);
551
552
return 0;
553
}
554
555
// 0x000C: variable request
556
int cmd_s_var_request(CalcHandle *h, const char *folder, const char *name,
557
int naids, uint16_t *aids,
558
int nattrs, const CalcAttr **attrs)
559
{
560
VirtualPacket* pkt;
561
int pks;
562
int i;
563
int j = 0;
564
565
pks = 2 + strlen(name)+1 + 5 + 2 + 2*naids + 2;
566
if(strlen(folder)) pks += strlen(folder)+1;
567
for(i = 0; i < nattrs; i++) pks += 4 + attrs[i]->size;
568
pks += 2;
569
pkt = dusb_vtl_pkt_new(pks, VPKT_VAR_REQ);
570
571
if(strlen(folder))
572
{
573
pkt->data[j++] = strlen(folder);
574
memcpy(pkt->data + j, folder, strlen(folder)+1);
575
j += strlen(folder)+1;
576
}
577
else
578
pkt->data[j++] = 0;
579
580
pkt->data[j++] = strlen(name);
581
memcpy(pkt->data + j, name, strlen(name)+1);
582
j += strlen(name)+1;
583
584
pkt->data[j++] = 0x01;
585
pkt->data[j++] = 0xFF; pkt->data[j++] = 0xFF;
586
pkt->data[j++] = 0xFF; pkt->data[j++] = 0xFF;
587
588
pkt->data[j++] = MSB(naids);
589
pkt->data[j++] = LSB(naids);
590
for(i = 0; i < naids; i++)
591
{
592
pkt->data[j++] = MSB(aids[i]);
593
pkt->data[j++] = LSB(aids[i]);
594
}
595
596
pkt->data[j++] = MSB(nattrs);
597
pkt->data[j++] = LSB(nattrs);
598
for(i = 0; i < nattrs; i++)
599
{
600
pkt->data[j++] = MSB(attrs[i]->id);
601
pkt->data[j++] = LSB(attrs[i]->id);
602
pkt->data[j++] = MSB(attrs[i]->size);
603
pkt->data[j++] = LSB(attrs[i]->size);
604
memcpy(pkt->data + j, attrs[i]->data, attrs[i]->size);
605
byteswap(pkt->data + j, attrs[i]->size);
606
j += attrs[i]->size;
607
}
608
pkt->data[j++] = 0x00; pkt->data[j++] = 0x00;
609
610
TRYF(dusb_send_data(h, pkt));
611
612
dusb_vtl_pkt_del(pkt);
613
ticalcs_info(" folder=%s, name=%s, naids=%i, nattrs=%i", folder, name, naids, nattrs);
614
615
return 0;
616
}
617
618
// 0x000D: variable contents (recv)
619
int cmd_r_var_content(CalcHandle *h, uint32_t *size, uint8_t **data)
620
{
621
VirtualPacket* pkt;
622
623
pkt = dusb_vtl_pkt_new(0, 0);
624
TRYF(dusb_recv_data(h, pkt));
625
626
CATCH_DELAY();
627
628
if(pkt->type == VPKT_ERROR)
629
return ERR_CALC_ERROR2 + err_code(pkt);
630
else if(pkt->type != VPKT_VAR_CNTS)
631
return ERR_INVALID_PACKET;
632
633
if(size != NULL)
634
*size = pkt->size;
635
636
*data = g_malloc0(pkt->size);
637
memcpy(*data, pkt->data, pkt->size);
638
639
dusb_vtl_pkt_del(pkt);
640
ticalcs_info(" size=%i", size);
641
642
return 0;
643
}
644
645
// 0x000D: variable contents (send)
646
int cmd_s_var_content(CalcHandle *h, uint32_t size, uint8_t *data)
647
{
648
VirtualPacket* pkt;
649
650
pkt = dusb_vtl_pkt_new(size, VPKT_VAR_CNTS);
651
652
memcpy(pkt->data, data, size);
653
TRYF(dusb_send_data(h, pkt));
654
655
dusb_vtl_pkt_del(pkt);
656
ticalcs_info(" size=%i", size);
657
658
return 0;
659
}
660
661
// 0x000E: parameter set
662
int cmd_s_param_set(CalcHandle *h, const CalcParam *param)
663
{
664
VirtualPacket* pkt;
665
666
pkt = dusb_vtl_pkt_new(2 + 2 + param->size, VPKT_PARM_SET);
667
668
pkt->data[0] = MSB(param->id);
669
pkt->data[1] = LSB(param->id);
670
pkt->data[2] = MSB(param->size);
671
pkt->data[3] = LSB(param->size);
672
memcpy(pkt->data + 4, param->data, param->size);
673
674
TRYF(dusb_send_data(h, pkt));
675
676
dusb_vtl_pkt_del(pkt);
677
ticalcs_info(" pid=%04x, size=%04x", param->id, param->size);
678
679
return 0;
680
}
681
682
// 0x0010: variable delete
683
int cmd_s_var_delete(CalcHandle *h, const char *folder, const char *name, int nattrs, const CalcAttr **attrs)
684
{
685
VirtualPacket* pkt;
686
int i;
687
int j = 0;
688
int pks;
689
690
pks = 2 + strlen(name)+1 + 2;
691
if(strlen(folder))
692
pks += strlen(folder)+1;
693
for(i = 0; i < nattrs; i++) pks += 4 + attrs[i]->size;
694
pks += 5;
695
pkt = dusb_vtl_pkt_new(pks, VPKT_DEL_VAR);
696
697
if(strlen(folder))
698
{
699
pkt->data[j++] = strlen(folder);
700
memcpy(pkt->data + j, folder, strlen(folder)+1);
701
j += strlen(folder)+1;
702
}
703
else
704
pkt->data[j++] = 0;
705
706
pkt->data[j++] = strlen(name);
707
memcpy(pkt->data + j, name, strlen(name)+1);
708
j += strlen(name)+1;
709
710
pkt->data[j++] = MSB(nattrs);
711
pkt->data[j++] = LSB(nattrs);
712
for(i = 0; i < nattrs; i++)
713
{
714
pkt->data[j++] = MSB(attrs[i]->id);
715
pkt->data[j++] = LSB(attrs[i]->id);
716
pkt->data[j++] = MSB(attrs[i]->size);
717
pkt->data[j++] = LSB(attrs[i]->size);
718
memcpy(pkt->data + j, attrs[i]->data, attrs[i]->size);
719
byteswap(pkt->data + j, attrs[i]->size);
720
j += attrs[i]->size;
721
}
722
723
pkt->data[j++] = 0x01; pkt->data[j++] = 0x00;
724
pkt->data[j++] = 0x00; pkt->data[j++] = 0x00;
725
pkt->data[j++] = 0x00;
726
727
TRYF(dusb_send_data(h, pkt));
728
729
dusb_vtl_pkt_del(pkt);
730
ticalcs_info(" folder=%s, name=%s, nattrs=%i", folder, name, nattrs);
731
732
return 0;
733
}
734
735
// 0x0011: remote control
736
int cmd_s_execute(CalcHandle *h, const char *folder, const char *name,
737
uint8_t action, const char *args, uint16_t code)
738
{
739
VirtualPacket* pkt;
740
int pks;
741
int j = 0;
742
743
pks = 3;
744
if(args) pks += strlen(args); else pks += 2;
745
if(strlen(folder)) pks += strlen(folder)+1;
746
if(strlen(name)) pks += strlen(name)+1;
747
pkt = dusb_vtl_pkt_new(pks, VPKT_EXECUTE);
748
749
pkt->data[j++] = strlen(folder);
750
if(strlen(folder))
751
{
752
memcpy(pkt->data + j, folder, strlen(folder)+1);
753
j += strlen(folder)+1;
754
}
755
756
pkt->data[j++] = strlen(name);
757
if(strlen(name))
758
{
759
memcpy(pkt->data + j, name, strlen(name)+1);
760
j += strlen(name)+1;
761
}
762
763
pkt->data[j++] = action;
764
765
if(action != EID_KEY && args != NULL)
766
memcpy(pkt->data + j, args, strlen(args));
767
else if(action == EID_KEY || args == NULL)
768
{
769
if(h->model == CALC_TI89T_USB)
770
{
771
pkt->data[j++] = MSB(code);
772
pkt->data[j++] = LSB(code);
773
}
774
else if(h->model == CALC_TI84P_USB)
775
{
776
pkt->data[j++] = LSB(code);
777
pkt->data[j++] = MSB(code);
778
}
779
}
780
781
TRYF(dusb_send_data(h, pkt));
782
783
dusb_vtl_pkt_del(pkt);
784
if(args)
785
ticalcs_info(" action=%i, folder=%s, name=%s, args=%s", action, folder, name, args);
786
else
787
ticalcs_info(" action=%i, keycode=%04x", action, code);
788
789
return 0;
790
}
791
792
// 0x0012: acknowledgement of mode setting
793
int cmd_r_mode_ack(CalcHandle *h)
794
{
795
VirtualPacket* pkt;
796
797
pkt = dusb_vtl_pkt_new(0, 0);
798
TRYF(dusb_recv_data(h, pkt));
799
800
CATCH_DELAY();
801
802
if(pkt->type == VPKT_ERROR)
803
return ERR_CALC_ERROR2 + err_code(pkt);
804
else if(pkt->type != VPKT_MODE_SET)
805
return ERR_INVALID_PACKET;
806
807
dusb_vtl_pkt_del(pkt);
808
809
return 0;
810
}
811
812
// 0xAA00: acknowledgement of data
813
int cmd_r_data_ack(CalcHandle *h)
814
{
815
VirtualPacket* pkt;
816
817
pkt = dusb_vtl_pkt_new(0, 0);
818
TRYF(dusb_recv_data(h, pkt));
819
820
CATCH_DELAY();
821
822
if(pkt->type == VPKT_ERROR)
823
return ERR_CALC_ERROR2 + err_code(pkt);
824
else if(pkt->type != VPKT_DATA_ACK)
825
return ERR_INVALID_PACKET;
826
827
dusb_vtl_pkt_del(pkt);
828
829
return 0;
830
}
831
832
// 0xBB00: delay acknowledgement
833
int cmd_r_delay_ack(CalcHandle *h)
834
{
835
VirtualPacket* pkt;
836
837
pkt = dusb_vtl_pkt_new(0, 0);
838
TRYF(dusb_recv_data(h, pkt));
839
840
if(pkt->type == VPKT_ERROR)
841
return ERR_CALC_ERROR2 + err_code(pkt);
842
else if(pkt->type != VPKT_DELAY_ACK)
843
return ERR_INVALID_PACKET;
844
845
PAUSE(100);
846
847
dusb_vtl_pkt_del(pkt);
848
849
return 0;
850
}
851
852
// 0xDD00: end of transmission (send)
853
int cmd_s_eot(CalcHandle *h)
854
{
855
VirtualPacket* pkt;
856
857
pkt = dusb_vtl_pkt_new(0, VPKT_EOT);
858
TRYF(dusb_send_data(h, pkt));
859
860
dusb_vtl_pkt_del(pkt);
861
862
return 0;
863
}
864
865
// 0xDD00: end of transmission (recv)
866
int cmd_r_eot(CalcHandle *h)
867
{
868
VirtualPacket* pkt;
869
870
pkt = dusb_vtl_pkt_new(0, 0);
871
TRYF(dusb_recv_data(h, pkt));
872
873
CATCH_DELAY();
874
875
if(pkt->type == VPKT_ERROR)
876
return ERR_CALC_ERROR2 + err_code(pkt);
877
else if(pkt->type != VPKT_EOT)
878
return ERR_INVALID_PACKET;
879
880
dusb_vtl_pkt_del(pkt);
881
882
return 0;
883
}
884
885
// 0xEE00: error
886
int cmd_s_error(CalcHandle *h, uint16_t code)
887
{
888
VirtualPacket* pkt;
889
890
pkt = dusb_vtl_pkt_new(2, VPKT_ERROR);
891
892
pkt->data[0] = MSB(code);
893
pkt->data[1] = LSB(code);
894
TRYF(dusb_send_data(h, pkt));
895
896
dusb_vtl_pkt_del(pkt);
897
ticalcs_info(" code = %04x", code);
898
899
return 0;
900
}
1
/* Hey EMACS -*- linux-c -*- */
2
/* $Id: cmd84p.c 2077 2006-03-31 21:16:19Z roms $ */
3
4
/* libticalcs - Ti Calculator library, a part of the TiLP project
5
* Copyright (C) 1999-2005 Romain Li�vin
6
*
7
* This program is free software; you can redistribute it and/or modify
8
* it under the terms of the GNU General Public License as published by
9
* the Free Software Foundation; either version 2 of the License, or
10
* (at your option) any later version.
11
*
12
* This program is distributed in the hope that it will be useful,
13
* but WITHOUT ANY WARRANTY; without even the implied warranty of
14
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15
* GNU General Public License for more details.
16
*
17
* You should have received a copy of the GNU General Public License
18
* along with this program; if not, write to the Free Software Foundation,
19
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
*/
21
22
/*
23
This unit handles virtual packet types (commands) thru DirectLink.
24
*/
25
26
// Some functions should be renamed or re-organized...
27
28
#include <stdlib.h>
29
#include <string.h>
30
31
#include "ticalcs.h"
32
#include "logging.h"
33
#include "error.h"
34
#include "macros.h"
35
#include "pause.h"
36
37
#include "dusb_vpkt.h"
38
#include "dusb_cmd.h"
39
40
// Helpers
41
42
GList *cpca_list = NULL;
43
44
TIEXPORT3 DUSBCalcParam* TICALL dusb_cp_new(uint16_t id, uint16_t size)
45
{
46
DUSBCalcParam* cp = g_malloc0(sizeof(DUSBCalcParam)); // aborts the program if it fails.
47
48
cp->id = id;
49
cp->size = size;
50
cp->data = g_malloc0(size); // aborts the program if it fails.
51
52
cpca_list = g_list_append(cpca_list, cp);
53
54
return cp;
55
}
56
57
TIEXPORT3 void TICALL dusb_cp_del(DUSBCalcParam* cp)
58
{
59
if (cp != NULL)
60
{
61
cpca_list = g_list_remove(cpca_list, cp);
62
63
g_free(cp->data);
64
g_free(cp);
65
}
66
else
67
{
68
ticalcs_critical("%s: cp is NULL", __FUNCTION__);
69
}
70
}
71
72
TIEXPORT3 DUSBCalcParam** TICALL dusb_cp_new_array(int size)
73
{
74
DUSBCalcParam** array = g_malloc0((size+1) * sizeof(DUSBCalcParam *)); // aborts the program if it fails.
75
return array;
76
}
77
78
TIEXPORT3 void TICALL dusb_cp_del_array(int size, DUSBCalcParam **params)
79
{
80
int i;
81
82
if (params != NULL)
83
{
84
for(i = 0; i < size && params[i]; i++)
85
{
86
dusb_cp_del(params[i]);
87
}
88
g_free(params);
89
}
90
else
91
{
92
ticalcs_critical("%s: params is NULL", __FUNCTION__);
93
}
94
95
}
96
97
/////////////----------------
98
99
TIEXPORT3 DUSBCalcAttr* TICALL dusb_ca_new(uint16_t id, uint16_t size)
100
{
101
DUSBCalcAttr* cp = g_malloc0(sizeof(DUSBCalcAttr)); // aborts the program if it fails.
102
103
cp->id = id;
104
cp->size = size;
105
cp->data = g_malloc0(size); // aborts the program if it fails.
106
107
cpca_list = g_list_append(cpca_list, cp);
108
109
return cp;
110
}
111
112
TIEXPORT3 void TICALL dusb_ca_del(DUSBCalcAttr* cp)
113
{
114
if (cp != NULL)
115
{
116
cpca_list = g_list_remove(cpca_list, cp);
117
118
g_free(cp->data);
119
g_free(cp);
120
}
121
else
122
{
123
ticalcs_critical("%s: cp is NULL", __FUNCTION__);
124
}
125
}
126
127
TIEXPORT3 DUSBCalcAttr** TICALL dusb_ca_new_array(int size)
128
{
129
DUSBCalcAttr** array = g_malloc0((size+1) * sizeof(DUSBCalcAttr *)); // aborts the program if it fails.
130
return array;
131
}
132
133
TIEXPORT3 void TICALL dusb_ca_del_array(int size, DUSBCalcAttr **attrs)
134
{
135
int i;
136
137
if (attrs != NULL)
138
{
139
for(i = 0; i < size && attrs[i]; i++)
140
{
141
dusb_ca_del(attrs[i]);
142
}
143
g_free(attrs);
144
}
145
else
146
{
147
ticalcs_critical("%s: attrs is NULL", __FUNCTION__);
148
}
149
}
150
151
void dusb_cpca_purge(void)
152
{
153
//printf("cpca_purge: %p %i\n", cpca_list, g_list_length(cpca_list));
154
g_list_foreach(cpca_list, (GFunc)dusb_ca_del, NULL);
155
g_list_free(cpca_list);
156
cpca_list = NULL;
157
}
158
159
/////////////----------------
160
161
static void byteswap(uint8_t *data, uint32_t len)
162
{/*
163
if(len == 2)
164
{
165
uint8_t tmp;
166
167
tmp = data[0];
168
data[0] = data[1];
169
data[1] = tmp;
170
}
171
else if(len == 4)
172
{
173
uint8_t tmp;
174
175
tmp = data[0];
176
data[0] = data[3];
177
data[3] = tmp;
178
179
tmp = data[1];
180
data[1] = data[2];
181
data[2] = tmp;
182
}
183
*/
184
}
185
186
/////////////----------------
187
188
static const uint16_t usb_errors[] = {
189
0x0004, 0x0006, 0x0008, 0x0009, 0x000c, 0x000d, 0x000e,
190
0x0011, 0x0012, 0x001c, 0x001d, 0x0022, 0x0027, 0x0029,
191
0x002b, 0x002e, 0x0034 };
192
193
static int err_code(DUSBVirtualPacket *pkt)
194
{
195
int i;
196
int code = (pkt->data[0] << 8) | pkt->data[1];
197
198
for(i = 0; i < (int)(sizeof(usb_errors) / sizeof(usb_errors[0])); i++)
199
if(usb_errors[i] == code)
200
return i+1;
201
202
ticalcs_warning("USB error code 0x%02x not found in list. Please report it at <tilp-devel@lists.sf.net>.", code);
203
204
return 0;
205
}
206
207
/////////////----------------
208
209
extern const DUSBVtlPktName vpkt_types[];
210
211
#define CATCH_DELAY() \
212
if (pkt->type == DUSB_VPKT_DELAY_ACK) \
213
{ \
214
uint32_t delay = (pkt->data[0] << 24) | (pkt->data[1] << 16) | (pkt->data[2] << 8) | (pkt->data[3] << 0); \
215
ticalcs_info(" delay = %u", delay); \
216
if (delay > 400000) \
217
{ \
218
delay = 400000; \
219
ticalcs_info(" (absurdly high delay, clamping to a more reasonable value)"); \
220
} \
221
\
222
PAUSE(delay/1000); \
223
\
224
dusb_vtl_pkt_del(pkt); \
225
pkt = dusb_vtl_pkt_new(0, 0); \
226
\
227
retval = dusb_recv_data(h, pkt); \
228
if (retval) \
229
{ \
230
goto end; \
231
} \
232
}
233
234
// 0x0001: set mode or ping
235
TIEXPORT3 int TICALL dusb_cmd_s_mode_set(CalcHandle *h, DUSBModeSet mode)
236
{
237
DUSBVirtualPacket* pkt;
238
int retval = 0;
239
240
if (h == NULL)
241
{
242
ticalcs_critical("%s: h is NULL", __FUNCTION__);
243
return ERR_INVALID_HANDLE;
244
}
245
246
TRYF(dusb_send_buf_size_request(h, DUSB_DFL_BUF_SIZE));
247
TRYF(dusb_recv_buf_size_alloc(h, NULL));
248
249
pkt = dusb_vtl_pkt_new(sizeof(mode), DUSB_VPKT_PING);
250
251
pkt->data[0] = MSB(mode.arg1);
252
pkt->data[1] = LSB(mode.arg1);
253
pkt->data[2] = MSB(mode.arg2);
254
pkt->data[3] = LSB(mode.arg2);
255
pkt->data[4] = MSB(mode.arg3);
256
pkt->data[5] = LSB(mode.arg3);
257
pkt->data[6] = MSB(mode.arg4);
258
pkt->data[7] = LSB(mode.arg4);
259
pkt->data[8] = MSB(mode.arg5);
260
pkt->data[9] = LSB(mode.arg5);
261
retval = dusb_send_data(h, pkt);
262
263
dusb_vtl_pkt_del(pkt);
264
265
ticalcs_info(" %04x %04x %04x %04x %04x", mode.arg1, mode.arg2, mode.arg3, mode.arg4, mode.arg5);
266
267
return retval;
268
}
269
270
// 0x0002: begin OS transfer
271
TIEXPORT3 int TICALL dusb_cmd_s_os_begin(CalcHandle *h, uint32_t size)
272
{
273
DUSBVirtualPacket* pkt;
274
int retval = 0;
275
276
if (h == NULL)
277
{
278
ticalcs_critical("%s: h is NULL", __FUNCTION__);
279
return ERR_INVALID_HANDLE;
280
}
281
282
pkt = dusb_vtl_pkt_new(11, DUSB_VPKT_OS_BEGIN);
283
284
pkt->data[7] = MSB(MSW(size));
285
pkt->data[8] = LSB(MSW(size));
286
pkt->data[9] = MSB(LSW(size));
287
pkt->data[10]= LSB(LSW(size));
288
retval = dusb_send_data(h, pkt);
289
290
dusb_vtl_pkt_del(pkt);
291
292
ticalcs_info(" size = %08x (%i)", size, size);
293
294
return retval;
295
}
296
297
// 0x0003: acknowledgement of OS transfer
298
TIEXPORT3 int TICALL dusb_cmd_r_os_ack(CalcHandle *h, uint32_t *size)
299
{
300
DUSBVirtualPacket* pkt;
301
int retval = 0;
302
303
if (h == NULL)
304
{
305
ticalcs_critical("%s: h is NULL", __FUNCTION__);
306
return ERR_INVALID_HANDLE;
307
}
308
309
pkt = dusb_vtl_pkt_new(0, 0);
310
311
retval = dusb_recv_data(h, pkt);
312
313
if (!retval)
314
{
315
CATCH_DELAY();
316
317
if(pkt->type == DUSB_VPKT_ERROR)
318
{
319
retval = ERR_CALC_ERROR2 + err_code(pkt);
320
goto end;
321
}
322
else if(pkt->type != DUSB_VPKT_OS_ACK)
323
{
324
retval = ERR_INVALID_PACKET;
325
goto end;
326
}
327
328
if (size != NULL)
329
{
330
*size = (pkt->data[0] << 24) | (pkt->data[1] << 16) | (pkt->data[2] << 8) | (pkt->data[3] << 0);
331
ticalcs_info(" size = %08x (%i)", *size, *size);
332
}
333
}
334
335
end:
336
dusb_vtl_pkt_del(pkt);
337
338
return retval;
339
}
340
341
static int s_os(uint8_t type, CalcHandle *h, uint16_t addr, uint8_t page, uint8_t flag, uint32_t size, uint8_t *data)
342
{
343
DUSBVirtualPacket* pkt;
344
int retval = 0;
345
346
if (h == NULL)
347
{
348
ticalcs_critical("%s: h is NULL", __FUNCTION__);
349
return ERR_INVALID_HANDLE;
350
}
351
if (data == NULL)
352
{
353
ticalcs_critical("%s: data is NULL", __FUNCTION__);
354
return ERR_INVALID_PARAMETER;
355
}
356
357
pkt = dusb_vtl_pkt_new(4 + size, type);
358
359
pkt->data[0] = MSB(addr);
360
pkt->data[1] = LSB(addr);
361
pkt->data[2] = page;
362
pkt->data[3] = flag;
363
memcpy(pkt->data+4, data, size);
364
retval = dusb_send_data(h, pkt);
365
366
dusb_vtl_pkt_del(pkt);
367
ticalcs_info(" addr=%04x, page=%02x, flag=%02x, size=%04x", addr, page, flag, size);
368
369
return retval;
370
}
371
372
// 0x0004: OS header
373
TIEXPORT3 int TICALL dusb_cmd_s_os_header(CalcHandle *h, uint16_t addr, uint8_t page, uint8_t flag, uint32_t size, uint8_t *data)
374
{
375
return s_os(DUSB_VPKT_OS_HEADER, h, addr, page, flag, size, data);
376
}
377
378
// 0x0005: OS data
379
TIEXPORT3 int TICALL dusb_cmd_s_os_data(CalcHandle *h, uint16_t addr, uint8_t page, uint8_t flag, uint32_t size, uint8_t *data)
380
{
381
return s_os(DUSB_VPKT_OS_DATA, h, addr, page, flag, size, data);
382
}
383
384
// 0x0004: OS header
385
TIEXPORT3 int TICALL dusb_cmd_s_os_header_89(CalcHandle *h, uint32_t size, uint8_t *data)
386
{
387
DUSBVirtualPacket* pkt;
388
int retval = 0;
389
390
if (h == NULL)
391
{
392
ticalcs_critical("%s: h is NULL", __FUNCTION__);
393
return ERR_INVALID_HANDLE;
394
}
395
if (data == NULL)
396
{
397
ticalcs_critical("%s: data is NULL", __FUNCTION__);
398
return ERR_INVALID_PARAMETER;
399
}
400
401
pkt = dusb_vtl_pkt_new(size, DUSB_VPKT_OS_HEADER);
402
403
memcpy(pkt->data, data, size);
404
retval = dusb_send_data(h, pkt);
405
406
dusb_vtl_pkt_del(pkt);
407
ticalcs_info(" size = %08x (%i)", size, size);
408
409
return retval;
410
}
411
412
// 0x0005: OS data
413
TIEXPORT3 int TICALL dusb_cmd_s_os_data_89(CalcHandle *h, uint32_t size, uint8_t *data)
414
{
415
DUSBVirtualPacket* pkt;
416
int retval = 0;
417
418
if (h == NULL)
419
{
420
ticalcs_critical("%s: h is NULL", __FUNCTION__);
421
return ERR_INVALID_HANDLE;
422
}
423
if (data == NULL)
424
{
425
ticalcs_critical("%s: data is NULL", __FUNCTION__);
426
return ERR_INVALID_PARAMETER;
427
}
428
429
pkt = dusb_vtl_pkt_new(size, DUSB_VPKT_OS_DATA);
430
431
memcpy(pkt->data, data, size);
432
retval = dusb_send_data(h, pkt);
433
434
dusb_vtl_pkt_del(pkt);
435
ticalcs_info(" size = %08x (%i)", size, size);
436
437
return retval;
438
}
439
440
// 0x0006: acknowledgement of EOT
441
TIEXPORT3 int TICALL dusb_cmd_r_eot_ack(CalcHandle *h)
442
{
443
DUSBVirtualPacket* pkt;
444
int retval = 0;
445
446
if (h == NULL)
447
{
448
ticalcs_critical("%s: h is NULL", __FUNCTION__);
449
return ERR_INVALID_HANDLE;
450
}
451
452
pkt = dusb_vtl_pkt_new(0, 0);
453
454
retval = dusb_recv_data(h, pkt);
455
456
if (!retval)
457
{
458
CATCH_DELAY();
459
460
if(pkt->type == DUSB_VPKT_ERROR)
461
{
462
retval = ERR_CALC_ERROR2 + err_code(pkt);
463
}
464
else if(pkt->type != DUSB_VPKT_EOT_ACK)
465
{
466
retval = ERR_INVALID_PACKET;
467
}
468
}
469
470
end:
471
dusb_vtl_pkt_del(pkt);
472
473
return retval;
474
}
475
476
// 0x0007: parameter request
477
TIEXPORT3 int TICALL dusb_cmd_s_param_request(CalcHandle *h, int npids, uint16_t *pids)
478
{
479
DUSBVirtualPacket* pkt;
480
int i;
481
int retval = 0;
482
483
if (h == NULL)
484
{
485
ticalcs_critical("%s: h is NULL", __FUNCTION__);
486
return ERR_INVALID_HANDLE;
487
}
488
if (npids != 0 && pids == NULL)
489
{
490
ticalcs_critical("%s: pids is NULL", __FUNCTION__);
491
return ERR_INVALID_PARAMETER;
492
}
493
494
pkt = dusb_vtl_pkt_new(2 + npids * sizeof(uint16_t), DUSB_VPKT_PARM_REQ);
495
496
pkt->data[0] = MSB(npids);
497
pkt->data[1] = LSB(npids);
498
499
for(i = 0; i < npids; i++)
500
{
501
pkt->data[2*(i+1) + 0] = MSB(pids[i]);
502
pkt->data[2*(i+1) + 1] = LSB(pids[i]);
503
}
504
505
retval = dusb_send_data(h, pkt);
506
507
dusb_vtl_pkt_del(pkt);
508
ticalcs_info(" npids=%i", npids);
509
510
return retval;
511
}
512
513
// 0x0008: parameter data
514
TIEXPORT3 int TICALL dusb_cmd_r_param_data(CalcHandle *h, int nparams, DUSBCalcParam **params)
515
{
516
DUSBVirtualPacket* pkt;
517
int i, j;
518
int retval = 0;
519
520
if (h == NULL)
521
{
522
ticalcs_critical("%s: h is NULL", __FUNCTION__);
523
return ERR_INVALID_HANDLE;
524
}
525
if (params == NULL)
526
{
527
ticalcs_critical("%s: params is NULL", __FUNCTION__);
528
return ERR_INVALID_PARAMETER;
529
}
530
531
pkt = dusb_vtl_pkt_new(0, 0);
532
533
retval = dusb_recv_data(h, pkt);
534
535
if (!retval)
536
{
537
CATCH_DELAY();
538
539
if(pkt->type == DUSB_VPKT_ERROR)
540
{
541
retval = ERR_CALC_ERROR2 + err_code(pkt);
542
goto end;
543
}
544
else if(pkt->type != DUSB_VPKT_PARM_DATA)
545
{
546
retval = ERR_INVALID_PACKET;
547
goto end;
548
}
549
550
if(((pkt->data[0] << 8) | pkt->data[1]) != nparams)
551
{
552
retval = ERR_INVALID_PACKET;
553
goto end;
554
}
555
556
for(i = 0, j = 2; i < nparams; i++)
557
{
558
DUSBCalcParam *s = params[i] = dusb_cp_new(0, 0);
559
560
s->id = pkt->data[j++] << 8; s->id |= pkt->data[j++];
561
s->ok = !pkt->data[j++];
562
if(s->ok)
563
{
564
s->size = pkt->data[j++] << 8; s->size |= pkt->data[j++];
565
s->data = (uint8_t *)g_malloc0(s->size);
566
memcpy(s->data, &pkt->data[j], s->size);
567
j += s->size;
568
}
569
}
570
}
571
572
end:
573
dusb_vtl_pkt_del(pkt);
574
ticalcs_info(" nparams=%i", nparams);
575
576
return retval;
577
}
578
579
// 0x0009: request directory listing
580
TIEXPORT3 int TICALL dusb_cmd_s_dirlist_request(CalcHandle *h, int naids, uint16_t *aids)
581
{
582
DUSBVirtualPacket* pkt;
583
int i;
584
int j = 0;
585
int retval = 0;
586
587
if (h == NULL)
588
{
589
ticalcs_critical("%s: h is NULL", __FUNCTION__);
590
return ERR_INVALID_HANDLE;
591
}
592
if (naids != 0 && aids == NULL)
593
{
594
ticalcs_critical("%s: aids is NULL", __FUNCTION__);
595
return ERR_INVALID_PARAMETER;
596
}
597
598
pkt = dusb_vtl_pkt_new(4 + 2*naids + 7, DUSB_VPKT_DIR_REQ);
599
600
pkt->data[j++] = MSB(MSW(naids));
601
pkt->data[j++] = LSB(MSW(naids));
602
pkt->data[j++] = MSB(LSW(naids));
603
pkt->data[j++] = LSB(LSW(naids));
604
605
for(i = 0; i < naids; i++)
606
{
607
pkt->data[j++] = MSB(aids[i]);
608
pkt->data[j++] = LSB(aids[i]);
609
}
610
611
pkt->data[j++] = 0x00; pkt->data[j++] = 0x01;
612
pkt->data[j++] = 0x00; pkt->data[j++] = 0x01;
613
pkt->data[j++] = 0x00; pkt->data[j++] = 0x01;
614
pkt->data[j++] = 0x01;
615
616
retval = dusb_send_data(h, pkt);
617
618
dusb_vtl_pkt_del(pkt);
619
ticalcs_info(" naids=%i", naids);
620
621
return retval;
622
}
623
624
// 0x000A: variable header (name is utf-8)
625
// beware: attr array contents is allocated by function
626
TIEXPORT3 int TICALL dusb_cmd_r_var_header(CalcHandle *h, char *folder, char *name, DUSBCalcAttr **attr)
627
{
628
DUSBVirtualPacket* pkt;
629
uint8_t fld_len;
630
uint8_t var_len;
631
int nattr;
632
int i, j;
633
int retval = 0;
634
635
if (h == NULL)
636
{
637
ticalcs_critical("%s: h is NULL", __FUNCTION__);
638
return ERR_INVALID_HANDLE;
639
}
640
if (folder == NULL || name == NULL || attr == NULL)
641
{
642
ticalcs_critical("%s: an argument is NULL", __FUNCTION__);
643
return ERR_INVALID_PARAMETER;
644
}
645
646
pkt = dusb_vtl_pkt_new(0, 0);
647
648
retval = dusb_recv_data(h, pkt);
649
650
if (!retval)
651
{
652
CATCH_DELAY();
653
654
if(pkt->type == DUSB_VPKT_EOT)
655
{
656
retval = ERR_EOT;
657
goto end;
658
}
659
else if(pkt->type == DUSB_VPKT_ERROR)
660
{
661
retval = ERR_CALC_ERROR2 + err_code(pkt);
662
goto end;
663
}
664
else if(pkt->type != DUSB_VPKT_VAR_HDR)
665
{
666
retval = ERR_INVALID_PACKET;
667
goto end;
668
}
669
670
j = 0;
671
fld_len = pkt->data[j++];
672
strcpy(folder, "");
673
if(fld_len)
674
{
675
memcpy(folder, &pkt->data[j], fld_len+1);
676
j += fld_len+1;
677
}
678
var_len = pkt->data[j++];
679
strcpy(name, "");
680
if(var_len)
681
{
682
memcpy(name, &pkt->data[j], var_len+1);
683
j += var_len+1;
684
}
685
686
nattr = (pkt->data[j+0] << 8) | pkt->data[j+1];
687
j += 2;
688
689
for(i = 0; i < nattr; i++)
690
{
691
DUSBCalcAttr *s = attr[i] = dusb_ca_new(0, 0);
692
693
s->id = pkt->data[j++] << 8; s->id |= pkt->data[j++];
694
s->ok = !pkt->data[j++];
695
if(s->ok)
696
{
697
s->size = pkt->data[j++] << 8; s->size |= pkt->data[j++];
698
s->data = (uint8_t *)g_malloc0(s->size);
699
memcpy(s->data, &pkt->data[j], s->size);
700
j += s->size;
701
}
702
}
703
}
704
705
end:
706
dusb_vtl_pkt_del(pkt);
707
ticalcs_info(" folder=%s, name=%s", folder, name);
708
709
return retval;
710
}
711
712
// 0x000B: request to send
713
TIEXPORT3 int TICALL dusb_cmd_s_rts(CalcHandle *h, const char *folder, const char *name, uint32_t size, int nattrs, const DUSBCalcAttr **attrs)
714
{
715
DUSBVirtualPacket* pkt;
716
int pks;
717
int i;
718
int j = 0;
719
int retval = 0;
720
721
if (h == NULL)
722
{
723
ticalcs_critical("%s: h is NULL", __FUNCTION__);
724
return ERR_INVALID_HANDLE;
725
}
726
if (folder == NULL || name == NULL || (nattrs != 0 && attrs == NULL))
727
{
728
ticalcs_critical("%s: an argument is NULL", __FUNCTION__);
729
return ERR_INVALID_PARAMETER;
730
}
731
732
pks = 2 + strlen(name)+1 + 5 + 2;
733
if(strlen(folder))
734
pks += strlen(folder)+1;
735
for(i = 0; i < nattrs; i++) pks += 4 + attrs[i]->size;
736
737
pkt = dusb_vtl_pkt_new(pks, DUSB_VPKT_RTS);
738
739
if(strlen(folder))
740
{
741
pkt->data[j++] = strlen(folder);
742
memcpy(pkt->data + j, folder, strlen(folder)+1);
743
j += strlen(folder)+1;
744
}
745
else
746
{
747
pkt->data[j++] = 0;
748
}
749
750
pkt->data[j++] = strlen(name);
751
memcpy(pkt->data + j, name, strlen(name)+1);
752
j += strlen(name)+1;
753
754
pkt->data[j++] = MSB(MSW(size));
755
pkt->data[j++] = LSB(MSW(size));
756
pkt->data[j++] = MSB(LSW(size));
757
pkt->data[j++] = LSB(LSW(size));
758
pkt->data[j++] = 0x01;
759
760
pkt->data[j++] = MSB(nattrs);
761
pkt->data[j++] = LSB(nattrs);
762
for(i = 0; i < nattrs; i++)
763
{
764
pkt->data[j++] = MSB(attrs[i]->id);
765
pkt->data[j++] = LSB(attrs[i]->id);
766
pkt->data[j++] = MSB(attrs[i]->size);
767
pkt->data[j++] = LSB(attrs[i]->size);
768
memcpy(pkt->data + j, attrs[i]->data, attrs[i]->size);
769
byteswap(pkt->data + j, attrs[i]->size);
770
j += attrs[i]->size;
771
}
772
773
retval = dusb_send_data(h, pkt);
774
775
dusb_vtl_pkt_del(pkt);
776
ticalcs_info(" folder=%s, name=%s, size=%i, nattrs=%i", folder, name, size, nattrs);
777
778
return retval;
779
}
780
781
// 0x000C: variable request
782
TIEXPORT3 int TICALL dusb_cmd_s_var_request(CalcHandle *h, const char *folder, const char *name, int naids, uint16_t *aids, int nattrs, const DUSBCalcAttr **attrs)
783
{
784
DUSBVirtualPacket* pkt;
785
int pks;
786
int i;
787
int j = 0;
788
int retval = 0;
789
790
if (h == NULL)
791
{
792
ticalcs_critical("%s: h is NULL", __FUNCTION__);
793
return ERR_INVALID_HANDLE;
794
}
795
if (folder == NULL || name == NULL || (naids != 0 && aids == NULL) || (nattrs != 0 && attrs == NULL))
796
{
797
ticalcs_critical("%s: an argument is NULL", __FUNCTION__);
798
return ERR_INVALID_PARAMETER;
799
}
800
801
pks = 2 + strlen(name)+1 + 5 + 2 + 2*naids + 2;
802
if(strlen(folder)) pks += strlen(folder)+1;
803
for(i = 0; i < nattrs; i++) pks += 4 + attrs[i]->size;
804
pks += 2;
805
806
pkt = dusb_vtl_pkt_new(pks, DUSB_VPKT_VAR_REQ);
807
808
if(strlen(folder))
809
{
810
pkt->data[j++] = strlen(folder);
811
memcpy(pkt->data + j, folder, strlen(folder)+1);
812
j += strlen(folder)+1;
813
}
814
else
815
pkt->data[j++] = 0;
816
817
pkt->data[j++] = strlen(name);
818
memcpy(pkt->data + j, name, strlen(name)+1);
819
j += strlen(name)+1;
820
821
pkt->data[j++] = 0x01;
822
pkt->data[j++] = 0xFF; pkt->data[j++] = 0xFF;
823
pkt->data[j++] = 0xFF; pkt->data[j++] = 0xFF;
824
825
pkt->data[j++] = MSB(naids);
826
pkt->data[j++] = LSB(naids);
827
for(i = 0; i < naids; i++)
828
{
829
pkt->data[j++] = MSB(aids[i]);
830
pkt->data[j++] = LSB(aids[i]);
831
}
832
833
pkt->data[j++] = MSB(nattrs);
834
pkt->data[j++] = LSB(nattrs);
835
for(i = 0; i < nattrs; i++)
836
{
837
pkt->data[j++] = MSB(attrs[i]->id);
838
pkt->data[j++] = LSB(attrs[i]->id);
839
pkt->data[j++] = MSB(attrs[i]->size);
840
pkt->data[j++] = LSB(attrs[i]->size);
841
memcpy(pkt->data + j, attrs[i]->data, attrs[i]->size);
842
byteswap(pkt->data + j, attrs[i]->size);
843
j += attrs[i]->size;
844
}
845
pkt->data[j++] = 0x00; pkt->data[j++] = 0x00;
846
847
retval = dusb_send_data(h, pkt);
848
849
dusb_vtl_pkt_del(pkt);
850
ticalcs_info(" folder=%s, name=%s, naids=%i, nattrs=%i", folder, name, naids, nattrs);
851
852
return retval;
853
}
854
855
// 0x000D: variable contents (recv)
856
TIEXPORT3 int TICALL dusb_cmd_r_var_content(CalcHandle *h, uint32_t *size, uint8_t **data)
857
{
858
DUSBVirtualPacket* pkt;
859
int retval = 0;
860
861
if (h == NULL)
862
{
863
ticalcs_critical("%s: h is NULL", __FUNCTION__);
864
return ERR_INVALID_HANDLE;
865
}
866
if (data == NULL)
867
{
868
ticalcs_critical("%s: data is NULL", __FUNCTION__);
869
return ERR_INVALID_PARAMETER;
870
}
871
872
pkt = dusb_vtl_pkt_new(0, 0);
873
874
retval = dusb_recv_data(h, pkt);
875
876
if (!retval)
877
{
878
CATCH_DELAY();
879
880
if(pkt->type == DUSB_VPKT_ERROR)
881
{
882
retval = ERR_CALC_ERROR2 + err_code(pkt);
883
goto end;
884
}
885
else if(pkt->type != DUSB_VPKT_VAR_CNTS)
886
{
887
retval = ERR_INVALID_PACKET;
888
goto end;
889
}
890
891
if(size != NULL)
892
{
893
*size = pkt->size;
894
}
895
896
*data = g_malloc0(pkt->size);
897
if (*data != NULL)
898
{
899
memcpy(*data, pkt->data, pkt->size);
900
}
901
else
902
{
903
retval = ERR_MALLOC;
904
}
905
ticalcs_info(" size=%i", pkt->size);
906
}
907
908
end:
909
dusb_vtl_pkt_del(pkt);
910
911
return retval;
912
}
913
914
// 0x000D: variable contents (send)
915
TIEXPORT3 int TICALL dusb_cmd_s_var_content(CalcHandle *h, uint32_t size, uint8_t *data)
916
{
917
DUSBVirtualPacket* pkt;
918
int retval = 0;
919
920
if (h == NULL)
921
{
922
ticalcs_critical("%s: h is NULL", __FUNCTION__);
923
return ERR_INVALID_HANDLE;
924
}
925
if (data == NULL)
926
{
927
ticalcs_critical("%s: data is NULL", __FUNCTION__);
928
return ERR_INVALID_PARAMETER;
929
}
930
931
pkt = dusb_vtl_pkt_new(size, DUSB_VPKT_VAR_CNTS);
932
933
memcpy(pkt->data, data, size);
934
retval = dusb_send_data(h, pkt);
935
936
dusb_vtl_pkt_del(pkt);
937
ticalcs_info(" size=%i", size);
938
939
return retval;
940
}
941
942
// 0x000E: parameter set
943
TIEXPORT3 int TICALL dusb_cmd_s_param_set(CalcHandle *h, const DUSBCalcParam *param)
944
{
945
DUSBVirtualPacket* pkt;
946
int retval = 0;
947
948
if (h == NULL)
949
{
950
ticalcs_critical("%s: h is NULL", __FUNCTION__);
951
return ERR_INVALID_HANDLE;
952
}
953
if (param == NULL)
954
{
955
ticalcs_critical("%s: param is NULL", __FUNCTION__);
956
return ERR_INVALID_PARAMETER;
957
}
958
959
pkt = dusb_vtl_pkt_new(2 + 2 + param->size, DUSB_VPKT_PARM_SET);
960
961
pkt->data[0] = MSB(param->id);
962
pkt->data[1] = LSB(param->id);
963
pkt->data[2] = MSB(param->size);
964
pkt->data[3] = LSB(param->size);
965
memcpy(pkt->data + 4, param->data, param->size);
966
967
retval = dusb_send_data(h, pkt);
968
969
dusb_vtl_pkt_del(pkt);
970
ticalcs_info(" pid=%04x, size=%04x", param->id, param->size);
971
972
return retval;
973
}
974
975
// 0x0010: modify/rename/delete variable
976
TIEXPORT3 int TICALL dusb_cmd_s_var_modify(CalcHandle *h,
977
const char *src_folder, const char *src_name,
978
int n_src_attrs, const DUSBCalcAttr **src_attrs,
979
const char *dst_folder, const char *dst_name,
980
int n_dst_attrs, const DUSBCalcAttr **dst_attrs)
981
{
982
DUSBVirtualPacket* pkt;
983
int i;
984
int j = 0;
985
int pks;
986
int retval = 0;
987
988
if (h == NULL)
989
{
990
ticalcs_critical("%s: h is NULL", __FUNCTION__);
991
return ERR_INVALID_HANDLE;
992
}
993
if (src_folder == NULL || src_name == NULL || src_attrs == NULL || dst_folder == NULL || dst_name == NULL || (n_dst_attrs != 0 && dst_attrs == NULL))
994
{
995
ticalcs_critical("%s: an argument is NULL", __FUNCTION__);
996
return ERR_INVALID_PARAMETER;
997
}
998
999
pks = 2 + strlen(src_name)+1 + 2;
1000
if(strlen(src_folder))
1001
pks += strlen(src_folder)+1;
1002
for(i = 0; i < n_src_attrs; i++)
1003
pks += 4 + src_attrs[i]->size;
1004
1005
pks += 5;
1006
1007
if(strlen(dst_folder))
1008
pks += strlen(dst_folder)+1;
1009
if(strlen(dst_name))
1010
pks += strlen(dst_name)+1;
1011
for (i = 0; i < n_dst_attrs; i++)
1012
pks += 4 + dst_attrs[i]->size;
1013
1014
pkt = dusb_vtl_pkt_new(pks, DUSB_VPKT_DEL_VAR);
1015
1016
if(strlen(src_folder))
1017
{
1018
pkt->data[j++] = strlen(src_folder);
1019
memcpy(pkt->data + j, src_folder, strlen(src_folder)+1);
1020
j += strlen(src_folder)+1;
1021
}
1022
else
1023
{
1024
pkt->data[j++] = 0;
1025
}
1026
1027
pkt->data[j++] = strlen(src_name);
1028
memcpy(pkt->data + j, src_name, strlen(src_name)+1);
1029
j += strlen(src_name)+1;
1030
1031
pkt->data[j++] = MSB(n_src_attrs);
1032
pkt->data[j++] = LSB(n_src_attrs);
1033
for(i = 0; i < n_src_attrs; i++)
1034
{
1035
pkt->data[j++] = MSB(src_attrs[i]->id);
1036
pkt->data[j++] = LSB(src_attrs[i]->id);
1037
pkt->data[j++] = MSB(src_attrs[i]->size);
1038
pkt->data[j++] = LSB(src_attrs[i]->size);
1039
memcpy(pkt->data + j, src_attrs[i]->data, src_attrs[i]->size);
1040
j += src_attrs[i]->size;
1041
}
1042
1043
pkt->data[j++] = 0x01; /* ??? */
1044
1045
if(strlen(dst_folder))
1046
{
1047
pkt->data[j++] = strlen(dst_folder);
1048
memcpy(pkt->data + j, dst_folder, strlen(dst_folder)+1);
1049
j += strlen(dst_folder)+1;
1050
}
1051
else
1052
pkt->data[j++] = 0;
1053
1054
if(strlen(dst_name))
1055
{
1056
pkt->data[j++] = strlen(dst_name);
1057
memcpy(pkt->data + j, dst_name, strlen(dst_name)+1);
1058
j += strlen(dst_name)+1;
1059
}
1060
else
1061
pkt->data[j++] = 0;
1062
1063
pkt->data[j++] = MSB(n_dst_attrs);
1064
pkt->data[j++] = LSB(n_dst_attrs);
1065
for(i = 0; i < n_dst_attrs; i++)
1066
{
1067
pkt->data[j++] = MSB(dst_attrs[i]->id);
1068
pkt->data[j++] = LSB(dst_attrs[i]->id);
1069
pkt->data[j++] = MSB(dst_attrs[i]->size);
1070
pkt->data[j++] = LSB(dst_attrs[i]->size);
1071
memcpy(pkt->data + j, dst_attrs[i]->data, dst_attrs[i]->size);
1072
j += dst_attrs[i]->size;
1073
}
1074
1075
g_assert(j == pks);
1076
1077
retval = dusb_send_data(h, pkt);
1078
1079
ticalcs_info(" src_folder=%s, name=%s, nattrs=%i", src_folder, src_name, n_src_attrs);
1080
ticalcs_info(" dst_folder=%s, name=%s, nattrs=%i", dst_folder, dst_name, n_dst_attrs);
1081
1082
dusb_vtl_pkt_del(pkt);
1083
return retval;
1084
}
1085
1086
TIEXPORT3 int TICALL dusb_cmd_s_var_delete(CalcHandle *h, const char *folder, const char *name, int nattrs, const DUSBCalcAttr **attrs)
1087
{
1088
const DUSBCalcAttr * dummy;
1089
return dusb_cmd_s_var_modify(h, folder, name, nattrs, attrs, "", "", 0, &dummy);
1090
}
1091
1092
// 0x0011: remote control
1093
TIEXPORT3 int TICALL dusb_cmd_s_execute(CalcHandle *h, const char *folder, const char *name, uint8_t action, const char *args, uint16_t code)
1094
{
1095
DUSBVirtualPacket* pkt = NULL;
1096
int pks;
1097
int j = 0;
1098
int retval = 0;
1099
1100
if (h == NULL)
1101
{
1102
ticalcs_critical("%s: h is NULL", __FUNCTION__);
1103
return ERR_INVALID_HANDLE;
1104
}
1105
if (folder == NULL || name == NULL)
1106
{
1107
ticalcs_critical("%s: an argument is NULL", __FUNCTION__);
1108
return ERR_INVALID_PARAMETER;
1109
}
1110
1111
if(h->model == CALC_TI89T_USB)
1112
{
1113
pks = 3;
1114
if(args) pks += strlen(args); else pks += 2;
1115
if(strlen(folder)) pks += strlen(folder)+1;
1116
if(strlen(name)) pks += strlen(name)+1;
1117
pkt = dusb_vtl_pkt_new(pks, DUSB_VPKT_EXECUTE);
1118
1119
pkt->data[j++] = strlen(folder);
1120
if(strlen(folder))
1121
{
1122
memcpy(pkt->data + j, folder, strlen(folder)+1);
1123
j += strlen(folder)+1;
1124
}
1125
1126
pkt->data[j++] = strlen(name);
1127
if(strlen(name))
1128
{
1129
memcpy(pkt->data + j, name, strlen(name)+1);
1130
j += strlen(name)+1;
1131
}
1132
1133
pkt->data[j++] = action;
1134
1135
if(action != EID_KEY && args != NULL)
1136
{
1137
memcpy(pkt->data + j, args, strlen(args));
1138
}
1139
else if(action == EID_KEY || args == NULL)
1140
{
1141
pkt->data[j++] = MSB(code);
1142
pkt->data[j++] = LSB(code);
1143
}
1144
}
1145
else if(h->model == CALC_TI84P_USB)
1146
{
1147
pks = 3;
1148
if(args) pks += strlen(args); else pks += 2;
1149
if(strlen(name)) pks += strlen(name);
1150
pkt = dusb_vtl_pkt_new(pks, DUSB_VPKT_EXECUTE);
1151
1152
// MSB first (like other commands anyway).
1153
// Otherwise, a "EE 00 00 0D" packet is returned.
1154
pkt->data[j++] = MSB(strlen(name));
1155
pkt->data[j++] = LSB(strlen(name));
1156
if(strlen(name))
1157
{
1158
memcpy(pkt->data + j, name, strlen(name));
1159
j += strlen(name);
1160
}
1161
1162
pkt->data[j++] = action;
1163
1164
if(action != EID_KEY && args != NULL)
1165
{
1166
memcpy(pkt->data + j, args, strlen(args));
1167
}
1168
else if(action == EID_KEY || args == NULL)
1169
{
1170
pkt->data[j++] = LSB(code);
1171
pkt->data[j++] = MSB(code);
1172
}
1173
}
1174
1175
retval = dusb_send_data(h, pkt);
1176
1177
dusb_vtl_pkt_del(pkt);
1178
if (action == EID_KEY)
1179
{
1180
ticalcs_info(" action=%i, keycode=%04x", action, code);
1181
}
1182
else
1183
{
1184
ticalcs_info(" action=%i, folder=%s, name=%s, args=%s", action, folder ? folder : "NULL", name ? name : "NULL", args ? args : "NULL");
1185
}
1186
1187
return retval;
1188
}
1189
1190
// 0x0012: acknowledgement of mode setting
1191
TIEXPORT3 int TICALL dusb_cmd_r_mode_ack(CalcHandle *h)
1192
{
1193
DUSBVirtualPacket* pkt;
1194
int retval = 0;
1195
1196
if (h == NULL)
1197
{
1198
ticalcs_critical("%s: h is NULL", __FUNCTION__);
1199
return ERR_INVALID_HANDLE;
1200
}
1201
1202
pkt = dusb_vtl_pkt_new(0, 0);
1203
1204
retval = dusb_recv_data(h, pkt);
1205
1206
if (!retval)
1207
{
1208
CATCH_DELAY();
1209
1210
if(pkt->type == DUSB_VPKT_ERROR)
1211
{
1212
retval = ERR_CALC_ERROR2 + err_code(pkt);
1213
}
1214
else if(pkt->type != DUSB_VPKT_MODE_SET)
1215
{
1216
retval = ERR_INVALID_PACKET;
1217
}
1218
}
1219
1220
end:
1221
dusb_vtl_pkt_del(pkt);
1222
1223
return retval;
1224
}
1225
1226
// 0xAA00: acknowledgement of data
1227
TIEXPORT3 int TICALL dusb_cmd_r_data_ack(CalcHandle *h)
1228
{
1229
DUSBVirtualPacket* pkt;
1230
int retval = 0;
1231
1232
if (h == NULL)
1233
{
1234
ticalcs_critical("%s: h is NULL", __FUNCTION__);
1235
return ERR_INVALID_HANDLE;
1236
}
1237
1238
pkt = dusb_vtl_pkt_new(0, 0);
1239
1240
retval = dusb_recv_data(h, pkt);
1241
1242
if (!retval)
1243
{
1244
CATCH_DELAY();
1245
1246
if(pkt->type == DUSB_VPKT_ERROR)
1247
{
1248
retval = ERR_CALC_ERROR2 + err_code(pkt);
1249
}
1250
else if(pkt->type != DUSB_VPKT_DATA_ACK)
1251
{
1252
ticalcs_info("cmd_r_data_ack: expected type 0x%4X, received type 0x%4X", DUSB_VPKT_DATA_ACK, pkt->type);
1253
retval = ERR_INVALID_PACKET;
1254
}
1255
}
1256
1257
end:
1258
dusb_vtl_pkt_del(pkt);
1259
1260
return retval;
1261
}
1262
1263
// 0xBB00: delay acknowledgement
1264
TIEXPORT3 int TICALL dusb_cmd_r_delay_ack(CalcHandle *h)
1265
{
1266
DUSBVirtualPacket* pkt;
1267
int retval = 0;
1268
1269
if (h == NULL)
1270
{
1271
ticalcs_critical("%s: h is NULL", __FUNCTION__);
1272
return ERR_INVALID_HANDLE;
1273
}
1274
1275
pkt = dusb_vtl_pkt_new(0, 0);
1276
1277
retval = dusb_recv_data(h, pkt);
1278
1279
if (!retval)
1280
{
1281
if(pkt->type == DUSB_VPKT_ERROR)
1282
{
1283
retval = ERR_CALC_ERROR2 + err_code(pkt);
1284
}
1285
else if(pkt->type != DUSB_VPKT_DELAY_ACK)
1286
{
1287
ticalcs_info("cmd_r_data_ack: expected type 0x%4X, received type 0x%4X", DUSB_VPKT_DELAY_ACK, pkt->type);
1288
retval = ERR_INVALID_PACKET;
1289
}
1290
}
1291
1292
PAUSE(100);
1293
1294
dusb_vtl_pkt_del(pkt);
1295
1296
return retval;
1297
}
1298
1299
// 0xDD00: end of transmission (send)
1300
TIEXPORT3 int TICALL dusb_cmd_s_eot(CalcHandle *h)
1301
{
1302
DUSBVirtualPacket* pkt;
1303
int retval = 0;
1304
1305
if (h == NULL)
1306
{
1307
ticalcs_critical("%s: h is NULL", __FUNCTION__);
1308
return ERR_INVALID_HANDLE;
1309
}
1310
1311
pkt = dusb_vtl_pkt_new(0, DUSB_VPKT_EOT);
1312
1313
retval = dusb_send_data(h, pkt);
1314
1315
dusb_vtl_pkt_del(pkt);
1316
1317
return retval;
1318
}
1319
1320
// 0xDD00: end of transmission (recv)
1321
TIEXPORT3 int TICALL dusb_cmd_r_eot(CalcHandle *h)
1322
{
1323
DUSBVirtualPacket* pkt;
1324
int retval = 0;
1325
1326
if (h == NULL)
1327
{
1328
ticalcs_critical("%s: h is NULL", __FUNCTION__);
1329
return ERR_INVALID_HANDLE;
1330
}
1331
1332
pkt = dusb_vtl_pkt_new(0, 0);
1333
1334
retval = dusb_recv_data(h, pkt);
1335
1336
if (!retval)
1337
{
1338
CATCH_DELAY();
1339
1340
if(pkt->type == DUSB_VPKT_ERROR)
1341
{
1342
retval = ERR_CALC_ERROR2 + err_code(pkt);
1343
goto end;
1344
}
1345
else if(pkt->type != DUSB_VPKT_EOT)
1346
{
1347
retval = ERR_INVALID_PACKET;
1348
goto end;
1349
}
1350
}
1351
1352
end:
1353
dusb_vtl_pkt_del(pkt);
1354
1355
return retval;
1356
}
1357
1358
// 0xEE00: error
1359
TIEXPORT3 int TICALL dusb_cmd_s_error(CalcHandle *h, uint16_t code)
1360
{
1361
DUSBVirtualPacket* pkt;
1362
int retval = 0;
1363
1364
if (h == NULL)
1365
{
1366
ticalcs_critical("%s: h is NULL", __FUNCTION__);
1367
return ERR_INVALID_HANDLE;
1368
}
1369
1370
pkt = dusb_vtl_pkt_new(2, DUSB_VPKT_ERROR);
1371
1372
pkt->data[0] = MSB(code);
1373
pkt->data[1] = LSB(code);
1374
retval = dusb_send_data(h, pkt);
1375
1376
dusb_vtl_pkt_del(pkt);
1377
ticalcs_info(" code = %04x", code);
1378
1379
return retval;
1380
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.1