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