source: thomson/elec/CrO2/software/device.cpp@ 53c4be3

/* CrO2 datassette emulator
 * Copyright 2012, Adrien Destugues <pulkomandy@pulkomandy.ath.cx>
 *
 * Distributed under the terms of the MIT licence.
 *
 * Handles device communication through libusb
 */

#include "device.h"
#include "k5.h"

#include <typeinfo>

bool Device::initOnce = false;
Device* Device::instance = NULL;

const uint32_t Device::vid = 0x16C0;
const uint32_t Device::pid = 0x05DC;
const char* Device::vendor = "pulkomandy.ath.cx";
const char* Device::product = "CrO2";

/* These are the vendor specific commands implemented by our USB device */
#define PSCMD_CONFIG  0
#define PSCMD_GET   1
#define PSCMD_PUT   2
#define PSCMD_STATUS   3


// Gets the device instance. Throws an error message if something bad happens.
Device& Device::getDevice() throw(const char*)
{
        if (instance == NULL)
                instance = new Device();

        return *instance;
}


/* USB device lookup by VID and PID, then Vendor and Product strings, as we use
 * V-USB shared ID. */
static int  usbGetStringAscii(usb_dev_handle *dev, int index, int langid,
        char *buf, int buflen)
{
char    buffer[256];
int     rval, i;

    if((rval = usb_control_msg(dev, USB_ENDPOINT_IN, USB_REQ_GET_DESCRIPTOR,
                        (USB_DT_STRING << 8) + index, langid, buffer, sizeof(buffer), 1000)) < 0)
        return rval;
    if(buffer[1] != USB_DT_STRING)
        return 0;
    if((unsigned char)buffer[0] < rval)
        rval = (unsigned char)buffer[0];
    rval /= 2;
    /* lossy conversion to ISO Latin1 */
    for(i=1;i<rval;i++){
        if(i > buflen)  /* destination buffer overflow */
            break;
        buf[i-1] = buffer[2 * i];
        if(buffer[2 * i + 1] != 0)  /* outside of ISO Latin1 range */
            buf[i-1] = '?';
    }
    buf[i-1] = 0;
    return i-1;
}

Device::Device() throw(const char*)
{
        handle = NULL;

        if (!initOnce)
        {
                initOnce = true;
                usb_init();
        }

    usb_find_busses();
    usb_find_devices();

    for(struct usb_bus* bus=usb_get_busses(); bus; bus=bus->next)
        {
                for(struct usb_device* dev=bus->devices; dev; dev=dev->next)
                {
                        if(dev->descriptor.idVendor != vid || dev->descriptor.idProduct != pid)
                                continue;

                        // Found device with correct VID and PID. Now try to match the 
                        // vendor and product strings
                        char    string[256];
                        int     len;
                        handle = usb_open(dev);
                                /* we need to open the device in order to query strings */
                        if(!handle){
                                continue;
                        }
                        /* now check whether the names match: */
                        len = usbGetStringAscii(handle, dev->descriptor.iManufacturer,
                                0x0409, string, sizeof(string));
                        if(len >= 0)
                        {
                                if(strcmp(string, vendor) == 0){
                                        len = usbGetStringAscii(handle, dev->descriptor.iProduct,
                                                0x0409, string, sizeof(string));
                                        if(len >= 0){
                                                if(strcmp(string, product) == 0)
                                                        break;
                                        }
                                }
                        }
                        usb_close(handle);
                        handle = NULL;
                }
                if(handle)
                        break;
        }

        // At this point, either we have found a device and handle is pointing to it,
        // or we failed and handle is NULL.
        if (!handle)
                throw "Device not found. Is the USB cable plugged correctly?";
}


Device::~Device()
{
        usb_close(handle);
}


int Device::read(uint8_t* buffer, size_t max)
{
        return usb_control_msg(handle, USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_IN,
                PSCMD_GET, 0,0, (char*)buffer, max, 5000);

}


int Device::write(const uint8_t* buffer, size_t size, int blktype)
{
        int rqtype = (size == 0) ? USB_ENDPOINT_IN:USB_ENDPOINT_OUT;
        return usb_control_msg(handle, USB_TYPE_VENDOR | USB_RECIP_DEVICE | rqtype,
                PSCMD_PUT, blktype,0 /*checksum*/, (char*)buffer, size, 5000);

}


void Device::write(const Tape& file) throw (const char*)
{
        for (int k = 0; k < file.getBlockCount(); k++)
        {
                // wait for motor on
                while (getStatus() & 8)
                        Sleep(1000);

                const Tape::Block& block = file.getBlock(k);
                try {
                        const K5::Block& moblock = dynamic_cast<const K5::Block&>(block); 
                        write(moblock.data, moblock.length - 1, moblock.type);
                                // TODO error handling on write
                } catch (std::bad_cast x) {
                        throw "Only MO5 files supported so far. Sorry!";
                };

                // TODO wait for correct time (read status from usb OR compute from size+type)
                Sleep(1400);
        }
}

uint8_t Device::getStatus()
{
        uint8_t status;
        usb_control_msg(handle, USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_IN,
                        PSCMD_STATUS, 0,0, (char*)&status, 1, 5000);
                // TODO handle errors (return value)
        return status;
}