version 1.24, 2014/07/25 08:10:39 |
version 1.24.4.5, 2014/12/05 09:37:50 |
Line 38 __KERNEL_RCSID(0, "$NetBSD$"); |
|
Line 38 __KERNEL_RCSID(0, "$NetBSD$"); |
|
#include <sys/kernel.h> |
#include <sys/kernel.h> |
#include <sys/fcntl.h> |
#include <sys/fcntl.h> |
#include <sys/device.h> |
#include <sys/device.h> |
#include <sys/malloc.h> |
|
#include <sys/ioctl.h> |
#include <sys/ioctl.h> |
#include <sys/uio.h> |
#include <sys/uio.h> |
#include <sys/conf.h> |
#include <sys/conf.h> |
Line 202 int utoppy_activate(device_t |
|
Line 201 int utoppy_activate(device_t |
|
extern struct cfdriver utoppy_cd; |
extern struct cfdriver utoppy_cd; |
CFATTACH_DECL_NEW(utoppy, sizeof(struct utoppy_softc), utoppy_match, utoppy_attach, utoppy_detach, utoppy_activate); |
CFATTACH_DECL_NEW(utoppy, sizeof(struct utoppy_softc), utoppy_match, utoppy_attach, utoppy_detach, utoppy_activate); |
|
|
int |
int |
utoppy_match(device_t parent, cfdata_t match, void *aux) |
utoppy_match(device_t parent, cfdata_t match, void *aux) |
{ |
{ |
struct usb_attach_arg *uaa = aux; |
struct usb_attach_arg *uaa = aux; |
|
|
if (uaa->vendor == USB_VENDOR_TOPFIELD && |
if (uaa->vendor == USB_VENDOR_TOPFIELD && |
uaa->product == USB_PRODUCT_TOPFIELD_TF5000PVR) |
uaa->product == USB_PRODUCT_TOPFIELD_TF5000PVR) |
return (UMATCH_VENDOR_PRODUCT); |
return UMATCH_VENDOR_PRODUCT; |
|
|
return (UMATCH_NONE); |
return UMATCH_NONE; |
} |
} |
|
|
void |
void |
utoppy_attach(device_t parent, device_t self, void *aux) |
utoppy_attach(device_t parent, device_t self, void *aux) |
{ |
{ |
struct utoppy_softc *sc = device_private(self); |
struct utoppy_softc *sc = device_private(self); |
Line 223 utoppy_attach(device_t parent, device_t |
|
Line 222 utoppy_attach(device_t parent, device_t |
|
usbd_interface_handle iface; |
usbd_interface_handle iface; |
usb_endpoint_descriptor_t *ed; |
usb_endpoint_descriptor_t *ed; |
char *devinfop; |
char *devinfop; |
u_int8_t epcount; |
uint8_t epcount; |
int i; |
int i; |
|
|
sc->sc_dev = self; |
sc->sc_dev = self; |
Line 335 utoppy_activate(device_t self, enum deva |
|
Line 334 utoppy_activate(device_t self, enum deva |
|
} |
} |
} |
} |
|
|
int |
int |
utoppy_detach(device_t self, int flags) |
utoppy_detach(device_t self, int flags) |
{ |
{ |
struct utoppy_softc *sc = device_private(self); |
struct utoppy_softc *sc = device_private(self); |
Line 368 utoppy_detach(device_t self, int flags) |
|
Line 367 utoppy_detach(device_t self, int flags) |
|
usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev, |
usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev, |
sc->sc_dev); |
sc->sc_dev); |
|
|
return (0); |
return 0; |
} |
} |
|
|
static const uint16_t utoppy_crc16_lookup[] = { |
static const uint16_t utoppy_crc16_lookup[] = { |
Line 436 utoppy_usbd_status2errno(usbd_status err |
|
Line 435 utoppy_usbd_status2errno(usbd_status err |
|
{ |
{ |
|
|
if (err >= USBD_ERROR_MAX) |
if (err >= USBD_ERROR_MAX) |
return (EFAULT); |
return EFAULT; |
return (utoppy_usbdstatus_lookup[err]); |
return utoppy_usbdstatus_lookup[err]; |
} |
} |
|
|
#ifdef UTOPPY_DEBUG |
#ifdef UTOPPY_DEBUG |
Line 470 utoppy_state_string(enum utoppy_state st |
|
Line 469 utoppy_state_string(enum utoppy_state st |
|
break; |
break; |
} |
} |
|
|
return (str); |
return str; |
} |
} |
|
|
static void |
static void |
Line 524 utoppy_dump_packet(const void *b, size_t |
|
Line 523 utoppy_dump_packet(const void *b, size_t |
|
|
|
static usbd_status |
static usbd_status |
utoppy_bulk_transfer(usbd_xfer_handle xfer, usbd_pipe_handle pipe, |
utoppy_bulk_transfer(usbd_xfer_handle xfer, usbd_pipe_handle pipe, |
u_int16_t flags, u_int32_t timeout, void *buf, u_int32_t *size, |
uint16_t flags, uint32_t timeout, void *buf, uint32_t *size, |
const char *lbl) |
const char *lbl) |
{ |
{ |
usbd_status err; |
usbd_status err; |
Line 534 utoppy_bulk_transfer(usbd_xfer_handle xf |
|
Line 533 utoppy_bulk_transfer(usbd_xfer_handle xf |
|
err = usbd_sync_transfer_sig(xfer); |
err = usbd_sync_transfer_sig(xfer); |
|
|
usbd_get_xfer_status(xfer, NULL, NULL, size, NULL); |
usbd_get_xfer_status(xfer, NULL, NULL, size, NULL); |
return (err); |
return err; |
} |
} |
|
|
static int |
static int |
Line 562 utoppy_send_packet(struct utoppy_softc * |
|
Line 561 utoppy_send_packet(struct utoppy_softc * |
|
if (len >= UTOPPY_BSIZE) { |
if (len >= UTOPPY_BSIZE) { |
DPRINTF(UTOPPY_DBG_SEND_PACKET, ("%s: utoppy_send_packet: " |
DPRINTF(UTOPPY_DBG_SEND_PACKET, ("%s: utoppy_send_packet: " |
"packet too big (%d)\n", device_xname(sc->sc_dev), (int)len)); |
"packet too big (%d)\n", device_xname(sc->sc_dev), (int)len)); |
return (EINVAL); |
return EINVAL; |
} |
} |
|
|
h->h_len = htole16(dlen + UTOPPY_HEADER_SIZE); |
h->h_len = htole16(dlen + UTOPPY_HEADER_SIZE); |
Line 614 utoppy_send_packet(struct utoppy_softc * |
|
Line 613 utoppy_send_packet(struct utoppy_softc * |
|
memcpy(sc->sc_out_buf, data, thislen); |
memcpy(sc->sc_out_buf, data, thislen); |
|
|
err = utoppy_bulk_transfer(sc->sc_out_xfer, sc->sc_out_pipe, |
err = utoppy_bulk_transfer(sc->sc_out_xfer, sc->sc_out_pipe, |
USBD_NO_COPY, timeout, sc->sc_out_buf, &thislen, |
0, timeout, sc->sc_out_buf, &thislen, |
"utoppytx"); |
"utoppytx"); |
|
|
if (thislen != min(len, UTOPPY_FRAG_SIZE)) { |
if (thislen != min(len, UTOPPY_FRAG_SIZE)) { |
Line 632 utoppy_send_packet(struct utoppy_softc * |
|
Line 631 utoppy_send_packet(struct utoppy_softc * |
|
DPRINTF(UTOPPY_DBG_SEND_PACKET, ("%s: utoppy_send_packet: " |
DPRINTF(UTOPPY_DBG_SEND_PACKET, ("%s: utoppy_send_packet: " |
"usbd_bulk_transfer() returned %d.\n", device_xname(sc->sc_dev),err)); |
"usbd_bulk_transfer() returned %d.\n", device_xname(sc->sc_dev),err)); |
|
|
return (err ? utoppy_usbd_status2errno(err) : 0); |
return err ? utoppy_usbd_status2errno(err) : 0; |
} |
} |
|
|
static int |
static int |
Line 655 utoppy_recv_packet(struct utoppy_softc * |
|
Line 654 utoppy_recv_packet(struct utoppy_softc * |
|
requested = thislen = min(bytesleft, UTOPPY_FRAG_SIZE); |
requested = thislen = min(bytesleft, UTOPPY_FRAG_SIZE); |
|
|
err = utoppy_bulk_transfer(sc->sc_in_xfer, sc->sc_in_pipe, |
err = utoppy_bulk_transfer(sc->sc_in_xfer, sc->sc_in_pipe, |
USBD_NO_COPY | USBD_SHORT_XFER_OK, timeout, sc->sc_in_buf, |
USBD_SHORT_XFER_OK, timeout, sc->sc_in_buf, |
&thislen, "utoppyrx"); |
&thislen, "utoppyrx"); |
|
|
DPRINTF(UTOPPY_DBG_RECV_PACKET, ("%s: utoppy_recv_packet: " |
DPRINTF(UTOPPY_DBG_RECV_PACKET, ("%s: utoppy_recv_packet: " |
Line 672 utoppy_recv_packet(struct utoppy_softc * |
|
Line 671 utoppy_recv_packet(struct utoppy_softc * |
|
} while (err == 0 && bytesleft && thislen == requested); |
} while (err == 0 && bytesleft && thislen == requested); |
|
|
if (err) |
if (err) |
return (utoppy_usbd_status2errno(err)); |
return utoppy_usbd_status2errno(err); |
|
|
h = sc->sc_in_data; |
h = sc->sc_in_data; |
|
|
Line 684 utoppy_recv_packet(struct utoppy_softc * |
|
Line 683 utoppy_recv_packet(struct utoppy_softc * |
|
DPRINTF(UTOPPY_DBG_RECV_PACKET, ("%s: utoppy_recv_packet: bad " |
DPRINTF(UTOPPY_DBG_RECV_PACKET, ("%s: utoppy_recv_packet: bad " |
" length (len %d, h_len %d)\n", device_xname(sc->sc_dev), |
" length (len %d, h_len %d)\n", device_xname(sc->sc_dev), |
(int)len, le16toh(h->h_len))); |
(int)len, le16toh(h->h_len))); |
return (EIO); |
return EIO; |
} |
} |
|
|
len = h->h_len = le16toh(h->h_len); |
len = h->h_len = le16toh(h->h_len); |
Line 708 utoppy_recv_packet(struct utoppy_softc * |
|
Line 707 utoppy_recv_packet(struct utoppy_softc * |
|
DPRINTF(UTOPPY_DBG_RECV_PACKET, ("%s: " |
DPRINTF(UTOPPY_DBG_RECV_PACKET, ("%s: " |
"utoppy_recv_packet: failed to ACK file data: %d\n", |
"utoppy_recv_packet: failed to ACK file data: %d\n", |
device_xname(sc->sc_dev), err)); |
device_xname(sc->sc_dev), err)); |
return (err); |
return err; |
} |
} |
} |
} |
|
|
Line 750 utoppy_recv_packet(struct utoppy_softc * |
|
Line 749 utoppy_recv_packet(struct utoppy_softc * |
|
(int)len, crc, h->h_crc)); |
(int)len, crc, h->h_crc)); |
DDUMP_PACKET(h, len); |
DDUMP_PACKET(h, len); |
|
|
return ((crc == h->h_crc) ? 0 : EBADMSG); |
return (crc == h->h_crc) ? 0 : EBADMSG; |
} |
} |
|
|
static __inline void * |
static __inline void * |
Line 758 utoppy_current_ptr(void *b) |
|
Line 757 utoppy_current_ptr(void *b) |
|
{ |
{ |
struct utoppy_header *h = b; |
struct utoppy_header *h = b; |
|
|
return (&h->h_data[h->h_len]); |
return &h->h_data[h->h_len]; |
} |
} |
|
|
static __inline void |
static __inline void |
Line 854 utoppy_add_path(struct utoppy_softc *sc, |
|
Line 853 utoppy_add_path(struct utoppy_softc *sc, |
|
err, (int)len)); |
err, (int)len)); |
|
|
if (err) |
if (err) |
return (err); |
return err; |
|
|
if (len < 2) |
if (len < 2) |
return (EINVAL); |
return EINVAL; |
|
|
/* |
/* |
* copyinstr(9) has already copied the terminating NUL character, |
* copyinstr(9) has already copied the terminating NUL character, |
Line 885 utoppy_add_path(struct utoppy_softc *sc, |
|
Line 884 utoppy_add_path(struct utoppy_softc *sc, |
|
DPRINTF(UTOPPY_DBG_ADDPATH, ("utoppy_add_path: final len %d\n", |
DPRINTF(UTOPPY_DBG_ADDPATH, ("utoppy_add_path: final len %d\n", |
(u_int)len)); |
(u_int)len)); |
|
|
return (0); |
return 0; |
} |
} |
|
|
static __inline int |
static __inline int |
Line 894 utoppy_get_8(struct utoppy_softc *sc, ui |
|
Line 893 utoppy_get_8(struct utoppy_softc *sc, ui |
|
uint8_t *p; |
uint8_t *p; |
|
|
if (sc->sc_in_len < sizeof(*vp)) |
if (sc->sc_in_len < sizeof(*vp)) |
return (1); |
return 1; |
|
|
p = UTOPPY_IN_DATA(sc); |
p = UTOPPY_IN_DATA(sc); |
*vp = *p; |
*vp = *p; |
sc->sc_in_offset += sizeof(*vp); |
sc->sc_in_offset += sizeof(*vp); |
sc->sc_in_len -= sizeof(*vp); |
sc->sc_in_len -= sizeof(*vp); |
return (0); |
return 0; |
} |
} |
|
|
static __inline int |
static __inline int |
Line 910 utoppy_get_16(struct utoppy_softc *sc, u |
|
Line 909 utoppy_get_16(struct utoppy_softc *sc, u |
|
uint8_t *p; |
uint8_t *p; |
|
|
if (sc->sc_in_len < sizeof(v)) |
if (sc->sc_in_len < sizeof(v)) |
return (1); |
return 1; |
|
|
p = UTOPPY_IN_DATA(sc); |
p = UTOPPY_IN_DATA(sc); |
v = *p++; |
v = *p++; |
Line 918 utoppy_get_16(struct utoppy_softc *sc, u |
|
Line 917 utoppy_get_16(struct utoppy_softc *sc, u |
|
*vp = v; |
*vp = v; |
sc->sc_in_offset += sizeof(v); |
sc->sc_in_offset += sizeof(v); |
sc->sc_in_len -= sizeof(v); |
sc->sc_in_len -= sizeof(v); |
return (0); |
return 0; |
} |
} |
|
|
static __inline int |
static __inline int |
Line 928 utoppy_get_32(struct utoppy_softc *sc, u |
|
Line 927 utoppy_get_32(struct utoppy_softc *sc, u |
|
uint8_t *p; |
uint8_t *p; |
|
|
if (sc->sc_in_len < sizeof(v)) |
if (sc->sc_in_len < sizeof(v)) |
return (1); |
return 1; |
|
|
p = UTOPPY_IN_DATA(sc); |
p = UTOPPY_IN_DATA(sc); |
v = *p++; |
v = *p++; |
Line 938 utoppy_get_32(struct utoppy_softc *sc, u |
|
Line 937 utoppy_get_32(struct utoppy_softc *sc, u |
|
*vp = v; |
*vp = v; |
sc->sc_in_offset += sizeof(v); |
sc->sc_in_offset += sizeof(v); |
sc->sc_in_len -= sizeof(v); |
sc->sc_in_len -= sizeof(v); |
return (0); |
return 0; |
} |
} |
|
|
static __inline int |
static __inline int |
Line 948 utoppy_get_64(struct utoppy_softc *sc, u |
|
Line 947 utoppy_get_64(struct utoppy_softc *sc, u |
|
uint8_t *p; |
uint8_t *p; |
|
|
if (sc->sc_in_len < sizeof(v)) |
if (sc->sc_in_len < sizeof(v)) |
return (1); |
return 1; |
|
|
p = UTOPPY_IN_DATA(sc); |
p = UTOPPY_IN_DATA(sc); |
v = *p++; |
v = *p++; |
Line 962 utoppy_get_64(struct utoppy_softc *sc, u |
|
Line 961 utoppy_get_64(struct utoppy_softc *sc, u |
|
*vp = v; |
*vp = v; |
sc->sc_in_offset += sizeof(v); |
sc->sc_in_offset += sizeof(v); |
sc->sc_in_len -= sizeof(v); |
sc->sc_in_len -= sizeof(v); |
return (0); |
return 0; |
} |
} |
|
|
static __inline int |
static __inline int |
Line 971 utoppy_get_string(struct utoppy_softc *s |
|
Line 970 utoppy_get_string(struct utoppy_softc *s |
|
char *p; |
char *p; |
|
|
if (sc->sc_in_len < len) |
if (sc->sc_in_len < len) |
return (1); |
return 1; |
|
|
memset(str, 0, len); |
memset(str, 0, len); |
p = UTOPPY_IN_DATA(sc); |
p = UTOPPY_IN_DATA(sc); |
strncpy(str, p, len); |
strncpy(str, p, len); |
sc->sc_in_offset += len; |
sc->sc_in_offset += len; |
sc->sc_in_len -= len; |
sc->sc_in_len -= len; |
return (0); |
return 0; |
} |
} |
|
|
static int |
static int |
Line 989 utoppy_command(struct utoppy_softc *sc, |
|
Line 988 utoppy_command(struct utoppy_softc *sc, |
|
|
|
err = utoppy_send_packet(sc, cmd, timeout); |
err = utoppy_send_packet(sc, cmd, timeout); |
if (err) |
if (err) |
return (err); |
return err; |
|
|
err = utoppy_recv_packet(sc, presp, timeout); |
err = utoppy_recv_packet(sc, presp, timeout); |
if (err == EBADMSG) { |
if (err == EBADMSG) { |
Line 997 utoppy_command(struct utoppy_softc *sc, |
|
Line 996 utoppy_command(struct utoppy_softc *sc, |
|
utoppy_send_packet(sc, UTOPPY_RESP_ERROR, timeout); |
utoppy_send_packet(sc, UTOPPY_RESP_ERROR, timeout); |
} |
} |
|
|
return (err); |
return err; |
} |
} |
|
|
static int |
static int |
Line 1009 utoppy_timestamp_decode(struct utoppy_so |
|
Line 1008 utoppy_timestamp_decode(struct utoppy_so |
|
|
|
if (utoppy_get_16(sc, &mjd) || utoppy_get_8(sc, &hour) || |
if (utoppy_get_16(sc, &mjd) || utoppy_get_8(sc, &hour) || |
utoppy_get_8(sc, &minute) || utoppy_get_8(sc, &sec)) |
utoppy_get_8(sc, &minute) || utoppy_get_8(sc, &sec)) |
return (1); |
return 1; |
|
|
if (mjd == 0xffffu && hour == 0xffu && minute == 0xffu && sec == 0xffu){ |
if (mjd == 0xffffu && hour == 0xffu && minute == 0xffu && sec == 0xffu){ |
*tp = 0; |
*tp = 0; |
return (0); |
return 0; |
} |
} |
|
|
rv = (mjd < UTOPPY_MJD_1970) ? UTOPPY_MJD_1970 : (uint32_t) mjd; |
rv = (mjd < UTOPPY_MJD_1970) ? UTOPPY_MJD_1970 : (uint32_t) mjd; |
Line 1027 utoppy_timestamp_decode(struct utoppy_so |
|
Line 1026 utoppy_timestamp_decode(struct utoppy_so |
|
rv += sec; |
rv += sec; |
*tp = (time_t)rv; |
*tp = (time_t)rv; |
|
|
return (0); |
return 0; |
} |
} |
|
|
static void |
static void |
Line 1061 utoppy_turbo_mode(struct utoppy_softc *s |
|
Line 1060 utoppy_turbo_mode(struct utoppy_softc *s |
|
|
|
err = utoppy_command(sc, UTOPPY_CMD_TURBO, UTOPPY_SHORT_TIMEOUT, &r); |
err = utoppy_command(sc, UTOPPY_CMD_TURBO, UTOPPY_SHORT_TIMEOUT, &r); |
if (err) |
if (err) |
return (err); |
return err; |
|
|
return ((r == UTOPPY_RESP_SUCCESS) ? 0 : EIO); |
return (r == UTOPPY_RESP_SUCCESS) ? 0 : EIO; |
} |
} |
|
|
static int |
static int |
Line 1076 utoppy_check_ready(struct utoppy_softc * |
|
Line 1075 utoppy_check_ready(struct utoppy_softc * |
|
|
|
err = utoppy_command(sc, UTOPPY_CMD_READY, UTOPPY_LONG_TIMEOUT, &r); |
err = utoppy_command(sc, UTOPPY_CMD_READY, UTOPPY_LONG_TIMEOUT, &r); |
if (err) |
if (err) |
return (err); |
return err; |
|
|
return ((r == UTOPPY_RESP_SUCCESS) ? 0 : EIO); |
return (r == UTOPPY_RESP_SUCCESS) ? 0 : EIO; |
} |
} |
|
|
static int |
static int |
Line 1101 utoppy_cancel(struct utoppy_softc *sc) |
|
Line 1100 utoppy_cancel(struct utoppy_softc *sc) |
|
} |
} |
|
|
if (err) |
if (err) |
return (err); |
return err; |
|
|
/* |
/* |
* Make sure turbo mode is off, otherwise the Toppy will not |
* Make sure turbo mode is off, otherwise the Toppy will not |
Line 1110 utoppy_cancel(struct utoppy_softc *sc) |
|
Line 1109 utoppy_cancel(struct utoppy_softc *sc) |
|
(void) utoppy_turbo_mode(sc, 0); |
(void) utoppy_turbo_mode(sc, 0); |
|
|
sc->sc_state = UTOPPY_STATE_IDLE; |
sc->sc_state = UTOPPY_STATE_IDLE; |
return (0); |
return 0; |
} |
} |
|
|
static int |
static int |
Line 1123 utoppy_stats(struct utoppy_softc *sc, st |
|
Line 1122 utoppy_stats(struct utoppy_softc *sc, st |
|
UTOPPY_OUT_INIT(sc); |
UTOPPY_OUT_INIT(sc); |
err = utoppy_command(sc, UTOPPY_CMD_STATS, UTOPPY_LONG_TIMEOUT, &r); |
err = utoppy_command(sc, UTOPPY_CMD_STATS, UTOPPY_LONG_TIMEOUT, &r); |
if (err) |
if (err) |
return (err); |
return err; |
|
|
if (r != UTOPPY_RESP_STATS_DATA) |
if (r != UTOPPY_RESP_STATS_DATA) |
return (EIO); |
return EIO; |
|
|
if (utoppy_get_32(sc, &hsize) || utoppy_get_32(sc, &hfree)) |
if (utoppy_get_32(sc, &hsize) || utoppy_get_32(sc, &hfree)) |
return (EIO); |
return EIO; |
|
|
us->us_hdd_size = hsize; |
us->us_hdd_size = hsize; |
us->us_hdd_size *= 1024; |
us->us_hdd_size *= 1024; |
us->us_hdd_free = hfree; |
us->us_hdd_free = hfree; |
us->us_hdd_free *= 1024; |
us->us_hdd_free *= 1024; |
|
|
return (0); |
return 0; |
} |
} |
|
|
static int |
static int |
Line 1162 utoppy_readdir_next(struct utoppy_softc |
|
Line 1161 utoppy_readdir_next(struct utoppy_softc |
|
UTOPPY_LONG_TIMEOUT); |
UTOPPY_LONG_TIMEOUT); |
} |
} |
utoppy_cancel(sc); |
utoppy_cancel(sc); |
return (err); |
return err; |
} |
} |
|
|
DPRINTF(UTOPPY_DBG_READDIR, ("%s: utoppy_readdir_next: " |
DPRINTF(UTOPPY_DBG_READDIR, ("%s: utoppy_readdir_next: " |
Line 1182 utoppy_readdir_next(struct utoppy_softc |
|
Line 1181 utoppy_readdir_next(struct utoppy_softc |
|
"utoppy_send_packet(ACK) returned %d\n", |
"utoppy_send_packet(ACK) returned %d\n", |
device_xname(sc->sc_dev), err)); |
device_xname(sc->sc_dev), err)); |
utoppy_cancel(sc); |
utoppy_cancel(sc); |
return (err); |
return err; |
} |
} |
sc->sc_state = UTOPPY_STATE_READDIR; |
sc->sc_state = UTOPPY_STATE_READDIR; |
sc->sc_in_offset = 0; |
sc->sc_in_offset = 0; |
Line 1203 utoppy_readdir_next(struct utoppy_softc |
|
Line 1202 utoppy_readdir_next(struct utoppy_softc |
|
"bad response: 0x%x\n", device_xname(sc->sc_dev), resp)); |
"bad response: 0x%x\n", device_xname(sc->sc_dev), resp)); |
sc->sc_state = UTOPPY_STATE_IDLE; |
sc->sc_state = UTOPPY_STATE_IDLE; |
sc->sc_in_len = 0; |
sc->sc_in_len = 0; |
return (EIO); |
return EIO; |
} |
} |
|
|
return (0); |
return 0; |
} |
} |
|
|
static size_t |
static size_t |
Line 1223 utoppy_readdir_decode(struct utoppy_soft |
|
Line 1222 utoppy_readdir_decode(struct utoppy_soft |
|
utoppy_get_32(sc, &ud->ud_attributes)) { |
utoppy_get_32(sc, &ud->ud_attributes)) { |
DPRINTF(UTOPPY_DBG_READDIR, ("%s: utoppy_readdir_decode: no " |
DPRINTF(UTOPPY_DBG_READDIR, ("%s: utoppy_readdir_decode: no " |
"more to decode\n", device_xname(sc->sc_dev))); |
"more to decode\n", device_xname(sc->sc_dev))); |
return (0); |
return 0; |
} |
} |
|
|
switch (ftype) { |
switch (ftype) { |
Line 1244 utoppy_readdir_decode(struct utoppy_soft |
|
Line 1243 utoppy_readdir_decode(struct utoppy_soft |
|
((ftype == UTOPPY_FTYPE_FILE) ? "FILE" : "UNKNOWN"), ud->ud_path, |
((ftype == UTOPPY_FTYPE_FILE) ? "FILE" : "UNKNOWN"), ud->ud_path, |
ud->ud_size, (u_long)ud->ud_mtime, ud->ud_attributes)); |
ud->ud_size, (u_long)ud->ud_mtime, ud->ud_attributes)); |
|
|
return (1); |
return 1; |
} |
} |
|
|
static int |
static int |
Line 1260 utoppy_readfile_next(struct utoppy_softc |
|
Line 1259 utoppy_readfile_next(struct utoppy_softc |
|
"utoppy_recv_packet() returned %d\n", |
"utoppy_recv_packet() returned %d\n", |
device_xname(sc->sc_dev), err)); |
device_xname(sc->sc_dev), err)); |
utoppy_cancel(sc); |
utoppy_cancel(sc); |
return (err); |
return err; |
} |
} |
|
|
switch (resp) { |
switch (resp) { |
Line 1274 utoppy_readfile_next(struct utoppy_softc |
|
Line 1273 utoppy_readfile_next(struct utoppy_softc |
|
"utoppy_send_packet(UTOPPY_CMD_ACK) returned %d\n", |
"utoppy_send_packet(UTOPPY_CMD_ACK) returned %d\n", |
device_xname(sc->sc_dev), err)); |
device_xname(sc->sc_dev), err)); |
utoppy_cancel(sc); |
utoppy_cancel(sc); |
return (err); |
return err; |
} |
} |
|
|
sc->sc_in_len = 0; |
sc->sc_in_len = 0; |
Line 1289 utoppy_readfile_next(struct utoppy_softc |
|
Line 1288 utoppy_readfile_next(struct utoppy_softc |
|
"UTOPPY_RESP_FILE_DATA did not provide offset\n", |
"UTOPPY_RESP_FILE_DATA did not provide offset\n", |
device_xname(sc->sc_dev))); |
device_xname(sc->sc_dev))); |
utoppy_cancel(sc); |
utoppy_cancel(sc); |
return (EBADMSG); |
return EBADMSG; |
} |
} |
|
|
DPRINTF(UTOPPY_DBG_READ, ("%s: utoppy_readfile_next: " |
DPRINTF(UTOPPY_DBG_READ, ("%s: utoppy_readfile_next: " |
Line 1317 utoppy_readfile_next(struct utoppy_softc |
|
Line 1316 utoppy_readfile_next(struct utoppy_softc |
|
DPRINTF(UTOPPY_DBG_READ, ("%s: utoppy_readfile_next: bad " |
DPRINTF(UTOPPY_DBG_READ, ("%s: utoppy_readfile_next: bad " |
"response code 0x%0x\n", device_xname(sc->sc_dev), resp)); |
"response code 0x%0x\n", device_xname(sc->sc_dev), resp)); |
utoppy_cancel(sc); |
utoppy_cancel(sc); |
return (EIO); |
return EIO; |
} |
} |
|
|
return (0); |
return 0; |
} |
} |
|
|
int |
int |
Line 1335 utoppyopen(dev_t dev, int flag, int mode |
|
Line 1334 utoppyopen(dev_t dev, int flag, int mode |
|
return ENXIO; |
return ENXIO; |
|
|
if (sc == NULL || sc->sc_iface == NULL || sc->sc_dying) |
if (sc == NULL || sc->sc_iface == NULL || sc->sc_dying) |
return (ENXIO); |
return ENXIO; |
|
|
if (sc->sc_state != UTOPPY_STATE_CLOSED) { |
if (sc->sc_state != UTOPPY_STATE_CLOSED) { |
DPRINTF(UTOPPY_DBG_OPEN, ("%s: utoppyopen: already open\n", |
DPRINTF(UTOPPY_DBG_OPEN, ("%s: utoppyopen: already open\n", |
device_xname(sc->sc_dev))); |
device_xname(sc->sc_dev))); |
return (EBUSY); |
return EBUSY; |
} |
} |
|
|
DPRINTF(UTOPPY_DBG_OPEN, ("%s: utoppyopen: opening...\n", |
DPRINTF(UTOPPY_DBG_OPEN, ("%s: utoppyopen: opening...\n", |
Line 1368 utoppyopen(dev_t dev, int flag, int mode |
|
Line 1367 utoppyopen(dev_t dev, int flag, int mode |
|
goto done; |
goto done; |
} |
} |
|
|
sc->sc_out_data = malloc(UTOPPY_BSIZE + 1, M_DEVBUF, M_WAITOK); |
sc->sc_out_data = kmem_alloc(UTOPPY_BSIZE + 1, KM_SLEEP); |
if (sc->sc_out_data == NULL) { |
if (sc->sc_out_data == NULL) { |
error = ENOMEM; |
error = ENOMEM; |
goto error; |
goto error; |
} |
} |
|
|
sc->sc_in_data = malloc(UTOPPY_BSIZE + 1, M_DEVBUF, M_WAITOK); |
sc->sc_in_data = kmem_alloc(UTOPPY_BSIZE + 1, KM_SLEEP); |
if (sc->sc_in_data == NULL) { |
if (sc->sc_in_data == NULL) { |
free(sc->sc_out_data, M_DEVBUF); |
kmem_free(sc->sc_out_data, UTOPPY_BSIZE + 1); |
sc->sc_out_data = NULL; |
sc->sc_out_data = NULL; |
error = ENOMEM; |
error = ENOMEM; |
goto error; |
goto error; |
Line 1407 utoppyopen(dev_t dev, int flag, int mode |
|
Line 1406 utoppyopen(dev_t dev, int flag, int mode |
|
if (--sc->sc_refcnt < 0) |
if (--sc->sc_refcnt < 0) |
usb_detach_wakeupold(sc->sc_dev); |
usb_detach_wakeupold(sc->sc_dev); |
|
|
return (error); |
return error; |
} |
} |
|
|
int |
int |
Line 1427 utoppyclose(dev_t dev, int flag, int mod |
|
Line 1426 utoppyclose(dev_t dev, int flag, int mod |
|
DPRINTF(UTOPPY_DBG_CLOSE, ("%s: utoppyclose: not properly open:" |
DPRINTF(UTOPPY_DBG_CLOSE, ("%s: utoppyclose: not properly open:" |
" %s\n", device_xname(sc->sc_dev), |
" %s\n", device_xname(sc->sc_dev), |
utoppy_state_string(sc->sc_state))); |
utoppy_state_string(sc->sc_state))); |
return (0); |
return 0; |
} |
} |
|
|
if (sc->sc_out_data) |
if (sc->sc_out_data) |
Line 1450 utoppyclose(dev_t dev, int flag, int mod |
|
Line 1449 utoppyclose(dev_t dev, int flag, int mod |
|
} |
} |
|
|
if (sc->sc_out_data) { |
if (sc->sc_out_data) { |
free(sc->sc_out_data, M_DEVBUF); |
kmem_free(sc->sc_out_data, UTOPPY_BSIZE + 1); |
sc->sc_out_data = NULL; |
sc->sc_out_data = NULL; |
} |
} |
|
|
if (sc->sc_in_data) { |
if (sc->sc_in_data) { |
free(sc->sc_in_data, M_DEVBUF); |
kmem_free(sc->sc_in_data, UTOPPY_BSIZE + 1); |
sc->sc_in_data = NULL; |
sc->sc_in_data = NULL; |
} |
} |
|
|
Line 1464 utoppyclose(dev_t dev, int flag, int mod |
|
Line 1463 utoppyclose(dev_t dev, int flag, int mod |
|
DPRINTF(UTOPPY_DBG_CLOSE, ("%s: utoppyclose: done.\n", |
DPRINTF(UTOPPY_DBG_CLOSE, ("%s: utoppyclose: done.\n", |
device_xname(sc->sc_dev))); |
device_xname(sc->sc_dev))); |
|
|
return (0); |
return 0; |
} |
} |
|
|
int |
int |
Line 1478 utoppyread(dev_t dev, struct uio *uio, i |
|
Line 1477 utoppyread(dev_t dev, struct uio *uio, i |
|
sc = device_lookup_private(&utoppy_cd, UTOPPYUNIT(dev)); |
sc = device_lookup_private(&utoppy_cd, UTOPPYUNIT(dev)); |
|
|
if (sc->sc_dying) |
if (sc->sc_dying) |
return (EIO); |
return EIO; |
|
|
sc->sc_refcnt++; |
sc->sc_refcnt++; |
|
|
Line 1494 utoppyread(dev_t dev, struct uio *uio, i |
|
Line 1493 utoppyread(dev_t dev, struct uio *uio, i |
|
err = utoppy_readdir_next(sc); |
err = utoppy_readdir_next(sc); |
else |
else |
if ((err = uiomove(&ud, sizeof(ud), uio)) != 0) |
if ((err = uiomove(&ud, sizeof(ud), uio)) != 0) |
utoppy_cancel(sc); |
utoppy_cancel(sc); |
} |
} |
break; |
break; |
|
|
Line 1545 utoppyread(dev_t dev, struct uio *uio, i |
|
Line 1544 utoppyread(dev_t dev, struct uio *uio, i |
|
if (--sc->sc_refcnt < 0) |
if (--sc->sc_refcnt < 0) |
usb_detach_wakeupold(sc->sc_dev); |
usb_detach_wakeupold(sc->sc_dev); |
|
|
return (err); |
return err; |
} |
} |
|
|
int |
int |
Line 1559 utoppywrite(dev_t dev, struct uio *uio, |
|
Line 1558 utoppywrite(dev_t dev, struct uio *uio, |
|
sc = device_lookup_private(&utoppy_cd, UTOPPYUNIT(dev)); |
sc = device_lookup_private(&utoppy_cd, UTOPPYUNIT(dev)); |
|
|
if (sc->sc_dying) |
if (sc->sc_dying) |
return (EIO); |
return EIO; |
|
|
switch(sc->sc_state) { |
switch(sc->sc_state) { |
case UTOPPY_STATE_WRITEFILE: |
case UTOPPY_STATE_WRITEFILE: |
break; |
break; |
|
|
case UTOPPY_STATE_IDLE: |
case UTOPPY_STATE_IDLE: |
return (0); |
return 0; |
|
|
default: |
default: |
return (EIO); |
return EIO; |
} |
} |
|
|
sc->sc_refcnt++; |
sc->sc_refcnt++; |
Line 1648 utoppywrite(dev_t dev, struct uio *uio, |
|
Line 1647 utoppywrite(dev_t dev, struct uio *uio, |
|
if (--sc->sc_refcnt < 0) |
if (--sc->sc_refcnt < 0) |
usb_detach_wakeupold(sc->sc_dev); |
usb_detach_wakeupold(sc->sc_dev); |
|
|
return (err); |
return err; |
} |
} |
|
|
int |
int |
Line 1666 utoppyioctl(dev_t dev, u_long cmd, void |
|
Line 1665 utoppyioctl(dev_t dev, u_long cmd, void |
|
sc = device_lookup_private(&utoppy_cd, UTOPPYUNIT(dev)); |
sc = device_lookup_private(&utoppy_cd, UTOPPYUNIT(dev)); |
|
|
if (sc->sc_dying) |
if (sc->sc_dying) |
return (EIO); |
return EIO; |
|
|
DPRINTF(UTOPPY_DBG_IOCTL, ("%s: utoppyioctl: cmd 0x%08lx, state '%s'\n", |
DPRINTF(UTOPPY_DBG_IOCTL, ("%s: utoppyioctl: cmd 0x%08lx, state '%s'\n", |
device_xname(sc->sc_dev), cmd, utoppy_state_string(sc->sc_state))); |
device_xname(sc->sc_dev), cmd, utoppy_state_string(sc->sc_state))); |
Line 1674 utoppyioctl(dev_t dev, u_long cmd, void |
|
Line 1673 utoppyioctl(dev_t dev, u_long cmd, void |
|
if (sc->sc_state != UTOPPY_STATE_IDLE && cmd != UTOPPYIOCANCEL) { |
if (sc->sc_state != UTOPPY_STATE_IDLE && cmd != UTOPPYIOCANCEL) { |
DPRINTF(UTOPPY_DBG_IOCTL, ("%s: utoppyioctl: still busy.\n", |
DPRINTF(UTOPPY_DBG_IOCTL, ("%s: utoppyioctl: still busy.\n", |
device_xname(sc->sc_dev))); |
device_xname(sc->sc_dev))); |
return (EBUSY); |
return EBUSY; |
} |
} |
|
|
sc->sc_refcnt++; |
sc->sc_refcnt++; |
Line 1913 utoppyioctl(dev_t dev, u_long cmd, void |
|
Line 1912 utoppyioctl(dev_t dev, u_long cmd, void |
|
if (--sc->sc_refcnt < 0) |
if (--sc->sc_refcnt < 0) |
usb_detach_wakeupold(sc->sc_dev); |
usb_detach_wakeupold(sc->sc_dev); |
|
|
return (err); |
return err; |
} |
} |