Eureka!

First, here are  my EEPROM read/write functions:

////
// eeprom.h: eeprom read/write functions for PIC18F MCUs
// Phil Pemberton <piclist@philpem.me.uk>

// read the byte at <addr> from data EEPROM
unsigned char eeGet(unsigned int addr);

// write the byte <data> to data EEPROM at address <addr>
void eePut(unsigned int addr, unsigned char data);

// read <count> bytes of data from data EEPROM into the array <data>
void eeGetBlock(unsigned int addr, unsigned char *data, unsigned char count);

// write <count> bytes of data from the array <data> into data EEPROM
void eePutBlock(unsigned int addr, const unsigned char *data, unsigned char 
count);

//// end eeprom.h


////
// eeprom.c: eeprom read/write functions for PIC18F MCUs
// Phil Pemberton <piclist@philpem.me.uk>

#include <p18f4550.h>		// FIXME: change this for whatever chip is in use
#include "eeprom.h"

// read the byte at <addr> from data EEPROM
unsigned char eeGet(unsigned int addr)
{
	// load the address
//	EEADRH = (addr >> 8);
	EEADR = (addr & 0xff);

	// reading from data memory, not pgm flash
	EECON1bits.EEPGD = 0;
	EECON1bits.CFGS = 0;
	EECON1bits.RD = 1;

	return EEDATA;
}

void eePut(unsigned int addr, unsigned char data)
{
	int old_gie;

	// load the address
//	EEADRH = (addr >> 8);
	EEADR = (addr & 0xff);

	// reading from data memory, not pgm flash
	EECON1bits.EEPGD = 0;
	EECON1bits.CFGS = 0;
	EECON1bits.WREN = 1;

	// critical write sequence
	old_gie = INTCONbits.GIE;
	INTCONbits.GIE = 0;
	_asm
		MOVLW 0x55
		MOVWF EECON2,0
		MOVLW 0xAA
		MOVWF EECON2,0
	_endasm

	// do the write and wait for it to complete
	EECON1bits.WR = 1;
	while (EECON1bits.WR);

	// end of critical write sequence
	INTCONbits.GIE = old_gie;

	// disable EEPROM writes
	EECON1bits.WREN = 0;
}

void eeGetBlock(unsigned int addr, unsigned char *data, unsigned char count)
{
	int x;
	for (x=0; x<count; x++) {
		data[x] = eeGet(addr+x);
	}
}

void eePutBlock(unsigned int addr, const unsigned char *data, unsigned char count)
{
	int x;
	for (x=0; x<count; x++) {
		eePut(addr+x, data[x]);
	}
}

////

And now the code that does the real magic.. This replaces the 
USBStdGetDscHandler function in system/usb/usb9/usb9.c:

void USBStdGetDscHandler(void)
{
     if(SetupPkt.bmRequestType == 0x80)
     {
         switch(SetupPkt.bDscType)
         {
             case DSC_DEV:
                 ctrl_trf_session_owner = MUID_USB9;
                 pSrc.bRom = (rom byte*)&device_dsc;
                 wCount._word = sizeof(device_dsc);          // Set data count
				usb_stat.ctrl_trf_mem = _ROM;               // Set memory type
                 break;
             case DSC_CFG:
                 ctrl_trf_session_owner = MUID_USB9;
                 pSrc.bRom = *(USB_CD_Ptr+SetupPkt.bDscIndex);
                 wCount._word = *(pSrc.wRom+1);              // Set data count
				usb_stat.ctrl_trf_mem = _ROM;               // Set memory type
                 break;
             case DSC_STR:
				// are we providing the S/N descriptor?
				if (SetupPkt.bDscIndex != 0xff) {
					// no, get the specified descriptor from ROM
	                ctrl_trf_session_owner = MUID_USB9;
	                pSrc.bRom = *(USB_SD_Ptr+SetupPkt.bDscIndex);
	                wCount._word = *pSrc.bRom;                  // Set data count
					usb_stat.ctrl_trf_mem = _ROM;               // Set memory type
				} else {
					int i;
					unsigned char snblock[8];
					volatile far struct{byte bLength;byte bDscType;word string[16];} 
usb_serial_str;
					
					// requested S/N descriptor -- get the serial number from EEPROM
					eeGetBlock(0, snblock, 8);

					// convert it into a hex string and load it into the descriptor buffer
					for (i=0; i<8; i++) {
						const char hexconv[17] = "0123456789ABCDEF";
						usb_serial_str.string[i*2]   = hexconv[snblock[i] >> 4];
						usb_serial_str.string[i*2+1] = hexconv[snblock[i] & 0x0F];
					}

					// set the descriptor length and type
					usb_serial_str.bLength = sizeof(usb_serial_str);
					usb_serial_str.bDscType = DSC_STR;

					// prepare the data transfer (which is done elsewhere)
	                ctrl_trf_session_owner = MUID_USB9;
	                pSrc.bRam = (byte*)&usb_serial_str;
					wCount._word = *pSrc.bRam;
					usb_stat.ctrl_trf_mem = _RAM;               // Set memory type
				}
                 break;
         }//end switch
     }//end if
}//end USBStdGetDscHandler

Now all you have to do is modify the device descriptor in usbdsc.c to link 
string descriptor 0xFF to the serial number field:

// ....
     0x0000,                 // Device release number in BCD format
     0x01,                   // Manufacturer string index
     0x02,                   // Product string index
     0xff,                   // Device serial number string index [*]
     0x01                    // Number of possible configurations
};

Now program the device serial number into EEPROM locations 0x00 thru 0x08, and 
when your device enumerates it'll have a serial number. This basically allows 
settings belonging to the device to follow it no matter which port it's on. 
For instance, if you've set up a CDC device and set it to use COM5, when you 
move it to another USB port, Windows should (in theory) realise it's the same 
device and allocate COM5 to it. Well, that's the theory anyway.

Next job is to cook up a small app to make building string descriptors a 
little easier. Enter a string, get a descriptor, that sort of thing. Entering 
strings as single-quote/char/single-quote/comma gets really old, really fast.

-- 
Phil.                         |  (\_/)  This is Bunny. Copy and paste Bunny
piclist@philpem.me.uk         | (='.'=) into your signature to help him gain
http://www.philpem.me.uk/     | (")_(") world domination.
-- 
http://www.piclist.com PIC/SX FAQ & list archive
View/change your membership options at
http://mailman.mit.edu/mailman/listinfo/piclist