/*
** rfidtag_xchange(udp, *outp, out_len, *inp, in_len)
** send a command to the reader and gets the answer
** returns 0 if all goes well; -1 if not
**LOCKED IN
*/
int
rfidtag_xchange (struct usb_dev_handle *udp, char *outp, int out_len, char *inp,
int in_len)
{
int bytes_sent;
int bytes_recv;
count++;
if ((bytes_sent =
usb_bulk_write (udp, 0x02, (char *) outp, out_len, 10)) < 0)
{
if ((bytes_sent =
usb_bulk_write (udp, 0x02, (char *) outp, out_len, 10)) < 0)
{
perror ("usb_bulk_write");
}
}
if ((bytes_recv = usb_bulk_read (udp, 0x82, (char *) inp, in_len, 10)) < 0)
{
if ((bytes_recv =
usb_bulk_read (udp, 0x82, (char *) inp, in_len, 100)) < 0)
{
perror ("usb_bulk_read");
return (-1);
}
}
return bytes_recv;
}
qint32 LibUsb::write(QByteArray *buf, const quint32 bytes)
{
// check it isn't closed
if (!this->device) return -1;
QString cmd, s;
for (int i=0; i<buf->size(); i++) {
cmd.append(s.sprintf("%02X",(uchar)buf->at(i))+":");
}
cmd.remove(cmd.size()-1, 1); //remove last colon
qDebug() << "Sending" << buf->size() << "bytes:" << cmd;
// we use a non-interrupted write on Linux/Mac since the interrupt
// write block size is incorectly implemented in the version of
// libusb we build with. It is no less efficent.
#if defined Q_OS_MAC || WIN32 || __linux__
qint32 rc = usb_bulk_write(this->device, this->writeEndpoint, buf->data(), bytes, USB_TIMEOUT_MSEC);
#else // Workaround for OSX with the brew libusb package...
qint32 rc = usb_bulk_write(this->device, this->writeEndpoint, buf->constData(), bytes, USB_TIMEOUT_MSEC);
#endif
if (rc < 0)
{
if (rc == -110)
qDebug() << "Timeout";
else if (rc == -2)
qCritical() << "EndPoint not found";
else
qCritical() << "usb_interrupt_write Error writing: "<< usb_strerror();
}
return rc;
}
void write_configuration_block_USB500( usb_dev_handle *udev, configurationBlock *cblock )
{
__u8 send_configuration[3] = {0x01, 0xff, 0xff}; // Send Configuration String
__u8 acknowledge = 0x0; // Acknowledge
unsigned int size = 0;
int ret;
/* Determine the size of the Configuration Block */
switch(cblock->type) {
case 0x1: // EL-USB-1 Temperature Logger Packet size 64 bytes
case 0x2: // EL-USB-1 Temperature Logger Packet size 64 bytes
send_configuration[1] = 0x40; // Low Byte
send_configuration[2] = 0x00; // High Byte
size = 64;
break;
case 0x3: // EL-USB-2 Temperature/Humidity Logger Packet size 128 bytes
send_configuration[1] = 0x80; // Low Byte
send_configuration[2] = 0x00; // High Byte
size = 128;
break;
case 0x4: // EL-USB-3 Voltage Logger 256 bytes
case 0x6: // EL-USB-3 Voltage Logger 256 bytes
case 0x5: // EL-USB-4 Current Logger 256 bytes
case 0x7: // EL-USB-4 Current Logger 256 bytes
send_configuration[1] = 0x00; // Low Byte
send_configuration[2] = 0x01; // High Byte
size = 256;
break;
default:
printf("Unknown type device = %d\n", cblock->type);
return;
break;
}
unlock_device_USB500(udev);
ret = usb_bulk_write(udev, USB_ENDPOINT_OUT | 2, (char *) send_configuration, 3, USB500_WAIT_WRITE);
if (ret < 0) {
perror("Error in sending configuration acknowledgement (Bulk Write)");
}
ret = usb_bulk_write(udev, USB_ENDPOINT_OUT | 2, (char *) cblock, size, USB500_WAIT_WRITE);
if (ret < 0) {
perror("Error in sending configuration block (Bulk Write)");
}
acknowledge = 0x0;
do {
ret = usb_bulk_read(udev, USB_ENDPOINT_IN|2, (char *) &acknowledge, 1, USB500_WAIT_READ);
} while (acknowledge != 0xff);
lock_device_USB500(udev);
}
static int wrap_scsi(DPFContext * h, unsigned char *cmd, int cmdlen, char out,
unsigned char *data, unsigned long block_len)
{
int len;
int ret;
static unsigned char ansbuf[13]; // Do not change size.
g_buf[14] = cmdlen;
memcpy(&g_buf[15], cmd, cmdlen);
g_buf[8] = block_len;
g_buf[9] = block_len >> 8;
g_buf[10] = block_len >> 16;
g_buf[11] = block_len >> 24;
ret = usb_bulk_write(h->udev, ENDPT_OUT, (const char *) g_buf, sizeof(g_buf), 1000);
if (ret < 0)
return ret;
if (out == DIR_OUT) {
if (data) {
ret = usb_bulk_write(h->udev, ENDPT_OUT, (const char *) data, block_len, 3000);
if (ret != (int) block_len) {
fprintf(stderr, "dpf_ax ERROR: bulk write.\n");
return ret;
}
}
} else if (data) {
ret = usb_bulk_read(h->udev, ENDPT_IN, (char *) data, block_len, 4000);
if (ret != (int) block_len) {
fprintf(stderr, "dpf_ax ERROR: bulk read.\n");
return ret;
}
}
// get ACK:
len = sizeof(ansbuf);
int retry = 0;
int timeout = 0;
do {
timeout = 0;
ret = usb_bulk_read(h->udev, ENDPT_IN, (char *) ansbuf, len, 5000);
if (ret != len) {
fprintf(stderr, "dpf_ax ERROR: bulk ACK read.\n");
timeout = 1;
}
retry++;
} while (timeout && retry < 5);
if (strncmp((char *) ansbuf, "USBS", 4)) {
fprintf(stderr, "dpf_ax ERROR: got invalid reply\n.");
return -1;
}
// pass back return code set by peer:
return ansbuf[12];
}
int emulate_scsi(usb_dev_handle *dev, unsigned char *cmd, int cmdlen, char out,
unsigned char *data, unsigned long block_len)
{
int len;
int ret;
static unsigned char ansbuf[13]; // Do not change size.
g_buf[14] = cmdlen;
memcpy(&g_buf[15], cmd, cmdlen);
g_buf[8] = block_len;
g_buf[9] = block_len >> 8;
g_buf[10] = block_len >> 16;
g_buf[11] = block_len >> 24;
ret = usb_bulk_write(dev, ENDPT_OUT, g_buf, sizeof(g_buf), 1000);
if (ret < 0) return ret;
if (out == DIR_OUT) {
if (data) {
ret = usb_bulk_write(dev, ENDPT_OUT, (const char* )data,
block_len, 3000);
if (ret != block_len) {
perror("bulk write");
return ret;
}
}
} else if (data) {
ret = usb_bulk_read(dev, ENDPT_IN, (char *) data, block_len, 4000);
if (ret != block_len) {
perror("bulk data read");
}
}
// get ACK:
len = sizeof(ansbuf);
int retry = 0;
do {
ret = usb_bulk_read(dev, ENDPT_IN, (char *) ansbuf, len, 5000);
if (ret != len) {
perror("bulk ACK read");
ret = DEVERR_TIMEOUT;
}
retry++;
} while (ret == DEVERR_TIMEOUT && retry < 5);
if (strncmp((char *) ansbuf, "USBS", 4)) {
return handle_error("Got invalid reply\n");
}
// pass back return code set by peer:
return ansbuf[12];
}
int
pn53x_usb_bulk_write (struct pn53x_usb_data *data, uint8_t abtTx[], const size_t szTx, const int timeout)
{
LOG_HEX ("TX", abtTx, szTx);
int res = usb_bulk_write (data->pudh, data->uiEndPointOut, (char *) abtTx, szTx, timeout);
if (res > 0) {
// HACK This little hack is a well know problem of USB, see http://www.libusb.org/ticket/6 for more details
if ((res % data->uiMaxPacketSize) == 0) {
usb_bulk_write (data->pudh, data->uiEndPointOut, "\0", 0, timeout);
}
} else {
log_put (LOG_CATEGORY, NFC_PRIORITY_ERROR, "Unable to write to USB (%s)", _usb_strerror (res));
}
return res;
}
int send_usb(const char *msg, struct my_usb_device *mydev, struct fpga_packet_header *phead, int len, int timeout)
{
char *p = (char *)phead;
int ret;
if(verbose >= LOG_DEBUG)
dump_packet(msg, p, len);
if(mydev->my_ep_out & USB_ENDPOINT_IN) {
ERR("send_usb called with an input endpoint 0x%x\n", mydev->my_ep_out);
return -EINVAL;
}
ret = usb_bulk_write(mydev->handle, mydev->my_ep_out, p, len, timeout);
if(ret < 0) {
/*
* If the device was gone, it may be the
* result of renumeration. Ignore it.
*/
if(ret != -ENODEV) {
ERR("bulk_write to endpoint 0x%x failed: %s\n", mydev->my_ep_out, usb_strerror());
dump_packet("send_usb[ERR]", p, len);
} else {
disconnected = 1;
my_usb_device_cleanup(mydev);
}
return ret;
} else if(ret != len) {
ERR("bulk_write to endpoint 0x%x short write: %s\n", mydev->my_ep_out, usb_strerror());
dump_packet("send_usb[ERR]", p, len);
return -EFAULT;
}
return ret;
}
u8 usb_storage_read_capacity(u8 device)
{
/* send cwb "usbc" */
u8 tmp[8];
u8 i;
usb_storage_cbw * cbw = (usb_storage_cbw*)malloc(sizeof(usb_storage_cbw));
usb_control_msg(massstorage[device], 0x02,1,0, 0x8100, 0,tmp, 0);
cbw->dCBWSignature= 0x43425355;
cbw->dCBWTag=0x826A6008;
cbw->dCBWDataTransferLength=0x00000008;
cbw->bCWDFlags=0x80;
cbw->bCBWLun=0x00;
cbw->bCBWCBLength=0x0A;
for(i=0;i<16;i++)
cbw->CBWCB[i]=0x00;
cbw->CBWCB[0]=0x25; // 0x12 = INQUIRY
usb_bulk_write(massstorage[device], 2, (u8*)cbw, 31, 0);
usb_bulk_read(massstorage[device], 1, (u8*)cbw, 8, 0);
usb_bulk_read(massstorage[device], 1, (u8*)cbw, 13, 0);
free(cbw);
return 0;
}
/*
* ep1 commands are up to USB_EP1OUT_SIZE bytes in length.
* This function takes care of zeroing the unused bytes before sending the packet.
* Any reply packet is not handled by this function.
*/
static int ep1_generic_commandl(usb_dev_handle *pHDev_param, size_t length, ...)
{
uint8_t usb_buffer[USB_EP1OUT_SIZE];
uint8_t *usb_buffer_p;
va_list ap;
int usb_ret;
if (length > sizeof(usb_buffer))
length = sizeof(usb_buffer);
usb_buffer_p = usb_buffer;
va_start(ap, length);
while (length > 0) {
*usb_buffer_p++ = va_arg(ap, int);
length--;
}
memset(
usb_buffer_p,
0,
sizeof(usb_buffer) - (usb_buffer_p - usb_buffer)
);
usb_ret = usb_bulk_write(
pHDev_param,
USB_EP1OUT_ADDR,
(char *)usb_buffer, sizeof(usb_buffer),
USB_TIMEOUT_MS
);
return usb_ret;
}
int main(int argc, char *argv[]) {
if (2 != argc) {
usage();
return 1;
}
struct usb_dev_handle *hdev = open_port();
if (!hdev) {
return 1;
}
unsigned int len = 0;
unsigned char* write_buf = prepare_write_buf(argv[1], &len);
if (NULL == write_buf)
return 1;
unsigned int remain = len;
unsigned int towrite;
printf("Writing data ...\n");
while (remain) {
towrite = remain > 512 ? 512 : remain;
if (towrite != usb_bulk_write(hdev, 0x03, write_buf + (len - remain),
towrite, 3000)) {
perror("usb_bulk_write failed");
break;
}
remain -= towrite;
printf("\r%d%\t %d bytes ", (len - remain) * 100 / len, len
- remain);
fflush(stdout);
}
if (0 == remain)
printf("Done!\n");
return 0;
}
int xusb_send(struct xusb *xusb, char *buf, int len, int timeout)
{
int ret;
dump_packet(LOG_DEBUG, DBG_MASK, __FUNCTION__, buf, len);
if(EP_OUT(xusb) & USB_ENDPOINT_IN) {
ERR("%s called with an input endpoint 0x%x\n", __FUNCTION__, EP_OUT(xusb));
return -EINVAL;
}
ret = usb_bulk_write(xusb->handle, EP_OUT(xusb), buf, len, timeout);
if(ret < 0) {
/*
* If the device was gone, it may be the
* result of renumeration. Ignore it.
*/
if(ret != -ENODEV) {
ERR("bulk_write to endpoint 0x%x failed: (%d) %s\n",
EP_OUT(xusb), ret, usb_strerror());
dump_packet(LOG_ERR, DBG_MASK, "xbus_send[ERR]", buf, len);
//exit(2);
} else {
DBG("bulk_write to endpoint 0x%x got ENODEV\n", EP_OUT(xusb));
xusb_close(xusb);
}
return ret;
} else if(ret != len) {
ERR("bulk_write to endpoint 0x%x short write: (%d) %s\n",
EP_OUT(xusb), ret, usb_strerror());
dump_packet(LOG_ERR, DBG_MASK, "xbus_send[ERR]", buf, len);
return -EFAULT;
}
return ret;
}
int musb_write(MUSB_INTERFACE *musb_interface, int endpoint, const void *buf, int count, int timeout)
{
int n_written;
#if defined(HAVE_LIBUSB)
n_written = usb_bulk_write(musb_interface->dev, endpoint, (char*)buf, count, timeout);
if (n_written != count) {
fprintf(stderr, "musb_write: requested %d, wrote %d, errno %d (%s)\n", count, n_written, errno, strerror(errno));
}
#elif defined(HAVE_LIBUSB10)
int status = libusb_bulk_transfer(musb_interface->dev, endpoint, (unsigned char*)buf, count, &n_written, timeout);
if (n_written != count) {
fprintf(stderr, "musb_write: requested %d, wrote %d, errno %d (%s)\n", count, n_written, status, strerror(status));
}
#elif defined(OS_DARWIN)
IOReturn status;
IOUSBInterfaceInterface182 **interface = (IOUSBInterfaceInterface182 **)musb_interface->interface;
status = (*interface)->WritePipeTO(interface, endpoint, buf, count, 0, timeout);
if (status != 0) {
fprintf(stderr, "musb_write: WritePipe() status %d 0x%x\n", status, status);
return -1;
}
n_written = count;
#elif defined(_MSC_VER)
WriteFile(musb_interface->whandle, buf, count, &n_written, NULL);
#endif
//fprintf(stderr, "musb_write(ep %d, %d bytes) (%s) returns %d\n", endpoint, count, buf, n_written);
return n_written;
}
int write_cmd(usb_dev_handle *udev, unsigned char *cmd, int read)
{
int ret=0, i=0;
unsigned char receive_data[1024];
unsigned char interrupt_data;
for (i=0; i<1024; i++)
receive_data[i] = 0x00;
printf("write_cmd\n");
ret = usb_bulk_write(udev, 0x02, cmd, sizeof(cmd), 10000);
if (ret != sizeof(cmd))
printf("Error!\n");
//if (read)
{
ret = usb_bulk_read(udev, 0x81, receive_data, sizeof(receive_data), 10000);
mcrw_debug(receive_data, ret);
}
//else
{
ret = usb_interrupt_read(udev, 0x83, &interrupt_data, 1, 10000);
mcrw_debug(&interrupt_data, ret);
}
return 0;
}
bool MotorController::sendCommandWithPayload(string command, string payload) {
int packetSize = 64;
char OutputPacketBuffer[64] = {0}; //Allocate a memory buffer which will contain data to send to the USB device
string toSendString = "";
wchar_t payloadLength = 1;
if (payload.size() > 0 && payload != "") {
payloadLength = payload.size();
toSendString = command + (char)payloadLength + payload;
for (int i = 0; i < toSendString.size(); i++) {
OutputPacketBuffer[i] = toSendString[i];
printf ("Byte out #%i: [%i] \n",i,toSendString[i]);
}
}
else {
payloadLength = 0;
toSendString = command + (char)payloadLength;
OutputPacketBuffer[0] = toSendString[0];
OutputPacketBuffer[1] = (char)0;
}
if(usb_bulk_write(usbDeviceHandle, 0x01, &OutputPacketBuffer[0], packetSize, 500) != packetSize)
return false;
return true;
}
int grecko_read(unsigned long addr, unsigned char *buf, int size)
{
unsigned char data[8];
unsigned long addr2 = addr+size;
unsigned char *ptr = (unsigned char*) &addr;
int i, ret;
addr = htonl(addr - (addr%4));
addr2 = htonl(addr2 - (addr2%4));
/* read command */
grecko_send_command(4);
/* memory offsets */
memcpy(data, addr, 4);
memcpy(data, addr2, 4);
usb_bulk_write(dev, ep, (unsigned char *)&data, 8, timeout);
/* data read */
ret = usb_bulk_read(dev, ep, (unsigned char *)buf, 4096, timeout);
if (ret < 0)
return -1;
for(i=0;i<ret;i++) {
printf("%02x ", readbuf[i]);
}
return ret;
}
/* Optimised packet handling to reduce overhead during bulk file transfers. */
int send_cancel(libusb_device_handle* fd)
{
trace(3, printf("send_cancel\n"));
return usb_bulk_write(fd, 0x01, cancel_packet, 8, default_timeout());
}
int cable_usbblaster_out(uint8_t value)
{
int rv; // to catch return values of functions
char out;
int err = APP_ERR_NONE;
// open the device, if necessary
if(h_device == NULL) {
rv = cable_usbblaster_open_cable();
if(rv != APP_ERR_NONE) return rv;
}
out = (USBBLASTER_CMD_OE | USBBLASTER_CMD_nCS); // Set output enable (appears necessary) and nCS (necessary for byte-shift reads)
// Translate to USB blaster protocol
// USB-Blaster has no TRST pin
if(value & TCLK_BIT)
out |= USBBLASTER_CMD_TCK;
if(value & TDI_BIT)
out |= USBBLASTER_CMD_TDI;
if(value & TMS_BIT)
out |= USBBLASTER_CMD_TMS;
rv = usb_bulk_write(h_device, EP2, &out, 1, USB_TIMEOUT);
if (rv != 1){
fprintf(stderr, "\nFailed to write to the FIFO (rv = %d):\n%s", rv, usb_strerror());
err |= APP_ERR_USB;
}
return err;
}
int lothar_usb_write(void *connection, uint8_t const *data, size_t len)
{
int status = usb_bulk_write((usb_dev_handle *)connection, USB_ENDPOINT_OUT | 1, (char *)data, len, 0);
if(status < 0)
LOTHAR_RETURN_ERROR(LOTHAR_ERROR_NXT_WRITE_ERROR);
return status;
}
int TCD2Usb::TCD2Usb_bulk_write_EP1OUT(const char *buf, size_t nbytes)
{
int retval = 0;
// EP1OUT only takes 64 bytes total
if( nbytes > 64 )
{
// printf("TCD2Usb::TCD2Usb_bulk_write_EP1OUT: > 64 bytes for EP1OUT write\n");
return -TCD2USB_WRITE_TOO_MANY_BYTES_ERR;
}
// Check if TCD USB device is open
if(!IsOpen())
{
// printf("TCD2Usb::TCD2Usb_bulk_write_EP1OUT: TCD2 USB device not open!\n");
return -TCD2USB_OPEN_ERR;
}
// Check if TCD USB device is claimed
if(!IsClaimed())
{
// printf("TCD2Usb::TCD2Usb_bulk_write_EP1IN: TCD2 USB device not claimed!\n");
return -TCD2USB_CLAIM_ERR;
}
// Write to EP1OUT
if( (retval = usb_bulk_write(usbhdl,1,(char*)buf,nbytes,10)) < 0 )// timeout is ms
{
// printf("TCD2Usb::TCD2Usb_bulk_write: Write attempt failed. Returned %d\n",retval);
// printf("usbhdl = %d\n",usbhdl);
return -TCD2USB_WRITE_ERR;
}
//printf("Was able to write\n");
return 0;
}
int camera_bulk_write(usb_dev_handle *handle, char *buffer, int length)
{
if(verbose)
fprintf(stderr, "CAMERA BULK WRITE %x\n", length);
return usb_bulk_write(handle, CAMERA_BULK_WRITE_EP, buffer, length,
USB_TIMEOUT);
}
void sendBuffer(char* buffer, size_t size) {
OpenIBootCmd cmd;
cmd.command = OPENIBOOTCMD_SENDCOMMAND;
cmd.dataLen = size;
usb_interrupt_write(device, 4, (char*) (&cmd), sizeof(OpenIBootCmd), 1000);
while(1) {
usb_interrupt_read(device, 3, (char*) (&cmd), sizeof(OpenIBootCmd), 1000);
if(cmd.command == OPENIBOOTCMD_SENDCOMMAND_GOAHEAD)
break;
}
int toSend = 0;
while(size > 0) {
if(size <= MAX_TO_SEND)
toSend = size;
else
toSend = MAX_TO_SEND;
usb_bulk_write(device, 2, buffer, toSend, 1000);
buffer += toSend;
size -= toSend;
}
}
static vsf_err_t versaloon_libusb_comm_transact(uint8_t *buffer_out,
uint16_t out_len, uint8_t *buffer_in, uint16_t *in_len)
{
int ret;
ret = usb_bulk_write(versaloon_device_handle, usb_param_epout(),
(char *)buffer_out, out_len, versaloon_to);
if (ret != out_len)
{
LOG_ERROR(ERRMSG_FAILURE_OPERATION_ERRSTRING, "send usb data",
usb_strerror());
return ERRCODE_FAILURE_OPERATION;
}
if (in_len != NULL)
{
ret = usb_bulk_read(versaloon_device_handle, usb_param_epin(),
(char *)buffer_in, *in_len, versaloon_to);
if (ret > 0)
{
*in_len = (uint16_t)ret;
return VSFERR_NONE;
}
else
{
LOG_ERROR(ERRMSG_FAILURE_OPERATION_ERRSTRING, "receive usb data",
usb_strerror());
return VSFERR_FAIL;
}
}
else
{
return VSFERR_NONE;
}
}
void SendCommand(UsbCommand *c)
{
int ret;
#if 0
printf("Sending %d bytes\n", sizeof(UsbCommand));
#endif
ret = usb_bulk_write(devh, 0x01, (char*)c, sizeof(UsbCommand), 1000);
if (ret<0) {
error_occured = 1;
if (return_on_error)
return;
fprintf(stderr, "write failed: %s!\nTrying to reopen device...\n",
usb_strerror());
if (devh) {
usb_close(devh);
devh = NULL;
}
while(!OpenProxmark(0)) { sleep(1); }
printf(PROXPROMPT);
fflush(NULL);
return;
}
}
int LibUsb::write(char *buf, int bytes, int timeout)
{
// check it isn't closed
if (!device) return -1;
int rc;
if (OperatingSystem == WINDOWS) {
rc = usb_interrupt_write(device, writeEndpoint, buf, bytes, 1000);
} else {
// we use a non-interrupted write on Linux/Mac since the interrupt
// write block size is incorrectly implemented in the version of
// libusb we build with. It is no less efficient.
rc = usb_bulk_write(device, writeEndpoint, buf, bytes, timeout);
}
if (rc < 0)
{
// Report timeouts - previously we ignored -110 errors. This masked a serious
// problem with write on Linux/Mac, the USB stick needed a reset to avoid
// these error messages, so we DO report them now
qDebug()<<"usb_interrupt_write Error writing ["<<rc<<"]: "<< usb_strerror();
}
return rc;
}
/*****************************************************************************
*
* WriteUSB
*
****************************************************************************/
status_t WriteUSB(unsigned int reader_index, unsigned int length,
unsigned char *buffer)
{
int rv;
char debug_header[] = "-> 121234 ";
(void)snprintf(debug_header, sizeof(debug_header), "-> %06X ",
(int)reader_index);
DEBUG_XXD(debug_header, buffer, length);
rv = usb_bulk_write(usbDevice[reader_index].handle,
usbDevice[reader_index].bulk_out, (char *)buffer, length,
USB_WRITE_TIMEOUT);
if (rv < 0)
{
DEBUG_CRITICAL4("usb_bulk_write(%s/%s): %s",
usbDevice[reader_index].dirname, usbDevice[reader_index].filename,
strerror(errno));
if (ENODEV == errno)
return STATUS_NO_SUCH_DEVICE;
return STATUS_UNSUCCESSFUL;
}
return STATUS_SUCCESS;
} /* WriteUSB */
unsigned char *mc2rw_read_page(usb_dev_handle *udev, int page)
{
int i=0, p=0, wret=0, rret=0;
int prev_size;
static unsigned char data_p[USB_FRAMESIZE*4], temp_data[USB_FRAMESIZE];
struct psx_usb_read_receive_buf receive_data;
mcrw_addr_debug(page);
mc2rw_read_set_sector(udev, page);
/* read data */
printf("Reading Data\n");
for (p=0; p<4; p++)
{
unsigned char send_data[148] = {0xaa, 0x42, 0x90, 0x00, 0x81, 0x43, 0x80, 0x00, 0x00};
//mcrw_debug(send_data, sizeof(send_data));
wret = usb_bulk_write(udev, 0x02, send_data, sizeof(send_data), 1000);
rret = usb_bulk_read(udev, 0x81, temp_data, sizeof(temp_data), 1000);
//printf("segment: &(data_p[%d]) = 0x%X\n", USB_FRAMESIZE*p, &(data_p[USB_FRAMESIZE*p]));
memcpy(&(data_p[USB_FRAMESIZE*p]), temp_data, rret);
}
mcrw_debug(data_p, sizeof(data_p));
mc2rw_read_ecc(udev);
mc2rw_read_commit(udev);
return data_p;
}
grub_usb_err_t
grub_usb_bulk_write (grub_usb_device_t dev,
int endpoint, grub_size_t size, char *data)
{
usb_dev_handle *devh;
struct usb_device *d = dev->data;
devh = usb_open (d);
if (usb_claim_interface (devh, 0) < 0)
goto fail;
if (usb_bulk_write (devh, endpoint, data, size, 20) < 0)
goto fail;
if (usb_release_interface (devh, 0) < 0)
goto fail;
usb_close (devh);
return GRUB_USB_ERR_NONE;
fail:
usb_close (devh);
return GRUB_USB_ERR_STALL;
}
u8 usb_storage_inquiry(u8 device)
{
/* send cwb "usbc" */
usb_storage_cbw *cbw = (usb_storage_cbw*)malloc(sizeof(usb_storage_cbw));
cbw->dCBWSignature= 0x43425355;
cbw->dCBWTag=0x826A6008;
cbw->dCBWDataTransferLength=0x00000024;
cbw->bCWDFlags=0x80;
cbw->bCBWLun=0x00;
cbw->bCBWCBLength=0x01;
u8 i;
for(i=0;i<16;i++)
cbw->CBWCB[i]=0x00;
cbw->CBWCB[0]=0x12; // 0x12 = INQUIRY
usb_bulk_write(massstorage[device], 2, (u8*)cbw, 31, 0);
usb_bulk_read(massstorage[device], 1, (u8*)cbw, 36, 0);
usb_bulk_read(massstorage[device], 1, (u8*)cbw, 13, 0);
free(cbw);
return 0;
}
void test_bulk_transfer(usb_dev_handle *dev)
{
int r,i;
char answer[reqBulkLen];
char question[reqBulkLen];
for (i=0;i<reqBulkLen; i++) question[i]=i;
r = usb_bulk_write(dev, endpoint_Bulk_out, question, reqBulkLen, timeout);
if( r < 0 )
{
perror("USB bulk write"); bad("USB write failed");
}
r = usb_bulk_read(dev, endpoint_Bulk_in, answer, reqBulkLen, timeout);
if( r != reqBulkLen )
{
perror("USB bulk read"); bad("USB read failed");
}
// for (i=0;i<reqBulkLen;i++) printf("%i, %i, \n",question[i],answer[i]);
for(i = 0;i < reqBulkLen; i++) {
if(i%8 == 0)
printf("\n");
printf("%02x, %02x; ",question[i],answer[i]);
}
printf("\n");
// usb_set_altinterface(dev, 0);
usb_release_interface(dev, 0);
}
/*****************************************************************************
*
* WriteUSB
*
****************************************************************************/
status_t WriteUSB(unsigned int reader_index, unsigned int length,
unsigned char *buffer)
{
int rv;
char debug_header[] = "-> 121234 ";
int pos;
int len;
int delayed = FALSE;
(void)snprintf(debug_header, sizeof(debug_header), "-> %06X ",
(int)reader_index);
DEBUG_XXD(debug_header, buffer, length);
// Fix APG8201 and ACR85 ICC cannot receive command properly
// Add delay for APG8201 and ACR85 ICC
if ((usbDevice[reader_index].ccid.readerID == ACS_APG8201) ||
(usbDevice[reader_index].ccid.readerID == ACS_ACR85_PINPAD_READER_ICC))
{
delayed = TRUE;
}
// Send command by dividing number of packets
pos = 0;
while (length > 0)
{
if (length > usbDevice[reader_index].bulkOutMaxPacketSize)
len = usbDevice[reader_index].bulkOutMaxPacketSize;
else
len = length;
rv = usb_bulk_write(usbDevice[reader_index].handle,
usbDevice[reader_index].bulk_out, (char *)buffer + pos, len,
USB_WRITE_TIMEOUT);
if (rv < 0)
{
DEBUG_CRITICAL4("usb_bulk_write(%s/%s): %s",
usbDevice[reader_index].dirname, usbDevice[reader_index].filename,
strerror(errno));
if (ENODEV == errno)
return STATUS_NO_SUCH_DEVICE;
return STATUS_UNSUCCESSFUL;
}
if (delayed)
{
// Delay 10 ms
if (length > usbDevice[reader_index].bulkOutMaxPacketSize)
usleep(10 * 1000);
}
pos += len;
length -= len;
}
return STATUS_SUCCESS;
} /* WriteUSB */
