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

static void redrat3_get_firmware_rev(struct redrat3_dev *rr3){	int rc = 0;	char *buffer;	rr3_ftr(rr3->dev, "Entering %s/n", __func__);	buffer = kzalloc(sizeof(char) * (RR3_FW_VERSION_LEN + 1), GFP_KERNEL);	if (!buffer) {		dev_err(rr3->dev, "Memory allocation failure/n");		return;	}	rc = usb_control_msg(rr3->udev, usb_rcvctrlpipe(rr3->udev, 0),			     RR3_FW_VERSION,			     USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,			     0, 0, buffer, RR3_FW_VERSION_LEN, HZ * 5);	if (rc >= 0)		dev_info(rr3->dev, "Firmware rev: %s", buffer);	else		dev_err(rr3->dev, "Problem fetching firmware ID/n");	kfree(buffer);	rr3_ftr(rr3->dev, "Exiting %s/n", __func__);}

static int redrat3_dev_suspend(struct usb_interface *intf, pm_message_t message){	struct redrat3_dev *rr3 = usb_get_intfdata(intf);	rr3_ftr(rr3->dev, "suspend/n");	usb_kill_urb(rr3->read_urb);	return 0;}

/* gather IR data from incoming urb, process it when we have enough */static int redrat3_get_ir_data(struct redrat3_dev *rr3, unsigned len){    struct device *dev = rr3->dev;    unsigned pkttype;    int ret = 0;    rr3_ftr(dev, "Entering %s/n", __func__);    if (rr3->bytes_read == 0 && len >= sizeof(struct redrat3_header)) {        redrat3_read_packet_start(rr3, len);    } else if (rr3->bytes_read != 0) {        redrat3_read_packet_continue(rr3, len);    } else if (rr3->bytes_read == 0) {        dev_err(dev, "error: no packet data read/n");        ret = -ENODATA;        goto out;    }    if (rr3->bytes_read < be16_to_cpu(rr3->irdata.header.length) +            sizeof(struct redrat3_header))        /* we're still accumulating data */        return 0;    /* if we get here, we've got IR data to decode */    pkttype = be16_to_cpu(rr3->irdata.header.transfer_type);    if (pkttype == RR3_MOD_SIGNAL_IN)        redrat3_process_ir_data(rr3);    else        rr3_dbg(dev, "discarding non-signal data packet (type 0x%02x)/n",                pkttype);out:    rr3->bytes_read = 0;    return ret;}

static int redrat3_dev_resume(struct usb_interface *intf){	struct redrat3_dev *rr3 = usb_get_intfdata(intf);	rr3_ftr(rr3->dev, "resume/n");	if (usb_submit_urb(rr3->read_urb, GFP_ATOMIC))		return -EIO;	return 0;}

static void redrat3_dev_disconnect(struct usb_interface *intf){    struct usb_device *udev = interface_to_usbdev(intf);    struct redrat3_dev *rr3 = usb_get_intfdata(intf);    rr3_ftr(&intf->dev, "Entering %s/n", __func__);    if (!rr3)        return;    usb_set_intfdata(intf, NULL);    rc_unregister_device(rr3->rc);    led_classdev_unregister(&rr3->led);    del_timer_sync(&rr3->rx_timeout);    redrat3_delete(rr3, udev);    rr3_ftr(&intf->dev, "RedRat3 IR Transceiver now disconnected/n");}

static void redrat3_read_packet_continue(struct redrat3_dev *rr3, int len){	rr3_ftr(rr3->dev, "Entering %s/n", __func__);	memcpy(rr3->datap, (unsigned char *)rr3->bulk_in_buf, len);	rr3->datap += len;	rr3->bytes_read += len;	rr3_dbg(rr3->dev, "bytes_read %d, pktlen %d/n",		rr3->bytes_read, rr3->pktlen);}

/* * redrat3_issue_async * *  Issues an async read to the ir data in port.. *  sets the callback to be redrat3_handle_async */static void redrat3_issue_async(struct redrat3_dev *rr3){    int res;    rr3_ftr(rr3->dev, "Entering %s/n", __func__);    res = usb_submit_urb(rr3->read_urb, GFP_ATOMIC);    if (res)        rr3_dbg(rr3->dev, "%s: receive request FAILED! "                "(res %d, len %d)/n", __func__, res,                rr3->read_urb->transfer_buffer_length);}

static inline void redrat3_delete(struct redrat3_dev *rr3,                                  struct usb_device *udev){    rr3_ftr(rr3->dev, "%s cleaning up/n", __func__);    usb_kill_urb(rr3->read_urb);    usb_kill_urb(rr3->flash_urb);    usb_free_urb(rr3->read_urb);    usb_free_urb(rr3->flash_urb);    usb_free_coherent(udev, le16_to_cpu(rr3->ep_in->wMaxPacketSize),                      rr3->bulk_in_buf, rr3->dma_in);    kfree(rr3);}

static void redrat3_write_bulk_callback(struct urb *urb, struct pt_regs *regs){	struct redrat3_dev *rr3;	int len;	if (!urb)		return;	rr3 = urb->context;	if (rr3) {		len = urb->actual_length;		rr3_ftr(rr3->dev, "%s: called (status=%d len=%d)/n",			__func__, urb->status, len);	}}

static void redrat3_read_packet_start(struct redrat3_dev *rr3, int len){	u16 tx_error;	u16 hdrlen;	rr3_ftr(rr3->dev, "Entering %s/n", __func__);	/*                                      */	memcpy(&(rr3->pktlen), (unsigned char *) rr3->bulk_in_buf,	       sizeof(rr3->pktlen));	memcpy(&(rr3->pkttype), ((unsigned char *) rr3->bulk_in_buf +		sizeof(rr3->pktlen)),	       sizeof(rr3->pkttype));	/*                                                      */	rr3->pktlen = be16_to_cpu(rr3->pktlen);	rr3->pkttype = be16_to_cpu(rr3->pkttype);	switch (rr3->pkttype) {	case RR3_ERROR:		memcpy(&tx_error, ((unsigned char *)rr3->bulk_in_buf			+ (sizeof(rr3->pktlen) + sizeof(rr3->pkttype))),		       sizeof(tx_error));		tx_error = be16_to_cpu(tx_error);		redrat3_dump_fw_error(rr3, tx_error);		break;	case RR3_MOD_SIGNAL_IN:		hdrlen = sizeof(rr3->pktlen) + sizeof(rr3->pkttype);		rr3->bytes_read = len;		rr3->bytes_read -= hdrlen;		rr3->datap = &(rr3->pbuf[0]);		memcpy(rr3->datap, ((unsigned char *)rr3->bulk_in_buf + hdrlen),		       rr3->bytes_read);		rr3->datap += rr3->bytes_read;		rr3_dbg(rr3->dev, "bytes_read %d, pktlen %d/n",			rr3->bytes_read, rr3->pktlen);		break;	default:		rr3_dbg(rr3->dev, "ignoring packet with type 0x%02x, "			"len of %d, 0x%02x/n", rr3->pkttype, len, rr3->pktlen);		break;	}}

static int redrat3_get_ir_data(struct redrat3_dev *rr3, int len){	struct device *dev = rr3->dev;	int ret = 0;	rr3_ftr(dev, "Entering %s/n", __func__);	if (rr3->pktlen > RR3_MAX_BUF_SIZE) {		dev_err(rr3->dev, "error: packet larger than buffer/n");		ret = -EINVAL;		goto out;	}	if ((rr3->bytes_read == 0) &&	    (len >= (sizeof(rr3->pkttype) + sizeof(rr3->pktlen)))) {		redrat3_read_packet_start(rr3, len);	} else if (rr3->bytes_read != 0) {		redrat3_read_packet_continue(rr3, len);	} else if (rr3->bytes_read == 0) {		dev_err(dev, "error: no packet data read/n");		ret = -ENODATA;		goto out;	}	if (rr3->bytes_read > rr3->pktlen) {		dev_err(dev, "bytes_read (%d) greater than pktlen (%d)/n",			rr3->bytes_read, rr3->pktlen);		ret = -EINVAL;		goto out;	} else if (rr3->bytes_read < rr3->pktlen)		/*                               */		return 0;	/*                                             */	if (rr3->pkttype == RR3_MOD_SIGNAL_IN)		redrat3_process_ir_data(rr3);	else		rr3_dbg(dev, "discarding non-signal data packet "			"(type 0x%02x)/n", rr3->pkttype);out:	rr3->bytes_read = 0;	rr3->pktlen = 0;	rr3->pkttype = 0;	return ret;}

static void redrat3_disable_detector(struct redrat3_dev *rr3){	struct device *dev = rr3->dev;	u8 ret;	rr3_ftr(dev, "Entering %s/n", __func__);	ret = redrat3_send_cmd(RR3_RC_DET_DISABLE, rr3);	if (ret != 0)		dev_err(dev, "%s: failure!/n", __func__);	ret = redrat3_send_cmd(RR3_RC_DET_STATUS, rr3);	if (ret != 0)		dev_warn(dev, "%s: detector status: %d, should be 0/n",			 __func__, ret);	rr3->det_enabled = false;}

static void redrat3_read_packet_continue(struct redrat3_dev *rr3, unsigned len){    void *irdata = &rr3->irdata;    rr3_ftr(rr3->dev, "Entering %s/n", __func__);    if (len + rr3->bytes_read > sizeof(rr3->irdata)) {        dev_warn(rr3->dev, "too much data for packet/n");        rr3->bytes_read = 0;        return;    }    memcpy(irdata + rr3->bytes_read, rr3->bulk_in_buf, len);    rr3->bytes_read += len;    rr3_dbg(rr3->dev, "bytes_read %d, pktlen %d/n", rr3->bytes_read,            be16_to_cpu(rr3->irdata.header.length));}

static void redrat3_handle_async(struct urb *urb, struct pt_regs *regs){	struct redrat3_dev *rr3;	int ret;	if (!urb)		return;	rr3 = urb->context;	if (!rr3) {		pr_err("%s called with invalid context!/n", __func__);		usb_unlink_urb(urb);		return;	}	rr3_ftr(rr3->dev, "Entering %s/n", __func__);	switch (urb->status) {	case 0:		ret = redrat3_get_ir_data(rr3, urb->actual_length);		if (!ret) {			/*                                */			redrat3_issue_async(rr3);		}		break;	case -ECONNRESET:	case -ENOENT:	case -ESHUTDOWN:		usb_unlink_urb(urb);		return;	case -EPIPE:	default:		dev_warn(rr3->dev, "Error: urb status = %d/n", urb->status);		rr3->bytes_read = 0;		rr3->pktlen = 0;		rr3->pkttype = 0;		break;	}}

static void redrat3_reset(struct redrat3_dev *rr3){	struct usb_device *udev = rr3->udev;	struct device *dev = rr3->dev;	int rc, rxpipe, txpipe;	u8 *val;	int len = sizeof(u8);	rr3_ftr(dev, "Entering %s/n", __func__);	rxpipe = usb_rcvctrlpipe(udev, 0);	txpipe = usb_sndctrlpipe(udev, 0);	val = kzalloc(len, GFP_KERNEL);	if (!val) {		dev_err(dev, "Memory allocation failure/n");		return;	}	*val = 0x01;	rc = usb_control_msg(udev, rxpipe, RR3_RESET,			     USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,			     RR3_CPUCS_REG_ADDR, 0, val, len, HZ * 25);	rr3_dbg(dev, "reset returned 0x%02x/n", rc);	*val = 5;	rc = usb_control_msg(udev, txpipe, RR3_SET_IR_PARAM,			     USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT,			     RR3_IR_IO_LENGTH_FUZZ, 0, val, len, HZ * 25);	rr3_dbg(dev, "set ir parm len fuzz %d rc 0x%02x/n", *val, rc);	*val = RR3_DRIVER_MAXLENS;	rc = usb_control_msg(udev, txpipe, RR3_SET_IR_PARAM,			     USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT,			     RR3_IR_IO_MAX_LENGTHS, 0, val, len, HZ * 25);	rr3_dbg(dev, "set ir parm max lens %d rc 0x%02x/n", *val, rc);	kfree(val);}

static void redrat3_read_packet_start(struct redrat3_dev *rr3, unsigned len){    struct redrat3_header *header = rr3->bulk_in_buf;    unsigned pktlen, pkttype;    rr3_ftr(rr3->dev, "Entering %s/n", __func__);    /* grab the Length and type of transfer */    pktlen = be16_to_cpu(header->length);    pkttype = be16_to_cpu(header->transfer_type);    if (pktlen > sizeof(rr3->irdata)) {        dev_warn(rr3->dev, "packet length %u too large/n", pktlen);        return;    }    switch (pkttype) {    case RR3_ERROR:        if (len >= sizeof(struct redrat3_error)) {            struct redrat3_error *error = rr3->bulk_in_buf;            unsigned fw_error = be16_to_cpu(error->fw_error);            redrat3_dump_fw_error(rr3, fw_error);        }        break;    case RR3_MOD_SIGNAL_IN:        memcpy(&rr3->irdata, rr3->bulk_in_buf, len);        rr3->bytes_read = len;        rr3_dbg(rr3->dev, "bytes_read %d, pktlen %d/n",                rr3->bytes_read, pktlen);        break;    default:        rr3_dbg(rr3->dev, "ignoring packet with type 0x%02x, len of %d, 0x%02x/n",                pkttype, len, pktlen);        break;    }}

/* Enables the long range detector and starts async receive */static int redrat3_enable_detector(struct redrat3_dev *rr3){    struct device *dev = rr3->dev;    u8 ret;    rr3_ftr(dev, "Entering %s/n", __func__);    ret = redrat3_send_cmd(RR3_RC_DET_ENABLE, rr3);    if (ret != 0)        dev_dbg(dev, "%s: unexpected ret of %d/n",                __func__, ret);    ret = redrat3_send_cmd(RR3_RC_DET_STATUS, rr3);    if (ret != 1) {        dev_err(dev, "%s: detector status: %d, should be 1/n",                __func__, ret);        return -EIO;    }    redrat3_issue_async(rr3);    return 0;}

static int redrat3_transmit_ir(struct rc_dev *rcdev, unsigned *txbuf,                               unsigned count){    struct redrat3_dev *rr3 = rcdev->priv;    struct device *dev = rr3->dev;    struct redrat3_irdata *irdata = NULL;    int ret, ret_len;    int lencheck, cur_sample_len, pipe;    int *sample_lens = NULL;    u8 curlencheck = 0;    unsigned i, sendbuf_len;    rr3_ftr(dev, "Entering %s/n", __func__);    if (rr3->transmitting) {        dev_warn(dev, "%s: transmitter already in use/n", __func__);        return -EAGAIN;    }    if (count > RR3_MAX_SIG_SIZE - RR3_TX_TRAILER_LEN)        return -EINVAL;    /* rr3 will disable rc detector on transmit */    rr3->transmitting = true;    sample_lens = kzalloc(sizeof(int) * RR3_DRIVER_MAXLENS, GFP_KERNEL);    if (!sample_lens) {        ret = -ENOMEM;        goto out;    }    irdata = kzalloc(sizeof(*irdata), GFP_KERNEL);    if (!irdata) {        ret = -ENOMEM;        goto out;    }    for (i = 0; i < count; i++) {        cur_sample_len = redrat3_us_to_len(txbuf[i]);        if (cur_sample_len > 0xffff) {            dev_warn(dev, "transmit period of %uus truncated to %uus/n",                     txbuf[i], redrat3_len_to_us(0xffff));            cur_sample_len = 0xffff;        }        for (lencheck = 0; lencheck < curlencheck; lencheck++) {            if (sample_lens[lencheck] == cur_sample_len)                break;        }        if (lencheck == curlencheck) {            rr3_dbg(dev, "txbuf[%d]=%u, pos %d, enc %u/n",                    i, txbuf[i], curlencheck, cur_sample_len);            if (curlencheck < RR3_DRIVER_MAXLENS) {                /* now convert the value to a proper                 * rr3 value.. */                sample_lens[curlencheck] = cur_sample_len;                put_unaligned_be16(cur_sample_len,                                   &irdata->lens[curlencheck]);                curlencheck++;            } else {                ret = -EINVAL;                goto out;            }        }        irdata->sigdata[i] = lencheck;    }    irdata->sigdata[count] = RR3_END_OF_SIGNAL;    irdata->sigdata[count + 1] = RR3_END_OF_SIGNAL;    sendbuf_len = offsetof(struct redrat3_irdata,                           sigdata[count + RR3_TX_TRAILER_LEN]);    /* fill in our packet header */    irdata->header.length = cpu_to_be16(sendbuf_len -                                        sizeof(struct redrat3_header));    irdata->header.transfer_type = cpu_to_be16(RR3_MOD_SIGNAL_OUT);    irdata->pause = cpu_to_be32(redrat3_len_to_us(100));    irdata->mod_freq_count = cpu_to_be16(mod_freq_to_val(rr3->carrier));    irdata->no_lengths = curlencheck;    irdata->sig_size = cpu_to_be16(count + RR3_TX_TRAILER_LEN);    pipe = usb_sndbulkpipe(rr3->udev, rr3->ep_out->bEndpointAddress);    ret = usb_bulk_msg(rr3->udev, pipe, irdata,                       sendbuf_len, &ret_len, 10 * HZ);    rr3_dbg(dev, "sent %d bytes, (ret %d)/n", ret_len, ret);    /* now tell the hardware to transmit what we sent it */    pipe = usb_rcvctrlpipe(rr3->udev, 0);    ret = usb_control_msg(rr3->udev, pipe, RR3_TX_SEND_SIGNAL,                          USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,                          0, 0, irdata, 2, HZ * 10);    if (ret < 0)        dev_err(dev, "Error: control msg send failed, rc %d/n", ret);    else        ret = count;out:    kfree(sample_lens);    kfree(irdata);//.........这里部分代码省略.........

static void redrat3_process_ir_data(struct redrat3_dev *rr3){    DEFINE_IR_RAW_EVENT(rawir);    struct device *dev;    unsigned i, trailer = 0;    unsigned sig_size, single_len, offset, val;    unsigned long delay;    u32 mod_freq;    if (!rr3) {        pr_err("%s called with no context!/n", __func__);        return;    }    rr3_ftr(rr3->dev, "Entered %s/n", __func__);    dev = rr3->dev;    /* Make sure we reset the IR kfifo after a bit of inactivity */    delay = usecs_to_jiffies(rr3->hw_timeout);    mod_timer(&rr3->rx_timeout, jiffies + delay);    mod_freq = redrat3_val_to_mod_freq(&rr3->irdata);    rr3_dbg(dev, "Got mod_freq of %u/n", mod_freq);    /* process each rr3 encoded byte into an int */    sig_size = be16_to_cpu(rr3->irdata.sig_size);    for (i = 0; i < sig_size; i++) {        offset = rr3->irdata.sigdata[i];        val = get_unaligned_be16(&rr3->irdata.lens[offset]);        single_len = redrat3_len_to_us(val);        /* we should always get pulse/space/pulse/space samples */        if (i % 2)            rawir.pulse = false;        else            rawir.pulse = true;        rawir.duration = US_TO_NS(single_len);        /* Save initial pulse length to fudge trailer */        if (i == 0)            trailer = rawir.duration;        /* cap the value to IR_MAX_DURATION */        rawir.duration &= IR_MAX_DURATION;        rr3_dbg(dev, "storing %s with duration %d (i: %d)/n",                rawir.pulse ? "pulse" : "space", rawir.duration, i);        ir_raw_event_store_with_filter(rr3->rc, &rawir);    }    /* add a trailing space, if need be */    if (i % 2) {        rawir.pulse = false;        /* this duration is made up, and may not be ideal... */        if (trailer < US_TO_NS(1000))            rawir.duration = US_TO_NS(2800);        else            rawir.duration = trailer;        rr3_dbg(dev, "storing trailing space with duration %d/n",                rawir.duration);        ir_raw_event_store_with_filter(rr3->rc, &rawir);    }    rr3_dbg(dev, "calling ir_raw_event_handle/n");    ir_raw_event_handle(rr3->rc);}

static int __devinit redrat3_dev_probe(struct usb_interface *intf,				       const struct usb_device_id *id){	struct usb_device *udev = interface_to_usbdev(intf);	struct device *dev = &intf->dev;	struct usb_host_interface *uhi;	struct redrat3_dev *rr3;	struct usb_endpoint_descriptor *ep;	struct usb_endpoint_descriptor *ep_in = NULL;	struct usb_endpoint_descriptor *ep_out = NULL;	u8 addr, attrs;	int pipe, i;	int retval = -ENOMEM;	rr3_ftr(dev, "%s called/n", __func__);	uhi = intf->cur_altsetting;	/*                                         */	for (i = 0; i < uhi->desc.bNumEndpoints; ++i) {		ep = &uhi->endpoint[i].desc;		addr = ep->bEndpointAddress;		attrs = ep->bmAttributes;		if ((ep_in == NULL) &&		    ((addr & USB_ENDPOINT_DIR_MASK) == USB_DIR_IN) &&		    ((attrs & USB_ENDPOINT_XFERTYPE_MASK) ==		     USB_ENDPOINT_XFER_BULK)) {			rr3_dbg(dev, "found bulk-in endpoint at 0x%02x/n",				ep->bEndpointAddress);			/*                                                  */			if (ep->bEndpointAddress == RR3_BULK_IN_EP_ADDR)				ep_in = ep;		}		if ((ep_out == NULL) &&		    ((addr & USB_ENDPOINT_DIR_MASK) == USB_DIR_OUT) &&		    ((attrs & USB_ENDPOINT_XFERTYPE_MASK) ==		     USB_ENDPOINT_XFER_BULK)) {			rr3_dbg(dev, "found bulk-out endpoint at 0x%02x/n",				ep->bEndpointAddress);			ep_out = ep;		}	}	if (!ep_in || !ep_out) {		dev_err(dev, "Couldn't find both in and out endpoints/n");		retval = -ENODEV;		goto no_endpoints;	}	/*                                                        */	rr3 = kzalloc(sizeof(*rr3), GFP_KERNEL);	if (rr3 == NULL) {		dev_err(dev, "Memory allocation failure/n");		goto no_endpoints;	}	rr3->dev = &intf->dev;	/*                         */	rr3->read_urb = usb_alloc_urb(0, GFP_KERNEL);	if (!rr3->read_urb) {		dev_err(dev, "Read urb allocation failure/n");		goto error;	}	rr3->ep_in = ep_in;	rr3->bulk_in_buf = usb_alloc_coherent(udev, ep_in->wMaxPacketSize,					      GFP_ATOMIC, &rr3->dma_in);	if (!rr3->bulk_in_buf) {		dev_err(dev, "Read buffer allocation failure/n");		goto error;	}	pipe = usb_rcvbulkpipe(udev, ep_in->bEndpointAddress);	usb_fill_bulk_urb(rr3->read_urb, udev, pipe,			  rr3->bulk_in_buf, ep_in->wMaxPacketSize,			  (usb_complete_t)redrat3_handle_async, rr3);	/*                         */	rr3->write_urb = usb_alloc_urb(0, GFP_KERNEL);	if (!rr3->write_urb) {		dev_err(dev, "Write urb allocation failure/n");		goto error;	}	rr3->ep_out = ep_out;	rr3->bulk_out_buf = usb_alloc_coherent(udev, ep_out->wMaxPacketSize,					       GFP_ATOMIC, &rr3->dma_out);	if (!rr3->bulk_out_buf) {		dev_err(dev, "Write buffer allocation failure/n");		goto error;	}	pipe = usb_sndbulkpipe(udev, ep_out->bEndpointAddress);	usb_fill_bulk_urb(rr3->write_urb, udev, pipe,			  rr3->bulk_out_buf, ep_out->wMaxPacketSize,			  (usb_complete_t)redrat3_write_bulk_callback, rr3);//.........这里部分代码省略.........

static void redrat3_process_ir_data(struct redrat3_dev *rr3){	DEFINE_IR_RAW_EVENT(rawir);	struct redrat3_signal_header header;	struct device *dev;	int i, trailer = 0;	unsigned long delay;	u32 mod_freq, single_len;	u16 *len_vals;	u8 *data_vals;	u32 tmp32;	u16 tmp16;	char *sig_data;	if (!rr3) {		pr_err("%s called with no context!/n", __func__);		return;	}	rr3_ftr(rr3->dev, "Entered %s/n", __func__);	dev = rr3->dev;	sig_data = rr3->pbuf;	header.length = rr3->pktlen;	header.transfer_type = rr3->pkttype;	/*              */	if (!(header.length >= RR3_HEADER_LENGTH))		dev_warn(dev, "read returned less than rr3 header len/n");	/*                                                           */	delay = usecs_to_jiffies(rr3->hw_timeout);	mod_timer(&rr3->rx_timeout, jiffies + delay);	memcpy(&tmp32, sig_data + RR3_PAUSE_OFFSET, sizeof(tmp32));	header.pause = be32_to_cpu(tmp32);	memcpy(&tmp16, sig_data + RR3_FREQ_COUNT_OFFSET, sizeof(tmp16));	header.mod_freq_count = be16_to_cpu(tmp16);	memcpy(&tmp16, sig_data + RR3_NUM_PERIOD_OFFSET, sizeof(tmp16));	header.no_periods = be16_to_cpu(tmp16);	header.max_lengths = sig_data[RR3_MAX_LENGTHS_OFFSET];	header.no_lengths = sig_data[RR3_NUM_LENGTHS_OFFSET];	memcpy(&tmp16, sig_data + RR3_MAX_SIGS_OFFSET, sizeof(tmp16));	header.max_sig_size = be16_to_cpu(tmp16);	memcpy(&tmp16, sig_data + RR3_NUM_SIGS_OFFSET, sizeof(tmp16));	header.sig_size = be16_to_cpu(tmp16);	header.no_repeats= sig_data[RR3_REPEATS_OFFSET];	if (debug) {		redrat3_dump_signal_header(&header);		redrat3_dump_signal_data(sig_data, header.sig_size);	}	mod_freq = redrat3_val_to_mod_freq(&header);	rr3_dbg(dev, "Got mod_freq of %u/n", mod_freq);	/*                                                      */	len_vals = (u16 *)(sig_data + RR3_HEADER_LENGTH);	data_vals = sig_data + RR3_HEADER_LENGTH +		    (header.max_lengths * sizeof(u16));	/*                                           */	for (i = 0; i < header.sig_size; i++) {		u16 val = len_vals[data_vals[i]];		single_len = redrat3_len_to_us((u32)be16_to_cpu(val));		/*                                                      */		if (i % 2)			rawir.pulse = false;		else			rawir.pulse = true;		rawir.duration = US_TO_NS(single_len);		/*                                            */		if (i == 0)			trailer = rawir.duration;		/*                                  */		rawir.duration &= IR_MAX_DURATION;		rr3_dbg(dev, "storing %s with duration %d (i: %d)/n",			rawir.pulse ? "pulse" : "space", rawir.duration, i);		ir_raw_event_store_with_filter(rr3->rc, &rawir);	}	/*                                  */	if (i % 2) {		rawir.pulse = false;		/*                                                   */		if (trailer < US_TO_NS(1000))			rawir.duration = US_TO_NS(2800);		else			rawir.duration = trailer;//.........这里部分代码省略.........

static int redrat3_transmit_ir(struct rc_dev *rcdev, unsigned *txbuf,				unsigned count){	struct redrat3_dev *rr3 = rcdev->priv;	struct device *dev = rr3->dev;	struct redrat3_signal_header header;	int i, j, ret, ret_len, offset;	int lencheck, cur_sample_len, pipe;	char *buffer = NULL, *sigdata = NULL;	int *sample_lens = NULL;	u32 tmpi;	u16 tmps;	u8 *datap;	u8 curlencheck = 0;	u16 *lengths_ptr;	int sendbuf_len;	rr3_ftr(dev, "Entering %s/n", __func__);	if (rr3->transmitting) {		dev_warn(dev, "%s: transmitter already in use/n", __func__);		return -EAGAIN;	}	if (count > (RR3_DRIVER_MAXLENS * 2))		return -EINVAL;	/*                                          */	rr3->det_enabled = false;	rr3->transmitting = true;	sample_lens = kzalloc(sizeof(int) * RR3_DRIVER_MAXLENS, GFP_KERNEL);	if (!sample_lens) {		ret = -ENOMEM;		goto out;	}	for (i = 0; i < count; i++) {		for (lencheck = 0; lencheck < curlencheck; lencheck++) {			cur_sample_len = redrat3_us_to_len(txbuf[i]);			if (sample_lens[lencheck] == cur_sample_len)				break;		}		if (lencheck == curlencheck) {			cur_sample_len = redrat3_us_to_len(txbuf[i]);			rr3_dbg(dev, "txbuf[%d]=%u, pos %d, enc %u/n",				i, txbuf[i], curlencheck, cur_sample_len);			if (curlencheck < 255) {				/*                                                     */				sample_lens[curlencheck] = cur_sample_len;				curlencheck++;			} else {				dev_err(dev, "signal too long/n");				ret = -EINVAL;				goto out;			}		}	}	sigdata = kzalloc((count + RR3_TX_TRAILER_LEN), GFP_KERNEL);	if (!sigdata) {		ret = -ENOMEM;		goto out;	}	sigdata[count] = RR3_END_OF_SIGNAL;	sigdata[count + 1] = RR3_END_OF_SIGNAL;	for (i = 0; i < count; i++) {		for (j = 0; j < curlencheck; j++) {			if (sample_lens[j] == redrat3_us_to_len(txbuf[i]))				sigdata[i] = j;		}	}	offset = RR3_TX_HEADER_OFFSET;	sendbuf_len = RR3_HEADER_LENGTH + (sizeof(u16) * RR3_DRIVER_MAXLENS)			+ count + RR3_TX_TRAILER_LEN + offset;	buffer = kzalloc(sendbuf_len, GFP_KERNEL);	if (!buffer) {		ret = -ENOMEM;		goto out;	}	/*                           */	header.length = sendbuf_len - offset;	header.transfer_type = RR3_MOD_SIGNAL_OUT;	header.pause = redrat3_len_to_us(100);	header.mod_freq_count = mod_freq_to_val(rr3->carrier);	header.no_periods = 0; /*                 */	header.max_lengths = RR3_DRIVER_MAXLENS;	header.no_lengths = curlencheck;	header.max_sig_size = RR3_MAX_SIG_SIZE;	header.sig_size = count + RR3_TX_TRAILER_LEN;	/*                                                                */	header.no_repeats = 0;	tmps = cpu_to_be16(header.length);	memcpy(buffer, &tmps, 2);//.........这里部分代码省略.........

static int redrat3_dev_probe(struct usb_interface *intf,                             const struct usb_device_id *id){    struct usb_device *udev = interface_to_usbdev(intf);    struct device *dev = &intf->dev;    struct usb_host_interface *uhi;    struct redrat3_dev *rr3;    struct usb_endpoint_descriptor *ep;    struct usb_endpoint_descriptor *ep_in = NULL;    struct usb_endpoint_descriptor *ep_out = NULL;    u8 addr, attrs;    int pipe, i;    int retval = -ENOMEM;    rr3_ftr(dev, "%s called/n", __func__);    uhi = intf->cur_altsetting;    /* find our bulk-in and bulk-out endpoints */    for (i = 0; i < uhi->desc.bNumEndpoints; ++i) {        ep = &uhi->endpoint[i].desc;        addr = ep->bEndpointAddress;        attrs = ep->bmAttributes;        if ((ep_in == NULL) &&                ((addr & USB_ENDPOINT_DIR_MASK) == USB_DIR_IN) &&                ((attrs & USB_ENDPOINT_XFERTYPE_MASK) ==                 USB_ENDPOINT_XFER_BULK)) {            rr3_dbg(dev, "found bulk-in endpoint at 0x%02x/n",                    ep->bEndpointAddress);            /* data comes in on 0x82, 0x81 is for other data... */            if (ep->bEndpointAddress == RR3_BULK_IN_EP_ADDR)                ep_in = ep;        }        if ((ep_out == NULL) &&                ((addr & USB_ENDPOINT_DIR_MASK) == USB_DIR_OUT) &&                ((attrs & USB_ENDPOINT_XFERTYPE_MASK) ==                 USB_ENDPOINT_XFER_BULK)) {            rr3_dbg(dev, "found bulk-out endpoint at 0x%02x/n",                    ep->bEndpointAddress);            ep_out = ep;        }    }    if (!ep_in || !ep_out) {        dev_err(dev, "Couldn't find both in and out endpoints/n");        retval = -ENODEV;        goto no_endpoints;    }    /* allocate memory for our device state and initialize it */    rr3 = kzalloc(sizeof(*rr3), GFP_KERNEL);    if (rr3 == NULL) {        dev_err(dev, "Memory allocation failure/n");        goto no_endpoints;    }    rr3->dev = &intf->dev;    /* set up bulk-in endpoint */    rr3->read_urb = usb_alloc_urb(0, GFP_KERNEL);    if (!rr3->read_urb) {        dev_err(dev, "Read urb allocation failure/n");        goto error;    }    rr3->ep_in = ep_in;    rr3->bulk_in_buf = usb_alloc_coherent(udev,                                          le16_to_cpu(ep_in->wMaxPacketSize), GFP_ATOMIC, &rr3->dma_in);    if (!rr3->bulk_in_buf) {        dev_err(dev, "Read buffer allocation failure/n");        goto error;    }    pipe = usb_rcvbulkpipe(udev, ep_in->bEndpointAddress);    usb_fill_bulk_urb(rr3->read_urb, udev, pipe, rr3->bulk_in_buf,                      le16_to_cpu(ep_in->wMaxPacketSize), redrat3_handle_async, rr3);    rr3->ep_out = ep_out;    rr3->udev = udev;    redrat3_reset(rr3);    redrat3_get_firmware_rev(rr3);    /* might be all we need to do? */    retval = redrat3_enable_detector(rr3);    if (retval < 0)        goto error;    /* store current hardware timeout, in us, will use for kfifo resets */    rr3->hw_timeout = redrat3_get_timeout(rr3);    /* default.. will get overridden by any sends with a freq defined */    rr3->carrier = 38000;    /* led control */    rr3->led.name = "redrat3:red:feedback";    rr3->led.default_trigger = "rc-feedback";    rr3->led.brightness_set = redrat3_brightness_set;//.........这里部分代码省略.........