static ssize_t
proximity_enable_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct gp2a_data *data = dev_get_drvdata(dev);
int value = 0;
char input;
int err = 0;
int16_t thrd;
u8 reg;
err = kstrtoint(buf, 10, &value);
if (err) {
pr_err("%s, kstrtoint failed.", __func__);
goto done;
}
if (value != 0 && value != 1)
goto done;
pr_info("%s, %d value = %d\n", __func__, __LINE__, value);
if (data->proximity_enabled && !value) { /* Prox power off */
input = gpio_get_value_cansleep(data->pdata->p_out);
input_report_abs(data->proximity_input_dev,
ABS_DISTANCE, input);
input_sync(data->proximity_input_dev);
disable_irq(data->irq);
proximity_onoff(0, data);
disable_irq_wake(data->irq);
if (data->pdata->led_on)
data->pdata->led_on(false);
}
if (!data->proximity_enabled && value) { /* prox power on */
if (data->pdata->led_on)
data->pdata->led_on(true);
usleep_range(1000, 1100);
proximity_onoff(1, data);
err = proximity_open_calibration(data);
if (err < 0 && err != -ENOENT)
pr_err("%s: proximity_open_offset() failed\n",
__func__);
else {
thrd = gp2a_reg[3][1]+(data->offset_value);
THR_REG_LSB(thrd, reg);
gp2a_i2c_write(data, gp2a_reg[3][0], ®);
THR_REG_MSB(thrd, reg);
gp2a_i2c_write(data, gp2a_reg[4][0], ®);
thrd = gp2a_reg[5][1]+(data->offset_value);
THR_REG_LSB(thrd, reg);
gp2a_i2c_write(data, gp2a_reg[5][0], ®);
THR_REG_MSB(thrd, reg);
gp2a_i2c_write(data, gp2a_reg[6][0], ®);
}
enable_irq_wake(data->irq);
msleep(160);
input = gpio_get_value_cansleep(data->pdata->p_out);
input_report_abs(data->proximity_input_dev,
ABS_DISTANCE, input * 2);
input_sync(data->proximity_input_dev);
enable_irq(data->irq);
}
data->proximity_enabled = value;
done:
return count;
}
static void bt_release(struct device *dev)
{
void *data = dev_get_drvdata(dev);
kfree(data);
}
static ssize_t show_class(struct device *dev, struct device_attribute *attr, char *buf)
{
struct hci_dev *hdev = dev_get_drvdata(dev);
return sprintf(buf, "0x%.2x%.2x%.2x\n",
hdev->dev_class[2], hdev->dev_class[1], hdev->dev_class[0]);
}
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 ssize_t show_sniff_min_interval(struct device *dev, struct device_attribute *attr, char *buf)
{
struct hci_dev *hdev = dev_get_drvdata(dev);
return sprintf(buf, "%d\n", hdev->sniff_min_interval);
}
int power_supply_uevent(struct device *dev, struct kobj_uevent_env *env)
{
struct power_supply *psy = dev_get_drvdata(dev);
int ret = 0, j;
char *prop_buf;
char *attrname;
// dev_dbg(dev, "uevent\n");
if (!psy || !psy->dev) {
dev_dbg(dev, "No power supply yet\n");
return ret;
}
// dev_dbg(dev, "POWER_SUPPLY_NAME=%s\n", psy->name);
ret = add_uevent_var(env, "POWER_SUPPLY_NAME=%s", psy->name);
if (ret)
return ret;
prop_buf = (char *)get_zeroed_page(GFP_KERNEL);
if (!prop_buf)
return -ENOMEM;
for (j = 0; j < psy->num_properties; j++) {
struct device_attribute *attr;
char *line;
attr = &power_supply_attrs[psy->properties[j]];
ret = power_supply_show_property(dev, attr, prop_buf);
if (ret == -ENODEV) {
/* When a battery is absent, we expect -ENODEV. Don't abort;
send the uevent with at least the the PRESENT=0 property */
ret = 0;
continue;
}
if (ret < 0)
goto out;
line = strchr(prop_buf, '\n');
if (line)
*line = 0;
attrname = kstruprdup(attr->attr.name, GFP_KERNEL);
if (!attrname) {
ret = -ENOMEM;
goto out;
}
//dev_dbg(dev, "prop %s=%s\n", attrname, prop_buf);
ret = add_uevent_var(env, "POWER_SUPPLY_%s=%s", attrname, prop_buf);
kfree(attrname);
if (ret)
goto out;
}
out:
free_page((unsigned long)prop_buf);
return ret;
}
static ssize_t proximity_enable_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct cm3663_data *cm3663 = dev_get_drvdata(dev);
bool new_value;
u8 tmp;
#if defined(CONFIG_MACH_S2PLUS)
u8 val = 1;
#endif
if (sysfs_streq(buf, "1"))
new_value = true;
else if (sysfs_streq(buf, "0"))
new_value = false;
else {
pr_err("%s: invalid value %d\n", __func__, *buf);
return -EINVAL;
}
mutex_lock(&cm3663->power_lock);
if (new_value && !(cm3663->power_state & PROXIMITY_ENABLED)) {
cm3663->pdata->proximity_power(1);
cm3663->power_state |= PROXIMITY_ENABLED;
cm3663_i2c_read(cm3663, REGS_ARA, &tmp);
cm3663_i2c_read(cm3663, REGS_ARA, &tmp);
cm3663_i2c_read(cm3663, REGS_ARA, &tmp);
cm3663_i2c_write(cm3663, REGS_INIT, reg_defaults[3]);
cm3663_i2c_write(cm3663, REGS_PS_THD, reg_defaults[7]);
cm3663_i2c_write(cm3663, REGS_PS_CMD, reg_defaults[5]);
#if defined(CONFIG_MACH_S2PLUS)
/* report the first value */
val = gpio_get_value(cm3663->i2c_client->irq);
if (val < 0) {
pr_err("%s: gpio_get_value error %d\n", __func__, val);
return IRQ_HANDLED;
}
cm3663_i2c_read(cm3663, REGS_PS_DATA, &tmp);
printk(KERN_INFO "%s: proximity value = %d, val = %d\n",
__func__, tmp, val);
/* 0 is close, 1 is far */
input_report_abs(cm3663->proximity_input_dev,
ABS_DISTANCE, val);
input_sync(cm3663->proximity_input_dev);
wake_lock_timeout(&cm3663->prx_wake_lock, 3*HZ);
#endif
enable_irq(cm3663->irq);
enable_irq_wake(cm3663->irq);
} else if (!new_value && (cm3663->power_state & PROXIMITY_ENABLED)) {
cm3663->power_state &= ~PROXIMITY_ENABLED;
disable_irq_wake(cm3663->irq);
disable_irq(cm3663->irq);
cm3663_i2c_write(cm3663, REGS_PS_CMD, 0x01);
cm3663->pdata->proximity_power(0);
}
mutex_unlock(&cm3663->power_lock);
return size;
}
/*
* ---------------------------------------------------------------------------
* Tahvo related functions
* These are Nokia proprietary code, except for the OTG register settings,
* which are copied from isp1301.c
* ---------------------------------------------------------------------------
*/
static ssize_t vbus_state_show(struct device *device,
struct device_attribute *attr, char *buf)
{
struct tahvo_usb *tu = dev_get_drvdata(device);
return sprintf(buf, "%d\n", tu->vbus_state);
}
static ssize_t magnetic_get_selftest(struct device *dev,
struct device_attribute *attr, char *buf)
{
char chTempBuf[22] = { 0, };
int iRet = 0;
s8 id = 0, x = 0, y1 = 0, y2 = 0, dir = 0;
s16 sx = 0, sy = 0, ohx = 0, ohy = 0, ohz = 0;
s8 err[7] = {-1, };
struct ssp_data *data = dev_get_drvdata(dev);
struct ssp_msg *msg = kzalloc(sizeof(*msg), GFP_KERNEL);
if (msg == NULL) {
pr_err("[SSP] %s, failed to alloc memory for ssp_msg\n", __func__);
goto exit;
}
msg->cmd = GEOMAGNETIC_FACTORY;
msg->length = 22;
msg->options = AP2HUB_READ;
msg->buffer = chTempBuf;
msg->free_buffer = 0;
iRet = ssp_spi_sync(data, msg, 1000);
if (iRet != SUCCESS) {
pr_err("[SSP]: %s - Magnetic Selftest Timeout!! %d\n", __func__, iRet);
goto exit;
}
id = (s8)(chTempBuf[0]);
err[0] = (s8)(chTempBuf[1]);
err[1] = (s8)(chTempBuf[2]);
err[2] = (s8)(chTempBuf[3]);
x = (s8)(chTempBuf[4]);
y1 = (s8)(chTempBuf[5]);
y2 = (s8)(chTempBuf[6]);
err[3] = (s8)(chTempBuf[7]);
dir = (s8)(chTempBuf[8]);
err[4] = (s8)(chTempBuf[9]);
ohx = (s16)((chTempBuf[10] << 8) + chTempBuf[11]);
ohy = (s16)((chTempBuf[12] << 8) + chTempBuf[13]);
ohz = (s16)((chTempBuf[14] << 8) + chTempBuf[15]);
err[6] = (s8)(chTempBuf[16]);
sx = (s16)((chTempBuf[17] << 8) + chTempBuf[18]);
sy = (s16)((chTempBuf[19] << 8) + chTempBuf[20]);
err[5] = (s8)(chTempBuf[21]);
if (unlikely(id != 0x2))
err[0] = -1;
if (unlikely(x < -30 || x > 30))
err[3] = -1;
if (unlikely(y1 < -30 || y1 > 30))
err[3] = -1;
if (unlikely(y2 < -30 || y2 > 30))
err[3] = -1;
if (unlikely(sx < 17 || sy < 22))
err[5] = -1;
if (unlikely(ohx < -600 || ohx > 600))
err[6] = -1;
if (unlikely(ohy < -600 || ohy > 600))
err[6] = -1;
if (unlikely(ohz < -600 || ohz > 600))
err[6] = -1;
pr_info("[SSP] %s\n"
"[SSP] Test1 - err = %d, id = %d\n"
"[SSP] Test3 - err = %d\n"
"[SSP] Test4 - err = %d, offset = %d,%d,%d\n"
"[SSP] Test5 - err = %d, direction = %d\n"
"[SSP] Test6 - err = %d, sensitivity = %d,%d\n"
"[SSP] Test7 - err = %d, offset = %d,%d,%d\n"
"[SSP] Test2 - err = %d\n",
__func__, err[0], id, err[2], err[3], x, y1, y2, err[4], dir,
err[5], sx, sy, err[6], ohx, ohy, ohz, err[1]);
exit:
return sprintf(buf,
"%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d\n",
err[0], id, err[2], err[3], x, y1, y2, err[4], dir,
err[5], sx, sy, err[6], ohx, ohy, ohz, err[1]);
}
/**
* ufshcd_pci_suspend - suspend power management function
* @pdev: pointer to PCI device handle
* @state: power state
*
* Returns 0 if successful
* Returns non-zero otherwise
*/
static int ufshcd_pci_suspend(struct device *dev)
{
return ufshcd_system_suspend(dev_get_drvdata(dev));
}
/**
* ufshcd_pci_resume - resume power management function
* @pdev: pointer to PCI device handle
*
* Returns 0 if successful
* Returns non-zero otherwise
*/
static int ufshcd_pci_resume(struct device *dev)
{
return ufshcd_system_resume(dev_get_drvdata(dev));
}
static int ufshcd_pci_runtime_idle(struct device *dev)
{
return ufshcd_runtime_idle(dev_get_drvdata(dev));
}
static int xhci_plat_probe(struct platform_device *pdev)
{
const struct hc_driver *driver;
struct xhci_hcd *xhci;
struct resource *res;
struct usb_hcd *hcd;
int ret;
int irq;
if (usb_disabled())
return -ENODEV;
driver = &xhci_plat_xhci_driver;
irq = platform_get_irq(pdev, 0);
if (irq < 0)
return -ENODEV;
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!res)
return -ENODEV;
hcd = usb_create_hcd(driver, &pdev->dev, dev_name(&pdev->dev));
if (!hcd)
return -ENOMEM;
hcd_to_bus(hcd)->skip_resume = true;
hcd->rsrc_start = res->start;
hcd->rsrc_len = resource_size(res);
if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len,
driver->description)) {
dev_dbg(&pdev->dev, "controller already in use\n");
ret = -EBUSY;
goto put_hcd;
}
hcd->regs = ioremap_nocache(hcd->rsrc_start, hcd->rsrc_len);
if (!hcd->regs) {
dev_dbg(&pdev->dev, "error mapping memory\n");
ret = -EFAULT;
goto release_mem_region;
}
pm_runtime_set_active(&pdev->dev);
pm_runtime_enable(&pdev->dev);
pm_runtime_get_sync(&pdev->dev);
ret = usb_add_hcd(hcd, irq, IRQF_SHARED);
if (ret)
goto unmap_registers;
/* USB 2.0 roothub is stored in the platform_device now. */
hcd = dev_get_drvdata(&pdev->dev);
xhci = hcd_to_xhci(hcd);
xhci->shared_hcd = usb_create_shared_hcd(driver, &pdev->dev,
dev_name(&pdev->dev), hcd);
if (!xhci->shared_hcd) {
ret = -ENOMEM;
goto dealloc_usb2_hcd;
}
hcd_to_bus(xhci->shared_hcd)->skip_resume = true;
/*
* Set the xHCI pointer before xhci_plat_setup() (aka hcd_driver.reset)
* is called by usb_add_hcd().
*/
*((struct xhci_hcd **) xhci->shared_hcd->hcd_priv) = xhci;
ret = usb_add_hcd(xhci->shared_hcd, irq, IRQF_SHARED);
if (ret)
goto put_usb3_hcd;
phy = usb_get_transceiver();
/* Register with OTG if present, ignore USB2 OTG using other PHY */
if (phy && phy->otg && !(phy->flags & ENABLE_SECONDARY_PHY)) {
dev_dbg(&pdev->dev, "%s otg support available\n", __func__);
ret = otg_set_host(phy->otg, &hcd->self);
if (ret) {
dev_err(&pdev->dev, "%s otg_set_host failed\n",
__func__);
usb_put_transceiver(phy);
goto put_usb3_hcd;
}
} else {
pm_runtime_no_callbacks(&pdev->dev);
}
pm_runtime_put(&pdev->dev);
return 0;
put_usb3_hcd:
usb_put_hcd(xhci->shared_hcd);
dealloc_usb2_hcd:
usb_remove_hcd(hcd);
unmap_registers:
iounmap(hcd->regs);
release_mem_region:
release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
put_hcd:
usb_put_hcd(hcd);
return ret;
}
static ssize_t hall_device_enable_show(struct device *dev, struct device_attribute *attr, char *buf)
{
struct hall_device_chip *chip = dev_get_drvdata(dev);
return snprintf(buf, PAGE_SIZE, "%d\n", chip->enabled);
}
static ssize_t gyro_selftest_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct ssp_data *data = dev_get_drvdata(dev);
return mpu6500_gyro_selftest(buf, data);
}
static int setup_msp_config(struct snd_pcm_substream *substream,
struct snd_soc_dai *dai,
struct ux500_msp_config *msp_config)
{
struct ux500_msp_i2s_drvdata *drvdata = dev_get_drvdata(dai->dev);
struct msp_protdesc *prot_desc = &msp_config->protdesc;
struct snd_pcm_runtime *runtime = substream->runtime;
unsigned int fmt = drvdata->fmt;
int ret;
memset(msp_config, 0, sizeof(*msp_config));
msp_config->f_inputclk = drvdata->master_clk;
msp_config->tx_fifo_config = TX_FIFO_ENABLE;
msp_config->rx_fifo_config = RX_FIFO_ENABLE;
msp_config->def_elem_len = 1;
msp_config->direction = substream->stream == SNDRV_PCM_STREAM_PLAYBACK ?
MSP_DIR_TX : MSP_DIR_RX;
msp_config->data_size = MSP_DATA_BITS_32;
msp_config->frame_freq = runtime->rate;
dev_dbg(dai->dev, "%s: f_inputclk = %u, frame_freq = %u.\n",
__func__, msp_config->f_inputclk, msp_config->frame_freq);
/* To avoid division by zero */
prot_desc->clocks_per_frame = 1;
dev_dbg(dai->dev, "%s: rate: %u, channels: %d.\n", __func__,
runtime->rate, runtime->channels);
switch (fmt &
(SND_SOC_DAIFMT_FORMAT_MASK | SND_SOC_DAIFMT_MASTER_MASK)) {
case SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_CBS_CFS:
dev_dbg(dai->dev, "%s: SND_SOC_DAIFMT_I2S.\n", __func__);
msp_config->default_protdesc = 1;
msp_config->protocol = MSP_I2S_PROTOCOL;
break;
case SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_CBM_CFM:
dev_dbg(dai->dev, "%s: SND_SOC_DAIFMT_I2S.\n", __func__);
msp_config->data_size = MSP_DATA_BITS_16;
msp_config->protocol = MSP_I2S_PROTOCOL;
ret = setup_i2s_protdesc(prot_desc);
if (ret < 0)
return ret;
break;
case SND_SOC_DAIFMT_DSP_A | SND_SOC_DAIFMT_CBS_CFS:
case SND_SOC_DAIFMT_DSP_A | SND_SOC_DAIFMT_CBM_CFM:
case SND_SOC_DAIFMT_DSP_B | SND_SOC_DAIFMT_CBS_CFS:
case SND_SOC_DAIFMT_DSP_B | SND_SOC_DAIFMT_CBM_CFM:
dev_dbg(dai->dev, "%s: PCM format.\n", __func__);
msp_config->data_size = MSP_DATA_BITS_16;
msp_config->protocol = MSP_PCM_PROTOCOL;
ret = setup_pcm_protdesc(dai, fmt, prot_desc);
if (ret < 0)
return ret;
ret = setup_pcm_multichan(dai, msp_config);
if (ret < 0)
return ret;
ret = setup_pcm_framing(dai, runtime->rate, prot_desc);
if (ret < 0)
return ret;
break;
default:
dev_err(dai->dev, "%s: Error: Unsupported format (%d)!\n",
__func__, fmt);
return -EINVAL;
}
return setup_clocking(dai, fmt, msp_config);
}
static int __devinit bu26507_led_probe(struct platform_device *pdev)
{
struct bu26507_dev *iodev = dev_get_drvdata(pdev->dev.parent);
struct bu26507_platform_data *pdata = dev_get_platdata(iodev->dev);
struct bu26507_led *led;
char name[20];
int ret;
if (!pdata) {
dev_err(&pdev->dev, "no platform data\n");
ret = -ENODEV;
}
led = kzalloc(sizeof(*led), GFP_KERNEL);
if (led == NULL) {
ret = -ENOMEM;
goto err_mem;
}
led->pd_id = platform_get_device_id(pdev)->driver_data;
led->id = pdev->id;
pr_debug("%s():pd_id = %d, id = %d\n", __func__, led->pd_id, led->id);
led->cdev.brightness_set = bu26507_led_brightness_set;
led->cdev.brightness = 0;
led->iodev = iodev;
if (bu26507_LED == led->pd_id) {
snprintf(name, sizeof(name), "%s%d", pdev->name, pdev->id);
led->cdev.name = name;
if (pdata->led_on[led->id]) {
bu26507_set_led_current(led, BU26507_DEFAULT_CURRENT);
led->cdev.brightness = BU26507_DEFAULT_CURRENT;
} else {
led->cdev.brightness = 0;
}
} else if (bu26507_PWM) {
led->cdev.name = pdev->name;
bu26507_set_led_pwm(led, BU26507_DEFAULT_PWM);
led->cdev.brightness = BU26507_DEFAULT_PWM;
} else {
led->cdev.name = pdev->name;
led->cdev.brightness = 0;
}
mutex_init(&led->mutex);
platform_set_drvdata(pdev, led);
ret = led_classdev_register(&pdev->dev, &led->cdev);
if (ret < 0)
goto err_register_led;
#ifdef CONFIG_HAS_EARLYSUSPEND
led->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN;
led->early_suspend.suspend = bu26507_early_suspend;
led->early_suspend.resume = bu26507_late_resume;
register_early_suspend(&led->early_suspend);
#endif
return 0;
err_register_led:
kfree(led);
err_mem:
return ret;
}
static int setup_frameper(struct snd_soc_dai *dai, unsigned int rate,
struct msp_protdesc *prot_desc)
{
struct ux500_msp_i2s_drvdata *drvdata = dev_get_drvdata(dai->dev);
switch (drvdata->slots) {
case 1:
switch (rate) {
case 8000:
prot_desc->frame_period =
FRAME_PER_SINGLE_SLOT_8_KHZ;
break;
case 16000:
prot_desc->frame_period =
FRAME_PER_SINGLE_SLOT_16_KHZ;
break;
case 44100:
prot_desc->frame_period =
FRAME_PER_SINGLE_SLOT_44_1_KHZ;
break;
case 48000:
prot_desc->frame_period =
FRAME_PER_SINGLE_SLOT_48_KHZ;
break;
default:
dev_err(dai->dev,
"%s: Error: Unsupported sample-rate (freq = %d)!\n",
__func__, rate);
return -EINVAL;
}
break;
case 2:
prot_desc->frame_period = FRAME_PER_2_SLOTS;
break;
case 8:
prot_desc->frame_period = FRAME_PER_8_SLOTS;
break;
case 16:
prot_desc->frame_period = FRAME_PER_16_SLOTS;
break;
default:
dev_err(dai->dev,
"%s: Error: Unsupported slot-count (slots = %d)!\n",
__func__, drvdata->slots);
return -EINVAL;
}
prot_desc->clocks_per_frame =
prot_desc->frame_period+1;
dev_dbg(dai->dev, "%s: Clocks per frame: %u\n",
__func__,
prot_desc->clocks_per_frame);
return 0;
}
static ssize_t poll_delay_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct cm3663_data *cm3663 = dev_get_drvdata(dev);
return sprintf(buf, "%lld\n", ktime_to_ns(cm3663->light_poll_delay));
}
int tegra_bbc_proxy_edp_register(struct device *dev, u32 num_states,
u32 *states)
{
struct edp_manager *mgr;
struct edp_client *ap;
int ret;
int i;
struct tegra_bbc_proxy *bbc = dev_get_drvdata(dev);
mutex_lock(&bbc->edp_lock);
/* client should only be registered once per modem boot */
if (bbc->edp_client_registered) {
dev_err(dev, "bbc edp client already registered\n");
ret = -EBUSY;
goto done;
}
memset(bbc->modem_edp_states, 0, sizeof(bbc->modem_edp_states));
memset(&bbc->modem_edp_client, 0, sizeof(bbc->modem_edp_client));
/* retrieve max current for supported states */
for (i = 0; i < num_states; i++) {
bbc->modem_edp_states[i] = *states;
states++;
}
strncpy(bbc->modem_edp_client.name, "bbc", EDP_NAME_LEN);
bbc->modem_edp_client.name[EDP_NAME_LEN - 1] = '\0';
bbc->modem_edp_client.states = bbc->modem_edp_states;
bbc->modem_edp_client.num_states = num_states;
bbc->modem_edp_client.e0_index = 0;
bbc->modem_edp_client.max_borrowers = 1;
bbc->modem_edp_client.priority = EDP_MAX_PRIO;
mgr = edp_get_manager(bbc->edp_manager_name);
if (!mgr) {
dev_err(dev, "can't get edp manager\n");
ret = -EINVAL;
goto done;
}
/* unregister modem_boot_client */
ret = edp_unregister_client(bbc->modem_boot_edp_client);
if (ret) {
dev_err(dev, "unable to register bbc boot edp client\n");
goto done;
}
bbc->edp_boot_client_registered = 0;
/* register modem client */
ret = edp_register_client(mgr, &bbc->modem_edp_client);
if (ret) {
dev_err(dev, "unable to register bbc edp client\n");
goto done;
}
bbc->edp_client_registered = 1;
ap = edp_get_client(bbc->ap_name);
if (!ap) {
dev_err(dev, "can't get ap client\n");
goto done;
}
ret = edp_register_loan(&bbc->modem_edp_client, ap);
if (ret && ret != -EEXIST) {
dev_err(dev, "unable to register bbc loan to ap\n");
goto done;
}
done:
mutex_unlock(&bbc->edp_lock);
return ret;
}
int sensor_imx135_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int ret = 0;
struct fimc_is_core *core;
struct v4l2_subdev *subdev_module;
struct fimc_is_module_enum *module;
struct fimc_is_device_sensor *device;
struct sensor_open_extended *ext;
BUG_ON(!fimc_is_dev);
core = (struct fimc_is_core *)dev_get_drvdata(fimc_is_dev);
if (!core) {
err("core device is not yet probed");
return -EPROBE_DEFER;
}
device = &core->sensor[SENSOR_IMX135_INSTANCE];
subdev_module = kzalloc(sizeof(struct v4l2_subdev), GFP_KERNEL);
if (!subdev_module) {
err("subdev_module is NULL");
ret = -ENOMEM;
goto p_err;
}
module = &device->module_enum[atomic_read(&core->resourcemgr.rsccount_module)];
atomic_inc(&core->resourcemgr.rsccount_module);
module->id = SENSOR_NAME_IMX135;
module->subdev = subdev_module;
module->device = SENSOR_IMX135_INSTANCE;
module->ops = NULL;
module->client = client;
module->active_width = 4128;
module->active_height = 3096;
module->pixel_width = module->active_width + 16;
module->pixel_height = module->active_height + 10;
module->max_framerate = 120;
module->sensor_maker = "SONY";
module->sensor_name = "IMX135";
module->setfile_name = "setfile_imx135.bin";
module->cfgs = ARRAY_SIZE(config_imx135);
module->cfg = config_imx135;
module->private_data = NULL;
module->lanes = CSI_DATA_LANES_4;
ext = &module->ext;
memset(ext, 0x0, sizeof(struct sensor_open_extended));
ext->mipi_lane_num = 4;
ext->sensor_con.product_name = 0;
ext->sensor_con.peri_type = SE_I2C;
//ext->sensor_con.peri_setting.i2c.channel = sensor_info->i2c_channel;
//ext->sensor_con.peri_setting.i2c.slave_address = sensor_info->sensor_slave_address;
ext->sensor_con.peri_setting.i2c.speed = 400000;
ext->actuator_con.product_name = ACTUATOR_NAME_AK7345;
ext->actuator_con.peri_type = SE_I2C;
//ext->actuator_con.peri_setting.i2c.channel = sensor_info->actuator_i2c;
//ext->flash_con.product_name = sensor_info->flash_id;
ext->flash_con.peri_type = SE_GPIO;
//ext->flash_con.peri_setting.gpio.first_gpio_port_no = sensor_info->flash_first_gpio;
//ext->flash_con.peri_setting.gpio.second_gpio_port_no = sensor_info->flash_second_gpio;
ext->from_con.product_name = FROMDRV_NAME_NOTHING;
ext->mclk = 0;
ext->mipi_lane_num = 0;
ext->mipi_speed = 0;
ext->fast_open_sensor = 0;
ext->self_calibration_mode = 0;
ext->I2CSclk = I2C_L0;
ext->companion_con.product_name = COMPANION_NAME_NOTHING;
if (client)
v4l2_i2c_subdev_init(subdev_module, client, &subdev_ops);
else
v4l2_subdev_init(subdev_module, &subdev_ops);
v4l2_set_subdevdata(subdev_module, module);
v4l2_set_subdev_hostdata(subdev_module, device);
snprintf(subdev_module->name, V4L2_SUBDEV_NAME_SIZE, "sensor-subdev.%d", module->id);
p_err:
info("%s(%d)\n", __func__, ret);
return ret;
}
static int __devinit sil680_init_one(struct pci_dev *pdev,
const struct pci_device_id *id)
{
static const struct ata_port_info info = {
.flags = ATA_FLAG_SLAVE_POSS,
.pio_mask = 0x1f,
.mwdma_mask = 0x07,
.udma_mask = ATA_UDMA6,
.port_ops = &sil680_port_ops
};
static const struct ata_port_info info_slow = {
.flags = ATA_FLAG_SLAVE_POSS,
.pio_mask = 0x1f,
.mwdma_mask = 0x07,
.udma_mask = ATA_UDMA5,
.port_ops = &sil680_port_ops
};
const struct ata_port_info *ppi[] = { &info, NULL };
static int printed_version;
struct ata_host *host;
void __iomem *mmio_base;
int rc, try_mmio;
if (!printed_version++)
dev_printk(KERN_DEBUG, &pdev->dev, "version " DRV_VERSION "\n");
rc = pcim_enable_device(pdev);
if (rc)
return rc;
switch (sil680_init_chip(pdev, &try_mmio)) {
case 0:
ppi[0] = &info_slow;
break;
case 0x30:
return -ENODEV;
}
if (!try_mmio)
goto use_ioports;
/* Try to acquire MMIO resources and fallback to PIO if
* that fails
*/
rc = pcim_iomap_regions(pdev, 1 << SIL680_MMIO_BAR, DRV_NAME);
if (rc)
goto use_ioports;
/* Allocate host and set it up */
host = ata_host_alloc_pinfo(&pdev->dev, ppi, 2);
if (!host)
return -ENOMEM;
host->iomap = pcim_iomap_table(pdev);
/* Setup DMA masks */
rc = pci_set_dma_mask(pdev, ATA_DMA_MASK);
if (rc)
return rc;
rc = pci_set_consistent_dma_mask(pdev, ATA_DMA_MASK);
if (rc)
return rc;
pci_set_master(pdev);
/* Get MMIO base and initialize port addresses */
mmio_base = host->iomap[SIL680_MMIO_BAR];
host->ports[0]->ioaddr.bmdma_addr = mmio_base + 0x00;
host->ports[0]->ioaddr.cmd_addr = mmio_base + 0x80;
host->ports[0]->ioaddr.ctl_addr = mmio_base + 0x8a;
host->ports[0]->ioaddr.altstatus_addr = mmio_base + 0x8a;
ata_sff_std_ports(&host->ports[0]->ioaddr);
host->ports[1]->ioaddr.bmdma_addr = mmio_base + 0x08;
host->ports[1]->ioaddr.cmd_addr = mmio_base + 0xc0;
host->ports[1]->ioaddr.ctl_addr = mmio_base + 0xca;
host->ports[1]->ioaddr.altstatus_addr = mmio_base + 0xca;
ata_sff_std_ports(&host->ports[1]->ioaddr);
/* Register & activate */
return ata_host_activate(host, pdev->irq, ata_sff_interrupt,
IRQF_SHARED, &sil680_sht);
use_ioports:
return ata_pci_sff_init_one(pdev, ppi, &sil680_sht, NULL);
}
#ifdef CONFIG_PM
static int sil680_reinit_one(struct pci_dev *pdev)
{
struct ata_host *host = dev_get_drvdata(&pdev->dev);
int try_mmio, rc;
rc = ata_pci_device_do_resume(pdev);
if (rc)
return rc;
sil680_init_chip(pdev, &try_mmio);
ata_host_resume(host);
return 0;
}
#endif
static const struct pci_device_id sil680[] = {
{ PCI_VDEVICE(CMD, PCI_DEVICE_ID_SII_680), },
{ },
};
static struct pci_driver sil680_pci_driver = {
.name = DRV_NAME,
.id_table = sil680,
.probe = sil680_init_one,
.remove = ata_pci_remove_one,
#ifdef CONFIG_PM
.suspend = ata_pci_device_suspend,
.resume = sil680_reinit_one,
#endif
};
static int __init sil680_init(void)
{
return pci_register_driver(&sil680_pci_driver);
}
static void __exit sil680_exit(void)
{
pci_unregister_driver(&sil680_pci_driver);
}
MODULE_AUTHOR("Alan Cox");
MODULE_DESCRIPTION("low-level driver for SI680 PATA");
MODULE_LICENSE("GPL");
MODULE_DEVICE_TABLE(pci, sil680);
MODULE_VERSION(DRV_VERSION);
module_init(sil680_init);
module_exit(sil680_exit);
static ssize_t show_idle_timeout(struct device *dev, struct device_attribute *attr, char *buf)
{
struct hci_dev *hdev = dev_get_drvdata(dev);
return sprintf(buf, "%d\n", hdev->idle_timeout);
}
static int imx_drm_resume(struct device *dev)
{
struct drm_device *drm_dev = dev_get_drvdata(dev);
return drm_mode_config_helper_resume(drm_dev);
}
static ssize_t show_conn_type(struct device *dev, struct device_attribute *attr, char *buf)
{
struct hci_conn *conn = dev_get_drvdata(dev);
return sprintf(buf, "%s\n", conn->type == ACL_LINK ? "ACL" : "SCO");
}
int omap_tll_init(struct usbhs_omap_platform_data *pdata)
{
int i;
bool needs_tll;
unsigned reg;
struct usbtll_omap *tll;
if (!tll_dev)
return -ENODEV;
pm_runtime_get_sync(tll_dev);
spin_lock(&tll_lock);
tll = dev_get_drvdata(tll_dev);
needs_tll = false;
for (i = 0; i < tll->nch; i++)
needs_tll |= omap_usb_mode_needs_tll(pdata->port_mode[i]);
if (needs_tll) {
void __iomem *base = tll->base;
/* Program Common TLL register */
reg = usbtll_read(base, OMAP_TLL_SHARED_CONF);
reg |= (OMAP_TLL_SHARED_CONF_FCLK_IS_ON
| OMAP_TLL_SHARED_CONF_USB_DIVRATION);
reg &= ~OMAP_TLL_SHARED_CONF_USB_90D_DDR_EN;
reg &= ~OMAP_TLL_SHARED_CONF_USB_180D_SDR_EN;
usbtll_write(base, OMAP_TLL_SHARED_CONF, reg);
/* Enable channels now */
for (i = 0; i < tll->nch; i++) {
reg = usbtll_read(base, OMAP_TLL_CHANNEL_CONF(i));
if (is_ohci_port(pdata->port_mode[i])) {
reg |= ohci_omap3_fslsmode(pdata->port_mode[i])
<< OMAP_TLL_CHANNEL_CONF_FSLSMODE_SHIFT;
reg |= OMAP_TLL_CHANNEL_CONF_CHANMODE_FSLS;
} else if (pdata->port_mode[i] ==
OMAP_EHCI_PORT_MODE_TLL) {
/*
* Disable AutoIdle, BitStuffing
* and use SDR Mode
*/
reg &= ~(OMAP_TLL_CHANNEL_CONF_UTMIAUTOIDLE
| OMAP_TLL_CHANNEL_CONF_ULPINOBITSTUFF
| OMAP_TLL_CHANNEL_CONF_ULPIDDRMODE);
} else if (pdata->port_mode[i] ==
OMAP_EHCI_PORT_MODE_HSIC) {
/*
* HSIC Mode requires UTMI port configurations
*/
reg |= OMAP_TLL_CHANNEL_CONF_DRVVBUS
| OMAP_TLL_CHANNEL_CONF_CHRGVBUS
| OMAP_TLL_CHANNEL_CONF_MODE_TRANSPARENT_UTMI
| OMAP_TLL_CHANNEL_CONF_ULPINOBITSTUFF;
} else {
continue;
}
reg |= OMAP_TLL_CHANNEL_CONF_CHANEN;
usbtll_write(base, OMAP_TLL_CHANNEL_CONF(i), reg);
usbtll_writeb(base,
OMAP_TLL_ULPI_SCRATCH_REGISTER(i),
0xbe);
}
}
spin_unlock(&tll_lock);
pm_runtime_put_sync(tll_dev);
return 0;
}
static ssize_t show_type(struct device *dev, struct device_attribute *attr, char *buf)
{
struct hci_dev *hdev = dev_get_drvdata(dev);
return sprintf(buf, "%s\n", typetostr(hdev->type));
}
static void hdmi_unbind(struct device *dev, struct device *master,
void *data)
{
set_hdmi_pdev(dev_get_drvdata(master), NULL);
}
static ssize_t show_manufacturer(struct device *dev, struct device_attribute *attr, char *buf)
{
struct hci_dev *hdev = dev_get_drvdata(dev);
return sprintf(buf, "%d\n", hdev->manufacturer);
}
/* sysfs store function for play mode*/
static ssize_t qpnp_hap_play_mode_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
struct timed_output_dev *timed_dev = dev_get_drvdata(dev);
struct qpnp_hap *hap = container_of(timed_dev, struct qpnp_hap,
timed_dev);
char str[QPNP_HAP_STR_SIZE + 1];
int rc = 0, temp, old_mode, i;
if (snprintf(str, QPNP_HAP_STR_SIZE, "%s", buf) > QPNP_HAP_STR_SIZE)
return -EINVAL;
for (i = 0; i < strlen(str); i++) {
if (str[i] == ' ' || str[i] == '\n' || str[i] == '\t') {
str[i] = '\0';
break;
}
}
if (strcmp(str, "buffer") == 0)
temp = QPNP_HAP_BUFFER;
else if (strcmp(str, "direct") == 0)
temp = QPNP_HAP_DIRECT;
else if (strcmp(str, "audio") == 0)
temp = QPNP_HAP_AUDIO;
else if (strcmp(str, "pwm") == 0)
temp = QPNP_HAP_PWM;
else
return -EINVAL;
if (temp == hap->play_mode)
return count;
if (temp == QPNP_HAP_BUFFER && !hap->buffer_cfg_state) {
rc = qpnp_hap_parse_buffer_dt(hap);
if (!rc)
rc = qpnp_hap_buffer_config(hap);
} else if (temp == QPNP_HAP_PWM && !hap->pwm_cfg_state) {
rc = qpnp_hap_parse_pwm_dt(hap);
if (!rc)
rc = qpnp_hap_pwm_config(hap);
}
if (rc < 0)
return rc;
rc = qpnp_hap_mod_enable(hap, false);
if (rc < 0)
return rc;
old_mode = hap->play_mode;
hap->play_mode = temp;
/* Configure the PLAY MODE register */
rc = qpnp_hap_play_mode_config(hap);
if (rc) {
hap->play_mode = old_mode;
return rc;
}
if (hap->play_mode == QPNP_HAP_AUDIO) {
rc = qpnp_hap_mod_enable(hap, true);
if (rc < 0) {
hap->play_mode = old_mode;
return rc;
}
}
return count;
}