static void ush_hsic_port_disable(struct pci_dev *pdev) { printk(KERN_ERR "%s---->\n", __func__); #if 1 if (hsic.modem_dev) { struct usb_device *hdev; dev_dbg(&pci_dev->dev, "%s----> disconnect modem\n", __func__); hdev = hsic.modem_dev->parent; usb_disable_autosuspend(hsic.modem_dev); usb_disable_autosuspend(hsic.rh_dev); if (hdev->children[HSIC_USH_PORT - 1] == hsic.modem_dev) { printk(KERN_ERR "%s----> usb disconnect\n", __func__); usb_disconnect(&hsic.modem_dev); hdev->children[HSIC_USH_PORT - 1] = NULL; } } #endif if (hsic.rh_dev) { dev_dbg(&pci_dev->dev, "%s----> disable port\n", __func__); printk(KERN_ERR "%s----> disable PP\n", __func__); clear_port_feature(hsic.rh_dev, HSIC_USH_PORT, USB_PORT_FEAT_POWER); } hsic.hsic_stopped = 1; hsic_enable = 0; }
static void ush_hsic_port_disable(void) { hsic_enable = 0; if ((hsic.modem_dev) && (hsic.autosuspend_enable != 0)) { dev_dbg(&pci_dev->dev, "Disable auto suspend in port disable\n"); usb_disable_autosuspend(hsic.modem_dev); usb_disable_autosuspend(hsic.rh_dev); hsic.autosuspend_enable = 0; } if (hsic.rh_dev) { if (hsic.autosuspend_enable != 0) { dev_dbg(&pci_dev->dev, "Disable auto suspend in port disable\n"); usb_disable_autosuspend(hsic.rh_dev); hsic.autosuspend_enable = 0; } clear_port_feature(hsic.rh_dev, HSIC_USH_PORT, USB_PORT_FEAT_POWER); usb_enable_autosuspend(hsic.rh_dev); hsic.autosuspend_enable = 1; } s3_wake_unlock(); }
// // Description: Leave all power save mode: LPS, FwLPS, IPS if needed. // Move code to function by tynli. 2010.03.26. // void LeaveAllPowerSaveMode(IN struct rtl_priv *rtlpriv) { struct mlme_priv *pmlmepriv = &(rtlpriv->mlmepriv); uint8_t enqueue = 0; //DBG_871X("%s.....\n",__FUNCTION__); if (check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE) { //connect rtw_lps_ctrl_wk_cmd(rtlpriv, LPS_CTRL_LEAVE, enqueue); } else { if(rtlpriv->pwrctrlpriv.rf_pwrstate== rf_off) { #ifdef CONFIG_AUTOSUSPEND if(rtlpriv->registrypriv.usbss_enable) { usb_disable_autosuspend(rtl_usbdev(rtlpriv)->pusbdev); } else #endif { } } } }
void LeaveAllPowerSaveMode(struct rtw_adapter *adapter) { struct mlme_priv *pmlmepriv = &(adapter->mlmepriv); /* DBG_8192D("%s.....\n",__func__); */ if (check_fwstate(pmlmepriv, _FW_LINKED) == true) { /* connect */ #ifdef CONFIG_LPS /* DBG_8192D("==> leave LPS.......\n"); */ rtw_lps_leave(adapter); #endif } else { if (adapter->pwrctrlpriv.rf_pwrstate == rf_off) { #ifdef CONFIG_AUTOSUSPEND if (adapter->registrypriv.usbss_enable) { #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 35)) usb_disable_autosuspend(adapter_to_dvobj (adapter)->pusbdev); #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 22) && LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 34)) adapter_to_dvobj(adapter)->pusbdev->autosuspend_disabled = adapter->bDisableAutosuspend; /* autosuspend disabled by the user */ #endif } else #endif { } } } }
static void hsic_aux_work(struct work_struct *work) { dev_dbg(&pci_dev->dev, "%s---->\n", __func__); if (hsic.modem_dev == NULL) { dev_dbg(&pci_dev->dev, "%s---->Modem not created\n", __func__); return; } mutex_lock(&hsic.hsic_mutex); /* Free the aux irq */ hsic_aux_irq_free(); dev_dbg(&pci_dev->dev, "%s---->AUX IRQ is disabled\n", __func__); if (hsic.hsic_stopped == 0) ehci_hsic_stop_host(pci_dev); hsic_enter_exit_d3(1); usleep_range(5000, 6000); hsic_enter_exit_d3(0); ehci_hsic_start_host(pci_dev); hsic.autosuspend_enable = 0; usb_disable_autosuspend(hsic.rh_dev); hsic.hsic_aux_finish = 1; wake_up(&hsic.aux_wq); mutex_unlock(&hsic.hsic_mutex); dev_dbg(&pci_dev->dev, "%s<----\n", __func__); return; }
static ssize_t set_level(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct usb_device *udev = to_usb_device(dev); int len = count; char *cp; int rc = count; warn_level(); cp = memchr(buf, '\n', count); if (cp) len = cp - buf; usb_lock_device(udev); if (len == sizeof on_string - 1 && strncmp(buf, on_string, len) == 0) usb_disable_autosuspend(udev); else if (len == sizeof auto_string - 1 && strncmp(buf, auto_string, len) == 0) usb_enable_autosuspend(udev); else rc = -EINVAL; usb_unlock_device(udev); return rc; }
int brcm_usb_probe(struct platform_device *pdev, char *hcd_name, const struct hc_driver *hc_driver) { struct resource *res = NULL; struct usb_hcd *hcd = NULL; int irq, ret, len; if (usb_disabled()) return -ENODEV; if (!usb_clk) usb_clk = clk_get(NULL, "usb"); clk_enable(usb_clk); res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!res) { err("platform_get_resource error."); return -ENODEV; } irq = platform_get_irq(pdev, 0); if (irq < 0) { err("platform_get_irq error."); return -ENODEV; } /* initialize hcd */ hcd = usb_create_hcd(hc_driver, &pdev->dev, (char *)hcd_name); if (!hcd) { err("Failed to create hcd"); return -ENOMEM; } len = res->end - res->start + 1; hcd->regs = ioremap(res->start, len); hcd->rsrc_start = res->start; hcd->rsrc_len = len; ret = usb_add_hcd(hcd, irq, IRQF_DISABLED); if (ret != 0) { err("Failed to add hcd"); iounmap(hcd->regs); usb_put_hcd(hcd); clk_disable(usb_clk); return ret; } #ifdef CONFIG_PM /* disable autosuspend by default to preserve * original behavior */ #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 32) usb_disable_autosuspend(hcd->self.root_hub); #else hcd->self.root_hub->autosuspend_disabled = 1; #endif #endif return ret; }
static ssize_t hsic_autosuspend_enable_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size) { int retval; int org_req; if (size > HSIC_ENABLE_SIZE) { dev_dbg(dev, "Invalid, size = %d\n", size); return -EINVAL; } if (sscanf(buf, "%d", &org_req) != 1) { dev_dbg(dev, "Invalid, value\n"); return -EINVAL; } mutex_lock(&hsic.hsic_mutex); hsic.autosuspend_enable = org_req; if (hsic.modem_dev != NULL) { if (hsic.autosuspend_enable == 0) { dev_dbg(dev, "Modem dev autosuspend disable\n"); usb_disable_autosuspend(hsic.modem_dev); } else { dev_dbg(dev, "Enable auto suspend\n"); usb_enable_autosuspend(hsic.modem_dev); hsic_wakeup_irq_init(); } } if (hsic.rh_dev != NULL) { if (hsic.autosuspend_enable == 0) { dev_dbg(dev, "port autosuspend disable\n"); usb_disable_autosuspend(hsic.rh_dev); } else { dev_dbg(dev, "port Enable auto suspend\n"); usb_enable_autosuspend(hsic.rh_dev); } } mutex_unlock(&hsic.hsic_mutex); return size; }
/* Kernel needs to suspend all functions separately. Therefore all * registered functions must have drivers with suspend and resume * methods. Failing that the kernel simply removes the whole card. * * If already not resumed, this function turns on the traffic and * sends a 'host sleep cancel' request to the firmware. */ static int mwifiex_usb_resume(struct usb_interface *intf) { struct usb_card_rec *card = usb_get_intfdata(intf); struct mwifiex_adapter *adapter; int i; if (!card || !card->adapter) { pr_err("%s: card or card->adapter is NULL\n", __func__); return 0; } adapter = card->adapter; if (unlikely(!adapter->is_suspended)) { dev_warn(adapter->dev, "Device already resumed\n"); return 0; } /* Indicate device resumed. The netdev queue will be resumed only * after the urbs have been re-submitted */ adapter->is_suspended = false; if (!atomic_read(&card->rx_data_urb_pending)) for (i = 0; i < MWIFIEX_RX_DATA_URB; i++) mwifiex_usb_submit_rx_urb(&card->rx_data_list[i], MWIFIEX_RX_DATA_BUF_SIZE); if (!atomic_read(&card->rx_cmd_urb_pending)) { card->rx_cmd.skb = dev_alloc_skb(MWIFIEX_RX_CMD_BUF_SIZE); if (card->rx_cmd.skb) mwifiex_usb_submit_rx_urb(&card->rx_cmd, MWIFIEX_RX_CMD_BUF_SIZE); } for (i = 0; i < adapter->priv_num; i++) if (adapter->priv[i]->media_connected) netif_carrier_on(adapter->priv[i]->netdev); /* Disable Host Sleep */ if (adapter->hs_activated) mwifiex_cancel_hs(mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY), MWIFIEX_ASYNC_CMD); #ifdef CONFIG_PM /* Resume handler may be called due to remote wakeup, * force to exit suspend anyway */ usb_disable_autosuspend(card->udev); #endif /* CONFIG_PM */ return 0; }
/** * @brief This function makes USB device to resume. * * @param handle A pointer to moal_handle structure * * @return 0 --success, otherwise fail */ int woal_exit_usb_suspend(moal_handle * handle) { #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24) #ifdef CONFIG_PM struct usb_device *udev = ((struct usb_card_rec *) (handle->card))->udev; #endif /* CONFIG_PM */ #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,34) struct usb_interface *intf = ((struct usb_card_rec *) (handle->card))->intf; #endif /* < 2.6.34 */ #endif /* >= 2.6.24 */ ENTER(); if (handle->is_suspended == MFALSE) { PRINTM(MERROR, "Device already resumed\n"); LEAVE(); return -EFAULT; } #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24) #ifdef CONFIG_PM /* Exit from USB suspend */ usb_lock_device(udev); #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,34) udev->autosuspend_disabled = 1; /* /sys/bus/usb/devices/.../power/level < on */ #endif /* < 2.6.34 */ #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,33) udev->autoresume_disabled = 0; #endif /* < 2.6.33 */ usb_unlock_device(udev); #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,34) #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,32) intf->pm_usage_cnt = 0; #else atomic_set(&intf->pm_usage_cnt, 0); #endif /* < 2.6.32 */ usb_autopm_get_interface(intf); #else usb_lock_device(udev); atomic_set(&udev->dev.power.usage_count, 0); usb_disable_autosuspend(udev); usb_unlock_device(udev); #endif /* < 2.6.34 */ #endif /* >= 2.6.24 */ #endif /* CONFIG_PM */ //lxy LEAVE(); return 0; }
static void rmnet_usb_disable_hsic_autosuspend(struct usbnet *usbnet, int enable_autosuspend) { struct usb_device *usb_dev = usbnet->udev; struct rmnet_ctrl_udev *rmnet_udev = (struct rmnet_ctrl_udev *)usbnet->data[1]; usb_get_dev(usb_dev); if (!enable_autosuspend) { usb_disable_autosuspend(usb_dev); rmnet_udev->autosuspend_disabled = 1; rmnet_udev->autosuspend_dis_cnt++; } else { usb_enable_autosuspend(usb_dev); rmnet_udev->autosuspend_disabled = 0; rmnet_udev->autosuspend_en_cnt++; } usb_put_dev(usb_dev); }
/* * Detect any quirks the device has, and do any housekeeping for it if needed. */ void usb_detect_quirks(struct usb_device *udev) { const struct usb_device_id *id = usb_quirk_list; id = find_id(udev); if (id) udev->quirks = (u32)(id->driver_info); if (udev->quirks) dev_dbg(&udev->dev, "USB quirks for this device: %x\n", udev->quirks); #ifdef CONFIG_USB_SUSPEND /* By default, disable autosuspend for all devices. The hub driver * will enable it for hubs. */ usb_disable_autosuspend(udev); /* Autosuspend can also be disabled if the initial autosuspend_delay * is negative. */ if (udev->autosuspend_delay < 0) usb_autoresume_device(udev); #endif /* For the present, all devices default to USB-PERSIST enabled */ #if 0 /* was: #ifdef CONFIG_PM */ /* Hubs are automatically enabled for USB-PERSIST */ if (udev->descriptor.bDeviceClass == USB_CLASS_HUB) udev->persist_enabled = 1; #else /* In the absence of PM, we can safely enable USB-PERSIST * for all devices. It will affect things like hub resets * and EMF-related port disables. */ if (!(udev->quirks & USB_QUIRK_RESET_MORPHS)) udev->persist_enabled = 1; #endif /* CONFIG_PM */ }
static int hsic_s_probe(struct usb_serial *serial, const struct usb_device_id *id) { struct hsictty_intf_private *spriv; spriv = kzalloc(sizeof(struct hsictty_intf_private), GFP_KERNEL); if (!spriv) return -ENOMEM; spin_lock_init(&spriv->susp_lock); sema_init(&spriv->handshake_sem, 1); spriv->channel_open_flag = 0; spriv->multi_channel_mode = 0; spriv->support_pm = 1; usb_disable_autosuspend(serial->dev); wake_lock_init(&spriv->tx_wakelock, WAKE_LOCK_SUSPEND, "hsic_tx"); wake_lock_init(&spriv->rx_wakelock, WAKE_LOCK_SUSPEND, "hsic_rx"); #ifdef USE_READ_WORK spriv->hsictty_read_wq = create_workqueue("hsic tty task"); if (!spriv->hsictty_read_wq) { hsictty_error("%s: can't create workqueue\n", __func__); return -EINVAL; } #endif #ifdef BACKUP_DATA_DUMP backup_queue_init(); dumped = 0; #endif usb_set_serial_data(serial, spriv); return 0; }
/** * Probe method is ran whenever a device is binded to the driver * * TODO remove goto's */ static int razer_core_probe(struct hid_device *hdev, const struct hid_device_id *id) { int retval = 0; struct usb_interface *intf = to_usb_interface(hdev->dev.parent); struct usb_device *usb_dev = interface_to_usbdev(intf); struct razer_core_device *dev = NULL; dev = kzalloc(sizeof(struct razer_core_device), GFP_KERNEL); if(dev == NULL) { dev_err(&intf->dev, "out of memory\n"); retval = -ENOMEM; goto exit; } // Initialise mutex mutex_init(&dev->lock); // Setup values dev->usb_dev = usb_dev; CREATE_DEVICE_FILE(&hdev->dev, &dev_attr_version); CREATE_DEVICE_FILE(&hdev->dev, &dev_attr_matrix_custom_frame); CREATE_DEVICE_FILE(&hdev->dev, &dev_attr_matrix_effect_wave); CREATE_DEVICE_FILE(&hdev->dev, &dev_attr_matrix_effect_spectrum); CREATE_DEVICE_FILE(&hdev->dev, &dev_attr_matrix_effect_none); CREATE_DEVICE_FILE(&hdev->dev, &dev_attr_matrix_effect_reactive); CREATE_DEVICE_FILE(&hdev->dev, &dev_attr_matrix_effect_breath); CREATE_DEVICE_FILE(&hdev->dev, &dev_attr_matrix_effect_custom); CREATE_DEVICE_FILE(&hdev->dev, &dev_attr_device_serial); CREATE_DEVICE_FILE(&hdev->dev, &dev_attr_firmware_version); CREATE_DEVICE_FILE(&hdev->dev, &dev_attr_device_type); CREATE_DEVICE_FILE(&hdev->dev, &dev_attr_matrix_effect_static); CREATE_DEVICE_FILE(&hdev->dev, &dev_attr_matrix_brightness); CREATE_DEVICE_FILE(&hdev->dev, &dev_attr_device_mode); if (retval) { goto exit_free; } dev_set_drvdata(&hdev->dev, dev); hid_set_drvdata(hdev, dev); retval = hid_parse(hdev); if(retval) { hid_err(hdev, "parse failed\n"); goto exit_free; } retval = hid_hw_start(hdev, HID_CONNECT_DEFAULT); if (retval) { hid_err(hdev, "hw start failed\n"); goto exit_free; } usb_disable_autosuspend(usb_dev); return 0; exit: return retval; exit_free: kfree(dev); return retval; }
static ssize_t hsic_port_enable_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size) { int retval; int org_req; if (size > HSIC_ENABLE_SIZE) { dev_dbg(dev, "Invalid, size = %d\n", size); return -EINVAL; } if (sscanf(buf, "%d", &org_req) != 1) { dev_dbg(dev, "Invalid, value\n"); return -EINVAL; } /* Free the aux irq */ hsic_aux_irq_free(); dev_dbg(dev, "%s---->AUX IRQ is disabled\n", __func__); if (delayed_work_pending(&hsic.hsic_aux)) { dev_dbg(dev, "%s---->Wait for delayed work finish\n", __func__); retval = wait_event_interruptible(hsic.aux_wq, hsic.hsic_aux_finish); if (retval < 0) return retval; if (org_req) return size; } mutex_lock(&hsic.hsic_mutex); if (org_req) { dev_dbg(dev, "enable hsic\n"); /* add this due to hcd release doesn't set hcd to NULL */ if (hsic.hsic_stopped == 0) ehci_hsic_stop_host(pci_dev); hsic_enter_exit_d3(1); usleep_range(5000, 6000); hsic_enter_exit_d3(0); ehci_hsic_start_host(pci_dev); hsic.autosuspend_enable = 0; usb_disable_autosuspend(hsic.rh_dev); } else { dev_dbg(dev, "disable hsic\n"); /* If device enable auto suspend, disable it before disable hsic */ if (hsic.autosuspend_enable) { dev_dbg(dev, "disable pm\n"); if (hsic.modem_dev != NULL) { usb_disable_autosuspend(hsic.modem_dev); hsic.autosuspend_enable = 0; } if (hsic.rh_dev != NULL) { usb_disable_autosuspend(hsic.rh_dev); hsic.autosuspend_enable = 0; } } /* add this due to hcd release doesn't set hcd to NULL */ if (hsic.hsic_stopped == 0) ehci_hsic_stop_host(pci_dev); } mutex_unlock(&hsic.hsic_mutex); return size; }
static int ipc_bridge_probe(struct usb_interface *intf, const struct usb_device_id *id) { struct ipc_bridge *dev; struct usb_device *udev = interface_to_usbdev(intf); struct usb_host_interface *intf_desc; struct usb_endpoint_descriptor *ep; u16 wMaxPacketSize; int ret; intf_desc = intf->cur_altsetting; if (intf_desc->desc.bNumEndpoints != 1 || !usb_endpoint_is_int_in( &intf_desc->endpoint[0].desc)) { dev_err(&intf->dev, "driver expects only 1 int ep\n"); return -ENODEV; } dev = kzalloc(sizeof(*dev), GFP_KERNEL); if (!dev) { dev_err(&intf->dev, "fail to allocate dev\n"); return -ENOMEM; } __ipc_bridge_dev = dev; dev->inturb = usb_alloc_urb(0, GFP_KERNEL); if (!dev->inturb) { dev_err(&intf->dev, "fail to allocate int urb\n"); ret = -ENOMEM; goto free_dev; } ep = &intf->cur_altsetting->endpoint[0].desc; wMaxPacketSize = le16_to_cpu(ep->wMaxPacketSize); dev->intbuf = kmalloc(wMaxPacketSize, GFP_KERNEL); if (!dev->intbuf) { dev_err(&intf->dev, "%s: error allocating int buffer\n", __func__); ret = -ENOMEM; goto free_inturb; } usb_fill_int_urb(dev->inturb, udev, usb_rcvintpipe(udev, ep->bEndpointAddress), dev->intbuf, wMaxPacketSize, ipc_bridge_int_cb, dev, ep->bInterval); dev->in_ctlreq = kmalloc(sizeof(*dev->in_ctlreq), GFP_KERNEL); if (!dev->in_ctlreq) { dev_err(&intf->dev, "error allocating IN control req\n"); ret = -ENOMEM; goto free_intbuf; } dev->in_ctlreq->bRequestType = (USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE); dev->in_ctlreq->bRequest = USB_CDC_GET_ENCAPSULATED_RESPONSE; dev->in_ctlreq->wValue = 0; dev->in_ctlreq->wIndex = intf->cur_altsetting->desc.bInterfaceNumber; dev->in_ctlreq->wLength = cpu_to_le16(IPC_BRIDGE_MAX_READ_SZ); dev->readurb = usb_alloc_urb(0, GFP_KERNEL); if (!dev->readurb) { dev_err(&intf->dev, "fail to allocate read urb\n"); ret = -ENOMEM; goto free_in_ctlreq; } dev->readbuf = kmalloc(IPC_BRIDGE_MAX_READ_SZ, GFP_KERNEL); if (!dev->readbuf) { dev_err(&intf->dev, "fail to allocate read buffer\n"); ret = -ENOMEM; goto free_readurb; } dev->out_ctlreq = kmalloc(sizeof(*dev->out_ctlreq), GFP_KERNEL); if (!dev->out_ctlreq) { dev_err(&intf->dev, "error allocating OUT control req\n"); ret = -ENOMEM; goto free_readbuf; } dev->out_ctlreq->bRequestType = (USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE); dev->out_ctlreq->bRequest = USB_CDC_SEND_ENCAPSULATED_COMMAND; dev->out_ctlreq->wValue = 0; dev->out_ctlreq->wIndex = intf->cur_altsetting->desc.bInterfaceNumber; dev->writeurb = usb_alloc_urb(0, GFP_KERNEL); if (!dev->writeurb) { dev_err(&intf->dev, "fail to allocate write urb\n"); ret = -ENOMEM; goto free_out_ctlreq; } dev->udev = usb_get_dev(interface_to_usbdev(intf)); dev->intf = intf; spin_lock_init(&dev->lock); init_completion(&dev->write_done); init_waitqueue_head(&dev->read_wait_q); INIT_LIST_HEAD(&dev->rx_list); mutex_init(&dev->open_mutex); mutex_init(&dev->read_mutex); mutex_init(&dev->write_mutex); usb_set_intfdata(intf, dev); usb_enable_autosuspend(udev); dev->pdev = platform_device_alloc("ipc_bridge", -1); if (!dev->pdev) { dev_err(&intf->dev, "fail to allocate pdev\n"); ret = -ENOMEM; goto destroy_mutex; } ret = platform_device_add_data(dev->pdev, &ipc_bridge_pdata, sizeof(struct ipc_bridge_platform_data)); if (ret) { dev_err(&intf->dev, "fail to add pdata\n"); goto put_pdev; } ret = platform_device_add(dev->pdev); if (ret) { dev_err(&intf->dev, "fail to add pdev\n"); goto put_pdev; } ret = ipc_bridge_submit_inturb(dev, GFP_KERNEL); if (ret) { dev_err(&intf->dev, "fail to start reading\n"); goto del_pdev; } ipc_bridge_debugfs_init(); return 0; del_pdev: platform_device_del(dev->pdev); put_pdev: platform_device_put(dev->pdev); destroy_mutex: usb_disable_autosuspend(udev); mutex_destroy(&dev->write_mutex); mutex_destroy(&dev->read_mutex); mutex_destroy(&dev->open_mutex); usb_put_dev(dev->udev); usb_free_urb(dev->writeurb); free_out_ctlreq: kfree(dev->out_ctlreq); free_readbuf: kfree(dev->readbuf); free_readurb: usb_free_urb(dev->readurb); free_in_ctlreq: kfree(dev->in_ctlreq); free_intbuf: kfree(dev->intbuf); free_inturb: usb_free_urb(dev->inturb); free_dev: kfree(dev); __ipc_bridge_dev = NULL; return ret; }
/* the root hub will call this callback when device added/removed */ static void hsic_notify(struct usb_device *udev, unsigned action) { int retval; struct pci_dev *pdev = to_pci_dev(udev->bus->controller); /* Ignore and only valid for HSIC. Filter out * the USB devices added by other USB2 host driver */ if (pdev->device != 0x119d) return; /* Ignore USB devices on external hub */ if (udev->parent && udev->parent->parent) return; /* Only valid for hsic port1 */ if (udev->portnum == 2) { pr_debug("%s ignore hsic port2\n", __func__); return; } switch (action) { case USB_DEVICE_ADD: pr_debug("Notify HSIC add device\n"); /* Root hub */ if (!udev->parent) { hsic.rh_dev = udev; pr_debug("%s Enable autosuspend\n", __func__); pm_runtime_set_autosuspend_delay(&udev->dev, hsic.bus_inactivityDuration); hsic.autosuspend_enable = 1; usb_enable_autosuspend(udev); } else { /* Modem devices */ hsic.modem_dev = udev; pm_runtime_set_autosuspend_delay (&udev->dev, hsic.port_inactivityDuration); udev->persist_enabled = 0; if (hsic.remoteWakeup_enable) { pr_debug("%s Modem dev remote wakeup enabled\n", __func__); device_set_wakeup_capable (&hsic.modem_dev->dev, 1); device_set_wakeup_capable (&hsic.rh_dev->dev, 1); } else { pr_debug("%s Modem dev remote wakeup disabled\n", __func__); device_set_wakeup_capable (&hsic.modem_dev->dev, 0); device_set_wakeup_capable (&hsic.rh_dev->dev, 0); } pr_debug("%s Disable autosuspend\n", __func__); usb_disable_autosuspend(hsic.modem_dev); hsic.autosuspend_enable = 0; pr_debug("%s----> Enable AUX irq\n", __func__); retval = hsic_aux_irq_init(); if (retval) dev_err(&pci_dev->dev, "unable to request IRQ\n"); } break; case USB_DEVICE_REMOVE: pr_debug("Notify HSIC delete device\n"); /* Root hub */ if (!udev->parent) { pr_debug("%s rh_dev deleted\n", __func__); hsic.rh_dev = NULL; hsic.autosuspend_enable = 1; } else { /* Modem devices */ pr_debug("%s----> modem dev deleted\n", __func__); hsic.modem_dev = NULL; } s3_wake_unlock(); break; default: pr_debug("Notify action not supported\n"); break ; } return; }
/* Motorola Wrigley LTE CDC Ethernet Device */ static void wrigley_cdc_unbind(struct usbnet *dev, struct usb_interface *intf) { oob_wake_unregister(intf); usb_disable_autosuspend(interface_to_usbdev(intf)); usbnet_cdc_unbind(dev, intf); }
/* the root hub will call this callback when device added/removed */ void hsic_notify(struct usb_device *udev, unsigned action) { int retval; struct pci_dev *pdev = to_pci_dev(udev->bus->controller); printk(KERN_ERR "pdev device ID: %d, portnum: %d", pdev->device, udev->portnum); /* Ignore and only valid for HSIC. Filter out * the USB devices added by other USB2 host driver */ if (pdev->device != USH_PCI_ID) return; /* Ignore USB devices on external hub */ if (udev->parent && udev->parent->parent) return; switch (action) { case USB_DEVICE_ADD: pr_debug("Notify HSIC add device\n"); /* Root hub */ if (!udev->parent) { if (udev->speed == USB_SPEED_HIGH) { pr_debug("%s rh device set\n", __func__); hsic.rh_dev = udev; pr_debug("%s Disable autosuspend\n", __func__); pm_runtime_set_autosuspend_delay(&udev->dev, hsic.bus_inactivityDuration); usb_disable_autosuspend(udev); } } else { if (udev->portnum != HSIC_USH_PORT) { pr_debug("%s ignore ush ports except port5\n", __func__); pr_debug("%s ush ports %d\n", __func__, udev->portnum); break; } /* Modem devices */ hsic.modem_dev = udev; pm_runtime_set_autosuspend_delay (&udev->dev, hsic.port_inactivityDuration); if (hsic.remoteWakeup_enable) { pr_debug("%s Modem dev remote wakeup enabled\n", __func__); device_set_wakeup_capable (&hsic.modem_dev->dev, 1); device_set_wakeup_capable (&hsic.rh_dev->dev, 1); } else { pr_debug("%s Modem dev remote wakeup disabled\n", __func__); device_set_wakeup_capable (&hsic.modem_dev->dev, 0); device_set_wakeup_capable (&hsic.rh_dev->dev, 0); } usb_disable_autosuspend(hsic.modem_dev); usb_disable_autosuspend(hsic.rh_dev); #if 0 if (hsic.autosuspend_enable) { pr_debug("%s----> enable autosuspend\n", __func__); usb_enable_autosuspend(udev->parent); hsic_wakeup_irq_init(); } if (hsic.autosuspend_enable == 0) { pr_debug("%s Modem dev autosuspend disable\n", __func__); usb_disable_autosuspend(hsic.modem_dev); } #endif } break; case USB_DEVICE_REMOVE: pr_debug("Notify HSIC delete device\n"); /* Root hub */ if (udev->speed != USB_SPEED_HIGH) { pr_debug("%s ignore ss port\n", __func__); break; } if (!udev->parent) { pr_debug("%s rh_dev deleted\n", __func__); hsic.rh_dev = NULL; } else { /* Modem devices */ pr_debug("%s----> modem dev deleted\n", __func__); hsic.modem_dev = NULL; usb_disable_autosuspend(hsic.rh_dev); } break; case MODEM_WORK_FLUSH: if (udev == hsic.modem_dev) { pr_debug("Notify MODEM work flush\n"); synchronize_irq(gpio_to_irq(hsic.aux_gpio)); flush_work(&hsic.hsic_aux); } break; default: pr_debug("Notify action not supported\n"); break ; } return; }
/** * Probe method is ran whenever a device is binded to the driver * * TODO remove goto's */ static int razer_kbd_probe(struct hid_device *hdev, const struct hid_device_id *id) { int retval; struct usb_interface *intf = to_usb_interface(hdev->dev.parent); struct usb_device *usb_dev = interface_to_usbdev(intf); struct razer_kbd_device *dev = NULL; dev = kzalloc(sizeof(struct razer_kbd_device), GFP_KERNEL); if(dev == NULL) { dev_err(&intf->dev, "out of memory\n"); retval = -ENOMEM; goto exit; } if(usb_dev->descriptor.idProduct == USB_DEVICE_ID_RAZER_BLACKWIDOW_ULTIMATE_2013) { retval = device_create_file(&hdev->dev, &dev_attr_mode_pulsate); if (retval) goto exit_free; } else { retval = device_create_file(&hdev->dev, &dev_attr_mode_wave); if (retval) goto exit_free; retval = device_create_file(&hdev->dev, &dev_attr_mode_spectrum); if (retval) goto exit_free; retval = device_create_file(&hdev->dev, &dev_attr_mode_none); if (retval) goto exit_free; retval = device_create_file(&hdev->dev, &dev_attr_mode_reactive); if (retval) goto exit_free; retval = device_create_file(&hdev->dev, &dev_attr_mode_breath); if (retval) goto exit_free; retval = device_create_file(&hdev->dev, &dev_attr_mode_custom); if (retval) goto exit_free; retval = device_create_file(&hdev->dev, &dev_attr_temp_clear_row); if (retval) goto exit_free; retval = device_create_file(&hdev->dev, &dev_attr_set_key_row); if (retval) goto exit_free; } retval = device_create_file(&hdev->dev, &dev_attr_get_serial); if (retval) goto exit_free; retval = device_create_file(&hdev->dev, &dev_attr_device_type); if (retval) goto exit_free; retval = device_create_file(&hdev->dev, &dev_attr_mode_game); if (retval) goto exit_free; retval = device_create_file(&hdev->dev, &dev_attr_mode_static); if (retval) goto exit_free; retval = device_create_file(&hdev->dev, &dev_attr_reset); if (retval) goto exit_free; retval = device_create_file(&hdev->dev, &dev_attr_macro_keys); if (retval) goto exit_free; retval = device_create_file(&hdev->dev, &dev_attr_set_brightness); if (retval) goto exit_free; retval = device_create_file(&hdev->dev, &dev_attr_test); if (retval) goto exit_free; hid_set_drvdata(hdev, dev); retval = hid_parse(hdev); if(retval) { hid_err(hdev, "parse failed\n"); goto exit_free; } retval = hid_hw_start(hdev, HID_CONNECT_DEFAULT); if (retval) { hid_err(hdev, "hw start failed\n"); goto exit_free; } razer_reset(usb_dev); usb_disable_autosuspend(usb_dev); //razer_activate_macro_keys(usb_dev); //msleep(3000); return 0; exit: return retval; exit_free: kfree(dev); return retval; }
static int usbbcm_device_probe(struct usb_interface *intf, const struct usb_device_id *id) { int retval =0 ; PMINI_ADAPTER psAdapter = NULL; PS_INTERFACE_ADAPTER psIntfAdapter = NULL; struct usb_device *udev = NULL; // BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "Usbbcm probe!!"); if((intf == NULL) || (id == NULL)) { // BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "intf or id is NULL"); return -EINVAL; } /* Allocate Adapter structure */ if((psAdapter = kmalloc(sizeof(MINI_ADAPTER), GFP_KERNEL)) == NULL) { //BCM_DEBUG_PRINT(psAdapter,DBG_TYPE_PRINTK, 0, 0, "Out of memory"); return -ENOMEM; } memset(psAdapter, 0, sizeof(MINI_ADAPTER)); /* Init default driver debug state */ psAdapter->stDebugState.debug_level = DBG_LVL_CURR; psAdapter->stDebugState.type = DBG_TYPE_INITEXIT; memset (psAdapter->stDebugState.subtype, 0, sizeof (psAdapter->stDebugState.subtype)); /* Technically, one can start using BCM_DEBUG_PRINT after this point. * However, realize that by default the Type/Subtype bitmaps are all zero now; * so no prints will actually appear until the TestApp turns on debug paths via * the ioctl(); so practically speaking, in early init, no logging happens. * * A solution (used below): we explicitly set the bitmaps to 1 for Type=DBG_TYPE_INITEXIT * and ALL subtype's of the same. Now all bcm debug statements get logged, enabling debug * during early init. * Further, we turn this OFF once init_module() completes. */ psAdapter->stDebugState.subtype[DBG_TYPE_INITEXIT] = 0xff; BCM_SHOW_DEBUG_BITMAP(psAdapter); retval = InitAdapter(psAdapter); if(retval) { BCM_DEBUG_PRINT (psAdapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "InitAdapter Failed\n"); AdapterFree(psAdapter); return retval; } /* Allocate interface adapter structure */ if((psAdapter->pvInterfaceAdapter = kmalloc(sizeof(S_INTERFACE_ADAPTER), GFP_KERNEL)) == NULL) { BCM_DEBUG_PRINT(psAdapter,DBG_TYPE_PRINTK, 0, 0, "Out of memory"); AdapterFree (psAdapter); return -ENOMEM; } memset(psAdapter->pvInterfaceAdapter, 0, sizeof(S_INTERFACE_ADAPTER)); psIntfAdapter = InterfaceAdapterGet(psAdapter); psIntfAdapter->psAdapter = psAdapter; /* Store usb interface in Interface Adapter */ psIntfAdapter->interface = intf; usb_set_intfdata(intf, psIntfAdapter); BCM_DEBUG_PRINT(psAdapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "psIntfAdapter 0x%x",(unsigned int)psIntfAdapter); retval = InterfaceAdapterInit(psIntfAdapter); if(retval) { /* If the Firmware/Cfg File is not present * then return success, let the application * download the files. */ if(-ENOENT == retval){ BCM_DEBUG_PRINT(psAdapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "File Not Found, Use App to Download\n"); return STATUS_SUCCESS; } BCM_DEBUG_PRINT(psAdapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "InterfaceAdapterInit Failed \n"); usb_set_intfdata(intf, NULL); udev = interface_to_usbdev (intf); usb_put_dev(udev); if(psAdapter->bUsbClassDriverRegistered == TRUE) usb_deregister_dev (intf, &usbbcm_class); InterfaceAdapterFree(psIntfAdapter); return retval ; } if(psAdapter->chip_id > T3) { uint32_t uiNackZeroLengthInt=4; if(wrmalt(psAdapter, DISABLE_USB_ZERO_LEN_INT, &uiNackZeroLengthInt, sizeof(uiNackZeroLengthInt))) { return -EIO;; } } udev = interface_to_usbdev (intf); /* Check whether the USB-Device Supports remote Wake-Up */ if(USB_CONFIG_ATT_WAKEUP & udev->actconfig->desc.bmAttributes) { /* If Suspend then only support dynamic suspend */ if(psAdapter->bDoSuspend) { udev->autosuspend_delay = 0; intf->needs_remote_wakeup = 1; #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 35) udev->autosuspend_disabled = 0; #else usb_enable_autosuspend(udev); #endif device_init_wakeup(&intf->dev,1); #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 32) usb_autopm_disable(intf); #endif INIT_WORK(&psIntfAdapter->usbSuspendWork, putUsbSuspend); BCM_DEBUG_PRINT(psAdapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "Enabling USB Auto-Suspend\n"); } else { intf->needs_remote_wakeup = 0; #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 35) udev->autosuspend_disabled = 1; #else usb_disable_autosuspend(udev); #endif } } psAdapter->stDebugState.subtype[DBG_TYPE_INITEXIT] = 0x0; return retval; }
// // Description: Leave all power save mode: LPS, FwLPS, IPS if needed. // Move code to function by tynli. 2010.03.26. // void LeaveAllPowerSaveMode(IN PADAPTER Adapter) { struct mlme_priv *pmlmepriv = &(Adapter->mlmepriv); u32 LPSLeaveTimeOut = 10000; //u32 IPSLeaveTimeOut = 10000; _func_enter_; //DBG_8192C("%s.....\n",__FUNCTION__); if (check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE) { //connect #ifdef CONFIG_P2P p2p_ps_wk_cmd(Adapter, P2P_PS_DISABLE, 0); #endif //CONFIG_P2P #ifdef CONFIG_LPS //DBG_8192C("==> leave LPS.......\n"); LPS_Leave(Adapter); if (Adapter->pwrctrlpriv.bLeisurePs) { BOOLEAN bAwake = _TRUE; Adapter->HalFunc.GetHwRegHandler(Adapter, HW_VAR_FWLPS_RF_ON, (u8 *)(&bAwake)); while(!bAwake) { rtw_usleep_os(100); LPSLeaveTimeOut--; if(LPSLeaveTimeOut <= 0) { DBG_8192C("Wait for FW LPS leave too long!!! LPSLeaveTimeOut = %d\n", LPSLeaveTimeOut ); break; } Adapter->HalFunc.GetHwRegHandler(Adapter, HW_VAR_FWLPS_RF_ON, (u8 *)(&bAwake)); } } #endif } else { if(Adapter->pwrctrlpriv.rf_pwrstate== rf_off) { #ifdef CONFIG_AUTOSUSPEND if(Adapter->registrypriv.usbss_enable) { #if (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,35)) usb_disable_autosuspend(Adapter->dvobjpriv.pusbdev); #elif (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,22) && LINUX_VERSION_CODE<=KERNEL_VERSION(2,6,34)) Adapter->dvobjpriv.pusbdev->autosuspend_disabled = Adapter->bDisableAutosuspend;//autosuspend disabled by the user #endif } else #endif { /* #ifdef CONFIG_IPS if(_FALSE == ips_leave(Adapter)) { DBG_8192C("======> ips_leave fail.............\n"); } #endif */ } } } _func_exit_; }
static void hsicdev_add(struct usb_device *udev) { pr_debug("Notify HSIC add device\n"); if (is_ush_hsic(udev) == 0) { pr_debug("Not a USH HSIC device\n"); return; } /* Root hub */ if (!udev->parent) { if (udev->speed == USB_SPEED_HIGH) { pr_debug("%s rh device set\n", __func__); hsic.rh_dev = udev; pr_debug("%s Disable autosuspend\n", __func__); pm_runtime_set_autosuspend_delay(&udev->dev, hsic.bus_inactivityDuration); usb_disable_autosuspend(udev); hsic.autosuspend_enable = 0; } } else { if (udev->portnum != HSIC_USH_PORT) { pr_debug("%s ignore ush ports %d\n", __func__, udev->portnum); return; } /* Modem devices */ hsic.port_disconnect = 0; hsic.modem_dev = udev; pm_runtime_set_autosuspend_delay (&udev->dev, hsic.port_inactivityDuration); if (hsic.remoteWakeup_enable) { pr_debug("%s Modem dev remote wakeup enabled\n", __func__); device_set_wakeup_capable (&hsic.modem_dev->dev, 1); device_set_wakeup_capable (&hsic.rh_dev->dev, 1); } else { pr_debug("%s Modem dev remote wakeup disabled\n", __func__); device_set_wakeup_capable (&hsic.modem_dev->dev, 0); device_set_wakeup_capable (&hsic.rh_dev->dev, 0); } hsic.autosuspend_enable = HSIC_AUTOSUSPEND; if (hsic.autosuspend_enable) { pr_debug("%s----> enable autosuspend\n", __func__); usb_enable_autosuspend(hsic.modem_dev); usb_enable_autosuspend(hsic.rh_dev); hsic_wakeup_irq_init(); } if (hsic.autosuspend_enable == 0) { pr_debug("%s Modem dev autosuspend disable\n", __func__); usb_disable_autosuspend(hsic.modem_dev); usb_disable_autosuspend(hsic.rh_dev); } } }
/** * Probe method is ran whenever a device is binded to the driver * * TODO remove goto's */ static int razer_mousemat_probe(struct hid_device *hdev, const struct hid_device_id *id) { int retval = 0; struct usb_interface *intf = to_usb_interface(hdev->dev.parent); struct usb_device *usb_dev = interface_to_usbdev(intf); struct razer_mousemat_device *dev = NULL; dev = kzalloc(sizeof(struct razer_mousemat_device), GFP_KERNEL); if(dev == NULL) { dev_err(&intf->dev, "out of memory\n"); retval = -ENOMEM; goto exit; } if(intf->cur_altsetting->desc.bInterfaceProtocol == USB_INTERFACE_PROTOCOL_MOUSE) { switch(usb_dev->descriptor.idProduct) { case USB_DEVICE_ID_RAZER_GOLIATHUS_CHROMA: case USB_DEVICE_ID_RAZER_GOLIATHUS_CHROMA_EXTENDED: CREATE_DEVICE_FILE(&hdev->dev, &dev_attr_version); CREATE_DEVICE_FILE(&hdev->dev, &dev_attr_matrix_custom_frame); CREATE_DEVICE_FILE(&hdev->dev, &dev_attr_matrix_reactive_trigger); CREATE_DEVICE_FILE(&hdev->dev, &dev_attr_matrix_effect_spectrum); CREATE_DEVICE_FILE(&hdev->dev, &dev_attr_matrix_effect_none); CREATE_DEVICE_FILE(&hdev->dev, &dev_attr_matrix_effect_reactive); CREATE_DEVICE_FILE(&hdev->dev, &dev_attr_matrix_effect_breath); CREATE_DEVICE_FILE(&hdev->dev, &dev_attr_matrix_effect_custom); CREATE_DEVICE_FILE(&hdev->dev, &dev_attr_device_serial); CREATE_DEVICE_FILE(&hdev->dev, &dev_attr_firmware_version); CREATE_DEVICE_FILE(&hdev->dev, &dev_attr_device_type); CREATE_DEVICE_FILE(&hdev->dev, &dev_attr_matrix_effect_static); CREATE_DEVICE_FILE(&hdev->dev, &dev_attr_matrix_brightness); CREATE_DEVICE_FILE(&hdev->dev, &dev_attr_device_mode); // Device initial brightness is always 100% anyway saved_brightness = 0xFF; break; default: CREATE_DEVICE_FILE(&hdev->dev, &dev_attr_version); CREATE_DEVICE_FILE(&hdev->dev, &dev_attr_matrix_custom_frame); CREATE_DEVICE_FILE(&hdev->dev, &dev_attr_matrix_reactive_trigger); CREATE_DEVICE_FILE(&hdev->dev, &dev_attr_matrix_effect_wave); CREATE_DEVICE_FILE(&hdev->dev, &dev_attr_matrix_effect_spectrum); CREATE_DEVICE_FILE(&hdev->dev, &dev_attr_matrix_effect_none); CREATE_DEVICE_FILE(&hdev->dev, &dev_attr_matrix_effect_reactive); CREATE_DEVICE_FILE(&hdev->dev, &dev_attr_matrix_effect_breath); CREATE_DEVICE_FILE(&hdev->dev, &dev_attr_matrix_effect_custom); CREATE_DEVICE_FILE(&hdev->dev, &dev_attr_device_serial); CREATE_DEVICE_FILE(&hdev->dev, &dev_attr_firmware_version); CREATE_DEVICE_FILE(&hdev->dev, &dev_attr_device_type); CREATE_DEVICE_FILE(&hdev->dev, &dev_attr_matrix_effect_static); CREATE_DEVICE_FILE(&hdev->dev, &dev_attr_matrix_brightness); CREATE_DEVICE_FILE(&hdev->dev, &dev_attr_device_mode); break; } } if (retval) goto exit_free; hid_set_drvdata(hdev, dev); retval = hid_parse(hdev); if(retval) { hid_err(hdev, "parse failed\n"); goto exit_free; } retval = hid_hw_start(hdev, HID_CONNECT_DEFAULT); if (retval) { hid_err(hdev, "hw start failed\n"); goto exit_free; } usb_disable_autosuspend(usb_dev); return 0; exit: return retval; exit_free: kfree(dev); return retval; }
/** * Probe method is ran whenever a device is binded to the driver */ static int razer_kraken_probe(struct hid_device *hdev, const struct hid_device_id *id) { int retval = 0; struct usb_interface *intf = to_usb_interface(hdev->dev.parent); struct usb_device *usb_dev = interface_to_usbdev(intf); struct razer_kraken_device *dev = NULL; dev = kzalloc(sizeof(struct razer_kraken_device), GFP_KERNEL); if(dev == NULL) { dev_err(&intf->dev, "out of memory\n"); retval = -ENOMEM; goto exit; } // Init data razer_kraken_init(dev, intf); if(dev->usb_interface_protocol == USB_INTERFACE_PROTOCOL_NONE) { CREATE_DEVICE_FILE(&hdev->dev, &dev_attr_version); // Get driver version CREATE_DEVICE_FILE(&hdev->dev, &dev_attr_test); // Test mode CREATE_DEVICE_FILE(&hdev->dev, &dev_attr_device_type); // Get string of device type CREATE_DEVICE_FILE(&hdev->dev, &dev_attr_device_serial); // Get string of device serial CREATE_DEVICE_FILE(&hdev->dev, &dev_attr_firmware_version); // Get string of device fw version CREATE_DEVICE_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: CREATE_DEVICE_FILE(&hdev->dev, &dev_attr_matrix_effect_none); // No effect CREATE_DEVICE_FILE(&hdev->dev, &dev_attr_matrix_effect_static); // Static effect CREATE_DEVICE_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: CREATE_DEVICE_FILE(&hdev->dev, &dev_attr_matrix_effect_none); // No effect CREATE_DEVICE_FILE(&hdev->dev, &dev_attr_matrix_effect_spectrum); // Spectrum effect CREATE_DEVICE_FILE(&hdev->dev, &dev_attr_matrix_effect_static); // Static effect CREATE_DEVICE_FILE(&hdev->dev, &dev_attr_matrix_effect_custom); // Custom effect CREATE_DEVICE_FILE(&hdev->dev, &dev_attr_matrix_effect_breath); // Brething effect CREATE_DEVICE_FILE(&hdev->dev, &dev_attr_matrix_current_effect); // Get current effect break; } } dev_set_drvdata(&hdev->dev, dev); if(hid_parse(hdev)) { hid_err(hdev, "parse failed\n"); goto exit_free; } if (hid_hw_start(hdev, HID_CONNECT_DEFAULT)) { hid_err(hdev, "hw start failed\n"); goto exit_free; } usb_disable_autosuspend(usb_dev); return 0; exit: return retval; exit_free: kfree(dev); return retval; }
static int ss801u_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg) { usb_ss801u *dev; int argerr = 0; int retval = 0; u32 tmp; unsigned n_ioc = 0; struct spi_ioc_transfer *ioc = NULL; printk(KERN_INFO "Patrick-> ss801u_ioctl start\n"); dev = (usb_ss801u *)file->private_data; pr_debug("ioctl Start!!\n"); /* ================================ Check input cmd and arg ======================================== */ /* ================================================================================================= */ /* ---- Check control code ---- */ if (EGIS_IOCTL_MAXNR <= _IOC_NR(cmd)) return -ENOTTY; /* ================================== Switch control code ========================================== */ /* ================================================================================================= */ mutex_lock(&dev->io_mutex); if (!dev->interface) { /* disconnect() was called */ retval = -ENODEV; goto exit; } /* ----- Avoid suspend ----- */ usb_autopm_get_interface(dev->interface); /* ---- Check argument buffer ---- */ if (_IOC_READ & _IOC_DIR(cmd)) { /* access_ok : 1 means success */ /* VERIFY_WRITE : A buffer that SDK reads means drivers should write it. */ argerr = !access_ok(VERIFY_WRITE, (void __user *)arg, _IOC_SIZE(cmd)); } if (_IOC_WRITE & _IOC_DIR(cmd)) argerr = !access_ok(VERIFY_READ, (void __user *)arg, _IOC_SIZE(cmd)); if (argerr) return -EINVAL; if (SPI_IOC_MAGIC == _IOC_TYPE(cmd)) { tmp = _IOC_SIZE(cmd); if ((tmp % sizeof(struct spi_ioc_transfer)) != 0) { retval = -EINVAL; goto done; } n_ioc = tmp / sizeof(struct spi_ioc_transfer); pr_debug("%s->%s: Got %d spi_ioc_transfer Packages\n", __FILE__, __func__, n_ioc); if (n_ioc == 0) goto done; /* copy into scratch area */ ioc = kmalloc(tmp, GFP_KERNEL); if (!ioc) { retval = -ENOMEM; goto done; } if (__copy_from_user(ioc, (void __user *)arg, tmp)) { kfree(ioc); retval = -EFAULT; goto done; } switch (ioc->opcode) { case JADE_REGISTER_MASSREAD: printk(KERN_INFO "Patrick-> JADE_REGISTER_MASSREAD start\n"); if (ioc->rx_buf) { if (!access_ok(VERIFY_WRITE, (u8 __user *) (uintptr_t) ioc->rx_buf, ioc->len)) { pr_debug("!access_ok on JADE_REGISTER_MASSREAD!!"); retval = -EACCES; goto done; } } retval = ES603_IO_Bulk_Read(dev, ioc, n_ioc); printk(KERN_INFO "Patrick-> JADE_REGISTER_MASSREAD finish\n"); break; case JADE_REGISTER_MASSWRITE: printk(KERN_INFO "Patrick-> JADE_REGISTER_MASSWRITE start\n"); retval = ES603_IO_Bulk_Write(dev, ioc, n_ioc); printk(KERN_INFO "Patrick-> JADE_REGISTER_MASSWRITE finish\n"); break; case JADE_GET_ONE_IMG: printk(KERN_INFO "Patrick-> JADE_GET_ONE_IMG start\n"); retval = es603_io_bulk_get_image(dev, ioc, n_ioc); printk(KERN_INFO "Patrick-> JADE_GET_ONE_IMG finish\n"); break; case JADE_GET_FULL_IMAGE2: printk(KERN_INFO "Patrick-> JADE_GET_FULL_IMAGE2 start\n"); retval = es603_io_bulk_get_full_image(dev, ioc, n_ioc); printk(KERN_INFO "Patrick-> JADE_GET_FULL_IMAGE2 finish\n"); break; default: retval = -EFAULT; } done: kfree(ioc); } else if (EGIS_IOCTL_MAGIC == _IOC_TYPE(cmd)) { switch (cmd) { /* -------------------- ss801u SCSI CMD XFER ---------------------- */ /* ---------------------------------------------------------------- */ case EGIS_IOCTL_SCSI_READ: { retval = Egis_IO_SCSI_Read(dev, arg); break; } case EGIS_IOCTL_SCSI_WRITE: { retval = Egis_IO_SCSI_Write(dev, arg); break; } case EGIS_IOCTL_SET_NORMALMODE_REG: { EgisMsg(dev->bPrintDbgMsg, KERN_INFO, "=ioctl=EGIS_IOCTL_SET_NORMALMODE_REG "); if (copy_from_user((void *)&dev->normalCBW, (void *)arg, CBW_SIZE)) { EgisMsg(dev->bPrintDbgMsg, KERN_ERR, "=ioctl=EGIS_IOCTL_SET_NORMALMODE_REG copy from user fail\r\n"); retval = -EFAULT; break; } break; } case EGIS_IOCTL_SET_CONTACTMODE_REG: { EgisMsg(dev->bPrintDbgMsg, KERN_INFO, "=ioctl=EGIS_IOCTL_SET_CONTACTMODE_REG "); if (copy_from_user(&dev->contactCBW, (void *)arg, CBW_SIZE)) { EgisMsg(dev->bPrintDbgMsg, KERN_ERR, "=ioctl=EGIS_IOCTL_SET_CONTACTMODE_REG copy from user fail\r\n"); retval = -EFAULT; break; } break; } /* -------------------- JADE USB BASIC XFER ----------------------- */ /* ---------------------------------------------------------------- */ case EGIS_IOCTL_BULK_READ: { retval = Egis_IO_Bulk_Read(dev, arg); break; } case EGIS_IOCTL_BULK_WRITE: { retval = Egis_IO_Bulk_Write(dev, arg); break; } case EGIS_IOCTL_CTRLXFER_READ: { retval = Egis_IO_CtrlXfer(dev, arg, Ctrl_IN); break; } case EGIS_IOCTL_CTRLXFER_WRITE: { retval = Egis_IO_CtrlXfer(dev, arg, Ctrl_OUT); break; } /*---------------------- Helper function ------------------------- */ /*---------------------------------------------------------------- */ case EGIS_IOCTL_ENTER_SUSPEND: dev->udev->autosuspend_delay = 0; break; case EGIS_IOCTL_RESET_DEVICE: retval = Egis_IO_Reset_Device(dev); break; case EGIS_IOCTL_CREATE_SIGNAL: dev->sig_type = arg; break; /* -------------------- Alternative Setting ----------------------- */ /* ---------------------------------------------------------------- */ case EGIS_IOCTL_SET_AUTOSUSPEND_TIME: dev->idle_delay_time = arg; dev->udev->autosuspend_delay = dev->idle_delay_time*HZ; EgisMsg(dev->bPrintDbgMsg, KERN_INFO, "=ioctl= idle-delay time %d \r\n", dev->idle_delay_time); break; /* ------------------------- Information -------------------------- */ /* ---------------------------------------------------------------- */ case EGIS_IOCTL_GET_VERSION: EgisMsg(dev->bPrintDbgMsg, KERN_INFO, "=ioctl= EGIS_IOCTL_GET_VERSION %s\r\n", dev->version.vstring); if (copy_to_user((void *)arg, &dev->version, sizeof(FPDriver_Version))) { EgisMsg(dev->bPrintDbgMsg, KERN_ERR, "=ioctl= EGIS_IOCTL_GET_VERSION copy to user fail\r\n"); retval = -EFAULT; break; } break; /* ------------------------ Debug usage --------------------------- */ /* ---------------------------------------------------------------- */ case EGIS_IOCTL_ENABLE_DBG_MSG: dev->bPrintDbgMsg = arg; break; /* ------------------------ FOR TEST ------------------------------ */ /* ---------------------------------------------------------------- */ case EGIS_IOCTL_TS_SIGNAL: if (dev->async_resume) { EgisMsg(dev->bPrintDbgMsg, KERN_INFO, "=ioctl= kill_fasync resume!!\r\n"); kill_fasync(&dev->async_resume, SIGIO, POLL_IN); } if (dev->async_suspend) { EgisMsg(dev->bPrintDbgMsg, KERN_INFO, "=ioctl= kill_fasync suspend !!\r\n"); kill_fasync(&dev->async_suspend, SIGIO, POLL_IN); } break; case EGIS_IOCTL_TS_SWITCH_AUTOSUSPEND: arg ? usb_enable_autosuspend(dev->udev):usb_disable_autosuspend(dev->udev); break; case EGIS_IOCTL_TS_SWITCH_RMWAKEUP: dev->udev->do_remote_wakeup = arg; EgisMsg(dev->bPrintDbgMsg, KERN_INFO, "=ioctl= do_remote_wakeup %d \r\n", dev->udev->do_remote_wakeup); break; default : retval = -ENOTTY; break; } } else { retval = -ENOTTY; } exit: /* ----- Auto suspend ----- */ usb_autopm_put_interface(dev->interface); mutex_unlock(&dev->io_mutex); printk(KERN_INFO "Patrick-> ss801u_ioctl finish\n"); return retval; }
static int hsictty_ioctl(struct tty_struct *tty, unsigned int cmd, unsigned long arg) { struct usb_serial_port *port = tty->driver_data; struct hsictty_port_private *portdata; struct hsictty_intf_private *intfdata; int channel = -1; int ret = -EINVAL; portdata = usb_get_serial_port_data(port); intfdata = usb_get_serial_data(port->serial); down(&portdata->ch_sem_w); down(&portdata->ch_sem_r); channel = tty->index; if (!intfdata->multi_channel_mode && channel != HSIC_DATA_START_CHANNEL) { hsictty_dbg("%s: invalid channel mode -- ch:%d!\n", __func__, channel); goto out; } switch (cmd) { case HSIC_TTY_IOCTL_SET_MULTIMODE: { int mode = 1; int i = 0, j = 0; struct usb_serial_port *port_tmp; struct hsictty_port_private *portdata_tmp; struct urb *urb; if (copy_from_user(&mode, (int *)arg, sizeof(int))) { hsictty_error("%s: copy param failed\n", __func__); ret = -EFAULT; goto out; } intfdata->multi_channel_mode = mode; /*set tx zlp support for multi-channel, clear tx zlp support for bootrom */ for (i = 0; i < port->serial->num_ports; ++i) { port_tmp = port->serial->port[i]; portdata_tmp = usb_get_serial_port_data(port_tmp); for (j = 0; j < N_OUT_URB; j++) { urb = portdata_tmp->out_urbs[j]; if (urb) { if (mode) urb->transfer_flags |= URB_ZERO_PACKET; else urb->transfer_flags &= ~URB_ZERO_PACKET; } } } hsictty_dbg ("%s: set hsic tty multi-channel mode to [%d][%s] from user space!\n", __func__, mode, mode ? "multi-channel mode" : "single channel mode"); } break; case HSIC_TTY_IOCTL_HSIC_RESET: { int i = 0; struct usb_serial_port *port_tmp; struct hsictty_port_private *portdata_tmp; //struct tty_struct *tty = NULL; pm_qos_update_request_timeout(&dl_kfc_num_qos, 3, 15 * 1000 * 1000); pm_qos_update_request_timeout(&dl_kfc_freq_qos, 1200000, 15 * 1000 * 1000); if (intfdata->support_pm) { pm_runtime_resume(&port->serial->dev->dev); usb_disable_autosuspend(port->serial->dev); } intfdata->multi_channel_mode = 0; for (i = 1; i < port->serial->num_ports; ++i) { port_tmp = port->serial->port[i]; portdata_tmp = usb_get_serial_port_data(port_tmp); portdata_tmp->opened = 0; #ifndef USE_READ_WORK complete_all(&portdata_tmp->rx_notifier); #endif complete_all(&portdata_tmp->tx_notifier); /* hangup here before diconncest marked * may casue tty abnormally opened in serial core. tty = tty_port_tty_get(&port_tmp->port); if (tty) { tty_vhangup(tty); tty_kref_put(tty); } */ clear_bit(i, &intfdata->channel_open_flag); } #ifdef BACKUP_DATA_DUMP if (!dumped) { dumped = 1; backup_dump(HSIC_DATA_START_CHANNEL, 0); backup_dump(HSIC_DATA_START_CHANNEL, 1); } #endif hsictty_info ("%s: hsic tty reset triggerred from userspace!\n", __func__); } break; case HSIC_TTY_IOCTL_HSIC_PM_ENABLE: if (intfdata->support_pm) { usb_enable_autosuspend(port->serial->dev); //pm_runtime_set_autosuspend_delay(&port->serial->dev->dev, 200); /* enable ehci root_hub runtime_pm */ pm_runtime_allow(port->serial->dev->dev.parent->parent); } hsictty_info("%s: hsic pm enable from userspace!\n", __func__); break; default: hsictty_error("%s: illgal command !\n", __func__); ret = -ENOIOCTLCMD; goto out; } ret = 0; out: up(&portdata->ch_sem_w); up(&portdata->ch_sem_r); return ret; }