So, I'm building a device (it's a programmable, USB-powered RGB LED lamp, so it's rather silly :) but this problem comes up in more serious contexts as well, such as when a PLC provides a USB interface for application download to the PLC) that is going to use an application/executive model for the firmware -- the executive is programmed into Flash, implementing the USB device and core I/O functions as well as an interpreter for the application firmware, which is compiled to some sort of intermediate format before download to the device, which stores it in a separate memory space (an EEPROM or a separate Flash).
However, this raises the question of "what class should my device be?":
Vendor class is always an option, but it's something I'd rather not resort to unless I had to as it makes the tooling just that much more annoying without gaining me much over a "dumb pipe" solution, unless there are existing vendor class de-facto standard protocols I can follow for this?
You'd think DFU would make sense, but it's really designed for monolithic device firmware, not applications in an application/executive model
Mass Storage is not simple to implement (due to having to deal with command sets optimized for complex storage devices on the order of GB or TB, with way more going on inside them than a simple, randomly-accessible EEPROM or the likes)
CDC has a couple options -- CDC-ACM works everywhere, but requires a bit of extra gook to deal with the encapsulated-command business. Linux also supports CDC without a control model through the "generic" usb-serial driver, but it's not clear if Windows can be cajoled into supporting such a "skeletal" CDC implementation without having to write code. (I can sacrifice Windows support in this application, but it'd be a nice-to-have even if it's at a "should work" state.)
HID also provides a couple options: one can implement a "dumb pipe" over HID if CDC isn't an option for some reason, or it's possible to do more sophisticated protocols via HID as well. This has the advantage that both Windows and Linux deal well with talking to HID devices from userland, but has downsides as well, since this isn't what HID was intended to do.
Media Transfer Protocol provides a Mass Storage alternative that works more along the lines of a filesystem (and is thus simpler in some ways) but has the downside that it is not supported very cleanly on Windows (Explorer handles it OK, but it is not handled cleanly from a scripting/command line standpoint at all). Linux tends to be a bit picky about MTP devices as well...
Anyone out there know what's been done before in this type of application?