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