[xhci] Use meaningful device names in debug messages

Signed-off-by: Michael Brown <mcb30@ipxe.org>

src/drivers/usb/xhci.c

 	xhci->op = ( xhci->cap + caplength );
 	xhci->run = ( xhci->cap + rtsoff );
 	xhci->db = ( xhci->cap + dboff );
-	DBGC2 ( xhci, "XHCI %p cap %08lx op %08lx run %08lx db %08lx\n",
-		xhci, virt_to_phys ( xhci->cap ), virt_to_phys ( xhci->op ),
-		virt_to_phys ( xhci->run ), virt_to_phys ( xhci->db ) );
+	DBGC2 ( xhci, "XHCI %s cap %08lx op %08lx run %08lx db %08lx\n",
+		xhci->name, virt_to_phys ( xhci->cap ),
+		virt_to_phys ( xhci->op ), virt_to_phys ( xhci->run ),
+		virt_to_phys ( xhci->db ) );
 
 	/* Read structural parameters 1 */
 	hcsparams1 = readl ( xhci->cap + XHCI_CAP_HCSPARAMS1 );
 	xhci->slots = XHCI_HCSPARAMS1_SLOTS ( hcsparams1 );
 	xhci->intrs = XHCI_HCSPARAMS1_INTRS ( hcsparams1 );
 	xhci->ports = XHCI_HCSPARAMS1_PORTS ( hcsparams1 );
-	DBGC ( xhci, "XHCI %p has %d slots %d intrs %d ports\n",
-	       xhci, xhci->slots, xhci->intrs, xhci->ports );
+	DBGC ( xhci, "XHCI %s has %d slots %d intrs %d ports\n",
+	       xhci->name, xhci->slots, xhci->intrs, xhci->ports );
 
 	/* Read structural parameters 2 */
 	hcsparams2 = readl ( xhci->cap + XHCI_CAP_HCSPARAMS2 );
 	xhci->scratchpads = XHCI_HCSPARAMS2_SCRATCHPADS ( hcsparams2 );
-	DBGC2 ( xhci, "XHCI %p needs %d scratchpads\n",
-		xhci, xhci->scratchpads );
+	DBGC2 ( xhci, "XHCI %s needs %d scratchpads\n",
+		xhci->name, xhci->scratchpads );
 
 	/* Read capability parameters 1 */
 	hccparams1 = readl ( xhci->cap + XHCI_CAP_HCCPARAMS1 );
 	xhci->pagesize = XHCI_PAGESIZE ( pagesize );
 	assert ( xhci->pagesize != 0 );
 	assert ( ( ( xhci->pagesize ) & ( xhci->pagesize - 1 ) ) == 0 );
-	DBGC2 ( xhci, "XHCI %p page size %zd bytes\n",
-		xhci, xhci->pagesize );
+	DBGC2 ( xhci, "XHCI %s page size %zd bytes\n",
+		xhci->name, xhci->pagesize );
 }
 
 /**
 	 * address is outside the 32-bit address space, then fail.
 	 */
 	if ( ( value & ~0xffffffffULL ) && ! xhci->addr64 ) {
-		DBGC ( xhci, "XHCI %p cannot access address %lx\n",
-		       xhci, value );
+		DBGC ( xhci, "XHCI %s cannot access address %lx\n",
+		       xhci->name, value );
 		return -ENOTSUP;
 	}
 
 
 	/* Dump USBCMD */
 	usbcmd = readl ( xhci->op + XHCI_OP_USBCMD );
-	DBGC ( xhci, "XHCI %p USBCMD %08x%s%s\n", xhci, usbcmd,
+	DBGC ( xhci, "XHCI %s USBCMD %08x%s%s\n", xhci->name, usbcmd,
 	       ( ( usbcmd & XHCI_USBCMD_RUN ) ? " run" : "" ),
 	       ( ( usbcmd & XHCI_USBCMD_HCRST ) ? " hcrst" : "" ) );
 
 	/* Dump USBSTS */
 	usbsts = readl ( xhci->op + XHCI_OP_USBSTS );
-	DBGC ( xhci, "XHCI %p USBSTS %08x%s\n", xhci, usbsts,
+	DBGC ( xhci, "XHCI %s USBSTS %08x%s\n", xhci->name, usbsts,
 	       ( ( usbsts & XHCI_USBSTS_HCH ) ? " hch" : "" ) );
 
 	/* Dump PAGESIZE */
 	pagesize = readl ( xhci->op + XHCI_OP_PAGESIZE );
-	DBGC ( xhci, "XHCI %p PAGESIZE %08x\n", xhci, pagesize );
+	DBGC ( xhci, "XHCI %s PAGESIZE %08x\n", xhci->name, pagesize );
 
 	/* Dump DNCTRL */
 	dnctrl = readl ( xhci->op + XHCI_OP_DNCTRL );
-	DBGC ( xhci, "XHCI %p DNCTRL %08x\n", xhci, dnctrl );
+	DBGC ( xhci, "XHCI %s DNCTRL %08x\n", xhci->name, dnctrl );
 
 	/* Dump CONFIG */
 	config = readl ( xhci->op + XHCI_OP_CONFIG );
-	DBGC ( xhci, "XHCI %p CONFIG %08x\n", xhci, config );
+	DBGC ( xhci, "XHCI %s CONFIG %08x\n", xhci->name, config );
 }
 
 /**
 
 	/* Dump PORTSC */
 	portsc = readl ( xhci->op + XHCI_OP_PORTSC ( port ) );
-	DBGC ( xhci, "XHCI %p port %d PORTSC %08x%s%s%s%s psiv=%d\n",
-	       xhci, port, portsc,
+	DBGC ( xhci, "XHCI %s-%d PORTSC %08x%s%s%s%s psiv=%d\n",
+	       xhci->name, port, portsc,
 	       ( ( portsc & XHCI_PORTSC_CCS ) ? " ccs" : "" ),
 	       ( ( portsc & XHCI_PORTSC_PED ) ? " ped" : "" ),
 	       ( ( portsc & XHCI_PORTSC_PR ) ? " pr" : "" ),
 
 	/* Dump PORTPMSC */
 	portpmsc = readl ( xhci->op + XHCI_OP_PORTPMSC ( port ) );
-	DBGC ( xhci, "XHCI %p port %d PORTPMSC %08x\n", xhci, port, portpmsc );
+	DBGC ( xhci, "XHCI %s-%d PORTPMSC %08x\n", xhci->name, port, portpmsc );
 
 	/* Dump PORTLI */
 	portli = readl ( xhci->op + XHCI_OP_PORTLI ( port ) );
-	DBGC ( xhci, "XHCI %p port %d PORTLI %08x\n", xhci, port, portli );
+	DBGC ( xhci, "XHCI %s-%d PORTLI %08x\n", xhci->name, port, portli );
 
 	/* Dump PORTHLPMC */
 	porthlpmc = readl ( xhci->op + XHCI_OP_PORTHLPMC ( port ) );
-	DBGC ( xhci, "XHCI %p port %d PORTHLPMC %08x\n",
-	       xhci, port, porthlpmc );
+	DBGC ( xhci, "XHCI %s-%d PORTHLPMC %08x\n",
+	       xhci->name, port, porthlpmc );
 }
 
 /******************************************************************************
 	legacy = xhci_extended_capability ( xhci, XHCI_XECP_ID_LEGACY, 0 );
 	if ( ! legacy ) {
 		/* Not an error; capability may not be present */
-		DBGC ( xhci, "XHCI %p has no USB legacy support capability\n",
-		       xhci );
+		DBGC ( xhci, "XHCI %s has no USB legacy support capability\n",
+		       xhci->name );
 		return;
 	}
 
 	bios = readb ( xhci->cap + legacy + XHCI_USBLEGSUP_BIOS );
 	if ( ! ( bios & XHCI_USBLEGSUP_BIOS_OWNED ) ) {
 		/* Not an error; already owned by OS */
-		DBGC ( xhci, "XHCI %p USB legacy support already disabled\n",
-		       xhci );
+		DBGC ( xhci, "XHCI %s USB legacy support already disabled\n",
+		       xhci->name );
 		return;
 	}
 
 		/* Check if BIOS has released ownership */
 		bios = readb ( xhci->cap + xhci->legacy + XHCI_USBLEGSUP_BIOS );
 		if ( ! ( bios & XHCI_USBLEGSUP_BIOS_OWNED ) ) {
-			DBGC ( xhci, "XHCI %p claimed ownership from BIOS\n",
-			       xhci );
+			DBGC ( xhci, "XHCI %s claimed ownership from BIOS\n",
+			       xhci->name );
 			ctlsts = readl ( xhci->cap + xhci->legacy +
 					 XHCI_USBLEGSUP_CTLSTS );
 			if ( ctlsts ) {
-				DBGC ( xhci, "XHCI %p warning: BIOS retained "
-				       "SMIs: %08x\n", xhci, ctlsts );
+				DBGC ( xhci, "XHCI %s warning: BIOS retained "
+				       "SMIs: %08x\n", xhci->name, ctlsts );
 			}
 			return;
 		}
 	/* BIOS did not release ownership.  Claim it forcibly by
 	 * disabling all SMIs.
 	 */
-	DBGC ( xhci, "XHCI %p could not claim ownership from BIOS: forcibly "
-	       "disabling SMIs\n", xhci );
+	DBGC ( xhci, "XHCI %s could not claim ownership from BIOS: forcibly "
+	       "disabling SMIs\n", xhci->name );
 	writel ( 0, xhci->cap + xhci->legacy + XHCI_USBLEGSUP_CTLSTS );
 }
 
 
 	/* Do nothing if releasing ownership is prevented */
 	if ( xhci_legacy_prevent_release ) {
-		DBGC ( xhci, "XHCI %p not releasing ownership to BIOS\n", xhci);
+		DBGC ( xhci, "XHCI %s not releasing ownership to BIOS\n",
+		       xhci->name );
 		return;
 	}
 
 	/* Release ownership */
 	writeb ( 0, xhci->cap + xhci->legacy + XHCI_USBLEGSUP_OS );
-	DBGC ( xhci, "XHCI %p released ownership to BIOS\n", xhci );
+	DBGC ( xhci, "XHCI %s released ownership to BIOS\n", xhci->name );
 }
 
 /******************************************************************************
 			return supported;
 	}
 
-	DBGC ( xhci, "XHCI %p port %d has no supported protocol\n",
-	       xhci, port );
+	DBGC ( xhci, "XHCI %s-%d has no supported protocol\n",
+	       xhci->name, port );
 	return 0;
 }
 
 		name.text[4] = '\0';
 		slot = readl ( xhci->cap + supported + XHCI_SUPPORTED_SLOT );
 		type = XHCI_SUPPORTED_SLOT_TYPE ( slot );
-		DBGC2 ( xhci, "XHCI %p port %d %sv%04x type %d",
-			xhci, port, name.text, protocol, type );
+		DBGC2 ( xhci, "XHCI %s-%d %sv%04x type %d",
+			xhci->name, port, name.text, protocol, type );
 		ports = readl ( xhci->cap + supported + XHCI_SUPPORTED_PORTS );
 		psic = XHCI_SUPPORTED_PORTS_PSIC ( ports );
 		if ( psic ) {
 		case XHCI_SPEED_HIGH :	return USB_SPEED_HIGH;
 		case XHCI_SPEED_SUPER :	return USB_SPEED_SUPER;
 		default:
-			DBGC ( xhci, "XHCI %p port %d non-standard PSI value "
-			       "%d\n", xhci, port, psiv );
+			DBGC ( xhci, "XHCI %s-%d non-standard PSI value %d\n",
+			       xhci->name, port, psiv );
 			return -ENOTSUP;
 		}
 	}
 		}
 	}
 
-	DBGC ( xhci, "XHCI %p port %d spurious PSI value %d\n",
-	       xhci, port, psiv );
+	DBGC ( xhci, "XHCI %s-%d spurious PSI value %d\n",
+	       xhci->name, port, psiv );
 	return -ENOENT;
 }
 
 		case USB_SPEED_HIGH :	return XHCI_SPEED_HIGH;
 		case USB_SPEED_SUPER :	return XHCI_SPEED_SUPER;
 		default:
-			DBGC ( xhci, "XHCI %p port %d non-standad speed %d\n",
-			       xhci, port, speed );
+			DBGC ( xhci, "XHCI %s-%d non-standad speed %d\n",
+			       xhci->name, port, speed );
 			return -ENOTSUP;
 		}
 	}
 		}
 	}
 
-	DBGC ( xhci, "XHCI %p port %d unrepresentable speed %#x\n",
-	       xhci, port, speed );
+	DBGC ( xhci, "XHCI %s-%d unrepresentable speed %#x\n",
+	       xhci->name, port, speed );
 	return -ENOENT;
 }
 
 	len = ( ( xhci->slots + 1 ) * sizeof ( xhci->dcbaa[0] ) );
 	xhci->dcbaa = malloc_dma ( len, xhci_align ( len ) );
 	if ( ! xhci->dcbaa ) {
-		DBGC ( xhci, "XHCI %p could not allocate DCBAA\n", xhci );
+		DBGC ( xhci, "XHCI %s could not allocate DCBAA\n", xhci->name );
 		rc = -ENOMEM;
 		goto err_alloc;
 	}
 				  xhci->op + XHCI_OP_DCBAAP ) ) != 0 )
 		goto err_writeq;
 
-	DBGC2 ( xhci, "XHCI %p DCBAA at [%08lx,%08lx)\n",
-		xhci, dcbaap, ( dcbaap + len ) );
+	DBGC2 ( xhci, "XHCI %s DCBAA at [%08lx,%08lx)\n",
+		xhci->name, dcbaap, ( dcbaap + len ) );
 	return 0;
 
  err_writeq:
 	len = ( xhci->scratchpads * xhci->pagesize );
 	xhci->scratchpad = umalloc ( len );
 	if ( ! xhci->scratchpad ) {
-		DBGC ( xhci, "XHCI %p could not allocate scratchpad buffers\n",
-		       xhci );
+		DBGC ( xhci, "XHCI %s could not allocate scratchpad buffers\n",
+		       xhci->name );
 		rc = -ENOMEM;
 		goto err_alloc;
 	}
 	xhci->scratchpad_array =
 		malloc_dma ( array_len, xhci_align ( array_len ) );
 	if ( ! xhci->scratchpad_array ) {
-		DBGC ( xhci, "XHCI %p could not allocate scratchpad buffer "
-		       "array\n", xhci );
+		DBGC ( xhci, "XHCI %s could not allocate scratchpad buffer "
+		       "array\n", xhci->name );
 		rc = -ENOMEM;
 		goto err_alloc_array;
 	}
 	assert ( xhci->dcbaa != NULL );
 	xhci->dcbaa[0] = cpu_to_le64 ( virt_to_phys ( xhci->scratchpad_array ));
 
-	DBGC2 ( xhci, "XHCI %p scratchpad [%08lx,%08lx) array [%08lx,%08lx)\n",
-		xhci, user_to_phys ( xhci->scratchpad, 0 ),
+	DBGC2 ( xhci, "XHCI %s scratchpad [%08lx,%08lx) array [%08lx,%08lx)\n",
+		xhci->name, user_to_phys ( xhci->scratchpad, 0 ),
 		user_to_phys ( xhci->scratchpad, len ),
 		virt_to_phys ( xhci->scratchpad_array ),
 		( virt_to_phys ( xhci->scratchpad_array ) + array_len ) );
 		mdelay ( 1 );
 	}
 
-	DBGC ( xhci, "XHCI %p timed out waiting for stop\n", xhci );
+	DBGC ( xhci, "XHCI %s timed out waiting for stop\n", xhci->name );
 	return -ETIMEDOUT;
 }
 
 		mdelay ( 1 );
 	}
 
-	DBGC ( xhci, "XHCI %p timed out waiting for reset\n", xhci );
+	DBGC ( xhci, "XHCI %s timed out waiting for reset\n", xhci->name );
 	return -ETIMEDOUT;
 }
 
 				  xhci->op + XHCI_OP_CRCR ) ) != 0 )
 		goto err_writeq;
 
-	DBGC2 ( xhci, "XHCI %p CRCR at [%08lx,%08lx)\n",
-		xhci, crp, ( crp + xhci->command.len ) );
+	DBGC2 ( xhci, "XHCI %s CRCR at [%08lx,%08lx)\n",
+		xhci->name, crp, ( crp + xhci->command.len ) );
 	return 0;
 
  err_writeq:
 				  xhci->run + XHCI_RUN_ERSTBA ( 0 ) ) ) != 0 )
 		goto err_writeq_erstba;
 
-	DBGC2 ( xhci, "XHCI %p event ring [%08lx,%08lx) table [%08lx,%08lx)\n",
-		xhci, virt_to_phys ( event->trb ),
+	DBGC2 ( xhci, "XHCI %s event ring [%08lx,%08lx) table [%08lx,%08lx)\n",
+		xhci->name, virt_to_phys ( event->trb ),
 		( virt_to_phys ( event->trb ) + len ),
 		virt_to_phys ( event->segment ),
 		( virt_to_phys ( event->segment ) +
 	/* Identify slot */
 	if ( ( trb->slot > xhci->slots ) ||
 	     ( ( slot = xhci->slot[trb->slot] ) == NULL ) ) {
-		DBGC ( xhci, "XHCI %p transfer event invalid slot %d:\n",
-		       xhci, trb->slot );
+		DBGC ( xhci, "XHCI %s transfer event invalid slot %d:\n",
+		       xhci->name, trb->slot );
 		DBGC_HDA ( xhci, 0, trb, sizeof ( *trb ) );
 		return;
 	}
 	/* Identify endpoint */
 	if ( ( trb->endpoint > XHCI_CTX_END ) ||
 	     ( ( endpoint = slot->endpoint[trb->endpoint] ) == NULL ) ) {
-		DBGC ( xhci, "XHCI %p slot %d transfer event invalid epid "
-		       "%d:\n", xhci, slot->id, trb->endpoint );
+		DBGC ( xhci, "XHCI %s slot %d transfer event invalid epid "
+		       "%d:\n", xhci->name, slot->id, trb->endpoint );
 		DBGC_HDA ( xhci, 0, trb, sizeof ( *trb ) );
 		return;
 	}
 
 		/* Construct error */
 		rc = -ECODE ( trb->code );
-		DBGC ( xhci, "XHCI %p slot %d ctx %d failed (code %d): %s\n",
-		       xhci, slot->id, endpoint->ctx, trb->code,
+		DBGC ( xhci, "XHCI %s slot %d ctx %d failed (code %d): %s\n",
+		       xhci->name, slot->id, endpoint->ctx, trb->code,
 		       strerror ( rc ) );
 		DBGC_HDA ( xhci, 0, trb, sizeof ( *trb ) );
 
 
 	/* Ignore "command ring stopped" notifications */
 	if ( trb->code == XHCI_CMPLT_CMD_STOPPED ) {
-		DBGC2 ( xhci, "XHCI %p command ring stopped\n", xhci );
+		DBGC2 ( xhci, "XHCI %s command ring stopped\n", xhci->name );
 		return;
 	}
 
 	/* Ignore unexpected completions */
 	if ( ! xhci->pending ) {
 		rc = -ECODE ( trb->code );
-		DBGC ( xhci, "XHCI %p unexpected completion (code %d): %s\n",
-		       xhci, trb->code, strerror ( rc ) );
+		DBGC ( xhci, "XHCI %s unexpected completion (code %d): %s\n",
+		       xhci->name, trb->code, strerror ( rc ) );
 		DBGC_HDA ( xhci, 0, trb, sizeof ( *trb ) );
 		return;
 	}
 
 	/* Construct error */
 	rc = -ECODE ( trb->code );
-	DBGC ( xhci, "XHCI %p host controller event (code %d): %s\n",
-	       xhci, trb->code, strerror ( rc ) );
+	DBGC ( xhci, "XHCI %s host controller event (code %d): %s\n",
+	       xhci->name, trb->code, strerror ( rc ) );
 }
 
 /**
 			break;
 
 		default:
-			DBGC ( xhci, "XHCI %p unrecognised event %#x\n:",
-			       xhci, event->cons );
+			DBGC ( xhci, "XHCI %s unrecognised event %#x\n:",
+			       xhci->name, event->cons );
 			DBGC_HDA ( xhci, virt_to_phys ( trb ),
 				   trb, sizeof ( *trb ) );
 			break;
 	physaddr_t crp;
 
 	/* Abort the command */
-	DBGC2 ( xhci, "XHCI %p aborting command\n", xhci );
+	DBGC2 ( xhci, "XHCI %s aborting command\n", xhci->name );
 	xhci_writeq ( xhci, XHCI_CRCR_CA, xhci->op + XHCI_OP_CRCR );
 
 	/* Allow time for command to abort */
 		if ( ! xhci->pending ) {
 			if ( complete->code != XHCI_CMPLT_SUCCESS ) {
 				rc = -ECODE ( complete->code );
-				DBGC ( xhci, "XHCI %p command failed (code "
-				       "%d): %s\n", xhci, complete->code,
+				DBGC ( xhci, "XHCI %s command failed (code "
+				       "%d): %s\n", xhci->name, complete->code,
 				       strerror ( rc ) );
 				DBGC_HDA ( xhci, 0, trb, sizeof ( *trb ) );
 				return rc;
 	}
 
 	/* Timeout */
-	DBGC ( xhci, "XHCI %p timed out waiting for completion\n", xhci );
+	DBGC ( xhci, "XHCI %s timed out waiting for completion\n", xhci->name );
 	rc = -ETIMEDOUT;
 
 	/* Abort command */
 
 	/* Issue command and wait for completion */
 	if ( ( rc = xhci_command ( xhci, &trb ) ) != 0 ) {
-		DBGC ( xhci, "XHCI %p could not enable new slot: %s\n",
-		       xhci, strerror ( rc ) );
+		DBGC ( xhci, "XHCI %s could not enable new slot: %s\n",
+		       xhci->name, strerror ( rc ) );
 		return rc;
 	}
 
 	/* Extract slot number */
 	slot = enabled->slot;
 
-	DBGC2 ( xhci, "XHCI %p slot %d enabled\n", xhci, slot );
+	DBGC2 ( xhci, "XHCI %s slot %d enabled\n", xhci->name, slot );
 	return slot;
 }
 
 
 	/* Issue command and wait for completion */
 	if ( ( rc = xhci_command ( xhci, &trb ) ) != 0 ) {
-		DBGC ( xhci, "XHCI %p could not disable slot %d: %s\n",
-		       xhci, slot, strerror ( rc ) );
+		DBGC ( xhci, "XHCI %s could not disable slot %d: %s\n",
+		       xhci->name, slot, strerror ( rc ) );
 		return rc;
 	}
 
-	DBGC2 ( xhci, "XHCI %p slot %d disabled\n", xhci, slot );
+	DBGC2 ( xhci, "XHCI %s slot %d disabled\n", xhci->name, slot );
 	return 0;
 }
 
 	slot_ctx = ( slot->context +
 		     xhci_device_context_offset ( xhci, XHCI_CTX_SLOT ) );
 	usb->address = slot_ctx->address;
-	DBGC2 ( xhci, "XHCI %p assigned address %d to %s\n",
-		xhci, usb->address, usb->name );
+	DBGC2 ( xhci, "XHCI %s assigned address %d to %s\n",
+		xhci->name, usb->address, usb->name );
 
 	return 0;
 }
 				   xhci_configure_endpoint_input ) ) != 0 )
 		return rc;
 
-	DBGC2 ( xhci, "XHCI %p slot %d ctx %d configured\n",
-		xhci, slot->id, endpoint->ctx );
+	DBGC2 ( xhci, "XHCI %s slot %d ctx %d configured\n",
+		xhci->name, slot->id, endpoint->ctx );
 	return 0;
 }
 
 				   xhci_deconfigure_endpoint_input ) ) != 0 )
 		return rc;
 
-	DBGC2 ( xhci, "XHCI %p slot %d ctx %d deconfigured\n",
-		xhci, slot->id, endpoint->ctx );
+	DBGC2 ( xhci, "XHCI %s slot %d ctx %d deconfigured\n",
+		xhci->name, slot->id, endpoint->ctx );
 	return 0;
 }
 
 				   xhci_evaluate_context_input ) ) != 0 )
 		return rc;
 
-	DBGC2 ( xhci, "XHCI %p slot %d ctx %d (re-)evaluated\n",
-		xhci, slot->id, endpoint->ctx );
+	DBGC2 ( xhci, "XHCI %s slot %d ctx %d (re-)evaluated\n",
+		xhci->name, slot->id, endpoint->ctx );
 	return 0;
 }
 
 
 	/* Issue command and wait for completion */
 	if ( ( rc = xhci_command ( xhci, &trb ) ) != 0 ) {
-		DBGC ( xhci, "XHCI %p slot %d ctx %d could not reset endpoint "
-		       "in state %d: %s\n", xhci, slot->id, endpoint->ctx,
+		DBGC ( xhci, "XHCI %s slot %d ctx %d could not reset endpoint "
+		       "in state %d: %s\n", xhci->name, slot->id, endpoint->ctx,
 		       endpoint->context->state, strerror ( rc ) );
 		return rc;
 	}
 
 	/* Issue command and wait for completion */
 	if ( ( rc = xhci_command ( xhci, &trb ) ) != 0 ) {
-		DBGC ( xhci, "XHCI %p slot %d ctx %d could not stop endpoint "
-		       "in state %d: %s\n", xhci, slot->id, endpoint->ctx,
+		DBGC ( xhci, "XHCI %s slot %d ctx %d could not stop endpoint "
+		       "in state %d: %s\n", xhci->name, slot->id, endpoint->ctx,
 		       endpoint->context->state, strerror ( rc ) );
 		return rc;
 	}
 
 	/* Issue command and wait for completion */
 	if ( ( rc = xhci_command ( xhci, &trb ) ) != 0 ) {
-		DBGC ( xhci, "XHCI %p slot %d ctx %d could not set TR dequeue "
-		       "pointer in state %d: %s\n", xhci, slot->id,
+		DBGC ( xhci, "XHCI %s slot %d ctx %d could not set TR dequeue "
+		       "pointer in state %d: %s\n", xhci->name, slot->id,
 		       endpoint->ctx, endpoint->context->state, strerror ( rc));
 		return rc;
 	}
 	     ( ( rc = xhci_configure_endpoint ( xhci, slot, endpoint ) ) != 0 ))
 		goto err_configure_endpoint;
 
-	DBGC2 ( xhci, "XHCI %p slot %d ctx %d ring [%08lx,%08lx)\n",
-		xhci, slot->id, ctx, virt_to_phys ( endpoint->ring.trb ),
+	DBGC2 ( xhci, "XHCI %s slot %d ctx %d ring [%08lx,%08lx)\n",
+		xhci->name, slot->id, ctx, virt_to_phys ( endpoint->ring.trb ),
 		( virt_to_phys ( endpoint->ring.trb ) + endpoint->ring.len ) );
 	return 0;
 
 	/* Ring doorbell to resume processing */
 	xhci_doorbell ( &endpoint->ring );
 
-	DBGC ( xhci, "XHCI %p slot %d ctx %d reset\n",
-	       xhci, slot->id, endpoint->ctx );
+	DBGC ( xhci, "XHCI %s slot %d ctx %d reset\n",
+	       xhci->name, slot->id, endpoint->ctx );
 	return 0;
 }
 
 	type = xhci_port_slot_type ( xhci, usb->port->address );
 	if ( type < 0 ) {
 		rc = type;
-		DBGC ( xhci, "XHCI %p port %d has no slot type\n",
-		       xhci, usb->port->address );
+		DBGC ( xhci, "XHCI %s-%d has no slot type\n",
+		       xhci->name, usb->port->address );
 		goto err_type;
 	}
 
 	assert ( xhci->dcbaa[id] == 0 );
 	xhci->dcbaa[id] = cpu_to_le64 ( virt_to_phys ( slot->context ) );
 
-	DBGC2 ( xhci, "XHCI %p slot %d device context [%08lx,%08lx) for %s\n",
-		xhci, slot->id, virt_to_phys ( slot->context ),
+	DBGC2 ( xhci, "XHCI %s slot %d device context [%08lx,%08lx) for %s\n",
+		xhci->name, slot->id, virt_to_phys ( slot->context ),
 		( virt_to_phys ( slot->context ) + len ), usb->name );
 	return 0;
 
 		 * has been re-enabled, then some assertions will be
 		 * triggered.
 		 */
-		DBGC ( xhci, "XHCI %p slot %d leaking context memory\n",
-		      xhci, slot->id );
+		DBGC ( xhci, "XHCI %s slot %d leaking context memory\n",
+		       xhci->name, slot->id );
 		slot->context = NULL;
 	}
 
 		mdelay ( 1 );
 	}
 
-	DBGC ( xhci, "XHCI %p timed out waiting for port %d to enable\n",
-	       xhci, port->address );
+	DBGC ( xhci, "XHCI %s-%d timed out waiting for port to enable\n",
+	       xhci->name, port->address );
 	return -ETIMEDOUT;
 }
 
 
 	/* Read port status */
 	portsc = readl ( xhci->op + XHCI_OP_PORTSC ( port->address ) );
-	DBGC2 ( xhci, "XHCI %p port %d status is %08x\n",
-		xhci, port->address, portsc );
+	DBGC2 ( xhci, "XHCI %s-%d status is %08x\n",
+		xhci->name, port->address, portsc );
 	ccs = ( portsc & XHCI_PORTSC_CCS );
 	ped = ( portsc & XHCI_PORTSC_PED );
 	csc = ( portsc & XHCI_PORTSC_CSC );
  */
 static int xhci_root_clear_tt ( struct usb_hub *hub, struct usb_port *port,
 				struct usb_endpoint *ep ) {
-	struct ehci_device *ehci = usb_hub_get_drvdata ( hub );
+	struct xhci_device *xhci = usb_hub_get_drvdata ( hub );
 
 	/* Should never be called; this is a root hub */
-	DBGC ( ehci, "XHCI %p port %d nonsensical CLEAR_TT for %s endpoint "
-	       "%02x\n", ehci, port->address, ep->usb->name, ep->address );
+	DBGC ( xhci, "XHCI %s-%d nonsensical CLEAR_TT for %s %s\n", xhci->name,
+	       port->address, ep->usb->name, usb_endpoint_name ( ep ) );
 
 	return -ENOTSUP;
 }
 	pci_read_config_dword ( pci, XHCI_PCH_USB3PSSEN, &usb3pssen );
 	pci_read_config_dword ( pci, XHCI_PCH_USB3PRM, &usb3prm );
 	if ( usb3prm & ~usb3pssen ) {
-		DBGC ( xhci, "XHCI %p enabling SuperSpeed on ports %08x\n",
-		       xhci, ( usb3prm & ~usb3pssen ) );
+		DBGC ( xhci, "XHCI %s enabling SuperSpeed on ports %08x\n",
+		       xhci->name, ( usb3prm & ~usb3pssen ) );
 	}
 	pch->usb3pssen = usb3pssen;
 	usb3pssen |= usb3prm;
 	pci_read_config_dword ( pci, XHCI_PCH_XUSB2PR, &xusb2pr );
 	pci_read_config_dword ( pci, XHCI_PCH_XUSB2PRM, &xusb2prm );
 	if ( xusb2prm & ~xusb2pr ) {
-		DBGC ( xhci, "XHCI %p routing ports %08x from EHCI to xHCI\n",
-		       xhci, ( xusb2prm & ~xusb2pr ) );
+		DBGC ( xhci, "XHCI %s routing ports %08x from EHCI to xHCI\n",
+		       xhci->name, ( xusb2prm & ~xusb2pr ) );
 	}
 	pch->xusb2pr = xusb2pr;
 	xusb2pr |= xusb2prm;
 		rc = -ENOMEM;
 		goto err_alloc;
 	}
+	xhci->name = pci->dev.name;
 
 	/* Fix up PCI device */
 	adjust_pci_device ( pci );

src/drivers/usb/xhci.h

 struct xhci_device {
 	/** Registers */
 	void *regs;
+	/** Name */
+	const char *name;
 
 	/** Capability registers */
 	void *cap;