TDE
/
extra-dependencies
mirror of https://mirror.git.trinitydesktop.org/gitea/TDE/extra-dependencies.git
0
0
Fork 0
Code Issues Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '3b0c3b8206'
${ noResults }
extra-dependencies/debian/pilot-link/pilot-link-0.12.5-dfsg/libpisock/darwinusb.c

1969 lines
66 KiB
Raw Blame History

/*
* $Id: darwinusb.c,v 1.66 2006/11/09 10:26:21 fpillet Exp $
*
* darwinusb.c: I/O support for Darwin (Mac OS X) USB
*
* Copyright (c) 2004-2006, Florent Pillet.
*
* libpisock interface modeled after linuxusb.c by Jeff Dionne and
* Kenneth Albanowski
* Some structures & defines extracted from Linux "visor.c",
* which is Copyright (C) 1999 - 2003 Greg Kroah-Hartman (greg@kroah.com)
* KLSI adapter (PalmConnect USB) support implemented thanks for the
* Linux implementation made by Utz-Uwe Haus (haus@uuhaus.de)
*
* This library is free software; you can redistribute it and/or modify it
* under the terms of the GNU Library General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This library is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library
* General Public License for more details.
*
* You should have received a copy of the GNU Library General Public License
* along with this library; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
*/
/* Theory of operation
*
* Darwin IOKit is different from traditional unix i/o. It is much more
* structured, and also more complex.
*
* One of the strengths of IOKit is IOUSBLib which allows talking to USB
* devices directly from userland code, without the need to write a driver.
* This is the way we do it here.
*
* Here is what we do:
* - We start a separate thread which will handle the USB communications. The
* main (controlling) thread exposes start, stop, poll, read and write
* functions. These function take care of controlling the USB thread.
* - We register for "device added" notifications. These notifications are
* sent by the IOKit to registered clients when a new device shows up. We
* use a matching dictionary to restrict the devices we're interested in to
* USB devices (IOUSBDevice class)
* - When we get notified that a new device showed up, we check the USB vendor
* ID and product ID and only accept those that are known to be Palm OS
* devices
* - We then examine the device interfaces and select the pipes we're going to
* use for input and output.
* - We register for notifications coming from the device. When the device
* goes away, our notification callback is called and we can cleanly close
* things.
* - Once everything is initialized, we fire a first "read" from the read
* pipe. Subsequent reads are fired directly from the previous read's
* completion routine [1].
* - In case the thread or application is aborted, the IOKit will clean things
* up for us.
*
* [1] Reading is done asynchronously and in a chained way: we fire a read
* with ReadPipeAsync(). Once the read completes (or fails), our
* completion routine is called. As long as the read is not "aborted"
* (which means the device has been disconnected), we fire another read
* from the read_completion() function.
*
* All read data fills a buffer which is independantly consumed by the
* main thread. This way, we get the maximum read throughput by making
* sure that any data received from the device is fetched as soon as
* possible and made available to the main thread.
*
* Writes, in the contrary, are synchronous for now. I can make them async
* as well, though I have not explored the implications for the libpisock
* code yet. This could speed things up a bit as well, though.
*/
#include <mach/mach.h>
#include <stdio.h>
#include <pthread.h>
#include <IOKit/IOKitLib.h>
#include <IOKit/IOMessage.h>
#include <IOKit/IOCFPlugIn.h>
#include <IOKit/usb/IOUSBLib.h>
#include <CoreFoundation/CFByteOrder.h>
#include "pi-debug.h"
#include "pi-source.h"
#include "pi-usb.h"
#include "pi-util.h"
/* Define this to make debug logs include USB debug info */
#ifdef PI_DEBUG
#define DEBUG_USB 1
#endif
#undef DEBUG_USB /* comment out to leave debug enabled */
/* Macro to log more information when debugging USB. Note that this is for
* my own use, mostly, as the info logged is primarily being used to
* debug complex thread/usb issues
*/
#ifdef DEBUG_USB
#define ULOG(a) LOG(a)
#else
#define ULOG(a) do {} while(0)
#endif
/* These values are somewhat tricky. Priming reads with a size of exactly one
* USB packet works best (no timeouts). Probably best to leave these as they are.
*/
#define MAX_AUTO_READ_SIZE 4096
#define AUTO_READ_SIZE 64
/* Options */
#if HAVE_PTHREAD
static int accept_multiple_simultaneous_connections = 1; /* enabled by default when compiling with --enable-threads */
#else
static int accept_multiple_simultaneous_connections = 0; /* disabled by default, set to 1 to enable */
#endif
/* IOKit interface */
static IONotificationPortRef usb_notify_port;
static io_iterator_t usb_device_added_iter;
/* RunLoop / threading management */
static CFRunLoopRef usb_run_loop = 0;
static pthread_mutex_t usb_run_loop_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t usb_thread_ready_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t usb_thread_ready_cond = PTHREAD_COND_INITIALIZER;
static pthread_mutex_t usb_connections_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t usb_connection_added_cond = PTHREAD_COND_INITIALIZER;
static pthread_t usb_thread = 0;
/* Device interface linked list */
typedef struct usb_connection_t
{
struct usb_connection_t *next; /* linked list */
struct pi_socket *ps; /* the pilot-link socket we're associated with (if already paired) */
/* refcount management */
pthread_mutex_t ref_count_mutex;
int ref_count;
IOUSBInterfaceInterface190 **interface; /* IOUSBInterface190 is 1.9.0 available on OS X 10.2 and later */
IOUSBDeviceInterface **device;
io_object_t device_notification; /* for device removal */
unsigned short vendorID; /* connected USB device vendor ID */
unsigned short productID; /* connected USB device product ID */
unsigned short dev_flags; /* copy of the flags from the acceptedDevices structure */
int opened; /* set to != 0 if the connection is opened */
int device_present;
int read_pending; /* set to 1 when a prime_read() has been issued and the read_completion() has not been called yet */
int in_pipe_ref; /* pipe for reads */
int in_pipe_bulk_size; /* max packet size of bulk packets on input */
int out_pipe_ref; /* pipe for writes */
int out_pipe_bulk_size; /* size of bulk packets on the out pipe (used when talking with a PalmConnect USB serial adapter) */
/* these provide hints about the size of the next read */
int auto_read_size; /* if != 0, prime reads to the input pipe to get data permanently */
int read_ahead_size; /* when waiting for big chunks of data, used as a hint to make bigger read requests */
int last_read_ahead_size; /* also need this to properly compute the size of the next read */
unsigned long total_bytes_read; /* total number of bytes received since connection was opened */
unsigned long total_bytes_written; /* total number of bytes sent since connection was opened */
pthread_mutex_t read_queue_mutex;
pthread_cond_t read_queue_data_avail_cond;
char *read_queue; /* stores completed reads, grows by 64k chunks */
size_t read_queue_size;
size_t read_queue_used;
char read_buffer[MAX_AUTO_READ_SIZE];
} usb_connection_t;
static usb_connection_t *usb_connections = NULL; /* linked list of active connections */
/* USB control requests we send to the devices
* Got them from linux/drivers/usb/serial/visor.h
*/
#define GENERIC_REQUEST_BYTES_AVAILABLE 0x01
#define GENERIC_CLOSE_NOTIFICATION 0x02
#define VISOR_GET_CONNECTION_INFORMATION 0x03
#define PALM_GET_EXT_CONNECTION_INFORMATION 0x04
/* Structures defining the info a device returns
* Got them from linux/drivers/usb/serial/visor.h
*/
typedef struct
{
UInt16 num_ports;
struct
{
UInt8 port_function_id;
UInt8 port;
} connections[8];
} visor_connection_info;
/* struct visor_connection_info.connection[x].port defines: */
#define VISOR_ENDPOINT_1 0x01
#define VISOR_ENDPOINT_2 0x02
/* struct visor_connection_info.connection[x].port_function_id defines: */
#define VISOR_FUNCTION_GENERIC 0x00
#define VISOR_FUNCTION_DEBUGGER 0x01
#define VISOR_FUNCTION_HOTSYNC 0x02
#define VISOR_FUNCTION_CONSOLE 0x03
#define VISOR_FUNCTION_REMOTE_FILE_SYS 0x04
typedef struct
{
UInt8 num_ports;
UInt8 endpoint_numbers_different;
UInt16 reserved1;
struct
{
UInt32 port_function_id;
UInt8 port;
UInt8 endpoint_info;
UInt16 reserved;
} connections[8];
} palm_ext_connection_info;
/* PalmConnect USB specific information
* Extracted from Linux kl5kusb105 Copyright (C) 2001 Utz-Uwe Haus <haus@uuhaus.de>
* Using documentation Utz-Uwe provided
*/
enum {
/* Values for KLSI_GET/SET_COMM_DESCRIPTOR */
KLSI_BAUD_115200 = 0,
KLSI_BAUD_57600 = 1,
KLSI_BAUD_38400 = 2,
KLSI_BAUD_28800 = 3,
KLSI_BAUD_19200 = 4,
KLSI_BAUD_14400 = 5,
KLSI_BAUD_9600 = 6,
KLSI_BAUD_7200 = 7,
KLSI_BAUD_4800 = 8,
KLSI_BAUD_2400 = 9,
KLSI_BAUD_1200 = 10,
KLSI_BAUD_600 = 11,
KLSI_BAUD_230400 = 12,
KLSI_PARITY_NONE = 0,
KLSI_PARITY_ODD = 1,
KLSI_PARITY_EVEN = 2,
KLSI_PARITY_MARK = 3,
KLSI_STOPBITS_0 = 0,
KLSI_STOPBITS_2 = 2,
/* Handshake values for KLSI_GET_HANDSHAKE_LINES */
KLSI_GETHS_DCD = 0x80, /* Data Carrier Detect */
KLSI_GETHS_RI = 0x40, /* Ring Indicator */
KLSI_GETHS_DSR = 0x20, /* Data Set Ready */
KLSI_GETHS_CTS = 0x10, /* Clear To Send */
/* Handshake values for KLST_SET_HANDSHAKE_LINES */
KLSI_SETHS_RTS = 0x02, /* Ready To Send */
KLSI_SETHS_DTR = 0x01, /* Data Terminal Ready */
/* Flow control values */
KLSI_FLOW_USE_RTS = 0x01, /* use RTS/CTS */
KLSI_FLOW_USE_DSR = 0x02, /* use DSR/CD */
KLSI_FLOW_USE_XON = 0x04 /* use XON/XOFF */
};
#define KLSI_GET_COMM_DESCRIPTOR 0
#define KLSI_SET_COMM_DESCRIPTOR 1
#define KLSI_GET_HANDSHAKE_LINES 2
#define KLSI_SET_HANDSHAKE_LINES 3
#define KLSI_GET_FLOWCONTROL 4
#define KLSI_SET_FLOWCONTROL 5
typedef struct
{
unsigned char DCBLength __attribute__((packed));
unsigned char BaudRateIndex __attribute__((packed));
unsigned char DataBits __attribute__((packed));
unsigned char Parity __attribute__((packed));
unsigned char StopBits __attribute__((packed));
} klsi_port_settings;
/* Some vendor and product codes we use */
#define VENDOR_SONY 0x054c
#define VENDOR_KEYSPAN 0x06cd
#define VENDOR_HANDSPRING 0x082d
#define VENDOR_PALMONE 0x0830
#define VENDOR_TAPWAVE 0x12ef
#define PRODUCT_PALMCONNECT_USB 0x0080
#define PRODUCT_HANDSPRING_VISOR 0x0100
#define PRODUCT_SONY_CLIE_3_5 0x0038
/* This table helps us determine whether a connecting USB device is
* one we'd like to talk to. Don't forget to update it as new
* devices come out. To accept ALL the devices from a vendor, add
* an entry with the vendorID and 0xFFFF as productID.
*/
#define FLAG_ANSWERS_CONN_INFO 0x0001 /* device is known to answer connection information requests */
#define FLAG_USE_FIRST_PAIR 0x0002 /* thanks to dumb programmers at Palm, the connection information doesn't match the actual pipes being used. If this flag is set, always try to use the first endoints pair */
#define FLAG_USE_SECOND_PAIR 0x0004 /* ditto */
#define FLAG_ANSWERS_PALM_CONN_INFO 0x0008 /* means that if the device doesn't answer PALM_EXT_CONNECTION_INFORMATION, don't try the visor variant (for stupid PalmOne handhelds) */
#define FLAG_REJECT 0x8000 /* device is known but not supported yet */
static struct {
unsigned short vendorID;
unsigned short productID;
unsigned short flags;
}
acceptedDevices[] = {
/* Sony */
{0x054c, 0x0038}, /* Sony Palm OS 3.5 devices, S300 */
{0x054c, 0x0066}, /* Sony T, S320, SJ series, and other Palm OS 4.0 devices */
{0x054c, 0x0095}, /* Sony S360 */
{0x054c, 0x000a}, /* Sony NR and other Palm OS 4.1 devices */
{0x054c, 0x009a}, /* Sony NR70V/U */
{0x054c, 0x00da}, /* Sony NX */
{0x054c, 0x00e9}, /* Sony NZ */
{0x054c, 0x0144}, /* Sony UX */
{0x054c, 0x0169}, /* Sony TJ */
/* Keyspan serial-to-USB PDA adapter */
{0x06cd, 0x0103, FLAG_REJECT}, /* ID sent by an adapter which firmware has not been uploaded yet */
{0x06cd, 0x0104, FLAG_REJECT}, /* ID sent by an adapter with proper firmware uploaded */
/* AlphaSmart */
{0x081e, 0xdf00}, /* Dana */
/* HANDSPRING (vendor 0x082d) */
{0x082d, 0x0100}, /* Visor */
{0x082d, 0x0200}, /* Treo */
{0x082d, 0x0300, FLAG_ANSWERS_CONN_INFO}, /* Treo 600 */
/* PalmOne, Palm Inc */
{0x0830, 0x0001, FLAG_ANSWERS_CONN_INFO}, /* m500 */
{0x0830, 0x0002, FLAG_ANSWERS_CONN_INFO}, /* m505 */
{0x0830, 0x0003, FLAG_ANSWERS_CONN_INFO}, /* m515 */
{0x0830, 0x0010},
{0x0830, 0x0011},
{0x0830, 0x0020}, /* i705 */
{0x0830, 0x0030},
{0x0830, 0x0031}, /* Tungsten|W */
{0x0830, 0x0040}, /* m125 */
{0x0830, 0x0050}, /* m130 */
{0x0830, 0x0051},
{0x0830, 0x0052},
{0x0830, 0x0053},
{0x0830, 0x0060, FLAG_ANSWERS_CONN_INFO}, /* Tungsten series, Zire 71 */
{0x0830, 0x0061, FLAG_ANSWERS_PALM_CONN_INFO | FLAG_USE_FIRST_PAIR}, /* Zire 22, 31, 72, T|5, T|X, LifeDrive, Treo 650 -- for T|X and LD, they don't answer to the PALM_EXT_CONNECTION_INFORMATION control code. In this case we revert to using the first pair of pipes */
{0x0830, 0x0062},
{0x0830, 0x0063},
{0x0830, 0x0070, FLAG_ANSWERS_CONN_INFO}, /* Zire */
{0x0830, 0x0071},
{0x0830, 0x0080}, /* palmOne serial adapter */
{0x0830, 0x0099},
{0x0830, 0x0100},
/* GARMIN */
{0x091e, 0x0004}, /* IQUE 3600 */
/* Kyocera */
{0x0c88, 0x0021}, /* 7135 Smartphone */
{0x0c88, 0xa226}, /* 6035 Smartphone */
/* Tapwave */
{0x12ef, 0x0100, FLAG_ANSWERS_CONN_INFO}, /* Zodiac, Zodiac2 */
/* ACEECA */
{0x4766, 0x0001}, /* MEZ1000 */
/* Fossil */
{0x0e67, 0x0002}, /* Abacus wrist PDA */
/* Samsung */
{0x04e8, 0x8001} /* I330 */
};
/* local prototypes */
static int change_refcount(usb_connection_t *c, int increment);
static void stop_listening(usb_connection_t *c);
static IOReturn control_request (IOUSBDeviceInterface **dev, UInt8 requestType, UInt8 request, UInt16 value, UInt16 index, void *pData, UInt16 maxReplyLength);
static void device_added (void *refCon, io_iterator_t iterator);
static void device_notification (usb_connection_t *connexion, io_service_t service, natural_t messageType, void *messageArgument);
static void read_completion (usb_connection_t *connexion, IOReturn result, void *arg0);
static int accepts_device (unsigned short vendor, unsigned short product, unsigned short *flags);
static IOReturn configure_device (IOUSBDeviceInterface **dev, unsigned short vendor, unsigned short product, unsigned short flags, int *port_number, int *input_pipe_number, int *output_pipe_number, int *pipe_info_retrieved);
static IOReturn find_interfaces (usb_connection_t *usb, IOUSBDeviceInterface **dev, unsigned short vendor, unsigned short product, unsigned short accept_flags, int port_number, int input_pipe_number, int output_pipe_number, int pipe_info_retrieved);
static int prime_read (usb_connection_t *connexion);
static IOReturn read_visor_connection_information (IOUSBDeviceInterface **dev, int *port_number, int *input_pipe, int *output_pipe);
static IOReturn decode_generic_connection_information(palm_ext_connection_info *ci, int *port_number, int *input_pipe, int *output_pipe);
static IOReturn read_generic_connection_information (IOUSBDeviceInterface **dev, int *port_number, int *input_pipe_number, int *output_pipe_number);
static IOReturn klsi_set_portspeed(IOUSBDeviceInterface **dev, int speed);
/***************************************************************************/
/* */
/* GLOBAL DARWINUSB OPTIONS FOR CLIENT CODE */
/* */
/***************************************************************************/
void
darwinusb_setoptions(int multiple_connections_support)
{
accept_multiple_simultaneous_connections = multiple_connections_support;
}
/***************************************************************************/
/* */
/* CONNECTIONS LINKED LIST MANAGEMENT */
/* */
/***************************************************************************/
static void
add_connection(usb_connection_t *c)
{
LOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "darwinusb: adding connection %p to linked list\n", c));
pthread_mutex_lock(&usb_connections_mutex);
c->next = usb_connections;
usb_connections = c;
//pthread_cond_signal(&usb_connection_added_cond);
pthread_mutex_unlock(&usb_connections_mutex);
}
static int
remove_connection(usb_connection_t *c)
{
/* remove the connection from the linked list if it exists
* and return != 0. Otherwise return 0. Don't free the
* connection structure or variables.
*/
usb_connection_t *previous = NULL, *elem;
pthread_mutex_lock(&usb_connections_mutex);
elem = usb_connections;
while (elem && elem != c)
{
previous = elem;
elem = elem->next;
}
if (elem)
{
if (previous)
previous->next = elem->next;
else
usb_connections = elem->next;
LOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "darwinusb: removed connection %p from linked list\n", c));
}
pthread_mutex_unlock(&usb_connections_mutex);
return elem != NULL;
}
static int
device_already_in_use(IOUSBDeviceInterface **device)
{
usb_connection_t *elem;
pthread_mutex_lock(&usb_connections_mutex);
elem = usb_connections;
while (elem != NULL && elem->device != device)
elem = elem->next;
pthread_mutex_unlock(&usb_connections_mutex);
return elem != NULL;
}
static usb_connection_t*
connection_for_socket(pi_socket_t *ps)
{
/* if there is no active connection associated with this socket,
* try to associate the first unassociated connection
*/
usb_connection_t *c = ((pi_usb_data_t *)ps->device->data)->ref;
if (change_refcount(c, +1) > 0)
return c;
pthread_mutex_lock(&usb_connections_mutex);
c = usb_connections;
while (c && (c->ps != NULL || c->opened == 0 || c->total_bytes_read == 0)) /* skip connections which are being disposed of (opened=0) */
c = c->next;
if (change_refcount(c, +1) <= 0)
c = NULL;
else
{
c->ps = ps;
((pi_usb_data_t *)ps->device->data)->ref = c;
}
pthread_mutex_unlock(&usb_connections_mutex);
return c;
}
static int
change_refcount(usb_connection_t *c, int increment)
{
/* update the refcount on the connection structure. If the refcount becomes
* zero, call the stop_listening() function
*/
int rc;
if (c == NULL)
return 0;
if (pthread_mutex_lock(&c->ref_count_mutex) != 0)
{
LOG((PI_DBG_DEV, PI_DBG_LVL_ERR, "darwinusb: connection %p, can't lock ref_count_mutex (ref_count=%d)\n",c,c->ref_count_mutex));
return 0;
}
rc = c->ref_count = c->ref_count + increment;
if (rc < 0)
LOG((PI_DBG_DEV, PI_DBG_LVL_ERR, "darwinusb: connection %p's refcount became < 0 (%d)\n", c, c->ref_count));
if (rc == 0)
{
if (remove_connection(c))
stop_listening(c);
}
else
pthread_mutex_unlock(&c->ref_count_mutex);
return rc;
}
/***************************************************************************/
/* */
/* INTERNAL ROUTINES */
/* */
/***************************************************************************/
static int
start_listening(void)
{
mach_port_t masterPort;
CFMutableDictionaryRef matchingDict;
CFRunLoopSourceRef runLoopSource;
kern_return_t kr;
LOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "darwinusb: start_listening for connections\n"));
/* first create a master_port for my task */
kr = IOMasterPort (MACH_PORT_NULL, &masterPort);
if (kr || !masterPort)
{
LOG((PI_DBG_DEV, PI_DBG_LVL_ERR, "darwinusb: couldn't create a master IOKit Port(%08x)\n", kr));
return PI_ERR_GENERIC_SYSTEM;
}
/* Set up the matching criteria for the devices we're interested in
* Interested in instances of class IOUSBDevice and its subclasses
* Since we are supporting many USB devices, we just get notifications
* for all USB devices and sort out the ones that we want later.
*/
matchingDict = IOServiceMatching (kIOUSBDeviceClassName);
if (!matchingDict)
{
LOG((PI_DBG_DEV, PI_DBG_LVL_ERR, "darwinusb: can't create a USB matching dictionary\n"));
mach_port_deallocate (mach_task_self(), masterPort);
return PI_ERR_GENERIC_SYSTEM;
}
/* Create a notification port and add its run loop event source to our run loop
* This is how async notifications get set up.
*/
usb_notify_port = IONotificationPortCreate (masterPort);
runLoopSource = IONotificationPortGetRunLoopSource (usb_notify_port);
CFRunLoopAddSource(CFRunLoopGetCurrent(), runLoopSource, kCFRunLoopDefaultMode);
/* Set up a notifications to be called when a raw device is first matched by I/O Kit */
kr = IOServiceAddMatchingNotification (
usb_notify_port,
kIOFirstMatchNotification,
matchingDict,
device_added,
NULL,
&usb_device_added_iter);
LOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "darwinusb: added service matching notification (kr=0x%08lx)\n", kr));
/* Iterate once to get already-present devices and arm the notification */
device_added (NULL, usb_device_added_iter);
/* Now done with the master_port */
mach_port_deallocate (mach_task_self(), masterPort);
return 0;
}
static void
stop_listening(usb_connection_t *c)
{
LOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "darwinusb: stop_listening for connection %p\n",c));
c->opened = 0;
c->in_pipe_ref = 0;
c->out_pipe_ref = 0;
if (c->ps)
{
/* we do this because if the connection abruptly ends before pilot-link notices,
* we want to avoid pi_close() trying to do a dlp_EndOfSync()
*/
c->ps->state = PI_SOCK_CLOSE;
if (c->ps->device != NULL && c->ps->device->data != NULL)
((pi_usb_data_t *)c->ps->device->data)->ref = NULL;
}
c->ps = NULL;
if (c->device_notification)
{
IOObjectRelease (c->device_notification);
c->device_notification = 0;
}
if (c->interface)
{
(*c->interface)->USBInterfaceClose (c->interface);
(*c->interface)->Release(c->interface);
c->interface = NULL;
}
if (c->device)
{
(*c->device)->USBDeviceClose (c->device);
(*c->device)->Release(c->device);
c->device = NULL;
}
pthread_mutex_destroy(&c->read_queue_mutex);
pthread_mutex_destroy(&c->ref_count_mutex);
free(c);
}
static void *
usb_thread_run(void *foo)
{
if (start_listening() == 0)
{
LOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "darwinusb: usb_thread_run, starting...\n"));
/* obtain the CFRunLoop for this thread */
pthread_mutex_lock(&usb_run_loop_mutex);
usb_run_loop = CFRunLoopGetCurrent();
pthread_mutex_unlock(&usb_run_loop_mutex);
/* signal main thread that init was successful */
pthread_mutex_lock(&usb_thread_ready_mutex);
pthread_cond_broadcast(&usb_thread_ready_cond);
pthread_mutex_unlock(&usb_thread_ready_mutex);
CFRunLoopRun();
LOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "darwinusb: usb_thread_run, done with runloop\n"));
pthread_mutex_lock(&usb_run_loop_mutex);
usb_run_loop = 0;
pthread_mutex_unlock(&usb_run_loop_mutex);
if (usb_device_added_iter)
{
IOObjectRelease (usb_device_added_iter);
usb_device_added_iter = 0;
}
if (usb_notify_port)
{
IONotificationPortDestroy(usb_notify_port);
usb_notify_port = NULL;
}
/* decrement the refcount of each structure. If there
* was a pending read, decrement once more since
* prime_read() increments the refcount
*/
usb_connection_t *elem, *next, *prev = NULL;
pthread_mutex_lock(&usb_connections_mutex);
elem = usb_connections;
while (elem != NULL)
{
next = elem->next;
pthread_mutex_lock(&elem->ref_count_mutex);
elem->ref_count--;
if (elem->read_pending)
elem->ref_count--;
if (elem < 0)
LOG((PI_DBG_DEV, PI_DBG_LVL_ERR, "darwinusb: while stopping usb_thread, connection %p's refcount became < 0 (%d)", elem, elem->ref_count));
if (elem == 0)
{
if (prev != NULL)
prev->next = next;
else
usb_connections = next;
stop_listening(elem);
elem = NULL;
}
else
{
pthread_mutex_unlock(&elem->ref_count_mutex);
prev = elem;
}
}
pthread_mutex_unlock(&usb_connections_mutex);
usb_thread = 0;
usb_run_loop = NULL;
LOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "darwinusb: usb_thread_run, exited.\n"));
}
else
{
/* signal main thread that init failed */
usb_thread = 0;
usb_run_loop = NULL;
pthread_mutex_lock(&usb_thread_ready_mutex);
pthread_cond_signal(&usb_thread_ready_cond);
pthread_mutex_unlock(&usb_thread_ready_mutex);
}
return NULL;
}
static void
device_added (void *refCon, io_iterator_t iterator)
{
kern_return_t kr;
io_service_t ioDevice;
IOCFPlugInInterface **plugInInterface = NULL;
IOUSBDeviceInterface **dev = NULL;
HRESULT res;
SInt32 score;
UInt16 vendor, product;
unsigned short accept_flags;
int port_number = 0xff,
input_pipe_number = 0xff,
output_pipe_number = 0xff,
pipe_info_retrieved = 0;
LOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "darwinusb: device_added\n"));
while ((ioDevice = IOIteratorNext (iterator)))
{
if (usb_connections != NULL && !accept_multiple_simultaneous_connections)
{
LOG((PI_DBG_DEV, PI_DBG_LVL_ERR, "darwinusb: new device plugged but we already have a running connection\n"));
IOObjectRelease (ioDevice);
continue;
}
kr = IOCreatePlugInInterfaceForService (ioDevice, kIOUSBDeviceUserClientTypeID, kIOCFPlugInInterfaceID, &plugInInterface, &score);
if (kr != kIOReturnSuccess || !plugInInterface)
{
LOG((PI_DBG_DEV, PI_DBG_LVL_ERR, "darwinusb: -> unable to create a plugin (kr=0x%08x)\n", kr));
IOObjectRelease (ioDevice);
continue;
}
res = (*plugInInterface)->QueryInterface (plugInInterface, CFUUIDGetUUIDBytes (kIOUSBDeviceInterfaceID), (LPVOID *)&dev);
(*plugInInterface)->Release (plugInInterface);
if (res || !dev)
{
LOG((PI_DBG_DEV, PI_DBG_LVL_ERR, "darwinusb: couldn't create a device interface (res=0x%08x)\n", (int) res));
IOObjectRelease (ioDevice);
continue;
}
/* make sure this device is not already being handled (this may happen
* with some handhelds that reconnect immediately after disconnecting, like the T5)
*/
if (device_already_in_use(dev))
{
LOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "darwinusb: device %p already in use, skipping it\n"));
IOObjectRelease (ioDevice);
continue;
}
kr = (*dev)->GetDeviceVendor (dev, &vendor);
kr = (*dev)->GetDeviceProduct (dev, &product);
if (accepts_device(vendor, product, &accept_flags) == 0)
{
ULOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "darwinusb: not accepting device (vendor=0x%04x product=0x%04x)\n", vendor, product));
(*dev)->Release(dev);
IOObjectRelease (ioDevice);
continue;
}
LOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "darwinusb: Accepted USB device, vendor: 0x%04x product: 0x%04x\n", vendor, product));
kr = (*dev)->USBDeviceOpen (dev);
if (kr != kIOReturnSuccess)
{
LOG((PI_DBG_DEV, PI_DBG_LVL_ERR, "darwinusb: unable to open device (kr=0x%08x)\n", kr));
(*dev)->Release(dev);
IOObjectRelease (ioDevice);
continue;
}
/* configure the device and query for its preferred I/O pipes */
kr = configure_device (dev, vendor, product, accept_flags, &port_number, &input_pipe_number, &output_pipe_number, &pipe_info_retrieved);
if (kr != kIOReturnSuccess)
{
LOG((PI_DBG_DEV, PI_DBG_LVL_ERR, (kr == kIOReturnNotReady)
? "darwinusb: device not ready to synchonize\n"
: "darwinusb: unable to configure device (kr=0x%08x)\n", kr));
(*dev)->USBDeviceClose (dev);
(*dev)->Release (dev);
IOObjectRelease (ioDevice);
continue;
}
/* allocate and initialize the USB connection structure */
usb_connection_t *c = malloc(sizeof(usb_connection_t));
if (c == NULL)
{
LOG((PI_DBG_DEV, PI_DBG_LVL_ERR, "out of memory"));
(*dev)->USBDeviceClose (dev);
(*dev)->Release (dev);
IOObjectRelease (ioDevice);
break;
}
memset(c, 0, sizeof(usb_connection_t));
c->auto_read_size = AUTO_READ_SIZE;
c->device = dev;
c->ref_count = 1;
c->opened = 1;
c->device_present = 1;
c->vendorID = vendor;
c->productID = product;
c->dev_flags = accept_flags;
/* try to locate the pipes we need to talk to the device */
kr = find_interfaces(c, dev, vendor, product, accept_flags, port_number, input_pipe_number, output_pipe_number, pipe_info_retrieved);
if (kr != kIOReturnSuccess)
{
LOG((PI_DBG_DEV, PI_DBG_LVL_ERR, "darwinusb: unable to find interfaces (kr=0x%08x)\n", kr));
free(c);
(*dev)->USBDeviceClose (dev);
(*dev)->Release (dev);
IOObjectRelease (ioDevice);
continue;
}
/* Just like with service matching notifications, we need to create an event source and add it
* to our run loop in order to receive async completion notifications.
*/
CFRunLoopSourceRef runLoopSource;
kr = (*c->interface)->CreateInterfaceAsyncEventSource (c->interface, &runLoopSource);
if (kr != kIOReturnSuccess)
{
LOG((PI_DBG_DEV, PI_DBG_LVL_ERR, "darwinusb: Unable to create async event source (%08x)\n", kr));
free(c);
(*dev)->USBDeviceClose (dev);
(*dev)->Release (dev);
IOObjectRelease (ioDevice);
continue;
}
CFRunLoopAddSource (CFRunLoopGetCurrent(), runLoopSource, kCFRunLoopDefaultMode);
LOG((PI_DBG_DEV, PI_DBG_LVL_INFO, "darwinusb: USBConnection %p OPENED c->in_pipe_ref=%d c->out_pipe_ref=%d\n",c,c->in_pipe_ref,c->out_pipe_ref));
/* Register for an interest notification for this device,
* so we get notified when it goes away
*/
LOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "darwinusb: registering for disconnect notification\n"));
kr = IOServiceAddInterestNotification(
usb_notify_port,
ioDevice,
kIOGeneralInterest,
(IOServiceInterestCallback)device_notification,
(void *)c,
&c->device_notification);
IOObjectRelease(ioDevice);
/* add the device to our linked list, then only start reading data
* (order of operations matters here to avoid race conditions)
*/
pthread_mutex_init(&c->read_queue_mutex, NULL);
pthread_mutex_init(&c->ref_count_mutex, NULL);
pthread_cond_init(&c->read_queue_data_avail_cond, NULL);
add_connection(c);
prime_read(c);
}
}
static IOReturn
configure_device(IOUSBDeviceInterface **di,
unsigned short vendor,
unsigned short product,
unsigned short flags,
int *port_number,
int *input_pipe_number,
int *output_pipe_number,
int *pipe_info_retrieved)
{
UInt8 numConf, conf, deviceClass;
IOReturn kr;
IOUSBConfigurationDescriptorPtr confDesc;
/* Get the device class. Most handhelds are registered as composite devices
* and therefore already opened & configured by OS X drivers! It seems that
* reconfiguring them as we did before is what caused some Sony devices to
* refuse talking to us.
*/
kr = (*di)->GetDeviceClass (di, &deviceClass);
if (kr != kIOReturnSuccess)
return kr;
if (deviceClass != kUSBCompositeClass)
{
LOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "darwinusb: Not a composite device: performing confiuration\n"));
kr = (*di)->GetNumberOfConfigurations (di, &numConf);
if (!numConf)
{
LOG((PI_DBG_DEV, PI_DBG_LVL_ERR, "darwinusb: device has zero configurations!\n"));
return -1;
}
/* try all possible configurations if the first one fails
* (shouldn't happen in most cases though)
*/
for (conf=0; conf < numConf; conf++)
{
kr = (*di)->GetConfigurationDescriptorPtr(di, 0, &confDesc);
if (kr)
{
LOG((PI_DBG_DEV, PI_DBG_LVL_ERR, "darwinusb: unable to get config descriptor for index %d (err=%08x numConf=%d)\n",
0, kr, (int)numConf));
continue;
}
kr = (*di)->SetConfiguration(di, confDesc->bConfigurationValue);
if (kr == kIOReturnSuccess)
{
LOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "darwinusb: successfully set configuration %d\n",(int)confDesc->bConfigurationValue));
break;
}
LOG((PI_DBG_DEV, PI_DBG_LVL_ERR, "darwinusb: unable to set configuration to value %d (err=%08x numConf=%d)\n",
(int)confDesc->bConfigurationValue, kr, (int)numConf));
}
if (conf == numConf)
return kr;
}
if (vendor == VENDOR_PALMONE && product == PRODUCT_PALMCONNECT_USB)
{
kr = klsi_set_portspeed(di, 9600);
*input_pipe_number = 0x01;
*output_pipe_number = 0x02;
*pipe_info_retrieved = 1;
return kr;
}
/* Try reading pipe information. Most handhelds support a control request that returns info about the ports and
* pipes. We first try the generic control code, and if it doesn't work we try the Visor one which seems to be
* supported by some devices Also, we can detect that a T5 / LifeDrive is in "wait" mode
* (device appears on USB but not synchronizing) and in this case we return a kIOReturnNotReady code.
*/
kr = read_generic_connection_information (di, port_number, input_pipe_number, output_pipe_number);
if (kr != kIOReturnSuccess && kr != kIOReturnNotReady && !(flags & FLAG_ANSWERS_PALM_CONN_INFO))
kr = read_visor_connection_information (di, port_number, input_pipe_number, output_pipe_number);
if (kr == kIOReturnNotReady)
return kr;
/* With some devices (Palm) we need to hardcode the location of the pipes to use
* because the Palm engineers had the good idea to mismatch the connection information data
* and the actual pipes to use
*/
if (flags & (FLAG_USE_FIRST_PAIR | FLAG_USE_SECOND_PAIR))
{
*pipe_info_retrieved = 1;
return kIOReturnSuccess;
}
/* For device which we know return connection information, we want it to be returned to
* consider the device alive
*/
if (kr != kIOReturnSuccess && (flags & FLAG_ANSWERS_CONN_INFO))
return kIOReturnNotReady;
*pipe_info_retrieved = (kr == kIOReturnSuccess);
/* query bytes available. Not that we really care, but most devices expect to receive this
* before they agree on talking to us.
*/
if (vendor != VENDOR_TAPWAVE)
{
unsigned char ba[2];
kr = control_request (di, 0xc2, GENERIC_REQUEST_BYTES_AVAILABLE, 0, 0, &ba[0] , 2);
if (kr != kIOReturnSuccess)
LOG((PI_DBG_DEV, PI_DBG_LVL_ERR, "darwinusb: GENERIC_REQUEST_BYTES_AVAILABLE failed (err=%08x)\n", kr));
LOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "GENERIC_REQUEST_BYTES_AVAILABLE returns 0x%02x%02x\n", ba[0], ba[1]));
}
return kIOReturnSuccess;
}
static IOReturn
find_interfaces(usb_connection_t *c,
IOUSBDeviceInterface **di,
unsigned short vendor,
unsigned short product,
unsigned short accept_flags,
int port_number,
int input_pipe_number,
int output_pipe_number,
int pipe_info_retrieved)
{
IOReturn kr;
io_iterator_t iterator;
io_service_t usbInterface;
HRESULT res;
SInt32 score;
UInt8 intfClass, intfSubClass, intfNumEndpoints;
int pipeRef, pass;
IOUSBFindInterfaceRequest request;
IOCFPlugInInterface **plugInInterface = NULL;
UInt8 direction, number, transferType, interval;
UInt16 maxPacketSize;
request.bInterfaceClass = kIOUSBFindInterfaceDontCare;
request.bInterfaceSubClass = kIOUSBFindInterfaceDontCare;
request.bInterfaceProtocol = kIOUSBFindInterfaceDontCare;
request.bAlternateSetting = kIOUSBFindInterfaceDontCare;
kr = (*di)->CreateInterfaceIterator (di, &request, &iterator);
while ((usbInterface = IOIteratorNext (iterator)))
{
kr = IOCreatePlugInInterfaceForService (usbInterface, kIOUSBInterfaceUserClientTypeID, kIOCFPlugInInterfaceID, &plugInInterface, &score);
kr = IOObjectRelease (usbInterface); // done with the usbInterface object now that I have the plugin
if (kr != kIOReturnSuccess || !plugInInterface)
{
LOG((PI_DBG_DEV, PI_DBG_LVL_ERR, "darwinusb: unable to create a plugin (%08x)\n", kr));
continue;
}
/* we have the interface plugin: we now need the interface interface */
res = (*plugInInterface)->QueryInterface (plugInInterface, CFUUIDGetUUIDBytes(kIOUSBInterfaceInterfaceID), (LPVOID *) &c->interface);
(*plugInInterface)->Release (plugInInterface); /* done with this */
if (res || c->interface == NULL)
{
LOG((PI_DBG_DEV, PI_DBG_LVL_ERR, "darwinusb: couldn't create an IOUSBInterfaceInterface (%08x)\n", (int) res));
continue;
}
/* get the interface class and subclass */
kr = (*c->interface)->GetInterfaceClass (c->interface, &intfClass);
kr = (*c->interface)->GetInterfaceSubClass (c->interface, &intfSubClass);
LOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "darwinusb: interface class %d, subclass %d\n", intfClass, intfSubClass));
/* Now open the interface. This will cause the pipes to be instantiated that are
* associated with the endpoints defined in the interface descriptor.
*/
kr = (*c->interface)->USBInterfaceOpen (c->interface);
if (kr != kIOReturnSuccess)
{
LOG((PI_DBG_DEV, PI_DBG_LVL_ERR, "darwinusb: unable to open interface (%08x)\n", kr));
(*c->interface)->Release (c->interface);
c->interface = NULL;
continue;
}
kr = (*c->interface)->GetNumEndpoints (c->interface, &intfNumEndpoints);
if (kr != kIOReturnSuccess)
{
LOG((PI_DBG_DEV, PI_DBG_LVL_ERR, "darwinusb: unable to get number of endpoints (%08x)\n", kr));
(*c->interface)->USBInterfaceClose (c->interface);
(*c->interface)->Release (c->interface);
c->interface = NULL;
continue;
}
LOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "darwinusb: interface has %d endpoints\n", intfNumEndpoints));
/* If device didn't answer to the connection_information request,
* try to read a preamble sent by the device. This is sent by devices which chipsets
* don't support the vendor control endpoint requests. Look for the first pipe on
* which a preamble is available.
*/
if (!pipe_info_retrieved)
{
int reqTimeout;
int preambleFound = 0;
for (reqTimeout = 100; reqTimeout <= 300 && !preambleFound; reqTimeout += 100)
{
LOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "darwinusb: checking for pipe_info sent by device with timeout %dms\n",reqTimeout));
for (pipeRef = 1; pipeRef <= intfNumEndpoints; pipeRef++)
{
kr = (*c->interface)->GetPipeProperties (c->interface, pipeRef, &direction, &number,
&transferType, &maxPacketSize, &interval);
if (kr != kIOReturnSuccess)
continue;
if (direction == kUSBIn)
{
UInt32 size = sizeof(c->read_buffer)-1;
LOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "darwinusb: trying pipe %d type=%d\n", pipeRef, (int)transferType));
if (transferType == kUSBBulk)
kr = (*c->interface)->ReadPipeTO (c->interface, pipeRef, &c->read_buffer, &size, reqTimeout, 250);
else
kr = (*c->interface)->ReadPipe (c->interface, pipeRef, &c->read_buffer, &size);
if (kr == kIOReturnSuccess && size >= 8)
{
/* got something! */
LOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "darwinusb: got %d bytes there!\n", (int)size));
CHECK(PI_DBG_DEV, PI_DBG_LVL_DEBUG, pi_dumpdata(c->read_buffer, size));
if (!memcmp(c->read_buffer, "VNDR10", 6))
{
/* VNDR version 1.0 */
palm_ext_connection_info ci;
memcpy(&ci, &c->read_buffer[6], sizeof(ci));
decode_generic_connection_information(&ci, &port_number, &input_pipe_number, &output_pipe_number);
preambleFound = 1;
break;
}
}
}
}
}
}
/* Locate the pipes we're going to use for reading and writing.
* We have four chances to find the right pipes:
* 1. If we got a hint from the device with input/output pipes, we try this one first.
* 2. If we didn't get both pipes, try using the port number hint. There is at least one recent
* device (LifeDrive) on which the port_number hint is actually an endpoint pair index.
* The code below tries to cope with that.
* 3. If we're still missing one or two pipes, give a second try looking for pipes with a
* 64 bytes transfer size
* 4. Finally of this failed, forget about the transfer size and take the first ones that
* come (i.e. Tungsten W has a 64 bytes IN pipe and a 32 bytes OUT pipe).
*/
for (pass=1; pass <= 4 && (c->in_pipe_ref==0 || c->out_pipe_ref==0); pass++)
{
LOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "darwinusb: pass %d looking for pipes, port_number=0x%02x, input_pipe_number=0x%02x, output_pipe_number=0x%02x\n",
pass, port_number, input_pipe_number, output_pipe_number));
c->in_pipe_ref = 0;
c->out_pipe_ref = 0;
int input_pipes_seen = 0;
int output_pipes_seen = 0;
for (pipeRef = 1; pipeRef <= intfNumEndpoints; pipeRef++)
{
kr = (*c->interface)->GetPipeProperties (c->interface, pipeRef, &direction, &number,
&transferType, &maxPacketSize, &interval);
if (kr != kIOReturnSuccess)
{
LOG((PI_DBG_DEV, PI_DBG_LVL_ERR, "darwinusb: unable to get properties of pipe %d (kr=0x%08x)\n", pipeRef, kr));
}
else
{
int pair_index = (direction == kUSBIn) ? ++input_pipes_seen : ++output_pipes_seen;
LOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG,
"darwinusb: pipe %d: direction=0x%02x, number=0x%02x, transferType=0x%02x, maxPacketSize=%d, interval=0x%02x, pair_index=%d\n",
pipeRef,(int)direction,(int)number,(int)transferType,(int)maxPacketSize,(int)interval,pair_index));
if (c->in_pipe_ref == 0 &&
direction == kUSBIn &&
transferType == kUSBBulk)
{
if ((pass == 1 && input_pipe_number != 0xff && number == input_pipe_number) ||
(pass == 1 && port_number == 0xff && input_pipe_number == 0xff && (accept_flags & FLAG_USE_FIRST_PAIR)) ||
(pass == 2 && port_number != 0xff && number == port_number) ||
(pass == 3 && ((port_number != 0xff && pair_index == port_number) || (port_number == 0xff && (maxPacketSize == 64 || maxPacketSize == 512)))) ||
pass == 4)
c->in_pipe_ref = pipeRef;
c->in_pipe_bulk_size = maxPacketSize;
}
else if (c->out_pipe_ref == 0 &&
direction == kUSBOut &&
transferType == kUSBBulk)
{
if ((pass == 1 && output_pipe_number != 0xff && number == output_pipe_number) ||
(pass == 1 && port_number == 0xff && input_pipe_number == 0xff && (accept_flags & FLAG_USE_FIRST_PAIR)) ||
(pass == 2 && port_number != 0xff && number == port_number) ||
(pass == 3 && ((port_number != 0xff && pair_index == port_number) || (port_number == 0xff && (maxPacketSize == 64 || maxPacketSize == 512)))) ||
pass == 4)
{
c->out_pipe_ref = pipeRef;
c->out_pipe_bulk_size = maxPacketSize;
}
}
}
}
}
if (c->in_pipe_ref && c->out_pipe_ref)
return kIOReturnSuccess;
LOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "darwinusb: couldn't find any suitable pipes pair on this interface\n"));
(*c->interface)->USBInterfaceClose (c->interface);
(*c->interface)->Release (c->interface);
c->interface = NULL;
c->in_pipe_ref = 0;
c->out_pipe_ref = 0;
}
return c->interface==NULL ? -1 : kIOReturnSuccess;
}
static IOReturn
control_request(IOUSBDeviceInterface **dev, UInt8 requestType, UInt8 request, UInt16 value, UInt16 index, void *pData, UInt16 maxReplyLength)
{
IOReturn kr;
IOUSBDevRequest req;
void *pReply = pData;
if (!pReply && maxReplyLength)
pReply = malloc(maxReplyLength);
req.bmRequestType = requestType; /* i.e. 0xc2=kUSBIn, kUSBVendor, kUSBEndpoint */
req.bRequest = request;
req.wValue = value;
req.wIndex = index;
req.wLength = maxReplyLength;
req.pData = pReply;
req.wLenDone = 0;
kr = (*dev)->DeviceRequest (dev, &req);
LOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "darwinusb: control_request(0x%02x) wLenDone=%d kr=0x%08lx\n", (int)request, req.wLenDone, kr));
if (pReply && !pData)
free (pReply);
return kr;
}
static IOReturn
read_visor_connection_information (IOUSBDeviceInterface **dev, int *port_number, int *input_pipe, int *output_pipe)
{
int i;
kern_return_t kr;
visor_connection_info ci;
memset(&ci, 0, sizeof(ci));
kr = control_request (dev, 0xc2, VISOR_GET_CONNECTION_INFORMATION, 0, 0, &ci, sizeof(ci));
if (kr != kIOReturnSuccess)
{
LOG((PI_DBG_DEV, PI_DBG_LVL_ERR, "darwinusb: VISOR_GET_CONNECTION_INFORMATION failed (err=%08x)\n", kr));
}
else
{
CHECK(PI_DBG_DEV, PI_DBG_LVL_DEBUG, pi_dumpdata((const char *)&ci, sizeof(ci)));
ci.num_ports = CFSwapInt16LittleToHost(ci.num_ports); /* number of ports is little-endian */
if (ci.num_ports > 8)
ci.num_ports = 8;
LOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "darwinusb: VISOR_GET_CONNECTION_INFORMATION, num_ports=%d\n", ci.num_ports));
kr = kIOReturnNotReady;
for (i=0; i < ci.num_ports; i++)
{
char *function_str;
switch (ci.connections[i].port_function_id)
{
case VISOR_FUNCTION_GENERIC:
function_str = "GENERIC";
break;
case VISOR_FUNCTION_DEBUGGER:
function_str = "DEBUGGER";
break;
case VISOR_FUNCTION_HOTSYNC:
function_str = "HOTSYNC";
if (port_number)
*port_number = ci.connections[i].port;
kr = kIOReturnSuccess;
break;
case VISOR_FUNCTION_CONSOLE:
function_str = "CONSOLE";
break;
case VISOR_FUNCTION_REMOTE_FILE_SYS:
function_str = "REMOTE_FILE_SYSTEM";
break;
default:
function_str = "UNKNOWN";
break;
}
LOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "\t[%d] port_function_id=0x%02x (%s)\n", i, ci.connections[i].port_function_id, function_str));
LOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "\t[%d] port=%d\n", i, ci.connections[i].port));
}
}
return kr;
}
static IOReturn
decode_generic_connection_information(palm_ext_connection_info *ci, int *port_number, int *input_pipe, int *output_pipe)
{
int i;
CHECK(PI_DBG_DEV, PI_DBG_LVL_DEBUG, pi_dumpdata((const char *)ci, sizeof(palm_ext_connection_info)));
LOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "darwinusb: decode_generic_connection_information num_ports=%d, endpoint_numbers_different=%d\n", ci->num_ports, ci->endpoint_numbers_different));
for (i=0; i < ci->num_ports; i++)
{
UInt32 port_function_id = CFSwapInt32LittleToHost(ci->connections[i].port_function_id);
LOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "\t[%d] port_function_id=0x%08lx ('%4.4s')\n", i, port_function_id, (char*)&port_function_id));
LOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "\t[%d] port=%d\n", i, ci->connections[i].port));
LOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "\t[%d] endpoint_info=%d (0x%02x)\n", i, ci->connections[i].endpoint_info, (int)ci->connections[i].endpoint_info));
if (port_function_id == 'rfsL')
{
/* This is a T5 in USB connected but not synchronizing:
* don't bother trying to talk to it
*/
return kIOReturnNotReady;
}
if (port_function_id == 'sync' || port_function_id == 'ppp_')
{
/* we found the port/pipes to use for synchronization
* If endpoint_numbers_different is != 0, then the number of each
* endpoint to use for IN and OUT is stored in endpoint_info.
* Otherwise, the port number (same for both endpoints) is in
* port.
*/
if (!ci->endpoint_numbers_different)
{
if (port_number)
*port_number = ci->connections[i].port;
}
else if (ci->connections[i].endpoint_info)
{
if (input_pipe)
*input_pipe = ci->connections[i].endpoint_info >> 4;
if (output_pipe)
*output_pipe = ci->connections[i].endpoint_info & 0x0f;
}
}
}
return kIOReturnSuccess;
}
static IOReturn
read_generic_connection_information (IOUSBDeviceInterface **dev, int *port_number, int *input_pipe, int *output_pipe)
{
kern_return_t kr;
palm_ext_connection_info ci;
memset(&ci, 0, sizeof(ci));
kr = control_request (dev, 0xc2, PALM_GET_EXT_CONNECTION_INFORMATION, 0, 0, &ci, sizeof(ci));
if (kr != kIOReturnSuccess)
{
LOG((PI_DBG_DEV, PI_DBG_LVL_ERR, "darwinusb: PALM_GET_EXT_CONNECTION_INFORMATION failed (err=%08x)\n", kr));
return kr;
}
return decode_generic_connection_information(&ci, port_number, input_pipe, output_pipe);
}
static IOReturn
klsi_set_portspeed(IOUSBDeviceInterface **dev, int speed)
{
/* set the comms speed for a KLSI serial adapter (PalmConnect USB) */
kern_return_t kr;
klsi_port_settings settings = {5, KLSI_BAUD_9600, 8, KLSI_PARITY_NONE, KLSI_STOPBITS_0};
switch (speed)
{
case 230400: settings.BaudRateIndex = KLSI_BAUD_230400; break;
case 115200: settings.BaudRateIndex = KLSI_BAUD_115200; break;
case 57600: settings.BaudRateIndex = KLSI_BAUD_57600; break;
case 38400: settings.BaudRateIndex = KLSI_BAUD_38400; break;
case 28800: settings.BaudRateIndex = KLSI_BAUD_28800; break;
case 19200: settings.BaudRateIndex = KLSI_BAUD_19200; break;
case 14400: settings.BaudRateIndex = KLSI_BAUD_14400; break;
case 9600: settings.BaudRateIndex = KLSI_BAUD_9600; break;
case 7200: settings.BaudRateIndex = KLSI_BAUD_7200; break;
case 4800: settings.BaudRateIndex = KLSI_BAUD_4800; break;
case 2400: settings.BaudRateIndex = KLSI_BAUD_2400; break;
case 1200: settings.BaudRateIndex = KLSI_BAUD_1200; break;
case 600: settings.BaudRateIndex = KLSI_BAUD_600; break;
default: break;
}
kr = control_request(dev, 0x40, KLSI_SET_COMM_DESCRIPTOR, 0, 0, &settings, 5);
if (kr == kIOReturnSuccess)
{
kr = control_request(dev, 0x40, KLSI_SET_COMM_DESCRIPTOR, 0, 0, &settings, 5);
if (kr == kIOReturnSuccess)
kr = control_request(dev, 0x40, KLSI_SET_FLOWCONTROL, (speed > 9600) ? KLSI_FLOW_USE_RTS : 0, 0, NULL, 0);
control_request(dev, 0x40, KLSI_SET_HANDSHAKE_LINES, KLSI_SETHS_DTR | KLSI_SETHS_RTS, 0, NULL, 0);
}
return kr;
}
static void
device_notification(usb_connection_t *c, io_service_t service, natural_t messageType, void *messageArgument)
{
LOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "darwinusb: device_notification (c=%p messageType=0x%08lx)\n", c, messageType));
if (messageType == kIOMessageServiceIsTerminated && c != NULL)
{
c->device_present = 0;
c->opened = 0; /* so that stop_listening() does'nt try to send the control_request */
if (change_refcount(c,-1) > 0)
{
/* In case the reading thread is waiting for data,
* we need to raise the usb_data_available cond once.
* since darwin_usb_read tests usb.opened, it will
* gracefully exit during a data wait.
*/
ULOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "darwinusb: device_notification signaling c->read_queue_data_avail_cond for c=%p\n",c));
pthread_mutex_lock (&c->read_queue_mutex);
pthread_cond_signal (&c->read_queue_data_avail_cond);
pthread_mutex_unlock (&c->read_queue_mutex);
}
}
}
static void
read_completion (usb_connection_t *c, IOReturn result, void *arg0)
{
size_t bytes_read = (size_t) arg0;
ULOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "darwinusb: read_completion(c=%p, result=0x%08lx, bytes_read=%d)\n", c, (long)result, bytes_read));
if (!c->opened)
{
change_refcount(c, -1);
return;
}
if (result != kIOReturnSuccess)
{
LOG((PI_DBG_DEV, PI_DBG_LVL_WARN, "darwinusb: async read completion(%p) received error code 0x%08x\n", c, result));
}
if (bytes_read)
{
if (c->vendorID == VENDOR_PALMONE && c->productID == PRODUCT_PALMCONNECT_USB)
{
/* decode PalmConnect USB frame */
if (bytes_read < 2)
bytes_read = 0;
else
{
int data_size = (int)c->read_buffer[0] | ((int)c->read_buffer[1] << 8);
if ((data_size + 2) > bytes_read)
{
LOG((PI_DBG_DEV, PI_DBG_LVL_ERR, "darwinusb: invalid PalmConnect packet (%d bytes, says %d content bytes)\n",
bytes_read, data_size));
bytes_read = 0;
} else {
memmove(&c->read_buffer[0], &c->read_buffer[2], data_size);
bytes_read = data_size;
}
}
}
if (bytes_read > 0)
{
pthread_mutex_lock(&c->read_queue_mutex);
if (c->read_queue == NULL)
{
c->read_queue_size = ((bytes_read + 0xfffe) & ~0xffff) - 1; /* 64k chunks */
c->read_queue = (char *) malloc (c->read_queue_size);
c->read_queue_used = 0;
}
else if ((c->read_queue_used + bytes_read) > c->read_queue_size)
{
c->read_queue_size += ((bytes_read + 0xfffe) & ~0xffff) - 1;
c->read_queue = (char *) realloc (c->read_queue, c->read_queue_size);
}
if (c->read_queue)
{
memcpy(c->read_queue + c->read_queue_used, c->read_buffer, bytes_read);
c->read_queue_used += bytes_read;
ULOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "darwinusb: signaling c->read_queue_data_avail_cond for c=%p\n",c));
pthread_cond_signal(&c->read_queue_data_avail_cond);
}
else
{
c->read_queue_used = 0;
c->read_queue_size = 0;
}
pthread_mutex_unlock(&c->read_queue_mutex);
if (c->total_bytes_read == 0)
{
/* the connection is now considered live */
pthread_mutex_lock(&usb_connections_mutex);
pthread_cond_signal(&usb_connection_added_cond);
pthread_mutex_unlock(&usb_connections_mutex);
}
c->total_bytes_read += (unsigned long)bytes_read;
}
}
if (result != kIOReturnAborted && c->opened && usb_run_loop)
{
if (result != kIOReturnSuccess)
{
LOG((PI_DBG_DEV, PI_DBG_LVL_ERR, "darwinusb: clearing input pipe stall\n"));
(*c->interface)->ClearPipeStallBothEnds (c->interface, c->in_pipe_ref);
}
prime_read(c);
}
change_refcount(c, -1);
}
static int
prime_read(usb_connection_t *c)
{
/* increment refcount */
if (pthread_mutex_lock(&c->ref_count_mutex) != 0)
{
/* c became invalid? */
LOG((PI_DBG_DEV, PI_DBG_LVL_ERR, "darwinusb: prime_read(%p): can't lock c->ref_count_mutex (structure freed?)\n", c));
return 0;
}
c->ref_count++;
pthread_mutex_unlock(&c->ref_count_mutex);
if (c->opened)
{
/* select a correct read size (always use a multiple of the USB packet size) */
if (c->vendorID == VENDOR_PALMONE && c->productID == PRODUCT_PALMCONNECT_USB)
{
/* with PalmConnect USB, always use 64 bytes */
c->last_read_ahead_size = 64;
}
else
{
c->last_read_ahead_size = c->read_ahead_size & ~(c->in_pipe_bulk_size-1);
if (c->last_read_ahead_size <= 0)
c->last_read_ahead_size = c->auto_read_size;
if (c->last_read_ahead_size > MAX_AUTO_READ_SIZE)
c->last_read_ahead_size = MAX_AUTO_READ_SIZE;
else if (c->last_read_ahead_size < c->in_pipe_bulk_size)
c->last_read_ahead_size = c->in_pipe_bulk_size; // USB packet size
}
ULOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "darwinusb: prime_read(%p) for %d bytes\n", c, c->last_read_ahead_size));
IOReturn kr = (*c->interface)->ReadPipeAsyncTO (c->interface, c->in_pipe_ref,
c->read_buffer, c->last_read_ahead_size, 5000, 5000, (IOAsyncCallback1)&read_completion, (void *)c);
if (kr == kIOUSBPipeStalled || kr == kIOUSBTransactionTimeout || kr == kIOUSBDataToggleErr)
{
// this code may be removed later as we are now using ReadPipeAsyncTO which is not
// supposed to return them (it calls the completion callback instead)
ULOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "darwinusb: stalled -- clearing stall and re-priming\n"));
(*c->interface)->ClearPipeStall (c->interface, c->in_pipe_ref);
kr = (*c->interface)->ReadPipeAsyncTO (c->interface, c->in_pipe_ref,
c->read_buffer, c->last_read_ahead_size, 5000, 5000, (IOAsyncCallback1)&read_completion, (void *)c);
}
if (kr == kIOReturnSuccess)
{
c->read_pending = 1;
return 1;
}
LOG((PI_DBG_DEV, PI_DBG_LVL_ERR, "darwinusb: prime_read(%p): ReadPipeAsync returned error 0x%08x\n", c, kr));
}
change_refcount(c, -1);
return 0;
}
static int
accepts_device(unsigned short vendor, unsigned short product, unsigned short *flags)
{
int i;
for (i=0; i < (int)(sizeof(acceptedDevices) / sizeof(acceptedDevices[0])); i++)
{
if (vendor == acceptedDevices[i].vendorID)
{
if (acceptedDevices[i].flags & FLAG_REJECT)
return 0;
if (acceptedDevices[i].productID == 0xffff || product == acceptedDevices[i].productID)
{
if (flags)
*flags = acceptedDevices[i].flags;
return 1;
}
}
}
return 0;
}
/***************************************************************************/
/* */
/* ENTRY POINTS CALLED BY LIBPISOCK */
/* */
/***************************************************************************/
static int
u_flush(pi_socket_t *ps, int flags)
{
usb_connection_t *c = ((pi_usb_data_t *)ps->device->data)->ref;
if (change_refcount(c, +1) <= 0)
return PI_ERR_SOCK_DISCONNECTED;
if (!c->opened)
{
change_refcount(c, -1);
return PI_ERR_SOCK_DISCONNECTED;
}
if (flags & PI_FLUSH_INPUT)
{
pthread_mutex_lock(&c->read_queue_mutex);
c->read_queue_used = 0;
pthread_mutex_unlock(&c->read_queue_mutex);
}
change_refcount(c, -1);
return 0;
}
static int
u_open(struct pi_socket *ps, struct pi_sockaddr *addr, size_t addrlen)
{
pthread_mutex_lock(&usb_thread_ready_mutex);
if (usb_thread == 0)
{
/* thread doesn't exist yet: create it and wait for
* the init phase to be either successful or failed
*/
pthread_create(&usb_thread, NULL, usb_thread_run, NULL);
pthread_cond_wait(&usb_thread_ready_cond, &usb_thread_ready_mutex);
pthread_mutex_unlock(&usb_thread_ready_mutex);
if (usb_thread != 0)
return 1;
errno = EINVAL;
return pi_set_error(ps->sd, PI_ERR_GENERIC_SYSTEM);
}
pthread_mutex_unlock(&usb_thread_ready_mutex);
return 1;
}
static int
u_close(struct pi_socket *ps)
{
usb_connection_t *c = ((pi_usb_data_t *)ps->device->data)->ref;
ULOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "darwinusb: u_close(ps=%p c=%p\n",ps,c));
if (c && change_refcount(c, 1) > 0)
{
// @@@ TODO: for KLSI, we should set total_bytes_read to 0 so that next time we receive data,
// @@@ a new connection is declared `live'
//if (c->vendorID == VENDOR_PALMONE && c->productID == PRODUCT_PALMCONNECT_USB)
// control_request(c->device, 0x40, KLSI_SET_HANDSHAKE_LINES, KLSI_SETHS_RTS, 0, NULL, 0);
c->opened = 0; /* set opened to 0 so that other threads don't try to acquire this connection, as it is on the way out */
c->total_bytes_read = 0;
c->total_bytes_written = 0;
c->ps = NULL;
change_refcount(c, -2); /* decrement current refcount + disconnect */
}
return close(ps->sd);
}
static int
u_wait_for_device(struct pi_socket *ps, int *timeout)
{
usb_connection_t *c = connection_for_socket(ps);
struct timespec to, to_expiration;
ULOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "darwinusb: u_wait_for_device(ps=%p c=%p, timeout=%d)\n",ps,c,timeout ? *timeout : 0));
if (timeout && *timeout)
{
pi_timeout_to_timespec(*timeout, &to_expiration);
to.tv_sec = *timeout / 1000;
to.tv_nsec = (*timeout % 1000) * 1000 * 1000;
}
if (c == NULL)
{
LOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "darwinusb: u_wait_for_device -> waiting for a connection to come up\n"));
pthread_mutex_lock(&usb_connections_mutex);
if (timeout && *timeout)
{
if (pthread_cond_timedwait_relative_np(&usb_connection_added_cond, &usb_connections_mutex, &to) == ETIMEDOUT)
// if (pthread_cond_timedwait(&usb_connection_added_cond, &usb_connections_mutex, &when) == ETIMEDOUT)
{
LOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "darwinusb: u_wait_for_device -> connection wait timed out\n"));
pthread_mutex_unlock(&usb_connections_mutex);
return PI_ERR_SOCK_TIMEOUT;
}
}
else
pthread_cond_wait(&usb_connection_added_cond, &usb_connections_mutex);
pthread_mutex_unlock(&usb_connections_mutex);
c = connection_for_socket(ps);
ULOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "darwinusb: u_wait_for_device -> end of wait, c=%p\n",c));
if (c && c->vendorID==VENDOR_PALMONE && c->productID==PRODUCT_PALMCONNECT_USB)
{
/* when working with a PalmConnect USB, make sure we use the right speed
* then let the adapter send us data
*/
klsi_set_portspeed(c->device, ((pi_usb_data_t *)ps->device->data)->rate);
}
if (timeout && *timeout)
{
/* if there was a timeout, compute the remaining timeout time */
*timeout = pi_timespec_to_timeout(&to_expiration);
}
}
return (c != NULL);
}
static int
u_poll(struct pi_socket *ps, int timeout)
{
usb_connection_t *c = connection_for_socket(ps);
if (c == NULL)
return PI_ERR_SOCK_DISCONNECTED;
struct timespec to;
ULOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "darwinusb: u_poll(ps=%p c=%p, timeout=%d)\n",ps,c,timeout));
if (timeout)
{
to.tv_sec = timeout / 1000;
to.tv_nsec = (timeout % 1000) * 1000 * 1000;
}
pthread_mutex_lock(&c->read_queue_mutex);
int available = c->read_queue_used;
if (!available)
{
ULOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "darwinusb: u_poll -> waiting data to be available for c=%p\n",c));
if (timeout)
{
if (pthread_cond_timedwait_relative_np(&c->read_queue_data_avail_cond, &c->read_queue_mutex, &to) == ETIMEDOUT)
{
ULOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "darwinusb: u_poll -> data wait timed out\n"));
available = PI_ERR_SOCK_TIMEOUT;
}
else
available = c->read_queue_used;
}
else
{
/* wait forever for some data to arrive */
pthread_cond_wait(&c->read_queue_data_avail_cond, &c->read_queue_mutex);
available = c->read_queue_used;
}
}
pthread_mutex_unlock(&c->read_queue_mutex);
change_refcount(c, -1);
ULOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "darwinusb: u_poll -> end, c=%p, result=%d\n",c,available));
return available;
}
static ssize_t
u_write(struct pi_socket *ps, const unsigned char *buf, size_t len, int flags)
{
IOReturn kr;
size_t transferred_bytes = 0,
data_size;
usb_connection_t *c = ((pi_usb_data_t *)ps->device->data)->ref;
if (change_refcount(c,+1)<=0 || !c->opened)
{
/* make sure we report broken connections */
if (ps->state == PI_SOCK_CONN_ACCEPT || ps->state == PI_SOCK_CONN_INIT)
ps->state = PI_SOCK_CONN_BREAK;
change_refcount(c, -1);
return PI_ERR_SOCK_DISCONNECTED;
}
ULOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "darwinusb: u_write(ps=%p, c=%p, len=%d, flags=%d)\n",ps,c,(int)len,flags));
if (c->vendorID == VENDOR_PALMONE && c->productID == PRODUCT_PALMCONNECT_USB)
{
/* format packets for the PalmConnect USB adapter */
unsigned char *packet = malloc(c->out_pipe_bulk_size);
if (packet == NULL)
return pi_set_error(ps->sd, PI_ERR_GENERIC_MEMORY);
while (len > 0)
{
data_size = len;
if (data_size > (size_t)(c->out_pipe_bulk_size - 2))
data_size = (size_t)(c->out_pipe_bulk_size - 2);
packet[0] = data_size;
packet[1] = data_size >> 8;
memcpy(&packet[2], &buf[transferred_bytes], data_size);
kr = (*c->interface)->WritePipeTO(c->interface, c->out_pipe_ref, packet, c->out_pipe_bulk_size, 5000, 5000);
if (kr != kIOReturnSuccess) {
LOG((PI_DBG_DEV, PI_DBG_LVL_ERR, "darwinusb: darwin_usb_write(): WritePipe returned kr=0x%08lx\n", kr));
break;
}
c->total_bytes_written += (unsigned long)data_size;
transferred_bytes += data_size;
len -= data_size;
}
free(packet);
}
else
{
kr = (*c->interface)->WritePipeTO(c->interface, c->out_pipe_ref, (void *)buf, len, 5000, 5000);
if (kr != kIOReturnSuccess)
{
LOG((PI_DBG_DEV, PI_DBG_LVL_ERR, "darwinusb: darwin_usb_write(): WritePipe returned kr=0x%08lx\n", kr));
}
else
{
c->total_bytes_written += (unsigned long)len;
transferred_bytes = len;
}
}
if (change_refcount(c, -1) <= 0)
return PI_ERR_SOCK_DISCONNECTED;
return transferred_bytes;
}
static ssize_t
u_read(struct pi_socket *ps, pi_buffer_t *buf, size_t len, int flags)
{
int timeout = ((struct pi_usb_data *)ps->device->data)->timeout;
int timed_out = 0;
usb_connection_t *c = ((pi_usb_data_t *)ps->device->data)->ref;
if (change_refcount(c,+1)<=0 || !c->opened)
{
/* make sure we report broken connections */
if (ps->state == PI_SOCK_CONN_ACCEPT || ps->state == PI_SOCK_CONN_INIT)
ps->state = PI_SOCK_CONN_BREAK;
if (c != NULL)
change_refcount(c, -1);
return PI_ERR_SOCK_DISCONNECTED;
}
if (pi_buffer_expect (buf, len) == NULL)
{
errno = ENOMEM;
change_refcount(c, -1);
return pi_set_error(ps->sd, PI_ERR_GENERIC_MEMORY);
}
#ifdef DEBUG_USB
struct timeval startTime, endTime;
gettimeofday(&startTime, NULL);
LOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "darwinusb: u_read(ps=%p, c=%p, len=%d, timeout=%d, flags=%d)\n", ps, c, (int)len, timeout, flags));
#endif
pthread_mutex_lock(&c->read_queue_mutex);
if (flags == PI_MSG_PEEK && len > 256)
len = 256;
if (c->read_queue_used < len)
{
struct timeval now;
struct timespec when;
gettimeofday(&now, NULL);
when.tv_sec = now.tv_sec + timeout / 1000;
when.tv_nsec = now.tv_usec + (timeout % 1000) * 1000 * 1000;
if (when.tv_nsec >= 1000000000)
{
when.tv_nsec -= 1000000000;
when.tv_sec++;
}
do
{
/* next prime_read() will use a bigger read request */
c->read_ahead_size = len - c->read_queue_used - c->last_read_ahead_size;
if (timeout)
{
if (pthread_cond_timedwait(&c->read_queue_data_avail_cond, &c->read_queue_mutex, &when) == ETIMEDOUT)
{
timed_out = 1;
break;
}
}
else
pthread_cond_wait(&c->read_queue_data_avail_cond, &c->read_queue_mutex);
}
while (c->opened && (c->read_queue_used < len || (flags == PI_MSG_PEEK && c->read_queue_used >= 256)));
c->read_ahead_size = 0;
}
if (!c->opened)
{
/* make sure we report broken connections */
if (ps->state == PI_SOCK_CONN_ACCEPT || ps->state == PI_SOCK_CONN_INIT)
ps->state = PI_SOCK_CONN_BREAK;
len = PI_ERR_SOCK_DISCONNECTED;
}
else
{
if (c->read_queue_used < len)
len = c->read_queue_used;
if (len)
{
pi_buffer_append (buf, c->read_queue, len);
if (flags != PI_MSG_PEEK)
{
c->read_queue_used -= len;
if (c->read_queue_used > 0)
memmove(c->read_queue, c->read_queue + len, c->read_queue_used);
if ((c->read_queue_size - c->read_queue_used) > (16L * 65535L))
{
/* if we have more than 1M free in the read queue, we'd better
* shrink the buffer
*/
c->read_queue_size = ((c->read_queue_used + 0xfffe) & ~0xffff) - 1;
c->read_queue = (char *) realloc (c->read_queue, c->read_queue_size);
}
}
}
else if (timed_out)
len = PI_ERR_SOCK_TIMEOUT;
}
#ifdef DEBUG_USB
double a,b;
gettimeofday(&endTime, NULL);
a = (double)startTime.tv_sec + (double)startTime.tv_usec / (double)1000000;
b = (double)endTime.tv_sec + (double)endTime.tv_usec / (double)1000000;
if (len >= 0) {
LOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "darwinusb: -> u_read complete (bytes_read=%d, remaining bytes in queue=%d) in %.06fs\n",
len, c->read_queue_used,b-a));
} else {
LOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "darwinusb: -> u_read end with error (err=%d) in %.06fs\n",
len,b-a));
}
#endif
pthread_mutex_unlock(&c->read_queue_mutex);
if (change_refcount(c, -1) <= 0)
len = PI_ERR_SOCK_DISCONNECTED;
return len;
}
static int
u_changebaud(pi_socket_t *ps)
{
/* Change the baud rate. This is only useful for serial-to-USB adapters,
* as these adapters need to know which rate we use to talk to the device.
* We currently only support the PalmConnect USB adapter.
*/
pi_usb_data_t *data = (pi_usb_data_t *)ps->device->data;
usb_connection_t *c = data->ref;
if (c == NULL)
return PI_ERR_SOCK_DISCONNECTED;
LOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "darwinusb: u_changebaud(ps=%p, c=%p, rate=%d)\n", ps, c, data->rate));
if (c->vendorID == VENDOR_PALMONE && c->productID == PRODUCT_PALMCONNECT_USB)
return klsi_set_portspeed(c->device, data->rate);
return 0;
}
void
pi_usb_impl_init (struct pi_usb_impl *impl)
{
impl->open = u_open;
impl->close = u_close;
impl->write = u_write;
impl->read = u_read;
impl->flush = u_flush;
impl->poll = u_poll;
impl->wait_for_device = u_wait_for_device;
impl->changebaud = u_changebaud;
impl->control_request = NULL; /* that is, until we factor out common code */
}
/* vi: set ts=8 sw=4 sts=4 noexpandtab: cin */
/* ex: set tabstop=4 expandtab: */
/* Local Variables: */
/* indent-tabs-mode: t */
/* c-basic-offset: 8 */
/* End: */
View Git Blame Copy Permalink