static int __devinit qt1070_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct qt1070_data *data; struct input_dev *input; int i; int err; err = i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE); if (!err) { dev_err(&client->dev, "%s adapter not supported\n", dev_driver_string(&client->adapter->dev)); return -ENODEV; } if (!client->irq) { dev_err(&client->dev, "please assign the irq to this device\n"); return -EINVAL; } if (!qt1070_identify(client)) return -ENODEV; data = kzalloc(sizeof(struct qt1070_data), GFP_KERNEL); input = input_allocate_device(); if (!data || !input) { dev_err(&client->dev, "insufficient memory\n"); err = -ENOMEM; goto err_free_mem; } data->client = client; data->input = input; data->irq = client->irq; input->name = "AT42QT1070 QTouch Sensor"; input->dev.parent = &client->dev; input->id.bustype = BUS_I2C; input->keycode = data->keycodes; input->keycodesize = sizeof(data->keycodes[0]); input->keycodemax = ARRAY_SIZE(qt1070_key2code); __set_bit(EV_KEY, input->evbit); for (i = 0; i < ARRAY_SIZE(qt1070_key2code); i++) { data->keycodes[i] = qt1070_key2code[i]; __set_bit(qt1070_key2code[i], input->keybit); } qt1070_write(client, CALIBRATE_CMD, 1); msleep(QT1070_CAL_TIME); qt1070_write(client, RESET, 1); msleep(QT1070_RESET_TIME); err = request_threaded_irq(client->irq, NULL, qt1070_interrupt, IRQF_TRIGGER_NONE, client->dev.driver->name, data); if (err) { dev_err(&client->dev, "fail to request irq\n"); goto err_free_mem; } err = input_register_device(data->input); if (err) { dev_err(&client->dev, "Failed to register input device\n"); goto err_free_irq; } i2c_set_clientdata(client, data); qt1070_read(client, DET_STATUS); return 0; err_free_irq: free_irq(client->irq, data); err_free_mem: input_free_device(input); kfree(data); return err; }
static int __devinit if_usb_probe(struct usb_interface *intf, const struct usb_device_id *id) { struct usb_host_interface *data_desc; struct usb_link_device *usb_ld = (struct usb_link_device *)id->driver_info; struct link_device *ld = &usb_ld->ld; struct usb_interface *data_intf; struct usb_device *usbdev = interface_to_usbdev(intf); struct device *dev, *ehci_dev, *root_hub; struct if_usb_devdata *pipe; struct urb *urb; int i; int j; int dev_id; int err; /* To detect usb device order probed */ dev_id = intf->cur_altsetting->desc.bInterfaceNumber; if (dev_id >= IF_USB_DEVNUM_MAX) { dev_err(&intf->dev, "Device id %d cannot support\n", dev_id); return -EINVAL; } if (!usb_ld) { dev_err(&intf->dev, "if_usb device doesn't be allocated\n"); err = ENOMEM; goto out; } mif_info("probe dev_id=%d usb_device_id(0x%p), usb_ld (0x%p)\n", dev_id, id, usb_ld); usb_ld->usbdev = usbdev; usb_get_dev(usbdev); for (i = 0; i < IF_USB_DEVNUM_MAX; i++) { data_intf = usb_ifnum_to_if(usbdev, i); /* remap endpoint of RAW to no.1 for LTE modem */ if (i == 0) pipe = &usb_ld->devdata[1]; else if (i == 1) pipe = &usb_ld->devdata[0]; else pipe = &usb_ld->devdata[i]; pipe->disconnected = 0; pipe->data_intf = data_intf; data_desc = data_intf->cur_altsetting; /* Endpoints */ if (usb_pipein(data_desc->endpoint[0].desc.bEndpointAddress)) { pipe->rx_pipe = usb_rcvbulkpipe(usbdev, data_desc->endpoint[0].desc.bEndpointAddress); pipe->tx_pipe = usb_sndbulkpipe(usbdev, data_desc->endpoint[1].desc.bEndpointAddress); pipe->rx_buf_size = 1024*4; } else { pipe->rx_pipe = usb_rcvbulkpipe(usbdev, data_desc->endpoint[1].desc.bEndpointAddress); pipe->tx_pipe = usb_sndbulkpipe(usbdev, data_desc->endpoint[0].desc.bEndpointAddress); pipe->rx_buf_size = 1024*4; } if (i == 0) { dev_info(&usbdev->dev, "USB IF USB device found\n"); } else { err = usb_driver_claim_interface(&if_usb_driver, data_intf, usb_ld); if (err < 0) { mif_err("failed to cliam usb interface\n"); goto out; } } usb_set_intfdata(data_intf, usb_ld); usb_ld->dev_count++; pm_suspend_ignore_children(&data_intf->dev, true); for (j = 0; j < URB_COUNT; j++) { urb = usb_alloc_urb(0, GFP_KERNEL); if (!urb) { mif_err("alloc urb fail\n"); err = -ENOMEM; goto out2; } urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; urb->transfer_buffer = usb_alloc_coherent(usbdev, pipe->rx_buf_size, GFP_KERNEL, &urb->transfer_dma); if (!urb->transfer_buffer) { mif_err( "Failed to allocate transfer buffer\n"); usb_free_urb(urb); err = -ENOMEM; goto out2; } usb_fill_bulk_urb(urb, usbdev, pipe->rx_pipe, urb->transfer_buffer, pipe->rx_buf_size, usb_rx_complete, pipe); usb_anchor_urb(urb, &pipe->urbs); } } /* temporary call reset_resume */ atomic_set(&usb_ld->suspend_count, 1); if_usb_reset_resume(data_intf); atomic_set(&usb_ld->suspend_count, 0); SET_HOST_ACTIVE(usb_ld->pdata, 1); usb_ld->host_wake_timeout_flag = 0; if (gpio_get_value(usb_ld->pdata->gpio_phone_active)) { struct link_pm_data *pm_data = usb_ld->link_pm_data; int delay = pm_data->autosuspend_delay_ms ?: DEFAULT_AUTOSUSPEND_DELAY_MS; pm_runtime_set_autosuspend_delay(&usbdev->dev, delay); dev = &usbdev->dev; if (dev->parent) { dev_dbg(&usbdev->dev, "if_usb Runtime PM Start!!\n"); usb_enable_autosuspend(usb_ld->usbdev); /* s5p-ehci runtime pm allow - usb phy suspend mode */ root_hub = &usbdev->bus->root_hub->dev; ehci_dev = root_hub->parent; mif_debug("ehci device = %s, %s\n", dev_driver_string(ehci_dev), dev_name(ehci_dev)); pm_runtime_allow(ehci_dev); if (!pm_data->autosuspend) pm_runtime_forbid(dev); if (has_hub(usb_ld)) link_pm_preactive(pm_data); pm_data->root_hub = root_hub; } usb_ld->flow_suspend = 0; /* Queue work if skbs were pending before a disconnect/probe */ if (ld->sk_fmt_tx_q.qlen || ld->sk_raw_tx_q.qlen) queue_delayed_work(ld->tx_wq, &ld->tx_delayed_work, 0); usb_ld->if_usb_connected = 1; /*USB3503*/ mif_debug("hub active complete\n"); usb_change_modem_state(usb_ld, STATE_ONLINE); } else {
static int __devinit qt2160_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct qt2160_data *qt2160; struct input_dev *input; int i; int error; /* Check functionality */ error = i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE); if (!error) { dev_err(&client->dev, "%s adapter not supported\n", dev_driver_string(&client->adapter->dev)); return -ENODEV; } if (!qt2160_identify(client)) return -ENODEV; /* Chip is valid and active. Allocate structure */ qt2160 = kzalloc(sizeof(struct qt2160_data), GFP_KERNEL); input = input_allocate_device(); if (!qt2160 || !input) { dev_err(&client->dev, "insufficient memory\n"); error = -ENOMEM; goto err_free_mem; } qt2160->client = client; qt2160->input = input; INIT_DELAYED_WORK(&qt2160->dwork, qt2160_worker); spin_lock_init(&qt2160->lock); input->name = "AT42QT2160 Touch Sense Keyboard"; input->id.bustype = BUS_I2C; input->keycode = qt2160->keycodes; input->keycodesize = sizeof(qt2160->keycodes[0]); input->keycodemax = ARRAY_SIZE(qt2160_key2code); __set_bit(EV_KEY, input->evbit); __clear_bit(EV_REP, input->evbit); for (i = 0; i < ARRAY_SIZE(qt2160_key2code); i++) { qt2160->keycodes[i] = qt2160_key2code[i]; __set_bit(qt2160_key2code[i], input->keybit); } __clear_bit(KEY_RESERVED, input->keybit); /* Calibrate device */ error = qt2160_write(client, QT2160_CMD_CALIBRATE, 1); if (error) { dev_err(&client->dev, "failed to calibrate device\n"); goto err_free_mem; } if (client->irq) { error = request_irq(client->irq, qt2160_irq, IRQF_TRIGGER_FALLING, "qt2160", qt2160); if (error) { dev_err(&client->dev, "failed to allocate irq %d\n", client->irq); goto err_free_mem; } } error = input_register_device(qt2160->input); if (error) { dev_err(&client->dev, "Failed to register input device\n"); goto err_free_irq; } i2c_set_clientdata(client, qt2160); qt2160_schedule_read(qt2160); return 0; err_free_irq: if (client->irq) free_irq(client->irq, qt2160); err_free_mem: input_free_device(input); kfree(qt2160); return error; }
static int __devinit adp8860_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct backlight_device *bl; struct adp8860_bl *data; struct adp8860_backlight_platform_data *pdata = client->dev.platform_data; struct backlight_properties props; uint8_t reg_val; int ret; if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA)) { dev_err(&client->dev, "SMBUS Byte Data not Supported\n"); return -EIO; } if (!pdata) { dev_err(&client->dev, "no platform data?\n"); return -EINVAL; } data = devm_kzalloc(&client->dev, sizeof(*data), GFP_KERNEL); if (data == NULL) return -ENOMEM; ret = adp8860_read(client, ADP8860_MFDVID, ®_val); if (ret < 0) return ret; switch (ADP8860_MANID(reg_val)) { case ADP8863_MANUFID: data->gdwn_dis = !!pdata->gdwn_dis; case ADP8860_MANUFID: data->en_ambl_sens = !!pdata->en_ambl_sens; break; case ADP8861_MANUFID: data->gdwn_dis = !!pdata->gdwn_dis; break; default: dev_err(&client->dev, "failed to probe\n"); return -ENODEV; } /* It's confirmed that the DEVID field is actually a REVID */ data->revid = ADP8860_DEVID(reg_val); data->client = client; data->pdata = pdata; data->id = id->driver_data; data->current_brightness = 0; i2c_set_clientdata(client, data); memset(&props, 0, sizeof(props)); props.type = BACKLIGHT_RAW; props.max_brightness = ADP8860_MAX_BRIGHTNESS; mutex_init(&data->lock); bl = backlight_device_register(dev_driver_string(&client->dev), &client->dev, data, &adp8860_bl_ops, &props); if (IS_ERR(bl)) { dev_err(&client->dev, "failed to register backlight\n"); return PTR_ERR(bl); } bl->props.brightness = ADP8860_MAX_BRIGHTNESS; data->bl = bl; if (data->en_ambl_sens) ret = sysfs_create_group(&bl->dev.kobj, &adp8860_bl_attr_group); if (ret) { dev_err(&client->dev, "failed to register sysfs\n"); goto out1; } ret = adp8860_bl_setup(bl); if (ret) { ret = -EIO; goto out; } backlight_update_status(bl); dev_info(&client->dev, "%s Rev.%d Backlight\n", client->name, data->revid); if (pdata->num_leds) adp8860_led_probe(client); return 0; out: if (data->en_ambl_sens) sysfs_remove_group(&data->bl->dev.kobj, &adp8860_bl_attr_group); out1: backlight_device_unregister(bl); return ret; }
struct dca_provider *ioat_dca_init(struct pci_dev *pdev, void __iomem *iobase) { struct dca_provider *dca; struct ioat_dca_priv *ioatdca; int slots; int i; int err; u16 dca_offset; u16 csi_fsb_control; u16 pcie_control; u8 bit; union { u64 full; struct { u32 low; u32 high; }; } tag_map; if (!system_has_dca_enabled(pdev)) return NULL; dca_offset = readw(iobase + IOAT_DCAOFFSET_OFFSET); if (dca_offset == 0) return NULL; slots = ioat_dca_count_dca_slots(iobase, dca_offset); if (slots == 0) return NULL; dca = alloc_dca_provider(&ioat_dca_ops, sizeof(*ioatdca) + (sizeof(struct ioat_dca_slot) * slots)); if (!dca) return NULL; ioatdca = dca_priv(dca); ioatdca->iobase = iobase; ioatdca->dca_base = iobase + dca_offset; ioatdca->max_requesters = slots; /* some bios might not know to turn these on */ csi_fsb_control = readw(ioatdca->dca_base + IOAT3_CSI_CONTROL_OFFSET); if ((csi_fsb_control & IOAT3_CSI_CONTROL_PREFETCH) == 0) { csi_fsb_control |= IOAT3_CSI_CONTROL_PREFETCH; writew(csi_fsb_control, ioatdca->dca_base + IOAT3_CSI_CONTROL_OFFSET); } pcie_control = readw(ioatdca->dca_base + IOAT3_PCI_CONTROL_OFFSET); if ((pcie_control & IOAT3_PCI_CONTROL_MEMWR) == 0) { pcie_control |= IOAT3_PCI_CONTROL_MEMWR; writew(pcie_control, ioatdca->dca_base + IOAT3_PCI_CONTROL_OFFSET); } /* TODO version, compatibility and configuration checks */ /* copy out the APIC to DCA tag map */ tag_map.low = readl(ioatdca->dca_base + IOAT3_APICID_TAG_MAP_OFFSET_LOW); tag_map.high = readl(ioatdca->dca_base + IOAT3_APICID_TAG_MAP_OFFSET_HIGH); for (i = 0; i < 8; i++) { bit = tag_map.full >> (8 * i); ioatdca->tag_map[i] = bit & DCA_TAG_MAP_MASK; } if (dca3_tag_map_invalid(ioatdca->tag_map)) { WARN_TAINT_ONCE(1, TAINT_FIRMWARE_WORKAROUND, "%s %s: APICID_TAG_MAP set incorrectly by BIOS, disabling DCA\n", dev_driver_string(&pdev->dev), dev_name(&pdev->dev)); free_dca_provider(dca); return NULL; } err = register_dca_provider(dca, &pdev->dev); if (err) { free_dca_provider(dca); return NULL; } return dca; }
static int __devinit adp8870_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct backlight_device *bl; struct adp8870_bl *data; struct adp8870_backlight_platform_data *pdata = client->dev.platform_data; uint8_t reg_val; int ret; if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA)) { dev_err(&client->dev, "SMBUS Byte Data not Supported\n"); return -EIO; } if (!pdata) { dev_err(&client->dev, "no platform data?\n"); return -EINVAL; } ret = adp8870_read(client, ADP8870_MFDVID, ®_val); if (ret < 0) return -EIO; if (ADP8870_MANID(reg_val) != ADP8870_MANUFID) { dev_err(&client->dev, "failed to probe\n"); return -ENODEV; } data = kzalloc(sizeof(*data), GFP_KERNEL); if (data == NULL) return -ENOMEM; data->revid = ADP8870_DEVID(reg_val); data->client = client; data->pdata = pdata; data->id = id->driver_data; data->current_brightness = 0; i2c_set_clientdata(client, data); mutex_init(&data->lock); bl = backlight_device_register(dev_driver_string(&client->dev), &client->dev, data, &adp8870_bl_ops); if (IS_ERR(bl)) { dev_err(&client->dev, "failed to register backlight\n"); ret = PTR_ERR(bl); goto out2; } bl->props.max_brightness = bl->props.brightness = ADP8870_MAX_BRIGHTNESS; data->bl = bl; if (pdata->en_ambl_sens) ret = sysfs_create_group(&bl->dev.kobj, &adp8870_bl_attr_group); if (ret) { dev_err(&client->dev, "failed to register sysfs\n"); goto out1; } ret = adp8870_bl_setup(bl); if (ret) { ret = -EIO; goto out; } dev_info(&client->dev, "Rev.%d Backlight\n", data->revid); if (pdata->num_leds) adp8870_led_probe(client); return 0; out: if (data->pdata->en_ambl_sens) sysfs_remove_group(&data->bl->dev.kobj, &adp8870_bl_attr_group); out1: backlight_device_unregister(bl); out2: i2c_set_clientdata(client, NULL); kfree(data); return ret; }
static int __devinit qt1070_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct qt1070_data *data; struct input_dev *input; struct pinctrl *pinctrl; int i; int err; pinctrl = devm_pinctrl_get_select_default(&client->dev); if (IS_ERR(pinctrl)) { dev_err(&client->dev, "Failed to request pinctrl\n"); return PTR_ERR(pinctrl); } err = i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE); if (!err) { dev_err(&client->dev, "%s adapter not supported\n", dev_driver_string(&client->adapter->dev)); return -ENODEV; } if (!client->irq) { dev_err(&client->dev, "please assign the irq to this device\n"); return -EINVAL; } /* Identify the qt1070 chip */ if (!qt1070_identify(client)) return -ENODEV; data = kzalloc(sizeof(struct qt1070_data), GFP_KERNEL); input = input_allocate_device(); if (!data || !input) { dev_err(&client->dev, "insufficient memory\n"); err = -ENOMEM; goto err_free_mem; } data->client = client; data->input = input; data->irq = client->irq; input->name = "AT42QT1070 QTouch Sensor"; input->dev.parent = &client->dev; input->id.bustype = BUS_I2C; /* Add the keycode */ input->keycode = data->keycodes; input->keycodesize = sizeof(data->keycodes[0]); input->keycodemax = ARRAY_SIZE(qt1070_key2code); __set_bit(EV_KEY, input->evbit); for (i = 0; i < ARRAY_SIZE(qt1070_key2code); i++) { data->keycodes[i] = qt1070_key2code[i]; __set_bit(qt1070_key2code[i], input->keybit); } /* Calibrate device */ qt1070_write(client, CALIBRATE_CMD, 1); msleep(QT1070_CAL_TIME); /* Soft reset */ qt1070_write(client, RESET, 1); msleep(QT1070_RESET_TIME); err = request_threaded_irq(client->irq, NULL, qt1070_interrupt, IRQF_TRIGGER_NONE | IRQF_ONESHOT, client->dev.driver->name, data); if (err) { dev_err(&client->dev, "fail to request irq\n"); goto err_free_mem; } err = device_init_wakeup(&client->dev, true); if (err) dev_err(&client->dev, "fail to init device as wakeup source\n"); err = enable_irq_wake(client->irq); if (err) dev_err(&client->dev, "fail to enable irq wake\n"); /* Register the input device */ err = input_register_device(data->input); if (err) { dev_err(&client->dev, "Failed to register input device\n"); goto err_free_irq; } i2c_set_clientdata(client, data); /* Read to clear the chang line */ qt1070_read(client, DET_STATUS); return 0; err_free_irq: free_irq(client->irq, data); err_free_mem: input_free_device(input); kfree(data); return err; }
static int tca6416_keypad_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct tca6416_keys_platform_data *pdata; struct tca6416_keypad_chip *chip; struct input_dev *input; int error; int i; /* Check functionality */ if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE)) { dev_err(&client->dev, "%s adapter not supported\n", dev_driver_string(&client->adapter->dev)); return -ENODEV; } pdata = dev_get_platdata(&client->dev); if (!pdata) { dev_dbg(&client->dev, "no platform data\n"); return -EINVAL; } chip = kzalloc(sizeof(struct tca6416_keypad_chip) + pdata->nbuttons * sizeof(struct tca6416_button), GFP_KERNEL); input = input_allocate_device(); if (!chip || !input) { error = -ENOMEM; goto fail1; } chip->client = client; chip->input = input; chip->io_size = id->driver_data; chip->pinmask = pdata->pinmask; chip->use_polling = pdata->use_polling; INIT_DELAYED_WORK(&chip->dwork, tca6416_keys_work_func); input->phys = "tca6416-keys/input0"; input->name = client->name; input->dev.parent = &client->dev; input->open = tca6416_keys_open; input->close = tca6416_keys_close; input->id.bustype = BUS_HOST; input->id.vendor = 0x0001; input->id.product = 0x0001; input->id.version = 0x0100; /* Enable auto repeat feature of Linux input subsystem */ if (pdata->rep) __set_bit(EV_REP, input->evbit); for (i = 0; i < pdata->nbuttons; i++) { unsigned int type; chip->buttons[i] = pdata->buttons[i]; type = (pdata->buttons[i].type) ?: EV_KEY; input_set_capability(input, type, pdata->buttons[i].code); } input_set_drvdata(input, chip); /* * Initialize cached registers from their original values. * we can't share this chip with another i2c master. */ error = tca6416_setup_registers(chip); if (error) goto fail1; if (!chip->use_polling) { if (pdata->irq_is_gpio) chip->irqnum = gpio_to_irq(client->irq); else chip->irqnum = client->irq; error = request_threaded_irq(chip->irqnum, NULL, tca6416_keys_isr, IRQF_TRIGGER_FALLING | IRQF_ONESHOT, "tca6416-keypad", chip); if (error) { dev_dbg(&client->dev, "Unable to claim irq %d; error %d\n", chip->irqnum, error); goto fail1; } disable_irq(chip->irqnum); } error = input_register_device(input); if (error) { dev_dbg(&client->dev, "Unable to register input device, error: %d\n", error); goto fail2; } i2c_set_clientdata(client, chip); device_init_wakeup(&client->dev, 1); return 0; fail2: if (!chip->use_polling) { free_irq(chip->irqnum, chip); enable_irq(chip->irqnum); } fail1: input_free_device(input); kfree(chip); return error; }
static ssize_t name_show(struct device *dev, struct device_attribute *attr, char *buf) { return sprintf(buf, "%s %s\n", dev_driver_string(dev->parent), dev_name(dev->parent)); }