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

static int arvo_init_specials(struct hid_device *hdev){	struct usb_interface *intf = to_usb_interface(hdev->dev.parent);	struct usb_device *usb_dev = interface_to_usbdev(intf);	struct arvo_device *arvo;	int retval;	if (intf->cur_altsetting->desc.bInterfaceProtocol			== USB_INTERFACE_PROTOCOL_KEYBOARD) {		hid_set_drvdata(hdev, NULL);		return 0;	}	arvo = kzalloc(sizeof(*arvo), GFP_KERNEL);	if (!arvo) {		hid_err(hdev, "can't alloc device descriptor/n");		return -ENOMEM;	}	hid_set_drvdata(hdev, arvo);	retval = arvo_init_arvo_device_struct(usb_dev, arvo);	if (retval) {		hid_err(hdev, "couldn't init struct arvo_device/n");		goto exit_free;	}	retval = roccat_connect(arvo_class, hdev,			sizeof(struct arvo_roccat_report));	if (retval < 0) {		hid_err(hdev, "couldn't init char dev/n");	} else {		arvo->chrdev_minor = retval;		arvo->roccat_claimed = 1;	}	return 0;exit_free:	kfree(arvo);	return retval;}

static ssize_t pyra_sysfs_write_settings(struct file *fp,		struct kobject *kobj, struct bin_attribute *attr, char *buf,		loff_t off, size_t count){	struct device *dev =			container_of(kobj, struct device, kobj)->parent->parent;	struct pyra_device *pyra = hid_get_drvdata(dev_get_drvdata(dev));	struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));	int retval = 0;	int difference;	struct pyra_roccat_report roccat_report;	if (off != 0 || count != sizeof(struct pyra_settings))		return -EINVAL;	mutex_lock(&pyra->pyra_lock);	difference = memcmp(buf, &pyra->settings, sizeof(struct pyra_settings));	if (difference) {		retval = pyra_set_settings(usb_dev,				(struct pyra_settings const *)buf);		if (retval) {			mutex_unlock(&pyra->pyra_lock);			return retval;		}		memcpy(&pyra->settings, buf,				sizeof(struct pyra_settings));		profile_activated(pyra, pyra->settings.startup_profile);		roccat_report.type = PYRA_MOUSE_EVENT_BUTTON_TYPE_PROFILE_2;		roccat_report.value = pyra->settings.startup_profile + 1;		roccat_report.key = 0;		roccat_report_event(pyra->chrdev_minor,				(uint8_t const *)&roccat_report);	}	mutex_unlock(&pyra->pyra_lock);	return sizeof(struct pyra_settings);}

static void razer_kbd_disconnect(struct hid_device *hdev){    struct razer_kbd_device *dev;    struct usb_interface *intf = to_usb_interface(hdev->dev.parent);    dev = hid_get_drvdata(hdev);    device_remove_file(&hdev->dev, &dev_attr_mode_wave);    device_remove_file(&hdev->dev, &dev_attr_mode_spectrum);    device_remove_file(&hdev->dev, &dev_attr_mode_none);    device_remove_file(&hdev->dev, &dev_attr_mode_reactive);    device_remove_file(&hdev->dev, &dev_attr_mode_breath);    device_remove_file(&hdev->dev, &dev_attr_mode_custom);    device_remove_file(&hdev->dev, &dev_attr_mode_static);    device_remove_file(&hdev->dev, &dev_attr_temp_clear_row);    device_remove_file(&hdev->dev, &dev_attr_set_key_row);    device_remove_file(&hdev->dev, &dev_attr_reset);    device_remove_file(&hdev->dev, &dev_attr_macro_keys);    device_remove_file(&hdev->dev, &dev_attr_set_brightness);    hid_hw_stop(hdev);    kfree(dev);    dev_info(&intf->dev, "Razer Blackwidow Chroma disconnected/n");}

static ssize_t razer_attr_write_set_key_row(struct device *dev, struct device_attribute *attr,               const char *buf, size_t count)       {                                       struct usb_interface *intf = to_usb_interface(dev->parent);         //struct razer_kbd_device *widow = usb_get_intfdata(intf);               struct usb_device *usb_dev = interface_to_usbdev(intf);    size_t buf_size = (RAZER_BLACKWIDOW_CHROMA_ROW_LEN+1)*3 + 1;    //printk(KERN_ALERT "sizeof(razer_row_rgb): %d/n",sizeof(struct razer_row_rgb));    size_t offset = 0;    while(offset<count)    {        unsigned char row_index = (unsigned char)buf[offset];        if(count-offset < buf_size)        {            printk(KERN_ALERT "Wrong Amount of RGB data provided: %d of %d/n",(int)count,(int)buf_size);            return 0;        }        razer_set_key_row(usb_dev,row_index,(struct razer_row_rgb*)&buf[offset+1]);        offset += buf_size;    }    return count;                           }                                   

static int usb_port_runtime_suspend(struct device *dev){	struct usb_port *port_dev = to_usb_port(dev);	struct usb_device *hdev = to_usb_device(dev->parent->parent);	struct usb_interface *intf = to_usb_interface(dev->parent);	struct usb_hub *hub = usb_hub_to_struct_hub(hdev);	struct usb_port *peer = port_dev->peer;	int port1 = port_dev->portnum;	int retval;	if (!hub)		return -EINVAL;	if (hub->in_reset)		return -EBUSY;	if (dev_pm_qos_flags(&port_dev->dev, PM_QOS_FLAG_NO_POWER_OFF)			== PM_QOS_FLAGS_ALL)		return -EAGAIN;	if (usb_port_block_power_off)		return -EBUSY;	usb_autopm_get_interface(intf);	retval = usb_hub_set_port_power(hdev, hub, port1, false);	usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_C_CONNECTION);	if (!port_dev->is_superspeed)		usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_C_ENABLE);	usb_autopm_put_interface(intf);	/*	 * Our peer usb3 port may now be able to suspend, so	 * asynchronously queue a suspend request to observe that this	 * usb2 port is now off.	 */	if (!port_dev->is_superspeed && peer)		pm_runtime_put(&peer->dev);	return retval;}

static ssize_t konepure_sysfs_read(struct file *fp, struct kobject *kobj,		char *buf, loff_t off, size_t count,		size_t real_size, uint command){	struct device *dev =			container_of(kobj, struct device, kobj)->parent->parent;	struct konepure_device *konepure = hid_get_drvdata(dev_get_drvdata(dev));	struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));	int retval;	if (off >= real_size)		return 0;	if (off != 0 || count != real_size)		return -EINVAL;	mutex_lock(&konepure->konepure_lock);	retval = roccat_common2_receive(usb_dev, command, buf, real_size);	mutex_unlock(&konepure->konepure_lock);	return retval ? retval : real_size;}

static void logi_dj_recv_add_djhid_device(struct dj_receiver_dev *djrcv_dev,					  struct dj_report *dj_report){	/* Called in delayed work context */	struct hid_device *djrcv_hdev = djrcv_dev->hdev;	struct usb_interface *intf = to_usb_interface(djrcv_hdev->dev.parent);	struct usb_device *usbdev = interface_to_usbdev(intf);	struct hid_device *dj_hiddev;	struct dj_device *dj_dev;	/* Device index goes from 1 to 6, we need 3 bytes to store the	 * semicolon, the index, and a null terminator	 */	unsigned char tmpstr[3];	if (dj_report->report_params[DEVICE_PAIRED_PARAM_SPFUNCTION] &	    SPFUNCTION_DEVICE_LIST_EMPTY) {		dbg_hid("%s: device list is empty/n", __func__);		return;	}<<<<<<< HEAD

static ssize_t isku_sysfs_read(struct file *fp, struct kobject *kobj,		char *buf, loff_t off, size_t count,		size_t real_size, uint command){	struct device *dev =			container_of(kobj, struct device, kobj)->parent->parent;	struct isku_device *isku = hid_get_drvdata(dev_get_drvdata(dev));	struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));	int retval;	if (off >= real_size)		return 0;	if (off != 0 || count > real_size)		return -EINVAL;	mutex_lock(&isku->isku_lock);	retval = isku_receive(usb_dev, command, buf, count);	mutex_unlock(&isku->isku_lock);	return retval ? retval : count;}

/** * Write device file "mode_breath" */static ssize_t razer_attr_write_mode_breath(struct device *dev, struct device_attribute *attr, const char *buf, size_t count){    struct usb_interface *intf = to_usb_interface(dev->parent);    struct usb_device *usb_dev = interface_to_usbdev(intf);    const char *alt_buf[6] = { 0 };    if(count == 3)    {        // Single colour mode        razer_set_breath_mode(usb_dev, 0x01, (struct razer_rgb*)&buf[0], (struct razer_rgb*)&alt_buf[3]);    } else if(count == 6)    {        // Dual colour mode        razer_set_breath_mode(usb_dev, 0x02, (struct razer_rgb*)&buf[0], (struct razer_rgb*)&buf[3]);    } else    {        // "Random" colour mode        razer_set_breath_mode(usb_dev, 0x03, (struct razer_rgb*)&alt_buf[0], (struct razer_rgb*)&alt_buf[3]);    }    return count;}

static ssize_t koneplus_sysfs_write(struct file *fp, struct kobject *kobj,		void const *buf, loff_t off, size_t count,		size_t real_size, uint command){	struct device *dev =			container_of(kobj, struct device, kobj)->parent->parent;	struct koneplus_device *koneplus = hid_get_drvdata(dev_get_drvdata(dev));	struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));	int retval;	if (off != 0 || count != real_size)		return -EINVAL;	mutex_lock(&koneplus->koneplus_lock);	retval = koneplus_send(usb_dev, command, buf, real_size);	mutex_unlock(&koneplus->koneplus_lock);	if (retval)		return retval;	return real_size;}

/** * Unbind function */static void razer_kraken_disconnect(struct hid_device *hdev){    struct razer_kraken_device *dev;    struct usb_interface *intf = to_usb_interface(hdev->dev.parent);    dev = hid_get_drvdata(hdev);    if(dev->usb_interface_protocol == USB_INTERFACE_PROTOCOL_NONE) {        device_remove_file(&hdev->dev, &dev_attr_version);                               // Get driver version        device_remove_file(&hdev->dev, &dev_attr_test);                                  // Test mode        device_remove_file(&hdev->dev, &dev_attr_device_type);                           // Get string of device type        device_remove_file(&hdev->dev, &dev_attr_device_serial);                         // Get string of device serial        device_remove_file(&hdev->dev, &dev_attr_firmware_version);                      // Get string of device fw version        device_remove_file(&hdev->dev, &dev_attr_device_mode);                           // Get device mode        switch(dev->usb_pid) {        case USB_DEVICE_ID_RAZER_KRAKEN_CLASSIC:        case USB_DEVICE_ID_RAZER_KRAKEN_CLASSIC_ALT:            device_remove_file(&hdev->dev, &dev_attr_matrix_effect_none);            // No effect            device_remove_file(&hdev->dev, &dev_attr_matrix_effect_static);          // Static effect            device_remove_file(&hdev->dev, &dev_attr_matrix_current_effect);         // Get current effect            break;        case USB_DEVICE_ID_RAZER_KRAKEN:        case USB_DEVICE_ID_RAZER_KRAKEN_V2:            device_remove_file(&hdev->dev, &dev_attr_matrix_effect_none);            // No effect            device_remove_file(&hdev->dev, &dev_attr_matrix_effect_spectrum);        // Spectrum effect            device_remove_file(&hdev->dev, &dev_attr_matrix_effect_static);          // Static effect            device_remove_file(&hdev->dev, &dev_attr_matrix_effect_custom);          // Custom effect            device_remove_file(&hdev->dev, &dev_attr_matrix_effect_breath);          // Brething effect            device_remove_file(&hdev->dev, &dev_attr_matrix_current_effect);         // Get current effect            break;        }    }    hid_hw_stop(hdev);    kfree(dev);    dev_info(&intf->dev, "Razer Device disconnected/n");}

static int usb_port_runtime_resume(struct device *dev){	struct usb_port *port_dev = to_usb_port(dev);	struct usb_device *hdev = to_usb_device(dev->parent->parent);	struct usb_interface *intf = to_usb_interface(dev->parent);	struct usb_hub *hub = usb_hub_to_struct_hub(hdev);	int port1 = port_dev->portnum;	int retval;	if (!hub)		return -EINVAL;	usb_autopm_get_interface(intf);	set_bit(port1, hub->busy_bits);	retval = usb_hub_set_port_power(hdev, hub, port1, true);	if (port_dev->child && !retval) {		/*		 * Wait for usb hub port to be reconnected in order to make		 * the resume procedure successful.		 */		retval = hub_port_debounce_be_connected(hub, port1);		if (retval < 0) {			dev_dbg(&port_dev->dev, "can't get reconnection after setting port  power on, status %d/n",					retval);			goto out;		}		usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_C_ENABLE);		/* Set return value to 0 if debounce successful */		retval = 0;	}out:	clear_bit(port1, hub->busy_bits);	usb_autopm_put_interface(intf);	return retval;}

/** * * Write device file "set_brightness" * * Sets the brightness to the ASCII number written to this file. */static ssize_t razer_attr_write_set_brightness(struct device *dev, struct device_attribute *attr, const char *buf, size_t count){    struct usb_interface *intf = to_usb_interface(dev->parent);    struct usb_device *usb_dev = interface_to_usbdev(intf);    struct razer_report report = {0};    unsigned char brightness = (unsigned char)simple_strtoul(buf, NULL, 10);    switch (usb_dev->descriptor.idProduct) {    case USB_DEVICE_ID_RAZER_GOLIATHUS_CHROMA:    case USB_DEVICE_ID_RAZER_GOLIATHUS_CHROMA_EXTENDED:        report = razer_chroma_extended_matrix_brightness(VARSTORE, ZERO_LED, brightness);        saved_brightness = brightness;        break;    default:        report = razer_chroma_standard_set_led_brightness(VARSTORE, BACKLIGHT_LED, brightness);        break;    }    razer_send_payload(usb_dev, &report);    return count;}

/** * Read device file "set_brightness" * * Returns brightness or -1 if the initial brightness is not known */static ssize_t razer_attr_read_set_brightness(struct device *dev, struct device_attribute *attr, char *buf){    struct usb_interface *intf = to_usb_interface(dev->parent);    struct usb_device *usb_dev = interface_to_usbdev(intf);    struct razer_report response = {0};    struct razer_report report = {0};    unsigned char brightness = 0;    switch (usb_dev->descriptor.idProduct) {    case USB_DEVICE_ID_RAZER_GOLIATHUS_CHROMA:    case USB_DEVICE_ID_RAZER_GOLIATHUS_CHROMA_EXTENDED:        brightness = saved_brightness;        break;    default:        report = razer_chroma_standard_get_led_brightness(VARSTORE, BACKLIGHT_LED);;        response = razer_send_payload(usb_dev, &report);        brightness = response.arguments[2];        break;    }    return sprintf(buf, "%d/n", brightness);}

/** * Read device file "device_type" * * Returns friendly string of device type */static ssize_t razer_attr_read_device_type(struct device *dev, struct device_attribute *attr,                char *buf){    struct usb_interface *intf = to_usb_interface(dev->parent);    //struct razer_kbd_device *widow = usb_get_intfdata(intf);    struct usb_device *usb_dev = interface_to_usbdev(intf);    int write_count = 0;    if(usb_dev->descriptor.idProduct == USB_DEVICE_ID_RAZER_BLACKWIDOW_CHROMA)    {        write_count = sprintf(buf, "Razer BlackWidow Chroma/n");    } else if(usb_dev->descriptor.idProduct == USB_DEVICE_ID_RAZER_BLACKWIDOW_CHROMA_TE)    {        write_count = sprintf(buf, "Razer BlackWidow Chroma Tournament Edition/n");    } else if(usb_dev->descriptor.idProduct == USB_DEVICE_ID_RAZER_BLACKWIDOW_ULTIMATE_2013)    {        write_count = sprintf(buf, "Razer BlackWidow Ultimate 2013/n");    } else    {        write_count = sprintf(buf, "Unknown Device/n");    }    return write_count;}

static intmt76u_tx_queue_skb(struct mt76_dev *dev, struct mt76_queue *q,		   struct sk_buff *skb, struct mt76_wcid *wcid,		   struct ieee80211_sta *sta){	struct usb_interface *intf = to_usb_interface(dev->dev);	struct usb_device *udev = interface_to_usbdev(intf);	u8 ep = q2ep(q->hw_idx);	struct mt76u_buf *buf;	u16 idx = q->tail;	unsigned int pipe;	int err;	if (q->queued == q->ndesc)		return -ENOSPC;	err = dev->drv->tx_prepare_skb(dev, NULL, skb, q, wcid, sta, NULL);	if (err < 0)		return err;	buf = &q->entry[idx].ubuf;	buf->done = false;	err = mt76u_tx_build_sg(skb, buf->urb);	if (err < 0)		return err;	pipe = usb_sndbulkpipe(udev, dev->usb.out_ep[ep]);	usb_fill_bulk_urb(buf->urb, udev, pipe, NULL, skb->len,			  mt76u_complete_tx, buf);	q->tail = (q->tail + 1) % q->ndesc;	q->entry[idx].skb = skb;	q->queued++;	return idx;}

static ssize_t pyra_sysfs_write_settings(struct file *fp,		struct kobject *kobj, struct bin_attribute *attr, char *buf,		loff_t off, size_t count){	struct device *dev = kobj_to_dev(kobj)->parent->parent;	struct pyra_device *pyra = hid_get_drvdata(dev_get_drvdata(dev));	struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));	int retval = 0;	struct pyra_roccat_report roccat_report;	struct pyra_settings const *settings;	if (off != 0 || count != PYRA_SIZE_SETTINGS)		return -EINVAL;	settings = (struct pyra_settings const *)buf;	if (settings->startup_profile >= ARRAY_SIZE(pyra->profile_settings))		return -EINVAL;	mutex_lock(&pyra->pyra_lock);	retval = pyra_set_settings(usb_dev, settings);	if (retval) {		mutex_unlock(&pyra->pyra_lock);		return retval;	}	profile_activated(pyra, settings->startup_profile);	roccat_report.type = PYRA_MOUSE_EVENT_BUTTON_TYPE_PROFILE_2;	roccat_report.value = settings->startup_profile + 1;	roccat_report.key = 0;	roccat_report_event(pyra->chrdev_minor,			(uint8_t const *)&roccat_report);	mutex_unlock(&pyra->pyra_lock);	return PYRA_SIZE_SETTINGS;}

/** * Write device file "mode_static" * * Set the keyboard to static mode when 3 RGB bytes are written */static ssize_t razer_attr_write_mode_static(struct device *dev, struct device_attribute *attr, const char *buf, size_t count){    struct usb_interface *intf = to_usb_interface(dev->parent);    struct usb_device *usb_dev = interface_to_usbdev(intf);    if(usb_dev->descriptor.idProduct == USB_DEVICE_ID_RAZER_BLACKWIDOW_ULTIMATE_2013)    {        // Set BlackWidow Ultimate to static colour        razer_set_static_mode_blackwidow_ultimate(usb_dev);    } else if(usb_dev->descriptor.idProduct == USB_DEVICE_ID_RAZER_BLACKWIDOW_CHROMA)    {        // Set BlackWidow Chroma to static colour        if(count == 3)        {            razer_set_static_mode(usb_dev, (struct razer_rgb*)&buf[0]);        }    } else    {        printk(KERN_WARNING "razerkbd: Cannot set static mode for this device");    }    return count;}

/** * Unbind function */static void razer_kbd_disconnect(struct hid_device *hdev){    struct razer_kbd_device *dev;    struct usb_interface *intf = to_usb_interface(hdev->dev.parent);    struct usb_device *usb_dev = interface_to_usbdev(intf);    dev = hid_get_drvdata(hdev);    if(usb_dev->descriptor.idProduct == USB_DEVICE_ID_RAZER_BLACKWIDOW_ULTIMATE_2013)    {        device_remove_file(&hdev->dev, &dev_attr_mode_pulsate);    } else    {        device_remove_file(&hdev->dev, &dev_attr_mode_wave);        device_remove_file(&hdev->dev, &dev_attr_mode_spectrum);        device_remove_file(&hdev->dev, &dev_attr_mode_none);        device_remove_file(&hdev->dev, &dev_attr_mode_reactive);        device_remove_file(&hdev->dev, &dev_attr_mode_breath);        device_remove_file(&hdev->dev, &dev_attr_mode_custom);        device_remove_file(&hdev->dev, &dev_attr_temp_clear_row);        device_remove_file(&hdev->dev, &dev_attr_set_key_row);    }    device_remove_file(&hdev->dev, &dev_attr_mode_game);    device_remove_file(&hdev->dev, &dev_attr_get_serial);    device_remove_file(&hdev->dev, &dev_attr_mode_static);    device_remove_file(&hdev->dev, &dev_attr_reset);    device_remove_file(&hdev->dev, &dev_attr_macro_keys);    device_remove_file(&hdev->dev, &dev_attr_set_brightness);    device_remove_file(&hdev->dev, &dev_attr_test);    device_remove_file(&hdev->dev, &dev_attr_device_type);    hid_hw_stop(hdev);    kfree(dev);    dev_info(&intf->dev, "Razer Device disconnected/n");}

static ssize_t pyra_sysfs_read(struct file *fp, struct kobject *kobj,		char *buf, loff_t off, size_t count,		size_t real_size, uint command){	struct device *dev = kobj_to_dev(kobj)->parent->parent;	struct pyra_device *pyra = hid_get_drvdata(dev_get_drvdata(dev));	struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));	int retval;	if (off >= real_size)		return 0;	if (off != 0 || count != real_size)		return -EINVAL;	mutex_lock(&pyra->pyra_lock);	retval = roccat_common2_receive(usb_dev, command, buf, real_size);	mutex_unlock(&pyra->pyra_lock);	if (retval)		return retval;	return real_size;}

static ssize_t kovaplus_sysfs_write_profile_settings(struct file *fp,		struct kobject *kobj, struct bin_attribute *attr, char *buf,		loff_t off, size_t count){	struct device *dev =			container_of(kobj, struct device, kobj)->parent->parent;	struct kovaplus_device *kovaplus = hid_get_drvdata(dev_get_drvdata(dev));	struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));	int retval = 0;	int difference;	int profile_index;	struct kovaplus_profile_settings *profile_settings;	if (off != 0 || count != sizeof(struct kovaplus_profile_settings))		return -EINVAL;	profile_index = ((struct kovaplus_profile_settings const *)buf)->profile_index;	profile_settings = &kovaplus->profile_settings[profile_index];	mutex_lock(&kovaplus->kovaplus_lock);	difference = memcmp(buf, profile_settings,			sizeof(struct kovaplus_profile_settings));	if (difference) {		retval = kovaplus_set_profile_settings(usb_dev,				(struct kovaplus_profile_settings const *)buf);		if (!retval)			memcpy(profile_settings, buf,					sizeof(struct kovaplus_profile_settings));	}	mutex_unlock(&kovaplus->kovaplus_lock);	if (retval)		return retval;	return sizeof(struct kovaplus_profile_settings);}

/** * Write device file "matrix_reactive_trigger" * * It triggers the mouse pad when written to */static ssize_t razer_attr_write_mode_reactive_trigger(struct device *dev, struct device_attribute *attr, const char *buf, size_t count){    struct usb_interface *intf = to_usb_interface(dev->parent);    struct usb_device *usb_dev = interface_to_usbdev(intf);    struct razer_report report = {0};    struct razer_rgb rgb = {0};    switch (usb_dev->descriptor.idProduct) {    case USB_DEVICE_ID_RAZER_GOLIATHUS_CHROMA:    case USB_DEVICE_ID_RAZER_GOLIATHUS_CHROMA_EXTENDED:        // TODO: Fix reactive trigger for Goliathus        report = razer_chroma_extended_matrix_effect_reactive(VARSTORE, ZERO_LED, 0, &rgb);        break;    default:        // TODO: Issue zeroed out razer_chroma_standard_matrix_effect_reactive report        report = razer_chroma_misc_matrix_reactive_trigger();        break;    }    razer_send_payload(usb_dev, &report);    return count;}

static ssize_t set_attr_decimals(struct device *dev,                                 struct device_attribute *attr, const char *buf, size_t count){    struct usb_interface *intf = to_usb_interface(dev);    struct usb_sevsegdev *mydev = usb_get_intfdata(intf);    size_t end = my_memlen(buf, count);    int i;    if (end > sizeof(mydev->decimals))        return -EINVAL;    for (i = 0; i < end; i++)        if (buf[i] != '0' && buf[i] != '1')            return -EINVAL;    memset(mydev->decimals, 0, sizeof(mydev->decimals));    for (i = 0; i < end; i++)        if (buf[i] == '1')            mydev->decimals[end-1-i] = 1;    update_display_visual(mydev, GFP_KERNEL);    return count;}

static int pcan_usb_do_cleanup(struct device *dev, void *arg){	struct usb_interface *intf;	struct pcan_usb_interface *usb_if;	struct pcandev *pdev;	int c;	DPRINTK(KERN_DEBUG "%s: %s()/n", DEVICE_NAME, __FUNCTION__);	intf = to_usb_interface(dev);	usb_if = (struct pcan_usb_interface *)usb_get_intfdata(intf);	/* Browse controllers list */	for (pdev=&usb_if->dev[c=0]; c < usb_if->dev_ctrl_count; c++, pdev++)	{		if (pdev->ucPhysicallyInstalled)			/* Last chance for URB submitting */			if (usb_if->device_ctrl_cleanup)				usb_if->device_ctrl_cleanup(pdev);	}	return 0;}

/* * Sending HID_REQ_GET_REPORT changes the operation mode of the ps3 controller * to "operational".  Without this, the ps3 controller will not report any * events. */static int sixaxis_set_operational_usb(struct hid_device *hdev){	struct usb_interface *intf = to_usb_interface(hdev->dev.parent);	struct usb_device *dev = interface_to_usbdev(intf);	__u16 ifnum = intf->cur_altsetting->desc.bInterfaceNumber;	int ret;	char *buf = kmalloc(18, GFP_KERNEL);	if (!buf)		return -ENOMEM;	ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),				 HID_REQ_GET_REPORT,				 USB_DIR_IN | USB_TYPE_CLASS |				 USB_RECIP_INTERFACE,				 (3 << 8) | 0xf2, ifnum, buf, 17,				 USB_CTRL_GET_TIMEOUT);	if (ret < 0)		hid_err(hdev, "can't set operational mode/n");	kfree(buf);	return ret;}

static ssize_t pyra_sysfs_write_profile_buttons(struct file *fp,		struct kobject *kobj, struct bin_attribute *attr, char *buf,		loff_t off, size_t count){	struct device *dev =			container_of(kobj, struct device, kobj)->parent->parent;	struct pyra_device *pyra = hid_get_drvdata(dev_get_drvdata(dev));	struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));	int retval = 0;	int difference;	int profile_number;	struct pyra_profile_buttons *profile_buttons;	if (off != 0 || count != sizeof(struct pyra_profile_buttons))		return -EINVAL;	profile_number = ((struct pyra_profile_buttons const *)buf)->number;	profile_buttons = &pyra->profile_buttons[profile_number];	mutex_lock(&pyra->pyra_lock);	difference = memcmp(buf, profile_buttons,			sizeof(struct pyra_profile_buttons));	if (difference) {		retval = pyra_set_profile_buttons(usb_dev,				(struct pyra_profile_buttons const *)buf);		if (!retval)			memcpy(profile_buttons, buf,					sizeof(struct pyra_profile_buttons));	}	mutex_unlock(&pyra->pyra_lock);	if (retval)		return retval;	return sizeof(struct pyra_profile_buttons);}