1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23#include <linux/pci.h>
24
25#include "xhci.h"
26
27
28#define PCI_VENDOR_ID_FRESCO_LOGIC 0x1b73
29#define PCI_DEVICE_ID_FRESCO_LOGIC_PDK 0x1000
30
31static const char hcd_name[] = "xhci_hcd";
32
33
34static int xhci_pci_reinit(struct xhci_hcd *xhci, struct pci_dev *pdev)
35{
36
37
38
39
40
41
42
43 if (!pci_set_mwi(pdev))
44 xhci_dbg(xhci, "MWI active\n");
45
46 xhci_dbg(xhci, "Finished xhci_pci_reinit\n");
47 return 0;
48}
49
50
51static int xhci_pci_setup(struct usb_hcd *hcd)
52{
53 struct xhci_hcd *xhci = hcd_to_xhci(hcd);
54 struct pci_dev *pdev = to_pci_dev(hcd->self.controller);
55 int retval;
56 u32 temp;
57
58 hcd->self.sg_tablesize = TRBS_PER_SEGMENT - 2;
59
60 xhci->cap_regs = hcd->regs;
61 xhci->op_regs = hcd->regs +
62 HC_LENGTH(xhci_readl(xhci, &xhci->cap_regs->hc_capbase));
63 xhci->run_regs = hcd->regs +
64 (xhci_readl(xhci, &xhci->cap_regs->run_regs_off) & RTSOFF_MASK);
65
66 xhci->hcs_params1 = xhci_readl(xhci, &xhci->cap_regs->hcs_params1);
67 xhci->hcs_params2 = xhci_readl(xhci, &xhci->cap_regs->hcs_params2);
68 xhci->hcs_params3 = xhci_readl(xhci, &xhci->cap_regs->hcs_params3);
69 xhci->hcc_params = xhci_readl(xhci, &xhci->cap_regs->hc_capbase);
70 xhci->hci_version = HC_VERSION(xhci->hcc_params);
71 xhci->hcc_params = xhci_readl(xhci, &xhci->cap_regs->hcc_params);
72 xhci_print_registers(xhci);
73
74
75 if (pdev->vendor == PCI_VENDOR_ID_FRESCO_LOGIC &&
76 pdev->device == PCI_DEVICE_ID_FRESCO_LOGIC_PDK &&
77 pdev->revision == 0x0) {
78 xhci->quirks |= XHCI_RESET_EP_QUIRK;
79 xhci_dbg(xhci, "QUIRK: Fresco Logic xHC needs configure"
80 " endpoint cmd after reset endpoint\n");
81 }
82 if (pdev->vendor == PCI_VENDOR_ID_NEC)
83 xhci->quirks |= XHCI_NEC_HOST;
84
85
86 retval = xhci_halt(xhci);
87 if (retval)
88 return retval;
89
90 xhci_dbg(xhci, "Resetting HCD\n");
91
92 retval = xhci_reset(xhci);
93 if (retval)
94 return retval;
95 xhci_dbg(xhci, "Reset complete\n");
96
97 temp = xhci_readl(xhci, &xhci->cap_regs->hcc_params);
98 if (HCC_64BIT_ADDR(temp)) {
99 xhci_dbg(xhci, "Enabling 64-bit DMA addresses.\n");
100 dma_set_mask(hcd->self.controller, DMA_BIT_MASK(64));
101 } else {
102 dma_set_mask(hcd->self.controller, DMA_BIT_MASK(32));
103 }
104
105 xhci_dbg(xhci, "Calling HCD init\n");
106
107 retval = xhci_init(hcd);
108 if (retval)
109 return retval;
110 xhci_dbg(xhci, "Called HCD init\n");
111
112 pci_read_config_byte(pdev, XHCI_SBRN_OFFSET, &xhci->sbrn);
113 xhci_dbg(xhci, "Got SBRN %u\n", (unsigned int) xhci->sbrn);
114
115
116 return xhci_pci_reinit(xhci, pdev);
117}
118
119#ifdef CONFIG_PM
120static int xhci_pci_suspend(struct usb_hcd *hcd, bool do_wakeup)
121{
122 struct xhci_hcd *xhci = hcd_to_xhci(hcd);
123 int retval = 0;
124
125 if (hcd->state != HC_STATE_SUSPENDED)
126 return -EINVAL;
127
128 retval = xhci_suspend(xhci);
129
130 return retval;
131}
132
133static int xhci_pci_resume(struct usb_hcd *hcd, bool hibernated)
134{
135 struct xhci_hcd *xhci = hcd_to_xhci(hcd);
136 int retval = 0;
137
138 retval = xhci_resume(xhci, hibernated);
139 return retval;
140}
141#endif
142
143static const struct hc_driver xhci_pci_hc_driver = {
144 .description = hcd_name,
145 .product_desc = "xHCI Host Controller",
146 .hcd_priv_size = sizeof(struct xhci_hcd),
147
148
149
150
151 .irq = xhci_irq,
152 .flags = HCD_MEMORY | HCD_USB3,
153
154
155
156
157 .reset = xhci_pci_setup,
158 .start = xhci_run,
159#ifdef CONFIG_PM
160 .pci_suspend = xhci_pci_suspend,
161 .pci_resume = xhci_pci_resume,
162#endif
163 .stop = xhci_stop,
164 .shutdown = xhci_shutdown,
165
166
167
168
169 .urb_enqueue = xhci_urb_enqueue,
170 .urb_dequeue = xhci_urb_dequeue,
171 .alloc_dev = xhci_alloc_dev,
172 .free_dev = xhci_free_dev,
173 .alloc_streams = xhci_alloc_streams,
174 .free_streams = xhci_free_streams,
175 .add_endpoint = xhci_add_endpoint,
176 .drop_endpoint = xhci_drop_endpoint,
177 .endpoint_reset = xhci_endpoint_reset,
178 .check_bandwidth = xhci_check_bandwidth,
179 .reset_bandwidth = xhci_reset_bandwidth,
180 .address_device = xhci_address_device,
181 .update_hub_device = xhci_update_hub_device,
182 .reset_device = xhci_discover_or_reset_device,
183
184
185
186
187 .get_frame_number = xhci_get_frame,
188
189
190 .hub_control = xhci_hub_control,
191 .hub_status_data = xhci_hub_status_data,
192 .bus_suspend = xhci_bus_suspend,
193 .bus_resume = xhci_bus_resume,
194};
195
196
197
198
199static const struct pci_device_id pci_ids[] = { {
200
201 PCI_DEVICE_CLASS(PCI_CLASS_SERIAL_USB_XHCI, ~0),
202 .driver_data = (unsigned long) &xhci_pci_hc_driver,
203 },
204 { }
205};
206MODULE_DEVICE_TABLE(pci, pci_ids);
207
208
209static struct pci_driver xhci_pci_driver = {
210 .name = (char *) hcd_name,
211 .id_table = pci_ids,
212
213 .probe = usb_hcd_pci_probe,
214 .remove = usb_hcd_pci_remove,
215
216
217 .shutdown = usb_hcd_pci_shutdown,
218#ifdef CONFIG_PM_SLEEP
219 .driver = {
220 .pm = &usb_hcd_pci_pm_ops
221 },
222#endif
223};
224
225int xhci_register_pci(void)
226{
227 return pci_register_driver(&xhci_pci_driver);
228}
229
230void xhci_unregister_pci(void)
231{
232 pci_unregister_driver(&xhci_pci_driver);
233}
234