Exemplo n.º 1
0
int fsa9480_reset_ic(void)
{
	struct fsa9480_usbsw *usbsw = chip;
	struct i2c_client *client = chip->client;

    /*
	Disable Interrupt
	Write 0x01 to 0x1B Register <= Reset IC
	Write 0x40 to 0x05 Register <= Mask interrupt1
	Write 0x20 to 0x06 Register <= Mask interrupt2
	Write 0x2F to 0x25 Register <= Mask interrupt charger
	Write 0x1E to 0x02 Register <= Initialize control register
	Enable Interrupt 
	*/
	printk(KERN_WARNING "[FSA9480] %s. TSU8111 will be reset\n", __func__);
	fsa9480_detect_dev(usbsw, 2);

	disable_irq(client->irq);

	fsa9480_write_reg(client, 0x1B, 0x01);
	msleep(1);

	fsa9480_write_reg(client, FSA9480_REG_INT1_MASK, 0x40);
	fsa9480_write_reg(client, FSA9480_REG_INT2_MASK, 0x20);	
	fsa9480_write_reg(client, FSA9480_REG_CHG_INT_MASK, 0xc0);
	fsa9480_write_reg(client, FSA9480_REG_CTRL, 0x1E);	

	enable_irq(client->irq);

	printk(KERN_WARNING "[FSA9480] %s. TSU8111 reset...Done\n", __func__);
	
	return 0;
	
}
Exemplo n.º 2
0
static int fsa9480_resume(struct i2c_client *client)
{
	struct fsa9480_usbsw *usbsw = i2c_get_clientdata(client);

	/* device detection */
	fsa9480_detect_dev(usbsw);

	return 0;
}
Exemplo n.º 3
0
static void fsa9480_usb_detect(struct work_struct *work)
{
	struct fsa9480_usbsw *usbsw = container_of(work,
			struct fsa9480_usbsw, usb_work.work);

	usbsw->is_usb_ready = true;

	fsa9480_detect_dev(usbsw);
}
Exemplo n.º 4
0
static int __devinit fsa9480_probe(struct i2c_client *client,
			 const struct i2c_device_id *id)
{
	struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
	struct fsa9480_usbsw *usbsw;
	int ret = 0;

	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
		return -EIO;

	usbsw = kzalloc(sizeof(struct fsa9480_usbsw), GFP_KERNEL);
	if (!usbsw) {
		dev_err(&client->dev, "failed to allocate driver data\n");
		return -ENOMEM;
	}

	usbsw->client = client;
	usbsw->pdata = client->dev.platform_data;

	chip = usbsw;

	i2c_set_clientdata(client, usbsw);

	ret = fsa9480_irq_init(usbsw);
	if (ret)
		goto fail1;

	ret = sysfs_create_group(&client->dev.kobj, &fsa9480_group);
	if (ret) {
		dev_err(&client->dev,
				"failed to create fsa9480 attribute group\n");
		goto fail2;
	}

	/* ADC Detect Time: 500ms */
	fsa9480_write_reg(client, FSA9480_REG_TIMING1, 0x6);

	if (chip->pdata->reset_cb)
		chip->pdata->reset_cb();

	/* device detection */
	fsa9480_detect_dev(usbsw, INT_ATTACH);

	pm_runtime_set_active(&client->dev);

	return 0;

fail2:
	if (client->irq)
		free_irq(client->irq, usbsw);
fail1:
	i2c_set_clientdata(client, NULL);
	kfree(usbsw);
	return ret;
}
Exemplo n.º 5
0
static int __devinit fsa9480_probe(struct i2c_client *client,
			 const struct i2c_device_id *id)
{
	struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
	struct fsa9480_usbsw *usbsw;
	int ret = 0;

	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
		return -EIO;

	usbsw = kzalloc(sizeof(struct fsa9480_usbsw), GFP_KERNEL);
	if (!usbsw) {
		dev_err(&client->dev, "failed to allocate driver data\n");
		return -ENOMEM;
	}

	usbsw->client = client;
	usbsw->pdata = client->dev.platform_data;
	if (!usbsw->pdata)
		goto fail1;

	i2c_set_clientdata(client, usbsw);

	if (usbsw->pdata->cfg_gpio)
		usbsw->pdata->cfg_gpio();

	fsa9480_reg_init(usbsw);

	ret = fsa9480_irq_init(usbsw);
	if (ret)
		goto fail1;

	ret = sysfs_create_group(&client->dev.kobj, &fsa9480_group);
	if (ret) {
		dev_err(&client->dev,
				"failed to create fsa9480 attribute group\n");
		goto fail2;
	}

	if (usbsw->pdata->reset_cb)
		usbsw->pdata->reset_cb();

	/* device detection */
	fsa9480_detect_dev(usbsw);

	return 0;

fail2:
	if (client->irq)
		free_irq(client->irq, usbsw);
fail1:
	i2c_set_clientdata(client, NULL);
	kfree(usbsw);
	return ret;
}
Exemplo n.º 6
0
static int fsa9480_resume(struct i2c_client *client) 
{ 
       struct fsa9480_usbsw *usbsw = i2c_get_clientdata(client); 
       int dev1, dev2; 
 
       dev1 = fsa9480_read_reg(client, FSA9480_REG_DEV_T1); 
       dev2 = fsa9480_read_reg(client, FSA9480_REG_DEV_T2); 
 
       /* device detection */ 
       fsa9480_detect_dev(usbsw, (dev1 || dev2) ? INT_ATTACH : INT_DETACH); 
 
       return 0; 
} 
Exemplo n.º 7
0
static irqreturn_t fsa9480_irq_handler(int irq, void *data)
{
	struct fsa9480_usbsw *usbsw = data;
	struct i2c_client *client = usbsw->client;
	int intr;

	/* clear interrupt */
	fsa9480_read_irq(client, &intr);

	/* device detection */
	fsa9480_detect_dev(usbsw, intr);

	return IRQ_HANDLED;
}
Exemplo n.º 8
0
static irqreturn_t fsa9480_irq_thread(int irq, void *data)
{
    struct fsa9480_usbsw *usbsw = data;
    struct i2c_client *client = usbsw->client;
    int intr;
    int max_events = 100;
    int events_seen = 0;

    /*
     * the fsa could have queued up a few events if we haven't processed
     * them promptly
     */
    while (max_events-- > 0) {
        intr = i2c_smbus_read_word_data(client, FSA9480_REG_INT1);
        if (intr < 0)
            dev_err(&client->dev, "%s: err %d\n", __func__, intr);
        else if (intr == 0)
            break;
        else if (intr > 0)
            events_seen++;
    }
    if (!max_events)
        dev_warn(&client->dev, "too many events. fsa hosed?\n");

    if (!events_seen) {
        /*
         * interrupt was fired, but no status bits were set,
         * so device was reset. In this case, the registers were
         * reset to defaults so they need to be reinitialised.
         */
        fsa9480_reg_init(usbsw);
    }

    /*
     * fsa may take some time to update the dev_type reg after reading
     * the int reg.
     */
    usleep_range(200, 300);

    /* device detection */
    fsa9480_detect_dev(usbsw);

    return IRQ_HANDLED;
}
Exemplo n.º 9
0
static irqreturn_t fsa9480_irq_thread(int irq, void *data)
{
	struct fsa9480_usbsw *usbsw = data;
	struct i2c_client *client = usbsw->client;
	int intr;

	/* read and clear interrupt status bits */
	intr = i2c_smbus_read_word_data(client, FSA9480_REG_INT1);
	if (intr < 0) {
		dev_err(&client->dev, "%s: err %d\n", __func__, intr);
	} else if (intr == 0) {
		/* interrupt was fired, but no status bits were set,
		so device was reset. In this case, the registers were
		reset to defaults so they need to be reinitialised. */
		fsa9480_reg_init(usbsw);
	}

	/* device detection */
	fsa9480_detect_dev(usbsw);

	return IRQ_HANDLED;
}
Exemplo n.º 10
0
static int fsa9480_resume(struct i2c_client *client)
{
	struct fsa9480_usbsw *usbsw = i2c_get_clientdata(client);
	int dev1, dev2;

	if (device_may_wakeup(&client->dev) && client->irq)
		disable_irq_wake(client->irq);

	/*
	 * Clear Pending interrupt. Note that detect_dev does what
	 * the interrupt handler does. So, we don't miss pending and
	 * we reenable interrupt if there is one.
	 */
	fsa9480_read_reg(client, FSA9480_REG_INT1);
	fsa9480_read_reg(client, FSA9480_REG_INT2);

	dev1 = fsa9480_read_reg(client, FSA9480_REG_DEV_T1);
	dev2 = fsa9480_read_reg(client, FSA9480_REG_DEV_T2);

	/* device detection */
	fsa9480_detect_dev(usbsw, (dev1 || dev2) ? INT_ATTACH : INT_DETACH);

	return 0;
}
Exemplo n.º 11
0
static int __devinit fsa9480_probe(struct i2c_client *client,
                                   const struct i2c_device_id *id)
{
    struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
    struct fsa9480_usbsw *usbsw;
    int ret = 0;

    if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
        return -EIO;

    usbsw = kzalloc(sizeof(struct fsa9480_usbsw), GFP_KERNEL);
    if (!usbsw) {
        dev_err(&client->dev, "failed to allocate driver data\n");
        return -ENOMEM;
    }

    usbsw->client = client;
    usbsw->pdata = client->dev.platform_data;
    if (!usbsw->pdata)
        goto fail1;

    i2c_set_clientdata(client, usbsw);

    if (usbsw->pdata->cfg_gpio)
        usbsw->pdata->cfg_gpio();

    fsa9480_reg_init(usbsw);

    ret = fsa9480_irq_init(usbsw);
    if (ret)
        goto fail1;

    ret = sysfs_create_group(&client->dev.kobj, &fsa9480_group);
    if (ret) {
        dev_err(&client->dev,
                "failed to create fsa9480 attribute group\n");
        goto fail2;
    }

    if (usbsw->pdata->reset_cb)
        usbsw->pdata->reset_cb();

    /* device detection */
    fsa9480_detect_dev(usbsw);

#if defined(CONFIG_SAMSUNG_CAPTIVATE) || defined(CONFIG_SAMSUNG_FASCINATE)
    if (misc_register(&dockaudio_device))
        printk("%s misc_register(%s) failed\n", __FUNCTION__, dockaudio_device.name);
    else {
        if (sysfs_create_group(&dockaudio_device.this_device->kobj, &dockaudio_group) < 0)
            dev_err("failed to create sysfs group for device %s\n", dockaudio_device.name);
    }
#endif

    return 0;

fail2:
    if (client->irq)
        free_irq(client->irq, usbsw);
fail1:
    i2c_set_clientdata(client, NULL);
    kfree(usbsw);
    return ret;
}
Exemplo n.º 12
0
static void fsa9480_detect_dev(struct fsa9480_usbsw *usbsw)
{
	int device_type, ret;
	unsigned char val1, val2;
	struct fsa9480_platform_data *pdata = usbsw->pdata;
	struct i2c_client *client = usbsw->client;

#ifdef CONFIG_MACH_VICTORY
	adc_fsa  = i2c_smbus_read_word_data(client, FSA9480_REG_ADC);
	if (adc_fsa < 0)
		dev_err(&client->dev, "%s: err %d\n", __func__, adc_fsa);
	if ( adc_fsa == WIMAX_CABLE_50K){
		switch_set_state(&wimax_cable, USB_CABLE_50K);
	} else if (adc_fsa == WIMAX_CABLE_50K_DIS) {
		fsa9480_manual_switching(SWITCH_PORT_AUTO);
		switch_set_state(&wimax_cable, CABLE_DISCONNECT);
	} 
#endif
	device_type = i2c_smbus_read_word_data(client, FSA9480_REG_DEV_T1);
	if (device_type < 0)
		dev_err(&client->dev, "%s: err %d\n", __func__, device_type);

	val1 = device_type & 0xff;
	val2 = device_type >> 8;

	dev_info(&client->dev, "dev1: 0x%x, dev2: 0x%x\n", val1, val2);

	/* Attached */
	if (val1 || val2) {
		/* USB */
#ifdef CONFIG_MACH_VICTORY
		if (val1 & DEV_T1_USB_MASK){
#else		
			if (val1 & DEV_T1_USB_MASK || val2 & DEV_T2_USB_MASK ) {
#endif
			if (pdata->usb_cb)
				pdata->usb_cb(FSA9480_ATTACHED);

			micro_usb_status = 1;
#ifdef _SUPPORT_SAMSUNG_AUTOINSTALLER_
			askon_gadget_disconnect();
			if (!askon_status)
				UsbIndicator(1);
#else
				UsbIndicator(1);
#endif
			if (usbsw->mansw) {
				ret = i2c_smbus_write_byte_data(client,
					FSA9480_REG_MANSW1, usbsw->mansw);
				if (ret < 0)
					dev_err(&client->dev,
						"%s: err %d\n", __func__, ret);
			}
#ifdef CONFIG_MACH_VICTORY
		} else if ( val2 & DEV_T2_USB_MASK ) {
			if (pdata->wimax_cb)
				pdata->wimax_cb(FSA9480_ATTACHED);
				switch_set_state(&wimax_cable, USB_CABLE_255K);
#endif
		/* UART */
		} else if (val1 & DEV_T1_UART_MASK || val2 & DEV_T2_UART_MASK) {
			if(val2 & DEV_T2_UART_MASK)
				MicroJigUARTOffStatus = 1;

			if (pdata->uart_cb)
				pdata->uart_cb(FSA9480_ATTACHED);

			if (usbsw->mansw) {
				ret = i2c_smbus_write_byte_data(client,
					FSA9480_REG_MANSW1, SW_UART);
				if (ret < 0)
					dev_err(&client->dev,
						"%s: err %d\n", __func__, ret);
			}

			if (val2 & DEV_T2_JIG_MASK) {
				if (pdata->jig_cb)
					pdata->jig_cb(FSA9480_ATTACHED);
			}
		/* CHARGER */
		} else if (val1 & DEV_T1_CHARGER_MASK) {
			if (pdata->charger_cb)
				pdata->charger_cb(FSA9480_ATTACHED);
		/* JIG */
		} else if (val2 & DEV_T2_JIG_MASK) {
			if (pdata->jig_cb)
				pdata->jig_cb(FSA9480_ATTACHED);
		/* Desk Dock */
		} else if (val2 & DEV_AV) {
			if (pdata->deskdock_cb)
				pdata->deskdock_cb(FSA9480_ATTACHED);
				dock_status = 1;
			
			ret = i2c_smbus_write_byte_data(client,
					FSA9480_REG_MANSW1, SW_VAUDIO);
			if (ret < 0)
				dev_err(&client->dev,
					"%s: err %d\n", __func__, ret);

			ret = i2c_smbus_read_byte_data(client,
					FSA9480_REG_CTRL);
			if (ret < 0)
				dev_err(&client->dev,
					"%s: err %d\n", __func__, ret);

			ret = i2c_smbus_write_byte_data(client,
					FSA9480_REG_CTRL, ret & ~CON_MANUAL_SW);
			if (ret < 0)
				dev_err(&client->dev,
					"%s: err %d\n", __func__, ret);
		/* Car Dock */
		} else if (val2 & DEV_JIG_UART_ON) {
			if (pdata->cardock_cb)
				pdata->cardock_cb(FSA9480_ATTACHED);
			dock_status = 1;

                        ret = i2c_smbus_write_byte_data(client,
                                        FSA9480_REG_MANSW1, SW_VAUDIO);
                        if (ret < 0)
                                dev_err(&client->dev,
                                        "%s: err %d\n", __func__, ret);

                        ret = i2c_smbus_read_byte_data(client,
                                        FSA9480_REG_CTRL);
                        if (ret < 0)
                                dev_err(&client->dev,
                                        "%s: err %d\n", __func__, ret);

                        ret = i2c_smbus_write_byte_data(client,
                                FSA9480_REG_CTRL, ret & ~CON_MANUAL_SW);
                        if (ret < 0)
                                dev_err(&client->dev,
                                        "%s: err %d\n", __func__, ret);
		}
	/* Detached */
	} else {
		/* USB */
#ifdef CONFIG_MACH_VICTORY
		if (usbsw->dev1 & DEV_T1_USB_MASK){
#else		
		if (usbsw->dev1 & DEV_T1_USB_MASK ||
				usbsw->dev2 & DEV_T2_USB_MASK) {
#endif
			micro_usb_status = 0;
			UsbIndicator(0);
			if (pdata->usb_cb)
				pdata->usb_cb(FSA9480_DETACHED);
#ifdef CONFIG_MACH_VICTORY		
        	/* USB JIG */
		} else if (usbsw->dev2 & DEV_T2_USB_MASK) {
			if (pdata->wimax_cb)
				pdata->wimax_cb(FSA9480_DETACHED);
			switch_set_state(&wimax_cable, CABLE_DISCONNECT);
#endif
		/* UART */
		} else if (usbsw->dev1 & DEV_T1_UART_MASK ||
				usbsw->dev2 & DEV_T2_UART_MASK) {
			if(usbsw->dev2 & DEV_T2_UART_MASK)
				MicroJigUARTOffStatus = 0;

			if (pdata->uart_cb)
				pdata->uart_cb(FSA9480_DETACHED);
			if (usbsw->dev2 & DEV_T2_JIG_MASK) {
				if (pdata->jig_cb)
					pdata->jig_cb(FSA9480_DETACHED);
			}
		/* CHARGER */
		} else if (usbsw->dev1 & DEV_T1_CHARGER_MASK) {
			if (pdata->charger_cb)
				pdata->charger_cb(FSA9480_DETACHED);
		/* JIG */
		} else if (usbsw->dev2 & DEV_T2_JIG_MASK) {
			if (pdata->jig_cb)
				pdata->jig_cb(FSA9480_DETACHED);
		/* Desk Dock */
		} else if (usbsw->dev2 & DEV_AV) {
			if (pdata->deskdock_cb)
				pdata->deskdock_cb(FSA9480_DETACHED);
			dock_status = 0;
			
			ret = i2c_smbus_read_byte_data(client,FSA9480_REG_CTRL);
			if (ret < 0)
				dev_err(&client->dev,
					"%s: err %d\n", __func__, ret);

			ret = i2c_smbus_write_byte_data(client,
					FSA9480_REG_CTRL, ret | CON_MANUAL_SW);
			if (ret < 0)
				dev_err(&client->dev,
					"%s: err %d\n", __func__, ret);
		/* Car Dock */
		} else if (usbsw->dev2 & DEV_JIG_UART_ON) {
			if (pdata->cardock_cb)
				pdata->cardock_cb(FSA9480_DETACHED);
			dock_status = 0;

                        ret = i2c_smbus_read_byte_data(client,
                                        FSA9480_REG_CTRL);
                        if (ret < 0)
                                dev_err(&client->dev,
                                        "%s: err %d\n", __func__, ret);

                        ret = i2c_smbus_write_byte_data(client,
                                        FSA9480_REG_CTRL, ret | CON_MANUAL_SW);
                        if (ret < 0)
                                dev_err(&client->dev,
                                        "%s: err %d\n", __func__, ret);
		}
	}

	usbsw->dev1 = val1;
	usbsw->dev2 = val2;
}

static void fsa9480_reg_init(struct fsa9480_usbsw *usbsw)
{
	struct i2c_client *client = usbsw->client;
	unsigned int ctrl = CON_MASK;
	int ret;
#if defined (CONFIG_MACH_ATLAS) || defined (CONFIG_MACH_FORTE)
	/* mask interrupts (unmask attach/detach only) */
	ret = i2c_smbus_write_word_data(client, FSA9480_REG_INT1_MASK, 0x1ffc);
	if (ret < 0)
		dev_err(&client->dev, "%s: err %d\n", __func__, ret);
#elif CONFIG_MACH_VICTORY
	/* mask interrupts (unmask attach/detach only reserved attach only) */
	ret = i2c_smbus_write_word_data(client, FSA9480_REG_INT1_MASK, 0x1dfc);
	if (ret < 0)
		dev_err(&client->dev, "%s: err %d\n", __func__, ret);
#endif
	/* mask all car kit interrupts */
	ret = i2c_smbus_write_word_data(client, FSA9480_REG_CK_INTMASK1, 0x07ff);
	if (ret < 0)
		dev_err(&client->dev, "%s: err %d\n", __func__, ret);

	/* ADC Detect Time: 500ms */
	ret = i2c_smbus_write_byte_data(client, FSA9480_REG_TIMING1, 0x6);
	if (ret < 0)
		dev_err(&client->dev, "%s: err %d\n", __func__, ret);

	usbsw->mansw = i2c_smbus_read_byte_data(client, FSA9480_REG_MANSW1);
	if (usbsw->mansw < 0)
		dev_err(&client->dev, "%s: err %d\n", __func__, usbsw->mansw);

	if (usbsw->mansw)
		ctrl &= ~CON_MANUAL_SW;	/* Manual Switching Mode */

	ret = i2c_smbus_write_byte_data(client, FSA9480_REG_CTRL, ctrl);
	if (ret < 0)
		dev_err(&client->dev, "%s: err %d\n", __func__, ret);
}

static irqreturn_t fsa9480_irq_thread(int irq, void *data)
{
	struct fsa9480_usbsw *usbsw = data;
	struct i2c_client *client = usbsw->client;
	int intr;
	
	/* read and clear interrupt status bits */
	intr = i2c_smbus_read_word_data(client, FSA9480_REG_INT1);
	if (intr < 0) {
		dev_err(&client->dev, "%s: err %d\n", __func__, intr);
	} else if (intr == 0) {
		/* interrupt was fired, but no status bits were set,
		so device was reset. In this case, the registers were
		reset to defaults so they need to be reinitialised. */
		fsa9480_reg_init(usbsw);
	}

	/* device detection */
	fsa9480_detect_dev(usbsw);
	
	return IRQ_HANDLED;
}

static int fsa9480_irq_init(struct fsa9480_usbsw *usbsw)
{
	struct i2c_client *client = usbsw->client;
	int ret;

	if (client->irq) {
		ret = request_threaded_irq(client->irq, NULL,
			fsa9480_irq_thread, IRQF_TRIGGER_FALLING,
			"fsa9480 micro USB", usbsw);
		if (ret) {
			dev_err(&client->dev, "failed to reqeust IRQ\n");
			return ret;
		}

		ret = enable_irq_wake(client->irq);
		if (ret < 0)
			dev_err(&client->dev,
				"failed to enable wakeup src %d\n", ret);
	}

	return 0;
}

static int __devinit fsa9480_probe(struct i2c_client *client,
			 const struct i2c_device_id *id)
{
	struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
	struct fsa9480_usbsw *usbsw;
	int ret = 0;
#ifdef CONFIG_MACH_FORTE 
        s3c_gpio_cfgpin(GPIO_USB_SCL_28V, S3C_GPIO_OUTPUT);
        s3c_gpio_setpull(GPIO_USB_SCL_28V, S3C_GPIO_PULL_NONE);

        s3c_gpio_cfgpin(GPIO_USB_SDA_28V, S3C_GPIO_OUTPUT);
        s3c_gpio_setpull(GPIO_USB_SDA_28V, S3C_GPIO_PULL_NONE);
#endif

	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
		return -EIO;

	usbsw = kzalloc(sizeof(struct fsa9480_usbsw), GFP_KERNEL);
	if (!usbsw) {
		dev_err(&client->dev, "failed to allocate driver data\n");
		return -ENOMEM;
	}

	usbsw->client = client;
	usbsw->pdata = client->dev.platform_data;
	if (!usbsw->pdata)
		goto fail1;

	i2c_set_clientdata(client, usbsw);
	
	local_usbsw = usbsw;  // temp

	if (usbsw->pdata->cfg_gpio)
		usbsw->pdata->cfg_gpio();

	fsa9480_reg_init(usbsw);

	ret = fsa9480_irq_init(usbsw);
	if (ret)
		goto fail1;

	ret = sysfs_create_group(&client->dev.kobj, &fsa9480_group);
	if (ret) {
		dev_err(&client->dev,
				"failed to create fsa9480 attribute group\n");
		goto fail2;
	}

	if (usbsw->pdata->reset_cb)
		usbsw->pdata->reset_cb();

        indicator_dev.name = DRIVER_NAME;
#if 1
        indicator_dev.print_name = print_switch_name;
        indicator_dev.print_state = print_switch_state;
#endif
        switch_dev_register(&indicator_dev);

#if defined(CONFIG_MACH_VICTORY)
		ret = switch_dev_register(&wimax_cable);
		wimax_cable.print_state = wimax_cable_type; 
#endif

	/* device detection */
	fsa9480_detect_dev(usbsw);
	
	// set fsa9480 init flag.
	if (usbsw->pdata->set_init_flag)
		usbsw->pdata->set_init_flag();

	return 0;

fail2:
	if (client->irq)
		free_irq(client->irq, usbsw);
fail1:
	i2c_set_clientdata(client, NULL);
	kfree(usbsw);
	return ret;
}

static int __devexit fsa9480_remove(struct i2c_client *client)
{
	struct fsa9480_usbsw *usbsw = i2c_get_clientdata(client);

	if (client->irq) {
		disable_irq_wake(client->irq);
		free_irq(client->irq, usbsw);
	}
	i2c_set_clientdata(client, NULL);

	sysfs_remove_group(&client->dev.kobj, &fsa9480_group);
	kfree(usbsw);
	return 0;
}

#ifdef CONFIG_PM

static int fsa9480_suspend(struct i2c_client *client, pm_message_t mesg)
{
#ifdef CONFIG_MACH_VICTORY 
	disable_irq(client->irq	);
#endif
	return 0;
}

static int fsa9480_resume(struct i2c_client *client)
{
	struct fsa9480_usbsw *usbsw = i2c_get_clientdata(client);

#ifdef CONFIG_MACH_VICTORY
	enable_irq(client->irq);
#endif
	/* device detection */
	fsa9480_detect_dev(usbsw);

	return 0;
}

#else

#define fsa9480_suspend NULL
#define fsa9480_resume NULL

#endif /* CONFIG_PM */

static const struct i2c_device_id fsa9480_id[] = {
	{"fsa9480", 0},
	{}
};
MODULE_DEVICE_TABLE(i2c, fsa9480_id);

static struct i2c_driver fsa9480_i2c_driver = {
	.driver = {
		.name = "fsa9480",
	},
	.probe = fsa9480_probe,
	.remove = __devexit_p(fsa9480_remove),
	.suspend = fsa9480_suspend,
	.resume = fsa9480_resume,
	.id_table = fsa9480_id,
};
Exemplo n.º 13
0
static int __devinit fsa9480_probe(struct i2c_client *client,
                        const struct i2c_device_id *id)
{
	//struct regulator *regulator;
	struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
	struct fsa9480_platform_data *pdata = client->dev.platform_data;
	struct fsa9480_usbsw *usbsw;
	struct pm860x_vbus_info *vbus;
#if 0	// TODO: 
	struct pxa_vbus_info info;
#endif
	unsigned int data;
	int ret = 0;
	u8 devID;
	
	u8 intr, intr2, intr_chg;
	u8 mansw1;
	unsigned int ctrl = CTRL_MASK;

	printk("[FSA9480] PROBE ......\n");
	if (!i2c_check_functionality(adapter, I2C_FUNC_I2C))
		return -EIO;	   
	isProbe = 1;
	   
	//add for AT Command 
	//wake_lock_init(&JIGConnect_idle_wake, WAKE_LOCK_IDLE, "jig_connect_idle_wake");
	wake_lock_init(&JIGConnect_suspend_wake, WAKE_LOCK_SUSPEND, "jig_connect_suspend_wake");
	wake_lock_init(&mUSB_suspend_wake, WAKE_LOCK_SUSPEND, "mUSB_detect");

#ifdef CONFIG_KONA_PI_MGR
	ret=pi_mgr_qos_add_request(&qos_node, "fsa9480", PI_MGR_PI_ID_ARM_SUB_SYSTEM,
			       PI_MGR_QOS_DEFAULT_VALUE);
	if (ret)
	{
		pr_err("%s: failed to add fsa9480 to qos\n",__func__);
		return -1;
	}
#endif

	usbsw = kzalloc(sizeof(struct fsa9480_usbsw), GFP_KERNEL);
	if (!usbsw) {
		dev_err(&client->dev, "failed to allocate driver data\n");
		return -ENOMEM;
	}

	usbsw->client = client;
	usbsw->pdata = client->dev.platform_data;

	chip = usbsw;

	i2c_set_clientdata(client, usbsw);

#if defined (VBUS_DETECT) /* Init vbus for pxa(MARVELL) */
//	chip->pdata = pm860x_pdata->vbus;
	vbus = kzalloc(sizeof(struct pm860x_vbus_info), GFP_KERNEL);
	if (!vbus) {
		ret = -ENOMEM;
		goto out_mem;
	}
	dev_set_drvdata(&client->dev, vbus);
	
	vbus->res = kzalloc(sizeof(struct resource), GFP_KERNEL);
	if (!vbus->res) {
		ret = -ENOMEM;
		goto out_mem2;
	}
	vbus->res->start = pdata->vbus->reg_base;
	vbus->res->end = pdata ->vbus->reg_end;

	memset(&info,0,sizeof(struct pxa_vbus_info));
	info.dev = &client->dev;
	info.res = vbus->res;

	pxa_vbus_init(&info);

	data = VBUS_A_VALID | VBUS_A_SESSION_VALID | VBUS_B_SESSION_VALID | VBUS_B_SESSION_END | VBUS_ID;
	pxa_unmask_vbus(data);
#endif

#if defined(CONFIG_SPA)
	spa_external_event = spa_get_external_event_handler();
#elif defined(CONFIG_BATTERY_D2083)
	ret = d2083_register_enable_charge(TSU8111_Charger_Enable);
	if(ret < 0) {
		pr_err("%s. fail to register enable charge function\n", __func__);
		goto out_charger_enable;
	}
	ret = d2083_register_enable_back_charge(TSU8111_Charger_BackCHG_Enable);
	if(ret < 0) {
		pr_err("%s. fail to register enable charge function\n", __func__);
		goto out_charger_enable;
	}	
	ret = d2083_register_disable_charge(TSU8111_Charger_Disable);
	if(ret < 0) {
		pr_err("%s. fail to register disable charge function\n", __func__);
		goto out_charger_disable;
	}
	spa_external_event = d2083_get_external_event_handler();
#endif

	/* clear interrupt */
	fsa9480_read_reg(client, FSA9480_REG_INT1, &intr);

	fsa9480_read_reg(client, FSA9480_REG_DEVID, &devID);
	if(devID==0x0a || devID==0x5A)
		muic_type=muicTypeTI6111;
	else if(devID==0x00)
		muic_type=muicTypeFSA880;
	else
		muic_type=muicTypeFSA;

	if(muic_type==muicTypeFSA880)
	{
		intr &= 0xffff;
		/* set control register */
		fsa9480_write_reg(client, FSA9480_REG_CTRL, 0x04);
	}
	else if(muic_type==muicTypeTI6111)
	{
		intr &= 0xffff;

		/* clear interrupt */
		fsa9480_read_reg(client, FSA9480_REG_INT2, &intr2);
		fsa9480_read_reg(client, FSA9480_REG_CHG_INT, &intr_chg);

		/* unmask interrupt (attach/detach only) */
		ret = fsa9480_write_reg(client, FSA9480_REG_INT1_MASK, 0x00);
		if (ret < 0)
			return ret;

#if 0/*FSA9480's Interrupt Mask init setting*/
	   //ret = fsa9480_write_reg(client, FSA9480_REG_INT2_MASK, 0x00);
#endif
		/*TI USB : not to get Connect Interrupt : no more double interrupt*/
		ret = fsa9480_write_reg(client, FSA9480_REG_INT1_MASK, 0x40);
		if (ret < 0)
			return ret;

		ret = fsa9480_write_reg(client, FSA9480_REG_INT2_MASK, 0x20);
		if (ret < 0)
			return ret;

		ret = fsa9480_write_reg(client, FSA9480_REG_CHG_INT_MASK, 0xc0);
		if (ret < 0)
			return ret;


	   fsa9480_read_reg(client, FSA9480_REG_MANSW1, &mansw1);
	   usbsw->mansw = mansw1;

		ctrl &= ~INT_MASK;			  /* Unmask Interrupt */
		if (usbsw->mansw)
			ctrl &= ~MANUAL_SWITCH; /* Manual Switching Mode */
	   
		fsa9480_write_reg(client, FSA9480_REG_CTRL, ctrl);
	}
	else
	   printk("[FSA9480] Error!!!! No Type. Check dev ID(0x01 addr) ......\n");

   ret = fsa9480_irq_init(usbsw);
   if (ret)
           goto fsa9480_probe_fail;

   ret = sysfs_create_group(&client->dev.kobj, &fsa9480_group);
   if (ret) {
           dev_err(&client->dev,
                           "[FSA9480] Creating fsa9480 attribute group failed");
           goto fsa9480_probe_fail2;
   }

	/* device detection */
	fsa9480_detect_dev(usbsw, 1);
	isProbe = 0;
	tsu8111_check_ovp();

	/*reset UIC*/
	if(muic_type==muicTypeFSA880)
		fsa9480_write_reg(client, FSA9480_REG_CTRL, 0x04);
	else
	{
		fsa9480_write_reg(client, FSA9480_REG_CTRL, 0x1E);
		/*set timing1 to 100ms*/
//		fsa9480_write_reg(client, FSA9480_REG_TIMING1, 0x1);
	}	   

#ifdef CONFIG_KONA_PI_MGR
	//ret=pi_mgr_qos_request_update(&qos_node, 0);
	//if (ret)
	//{
	//	pr_err("%s: failed to request update qos_node\n",__func__);
	//}
#endif


       printk("[FSA9480] PROBE Done.\n");
       return 0;

out_mem:
	return ret;
#if defined(CONFIG_BATTERY_D2083)
out_charger_enable:
out_charger_disable:
#endif /* CONFIG_BATTERY_D2083 */
out_mem2:
	kfree(vbus);
fsa9480_probe_fail2:
   if (client->irq)
       free_irq(client->irq, NULL);
fsa9480_probe_fail:
	i2c_set_clientdata(client, NULL);
	kfree(usbsw);
	return ret;
}
Exemplo n.º 14
0
static void fsa9480_work_cb(struct work_struct *work)
{
	u8 intr, intr2, intr3;
	struct fsa9480_usbsw *usbsw = container_of(work, struct fsa9480_usbsw, work);
	struct i2c_client *client = usbsw->client;

	wake_lock_timeout(&mUSB_suspend_wake,1*HZ);
	
       /* clear interrupt */
	if(muic_type==muicTypeTI6111)
	{
		msleep(200);
	
		fsa9480_read_reg(client, FSA9480_REG_INT1, &intr);
		fsa9480_read_reg(client, FSA9480_REG_INT2, &intr2);	
		fsa9480_read_reg(client, FSA9480_REG_CHG_INT, &intr3);
		printk("[FSA9480] %s: intr=0x%x, intr2 = 0x%X, chg_intr=0x%x \n",__func__,intr,intr2, intr3);


	}
	else
	{
		fsa9480_read_reg(client, FSA9480_REG_INT1, &intr);
		fsa9480_read_reg(client, FSA9480_REG_INT2, &intr2);	
		printk("[FSA9480] %s: intr=0x%x, intr2=0x%x \n",__func__,intr,intr2);
	}

	if(intr3 & CH_DONE) //EOC disable charger // Luke 
	{
		//msleep(500);	 // Test only

		//fsa9480_read_reg(client, FSA9480_REG_DEV_T1, &val1);
		//if(val1&=DEV_VBUS) // Check if VBUS is valid //Luke
		//{
#if defined(CONFIG_BATTERY_D2083)
			if(spa_external_event)
			{
				pr_info("%s. Send D2083_EVENT_CHARGE_FULL event\n", __func__);
				spa_external_event(D2083_CATEGORY_BATTERY, D2083_EVENT_CHARGE_FULL);
			}
		//}
#endif
	}

	intr &= 0xffff;

	/* device detection */
	fsa9480_detect_dev(usbsw, intr);

	if((intr== 0x00) && (intr3 == 0))
	{	
		printk("[FSA9480] (intr== 0x00) in work_cb !!!!!\n");
		fsa9480_read_adc_value();
		#if 0	// TODO: 
		if(muic_type==muicTypeTI6111)
			TI_SWreset(usbsw);
		#endif
		
		return;
	}

	if(!(intr3 & CH_DONE))
		tsu8111_check_ovp();
	
	if( intr==0x03) // INT error case
		fsa9480_reset_ic();
	
}