void hifi_om_init(struct platform_device *dev, unsigned char* hifi_priv_base_virt, unsigned char* hifi_priv_base_phy) { BUG_ON(NULL == dev); #ifdef PLATFORM_HI3XXX BUG_ON(NULL == hifi_priv_base_virt); BUG_ON(NULL == hifi_priv_base_phy); #endif memset(&g_om_data, 0, sizeof(struct hifi_om_s)); g_om_data.debug_level = 2; /*info level*/ #ifdef PLATFORM_HI3XXX g_om_data.dsp_time_stamp = (unsigned int*)ioremap_wc(SYS_TIME_STAMP_REG, 0x4); if (NULL == g_om_data.dsp_time_stamp) { printk("time stamp reg ioremap_wc Error.\n");//can't use logx return; } #endif g_om_data.dsp_loaded = hifi_check_img_loaded(); IN_FUNCTION; #ifdef PLATFORM_HI3XXX g_om_data.dsp_debug_level = 2; /*info level*/ g_om_data.first_dump_log = true; g_om_data.is_watchdog_coming = false; g_om_data.dsp_panic_mark = (unsigned int*)(hifi_priv_base_virt + (DRV_DSP_PANIC_MARK - HIFI_BASE_ADDR)); g_om_data.dsp_bin_addr = (char*)(hifi_priv_base_virt + (HIFI_RUN_LOCATION - HIFI_BASE_ADDR)); g_om_data.dsp_exception_no = (unsigned int*)(hifi_priv_base_virt + (DRV_DSP_EXCEPTION_NO - HIFI_BASE_ADDR)); g_om_data.dsp_log_cur_addr = (unsigned int*)(hifi_priv_base_virt + (DRV_DSP_UART_TO_MEM_CUR_ADDR - HIFI_BASE_ADDR)); g_om_data.dsp_log_addr = NULL; g_om_data.dsp_debug_level_addr = (unsigned int*)(hifi_priv_base_virt + (DRV_DSP_UART_LOG_LEVEL - HIFI_BASE_ADDR)); g_om_data.dsp_debug_kill_addr = (unsigned int*)(hifi_priv_base_virt + (DRV_DSP_KILLME_ADDR - HIFI_BASE_ADDR)); *(g_om_data.dsp_exception_no) = ~0; g_om_data.pre_exception_no = ~0; s_dsp_dump_info[NORMAL_BIN].data_addr = g_om_data.dsp_bin_addr; s_dsp_dump_info[PANIC_BIN].data_addr = g_om_data.dsp_bin_addr; hifi_set_dsp_debug_level(g_om_data.dsp_debug_level); sema_init(&g_om_data.dsp_dump_sema, 1); g_om_data.kdumpdsp_task = kthread_create(hifi_dump_dsp_thread, 0, "dspdumplog"); if (IS_ERR(g_om_data.kdumpdsp_task)) { loge("creat hifi dump log thread fail.\n"); } else { wake_up_process(g_om_data.kdumpdsp_task); } #endif g_om_data.dsp_hifidebug_show_tag = false; hifi_create_procfs(); #ifdef PLATFORM_HI6XXX g_om_data.hifi_mntn_wq = create_singlethread_workqueue("hifi_misc_mntn_workqueue"); INIT_WORK(&(g_om_data.hifi_mntn_work.work_stru), hifi_handle_mntn_work); #endif OUT_FUNCTION; return; }
static int twl6030_usb_probe(struct platform_device *pdev) { u32 ret; struct twl6030_usb *twl; int status, err; struct device_node *np = pdev->dev.of_node; struct device *dev = &pdev->dev; struct twl4030_usb_data *pdata = dev->platform_data; twl = devm_kzalloc(dev, sizeof *twl, GFP_KERNEL); if (!twl) return -ENOMEM; twl->dev = &pdev->dev; twl->irq1 = platform_get_irq(pdev, 0); twl->irq2 = platform_get_irq(pdev, 1); twl->linkstat = OMAP_MUSB_UNKNOWN; twl->comparator.set_vbus = twl6030_set_vbus; twl->comparator.start_srp = twl6030_start_srp; ret = omap_usb2_set_comparator(&twl->comparator); if (ret == -ENODEV) { dev_info(&pdev->dev, "phy not ready, deferring probe"); return -EPROBE_DEFER; } if (np) { twl->regulator = "usb"; } else if (pdata) { if (pdata->features & TWL6025_SUBCLASS) twl->regulator = "ldousb"; else twl->regulator = "vusb"; } else { dev_err(&pdev->dev, "twl6030 initialized without pdata\n"); return -EINVAL; } /* init spinlock for workqueue */ spin_lock_init(&twl->lock); err = twl6030_usb_ldo_init(twl); if (err) { dev_err(&pdev->dev, "ldo init failed\n"); return err; } platform_set_drvdata(pdev, twl); if (device_create_file(&pdev->dev, &dev_attr_vbus)) dev_warn(&pdev->dev, "could not create sysfs file\n"); INIT_WORK(&twl->set_vbus_work, otg_set_vbus_work); twl->irq_enabled = true; status = request_threaded_irq(twl->irq1, NULL, twl6030_usbotg_irq, IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING | IRQF_ONESHOT, "twl6030_usb", twl); if (status < 0) { dev_err(&pdev->dev, "can't get IRQ %d, err %d\n", twl->irq1, status); device_remove_file(twl->dev, &dev_attr_vbus); return status; } status = request_threaded_irq(twl->irq2, NULL, twl6030_usb_irq, IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING | IRQF_ONESHOT, "twl6030_usb", twl); if (status < 0) { dev_err(&pdev->dev, "can't get IRQ %d, err %d\n", twl->irq2, status); free_irq(twl->irq1, twl); device_remove_file(twl->dev, &dev_attr_vbus); return status; } twl->asleep = 0; twl6030_enable_irq(twl); dev_info(&pdev->dev, "Initialized TWL6030 USB module\n"); return 0; }
int Si47xx_dev_init(struct Si47xx_device_t *si47xx_dev) { int ret = 0; Si47xx_dev = si47xx_dev; Si47xx_dev->client = si47xx_dev->client; pSi47xxdata = si47xx_dev->pdata; si47xx_irq = Si47xx_dev->client->irq; debug("Si47xx_dev_init called"); mutex_lock(&Si47xx_dev->lock); Si47xx_dev->state.power_state = RADIO_POWERDOWN; Si47xx_dev->state.seek_state = RADIO_SEEK_OFF; Si47xx_dev->valid_client_state = eTRUE; Si47xx_dev->valid = eFALSE; #ifdef RDS_INTERRUPT_ON_ALWAYS /*Creating Circular Buffer */ /*Single RDS_Block_Data buffer size is 4x16 bits */ RDS_Block_Data_buffer = kzalloc(RDS_BUFFER_LENGTH * 8, GFP_KERNEL); if (!RDS_Block_Data_buffer) { dev_err(Si47xx_dev->dev, "Not sufficient memory for creating " "RDS_Block_Data_buffer"); ret = -ENOMEM; goto EXIT; } /*Single RDS_Block_Error buffer size is 4x8 bits */ RDS_Block_Error_buffer = kzalloc(RDS_BUFFER_LENGTH * 4, GFP_KERNEL); if (!RDS_Block_Error_buffer) { dev_err(Si47xx_dev->dev, "Not sufficient memory for creating " "RDS_Block_Error_buffer"); ret = -ENOMEM; kfree(RDS_Block_Data_buffer); goto EXIT; } /*Initialising read and write indices */ RDS_Buffer_Index_read = 0; RDS_Buffer_Index_write = 0; /*Creating work-queue */ Si47xx_wq = create_singlethread_workqueue("Si47xx_wq"); if (!Si47xx_wq) { dev_err(Si47xx_dev->dev, "Not sufficient memory for Si47xx_wq, work-queue"); ret = -ENOMEM; kfree(RDS_Block_Error_buffer); kfree(RDS_Block_Data_buffer); goto EXIT; } /*Initialising work_queue */ INIT_WORK(&Si47xx_work, Si47xx_work_func); RDS_Data_Available = 0; RDS_Data_Lost = 0; RDS_Groups_Available_till_now = 0; EXIT: #endif mutex_unlock(&(Si47xx_dev->lock)); debug("Si47xx_dev_init call over"); return ret; }
static int tegra_otg_probe(struct platform_device *pdev) { struct tegra_otg_data *tegra; struct resource *res; int err; tegra = kzalloc(sizeof(struct tegra_otg_data), GFP_KERNEL); if (!tegra) return -ENOMEM; tegra->otg.dev = &pdev->dev; tegra->otg.label = "tegra-otg"; tegra->otg.state = OTG_STATE_UNDEFINED; tegra->otg.set_host = tegra_otg_set_host; tegra->otg.set_peripheral = tegra_otg_set_peripheral; tegra->otg.set_suspend = tegra_otg_set_suspend; tegra->otg.set_power = tegra_otg_set_power; spin_lock_init(&tegra->lock); wake_lock_init(&usb_wake_lock, WAKE_LOCK_SUSPEND, "tegra_otg"); platform_set_drvdata(pdev, tegra); tegra->clk = clk_get(&pdev->dev, NULL); if (IS_ERR(tegra->clk)) { dev_err(&pdev->dev, "Can't get otg clock\n"); err = PTR_ERR(tegra->clk); goto err_clk; } err = clk_enable(tegra->clk); if (err) goto err_clken; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!res) { dev_err(&pdev->dev, "Failed to get I/O memory\n"); err = -ENXIO; goto err_io; } tegra->regs = ioremap(res->start, resource_size(res)); if (!tegra->regs) { err = -ENOMEM; goto err_io; } tegra->otg.state = OTG_STATE_A_SUSPEND; err = otg_set_transceiver(&tegra->otg); if (err) { dev_err(&pdev->dev, "can't register transceiver (%d)\n", err); goto err_otg; } res = platform_get_resource(pdev, IORESOURCE_IRQ, 0); if (!res) { dev_err(&pdev->dev, "Failed to get IRQ\n"); err = -ENXIO; goto err_irq; } tegra->irq = res->start; err = request_threaded_irq(tegra->irq, tegra_otg_irq, NULL, IRQF_SHARED, "tegra-otg", tegra); if (err) { dev_err(&pdev->dev, "Failed to register IRQ\n"); goto err_irq; } INIT_WORK (&tegra->work, irq_work); dev_info(&pdev->dev, "otg transceiver registered\n"); return 0; err_irq: otg_set_transceiver(NULL); err_otg: iounmap(tegra->regs); err_io: clk_disable(tegra->clk); err_clken: clk_put(tegra->clk); err_clk: platform_set_drvdata(pdev, NULL); kfree(tegra); return err; }
/* * Receive a management frame from the device. * This can be an arbitrary number of traps, and at most one response * frame for a previous request sent via islpci_mgt_transmit(). */ int islpci_mgt_receive(struct net_device *ndev) { islpci_private *priv = netdev_priv(ndev); isl38xx_control_block *cb = (isl38xx_control_block *) priv->control_block; u32 curr_frag; #if VERBOSE > SHOW_ERROR_MESSAGES DEBUG(SHOW_FUNCTION_CALLS, "islpci_mgt_receive\n"); #endif /* Only once per interrupt, determine fragment range to * process. This avoids an endless loop (i.e. lockup) if * frames come in faster than we can process them. */ curr_frag = le32_to_cpu(cb->device_curr_frag[ISL38XX_CB_RX_MGMTQ]); barrier(); for (; priv->index_mgmt_rx < curr_frag; priv->index_mgmt_rx++) { pimfor_header_t *header; u32 index = priv->index_mgmt_rx % ISL38XX_CB_MGMT_QSIZE; struct islpci_membuf *buf = &priv->mgmt_rx[index]; u16 frag_len; int size; struct islpci_mgmtframe *frame; /* I have no idea (and no documentation) if flags != 0 * is possible. Drop the frame, reuse the buffer. */ if (le16_to_cpu(cb->rx_data_mgmt[index].flags) != 0) { printk(KERN_WARNING "%s: unknown flags 0x%04x\n", ndev->name, le16_to_cpu(cb->rx_data_mgmt[index].flags)); continue; } /* The device only returns the size of the header(s) here. */ frag_len = le16_to_cpu(cb->rx_data_mgmt[index].size); /* * We appear to have no way to tell the device the * size of a receive buffer. Thus, if this check * triggers, we likely have kernel heap corruption. */ if (frag_len > MGMT_FRAME_SIZE) { printk(KERN_WARNING "%s: Bogus packet size of %d (%#x).\n", ndev->name, frag_len, frag_len); frag_len = MGMT_FRAME_SIZE; } /* Ensure the results of device DMA are visible to the CPU. */ pci_dma_sync_single_for_cpu(priv->pdev, buf->pci_addr, buf->size, PCI_DMA_FROMDEVICE); /* Perform endianess conversion for PIMFOR header in-place. */ header = pimfor_decode_header(buf->mem, frag_len); if (!header) { printk(KERN_WARNING "%s: no PIMFOR header found\n", ndev->name); continue; } /* The device ID from the PIMFOR packet received from * the MVC is always 0. We forward a sensible device_id. * Not that anyone upstream would care... */ header->device_id = priv->ndev->ifindex; #if VERBOSE > SHOW_ERROR_MESSAGES DEBUG(SHOW_PIMFOR_FRAMES, "PIMFOR: op %i, oid 0x%08x, device %i, flags 0x%x length 0x%x\n", header->operation, header->oid, header->device_id, header->flags, header->length); /* display the buffer contents for debugging */ display_buffer((char *) header, PIMFOR_HEADER_SIZE); display_buffer((char *) header + PIMFOR_HEADER_SIZE, header->length); #endif /* nobody sends these */ if (header->flags & PIMFOR_FLAG_APPLIC_ORIGIN) { printk(KERN_DEBUG "%s: errant PIMFOR application frame\n", ndev->name); continue; } /* Determine frame size, skipping OID_INL_TUNNEL headers. */ size = PIMFOR_HEADER_SIZE + header->length; frame = kmalloc(sizeof (struct islpci_mgmtframe) + size, GFP_ATOMIC); if (!frame) { printk(KERN_WARNING "%s: Out of memory, cannot handle oid 0x%08x\n", ndev->name, header->oid); continue; } frame->ndev = ndev; memcpy(&frame->buf, header, size); frame->header = (pimfor_header_t *) frame->buf; frame->data = frame->buf + PIMFOR_HEADER_SIZE; #if VERBOSE > SHOW_ERROR_MESSAGES DEBUG(SHOW_PIMFOR_FRAMES, "frame: header: %p, data: %p, size: %d\n", frame->header, frame->data, size); #endif if (header->operation == PIMFOR_OP_TRAP) { #if VERBOSE > SHOW_ERROR_MESSAGES printk(KERN_DEBUG "TRAP: oid 0x%x, device %i, flags 0x%x length %i\n", header->oid, header->device_id, header->flags, header->length); #endif /* Create work to handle trap out of interrupt * context. */ INIT_WORK(&frame->ws, prism54_process_trap); schedule_work(&frame->ws); } else { /* Signal the one waiting process that a response * has been received. */ if ((frame = xchg(&priv->mgmt_received, frame)) != NULL) { printk(KERN_WARNING "%s: mgmt response not collected\n", ndev->name); kfree(frame); } #if VERBOSE > SHOW_ERROR_MESSAGES DEBUG(SHOW_TRACING, "Wake up Mgmt Queue\n"); #endif wake_up(&priv->mgmt_wqueue); } } return 0; }
static int __devinit ezx_pcap_probe(struct spi_device *spi) { struct pcap_platform_data *pdata = spi->dev.platform_data; struct pcap_chip *pcap; int i, adc_irq; int ret = -ENODEV; if (!pdata) goto ret; pcap = kzalloc(sizeof(*pcap), GFP_KERNEL); if (!pcap) { ret = -ENOMEM; goto ret; } mutex_init(&pcap->io_mutex); mutex_init(&pcap->adc_mutex); INIT_WORK(&pcap->isr_work, pcap_isr_work); INIT_WORK(&pcap->msr_work, pcap_msr_work); dev_set_drvdata(&spi->dev, pcap); spi->bits_per_word = 32; spi->mode = SPI_MODE_0 | (pdata->config & PCAP_CS_AH ? SPI_CS_HIGH : 0); ret = spi_setup(spi); if (ret) goto free_pcap; pcap->spi = spi; pcap->irq_base = pdata->irq_base; pcap->workqueue = create_singlethread_workqueue("pcapd"); if (!pcap->workqueue) { dev_err(&spi->dev, "cant create pcap thread\n"); goto free_pcap; } if (!(pdata->config & PCAP_SECOND_PORT)) ezx_pcap_write(pcap, PCAP_REG_INT_SEL, (1 << PCAP_IRQ_ADCDONE2)); for (i = pcap->irq_base; i < (pcap->irq_base + PCAP_NIRQS); i++) { set_irq_chip_and_handler(i, &pcap_irq_chip, handle_simple_irq); set_irq_chip_data(i, pcap); #ifdef CONFIG_ARM set_irq_flags(i, IRQF_VALID); #else set_irq_noprobe(i); #endif } ezx_pcap_write(pcap, PCAP_REG_MSR, PCAP_MASK_ALL_INTERRUPT); ezx_pcap_write(pcap, PCAP_REG_ISR, PCAP_CLEAR_INTERRUPT_REGISTER); pcap->msr = PCAP_MASK_ALL_INTERRUPT; set_irq_type(spi->irq, IRQ_TYPE_EDGE_RISING); set_irq_data(spi->irq, pcap); set_irq_chained_handler(spi->irq, pcap_irq_handler); set_irq_wake(spi->irq, 1); adc_irq = pcap_to_irq(pcap, (pdata->config & PCAP_SECOND_PORT) ? PCAP_IRQ_ADCDONE2 : PCAP_IRQ_ADCDONE); ret = request_irq(adc_irq, pcap_adc_irq, 0, "ADC", pcap); if (ret) goto free_irqchip; for (i = 0; i < pdata->num_subdevs; i++) { ret = pcap_add_subdev(pcap, &pdata->subdevs[i]); if (ret) goto remove_subdevs; } if (pdata->init) pdata->init(pcap); return 0; remove_subdevs: device_for_each_child(&spi->dev, NULL, pcap_remove_subdev); free_irq(adc_irq, pcap); free_irqchip: for (i = pcap->irq_base; i < (pcap->irq_base + PCAP_NIRQS); i++) set_irq_chip_and_handler(i, NULL, NULL); destroy_workqueue(pcap->workqueue); free_pcap: kfree(pcap); ret: return ret; }
static int __init mmc_omap_probe(struct platform_device *pdev) { struct omap_mmc_platform_data *pdata = pdev->dev.platform_data; struct mmc_omap_host *host = NULL; struct resource *res; int i, ret = 0; int irq; if (pdata == NULL) { dev_err(&pdev->dev, "platform data missing\n"); return -ENXIO; } if (pdata->nr_slots == 0) { dev_err(&pdev->dev, "no slots\n"); return -ENXIO; } res = platform_get_resource(pdev, IORESOURCE_MEM, 0); irq = platform_get_irq(pdev, 0); if (res == NULL || irq < 0) return -ENXIO; res = request_mem_region(res->start, resource_size(res), pdev->name); if (res == NULL) return -EBUSY; host = kzalloc(sizeof(struct mmc_omap_host), GFP_KERNEL); if (host == NULL) { ret = -ENOMEM; goto err_free_mem_region; } INIT_WORK(&host->slot_release_work, mmc_omap_slot_release_work); INIT_WORK(&host->send_stop_work, mmc_omap_send_stop_work); INIT_WORK(&host->cmd_abort_work, mmc_omap_abort_command); setup_timer(&host->cmd_abort_timer, mmc_omap_cmd_timer, (unsigned long) host); spin_lock_init(&host->clk_lock); setup_timer(&host->clk_timer, mmc_omap_clk_timer, (unsigned long) host); spin_lock_init(&host->dma_lock); setup_timer(&host->dma_timer, mmc_omap_dma_timer, (unsigned long) host); spin_lock_init(&host->slot_lock); init_waitqueue_head(&host->slot_wq); host->pdata = pdata; host->dev = &pdev->dev; platform_set_drvdata(pdev, host); host->id = pdev->id; host->mem_res = res; host->irq = irq; host->use_dma = 1; host->dev->dma_mask = &pdata->dma_mask; host->dma_ch = -1; host->irq = irq; host->phys_base = host->mem_res->start; host->virt_base = ioremap(res->start, resource_size(res)); if (!host->virt_base) goto err_ioremap; host->iclk = clk_get(&pdev->dev, "ick"); if (IS_ERR(host->iclk)) { ret = PTR_ERR(host->iclk); goto err_free_mmc_host; } clk_enable(host->iclk); host->fclk = clk_get(&pdev->dev, "fck"); if (IS_ERR(host->fclk)) { ret = PTR_ERR(host->fclk); goto err_free_iclk; } ret = request_irq(host->irq, mmc_omap_irq, 0, DRIVER_NAME, host); if (ret) goto err_free_fclk; if (pdata->init != NULL) { ret = pdata->init(&pdev->dev); if (ret < 0) goto err_free_irq; } host->nr_slots = pdata->nr_slots; for (i = 0; i < pdata->nr_slots; i++) { ret = mmc_omap_new_slot(host, i); if (ret < 0) { while (--i >= 0) mmc_omap_remove_slot(host->slots[i]); goto err_plat_cleanup; } } host->reg_shift = (cpu_is_omap7xx() ? 1 : 2); return 0; err_plat_cleanup: if (pdata->cleanup) pdata->cleanup(&pdev->dev); err_free_irq: free_irq(host->irq, host); err_free_fclk: clk_put(host->fclk); err_free_iclk: clk_disable(host->iclk); clk_put(host->iclk); err_free_mmc_host: iounmap(host->virt_base); err_ioremap: kfree(host); err_free_mem_region: release_mem_region(res->start, resource_size(res)); return ret; }
int usbnet_probe (struct usb_interface *udev, const struct usb_device_id *prod) { struct usbnet *dev; struct net_device *net; struct usb_host_interface *interface; struct driver_info *info; struct usb_device *xdev; int status; const char *name; name = udev->dev.driver->name; info = (struct driver_info *) prod->driver_info; if (!info) { dev_dbg (&udev->dev, "blacklisted by %s\n", name); return -ENODEV; } xdev = interface_to_usbdev (udev); interface = udev->cur_altsetting; usb_get_dev (xdev); status = -ENOMEM; // set up our own records net = alloc_etherdev(sizeof(*dev)); if (!net) { dbg ("can't kmalloc dev"); goto out; } /* netdev_printk() needs this so do it as early as possible */ SET_NETDEV_DEV(net, &udev->dev); dev = netdev_priv(net); dev->udev = xdev; dev->intf = udev; dev->driver_info = info; dev->driver_name = name; dev->msg_enable = netif_msg_init (msg_level, NETIF_MSG_DRV | NETIF_MSG_PROBE | NETIF_MSG_LINK); skb_queue_head_init (&dev->rxq); skb_queue_head_init (&dev->txq); skb_queue_head_init (&dev->done); skb_queue_head_init(&dev->rxq_pause); dev->bh.func = usbnet_bh; dev->bh.data = (unsigned long) dev; INIT_WORK (&dev->kevent, kevent); init_usb_anchor(&dev->deferred); dev->delay.function = usbnet_bh; dev->delay.data = (unsigned long) dev; init_timer (&dev->delay); mutex_init (&dev->phy_mutex); dev->net = net; strcpy (net->name, "usb%d"); memcpy (net->dev_addr, node_id, sizeof node_id); /* rx and tx sides can use different message sizes; * bind() should set rx_urb_size in that case. */ dev->hard_mtu = net->mtu + net->hard_header_len; #if 0 // dma_supported() is deeply broken on almost all architectures // possible with some EHCI controllers if (dma_supported (&udev->dev, DMA_BIT_MASK(64))) net->features |= NETIF_F_HIGHDMA; #endif net->netdev_ops = &usbnet_netdev_ops; net->watchdog_timeo = TX_TIMEOUT_JIFFIES; net->ethtool_ops = &usbnet_ethtool_ops; // allow device-specific bind/init procedures // NOTE net->name still not usable ... if (info->bind) { status = info->bind (dev, udev); if (status < 0) goto out1; // heuristic: "usb%d" for links we know are two-host, // else "eth%d" when there's reasonable doubt. userspace // can rename the link if it knows better. if ((dev->driver_info->flags & FLAG_ETHER) != 0 && (net->dev_addr [0] & 0x02) == 0) strcpy (net->name, "eth%d"); /* WLAN devices should always be named "wlan%d" */ if ((dev->driver_info->flags & FLAG_WLAN) != 0) strcpy(net->name, "wlan%d"); /* WWAN devices should always be named "wwan%d" */ if ((dev->driver_info->flags & FLAG_WWAN) != 0) strcpy(net->name, "wwan%d"); /* maybe the remote can't receive an Ethernet MTU */ if (net->mtu > (dev->hard_mtu - net->hard_header_len)) net->mtu = dev->hard_mtu - net->hard_header_len; } else if (!info->in || !info->out) status = usbnet_get_endpoints (dev, udev); else { dev->in = usb_rcvbulkpipe (xdev, info->in); dev->out = usb_sndbulkpipe (xdev, info->out); if (!(info->flags & FLAG_NO_SETINT)) status = usb_set_interface (xdev, interface->desc.bInterfaceNumber, interface->desc.bAlternateSetting); else status = 0; } if (status >= 0 && dev->status) status = init_status (dev, udev); if (status < 0) goto out3; if (!dev->rx_urb_size) dev->rx_urb_size = dev->hard_mtu; dev->maxpacket = usb_maxpacket (dev->udev, dev->out, 1); if ((dev->driver_info->flags & FLAG_WLAN) != 0) SET_NETDEV_DEVTYPE(net, &wlan_type); if ((dev->driver_info->flags & FLAG_WWAN) != 0) SET_NETDEV_DEVTYPE(net, &wwan_type); status = register_netdev (net); if (status) goto out3; netif_info(dev, probe, dev->net, "register '%s' at usb-%s-%s, %s, %pM\n", udev->dev.driver->name, xdev->bus->bus_name, xdev->devpath, dev->driver_info->description, net->dev_addr); // ok, it's ready to go. usb_set_intfdata (udev, dev); netif_device_attach (net); if (dev->driver_info->flags & FLAG_LINK_INTR) netif_carrier_off(net); return 0; out3: if (info->unbind) info->unbind (dev, udev); out1: free_netdev(net); out: usb_put_dev(xdev); return status; }
static int __devinit dock_keyboard_probe(struct platform_device *pdev) { // struct dock_keyboard_data *data = pdev->dev.platform_data; struct dock_keyboard_data *data; struct input_dev *input; int i, error; #if defined(ACC_INT_KBD) int gpio, irq; #endif struct device *keyboard_dev; data = kzalloc(sizeof(struct dock_keyboard_data), GFP_KERNEL); if(NULL == data) { error = -ENOMEM; goto err_free_mem; } INIT_WORK(&data->work_msg, key_event_work); INIT_WORK(&data->work_led, led_work); input = input_allocate_device(); if (!input) { printk(KERN_ERR "[Keyboard] Fail to allocate input device.\n"); error = -ENOMEM; goto err_free_mem; } data->input_dev = input; data->kl = UNKOWN_KEYLAYOUT; input->name = pdev->name; input->dev.parent = &pdev->dev; input->id.bustype = BUS_RS232; set_bit(EV_SYN, input->evbit); // set_bit(EV_REP, input->evbit); set_bit(EV_KEY, input->evbit); for(i = 0; i < KEYBOARD_SIZE; i++) { if( KEY_RESERVED != dock_keycodes[i].keycode) { input_set_capability(input, EV_KEY, dock_keycodes[i].keycode); } } /* for the UK keyboard */ input_set_capability(input, EV_KEY, KEY_NUMERIC_POUND); /* for the remaped keys */ input_set_capability(input, EV_KEY, KEY_NEXTSONG); input_set_capability(input, EV_KEY, KEY_PREVIOUSSONG); error = input_register_device(data->input_dev); if(error<0) { printk(KERN_ERR "[Keyboard] Fail to register input device.\n"); error = -ENOMEM; goto err_free_mem; } /* Accessory detect pin is used by dock accessory driver. */ #if defined(ACC_INT_KBD) gpio = GPIO_ACCESSORY_INT; s3c_gpio_cfgpin(gpio, S3C_GPIO_INPUT); s3c_gpio_setpull(gpio, S3C_GPIO_PULL_NONE); irq = IRQ_EINT5; error = request_irq(irq, accessory_interrupt, IRQF_SAMPLE_RANDOM|IRQF_TRIGGER_RISING|IRQF_TRIGGER_FALLING, "p1_keyboard", data); if(error) { printk(KERN_ERR "[Keyboard] Fail to request irq : %d\n", error); error = -EINTR; goto err_free_mem; } data->gpio = gpio; #else data->gpio = GPIO_ACCESSORY_INT; #endif g_data = data; keyboard_dev = device_create(sec_class, NULL, 0, NULL, "keyboard"); if (IS_ERR(keyboard_dev)) pr_err("Failed to create device(ts)!\n"); if (device_create_file(keyboard_dev, &dev_attr_keyboard_led) < 0) pr_err("Failed to create device file(%s)!\n", dev_attr_keyboard_led.attr.name); #ifdef CONFIG_HAS_EARLYSUSPEND data->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1; data->early_suspend.suspend = keyboard_early_suspend; data->early_suspend.resume = keyboard_late_resume; register_early_suspend(&data->early_suspend); #endif /* CONFIG_HAS_EARLYSUSPEND */ init_timer(&data->timer); data->timer.expires = jiffies + HZ * 5; data->timer.function = keyboard_timer; /* timer handler */ add_timer(&data->timer); init_timer(&data->key_timer); data->key_timer.expires = jiffies + HZ/2; data->key_timer.function = remapkey_timer; add_timer(&data->key_timer); boot_time = jiffies_to_msecs(jiffies); return 0; err_free_mem: input_free_device(input); kfree(data); return error; }
static int __devinit exynos_tmu_probe(struct platform_device *pdev) { struct exynos_tmu_data *data; struct exynos_tmu_platform_data *pdata = pdev->dev.platform_data; int ret, i; if (!pdata) pdata = exynos_get_driver_data(pdev); if (!pdata) { dev_err(&pdev->dev, "No platform init data supplied.\n"); return -ENODEV; } data = devm_kzalloc(&pdev->dev, sizeof(struct exynos_tmu_data), GFP_KERNEL); if (!data) { dev_err(&pdev->dev, "Failed to allocate driver structure\n"); return -ENOMEM; } data->irq = platform_get_irq(pdev, 0); if (data->irq < 0) { dev_err(&pdev->dev, "Failed to get platform irq\n"); return data->irq; } INIT_WORK(&data->irq_work, exynos_tmu_work); data->mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!data->mem) { dev_err(&pdev->dev, "Failed to get platform resource\n"); return -ENOENT; } data->base = devm_request_and_ioremap(&pdev->dev, data->mem); if (!data->base) { dev_err(&pdev->dev, "Failed to ioremap memory\n"); return -ENODEV; } ret = devm_request_irq(&pdev->dev, data->irq, exynos_tmu_irq, IRQF_TRIGGER_RISING, "exynos-tmu", data); if (ret) { dev_err(&pdev->dev, "Failed to request irq: %d\n", data->irq); return ret; } data->regulator = regulator_get(&pdev->dev, "vdd_tmu"); if (IS_ERR(data->regulator)) { dev_err(&pdev->dev, "Failed to get regulator:vdd_tmu\n"); return PTR_ERR(data->regulator); } data->clk = clk_get(NULL, "tmu_apbif"); if (IS_ERR(data->clk)) { dev_err(&pdev->dev, "Failed to get clock\n"); goto err_reg; } if (pdata->type == SOC_ARCH_EXYNOS || pdata->type == SOC_ARCH_EXYNOS4210) data->soc = pdata->type; else { ret = -EINVAL; dev_err(&pdev->dev, "Platform not supported\n"); goto err_clk; } data->pdata = pdata; platform_set_drvdata(pdev, data); mutex_init(&data->lock); regulator_enable(data->regulator); ret = exynos_tmu_initialize(pdev); if (ret) { dev_err(&pdev->dev, "Failed to initialize TMU\n"); goto err_clk; } exynos_tmu_control(pdev, true); /* Register the sensor with thermal management interface */ (&exynos_sensor_conf)->private_data = data; exynos_sensor_conf.trip_data.trip_count = pdata->trigger_level0_en + pdata->trigger_level1_en + pdata->trigger_level2_en + pdata->trigger_level3_en; for (i = 0; i < exynos_sensor_conf.trip_data.trip_count; i++) exynos_sensor_conf.trip_data.trip_val[i] = pdata->threshold + pdata->trigger_levels[i]; exynos_sensor_conf.cooling_data.freq_clip_count = pdata->freq_tab_count; for (i = 0; i < pdata->freq_tab_count; i++) { exynos_sensor_conf.cooling_data.freq_data[i].freq_clip_max = pdata->freq_tab[i].freq_clip_max; exynos_sensor_conf.cooling_data.freq_data[i].temp_level = pdata->freq_tab[i].temp_level; } ret = exynos_register_thermal(&exynos_sensor_conf); if (ret) { dev_err(&pdev->dev, "Failed to register thermal interface\n"); goto err_clk; } return 0; err_clk: platform_set_drvdata(pdev, NULL); clk_put(data->clk); err_reg: regulator_put(data->regulator); return ret; }
static int pn547_probe(struct i2c_client *client, const struct i2c_device_id *id) { int ret; int err; int addr; char tmp[4] = {0x20, 0x00, 0x01, 0x01}; int addrcnt; struct pn547_i2c_platform_data *platform_data; struct pn547_dev *pn547_dev; #ifdef CONFIG_MACH_VICTORLTE_CTC pr_info("%s : start system_rev : %d\n", __func__,system_rev); if (system_rev < 3) { pr_info("%s : probe fail \n", __func__); return -ENODEV; } #endif if (client->dev.of_node) { platform_data = devm_kzalloc(&client->dev, sizeof(struct pn547_i2c_platform_data), GFP_KERNEL); if (!platform_data) { dev_err(&client->dev, "Failed to allocate memory\n"); return -ENOMEM; } err = pn547_parse_dt(&client->dev, platform_data); if (err) return err; } else { platform_data = client->dev.platform_data; } if (platform_data == NULL) { pr_err("%s : nfc probe fail\n", __func__); return -ENODEV; } if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { pr_err("%s : need I2C_FUNC_I2C\n", __func__); return -ENODEV; } ret = gpio_request(platform_data->irq_gpio, "nfc_int"); if (ret) return -ENODEV; ret = gpio_request(platform_data->ven_gpio, "nfc_ven"); if (ret) goto err_ven; ret = gpio_request(platform_data->firm_gpio, "nfc_firm"); if (ret) goto err_firm; #ifdef CONFIG_NFC_PN547_CLOCK_REQUEST ret = gpio_request(platform_data->clk_req_gpio, "nfc_clk_req"); if (ret) goto err_clk_req; #endif #ifdef CONFIG_NFC_PN547_8226_USE_BBCLK2 ret = gpio_request(platform_data->clk_req_gpio, "nfc_clk_req"); if (ret) goto err_clk_req; #endif pn547_dev = kzalloc(sizeof(*pn547_dev), GFP_KERNEL); if (pn547_dev == NULL) { dev_err(&client->dev, "failed to allocate memory for module data\n"); ret = -ENOMEM; goto err_exit; } #ifdef CONFIG_NFC_PN547_CLOCK_REQUEST pn547_dev->nfc_clock = msm_xo_get(MSM_XO_TCXO_A1, "nfc"); if (IS_ERR(pn547_dev->nfc_clock)) { ret = PTR_ERR(pn547_dev->nfc_clock); printk(KERN_ERR "%s: Couldn't get TCXO_A1 vote for NFC (%d)\n", __func__, ret); ret = -ENODEV; goto err_get_clock; } pn547_dev->clock_state = false; #endif #ifdef CONFIG_NFC_PN547_8226_USE_BBCLK2 pn547_dev->nfc_clock = clk_get(NULL, "nfc_clock"); if (IS_ERR(pn547_dev->nfc_clock)) { ret = PTR_ERR(pn547_dev->nfc_clock); printk(KERN_ERR "%s: Couldn't get D1 (%d)\n", __func__, ret); } else { if (clk_prepare_enable(pn547_dev->nfc_clock)) printk(KERN_ERR "%s: Couldn't prepare D1\n", __func__); } #endif #ifdef CONFIG_NFC_PN547_PMC8974_CLK_REQ #ifdef CONFIG_NFC_I2C_OVERWRITE pn547_dev->nfc_clk = clk_get(NULL, "nfc_clk"); #else pn547_dev->nfc_clk = clk_get(&client->dev, "nfc_clk"); #endif if (IS_ERR(pn547_dev->nfc_clk)) { ret = PTR_ERR(pn547_dev->nfc_clk); printk(KERN_ERR "%s: Couldn't get D1 (%d)\n", __func__, ret); } else { if (clk_prepare_enable(pn547_dev->nfc_clk)) printk(KERN_ERR "%s: Couldn't prepare D1\n", __func__); } #endif pr_info("%s : IRQ num %d\n", __func__, client->irq); pn547_dev->irq_gpio = platform_data->irq_gpio; pn547_dev->ven_gpio = platform_data->ven_gpio; pn547_dev->firm_gpio = platform_data->firm_gpio; pn547_dev->conf_gpio = platform_data->conf_gpio; #ifdef CONFIG_NFC_PN547_CLOCK_REQUEST pn547_dev->clk_req_gpio = platform_data->clk_req_gpio; pn547_dev->clk_req_irq = platform_data->clk_req_irq; #endif #ifdef CONFIG_NFC_PN547_8226_USE_BBCLK2 pn547_dev->clk_req_gpio = platform_data->clk_req_gpio; #endif pn547_dev->client = client; /* init mutex and queues */ init_waitqueue_head(&pn547_dev->read_wq); mutex_init(&pn547_dev->read_mutex); pn547_dev->pn547_device.minor = MISC_DYNAMIC_MINOR; #ifdef CONFIG_NFC_PN547 pn547_dev->pn547_device.name = "pn547"; #else pn547_dev->pn547_device.name = "pn544"; #endif pn547_dev->pn547_device.fops = &pn547_dev_fops; ret = misc_register(&pn547_dev->pn547_device); if (ret) { pr_err("%s : misc_register failed\n", __FILE__); goto err_misc_register; } /* request irq. the irq is set whenever the chip has data available * for reading. it is cleared when all data has been read. */ pr_info("%s : requesting IRQ %d\n", __func__, client->irq); gpio_direction_input(pn547_dev->irq_gpio); gpio_direction_output(pn547_dev->ven_gpio, 0); gpio_direction_output(pn547_dev->firm_gpio, 0); #if defined(CONFIG_NFC_PN547_CLOCK_REQUEST) || defined(CONFIG_NFC_PN547_8226_USE_BBCLK2) gpio_direction_input(pn547_dev->clk_req_gpio); #endif i2c_set_clientdata(client, pn547_dev); wake_lock_init(&pn547_dev->nfc_wake_lock, WAKE_LOCK_SUSPEND, "nfc_wake_lock"); #ifdef CONFIG_NFC_PN547_CLOCK_REQUEST pn547_dev->wq_clock = create_singlethread_workqueue("nfc_wq"); if (!pn547_dev->wq_clock) { ret = -ENOMEM; pr_err("%s: could not create workqueue\n", __func__); goto err_create_workqueue; } INIT_WORK(&pn547_dev->work_nfc_clock, nfc_work_func_clock); #endif if(client->irq <=0) { pr_info("%s : [Before] requesting IRQ %d\n", __func__, client->irq); client->irq = gpio_to_irq(pn547_dev->irq_gpio); pr_info("%s : [After] requesting IRQ %d\n", __func__, client->irq); } ret = request_irq(client->irq, pn547_dev_irq_handler, IRQF_TRIGGER_RISING, "pn547", pn547_dev); if (ret) { dev_err(&client->dev, "request_irq failed\n"); goto err_request_irq_failed; } disable_irq_nosync(pn547_dev->client->irq); atomic_set(&pn547_dev->irq_enabled, 0); #ifdef CONFIG_NFC_PN547_CLOCK_REQUEST ret = request_irq(pn547_dev->clk_req_irq, pn547_dev_clk_req_irq_handler, IRQF_SHARED | IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING , "pn547_clk_req", pn547_dev); if (ret) { dev_err(&client->dev, "request_irq(clk_req) failed\n"); goto err_request_irq_failed; } enable_irq_wake(pn547_dev->clk_req_irq); #endif gpio_set_value(pn547_dev->ven_gpio, 1); gpio_set_value(pn547_dev->firm_gpio, 1); /* add firmware pin */ usleep_range(4900, 5000); gpio_set_value(pn547_dev->ven_gpio, 0); usleep_range(4900, 5000); gpio_set_value(pn547_dev->ven_gpio, 1); usleep_range(4900, 5000); for (addr = 0x2B; addr > 0x27; addr--) { client->addr = addr; addrcnt = 2; do { ret = i2c_master_send(client, tmp, 4); if (ret > 0) { pr_info("%s : i2c addr=0x%X\n", __func__, client->addr); break; } } while (addrcnt--); if (ret > 0) break; } if(ret <= 0) client->addr = 0x2B; gpio_set_value(pn547_dev->ven_gpio, 0); gpio_set_value(pn547_dev->firm_gpio, 0); /* add */ if (ret < 0) pr_err("%s : fail to get i2c addr\n", __func__); /* goto err_request_irq_failed; */ else pr_info("%s : success\n", __func__); return 0; err_request_irq_failed: #ifdef CONFIG_NFC_PN547_CLOCK_REQUEST err_create_workqueue: #endif misc_deregister(&pn547_dev->pn547_device); wake_lock_destroy(&pn547_dev->nfc_wake_lock); err_misc_register: mutex_destroy(&pn547_dev->read_mutex); #ifdef CONFIG_NFC_PN547_CLOCK_REQUEST msm_xo_put(pn547_dev->nfc_clock); err_get_clock: #endif kfree(pn547_dev); err_exit: #if defined(CONFIG_NFC_PN547_CLOCK_REQUEST) || defined(CONFIG_NFC_PN547_8226_USE_BBCLK2) gpio_free(platform_data->clk_req_gpio); err_clk_req: #endif gpio_free(platform_data->firm_gpio); err_firm: gpio_free(platform_data->ven_gpio); err_ven: gpio_free(platform_data->irq_gpio); pr_err("[pn547] pn547_probe fail!\n"); return ret; }
static int __devinit mipi_samsung_disp_probe(struct platform_device *pdev) { struct platform_device *msm_fb_added_dev; #if defined(CONFIG_LCD_CLASS_DEVICE) struct lcd_device *lcd_device; int ret; #endif #if defined(CONFIG_BACKLIGHT_CLASS_DEVICE) struct backlight_device *bd; #endif msd.dstat.acl_on = false; if (pdev->id == 0) { msd.mipi_samsung_disp_pdata = pdev->dev.platform_data; first_on = false; return 0; } msm_fb_added_dev = msm_fb_add_device(pdev); mutex_init(&dsi_tx_mutex); #if defined(CONFIG_HAS_EARLYSUSPEND) || defined(CONFIG_LCD_CLASS_DEVICE) msd.msm_pdev = msm_fb_added_dev; #endif #if defined(CONFIG_HAS_EARLYSUSPEND) msd.early_suspend.suspend = mipi_samsung_disp_early_suspend; msd.early_suspend.resume = mipi_samsung_disp_late_resume; msd.early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN; register_early_suspend(&msd.early_suspend); #endif #if defined(CONFIG_ESD_ERR_FG_RECOVERY) INIT_WORK(&err_fg_work, err_fg_work_func); err_fg_gpio = MSM_GPIO_TO_INT(GPIO_ESD_VGH_DET); ret = gpio_request(GPIO_ESD_VGH_DET, "err_fg"); if (ret) { pr_err("request gpio GPIO_LCD_ESD_DET failed, ret=%d\n",ret); gpio_free(GPIO_ESD_VGH_DET); return ret; } gpio_tlmm_config(GPIO_CFG(GPIO_ESD_VGH_DET, 0, GPIO_CFG_INPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA),GPIO_CFG_ENABLE); ret = request_threaded_irq(err_fg_gpio, NULL, err_fg_irq_handler, IRQF_TRIGGER_HIGH | IRQF_ONESHOT, "esd_detect", NULL); if (ret) { pr_err("%s : Failed to request_irq. :ret=%d", __func__, ret); } disable_irq(err_fg_gpio); #endif #if defined(CONFIG_LCD_CLASS_DEVICE) lcd_device = lcd_device_register("panel", &pdev->dev, NULL, &mipi_samsung_disp_props); if (IS_ERR(lcd_device)) { ret = PTR_ERR(lcd_device); printk(KERN_ERR "lcd : failed to register device\n"); return ret; } #ifdef WA_FOR_FACTORY_MODE sysfs_remove_file(&lcd_device->dev.kobj, &dev_attr_lcd_power.attr); ret = sysfs_create_file(&lcd_device->dev.kobj, &dev_attr_lcd_power.attr); if (ret) { pr_info("sysfs create fail-%s\n", dev_attr_lcd_power.attr.name); } #endif ret = sysfs_create_file(&lcd_device->dev.kobj, &dev_attr_lcd_type.attr); if (ret) { pr_info("sysfs create fail-%s\n", dev_attr_lcd_type.attr.name); } ret = sysfs_create_file(&lcd_device->dev.kobj, &dev_attr_gamma_mode.attr); if (ret) { pr_info("sysfs create fail-%s\n", dev_attr_gamma_mode.attr.name); } ret = sysfs_create_file(&lcd_device->dev.kobj, &dev_attr_power_reduce.attr); if (ret) { pr_info("sysfs create fail-%s\n", dev_attr_power_reduce.attr.name); } #if defined(CONFIG_BACKLIGHT_CLASS_DEVICE) bd = backlight_device_register("panel", &lcd_device->dev, NULL, NULL, NULL); if (IS_ERR(bd)) { ret = PTR_ERR(bd); pr_info("backlight : failed to register device\n"); return ret; } ret = sysfs_create_file(&bd->dev.kobj, &dev_attr_auto_brightness.attr); if (ret) { pr_info("sysfs create fail-%s\n", dev_attr_auto_brightness.attr.name); } #endif #endif #if defined(CONFIG_MDNIE_LITE_TUNING) \ || defined(CONFIG_FB_MDP4_ENHANCE) /* mdnie sysfs create */ init_mdnie_class(); #endif mipi_dsi_buf_alloc(&mdnie_tune_tx_buf, DSI_BUF_SIZE); #if defined(DDI_VIDEO_ENHANCE_TUNING) ret = sysfs_create_file(&lcd_device->dev.kobj, &dev_attr_tuning.attr); if (ret) { pr_info("sysfs create fail-%s\n", dev_attr_tuning.attr.name); } #endif return 0; }
static int btusb_probe(struct usb_interface *intf, const struct usb_device_id *id) { struct usb_endpoint_descriptor *ep_desc; struct btusb_data *data; struct hci_dev *hdev; int i, err; BT_DBG("intf %p id %p", intf, id); /* interface numbers are hardcoded in the spec */ if (intf->cur_altsetting->desc.bInterfaceNumber != 0) return -ENODEV; if (!id->driver_info) { const struct usb_device_id *match; match = usb_match_id(intf, blacklist_table); if (match) id = match; } if (id->driver_info == BTUSB_IGNORE) return -ENODEV; if (ignore_dga && id->driver_info & BTUSB_DIGIANSWER) return -ENODEV; if (ignore_csr && id->driver_info & BTUSB_CSR) return -ENODEV; if (ignore_sniffer && id->driver_info & BTUSB_SNIFFER) return -ENODEV; if (id->driver_info & BTUSB_ATH3012) { struct usb_device *udev = interface_to_usbdev(intf); /* Old firmware would otherwise let ath3k driver load * patch and sysconfig files */ if (le16_to_cpu(udev->descriptor.bcdDevice) <= 0x0001) return -ENODEV; } data = kzalloc(sizeof(*data), GFP_KERNEL); if (!data) return -ENOMEM; for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) { ep_desc = &intf->cur_altsetting->endpoint[i].desc; if (!data->intr_ep && usb_endpoint_is_int_in(ep_desc)) { data->intr_ep = ep_desc; continue; } if (!data->bulk_tx_ep && usb_endpoint_is_bulk_out(ep_desc)) { data->bulk_tx_ep = ep_desc; continue; } if (!data->bulk_rx_ep && usb_endpoint_is_bulk_in(ep_desc)) { data->bulk_rx_ep = ep_desc; continue; } } if (!data->intr_ep || !data->bulk_tx_ep || !data->bulk_rx_ep) { kfree(data); return -ENODEV; } data->cmdreq_type = USB_TYPE_CLASS; data->udev = interface_to_usbdev(intf); data->intf = intf; spin_lock_init(&data->lock); INIT_WORK(&data->work, btusb_work); INIT_WORK(&data->waker, btusb_waker); spin_lock_init(&data->txlock); init_usb_anchor(&data->tx_anchor); init_usb_anchor(&data->intr_anchor); init_usb_anchor(&data->bulk_anchor); init_usb_anchor(&data->isoc_anchor); init_usb_anchor(&data->deferred); hdev = hci_alloc_dev(); if (!hdev) { kfree(data); return -ENOMEM; } hdev->bus = HCI_USB; hdev->driver_data = data; data->hdev = hdev; SET_HCIDEV_DEV(hdev, &intf->dev); hdev->open = btusb_open; hdev->close = btusb_close; hdev->flush = btusb_flush; hdev->send = btusb_send_frame; hdev->destruct = btusb_destruct; hdev->notify = btusb_notify; hdev->owner = THIS_MODULE; /* Interface numbers are hardcoded in the specification */ data->isoc = usb_ifnum_to_if(data->udev, 1); if (!reset) set_bit(HCI_QUIRK_NO_RESET, &hdev->quirks); if (force_scofix || id->driver_info & BTUSB_WRONG_SCO_MTU) { if (!disable_scofix) set_bit(HCI_QUIRK_FIXUP_BUFFER_SIZE, &hdev->quirks); } if (id->driver_info & BTUSB_BROKEN_ISOC) data->isoc = NULL; if (id->driver_info & BTUSB_DIGIANSWER) { data->cmdreq_type = USB_TYPE_VENDOR; set_bit(HCI_QUIRK_NO_RESET, &hdev->quirks); } if (id->driver_info & BTUSB_CSR) { struct usb_device *udev = data->udev; /* Old firmware would otherwise execute USB reset */ if (le16_to_cpu(udev->descriptor.bcdDevice) < 0x117) set_bit(HCI_QUIRK_NO_RESET, &hdev->quirks); } if (id->driver_info & BTUSB_SNIFFER) { struct usb_device *udev = data->udev; /* New sniffer firmware has crippled HCI interface */ if (le16_to_cpu(udev->descriptor.bcdDevice) > 0x997) set_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks); data->isoc = NULL; } if (id->driver_info & BTUSB_BCM92035) { unsigned char cmd[] = { 0x3b, 0xfc, 0x01, 0x00 }; struct sk_buff *skb; skb = bt_skb_alloc(sizeof(cmd), GFP_KERNEL); if (skb) { memcpy(skb_put(skb, sizeof(cmd)), cmd, sizeof(cmd)); skb_queue_tail(&hdev->driver_init, skb); } } if (data->isoc) { err = usb_driver_claim_interface(&btusb_driver, data->isoc, data); if (err < 0) { hci_free_dev(hdev); kfree(data); return err; } } err = hci_register_dev(hdev); if (err < 0) { hci_free_dev(hdev); kfree(data); return err; } usb_set_intfdata(intf, data); return 0; }
/*different handlings of different flash's states*/ int tps61310_set_flash(unsigned led_state) { int rc = 0; hw_camera_flash_number led_num = get_hw_camera_flash_number(); printk("tps61310_set_flash: led_state = %d\n", led_state); /* timer should be cancel,when Led_state possible changed */ if(timer_is_run) { hrtimer_cancel(&flash_timer); timer_is_run = false; } switch (led_state) { case MSM_CAMERA_LED_LOW: case MSM_CAMERA_LED_TORCH: case MSM_CAMERA_LED_TORCH_MIDDLE: //use for flashlight tps61310_i2c_write( tps61310_client,0x00, 0x0A ); tps61310_i2c_write( tps61310_client,0x05, 0x6F ); tps61310_i2c_write( tps61310_client,0x01, 0x40 ); tps61310_i2c_write( tps61310_client,0x02, 0x40 ); INIT_WORK(&flash_work, flash_on); hrtimer_init(&flash_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); flash_timer.function= flash_timer_func; timer_is_run = true; hrtimer_start(&flash_timer, ktime_set(FLASH_REFRESHED_TIME, 0), HRTIMER_MODE_REL); break; case MSM_CAMERA_LED_HIGH: gpio_set_value(tps61310_strb0, 1); tps61310_i2c_write( tps61310_client, 0x03, 0xE7 ); tps61310_i2c_write( tps61310_client, 0x05, 0x6F ); if(CAMERA_FLASH_LED_DOUBLE == led_num) { tps61310_i2c_write( tps61310_client, 0x01, 0x94 ); tps61310_i2c_write( tps61310_client, 0x02, 0x8a ); } else { tps61310_i2c_write( tps61310_client, 0x01, 0x88 ); tps61310_i2c_write( tps61310_client, 0x02, 0x88 ); } break; case MSM_CAMERA_LED_TORCH_HIGH: //use for flashlight tps61310_i2c_write( tps61310_client, 0x00, 0x12 ); tps61310_i2c_write( tps61310_client, 0x05, 0x6F ); tps61310_i2c_write( tps61310_client, 0x01, 0x40 ); tps61310_i2c_write( tps61310_client, 0x02, 0x40 ); INIT_WORK(&flash_work, flash_on); hrtimer_init(&flash_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); flash_timer.function= flash_timer_func; timer_is_run = true; hrtimer_start(&flash_timer, ktime_set(FLASH_REFRESHED_TIME, 0), HRTIMER_MODE_REL); break; case MSM_CAMERA_LED_TORCH_LOW: //use for flashlight tps61310_i2c_write( tps61310_client,0x00, 0x08); tps61310_i2c_write( tps61310_client,0x05, 0x6F ); tps61310_i2c_write( tps61310_client,0x01, 0x40 ); tps61310_i2c_write( tps61310_client,0x02, 0x40 ); INIT_WORK(&flash_work, flash_on); hrtimer_init(&flash_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); flash_timer.function= flash_timer_func; timer_is_run = true; hrtimer_start(&flash_timer, ktime_set(FLASH_REFRESHED_TIME, 0), HRTIMER_MODE_REL); break; case MSM_CAMERA_LED_OFF: tps61310_i2c_write( tps61310_client, 0x00, 0x80 ); gpio_set_value(tps61310_strb0, 0); break; case MSM_CAMERA_LED_FIRST_MMI: printk("MSM_CAMERA_LED_FIRST_MMI\n"); tps61310_i2c_write( tps61310_client,0x00, 0x08 );/*turn on led and then delay*/ tps61310_i2c_write( tps61310_client,0x05, 0x6F ); tps61310_i2c_write( tps61310_client,0x01, 0x40 ); tps61310_i2c_write( tps61310_client,0x02, 0x40 ); usleep(1000*200); tps61310_i2c_write( tps61310_client, 0x00, 0x80 );/*turn off*/ gpio_set_value(tps61310_strb0, 0); break; case MSM_CAMERA_LED_SECOND_MMI: printk("MSM_CAMERA_LED_SECOND_MMI\n"); tps61310_i2c_write( tps61310_client,0x00, 0x02 );/*switch to the other led*/ tps61310_i2c_write( tps61310_client,0x05, 0x6F ); tps61310_i2c_write( tps61310_client,0x01, 0x40 ); tps61310_i2c_write( tps61310_client,0x02, 0x40 ); usleep(1000*200); tps61310_i2c_write( tps61310_client, 0x00, 0x80 );/*turn off*/ gpio_set_value(tps61310_strb0, 0); break; default: /* Deal with nothing here. */ break; } return rc; }
/**************************************************************************** * driver functions ***************************************************************************/ static int __init mt65xx_leds_probe(struct platform_device *pdev) { int i; int ret, rc; struct cust_mt65xx_led *cust_led_list = mt_get_cust_led_list(); LEDS_DRV_DEBUG("[LED]%s\n", __func__); get_div_array(); for (i = 0; i < MT65XX_LED_TYPE_TOTAL; i++) { if (cust_led_list[i].mode == MT65XX_LED_MODE_NONE) { g_leds_data[i] = NULL; continue; } g_leds_data[i] = kzalloc(sizeof(struct mt65xx_led_data), GFP_KERNEL); if (!g_leds_data[i]) { ret = -ENOMEM; goto err; } g_leds_data[i]->cust.mode = cust_led_list[i].mode; g_leds_data[i]->cust.data = cust_led_list[i].data; g_leds_data[i]->cust.name = cust_led_list[i].name; g_leds_data[i]->cdev.name = cust_led_list[i].name; g_leds_data[i]->cust.config_data = cust_led_list[i].config_data;//bei add g_leds_data[i]->cdev.brightness_set = mt65xx_led_set; g_leds_data[i]->cdev.blink_set = mt65xx_blink_set; INIT_WORK(&g_leds_data[i]->work, mt_mt65xx_led_work); ret = led_classdev_register(&pdev->dev, &g_leds_data[i]->cdev); if(strcmp(g_leds_data[i]->cdev.name,"lcd-backlight") == 0) { rc = device_create_file(g_leds_data[i]->cdev.dev, &dev_attr_duty); if(rc) { LEDS_DRV_DEBUG("[LED]device_create_file duty fail!\n"); } rc = device_create_file(g_leds_data[i]->cdev.dev, &dev_attr_div); if(rc) { LEDS_DRV_DEBUG("[LED]device_create_file duty fail!\n"); } rc = device_create_file(g_leds_data[i]->cdev.dev, &dev_attr_frequency); if(rc) { LEDS_DRV_DEBUG("[LED]device_create_file duty fail!\n"); } rc = device_create_file(g_leds_data[i]->cdev.dev, &dev_attr_pwm_register); if(rc) { LEDS_DRV_DEBUG("[LED]device_create_file duty fail!\n"); } bl_setting = &g_leds_data[i]->cust; } if (ret) goto err; } #ifdef CONTROL_BL_TEMPERATURE last_level = 0; limit = 255; limit_flag = 0; current_level = 0; LEDS_DRV_DEBUG("[LED]led probe last_level = %d, limit = %d, limit_flag = %d, current_level = %d\n",last_level,limit,limit_flag,current_level); #endif return 0; err: if (i) { for (i = i-1; i >=0; i--) { if (!g_leds_data[i]) continue; led_classdev_unregister(&g_leds_data[i]->cdev); cancel_work_sync(&g_leds_data[i]->work); kfree(g_leds_data[i]); g_leds_data[i] = NULL; } } return ret; }
static int cm3663_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id) { int ret = -ENODEV; struct input_dev *input_dev; struct cm3663_data *cm3663; if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { pr_err("%s: i2c functionality check failed!\n", __func__); return ret; } cm3663 = kzalloc(sizeof(struct cm3663_data), GFP_KERNEL); if (!cm3663) { pr_err("%s: failed to alloc memory for module data\n", __func__); return -ENOMEM; } cm3663->pdata = client->dev.platform_data; cm3663->i2c_client = client; i2c_set_clientdata(client, cm3663); /* wake lock init */ wake_lock_init(&cm3663->prx_wake_lock, WAKE_LOCK_SUSPEND, "prx_wake_lock"); mutex_init(&cm3663->power_lock); /* setup initial registers */ ret = cm3663_setup_reg(cm3663); if (ret < 0) { pr_err("%s: could not setup regs\n", __func__); goto err_setup_reg; } ret = cm3663_setup_irq(cm3663); if (ret) { pr_err("%s: could not setup irq\n", __func__); goto err_setup_irq; } /* allocate proximity input_device */ input_dev = input_allocate_device(); if (!input_dev) { pr_err("%s: could not allocate input device\n", __func__); goto err_input_allocate_device_proximity; } cm3663->proximity_input_dev = input_dev; input_set_drvdata(input_dev, cm3663); input_dev->name = "proximity_sensor"; input_set_capability(input_dev, EV_ABS, ABS_DISTANCE); input_set_abs_params(input_dev, ABS_DISTANCE, 0, 1, 0, 0); ret = input_register_device(input_dev); if (ret < 0) { pr_err("%s: could not register input device\n", __func__); input_free_device(input_dev); goto err_input_register_device_proximity; } ret = sysfs_create_group(&input_dev->dev.kobj, &proximity_attribute_group); if (ret) { pr_err("%s: could not create sysfs group\n", __func__); goto err_sysfs_create_group_proximity; } /* light_timer settings. we poll for light values using a timer. */ hrtimer_init(&cm3663->light_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); cm3663->light_poll_delay = ns_to_ktime(200 * NSEC_PER_MSEC); cm3663->light_timer.function = cm3663_light_timer_func; /* prox_timer settings. we poll for light values using a timer. */ hrtimer_init(&cm3663->prox_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); cm3663->prox_poll_delay = ns_to_ktime(2000 * NSEC_PER_MSEC); cm3663->prox_timer.function = cm3663_prox_timer_func; /* the timer just fires off a work queue request. we need a thread to read the i2c (can be slow and blocking). */ cm3663->light_wq = create_singlethread_workqueue("cm3663_light_wq"); if (!cm3663->light_wq) { ret = -ENOMEM; pr_err("%s: could not create light workqueue\n", __func__); goto err_create_light_workqueue; } cm3663->prox_wq = create_singlethread_workqueue("cm3663_prox_wq"); if (!cm3663->prox_wq) { ret = -ENOMEM; pr_err("%s: could not create prox workqueue\n", __func__); goto err_create_prox_workqueue; } /* this is the thread function we run on the work queue */ INIT_WORK(&cm3663->work_light, cm3663_work_func_light); INIT_WORK(&cm3663->work_prox, cm3663_work_func_prox); /* allocate lightsensor-level input_device */ input_dev = input_allocate_device(); if (!input_dev) { pr_err("%s: could not allocate input device\n", __func__); ret = -ENOMEM; goto err_input_allocate_device_light; } input_set_drvdata(input_dev, cm3663); input_dev->name = "light_sensor"; #if defined(CONFIG_MACH_S2PLUS) input_set_capability(input_dev, EV_REL, REL_MISC); #else input_set_capability(input_dev, EV_ABS, ABS_MISC); input_set_abs_params(input_dev, ABS_MISC, 0, 1, 0, 0); #endif ret = input_register_device(input_dev); if (ret < 0) { pr_err("%s: could not register input device\n", __func__); input_free_device(input_dev); goto err_input_register_device_light; } cm3663->light_input_dev = input_dev; ret = sysfs_create_group(&input_dev->dev.kobj, &light_attribute_group); if (ret) { pr_err("%s: could not create sysfs group\n", __func__); goto err_sysfs_create_group_light; } #if defined(CONFIG_MACH_S2PLUS) /* set sysfs for proximity sensor */ cm3663->proximity_dev = sensors_classdev_register("proximity_sensor"); if (IS_ERR(cm3663->proximity_dev)) { pr_err("%s: could not create proximity_dev\n", __func__); goto err_proximity_classdev_create; } if (device_create_file(cm3663->proximity_dev, &dev_attr_state) < 0) { pr_err("%s: could not create device file(%s)!\n", __func__, dev_attr_state.attr.name); goto err_proximity_device_create_file1; } if (device_create_file(cm3663->proximity_dev, &dev_attr_prox_avg) < 0) { pr_err("%s: could not create device file(%s)!\n", __func__, dev_attr_prox_avg.attr.name); goto err_proximity_device_create_file2; } dev_set_drvdata(cm3663->proximity_dev, cm3663); /* set sysfs for light sensor */ cm3663->switch_cmd_dev = sensors_classdev_register("light_sensor"); if (IS_ERR(cm3663->switch_cmd_dev)) { pr_err("%s: could not create switch_cmd_dev\n", __func__); goto err_light_classdev_create; } if (device_create_file(cm3663->switch_cmd_dev, &dev_attr_lux) < 0) { pr_err("%s: could not create device file(%s)!\n", __func__, dev_attr_lux.attr.name); goto err_light_device_create_file; } dev_set_drvdata(cm3663->switch_cmd_dev, cm3663); #else /* set sysfs for proximity sensor */ cm3663->proximity_class = class_create(THIS_MODULE, "proximity"); if (IS_ERR(cm3663->proximity_class)) { pr_err("%s: could not create proximity_class\n", __func__); goto err_proximity_class_create; } cm3663->proximity_dev = device_create(cm3663->proximity_class, NULL, 0, NULL, "proximity"); if (IS_ERR(cm3663->proximity_dev)) { pr_err("%s: could not create proximity_dev\n", __func__); goto err_proximity_device_create; } if (device_create_file(cm3663->proximity_dev, &dev_attr_proximity_state) < 0) { pr_err("%s: could not create device file(%s)!\n", __func__, dev_attr_proximity_state.attr.name); goto err_proximity_device_create_file1; } if (device_create_file(cm3663->proximity_dev, &dev_attr_proximity_avg) < 0) { pr_err("%s: could not create device file(%s)!\n", __func__, dev_attr_proximity_avg.attr.name); goto err_proximity_device_create_file2; } dev_set_drvdata(cm3663->proximity_dev, cm3663); /* set sysfs for light sensor */ cm3663->lightsensor_class = class_create(THIS_MODULE, "lightsensor"); if (IS_ERR(cm3663->lightsensor_class)) { pr_err("%s: could not create lightsensor_class\n", __func__); goto err_light_class_create; } cm3663->switch_cmd_dev = device_create(cm3663->lightsensor_class, NULL, 0, NULL, "switch_cmd"); if (IS_ERR(cm3663->switch_cmd_dev)) { pr_err("%s: could not create switch_cmd_dev\n", __func__); goto err_light_device_create; } if (device_create_file(cm3663->switch_cmd_dev, &dev_attr_lightsensor_file_state) < 0) { pr_err("%s: could not create device file(%s)!\n", __func__, dev_attr_lightsensor_file_state.attr.name); goto err_light_device_create_file; } dev_set_drvdata(cm3663->switch_cmd_dev, cm3663); #endif goto done; /* error, unwind it all */ #if defined(CONFIG_MACH_S2PLUS) err_light_device_create_file: sensors_classdev_unregister(cm3663->switch_cmd_dev); err_light_classdev_create: device_remove_file(cm3663->proximity_dev, &dev_attr_prox_avg); err_proximity_device_create_file2: device_remove_file(cm3663->proximity_dev, &dev_attr_state); err_proximity_device_create_file1: sensors_classdev_unregister(cm3663->proximity_dev); err_proximity_classdev_create: #else err_light_device_create_file: device_destroy(cm3663->lightsensor_class, 0); err_light_device_create: class_destroy(cm3663->lightsensor_class); err_light_class_create: device_remove_file(cm3663->proximity_dev, &dev_attr_proximity_avg); err_proximity_device_create_file2: device_remove_file(cm3663->proximity_dev, &dev_attr_proximity_state); err_proximity_device_create_file1: device_destroy(cm3663->proximity_class, 0); err_proximity_device_create: class_destroy(cm3663->proximity_class); err_proximity_class_create: #endif sysfs_remove_group(&input_dev->dev.kobj, &light_attribute_group); err_sysfs_create_group_light: input_unregister_device(cm3663->light_input_dev); err_input_register_device_light: err_input_allocate_device_light: destroy_workqueue(cm3663->prox_wq); err_create_prox_workqueue: destroy_workqueue(cm3663->light_wq); err_create_light_workqueue: sysfs_remove_group(&cm3663->proximity_input_dev->dev.kobj, &proximity_attribute_group); err_sysfs_create_group_proximity: input_unregister_device(cm3663->proximity_input_dev); err_input_register_device_proximity: err_input_allocate_device_proximity: free_irq(cm3663->irq, 0); err_setup_irq: err_setup_reg: mutex_destroy(&cm3663->power_lock); wake_lock_destroy(&cm3663->prx_wake_lock); kfree(cm3663); done: return ret; }
/* * nss_auto_scale_handler() * Enables or Disable Auto Scaling */ static int nss_auto_scale_handler (ctl_table *ctl, int write, void __user *buffer, size_t *lenp, loff_t *ppos) { int ret; ret = proc_dointvec(ctl, write, buffer, lenp, ppos); if (!write) { return ret; } if (nss_cmd_buf.auto_scale != 1) { /* * Is auto scaling currently enabled? If so, send the command to * disable stats reporting to NSS */ if (nss_runtime_samples.freq_scale_ready != 0) { nss_cmd_buf.current_freq = nss_runtime_samples.freq_scale[nss_runtime_samples.freq_scale_index].frequency; nss_work = (nss_work_t *)kmalloc(sizeof(nss_work_t), GFP_ATOMIC); if (!nss_work) { nss_info("NSS Freq WQ kmalloc fail"); return ret; } INIT_WORK((struct work_struct *)nss_work, nss_wq_function); nss_work->frequency = nss_cmd_buf.current_freq; nss_work->stats_enable = 0; queue_work(nss_wq, (struct work_struct *)nss_work); nss_runtime_samples.freq_scale_ready = 0; /* * The current samples would be stale later when scaling is * enabled again, hence reset them */ nss_reset_frequency_stats_samples(); } return ret; } /* * Auto Scaling is already being done */ if (nss_runtime_samples.freq_scale_ready == 1) { return ret; } /* * Setup default values - Middle of Freq Scale Band */ nss_runtime_samples.freq_scale_index = 1; nss_cmd_buf.current_freq = nss_runtime_samples.freq_scale[nss_runtime_samples.freq_scale_index].frequency; nss_work = (nss_work_t *)kmalloc(sizeof(nss_work_t), GFP_ATOMIC); if (!nss_work) { nss_info("NSS Freq WQ kmalloc fail"); return ret; } INIT_WORK((struct work_struct *)nss_work, nss_wq_function); nss_work->frequency = nss_cmd_buf.current_freq; nss_work->stats_enable = 1; queue_work(nss_wq, (struct work_struct *)nss_work); nss_runtime_samples.freq_scale_ready = 1; return ret; }
static int headset_switch_probe(struct platform_device *pdev) { struct pm860x_chip *chip = dev_get_drvdata(pdev->dev.parent); struct pm860x_headset_info *info; struct pm860x_platform_data *pm860x_pdata; struct gpio_switch_platform_data *pdata_headset = pdev->dev.platform_data; struct gpio_switch_platform_data *pdata_hook = pdata_headset + 1; struct headset_switch_data *switch_data_headset, *switch_data_hook; int irq_headset, irq_hook, ret = 0; if (pdev->dev.parent->platform_data) { pm860x_pdata = pdev->dev.parent->platform_data; } else { pr_debug("Invalid pm860x platform data!\n"); return -EINVAL; } if (pdata_headset == NULL || pdata_hook == NULL) { pr_debug("Invalid gpio switch platform data!\n"); return -EBUSY; } irq_headset = platform_get_irq(pdev, 0); if (irq_headset < 0) { dev_err(&pdev->dev, "No IRQ resource for headset!\n"); return -EINVAL; } irq_hook = platform_get_irq(pdev, 1); if (irq_hook < 0) { dev_err(&pdev->dev, "No IRQ resource for hook!\n"); return -EINVAL; } info = kzalloc(sizeof(struct pm860x_headset_info), GFP_KERNEL); if (!info) return -ENOMEM; info->chip = chip; info->dev = &pdev->dev; info->irq_headset = irq_headset + chip->irq_base; info->irq_hook = irq_hook + chip->irq_base; info->headset_flag = pm860x_pdata->headset_flag; info->i2c = (chip->id == CHIP_PM8607) ? chip->client : chip->companion; switch_data_headset = kzalloc(sizeof(struct headset_switch_data), GFP_KERNEL); if (!switch_data_headset) return -ENOMEM; switch_data_hook = kzalloc(sizeof(struct headset_switch_data), GFP_KERNEL); if (!switch_data_hook) return -ENOMEM; switch_data_headset->sdev.name = pdata_headset->name; switch_data_headset->name_on = pdata_headset->name_on; switch_data_headset->name_off = pdata_headset->name_off; switch_data_headset->state_on = pdata_headset->state_on; switch_data_headset->state_off = pdata_headset->state_off; switch_data_headset->sdev.print_state = switch_headset_print_state; info->psw_data_headset = switch_data_headset; switch_data_hook->sdev.name = pdata_hook->name; switch_data_hook->name_on = pdata_hook->name_on; switch_data_hook->name_off = pdata_hook->name_off; switch_data_hook->state_on = pdata_hook->state_on; switch_data_hook->state_off = pdata_hook->state_off; switch_data_hook->sdev.print_state = switch_headset_print_state; info->psw_data_hook = switch_data_hook; ret = switch_dev_register(&switch_data_headset->sdev); if (ret < 0) goto err_switch_dev_register; ret = switch_dev_register(&switch_data_hook->sdev); if (ret < 0) goto err_switch_dev_register; ret = request_threaded_irq(info->irq_headset, NULL, pm860x_headset_handler, IRQF_ONESHOT, "headset", info); if (ret < 0) { dev_err(chip->dev, "Failed to request IRQ: #%d: %d\n", info->irq_headset, ret); goto out_irq_headset; } ret = request_threaded_irq(info->irq_hook, NULL, pm860x_headset_handler, IRQF_ONESHOT, "hook", info); if (ret < 0) { dev_err(chip->dev, "Failed to request IRQ: #%d: %d\n", info->irq_hook, ret); goto out_irq_hook; } platform_set_drvdata(pdev, info); /* set hook detection debounce time to 24ms, it's the best setting we experienced */ pm860x_set_bits(info->i2c, PM8607_HEADSET_DECTION, PM8607_HEADSET_BTN_DBNC, 0x10); //pm860x_set_bits(info->i2c, PM8607_HEADSET_DECTION, PM8607_HEADSET_PERIOD, 0x04); /* set headset period to continuous detection */ pm860x_set_bits(info->i2c, PM8607_HEADSET_DECTION, PM8607_HEADSET_PERIOD, 0x06); /* set MIC detection parameter: MIC period set to 250msec */ pm860x_reg_write(info->i2c, PM8607_MIC_DECTION, 0xDC); /* mask hook interrupt since we don't want the first false hook press down detection when inserting a headset without Mic */ pm860x_set_bits(info->i2c, PM8607_INT_MASK_3, PM8607_INT_EN_HOOK, 0); /* enable headset detection */ pm860x_set_bits(info->i2c, PM8607_HEADSET_DECTION, PM8607_HEADSET_EN_HS_DET, 1); INIT_WORK(&info->work_headset, headset_switch_work); INIT_WORK(&info->work_hook, hook_switch_work); /* Perform initial detection */ headset_switch_work(&info->work_headset); hook_switch_work(&info->work_hook); return 0; err_switch_dev_register: kfree(switch_data_headset); kfree(switch_data_hook); out_irq_hook: free_irq(info->irq_headset, info); out_irq_headset: kfree(info); return ret; }
static acpi_status __acpi_os_execute(acpi_execute_type type, acpi_osd_exec_callback function, void *context, int hp) { acpi_status status = AE_OK; struct acpi_os_dpc *dpc; struct workqueue_struct *queue; int ret; ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Scheduling function [%p(%p)] for deferred execution.\n", function, context)); /* * Allocate/initialize DPC structure. Note that this memory will be * freed by the callee. The kernel handles the work_struct list in a * way that allows us to also free its memory inside the callee. * Because we may want to schedule several tasks with different * parameters we can't use the approach some kernel code uses of * having a static work_struct. */ dpc = kzalloc(sizeof(struct acpi_os_dpc), GFP_ATOMIC); if (!dpc) return AE_NO_MEMORY; dpc->function = function; dpc->context = context; /* * We can't run hotplug code in keventd_wq/kacpid_wq/kacpid_notify_wq * because the hotplug code may call driver .remove() functions, * which invoke flush_scheduled_work/acpi_os_wait_events_complete * to flush these workqueues. * * To prevent lockdep from complaining unnecessarily, make sure that * there is a different static lockdep key for each workqueue by using * INIT_WORK() for each of them separately. */ if (hp) { queue = kacpi_hotplug_wq; dpc->wait = 1; INIT_WORK(&dpc->work, acpi_os_execute_deferred); } else if (type == OSL_NOTIFY_HANDLER) { queue = kacpi_notify_wq; INIT_WORK(&dpc->work, acpi_os_execute_deferred); } else { queue = kacpid_wq; INIT_WORK(&dpc->work, acpi_os_execute_deferred); } /* * On some machines, a software-initiated SMI causes corruption unless * the SMI runs on CPU 0. An SMI can be initiated by any AML, but * typically it's done in GPE-related methods that are run via * workqueues, so we can avoid the known corruption cases by always * queueing on CPU 0. */ ret = queue_work_on(0, queue, &dpc->work); if (!ret) { printk(KERN_ERR PREFIX "Call to queue_work() failed.\n"); status = AE_ERROR; kfree(dpc); } return status; }
static int __devinit an30259a_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct an30259a_data *data; int ret, i; dev_err(&client->adapter->dev, "%s\n", __func__); if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { dev_err(&client->dev, "need I2C_FUNC_I2C.\n"); return -ENODEV; } data = kzalloc(sizeof(*data), GFP_KERNEL); if (!data) { dev_err(&client->adapter->dev, "failed to allocate driver data.\n"); return -ENOMEM; } #ifdef CONFIG_OF ret = an30259a_parse_dt(&client->dev); if (ret) { pr_err("[%s] an30259a parse dt failed\n", __func__); kfree(data); return ret; } #endif i2c_set_clientdata(client, data); data->client = client; b_client = client; mutex_init(&data->mutex); /* initialize LED */ LED_R_CURRENT = LED_G_CURRENT = LED_B_CURRENT = led_default_cur; led_conf[0].max_brightness = LED_R_CURRENT; led_conf[1].max_brightness = LED_G_CURRENT; led_conf[2].max_brightness = LED_B_CURRENT; for (i = 0; i < MAX_NUM_LEDS; i++) { ret = an30259a_initialize(client, &data->leds[i], i); if (ret < 0) { dev_err(&client->adapter->dev, "failure on initialization\n"); goto exit; } INIT_WORK(&(data->leds[i].brightness_work), an30259a_led_brightness_work); } #if defined (CONFIG_SEC_FACTORY) #if defined (CONFIG_SEC_S_PROJECT) if ( (f_jig_cable == 0) && (get_lcd_attached() == 0) ) { pr_info("%s:Factory MODE - No OCTA, Battery BOOTING\n", __func__); leds_on(LED_R, true, false, LED_R_CURRENT); leds_i2c_write_all(data->client); } #endif #endif #ifdef SEC_LED_SPECIFIC led_enable_fade = 0; /* default to stock behaviour = blink */ // led_intensity = 0; /* default to CM behaviour = brighter blink intensity allowed */ led_intensity = 40; /* default to Samsung behaviour = normal intensity */ led_speed = 1; /* default to stock behaviour = normal blinking/fading speed */ led_slope_up_1 = 1; /* default slope durations for fading */ led_slope_up_2 = 1; led_slope_down_1 = 1; led_slope_down_2 = 1; led_dev = device_create(sec_class, NULL, 0, data, "led"); if (IS_ERR(led_dev)) { dev_err(&client->dev, "Failed to create device for samsung specific led\n"); ret = -ENODEV; goto exit1; } ret = sysfs_create_group(&led_dev->kobj, &sec_led_attr_group); if (ret) { dev_err(&client->dev, "Failed to create sysfs group for samsung specific led\n"); goto exit; } #endif return ret; #ifdef SEC_LED_SPECIFIC exit1: device_destroy(sec_class, 0); #endif exit: mutex_destroy(&data->mutex); kfree(data); return ret; }
static int adp8870_led_probe(struct i2c_client *client) { struct adp8870_backlight_platform_data *pdata = client->dev.platform_data; struct adp8870_bl *data = i2c_get_clientdata(client); struct adp8870_led *led, *led_dat; struct led_info *cur_led; int ret, i; led = devm_kzalloc(&client->dev, pdata->num_leds * sizeof(*led), GFP_KERNEL); if (led == NULL) { dev_err(&client->dev, "failed to alloc memory\n"); return -ENOMEM; } ret = adp8870_write(client, ADP8870_ISCLAW, pdata->led_fade_law); if (ret) return ret; ret = adp8870_write(client, ADP8870_ISCT1, (pdata->led_on_time & 0x3) << 6); if (ret) return ret; ret = adp8870_write(client, ADP8870_ISCF, FADE_VAL(pdata->led_fade_in, pdata->led_fade_out)); if (ret) return ret; for (i = 0; i < pdata->num_leds; ++i) { cur_led = &pdata->leds[i]; led_dat = &led[i]; led_dat->id = cur_led->flags & ADP8870_FLAG_LED_MASK; if (led_dat->id > 7 || led_dat->id < 1) { dev_err(&client->dev, "Invalid LED ID %d\n", led_dat->id); goto err; } if (pdata->bl_led_assign & (1 << (led_dat->id - 1))) { dev_err(&client->dev, "LED %d used by Backlight\n", led_dat->id); goto err; } led_dat->cdev.name = cur_led->name; led_dat->cdev.default_trigger = cur_led->default_trigger; led_dat->cdev.brightness_set = adp8870_led_set; led_dat->cdev.brightness = LED_OFF; led_dat->flags = cur_led->flags >> FLAG_OFFT_SHIFT; led_dat->client = client; led_dat->new_brightness = LED_OFF; INIT_WORK(&led_dat->work, adp8870_led_work); ret = led_classdev_register(&client->dev, &led_dat->cdev); if (ret) { dev_err(&client->dev, "failed to register LED %d\n", led_dat->id); goto err; } ret = adp8870_led_setup(led_dat); if (ret) { dev_err(&client->dev, "failed to write\n"); i++; goto err; } } data->led = led; return 0; err: for (i = i - 1; i >= 0; --i) { led_classdev_unregister(&led[i].cdev); cancel_work_sync(&led[i].work); } return ret; }
static int __devinit twl6030_usb_probe(struct platform_device *pdev) { struct twl6030_usb *twl; int status, err; struct twl4030_usb_data *pdata; struct device *dev = &pdev->dev; pdata = dev->platform_data; twl = kzalloc(sizeof *twl, GFP_KERNEL); if (!twl) return -ENOMEM; twl->dev = &pdev->dev; twl->irq1 = platform_get_irq(pdev, 0); twl->irq2 = platform_get_irq(pdev, 1); twl->features = pdata->features; twl->otg.dev = twl->dev; twl->otg.label = "twl6030"; twl->otg.set_host = twl6030_set_host; twl->otg.set_peripheral = twl6030_set_peripheral; twl->otg.set_vbus = twl6030_set_vbus; twl->otg.init = twl6030_phy_init; twl->otg.shutdown = twl6030_phy_shutdown; twl->otg.set_suspend = twl6030_phy_suspend; twl->otg.start_srp = twl6030_start_srp; /* init spinlock for workqueue */ spin_lock_init(&twl->lock); err = twl6030_usb_ldo_init(twl); if (err) { dev_err(&pdev->dev, "ldo init failed\n"); kfree(twl); return err; } otg_set_transceiver(&twl->otg); platform_set_drvdata(pdev, twl); if (device_create_file(&pdev->dev, &dev_attr_vbus)) dev_warn(&pdev->dev, "could not create sysfs file\n"); ATOMIC_INIT_NOTIFIER_HEAD(&twl->otg.notifier); INIT_WORK(&twl->set_vbus_work, otg_set_vbus_work); twl->vbus_enable = false; twl->irq_enabled = true; status = request_threaded_irq(twl->irq1, NULL, twl6030_usbotg_irq, IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING, "twl6030_usb", twl); if (status < 0) { dev_err(&pdev->dev, "can't get IRQ %d, err %d\n", twl->irq1, status); device_remove_file(twl->dev, &dev_attr_vbus); kfree(twl); return status; } status = request_threaded_irq(twl->irq2, NULL, twl6030_usb_irq, IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING, "twl6030_usb", twl); if (status < 0) { dev_err(&pdev->dev, "can't get IRQ %d, err %d\n", twl->irq2, status); free_irq(twl->irq1, twl); device_remove_file(twl->dev, &dev_attr_vbus); kfree(twl); return status; } twl->asleep = 0; pdata->phy_init(dev); twl6030_phy_suspend(&twl->otg, 0); twl6030_enable_irq(&twl->otg); dev_info(&pdev->dev, "Initialized TWL6030 USB module\n"); return 0; }
/*<BU5D08118 zhangtao 20100419 begin*/ static int aps_12d_probe( struct i2c_client *client, const struct i2c_device_id *id) { int ret; struct aps_data *aps; /*the aps_12d sensors ispower on*/ /* <BU5D07679 zhangtao 20100413 begin */ struct vreg *vreg_gp4=NULL; int rc; /* <DTS2010100800714 liugaofei 20101008 begin */ int i; /* DTS2010100800714 liugaofei 20101008 end */ vreg_gp4 = vreg_get(NULL, VREG_GP4_NAME); /* < DTS2010061200552 zhangtao 20100612 begin */ if (IS_ERR(vreg_gp4)) { pr_err("%s:gp4 power init get failed\n", __func__); } /* DTS2010061200552 zhangtao 20100612 end> */ /* <DTS2011012600839 liliang 20110215 begin */ /* set gp4 voltage as 2700mV for all */ rc = vreg_set_level(vreg_gp4,VREG_GP4_VOLTAGE_VALUE_2700); /* <DTS2011012600839 liliang 20110215 end >*/ if (rc) { PROXIMITY_DEBUG("%s: vreg_gp4 vreg_set_level failed \n", __func__); return rc; } rc = vreg_enable(vreg_gp4); if (rc) { pr_err("%s: vreg_gp4 vreg_enable failed \n", __func__); return rc; } mdelay(5); /* BU5D07679 zhangtao 20100413 end> */ if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { PROXIMITY_DEBUG(KERN_ERR "aps_12d_probe: need I2C_FUNC_I2C\n"); ret = -ENODEV; goto err_check_functionality_failed; } /* < DTS2010091001474 zhangtao 20100910 begin */ /* if querry the board is T1 or T2 turn off the proximity */ /*< DTS2010092400487 lijianzhao 20100924 begin */ /* This modification for version A&B of U8800,only */ if((machine_is_msm7x30_u8800())&&((get_hw_sub_board_id() == HW_VER_SUB_VA) || ((get_hw_sub_board_id() == HW_VER_SUB_VB)))) { printk(KERN_ERR "aps_12d_probe: aps is not supported in U8800 and U8800 T1 board!\n"); ret = -ENODEV; goto err_check_functionality_failed; } /* DTS2010092400487 lijianzhao 20100924 end >*/ /* DTS2010091001474 zhangtao 20100910 end > */ aps = kzalloc(sizeof(*aps), GFP_KERNEL); if (aps == NULL) { ret = -ENOMEM; goto err_alloc_data_failed; } mutex_init(&aps->mlock); INIT_WORK(&aps->work, aps_12d_work_func); aps->client = client; i2c_set_clientdata(client, aps); PROXIMITY_DEBUG(KERN_INFO "ghj aps_12d_probe send command 2\n "); /* Command 2 register: 25mA,DC,12bit,Range1 */ /* < DTS2010081803338 zhangtao 20100818 begin */ /* make the rang smaller can make the ir changge bigger */ ret = aps_i2c_reg_write(aps, APS_12D_REG_CMD2, \ /* < DTS2010102103994 zhangtao 20101112 begin */ (uint8_t)(APS_12D_IRDR_SEL_50MA << 6 | \ APS_12D_FREQ_SEL_DC << 4 | \ APS_12D_RES_SEL_12 << 2 | \ APS_12D_RANGE_SEL_ALS_1000)); /* DTS2010102103994 zhangtao 20101112 end > */ /* DTS2010081803338 zhangtao 20100818 end > */ if(ret < 0) { goto err_detect_failed; } /* <DTS2010100800714 liugaofei 20101008 begin */ range_index = 0; for(i = 0; i < TOTAL_RANGE_NUM; i++) { /* NOTE: do NOT use the last one */ up_range_value[i] = MAX_ADC_OUTPUT - high_threshold_value[i] - RANGE_FIX; } down_range_value[0] = 0; for(i = 1; i < TOTAL_RANGE_NUM; i++) { /* NOTE: do not use the first one */ down_range_value[i] = (MAX_ADC_OUTPUT - high_threshold_value[i-1] - (MAX_ADC_OUTPUT / ADJUST_GATE)) / 4; } /* DTS2010100800714 liugaofei 20101008 end */ /* < DTS2011042705601 zhangtao 20110427 begin */ /*we don't use the input device sensors again */ aps->input_dev = input_allocate_device(); if (aps->input_dev == NULL) { ret = -ENOMEM; PROXIMITY_DEBUG(KERN_ERR "aps_12d_probe: Failed to allocate input device\n"); goto err_input_dev_alloc_failed; } aps->input_dev->name = "sensors_aps"; aps->input_dev->id.bustype = BUS_I2C; input_set_drvdata(aps->input_dev, aps); ret = input_register_device(aps->input_dev); if (ret) { printk(KERN_ERR "aps_probe: Unable to register %s input device\n", aps->input_dev->name); goto err_input_register_device_failed; } /* DTS2011042705601 zhangtao 20110427 end > */ set_bit(EV_ABS, aps->input_dev->evbit); input_set_abs_params(aps->input_dev, ABS_LIGHT, 0, 10240, 0, 0); input_set_abs_params(aps->input_dev, ABS_DISTANCE, 0, 1, 0, 0); ret = misc_register(&light_device); if (ret) { printk(KERN_ERR "aps_12d_probe: light_device register failed\n"); goto err_light_misc_device_register_failed; } ret = misc_register(&proximity_device); if (ret) { printk(KERN_ERR "aps_12d_probe: proximity_device register failed\n"); goto err_proximity_misc_device_register_failed; } /* < DTS2010090300997 zhangtao 20100903 begin */ if( light_device.minor != MISC_DYNAMIC_MINOR ){ light_device_minor = light_device.minor; } if( proximity_device.minor != MISC_DYNAMIC_MINOR ){ proximity_device_minor = proximity_device.minor ; } wake_lock_init(&proximity_wake_lock, WAKE_LOCK_SUSPEND, "proximity"); /* DTS2010090300997 zhangtao 20100903 end > */ hrtimer_init(&aps->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); aps->timer.function = aps_timer_func; aps_wq = create_singlethread_workqueue("aps_wq"); if (!aps_wq) { ret = -ENOMEM; goto err_create_workqueue_failed; } this_aps_data =aps; /* <DTS2011032104626 shenjinming 20110321 begin */ #ifdef CONFIG_HUAWEI_HW_DEV_DCT /* detect current device successful, set the flag as present */ set_hw_dev_flag(DEV_I2C_APS); #endif /* <DTS2011032104626 shenjinming 20110321 end> */ /* < DTS2011052606009 jiaxianghong 20110527 end */ printk(KERN_INFO "aps_12d_probe: Start Proximity Sensor APS-12D\n"); /* DTS2010072801000 zhangtao 20100728 end > */ return 0; err_create_workqueue_failed: misc_deregister(&proximity_device); err_proximity_misc_device_register_failed: misc_deregister(&light_device); err_light_misc_device_register_failed: err_input_register_device_failed: input_free_device(aps->input_dev); err_input_dev_alloc_failed: err_detect_failed: kfree(aps); err_alloc_data_failed: err_check_functionality_failed: /* < DTS2010061200552 zhangtao 20100612 begin */ if(NULL != vreg_gp4) { /* < DTS2011052101089 shenjinming 20110521 begin */ /* can't use the flag ret here, it will change the return value of probe function */ vreg_disable(vreg_gp4); /* delete a line */ /* DTS2011052101089 shenjinming 20110521 end > */ } /* DTS2010061200552 zhangtao 20100612 end > */ return ret; }
static int bq24192_probe(struct i2c_client *client, const struct i2c_device_id *id) { const struct bq24192_platform_data *pdata; struct device_node *dev_node = client->dev.of_node; struct bq24192_chip *chip; int ret = 0; unsigned long flags; if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA)) { pr_err("i2c func fail.\n"); return -EIO; } chip = kzalloc(sizeof(struct bq24192_chip), GFP_KERNEL); if (!chip) { pr_err("failed to alloc memory\n"); return -ENOMEM; } chip->client = client; chip->usb_psy = power_supply_get_by_name("usb"); if (!chip->usb_psy) { pr_err("usb supply not found deferring probe\n"); ret = -EPROBE_DEFER; goto error; } if (dev_node) { ret = bq24192_parse_dt(dev_node, chip); if (ret) { pr_err("failed to parse dt\n"); goto error; } } else { pdata = client->dev.platform_data; if (pdata == NULL) { pr_err("no platform data.\n"); return -EINVAL; } chip->int_gpio = pdata->int_gpio; chip->chg_current_ma = pdata->chg_current_ma; chip->term_current_ma = pdata->term_current_ma; chip->wlc_support = pdata->wlc_support; chip->ext_ovp_otg_ctrl = pdata->ext_ovp_otg_ctrl; if (chip->ext_ovp_otg_ctrl) chip->otg_en_gpio = pdata->otg_en_gpio; chip->step_dwn_thr_mv = pdata->step_dwn_thr_mv; chip->step_dwn_currnet_ma = pdata->step_dwn_currnet_ma; chip->vbat_max_mv = pdata->vbat_max_mv; chip->pre_chg_current_ma = pdata->pre_chg_current_ma; chip->sys_vmin_mv = pdata->sys_vmin_mv; chip->vin_limit_mv = pdata->vin_limit_mv; chip->icl_vbus_mv = pdata->icl_vbus_mv; chip->wlc_dwn_i_ma = pdata->wlc_dwn_i_ma; } chip->set_chg_current_ma = chip->chg_current_ma; chip->batt_health = POWER_SUPPLY_HEALTH_GOOD; chip->max_input_i_ma = INPUT_CURRENT_LIMIT_MAX_MA; if (chip->wlc_support) { chip->wlc_psy = power_supply_get_by_name("wireless"); if (!chip->wlc_psy) { pr_err("wireless supply not found deferring probe\n"); ret = -EPROBE_DEFER; goto error; } } ret = gpio_request_one(chip->int_gpio, GPIOF_DIR_IN, "bq24192_int"); if (ret) { pr_err("failed to request int_gpio\n"); goto error; } chip->irq = gpio_to_irq(chip->int_gpio); if (chip->otg_en_gpio) { ret = gpio_request_one(chip->otg_en_gpio, GPIOF_OUT_INIT_LOW, "otg_en"); if (ret) { pr_err("otg_en_gpio request failed for %d ret=%d\n", chip->otg_en_gpio, ret); goto err_otg_en_gpio; } } i2c_set_clientdata(client, chip); ret = bq24192_hw_init(chip); if (ret) { pr_err("failed to init hw\n"); goto err_hw_init; } the_chip = chip; ret = bq24192_init_ac_psy(chip); if (ret) { pr_err("bq24192_init_ac_psy failed\n"); goto err_hw_init; } ret = bq24192_create_debugfs_entries(chip); if (ret) { pr_err("bq24192_create_debugfs_entries failed\n"); goto err_debugfs; } spin_lock_init(&chip->irq_work_lock); chip->irq_scheduled_time_status = 0; wake_lock_init(&chip->chg_wake_lock, WAKE_LOCK_SUSPEND, BQ24192_NAME); wake_lock_init(&chip->icl_wake_lock, WAKE_LOCK_SUSPEND, "icl_wake_lock"); wake_lock_init(&chip->irq_wake_lock, WAKE_LOCK_SUSPEND, BQ24192_NAME "irq"); wake_lock_init(&chip->extra_chg_lock, WAKE_LOCK_SUSPEND, "extra_chg_lock"); INIT_DELAYED_WORK(&chip->vbat_work, bq24192_vbat_work); INIT_DELAYED_WORK(&chip->input_limit_work, bq24192_input_limit_worker); INIT_DELAYED_WORK(&chip->therm_work, bq24192_therm_mitigation_work); INIT_DELAYED_WORK(&chip->extra_chg_work, bq24192_extra_chg_work); INIT_WORK(&chip->irq_work, bq24192_irq_worker); if (chip->irq) { ret = request_irq(chip->irq, bq24192_irq, IRQF_TRIGGER_FALLING, "bq24192_irq", chip); if (ret) { pr_err("request_irq %d failed\n", chip->irq); goto err_req_irq; } enable_irq_wake(chip->irq); } bq24192_enable_charging(chip, true); spin_lock_irqsave(&chip->irq_work_lock, flags); if (chip->irq_scheduled_time_status == 0) { schedule_work(&chip->irq_work); chip->irq_scheduled_time_status = 20; } spin_unlock_irqrestore(&chip->irq_work_lock, flags); pr_debug("probe success\n"); return 0; err_req_irq: wake_lock_destroy(&chip->chg_wake_lock); wake_lock_destroy(&chip->icl_wake_lock); wake_lock_destroy(&chip->irq_wake_lock); wake_lock_destroy(&chip->extra_chg_lock); if (chip->dent) debugfs_remove_recursive(chip->dent); err_debugfs: power_supply_unregister(&chip->ac_psy); err_hw_init: if (chip->otg_en_gpio) gpio_free(chip->otg_en_gpio); err_otg_en_gpio: if (chip->int_gpio) gpio_free(chip->int_gpio); error: kfree(chip); pr_debug("fail to probe\n"); return ret; }
/** * usb_alloc_dev - usb device constructor (usbcore-internal) * @parent: hub to which device is connected; null to allocate a root hub * @bus: bus used to access the device * @port1: one-based index of port; ignored for root hubs * Context: !in_interrupt() * * Only hub drivers (including virtual root hub drivers for host * controllers) should ever call this. * * This call may not be used in a non-sleeping context. */ struct usb_device *usb_alloc_dev(struct usb_device *parent, struct usb_bus *bus, unsigned port1) { struct usb_device *dev; struct usb_hcd *usb_hcd = container_of(bus, struct usb_hcd, self); unsigned root_hub = 0; dev = kzalloc(sizeof(*dev), GFP_KERNEL); if (!dev) return NULL; if (!usb_get_hcd(bus_to_hcd(bus))) { kfree(dev); return NULL; } /* Root hubs aren't true devices, so don't allocate HCD resources */ if (usb_hcd->driver->alloc_dev && parent && !usb_hcd->driver->alloc_dev(usb_hcd, dev)) { usb_put_hcd(bus_to_hcd(bus)); kfree(dev); return NULL; } device_initialize(&dev->dev); dev->dev.bus = &usb_bus_type; dev->dev.type = &usb_device_type; dev->dev.groups = usb_device_groups; dev->dev.dma_mask = bus->controller->dma_mask; set_dev_node(&dev->dev, dev_to_node(bus->controller)); dev->state = USB_STATE_ATTACHED; atomic_set(&dev->urbnum, 0); INIT_LIST_HEAD(&dev->ep0.urb_list); dev->ep0.desc.bLength = USB_DT_ENDPOINT_SIZE; dev->ep0.desc.bDescriptorType = USB_DT_ENDPOINT; /* ep0 maxpacket comes later, from device descriptor */ usb_enable_endpoint(dev, &dev->ep0, false); dev->can_submit = 1; /* Save readable and stable topology id, distinguishing devices * by location for diagnostics, tools, driver model, etc. The * string is a path along hub ports, from the root. Each device's * dev->devpath will be stable until USB is re-cabled, and hubs * are often labeled with these port numbers. The name isn't * as stable: bus->busnum changes easily from modprobe order, * cardbus or pci hotplugging, and so on. */ if (unlikely(!parent)) { dev->devpath[0] = '0'; dev->route = 0; dev->dev.parent = bus->controller; dev_set_name(&dev->dev, "usb%d", bus->busnum); root_hub = 1; } else { /* match any labeling on the hubs; it's one-based */ if (parent->devpath[0] == '0') { snprintf(dev->devpath, sizeof dev->devpath, "%d", port1); /* Root ports are not counted in route string */ dev->route = 0; } else { snprintf(dev->devpath, sizeof dev->devpath, "%s.%d", parent->devpath, port1); /* Route string assumes hubs have less than 16 ports */ if (port1 < 15) dev->route = parent->route + (port1 << ((parent->level - 1)*4)); else dev->route = parent->route + (15 << ((parent->level - 1)*4)); } dev->dev.parent = &parent->dev; dev_set_name(&dev->dev, "%d-%s", bus->busnum, dev->devpath); /* hub driver sets up TT records */ } dev->portnum = port1; dev->bus = bus; dev->parent = parent; INIT_LIST_HEAD(&dev->filelist); #ifdef CONFIG_PM mutex_init(&dev->pm_mutex); INIT_DELAYED_WORK(&dev->autosuspend, usb_autosuspend_work); INIT_WORK(&dev->autoresume, usb_autoresume_work); dev->autosuspend_delay = usb_autosuspend_delay * HZ; dev->connect_time = jiffies; dev->active_duration = -jiffies; #endif if (root_hub) /* Root hub always ok [and always wired] */ dev->authorized = 1; else { dev->authorized = usb_hcd->authorized_default; dev->wusb = usb_bus_is_wusb(bus)? 1 : 0; } return dev; }
/* * initialize a newly allocated inode. */ struct inode *ceph_alloc_inode(struct super_block *sb) { struct ceph_inode_info *ci; int i; ci = kmem_cache_alloc(ceph_inode_cachep, GFP_NOFS); if (!ci) return NULL; dout("alloc_inode %p\n", &ci->vfs_inode); ci->i_version = 0; ci->i_time_warp_seq = 0; ci->i_ceph_flags = 0; ci->i_release_count = 0; ci->i_symlink = NULL; ci->i_fragtree = RB_ROOT; mutex_init(&ci->i_fragtree_mutex); ci->i_xattrs.blob = NULL; ci->i_xattrs.prealloc_blob = NULL; ci->i_xattrs.dirty = false; ci->i_xattrs.index = RB_ROOT; ci->i_xattrs.count = 0; ci->i_xattrs.names_size = 0; ci->i_xattrs.vals_size = 0; ci->i_xattrs.version = 0; ci->i_xattrs.index_version = 0; ci->i_caps = RB_ROOT; ci->i_auth_cap = NULL; ci->i_dirty_caps = 0; ci->i_flushing_caps = 0; INIT_LIST_HEAD(&ci->i_dirty_item); INIT_LIST_HEAD(&ci->i_flushing_item); ci->i_cap_flush_seq = 0; ci->i_cap_flush_last_tid = 0; memset(&ci->i_cap_flush_tid, 0, sizeof(ci->i_cap_flush_tid)); init_waitqueue_head(&ci->i_cap_wq); ci->i_hold_caps_min = 0; ci->i_hold_caps_max = 0; INIT_LIST_HEAD(&ci->i_cap_delay_list); ci->i_cap_exporting_mds = 0; ci->i_cap_exporting_mseq = 0; ci->i_cap_exporting_issued = 0; INIT_LIST_HEAD(&ci->i_cap_snaps); ci->i_head_snapc = NULL; ci->i_snap_caps = 0; for (i = 0; i < CEPH_FILE_MODE_NUM; i++) ci->i_nr_by_mode[i] = 0; ci->i_truncate_seq = 0; ci->i_truncate_size = 0; ci->i_truncate_pending = 0; ci->i_max_size = 0; ci->i_reported_size = 0; ci->i_wanted_max_size = 0; ci->i_requested_max_size = 0; ci->i_pin_ref = 0; ci->i_rd_ref = 0; ci->i_rdcache_ref = 0; ci->i_wr_ref = 0; ci->i_wrbuffer_ref = 0; ci->i_wrbuffer_ref_head = 0; ci->i_shared_gen = 0; ci->i_rdcache_gen = 0; ci->i_rdcache_revoking = 0; INIT_LIST_HEAD(&ci->i_unsafe_writes); INIT_LIST_HEAD(&ci->i_unsafe_dirops); spin_lock_init(&ci->i_unsafe_lock); ci->i_snap_realm = NULL; INIT_LIST_HEAD(&ci->i_snap_realm_item); INIT_LIST_HEAD(&ci->i_snap_flush_item); INIT_WORK(&ci->i_wb_work, ceph_writeback_work); INIT_WORK(&ci->i_pg_inv_work, ceph_invalidate_work); INIT_WORK(&ci->i_vmtruncate_work, ceph_vmtruncate_work); return &ci->vfs_inode; }
static int omx_xenfront_probe(struct xenbus_device *dev, const struct xenbus_device_id *id) { struct omx_xenfront_info *fe; struct omx_xenif_sring *sring, *recv_sring; int err = 0; int i = 0; dprintk_in(); dprintk_deb("Frontend Probe Fired!\n"); fe = kzalloc(sizeof(*fe), GFP_KERNEL); dprintk_deb("fe info is @%#llx!\n", (unsigned long long)fe); if (!fe) { xenbus_dev_fatal(dev, -ENOMEM, "allocating info structure"); err = -ENOMEM; goto out; } __omx_xen_frontend = fe; for (i = 0; i < OMX_XEN_MAX_ENDPOINTS; i++) { fe->endpoints[i] = NULL; } fe->requests = kzalloc(OMX_MAX_INFLIGHT_REQUESTS * sizeof(enum frontend_status), GFP_KERNEL); spin_lock_init(&fe->status_lock); fe->xbdev = dev; fe->connected = OMXIF_STATE_DISCONNECTED; init_waitqueue_head(&fe->wq); fe->msg_workq = create_singlethread_workqueue("ReQ_FE"); if (unlikely(!fe->msg_workq)) { printk_err("Couldn't create msg_workq!\n"); err = -ENOMEM; goto out; } INIT_WORK(&fe->msg_workq_task, omx_xenif_interrupt); spin_lock_init(&fe->lock); dprintk_deb("Setting up shared ring\n"); sring = (struct omx_xenif_sring *)get_zeroed_page(GFP_NOIO | __GFP_HIGH); if (!sring) { xenbus_dev_fatal(dev, -ENOMEM, "allocating shared ring"); err = -ENOMEM; goto out; } SHARED_RING_INIT(sring); FRONT_RING_INIT(&fe->ring, sring, PAGE_SIZE); err = xenbus_grant_ring(dev, virt_to_mfn(fe->ring.sring)); if (err < 0) { free_page((unsigned long)sring); fe->ring.sring = NULL; printk_err("Failed to grant ring\n"); goto out; } fe->ring_ref = err; recv_sring = (struct omx_xenif_sring *)get_zeroed_page(GFP_NOIO | __GFP_HIGH); if (!sring) { xenbus_dev_fatal(dev, -ENOMEM, "allocating shared ring"); err = -ENOMEM; goto out; } SHARED_RING_INIT(recv_sring); FRONT_RING_INIT(&fe->recv_ring, recv_sring, PAGE_SIZE); err = xenbus_grant_ring(dev, virt_to_mfn(fe->recv_ring.sring)); if (err < 0) { free_page((unsigned long)recv_sring); fe->recv_ring.sring = NULL; printk_err("Failed to grant recv_ring\n"); goto out; } fe->recv_ring_ref = err; fe->handle = simple_strtoul(strrchr(dev->nodename, '/') + 1, NULL, 0); dprintk_deb("setting handle = %u\n", fe->handle); dev_set_drvdata(&dev->dev, fe); err = 0; //omx_xenfront_dev->info = info; //fe->endpoints = kzalloc(sizeof(struct omx_endpoint*) * OMX_XEN_MAX_ENDPOINTS, GFP_KERNEL); xenbus_switch_state(dev, XenbusStateInitialising); out: dprintk_out(); return err; }
void diagfwd_bridge_init(void) { int ret; pr_debug("diag: in %s\n", __func__); driver->diag_bridge_wq = create_singlethread_workqueue( "diag_bridge_wq"); driver->read_len_mdm = 0; if (driver->usb_buf_mdm_out == NULL) driver->usb_buf_mdm_out = kzalloc(USB_MAX_OUT_BUF, GFP_KERNEL); if (driver->usb_buf_mdm_out == NULL) goto err; if (driver->write_ptr_mdm == NULL) driver->write_ptr_mdm = kzalloc( sizeof(struct diag_request), GFP_KERNEL); if (driver->write_ptr_mdm == NULL) goto err; if (driver->usb_read_mdm_ptr == NULL) driver->usb_read_mdm_ptr = kzalloc( sizeof(struct diag_request), GFP_KERNEL); if (driver->usb_read_mdm_ptr == NULL) goto err; #ifdef CONFIG_DIAG_OVER_USB INIT_WORK(&(driver->diag_read_mdm_work), diag_read_mdm_work_fn); #endif INIT_WORK(&(driver->diag_disconnect_work), diag_disconnect_work_fn); INIT_WORK(&(driver->diag_usb_read_complete_work), diag_usb_read_complete_fn); #ifdef CONFIG_DIAG_OVER_USB driver->mdm_ch = usb_diag_open(DIAG_MDM, driver, diagfwd_bridge_notifier); if (IS_ERR(driver->mdm_ch)) { pr_err("diag: Unable to open USB diag MDM channel\n"); goto err; } #endif #ifdef CONFIG_DIAG_BRIDGE_CODE INIT_WORK(&(driver->diag_disconnect_work), diag_disconnect_work_fn); INIT_WORK(&(driver->diag_usb_read_complete_work), diag_usb_read_complete_fn); /* register HSIC device */ ret = platform_driver_register(&msm_hsic_ch_driver); if (ret) pr_err("diag: could not register HSIC device, ret: %d\n", ret); /* register SMUX device */ ret = platform_driver_register(&msm_diagfwd_smux_driver); if (ret) pr_err("diag: could not register SMUX device, ret: %d\n", ret); #endif return; err: pr_err("diag: Could not initialize for bridge forwarding\n"); kfree(driver->usb_buf_mdm_out); kfree(driver->write_ptr_mdm); kfree(driver->usb_read_mdm_ptr); if (driver->diag_bridge_wq) destroy_workqueue(driver->diag_bridge_wq); return; }
static int crystalcove_chgr_probe(struct platform_device *pdev) { struct chgr_info *info; int ret; info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL); if (!info) { dev_err(&pdev->dev, "mem alloc failed\n"); return -ENOMEM; } dev_info(&pdev->dev, "crystalcove charger probe begin\n"); info->pdev = pdev; #ifdef CONFIG_ACPI info->pdata = crystalcove_chgr_pdata(NULL); #else info->pdata = pdev->dev.platform_data; #endif platform_set_drvdata(pdev, info); mutex_init(&info->lock); INIT_WORK(&info->otg_work, crystalcove_otg_event_worker); info->irq = platform_get_irq(pdev, 0); ret = request_threaded_irq(info->irq, NULL, crystalcove_chgr_isr, IRQF_TRIGGER_RISING | IRQF_ONESHOT, CHGR_DRV_NAME, info); if (ret) { dev_err(&pdev->dev, "unable to register irq %d\n", info->irq); goto psy_reg_failed; } info->otg = usb_get_phy(USB_PHY_TYPE_USB2); if (!info->otg) { dev_warn(&pdev->dev, "Failed to get otg transceiver!!\n"); } else { info->id_nb.notifier_call = crystalcove_handle_otg_event; ret = usb_register_notifier(info->otg, &info->id_nb); if (ret) dev_err(&pdev->dev, "failed to register otg notifier\n"); } info->max_cc = info->pdata->max_cc; info->max_cv = info->pdata->max_cv; info->psy_usb.name = CHGR_DRV_NAME; info->psy_usb.type = POWER_SUPPLY_TYPE_USB; info->psy_usb.properties = crystalcove_chrg_usb_props; info->psy_usb.num_properties = ARRAY_SIZE(crystalcove_chrg_usb_props); info->psy_usb.get_property = crystalcove_chgr_usb_get_property; info->psy_usb.set_property = crystalcove_chgr_usb_set_property; info->psy_usb.supplied_to = info->pdata->supplied_to; info->psy_usb.num_supplicants = info->pdata->num_supplicants; info->psy_usb.throttle_states = info->pdata->throttle_states; info->psy_usb.num_throttle_states = info->pdata->num_throttle_states; info->psy_usb.supported_cables = info->pdata->supported_cables; ret = power_supply_register(&pdev->dev, &info->psy_usb); if (ret) { dev_err(&pdev->dev, "Failed: power supply register (%d)\n", ret); goto psy_reg_failed; } /* unmask the CHGR interrupts */ intel_mid_pmic_writeb(CRYSTALCOVE_MCHGRIRQS0_REG, 0x00); intel_mid_pmic_writeb(CRYSTALCOVE_MCHGRIRQSX_REG, 0x00); return 0; psy_reg_failed: return ret; }
/** * gether_setup - initialize one ethernet-over-usb link * @g: gadget to associated with these links * @ethaddr: NULL, or a buffer in which the ethernet address of the * host side of the link is recorded * Context: may sleep * * This sets up the single network link that may be exported by a * gadget driver using this framework. The link layer addresses are * set up using module parameters. * * Returns negative errno, or zero on success */ int gether_setup(struct usb_gadget *g, u8 ethaddr[ETH_ALEN]) { struct eth_dev *dev; struct net_device *net; int status; if (the_dev) return -EBUSY; net = alloc_etherdev(sizeof *dev); if (!net) return -ENOMEM; dev = netdev_priv(net); spin_lock_init(&dev->lock); spin_lock_init(&dev->req_lock); INIT_WORK(&dev->work, eth_work); INIT_LIST_HEAD(&dev->tx_reqs); INIT_LIST_HEAD(&dev->rx_reqs); skb_queue_head_init(&dev->rx_frames); /* network device setup */ dev->net = net; strcpy(net->name, "usb%d"); if (get_ether_addr(dev_addr, net->dev_addr)) dev_warn(&g->dev, "using random %s ethernet address\n", "self"); if (get_ether_addr(host_addr, dev->host_mac)) dev_warn(&g->dev, "using random %s ethernet address\n", "host"); if (ethaddr) memcpy(ethaddr, dev->host_mac, ETH_ALEN); net->netdev_ops = ð_netdev_ops; SET_ETHTOOL_OPS(net, &ops); /* two kinds of host-initiated state changes: * - iff DATA transfer is active, carrier is "on" * - tx queueing enabled if open *and* carrier is "on" */ netif_stop_queue(net); netif_carrier_off(net); dev->gadget = g; SET_NETDEV_DEV(net, &g->dev); SET_NETDEV_DEVTYPE(net, &gadget_type); status = register_netdev(net); if (status < 0) { dev_dbg(&g->dev, "register_netdev failed, %d\n", status); free_netdev(net); } else { INFO(dev, "MAC %pM\n", net->dev_addr); INFO(dev, "HOST MAC %pM\n", dev->host_mac); the_dev = dev; } return status; }