RE: [LinuxBIOS] #57: libusb host program for PLX NET20DC debug device

RE: [LinuxBIOS] #57: libusb host program for PLX NET20DC debug device

[Lu, Yinghai]

-----Original Message-----
From: Lu, Yinghai 

>To my understanding, you don't need to waiting for Eric's code.
>You can use the cable on two systems without debug port support.
>So just extend the program to make it can write the data too.

Greg,

Anyone is working on creating one usb_serial_driver for USB debug device
without
using host debug port?

YH

Re: [LinuxBIOS] #57: libusb host program for PLX NET20DC debug device

[Greg KH]

On Fri, Dec 01, 2006 at 10:26:19AM -0800, Lu, Yinghai wrote:
> -----Original Message-----
> From: Lu, Yinghai 
> 
> >To my understanding, you don't need to waiting for Eric's code.
> >You can use the cable on two systems without debug port support.
> >So just extend the program to make it can write the data too.
> 
> Greg,
> 
> Anyone is working on creating one usb_serial_driver for USB debug device
> without using host debug port?

I can do that in about 15 minutes if you give me the device ids for the
usb debug device that you wish to have.

Or you can also use the generic usb-serial driver today just fine with
no modification.  Have you had a problem with using that option?

thanks,

greg k-h

RE: [LinuxBIOS] #57: libusb host program for PLX NET20DC debug device

[Lu, Yinghai]

-----Original Message-----
From: Greg KH [mailto:gregkh@suse.de] 

>I can do that in about 15 minutes if you give me the device ids for the
>usb debug device that you wish to have.

>Or you can also use the generic usb-serial driver today just fine with
>no modification.  Have you had a problem with using that option?

We are talking about using USB debug device/EHCI debug port in LinuxBIOS
in legacy free PC.
Because one AM2+MCP55 MB doesn't have serial port.

I guess Eric is working on USB debug device/EHCI debug port for
earlyprintk or printk.

So we need one client program on host side. So it would great if we
could use current USB stack for 
the clients on system even without debug port.

I'm getting one USB debug device cable, and will test generic usb_serial
driver.

Thanks

YH

Re: [LinuxBIOS] #57: libusb host program for PLX NET20DC debug device

[Peter Stuge]

On Fri, Dec 01, 2006 at 10:41:23AM -0800, Greg KH wrote:
> On Fri, Dec 01, 2006 at 10:26:19AM -0800, Lu, Yinghai wrote:
> > Anyone is working on creating one usb_serial_driver for USB debug
> > device without using host debug port?
> 
> I can do that in about 15 minutes if you give me the device ids for
> the usb debug device that you wish to have.

The host (aka remote) end of the NET20DC debug device has vid 0x0525
and pid 0x127a.


> Or you can also use the generic usb-serial driver today just fine
> with no modification.  Have you had a problem with using that
> option?

Does it check for a debug descriptor and attach to the device if one
is found? Neat!


//Peter

Re: [LinuxBIOS] #57: libusb host program for PLX NET20DC debug device

[Greg KH]

On Fri, Dec 01, 2006 at 08:04:26PM +0100, Peter Stuge wrote:
> On Fri, Dec 01, 2006 at 10:41:23AM -0800, Greg KH wrote:
> > On Fri, Dec 01, 2006 at 10:26:19AM -0800, Lu, Yinghai wrote:
> > > Anyone is working on creating one usb_serial_driver for USB debug
> > > device without using host debug port?
> > 
> > I can do that in about 15 minutes if you give me the device ids for
> > the usb debug device that you wish to have.
> 
> The host (aka remote) end of the NET20DC debug device has vid 0x0525
> and pid 0x127a.

You can use the usb-serial generic driver with those ids (as module
parameters) today, with no kernel changes needed.

> > Or you can also use the generic usb-serial driver today just fine
> > with no modification.  Have you had a problem with using that
> > option?
> 
> Does it check for a debug descriptor and attach to the device if one
> is found? Neat!

No, sorry, you need to use the device ids.

thanks,

greg k-h

Re: [LinuxBIOS] #57: libusb host program for PLX NET20DC debug device

[Greg KH]

On Fri, Dec 01, 2006 at 10:55:48AM -0800, Lu, Yinghai wrote:
> -----Original Message-----
> From: Greg KH [mailto:gregkh@suse.de] 
> 
> >I can do that in about 15 minutes if you give me the device ids for the
> >usb debug device that you wish to have.
> 
> >Or you can also use the generic usb-serial driver today just fine with
> >no modification.  Have you had a problem with using that option?
> 
> We are talking about using USB debug device/EHCI debug port in LinuxBIOS
> in legacy free PC.
> Because one AM2+MCP55 MB doesn't have serial port.
> 
> I guess Eric is working on USB debug device/EHCI debug port for
> earlyprintk or printk.

Well, earlyprintk will not work, as you need PCI up and running.

And I have some code that barely works for this already, perhaps Eric
and I should work together on this :)

> So we need one client program on host side. So it would great if we
> could use current USB stack for 
> the clients on system even without debug port.

Yes, that will work just fine today using the usb-serial generic driver.
I'll knock up a "real" driver for the device later today and send it to
Linus, as it's trivial to do so, and will make it simpler than using the
module parameters.

thanks,

greg k-h

Re: [LinuxBIOS] #57: libusb host program for PLX NET20DC debug device

[Peter Stuge]

On Fri, Dec 01, 2006 at 11:19:16AM -0800, Greg KH wrote:
> Well, earlyprintk will not work, as you need PCI up and running.

Not all of it though. LinuxBIOS will probably do just enough PCI
setup to talk to the EHCI controller and use the debug port _very_
soon after power on.


> And I have some code that barely works for this already, perhaps
> Eric and I should work together on this :)

I would be interested in having a look at any code for it too.


> Yes, that will work just fine today using the usb-serial generic
> driver.

Ugh. I did not know it was that generic. The irony is that I always
ask other libusb users to check the kernel drivers to see if they
really need to write a libusb app.


> I'll knock up a "real" driver for the device later today and send
> it to Linus, as it's trivial to do so, and will make it simpler
> than using the module parameters.

Awesome. Thanks!


//Peter

Re: [LinuxBIOS] #57: libusb host program for PLX NET20DC debug device

[Eric W. Biederman]

Peter Stuge <stuge-linuxbios@cdy.org> writes:

> On Fri, Dec 01, 2006 at 11:19:16AM -0800, Greg KH wrote:
>> Well, earlyprintk will not work, as you need PCI up and running.
>
> Not all of it though. LinuxBIOS will probably do just enough PCI
> setup to talk to the EHCI controller and use the debug port _very_
> soon after power on.

Right.  For LinuxBIOS not a problem for earlyprintk in the kernel
somethings might need to be refactored.  The challenge in the kernel
is we don't know at build to how to do a pci_read_config...

The other hard part early in the kernel is the fact that the
bar is memory mapped I/O.  Which means it will need to get mapped
into the kernels page tables.

>> And I have some code that barely works for this already, perhaps
>> Eric and I should work together on this :)
>
> I would be interested in having a look at any code for it too.

Sure, I will send it out shortly.  I currently have a working
user space libusb thing (easy, but useful for my debug) and 
a rude read/write to the bar from user space program that
allowed me to debug the worst of the state machine from user
space.  I don't think I have the state setup logic correct yet
but that is minor in comparison.

I really wish the EHCI spec had made that stupid interface 16 bytes
instead of 8 or had a way to chain multiple access together.  The
we could have used a normal usb cable.  As it is most descriptors
are 1 byte to big to read.

>> Yes, that will work just fine today using the usb-serial generic
>> driver.
>
> Ugh. I did not know it was that generic. The irony is that I always
> ask other libusb users to check the kernel drivers to see if they
> really need to write a libusb app.
>
>
>> I'll knock up a "real" driver for the device later today and send
>> it to Linus, as it's trivial to do so, and will make it simpler
>> than using the module parameters.
>
> Awesome. Thanks!

Yep. It looks like it sufficient generic.  The Maximum packet size
appears to be reported correctly for writes which is the tidbit
I was worried about but otherwise it is just a pair of bulk transfer
endpoints.

Eric

Re: [LinuxBIOS] #57: libusb host program for PLX NET20DC debug device

[Peter Stuge]

On Fri, Dec 01, 2006 at 02:15:24PM -0700, Eric W. Biederman wrote:
> Right.  For LinuxBIOS not a problem for earlyprintk in the kernel
> somethings might need to be refactored.  The challenge in the
> kernel is we don't know at build to how to do a pci_read_config...
> 
> The other hard part early in the kernel is the fact that the
> bar is memory mapped I/O.  Which means it will need to get mapped
> into the kernels page tables.

I see.


> >> And I have some code that barely works for this already, perhaps
> >> Eric and I should work together on this :)
> >
> > I would be interested in having a look at any code for it too.
> 
> Sure, I will send it out shortly.  I currently have a working
> user space libusb thing (easy, but useful for my debug)

Hm - for driving which end?


> and a rude read/write to the bar from user space program that

How does that work? /dev/{port,mem}?


> allowed me to debug the worst of the state machine from user
> space.  I don't think I have the state setup logic correct yet
> but that is minor in comparison.
> 
> I really wish the EHCI spec had made that stupid interface 16 bytes
> instead of 8 or had a way to chain multiple access together.  The
> we could have used a normal usb cable.  As it is most descriptors
> are 1 byte to big to read.

Which descriptors are you reading?

The debug port isn't really supposed to be used with anything but a
debug device - which can't be enumerated normally anyway.


//Peter

RE: [LinuxBIOS] #57: libusb host program for PLX NET20DC debug device

[Lu, Yinghai]

-----Original Message-----
From: ebiederm@xmission.com [mailto:ebiederm@xmission.com] 
Sent: Friday, December 01, 2006 1:15 PM

Peter Stuge <stuge-linuxbios@cdy.org> writes:

>> On Fri, Dec 01, 2006 at 11:19:16AM -0800, Greg KH wrote:
>>> Well, earlyprintk will not work, as you need PCI up and running.
>>
>> Not all of it though. LinuxBIOS will probably do just enough PCI
>> setup to talk to the EHCI controller and use the debug port _very_
>> soon after power on.

>Right.  For LinuxBIOS not a problem for earlyprintk in the kernel
>somethings might need to be refactored.  The challenge in the kernel
>is we don't know at build to how to do a pci_read_config...

early_pci_read_config?
Otherwise printk will come too late, and will not get output before pci
bus ops is set.

>The other hard part early in the kernel is the fact that the
>bar is memory mapped I/O.  Which means it will need to get mapped
>into the kernels page tables.

several entries to map 0xfc000000 ( PCI IO mem range) in page table in
head.S?

YH

Re: [LinuxBIOS] #57: libusb host program for PLX NET20DC debug device

[Eric W. Biederman]

Peter Stuge <stuge-linuxbios@cdy.org> writes:

> On Fri, Dec 01, 2006 at 02:15:24PM -0700, Eric W. Biederman wrote:
>> Right.  For LinuxBIOS not a problem for earlyprintk in the kernel
>> somethings might need to be refactored.  The challenge in the
>> kernel is we don't know at build to how to do a pci_read_config...
>> 
>> The other hard part early in the kernel is the fact that the
>> bar is memory mapped I/O.  Which means it will need to get mapped
>> into the kernels page tables.
>
> I see.
>
>
>> >> And I have some code that barely works for this already, perhaps
>> >> Eric and I should work together on this :)
>> >
>> > I would be interested in having a look at any code for it too.
>> 
>> Sure, I will send it out shortly.  I currently have a working
>> user space libusb thing (easy, but useful for my debug)
>
> Hm - for driving which end?

Either.  The specific device we are talking about doesn't care.

>> and a rude read/write to the bar from user space program that
>
> How does that work? /dev/{port,mem}?

mmap /dev/mem.

>> allowed me to debug the worst of the state machine from user
>> space.  I don't think I have the state setup logic correct yet
>> but that is minor in comparison.
>> 
>> I really wish the EHCI spec had made that stupid interface 16 bytes
>> instead of 8 or had a way to chain multiple access together.  The
>> we could have used a normal usb cable.  As it is most descriptors
>> are 1 byte too big to read.
>
> Which descriptors are you reading?

Minor.  I was just wishing for less magic in this process, which
would make these kinds of devices much more available.

> The debug port isn't really supposed to be used with anything but a
> debug device - which can't be enumerated normally anyway.

It depends.  If you have a debug cable with magic ends and a hardcoded
address of 127 the normal enumeration doesn't work.  I don't think
anyone actually makes one of those.  Debug devices are also allowed to
be normal devices that just support the debug descriptor.  Which
is what I'm working with.

Eric

Re: [LinuxBIOS] #57: libusb host program for PLX NET20DC debug device

[Eric W. Biederman]

[-- Attachment #1: Type: text/plain, Size: 2345 bytes --]

Greg KH <gregkh@suse.de> writes:

> On Fri, Dec 01, 2006 at 10:55:48AM -0800, Lu, Yinghai wrote:
>> -----Original Message-----
>> From: Greg KH [mailto:gregkh@suse.de] 
>> 
>> >I can do that in about 15 minutes if you give me the device ids for the
>> >usb debug device that you wish to have.
>> 
>> >Or you can also use the generic usb-serial driver today just fine with
>> >no modification.  Have you had a problem with using that option?
>> 
>> We are talking about using USB debug device/EHCI debug port in LinuxBIOS
>> in legacy free PC.
>> Because one AM2+MCP55 MB doesn't have serial port.
>> 
>> I guess Eric is working on USB debug device/EHCI debug port for
>> earlyprintk or printk.
>
> Well, earlyprintk will not work, as you need PCI up and running.
>
> And I have some code that barely works for this already, perhaps Eric
> and I should work together on this :)

I'd love to work with someone on this.  I'm cc'ing Andi Kleen because
he asked me where we had gotten on this the other day.

One big thing we need is a way to tell if you have the
system booted if your device is plugged into the usb port that
connects to the usb debug port.  Figuring out which usb port
you really have to plug into is still trying and error but at
least being able to tell without having to try the code is good.

So here is my mostly somewhat working code.  I don't understand
what you have todo if you want to reset the device and then
find the device so this code currently only works if you have
ehci_hcd already loaded. 

I am avoiding the pci bit simply by having someone pass me the
hard coded numbers...

I think I can get it down to a single base address if I don't
print debugging of which port you are plugged into, or try and
debug the state out of reset.

usbtest.c is my little libusb client program.  It's useful
for exploring things.

usbdebug_direct.c is roughly a driver living in user space
so I can debug the hard bits of the logic.  Not a good production
technique but great for prototyping.  It has all of the basic
primitives needed to actually use the ehci debug port.

The next big thing for me I guess is to modify a kernel and see
what state the usb ports are in when I am booting and how much
of the reset logic I need to understand to make this work.
Greg I expect you understand that a little better than I do.

Eric


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #2: usbtest.c --]
[-- Type: text/x-csrc, Size: 7104 bytes --]

/*
 * Copyright (C) 2006 Eric Biederman (ebiederm@xmission.com)
 *
 *	This program is free software; you can redistribute it and/or
 *	modify it under the terms of the GNU General Public License version
 *	2 as published by the Free Software Foundation.
 *
 *      gcc -Wall -o ./usbtest ./usbtest.c -lusb
 */
#include <stdarg.h>
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <usb.h>

#define DEBUG_DEVICE_MAX 8

#ifndef USB_DT_DEBUG
#define USB_DT_DEBUG	10
#endif
#ifndef USB_FT_DEBUG_MODE
#define USB_FT_DEBUG_MODE	6
#endif 
#define CTRL_TIMEOUT	(5*1000)	/* milliseconds */
#define WRITE_TIMEOUT	(60*1000*1000)	/* 1 minute */

struct usb_debug_descriptor {
	uint8_t	bLength;
	uint8_t bDescriptorType;
	uint8_t bDebugInEndpoint;
	uint8_t bDebugOutEndpoint;
} __attribute__ ((packed));


static void die(char *fmt, ...)
{
	va_list ap;
	va_start(ap, fmt);
	vfprintf(stderr, fmt, ap);
	va_end(ap);
	fflush(stderr);
	fflush(stdout);
	exit(1);
}


static struct usb_device *next_debug_device(struct usb_device *dev,
	struct usb_debug_descriptor *debug)
{
	struct usb_bus *bus;
	if (dev) {
		bus = dev->bus;
		goto next;
	}
	for (bus = usb_busses; bus; bus = bus->next) {
		for (dev = bus->devices; dev; dev = dev->next) {
			struct usb_dev_handle *handle;
			int ret;
#if 1
			printf("%02x:%02x\n",
				dev->descriptor.idVendor,
				dev->descriptor.idProduct);
#endif
			handle = usb_open(dev);
			if (!handle)
				goto next;
			ret = usb_get_descriptor(handle, USB_DT_DEBUG, 0,
				debug, sizeof(*debug));
			usb_close(handle);
#if 1
			printf("ret: %d\n", ret);
#endif
			if (ret == sizeof(*debug))
				return dev;
next:
			;
		}
	}
	return NULL;
}

static int usb_set_debug_mode(usb_dev_handle *handle)
{
	return usb_control_msg(handle, USB_TYPE_STANDARD | USB_RECIP_DEVICE,
		USB_REQ_SET_FEATURE, USB_FT_DEBUG_MODE, 0, NULL, 0,
		CTRL_TIMEOUT);
		
}

static int usb_unconfigure(usb_dev_handle *handle)
{
	return usb_control_msg(handle, USB_TYPE_STANDARD | USB_RECIP_DEVICE,
		USB_REQ_SET_CONFIGURATION, 0, 0, NULL, 0,
		CTRL_TIMEOUT);
}


static int usb_debug_read(struct usb_device *dev,
				struct usb_debug_descriptor *debug)
{
	struct usb_dev_handle *handle;
	char buf[DEBUG_DEVICE_MAX];
	int iface, i, j;
	int ret = -1;

	/* Find the interface to claim! */
	iface = -1;
	for (i = 0; i < dev->config->interface->num_altsetting; i++) {
		struct usb_interface_descriptor *face;
		face = &dev->config->interface->altsetting[i];
		for (j = 0; j < face->bNumEndpoints; j++) {
			if (face->endpoint[j].bEndpointAddress == 
			    debug->bDebugInEndpoint) {
				iface = face->bInterfaceNumber;
				printf("wMaxPacketSize: %u iface: %d\n",
					face->endpoint[j].bEndpointAddress,
					iface);
				goto found_iface;
			}
		}
	}
	goto out;
found_iface:

	handle = usb_open(dev);
	if (!handle)
		goto out;
	if ((ret = usb_claim_interface(handle, iface)) < 0)
		goto out_close;
	if ((ret = usb_set_debug_mode(handle)) < 0)
		goto out_release;
	for (;;) {
		ret = usb_bulk_read(handle, debug->bDebugInEndpoint,
			buf, sizeof(buf), 1000000);
		if (ret < 0)
			goto out_release;
		printf("%d:%*.*s", ret, ret, ret, buf);
	}
out_release:
	usb_release_interface(handle, iface);
out_close:	
	usb_close(handle);
out:
	return ret;
}


static int usb_debug_write(struct usb_device *dev,
				struct usb_debug_descriptor *debug)
{
	struct usb_dev_handle *handle;
	char buf[DEBUG_DEVICE_MAX];
	int iface, i, j;
	int ret;

	ret = -1;
	/* Find the interface to claim! */
	iface = -1;
	for (i = 0; i < dev->config->interface->num_altsetting; i++) {
		struct usb_interface_descriptor *face;
		face = &dev->config->interface->altsetting[i];
		for (j = 0; j < face->bNumEndpoints; j++) {
			if (face->endpoint[j].bEndpointAddress == 
			    debug->bDebugOutEndpoint) {
				iface = face->bInterfaceNumber;
				printf("wMaxPacketSize: %u iface: %d\n",
					face->endpoint[j].bEndpointAddress,
					iface);
				goto found_iface;
			}
		}
	}
	goto out;
found_iface:
	handle = usb_open(dev);
	if (!handle)
		goto out;
	if ((ret = usb_claim_interface(handle, iface)) < 0)
		goto out_close;
	if ((ret = usb_set_debug_mode(handle)) < 0)
		goto out_release;
	for (;;) {
		if ((ret = read(STDIN_FILENO, buf, sizeof(buf))) <= 0)
			goto out_shutdown;

#if 1
		printf("%d:%*.*s", ret, ret, ret, buf);
#endif
		ret = usb_bulk_write(handle, debug->bDebugOutEndpoint,
			buf, ret, WRITE_TIMEOUT);
#if 1
		printf("usb_bulk_write: %d\n", ret);
#endif
		if (ret < 0)
			goto out_shutdown;
	}
out_shutdown:
	usb_unconfigure(handle);
out_release:
	usb_release_interface(handle, iface);
out_close:	
	usb_close(handle);
out:
	return ret;
}

enum debug_op {
	DEBUG_LIST = 0,
	DEBUG_REDIR = 1,
	DEBUG_READ  = 2,
	DEBUG_WRITE = 3,
};
int main(int argc, char **argv)
{
	struct usb_device *dev;
	struct usb_debug_descriptor debug_desc;
	int i;
	int wanted_bus, wanted_dev;
	int wanted_vendor, wanted_product;
	enum debug_op op;

	op = DEBUG_REDIR;
	wanted_bus = wanted_dev = -1;
	wanted_vendor = wanted_product = -1;
	for (i = 1; i < argc; i++) {
		if (strcmp(argv[i], "-s") == 0) {
			char *colon;
			i++;
			if (i >= argc)
				die("missing argument");
			colon = strchr(argv[i], ':');
			if (!colon)
				wanted_dev = strtoul(argv[i], NULL, 10);
			else {
				wanted_bus = strtoul(argv[i], NULL, 10);
				wanted_dev = strtoul(colon + 1, NULL, 10);
			}
		} 
		else if (strcmp(argv[i], "-d") == 0) {
			char *colon;
			i++;
			if (i >= argc)
				die("missing argument");
			wanted_vendor = strtoul(argv[i], NULL, 16);
			if (colon)
				wanted_product = strtoul(colon + 1, NULL, 16);
		}
		else if (strcmp(argv[i], "-l") == 0) {
			op = DEBUG_LIST;
		}
		else if (strcmp(argv[i], "-r") == 0) {
			op = DEBUG_READ;
		}
		else if (strcmp(argv[i], "-w") == 0) {
			op = DEBUG_WRITE;
		}
		else if (strcmp(argv[i], "-rw") == 0) {
			op = DEBUG_REDIR;
		}
		else {
			die("Unknown argument: %s\n", argv[i]);
		}
#if 0
		if (strcmp(argv[i], "-d") == 0)
			break;
#endif
	}

	
	usb_init();
	usb_find_busses();
	usb_find_devices();
	
	dev = next_debug_device(NULL, &debug_desc);
	for (; dev; dev = next_debug_device(dev, &debug_desc)) {
		int busnum;
		busnum = strtol(dev->bus->dirname, NULL, 10);
		if ((wanted_bus != -1) && (busnum != wanted_bus))
			continue;
		if ((wanted_dev != -1) && (dev->devnum != wanted_dev))
			continue;
		if ((wanted_vendor != -1) && 
		    (dev->descriptor.idVendor != wanted_vendor))
			continue;
		if ((wanted_product != -1) && 
		    (dev->descriptor.idProduct != wanted_product))
			continue;
		if (op != DEBUG_LIST)
			goto found;
		printf("%d.%d %04x:%04x\n",
			busnum, dev->devnum,
			dev->descriptor.idVendor,
			dev->descriptor.idProduct);
	}
	if (op == DEBUG_LIST)
		return 0;
	die("No debug devices found\n");
found:	
	printf("Found one!\n");
	printf("desc: %02x %02x %02x %02x\n",
		debug_desc.bLength,
		debug_desc.bDescriptorType,
		debug_desc.bDebugInEndpoint,
		debug_desc.bDebugOutEndpoint);


	switch(op) {
	case DEBUG_READ:
		usb_debug_read(dev, &debug_desc);
		break;
	case DEBUG_WRITE:
		usb_debug_write(dev, &debug_desc);
		break;
	default:
		die("Unknown operation\n");
	}
	return 0;
}

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #3: usbdebug_direct.c --]
[-- Type: text/x-csrc, Size: 17393 bytes --]

/*
 * Copyright (C) 2006 Eric Biederman (ebiederm@xmission.com)
 *
 *	This program is free software; you can redistribute it and/or
 *	modify it under the terms of the GNU General Public License version
 *	2 as published by the Free Software Foundation.
 *
 *      gcc -Wall -o ./usbdebug_direct ./usbdebug_direct.c
 */

#define _LARGEFILE_SOURCE
#define _FILE_OFFSET_BITS 64
#define _POSIC_C_SOURCE 199309
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <stdarg.h>
#include <stdlib.h>
#include <stdint.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <time.h>

static void die(char *fmt, ...)
{
	va_list ap;
	va_start(ap, fmt);
	vfprintf(stderr, fmt, ap);
	va_end(ap);
	fflush(stderr);
	fflush(stdout);
	exit(1);
}


static inline uint8_t readb(const volatile void  *addr)
{
	return *(volatile uint8_t *)addr;
}
static inline uint16_t readw(const volatile void  *addr)
{
	return *(volatile uint16_t *)addr;
}
static inline uint32_t readl(const volatile void  *addr)
{
	return *(volatile uint32_t *)addr;
}
static inline void writel(uint32_t b, volatile void  *addr)
{
	*(volatile uint32_t *)addr = b;
}
static inline void writeb(uint8_t b, volatile void  *addr)
{
	*(volatile uint8_t *)addr = b;
}
static inline void writew(uint16_t b, volatile void  *addr)
{
	*(volatile uint16_t *)addr = b;
}


//#define EHCI_BAR 0xbfce0000
#define EHCI_BAR_BYTES 4096
//#define EHCI_DEBUG_OFFSET 0x98
#define PAGE_SIZE 4096UL

static void *ehci_base, *ehci_op_base, *ehci_debug_base;

/* Off of ehci_base */
#define EHCI_CAPLENGTH		0x00
#define EHCI_HCIVERSION		0x02
#define EHCI_HCSPARAMS		0x04
#define EHCI_HCCPARAMS		0x08
#define EHCI_HCSP_PORTROUTE	0x0c

/* Off of ehci_op_base */
#define EHCI_USBCMD		0x00
#define  EHCI_USBCMD_RUN		(1 << 0)
#define EHCI_USBSTS		0x04
#define  EHCI_USBSTS_HCHALTED		(1 << 12)
#define EHCI_USBINTR		0x08
#define EHCI_FRINDEX		0x0c
#define EHCI_CTRLDSSEGMENT	0x10
#define EHCI_PERIODICLISTBASE	0x14
#define EHCI_ASYNCLISTADDR	0x18
#define EHCI_CONFIGFLAG		0x40
#define  EHCI_CONFIGFLAG_FLAG		(1 << 0)
#define EHCI_PORTSC		0x44
#define  EHCI_PORTSC_PORT_OWNER			(1 << 13)
#define  EHCI_PORTSC_PORT_RESET			(1 << 12)
#define  EHCI_PORTSC_PORT_ENABLED		(1 << 2)
#define  EHCI_PORTSC_CONNECT_STATUS_CHANGED	(1 << 1)
#define  EHCI_PORTSC_CONNECTED			(1 << 0)

/* Off of ehci_debug_base */
#define EHCI_CTRL	0x00
#define  EHCI_CTRL_OWNER			(1 << 30)
#define  EHCI_CTRL_ENABLED			(1 << 28)
#define  EHCI_CTRL_DONE				(1 << 16)
#define  EHCI_CTRL_INUSE			(1 << 10)
#define  EHCI_CTRL_EXCEPTION_MASK		7
#define  EHCI_CTRL_EXCEPTION_SHIFT		7
#define  EHCI_CTRL_EXCEPTION_NONE		0
#define  EHCI_CTRL_EXCEPTION_TRANSACTION	1
#define  EHCI_CTRL_EXCEPTION_HARDWARE		2
#define  EHCI_CTRL_ERROR			(1 << 6)
#define  EHCI_CTRL_GO				(1 << 5)
#define  EHCI_CTRL_WRITE			(1 << 4)
#define  EHCI_CTRL_LENGTH_MASK			(0xf << 0)
#define EHCI_PID		0x04
#define  EHCI_PID_RECEIVED_SHIFT	16
#define  EHCI_PID_SEND_SHIFT		8
#define  EHCI_PID_TOKEN_SHIFT		0
#define EHCI_DATA0	0x08
#define EHCI_DATA1	0x0c
#define EHCI_ADDR	0x10
#define  EHCI_ADDR_DEVNUM_SHIFT   8
#define  EHCI_ADDR_ENDPOINT_SHIFT 0

#define MKPID(x) (((x) & 0xf) | ((~(x) & 0xf) << 4))

/* token */
#define PID_OUT	MKPID(0x1)
#define PID_IN	MKPID(0x9)
#define PID_SOF	MKPID(0x5)
#define PID_SETUP	MKPID(0xd)
/* data */
#define PID_DATA0	MKPID(0x3)
#define PID_DATA1	MKPID(0xb)
#define PID_DATA2	MKPID(0x7)
#define PID_MDATA	MKPID(0xf)
#define PID_DATA_TOGGLE	(0x88)
/* handshake */
#define PID_ACK	MKPID(0x2)
#define PID_NAK	MKPID(0xa)
#define PID_STALL	MKPID(0xe)
#define PID_NYET	MKPID(0x6)
/* Special */
#define PID_PRE	MKPID(0xc)
#define PID_ERR	MKPID(0xc)
#define PID_SPLIT	MKPID(0x8)
#define PID_PING	MKPID(0x4)
#define PID_RESERVED	MKPID(0x0)

/*
 * Standard requests
 */
#define USB_REQ_GET_STATUS              0x00
#define USB_REQ_CLEAR_FEATURE           0x01
/* 0x02 is reserved */
#define USB_REQ_SET_FEATURE             0x03
/* 0x04 is reserved */
#define USB_REQ_SET_ADDRESS             0x05
#define USB_REQ_GET_DESCRIPTOR          0x06
#define USB_REQ_SET_DESCRIPTOR          0x07
#define USB_REQ_GET_CONFIGURATION       0x08
#define USB_REQ_SET_CONFIGURATION       0x09
#define USB_REQ_GET_INTERFACE           0x0A
#define USB_REQ_SET_INTERFACE           0x0B
#define USB_REQ_SYNCH_FRAME             0x0C

#define USB_TYPE_STANDARD	(0x00 << 5)
#define USB_TYPE_CLASS		(0x01 << 5)
#define USB_TYPE_VENDOR		(0x02 << 5)
#define USB_TYPE_RESERVED	(0x03 << 5)

#define USB_RECIP_DEVICE                0x00
#define USB_RECIP_INTERFACE             0x01
#define USB_RECIP_ENDPOINT              0x02
#define USB_RECIP_OTHER                 0x03

/*
 * Various libusb API related stuff
 */

#define USB_ENDPOINT_IN                 0x80
#define USB_ENDPOINT_OUT                0x00

#ifndef USB_DT_DEBUG
#define USB_DT_DEBUG	10
#endif
#ifndef USB_FT_DEBUG_MODE
#define USB_FT_DEBUG_MODE	6
#endif 

struct usb_debug_descriptor {
	uint8_t	bLength;
	uint8_t bDescriptorType;
	uint8_t bDebugInEndpoint;
	uint8_t bDebugOutEndpoint;
} __attribute__ ((packed));

struct usb_status {
	uint16_t status;
} __attribute__ ((packed));


struct usb_request {
	uint8_t  bmRequestType;
	uint8_t  bRequest;
	uint16_t wValue;
	uint16_t wIndex;
	uint16_t wLength;
} __attribute__ ((packed));

static int usb_wait_until_complete(void)
{
	unsigned ctrl;
	for (;;) {
		ctrl = readl(ehci_debug_base + EHCI_CTRL);
		/* Stop when the transaction is finished */
		if (ctrl & EHCI_CTRL_DONE)
			break;
	}
	/* Now that we have observed the completed transaction,
	 * clear the done bit.
	 */
	writel(ctrl | EHCI_CTRL_DONE, ehci_debug_base + EHCI_CTRL);
	return (ctrl & EHCI_CTRL_ERROR) ? 
		-((ctrl >> EHCI_CTRL_EXCEPTION_SHIFT) & EHCI_CTRL_EXCEPTION_MASK):
		ctrl & 0xf;
}

static void usb_breath(void)
{
	struct timespec req;
	/* Sleep to give the debug port a chance to breathe */
	req.tv_sec = 0;
	req.tv_nsec = 10*1000*1000; /* 10 miliseconds seems good */

	while (nanosleep(&req, &req) < 0)
		;
}

static int usb_wait_until_done(unsigned ctrl)
{
	unsigned pids, lpid;
	int ret;

retry:
	writel(ctrl | EHCI_CTRL_GO, ehci_debug_base + EHCI_CTRL);
	ret = usb_wait_until_complete();
	pids = readl(ehci_debug_base + EHCI_PID);
	lpid = (pids >> EHCI_PID_RECEIVED_SHIFT) & 0xff;
#if 0
	if ((ret >= 0) && lpid != PID_ACK)
		printf("lpid: %02x ret: %d\n", lpid, ret);
#endif
	if (ret < 0)
		return ret;

	/* If the port is getting full or it has dropped data
	 * start pacing ourselves, not necessary but it's friendly.
	 */
	if ((lpid == PID_NAK) || (lpid == PID_NYET))
		usb_breath();
	
	/* If I get a NACK reissue the transmission */
	if (lpid == PID_NAK)
		goto retry;

	return ret;
}

static void usb_set_data(const void *buf, int size)
{
	const unsigned char *bytes = buf;
	uint32_t lo, hi;
	int i;
	lo = hi = 0;
	for (i = 0; i < 4 && i < size; i++)
		lo |= bytes[i] << (8*i);
	for (; i < 8 && i < size; i++)
		hi |= bytes[i] << (8*(i - 4));
	writel(lo, ehci_debug_base + EHCI_DATA0);
	writel(hi, ehci_debug_base + EHCI_DATA1);
}

static void usb_get_data(void *buf, int size)
{
	unsigned char *bytes = buf;
	uint32_t lo, hi;
	int i;
	lo = readl(ehci_debug_base + EHCI_DATA0);
	hi = readl(ehci_debug_base + EHCI_DATA1);
#if 0
	printf("data: %08x%08x\n", hi, lo);
#endif
	for (i = 0; i < 4 && i < size; i++)
		bytes[i] = (lo >> (8*i)) & 0xff;
	for (; i < 8 && i < size; i++)
		bytes[i] = (hi >> (8*(i - 4))) & 0xff;
}

static int usb_bulk_write(int address, int endpoint, const char *bytes, int size)
{
	unsigned pids, addr, ctrl;
	int ret;
	if (size > 8)
		return -1;

	addr = ((address & 0x7f) << EHCI_ADDR_DEVNUM_SHIFT) | (endpoint & 0xf);

	pids = readl(ehci_debug_base + EHCI_PID);
	pids &= ~(0xff << EHCI_PID_TOKEN_SHIFT);
	pids |= PID_OUT << EHCI_PID_TOKEN_SHIFT;
	pids ^= (PID_DATA_TOGGLE << EHCI_PID_SEND_SHIFT);
	
	ctrl = readl(ehci_debug_base + EHCI_CTRL);
	ctrl &= ~EHCI_CTRL_LENGTH_MASK;
	ctrl |= EHCI_CTRL_WRITE;
	ctrl |= size & EHCI_CTRL_LENGTH_MASK;
	ctrl |= EHCI_CTRL_GO;

	usb_set_data(bytes, size);
	writel(addr, ehci_debug_base + EHCI_ADDR);
	writel(pids, ehci_debug_base + EHCI_PID);

	ret = usb_wait_until_done(ctrl);
	if (ret < 0) {
		printf("out failed!: %d\n", ret);
		return ret;
	}
	return ret;
}

static int usb_bulk_read(int address, int endpoint, void *data, int size)
{
	unsigned pids, addr, ctrl;
	int ret;

	if (size > 8)
		return -1;

	addr = ((address & 0x7f) << EHCI_ADDR_DEVNUM_SHIFT) | (endpoint & 0xf);

	pids = readl(ehci_debug_base + EHCI_PID);
	pids &= ~(0xff << EHCI_PID_TOKEN_SHIFT);
	pids |= PID_IN << EHCI_PID_TOKEN_SHIFT;
	pids ^= (PID_DATA_TOGGLE << EHCI_PID_SEND_SHIFT);
		
	ctrl = readl(ehci_debug_base + EHCI_CTRL);
	ctrl &= ~EHCI_CTRL_LENGTH_MASK;
	ctrl &= ~EHCI_CTRL_WRITE;
	ctrl |= size & EHCI_CTRL_LENGTH_MASK;
	ctrl |= EHCI_CTRL_GO;
		
	writel(addr, ehci_debug_base + EHCI_ADDR);
	writel(pids, ehci_debug_base + EHCI_PID);
	ret = usb_wait_until_done(ctrl);
	if (ret < 0) {
		printf("in failed!: %d\n", ret);
		return ret;
	}
	if (size > ret)
		size = ret;
	usb_get_data(data, size);
	return ret;
}

static int usb_control_msg(int address, int requesttype, int request, 
	int value, int index, void *data, int size)
{
	unsigned pids, addr, ctrl;
	struct usb_request req;
	int read;
	int ret;

	read = (requesttype & USB_ENDPOINT_IN) != 0;
	if (size > (read?8:0))
		return -1;
	
	/* Compute the control message */
	req.bmRequestType = requesttype;
	req.bRequest = request;
	req.wValue = value;
	req.wIndex = index;
	req.wLength = size;

	pids = PID_SETUP << EHCI_PID_TOKEN_SHIFT;
	pids |= PID_DATA0 << EHCI_PID_SEND_SHIFT;

	addr = ((address & 0x7f) << EHCI_ADDR_DEVNUM_SHIFT) | 0;
	
	ctrl = readl(ehci_debug_base + EHCI_CTRL);
	ctrl &= ~EHCI_CTRL_LENGTH_MASK;
	ctrl |= EHCI_CTRL_WRITE;
	ctrl |= sizeof(req) & EHCI_CTRL_LENGTH_MASK;
	ctrl |= EHCI_CTRL_GO;

	/* Send the setup message */
	usb_set_data(&req, sizeof(req));
	writel(addr, ehci_debug_base + EHCI_ADDR);
	writel(pids, ehci_debug_base + EHCI_PID);
	ret = usb_wait_until_done(ctrl);
	if (ret < 0) {
		//printf("setup failed!: %d\n", ret);
		return ret;
	}


	/* Read the result */
	ret = usb_bulk_read(address, 0, data, size);
#if 1
	pids = readl(ehci_debug_base + EHCI_PID);
	printf("final pids: %08x ret: %d, size: %d\n", pids, ret, size);
#endif
	return ret;
}

static int usb_control_msg0(int address, int requesttype, int request, 
	int value, int index)
{
	return usb_control_msg(address, requesttype, request, value, index, NULL, 0);
}

int main(int argc, char **argv)
{
	struct usb_debug_descriptor debug;
	unsigned long ehci_bar, ehci_debug_offset;
	unsigned endpoint_out, endpoint_in;
	unsigned devnum;
	unsigned hcsparams;
	unsigned debug_port, n_ports;
	int fd;
	unsigned val;
	int result = -1;
	int ret, i;

	if (argc != 3)
		die("usage: %s <bar base> <bar offset>\n"
		     "ex:  ./usbdebug_direct 0xbfce0000 0x98\n"
		     "ex:  ./usbdebug_direct 0x90404400 0xa0\n",
			argv[0]);

	ehci_bar = strtoul(argv[1], NULL, 0);
	ehci_debug_offset = strtoul(argv[2], NULL, 0);
	
	fd = open("/dev/mem", O_RDWR, O_SYNC);
	if (fd < 0)
		die("Cannot open /dev/mem: %s\n", strerror(errno));

	ehci_base = mmap(NULL, PAGE_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd,
		ehci_bar & ~(PAGE_SIZE - 1));
	if (ehci_base == MAP_FAILED)
		die("mmap of /dev/mem failed: %s\n", strerror(errno));

	ehci_base += ehci_bar & (PAGE_SIZE - 1);
	val = readb(ehci_base + EHCI_CAPLENGTH);
	ehci_op_base = ehci_base + val;
	ehci_debug_base = ehci_base + ehci_debug_offset;


	hcsparams = readl(ehci_base + EHCI_HCSPARAMS);
	debug_port = (hcsparams >> 20) & 0xf;
	n_ports = hcsparams & 0xf;

	printf("debug_port: %d\n", debug_port);
	printf("n_ports:    %d\n", n_ports);

	for (i = 1; i <= n_ports; i++) {
		val = readl(ehci_op_base + EHCI_PORTSC + (4*(i - 1)));
		printf("portsc%d: %08x\n", i, val);
	}
#if 0
	/* Reset the silly port */
#endif 
#if 0
	/* Claim ownership, but do not enable yet */
	val = readl(ehci_debug_base + EHCI_CTRL);
	printf("ctrl: %08x\n", val);
	val |= EHCI_CTRL_OWNER;
	val &= ~(EHCI_CTRL_ENABLED | EHCI_CTRL_INUSE);
	writel(val, ehci_debug_base + EHCI_CTRL);

	val = readl(ehci_debug_base + EHCI_CTRL);
	printf("ctrl: %08x\n", val);


#if 1
	/* Ensure everything is routed to the EHCI */
	val = readl(ehci_op_base + EHCI_CONFIGFLAG);
	val |= EHCI_CONFIGFLAG_FLAG;
	writel(val, ehci_op_base + EHCI_CONFIGFLAG);


	for (i = 1; i <= n_ports; i++) {
		val = readl(ehci_op_base + EHCI_PORTSC + (4*(i - 1)));
		printf("portsc%d: %08x\n", i, val);
	}
#endif

	/* Ensure the EHCI controller is running */
	val = readl(ehci_op_base + EHCI_USBCMD);
	val |= EHCI_USBCMD_RUN;
	writel(val, ehci_op_base + EHCI_USBCMD);

	while(readl(ehci_op_base + EHCI_USBSTS) & EHCI_USBSTS_HCHALTED)
		;

	/* Reset the usb debug port */
	val = readl(ehci_op_base + EHCI_PORTSC + 4*(debug_port - 1));
	val |= EHCI_PORTSC_PORT_RESET;
	writel(val, ehci_op_base + EHCI_PORTSC + 4*(debug_port - 1));
	
	/* Sleep long enough for the reset to take effect */
	usb_breath(); /* 10 millseconds */

	/* Stop the reset of the usb debug port */
	val &= ~EHCI_PORTSC_PORT_RESET;
	writel(val, ehci_op_base + EHCI_PORTSC + 4*(debug_port - 1));


	for (i = 1; i <= n_ports; i++) {
		val = readl(ehci_op_base + EHCI_PORTSC + (4*(i - 1)));
		printf("portsc%d: %08x\n", i, val);
	}

	/* Test to see if there is an attached device */
	val = readl(ehci_op_base + EHCI_PORTSC + 4*(debug_port - 1));
	if (!(val & EHCI_PORTSC_CONNECTED)) {
		printf("No device in debug port after reset \n");
		/* Give up the device */
		return -1;
	}

	/* Enable the debug port */
	val = readl(ehci_debug_base + EHCI_CTRL);
	printf("post reset ctrl: %08x\n", val);

	val |= EHCI_CTRL_ENABLED | EHCI_CTRL_INUSE;
	writel(val, ehci_debug_base + EHCI_CTRL);

	val = readl(ehci_debug_base + EHCI_CTRL);
	printf("post reset ctrl: %08x\n", val);

# if 1
	/* Hide the presence of this device from other software */
	val = readl(ehci_op_base + EHCI_PORTSC + 4*(debug_port - 1));
	val &= ~EHCI_PORTSC_PORT_ENABLED;
	writel(val, ehci_op_base + EHCI_PORTSC + 4*(debug_port - 1));
# endif
# if 1
	/* Disable the ehci controller */
	val = readl(ehci_op_base + EHCI_USBCMD);
	val &= ~EHCI_USBCMD_RUN;
	writel(val, ehci_op_base + EHCI_USBCMD);

	while(!(readl(ehci_op_base + EHCI_USBSTS) & EHCI_USBSTS_HCHALTED))
		;
# endif
#else
#define EHCI_CTRL_CLAIM (EHCI_CTRL_OWNER | EHCI_CTRL_ENABLED | EHCI_CTRL_INUSE)
	val  = readl(ehci_debug_base + EHCI_CTRL);
	printf("ctrl: %04x\n", val);

	writel(val | EHCI_CTRL_CLAIM, ehci_debug_base + EHCI_CTRL);

	val  = readl(ehci_debug_base + EHCI_CTRL);
	printf("ctrl: %04x\n", val);
	if ((val & EHCI_CTRL_CLAIM) != EHCI_CTRL_CLAIM) {
		printf("No device in debug port\n");
		writel(val & ~EHCI_CTRL_CLAIM, ehci_debug_base + EHCI_CTRL);
		return -1;
	}
	
#endif

	printf("Find the debug device!\n");

	/* Find the debug device and make it device number 127 */
	for (devnum = 0; devnum <= 127; devnum++) {
		//printf("devnum: %d\n", devnum);
		ret = usb_control_msg(devnum, 
			USB_ENDPOINT_IN | USB_TYPE_STANDARD | USB_RECIP_DEVICE,
			USB_REQ_GET_DESCRIPTOR, (USB_DT_DEBUG << 8), 0,
			&debug, sizeof(debug));
		if (ret > 0)
			break;
	}
	if (devnum > 127) {
		printf("Could not find attached debug device\n");
		goto err;
	}
	if (ret < 0) {
		printf("Attach device is not a debug device\n");
		goto err;
	}
	printf("devnum: %d\n", devnum);
	endpoint_out = debug.bDebugOutEndpoint;
	endpoint_in = debug.bDebugInEndpoint;


	/* Move the device to 127 if it isn't already there */
	if (devnum != 127) {
		ret = usb_control_msg0(devnum,
			USB_TYPE_STANDARD | USB_RECIP_DEVICE,
			USB_REQ_SET_ADDRESS, 127, 0);
		printf("set_address: %d\n", ret);
		if (ret < 0) {
			printf("Could not move attached device to 127\n");
			goto err;
		}
		devnum = 127;
	}

	/* Enable the debug interface */
	ret = usb_control_msg0(devnum, USB_TYPE_STANDARD | USB_RECIP_DEVICE,
		USB_REQ_SET_FEATURE, USB_FT_DEBUG_MODE, 0);
	printf("set_feature_debug_mode: %d\n", ret);
	if (ret < 0) {
		printf(" Could not enable the debug device\n");
		goto err;
	}

#if 1
	{
		//unsigned devnum = 2;
		//unsigned endpoint_out = 1;
		//unsigned endpoint_in = 0x82;
		char *test_strings[] = {
			"zero\n",
			"one\n",
			"two\n",
			"three\n",
			"four\n",
			"five\n",
			"six\n",
			"seven\n",
			"eight\n",
			"nine\n",
			"ten\n",
			"eleven\n",
#if 0
			"twelve\n",
#endif
			NULL,
		};
		char **ptr;

		/* Perform a small write to get the even/odd data state in sync
		 */
		ret = usb_bulk_write(devnum, endpoint_out, " ",1);
		printf("usb_bulk_write: %d\n", ret);

		/* Write the test messages */
		for (ptr = test_strings; *ptr; ptr++) {
			/* Write a test message */
			ret = usb_bulk_write(devnum, endpoint_out,
				*ptr, strlen(*ptr));
			printf("usb_bulk_write: %d\n", ret);
		}
	}
#endif
#if 0

	/* Read some test messages */
	for (;;) {
		char buf[8];
		ret = usb_bulk_read(devnum, endpoint_in, 
			buf, sizeof(buf));
		if (ret > 0)
			printf("%d:%*.*s", ret, ret, ret, buf);
	}
#endif
	for (i = 0; i < 256; i+=1) {
		val = readb(ehci_base + i);
		printf("%02x ", val);
		if ((i & 0xf) == 0xf)
			printf("\n");
	}
	printf("\n");

	result = 0;
err:
#ifdef EHCI_CTRL_CLAIM
	val = readl(ehci_debug_base + EHCI_CTRL);
	printf("ctrl: %08x\n", val);
	val &= ~(EHCI_CTRL_CLAIM | EHCI_CTRL_WRITE);
	writel(val, ehci_debug_base + EHCI_CTRL);
	val = readl(ehci_debug_base + EHCI_CTRL);
	printf("ctrl: %08x\n", val);
#endif
	return result;
	
}

RE: [LinuxBIOS] #57: libusb host program for PLX NET20DC debug device

[Lu, Yinghai]

Thanks for the code.

In LinuxBIOS,
I put usbdevice_direct.c in lib/, and call it from usb2_init in
mcp55_usb2.c

Got 
"No device in debug port"

Waiting for cable, hope to get that cable next Tuesday.

Will create usbdebug_direct_console.c in console/ for linuxbios_ram
code.
also usbdebug_direct_serial.c in pc80/ for cache_as_ram.c


YH

Re: [LinuxBIOS] #57: libusb host program for PLX NET20DC debug device

[Eric W. Biederman]

"Lu, Yinghai" <yinghai.lu@amd.com> writes:

> Thanks for the code.
>
> In LinuxBIOS,
> I put usbdevice_direct.c in lib/, and call it from usb2_init in
> mcp55_usb2.c
>
> Got 
> "No device in debug port"
>
> Waiting for cable, hope to get that cable next Tuesday.
>
> Will create usbdebug_direct_console.c in console/ for linuxbios_ram
> code.
> also usbdebug_direct_serial.c in pc80/ for cache_as_ram.c


Please yank the direct out of the filename if you are making something
like this out of it.  That was my note I was going direct to hardware
which is pretty much assumed if you are in LinuxBIOS.

Eric

Re: [LinuxBIOS] #57: libusb host program for PLX NET20DC debug device

[yhlu]

On 12/2/06, Eric W. Biederman <ebiederm@xmission.com> wrote:
> Please yank the direct out of the filename if you are making something
> like this out of it.  That was my note I was going direct to hardware
> which is pretty much assumed if you are in LinuxBIOS.

Yes, I adapted the code to used in LinuxBIOS, including CAR stage code
and RAM satge code.

I didn't have debug cable plugged yet.

BTW in kernel earlyprintk or prink, you could use
read_pci_config/write_pci_config before PCI system is loaded.

YH

Re: [LinuxBIOS] #57: libusb host program for PLX NET20DC debug device

[Eric W. Biederman]

yhlu <yinghailu@gmail.com> writes:

> On 12/2/06, Eric W. Biederman <ebiederm@xmission.com> wrote:
>> Please yank the direct out of the filename if you are making something
>> like this out of it.  That was my note I was going direct to hardware
>> which is pretty much assumed if you are in LinuxBIOS.
>
> Yes, I adapted the code to used in LinuxBIOS, including CAR stage code
> and RAM satge code.
>
> I didn't have debug cable plugged yet.

Even if you did it wouldn't work right now.  My initial
version does initialize the ehci properly so it won't
find any usb devices.  I almost have that fixed,
but it looks like for the usb device reset I need
a usable delay function, so I can delay 50ms.  Grr...

> BTW in kernel earlyprintk or prink, you could use
> read_pci_config/write_pci_config before PCI system is loaded.

Yep thanks that seems to be working.  Now I just need
to find an early delay and I can try this mess out!

Eric

Re: [LinuxBIOS] #57: libusb host program for PLX NET20DC debug device

[Stefan Reinauer]

* Eric W. Biederman <ebiederm@xmission.com> [061203 12:51]:
> > BTW in kernel earlyprintk or prink, you could use
> > read_pci_config/write_pci_config before PCI system is loaded.
> 
> Yep thanks that seems to be working.  Now I just need
> to find an early delay and I can try this mess out!

you could use io delay, one outb uses roughly 1us iirc.

-- 
coresystems GmbH • Brahmsstr. 16 • D-79104 Freiburg i. Br.
      Tel.: +49 761 7668825 • Fax: +49 761 7664613
Email: info@coresystems.de  • http://www.coresystems.de/

Re: [LinuxBIOS] #57: libusb host program for PLX NET20DC debug device

[Segher Boessenkool]

> you could use io delay, one outb uses roughly 1us iirc.

On LPC, yes -- or 0.5us or something like that.  On ISA it's
a lot faster, on PCI too -- better do 20 or so outb's to be
safe.  Or use a *real* timer instead, you'll have to abstract
this for portability anyway...


Segher

Re: [LinuxBIOS] #57: libusb host program for PLX NET20DC debug device

[Stefan Reinauer]

* Segher Boessenkool <segher@kernel.crashing.org> [061203 13:42]:
> On LPC, yes -- or 0.5us or something like that.  On ISA it's
> a lot faster, on PCI too -- better do 20 or so outb's to be
> safe.

The value's actually something we have been using as a rule of thumb
while doing outb to port 80. Don't think these are routed to LPC, are
they?

-- 
coresystems GmbH • Brahmsstr. 16 • D-79104 Freiburg i. Br.
      Tel.: +49 761 7668825 • Fax: +49 761 7664613
Email: info@coresystems.de  • http://www.coresystems.de/

Re: [LinuxBIOS] #57: libusb host program for PLX NET20DC debug device

[Eric W. Biederman]

Stefan Reinauer <stepan@coresystems.de> writes:

> * Segher Boessenkool <segher@kernel.crashing.org> [061203 13:42]:
>> On LPC, yes -- or 0.5us or something like that.  On ISA it's
>> a lot faster, on PCI too -- better do 20 or so outb's to be
>> safe.
>
> The value's actually something we have been using as a rule of thumb
> while doing outb to port 80. Don't think these are routed to LPC, are
> they?

Depends on the destination address.  For 0x80 you can be fairly
certain it will be an unacknowledged cycle subtractively decoded
to the slowest bus on the system.  Or routed to 32 PCI or the LPC bus
if there is something to actually looking at the value so it is slow.

Since all I need is something that delays for about 50ms 50,000 outb
to port 0x80 looks like a good first approximation, and since it
only happens once it is probably better to just bump that count up
instead of trying to be precise about it and have an accurate timer.

I'm not at all convinced a usb console can be made sufficiently solid
to be useful.  But it is at least worth trying so we can clearly say
it doesn't work well.

Eric

Re: [LinuxBIOS] #57: libusb host program for PLX NET20DC debug device

[Eric W. Biederman]

Greg KH <gregkh@suse.de> writes:

> On Fri, Dec 01, 2006 at 10:55:48AM -0800, Lu, Yinghai wrote:
>> -----Original Message-----
>> From: Greg KH [mailto:gregkh@suse.de] 
>> 
>> >I can do that in about 15 minutes if you give me the device ids for the
>> >usb debug device that you wish to have.
>> 
>> >Or you can also use the generic usb-serial driver today just fine with
>> >no modification.  Have you had a problem with using that option?
>> 
>> We are talking about using USB debug device/EHCI debug port in LinuxBIOS
>> in legacy free PC.
>> Because one AM2+MCP55 MB doesn't have serial port.
>> 
>> I guess Eric is working on USB debug device/EHCI debug port for
>> earlyprintk or printk.
>
> Well, earlyprintk will not work, as you need PCI up and running.

*grin*  I just generated the bootlog below.  So I think I have
it working.  There is a lot of cleanup left and I need some sleep but
it works for me.  I will generate a patch to start the conversation
after I wake up.

> And I have some code that barely works for this already, perhaps Eric
> and I should work together on this :)

Eric


Linux version 2.6.19-rc6devel (eric@fess.biederman.org) (gcc version 4.1.1 2006
0525 (Red Hat 4.1.1-1)) #153 SMP Sun Dec 3 07:56:52 MST 2006
Command line: ro root=LABEL=/ rhgb earlyprintk=dbgp console=tty0 console=ttyS0,1
15200 panic=30
BIOS-provided physical RAM map:
 BIOS-e820: 0000000000000000 - 000000000009fc00 (usable)
 BIOS-e820: 000000000009fc00 - 00000000000a0000 (reserved)
 BIOS-e820: 00000000000e6000 - 0000000000100000 (reserved)
 BIOS-e820: 0000000000100000 - 000000009ffd0000 (usable)
 BIOS-e820: 000000009ffd0000 - 000000009ffde000 (ACPI data)
 BIOS-e820: 000000009ffde000 - 00000000a0000000 (ACPI NVS)
 BIOS-e820: 00000000fec00000 - 00000000fec01000 (reserved)
 BIOS-e820: 00000000fee00000 - 00000000fee01000 (reserved)
 BIOS-e820: 00000000ff780000 - 0000000100000000 (reserved)
 BIOS-e820: 0000000100000000 - 000000024c000000 (usable)
end_pfn_map = 2408448
kernel direct mapping tables up to 24c000000 @ 8000-13000
DMI 2.3 present.
SRAT: PXM 0 -> APIC 0 -> Node 0
SRAT: PXM 0 -> APIC 1 -> Node 0
SRAT: PXM 1 -> APIC 2 -> Node 1
SRAT: PXM 1 -> APIC 3 -> Node 1
SRAT: Node 0 PXM 0 100000-a0000000
SRAT: Node 1 PXM 1 14c000000-24c000000
SRAT: Node 0 PXM 0 100000-14c000000
SRAT: Node 0 PXM 0 0-14c000000
Bootmem setup node 0 0000000000000000-000000014c000000
Bootmem setup node 1 000000014c000000-000000024c000000
Zone PFN ranges:
  DMA             0 ->     4096
  DMA32        4096 ->  1048576
  Normal    1048576 ->  2408448
early_node_map[4] active PFN ranges
    0:        0 ->      159
    0:      256 ->   655312
    0:  1048576 ->  1359872
    1:  1359872 ->  2408448
Nvidia board detected. Ignoring ACPI timer override.
If you got timer trouble try acpi_use_timer_override
ACPI: PM-Timer IO Port: 0x4008
ACPI: LAPIC (acpi_id[0x01] lapic_id[0x00] enabled)
Processor #0 (Bootup-CPU)
ACPI: LAPIC (acpi_id[0x02] lapic_id[0x01] enabled)
Processor #1
ACPI: LAPIC (acpi_id[0x03] lapic_id[0x02] enabled)
Processor #2
ACPI: LAPIC (acpi_id[0x04] lapic_id[0x03] enabled)
Processor #3
ACPI: IOAPIC (id[0x04] address[0xfec00000] gsi_base[0])
IOAPIC[0]: apic_id 4, address 0xfec00000, GSI 0-23
ACPI: IOAPIC (id[0x05] address[0xdfefc000] gsi_base[24])
IOAPIC[1]: apic_id 5, address 0xdfefc000, GSI 24-47
ACPI: INT_SRC_OVR (bus 0 bus_irq 0 global_irq 2 dfl dfl)
ACPI: BIOS IRQ0 pin2 override ignored.
ACPI: INT_SRC_OVR (bus 0 bus_irq 9 global_irq 9 high level)
Setting APIC routing to flat
Using ACPI (MADT) for SMP configuration information
Nosave address range: 000000000009f000 - 00000000000a0000
Nosave address range: 00000000000a0000 - 00000000000e6000
Nosave address range: 00000000000e6000 - 0000000000100000
Nosave address range: 000000009ffd0000 - 000000009ffde000
Nosave address range: 000000009ffde000 - 00000000a0000000
Nosave address range: 00000000a0000000 - 00000000fec00000
Nosave address range: 00000000fec00000 - 00000000fec01000
Nosave address range: 00000000fec01000 - 00000000fee00000
Nosave address range: 00000000fee00000 - 00000000fee01000
Nosave address range: 00000000fee01000 - 00000000ff780000
Nosave address range: 00000000ff780000 - 0000000100000000
Allocating PCI resources starting at a8000000 (gap: a0000000:5ec00000)
PERCPU: Allocating 66560 bytes of per cpu data
Built 2 zonelists.  Total pages: 1960348
Kernel command line: ro root=LABEL=/ rhgb earlyprintk=dbgp console=tty0 console=
ttyS0,115200 panic=30
Initializing CPU#0
PID hash table entries: 4096 (order: 12, 32768 bytes)
disabling early console

Re: [LinuxBIOS] #57: libusb host program for PLX NET20DC debug device

[Peter Stuge]

On Fri, Dec 01, 2006 at 04:02:03PM -0700, Eric W. Biederman wrote:
> >> Sure, I will send it out shortly.  I currently have a working
> >> user space libusb thing (easy, but useful for my debug)
> >
> > Hm - for driving which end?
> 
> Either.  The specific device we are talking about doesn't care.

Which device do you have?


> > The debug port isn't really supposed to be used with anything but
> > a debug device - which can't be enumerated normally anyway.
> 
> It depends.  If you have a debug cable with magic ends and a
> hardcoded address of 127 the normal enumeration doesn't work.  I
> don't think anyone actually makes one of those.

Only one of the ports on Stefan's PLX NET20DC that I had a look at
during the LinuxBIOS symposium enumerated for me.


> Debug devices are also allowed to be normal devices that just
> support the debug descriptor.  Which is what I'm working with.

Aye. I would be happy if we could get something out, as you have
done! :) Looking forward to trying it, I hope I get my device soon.


//Peter

Re: [LinuxBIOS] #57: libusb host program for PLX NET20DC debug device

[Eric W. Biederman]

Peter Stuge <stuge-linuxbios@cdy.org> writes:

> On Fri, Dec 01, 2006 at 04:02:03PM -0700, Eric W. Biederman wrote:
>> >> Sure, I will send it out shortly.  I currently have a working
>> >> user space libusb thing (easy, but useful for my debug)
>> >
>> > Hm - for driving which end?
>> 
>> Either.  The specific device we are talking about doesn't care.
>
> Which device do you have?

Well it is built by PLX, and from lsusb I see are:
0525:127a Netchip Technology, Inc. 

The hardware is a little rectangular pcb board a little smaller
then a business card.  Wrapped in a blue case, with vertical vents
on both of the long sides, and gets a little warm when you have been
running it for a while.  The device has what appears to be 2 normal
host to slave cables running into it.

The picture at the bottom of:
http://advdbg.org/blogs/advdbg_system/articles/64.aspx

Looks like what I have.  I'm curious about the whole plug both
ends into the host before plugging it into the client, and about
the strange target system BIOS requirements.

I think I succeeded in making it work without out that by just putting
in a reset.  It does make the whole setup of the device a pain though.

>> > The debug port isn't really supposed to be used with anything but
>> > a debug device - which can't be enumerated normally anyway.
>> 
>> It depends.  If you have a debug cable with magic ends and a
>> hardcoded address of 127 the normal enumeration doesn't work.  I
>> don't think anyone actually makes one of those.
>
> Only one of the ports on Stefan's PLX NET20DC that I had a look at
> during the LinuxBIOS symposium enumerated for me.

Very odd.  I'm pretty certain we are talking same thing.  But I do
know it has a couple of weird quirks, so maybe you just ran up against
that.

>> Debug devices are also allowed to be normal devices that just
>> support the debug descriptor.  Which is what I'm working with.
>
> Aye. I would be happy if we could get something out, as you have
> done! :) Looking forward to trying it, I hope I get my device soon.

Well at least this means after it works I can probably forget about
it and let someone else maintain the code ;)

Eric