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