Added missing tegra files.HEADmaster

1 files changed, 340 insertions, 0 deletions

diff --git a/drivers/misc/tegra-baseband/bb-m7400.c b/drivers/misc/tegra-baseband/bb-m7400.c
new file mode 100644
index 00000000000..5808a6e321c
--- /dev/null
+++ b/drivers/misc/tegra-baseband/bb-m7400.c
@@ -0,0 +1,340 @@
+/*
+ * drivers/misc/tegra-baseband/bb-m7400.c
+ *
+ * Copyright (c) 2011, NVIDIA Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+#include <linux/resource.h>
+#include <linux/platform_device.h>
+#include <linux/delay.h>
+#include <linux/gpio.h>
+#include <linux/interrupt.h>
+#include <linux/irq.h>
+#include <linux/err.h>
+#include <linux/device.h>
+#include <linux/usb.h>
+#include <linux/wakelock.h>
+#include <asm/mach-types.h>
+#include <asm/mach/arch.h>
+#include <mach/tegra-bb-power.h>
+#include <mach/usb_phy.h>
+#include "bb-power.h"
+
+static struct tegra_bb_gpio_data m7400_gpios[] = {
+        { { GPIO_INVALID, GPIOF_OUT_INIT_LOW, "MDM_PWR_ON" }, true },
+        { { GPIO_INVALID, GPIOF_IN, "MDM_PWRSTATUS" }, true },
+        { { GPIO_INVALID, GPIOF_OUT_INIT_HIGH, "MDM_SERVICE" }, true },
+        { { GPIO_INVALID, GPIOF_OUT_INIT_LOW, "MDM_USB_AWR" }, false },
+        { { GPIO_INVALID, GPIOF_IN, "MDM_USB_CWR" }, false },
+        { { GPIO_INVALID, GPIOF_IN, "MDM_RESOUT2" }, true },
+        { { GPIO_INVALID, GPIOF_OUT_INIT_LOW, "MDM_USB_ARR" }, false },
+        { { GPIO_INVALID, 0, NULL }, false },   /* End of table */
+};
+static bool ehci_registered;
+static int modem_status;
+static int gpio_awr;
+static int gpio_cwr;
+static int gpio_arr;
+static struct usb_device *m7400_usb_device;
+
+static int gpio_wait_timeout(int gpio, int value, int timeout_msec)
+{
+        int count;
+        for (count = 0; count < timeout_msec; ++count) {
+                if (gpio_get_value(gpio) == value)
+                        return 0;
+                mdelay(1);
+        }
+        return -1;
+}
+
+static int m7400_enum_handshake(void)
+{
+        int retval = 0;
+
+        /* Wait for CP to indicate ready - by driving CWR high. */
+        if (gpio_wait_timeout(gpio_cwr, 1, 10) != 0) {
+                        pr_info("%s: Error: timeout waiting for modem resume.\n",
+                                                        __func__);
+                        retval = -1;
+        }
+
+        /* Signal AP ready - Drive AWR and ARR high. */
+        gpio_set_value(gpio_awr, 1);
+        gpio_set_value(gpio_arr, 1);
+
+        return retval;
+}
+
+static int m7400_apup_handshake(bool checkresponse)
+{
+        int retval = 0;
+
+        /* Signal AP ready - Drive AWR and ARR high. */
+        gpio_set_value(gpio_awr, 1);
+        gpio_set_value(gpio_arr, 1);
+
+        if (checkresponse) {
+                /* Wait for CP ack - by driving CWR high. */
+                if (gpio_wait_timeout(gpio_cwr, 1, 10) != 0) {
+                        pr_info("%s: Error: timeout waiting for modem ack.\n",
+                                                        __func__);
+                        retval = -1;
+                }
+        }
+        return retval;
+}
+
+static void m7400_apdown_handshake(void)
+{
+        /* Signal AP going down to modem - Drive AWR low. */
+        /* No need to wait for a CP response */
+        gpio_set_value(gpio_awr, 0);
+}
+
+static int m7400_l2_suspend(void)
+{
+        /* Gets called for two cases :
+                a) Port suspend.
+                b) Bus suspend. */
+        if (modem_status == BBSTATE_L2)
+                return 0;
+
+        /* Post bus suspend: Drive ARR low. */
+        gpio_set_value(gpio_arr, 0);
+        modem_status = BBSTATE_L2;
+        return 0;
+}
+
+static int m7400_l2_resume(void)
+{
+        /* Gets called for two cases :
+                a) L2 resume.
+                b) bus resume phase of L3 resume. */
+        if (modem_status == BBSTATE_L0)
+                return 0;
+
+        /* Pre bus resume: Drive ARR high. */
+        gpio_set_value(gpio_arr, 1);
+
+        /* If host initiated resume - Wait for CP ack (CWR goes high). */
+        /* If device initiated resume - CWR will be already high. */
+        if (gpio_wait_timeout(gpio_cwr, 1, 10) != 0) {
+                pr_info("%s: Error: timeout waiting for modem ack.\n",
+                                                __func__);
+                return -1;
+        }
+        modem_status = BBSTATE_L0;
+        return 0;
+}
+
+static void m7400_l3_suspend(void)
+{
+        m7400_apdown_handshake();
+        modem_status = BBSTATE_L3;
+}
+
+static void m7400_l3_resume(void)
+{
+        m7400_apup_handshake(true);
+        modem_status = BBSTATE_L0;
+}
+
+static irqreturn_t m7400_wake_irq(int irq, void *dev_id)
+{
+        struct usb_interface *intf;
+
+        switch (modem_status) {
+        case BBSTATE_L2:
+                /* Resume usb host activity. */
+                if (m7400_usb_device) {
+                        usb_lock_device(m7400_usb_device);
+                        intf = usb_ifnum_to_if(m7400_usb_device, 0);
+                        usb_autopm_get_interface(intf);
+                        usb_autopm_put_interface(intf);
+                        usb_unlock_device(m7400_usb_device);
+                }
+                break;
+        default:
+                break;
+        }
+
+        return IRQ_HANDLED;
+}
+
+static int m7400_power(int code)
+{
+        switch (code) {
+        case PWRSTATE_L2L3:
+        m7400_l3_suspend();
+        break;
+        case PWRSTATE_L3L0:
+        m7400_l3_resume();
+        break;
+        default:
+        break;
+        }
+        return 0;
+}
+
+static void m7400_ehci_customize(struct platform_device *pdev)
+{
+        struct tegra_ehci_platform_data *ehci_pdata;
+        struct tegra_uhsic_config *hsic_config;
+
+        ehci_pdata = (struct tegra_ehci_platform_data *)
+                        pdev->dev.platform_data;
+        hsic_config = (struct tegra_uhsic_config *)
+                        ehci_pdata->phy_config;
+
+        /* Register PHY callbacks */
+        hsic_config->postsuspend = m7400_l2_suspend;
+        hsic_config->preresume = m7400_l2_resume;
+
+        /* Override required settings */
+        ehci_pdata->power_down_on_bus_suspend = 0;
+}
+
+static int m7400_attrib_write(struct device *dev, int value)
+{
+        struct tegra_bb_pdata *pdata;
+        static struct platform_device *ehci_device;
+        static bool first_enum = true;
+
+        if (value > 1 || (!ehci_registered && !value)) {
+                /* Supported values are 0/1. */
+                return -1;
+        }
+
+        pdata = (struct tegra_bb_pdata *) dev->platform_data;
+        if (value) {
+
+                /* Check readiness for enumeration */
+                if (first_enum)
+                        first_enum = false;
+                else
+                        m7400_enum_handshake();
+
+                /* Register ehci controller */
+                ehci_device = pdata->ehci_register();
+                if (ehci_device == NULL) {
+                        pr_info("%s - Error: ehci register failed.\n",
+                                                         __func__);
+                        return -1;
+                }
+
+                /* Customize PHY setup/callbacks */
+                m7400_ehci_customize(ehci_device);
+
+                ehci_registered = true;
+        } else {
+                /* Unregister ehci controller */
+                if (ehci_device != NULL)
+                        pdata->ehci_unregister(ehci_device);
+
+                /* Signal AP going down */
+                m7400_apdown_handshake();
+                ehci_registered = false;
+        }
+
+        return 0;
+}
+
+static int m7400_registered(struct usb_device *udev)
+{
+        m7400_usb_device = udev;
+        modem_status = BBSTATE_L0;
+        return 0;
+}
+
+static struct tegra_bb_gpio_irqdata m7400_gpioirqs[] = {
+        { GPIO_INVALID, "tegra_bb_wake", m7400_wake_irq,
+                                IRQF_TRIGGER_RISING, true, NULL },
+        { GPIO_INVALID, NULL, NULL, 0, NULL },  /* End of table */
+};
+
+static struct tegra_bb_power_gdata m7400_gdata = {
+        .gpio = m7400_gpios,
+        .gpioirq = m7400_gpioirqs,
+};
+
+static struct tegra_bb_power_mdata m7400_mdata = {
+        .vid = 0x04cc,
+        .pid = 0x230f,
+        .wake_capable = true,
+        .autosuspend_ready = true,
+        .reg_cb = m7400_registered,
+};
+
+static struct tegra_bb_power_data m7400_data = {
+        .gpio_data = &m7400_gdata,
+        .modem_data = &m7400_mdata,
+};
+
+static void *m7400_init(void *pdata)
+{
+        struct tegra_bb_pdata *platdata = (struct tegra_bb_pdata *) pdata;
+        union tegra_bb_gpio_id *id = platdata->id;
+
+        /* Fill the gpio ids allocated by hardware */
+        m7400_gpios[0].data.gpio = id->m7400.pwr_on;
+        m7400_gpios[1].data.gpio = id->m7400.pwr_status;
+        m7400_gpios[2].data.gpio = id->m7400.service;
+        m7400_gpios[3].data.gpio = id->m7400.usb_awr;
+        m7400_gpios[4].data.gpio = id->m7400.usb_cwr;
+        m7400_gpios[5].data.gpio = id->m7400.resout2;
+        m7400_gpios[6].data.gpio = id->m7400.uart_awr;
+        m7400_gpioirqs[0].id = id->m7400.usb_cwr;
+
+        if (!platdata->ehci_register || !platdata->ehci_unregister) {
+                pr_info("%s - Error: ehci reg/unreg functions missing.\n"
+                                                        , __func__);
+                return 0;
+        }
+
+        gpio_awr = m7400_gpios[3].data.gpio;
+        gpio_cwr = m7400_gpios[4].data.gpio;
+        gpio_arr = m7400_gpios[6].data.gpio;
+        if (gpio_awr == GPIO_INVALID || gpio_cwr == GPIO_INVALID
+                        || gpio_arr == GPIO_INVALID) {
+                pr_info("%s - Error: Invalid gpio data.\n", __func__);
+                return 0;
+        }
+
+        ehci_registered = false;
+        modem_status = BBSTATE_UNKNOWN;
+        return (void *) &m7400_data;
+}
+
+static void *m7400_deinit(void)
+{
+        return (void *) &m7400_data;
+}
+
+static struct tegra_bb_callback m7400_callbacks = {
+        .init = m7400_init,
+        .deinit = m7400_deinit,
+        .attrib = m7400_attrib_write,
+#ifdef CONFIG_PM
+        .power = m7400_power,
+#endif
+};
+
+void *m7400_get_cblist(void)
+{
+        return (void *) &m7400_callbacks;
+}