int dusb_recv(CalcHandle* handle, RawPacket* pkt)
{
uint8_t buf[5];
// Any packet has always an header of 5 bytes (size & type)
ticables_progress_reset(handle->cable);
TRYF(ticables_cable_recv(handle->cable, buf, 5));
pkt->size = buf[3] | (buf[2] << 8) | (buf[1] << 16) | (buf[0] << 24);
pkt->type = buf[4];
if(handle->model == CALC_TI84P_USB && pkt->size > 250)
return ERR_INVALID_PACKET;
if(handle->model == CALC_TI89T_USB && pkt->size > 1023)
return ERR_INVALID_PACKET;
//printf("dusb_send: pkt->size=%d\n", pkt->size);
// Next, follows data
TRYF(ticables_cable_recv(handle->cable, pkt->data, pkt->size));
if(pkt->size >= 128)
ticables_progress_get(handle->cable, NULL, NULL, &handle->updat->rate);
if (handle->updat->cancel)
return ERR_ABORT;
return 0;
}
TIEXPORT3 int TICALL dusb_recv(CalcHandle* handle, DUSBRawPacket* pkt)
{
uint8_t buf[5];
int ret;
VALIDATE_HANDLE(handle);
VALIDATE_NONNULL(pkt);
// Any packet has always an header of 5 bytes (size & type)
ticables_progress_reset(handle->cable);
ret = ticables_cable_recv(handle->cable, buf, 5);
while (!ret)
{
pkt->size = buf[3] | (((uint32_t)buf[2]) << 8) | (((uint32_t)buf[1]) << 16) | (((uint32_t)buf[0]) << 24);
pkt->type = buf[4];
if ( (handle->model == CALC_TI84P_USB || handle->model == CALC_TI84PC_USB || handle->model == CALC_TI82A_USB || handle->model == CALC_TI84PT_USB)
&& pkt->size > 250)
{
ticalcs_warning("Raw packet is unexpectedly large: %u bytes", pkt->size);
}
else if ( (handle->model == CALC_TI83PCE_USB || handle->model == CALC_TI84PCE_USB)
&& pkt->size > 1018)
{
ticalcs_warning("Raw packet is unexpectedly large: %u bytes", pkt->size);
}
else if (handle->model == CALC_TI89T_USB)
{
// Fall through.
}
// else do nothing for now.
if (pkt->size > sizeof(pkt->data))
{
ticalcs_critical("Raw packet is too large: %u bytes", pkt->size);
ret = ERR_INVALID_PACKET;
break;
}
//printf("dusb_send: pkt->size=%d\n", pkt->size);
// Next, follows data
ret = ticables_cable_recv(handle->cable, pkt->data, pkt->size);
if (!ret)
{
if (pkt->size >= 128)
{
ticables_progress_get(handle->cable, NULL, NULL, &handle->updat->rate);
}
if (handle->updat->cancel)
{
ret = ERR_ABORT;
}
}
break;
}
return ret;
}
TIEXPORT3 int TICALL dusb_send(CalcHandle* handle, DUSBRawPacket* pkt)
{
uint8_t buf[sizeof(pkt->data) + 5];
uint32_t size;
int ret;
VALIDATE_HANDLE(handle);
VALIDATE_NONNULL(pkt);
memset(buf, 0, sizeof(buf));
size = pkt->size;
if (size > sizeof(pkt->data))
{
size = sizeof(pkt->data);
}
buf[0] = MSB(MSW(size));
buf[1] = LSB(MSW(size));
buf[2] = MSB(LSW(size));
buf[3] = LSB(LSW(size));
buf[4] = pkt->type;
memcpy(buf + 5, pkt->data, size);
//printf("dusb_send: pkt->size=%d\n", pkt->size);
ticables_progress_reset(handle->cable);
ret = ticables_cable_send(handle->cable, buf, size + 5);
if (!ret)
{
if (size >= 128)
{
ticables_progress_get(handle->cable, NULL, NULL, &handle->updat->rate);
}
if (handle->updat->cancel)
{
ret = ERR_ABORT;
}
}
return ret;
}
int dusb_send(CalcHandle* handle, RawPacket* pkt)
{
uint8_t buf[1023 + 5]= { 0 };
uint32_t size = pkt->size + 5;
buf[0] = MSB(MSW(pkt->size));
buf[1] = LSB(MSW(pkt->size));
buf[2] = MSB(LSW(pkt->size));
buf[3] = LSB(LSW(pkt->size));
buf[4] = pkt->type;
memcpy(buf+5, pkt->data, pkt->size);
//printf("dusb_send: pkt->size=%d\n", pkt->size);
ticables_progress_reset(handle->cable);
TRYF(ticables_cable_send(handle->cable, buf, size));
if(size >= 128)
ticables_progress_get(handle->cable, NULL, NULL, &handle->updat->rate);
if (handle->updat->cancel)
return ERR_ABORT;
return 0;
}
TIEXPORT3 int TICALL dusb_send(CalcHandle* handle, DUSBRawPacket* pkt)
{
uint8_t buf[1023 + 5]= { 0 };
uint32_t size;
if (handle == NULL)
{
ticalcs_critical("%s: handle is NULL", __FUNCTION__);
return ERR_INVALID_HANDLE;
}
if (pkt == NULL)
{
ticalcs_critical("%s: pkt is NULL", __FUNCTION__);
return ERR_INVALID_PACKET;
}
size = pkt->size + 5;
buf[0] = MSB(MSW(pkt->size));
buf[1] = LSB(MSW(pkt->size));
buf[2] = MSB(LSW(pkt->size));
buf[3] = LSB(LSW(pkt->size));
buf[4] = pkt->type;
memcpy(buf+5, pkt->data, pkt->size);
//printf("dusb_send: pkt->size=%d\n", pkt->size);
ticables_progress_reset(handle->cable);
TRYF(ticables_cable_send(handle->cable, buf, size));
if(size >= 128)
ticables_progress_get(handle->cable, NULL, NULL, &handle->updat->rate);
if (handle->updat->cancel)
return ERR_ABORT;
return 0;
}
/*
Send a packet from PC (host) to TI (target):
- target [in] : a machine ID uint8_t
- cmd [in] : a command ID uint8_t
- length [in] : length of buffer
- data [in] : data to send (or 0x00 if NULL)
- int [out] : an error code
*/
TIEXPORT3 int TICALL dbus_send(CalcHandle* handle, uint8_t target, uint8_t cmd, uint16_t len, uint8_t* data)
{
int i;
uint16_t sum;
uint32_t length = (len == 0x0000) ? 65536 : len; // wrap around
uint8_t *buf;
int r, q;
static int ref = 0;
if (handle == NULL)
{
ticalcs_critical("%s: handle is NULL", __FUNCTION__);
return ERR_INVALID_HANDLE;
}
buf = (uint8_t *)handle->priv2; //[65536+6];
if (buf == NULL)
{
ticalcs_critical("%s: handle->priv2 is NULL", __FUNCTION__);
return ERR_INVALID_HANDLE;
}
ticables_progress_reset(handle->cable);
if(data == NULL)
{
// short packet (no data)
buf[0] = target;
buf[1] = cmd;
buf[2] = 0x00;
buf[3] = 0x00;
// TI80 does not use length
if(target == PC_TI80)
{
TRYF(ticables_cable_send(handle->cable, buf, 2));
}
else
{
TRYF(ticables_cable_send(handle->cable, buf, 4));
}
}
else
{
// std packet (data + checksum)
buf[0] = target;
buf[1] = cmd;
buf[2] = LSB(length);
buf[3] = MSB(length);
// copy data
memcpy(buf+4, data, length);
// add checksum of packet
sum = tifiles_checksum(data, length);
buf[length+4+0] = LSB(sum);
buf[length+4+1] = MSB(sum);
// compute chunks
MIN_SIZE = (handle->cable->model == CABLE_GRY) ? 512 : 2048;
BLK_SIZE = (length + 6) / 20; // 5%
if(BLK_SIZE == 0) BLK_SIZE = length + 6;
if(BLK_SIZE < 32) BLK_SIZE = 128; // SilverLink doesn't like small block (< 32)
q = (length + 6) / BLK_SIZE;
r = (length + 6) % BLK_SIZE;
handle->updat->max1 = length + 6;
handle->updat->cnt1 = 0;
// send full chunks
for(i = 0; i < q; i++)
{
TRYF(ticables_cable_send(handle->cable, &buf[i*BLK_SIZE], BLK_SIZE));
ticables_progress_get(handle->cable, NULL, NULL, &handle->updat->rate);
handle->updat->cnt1 += BLK_SIZE;
if(length > MIN_SIZE)
handle->updat->pbar();
if (handle->updat->cancel)
return ERR_ABORT;
}
// send last chunk
{
TRYF(ticables_cable_send(handle->cable, &buf[i*BLK_SIZE], (uint16_t)r));
ticables_progress_get(handle->cable, NULL, NULL, &handle->updat->rate);
handle->updat->cnt1 += 1;
if(length > MIN_SIZE)
handle->updat->pbar();
if (handle->updat->cancel)
return ERR_ABORT;
}
}
// force periodic refresh
if(!(ref++ % 4))
handle->updat->refresh();
return 0;
}
/*
Send a packet from PC (host) to TI (target):
- target [in] : a machine ID uint8_t
- cmd [in] : a command ID uint8_t
- length [in] : length of buffer
- data [in] : data to send (or 0x00 if NULL)
- int [out] : an error code
*/
TIEXPORT3 int TICALL dbus_send(CalcHandle* handle, uint8_t target, uint8_t cmd, uint16_t len, const uint8_t* data)
{
int i;
uint16_t sum;
uint32_t length = (len == 0x0000) ? 65536 : len; // wrap around
uint8_t *buf;
int r, q;
static int ref = 0;
int ret;
VALIDATE_HANDLE(handle);
buf = (uint8_t *)handle->buffer; //[65536+6];
if (buf == NULL)
{
ticalcs_critical("%s: handle->buffer is NULL", __FUNCTION__);
return ERR_INVALID_HANDLE;
}
ticables_progress_reset(handle->cable);
if (data == NULL)
{
// short packet (no data)
buf[0] = target;
buf[1] = cmd;
buf[2] = 0x00;
buf[3] = 0x00;
// The TI-80 does not use length
ret = ticables_cable_send(handle->cable, buf, (target == DBUS_MID_PC_TI80) ? 2 : 4);
}
else
{
// std packet (data + checksum)
buf[0] = target;
buf[1] = cmd;
buf[2] = LSB(length);
buf[3] = MSB(length);
// copy data
memcpy(buf+4, data, length);
// add checksum of packet
sum = tifiles_checksum(data, length);
buf[length+4+0] = LSB(sum);
buf[length+4+1] = MSB(sum);
// compute chunks
handle->priv.progress_min_size = (handle->cable->model == CABLE_GRY) ? 512 : 2048;
handle->priv.progress_blk_size = (length + 6) / 20; // 5%
if (handle->priv.progress_blk_size == 0)
{
handle->priv.progress_blk_size = length + 6;
}
if (handle->priv.progress_blk_size < 32)
{
handle->priv.progress_blk_size = 128; // SilverLink doesn't like small block (< 32)
}
q = (length + 6) / handle->priv.progress_blk_size;
r = (length + 6) % handle->priv.progress_blk_size;
handle->updat->max1 = length + 6;
handle->updat->cnt1 = 0;
ret = 0;
// send full chunks
for (i = 0; i < q; i++)
{
ret = ticables_cable_send(handle->cable, &buf[i*handle->priv.progress_blk_size], handle->priv.progress_blk_size);
if (ret)
{
break;
}
ticables_progress_get(handle->cable, NULL, NULL, &handle->updat->rate);
handle->updat->cnt1 += handle->priv.progress_blk_size;
if (length > handle->priv.progress_min_size)
{
handle->updat->pbar();
}
if (handle->updat->cancel)
{
ret = ERR_ABORT;
break;
}
}
// send last chunk
if (!ret)
{
ret = ticables_cable_send(handle->cable, &buf[i*handle->priv.progress_blk_size], (uint16_t)r);
if (!ret)
{
ticables_progress_get(handle->cable, NULL, NULL, &handle->updat->rate);
handle->updat->cnt1 += 1;
if (length > handle->priv.progress_min_size)
{
handle->updat->pbar();
}
if (handle->updat->cancel)
{
ret = ERR_ABORT;
}
}
}
}
// force periodic refresh
if (!ret && !(ref++ % 4))
{
handle->updat->refresh();
}
return ret;
}
