ARM: tegra: xusb: read usb_calib once in common file
[linux-3.10.git] / drivers / usb / host / xhci-tegra.c
1 /*
2  * xhci-tegra.c - Nvidia xHCI host controller driver
3  *
4  * Copyright (c) 2013, NVIDIA CORPORATION.  All rights reserved.
5  *
6  * This program is free software; you can redistribute it and/or modify it
7  * under the terms and conditions of the GNU General Public License,
8  * version 2, as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope it will be useful, but WITHOUT
11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
13  * more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
17  */
18
19 #include <linux/clk.h>
20 #include <linux/platform_device.h>
21 #include <linux/module.h>
22 #include <linux/slab.h>
23 #include <linux/clk.h>
24 #include <linux/ioport.h>
25 #include <linux/dma-mapping.h>
26 #include <linux/irq.h>
27 #include <linux/regulator/consumer.h>
28 #include <linux/platform_data/tegra_xusb.h>
29 #include <linux/platform_data/tegra_usb.h>
30 #include <linux/uaccess.h>
31
32 #include <mach/powergate.h>
33 #include <mach/clk.h>
34 #include <mach/tegra_usb_pad_ctrl.h>
35 #include <mach/tegra_usb_pmc.h>
36 #include <mach/pm_domains.h>
37 #include <mach/mc.h>
38 #include <mach/xusb.h>
39
40 #include "../../../arch/arm/mach-tegra/iomap.h" /* HACK -- remove */
41 #include "xhci-tegra.h"
42 #include "xhci.h"
43
44 /* macros */
45 #define PAGE_SELECT_MASK                        0xFFFFFE00
46 #define PAGE_SELECT_SHIFT                       9
47 #define PAGE_OFFSET_MASK                        0x000001FF
48 #define CSB_PAGE_SELECT(_addr)                                          \
49         ({                                                              \
50                 typecheck(u32, _addr);                                  \
51                 ((_addr & PAGE_SELECT_MASK) >> PAGE_SELECT_SHIFT);      \
52         })
53 #define CSB_PAGE_OFFSET(_addr)                                          \
54         ({                                                              \
55                 typecheck(u32, _addr);                                  \
56                 (_addr & PAGE_OFFSET_MASK);                             \
57         })
58
59 /* PMC register definition */
60 #define PMC_PORT_UTMIP_P0               0
61 #define PMC_PORT_UTMIP_P1               1
62 #define PMC_PORT_UTMIP_P2               2
63 #define PMC_PORT_UHSIC_P0               3
64 #define PMC_PORT_NUM                    4
65
66 #define PMC_USB_DEBOUNCE_DEL_0                  0xec
67 #define   UTMIP_LINE_DEB_CNT(x)         (((x) & 0xf) << 16)
68 #define   UTMIP_LINE_DEB_CNT_MASK               (0xf << 16)
69
70 #define PMC_UTMIP_UHSIC_SLEEP_CFG_0             0x1fc
71
72 /* private data types */
73 /* command requests from the firmware */
74 enum MBOX_CMD_TYPE {
75         MBOX_CMD_MSG_ENABLED = 1,
76         MBOX_CMD_INC_FALC_CLOCK,
77         MBOX_CMD_DEC_FALC_CLOCK,
78         MBOX_CMD_INC_SSPI_CLOCK,
79         MBOX_CMD_DEC_SSPI_CLOCK, /* 5 */
80         MBOX_CMD_SET_BW,
81         MBOX_CMD_SET_SS_PWR_GATING,
82         MBOX_CMD_SET_SS_PWR_UNGATING, /* 8 */
83         MBOX_CMD_SAVE_DFE_CTLE_CTX,
84
85         /* needs to be the last cmd */
86         MBOX_CMD_MAX,
87
88         /* resp msg to ack above commands */
89         MBOX_CMD_ACK = 128,
90         MBOX_CMD_NACK
91 };
92
93 /* Usb3 Firmware Cfg Table */
94 struct cfgtbl {
95         u32 boot_loadaddr_in_imem;
96         u32 boot_codedfi_offset;
97         u32 boot_codetag;
98         u32 boot_codesize;
99
100         /* Physical memory reserved by Bootloader/BIOS */
101         u32 phys_memaddr;
102         u16 reqphys_memsize;
103         u16 alloc_phys_memsize;
104
105         /* .rodata section */
106         u32 rodata_img_offset;
107         u32 rodata_section_start;
108         u32 rodata_section_end;
109         u32 main_fnaddr;
110
111         u32 fwimg_cksum;
112         u32 fwimg_created_time;
113
114         /* Fields that get filled by linker during linking phase
115          * or initialized in the FW code.
116          */
117         u32 imem_resident_start;
118         u32 imem_resident_end;
119         u32 idirect_start;
120         u32 idirect_end;
121         u32 l2_imem_start;
122         u32 l2_imem_end;
123         u32 version_id;
124         u8 init_ddirect;
125         u8 reserved[3];
126         u32 phys_addr_log_buffer;
127         u32 total_log_entries;
128         u32 dequeue_ptr;
129
130         /*      Below two dummy variables are used to replace
131          *      L2IMemSymTabOffsetInDFI and L2IMemSymTabSize in order to
132          *      retain the size of struct _CFG_TBL used by other AP/Module.
133          */
134         u32 dummy_var1;
135         u32 dummy_var2;
136
137         /* fwimg_len */
138         u32 fwimg_len;
139         u8 magic[8];
140         u32 SS_low_power_entry_timeout;
141         u8 padding[140]; /* padding bytes to makeup 256-bytes cfgtbl */
142 };
143
144 struct xusb_save_regs {
145         u32 msi_bar_sz;
146         u32 msi_axi_barst;
147         u32 msi_fpci_barst;
148         u32 msi_vec0;
149         u32 msi_en_vec0;
150         u32 fpci_error_masks;
151         u32 intr_mask;
152         u32 ipfs_intr_enable;
153         u32 ufpci_config;
154         u32 clkgate_hysteresis;
155         u32 xusb_host_mccif_fifo_cntrl;
156
157         /* PG does not mention below */
158         u32 hs_pls;
159         u32 fs_pls;
160         u32 hs_fs_speed;
161         u32 hs_fs_pp;
162         u32 cfg_aru;
163         u32 cfg_order;
164         u32 cfg_fladj;
165         u32 cfg_sid;
166         /* DFE and CTLE */
167         u32 tap1_val0;
168         u32 tap1_val1;
169         u32 amp_val0;
170         u32 amp_val1;
171         u32 ctle_z_val0;
172         u32 ctle_z_val1;
173         u32 ctle_g_val0;
174         u32 ctle_g_val1;
175 };
176
177 struct tegra_xhci_firmware {
178         void *data; /* kernel virtual address */
179         size_t size; /* firmware size */
180         dma_addr_t dma; /* dma address for controller */
181 };
182
183 struct tegra_xhci_hcd {
184         struct platform_device *pdev;
185         struct xhci_hcd *xhci;
186
187         spinlock_t lock;
188         struct mutex sync_lock;
189
190         int smi_irq;
191         int padctl_irq;
192         int usb3_irq;
193
194         bool ss_wake_event;
195         bool ss_pwr_gated;
196         bool host_pwr_gated;
197         bool hs_wake_event;
198         bool host_resume_req;
199         bool lp0_exit;
200         bool dfe_ctle_ctx_saved;
201         unsigned long last_jiffies;
202         unsigned long host_phy_base;
203         void __iomem *host_phy_virt_base;
204
205         void __iomem *pmc_base;
206         void __iomem *padctl_base;
207         void __iomem *fpci_base;
208         void __iomem *ipfs_base;
209
210         struct tegra_xusb_platform_data *pdata;
211         struct tegra_xusb_board_data *bdata;
212         struct tegra_xusb_pad_data *xusb_padctl;
213
214         /* mailbox variables */
215         struct mutex mbox_lock;
216         u32 mbox_owner;
217         u32 cmd_type;
218         u32 cmd_data;
219
220         struct regulator *xusb_vbus_reg;
221         struct regulator *xusb_avddio_usb3_reg;
222         struct regulator *xusb_hvdd_usb3_reg;
223         struct regulator *xusb_avdd_usb3_pll_reg;
224
225         struct work_struct mbox_work;
226         struct work_struct ss_elpg_exit_work;
227         struct work_struct host_elpg_exit_work;
228
229         struct clk *host_clk;
230         struct clk *ss_clk;
231
232         /* XUSB Falcon SuperSpeed Clock */
233         struct clk *falc_clk;
234
235         /* EMC Clock */
236         struct clk *emc_clk;
237         /* XUSB SS PI Clock */
238         struct clk *ss_src_clk;
239         /* PLLE Clock */
240         struct clk *plle_clk;
241         struct clk *pll_u_480M;
242         struct clk *clk_m;
243         /* refPLLE clk */
244         struct clk *pll_re_vco_clk;
245         /*
246          * XUSB/IPFS specific registers these need to be saved/restored in
247          * addition to spec defined registers
248          */
249         struct xusb_save_regs sregs;
250         bool usb2_rh_suspend;
251         bool usb3_rh_suspend;
252         bool hc_in_elpg;
253
254         unsigned long usb3_rh_remote_wakeup_ports; /* one bit per port */
255         /* firmware loading related */
256         struct tegra_xhci_firmware firmware;
257 };
258
259 static struct tegra_usb_pmc_data pmc_data;
260
261 /* functions */
262 static inline struct tegra_xhci_hcd *hcd_to_tegra_xhci(struct usb_hcd *hcd)
263 {
264         return (struct tegra_xhci_hcd *) dev_get_drvdata(hcd->self.controller);
265 }
266
267 #if defined(CONFIG_DEBUG_MUTEXES) || defined(CONFIG_SMP)
268 static inline void must_have_sync_lock(struct tegra_xhci_hcd *tegra)
269 {
270         WARN_ON(tegra->sync_lock.owner != current);
271 }
272 #else
273 static inline void must_have_sync_lock(struct tegra_xhci_hcd *tegra)
274 #endif
275
276 static void debug_print_portsc(struct xhci_hcd *xhci)
277 {
278         __le32 __iomem *addr;
279         int i;
280         int ports;
281
282         ports = HCS_MAX_PORTS(xhci->hcs_params1);
283         addr = &xhci->op_regs->port_status_base;
284         for (i = 0; i < ports; i++) {
285                 xhci_dbg(xhci, "%p port %d status reg = 0x%x\n",
286                                 addr, i, (unsigned int) xhci_readl(xhci, addr));
287                 addr += NUM_PORT_REGS;
288         }
289 }
290
291 static void pmc_init(void)
292 {
293 /* TODO: update to include HSIC */
294         pmc_data.instance = PMC_PORT_UTMIP_P2;
295         pmc_data.controller_type = TEGRA_USB_3_0;
296         pmc_data.phy_type = TEGRA_USB_PHY_INTF_UTMI;
297         tegra_usb_pmc_init(&pmc_data);
298 }
299
300 u32 csb_read(struct tegra_xhci_hcd *tegra, u32 addr)
301 {
302         void __iomem *fpci_base = tegra->fpci_base;
303         struct platform_device *pdev = tegra->pdev;
304         u32 input_addr;
305         u32 data;
306         u32 csb_page_select;
307
308         /* to select the appropriate CSB page to write to */
309         csb_page_select = CSB_PAGE_SELECT(addr);
310
311         dev_dbg(&pdev->dev, "csb_read: csb_page_select= 0x%08x\n",
312                         csb_page_select);
313
314         iowrite32(csb_page_select, fpci_base + XUSB_CFG_ARU_C11_CSBRANGE);
315
316         /* selects the appropriate offset in the page to read from */
317         input_addr = CSB_PAGE_OFFSET(addr);
318         data = ioread32(fpci_base + XUSB_CFG_CSB_BASE_ADDR + input_addr);
319
320         dev_dbg(&pdev->dev, "csb_read: input_addr = 0x%08x data = 0x%08x\n",
321                         input_addr, data);
322         return data;
323 }
324
325 void csb_write(struct tegra_xhci_hcd *tegra, u32 addr, u32 data)
326 {
327         void __iomem *fpci_base = tegra->fpci_base;
328         struct platform_device *pdev = tegra->pdev;
329         u32 input_addr;
330         u32 csb_page_select;
331
332         /* to select the appropriate CSB page to write to */
333         csb_page_select = CSB_PAGE_SELECT(addr);
334
335         dev_dbg(&pdev->dev, "csb_write:csb_page_selectx = 0x%08x\n",
336                         csb_page_select);
337
338         iowrite32(csb_page_select, fpci_base + XUSB_CFG_ARU_C11_CSBRANGE);
339
340         /* selects the appropriate offset in the page to write to */
341         input_addr = CSB_PAGE_OFFSET(addr);
342         iowrite32(data, fpci_base + XUSB_CFG_CSB_BASE_ADDR + input_addr);
343
344         dev_dbg(&pdev->dev, "csb_write: input_addr = 0x%08x data = %0x08x\n",
345                         input_addr, data);
346 }
347
348 static void tegra_xhci_debug_read_pads(struct tegra_xhci_hcd *tegra)
349 {
350         struct xhci_hcd *xhci = tegra->xhci;
351         u32 reg;
352
353         xhci_info(xhci, "============ PADCTL VALUES START =================\n");
354         reg = readl(tegra->padctl_base + USB2_PAD_MUX_0);
355         xhci_info(xhci, " PAD MUX = %x\n", reg);
356         reg = readl(tegra->padctl_base + USB2_PORT_CAP_0);
357         xhci_info(xhci, " PORT CAP = %x\n", reg);
358         reg = readl(tegra->padctl_base + SNPS_OC_MAP_0);
359         xhci_info(xhci, " SNPS OC MAP = %x\n", reg);
360         reg = readl(tegra->padctl_base + USB2_OC_MAP_0);
361         xhci_info(xhci, " USB2 OC MAP = %x\n", reg);
362         reg = readl(tegra->padctl_base + SS_PORT_MAP_0);
363         xhci_info(xhci, " SS PORT MAP = %x\n", reg);
364         reg = readl(tegra->padctl_base + OC_DET_0);
365         xhci_info(xhci, " OC DET 0= %x\n", reg);
366         reg = readl(tegra->padctl_base + IOPHY_USB3_PAD0_CTL_2_0);
367         xhci_info(xhci, " IOPHY_USB3_PAD0_CTL_2_0= %x\n", reg);
368         reg = readl(tegra->padctl_base + IOPHY_USB3_PAD1_CTL_2_0);
369         xhci_info(xhci, " IOPHY_USB3_PAD1_CTL_2_0= %x\n", reg);
370         reg = readl(tegra->padctl_base + USB2_OTG_PAD0_CTL_0_0);
371         xhci_info(xhci, " USB2_OTG_PAD0_CTL_0_0= %x\n", reg);
372         reg = readl(tegra->padctl_base + USB2_OTG_PAD1_CTL_0_0);
373         xhci_info(xhci, " USB2_OTG_PAD1_CTL_0_0= %x\n", reg);
374         reg = readl(tegra->padctl_base + USB2_OTG_PAD0_CTL_1_0);
375         xhci_info(xhci, " USB2_OTG_PAD0_CTL_1_0= %x\n", reg);
376         reg = readl(tegra->padctl_base + USB2_OTG_PAD1_CTL_1_0);
377         xhci_info(xhci, " USB2_OTG_PAD1_CTL_1_0= %x\n", reg);
378         reg = readl(tegra->padctl_base + USB2_BIAS_PAD_CTL_0_0);
379         xhci_info(xhci, " USB2_BIAS_PAD_CTL_0_0= %x\n", reg);
380         reg = readl(tegra->padctl_base + HSIC_PAD0_CTL_0_0);
381         xhci_info(xhci, " HSIC_PAD0_CTL_0_0= %x\n", reg);
382         reg = readl(tegra->padctl_base + HSIC_PAD1_CTL_0_0);
383         xhci_info(xhci, " HSIC_PAD1_CTL_0_0= %x\n", reg);
384         xhci_info(xhci, "============ PADCTL VALUES END=================\n");
385 }
386
387 static void tegra_xhci_cfg(struct tegra_xhci_hcd *tegra)
388 {
389         u32 reg;
390
391         reg = readl(tegra->ipfs_base + IPFS_XUSB_HOST_CONFIGURATION_0);
392         reg |= IPFS_EN_FPCI;
393         writel(reg, tegra->ipfs_base + IPFS_XUSB_HOST_CONFIGURATION_0);
394         udelay(10);
395
396         /* Program Bar0 Space */
397         reg = readl(tegra->fpci_base + XUSB_CFG_4);
398         reg |= tegra->host_phy_base;
399         writel(reg, tegra->fpci_base + XUSB_CFG_4);
400         usleep_range(100, 200);
401
402         /* Enable Bus Master */
403         reg = readl(tegra->fpci_base + XUSB_CFG_1);
404         reg |= 0x7;
405         writel(reg, tegra->fpci_base + XUSB_CFG_1);
406
407         /* Set intr mask to enable intr assertion */
408         reg = readl(tegra->ipfs_base + IPFS_XUSB_HOST_INTR_MASK_0);
409         reg |= IPFS_IP_INT_MASK;
410         writel(reg, tegra->ipfs_base + IPFS_XUSB_HOST_INTR_MASK_0);
411
412         /* Set hysteris to 0x80 */
413         writel(0x80, tegra->ipfs_base + IPFS_XUSB_HOST_CLKGATE_HYSTERESIS_0);
414 }
415
416 static int tegra_xusb_regulator_init(struct tegra_xhci_hcd *tegra,
417                 struct platform_device *pdev)
418 {
419         int err = 0;
420
421         tegra->xusb_hvdd_usb3_reg =
422                         devm_regulator_get(&pdev->dev, "hvdd_usb");
423         if (IS_ERR(tegra->xusb_hvdd_usb3_reg)) {
424                 dev_dbg(&pdev->dev, "hvdd_usb: regulator not found: %ld."
425                         , PTR_ERR(tegra->xusb_hvdd_usb3_reg));
426                 err = PTR_ERR(tegra->xusb_hvdd_usb3_reg);
427                 goto err_null_regulator;
428         }
429         err = regulator_enable(tegra->xusb_hvdd_usb3_reg);
430         if (err < 0) {
431                 dev_err(&pdev->dev,
432                         "hvdd_usb3: regulator enable failed:%d\n", err);
433                 goto err_null_regulator;
434         }
435
436         tegra->xusb_vbus_reg = devm_regulator_get(&pdev->dev, "usb_vbus");
437         if (IS_ERR(tegra->xusb_vbus_reg)) {
438                 dev_err(&pdev->dev, "vbus regulator not found: %ld."
439                         , PTR_ERR(tegra->xusb_vbus_reg));
440                 err = PTR_ERR(tegra->xusb_vbus_reg);
441                 goto err_put_hvdd_usb3;
442         }
443         err = regulator_enable(tegra->xusb_vbus_reg);
444         if (err < 0) {
445                 dev_err(&pdev->dev, "vbus: regulator enable failed:%d\n", err);
446                 goto err_put_hvdd_usb3;
447         }
448
449         tegra->xusb_avdd_usb3_pll_reg =
450                 devm_regulator_get(&pdev->dev, "avdd_usb_pll");
451         if (IS_ERR(tegra->xusb_avdd_usb3_pll_reg)) {
452                 dev_dbg(&pdev->dev, "regulator not found: %ld."
453                         , PTR_ERR(tegra->xusb_avdd_usb3_pll_reg));
454                 err = PTR_ERR(tegra->xusb_avdd_usb3_pll_reg);
455                 goto err_put_vbus;
456         }
457         err = regulator_enable(tegra->xusb_avdd_usb3_pll_reg);
458         if (err < 0) {
459                 dev_err(&pdev->dev,
460                         "avdd_usb3_pll: regulator enable failed:%d\n", err);
461                 goto err_put_vbus;
462         }
463
464         tegra->xusb_avddio_usb3_reg =
465                         devm_regulator_get(&pdev->dev, "avddio_usb");
466         if (IS_ERR(tegra->xusb_avddio_usb3_reg)) {
467                 dev_err(&pdev->dev, "avddio_usb3: regulator not found: %ld."
468                         , PTR_ERR(tegra->xusb_avddio_usb3_reg));
469                 err = PTR_ERR(tegra->xusb_avddio_usb3_reg);
470                 goto err_put_usb3_pll;
471         }
472         err = regulator_enable(tegra->xusb_avddio_usb3_reg);
473         if (err < 0) {
474                 dev_err(&pdev->dev,
475                         "avddio_usb3: regulator enable failed:%d\n", err);
476                 goto err_put_usb3_pll;
477         }
478
479         return err;
480
481 err_put_usb3_pll:
482         regulator_disable(tegra->xusb_avdd_usb3_pll_reg);
483 err_put_vbus:
484         regulator_disable(tegra->xusb_vbus_reg);
485 err_put_hvdd_usb3:
486         regulator_disable(tegra->xusb_hvdd_usb3_reg);
487 err_null_regulator:
488         tegra->xusb_vbus_reg = NULL;
489         tegra->xusb_avddio_usb3_reg = NULL;
490         tegra->xusb_hvdd_usb3_reg = NULL;
491         tegra->xusb_avdd_usb3_pll_reg = NULL;
492         return err;
493 }
494
495 static void tegra_xusb_regulator_deinit(struct tegra_xhci_hcd *tegra)
496 {
497         regulator_disable(tegra->xusb_avddio_usb3_reg);
498         regulator_disable(tegra->xusb_avdd_usb3_pll_reg);
499         regulator_disable(tegra->xusb_vbus_reg);
500         regulator_disable(tegra->xusb_hvdd_usb3_reg);
501
502         tegra->xusb_avddio_usb3_reg = NULL;
503         tegra->xusb_avdd_usb3_pll_reg = NULL;
504         tegra->xusb_vbus_reg = NULL;
505         tegra->xusb_hvdd_usb3_reg = NULL;
506 }
507
508 /*
509  * We need to enable only plle_clk as pllu_clk, utmip_clk and plle_re_vco_clk
510  * are under hardware control
511  */
512 static int tegra_usb2_clocks_init(struct tegra_xhci_hcd *tegra)
513 {
514         struct platform_device *pdev = tegra->pdev;
515         int err = 0;
516
517         tegra->plle_clk = devm_clk_get(&pdev->dev, "pll_e");
518         if (IS_ERR(tegra->plle_clk)) {
519                 dev_err(&pdev->dev, "%s: Failed to get plle clock\n", __func__);
520                 err = PTR_ERR(tegra->plle_clk);
521                 return err;
522         }
523         err = clk_enable(tegra->plle_clk);
524         if (err) {
525                 dev_err(&pdev->dev, "%s: could not enable plle clock\n",
526                         __func__);
527                 return err;
528         }
529
530         return err;
531 }
532
533 static void tegra_usb2_clocks_deinit(struct tegra_xhci_hcd *tegra)
534 {
535         clk_disable(tegra->plle_clk);
536         tegra->plle_clk = NULL;
537 }
538
539 static int tegra_xusb_partitions_clk_init(struct tegra_xhci_hcd *tegra)
540 {
541         struct platform_device *pdev = tegra->pdev;
542         int err = 0;
543
544         tegra->emc_clk = devm_clk_get(&pdev->dev, "emc");
545         if (IS_ERR(tegra->emc_clk)) {
546                 dev_err(&pdev->dev, "Failed to get xusb.emc clock\n");
547                 return PTR_ERR(tegra->emc_clk);
548         }
549
550         tegra->pll_re_vco_clk = devm_clk_get(&pdev->dev, "pll_re_vco");
551         if (IS_ERR(tegra->pll_re_vco_clk)) {
552                 dev_err(&pdev->dev, "Failed to get refPLLE clock\n");
553                 err = PTR_ERR(tegra->pll_re_vco_clk);
554                 goto get_emc_clk_failed;
555         }
556
557         /* get the clock handle of 120MHz clock source */
558         tegra->pll_u_480M = devm_clk_get(&pdev->dev, "pll_u_480M");
559         if (IS_ERR(tegra->pll_u_480M)) {
560                 dev_err(&pdev->dev, "Failed to get pll_u_480M clk handle\n");
561                 err = PTR_ERR(tegra->pll_u_480M);
562                 goto get_pll_u_480M_failed;
563         }
564
565         /* get the clock handle of 12MHz clock source */
566         tegra->clk_m = devm_clk_get(&pdev->dev, "clk_m");
567         if (IS_ERR(tegra->clk_m)) {
568                 dev_err(&pdev->dev, "Failed to get clk_m clk handle\n");
569                 err = PTR_ERR(tegra->clk_m);
570                 goto clk_get_clk_m_failed;
571         }
572
573         tegra->ss_src_clk = devm_clk_get(&pdev->dev, "ss_src");
574         if (IS_ERR(tegra->ss_src_clk)) {
575                 dev_err(&pdev->dev, "Failed to get SSPI clk\n");
576                 err = PTR_ERR(tegra->ss_src_clk);
577                 tegra->ss_src_clk = NULL;
578                 goto get_ss_src_clk_failed;
579         }
580
581         tegra->host_clk = devm_clk_get(&pdev->dev, "host");
582         if (IS_ERR(tegra->host_clk)) {
583                 dev_err(&pdev->dev, "Failed to get host partition clk\n");
584                 err = PTR_ERR(tegra->host_clk);
585                 tegra->host_clk = NULL;
586                 goto get_host_clk_failed;
587         }
588
589         tegra->ss_clk = devm_clk_get(&pdev->dev, "ss");
590         if (IS_ERR(tegra->ss_clk)) {
591                 dev_err(&pdev->dev, "Failed to get ss partition clk\n");
592                 err = PTR_ERR(tegra->ss_clk);
593                 tegra->ss_clk = NULL;
594                 goto get_ss_clk_failed;
595         }
596
597         err = clk_enable(tegra->pll_re_vco_clk);
598         if (err) {
599                 dev_err(&pdev->dev, "Failed to enable host partition clk\n");
600                 goto enable_pll_re_vco_clk_failed;
601         }
602         /* enable ss clock */
603         err = clk_enable(tegra->host_clk);
604         if (err) {
605                 dev_err(&pdev->dev, "Failed to enable host partition clk\n");
606                 goto enable_host_clk_failed;
607         }
608
609         err = clk_enable(tegra->ss_clk);
610         if (err) {
611                 dev_err(&pdev->dev, "Failed to enable ss partition clk\n");
612                 goto eanble_ss_clk_failed;
613         }
614
615         err = clk_enable(tegra->emc_clk);
616         if (err) {
617                 dev_err(&pdev->dev, "Failed to enable xusb.emc clk\n");
618                 goto eanble_emc_clk_failed;
619         }
620
621         return 0;
622
623 eanble_emc_clk_failed:
624         clk_disable(tegra->ss_clk);
625
626 eanble_ss_clk_failed:
627         clk_disable(tegra->host_clk);
628
629 enable_host_clk_failed:
630         clk_disable(tegra->pll_re_vco_clk);
631
632 enable_pll_re_vco_clk_failed:
633         tegra->ss_clk = NULL;
634
635 get_ss_clk_failed:
636         tegra->host_clk = NULL;
637
638 get_host_clk_failed:
639         tegra->ss_src_clk = NULL;
640
641 get_ss_src_clk_failed:
642         tegra->clk_m = NULL;
643
644 clk_get_clk_m_failed:
645         tegra->pll_u_480M = NULL;
646
647 get_pll_u_480M_failed:
648         tegra->pll_re_vco_clk = NULL;
649
650 get_emc_clk_failed:
651         tegra->emc_clk = NULL;
652
653         return err;
654 }
655
656 static void tegra_xusb_partitions_clk_deinit(struct tegra_xhci_hcd *tegra)
657 {
658         clk_disable(tegra->ss_clk);
659         clk_disable(tegra->host_clk);
660         clk_disable(tegra->pll_re_vco_clk);
661         tegra->ss_clk = NULL;
662         tegra->host_clk = NULL;
663         tegra->ss_src_clk = NULL;
664         tegra->clk_m = NULL;
665         tegra->pll_u_480M = NULL;
666         tegra->pll_re_vco_clk = NULL;
667 }
668
669 static void tegra_xhci_rx_idle_mode_override(struct tegra_xhci_hcd *tegra,
670         bool enable)
671 {
672         u32 reg;
673
674         reg = readl(tegra->padctl_base + IOPHY_MISC_PAD0_CTL_3_0);
675         if (enable) {
676                 reg &= ~RX_IDLE_MODE;
677                 reg |= RX_IDLE_MODE_OVRD;
678         } else {
679                 reg |= RX_IDLE_MODE;
680                 reg &= ~RX_IDLE_MODE_OVRD;
681         }
682         writel(reg, tegra->padctl_base + IOPHY_MISC_PAD0_CTL_3_0);
683
684         reg = readl(tegra->padctl_base + IOPHY_MISC_PAD1_CTL_3_0);
685         if (enable) {
686                 reg &= ~RX_IDLE_MODE;
687                 reg |= RX_IDLE_MODE_OVRD;
688         } else {
689                 reg |= RX_IDLE_MODE;
690                 reg &= ~RX_IDLE_MODE_OVRD;
691         }
692         writel(reg, tegra->padctl_base + IOPHY_MISC_PAD1_CTL_3_0);
693 }
694
695 /* Enable ss clk, host clk, falcon clk,
696  * fs clk, dev clk, plle and refplle
697  */
698
699 static int
700 tegra_xusb_request_clk_rate(struct tegra_xhci_hcd *tegra,
701                 struct clk *clk_handle, u32 rate, u32 *sw_resp)
702 {
703         int ret = 0;
704         enum MBOX_CMD_TYPE cmd_ack = MBOX_CMD_ACK;
705         int fw_req_rate = rate, cur_rate;
706
707         /* Do not handle clock change as needed for HS disconnect issue */
708         *sw_resp = fw_req_rate | (MBOX_CMD_ACK << MBOX_CMD_SHIFT);
709         return ret;
710
711         /* frequency request from firmware is in KHz.
712          * Convert it to MHz
713          */
714
715         /* get current rate of clock */
716         cur_rate = clk_get_rate(clk_handle);
717         cur_rate /= 1000;
718
719         if (fw_req_rate == cur_rate) {
720                 cmd_ack = MBOX_CMD_ACK;
721                 *sw_resp = fw_req_rate;
722         } else {
723
724                 if (clk_handle == tegra->ss_src_clk && fw_req_rate == 12000) {
725                         /* Change SS clock source to CLK_M at 12MHz */
726                         clk_set_parent(clk_handle, tegra->clk_m);
727                         clk_set_rate(clk_handle, fw_req_rate * 1000);
728
729                         /* save leakage power when SS freq is being decreased */
730                         tegra_xhci_rx_idle_mode_override(tegra, true);
731                 } else if (clk_handle == tegra->ss_src_clk &&
732                                 fw_req_rate == 120000) {
733                         /* Change SS clock source to HSIC_480 at 120MHz */
734                         clk_set_rate(clk_handle,  3000 * 1000);
735                         clk_set_parent(clk_handle, tegra->pll_u_480M);
736
737                         /* clear ovrd bits when SS freq is being increased */
738                         tegra_xhci_rx_idle_mode_override(tegra, false);
739                 }
740
741                 *sw_resp = clk_get_rate(clk_handle);
742                 *sw_resp /= 1000;
743
744                 if (*sw_resp != fw_req_rate) {
745                         xhci_err(tegra->xhci, "cur_rate=%d, fw_req_rate=%d\n",
746                                 cur_rate, fw_req_rate);
747                         cmd_ack = MBOX_CMD_NACK;
748                 }
749         }
750         *sw_resp |= (cmd_ack << MBOX_CMD_SHIFT);
751         return ret;
752 }
753
754 static void
755 tegra_xhci_ss_wake_on_interrupts(struct tegra_xhci_hcd *tegra, bool enable)
756 {
757         u32 elpg_program0;
758
759         elpg_program0 = readl(tegra->padctl_base + ELPG_PROGRAM_0);
760         elpg_program0 |= (SS_PORT0_WAKEUP_EVENT | SS_PORT1_WAKEUP_EVENT);
761
762         writel(elpg_program0, tegra->padctl_base + ELPG_PROGRAM_0);
763
764         /* Enable ss wake interrupts */
765         elpg_program0 = readl(tegra->padctl_base + ELPG_PROGRAM_0);
766
767         if (enable) {
768                 /* enable interrupts */
769                 elpg_program0 |= (SS_PORT0_WAKE_INTERRUPT_ENABLE |
770                                 SS_PORT1_WAKE_INTERRUPT_ENABLE);
771         } else {
772                 /* disable interrupts */
773                 elpg_program0 &= ~(SS_PORT0_WAKE_INTERRUPT_ENABLE |
774                                 SS_PORT1_WAKE_INTERRUPT_ENABLE);
775         }
776         writel(elpg_program0, tegra->padctl_base + ELPG_PROGRAM_0);
777 }
778
779 static void
780 tegra_xhci_hs_wake_on_interrupts(struct tegra_xhci_hcd *tegra, bool enable)
781 {
782         u32 elpg_program0;
783
784         elpg_program0 = readl(tegra->padctl_base + ELPG_PROGRAM_0);
785         elpg_program0 |= (USB2_PORT0_WAKEUP_EVENT | USB2_PORT1_WAKEUP_EVENT |
786                         USB2_HSIC_PORT0_WAKEUP_EVENT |
787                         USB2_HSIC_PORT1_WAKEUP_EVENT);
788         writel(elpg_program0, tegra->padctl_base + ELPG_PROGRAM_0);
789
790         /* Enable the wake interrupts */
791         elpg_program0 = readl(tegra->padctl_base + ELPG_PROGRAM_0);
792         if (enable)
793                 /* enable interrupts */
794                 elpg_program0 |= (USB2_PORT0_WAKE_INTERRUPT_ENABLE |
795                                 USB2_PORT1_WAKE_INTERRUPT_ENABLE |
796                                 USB2_HSIC_PORT0_WAKE_INTERRUPT_ENABLE |
797                                 USB2_HSIC_PORT1_WAKE_INTERRUPT_ENABLE);
798         else
799                 elpg_program0 &= ~(USB2_PORT0_WAKE_INTERRUPT_ENABLE |
800                                 USB2_PORT1_WAKE_INTERRUPT_ENABLE |
801                                 USB2_HSIC_PORT0_WAKE_INTERRUPT_ENABLE |
802                                 USB2_HSIC_PORT1_WAKE_INTERRUPT_ENABLE);
803         writel(elpg_program0, tegra->padctl_base + ELPG_PROGRAM_0);
804 }
805
806 static void
807 tegra_xhci_ss_wake_signal(struct tegra_xhci_hcd *tegra, bool enable)
808 {
809         u32 elpg_program0;
810
811         /* DO NOT COMBINE BELOW 2 WRITES */
812
813         /* Assert/Deassert clamp_en_early signals to SSP0/1 */
814         elpg_program0 = readl(tegra->padctl_base + ELPG_PROGRAM_0);
815         if (enable)
816                 elpg_program0 |= (SSP0_ELPG_CLAMP_EN_EARLY |
817                                 SSP1_ELPG_CLAMP_EN_EARLY);
818         else
819                 elpg_program0 &= ~(SSP0_ELPG_CLAMP_EN_EARLY |
820                                 SSP1_ELPG_CLAMP_EN_EARLY);
821         writel(elpg_program0, tegra->padctl_base + ELPG_PROGRAM_0);
822
823         /*
824          * Check the LP0 figure and leave gap bw writes to
825          * clamp_en_early and clamp_en
826          */
827         usleep_range(100, 200);
828
829         /* Assert/Deassert clam_en signal */
830         elpg_program0 = readl(tegra->padctl_base + ELPG_PROGRAM_0);
831
832         if (enable)
833                 elpg_program0 |= (SSP0_ELPG_CLAMP_EN | SSP1_ELPG_CLAMP_EN);
834         else
835                 elpg_program0 &= ~(SSP0_ELPG_CLAMP_EN | SSP1_ELPG_CLAMP_EN);
836
837         writel(elpg_program0, tegra->padctl_base + ELPG_PROGRAM_0);
838
839         /* wait for 250us for the writes to propogate */
840         if (enable)
841                 usleep_range(250, 300);
842 }
843
844 static void
845 tegra_xhci_ss_vcore(struct tegra_xhci_hcd *tegra, bool enable)
846 {
847         u32 elpg_program0;
848
849
850         /* Assert vcore_off signal */
851         elpg_program0 = readl(tegra->padctl_base + ELPG_PROGRAM_0);
852
853         if (enable)
854                 elpg_program0 |= (SSP0_ELPG_VCORE_DOWN|SSP1_ELPG_VCORE_DOWN);
855         else
856                 elpg_program0 &= ~(SSP0_ELPG_VCORE_DOWN|SSP1_ELPG_VCORE_DOWN);
857
858         writel(elpg_program0, tegra->padctl_base + ELPG_PROGRAM_0);
859 }
860
861 static void
862 tegra_xhci_padctl_enable_usb_vbus(struct tegra_xhci_hcd *tegra)
863 {
864         u32 reg;
865         struct tegra_xusb_pad_data *xusb_padctl = tegra->xusb_padctl;
866         struct xhci_hcd *xhci = tegra->xhci;
867
868         /* Program the following XUSB PADCTL registers to
869          * 0x7 to disable the over current signal mapping
870          * for USB 2.0 ports owned by XUSB and USB2:
871          */
872         reg = readl(tegra->padctl_base + SNPS_OC_MAP_0);
873         reg &= ~(0x1ff << 0);
874         reg |= xusb_padctl->snps_oc_map;
875         writel(reg, tegra->padctl_base + SNPS_OC_MAP_0);
876         reg = readl(tegra->padctl_base + SNPS_OC_MAP_0);
877
878         reg = readl(tegra->padctl_base + OC_DET_0);
879         reg &= ~(0x3f << 10);
880         reg |= xusb_padctl->oc_det;
881         writel(reg, tegra->padctl_base + OC_DET_0);
882
883         /* check if over current seen. Clear if present */
884         reg = readl(tegra->padctl_base + OC_DET_0);
885         if (reg & (0x3 << 20)) {
886                 xhci_info(xhci, "Over current detected. Clearing...\n");
887                 writel(reg, tegra->padctl_base + OC_DET_0);
888
889                 usleep_range(100, 200);
890
891                 reg = readl(tegra->padctl_base + OC_DET_0);
892                 if (reg & (0x3 << 20))
893                         xhci_info(xhci, "Over current still present\n");
894         }
895
896         reg = readl(tegra->padctl_base + USB2_OC_MAP_0);
897         reg &= ~(0x3f << 0);
898         reg |= xusb_padctl->usb2_oc_map;
899         writel(reg, tegra->padctl_base + USB2_OC_MAP_0);
900 }
901
902 static void tegra_xhci_save_dfe_ctle_context(struct tegra_xhci_hcd *tegra)
903 {
904         struct xhci_hcd *xhci = tegra->xhci;
905         u32 reg;
906
907         xhci_info(xhci, "saving dfe_cntl and ctle context\n");
908         /* save tap1_val0 for pad0 for dfe_cntl */
909         reg = readl(tegra->padctl_base + IOPHY_MISC_PAD0_CTL_6_0);
910         reg &= ~(0xff << 16);
911         reg |= (0x32 << 16);
912         writel(reg, tegra->padctl_base + IOPHY_MISC_PAD0_CTL_6_0);
913
914         reg = readl(tegra->padctl_base + IOPHY_MISC_PAD0_CTL_6_0);
915         tegra->sregs.tap1_val0 = ((reg & (0x1f << 24)) >> 24);
916
917         /* save tap1_val1 for pad1 for dfe_cntl */
918         reg = readl(tegra->padctl_base + IOPHY_MISC_PAD1_CTL_6_0);
919         reg &= ~(0xff << 16);
920         reg |= (0x32 << 16);
921         writel(reg, tegra->padctl_base + IOPHY_MISC_PAD1_CTL_6_0);
922
923         reg = readl(tegra->padctl_base + IOPHY_MISC_PAD1_CTL_6_0);
924         tegra->sregs.tap1_val1 = ((reg & (0x1f << 24)) >> 24);
925
926         /* save amp_val0 for pad0 for dfe_cntl */
927         reg = readl(tegra->padctl_base + IOPHY_MISC_PAD0_CTL_6_0);
928         reg &= ~(0xff << 16);
929         reg |= (0x33 << 16);
930         writel(reg, tegra->padctl_base + IOPHY_MISC_PAD0_CTL_6_0);
931
932         reg = readl(tegra->padctl_base + IOPHY_MISC_PAD0_CTL_6_0);
933         tegra->sregs.amp_val0 = ((reg & (0x7f << 24)) >> 24);
934
935         /* save amp_val1 for pad1 for dfe_cntl */
936         reg = readl(tegra->padctl_base + IOPHY_MISC_PAD1_CTL_6_0);
937         reg &= ~(0xff << 16);
938         reg |= (0x33 << 16);
939         writel(reg, tegra->padctl_base + IOPHY_MISC_PAD1_CTL_6_0);
940
941         reg = readl(tegra->padctl_base + IOPHY_MISC_PAD1_CTL_6_0);
942         tegra->sregs.amp_val1 = ((reg & (0x7f << 24)) >> 24);
943
944         /* save ctle_z_val0 for pad0 for ctle */
945         reg = readl(tegra->padctl_base + IOPHY_MISC_PAD0_CTL_6_0);
946         reg &= ~(0xff << 16);
947         reg |= (0x20 << 16);
948         writel(reg, tegra->padctl_base + IOPHY_MISC_PAD0_CTL_6_0);
949
950         reg = readl(tegra->padctl_base + IOPHY_MISC_PAD0_CTL_6_0);
951         tegra->sregs.ctle_z_val0 = ((reg & (0x3f << 24)) >> 24);
952
953         /* save ctle_z_val1 for pad1 for ctle */
954         reg = readl(tegra->padctl_base + IOPHY_MISC_PAD1_CTL_6_0);
955         reg &= ~(0xff << 16);
956         reg |= (0x20 << 16);
957         writel(reg, tegra->padctl_base + IOPHY_MISC_PAD1_CTL_6_0);
958
959         reg = readl(tegra->padctl_base + IOPHY_MISC_PAD1_CTL_6_0);
960         tegra->sregs.ctle_z_val1 = ((reg & (0x3f << 24)) >> 24);
961
962         /* save ctle_g_val0 for pad0 for ctle */
963         reg = readl(tegra->padctl_base + IOPHY_MISC_PAD0_CTL_6_0);
964         reg &= ~(0xff << 16);
965         reg |= (0x21 << 16);
966         writel(reg, tegra->padctl_base + IOPHY_MISC_PAD0_CTL_6_0);
967
968         reg = readl(tegra->padctl_base + IOPHY_MISC_PAD0_CTL_6_0);
969         tegra->sregs.ctle_g_val0 = ((reg & (0x3f << 24)) >> 24);
970
971         /* save ctle_g_val1 for pad1 for ctle */
972         reg = readl(tegra->padctl_base + IOPHY_MISC_PAD1_CTL_6_0);
973         reg &= ~(0xff << 16);
974         reg |= (0x21 << 16);
975         writel(reg, tegra->padctl_base + IOPHY_MISC_PAD1_CTL_6_0);
976
977         reg = readl(tegra->padctl_base + IOPHY_MISC_PAD1_CTL_6_0);
978         tegra->sregs.ctle_g_val1 = ((reg & (0x3f << 24)) >> 24);
979
980         tegra->dfe_ctle_ctx_saved = true;
981 }
982
983 static void tegra_xhci_restore_dfe_ctle_context(struct tegra_xhci_hcd *tegra)
984 {
985         struct xhci_hcd *xhci = tegra->xhci;
986         u32 reg;
987
988         /* don't restore if not saved */
989         if (tegra->dfe_ctle_ctx_saved == false)
990                 return;
991
992         xhci_info(xhci, "restoring dfe_cntl and ctle context\n");
993
994         /* restore dfe_cntl for pad0 */
995         reg = readl(tegra->padctl_base + IOPHY_USB3_PAD0_CTL_4_0);
996         reg &= ~((0x7f << 16) | (0x1f << 24));
997         reg |= ((tegra->sregs.amp_val0 << 16) | (tegra->sregs.tap1_val0 << 24));
998         writel(reg, tegra->padctl_base + IOPHY_USB3_PAD0_CTL_4_0);
999
1000         /* restore dfe_cntl for pad1 */
1001         reg = readl(tegra->padctl_base + IOPHY_USB3_PAD1_CTL_4_0);
1002         reg &= ~((0x7f << 16) | (0x1f << 24));
1003         reg |= ((tegra->sregs.amp_val1 << 16) | (tegra->sregs.tap1_val1 << 24));
1004         writel(reg, tegra->padctl_base + IOPHY_USB3_PAD1_CTL_4_0);
1005
1006         /* restore ctle for pad0 */
1007         reg = readl(tegra->padctl_base + IOPHY_USB3_PAD0_CTL_2_0);
1008         reg &= ~((0x3f << 8) | (0x3f << 16));
1009         reg |= ((tegra->sregs.ctle_g_val0 << 8) |
1010                 (tegra->sregs.ctle_z_val0 << 16));
1011         writel(reg, tegra->padctl_base + IOPHY_USB3_PAD0_CTL_2_0);
1012
1013         /* restore ctle for pad1 */
1014         reg = readl(tegra->padctl_base + IOPHY_USB3_PAD1_CTL_2_0);
1015         reg &= ~((0x3f << 8) | (0x3f << 16));
1016         reg |= ((tegra->sregs.ctle_g_val1 << 8) |
1017                 (tegra->sregs.ctle_z_val1 << 16));
1018         writel(reg, tegra->padctl_base + IOPHY_USB3_PAD1_CTL_2_0);
1019 }
1020 /* This function assigns the USB ports to the controllers,
1021  * then programs the port capabilities and pad parameters
1022  * of ports assigned to XUSB after booted to OS.
1023  */
1024 void
1025 tegra_xhci_padctl_portmap_and_caps(struct tegra_xhci_hcd *tegra)
1026 {
1027         u32 reg;
1028         struct tegra_xusb_pad_data *xusb_padctl = tegra->xusb_padctl;
1029
1030         /* Program the following XUSB PADCTL registers to assign
1031          * the USB2.0 ports to XUSB or USB2, according to the platform
1032          * specific configuration
1033          */
1034         reg = readl(tegra->padctl_base + USB2_PAD_MUX_0);
1035         reg &= ~(0xf << 0);
1036         reg |= xusb_padctl->pad_mux;
1037         writel(reg, tegra->padctl_base + USB2_PAD_MUX_0);
1038
1039         /* Program the following XUSB PADCTL registers to assign
1040          * the port capabilities for USB2.0 ports owned by XUSB,
1041          * according to the platform specific configuration:
1042          */
1043         reg = readl(tegra->padctl_base + USB2_PORT_CAP_0);
1044         reg &= ~((0x3 << 4) | (0x3 << 0));
1045         reg |= xusb_padctl->port_cap;
1046         writel(reg, tegra->padctl_base + USB2_PORT_CAP_0);
1047
1048
1049
1050         /* Program the following XUSB PADCTL registers to assign
1051          * the SuperSpeed port mapping to USB2.0 ports owned by XUSB,
1052          * where the SuperSpeed ports inherit their port capabilities
1053          * from the USB2.0 ports they mapped to, according to the
1054          * platform specific configuration
1055          */
1056         reg = readl(tegra->padctl_base + SS_PORT_MAP_0);
1057         reg &= ~(0x7 << 0);
1058         reg |= xusb_padctl->ss_port_map;
1059         writel(reg, tegra->padctl_base + SS_PORT_MAP_0);
1060
1061         reg = readl(tegra->padctl_base + IOPHY_USB3_PAD0_CTL_2_0);
1062         reg &= ~0xfffffff0;
1063         reg |= xusb_padctl->rx_wander | xusb_padctl->rx_eq |
1064                         xusb_padctl->cdr_cntl;
1065         writel(reg, tegra->padctl_base + IOPHY_USB3_PAD0_CTL_2_0);
1066
1067         reg = readl(tegra->padctl_base + IOPHY_USB3_PAD1_CTL_2_0);
1068         reg &= ~0xfffffff0;
1069         reg |= xusb_padctl->rx_wander | xusb_padctl->rx_eq |
1070                         xusb_padctl->cdr_cntl;
1071         writel(reg, tegra->padctl_base + IOPHY_USB3_PAD1_CTL_2_0);
1072
1073         reg = readl(tegra->padctl_base + IOPHY_USB3_PAD0_CTL_4_0);
1074         reg = xusb_padctl->dfe_cntl;
1075         writel(reg, tegra->padctl_base + IOPHY_USB3_PAD0_CTL_4_0);
1076
1077         reg = readl(tegra->padctl_base + IOPHY_USB3_PAD1_CTL_4_0);
1078         reg = xusb_padctl->dfe_cntl;
1079         writel(reg, tegra->padctl_base + IOPHY_USB3_PAD1_CTL_4_0);
1080
1081         tegra_xhci_restore_dfe_ctle_context(tegra);
1082
1083         reg = readl(tegra->padctl_base + USB2_OTG_PAD0_CTL_0_0);
1084         reg &= ~((0x3fff << 0) | (0x1f << 19));
1085         reg |= xusb_padctl->hs_slew | xusb_padctl->ls_rslew
1086                 | tegra->pdata->hs_curr_level_pad0 | xusb_padctl->otg_pad0_ctl0;
1087         writel(reg, tegra->padctl_base + USB2_OTG_PAD0_CTL_0_0);
1088
1089         reg = readl(tegra->padctl_base + USB2_OTG_PAD1_CTL_0_0);
1090         reg &= ~((0xfff << 0) | (0x1f << 19));
1091         reg |= xusb_padctl->hs_slew
1092                 | tegra->pdata->hs_curr_level_pad1 | xusb_padctl->otg_pad1_ctl0;
1093         writel(reg, tegra->padctl_base + USB2_OTG_PAD1_CTL_0_0);
1094
1095         reg = readl(tegra->padctl_base + USB2_OTG_PAD0_CTL_1_0);
1096         reg &= ~((0x7 << 0) | (0x3 << 9) | (0xf << 3));
1097         reg |= (xusb_padctl->otg_pad0_ctl1 << 0)
1098                 | (tegra->pdata->hs_iref_cap << 9)
1099                 | (tegra->pdata->hs_term_range_adj << 3);
1100         writel(reg, tegra->padctl_base + USB2_OTG_PAD0_CTL_1_0);
1101
1102         reg = readl(tegra->padctl_base + USB2_OTG_PAD1_CTL_1_0);
1103         reg &= ~((0x7 << 0) | (0xf << 3) | (0x3 << 9));
1104         reg |= (xusb_padctl->otg_pad1_ctl1 << 0)
1105                 | (tegra->pdata->hs_term_range_adj << 3)
1106                 | (tegra->pdata->hs_iref_cap << 9);
1107         writel(reg, tegra->padctl_base + USB2_OTG_PAD1_CTL_1_0);
1108
1109         reg = readl(tegra->padctl_base + USB2_BIAS_PAD_CTL_0_0);
1110         reg &= ~(0x1f << 0);
1111         reg |= tegra->pdata->hs_squelch_level | xusb_padctl->hs_disc_lvl;
1112         writel(reg, tegra->padctl_base + USB2_BIAS_PAD_CTL_0_0);
1113
1114         reg = readl(tegra->padctl_base + HSIC_PAD0_CTL_0_0);
1115         reg &= ~(0xff << 8);
1116         reg |= xusb_padctl->hsic_pad0_ctl0;
1117         writel(reg, tegra->padctl_base + HSIC_PAD0_CTL_0_0);
1118
1119         reg = readl(tegra->padctl_base + HSIC_PAD1_CTL_0_0);
1120         reg &= ~(0xff << 8);
1121         reg |= xusb_padctl->hsic_pad0_ctl1;
1122         writel(reg, tegra->padctl_base + HSIC_PAD1_CTL_0_0);
1123 }
1124
1125 /* This function read XUSB registers and stores in device context */
1126 static void
1127 tegra_xhci_save_xusb_ctx(struct tegra_xhci_hcd *tegra)
1128 {
1129
1130         /* a. Save the IPFS registers */
1131         tegra->sregs.msi_bar_sz =
1132                 readl(tegra->ipfs_base + IPFS_XUSB_HOST_MSI_BAR_SZ_0);
1133
1134         tegra->sregs.msi_axi_barst =
1135                 readl(tegra->ipfs_base + IPFS_XUSB_HOST_MSI_AXI_BAR_ST_0);
1136
1137         tegra->sregs.msi_fpci_barst =
1138                 readl(tegra->ipfs_base + IPFS_XUSB_HOST_FPCI_BAR_ST_0);
1139
1140         tegra->sregs.msi_vec0 =
1141                 readl(tegra->ipfs_base + IPFS_XUSB_HOST_MSI_VEC0_0);
1142
1143         tegra->sregs.msi_en_vec0 =
1144                 readl(tegra->ipfs_base + IPFS_XUSB_HOST_MSI_EN_VEC0_0);
1145
1146         tegra->sregs.fpci_error_masks =
1147                 readl(tegra->ipfs_base + IPFS_XUSB_HOST_FPCI_ERROR_MASKS_0);
1148
1149         tegra->sregs.intr_mask =
1150                 readl(tegra->ipfs_base + IPFS_XUSB_HOST_INTR_MASK_0);
1151
1152         tegra->sregs.ipfs_intr_enable =
1153                 readl(tegra->ipfs_base + IPFS_XUSB_HOST_IPFS_INTR_ENABLE_0);
1154
1155         tegra->sregs.ufpci_config =
1156                 readl(tegra->ipfs_base + IPFS_XUSB_HOST_UFPCI_CONFIG_0);
1157
1158         tegra->sregs.clkgate_hysteresis =
1159                 readl(tegra->ipfs_base + IPFS_XUSB_HOST_CLKGATE_HYSTERESIS_0);
1160
1161         tegra->sregs.xusb_host_mccif_fifo_cntrl =
1162                 readl(tegra->ipfs_base + IPFS_XUSB_HOST_MCCIF_FIFOCTRL_0);
1163
1164         /* b. Save the CFG registers */
1165
1166         tegra->sregs.hs_pls =
1167                 readl(tegra->fpci_base + XUSB_CFG_ARU_CONTEXT_HS_PLS);
1168
1169         tegra->sregs.fs_pls =
1170                 readl(tegra->fpci_base + XUSB_CFG_ARU_CONTEXT_FS_PLS);
1171
1172         tegra->sregs.hs_fs_speed =
1173                 readl(tegra->fpci_base + XUSB_CFG_ARU_CONTEXT_HSFS_SPEED);
1174
1175         tegra->sregs.hs_fs_pp =
1176                 readl(tegra->fpci_base + XUSB_CFG_ARU_CONTEXT_HSFS_PP);
1177
1178         tegra->sregs.cfg_aru =
1179                 readl(tegra->fpci_base + XUSB_CFG_ARU_CONTEXT);
1180
1181         tegra->sregs.cfg_order =
1182                 readl(tegra->fpci_base + XUSB_CFG_FPCICFG);
1183
1184         tegra->sregs.cfg_fladj =
1185                 readl(tegra->fpci_base + XUSB_CFG_24);
1186
1187         tegra->sregs.cfg_sid =
1188                 readl(tegra->fpci_base + XUSB_CFG_16);
1189 }
1190
1191 /* This function restores XUSB registers from device context */
1192 static void
1193 tegra_xhci_restore_ctx(struct tegra_xhci_hcd *tegra)
1194 {
1195         /* Restore Cfg registers */
1196         writel(tegra->sregs.hs_pls,
1197                 tegra->fpci_base + XUSB_CFG_ARU_CONTEXT_HS_PLS);
1198
1199         writel(tegra->sregs.fs_pls,
1200                 tegra->fpci_base + XUSB_CFG_ARU_CONTEXT_FS_PLS);
1201
1202         writel(tegra->sregs.hs_fs_speed,
1203                 tegra->fpci_base + XUSB_CFG_ARU_CONTEXT_HSFS_SPEED);
1204
1205         writel(tegra->sregs.hs_fs_pp,
1206                 tegra->fpci_base + XUSB_CFG_ARU_CONTEXT_HSFS_PP);
1207
1208         writel(tegra->sregs.cfg_aru,
1209                 tegra->fpci_base + XUSB_CFG_ARU_CONTEXT);
1210
1211         writel(tegra->sregs.cfg_order,
1212                 tegra->fpci_base + XUSB_CFG_FPCICFG);
1213
1214         writel(tegra->sregs.cfg_fladj,
1215                 tegra->fpci_base + XUSB_CFG_24);
1216
1217         writel(tegra->sregs.cfg_sid,
1218                 tegra->fpci_base + XUSB_CFG_16);
1219
1220         /* Restore IPFS registers */
1221
1222         writel(tegra->sregs.msi_bar_sz,
1223                 tegra->ipfs_base + IPFS_XUSB_HOST_MSI_BAR_SZ_0);
1224
1225         writel(tegra->sregs.msi_axi_barst,
1226                 tegra->ipfs_base + IPFS_XUSB_HOST_MSI_AXI_BAR_ST_0);
1227
1228         writel(tegra->sregs.msi_fpci_barst,
1229                 tegra->ipfs_base + IPFS_XUSB_HOST_FPCI_BAR_ST_0);
1230
1231         writel(tegra->sregs.msi_vec0,
1232                 tegra->ipfs_base + IPFS_XUSB_HOST_MSI_VEC0_0);
1233
1234         writel(tegra->sregs.msi_en_vec0,
1235                 tegra->ipfs_base + IPFS_XUSB_HOST_MSI_EN_VEC0_0);
1236
1237         writel(tegra->sregs.fpci_error_masks,
1238                 tegra->ipfs_base + IPFS_XUSB_HOST_FPCI_ERROR_MASKS_0);
1239
1240         writel(tegra->sregs.intr_mask,
1241                 tegra->ipfs_base + IPFS_XUSB_HOST_INTR_MASK_0);
1242
1243         writel(tegra->sregs.ipfs_intr_enable,
1244                 tegra->ipfs_base + IPFS_XUSB_HOST_IPFS_INTR_ENABLE_0);
1245
1246         writel(tegra->sregs.ufpci_config,
1247                 tegra->fpci_base + IPFS_XUSB_HOST_UFPCI_CONFIG_0);
1248
1249         writel(tegra->sregs.clkgate_hysteresis,
1250                 tegra->ipfs_base + IPFS_XUSB_HOST_CLKGATE_HYSTERESIS_0);
1251
1252         writel(tegra->sregs.xusb_host_mccif_fifo_cntrl,
1253                 tegra->ipfs_base + IPFS_XUSB_HOST_MCCIF_FIFOCTRL_0);
1254 }
1255
1256 static void tegra_xhci_enable_fw_message(struct tegra_xhci_hcd *tegra)
1257 {
1258         struct platform_device *pdev = tegra->pdev;
1259         u32 reg, timeout = 0xff, cmd;
1260
1261         mutex_lock(&tegra->mbox_lock);
1262
1263         do {
1264                 writel(MBOX_OWNER_SW,
1265                         tegra->fpci_base + XUSB_CFG_ARU_MBOX_OWNER);
1266                 reg = readl(tegra->fpci_base + XUSB_CFG_ARU_MBOX_OWNER);
1267                 usleep_range(10, 20);
1268         } while (reg != MBOX_OWNER_SW && timeout--);
1269
1270         if ((timeout == 0) && (reg != MBOX_OWNER_SW)) {
1271                 dev_err(&pdev->dev, "Failed to set mbox message owner ID\n");
1272                 return;
1273         }
1274
1275         writel((MBOX_CMD_MSG_ENABLED << MBOX_CMD_SHIFT),
1276                         tegra->fpci_base + XUSB_CFG_ARU_MBOX_DATA_IN);
1277
1278         cmd = readl(tegra->fpci_base + XUSB_CFG_ARU_MBOX_CMD);
1279         cmd |= MBOX_INT_EN | MBOX_FALC_INT_EN;
1280         writel(cmd, tegra->fpci_base + XUSB_CFG_ARU_MBOX_CMD);
1281
1282         mutex_unlock(&tegra->mbox_lock);
1283 }
1284
1285 static int load_firmware(struct tegra_xhci_hcd *tegra, bool resetARU)
1286 {
1287         struct platform_device *pdev = tegra->pdev;
1288         struct cfgtbl *cfg_tbl = (struct cfgtbl *) tegra->firmware.data;
1289         u32 phys_addr_lo;
1290         u32 HwReg;
1291         u16 nblocks;
1292         time_t fw_time;
1293         struct tm fw_tm;
1294         u8 hc_caplength;
1295         u32 usbsts, count = 0xff;
1296         struct xhci_cap_regs __iomem *cap_regs;
1297         struct xhci_op_regs __iomem *op_regs;
1298
1299         /* enable mbox interrupt */
1300         writel(readl(tegra->fpci_base + XUSB_CFG_ARU_MBOX_CMD) | MBOX_INT_EN,
1301                 tegra->fpci_base + XUSB_CFG_ARU_MBOX_CMD);
1302
1303         /* First thing, reset the ARU. By the time we get to
1304          * loading boot code below, reset would be complete.
1305          * alternatively we can busy wait on rst pending bit.
1306          */
1307         /* Don't reset during ELPG/LP0 exit path */
1308         if (resetARU) {
1309                 iowrite32(0x1, tegra->fpci_base + XUSB_CFG_ARU_RST);
1310                 usleep_range(1000, 2000);
1311         }
1312
1313         if (csb_read(tegra, XUSB_CSB_MP_ILOAD_BASE_LO) != 0) {
1314                 dev_info(&pdev->dev, "Firmware already loaded, Falcon state 0x%x\n",
1315                                 csb_read(tegra, XUSB_FALC_CPUCTL));
1316                 return 0;
1317         }
1318
1319         phys_addr_lo = tegra->firmware.dma;
1320         phys_addr_lo += sizeof(struct cfgtbl);
1321
1322         /* Program the size of DFI into ILOAD_ATTR */
1323         csb_write(tegra, XUSB_CSB_MP_ILOAD_ATTR, tegra->firmware.size);
1324
1325         /* Boot code of the firmware reads the ILOAD_BASE_LO register
1326          * to get to the start of the dfi in system memory.
1327          */
1328         csb_write(tegra, XUSB_CSB_MP_ILOAD_BASE_LO, phys_addr_lo);
1329
1330         /* Program the ILOAD_BASE_HI with a value of MSB 32 bits */
1331         csb_write(tegra, XUSB_CSB_MP_ILOAD_BASE_HI, 0);
1332
1333         /* Set BOOTPATH to 1 in APMAP Register. Bit 31 is APMAP_BOOTMAP */
1334         csb_write(tegra, XUSB_CSB_MP_APMAP, APMAP_BOOTPATH);
1335
1336         /* Invalidate L2IMEM. */
1337         csb_write(tegra, XUSB_CSB_MP_L2IMEMOP_TRIG, L2IMEM_INVALIDATE_ALL);
1338
1339         /* Initiate fetch of Bootcode from system memory into L2IMEM.
1340          * Program BootCode location and size in system memory.
1341          */
1342         HwReg = ((cfg_tbl->boot_codetag / IMEM_BLOCK_SIZE) &
1343                         L2IMEMOP_SIZE_SRC_OFFSET_MASK)
1344                         << L2IMEMOP_SIZE_SRC_OFFSET_SHIFT;
1345         HwReg |= ((cfg_tbl->boot_codesize / IMEM_BLOCK_SIZE) &
1346                         L2IMEMOP_SIZE_SRC_COUNT_MASK)
1347                         << L2IMEMOP_SIZE_SRC_COUNT_SHIFT;
1348         csb_write(tegra, XUSB_CSB_MP_L2IMEMOP_SIZE, HwReg);
1349
1350         /* Trigger L2IMEM Load operation. */
1351         csb_write(tegra, XUSB_CSB_MP_L2IMEMOP_TRIG, L2IMEM_LOAD_LOCKED_RESULT);
1352
1353         /* Setup Falcon Auto-fill */
1354         nblocks = (cfg_tbl->boot_codesize / IMEM_BLOCK_SIZE);
1355         if ((cfg_tbl->boot_codesize % IMEM_BLOCK_SIZE) != 0)
1356                 nblocks += 1;
1357         csb_write(tegra, XUSB_FALC_IMFILLCTL, nblocks);
1358
1359         HwReg = (cfg_tbl->boot_codetag / IMEM_BLOCK_SIZE) & IMFILLRNG_TAG_MASK;
1360         HwReg |= (((cfg_tbl->boot_codetag + cfg_tbl->boot_codesize)
1361                         /IMEM_BLOCK_SIZE) - 1) << IMFILLRNG1_TAG_HI_SHIFT;
1362         csb_write(tegra, XUSB_FALC_IMFILLRNG1, HwReg);
1363
1364         csb_write(tegra, XUSB_FALC_DMACTL, 0);
1365         msleep(50);
1366
1367         csb_write(tegra, XUSB_FALC_BOOTVEC, cfg_tbl->boot_codetag);
1368
1369         /* Start Falcon CPU */
1370         csb_write(tegra, XUSB_FALC_CPUCTL, CPUCTL_STARTCPU);
1371         usleep_range(1000, 2000);
1372
1373         fw_time = cfg_tbl->fwimg_created_time;
1374         time_to_tm(fw_time, 0, &fw_tm);
1375         dev_info(&pdev->dev,
1376                 "Firmware timestamp: %ld-%02d-%02d %02d:%02d:%02d UTC, "\
1377                 "Falcon state 0x%x\n", fw_tm.tm_year + 1900,
1378                 fw_tm.tm_mon + 1, fw_tm.tm_mday, fw_tm.tm_hour,
1379                 fw_tm.tm_min, fw_tm.tm_sec,
1380                 csb_read(tegra, XUSB_FALC_CPUCTL));
1381
1382         /* return fail if firmware status is not good */
1383         if (csb_read(tegra, XUSB_FALC_CPUCTL) == XUSB_FALC_STATE_HALTED)
1384                 return -EFAULT;
1385
1386         cap_regs = IO_ADDRESS(tegra->host_phy_base);
1387         hc_caplength = HC_LENGTH(ioread32(&cap_regs->hc_capbase));
1388         op_regs = IO_ADDRESS(tegra->host_phy_base + hc_caplength);
1389
1390         /* wait for USBSTS_CNR to get set */
1391         do {
1392                 usbsts = ioread32(&op_regs->status);
1393         } while ((usbsts & STS_CNR) && count--);
1394
1395         if (!count && (usbsts & STS_CNR)) {
1396                 dev_err(&pdev->dev, "Controller not ready\n");
1397                 return -EFAULT;
1398         }
1399         return 0;
1400 }
1401
1402 static void tegra_xhci_release_port_ownership(struct tegra_xhci_hcd *tegra,
1403         bool release)
1404 {
1405         u32 reg;
1406
1407         reg = readl(tegra->padctl_base + USB2_PAD_MUX_0);
1408         reg &= ~(0xf << 0);
1409
1410         if (!release)
1411                 reg |= tegra->xusb_padctl->pad_mux;
1412
1413         writel(reg, tegra->padctl_base + USB2_PAD_MUX_0);
1414 }
1415 /* SS ELPG Entry initiated by fw */
1416 static int tegra_xhci_ss_elpg_entry(struct tegra_xhci_hcd *tegra)
1417 {
1418         struct xhci_hcd *xhci = tegra->xhci;
1419         u32 ret = 0;
1420
1421         must_have_sync_lock(tegra);
1422
1423         /* This is SS partition ELPG entry
1424          * STEP 0: firmware will set WOC WOD bits in PVTPORTSC2 regs.
1425          */
1426
1427         /* Step 0: Acquire mbox and send PWRGATE msg to firmware
1428          * only if it is sw initiated one
1429          */
1430
1431         /* STEP 1: xHCI firmware and xHCIPEP driver communicates
1432          * SuperSpeed partition ELPG entry via mailbox protocol
1433          */
1434
1435         /* STEP 2: xHCI PEP driver and XUSB device mode driver
1436          * enable the XUSB wakeup interrupts for the SuperSpeed
1437          * and USB2.0 ports assigned to host.Section 4.1 Step 3
1438          */
1439         tegra_xhci_ss_wake_on_interrupts(tegra, true);
1440
1441         /* STEP 3: xHCI PEP driver initiates the signal sequence
1442          * to enable the XUSB SSwake detection logic for the
1443          * SuperSpeed ports assigned to host.Section 4.1 Step 4
1444          */
1445         tegra_xhci_ss_wake_signal(tegra, true);
1446
1447         /* STEP 4: System Power Management driver asserts reset
1448          * to XUSB SuperSpeed partition then disables its clocks
1449          */
1450         tegra_periph_reset_assert(tegra->ss_clk);
1451         clk_disable(tegra->ss_clk);
1452
1453         usleep_range(100, 200);
1454
1455         /* STEP 5: System Power Management driver disables the
1456          * XUSB SuperSpeed partition power rails.
1457          */
1458         debug_print_portsc(xhci);
1459
1460         /* tegra_powergate_partition also does partition reset assert */
1461         ret = tegra_powergate_partition(TEGRA_POWERGATE_XUSBA);
1462         if (ret) {
1463                 xhci_err(xhci, "%s: could not powergate xusba partition\n",
1464                                 __func__);
1465                 /* TODO: error recovery? */
1466         }
1467         tegra->ss_pwr_gated = true;
1468
1469         /* STEP 6: xHCI PEP driver initiates the signal sequence
1470          * to enable the XUSB SSwake detection logic for the
1471          * SuperSpeed ports assigned to host.Section 4.1 Step 7
1472          */
1473         tegra_xhci_ss_vcore(tegra, true);
1474
1475         return ret;
1476 }
1477
1478 /* Host ELPG Entry */
1479 static int tegra_xhci_host_elpg_entry(struct tegra_xhci_hcd *tegra)
1480 {
1481         struct xhci_hcd *xhci = tegra->xhci;
1482         struct usb_hcd *hcd = xhci_to_hcd(xhci);
1483         u32 ret;
1484         u32 portsc;
1485
1486         must_have_sync_lock(tegra);
1487
1488         /* If ss is already powergated skip ss ctx save stuff */
1489         if (tegra->ss_pwr_gated) {
1490                 xhci_info(xhci, "%s: SS partition is already powergated\n",
1491                         __func__);
1492         } else {
1493                 ret = tegra_xhci_ss_elpg_entry(tegra);
1494                 if (ret) {
1495                         xhci_err(xhci, "%s: ss_elpg_entry failed %d\n",
1496                                 __func__, ret);
1497                         return ret;
1498                 }
1499         }
1500
1501         /* 1. IS INTR PENDING INT_PENDING=1 ? */
1502
1503         /* STEP 1.1: Do a context save of XUSB and IPFS registers */
1504         tegra_xhci_save_xusb_ctx(tegra);
1505
1506         portsc = readl(hcd->regs + BAR0_XHCI_OP_PORTSC(PMC_PORT_UTMIP_P2 +
1507                                                 BAR0_XHCI_OP_PORTSC_UTMIP_0));
1508         pmc_init();
1509         if (DEV_FULLSPEED(portsc))
1510                 pmc_data.port_speed = USB_PMC_PORT_SPEED_FULL;
1511         else if (DEV_HIGHSPEED(portsc))
1512                 pmc_data.port_speed = USB_PMC_PORT_SPEED_HIGH;
1513         else if (DEV_LOWSPEED(portsc))
1514                 pmc_data.port_speed = USB_PMC_PORT_SPEED_LOW;
1515         else if (DEV_SUPERSPEED(portsc))
1516                 pmc_data.port_speed = USB_PMC_PORT_SPEED_SUPER;
1517         else
1518                 pmc_data.port_speed = USB_PMC_PORT_SPEED_UNKNOWN;
1519
1520         /* RCTRL and TCTRL is programmed in pmc_data.utmip_r/tctrl_val */
1521         pmc_data.pmc_ops->setup_pmc_wake_detect(&pmc_data);
1522
1523         tegra_xhci_hs_wake_on_interrupts(tegra, true);
1524         xhci_dbg(xhci, "%s: PMC_UTMIP_UHSIC_SLEEP_CFG_0 = %x\n", __func__,
1525                 readl(tegra->pmc_base + PMC_UTMIP_UHSIC_SLEEP_CFG_0));
1526
1527         /* STEP 4: Assert reset to host clk and disable host clk */
1528         tegra_periph_reset_assert(tegra->host_clk);
1529
1530         clk_disable(tegra->host_clk);
1531
1532         /* wait 150us */
1533         usleep_range(150, 200);
1534
1535         /* flush MC client of XUSB_HOST */
1536         tegra_powergate_mc_flush(TEGRA_POWERGATE_XUSBC);
1537
1538         /* STEP 4: Powergate host partition */
1539         /* tegra_powergate_partition also does partition reset assert */
1540         ret = tegra_powergate_partition(TEGRA_POWERGATE_XUSBC);
1541         if (ret) {
1542                 xhci_err(xhci, "%s: could not unpowergate xusbc partition %d\n",
1543                         __func__, ret);
1544                 /* TODO: error handling? */
1545                 return ret;
1546         }
1547         tegra->host_pwr_gated = true;
1548
1549         clk_disable(tegra->pll_re_vco_clk);
1550         clk_disable(tegra->emc_clk);
1551         /* set port ownership to SNPS */
1552         tegra_xhci_release_port_ownership(tegra, true);
1553
1554         xhci_dbg(xhci, "%s: PMC_UTMIP_UHSIC_SLEEP_CFG_0 = %x\n", __func__,
1555                 readl(tegra->pmc_base + PMC_UTMIP_UHSIC_SLEEP_CFG_0));
1556
1557         xhci_info(xhci, "%s: elpg_entry: completed\n", __func__);
1558         xhci_dbg(xhci, "%s: HOST POWER STATUS = %d\n",
1559                 __func__, tegra_powergate_is_powered(TEGRA_POWERGATE_XUSBC));
1560         return ret;
1561 }
1562
1563 /* SS ELPG Exit triggered by PADCTL irq */
1564 /**
1565  * tegra_xhci_ss_partition_elpg_exit - bring XUSBA partition out from elpg
1566  *
1567  * This function must be called with tegra->sync_lock acquired.
1568  *
1569  * @tegra: xhci controller context
1570  * @return 0 for success, or error numbers
1571  */
1572 static int tegra_xhci_ss_partition_elpg_exit(struct tegra_xhci_hcd *tegra)
1573 {
1574         struct xhci_hcd *xhci = tegra->xhci;
1575         int ret = 0;
1576
1577         must_have_sync_lock(tegra);
1578
1579         if (tegra->ss_pwr_gated && (tegra->ss_wake_event ||
1580                         tegra->hs_wake_event || tegra->host_resume_req)) {
1581
1582                 /*
1583                  * PWR_UNGATE SS partition. XUSBA
1584                  * tegra_unpowergate_partition also does partition reset
1585                  * deassert
1586                  */
1587                 ret = tegra_unpowergate_partition(TEGRA_POWERGATE_XUSBA);
1588                 if (ret) {
1589                         xhci_err(xhci,
1590                         "%s: could not unpowergate xusba partition %d\n",
1591                         __func__, ret);
1592                         goto out;
1593                 }
1594                 if (tegra->ss_wake_event)
1595                         tegra->ss_wake_event = false;
1596
1597         } else {
1598                 xhci_info(xhci, "%s: ss already power gated\n",
1599                         __func__);
1600                 return ret;
1601         }
1602
1603         /* Step 3: Enable clock to ss partition */
1604         clk_enable(tegra->ss_clk);
1605
1606         /* Step 4: Disable ss wake detection logic */
1607         tegra_xhci_ss_wake_on_interrupts(tegra, false);
1608
1609         /* Step 4.1: Disable ss wake detection logic */
1610         tegra_xhci_ss_vcore(tegra, false);
1611
1612         /* wait 150us */
1613         usleep_range(150, 200);
1614
1615         /* Step 4.2: Disable ss wake detection logic */
1616         tegra_xhci_ss_wake_signal(tegra, false);
1617
1618         /* Step 6 Deassert reset for ss clks */
1619         tegra_periph_reset_deassert(tegra->ss_clk);
1620
1621         xhci_dbg(xhci, "%s: SS ELPG EXIT. ALL DONE\n", __func__);
1622         tegra->ss_pwr_gated = false;
1623 out:
1624         return ret;
1625 }
1626
1627 static void ss_partition_elpg_exit_work(struct work_struct *work)
1628 {
1629         struct tegra_xhci_hcd *tegra = container_of(work, struct tegra_xhci_hcd,
1630                 ss_elpg_exit_work);
1631
1632         mutex_lock(&tegra->sync_lock);
1633         tegra_xhci_ss_partition_elpg_exit(tegra);
1634         mutex_unlock(&tegra->sync_lock);
1635 }
1636
1637 /* read pmc WAKE2_STATUS register to know if SS port caused remote wake */
1638 static void update_remote_wakeup_ports_pmc(struct tegra_xhci_hcd *tegra)
1639 {
1640         struct xhci_hcd *xhci = tegra->xhci;
1641         u32 wake2_status;
1642
1643 #define PMC_WAKE2_STATUS        0x168
1644 #define PADCTL_WAKE             (1 << (58 - 32)) /* PADCTL is WAKE#58 */
1645
1646         wake2_status = ioread32(tegra->pmc_base + PMC_WAKE2_STATUS);
1647
1648         if (wake2_status & PADCTL_WAKE) {
1649                 /* FIXME: This is customized for Dalmore, find a generic way */
1650                 set_bit(0, &tegra->usb3_rh_remote_wakeup_ports);
1651                 /* clear wake status */
1652                 iowrite32(PADCTL_WAKE, tegra->pmc_base + PMC_WAKE2_STATUS);
1653         }
1654
1655         xhci_dbg(xhci, "%s: usb3 roothub remote_wakeup_ports 0x%lx\n",
1656                         __func__, tegra->usb3_rh_remote_wakeup_ports);
1657 }
1658
1659 static void wait_remote_wakeup_ports(struct usb_hcd *hcd)
1660 {
1661         struct xhci_hcd *xhci = hcd_to_xhci(hcd);
1662         struct tegra_xhci_hcd *tegra = hcd_to_tegra_xhci(hcd);
1663         int port, num_ports;
1664         unsigned long *remote_wakeup_ports;
1665         u32 portsc;
1666         __le32 __iomem  **port_array;
1667         unsigned char *rh;
1668         unsigned int retry = 64;
1669
1670
1671         if (hcd == xhci->shared_hcd) {
1672                 port_array = xhci->usb3_ports;
1673                 num_ports = xhci->num_usb3_ports;
1674                 remote_wakeup_ports = &tegra->usb3_rh_remote_wakeup_ports;
1675                 rh = "usb3 roothub";
1676         } else
1677                 return;
1678
1679         while (*remote_wakeup_ports && retry--) {
1680                 for_each_set_bit(port, remote_wakeup_ports, num_ports) {
1681                         portsc = xhci_readl(xhci, port_array[port]);
1682
1683                         if (!(portsc & PORT_CONNECT)) {
1684                                 /* nothing to do if already disconnected */
1685                                 clear_bit(port, remote_wakeup_ports);
1686                                 continue;
1687                         }
1688
1689                         if ((portsc & PORT_PLS_MASK) == XDEV_U0)
1690                                 clear_bit(port, remote_wakeup_ports);
1691                         else
1692                                 xhci_dbg(xhci, "%s: %s port %d status 0x%x\n",
1693                                                 __func__, rh, port, portsc);
1694                 }
1695
1696                 if (*remote_wakeup_ports)
1697                         msleep(20); /* give some time, irq will direct U0 */
1698         }
1699
1700         xhci_dbg(xhci, "%s: %s remote_wakeup_ports 0x%lx\n", __func__, rh,
1701                         *remote_wakeup_ports);
1702 }
1703
1704 static void tegra_xhci_war_for_tctrl_rctrl(struct tegra_xhci_hcd *tegra)
1705 {
1706         u32 reg, utmip_rctrl_val, utmip_tctrl_val;
1707         struct tegra_xusb_pad_data *xusb_padctl = tegra->xusb_padctl;
1708
1709         /* Program XUSB as port owner for both Port 0 and port 1 */
1710         reg = readl(tegra->padctl_base + USB2_PAD_MUX_0);
1711         reg &= ~(0xf << 0);
1712         reg |= (1 << 0) | (1 << 2);
1713         writel(reg, tegra->padctl_base + USB2_PAD_MUX_0);
1714
1715         /* XUSB_PADCTL_USB2_BIAS_PAD_CTL_0_0::PD = 0 and
1716          * XUSB_PADCTL_USB2_BIAS_PAD_CTL_0_0::PD_TRK = 0
1717          */
1718         reg = readl(tegra->padctl_base + USB2_BIAS_PAD_CTL_0_0);
1719         reg &= ~((1 << 12) | (1 << 13));
1720         writel(reg, tegra->padctl_base + USB2_BIAS_PAD_CTL_0_0);
1721
1722         /* wait 20us */
1723         usleep_range(20, 30);
1724
1725         /* Read XUSB_PADCTL:: XUSB_PADCTL_USB2_BIAS_PAD_CTL_1_0
1726          * :: TCTRL and RCTRL
1727          */
1728         reg = readl(tegra->padctl_base + USB2_BIAS_PAD_CTL_1_0);
1729         utmip_rctrl_val = RCTRL(reg);
1730         utmip_tctrl_val = TCTRL(reg);
1731
1732         /*
1733          * tctrl_val = 0x1f - (16 - ffz(utmip_tctrl_val)
1734          * rctrl_val = 0x1f - (16 - ffz(utmip_rctrl_val)
1735          */
1736         pmc_data.utmip_rctrl_val = 0xf + ffz(utmip_rctrl_val);
1737         pmc_data.utmip_tctrl_val = 0xf + ffz(utmip_tctrl_val);
1738
1739         xhci_dbg(tegra->xhci, "rctrl_val = 0x%x, tctrl_val = 0x%x\n",
1740                 pmc_data.utmip_rctrl_val, pmc_data.utmip_tctrl_val);
1741
1742         /* XUSB_PADCTL_USB2_BIAS_PAD_CTL_0_0::PD = 1 and
1743          * XUSB_PADCTL_USB2_BIAS_PAD_CTL_0_0::PD_TRK = 1
1744          */
1745         reg = readl(tegra->padctl_base + USB2_BIAS_PAD_CTL_0_0);
1746         reg |= (1 << 12) | (1 << 13);
1747         writel(reg, tegra->padctl_base + USB2_BIAS_PAD_CTL_0_0);
1748
1749         /* Program these values into PMC regiseter and program the
1750          * PMC override
1751          */
1752         reg = PMC_TCTRL_VAL(pmc_data.utmip_tctrl_val) |
1753                 PMC_RCTRL_VAL(pmc_data.utmip_rctrl_val);
1754         writel(reg, tegra->pmc_base + PMC_UTMIP_TERM_PAD_CFG);
1755
1756         reg = readl(tegra->pmc_base + PMC_SLEEP_CFG);
1757         reg |= UTMIP_RCTRL_USE_PMC_P2 | UTMIP_TCTRL_USE_PMC_P2;
1758         writel(reg, tegra->pmc_base + PMC_SLEEP_CFG);
1759
1760         /* Restore correct port ownership in padctl */
1761         reg = readl(tegra->padctl_base + USB2_PAD_MUX_0);
1762         reg &= ~(0xf << 0);
1763         reg |= xusb_padctl->pad_mux;
1764         writel(reg, tegra->padctl_base + USB2_PAD_MUX_0);
1765 }
1766
1767 /* Host ELPG Exit triggered by PADCTL irq */
1768 /**
1769  * tegra_xhci_host_partition_elpg_exit - bring XUSBC partition out from elpg
1770  *
1771  * This function must be called with tegra->sync_lock acquired.
1772  *
1773  * @tegra: xhci controller context
1774  * @return 0 for success, or error numbers
1775  */
1776 static int
1777 tegra_xhci_host_partition_elpg_exit(struct tegra_xhci_hcd *tegra)
1778 {
1779         struct xhci_hcd *xhci = tegra->xhci;
1780         int ret = 0;
1781
1782         must_have_sync_lock(tegra);
1783
1784         if (!tegra->hc_in_elpg)
1785                 return 0;
1786
1787         clk_enable(tegra->emc_clk);
1788         clk_enable(tegra->pll_re_vco_clk);
1789         /* Step 2: Enable clock to host partition */
1790         clk_enable(tegra->host_clk);
1791
1792         if (tegra->lp0_exit) {
1793                 u32 reg;
1794
1795                 tegra_xhci_war_for_tctrl_rctrl(tegra);
1796                 /* check if over current seen. Clear if present */
1797                 reg = readl(tegra->padctl_base + OC_DET_0);
1798                 xhci_dbg(xhci, "%s: OC_DET_0=0x%x\n", __func__, reg);
1799                 if (reg & (0x3 << 20)) {
1800                         xhci_info(xhci, "Over current detected. Clearing...\n");
1801                         writel(reg, tegra->padctl_base + OC_DET_0);
1802
1803                         usleep_range(100, 200);
1804
1805                         reg = readl(tegra->padctl_base + OC_DET_0);
1806                         if (reg & (0x3 << 20))
1807                                 xhci_info(xhci, "Over current still present\n");
1808                 }
1809                 tegra_xhci_padctl_portmap_and_caps(tegra);
1810                 /* release clamps post deassert */
1811                 tegra_xhci_padctl_enable_usb_vbus(tegra);
1812                 tegra->lp0_exit = false;
1813         }
1814
1815         /* Clear FLUSH_ENABLE of MC client */
1816         tegra_powergate_mc_flush_done(TEGRA_POWERGATE_XUSBC);
1817
1818         /* set port ownership back to xusb */
1819         tegra_xhci_release_port_ownership(tegra, false);
1820
1821         /*
1822          * PWR_UNGATE Host partition. XUSBC
1823          * tegra_unpowergate_partition also does partition reset deassert
1824          */
1825         ret = tegra_unpowergate_partition(TEGRA_POWERGATE_XUSBC);
1826         if (ret) {
1827                 xhci_err(xhci, "%s: could not unpowergate xusbc partition %d\n",
1828                         __func__, ret);
1829                 goto out;
1830         }
1831
1832         /* Step 4: Deassert reset to host partition clk */
1833         tegra_periph_reset_deassert(tegra->host_clk);
1834
1835         /* Step 6.1: IPFS and XUSB BAR initialization */
1836         tegra_xhci_cfg(tegra);
1837
1838         /* Step 6.2: IPFS and XUSB related restore */
1839         tegra_xhci_restore_ctx(tegra);
1840
1841         /* Step 8: xhci spec related ctx restore
1842          * will be done in xhci_resume().Do it here.
1843          */
1844
1845         tegra_xhci_ss_partition_elpg_exit(tegra);
1846
1847         /* Change SS clock source to HSIC_480 and set ss_src_clk at 120MHz */
1848         if (clk_get_rate(tegra->ss_src_clk) == 12000000) {
1849                 clk_set_rate(tegra->ss_src_clk,  3000 * 1000);
1850                 clk_set_parent(tegra->ss_src_clk, tegra->pll_u_480M);
1851         }
1852
1853         /* clear ovrd bits */
1854         tegra_xhci_rx_idle_mode_override(tegra, false);
1855
1856         /* Load firmware */
1857         xhci_dbg(xhci, "%s: elpg_exit: loading firmware from pmc.\n"
1858                         "ss (p1=0x%x, p2=0x%x, p3=0x%x), "
1859                         "hs (p1=0x%x, p2=0x%x, p3=0x%x),\n"
1860                         "fs (p1=0x%x, p2=0x%x, p3=0x%x)\n",
1861                         __func__,
1862                         csb_read(tegra, XUSB_FALC_SS_PVTPORTSC1),
1863                         csb_read(tegra, XUSB_FALC_SS_PVTPORTSC2),
1864                         csb_read(tegra, XUSB_FALC_SS_PVTPORTSC3),
1865                         csb_read(tegra, XUSB_FALC_HS_PVTPORTSC1),
1866                         csb_read(tegra, XUSB_FALC_HS_PVTPORTSC2),
1867                         csb_read(tegra, XUSB_FALC_HS_PVTPORTSC3),
1868                         csb_read(tegra, XUSB_FALC_FS_PVTPORTSC1),
1869                         csb_read(tegra, XUSB_FALC_FS_PVTPORTSC2),
1870                         csb_read(tegra, XUSB_FALC_FS_PVTPORTSC3));
1871         debug_print_portsc(xhci);
1872
1873         ret = load_firmware(tegra, false /* EPLG exit, do not reset ARU */);
1874         if (ret < 0) {
1875                 xhci_err(xhci, "%s: failed to load firmware %d\n",
1876                         __func__, ret);
1877                 goto out;
1878         }
1879
1880         pmc_init();
1881         pmc_data.pmc_ops->disable_pmc_bus_ctrl(&pmc_data, 0);
1882
1883         tegra->hc_in_elpg = false;
1884         ret = xhci_resume(tegra->xhci, 0);
1885         if (ret) {
1886                 xhci_err(xhci, "%s: could not resume right %d\n",
1887                                 __func__, ret);
1888                 goto out;
1889         }
1890
1891         update_remote_wakeup_ports_pmc(tegra);
1892
1893         if (tegra->hs_wake_event)
1894                 tegra->hs_wake_event = false;
1895
1896         if (tegra->host_resume_req)
1897                 tegra->host_resume_req = false;
1898
1899         xhci_info(xhci, "elpg_exit: completed: lp0/elpg time=%d msec\n",
1900                 jiffies_to_msecs(jiffies - tegra->last_jiffies));
1901
1902         tegra->host_pwr_gated = false;
1903 out:
1904         return ret;
1905 }
1906
1907 static void host_partition_elpg_exit_work(struct work_struct *work)
1908 {
1909         struct tegra_xhci_hcd *tegra = container_of(work, struct tegra_xhci_hcd,
1910                 host_elpg_exit_work);
1911
1912         mutex_lock(&tegra->sync_lock);
1913         tegra_xhci_host_partition_elpg_exit(tegra);
1914         mutex_unlock(&tegra->sync_lock);
1915 }
1916
1917 /* Mailbox handling function. This function handles requests
1918  * from firmware and communicates with clock and powergating
1919  * module to alter clock rates and to power gate/ungate xusb
1920  * partitions.
1921  *
1922  * Following is the structure of mailbox messages.
1923  * bit 31:28 - msg type
1924  * bits 27:0 - mbox data
1925  * FIXME:  Check if we can just call clock functions like below
1926  * or should we schedule it for calling later ?
1927  */
1928
1929 static void
1930 tegra_xhci_process_mbox_message(struct work_struct *work)
1931 {
1932         u32 sw_resp = 0, cmd, data_in, fw_msg;
1933         int ret = 0;
1934         struct tegra_xhci_hcd *tegra = container_of(work, struct tegra_xhci_hcd,
1935                                         mbox_work);
1936         struct xhci_hcd *xhci = tegra->xhci;
1937         unsigned int freq_khz;
1938         bool send_ack_to_fw = true;
1939
1940         mutex_lock(&tegra->mbox_lock);
1941
1942         /* get the owner id */
1943         tegra->mbox_owner = readl(tegra->fpci_base + XUSB_CFG_ARU_MBOX_OWNER);
1944         tegra->mbox_owner &= MBOX_OWNER_ID_MASK;
1945
1946         /* get the mbox message from firmware */
1947         fw_msg = readl(tegra->fpci_base + XUSB_CFG_ARU_MBOX_DATA_OUT);
1948
1949         data_in = readl(tegra->fpci_base + XUSB_CFG_ARU_MBOX_DATA_IN);
1950         if (data_in) {
1951                 mutex_unlock(&tegra->mbox_lock);
1952                 return;
1953         }
1954
1955         /* get cmd type and cmd data */
1956         tegra->cmd_type = (fw_msg & MBOX_CMD_TYPE_MASK) >> MBOX_CMD_SHIFT;
1957         tegra->cmd_data = (fw_msg & MBOX_CMD_DATA_MASK);
1958
1959         /* decode the message and make appropriate requests to
1960          * clock or powergating module.
1961          */
1962
1963         switch (tegra->cmd_type) {
1964         case MBOX_CMD_INC_FALC_CLOCK:
1965         case MBOX_CMD_DEC_FALC_CLOCK:
1966                 ret = tegra_xusb_request_clk_rate(
1967                                 tegra,
1968                                 tegra->falc_clk,
1969                                 tegra->cmd_data,
1970                                 &sw_resp);
1971                 if (ret)
1972                         xhci_err(xhci, "%s: could not set required falc rate\n",
1973                                 __func__);
1974                 goto send_sw_response;
1975         case MBOX_CMD_INC_SSPI_CLOCK:
1976         case MBOX_CMD_DEC_SSPI_CLOCK:
1977                 ret = tegra_xusb_request_clk_rate(
1978                                 tegra,
1979                                 tegra->ss_src_clk,
1980                                 tegra->cmd_data,
1981                                 &sw_resp);
1982                 if (ret)
1983                         xhci_err(xhci, "%s: could not set required ss rate.\n",
1984                                 __func__);
1985                 goto send_sw_response;
1986         case MBOX_CMD_SET_BW:
1987                 /* fw sends BW request in MByte/sec */
1988                 freq_khz = tegra_emc_bw_to_freq_req(tegra->cmd_data << 10);
1989                 clk_set_rate(tegra->emc_clk, freq_khz * 1000);
1990
1991                 /* clear mbox owner as ACK will not be sent for this request */
1992                 writel(0, tegra->fpci_base + XUSB_CFG_ARU_MBOX_OWNER);
1993                 send_ack_to_fw = false;
1994
1995                 goto send_sw_response;
1996         case MBOX_CMD_SAVE_DFE_CTLE_CTX:
1997                 tegra_xhci_save_dfe_ctle_context(tegra);
1998                 tegra_xhci_restore_dfe_ctle_context(tegra);
1999                 sw_resp |= (MBOX_CMD_ACK << MBOX_CMD_SHIFT);
2000                 goto send_sw_response;
2001         case MBOX_CMD_ACK:
2002                 writel(0, tegra->fpci_base + XUSB_CFG_ARU_MBOX_CMD);
2003                 writel(0, tegra->fpci_base + XUSB_CFG_ARU_MBOX_OWNER);
2004                 break;
2005         case MBOX_CMD_NACK:
2006                 writel(0, tegra->fpci_base + XUSB_CFG_ARU_MBOX_CMD);
2007                 writel(0, tegra->fpci_base + XUSB_CFG_ARU_MBOX_OWNER);
2008                 break;
2009         default:
2010                 xhci_err(xhci, "%s: invalid cmdtype %d\n",
2011                                 __func__, tegra->cmd_type);
2012         }
2013         mutex_unlock(&tegra->mbox_lock);
2014         return;
2015
2016 send_sw_response:
2017         if (send_ack_to_fw) {
2018                 writel(sw_resp, tegra->fpci_base + XUSB_CFG_ARU_MBOX_DATA_IN);
2019                 cmd = readl(tegra->fpci_base + XUSB_CFG_ARU_MBOX_CMD);
2020                 cmd |= MBOX_INT_EN | MBOX_FALC_INT_EN;
2021                 writel(cmd, tegra->fpci_base + XUSB_CFG_ARU_MBOX_CMD);
2022         }
2023
2024         mutex_unlock(&tegra->mbox_lock);
2025 }
2026
2027 static irqreturn_t tegra_xhci_xusb_host_irq(int irq, void *ptrdev)
2028 {
2029         struct tegra_xhci_hcd *tegra = (struct tegra_xhci_hcd *) ptrdev;
2030         struct xhci_hcd *xhci = tegra->xhci;
2031
2032         xhci_dbg(xhci, "%s", __func__);
2033         return IRQ_HANDLED;
2034 }
2035
2036 static irqreturn_t tegra_xhci_padctl_irq(int irq, void *ptrdev)
2037 {
2038         struct tegra_xhci_hcd *tegra = (struct tegra_xhci_hcd *) ptrdev;
2039         struct xhci_hcd *xhci = tegra->xhci;
2040         u32 elpg_program0 = 0;
2041
2042         spin_lock(&tegra->lock);
2043
2044         tegra->last_jiffies = jiffies;
2045
2046         /* Check the intr cause. Could be  USB2 or HSIC or SS wake events */
2047         elpg_program0 = readl(tegra->padctl_base + ELPG_PROGRAM_0);
2048
2049         /* Clear the interrupt cause. We already read the intr status. */
2050         tegra_xhci_ss_wake_on_interrupts(tegra, false);
2051         tegra_xhci_hs_wake_on_interrupts(tegra, false);
2052
2053         xhci_dbg(xhci, "%s: elpg_program0 = %x\n",
2054                 __func__, elpg_program0);
2055         xhci_dbg(xhci, "%s: PMC REGISTER = %x\n",
2056                 __func__, readl(tegra->pmc_base + PMC_UTMIP_UHSIC_SLEEP_CFG_0));
2057         xhci_dbg(xhci, "%s: PAD ELPG_PROGRAM_0 INTERRUPT REGISTER = %x\n",
2058                 __func__, readl(tegra->padctl_base + ELPG_PROGRAM_0));
2059         xhci_dbg(xhci, "%s: OC_DET Register = %x\n",
2060                 __func__, readl(tegra->padctl_base + OC_DET_0));
2061         xhci_dbg(xhci, "%s: USB2_BATTERY_CHRG_OTGPAD0_0 Register = %x\n",
2062                 __func__,
2063                 readl(tegra->padctl_base + USB2_BATTERY_CHRG_OTGPAD0_0));
2064         xhci_dbg(xhci, "%s: USB2_BATTERY_CHRG_OTGPAD1_0 Register = %x\n",
2065                 __func__,
2066                 readl(tegra->padctl_base + USB2_BATTERY_CHRG_OTGPAD1_0));
2067         xhci_dbg(xhci, "%s: USB2_BATTERY_CHRG_BIASPAD_0 Register = %x\n",
2068                 __func__,
2069                 readl(tegra->padctl_base + USB2_BATTERY_CHRG_BIASPAD_0));
2070
2071         if (elpg_program0 & (SS_PORT0_WAKEUP_EVENT | SS_PORT1_WAKEUP_EVENT))
2072                 tegra->ss_wake_event = true;
2073         else if (elpg_program0 &
2074                         (USB2_PORT0_WAKEUP_EVENT | USB2_PORT1_WAKEUP_EVENT))
2075                 tegra->hs_wake_event = true;
2076
2077         if (tegra->ss_wake_event || tegra->hs_wake_event) {
2078                 if (tegra->ss_pwr_gated && !tegra->host_pwr_gated) {
2079                         xhci_err(xhci, "SS gated Host ungated. Should not happen\n");
2080                         WARN_ON(tegra->ss_pwr_gated && tegra->host_pwr_gated);
2081                 } else if (tegra->ss_pwr_gated
2082                                 && tegra->host_pwr_gated) {
2083                         xhci_dbg(xhci, "[%s] schedule host_elpg_exit_work\n",
2084                                 __func__);
2085                         schedule_work(&tegra->host_elpg_exit_work);
2086                 }
2087         } else {
2088                 xhci_err(xhci, "error: wake due to no hs/ss event\n");
2089                 writel(0xffffffff, tegra->padctl_base + ELPG_PROGRAM_0);
2090         }
2091         spin_unlock(&tegra->lock);
2092         return IRQ_HANDLED;
2093 }
2094
2095 static irqreturn_t tegra_xhci_smi_irq(int irq, void *ptrdev)
2096 {
2097         struct tegra_xhci_hcd *tegra = (struct tegra_xhci_hcd *) ptrdev;
2098         u32 temp;
2099
2100         spin_lock(&tegra->lock);
2101
2102         /* clear the mbox intr status 1st thing. Other
2103          * bits are W1C bits, so just write to SMI bit.
2104          */
2105
2106         temp = readl(tegra->fpci_base + XUSB_CFG_ARU_SMI_INTR);
2107
2108         /* write 1 to clear SMI INTR en bit ( bit 3 ) */
2109         temp = MBOX_SMI_INTR_EN;
2110         writel(temp, tegra->fpci_base + XUSB_CFG_ARU_SMI_INTR);
2111
2112         schedule_work(&tegra->mbox_work);
2113
2114         spin_unlock(&tegra->lock);
2115         return IRQ_HANDLED;
2116 }
2117
2118 static void tegra_xhci_plat_quirks(struct device *dev, struct xhci_hcd *xhci)
2119 {
2120         /*
2121          * As of now platform drivers don't provide MSI support so we ensure
2122          * here that the generic code does not try to make a pci_dev from our
2123          * dev struct in order to setup MSI
2124          */
2125         xhci->quirks |= XHCI_BROKEN_MSI;
2126         xhci->quirks &= ~XHCI_SPURIOUS_REBOOT;
2127 }
2128
2129 /* called during probe() after chip reset completes */
2130 static int xhci_plat_setup(struct usb_hcd *hcd)
2131 {
2132         return xhci_gen_setup(hcd, tegra_xhci_plat_quirks);
2133 }
2134
2135 static int tegra_xhci_request_mem_region(struct platform_device *pdev,
2136         const char *name, void __iomem **region)
2137 {
2138         struct resource *res;
2139         void __iomem *mem;
2140
2141         res = platform_get_resource_byname(pdev, IORESOURCE_MEM, name);
2142         if (!res) {
2143                 dev_err(&pdev->dev, "memory resource %s doesn't exist\n", name);
2144                 return -ENODEV;
2145         }
2146
2147         mem = devm_request_and_ioremap(&pdev->dev, res);
2148         if (!mem) {
2149                 dev_err(&pdev->dev, "failed to ioremap for %s\n", name);
2150                 return -EFAULT;
2151         }
2152         *region = mem;
2153
2154         return 0;
2155 }
2156
2157 static int tegra_xhci_request_irq(struct platform_device *pdev,
2158         const char *rscname, irq_handler_t handler, unsigned long irqflags,
2159         const char *devname, int *irq_no)
2160 {
2161         int ret;
2162         struct tegra_xhci_hcd *tegra = platform_get_drvdata(pdev);
2163         struct resource *res;
2164
2165         res = platform_get_resource_byname(pdev, IORESOURCE_IRQ, rscname);
2166         if (!res) {
2167                 dev_err(&pdev->dev, "irq resource %s doesn't exist\n", rscname);
2168                 return -ENODEV;
2169         }
2170
2171         ret = devm_request_irq(&pdev->dev, res->start, handler, irqflags,
2172                         devname, tegra);
2173         if (ret != 0) {
2174                 dev_err(&pdev->dev,
2175                         "failed to request_irq for %s (irq %d), error = %d\n",
2176                         devname, res->start, ret);
2177                 return ret;
2178         }
2179         *irq_no = res->start;
2180
2181         return 0;
2182 }
2183
2184 #ifdef CONFIG_PM
2185
2186 static int tegra_xhci_bus_suspend(struct usb_hcd *hcd)
2187 {
2188         struct tegra_xhci_hcd *tegra = hcd_to_tegra_xhci(hcd);
2189         struct xhci_hcd *xhci = hcd_to_xhci(hcd);
2190         int err = 0;
2191         unsigned long flags;
2192
2193         mutex_lock(&tegra->sync_lock);
2194
2195         if (xhci->shared_hcd == hcd) {
2196                 tegra->usb3_rh_suspend = true;
2197                 xhci_dbg(xhci, "%s: usb3 root hub\n", __func__);
2198         } else if (xhci->main_hcd == hcd) {
2199                 tegra->usb2_rh_suspend = true;
2200                 xhci_dbg(xhci, "%s: usb2 root hub\n", __func__);
2201         }
2202
2203         WARN_ON(tegra->hc_in_elpg);
2204
2205         /* suspend xhci bus. This will also set remote mask */
2206         err = xhci_bus_suspend(hcd);
2207         if (err) {
2208                 xhci_err(xhci, "%s: xhci_bus_suspend failed %d\n",
2209                                 __func__, err);
2210                 goto xhci_bus_suspend_failed;
2211         }
2212
2213         if (!(tegra->usb2_rh_suspend && tegra->usb3_rh_suspend))
2214                 goto done; /* one of the root hubs is still working */
2215
2216         spin_lock_irqsave(&tegra->lock, flags);
2217         tegra->hc_in_elpg = true;
2218         spin_unlock_irqrestore(&tegra->lock, flags);
2219
2220         WARN_ON(tegra->ss_pwr_gated && tegra->host_pwr_gated);
2221
2222         /* save xhci spec ctx. Already done by xhci_suspend */
2223         err = xhci_suspend(tegra->xhci);
2224         if (err) {
2225                 xhci_err(xhci, "%s: xhci_suspend failed %d\n", __func__, err);
2226                 goto xhci_suspend_failed;
2227         }
2228
2229         /* Powergate host. Include ss power gate if not already done */
2230         err = tegra_xhci_host_elpg_entry(tegra);
2231         if (err) {
2232                 xhci_err(xhci, "%s: unable to perform elpg entry %d\n",
2233                                 __func__, err);
2234                 goto tegra_xhci_host_elpg_entry_failed;
2235         }
2236
2237         /* At this point,ensure ss/hs intr enables are always on */
2238         tegra_xhci_ss_wake_on_interrupts(tegra, true);
2239         tegra_xhci_hs_wake_on_interrupts(tegra, true);
2240
2241 done:
2242         /* pads are disabled only if usb2 root hub in xusb is idle */
2243         /* pads will actually be disabled only when all usb2 ports are idle */
2244         if (xhci->main_hcd == hcd) {
2245                 utmi_phy_pad_disable();
2246                 utmi_phy_iddq_override(true);
2247         } else if (xhci->shared_hcd == hcd) {
2248                 /* save leakage power when SS not in use.
2249                  * This is also done when fw mbox message is received for freq
2250                  * decrease but on T114 we don't change freq due to sw WAR
2251                  * used for hs disconnect issue.
2252                  */
2253                 tegra_xhci_rx_idle_mode_override(tegra, true);
2254         }
2255         mutex_unlock(&tegra->sync_lock);
2256         return 0;
2257
2258 tegra_xhci_host_elpg_entry_failed:
2259
2260 xhci_suspend_failed:
2261         tegra->hc_in_elpg = false;
2262 xhci_bus_suspend_failed:
2263         if (xhci->shared_hcd == hcd)
2264                 tegra->usb3_rh_suspend = false;
2265         else if (xhci->main_hcd == hcd)
2266                 tegra->usb2_rh_suspend = false;
2267
2268         mutex_unlock(&tegra->sync_lock);
2269         return err;
2270 }
2271
2272 /* First, USB2HCD and then USB3HCD resume will be called */
2273 static int tegra_xhci_bus_resume(struct usb_hcd *hcd)
2274 {
2275         struct tegra_xhci_hcd *tegra = hcd_to_tegra_xhci(hcd);
2276         struct xhci_hcd *xhci = hcd_to_xhci(hcd);
2277         int err = 0;
2278
2279         mutex_lock(&tegra->sync_lock);
2280
2281         tegra->host_resume_req = true;
2282
2283         if (xhci->shared_hcd == hcd)
2284                 xhci_dbg(xhci, "%s: usb3 root hub\n", __func__);
2285         else if (xhci->main_hcd == hcd)
2286                 xhci_dbg(xhci, "%s: usb2 root hub\n", __func__);
2287
2288         /* pads are disabled only if usb2 root hub in xusb is idle */
2289         /* pads will actually be disabled only when all usb2 ports are idle */
2290         if (xhci->main_hcd == hcd && tegra->usb2_rh_suspend) {
2291                 utmi_phy_pad_enable();
2292                 utmi_phy_iddq_override(false);
2293         } else if (xhci->shared_hcd == hcd && tegra->usb3_rh_suspend) {
2294                 /* clear ovrd bits */
2295                 tegra_xhci_rx_idle_mode_override(tegra, false);
2296         }
2297         if (tegra->usb2_rh_suspend && tegra->usb3_rh_suspend) {
2298                 if (tegra->ss_pwr_gated && tegra->host_pwr_gated)
2299                         tegra_xhci_host_partition_elpg_exit(tegra);
2300         }
2301
2302          /* handle remote wakeup before resuming bus */
2303         wait_remote_wakeup_ports(hcd);
2304
2305         err = xhci_bus_resume(hcd);
2306         if (err) {
2307                 xhci_err(xhci, "%s: xhci_bus_resume failed %d\n",
2308                                 __func__, err);
2309                 goto xhci_bus_resume_failed;
2310         }
2311
2312         if (xhci->shared_hcd == hcd)
2313                 tegra->usb3_rh_suspend = false;
2314         else if (xhci->main_hcd == hcd)
2315                 tegra->usb2_rh_suspend = false;
2316
2317         mutex_unlock(&tegra->sync_lock);
2318         return 0;
2319
2320 xhci_bus_resume_failed:
2321         /* TODO: reverse elpg? */
2322         mutex_unlock(&tegra->sync_lock);
2323         return err;
2324 }
2325 #endif
2326
2327 static irqreturn_t tegra_xhci_irq(struct usb_hcd *hcd)
2328 {
2329         struct tegra_xhci_hcd *tegra = hcd_to_tegra_xhci(hcd);
2330         struct xhci_hcd *xhci = hcd_to_xhci(hcd);
2331         irqreturn_t iret = IRQ_HANDLED;
2332         u32 status;
2333
2334         spin_lock(&tegra->lock);
2335         if (tegra->hc_in_elpg) {
2336                 spin_lock(&xhci->lock);
2337                 if (HCD_HW_ACCESSIBLE(hcd)) {
2338                         status = xhci_readl(xhci, &xhci->op_regs->status);
2339                         status |= STS_EINT;
2340                         xhci_writel(xhci, status, &xhci->op_regs->status);
2341                 }
2342                 xhci_dbg(xhci, "%s: schedule host_elpg_exit_work\n",
2343                                 __func__);
2344                 schedule_work(&tegra->host_elpg_exit_work);
2345                 spin_unlock(&xhci->lock);
2346         } else
2347                 iret = xhci_irq(hcd);
2348         spin_unlock(&tegra->lock);
2349
2350         return iret;
2351 }
2352
2353
2354 static const struct hc_driver tegra_plat_xhci_driver = {
2355         .description =          "tegra-xhci",
2356         .product_desc =         "Nvidia xHCI Host Controller",
2357         .hcd_priv_size =        sizeof(struct xhci_hcd *),
2358
2359         /*
2360          * generic hardware linkage
2361          */
2362         .irq =                  tegra_xhci_irq,
2363         .flags =                HCD_MEMORY | HCD_USB3 | HCD_SHARED,
2364
2365         /*
2366          * basic lifecycle operations
2367          */
2368         .reset =                xhci_plat_setup,
2369         .start =                xhci_run,
2370         .stop =                 xhci_stop,
2371         .shutdown =             xhci_shutdown,
2372
2373         /*
2374          * managing i/o requests and associated device resources
2375          */
2376         .urb_enqueue =          xhci_urb_enqueue,
2377         .urb_dequeue =          xhci_urb_dequeue,
2378         .alloc_dev =            xhci_alloc_dev,
2379         .free_dev =             xhci_free_dev,
2380         .alloc_streams =        xhci_alloc_streams,
2381         .free_streams =         xhci_free_streams,
2382         .add_endpoint =         xhci_add_endpoint,
2383         .drop_endpoint =        xhci_drop_endpoint,
2384         .endpoint_reset =       xhci_endpoint_reset,
2385         .check_bandwidth =      xhci_check_bandwidth,
2386         .reset_bandwidth =      xhci_reset_bandwidth,
2387         .address_device =       xhci_address_device,
2388         .update_hub_device =    xhci_update_hub_device,
2389         .reset_device =         xhci_discover_or_reset_device,
2390
2391         /*
2392          * scheduling support
2393          */
2394         .get_frame_number =     xhci_get_frame,
2395
2396         /* Root hub support */
2397         .hub_control =          xhci_hub_control,
2398         .hub_status_data =      xhci_hub_status_data,
2399
2400 #ifdef CONFIG_PM
2401         .bus_suspend =          tegra_xhci_bus_suspend,
2402         .bus_resume =           tegra_xhci_bus_resume,
2403 #endif
2404 };
2405
2406 #ifdef CONFIG_PM
2407 static int
2408 tegra_xhci_suspend(struct platform_device *pdev,
2409                                                 pm_message_t state)
2410 {
2411         struct tegra_xhci_hcd *tegra = platform_get_drvdata(pdev);
2412         struct xhci_hcd *xhci = tegra->xhci;
2413
2414         int ret = 0;
2415
2416         mutex_lock(&tegra->sync_lock);
2417         if (!tegra->hc_in_elpg) {
2418                 xhci_warn(xhci, "%s: lp0 suspend entry while elpg not done\n",
2419                                 __func__);
2420                 mutex_unlock(&tegra->sync_lock);
2421                 return -EBUSY;
2422         }
2423         mutex_unlock(&tegra->sync_lock);
2424
2425         tegra_xhci_ss_wake_on_interrupts(tegra, false);
2426         tegra_xhci_hs_wake_on_interrupts(tegra, false);
2427
2428         /* enable_irq_wake for ss ports */
2429         ret = enable_irq_wake(tegra->padctl_irq);
2430         if (ret < 0) {
2431                 xhci_err(xhci,
2432                 "%s: Couldn't enable USB host mode wakeup, irq=%d, error=%d\n",
2433                 __func__, tegra->padctl_irq, ret);
2434         }
2435
2436         /* enable_irq_wake for hs/fs/ls ports */
2437         ret = enable_irq_wake(tegra->usb3_irq);
2438         if (ret < 0) {
2439                 xhci_err(xhci,
2440                 "%s: Couldn't enable USB host mode wakeup, irq=%d, error=%d\n",
2441                 __func__, tegra->usb3_irq, ret);
2442         }
2443         regulator_disable(tegra->xusb_avdd_usb3_pll_reg);
2444         regulator_disable(tegra->xusb_avddio_usb3_reg);
2445         tegra_usb2_clocks_deinit(tegra);
2446
2447         return ret;
2448 }
2449
2450 static int
2451 tegra_xhci_resume(struct platform_device *pdev)
2452 {
2453         struct tegra_xhci_hcd *tegra = platform_get_drvdata(pdev);
2454
2455         dev_dbg(&pdev->dev, "%s\n", __func__);
2456
2457         tegra->last_jiffies = jiffies;
2458
2459         disable_irq_wake(tegra->padctl_irq);
2460         disable_irq_wake(tegra->usb3_irq);
2461         tegra->lp0_exit = true;
2462
2463         regulator_enable(tegra->xusb_avddio_usb3_reg);
2464         regulator_enable(tegra->xusb_avdd_usb3_pll_reg);
2465         tegra_usb2_clocks_init(tegra);
2466
2467         return 0;
2468 }
2469 #endif
2470
2471
2472 static int init_bootloader_firmware(struct tegra_xhci_hcd *tegra)
2473 {
2474         struct platform_device *pdev = tegra->pdev;
2475         void __iomem *fw_mmio_base;
2476         phys_addr_t fw_mem_phy_addr;
2477         size_t fw_size;
2478         dma_addr_t fw_dma;
2479 #ifdef CONFIG_PLATFORM_ENABLE_IOMMU
2480         int ret;
2481 #endif
2482
2483         /* bootloader saved firmware memory address in PMC SCRATCH34 register */
2484         fw_mem_phy_addr = ioread32(tegra->pmc_base + PMC_SCRATCH34);
2485
2486         fw_mmio_base = devm_ioremap_nocache(&pdev->dev,
2487                         fw_mem_phy_addr, sizeof(struct cfgtbl));
2488
2489         if (!fw_mmio_base) {
2490                         dev_err(&pdev->dev, "error mapping fw memory 0x%x\n",
2491                                         fw_mem_phy_addr);
2492                         return -ENOMEM;
2493         }
2494
2495         fw_size = ioread32(fw_mmio_base + FW_SIZE_OFFSET);
2496         devm_iounmap(&pdev->dev, fw_mmio_base);
2497
2498         fw_mmio_base = devm_ioremap_nocache(&pdev->dev,
2499                         fw_mem_phy_addr, fw_size);
2500         if (!fw_mmio_base) {
2501                         dev_err(&pdev->dev, "error mapping fw memory 0x%x\n",
2502                                         fw_mem_phy_addr);
2503                         return -ENOMEM;
2504         }
2505
2506         dev_info(&pdev->dev, "Firmware Memory: phy 0x%x mapped 0x%p (%d Bytes)\n",
2507                         fw_mem_phy_addr, fw_mmio_base, fw_size);
2508
2509 #ifdef CONFIG_PLATFORM_ENABLE_IOMMU
2510         fw_dma = dma_map_linear(&pdev->dev, fw_mem_phy_addr, fw_size,
2511                         DMA_TO_DEVICE);
2512         if (fw_dma == DMA_ERROR_CODE) {
2513                 dev_err(&pdev->dev, "%s: dma_map_linear failed\n",
2514                                 __func__);
2515                 ret = -ENOMEM;
2516                 goto error_iounmap;
2517         }
2518 #else
2519         fw_dma = fw_mem_phy_addr;
2520 #endif
2521         dev_info(&pdev->dev, "Firmware DMA Memory: dma 0x%p (%d Bytes)\n",
2522                         (void *) fw_dma, fw_size);
2523
2524         /* all set and ready to go */
2525         tegra->firmware.data = fw_mmio_base;
2526         tegra->firmware.dma = fw_dma;
2527         tegra->firmware.size = fw_size;
2528
2529         return 0;
2530
2531 #ifdef CONFIG_PLATFORM_ENABLE_IOMMU
2532 error_iounmap:
2533         devm_iounmap(&pdev->dev, fw_mmio_base);
2534         return ret;
2535 #endif
2536 }
2537
2538 static void deinit_bootloader_firmware(struct tegra_xhci_hcd *tegra)
2539 {
2540         struct platform_device *pdev = tegra->pdev;
2541         void __iomem *fw_mmio_base = tegra->firmware.data;
2542
2543 #ifdef CONFIG_PLATFORM_ENABLE_IOMMU
2544         dma_unmap_single(&pdev->dev, tegra->firmware.dma,
2545                         tegra->firmware.size, DMA_TO_DEVICE);
2546 #endif
2547         devm_iounmap(&pdev->dev, fw_mmio_base);
2548
2549         memset(&tegra->firmware, 0, sizeof(tegra->firmware));
2550 }
2551
2552 static int init_firmware(struct tegra_xhci_hcd *tegra)
2553 {
2554         return init_bootloader_firmware(tegra);
2555 }
2556
2557 static void deinit_firmware(struct tegra_xhci_hcd *tegra)
2558 {
2559         deinit_bootloader_firmware(tegra);
2560 }
2561
2562 /* TODO: we have to refine error handling in tegra_xhci_probe() */
2563 static int tegra_xhci_probe(struct platform_device *pdev)
2564 {
2565         const struct hc_driver *driver;
2566         struct xhci_hcd *xhci;
2567         struct tegra_xhci_hcd *tegra;
2568         struct resource *res;
2569         struct usb_hcd  *hcd;
2570         u32 pmc_reg;
2571         int ret;
2572         int irq;
2573
2574         BUILD_BUG_ON(sizeof(struct cfgtbl) != 256);
2575
2576         if (usb_disabled())
2577                 return -ENODEV;
2578
2579         tegra = devm_kzalloc(&pdev->dev, sizeof(*tegra), GFP_KERNEL);
2580         if (!tegra) {
2581                 dev_err(&pdev->dev, "memory alloc failed\n");
2582                 return -ENOMEM;
2583         }
2584         tegra->pdev = pdev;
2585
2586         ret = tegra_xhci_request_mem_region(pdev, "pmc", &tegra->pmc_base);
2587         if (ret) {
2588                 dev_err(&pdev->dev, "failed to map pmc\n");
2589                 return ret;
2590         }
2591
2592         ret = tegra_xhci_request_mem_region(pdev, "padctl",
2593                         &tegra->padctl_base);
2594         if (ret) {
2595                 dev_err(&pdev->dev, "failed to map padctl\n");
2596                 return ret;
2597         }
2598
2599         ret = tegra_xhci_request_mem_region(pdev, "fpci", &tegra->fpci_base);
2600         if (ret) {
2601                 dev_err(&pdev->dev, "failed to map fpci\n");
2602                 return ret;
2603         }
2604
2605         ret = tegra_xhci_request_mem_region(pdev, "ipfs", &tegra->ipfs_base);
2606         if (ret) {
2607                 dev_err(&pdev->dev, "failed to map ipfs\n");
2608                 return ret;
2609         }
2610
2611         ret = tegra_xusb_partitions_clk_init(tegra);
2612         if (ret) {
2613                 dev_err(&pdev->dev,
2614                         "failed to initialize xusb partitions clocks\n");
2615                 return ret;
2616         }
2617
2618         /* Enable power rails to the PAD,VBUS
2619          * and pull-up voltage.Initialize the regulators
2620          */
2621         ret = tegra_xusb_regulator_init(tegra, pdev);
2622         if (ret) {
2623                 dev_err(&pdev->dev, "failed to initialize xusb regulator\n");
2624                 goto err_deinit_xusb_partition_clk;
2625         }
2626
2627         /* Enable UTMIP, PLLU and PLLE */
2628         ret = tegra_usb2_clocks_init(tegra);
2629         if (ret) {
2630                 dev_err(&pdev->dev, "error initializing usb2 clocks\n");
2631                 goto err_deinit_tegra_xusb_regulator;
2632         }
2633
2634         /* tegra_unpowergate_partition also does partition reset deassert */
2635         ret = tegra_unpowergate_partition(TEGRA_POWERGATE_XUSBA);
2636         if (ret)
2637                 dev_err(&pdev->dev, "could not unpowergate xusba partition\n");
2638
2639         /* tegra_unpowergate_partition also does partition reset deassert */
2640         ret = tegra_unpowergate_partition(TEGRA_POWERGATE_XUSBC);
2641         if (ret)
2642                 dev_err(&pdev->dev, "could not unpowergate xusbc partition\n");
2643
2644         tegra->pdata = dev_get_platdata(&pdev->dev);
2645         tegra->bdata = tegra->pdata->bdata;
2646         tegra->xusb_padctl = tegra->bdata->padctl_data;
2647
2648         /* reset the pointer back to NULL. driver uses it */
2649         /* platform_set_drvdata(pdev, NULL); */
2650
2651         /* calculate rctrl_val and tctrl_val once at boot time */
2652         tegra_xhci_war_for_tctrl_rctrl(tegra);
2653         pmc_init();
2654
2655         /* Program the XUSB pads to take ownership of ports */
2656         tegra_xhci_padctl_portmap_and_caps(tegra);
2657
2658         /* Enable Vbus of host ports */
2659         tegra_xhci_padctl_enable_usb_vbus(tegra);
2660
2661         /* Release XUSB wake logic state latching */
2662         tegra_xhci_ss_wake_signal(tegra, false);
2663         tegra_xhci_ss_vcore(tegra, false);
2664
2665         /* Deassert reset to XUSB host, ss, dev clocks */
2666         tegra_periph_reset_deassert(tegra->host_clk);
2667         tegra_periph_reset_deassert(tegra->ss_clk);
2668
2669         res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "host");
2670         if (!res) {
2671                 dev_err(&pdev->dev, "mem resource host doesn't exist\n");
2672                 ret = -ENODEV;
2673                 goto err_deinit_usb2_clocks;
2674         }
2675         tegra->host_phy_base = res->start;
2676
2677         tegra->host_phy_virt_base = devm_ioremap(&pdev->dev,
2678                                 res->start, resource_size(res));
2679         if (!tegra->host_phy_virt_base) {
2680                 dev_err(&pdev->dev, "error mapping host phy memory\n");
2681                 ret = -ENOMEM;
2682                 goto err_deinit_usb2_clocks;
2683         }
2684
2685         /* Setup IPFS access and BAR0 space */
2686         tegra_xhci_cfg(tegra);
2687
2688         ret = init_firmware(tegra);
2689         if (ret < 0) {
2690                 dev_err(&pdev->dev, "failed to init firmware\n");
2691                 ret = -ENODEV;
2692                 goto err_deinit_usb2_clocks;
2693         }
2694
2695         ret = load_firmware(tegra, true /* do reset ARU */);
2696         if (ret < 0) {
2697                 dev_err(&pdev->dev, "failed to load firmware\n");
2698                 ret = -ENODEV;
2699                 goto err_deinit_firmware;
2700         }
2701
2702         device_init_wakeup(&pdev->dev, 1);
2703         driver = &tegra_plat_xhci_driver;
2704
2705         hcd = usb_create_hcd(driver, &pdev->dev, dev_name(&pdev->dev));
2706         if (!hcd) {
2707                 dev_err(&pdev->dev, "failed to create usb2 hcd\n");
2708                 ret = -ENOMEM;
2709                 goto err_deinit_firmware;
2710         }
2711
2712         ret = tegra_xhci_request_mem_region(pdev, "host", &hcd->regs);
2713         if (ret) {
2714                 dev_err(&pdev->dev, "failed to map host\n");
2715                 goto err_put_usb2_hcd;
2716         }
2717         hcd->rsrc_start = res->start;
2718         hcd->rsrc_len = resource_size(res);
2719
2720         res = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "host");
2721         if (!res) {
2722                 dev_err(&pdev->dev, "irq resource host doesn't exist\n");
2723                 ret = -ENODEV;
2724                 goto err_put_usb2_hcd;
2725         }
2726         irq = res->start;
2727         ret = usb_add_hcd(hcd, irq, IRQF_SHARED);
2728         if (ret) {
2729                 dev_err(&pdev->dev, "failed to add usb2hcd, error = %d\n", ret);
2730                 goto err_put_usb2_hcd;
2731         }
2732
2733         /* USB 2.0 roothub is stored in the platform_device now. */
2734         hcd = dev_get_drvdata(&pdev->dev);
2735         xhci = hcd_to_xhci(hcd);
2736         tegra->xhci = xhci;
2737         platform_set_drvdata(pdev, tegra);
2738
2739         xhci->shared_hcd = usb_create_shared_hcd(driver, &pdev->dev,
2740                                                 dev_name(&pdev->dev), hcd);
2741         if (!xhci->shared_hcd) {
2742                 dev_err(&pdev->dev, "failed to create usb3 hcd\n");
2743                 ret = -ENOMEM;
2744                 goto err_remove_usb2_hcd;
2745         }
2746
2747         /*
2748          * Set the xHCI pointer before xhci_plat_setup() (aka hcd_driver.reset)
2749          * is called by usb_add_hcd().
2750          */
2751         *((struct xhci_hcd **) xhci->shared_hcd->hcd_priv) = xhci;
2752
2753         ret = usb_add_hcd(xhci->shared_hcd, irq, IRQF_SHARED);
2754         if (ret) {
2755                 dev_err(&pdev->dev, "failed to add usb3hcd, error = %d\n", ret);
2756                 goto err_put_usb3_hcd;
2757         }
2758
2759         device_init_wakeup(&hcd->self.root_hub->dev, 1);
2760         device_init_wakeup(&xhci->shared_hcd->self.root_hub->dev, 1);
2761         spin_lock_init(&tegra->lock);
2762         mutex_init(&tegra->sync_lock);
2763         mutex_init(&tegra->mbox_lock);
2764
2765         /* do mailbox related initializations */
2766         tegra->mbox_owner = 0xffff;
2767         INIT_WORK(&tegra->mbox_work, tegra_xhci_process_mbox_message);
2768
2769         tegra_xhci_enable_fw_message(tegra);
2770
2771         /* do ss partition elpg exit related initialization */
2772         INIT_WORK(&tegra->ss_elpg_exit_work, ss_partition_elpg_exit_work);
2773
2774         /* do host partition elpg exit related initialization */
2775         INIT_WORK(&tegra->host_elpg_exit_work, host_partition_elpg_exit_work);
2776
2777         /* Register interrupt handler for SMI line to handle mailbox
2778          * interrupt from firmware
2779          */
2780         ret = tegra_xhci_request_irq(pdev, "host-smi", tegra_xhci_smi_irq,
2781                         IRQF_SHARED, "tegra_xhci_mbox_irq", &tegra->smi_irq);
2782         if (ret != 0)
2783                 goto err_remove_usb3_hcd;
2784
2785         /* Register interrupt handler for PADCTRL line to
2786          * handle wake on connect irqs interrupt from
2787          * firmware
2788          */
2789         ret = tegra_xhci_request_irq(pdev, "padctl", tegra_xhci_padctl_irq,
2790                         IRQF_SHARED | IRQF_TRIGGER_HIGH,
2791                         "tegra_xhci_padctl_irq", &tegra->padctl_irq);
2792         if (ret != 0)
2793                 goto err_remove_usb3_hcd;
2794
2795         ret = tegra_xhci_request_irq(pdev, "usb3", tegra_xhci_xusb_host_irq,
2796                         IRQF_SHARED | IRQF_TRIGGER_HIGH, "xusb_host_irq",
2797                         &tegra->usb3_irq);
2798         if (ret != 0)
2799                 goto err_remove_usb3_hcd;
2800
2801         tegra->ss_pwr_gated = false;
2802         tegra->host_pwr_gated = false;
2803         tegra->hc_in_elpg = false;
2804         tegra->hs_wake_event = false;
2805         tegra->host_resume_req = false;
2806         tegra->lp0_exit = false;
2807         tegra->dfe_ctle_ctx_saved = false;
2808
2809         /* reset wake event to NONE */
2810         pmc_reg = readl(tegra->pmc_base + PMC_UTMIP_UHSIC_SLEEP_CFG_0);
2811         pmc_reg |= UTMIP_WAKE_VAL(0, WAKE_VAL_NONE);
2812         pmc_reg |= UTMIP_WAKE_VAL(1, WAKE_VAL_NONE);
2813         pmc_reg |= UTMIP_WAKE_VAL(2, WAKE_VAL_NONE);
2814         pmc_reg |= UTMIP_WAKE_VAL(3, WAKE_VAL_NONE);
2815         writel(pmc_reg, tegra->pmc_base + PMC_UTMIP_UHSIC_SLEEP_CFG_0);
2816
2817         tegra_xhci_debug_read_pads(tegra);
2818         utmi_phy_pad_enable();
2819         utmi_phy_iddq_override(false);
2820
2821         tegra_pd_add_device(&pdev->dev);
2822
2823         return 0;
2824
2825 err_remove_usb3_hcd:
2826         usb_remove_hcd(xhci->shared_hcd);
2827 err_put_usb3_hcd:
2828         usb_put_hcd(xhci->shared_hcd);
2829 err_remove_usb2_hcd:
2830         kfree(tegra->xhci);
2831         usb_remove_hcd(hcd);
2832 err_put_usb2_hcd:
2833         usb_put_hcd(hcd);
2834 err_deinit_firmware:
2835         deinit_firmware(tegra);
2836 err_deinit_usb2_clocks:
2837         tegra_usb2_clocks_deinit(tegra);
2838 err_deinit_tegra_xusb_regulator:
2839         tegra_xusb_regulator_deinit(tegra);
2840 err_deinit_xusb_partition_clk:
2841         tegra_xusb_partitions_clk_deinit(tegra);
2842
2843         return ret;
2844 }
2845
2846 static int tegra_xhci_remove(struct platform_device *pdev)
2847 {
2848         struct tegra_xhci_hcd *tegra = platform_get_drvdata(pdev);
2849         struct xhci_hcd *xhci = NULL;
2850         struct usb_hcd *hcd = NULL;
2851
2852         if (tegra == NULL)
2853                 return -EINVAL;
2854
2855         xhci = tegra->xhci;
2856         hcd = xhci_to_hcd(xhci);
2857
2858         devm_free_irq(&pdev->dev, tegra->usb3_irq, tegra);
2859         devm_free_irq(&pdev->dev, tegra->padctl_irq, tegra);
2860         devm_free_irq(&pdev->dev, tegra->smi_irq, tegra);
2861         usb_remove_hcd(xhci->shared_hcd);
2862         usb_put_hcd(xhci->shared_hcd);
2863         usb_remove_hcd(hcd);
2864         usb_put_hcd(hcd);
2865         kfree(xhci);
2866
2867         deinit_firmware(tegra);
2868         tegra_xusb_regulator_deinit(tegra);
2869         tegra_usb2_clocks_deinit(tegra);
2870         if (!tegra->hc_in_elpg)
2871                 tegra_xusb_partitions_clk_deinit(tegra);
2872         utmi_phy_pad_disable();
2873         utmi_phy_iddq_override(true);
2874
2875         return 0;
2876 }
2877
2878 static void tegra_xhci_shutdown(struct platform_device *pdev)
2879 {
2880         struct tegra_xhci_hcd *tegra = platform_get_drvdata(pdev);
2881         struct xhci_hcd *xhci = NULL;
2882         struct usb_hcd *hcd = NULL;
2883
2884         if (tegra == NULL)
2885                 return;
2886
2887         if (tegra->hc_in_elpg) {
2888                 mutex_lock(&tegra->sync_lock);
2889                 tegra_xhci_host_partition_elpg_exit(tegra);
2890                 mutex_unlock(&tegra->sync_lock);
2891         }
2892         xhci = tegra->xhci;
2893         hcd = xhci_to_hcd(xhci);
2894         xhci_shutdown(hcd);
2895 }
2896
2897 static struct platform_driver tegra_xhci_driver = {
2898         .probe  = tegra_xhci_probe,
2899         .remove = tegra_xhci_remove,
2900         .shutdown = tegra_xhci_shutdown,
2901 #ifdef CONFIG_PM
2902         .suspend = tegra_xhci_suspend,
2903         .resume  = tegra_xhci_resume,
2904 #endif
2905         .driver = {
2906                 .name = "tegra-xhci",
2907         },
2908 };
2909 MODULE_ALIAS("platform:tegra-xhci");
2910
2911 int tegra_xhci_register_plat(void)
2912 {
2913         return platform_driver_register(&tegra_xhci_driver);
2914 }
2915
2916 void tegra_xhci_unregister_plat(void)
2917 {
2918         platform_driver_unregister(&tegra_xhci_driver);
2919 }