🚀 go-pugleaf

Thomas G. McWilliams <tgm@netcom.com> wrote:
>The GPL certainly has an effect when considering the kernel.  We have
>a potential product that would require a device driver.  Our
>customers seem to keep bang up to date with Linux versions.  If we
>release a binary-only device driver, it will be unusable within a
>week of release, because there'll have been yet another kernel
>version issued... We can't make the sources available, because of the
>non-disclosure agreements that we have willingly signed.  Without the
>sources, users can't make the patches required to keep a binary driver
>usable.  We certainly can't devote someone to just following the

Why do new Linux kernels require new device drivers?  As long as the
interface between the kernel and the driver is not changing, and the
device itself is not changing, why can't the old driver work?  Are
you peeking around at internal kernel data structures or something?

Anyway, there's a trick you could use.  I've used this when I needed to
have device code run on multiple operating systems, and it worked pretty
well.  Convert the bulk of the driver into object form, using your favorite
simple object file format.

Run this through a program that converts it into a C source file that
contains the object file as an array, giving you something like this:

	unsigned char MyDriver[] = {
		0x12,0x43,0x25,...

Now, for each operating system, you write a driver that interfaces to that
operating system, and includes the MyDriver[] array.  On initialization,
go read the relocation and symbol information in MyDriver[], and do
whatever is necessary to turn it into code (e.g., perform relocation, find
the entry points, etc.).

You can hide in MyDriver[] all the proprietary or NDA stuff, and release
full source to the OS-specific portion of the driver.

A nice side effect of this is that if you've got to use different
compilers on different systems, you can at least know that the bulk
of your code (the MyDriver[] stuff) is the same, and you don't have
to worry as much about whether a bug that shows up on just one system
is a compiler bug on that system or not.  When you're trying to support
a driver on a wide variety of platforms (ours were running as Netware NLMs,
Windows VxDs, and SCO Unix drivers), getting the bulk of the driver to be
the same at the binary level on all the platforms is a real comfort.

--Tim Smith