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;
}
