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