Hello. I'm working on a driver for the Microchip USB to SPI bridge with
GPIO
(http://www.microchip.com/wwwproducts/Devices.aspx?dDocName=en556614)
because I wish to use one of these in my project. This will be my first
driver for an actual hardware device (I've done special-purpose
character/ioctl drivers before) and I'm starting from an implementation
that Mathew King of Trilithic wrote
(https://github.com/MathewKing/mcp2210-linux) to try out the device. As
it turns out, he discovered that it wasn't suitable for his application
and wont be using the chip or maintaining the code, so I'm picking it up.
My challenge is that while I'm creating a specific hardware product that
will use this chip, I would like to write a generic MCP2210 driver that
exposes its functionality and then have my driver (specific to my
hardware) live on top of that, as a dependent of the generic MCP2210
driver. The point of this is that I would like the MCP2210 driver to be
re-usable and I'm not really certain of how to go about this. Somebody
from the linux-usb mailing list suggested that the MCP2210 sounds like a
multi-function device and belongs under drivers/mfd.
So I guess I should start with the basic challenges with a generic USB
to SPI device and then talk about my specific hardware product.
The MCP2210: (datasheet here:
http://ww1.microchip.com/downloads/en/DeviceDoc/22288A.pdf)
On the peripheral side, the MCP2210 gives you 9 'GP' pins which can be
used for either an SPI chip-select, GPIO or some special 'dedicated'
purpose (an LED driver for an SPI traffic indicator, input to receive
interrupts from peripherals, USB suspend/resume output, etc.) and has a
small amount of non-volatile storage for initial settings at power-up as
well as 256-bytes for user data. The power-up settings includes the
initial mode for each GP pin, the initial value of each output GPIO pin,
some of the device's USB settings (iProduct, iVendor, idProduct,
idVendor and requested power) as well as the initial SPI communication
settings (SPI mode, timings, CS values, etc.) -- but only for one SPI
device. Thus, if you have different devices that require different
timings, you have to supply those at the time you want to start
communicating with each new device. So aside from what you can store in
the EEPROM and the USB fields, there is no way to auto-probe the
hardware on the peripheral side of this device.
On the USB side, the MCP2210's class is set to HID, subclass 'generic'
and the hid-generic driver will probe it by default (unless you bind
something else to it first). The USB class & sub-class cannot be
changed. :(
My hardware: (a single axis stepper driver & position sensor thingy)
My brother and I are working on a device who's hardware can vary
somewhat, so some devices may or may not be present while others might
be replaced with something different (but similar). Thus, our plan is
to store the configuration for a particular device in that 256 bytes of
EEPROM. Either way, I want to manage all of the details of working with
the MCP2210 in the MCP2210 driver code and simply feed it the correct
configuration for my device from my device-specific driver causing the
MCP2210 driver to expose the correct spidev devices, GPIO, etc.
Luckily, I've discovered an affordable way to acquire a valid
vendor/product ID (via the generous folks at Openmoko), so at least I
can have my driver probed upon matching that (instead of matching on
Microchip's default MCP2210 vendor/product id), but I'm not certain
exactly how to code these two drivers as separate entities, with one
depending upon the other.
Currently, the MCP2210 driver exposes a hidraw device (which I can at
least use to configure the chip) and a hard-coded spidev device on pin
4, which I presume worked for his test environment. So my specific
questions are:
1. What class should the generic MCP2210 driver be in? multi-function
device? SPI? Industrial I/O?
2. Can you kindly point me at the docs for this sub-system? (if it's
not obvious :)
3. When my driver is called via the functions exported in the struct
spi_master after I register it with spi_register_master(), I'm
presuming these will never be in an interrupt context (soft or
hard). Is that correct? (I'm planning on using simple mutexes for
locking.)
4. How do I specify in my specific driver that it's dependent upon the
generic MCP2210 driver? I know that's easy if it's in-tree via
Kconfig, but out-of-tree, during module_init or some such?
5. How should I communicate with the MCP2210 driver? Should I just
export my special functions via EXPORT_SYMBOL_GPL(mcp2210_xxx) or
use some other mechanism?
Help & advice very much appreciated!
Thanks,
Daniel Santos

Freeware

Windows

558 KB

5,261