TFUSBController.m

   1 //
   2 //  TFUSBController.m
   3 //  MacTF
   4 //
   5 //  Created by Nathan Oates on Sun Aug 01 2004.
   6 //  Copyright (c) 2004-7 Nathan Oates nathan@noates.com All rights reserved.
   7 //
   8
   9 /* This file was modified by Kalle Olavi Niemitalo on 2007-10-18.  */
  10
  11 // includes code based on uproar, license noted below:
  12 //  uproar 0.1
  13 //  Copyright (c) 2001 Kasima Tharnpipitchai <me@kasima.org>
  14
  15 /*
  16  *
  17  * This source code is free software; you can redistribute it and/or
  18  * modify it under the terms of the GNU Public License as published
  19  * by the Free Software Foundation; either version 2 of the License,
  20  * or (at your option) any later version.
  21  *
  22  * This source code is distributed in the hope that it will be useful,
  23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  25  * Please refer to the GNU Public License for more details.
  26  *
  27  * You should have received a copy of the GNU Public License along with
  28  * this source code; if not, write to:
  29  * Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  30  */
  31
  32 /* Much of the code that initializes and closes the device is from Apple
  33  * and is released under the license below.
  34  */
  35
  36 /*
  37  * © Copyright 2001 Apple Computer, Inc. All rights reserved.
  38  *
  39  * IMPORTANT:  This Apple software is supplied to you by Apple Computer, Inc. (“Apple”) in
  40  * consideration of your agreement to the following terms, and your use, installation,
  41  * modification or redistribution of this Apple software constitutes acceptance of these
  42  * terms.  If you do not agree with these terms, please do not use, install, modify or
  43  * redistribute this Apple software.
  44  *
  45  * In consideration of your agreement to abide by the following terms, and subject to these
  46  * terms, Apple grants you a personal, non exclusive license, under Apple’s copyrights in this
  47  * original Apple software (the “Apple Software”), to use, reproduce, modify and redistribute
  48  * the Apple Software, with or without modifications, in source and/or binary forms; provided
  49  * that if you redistribute the Apple Software in its entirety and without modifications, you
  50  * must retain this notice and the following text and disclaimers in all such redistributions
  51  * of the Apple Software.  Neither the name, trademarks, service marks or logos of Apple
  52  * Computer, Inc. may be used to endorse or promote products derived from the Apple Software
  53  * without specific prior written permission from Apple. Except as expressly stated in this
  54  * notice, no other rights or licenses, express or implied, are granted by Apple herein,
  55  * including but not limited to any patent rights that may be infringed by your derivative
  56  * works or by other works in which the Apple Software may be incorporated.
  57  *
  58  * The Apple Software is provided by Apple on an "AS IS" basis.  APPLE MAKES NO WARRANTIES,
  59  * EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION THE IMPLIED WARRANTIES OF NON-
  60  * INFRINGEMENT, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, REGARDING THE APPLE
  61  * SOFTWARE OR ITS USE AND OPERATION ALONE OR IN COMBINATION WITH YOUR PRODUCTS.
  62  *
  63  * IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL OR CONSEQUENTIAL
  64  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
  65  * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ARISING IN ANY WAY OUT OF THE USE,
  66  * REPRODUCTION, MODIFICATION AND/OR DISTRIBUTION OF THE APPLE SOFTWARE, HOWEVER CAUSED AND
  67  * WHETHER UNDER THEORY OF CONTRACT, TORT (INCLUDING NEGLIGENCE), STRICT LIABILITY OR
  68  * OTHERWISE, EVEN IF APPLE HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  69  */
  70
  71 #include <stdio.h>
  72 #include <stdlib.h>
  73 #include <string.h>
  74 #include <unistd.h>
  75
  76 #include <mach/mach.h>
  77 #include <IOKit/IOCFPlugIn.h>
  78 #include <CoreFoundation/CFNumber.h>
  79
  80 #import "DataHandler.h"
  81 #import "TFUSBController.h"
  82 #import "TFUSBControllerCommunicationBlock.h"
  83 #import "UIElements.h"
  84
  85 static void hexDump(UInt8 *buf, int len);
  86 static int doSend(IOUSBDeviceInterface197 **dev,
  87         IOUSBInterfaceInterface197 **intf, UInt8 *outBuf, UInt32 len, int type);
  88 static int doRecv(IOUSBDeviceInterface197 **dev,
  89         IOUSBInterfaceInterface197 **intf, UInt8 *inBuf, UInt32 dataLen, int type);
  90 static int dealWithInterface(io_service_t usbInterfaceRef,
  91         USBDeviceContext *device);
  92 static int dealWithDevice(io_service_t usbDeviceRef, USBDeviceContext *device);
  93 static int initDevice(USBDeviceContext *device);
  94
  95 static int debug;
  96 static int rate;
  97 static int kBlockSize;
  98 static int connectedSpeed;
  99
 100 @interface TFUSBController (PrivateMethods)
 101
 102 // Low-level USB
 103 - (NSData*) sendCommand:(NSData*) fullyPackagedCommand
 104         toDevice:(USBDeviceContext*)device expectResponse:(BOOL) getResponse
 105         careForReturn:(BOOL) careFactor;
 106
 107 // Protocol message sequences
 108 - (id) getFileListForPath:(NSString*)path;
 109 - (void) turnTurboOn:(BOOL) turnOn;
 110 - (void) renameFile:(NSString*) oldName withName:(NSString*)newName atPath:(NSString*)currentPath;
 111 - (void) makeFolder:(NSString*)newName atPath:(NSString*)currentPath;
 112 - (void) checkUSB:(USBDeviceContext*)device;
 113
 114 // User interface
 115 - (UIElements*) uiElements;
 116 - (void) updateProgress:(NSDictionary*) inDict;
 117 - (NSString*) elapsedTime:(NSTimeInterval) totalSeconds;
 118
 119 // Queue management
 120 - (BOOL) hasPriorityTransfer;
 121 - (NSDictionary*) nextTransferAndQueue:(NSMutableArray**)queue;
 122 - (void) removeTransfer:(NSDictionary*)transfer fromQueue:(NSMutableArray*)queue;
 123
 124 @end
 125
 126 #define         TopfieldVendorID        4571
 127    //1317 for HC
 128    //0x138c for humax
 129    //4571 for toppy
 130 #define         TF5kProdID      4096
 131 //42514 for HC
 132 //0x02ad for humax
 133 //4096 for toppy
 134
 135 // ---------------------------------------------------------------------------
 136 // Functions outside TFUSBController
 137 // ---------------------------------------------------------------------------
 138
 139 static void
 140 hexDump(UInt8 *buf, int len)
 141 {
 142         int row, col, maxrows;
 143
 144         maxrows = len/16;
 145         if (len % 16) maxrows++;
 146         for (row=0; row< maxrows; row++) {
 147                 for (col=0; col<16; col++) {
 148                         if (!(col%2)) printf(" ");
 149                         printf("%02x", buf[row*16 + col] & 0xff);
 150                 }
 151                 printf("\t");
 152                 for (col=0; col<16; col++) {
 153                         if ((buf[row*16 + col]>32) && (buf[row*16 + col]<126)) {
 154                                 printf("%c", buf[row*16 + col]);
 155                         }
 156                         else { printf("."); }
 157                 }
 158                 printf("\n");
 159         }
 160 }
 161
 162 static int
 163 doSend(IOUSBDeviceInterface197 **dev, IOUSBInterfaceInterface197 **intf,
 164         UInt8 *outBuf, UInt32 len, int type)
 165 {
 166         IOReturn        err;
 167         UInt32          sendLen;
 168
 169                 if (debug == 1){
 170                         printf(("sending:\n"));
 171             hexDump(outBuf, len);
 172                 }
 173                 sendLen = ((len/kBlockSize))*kBlockSize;
 174         if (len % kBlockSize)
 175             sendLen += kBlockSize;
 176         if ((sendLen % 0x200) == 0)
 177                 sendLen += kBlockSize;
 178
 179         err = (*intf)->WritePipeTO(intf, 1, outBuf, sendLen, 1000, 20000);
 180         if (err) {
 181                 printf("write err: %08x\n", err);
 182                 return err;
 183         }
 184         return err;
 185 }
 186
 187 static int
 188 doRecv(IOUSBDeviceInterface197 **dev, IOUSBInterfaceInterface197 **intf,
 189         UInt8 *inBuf, UInt32 dataLen, int type)
 190 {
 191         IOReturn        err;
 192         UInt32          len;
 193
 194         if (dataLen > kMaxXferSize) return 1;
 195
 196         len = (dataLen/kBlockSize) * kBlockSize;
 197         if (dataLen % kBlockSize)
 198                 len += kBlockSize;
 199
 200                 err = (*intf)->ReadPipeTO(intf, 2, (void *)inBuf, &len,  1000, 20000);
 201                 if (err) {
 202                 printf("read err 2: %08x\n", err);
 203                                 printf("resetting\n");
 204                                 err = (*intf)->ClearPipeStallBothEnds(intf, 2);
 205                         return err;
 206         }
 207
 208         if (debug == 1) {
 209           printf(("receiving: \n"));
 210                         hexDump(inBuf, len);
 211                 }
 212         return err;
 213 }
 214
 215 static int
 216 dealWithInterface(io_service_t usbInterfaceRef, USBDeviceContext *device)
 217 {
 218     IOReturn                            err;
 219     IOCFPlugInInterface                 **iodev;                // requires <IOKit/IOCFPlugIn.h>
 220     IOUSBInterfaceInterface197          **intf;
 221     IOUSBDeviceInterface197             **dev;
 222     SInt32                              score;
 223         UInt8                           numPipes, confNum, dSpeed;
 224
 225
 226     err = IOCreatePlugInInterfaceForService(usbInterfaceRef, kIOUSBInterfaceUserClientTypeID, kIOCFPlugInInterfaceID, &iodev, &score);
 227     if (err || !iodev)
 228     {
 229         printf("dealWithInterface: unable to create plugin. ret = %08x, iodev = %p\n", err, iodev);
 230         return kUproarDeviceErr;
 231     }
 232     err = (*iodev)->QueryInterface(iodev, CFUUIDGetUUIDBytes(kIOUSBInterfaceInterfaceID), (LPVOID)&(device->intf));
 233     (*iodev)->Release(iodev);                           // done with this
 234     intf = device->intf;
 235     if (err || !intf)
 236     {
 237         printf("dealWithInterface: unable to create a device interface. ret = %08x, intf = %p\n", err, intf);
 238         return kUproarDeviceErr;
 239     }
 240
 241     dev = device->dev;
 242     err = (*intf)->USBInterfaceOpen(intf);
 243     if (err)
 244     {
 245         printf("dealWithInterface: unable to open interface. ret = %08x\n", err);
 246         return kUproarDeviceErr;
 247     }
 248     err = (*intf)->GetNumEndpoints(intf, &numPipes);
 249     if (err)
 250     {
 251         printf("dealWithInterface: unable to get number of endpoints. ret = %08x\n", err);
 252         return kUproarDeviceErr;
 253     }
 254
 255     printf("dealWithInterface: found %d pipes\n", numPipes);
 256
 257     err = (*intf)->GetConfigurationValue(intf, &confNum);
 258     err = (*dev)->GetDeviceSpeed(dev, &dSpeed);
 259         if (dSpeed == 2) {
 260                 kBlockSize = 0x40;
 261         } else {
 262                 kBlockSize = 0x4;
 263         }
 264     printf("confnum: %08x, dspeed: %08x, blockS:%i\n", confNum, dSpeed, kBlockSize);
 265     connectedSpeed = dSpeed;
 266     return kUproarSuccess;
 267 }
 268
 269
 270 static int
 271 dealWithDevice(io_service_t usbDeviceRef, USBDeviceContext *device)
 272 {
 273     IOReturn                            err;
 274     IOCFPlugInInterface                 **iodev;                // requires <IOKit/IOCFPlugIn.h>
 275     IOUSBDeviceInterface197             **dev;
 276     SInt32                              score;
 277     UInt8                               numConf;
 278     IOUSBConfigurationDescriptorPtr     confDesc;
 279     IOUSBFindInterfaceRequest           interfaceRequest;
 280     io_iterator_t                       iterator;
 281     io_service_t                        usbInterfaceRef;
 282     int                                 found=0;
 283
 284
 285     err = IOCreatePlugInInterfaceForService(usbDeviceRef, kIOUSBDeviceUserClientTypeID, kIOCFPlugInInterfaceID, &iodev, &score);
 286     if (err || !iodev)
 287     {
 288         printf("dealWithDevice: unable to create plugin. ret = %08x, iodev = %p\n", err, iodev);
 289         return kUproarDeviceErr;
 290     }
 291     err = (*iodev)->QueryInterface(iodev, CFUUIDGetUUIDBytes(kIOUSBDeviceInterfaceID), (LPVOID)&(device->dev));
 292     (*iodev)->Release(iodev);
 293
 294     dev = device->dev;
 295     if (err || !dev)
 296     {
 297         printf("dealWithDevice: unable to create a device interface. ret = %08x, dev = %p\n", err, dev);
 298         return kUproarDeviceErr;
 299     }
 300     err = (*dev)->USBDeviceOpen(dev);
 301     if (err)
 302     {
 303         printf("dealWithDevice: unable to open device. ret = %08x\n", err);
 304         return kUproarDeviceErr;
 305     }
 306     err = (*dev)->GetNumberOfConfigurations(dev, &numConf);
 307     if (err || !numConf)
 308     {
 309         printf("dealWithDevice: unable to obtain the number of configurations. ret = %08x\n", err);
 310         return kUproarDeviceErr;
 311     }
 312     printf("dealWithDevice: found %d configurations\n", numConf);
 313     err = (*dev)->GetConfigurationDescriptorPtr(dev, 0, &confDesc);     // get the first config desc (index 0)
 314     if (err)
 315     {
 316         printf("dealWithDevice:unable to get config descriptor for index 0\n");
 317         return kUproarDeviceErr;
 318     }
 319     err = (*dev)->SetConfiguration(dev, confDesc->bConfigurationValue);
 320     if (err)
 321     {
 322         printf("dealWithDevice: unable to set the configuration\n");
 323         return kUproarDeviceErr;
 324     }
 325
 326     interfaceRequest.bInterfaceClass = kIOUSBFindInterfaceDontCare;             // requested class
 327     interfaceRequest.bInterfaceSubClass = kIOUSBFindInterfaceDontCare;          // requested subclass
 328     interfaceRequest.bInterfaceProtocol = kIOUSBFindInterfaceDontCare;          // requested protocol
 329     interfaceRequest.bAlternateSetting = kIOUSBFindInterfaceDontCare;           // requested alt setting
 330
 331     err = (*dev)->CreateInterfaceIterator(dev, &interfaceRequest, &iterator);
 332     if (err)
 333     {
 334         printf("dealWithDevice: unable to create interface iterator\n");
 335         return kUproarDeviceErr;
 336     }
 337
 338     while (usbInterfaceRef = IOIteratorNext(iterator))
 339     {
 340         printf("found interface: %p\n", (void*)usbInterfaceRef);
 341         err = dealWithInterface(usbInterfaceRef, device);
 342         IOObjectRelease(usbInterfaceRef);       // no longer need this reference
 343         found = 1;
 344     }
 345
 346     IOObjectRelease(iterator);
 347     iterator = 0;
 348     if ((!found) || (err))
 349         return kUproarDeviceErr;
 350     else
 351         return kUproarSuccess;
 352 }
 353
 354 static int
 355 initDevice(USBDeviceContext *device)
 356 {
 357     mach_port_t         masterPort = 0;
 358     kern_return_t               err;
 359     CFMutableDictionaryRef      matchingDictionary = 0;         // requires <IOKit/IOKitLib.h>
 360     short                       idVendor = TopfieldVendorID;
 361     short                       idProduct = TF5kProdID;
 362     CFNumberRef                 numberRef;
 363     io_iterator_t               iterator = 0;
 364     io_service_t                usbDeviceRef;
 365     int                         found =0;
 366
 367     err = IOMasterPort(bootstrap_port, &masterPort);
 368
 369     if (err)
 370     {
 371         printf("Anchortest: could not create master port, err = %08x\n", err);
 372         return err;
 373     }
 374     matchingDictionary = IOServiceMatching(kIOUSBDeviceClassName);      // requires <IOKit/usb/IOUSBLib.h>
 375     if (!matchingDictionary)
 376     {
 377         printf("Anchortest: could not create matching dictionary\n");
 378         return -1;
 379     }
 380     numberRef = CFNumberCreate(kCFAllocatorDefault, kCFNumberShortType, &idVendor);
 381     if (!numberRef)
 382     {
 383         printf("Anchortest: could not create CFNumberRef for vendor\n");
 384         return -1;
 385     }
 386     CFDictionaryAddValue(matchingDictionary, CFSTR(kUSBVendorName), numberRef);
 387     CFRelease(numberRef);
 388     numberRef = 0;
 389     numberRef = CFNumberCreate(kCFAllocatorDefault, kCFNumberShortType, &idProduct);
 390     if (!numberRef)
 391     {
 392         printf("Anchortest: could not create CFNumberRef for product\n");
 393         return -1;
 394     }
 395     CFDictionaryAddValue(matchingDictionary, CFSTR(kUSBProductName), numberRef);
 396     CFRelease(numberRef);
 397     numberRef = 0;
 398
 399     err = IOServiceGetMatchingServices(masterPort, matchingDictionary, &iterator);
 400     matchingDictionary = 0;                     // this was consumed by the above call
 401
 402     while (usbDeviceRef = IOIteratorNext(iterator))
 403     {
 404         printf("Found device %p\n", (void*)usbDeviceRef);
 405         err = dealWithDevice(usbDeviceRef, device);
 406         IOObjectRelease(usbDeviceRef);                  // no longer need this reference
 407         found = 1;
 408     }
 409
 410
 411     IOObjectRelease(iterator);
 412     iterator = 0;
 413     mach_port_deallocate(mach_task_self(), masterPort);
 414     if ((!found) || (err))
 415         return kUproarDeviceErr;
 416     else
 417         return kUproarSuccess;
 418 }
 419
 420 // ---------------------------------------------------------------------------
 421 // PrivateMethods: Low-level USB
 422 // ---------------------------------------------------------------------------
 423
 424 @implementation TFUSBController (PrivateMethods)
 425
 426 - (NSData*) sendCommand:(NSData*) fullyPackagedCommand
 427                 toDevice:(USBDeviceContext*)device expectResponse:(BOOL) getResponse
 428                 careForReturn:(BOOL) careFactor{
 429         IOReturn        err;
 430         int cmdLength = [fullyPackagedCommand length];
 431         unsigned char outBuffer[cmdLength];
 432         memset(outBuffer, 0, cmdLength);
 433 //      NSLog(@"send: %@", [fullyPackagedCommand description]);
 434         [fullyPackagedCommand getBytes:outBuffer];
 435
 436         err = doSend(device->dev, device->intf, outBuffer, cmdLength, 2);
 437         if (err)
 438                 NSLog(@"sendError: %08x\n");
 439
 440         if (! getResponse) return nil;
 441
 442         int inLen = 0xFFFF; // i think this is biggest needed?
 443         unsigned char inBuf[inLen];
 444         memset(inBuf, 0, inLen);
 445         err = doRecv(device->dev, device->intf, inBuf, inLen, 2);
 446         if (err)
 447                 NSLog(@"inError: %08x\n", err);
 448
 449         if (! careFactor) return nil;
 450         NSMutableData* data = [NSMutableData dataWithBytes:inBuf length:inLen];
 451         data = [self swap:data];
 452         inLen = inBuf[1]*256 + inBuf[0]; // work out how long the response really is. NB data is flipped, but inBuf still isn't
 453         return [data subdataWithRange:(NSRange) {0,inLen}];
 454 }
 455
 456 // ---------------------------------------------------------------------------
 457 // PrivateMethods: Protocol message sequences
 458 // ---------------------------------------------------------------------------
 459
 460 - (id) getFileListForPath:(NSString*) path {
 461         if (myContext == nil)
 462                 return nil;
 463
 464         NSData* hddListCmd = [self prepareCmdHddDirWithPath:path];
 465         if (hddListCmd == nil)
 466                 return nil;
 467
 468         [self checkUSB:myContext]; // sends cancel and waits for response
 469         int contiguousErrors = 0;
 470         [[dh fileList] removeAllObjects];
 471         NSData* response = [self sendCommand:hddListCmd toDevice:myContext
 472                 expectResponse:YES careForReturn:YES];
 473         while (response != nil && contiguousErrors++ < 5) {
 474                 const UInt32 eCode = [self checkCommunicationBlock:response];
 475                 if (eCode != USB_OK) {
 476                         response = [self sendCommand:[self prepareFailWithECode:eCode]
 477                                 toDevice:myContext expectResponse:YES careForReturn:YES];
 478                 } else switch ([self cmdFromCommunicationBlock:response]) {
 479                 case USB_Fail:
 480 //                      [statusField setStringValue:NSLocalizedString(@"LAST_ERROR", @"Error on last command.")];
 481                         [[dh fileList] removeAllObjects];
 482                         response = [self sendCommand:hddListCmd toDevice:myContext
 483                                 expectResponse:YES careForReturn:YES];
 484                         break;
 485                 case USB_DataHddDir:
 486                         contiguousErrors = 0;
 487                         size_t i;
 488                         // Swapping sometimes adds a byte of padding.  The following uses
 489                         // only complete 144-byte structures and so ignores such padding.
 490                         for (i=0; 8+(i+1)*114 <= [response length]; i++) {
 491                                 NSData* typeFile = [response subdataWithRange:(NSRange) {8+i*114,114}];
 492                                 NSMutableDictionary* tfFile = [dh getTFFileFromSwappedHexData:typeFile];
 493                                 if (![[tfFile objectForKey:@"name"] isEqualToString:@".."]) {
 494                                         [dh convertRawDataToUseful:tfFile];
 495                                         [[dh fileList] addObject:tfFile];
 496                                 }
 497                         }
 498                         response = [self sendCommand:[self prepareSuccess]
 499                                 toDevice:myContext expectResponse:YES careForReturn:YES];
 500                         break;
 501                 case USB_DataHddDirEnd:
 502                         contiguousErrors = 0;
 503                         response = nil;
 504                         break;
 505                 default:
 506                         [self checkUSB:myContext]; // cancel whatever is going on
 507                         [[dh fileList] removeAllObjects];
 508                         response = [self sendCommand:hddListCmd toDevice:myContext
 509                                 expectResponse:YES careForReturn:YES];
 510                         break;
 511                 }
 512         }
 513
 514         [tableView reloadData];
 515         [[self uiElements] tableView:tableView didClickTableColumn:[[self uiElements]selectedColumn]];
 516         [[self uiElements] tableView:tableView didClickTableColumn:[[self uiElements]selectedColumn]]; //twice so get the same sort as before
 517         return nil;
 518 }
 519
 520 - (void) turnTurboOn:(BOOL) turnOn {
 521         if (![[[self uiElements] isConnected] intValue]) return;
 522         [self checkUSB:myContext];
 523         NSData* turboCommand = [self prepareCmdTurboWithMode:(turnOn ? 1 : 0)];
 524         [self sendCommand:turboCommand toDevice:myContext expectResponse:YES careForReturn:NO];
 525 }
 526
 527 - (void) renameFile:(NSString*) oldName withName:(NSString*)newName atPath:(NSString*)currentPath {
 528         NSLog(@"%@,%@,%@", oldName, newName, currentPath);
 529         [self checkUSB:myContext];
 530         NSString* oldFname = [self fnameForFile:oldName atPath:currentPath];
 531         NSString* newFname = [self fnameForFile:newName atPath:currentPath];
 532         NSData* fileRenCmd = [self prepareCmdHddRenameFromFname:oldFname toFname:newFname];
 533         [self sendCommand:fileRenCmd toDevice:myContext expectResponse:YES careForReturn:NO];
 534 }
 535
 536 - (void) makeFolder:(NSString*)newName atPath:(NSString*)currentPath {
 537         [self checkUSB:myContext];
 538         NSString* fname = [self fnameForFile:newName atPath:currentPath];
 539         NSData* newFoldCmd = [self prepareCmdHddCreateDirWithFname:fname];
 540         NSData* usbCancel = [self prepareCancel];
 541         [self sendCommand:usbCancel toDevice:myContext expectResponse:YES careForReturn:NO];
 542         [self sendCommand:newFoldCmd toDevice:myContext expectResponse:YES careForReturn:NO];
 543 }
 544
 545 - (void) checkUSB:(USBDeviceContext*)device {
 546         NSData* usbCancel = [self prepareCancel];
 547         NSData* data = [self sendCommand:usbCancel toDevice:device expectResponse:YES careForReturn:YES];
 548         const UInt32 rW_bigendian = EndianU32_NtoB(USB_Success);
 549         int i = 0;
 550         NSData* responseWanted = [NSData dataWithBytes:&rW_bigendian length:4];
 551         while ((data == nil || [data length] < 8) && i < 8) {
 552                 NSLog (@"incorrect response");
 553                 i++;
 554                 data = [self sendCommand:usbCancel toDevice:device expectResponse:YES careForReturn:YES];
 555         }
 556         if (!i<=8) {
 557                 // tell someone that no longer connected here??
 558                 return;
 559                 }
 560         NSData* responseToCheck = [data subdataWithRange:(NSRange) {4,4}];
 561         if (![responseWanted isEqualToData:responseToCheck]) {
 562                 [self sendCommand:usbCancel toDevice:device expectResponse:YES careForReturn:NO]; // send reset again
 563         }
 564 }
 565
 566 // ---------------------------------------------------------------------------
 567 // PrivateMethods: User interface
 568 // ---------------------------------------------------------------------------
 569
 570 - (UIElements*) uiElements {
 571         return [NSApp delegate];
 572 }
 573
 574 -(void) updateProgress:(NSDictionary*) inDict {
 575         NSAutoreleasePool *pool=[[NSAutoreleasePool alloc] init];
 576         double offset = [[inDict objectForKey:@"offset"] doubleValue];
 577         double size = [[inDict objectForKey:@"size"] doubleValue];
 578         NSDate* startTime = [inDict objectForKey:@"startTime"];
 579         [progressBar setDoubleValue:((double)offset/size*100)];
 580         [progressBar displayIfNeeded];
 581         [progressTime setStringValue:[self elapsedTime:[[NSDate date] timeIntervalSinceDate:startTime]]];
 582         [progressTime displayIfNeeded];
 583         [pool release];
 584 }
 585
 586 - (NSString*) elapsedTime:(NSTimeInterval) totalSeconds {
 587         char hp = 20;
 588         char mp = 20;
 589         char sp = 20; //padding
 590         int hours = (totalSeconds / 3600);  // returns number of whole hours fitted in totalSecs
 591         if (hours < 10)
 592                 hp = 48;
 593         int minutes = ((totalSeconds / 60) - hours*60);  // Whole minutes
 594         if (minutes < 10)
 595                 mp = 48;
 596         int seconds = ((long) totalSeconds % 60);       // Here we can use modulo to get num secs NOT fitting in whole minutes (60 secs)
 597         if (seconds < 10)
 598                 sp = 48;
 599         return [NSString stringWithFormat:@"%c%i:%c%i:%c%i", hp, hours, mp, minutes, sp, seconds];
 600 }
 601
 602 // ---------------------------------------------------------------------------
 603 // Queues
 604 // ---------------------------------------------------------------------------
 605
 606 - (BOOL) hasPriorityTransfer {
 607         return [priorityTransferQueue count] > 0;
 608 }
 609
 610 - (NSDictionary*) nextTransferAndQueue:(NSMutableArray**)queue {
 611         if ([priorityTransferQueue count] > 0) {
 612                 *queue = priorityTransferQueue;
 613                 return [priorityTransferQueue objectAtIndex:0];
 614         } else if ([transferQueue count] > 0) {
 615                 *queue = transferQueue;
 616                 return [transferQueue objectAtIndex:0];
 617         } else {
 618                 *queue = nil;
 619                 return nil;
 620         }
 621 }
 622
 623 - (void) removeTransfer:(NSDictionary*)transfer
 624         fromQueue:(NSMutableArray*)queue
 625 {
 626         [queue removeObjectIdenticalTo:transfer];
 627 }
 628
 629 @end
 630
 631 // ---------------------------------------------------------------------------
 632 // Low-level USB
 633 // ---------------------------------------------------------------------------
 634
 635 @implementation TFUSBController
 636
 637 - (void) closeDevice:(USBDeviceContext *)device
 638 {
 639     IOUSBInterfaceInterface197  **intf;
 640     IOUSBDeviceInterface197     **dev;
 641     IOReturn                    err;
 642
 643     intf = device->intf;
 644     dev = device->dev;
 645
 646     err = (*intf)->USBInterfaceClose(intf);
 647     if (err)
 648     {
 649         printf("dealWithInterface: unable to close interface. ret = %08x\n", err);
 650     }
 651     err = (*intf)->Release(intf);
 652     if (err)
 653     {
 654         printf("dealWithInterface: unable to release interface. ret = %08x\n", err);
 655     }
 656
 657     err = (*dev)->USBDeviceClose(dev);
 658     if (err)
 659     {
 660         printf("dealWithDevice: error closing device - %08x\n", err);
 661         (*dev)->Release(dev);
 662     }
 663     err = (*dev)->Release(dev);
 664     if (err)
 665     {
 666         printf("dealWithDevice: error releasing device - %08x\n", err);
 667     }
 668 }
 669
 670 - (USBDeviceContext*) initializeUSB {
 671         USBDeviceContext        *device;
 672         int                     err;
 673         kBlockSize = 0x08;
 674         device = malloc(sizeof(USBDeviceContext));
 675         err = initDevice(device);
 676         if (err) {
 677                 printf("Could not connect to Topfield\n");
 678                 return nil;
 679         }
 680         printf("\n\n");
 681         printf("Connected to Topfield\n\n");
 682         myContext = device;
 683         return device;
 684 }
 685
 686 // ---------------------------------------------------------------------------
 687 // Protocol message sequences
 688 // ---------------------------------------------------------------------------
 689
 690 - (int) getFile:(NSDictionary*)fileInfo forPath:(NSString*)currentPath
 691                 toSaveTo:(NSString*)savePath beginAtOffset:(unsigned long long) offset
 692                 withLooping:(BOOL)looping existingTime:(NSTimeInterval)existingTime {
 693 //      [progressBar setDoubleValue:0];
 694 //      [progressTime setDoubleValue:0];
 695         NSString* nameOnToppy = [fileInfo objectForKey:@"name"];
 696         [[[self uiElements] currentlyField] setStringValue:
 697                 [NSLocalizedString(@"DOWNLOADING", @"Downloading: ") stringByAppendingString:nameOnToppy]];
 698         [[[self uiElements] connectLight] setImage:[NSImage imageNamed:@"blink.tiff"]];
 699         [[[self uiElements] currentlyField] displayIfNeeded];
 700         //construct file send request
 701         NSNumber* fileSize = [fileInfo objectForKey:@"fileSize"];
 702
 703         //prepackage commands to send
 704         NSData* fileSendCmd = [self prepareCmdHddFileSendWithDirection:USB_FileToHost
 705                 fname:[self fnameForFile:nameOnToppy atPath:currentPath]
 706                 offset:offset];
 707         NSData* usbSuccess = [self prepareSuccess];
 708         NSData* usbCancel = [self prepareCancel];
 709
 710         // send commands
 711
 712         if ([turboCB state])
 713                 [self turnTurboOn:YES];
 714         else
 715                 [self checkUSB:myContext]; //turbo has a check itself
 716         [self sendCommand:fileSendCmd toDevice:myContext expectResponse:YES careForReturn:NO];
 717         //start timer
 718         NSDate* startTime = [NSDate date];
 719         startTime = [startTime addTimeInterval:(0-existingTime)];
 720         // send start request and get response
 721         NSData *data = [self sendCommand:usbSuccess toDevice:myContext expectResponse:YES careForReturn:YES];
 722         const UInt32 rW_bigendian = EndianU32_NtoB(USB_DataHddFileData);
 723         NSData *responseWanted = [NSData dataWithBytes:&rW_bigendian length:4];
 724         if ([data length] < 16) {
 725                 NSLog(@"Incorrect Data length");
 726                 return 1;
 727         }
 728         NSData *responseToCheck = [data subdataWithRange:(NSRange) {4,4}];
 729         if (![responseWanted isEqualToData:responseToCheck]) {
 730                 NSLog(@"Unexpected response from Toppy during download");
 731                 return 1;
 732         }
 733
 734         // clean up data and prepare path to save it
 735         NSData* header = [data subdataWithRange:(NSRange) {4,4}]; //cmd data
 736         NSData* finalData = [data subdataWithRange:(NSRange) {16,[data length]-16}];
 737
 738         // first initialize a file of the right name, as NSFileHandle requires an existing file to work on
 739         if (offset == 0)
 740                 [[NSData dataWithBytes:"\0" length:1] writeToFile:savePath atomically:NO]; // write 0x00 to initialize (overwritten later)
 741         NSFileHandle* outFile = [NSFileHandle fileHandleForWritingAtPath:savePath];
 742         [outFile seekToFileOffset:offset];
 743         [outFile writeData:finalData];
 744         if (looping) {  // loop for multiple data sends (ie files > 64k)
 745                 int updateRate = 8;
 746                 if ([fileSize isGreaterThan:[NSNumber numberWithDouble:1048576]]) {
 747                         updateRate = 24;
 748                         NSLog(@"large file detected - low GUI update rate");
 749                 }
 750                 int timesAround = 0;
 751                 const UInt32 test_bigendian = EndianU32_NtoB(USB_DataHddFileData);
 752                 double amountReceived = 0xfe00 + offset;
 753                 NSData* testData = [NSData dataWithBytes:&test_bigendian length:4];
 754                 while ([header isEqualToData:testData] && [[[self uiElements] isConnected] intValue]) {
 755                         if ([self hasPriorityTransfer]) {
 756                                 [self addTransfer:[NSDictionary dictionaryWithObjectsAndKeys:
 757                                                 fileInfo,@"filename", currentPath,@"path", savePath,@"savePath",
 758                                                 [NSNumber numberWithUnsignedLongLong:amountReceived],@"offset",
 759                                                 @"download",@"transferType", [NSNumber numberWithBool:YES],@"looping",
 760                                                 [NSNumber numberWithInt:[[NSDate date] timeIntervalSinceDate:startTime]],@"existingTime",
 761                                                 nil]
 762                                         atIndex:1]; // nb adding to index 1 as the current transfer lies at 0 and will be deleted soon
 763                                 // send reset again     just to make sure!
 764                                 [self sendCommand:usbCancel toDevice:myContext expectResponse:YES careForReturn:NO];
 765                                 [outFile closeFile];
 766                                 //now add the right modification date to the file
 767                                 [[NSFileManager defaultManager]
 768                                         changeFileAttributes:[NSDictionary
 769                                                 dictionaryWithObject:[fileInfo objectForKey:@"date"]
 770                                                 forKey:@"NSFileModificationDate"]
 771                                         atPath:savePath];
 772                                 [self turnTurboOn:NO];
 773                                 return 0;
 774                         }
 775                         timesAround ++;
 776                         NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 777                         data = [self sendCommand:usbSuccess toDevice:myContext expectResponse:YES careForReturn:YES];
 778                         amountReceived += 0xfe00;
 779                         if (timesAround < 8 || timesAround % updateRate == 0) {
 780                                 [NSThread detachNewThreadSelector:@selector(updateProgress:) toTarget:self
 781                                         withObject:[NSDictionary dictionaryWithObjectsAndKeys:
 782                                                 [NSNumber numberWithDouble:(double)amountReceived], @"offset",
 783                                                 fileSize, @"size", startTime, @"startTime", nil]];
 784                         }
 785                         if ([data length] > 16){ //there is something to read
 786                                 header = [[data subdataWithRange:(NSRange) {4,4}] retain]; //cmd data
 787                                 NSData* finalData = [data subdataWithRange:(NSRange) {16,[data length]-16}];
 788                                 [outFile writeData:finalData];
 789                                 [outFile synchronizeFile];
 790                         }
 791                         else break;
 792                         [pool release];
 793                 }
 794         }
 795         [self sendCommand:usbCancel toDevice:myContext expectResponse:YES careForReturn:NO]; // send reset again        just to make sure!
 796         [outFile closeFile];
 797     //now add the right modification date to the file
 798         [[NSFileManager defaultManager]
 799                 changeFileAttributes:[NSDictionary
 800                         dictionaryWithObject:[fileInfo objectForKey:@"date"]
 801                         forKey:@"NSFileModificationDate"]
 802                 atPath:savePath];
 803         [self turnTurboOn:NO];
 804         if (looping) [[self uiElements] finishTransfer];
 805         return 0;
 806 }
 807
 808 - (void) uploadFile:(NSString*) fileToUpload ofSize:(long long) size
 809                 fromPath:(NSString*)curPath withAttributes:(NSData*) typeFile
 810                 atOffset:(unsigned long long)offset existingTime:(NSTimeInterval)existingTime {
 811         NSLog(@"upload: %@,%@,%qu", fileToUpload, curPath, offset);
 812         USBDeviceContext* dev = myContext;
 813         // prepare Send command
 814         NSMutableArray* array = [NSMutableArray arrayWithArray:[fileToUpload componentsSeparatedByString:@"/"]];
 815         NSMutableString* fname = [NSMutableString stringWithString:[array lastObject]];
 816         char dir = USB_FileToDevice;
 817         NSMutableData* build = [NSMutableData dataWithBytes:&dir length:1];
 818         short int nsize = [fname length]+[curPath length]+2;// one for slash, one for padding 0x00
 819         const UInt16 nsize_bigendian = EndianU16_NtoB(nsize);
 820         [build appendData:[NSData dataWithBytes:&nsize_bigendian length:2]];
 821         NSData* d = [curPath dataUsingEncoding:NSISOLatin1StringEncoding];
 822         [build appendData:d];
 823         dir = 0x5c; // 0x5c = "/"
 824         [build appendData:[NSData dataWithBytes:&dir length:1]];
 825         [build appendData:[fname dataUsingEncoding:NSISOLatin1StringEncoding]];// may need to pad to 95...
 826         if ([fname length] < 95)
 827                 [build increaseLengthBy:95-[fname length]];
 828         dir = 0x00;
 829         [build appendData:[NSData dataWithBytes:&dir length:1]];
 830         UInt64 offset_bigendian = EndianU64_NtoB(offset);
 831         [build appendData:[NSData dataWithBytes:&offset_bigendian length:8]];
 832
 833         // prepackage commands to send
 834         NSData* fileSendCmd = [self prepareCommand:USB_CmdHddFileSend withData:build];
 835         NSData* fileStartCmd = [self prepareCommand:USB_DataHddFileStart withData:typeFile];
 836         NSData* fileEndCmd = [self prepareDataHddFileEnd];
 837
 838         //start timer
 839         NSDate* startTime = [NSDate date];
 840         startTime = [startTime addTimeInterval:(0-existingTime)];
 841         //send commands
 842         if ([turboCB state])
 843                 [self turnTurboOn:YES];
 844         else
 845                 [self checkUSB:dev];
 846         // now the proper commands
 847         NSData *data = [self sendCommand:fileSendCmd toDevice:dev expectResponse:YES careForReturn:YES];
 848         data = [self sendCommand:fileStartCmd toDevice:dev expectResponse:YES careForReturn:YES];
 849         const UInt32 rW_bigendian = EndianU32_NtoB(USB_Success);
 850         NSData* responseWanted = [NSData dataWithBytes:&rW_bigendian length:4];
 851         NSData* responseToCheck = nil;
 852
 853         NSFileHandle* fileHandle = [NSFileHandle fileHandleForReadingAtPath:fileToUpload];
 854         [fileHandle seekToFileOffset:offset];
 855         do {
 856                 if ([self hasPriorityTransfer]) {
 857                         //break out and create a new transfer to continue it
 858                         NSLog(@"pausing upload");
 859                         [self addTransfer:[NSDictionary dictionaryWithObjectsAndKeys:
 860                                         fileToUpload,@"filename",
 861                                         [NSNumber numberWithUnsignedLongLong:size],@"fileSize",
 862                                         curPath,@"path",typeFile,@"attributes",@"upload",@"transferType",
 863                                         [NSNumber numberWithUnsignedLongLong:offset],@"offset",
 864                                         [NSNumber numberWithInt:[[NSDate date] timeIntervalSinceDate:startTime]],@"existingTime",
 865                                         nil]
 866                                 atIndex:1]; //nb use index 1 as current transfer is at 0 and will be deleted
 867                         [self turnTurboOn:NO];
 868                         break;
 869                 } else {
 870                 NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 871                 offset_bigendian = EndianU64_NtoB(offset);
 872                 NSMutableData* fileData = [NSMutableData dataWithBytes:&offset_bigendian length:8];
 873                 [fileData appendData:[fileHandle readDataOfLength:rate]];
 874                 offset += rate;
 875                 NSData* fileDataCmd = [self prepareCommand:USB_DataHddFileData withData:fileData];
 876                 data = [self sendCommand:fileDataCmd toDevice:dev expectResponse:YES careForReturn:YES];
 877                 if ([data length] >= 8)
 878                         responseToCheck = [data subdataWithRange:(NSRange) {4,4}];
 879                 else responseToCheck = nil;
 880                 if (responseToCheck == nil || ![responseWanted isEqualToData:responseToCheck])
 881                         break;
 882                 [NSThread detachNewThreadSelector:@selector(updateProgress:) toTarget:self
 883                         withObject:[NSDictionary dictionaryWithObjectsAndKeys:
 884                                 [NSNumber numberWithDouble:(double)offset], @"offset",
 885                                 [NSNumber numberWithDouble:(double)size], @"size",
 886                                 startTime, @"startTime", nil]];
 887                 [pool release];
 888                 }
 889         } while (offset < size && [[[self uiElements] isConnected] intValue]);
 890         if ([[[self uiElements] isConnected] intValue])
 891                 data = [self sendCommand:fileEndCmd toDevice:dev expectResponse:YES careForReturn:YES];
 892         [fileHandle closeFile];
 893         [[self uiElements] goToPath:[[self uiElements]currentPath]];
 894         [[self uiElements] tableView:tableView didClickTableColumn:[[self uiElements]selectedColumn]];
 895         [[self uiElements] tableView:tableView didClickTableColumn:[[self uiElements]selectedColumn]]; //twice so get the same sort as before
 896         [self turnTurboOn:NO];
 897         [[self uiElements] finishTransfer];
 898 }
 899
 900 - (void) deleteFile:(NSDictionary*)fileInfo fromPath:(NSString*)currentPath {
 901         [self checkUSB:myContext];
 902         NSString* fname = [self fnameForFile:[fileInfo objectForKey:@"name"]
 903                 atPath:currentPath];
 904         NSData* fileDelCmd = [self prepareCmdHddDelWithFname:fname];
 905         [self sendCommand:fileDelCmd toDevice:myContext expectResponse:YES careForReturn:NO];
 906 }
 907
 908 // ---------------------------------------------------------------------------
 909 // Queue management
 910 // ---------------------------------------------------------------------------
 911
 912 - (void) addPriorityTransfer:(id)newTransfer {
 913         [priorityTransferQueue addObject:newTransfer];
 914         NSLog(@"%i,p:%i-%@",[transferQueue count],[priorityTransferQueue count],[newTransfer objectForKey:@"transferType"]);
 915 }
 916
 917 - (void) addTransfer:(id)newTransfer atIndex:(int)front { //-1 for at end
 918         if (front>=0) [transferQueue insertObject:newTransfer atIndex:front];
 919         else [transferQueue addObject:newTransfer];
 920         NSLog(@"%i,p:%i",[transferQueue count],[priorityTransferQueue count]);
 921 }
 922
 923 - (void) clearQueues {
 924         [priorityTransferQueue removeAllObjects];
 925         [transferQueue removeAllObjects];
 926         [pausedQueue removeAllObjects];
 927 }
 928
 929 - (void) transfer:(id)sender {
 930         while ([[[self uiElements] isConnected] intValue]) {
 931                 NSAutoreleasePool *pool=[[NSAutoreleasePool alloc] init];
 932                 NSMutableArray* queue = nil;
 933                 NSDictionary* currentTransfer = [self nextTransferAndQueue:&queue];
 934                 if (currentTransfer != nil) {
 935                         NSString* transferType = [currentTransfer objectForKey:@"transferType"];
 936                         if ([transferType isEqualToString:@"fileList"]) {
 937                                 [self getFileListForPath:[currentTransfer objectForKey:@"path"]];
 938                         }
 939                         else if ([transferType isEqualToString:@"turbo"]) {
 940                 //              [self turnTurboOn:[[currentTransfer objectForKey:@"turboOn"] boolValue]];
 941                         }
 942                         else if ([transferType isEqualToString:@"rename"]) {
 943                                 [self renameFile:[currentTransfer objectForKey:@"oldName"]
 944                                         withName:[currentTransfer objectForKey:@"newName"]
 945                                         atPath:[currentTransfer objectForKey:@"path"]];
 946                         }
 947                         else if ([transferType isEqualToString:@"newFolder"]) {
 948                                 [self makeFolder:[currentTransfer objectForKey:@"newName"] atPath:[currentTransfer objectForKey:@"path"]];
 949                         }
 950                         else if ([transferType isEqualToString:@"delete"]) {
 951                                 [self deleteFile:[currentTransfer objectForKey:@"file"] fromPath:[currentTransfer objectForKey:@"path"]];
 952                         }
 953                         else if ([transferType isEqualToString:@"pause"]) {
 954                                 if ([transferQueue count] != 0) {
 955                                         NSArray* toPause = [transferQueue filteredArrayUsingPredicate:
 956                                                 [NSPredicate predicateWithFormat:@"(filename = %@)",
 957                                                         [currentTransfer objectForKey:@"filename"]]];
 958                                         if ([toPause count] > 1) NSLog(@"multiple pauses?");
 959                                         else {
 960                                                 [pausedQueue addObjectsFromArray:toPause];
 961                                                 [transferQueue removeObjectsInArray:toPause];
 962                                         }
 963                                 }
 964                         }
 965                         else if ([transferType isEqualToString:@"resume"]) {
 966                                 if ([pausedQueue count] != 0) {
 967                                         NSArray* toResume = [pausedQueue filteredArrayUsingPredicate:
 968                                                 [NSPredicate predicateWithFormat:@"(filename = %@)",
 969                                                         [currentTransfer objectForKey:@"filename"]]];
 970                                         if ([toResume count] > 1) NSLog(@"multiple resumes?");
 971                                         else {
 972                                                 [transferQueue addObjectsFromArray:toResume];
 973                                                 [pausedQueue removeObjectsInArray:toResume];
 974                                         }
 975                                 }
 976                         }
 977                         else if ([transferType isEqualToString:@"download"]) {
 978                                 [self getFile:[currentTransfer objectForKey:@"filename"]
 979                                         forPath:[currentTransfer objectForKey:@"path"]
 980                                         toSaveTo:[currentTransfer objectForKey:@"savePath"]
 981                                         beginAtOffset:[[currentTransfer objectForKey:@"offset"] unsignedLongLongValue]
 982                                         withLooping:[[currentTransfer objectForKey:@"looping"] boolValue]
 983                                         existingTime:[[currentTransfer objectForKey:@"existingTime"] intValue]];
 984                         }
 985                         else if ([transferType isEqualToString:@"upload"]) {
 986                                 [self uploadFile:[currentTransfer objectForKey:@"filename"]
 987                                         ofSize:[[currentTransfer objectForKey:@"fileSize"] unsignedLongLongValue]
 988                                         fromPath:[currentTransfer objectForKey:@"path"]
 989                                         withAttributes:[currentTransfer objectForKey:@"attributes"]
 990                                         atOffset:[[currentTransfer objectForKey:@"offset"] unsignedLongLongValue]
 991                                         existingTime:[[currentTransfer objectForKey:@"existingTime"] intValue]];
 992                         }
 993                         else {
 994                                 NSLog(@"Unrecognized transfer type: %@", transferType);
 995                         }
 996                         [self removeTransfer:currentTransfer fromQueue:queue];
 997                 }
 998                 else usleep(100);
 999                 [pool release];
1000         }
1001 }
1002
1003 // ---------------------------------------------------------------------------
1004 // User interface
1005 // ---------------------------------------------------------------------------
1006
1007 -(void) setProgressBar:(NSProgressIndicator*)bar time:(NSTextField*)timeField turbo:(NSButton*)turbo{
1008         progressBar = bar;
1009         progressTime = timeField;
1010         turboCB = turbo;
1011 }
1012
1013 - (void) setDH:(id)newDH tableView:(id)tv {
1014         dh = newDH;
1015         tableView = tv;
1016 }
1017
1018 // ---------------------------------------------------------------------------
1019 // Miscellaneous
1020 // ---------------------------------------------------------------------------
1021
1022 -(id) init {
1023         if (self = [super init]) {
1024                 debug = 0;
1025                 rate = 0xfe00;
1026                 transferQueue = [[NSMutableArray arrayWithCapacity:1] retain];
1027                 pausedQueue = [[NSMutableArray arrayWithCapacity:1] retain];
1028                 priorityTransferQueue = [[NSMutableArray arrayWithCapacity:1] retain];
1029         }
1030         return self;
1031 }
1032
1033 - (int) getSpeed {
1034         return connectedSpeed;
1035 }
1036
1037 -(void) setDebug:(int)mode {
1038         debug = mode;
1039         NSLog(@"Debug level: %i", debug);
1040 }
1041
1042 -(void) setRate:(int) newRate {
1043         rate = newRate;
1044         NSLog(@"New rate set: %i", rate);
1045 }
1046
1047 - (BOOL) hasCurrentTransfer {
1048         return [transferQueue count] > 0;
1049 }
1050
1051 - (id) currentTransferInfo {
1052         if ([transferQueue count] == 0)
1053                 return nil;
1054         else {
1055                 // Make a copy of the object so that it can be safely manipulated
1056                 // in a different thread from the original.
1057                 return [[transferQueue objectAtIndex:0] copy];
1058         }
1059 }
1060
1061 - (id) firstPausedTransferInfo {
1062         if ([pausedQueue count] == 0)
1063                 return nil;
1064         else {
1065                 // Make a copy of the object so that it can be safely manipulated
1066                 // in a different thread from the original.
1067                 return [[pausedQueue objectAtIndex:0] copy];
1068         }
1069 }
1070
1071 @end