自学教程：C++ usb_bulk_msg函数代码示例

/* * Synchronous write to the device * * Takes care of updating EDC counts and thus, handle device errors. */staticssize_t i2400mu_tx_bulk_out(struct i2400mu *i2400mu, void *buf, size_t buf_size){	int result;	struct device *dev = &i2400mu->usb_iface->dev;	int len;	struct usb_endpoint_descriptor *epd;	int pipe, do_autopm = 1;	result = usb_autopm_get_interface(i2400mu->usb_iface);	if (result < 0) {		dev_err(dev, "BM-CMD: can't get autopm: %d/n", result);		do_autopm = 0;	}	epd = usb_get_epd(i2400mu->usb_iface, i2400mu->endpoint_cfg.bulk_out);	pipe = usb_sndbulkpipe(i2400mu->usb_dev, epd->bEndpointAddress);retry:	result = usb_bulk_msg(i2400mu->usb_dev, pipe, buf, buf_size, &len, 200);	switch (result) {	case 0:		if (len != buf_size) {			dev_err(dev, "BM-CMD: short write (%u B vs %zu "				"expected)/n", len, buf_size);			result = -EIO;			break;		}		result = len;		break;	case -EPIPE:		/*		 * Stall -- maybe the device is choking with our		 * requests. Clear it and give it some time. If they		 * happen to often, it might be another symptom, so we		 * reset.		 *		 * No error handling for usb_clear_halt(0; if it		 * works, the retry works; if it fails, this switch		 * does the error handling for us.		 */		if (edc_inc(&i2400mu->urb_edc,			    10 * EDC_MAX_ERRORS, EDC_ERROR_TIMEFRAME)) {			dev_err(dev, "BM-CMD: too many stalls in "				"URB; resetting device/n");			usb_queue_reset_device(i2400mu->usb_iface);			/* fallthrough */		} else {			usb_clear_halt(i2400mu->usb_dev, pipe);			msleep(10);	/* give the device some time */			goto retry;		}	case -EINVAL:			/* while removing driver */	case -ENODEV:			/* dev disconnect ... */	case -ENOENT:			/* just ignore it */	case -ESHUTDOWN:		/* and exit */	case -ECONNRESET:		result = -ESHUTDOWN;		break;	case -ETIMEDOUT:			/* bah... */		break;	default:				/* any other? */		if (edc_inc(&i2400mu->urb_edc,			    EDC_MAX_ERRORS, EDC_ERROR_TIMEFRAME)) {				dev_err(dev, "BM-CMD: maximum errors in "					"URB exceeded; resetting device/n");				usb_queue_reset_device(i2400mu->usb_iface);				result = -ENODEV;				break;		}		dev_err(dev, "BM-CMD: URB error %d, retrying/n",			result);		goto retry;	}	if (do_autopm)		usb_autopm_put_interface(i2400mu->usb_iface);	return result;}

/* * Sends a barker buffer to the device * * This helper will allocate a kmalloced buffer and use it to transmit * (then free it). Reason for this is that other arches cannot use * stack/vmalloc/text areas for DMA transfers. * * Error recovery here is simpler: anything is considered a hard error * and will move the reset code to use a last-resort bus-based reset. */staticint __i2400mu_send_barker(struct i2400mu *i2400mu,			  const __le32 *barker,			  size_t barker_size,			  unsigned endpoint){	struct usb_endpoint_descriptor *epd = NULL;	int pipe, actual_len, ret;	struct device *dev = &i2400mu->usb_iface->dev;	void *buffer;	int do_autopm = 1;	ret = usb_autopm_get_interface(i2400mu->usb_iface);	if (ret < 0) {		dev_err(dev, "RESET: can't get autopm: %d/n", ret);		do_autopm = 0;	}	ret = -ENOMEM;	buffer = kmalloc(barker_size, GFP_KERNEL);	if (buffer == NULL)		goto error_kzalloc;	epd = usb_get_epd(i2400mu->usb_iface, endpoint);	pipe = usb_sndbulkpipe(i2400mu->usb_dev, epd->bEndpointAddress);	memcpy(buffer, barker, barker_size);retry:	ret = usb_bulk_msg(i2400mu->usb_dev, pipe, buffer, barker_size,			   &actual_len, 200);	switch (ret) {	case 0:		if (actual_len != barker_size) {	/* Too short? drop it */			dev_err(dev, "E: %s: short write (%d B vs %zu "				"expected)/n",				__func__, actual_len, barker_size);			ret = -EIO;		}		break;	case -EPIPE:		/*		 * Stall -- maybe the device is choking with our		 * requests. Clear it and give it some time. If they		 * happen to often, it might be another symptom, so we		 * reset.		 *		 * No error handling for usb_clear_halt(0; if it		 * works, the retry works; if it fails, this switch		 * does the error handling for us.		 */		if (edc_inc(&i2400mu->urb_edc,			    10 * EDC_MAX_ERRORS, EDC_ERROR_TIMEFRAME)) {			dev_err(dev, "E: %s: too many stalls in "				"URB; resetting device/n", __func__);			usb_queue_reset_device(i2400mu->usb_iface);			/* fallthrough */		} else {			usb_clear_halt(i2400mu->usb_dev, pipe);			msleep(10);	/* give the device some time */			goto retry;		}	case -EINVAL:			/* while removing driver */	case -ENODEV:			/* dev disconnect ... */	case -ENOENT:			/* just ignore it */	case -ESHUTDOWN:		/* and exit */	case -ECONNRESET:		ret = -ESHUTDOWN;		break;	default:			/* Some error? */		if (edc_inc(&i2400mu->urb_edc,			    EDC_MAX_ERRORS, EDC_ERROR_TIMEFRAME)) {			dev_err(dev, "E: %s: maximum errors in URB "				"exceeded; resetting device/n",				__func__);			usb_queue_reset_device(i2400mu->usb_iface);		} else {			dev_warn(dev, "W: %s: cannot send URB: %d/n",				 __func__, ret);			goto retry;		}	}	kfree(buffer);error_kzalloc:	if (do_autopm)		usb_autopm_put_interface(i2400mu->usb_iface);	return ret;}

/* * Get the next TX message in the TX FIFO and send it to the device * * Note that any iteration consumes a message to be sent, no matter if * it succeeds or fails (we have no real way to retry or complain). * * Return: 0 if ok, < 0 errno code on hard error. */staticint i2400mu_tx(struct i2400mu *i2400mu, struct i2400m_msg_hdr *tx_msg,	       size_t tx_msg_size){	int result = 0;	struct i2400m *i2400m = &i2400mu->i2400m;	struct device *dev = &i2400mu->usb_iface->dev;	int usb_pipe, sent_size, do_autopm;	struct usb_endpoint_descriptor *epd;	d_fnstart(4, dev, "(i2400mu %p)/n", i2400mu);	do_autopm = atomic_read(&i2400mu->do_autopm);	result = do_autopm ?		usb_autopm_get_interface(i2400mu->usb_iface) : 0;	if (result < 0) {		dev_err(dev, "TX: can't get autopm: %d/n", result);		do_autopm = 0;	}	epd = usb_get_epd(i2400mu->usb_iface, i2400mu->endpoint_cfg.bulk_out);	usb_pipe = usb_sndbulkpipe(i2400mu->usb_dev, epd->bEndpointAddress);retry:	result = usb_bulk_msg(i2400mu->usb_dev, usb_pipe,			      tx_msg, tx_msg_size, &sent_size, 200);	usb_mark_last_busy(i2400mu->usb_dev);	switch (result) {	case 0:		if (sent_size != tx_msg_size) {	/* Too short? drop it */			dev_err(dev, "TX: short write (%d B vs %zu "				"expected)/n", sent_size, tx_msg_size);			result = -EIO;		}		break;	case -EPIPE:		/*		 * Stall -- maybe the device is choking with our		 * requests. Clear it and give it some time. If they		 * happen to often, it might be another symptom, so we		 * reset.		 *		 * No error handling for usb_clear_halt(0; if it		 * works, the retry works; if it fails, this switch		 * does the error handling for us.		 */		if (edc_inc(&i2400mu->urb_edc,			    10 * EDC_MAX_ERRORS, EDC_ERROR_TIMEFRAME)) {			dev_err(dev, "BM-CMD: too many stalls in "				"URB; resetting device/n");			usb_queue_reset_device(i2400mu->usb_iface);			/* fallthrough */		} else {			usb_clear_halt(i2400mu->usb_dev, usb_pipe);			msleep(10);	/* give the device some time */			goto retry;		}	case -EINVAL:			/* while removing driver */	case -ENODEV:			/* dev disconnect ... */	case -ENOENT:			/* just ignore it */	case -ESHUTDOWN:		/* and exit */	case -ECONNRESET:		result = -ESHUTDOWN;		break;	default:			/* Some error? */		if (edc_inc(&i2400mu->urb_edc,			    EDC_MAX_ERRORS, EDC_ERROR_TIMEFRAME)) {			dev_err(dev, "TX: maximum errors in URB "				"exceeded; resetting device/n");			usb_queue_reset_device(i2400mu->usb_iface);		} else {			dev_err(dev, "TX: cannot send URB; retrying. "				"tx_msg @%zu %zu B [%d sent]: %d/n",				(void *) tx_msg - i2400m->tx_buf,				tx_msg_size, sent_size, result);			goto retry;		}	}	if (do_autopm)		usb_autopm_put_interface(i2400mu->usb_iface);	d_fnend(4, dev, "(i2400mu %p) = result/n", i2400mu);	return result;}

/* * Receive a message with payloads from the USB bus into an skb * * @i2400mu: USB device descriptor * @rx_skb: skb where to place the received message * * Deals with all the USB-specifics of receiving, dynamically * increasing the buffer size if so needed. Returns the payload in the * skb, ready to process. On a zero-length packet, we retry. * * On soft USB errors, we retry (until they become too frequent and * then are promoted to hard); on hard USB errors, we reset the * device. On other errors (skb realloacation, we just drop it and * hope for the next invocation to solve it). * * Returns: pointer to the skb if ok, ERR_PTR on error. *   NOTE: this function might realloc the skb (if it is too small), *   so always update with the one returned. *   ERR_PTR() is < 0 on error. *   Will return NULL if it cannot reallocate -- this can be *   considered a transient retryable error. */staticstruct sk_buff *i2400mu_rx(struct i2400mu *i2400mu, struct sk_buff *rx_skb){	int result = 0;	struct device *dev = &i2400mu->usb_iface->dev;	int usb_pipe, read_size, rx_size, do_autopm;	struct usb_endpoint_descriptor *epd;	const size_t max_pkt_size = 512;	d_fnstart(4, dev, "(i2400mu %p)/n", i2400mu);	do_autopm = atomic_read(&i2400mu->do_autopm);	result = do_autopm ?		usb_autopm_get_interface(i2400mu->usb_iface) : 0;	if (result < 0) {		dev_err(dev, "RX: can't get autopm: %d/n", result);		do_autopm = 0;	}	epd = usb_get_epd(i2400mu->usb_iface, i2400mu->endpoint_cfg.bulk_in);	usb_pipe = usb_rcvbulkpipe(i2400mu->usb_dev, epd->bEndpointAddress);retry:	rx_size = skb_end_pointer(rx_skb) - rx_skb->data - rx_skb->len;	if (unlikely(rx_size % max_pkt_size == 0)) {		rx_size -= 8;		d_printf(1, dev, "RX: rx_size adapted to %d [-8]/n", rx_size);	}	result = usb_bulk_msg(		i2400mu->usb_dev, usb_pipe, rx_skb->data + rx_skb->len,		rx_size, &read_size, 200);	usb_mark_last_busy(i2400mu->usb_dev);	switch (result) {	case 0:		if (read_size == 0)			goto retry;	/* ZLP, just resubmit */		skb_put(rx_skb, read_size);		break;	case -EPIPE:		/*		 * Stall -- maybe the device is choking with our		 * requests. Clear it and give it some time. If they		 * happen to often, it might be another symptom, so we		 * reset.		 *		 * No error handling for usb_clear_halt(0; if it		 * works, the retry works; if it fails, this switch		 * does the error handling for us.		 */		if (edc_inc(&i2400mu->urb_edc,			    10 * EDC_MAX_ERRORS, EDC_ERROR_TIMEFRAME)) {			dev_err(dev, "BM-CMD: too many stalls in "				"URB; resetting device/n");			goto do_reset;		}		usb_clear_halt(i2400mu->usb_dev, usb_pipe);		msleep(10);	/* give the device some time */		goto retry;	case -EINVAL:			/* while removing driver */	case -ENODEV:			/* dev disconnect ... */	case -ENOENT:			/* just ignore it */	case -ESHUTDOWN:	case -ECONNRESET:		break;	case -EOVERFLOW: {		/* too small, reallocate */		struct sk_buff *new_skb;		rx_size = i2400mu_rx_size_grow(i2400mu);		if (rx_size <= (1 << 16))	/* cap it */			i2400mu->rx_size = rx_size;		else if (printk_ratelimit()) {			dev_err(dev, "BUG? rx_size up to %d/n", rx_size);			result = -EINVAL;			goto out;		}		skb_put(rx_skb, read_size);		new_skb = skb_copy_expand(rx_skb, 0, rx_size - rx_skb->len,					  GFP_KERNEL);		if (new_skb == NULL) {			if (printk_ratelimit())				dev_err(dev, "RX: Can't reallocate skb to %d; "					"RX dropped/n", rx_size);//.........这里部分代码省略.........

static int usbtmc_ioctl_clear(struct usbtmc_device_data *data){	struct usb_host_interface *current_setting;	struct usb_endpoint_descriptor *desc;	struct device *dev;	u8 *buffer;	int rv;	int n;	int actual = 0;	int max_size;	dev = &data->intf->dev;	dev_dbg(dev, "Sending INITIATE_CLEAR request/n");	buffer = kmalloc(USBTMC_SIZE_IOBUFFER, GFP_KERNEL);	if (!buffer)		return -ENOMEM;	rv = usb_control_msg(data->usb_dev,			     usb_rcvctrlpipe(data->usb_dev, 0),			     USBTMC_REQUEST_INITIATE_CLEAR,			     USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,			     0, 0, buffer, 1, USBTMC_TIMEOUT);	if (rv < 0) {		dev_err(dev, "usb_control_msg returned %d/n", rv);		goto exit;	}	dev_dbg(dev, "INITIATE_CLEAR returned %x/n", buffer[0]);	if (buffer[0] != USBTMC_STATUS_SUCCESS) {		dev_err(dev, "INITIATE_CLEAR returned %x/n", buffer[0]);		rv = -EPERM;		goto exit;	}	max_size = 0;	current_setting = data->intf->cur_altsetting;	for (n = 0; n < current_setting->desc.bNumEndpoints; n++) {		desc = &current_setting->endpoint[n].desc;		if (desc->bEndpointAddress == data->bulk_in)			max_size = usb_endpoint_maxp(desc);	}	if (max_size == 0) {		dev_err(dev, "Couldn't get wMaxPacketSize/n");		rv = -EPERM;		goto exit;	}	dev_dbg(dev, "wMaxPacketSize is %d/n", max_size);	n = 0;usbtmc_clear_check_status:	dev_dbg(dev, "Sending CHECK_CLEAR_STATUS request/n");	rv = usb_control_msg(data->usb_dev,			     usb_rcvctrlpipe(data->usb_dev, 0),			     USBTMC_REQUEST_CHECK_CLEAR_STATUS,			     USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,			     0, 0, buffer, 2, USBTMC_TIMEOUT);	if (rv < 0) {		dev_err(dev, "usb_control_msg returned %d/n", rv);		goto exit;	}	dev_dbg(dev, "CHECK_CLEAR_STATUS returned %x/n", buffer[0]);	if (buffer[0] == USBTMC_STATUS_SUCCESS)		goto usbtmc_clear_bulk_out_halt;	if (buffer[0] != USBTMC_STATUS_PENDING) {		dev_err(dev, "CHECK_CLEAR_STATUS returned %x/n", buffer[0]);		rv = -EPERM;		goto exit;	}	if (buffer[1] == 1)		do {			dev_dbg(dev, "Reading from bulk in EP/n");			rv = usb_bulk_msg(data->usb_dev,					  usb_rcvbulkpipe(data->usb_dev,							  data->bulk_in),					  buffer, USBTMC_SIZE_IOBUFFER,					  &actual, USBTMC_TIMEOUT);			n++;			if (rv < 0) {				dev_err(dev, "usb_control_msg returned %d/n",					rv);				goto exit;			}		} while ((actual == max_size) &&			  (n < USBTMC_MAX_READS_TO_CLEAR_BULK_IN));	if (actual == max_size) {//.........这里部分代码省略.........

static ssize_twrite_rio(struct file *file, const char __user *buffer,	  size_t count, loff_t * ppos){	DEFINE_WAIT(wait);	struct rio_usb_data *rio = &rio_instance;	unsigned long copy_size;	unsigned long bytes_written = 0;	unsigned int partial;	int result = 0;	int maxretry;	int errn = 0;	int intr;	intr = mutex_lock_interruptible(&(rio->lock));	if (intr)		return -EINTR;        /* Sanity check to make sure rio is connected, powered, etc */        if (rio->present == 0 || rio->rio_dev == NULL) {		mutex_unlock(&(rio->lock));		return -ENODEV;	}	do {		unsigned long thistime;		char *obuf = rio->obuf;		thistime = copy_size =		    (count >= OBUF_SIZE) ? OBUF_SIZE : count;		if (copy_from_user(rio->obuf, buffer, copy_size)) {			errn = -EFAULT;			goto error;		}		maxretry = 5;		while (thistime) {			if (!rio->rio_dev) {				errn = -ENODEV;				goto error;			}			if (signal_pending(current)) {				mutex_unlock(&(rio->lock));				return bytes_written ? bytes_written : -EINTR;			}			result = usb_bulk_msg(rio->rio_dev,					 usb_sndbulkpipe(rio->rio_dev, 2),					 obuf, thistime, &partial, 5000);			dbg("write stats: result:%d thistime:%lu partial:%u",			     result, thistime, partial);			if (result == -ETIMEDOUT) {	/* NAK - so hold for a while */				if (!maxretry--) {					errn = -ETIME;					goto error;				}				prepare_to_wait(&rio->wait_q, &wait, TASK_INTERRUPTIBLE);				schedule_timeout(NAK_TIMEOUT);				finish_wait(&rio->wait_q, &wait);				continue;			} else if (!result && partial) {				obuf += partial;				thistime -= partial;			} else				break;		};		if (result) {			err("Write Whoops - %x", result);			errn = -EIO;			goto error;		}		bytes_written += copy_size;		count -= copy_size;		buffer += copy_size;	} while (count > 0);	mutex_unlock(&(rio->lock));	return bytes_written ? bytes_written : -EIO;error:	mutex_unlock(&(rio->lock));	return errn;}

static ssize_t bladerf_write(struct file *file, const char *user_buf, size_t count, loff_t *ppos){    bladerf_device_t *dev;    unsigned long flags;    char *buf = NULL;    struct data_buffer *db = NULL;    unsigned int idx;    int reread;    int status = 0;    /* TODO truncate count to be within range of ssize_t here? */    dev = (bladerf_device_t *)file->private_data;    if (dev->intnum == 0) {        int llen;        buf = (char *)kmalloc(count, GFP_KERNEL);        if (buf) {            if (copy_from_user(buf, user_buf, count)) {                status = -EFAULT;            } else {                status = usb_bulk_msg(dev->udev, usb_sndbulkpipe(dev->udev, 2), buf, count, &llen, BLADE_USB_TIMEOUT_MS);            }            kfree(buf);        } else {            dev_err(&dev->interface->dev, "Failed to allocate write buffer/n");            status = -ENOMEM;        }        if (status < 0)            return status;        else            return llen;    }    if (dev->writer) {        if (file != dev->writer) {            return -EPERM;        }    } else        dev->writer = file;    reread = atomic_read(&dev->data_out_used);    if (reread >= NUM_DATA_URB) {        status = wait_event_interruptible_timeout(dev->data_out_wait, atomic_read(&dev->data_out_used) < NUM_DATA_URB, 2 * HZ);        if (status < 0) {            return status;        } else if (status == 0) {            return -ETIMEDOUT;        }    }    spin_lock_irqsave(&dev->data_out_lock, flags);    idx = dev->data_out_producer_idx++;    dev->data_out_producer_idx &= (NUM_DATA_URB - 1);    db = &dev->data_out_bufs[idx];    atomic_inc(&dev->data_out_cnt);    atomic_inc(&dev->data_out_used);    spin_unlock_irqrestore(&dev->data_out_lock, flags);    if (copy_from_user(db->addr, user_buf, count)) {        return -EFAULT;    }    db->valid = 1; // mark this TX packet as having valid data    __submit_tx_urb(dev);    if (!dev->tx_en)        enable_tx(dev);    return count;}

//.........这里部分代码省略.........        case BLADE_RF_TX:            if (dev->intnum != 1) {                dev_err(&dev->interface->dev, "Cannot enable TX from config mode/n");                retval = -1;                break;            }            printk("RF_TX!/n");            retval = __bladerf_snd_one_word(dev, BLADE_USB_CMD_RF_TX, data);            break;        case BLADE_LMS_WRITE:        case BLADE_LMS_READ:        case BLADE_SI5338_WRITE:        case BLADE_SI5338_READ:        case BLADE_GPIO_WRITE:        case BLADE_GPIO_READ:        case BLADE_VCTCXO_WRITE:            if (copy_from_user(&spi_reg, (void __user *)arg, sizeof(struct uart_cmd))) {                retval = -EFAULT;                break;            }            nread = count = 16;            memset(buf, 0, 20);            buf[0] = 'N';            targetdev = UART_PKT_DEV_SI5338;            if (cmd == BLADE_GPIO_WRITE || cmd == BLADE_GPIO_READ)                targetdev = UART_PKT_DEV_GPIO;            if (cmd == BLADE_LMS_WRITE || cmd == BLADE_LMS_READ)                targetdev = UART_PKT_DEV_LMS;            if (cmd == BLADE_VCTCXO_WRITE)                targetdev = UART_PKT_DEV_VCTCXO;            if (cmd == BLADE_LMS_WRITE || cmd == BLADE_GPIO_WRITE || cmd == BLADE_SI5338_WRITE || cmd == BLADE_VCTCXO_WRITE) {                buf[1] = UART_PKT_MODE_DIR_WRITE | targetdev | 0x01;                buf[2] = spi_reg.addr;                buf[3] = spi_reg.data;            } else if (cmd == BLADE_LMS_READ || cmd == BLADE_GPIO_READ || cmd == BLADE_SI5338_READ) {                buf[1] = UART_PKT_MODE_DIR_READ | targetdev | 0x01;                buf[2] = spi_reg.addr;                buf[3] = 0xff;            }            retval = usb_bulk_msg(dev->udev, usb_sndbulkpipe(dev->udev, 2), buf, count, &nread, BLADE_USB_TIMEOUT_MS);            if (!retval) {                memset(buf, 0, 20);                tries = 3;                do {                    retval = usb_bulk_msg(dev->udev, usb_rcvbulkpipe(dev->udev, 0x82), buf, count, &nread, BLADE_USB_TIMEOUT_MS);                } while(retval == -ETIMEDOUT && tries--);                if (!retval) {                    spi_reg.addr = buf[2];                    spi_reg.data = buf[3];                }                if (copy_to_user((void __user *)arg, &spi_reg, sizeof(struct uart_cmd))) {                    retval = -EFAULT;                } else {                    retval = 0;                }            }            break;        case BLADE_GET_SPEED:            ret = dev->udev->speed == USB_SPEED_SUPER;            if (copy_to_user((void __user *)arg, &ret, sizeof(ret))) {                retval = -EFAULT;            } else {                retval = 0;            }            break;        case BLADE_GET_ADDR:            ret = dev->udev->devnum;            if (copy_to_user((void __user *)arg, &ret, sizeof(ret))) {                retval = -EFAULT;            } else {                retval = 0;            }            break;        case BLADE_GET_BUS:            ret = dev->udev->bus->busnum;            if (copy_to_user((void __user *)arg, &ret, sizeof(ret))) {                retval = -EFAULT;            } else {                retval = 0;            }            break;    }    return retval;}

static int p54u_upload_firmware_3887(struct ieee80211_hw *dev){	static char start_string[] = "~~~~</r";	struct p54u_priv *priv = dev->priv;	const struct firmware *fw_entry = NULL;	int err, alen;	u8 carry = 0;	u8 *buf, *tmp, *data;	unsigned int left, remains, block_size;	struct x2_header *hdr;	unsigned long timeout;	tmp = buf = kmalloc(P54U_FW_BLOCK, GFP_KERNEL);	if (!buf) {		printk(KERN_ERR "p54usb: cannot allocate firmware upload buffer!/n");		err = -ENOMEM;		goto err_bufalloc;	}	memcpy(buf, start_string, 4);	err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, 4);	if (err) {		printk(KERN_ERR "p54usb: reset failed! (%d)/n", err);		goto err_reset;	}	err = request_firmware(&fw_entry, "isl3887usb_bare", &priv->udev->dev);	if (err) {		printk(KERN_ERR "p54usb: cannot find firmware (isl3887usb_bare)!/n");		goto err_req_fw_failed;	}	p54_parse_firmware(dev, fw_entry);	left = block_size = min((size_t)P54U_FW_BLOCK, fw_entry->size);	strcpy(buf, start_string);	left -= strlen(start_string);	tmp += strlen(start_string);	data = fw_entry->data;	remains = fw_entry->size;	hdr = (struct x2_header *)(buf + strlen(start_string));	memcpy(hdr->signature, X2_SIGNATURE, X2_SIGNATURE_SIZE);	hdr->fw_load_addr = cpu_to_le32(ISL38XX_DEV_FIRMWARE_ADDR);	hdr->fw_length = cpu_to_le32(fw_entry->size);	hdr->crc = cpu_to_le32(~crc32_le(~0, (void *)&hdr->fw_load_addr,					 sizeof(u32)*2));	left -= sizeof(*hdr);	tmp += sizeof(*hdr);	while (remains) {		while (left--) {			if (carry) {				*tmp++ = carry;				carry = 0;				remains--;				continue;			}			switch (*data) {			case '~':				*tmp++ = '}';				carry = '^';				break;			case '}':				*tmp++ = '}';				carry = ']';				break;			default:				*tmp++ = *data;				remains--;				break;			}			data++;		}		err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, block_size);		if (err) {			printk(KERN_ERR "prism54usb: firmware upload failed!/n");			goto err_upload_failed;		}		tmp = buf;		left = block_size = min((unsigned int)P54U_FW_BLOCK, remains);	}	*((__le32 *)buf) = cpu_to_le32(~crc32_le(~0, fw_entry->data, fw_entry->size));	err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, sizeof(u32));	if (err) {		printk(KERN_ERR "prism54usb: firmware upload failed!/n");		goto err_upload_failed;	}	timeout = jiffies + msecs_to_jiffies(1000);	while (!(err = usb_bulk_msg(priv->udev,		usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA), buf, 128, &alen, 1000))) {		if (alen > 2 && !memcmp(buf, "OK", 2))			break;		if (alen > 5 && !memcmp(buf, "ERROR", 5)) {//.........这里部分代码省略.........

static int p54u_read_eeprom(struct ieee80211_hw *dev){	struct p54u_priv *priv = dev->priv;	void *buf;	struct p54_control_hdr *hdr;	int err, alen;	size_t offset = priv->hw_type ? 0x10 : 0x20;	buf = kmalloc(0x2020, GFP_KERNEL);	if (!buf) {		printk(KERN_ERR "prism54usb: cannot allocate memory for "		       "eeprom readback!/n");		return -ENOMEM;	}	if (priv->hw_type) {		*((u32 *) buf) = priv->common.rx_start;		err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, sizeof(u32));		if (err) {			printk(KERN_ERR "prism54usb: addr send failed/n");			goto fail;		}	} else {		struct net2280_reg_write *reg = buf;		reg->port = cpu_to_le16(NET2280_DEV_U32);		reg->addr = cpu_to_le32(P54U_DEV_BASE);		reg->val = cpu_to_le32(ISL38XX_DEV_INT_DATA);		err = p54u_bulk_msg(priv, P54U_PIPE_DEV, buf, sizeof(*reg));		if (err) {			printk(KERN_ERR "prism54usb: dev_int send failed/n");			goto fail;		}	}	hdr = buf + priv->common.tx_hdr_len;	p54_fill_eeprom_readback(hdr);	hdr->req_id = cpu_to_le32(priv->common.rx_start);	if (priv->common.tx_hdr_len) {		struct net2280_tx_hdr *tx_hdr = buf;		tx_hdr->device_addr = hdr->req_id;		tx_hdr->len = cpu_to_le16(EEPROM_READBACK_LEN);	}	/* we can just pretend to send 0x2000 bytes of nothing in the headers */	err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf,			    EEPROM_READBACK_LEN + priv->common.tx_hdr_len);	if (err) {		printk(KERN_ERR "prism54usb: eeprom req send failed/n");		goto fail;	}	err = usb_bulk_msg(priv->udev,			   usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA),			   buf, 0x2020, &alen, 1000);	if (!err && alen > offset) {		p54_parse_eeprom(dev, (u8 *)buf + offset, alen - offset);	} else {		printk(KERN_ERR "prism54usb: eeprom read failed!/n");		err = -EINVAL;		goto fail;	} fail:	kfree(buf);	return err;}

static ssize_t camera_write (struct file *file,	const char *buf, size_t len, loff_t *ppos){	struct camera_state	*camera;	ssize_t			bytes_written = 0;	if (len > MAX_PACKET_SIZE)		return -EINVAL;	camera = (struct camera_state *) file->private_data;	down (&camera->sem);	if (!camera->dev) {		up (&camera->sem);		return -ENODEV;	}		/* most writes will be small: simple commands, sometimes with	 * parameters.  putting images (like borders) into the camera	 * would be the main use of big writes.	 */	while (len > 0) {		char		*obuf = camera->buf;		int		maxretry = MAX_WRITE_RETRY;		unsigned long	copy_size, thistime;		/* it's not clear that retrying can do any good ... or that		 * fragmenting application packets into N writes is correct.		 */		thistime = copy_size = len;		if (copy_from_user (obuf, buf, copy_size)) {			bytes_written = -EFAULT;			break;		}		while (thistime) {			int		result;			int		count;			if (signal_pending (current)) {				if (!bytes_written)					bytes_written = -EINTR;				goto done;			}			result = usb_bulk_msg (camera->dev,				 usb_sndbulkpipe (camera->dev, camera->outEP),				 obuf, thistime, &count, HZ*10);			if (result)				dbg ("write USB err - %d", result);			if (count) {				obuf += count;				thistime -= count;				maxretry = MAX_WRITE_RETRY;				continue;			} else if (!result)				break;							if (result == -ETIMEDOUT) {	/* NAK - delay a bit */				if (!maxretry--) {					if (!bytes_written)						bytes_written = -ETIME;					goto done;				}                                interruptible_sleep_on_timeout (&camera->wait,					RETRY_TIMEOUT);				continue;			} 			if (!bytes_written)				bytes_written = -EIO;			goto done;		}		bytes_written += copy_size;		len -= copy_size;		buf += copy_size;	}done:	up (&camera->sem);	dbg ("wrote %Zd", bytes_written); 	return bytes_written;}

static ssize_t usbtmc_read(struct file *filp, char __user *buf,			   size_t count, loff_t *f_pos){	struct usbtmc_device_data *data;	struct device *dev;	u32 n_characters;	u8 *buffer;	int actual;	size_t done;	size_t remaining;	int retval;	size_t this_part;	/* Get pointer to private data structure */	data = filp->private_data;	dev = &data->intf->dev;	buffer = kmalloc(USBTMC_SIZE_IOBUFFER, GFP_KERNEL);	if (!buffer)		return -ENOMEM;	mutex_lock(&data->io_mutex);	if (data->zombie) {		retval = -ENODEV;		goto exit;	}	if (data->rigol_quirk) {		dev_dbg(dev, "usb_bulk_msg_in: count(%zu)/n", count);		retval = send_request_dev_dep_msg_in(data, count);		if (retval < 0) {			if (data->auto_abort)				usbtmc_ioctl_abort_bulk_out(data);			goto exit;		}	}	/* Loop until we have fetched everything we requested */	remaining = count;	this_part = remaining;	done = 0;	while (remaining > 0) {		if (!data->rigol_quirk) {			dev_dbg(dev, "usb_bulk_msg_in: remaining(%zu), count(%zu)/n", remaining, count);			if (remaining > USBTMC_SIZE_IOBUFFER - USBTMC_HEADER_SIZE - 3)				this_part = USBTMC_SIZE_IOBUFFER - USBTMC_HEADER_SIZE - 3;			else				this_part = remaining;			retval = send_request_dev_dep_msg_in(data, this_part);			if (retval < 0) {			dev_err(dev, "usb_bulk_msg returned %d/n", retval);				if (data->auto_abort)					usbtmc_ioctl_abort_bulk_out(data);				goto exit;			}		}		/* Send bulk URB */		retval = usb_bulk_msg(data->usb_dev,				      usb_rcvbulkpipe(data->usb_dev,						      data->bulk_in),				      buffer, USBTMC_SIZE_IOBUFFER, &actual,				      USBTMC_TIMEOUT);		dev_dbg(dev, "usb_bulk_msg: retval(%u), done(%zu), remaining(%zu), actual(%d)/n", retval, done, remaining, actual);		/* Store bTag (in case we need to abort) */		data->bTag_last_read = data->bTag;		if (retval < 0) {			dev_dbg(dev, "Unable to read data, error %d/n", retval);			if (data->auto_abort)				usbtmc_ioctl_abort_bulk_in(data);			goto exit;		}		/* Parse header in first packet */		if ((done == 0) || !data->rigol_quirk) {			/* Sanity checks for the header */			if (actual < USBTMC_HEADER_SIZE) {				dev_err(dev, "Device sent too small first packet: %u < %u/n", actual, USBTMC_HEADER_SIZE);				if (data->auto_abort)					usbtmc_ioctl_abort_bulk_in(data);				goto exit;			}			if (buffer[0] != 2) {				dev_err(dev, "Device sent reply with wrong MsgID: %u != 2/n", buffer[0]);				if (data->auto_abort)					usbtmc_ioctl_abort_bulk_in(data);				goto exit;			}			if (buffer[1] != data->bTag_last_write) {				dev_err(dev, "Device sent reply with wrong bTag: %u != %u/n", buffer[1], data->bTag_last_write);//.........这里部分代码省略.........

int zd_usb_ioread16v(struct zd_usb *usb, u16 *values,                     const zd_addr_t *addresses, unsigned int count){    int r;    int i, req_len, actual_req_len;    struct usb_device *udev;    struct usb_req_read_regs *req = NULL;    unsigned long timeout;    if (count < 1) {        dev_dbg_f(zd_usb_dev(usb), "error: count is zero/n");        return -EINVAL;    }    if (count > USB_MAX_IOREAD16_COUNT) {        dev_dbg_f(zd_usb_dev(usb),                  "error: count %u exceeds possible max %u/n",                  count, USB_MAX_IOREAD16_COUNT);        return -EINVAL;    }    if (in_atomic()) {        dev_dbg_f(zd_usb_dev(usb),                  "error: io in atomic context not supported/n");        return -EWOULDBLOCK;    }    if (!usb_int_enabled(usb)) {        dev_dbg_f(zd_usb_dev(usb),                  "error: usb interrupt not enabled/n");        return -EWOULDBLOCK;    }    req_len = sizeof(struct usb_req_read_regs) + count * sizeof(__le16);    req = kmalloc(req_len, GFP_KERNEL);    if (!req)        return -ENOMEM;    req->id = cpu_to_le16(USB_REQ_READ_REGS);    for (i = 0; i < count; i++)        req->addr[i] = cpu_to_le16((u16)addresses[i]);    udev = zd_usb_to_usbdev(usb);    prepare_read_regs_int(usb);    r = usb_bulk_msg(udev, usb_sndbulkpipe(udev, EP_REGS_OUT),                     req, req_len, &actual_req_len, 1000 /* ms */);    if (r) {        dev_dbg_f(zd_usb_dev(usb),                  "error in usb_bulk_msg(). Error number %d/n", r);        goto error;    }    if (req_len != actual_req_len) {        dev_dbg_f(zd_usb_dev(usb), "error in usb_bulk_msg()/n"                  " req_len %d != actual_req_len %d/n",                  req_len, actual_req_len);        r = -EIO;        goto error;    }    timeout = wait_for_completion_timeout(&usb->intr.read_regs.completion,                                          msecs_to_jiffies(1000));    if (!timeout) {        disable_read_regs_int(usb);        dev_dbg_f(zd_usb_dev(usb), "read timed out/n");        r = -ETIMEDOUT;        goto error;    }    r = get_results(usb, values, req, count);error:    kfree(req);    return r;}

static ssize_t usbtmc_write(struct file *filp, const char __user *buf,			    size_t count, loff_t *f_pos){	struct usbtmc_device_data *data;	u8 *buffer;	int retval;	int actual;	unsigned long int n_bytes;	int remaining;	int done;	int this_part;	data = filp->private_data;	buffer = kmalloc(USBTMC_SIZE_IOBUFFER, GFP_KERNEL);	if (!buffer)		return -ENOMEM;	mutex_lock(&data->io_mutex);	if (data->zombie) {		retval = -ENODEV;		goto exit;	}	remaining = count;	done = 0;	while (remaining > 0) {		if (remaining > USBTMC_SIZE_IOBUFFER - USBTMC_HEADER_SIZE) {			this_part = USBTMC_SIZE_IOBUFFER - USBTMC_HEADER_SIZE;			buffer[8] = 0;		} else {			this_part = remaining;			buffer[8] = 1;		}		/* Setup IO buffer for DEV_DEP_MSG_OUT message */		buffer[0] = 1;		buffer[1] = data->bTag;		buffer[2] = ~data->bTag;		buffer[3] = 0; /* Reserved */		buffer[4] = this_part >> 0;		buffer[5] = this_part >> 8;		buffer[6] = this_part >> 16;		buffer[7] = this_part >> 24;		/* buffer[8] is set above... */		buffer[9] = 0; /* Reserved */		buffer[10] = 0; /* Reserved */		buffer[11] = 0; /* Reserved */		if (copy_from_user(&buffer[USBTMC_HEADER_SIZE], buf + done, this_part)) {			retval = -EFAULT;			goto exit;		}		n_bytes = roundup(USBTMC_HEADER_SIZE + this_part, 4);		memset(buffer + USBTMC_HEADER_SIZE + this_part, 0, n_bytes - (USBTMC_HEADER_SIZE + this_part));		do {			retval = usb_bulk_msg(data->usb_dev,					      usb_sndbulkpipe(data->usb_dev,							      data->bulk_out),					      buffer, n_bytes,					      &actual, USBTMC_TIMEOUT);			if (retval != 0)				break;			n_bytes -= actual;		} while (n_bytes);		data->bTag_last_write = data->bTag;		data->bTag++;		if (!data->bTag)			data->bTag++;		if (retval < 0) {			dev_err(&data->intf->dev,				"Unable to send data, error %d/n", retval);			if (data->auto_abort)				usbtmc_ioctl_abort_bulk_out(data);			goto exit;		}		remaining -= this_part;		done += this_part;	}	retval = count;exit:	mutex_unlock(&data->io_mutex);	kfree(buffer);	return retval;}

int zd_usb_rfwrite(struct zd_usb *usb, u32 value, u8 bits){    int r;    struct usb_device *udev;    struct usb_req_rfwrite *req = NULL;    int i, req_len, actual_req_len;    u16 bit_value_template;    if (in_atomic()) {        dev_dbg_f(zd_usb_dev(usb),                  "error: io in atomic context not supported/n");        return -EWOULDBLOCK;    }    if (bits < USB_MIN_RFWRITE_BIT_COUNT) {        dev_dbg_f(zd_usb_dev(usb),                  "error: bits %d are smaller than"                  " USB_MIN_RFWRITE_BIT_COUNT %d/n",                  bits, USB_MIN_RFWRITE_BIT_COUNT);        return -EINVAL;    }    if (bits > USB_MAX_RFWRITE_BIT_COUNT) {        dev_dbg_f(zd_usb_dev(usb),                  "error: bits %d exceed USB_MAX_RFWRITE_BIT_COUNT %d/n",                  bits, USB_MAX_RFWRITE_BIT_COUNT);        return -EINVAL;    }#ifdef DEBUG    if (value & (~0UL << bits)) {        dev_dbg_f(zd_usb_dev(usb),                  "error: value %#09x has bits >= %d set/n",                  value, bits);        return -EINVAL;    }#endif /* DEBUG */    dev_dbg_f(zd_usb_dev(usb), "value %#09x bits %d/n", value, bits);    r = zd_usb_ioread16(usb, &bit_value_template, CR203);    if (r) {        dev_dbg_f(zd_usb_dev(usb),                  "error %d: Couldn't read CR203/n", r);        goto out;    }    bit_value_template &= ~(RF_IF_LE|RF_CLK|RF_DATA);    req_len = sizeof(struct usb_req_rfwrite) + bits * sizeof(__le16);    req = kmalloc(req_len, GFP_KERNEL);    if (!req)        return -ENOMEM;    req->id = cpu_to_le16(USB_REQ_WRITE_RF);    /* 1: 3683a, but not used in ZYDAS driver */    req->value = cpu_to_le16(2);    req->bits = cpu_to_le16(bits);    for (i = 0; i < bits; i++) {        u16 bv = bit_value_template;        if (value & (1 << (bits-1-i)))            bv |= RF_DATA;        req->bit_values[i] = cpu_to_le16(bv);    }    udev = zd_usb_to_usbdev(usb);    r = usb_bulk_msg(udev, usb_sndbulkpipe(udev, EP_REGS_OUT),                     req, req_len, &actual_req_len, 1000 /* ms */);    if (r) {        dev_dbg_f(zd_usb_dev(usb),                  "error in usb_bulk_msg(). Error number %d/n", r);        goto out;    }    if (req_len != actual_req_len) {        dev_dbg_f(zd_usb_dev(usb), "error in usb_bulk_msg()"                  " req_len %d != actual_req_len %d/n",                  req_len, actual_req_len);        r = -EIO;        goto out;    }    /* FALL-THROUGH with r == 0 */out:    kfree(req);    return r;}

int usb_stor_Bulk_transport(ccb *srb, struct us_data *us){	struct bulk_cb_wrap cbw;	struct bulk_cs_wrap csw;	int actlen, data_actlen;	int result;	unsigned int residue;	unsigned int pipein = usb_rcvbulkpipe(us->pusb_dev, us->recv_bulk_ep);	unsigned int pipeout = usb_sndbulkpipe(us->pusb_dev, us->send_bulk_ep);	int dir_in = US_DIRECTION(srb->cmd[0]);	srb->trans_bytes = 0;	/* set up the command wrapper */	cbw.Signature = cpu_to_le32(US_BULK_CB_SIGN);	cbw.DataTransferLength = cpu_to_le32(srb->datalen);	cbw.Flags = (dir_in ? US_BULK_FLAG_IN : US_BULK_FLAG_OUT);	cbw.Tag = ++cbw_tag;	cbw.Lun = srb->lun;	cbw.Length = srb->cmdlen;	/* copy the command payload */	memcpy(cbw.CDB, srb->cmd, cbw.Length);	/* send it to out endpoint */	US_DEBUGP("Bulk Command S 0x%x T 0x%x L %d F %d Trg %d LUN %d CL %d/n",	                le32_to_cpu(cbw.Signature), cbw.Tag,	                le32_to_cpu(cbw.DataTransferLength), cbw.Flags,	                (cbw.Lun >> 4), (cbw.Lun & 0x0F),	                cbw.Length);	result = usb_bulk_msg(us->pusb_dev, pipeout, &cbw, US_BULK_CB_WRAP_LEN,			      &actlen, USB_BULK_TO);	US_DEBUGP("Bulk command transfer result=%d/n", result);	if (result < 0) {		usb_stor_Bulk_reset(us);		return USB_STOR_TRANSPORT_FAILED;	}	/* DATA STAGE */	/* send/receive data payload, if there is any */	wait_ms(1);	data_actlen = 0;	if (srb->datalen) {		unsigned int pipe = dir_in ? pipein : pipeout;		result = usb_bulk_msg(us->pusb_dev, pipe, srb->pdata,		                      srb->datalen, &data_actlen, USB_BULK_TO);		US_DEBUGP("Bulk data transfer result 0x%x/n", result);		/* special handling of STALL in DATA phase */		if ((result < 0) && (us->pusb_dev->status & USB_ST_STALLED)) {			US_DEBUGP("DATA: stall/n");			/* clear the STALL on the endpoint */			result = usb_stor_Bulk_clear_endpt_stall(us, pipe);		}		if (result < 0) {			US_DEBUGP("Device status: %lx/n", us->pusb_dev->status);			usb_stor_Bulk_reset(us);			return USB_STOR_TRANSPORT_FAILED;		}	}	/* STATUS phase + error handling */	US_DEBUGP("Attempting to get CSW.../n");	result = usb_bulk_msg(us->pusb_dev, pipein, &csw, US_BULK_CS_WRAP_LEN,	                      &actlen, USB_BULK_TO);	/* did the endpoint stall? */	if ((result < 0) && (us->pusb_dev->status & USB_ST_STALLED)) {		US_DEBUGP("STATUS: stall/n");		/* clear the STALL on the endpoint */		result = usb_stor_Bulk_clear_endpt_stall(us, pipein);		if (result >= 0) {			US_DEBUGP("Attempting to get CSW.../n");			result = usb_bulk_msg(us->pusb_dev, pipein,			                      &csw, US_BULK_CS_WRAP_LEN,			                      &actlen, USB_BULK_TO);		}	}	if (result < 0) {		US_DEBUGP("Device status: %lx/n", us->pusb_dev->status);		usb_stor_Bulk_reset(us);		return USB_STOR_TRANSPORT_FAILED;	}	/* check bulk status */	residue = le32_to_cpu(csw.Residue);	US_DEBUGP("Bulk Status S 0x%x T 0x%x R %u Stat 0x%x/n",	          le32_to_cpu(csw.Signature), csw.Tag, residue, csw.Status);	if (csw.Signature != cpu_to_le32(US_BULK_CS_SIGN)) {		US_DEBUGP("Bad CSW signature/n");		usb_stor_Bulk_reset(us);		return USB_STOR_TRANSPORT_FAILED;	} else if (csw.Tag != cbw_tag) {		US_DEBUGP("Mismatching tag/n");		usb_stor_Bulk_reset(us);		return USB_STOR_TRANSPORT_FAILED;	} else if (csw.Status >= US_BULK_STAT_PHASE) {		US_DEBUGP("Status >= phase/n");//.........这里部分代码省略.........

/** * usb_interrupt_msg - Builds an interrupt urb, sends it off and waits for completion * @usb_dev: pointer to the usb device to send the message to * @pipe: endpoint "pipe" to send the message to * @data: pointer to the data to send * @len: length in bytes of the data to send * @actual_length: pointer to a location to put the actual length transferred in bytes * @timeout: time in msecs to wait for the message to complete before *	timing out (if 0 the wait is forever) * Context: !in_interrupt () * * This function sends a simple interrupt message to a specified endpoint and * waits for the message to complete, or timeout. * * If successful, it returns 0, otherwise a negative error number.  The number * of actual bytes transferred will be stored in the actual_length paramater. * * Don't use this function from within an interrupt context, like a bottom half * handler.  If you need an asynchronous message, or need to send a message * from within interrupt context, use usb_submit_urb() If a thread in your * driver uses this call, make sure your disconnect() method can wait for it to * complete.  Since you don't have a handle on the URB used, you can't cancel * the request. */int usb_interrupt_msg(struct usb_device *usb_dev, unsigned int pipe,		      void *data, int len, int *actual_length, int timeout){	return usb_bulk_msg(usb_dev, pipe, data, len, actual_length, timeout);}

static ssize_tread_rio(struct file *file, char __user *buffer, size_t count, loff_t * ppos){	DEFINE_WAIT(wait);	struct rio_usb_data *rio = &rio_instance;	ssize_t read_count;	unsigned int partial;	int this_read;	int result;	int maxretry = 10;	char *ibuf;	int intr;	intr = mutex_lock_interruptible(&(rio->lock));	if (intr)		return -EINTR;	/* Sanity check to make sure rio is connected, powered, etc */        if (rio->present == 0 || rio->rio_dev == NULL) {		mutex_unlock(&(rio->lock));		return -ENODEV;	}	ibuf = rio->ibuf;	read_count = 0;	while (count > 0) {		if (signal_pending(current)) {			mutex_unlock(&(rio->lock));			return read_count ? read_count : -EINTR;		}		if (!rio->rio_dev) {			mutex_unlock(&(rio->lock));			return -ENODEV;		}		this_read = (count >= IBUF_SIZE) ? IBUF_SIZE : count;		result = usb_bulk_msg(rio->rio_dev,				      usb_rcvbulkpipe(rio->rio_dev, 1),				      ibuf, this_read, &partial,				      8000);		dbg("read stats: result:%d this_read:%u partial:%u",		       result, this_read, partial);		if (partial) {			count = this_read = partial;		} else if (result == -ETIMEDOUT || result == 15) {	/* FIXME: 15 ??? */			if (!maxretry--) {				mutex_unlock(&(rio->lock));				err("read_rio: maxretry timeout");				return -ETIME;			}			prepare_to_wait(&rio->wait_q, &wait, TASK_INTERRUPTIBLE);			schedule_timeout(NAK_TIMEOUT);			finish_wait(&rio->wait_q, &wait);			continue;		} else if (result != -EREMOTEIO) {			mutex_unlock(&(rio->lock));			err("Read Whoops - result:%u partial:%u this_read:%u",			     result, partial, this_read);			return -EIO;		} else {			mutex_unlock(&(rio->lock));			return (0);		}		if (this_read) {			if (copy_to_user(buffer, ibuf, this_read)) {				mutex_unlock(&(rio->lock));				return -EFAULT;			}			count -= this_read;			read_count += this_read;			buffer += this_read;		}	}	mutex_unlock(&(rio->lock));	return read_count;}

/* this function reads a full JPEG picture synchronously * TODO: do it asynchronously... */static int read_frame(struct zr364xx_camera *cam, int framenum){	int i, n, temp, head, size, actual_length;	unsigned char *ptr = NULL, *jpeg;      redo:	/* hardware brightness */	n = send_control_msg(cam->udev, 1, 0x2001, 0, NULL, 0);	temp = (0x60 << 8) + 127 - cam->brightness;	n = send_control_msg(cam->udev, 1, temp, 0, NULL, 0);	/* during the first loop we are going to insert JPEG header */	head = 0;	/* this is the place in memory where we are going to build	 * the JPEG image */	jpeg = cam->framebuf + framenum * MAX_FRAME_SIZE;	/* read data... */	do {		n = usb_bulk_msg(cam->udev,				 usb_rcvbulkpipe(cam->udev, 0x81),				 cam->buffer, BUFFER_SIZE, &actual_length,				 CTRL_TIMEOUT);		DBG("buffer : %d %d", cam->buffer[0], cam->buffer[1]);		DBG("bulk : n=%d size=%d", n, actual_length);		if (n < 0) {			dev_err(&cam->udev->dev, "error reading bulk msg/n");			return 0;		}		if (actual_length < 0 || actual_length > BUFFER_SIZE) {			dev_err(&cam->udev->dev, "wrong number of bytes/n");			return 0;		}		/* swap bytes if camera needs it */		if (cam->method == METHOD0) {			u16 *buf = (u16*)cam->buffer;			for (i = 0; i < BUFFER_SIZE/2; i++)				swab16s(buf + i);		}		/* write the JPEG header */		if (!head) {			DBG("jpeg header");			ptr = jpeg;			memcpy(ptr, header1, sizeof(header1));			ptr += sizeof(header1);			header3 = 0;			memcpy(ptr, &header3, 1);			ptr++;			memcpy(ptr, cam->buffer, 64);			ptr += 64;			header3 = 1;			memcpy(ptr, &header3, 1);			ptr++;			memcpy(ptr, cam->buffer + 64, 64);			ptr += 64;			memcpy(ptr, header2, sizeof(header2));			ptr += sizeof(header2);			memcpy(ptr, cam->buffer + 128,			       actual_length - 128);			ptr += actual_length - 128;			head = 1;			DBG("header : %d %d %d %d %d %d %d %d %d",			    cam->buffer[0], cam->buffer[1], cam->buffer[2],			    cam->buffer[3], cam->buffer[4], cam->buffer[5],			    cam->buffer[6], cam->buffer[7], cam->buffer[8]);		} else {			memcpy(ptr, cam->buffer, actual_length);			ptr += actual_length;		}	}	/* ... until there is no more */	while (actual_length == BUFFER_SIZE);	/* we skip the 2 first frames which are usually buggy */	if (cam->skip) {		cam->skip--;		goto redo;	}	/* go back to find the JPEG EOI marker */	size = ptr - jpeg;	ptr -= 2;	while (ptr > jpeg) {		if (*ptr == 0xFF && *(ptr + 1) == 0xD9		    && *(ptr + 2) == 0xFF)			break;		ptr--;	}	if (ptr == jpeg)		DBG("No EOI marker");	/* Sometimes there is junk data in the middle of the picture,	 * we want to skip this bogus frames */	while (ptr > jpeg) {		if (*ptr == 0xFF && *(ptr + 1) == 0xFF		    && *(ptr + 2) == 0xFF)			break;//.........这里部分代码省略.........

static int bfusb_load_firmware(struct bfusb_data *data,			       const unsigned char *firmware, int count){	unsigned char *buf;	int err, pipe, len, size, sent = 0;	BT_DBG("bfusb %p udev %p", data, data->udev);	BT_INFO("BlueFRITZ! USB loading firmware");	buf = kmalloc(BFUSB_MAX_BLOCK_SIZE + 3, GFP_KERNEL);	if (!buf) {		BT_ERR("Can't allocate memory chunk for firmware");		return -ENOMEM;	}	pipe = usb_sndctrlpipe(data->udev, 0);	if (usb_control_msg(data->udev, pipe, USB_REQ_SET_CONFIGURATION,				0, 1, 0, NULL, 0, USB_CTRL_SET_TIMEOUT) < 0) {		BT_ERR("Can't change to loading configuration");		kfree(buf);		return -EBUSY;	}	data->udev->toggle[0] = data->udev->toggle[1] = 0;	pipe = usb_sndbulkpipe(data->udev, data->bulk_out_ep);	while (count) {		size = min_t(uint, count, BFUSB_MAX_BLOCK_SIZE + 3);		memcpy(buf, firmware + sent, size);		err = usb_bulk_msg(data->udev, pipe, buf, size,					&len, BFUSB_BLOCK_TIMEOUT);		if (err || (len != size)) {			BT_ERR("Error in firmware loading");			goto error;		}		sent  += size;		count -= size;	}	err = usb_bulk_msg(data->udev, pipe, NULL, 0,					&len, BFUSB_BLOCK_TIMEOUT);	if (err < 0) {		BT_ERR("Error in null packet request");		goto error;	}	pipe = usb_sndctrlpipe(data->udev, 0);	err = usb_control_msg(data->udev, pipe, USB_REQ_SET_CONFIGURATION,				0, 2, 0, NULL, 0, USB_CTRL_SET_TIMEOUT);	if (err < 0) {		BT_ERR("Can't change to running configuration");		goto error;	}	data->udev->toggle[0] = data->udev->toggle[1] = 0;	BT_INFO("BlueFRITZ! USB device ready");	kfree(buf);	return 0;error:	kfree(buf);	pipe = usb_sndctrlpipe(data->udev, 0);	usb_control_msg(data->udev, pipe, USB_REQ_SET_CONFIGURATION,				0, 0, 0, NULL, 0, USB_CTRL_SET_TIMEOUT);	return err;}

/* * Load the MIPS R4000 microcode into the device.  Once the image is loaded, * the device will detach itself from the bus and reattach later with a new * product Id (a la ezusb). */static int ar5523_load_firmware(struct usb_device *dev){	struct ar5523_fwblock *txblock, *rxblock;	const struct firmware *fw;	void *fwbuf;	int len, offset;	int foolen; /* XXX(hch): handle short transfers */	int error = -ENXIO;	if (request_firmware(&fw, AR5523_FIRMWARE_FILE, &dev->dev)) {		dev_err(&dev->dev, "no firmware found: %s/n",			AR5523_FIRMWARE_FILE);		return -ENOENT;	}	txblock = kmalloc(sizeof(*txblock), GFP_KERNEL);	if (!txblock)		goto out;	rxblock = kmalloc(sizeof(*rxblock), GFP_KERNEL);	if (!rxblock)		goto out_free_txblock;	fwbuf = kmalloc(AR5523_MAX_FWBLOCK_SIZE, GFP_KERNEL);	if (!fwbuf)		goto out_free_rxblock;	memset(txblock, 0, sizeof(struct ar5523_fwblock));	txblock->flags = cpu_to_be32(AR5523_WRITE_BLOCK);	txblock->total = cpu_to_be32(fw->size);	offset = 0;	len = fw->size;	while (len > 0) {		int mlen = min(len, AR5523_MAX_FWBLOCK_SIZE);		txblock->remain = cpu_to_be32(len - mlen);		txblock->len = cpu_to_be32(mlen);		/* send firmware block meta-data */		error = usb_bulk_msg(dev, ar5523_cmd_tx_pipe(dev),				     txblock, sizeof(*txblock), &foolen,				     AR5523_CMD_TIMEOUT);		if (error) {			dev_err(&dev->dev,				"could not send firmware block info/n");			goto out_free_fwbuf;		}		/* send firmware block data */		memcpy(fwbuf, fw->data + offset, mlen);		error = usb_bulk_msg(dev, ar5523_data_tx_pipe(dev),				     fwbuf, mlen, &foolen,				     AR5523_DATA_TIMEOUT);		if (error) {			dev_err(&dev->dev,				"could not send firmware block data/n");			goto out_free_fwbuf;		}		/* wait for ack from firmware */		error = usb_bulk_msg(dev, ar5523_cmd_rx_pipe(dev),				     rxblock, sizeof(*rxblock), &foolen,				     AR5523_CMD_TIMEOUT);		if (error) {			dev_err(&dev->dev,				"could not read firmware answer/n");			goto out_free_fwbuf;		}		len -= mlen;		offset += mlen;	}	/*	 * Set the error to -ENXIO to make sure we continue probing for	 * a driver.	 */	error = -ENXIO; out_free_fwbuf:	kfree(fwbuf); out_free_rxblock:	kfree(rxblock); out_free_txblock:	kfree(txblock); out:	release_firmware(fw);	return error;}

static int usX2Y_create_usbmidi(struct snd_card *card){	static struct snd_usb_midi_endpoint_info quirk_data_1 = {		.out_ep = 0x06,		.in_ep = 0x06,		.out_cables =	0x001,		.in_cables =	0x001	};	static struct snd_usb_audio_quirk quirk_1 = {		.vendor_name =	"TASCAM",		.product_name =	NAME_ALLCAPS,		.ifnum = 	0,       		.type = QUIRK_MIDI_FIXED_ENDPOINT,		.data = &quirk_data_1	};	static struct snd_usb_midi_endpoint_info quirk_data_2 = {		.out_ep = 0x06,		.in_ep = 0x06,		.out_cables =	0x003,		.in_cables =	0x003	};	static struct snd_usb_audio_quirk quirk_2 = {		.vendor_name =	"TASCAM",		.product_name =	"US428",		.ifnum = 	0,       		.type = QUIRK_MIDI_FIXED_ENDPOINT,		.data = &quirk_data_2	};	struct usb_device *dev = usX2Y(card)->chip.dev;	struct usb_interface *iface = usb_ifnum_to_if(dev, 0);	struct snd_usb_audio_quirk *quirk =		le16_to_cpu(dev->descriptor.idProduct) == USB_ID_US428 ?		&quirk_2 : &quirk_1;	snd_printdd("usX2Y_create_usbmidi /n");	return snd_usb_create_midi_interface(&usX2Y(card)->chip, iface, quirk);}static int usX2Y_create_alsa_devices(struct snd_card *card){	int err;	do {		if ((err = usX2Y_create_usbmidi(card)) < 0) {			snd_printk(KERN_ERR "usX2Y_create_alsa_devices: usX2Y_create_usbmidi error %i /n", err);			break;		}		if ((err = usX2Y_audio_create(card)) < 0) 			break;		if ((err = usX2Y_hwdep_pcm_new(card)) < 0)			break;		if ((err = snd_card_register(card)) < 0)			break;	} while (0);	return err;} static int snd_usX2Y_hwdep_dsp_load(struct snd_hwdep *hw,				    struct snd_hwdep_dsp_image *dsp){	struct usX2Ydev *priv = hw->private_data;	int	lret, err = -EINVAL;	snd_printdd( "dsp_load %s/n", dsp->name);	if (access_ok(VERIFY_READ, dsp->image, dsp->length)) {		struct usb_device* dev = priv->chip.dev;		char *buf = kmalloc(dsp->length, GFP_KERNEL);		if (!buf)			return -ENOMEM;		if (copy_from_user(buf, dsp->image, dsp->length)) {			kfree(buf);			return -EFAULT;		}		err = usb_set_interface(dev, 0, 1);		if (err)			snd_printk(KERN_ERR "usb_set_interface error /n");		else			err = usb_bulk_msg(dev, usb_sndbulkpipe(dev, 2), buf, dsp->length, &lret, 6000);		kfree(buf);	}	if (err)		return err;	if (dsp->index == 1) {		msleep(250);				// give the device some time		err = usX2Y_AsyncSeq04_init(priv);		if (err) {			snd_printk(KERN_ERR "usX2Y_AsyncSeq04_init error /n");			return err;		}		err = usX2Y_In04_init(priv);		if (err) {			snd_printk(KERN_ERR "usX2Y_In04_init error /n");			return err;		}		err = usX2Y_create_alsa_devices(hw->card);		if (err) {			snd_printk(KERN_ERR "usX2Y_create_alsa_devices error %i /n", err);			snd_card_free(hw->card);			return err;//.........这里部分代码省略.........

static int usbtmc_ioctl_abort_bulk_in(struct usbtmc_device_data *data){	u8 *buffer;	struct device *dev;	int rv;	int n;	int actual;	struct usb_host_interface *current_setting;	int max_size;	dev = &data->intf->dev;	buffer = kmalloc(USBTMC_SIZE_IOBUFFER, GFP_KERNEL);	if (!buffer)		return -ENOMEM;	rv = usb_control_msg(data->usb_dev,			     usb_rcvctrlpipe(data->usb_dev, 0),			     USBTMC_REQUEST_INITIATE_ABORT_BULK_IN,			     USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_ENDPOINT,			     data->bTag_last_read, data->bulk_in,			     buffer, 2, USBTMC_TIMEOUT);	if (rv < 0) {		dev_err(dev, "usb_control_msg returned %d/n", rv);		goto exit;	}	dev_dbg(dev, "INITIATE_ABORT_BULK_IN returned %x/n", buffer[0]);	if (buffer[0] == USBTMC_STATUS_FAILED) {		rv = 0;		goto exit;	}	if (buffer[0] != USBTMC_STATUS_SUCCESS) {		dev_err(dev, "INITIATE_ABORT_BULK_IN returned %x/n",			buffer[0]);		rv = -EPERM;		goto exit;	}	max_size = 0;	current_setting = data->intf->cur_altsetting;	for (n = 0; n < current_setting->desc.bNumEndpoints; n++)		if (current_setting->endpoint[n].desc.bEndpointAddress ==			data->bulk_in)			max_size = usb_endpoint_maxp(&current_setting->endpoint[n].desc);	if (max_size == 0) {		dev_err(dev, "Couldn't get wMaxPacketSize/n");		rv = -EPERM;		goto exit;	}	dev_dbg(&data->intf->dev, "wMaxPacketSize is %d/n", max_size);	n = 0;	do {		dev_dbg(dev, "Reading from bulk in EP/n");		rv = usb_bulk_msg(data->usb_dev,				  usb_rcvbulkpipe(data->usb_dev,						  data->bulk_in),				  buffer, USBTMC_SIZE_IOBUFFER,				  &actual, USBTMC_TIMEOUT);		n++;		if (rv < 0) {			dev_err(dev, "usb_bulk_msg returned %d/n", rv);			goto exit;		}	} while ((actual == max_size) &&		 (n < USBTMC_MAX_READS_TO_CLEAR_BULK_IN));	if (actual == max_size) {		dev_err(dev, "Couldn't clear device buffer within %d cycles/n",			USBTMC_MAX_READS_TO_CLEAR_BULK_IN);		rv = -EPERM;		goto exit;	}	n = 0;usbtmc_abort_bulk_in_status:	rv = usb_control_msg(data->usb_dev,			     usb_rcvctrlpipe(data->usb_dev, 0),			     USBTMC_REQUEST_CHECK_ABORT_BULK_IN_STATUS,			     USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_ENDPOINT,			     0, data->bulk_in, buffer, 0x08,			     USBTMC_TIMEOUT);	if (rv < 0) {		dev_err(dev, "usb_control_msg returned %d/n", rv);		goto exit;	}	dev_dbg(dev, "INITIATE_ABORT_BULK_IN returned %x/n", buffer[0]);//.........这里部分代码省略.........

//.........这里部分代码省略.........		buffer_len = aw_cmd.length;		value = aw_cmd.value;		pr_debug("buffer_len=%d/n", buffer_len);		pr_debug("value=%d/n", value);		if (buffer_len > IOCTL_SIZE) {			retval = -EINVAL;			goto err_out;		}		buffer = kmalloc(buffer_len, GFP_KERNEL);		if (!(buffer)) {			dev_err(&aw->aw_dev->dev,				"AWUSB_IOCSEND: Not enough memory for the send buffer");			retval = -ENOMEM;			goto err_out;		}		/* stage 1, get data from app */		if (copy_from_user(buffer, aw_cmd.buffer, aw_cmd.length)) {			retval = -EFAULT;			kfree(buffer);			goto err_out;		}#if 0		int ii = 0;		for (ii = 0; ii < buffer_len; ii++)				pr_debug(				"*(buffer + %d) = %d/n", ii, *(buffer + ii));		pr_debug("*buffer=%d, *(buffer+1)=%d/n", *buffer, *(buffer+1));#endif		/* stage 2, send data to usb device */		result = usb_bulk_msg(aw->aw_dev,		usb_sndbulkpipe(aw->aw_dev, 1),		buffer, buffer_len, &actual_len, 5000);		if (result) {			kfree(buffer);			dev_err(&aw->aw_dev->dev,				"Write Whoops - %08x", result);			retval = -EIO;			goto err_out;		}		kfree(buffer);		pr_debug("ioctl_aw--AWUSB_IOCSEND-exit/n");		break;	case AWUSB_IOCRECV:		pr_debug("ioctl_aw--AWUSB_IOCRECV/n");		data = (void __user *)arg;		if (data == NULL)			break;		if (copy_from_user(&aw_cmd, data, sizeof(struct aw_command))) {			retval = -EFAULT;			goto err_out;		}		if (aw_cmd.length < 0) {			retval = -EINVAL;			goto err_out;		}		buffer_len = aw_cmd.length;		value = aw_cmd.value;