//---------------------------------------------------------------------------
int part_connect(mass_dev* dev)
{
part_table partTable;
unsigned int count = 0, i;
XPRINTF("USBHDFSD: part_connect devId %i \n", dev->devId);
if (part_getPartitionTable(dev, &partTable) < 0)
return -1;
for ( i = 0; i < 4; i++)
{
if(
partTable.record[ i ].sid == 6 ||
partTable.record[ i ].sid == 4 ||
partTable.record[ i ].sid == 1 || // fat 16, fat 12
partTable.record[ i ].sid == 0x0B ||
partTable.record[ i ].sid == 0x0C || // fat 32
partTable.record[ i ].sid == 0x0E) // fat 16 LBA
{
XPRINTF("USBHDFSD: mount partition %d\n", i);
if (fat_mount(dev, partTable.record[i].start, partTable.record[i].count) >= 0)
count++;
}
}
if ( count == 0 )
{ // no partition table detected
// try to use "floppy" option
XPRINTF("USBHDFSD: mount drive\n");
if (fat_mount(dev, 0, dev->maxLBA) < 0)
return -1;
}
return 0;
}
/*
* (*kp) and k have the same mod and keysym. Both have a non-null ->chain.
* if there is a key in the (*kp)->chain list (*lp) that has the same mod and
* keysm as k->chain, then free (*lp) and set its location to *kp->chain
*/
static void
mergechain(Key *c, Key *k)
{
Key **lp;
Key *next = k->chain;
XPRINTF("Merging chain %s\n", showchain(k));
XPRINTF(" into chain %s\n", showchain(c));
k->chain = NULL;
freekey(k);
k = next;
for (lp = &c->chain; *lp; lp = &(*lp)->cnext)
if ((*lp)->mod == k->mod && (*lp)->keysym == k->keysym)
break;
if (*lp) {
if ((*lp)->chain && k->chain)
mergechain(*lp, k);
else {
XPRINTF("Overriding previous key alternate %s!\n", showchain(k));
k->cnext = (*lp)->cnext;
(*lp)->cnext = NULL;
freechain(*lp);
*lp = k;
}
} else {
k->cnext = NULL;
*lp = k;
}
}
/*-------------------------------------------------------------------------*/
int
writen (int fd, char *mesg, int len, struct equeue_s **qpp)
/* Send or queue the message <mesg> (length <len> bytes) to <fd>.
* If *<qpp> is non-NULL, the message is queued immediately.
* Otherwise, the function tries to send as much of the message
* as possible, and the queues whatever is left.
*/
{
int l = 0;
XPRINTF((stderr, "%s writen(%d, %p:%d, %p (-> %p) ))\n"
, time_stamp(), fd, mesg, len, qpp, *qpp));
if (!(*qpp))
{
/* Send as much of the message as possible */
do
l = write(fd, mesg, len);
while (l == -1 && errno == EINTR);
XPRINTF((stderr, "%s Wrote %d bytes.\n", time_stamp(), l));
if (l < 0 || l == len)
return l;
mesg += l;
len -= l;
}
if (!len)
return 0;
XPRINTF((stderr, "%s Queuing data %p:%d\n", time_stamp(), mesg, len));
add_to_queue(qpp, mesg, len, 0);
return l;
} /* writen() */
static int mass_stor_warmup(mass_dev *dev) {
inquiry_data id;
sense_data sd;
read_capacity_data rcd;
int stat;
XPRINTF("USBHDFSD: mass_stor_warmup\n");
if (!(dev->status & USBMASS_DEV_STAT_CONN)) {
printf("USBHDFSD: Error - no mass storage device found!\n");
return -1;
}
stat = usb_bulk_get_max_lun(dev);
XPRINTF("USBHDFSD: usb_bulk_get_max_lun %d\n", stat);
memset(&id, 0, sizeof(inquiry_data));
if ((stat = cbw_scsi_inquiry(dev, &id, sizeof(inquiry_data))) < 0) {
printf("USBHDFSD: Error - cbw_scsi_inquiry %d\n", stat);
return -1;
}
printf("USBHDFSD: Vendor: %.8s\n", id.vendor);
printf("USBHDFSD: Product: %.16s\n", id.product);
printf("USBHDFSD: Revision: %.4s\n", id.revision);
while((stat = cbw_scsi_test_unit_ready(dev)) != 0)
{
printf("USBHDFSD: Error - cbw_scsi_test_unit_ready %d\n", stat);
stat = cbw_scsi_request_sense(dev, &sd, sizeof(sense_data));
if (stat != 0)
printf("USBHDFSD: Error - cbw_scsi_request_sense %d\n", stat);
if ((sd.error_code == 0x70) && (sd.sense_key != 0x00))
{
printf("USBHDFSD: Sense Data key: %02X code: %02X qual: %02X\n", sd.sense_key, sd.add_sense_code, sd.add_sense_qual);
if ((sd.sense_key == 0x02) && (sd.add_sense_code == 0x04) && (sd.add_sense_qual == 0x02))
{
printf("USBHDFSD: Error - Additional initalization is required for this device!\n");
if ((stat = cbw_scsi_start_stop_unit(dev)) != 0) {
printf("USBHDFSD: Error - cbw_scsi_start_stop_unit %d\n", stat);
return -1;
}
}
}
}
if ((stat = cbw_scsi_read_capacity(dev, &rcd, sizeof(read_capacity_data))) != 0) {
printf("USBHDFSD: Error - cbw_scsi_read_capacity %d\n", stat);
return -1;
}
dev->sectorSize = getBI32(&rcd.block_length);
dev->maxLBA = getBI32(&rcd.last_lba);
printf("USBHDFSD: sectorSize %u maxLBA %u\n", dev->sectorSize, dev->maxLBA);
return 0;
}
//---------------------------------------------------------------------------
static int fs_getstat(iop_file_t *fd, const char *name, fio_stat_t *stat)
{
fat_driver* fatd;
int ret;
unsigned int cluster = 0;
fat_dir fatdir;
_fs_lock();
XPRINTF("USBHDFSD: fs_getstat called: unit %d name %s\n", fd->unit, name);
fatd = fat_getData(fd->unit);
if (fatd == NULL) { _fs_unlock(); return -ENODEV; }
XPRINTF("USBHDFSD: Calling fat_getFileStartCluster from fs_getstat\n");
ret = fat_getFileStartCluster(fatd, name, &cluster, &fatdir);
if (ret < 0) {
_fs_unlock();
return ret;
}
memset(stat, 0, sizeof(fio_stat_t));
fillStat(stat, &fatdir);
_fs_unlock();
return 0;
}
static Key *
parsechain(const char *s, const char *e, Key *spec)
{
const char *p, *q;
Key *chain = NULL, *last = NULL;
XPRINTF("Parsing chain from: '%s'\n", s);
for (p = s; p < e; p = (*q == ':' ? q + 1 : q)) {
Key *k;
for (q = p;
q < e && (isalnum(*q) || isblank(*q) || *q == '_' || *q == '+');
q++) ;
if (q < e && *q != ':')
q = e;
k = ecalloc(1, sizeof(*k));
*k = *spec;
if (!parsekey(p, q, k)) {
freekey(k);
freechain(chain);
chain = last = NULL;
break;
}
chain = chain ? : k;
if (last) {
last->func = &k_chain;
last->chain = k;
}
last = k;
}
if (chain)
XPRINTF("Parsed chain: %s\n", showchain(chain));
return chain;
}
//---------------------------------------------------------------------------
int scache_writeSector(cache_set* cache, unsigned int sector) {
int index; //index is given in single sectors not octal sectors
//int ret;
XPRINTF("cache: writeSector devId = %i sector = %i \n", cache->dev->devId, sector);
index = getSlot(cache, sector);
if (index < 0) { //sector not found in cache
printf("cache: writeSector: ERROR! the sector is not allocated! \n");
return -1;
}
XPRINTF("cache: slotFound=%i \n", index);
//prefere written sectors to stay in cache longer than read sectors
cache->rec[index].tax += 2;
//set dirty status
cache->rec[index].writeDirty = 1;
cache->writeFlag++;
XPRINTF("cache: done soft writing sector \n");
//write precaution
//cache->flushCounter++;
//if (cache->flushCounter == FLUSH_TRIGGER) {
//scache_flushSectors(devId);
//}
return cache->sectorSize;
}
/*
flush dirty sectors
*/
int scache_flushSectors(cache_set* cache) {
int i,ret;
int counter = 0;
XPRINTF("cache: flushSectors devId = %i \n", cache->dev->devId);
//cache->flushCounter = 0;
XPRINTF("scache: flushSectors writeFlag=%d\n", cache->writeFlag);
//no write operation occured since last flush
if (cache->writeFlag==0) {
return 0;
}
for (i = 0; i < CACHE_SIZE; i++) {
if (cache->rec[i].writeDirty) {
XPRINTF("scache: flushSectors dirty index=%d sector=%d \n", i, cache->rec[i].sector);
ret = WRITE_SECTOR(cache->dev, cache->rec[i].sector, cache->sectorBuf + (i * BLOCK_SIZE), BLOCK_SIZE);
cache->rec[i].writeDirty = 0;
//TODO - error handling
if (ret < 0) {
printf("scache: ERROR writing sector to disk! sector=%d\n", cache->rec[i].sector);
return ret;
}
counter ++;
}
}
cache->writeFlag = 0;
return counter;
}
//---------------------------------------------------------------------------
cache_set* scache_init(mass_dev* dev, int sectSize)
{
cache_set* cache;
XPRINTF("cache: init devId = %i sectSize = %i \n", dev->devId, sectSize);
cache = malloc(sizeof(cache_set));
if (cache == NULL) {
printf("scache init! Sector cache: can't alloate cache!\n");
return NULL;
}
XPRINTF("scache init! \n");
cache->dev = dev;
XPRINTF("sectorSize: 0x%x\n", cache->sectorSize);
cache->sectorBuf = (unsigned char*) malloc(BLOCK_SIZE * CACHE_SIZE);
if (cache->sectorBuf == NULL) {
printf("Sector cache: can't alloate memory of size:%d \n", BLOCK_SIZE * CACHE_SIZE);
free(cache);
return NULL;
}
XPRINTF("Sector cache: allocated memory at:%p of size:%d \n", cache->sectorBuf, BLOCK_SIZE * CACHE_SIZE);
//added by Hermes
cache->sectorSize = sectSize;
cache->indexLimit = BLOCK_SIZE/cache->sectorSize; //number of sectors per 1 cache slot
cache->cacheAccess = 0;
cache->cacheHits = 0;
initRecords(cache);
return cache;
}
int ieee1394_SendCommandBlockORB(struct SBP2Device *dev, struct CommandDescriptorBlock *firstCDB){
int result, retries;
struct sbp2_pointer address;
memset((unsigned char *)statusFIFO, 0, sizeof(statusFIFO));
address.low=(u32)firstCDB;
address.NodeID=dev->InitiatorNodeID;
address.high=0;
retries=0;
/* Write the pointer to the first ORB in the fetch agent's NEXT_ORB register. */
while((result=iLinkTrWrite(dev->trContext, dev->CommandBlockAgent_high, dev->CommandBlockAgent_low+0x08, &address, 8))<0){
XPRINTF("Error writing to the Fetch Agent's ORB_POINTER register @ 0x%08lx %08lx. Code: %d.\n", dev->CommandBlockAgent_high, dev->CommandBlockAgent_low+0x08, result);
DelayThread(200000);
ieee1394_ResetFetchAgent(dev);
retries++;
if(retries>3) return(-1);
}
#if 0
/* Write a value to the fetch agent's DOORBELL register. */
result=1;
if((result=iLinkTrWrite(dev->trContext, dev->CommandBlockAgent_high, dev->CommandBlockAgent_low+0x10, &result, 4))<0){
XPRINTF("Error writing to the Fetch Agent's DOORBELL register @ 0x%08lx %08lx. Code: %d.\n", dev->CommandBlockAgent_high, dev->CommandBlockAgent_low+0x10, result);
return -2;
}
#endif
return 1;
}
/*-------------------------------------------------------------------------*/
static void
free_socket (socket_t *sp)
/* The socket in structure <sp> has been closed already, now remove the
* structure from the socket list and free it and all still pending
* data.
*/
{
socket_t **spp;
equeue_t *qp, *qnext;
XPRINTF((stderr, "%s Freeing socket %p\n", time_stamp(), sp));
/* Remove the socket from the socket */
for (spp = &sockets; *spp; spp = &(*spp)->next)
{
if (*spp != sp)
continue;
XPRINTF((stderr, "%s Unlinking socket %p\n", time_stamp(), sp));
*spp = sp->next;
break;
}
/* Free all pending queued data */
for (qp = sp->queue; qp;)
{
XPRINTF((stderr, "%s Freeing queue %p\n", time_stamp(), qp));
qnext = qp->next;
free(qp);
qp = qnext;
}
free(sp);
} /* free_socket() */
int mass_stor_probe(int devId)
{
UsbDeviceDescriptor *device = NULL;
UsbConfigDescriptor *config = NULL;
UsbInterfaceDescriptor *intf = NULL;
XPRINTF("USBHDFSD: probe: devId=%i\n", devId);
mass_dev* mass_device = mass_stor_findDevice(devId, 0);
/* only one device supported */
if ((mass_device != NULL) && (mass_device->status & DEVICE_DETECTED))
{
printf("USBHDFSD: Error - only one mass storage device allowed ! \n");
return 0;
}
/* get device descriptor */
device = (UsbDeviceDescriptor*)UsbGetDeviceStaticDescriptor(devId, NULL, USB_DT_DEVICE);
if (device == NULL) {
printf("USBHDFSD: Error - Couldn't get device descriptor\n");
return 0;
}
/* Check if the device has at least one configuration */
if (device->bNumConfigurations < 1) { return 0; }
/* read configuration */
config = (UsbConfigDescriptor*)UsbGetDeviceStaticDescriptor(devId, device, USB_DT_CONFIG);
if (config == NULL) {
printf("USBHDFSD: Error - Couldn't get configuration descriptor\n");
return 0;
}
/* check that at least one interface exists */
XPRINTF("USBHDFSD: bNumInterfaces %d\n", config->bNumInterfaces);
if ((config->bNumInterfaces < 1) ||
(config->wTotalLength < (sizeof(UsbConfigDescriptor) + sizeof(UsbInterfaceDescriptor)))) {
printf("USBHDFSD: Error - No interfaces available\n");
return 0;
}
/* get interface */
intf = (UsbInterfaceDescriptor *) ((char *) config + config->bLength); /* Get first interface */
XPRINTF("USBHDFSD: bInterfaceClass %X bInterfaceSubClass %X bInterfaceProtocol %X\n",
intf->bInterfaceClass, intf->bInterfaceSubClass, intf->bInterfaceProtocol);
if ((intf->bInterfaceClass != USB_CLASS_MASS_STORAGE) ||
(intf->bInterfaceSubClass != USB_SUBCLASS_MASS_SCSI &&
intf->bInterfaceSubClass != USB_SUBCLASS_MASS_SFF_8070I) ||
(intf->bInterfaceProtocol != USB_PROTOCOL_MASS_BULK_ONLY) ||
(intf->bNumEndpoints < 2)) { //one bulk endpoint is not enough because
return 0; //we send the CBW to te bulk out endpoint
}
return 1;
}
inline int cbw_scsi_read_capacity(mass_dev* dev, void *buffer, int size)
{
int ret;
cbw_packet cbw;
int retryCount;
XPRINTF("USBHDFSD: cbw_scsi_read_capacity\n");
cbw.signature = CBW_TAG;
cbw.lun = 0;
cbw.tag = -TAG_READ_CAPACITY;
cbw.dataTransferLength = size; //READ_CAPACITY_REPLY_LENGTH
cbw.flags = 0x80; //inquiry data will flow In
cbw.comLength = 12;
//scsi command packet
cbw.comData[0] = 0x25; //read capacity operation code
cbw.comData[1] = 0; //lun/reserved/RelAdr
cbw.comData[2] = 0; //LBA 1
cbw.comData[3] = 0; //LBA 2
cbw.comData[4] = 0; //LBA 3
cbw.comData[5] = 0; //LBA 4
cbw.comData[6] = 0; //Reserved
cbw.comData[7] = 0; //Reserved
cbw.comData[8] = 0; //Reserved/PMI
cbw.comData[9] = 0; //reserved
cbw.comData[10] = 0; //reserved
cbw.comData[11] = 0; //reserved
ret = 1;
retryCount = 6;
while (ret != 0 && retryCount > 0) {
usb_bulk_command(dev, &cbw);
ret = usb_bulk_transfer(dev->bulkEpI, buffer, size);
if (ret != 0)
printf("USBHDFSD: cbw_scsi_read_capacity error from usb_bulk_transfer %d\n", ret);
//HACK HACK HACK !!!
//according to usb doc we should allways
//attempt to read the CSW packet. But in some cases
//reading of CSW packet just freeze ps2....:-(
if (ret == USB_RC_STALL) {
XPRINTF("USBHDFSD: call reset recovery ...\n");
usb_bulk_reset(dev, 1);
} else {
ret = usb_bulk_manage_status(dev, -TAG_READ_CAPACITY);
}
retryCount--;
}
return ret;
}
/* test that endpoint is bulk endpoint and if so, update device info */
static void usb_bulk_probeEndpoint(int devId, mass_dev* dev, UsbEndpointDescriptor* endpoint) {
if (endpoint->bmAttributes == USB_ENDPOINT_XFER_BULK) {
/* out transfer */
if ((endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_OUT && dev->bulkEpO < 0) {
dev->bulkEpO = UsbOpenEndpointAligned(devId, endpoint);
XPRINTF("USBHDFSD: register Output endpoint id =%i addr=%02X packetSize=%i\n", dev->bulkEpO, endpoint->bEndpointAddress, (unsigned short int)endpoint->wMaxPacketSizeHB<<8 | endpoint->wMaxPacketSizeLB);
} else
/* in transfer */
if ((endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_IN && dev->bulkEpI < 0) {
dev->bulkEpI = UsbOpenEndpointAligned(devId, endpoint);
XPRINTF("USBHDFSD: register Input endpoint id =%i addr=%02X packetSize=%i\n", dev->bulkEpI, endpoint->bEndpointAddress, (unsigned short int)endpoint->wMaxPacketSizeHB<<8 | endpoint->wMaxPacketSizeLB);
}
}
}
static int ieee1394_GetFetchAgentState(struct SBP2Device *dev){
unsigned long int FetchAgentState;
int result;
if((result=iLinkTrRead(dev->trContext, dev->CommandBlockAgent_high, dev->CommandBlockAgent_low, &FetchAgentState, 4))<0){
XPRINTF("Error reading the Fetch Agent's AGENT_STATE register @ 0x%08lx %08lx. Code: %d.\n", dev->CommandBlockAgent_high, dev->CommandBlockAgent_low, result);
return -1;
}
else{
FetchAgentState=BSWAP32(FetchAgentState);
XPRINTF("Fetch Agent state: %lu.\n", FetchAgentState);
return FetchAgentState;
}
}
int InitUSB(void)
{
int i;
int ret = 0;
for (i = 0; i < NUM_DEVICES; ++i)
{
g_mass_device[i].status = 0;
g_mass_device[i].devId = -1;
}
driver.next = NULL;
driver.prev = NULL;
driver.name = "mass-stor";
driver.probe = mass_stor_probe;
driver.connect = mass_stor_connect;
driver.disconnect = mass_stor_disconnect;
ret = UsbRegisterDriver(&driver);
XPRINTF("USBHDFSD: registerDriver=%i \n", ret);
if (ret < 0)
{
printf("USBHDFSD: register driver failed! ret=%d\n", ret);
return(-1);
}
return(0);
}
//---------------------------------------------------------------------------
static int part_getPartitionTable(mass_dev* dev, part_table* part)
{
part_raw_record* part_raw;
int ret;
unsigned int i;
unsigned char* sbuf;
ret = READ_SECTOR(dev, 0, sbuf); // read sector 0 - Disk MBR or boot sector
if ( ret < 0 )
{
XPRINTF("USBHDFSD: part_getPartitionTable read failed %d!\n", ret);
return -EIO;
}
printf("USBHDFSD: boot signature %X %X\n", sbuf[0x1FE], sbuf[0x1FF]);
if (sbuf[0x1FE] == 0x55 && sbuf[0x1FF] == 0xAA)
{
for ( i = 0; i < 4; i++)
{
part_raw = ( part_raw_record* )( sbuf + 0x01BE + ( i * 16 ) );
part_getPartitionRecord(part_raw, &part->record[i]);
}
return 4;
}
else
{
for ( i = 0; i < 4; i++)
{
part->record[i].sid = 0;;
}
return 0;
}
}
static int usb_bulk_status(mass_dev* dev, csw_packet* csw, unsigned int tag) {
int ret;
usb_callback_data cb_data;
cb_data.semh = dev->ioSema;
csw->signature = CSW_TAG;
csw->tag = tag;
csw->dataResidue = 0;
csw->status = 0;
ret = UsbBulkTransfer(
dev->bulkEpI, //bulk input pipe
csw, //data ptr
13, //data length
usb_callback,
(void*)&cb_data
);
if (ret == USB_RC_OK) {
WaitSema(cb_data.semh);
ret = cb_data.returnCode;
#ifdef DEBUG
if (cb_data.returnSize != 13)
printf("USBHDFSD: bulk csw.status returnSize: %i != 13\n", cb_data.returnSize);
if (csw->dataResidue != 0)
printf("USBHDFSD: bulk csw.status residue: %i\n", csw->dataResidue);
XPRINTF("USBHDFSD: bulk csw result: %d, csw.status: %i\n", ret, csw->status);
#endif
}
return ret;
}
int mass_stor_configureNextDevice(void)
{
int i;
XPRINTF("USBHDFSD: configuring devices... \n");
for (i = 0; i < NUM_DEVICES; ++i)
{
mass_dev *dev = &g_mass_device[i];
if (dev->devId != -1 && (dev->status & USBMASS_DEV_STAT_CONN) && !(dev->status & USBMASS_DEV_STAT_CONF))
{
int ret;
usb_set_configuration(dev, dev->configId);
usb_set_interface(dev, dev->interfaceNumber, dev->interfaceAlt);
dev->status |= USBMASS_DEV_STAT_CONF;
ret = mass_stor_warmup(dev);
if (ret < 0)
{
printf("USBHDFSD: Error - failed to warmup device %d\n", dev->devId);
mass_stor_release(dev);
continue;
}
dev->cache = scache_init(dev, dev->sectorSize); // modified by Hermes
if (dev->cache == NULL) {
printf("USBHDFSD: Error - scache_init failed \n" );
continue;
}
return part_connect(dev) >= 0;
}
}
return 0;
}
void
parsekeys(const char *s, Key *spec)
{
const char *p, *e;
Key *k;
XPRINTF("Parsing key: '%s'\n", s);
for (p = s; *p != '\0'; p = (*e == ',' ? e + 1 : e)) {
/* need to escape ',' in command */
for (e = p; *e != '\0' && (*e != ',' || (e > p && *(e - 1) == '\\')); e++) ;
if ((k = parsechain(p, e, spec))) {
XPRINTF("Adding key: '%s'\n", s);
addchain(k);
}
}
}
/* select the best record where to store new sector */
int getIndexWrite(cache_set* cache, unsigned int sector) {
int i, ret;
int minTax = 0x0FFFFFFF;
int index = 0;
for (i = 0; i < CACHE_SIZE; i++) {
if (cache->rec[i].tax < minTax) {
index = i;
minTax = cache->rec[i].tax;
}
}
//this sector is dirty - we need to flush it first
if (cache->rec[index].writeDirty) {
XPRINTF("scache: getIndexWrite: sector is dirty : %d index=%d \n", cache->rec[index].sector, index);
ret = WRITE_SECTOR(cache->dev, cache->rec[index].sector, cache->sectorBuf + (index * BLOCK_SIZE), BLOCK_SIZE);
cache->rec[index].writeDirty = 0;
//TODO - error handling
if (ret < 0) {
printf("scache: ERROR writing sector to disk! sector=%d\n", sector);
}
}
cache->rec[index].tax +=2;
cache->rec[index].sector = sector;
return index * cache->indexLimit;
}
static Bool
parsekey(const char *s, const char *e, Key *k)
{
const char *p, *q;
XPRINTF("Parsing key from: '%s'\n", s);
for (p = s; p < e && (isalnum(*p) || isblank(*p) || *p == '_'); p++) ;
if (p < e && *p == '+') {
k->mod = parsemod(s, p);
p++;
} else
p = s;
for (q = p; q < e && (isalnum(*q) || isblank(*q) || *q == '_'); q++) ;
if (q < e && *q != '=')
q = e;
if ((k->keysym = parsesym(p, q)) == NoSymbol) {
EPRINTF("Failed to parse symbol from '%s' to '%s'\n", p, q);
return False;
}
if (q < e)
k->arg = parsearg(q + 1, e);
else if (k->arg)
k->arg = strdup(k->arg);
return True;
}
static int usb_bulk_command(mass_dev* dev, cbw_packet* packet ) {
int ret;
usb_callback_data cb_data;
if(dev->status & USBMASS_DEV_STAT_ERR){
printf("USBHDFSD: Rejecting I/O to offline device %d.\n", dev->devId);
return -1;
}
cb_data.semh = dev->ioSema;
ret = UsbBulkTransfer(
dev->bulkEpO, //bulk output pipe
packet, //data ptr
31, //data length
usb_callback,
(void*)&cb_data
);
if (ret == USB_RC_OK) {
WaitSema(cb_data.semh);
ret = cb_data.returnCode;
}
if (ret != USB_RC_OK) {
XPRINTF("USBHDFSD: Error - sending bulk command %d. Calling reset recovery.\n", ret);
usb_bulk_reset(dev, 3);
}
return ret;
}
static KeySym
parsesym(const char *s, const char *e)
{
char *t;
KeySym sym = NoSymbol;
for (; s < e && isblank(*s); s++) ;
for (; e > s && isblank(*(e - 1)); e--) ;
XPRINTF("Parsing keysym from '%s'\n", s);
if (s < e && (t = strndup(s, e - s))) {
if ((sym = XStringToKeysym(t)) == NoSymbol)
XPRINTF("Failed to parse symbol '%s'\n", t);
free(t);
}
return sym;
}
static int scsiStartStopUnit(struct SBP2Device* dev)
{
struct CommandDescriptorBlock cdb;
XPRINTF("IEEE1394_disk: scsiStartStopUnit.\n");
cdb.misc=(ORB_NOTIFY | ORB_REQUEST_FORMAT(0) | CDB_MAX_PAYLOAD(dev->max_payload) | CDB_DIRECTION(WRITE_TRANSACTION) | CDB_SPEED(dev->speed));
cdb.DataDescriptor.low=cdb.DataDescriptor.high=0;
cdb.DataDescriptor.NodeID=dev->InitiatorNodeID;
cdb.NextOrb.high=cdb.NextOrb.low=0;
cdb.NextOrb.reserved=NULL_POINTER;
//scsi command packet
cdb.CDBs[3] = 0x1B; //start stop unit operation code
cdb.CDBs[2] = 1; //reserved/immed
cdb.CDBs[1] = 0; //reserved
cdb.CDBs[0] = 0; //reserved
cdb.CDBs[7] = 1; //POWER CONDITIONS/reserved/LoEj/Start "Start the media and acquire the format type"
cdb.CDBs[6] = 0; //reserved
cdb.CDBs[5] = 0; //reserved
cdb.CDBs[4] = 0; //reserved
cdb.CDBs[11] = 0; //reserved
cdb.CDBs[10] = 0; //reserved
cdb.CDBs[9] = 0; //reserved
cdb.CDBs[8] = 0; //reserved
ieee1394_SendCommandBlockORB(dev, &cdb);
return(ieee1394_Sync());
}
static int scsiReadCapacity(struct SBP2Device* dev, void *buffer, int size)
{
struct CommandDescriptorBlock cdb;
XPRINTF("IEEE1394_disk: scsiReadCapacity.\n");
cdb.misc=(ORB_NOTIFY | ORB_REQUEST_FORMAT(0) | CDB_MAX_PAYLOAD(dev->max_payload) | CDB_DIRECTION(WRITE_TRANSACTION) | CDB_SPEED(dev->speed) | CDB_DATA_SIZE(size));
cdb.DataDescriptor.low=(u32)buffer;
cdb.DataDescriptor.high=0;
cdb.DataDescriptor.NodeID=dev->InitiatorNodeID;
cdb.NextOrb.high=cdb.NextOrb.low=0;
cdb.NextOrb.reserved=NULL_POINTER;
//scsi command packet
cdb.CDBs[3] = 0x25; //read capacity operation code
cdb.CDBs[2] = 0; //reserved
cdb.CDBs[1] = 0; //LBA 1
cdb.CDBs[0] = 0; //LBA 2
cdb.CDBs[7] = 0; //LBA 3
cdb.CDBs[6] = 0; //LBA 4
cdb.CDBs[5] = 0; //Reserved
cdb.CDBs[4] = 0; //Reserved
cdb.CDBs[11] = 0; //Reserved
cdb.CDBs[10] = 0; //reserved
cdb.CDBs[9] = 0; //reserved
cdb.CDBs[8] = 0; //reserved
ieee1394_SendCommandBlockORB(dev, &cdb);
return(ieee1394_Sync());
}
static int scsiTestUnitReady(struct SBP2Device* dev){
struct CommandDescriptorBlock cdb;
XPRINTF("IEEE1394_disk: scsiTestUnitReady.\n");
cdb.misc=(u32)(ORB_NOTIFY | ORB_REQUEST_FORMAT(0) | CDB_MAX_PAYLOAD(dev->max_payload) | CDB_DIRECTION(WRITE_TRANSACTION) | CDB_SPEED(dev->speed));
cdb.DataDescriptor.low=cdb.DataDescriptor.high=0;
cdb.DataDescriptor.NodeID=dev->InitiatorNodeID;
cdb.NextOrb.high=cdb.NextOrb.low=0;
cdb.NextOrb.reserved=NULL_POINTER;
//scsi command packet
cdb.CDBs[3] = 0x00; //test unit ready operation code
cdb.CDBs[2] = 0; //reserved
cdb.CDBs[1] = 0; //reserved
cdb.CDBs[0] = 0; //reserved
cdb.CDBs[7] = 0; //reserved
cdb.CDBs[6] = 0; //reserved
cdb.CDBs[5] = 0; //reserved
cdb.CDBs[4] = 0; //reserved
cdb.CDBs[11] = 0; //reserved
cdb.CDBs[10] = 0; //reserved
cdb.CDBs[9] = 0; //reserved
cdb.CDBs[8] = 0; //reserved
ieee1394_SendCommandBlockORB(dev, &cdb);
return(ieee1394_Sync());
}
inline int cbw_scsi_start_stop_unit(mass_dev* dev)
{
int ret;
cbw_packet cbw;
XPRINTF("USBHDFSD: cbw_scsi_start_stop_unit\n");
cbw.signature = CBW_TAG;
cbw.lun = 0;
cbw.tag = -TAG_START_STOP_UNIT;
cbw.dataTransferLength = 0; //START_STOP_REPLY_LENGTH
cbw.flags = 0x80; //inquiry data will flow In
cbw.comLength = 12;
//scsi command packet
cbw.comData[0] = 0x1B; //start stop unit operation code
cbw.comData[1] = 1; //lun/reserved/immed
cbw.comData[2] = 0; //reserved
cbw.comData[3] = 0; //reserved
cbw.comData[4] = 1; //reserved/LoEj/Start "Start the media and acquire the format type"
cbw.comData[5] = 0; //reserved
cbw.comData[6] = 0; //reserved
cbw.comData[7] = 0; //reserved
cbw.comData[8] = 0; //reserved
cbw.comData[9] = 0; //reserved
cbw.comData[10] = 0; //reserved
cbw.comData[11] = 0; //reserved
usb_bulk_command(dev, &cbw);
ret = usb_bulk_manage_status(dev, -TAG_START_STOP_UNIT);
return ret;
}
/* This is declared as inline as there is only one call to it. */
static inline int ieee1394_Sync_withTimeout(u32 n500mSecUnits){
/* iop_sys_clock_t timeout_clk;
u32 ef_result;
USec2SysClock(n500mSecUnits*500000, &timeout_clk);
SetAlarm(&timeout_clk, &alarm_cb, NULL);
WaitEventFlag(sbp2_event_flag, WRITE_REQ_INCOMING|ERROR_TIME_OUT, WEF_OR|WEF_CLEAR, &ef_result);
if(ef_result&ERROR_TIME_OUT){
XPRINTF("-=Time out=-\n");
return(-1);
}
else CancelAlarm(&alarm_cb, NULL); */
unsigned int i=0;
while(RESP_SRC(((struct sbp2_status *)statusFIFO)->status)==0){
if(i>n500mSecUnits*10000){
XPRINTF("-=Time out=-\n");
return(-1);
}
DelayThread(50);
i++;
};
return(ProcessStatus());
}
inline int cbw_scsi_test_unit_ready(mass_dev* dev)
{
int ret;
cbw_packet cbw;
XPRINTF("USBHDFSD: cbw_scsi_test_unit_ready\n");
cbw.signature = CBW_TAG;
cbw.lun = 0;
cbw.tag = -TAG_TEST_UNIT_READY;
cbw.dataTransferLength = 0; //TUR_REPLY_LENGTH
cbw.flags = 0x80; //data will flow In
cbw.comLength = 12;
//scsi command packet
cbw.comData[0] = 0x00; //test unit ready operation code
cbw.comData[1] = 0; //lun/reserved
cbw.comData[2] = 0; //reserved
cbw.comData[3] = 0; //reserved
cbw.comData[4] = 0; //reserved
cbw.comData[5] = 0; //reserved
cbw.comData[6] = 0; //reserved
cbw.comData[7] = 0; //reserved
cbw.comData[8] = 0; //reserved
cbw.comData[9] = 0; //reserved
cbw.comData[10] = 0; //reserved
cbw.comData[11] = 0; //reserved
usb_bulk_command(dev, &cbw);
ret = usb_bulk_manage_status(dev, -TAG_TEST_UNIT_READY);
return ret;
}
