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