2 * This file is part of the coreboot project.
4 * Copyright (C) 2006 Eric Biederman (ebiederm@xmission.com)
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; version 2 of the License.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
20 * 2006.12.10 yhlu moved it to corbeoot and use struct instead
22 #if !defined(__ROMCC__)
23 #include <console/console.h>
25 #if CONFIG_USE_PRINTK_IN_CAR==0
26 #define printk(BIOS_DEBUG, fmt, arg...) do {} while(0)
34 #include <usbdebug_direct.h>
36 #define USB_DEBUG_DEVNUM 127
38 #define DBGP_DATA_TOGGLE 0x8800
39 #define DBGP_PID_UPDATE(x, tok) \
40 ((((x) ^ DBGP_DATA_TOGGLE) & 0xffff00) | ((tok) & 0xff))
42 #define DBGP_LEN_UPDATE(x, len) (((x) & ~0x0f) | ((len) & 0x0f))
44 * USB Packet IDs (PIDs)
48 #define USB_PID_OUT 0xe1
49 #define USB_PID_IN 0x69
50 #define USB_PID_SOF 0xa5
51 #define USB_PID_SETUP 0x2d
53 #define USB_PID_ACK 0xd2
54 #define USB_PID_NAK 0x5a
55 #define USB_PID_STALL 0x1e
56 #define USB_PID_NYET 0x96
58 #define USB_PID_DATA0 0xc3
59 #define USB_PID_DATA1 0x4b
60 #define USB_PID_DATA2 0x87
61 #define USB_PID_MDATA 0x0f
63 #define USB_PID_PREAMBLE 0x3c
64 #define USB_PID_ERR 0x3c
65 #define USB_PID_SPLIT 0x78
66 #define USB_PID_PING 0xb4
67 #define USB_PID_UNDEF_0 0xf0
69 #define USB_PID_DATA_TOGGLE 0x88
70 #define DBGP_CLAIM (DBGP_OWNER | DBGP_ENABLED | DBGP_INUSE)
72 #define PCI_CAP_ID_EHCI_DEBUG 0xa
74 #define HUB_ROOT_RESET_TIME 50 /* times are in msec */
75 #define HUB_SHORT_RESET_TIME 10
76 #define HUB_LONG_RESET_TIME 200
77 #define HUB_RESET_TIMEOUT 500
79 #define DBGP_MAX_PACKET 8
81 static int dbgp_wait_until_complete(struct ehci_dbg_port *ehci_debug)
86 ctrl = read32(&ehci_debug->control);
87 /* Stop when the transaction is finished */
92 if (!loop) return -1000;
94 /* Now that we have observed the completed transaction,
97 write32(&ehci_debug->control, ctrl | DBGP_DONE);
98 return (ctrl & DBGP_ERROR) ? -DBGP_ERRCODE(ctrl) : DBGP_LEN(ctrl);
101 static void dbgp_mdelay(int ms)
105 for (i = 0; i < 1000; i++)
110 static void dbgp_breath(void)
112 /* Sleep to give the debug port a chance to breathe */
115 static int dbgp_wait_until_done(struct ehci_dbg_port *ehci_debug, unsigned ctrl)
122 write32(&ehci_debug->control, ctrl | DBGP_GO);
123 ret = dbgp_wait_until_complete(ehci_debug);
124 pids = read32(&ehci_debug->pids);
125 lpid = DBGP_PID_GET(pids);
130 /* If the port is getting full or it has dropped data
131 * start pacing ourselves, not necessary but it's friendly.
133 if ((lpid == USB_PID_NAK) || (lpid == USB_PID_NYET))
136 /* If I get a NACK reissue the transmission */
137 if (lpid == USB_PID_NAK) {
138 if (--loop > 0) goto retry;
144 static void dbgp_set_data(struct ehci_dbg_port *ehci_debug, const void *buf, int size)
146 const unsigned char *bytes = buf;
150 for (i = 0; i < 4 && i < size; i++)
151 lo |= bytes[i] << (8*i);
152 for (; i < 8 && i < size; i++)
153 hi |= bytes[i] << (8*(i - 4));
154 write32(&ehci_debug->data03, lo);
155 write32(&ehci_debug->data47, hi);
158 static void dbgp_get_data(struct ehci_dbg_port *ehci_debug, void *buf, int size)
160 unsigned char *bytes = buf;
163 lo = read32(&ehci_debug->data03);
164 hi = read32(&ehci_debug->data47);
165 for (i = 0; i < 4 && i < size; i++)
166 bytes[i] = (lo >> (8*i)) & 0xff;
167 for (; i < 8 && i < size; i++)
168 bytes[i] = (hi >> (8*(i - 4))) & 0xff;
171 static int dbgp_bulk_write(struct ehci_dbg_port *ehci_debug, unsigned devnum, unsigned endpoint, const char *bytes, int size)
173 unsigned pids, addr, ctrl;
175 if (size > DBGP_MAX_PACKET)
178 addr = DBGP_EPADDR(devnum, endpoint);
180 pids = read32(&ehci_debug->pids);
181 pids = DBGP_PID_UPDATE(pids, USB_PID_OUT);
183 ctrl = read32(&ehci_debug->control);
184 ctrl = DBGP_LEN_UPDATE(ctrl, size);
188 dbgp_set_data(ehci_debug, bytes, size);
189 write32(&ehci_debug->address, addr);
190 write32(&ehci_debug->pids, pids);
192 ret = dbgp_wait_until_done(ehci_debug, ctrl);
199 int dbgp_bulk_write_x(struct ehci_debug_info *dbg_info, const char *bytes, int size)
201 return dbgp_bulk_write(dbg_info->ehci_debug, dbg_info->devnum, dbg_info->endpoint_out, bytes, size);
204 static int dbgp_bulk_read(struct ehci_dbg_port *ehci_debug, unsigned devnum, unsigned endpoint, void *data, int size)
206 unsigned pids, addr, ctrl;
209 if (size > DBGP_MAX_PACKET)
212 addr = DBGP_EPADDR(devnum, endpoint);
214 pids = read32(&ehci_debug->pids);
215 pids = DBGP_PID_UPDATE(pids, USB_PID_IN);
217 ctrl = read32(&ehci_debug->control);
218 ctrl = DBGP_LEN_UPDATE(ctrl, size);
222 write32(&ehci_debug->address, addr);
223 write32(&ehci_debug->pids, pids);
224 ret = dbgp_wait_until_done(ehci_debug, ctrl);
229 dbgp_get_data(ehci_debug, data, size);
232 int dbgp_bulk_read_x(struct ehci_debug_info *dbg_info, void *data, int size)
234 return dbgp_bulk_read(dbg_info->ehci_debug, dbg_info->devnum, dbg_info->endpoint_in, data, size);
237 static int dbgp_control_msg(struct ehci_dbg_port *ehci_debug, unsigned devnum, int requesttype, int request,
238 int value, int index, void *data, int size)
240 unsigned pids, addr, ctrl;
241 struct usb_ctrlrequest req;
245 read = (requesttype & USB_DIR_IN) != 0;
246 if (size > (read?DBGP_MAX_PACKET:0))
249 /* Compute the control message */
250 req.bRequestType = requesttype;
251 req.bRequest = request;
256 pids = DBGP_PID_SET(USB_PID_DATA0, USB_PID_SETUP);
257 addr = DBGP_EPADDR(devnum, 0);
259 ctrl = read32(&ehci_debug->control);
260 ctrl = DBGP_LEN_UPDATE(ctrl, sizeof(req));
264 /* Send the setup message */
265 dbgp_set_data(ehci_debug, &req, sizeof(req));
266 write32(&ehci_debug->address, addr);
267 write32(&ehci_debug->pids, pids);
268 ret = dbgp_wait_until_done(ehci_debug, ctrl);
273 /* Read the result */
274 ret = dbgp_bulk_read(ehci_debug, devnum, 0, data, size);
278 static int ehci_reset_port(struct ehci_regs *ehci_regs, int port)
281 unsigned delay_time, delay;
284 /* Reset the usb debug port */
285 portsc = read32(&ehci_regs->port_status[port - 1]);
287 portsc |= PORT_RESET;
288 write32(&ehci_regs->port_status[port - 1], portsc);
290 delay = HUB_ROOT_RESET_TIME;
291 for (delay_time = 0; delay_time < HUB_RESET_TIMEOUT;
292 delay_time += delay) {
295 portsc = read32(&ehci_regs->port_status[port - 1]);
296 if (portsc & PORT_RESET) {
297 /* force reset to complete */
299 write32(&ehci_regs->port_status[port - 1],
300 portsc & ~(PORT_RWC_BITS | PORT_RESET));
303 portsc = read32(&ehci_regs->port_status[port - 1]);
305 } while ((portsc & PORT_RESET) && (--loop > 0));
307 printk(BIOS_DEBUG, "ehci_reset_port forced done");
311 /* Device went away? */
312 if (!(portsc & PORT_CONNECT))
313 return -107;//-ENOTCONN;
315 /* bomb out completely if something weird happend */
316 if ((portsc & PORT_CSC))
317 return -22;//-EINVAL;
319 /* If we've finished resetting, then break out of the loop */
320 if (!(portsc & PORT_RESET) && (portsc & PORT_PE))
326 static int ehci_wait_for_port(struct ehci_regs *ehci_regs, int port)
330 for (reps = 0; reps < 3; reps++) {
332 status = read32(&ehci_regs->status);
333 if (status & STS_PCD) {
334 ret = ehci_reset_port(ehci_regs, port);
339 return -107; //-ENOTCONN;
345 # define dbgp_printk(fmt, arg...) printk(BIOS_DEBUG, fmt, arg)
347 #define dbgp_printk(fmt, arg...) do {} while(0)
349 static void usbdebug_direct_init(unsigned ehci_bar, unsigned offset, struct ehci_debug_info *info)
351 struct ehci_caps *ehci_caps;
352 struct ehci_regs *ehci_regs;
353 struct ehci_dbg_port *ehci_debug;
354 unsigned dbgp_endpoint_out;
355 unsigned dbgp_endpoint_in;
356 struct usb_debug_descriptor dbgp_desc;
357 unsigned ctrl, devnum;
359 unsigned delay_time, delay;
362 unsigned cmd, status, portsc, hcs_params, debug_port, n_ports, new_debug_port;
364 unsigned port_map_tried;
366 unsigned playtimes = 3;
368 ehci_caps = (struct ehci_caps *)ehci_bar;
369 ehci_regs = (struct ehci_regs *)(ehci_bar + HC_LENGTH(read32(&ehci_caps->hc_capbase)));
370 ehci_debug = (struct ehci_dbg_port *)(ehci_bar + offset);
372 info->ehci_debug = (void *)0;
378 hcs_params = read32(&ehci_caps->hcs_params);
379 debug_port = HCS_DEBUG_PORT(hcs_params);
380 n_ports = HCS_N_PORTS(hcs_params);
382 dbgp_printk("ehci_bar: 0x%x\n", ehci_bar);
383 dbgp_printk("debug_port: %d\n", debug_port);
384 dbgp_printk("n_ports: %d\n", n_ports);
387 for (i = 1; i <= n_ports; i++) {
388 portsc = read32(&ehci_regs->port_status[i-1]);
389 dbgp_printk("PORTSC #%d: %08x\n", i, portsc);
393 if(port_map_tried && (new_debug_port!=debug_port)) {
395 set_debug_port(debug_port);
401 /* Reset the EHCI controller */
403 cmd = read32(&ehci_regs->command);
405 write32(&ehci_regs->command, cmd);
407 cmd = read32(&ehci_regs->command);
408 } while ((cmd & CMD_RESET) && (--loop > 0));
411 dbgp_printk("Could not reset EHCI controller.\n");
413 dbgp_printk("EHCI controller reset successfully.\n");
415 /* Claim ownership, but do not enable yet */
416 ctrl = read32(&ehci_debug->control);
418 ctrl &= ~(DBGP_ENABLED | DBGP_INUSE);
419 write32(&ehci_debug->control, ctrl);
421 /* Start the ehci running */
422 cmd = read32(&ehci_regs->command);
423 cmd &= ~(CMD_LRESET | CMD_IAAD | CMD_PSE | CMD_ASE | CMD_RESET);
425 write32(&ehci_regs->command, cmd);
427 /* Ensure everything is routed to the EHCI */
428 write32(&ehci_regs->configured_flag, FLAG_CF);
430 /* Wait until the controller is no longer halted */
433 status = read32(&ehci_regs->status);
434 } while ((status & STS_HALT) && (--loop>0));
437 dbgp_printk("EHCI could not be started.\n");
440 dbgp_printk("EHCI started.\n");
442 /* Wait for a device to show up in the debug port */
443 ret = ehci_wait_for_port(ehci_regs, debug_port);
445 dbgp_printk("No device found in debug port %d\n", debug_port);
446 goto next_debug_port;
448 dbgp_printk("EHCI done waiting for port.\n");
450 /* Enable the debug port */
451 ctrl = read32(&ehci_debug->control);
453 write32(&ehci_debug->control, ctrl);
454 ctrl = read32(&ehci_debug->control);
455 if ((ctrl & DBGP_CLAIM) != DBGP_CLAIM) {
456 dbgp_printk("No device in EHCI debug port.\n");
457 write32(&ehci_debug->control, ctrl & ~DBGP_CLAIM);
460 dbgp_printk("EHCI debug port enabled.\n");
462 /* Completely transfer the debug device to the debug controller */
463 portsc = read32(&ehci_regs->port_status[debug_port - 1]);
465 write32(&ehci_regs->port_status[debug_port - 1], portsc);
469 /* Find the debug device and make it device number 127 */
470 for (devnum = 0; devnum <= 127; devnum++) {
471 ret = dbgp_control_msg(ehci_debug, devnum,
472 USB_DIR_IN | USB_TYPE_STANDARD | USB_RECIP_DEVICE,
473 USB_REQ_GET_DESCRIPTOR, (USB_DT_DEBUG << 8), 0,
474 &dbgp_desc, sizeof(dbgp_desc));
479 dbgp_printk("Could not find attached debug device.\n");
483 dbgp_printk("Attached device is not a debug device.\n");
486 dbgp_endpoint_out = dbgp_desc.bDebugOutEndpoint;
487 dbgp_endpoint_in = dbgp_desc.bDebugInEndpoint;
489 /* Move the device to 127 if it isn't already there */
490 if (devnum != USB_DEBUG_DEVNUM) {
491 ret = dbgp_control_msg(ehci_debug, devnum,
492 USB_DIR_OUT | USB_TYPE_STANDARD | USB_RECIP_DEVICE,
493 USB_REQ_SET_ADDRESS, USB_DEBUG_DEVNUM, 0, (void *)0, 0);
495 dbgp_printk("Could not move attached device to %d.\n",
499 devnum = USB_DEBUG_DEVNUM;
500 dbgp_printk("EHCI debug device renamed to 127.\n");
503 /* Enable the debug interface */
504 ret = dbgp_control_msg(ehci_debug, USB_DEBUG_DEVNUM,
505 USB_DIR_OUT | USB_TYPE_STANDARD | USB_RECIP_DEVICE,
506 USB_REQ_SET_FEATURE, USB_DEVICE_DEBUG_MODE, 0, (void *)0, 0);
508 dbgp_printk("Could not enable EHCI debug device.\n");
511 dbgp_printk("EHCI debug interface enabled.\n");
513 /* Perform a small write to get the even/odd data state in sync
515 ret = dbgp_bulk_write(ehci_debug, USB_DEBUG_DEVNUM, dbgp_endpoint_out, " ",1);
517 dbgp_printk("dbgp_bulk_write failed: %d\n", ret);
520 dbgp_printk("Test write done\n");
522 info->ehci_caps = ehci_caps;
523 info->ehci_regs = ehci_regs;
524 info->ehci_debug = ehci_debug;
525 info->devnum = devnum;
526 info->endpoint_out = dbgp_endpoint_out;
527 info->endpoint_in = dbgp_endpoint_in;
531 /* Things didn't work so remove my claim */
532 ctrl = read32(&ehci_debug->control);
533 ctrl &= ~(DBGP_CLAIM | DBGP_OUT);
534 write32(&ehci_debug->control, ctrl);
537 port_map_tried |= (1<<(debug_port-1));
538 if(port_map_tried != ((1<<n_ports) -1)) {
539 new_debug_port = ((debug_port-1+1)%n_ports) + 1;
540 set_debug_port(new_debug_port);
544 set_debug_port(debug_port);