Free usb drivers software for linux

Stoqdrivers package contains useful drivers for Stoq and retail systems.

This is a powerful collection of device drivers written in Python and totally focused on retail systems. Stoqdrivers also offers an unified API for devices like fiscal printers which makes it easy to embed in many applications.

DrakLive is a live distribution mastering tool.
draklive builds a live distribution according to a configuration file, creates a master image, and optionally installs it on a device.
Why a new live mastering tool?
Mandriva Move
The Move1/Move2 technology is quite deprecated now, it was about loading writable files in RAM, and using dnotify to monitor file modifications and copy the modified files on the USB key.
It required a specific boot process, and a complex mastering process. It is better replaced by something like unionfs, which allows transparent filesystem overlay (and makes possible files removal).
mklivecd
mklivecd already allows to create live distributions, but its not easy to keep it in sync with latest hardware or technical updates. mklivecd needs its own long initrd script (linuxrc), as well as a new rc.sysinit file. It makes the boot very complicated, and its not easy to maintain all these three programs (linuxrc, rc.sysinit, mklivecd) together.
linux-live / Slax
The linux-live scripts are quite similar, but they also requiresome additional library in the initrd, and they dont provide a good hardware drivers list in their initrd.
Advantages
draklives philosophy is to keep the live distribution as close as possible to a normal Mandriva Linux distribution. All specific live tweaks are done in a very tiny initrd script. Since this one is generated on the fly, its very small, and gets quite easy to debug.
The list of drivers included in the initrd is adjusted during the live distribution creation, according to the medium type. draklive uses the DrakX libraries to have an up-to-date drivers list.
Once the initrd script is done booting, the root device will be used transparently by the distribution, without any additional tricks.
Hardware detection is done with harddrake, providing a reliable integration.
Main features:
- live CD
- live distribution on USB key
- easy to test over NFS
- uses the Mandriva installer to create the live system
- fully read-write live system (using unionfs)
- automatic hardware configuration (using harddrake)
- generic code structure to make new technical choices usable quickly

JDBC Driver for SQLite is a thin layer on top of the SQLite 3.3.x C API. The native JNI library has SQLite compiled into it so all you need to do is include the two files packaged above in your project.
Usage:
Download the binary for the platform you are developing on. Open the tarball and copy the two files into your application directory:
sqlitejdbc.jar
[lib]sqlitejdbc.[dll, so, jnilib]
Reference the driver in your code:
Class.forName("org.sqlite.JDBC");
Connection conn = DriverManager.getConnection("jdbc:sqlite:filename");
// ... use the database ...
conn.close();
And call your program with the drivers JAR file in the classpath and the C library in the librarypath. E.g.
java -cp lib/yourprog.jar:lib/sqlitejdbc.jar
-Djava.library.path=lib
yourprog.Main
Enhancements:
- The driver is now thread-safe and fully supports UTF-16.
- There are binaries for Mac OS, Linux, and Windows, and instructions for compiling with MSVC.

EXAMPLE

# This is a really long synopsis, but hopefully it will give you an idea...

package MyPackage;

use Class::Driver;
use base q(Class::Driver);

our %drivers;

return 1;

sub new {
my($class, %args) = @_;
die "mime_type is required" unless($args{mime_type});
die "no driver to handle type $args{mime_type}"
unless($drivers{$args{mime_type}});
return $class->driver_load($drivers{$args{mime_type}}, %args);
}

sub driver_new {
my($class, %args) = @_;
return bless %args, $class;
}

sub driver_required { 1; }
sub driver_requied_here { 0; }

package MyPackage::avi;

use MyPackage;
use base q(MyPackage);
use Video::Info;

$MyPackage::drivers{video/x-msvideo} = avi;

return 1;

sub driver { "avi"; }

sub driver_new {
my($class, %args) = @_;
die "file is a required parameter for $args{mime_type} files"
unless($args{file});
$args{info} = Video::Info->new(-file => $args{file})
or die "Failed to create a Video::Info object for $args{file}";
return $class->SUPER::driver_new(%args);
}

sub duration {
my $self = shift;
return $args{info}->duration;
}

package MyPackage::mp3;
use base q(MyPackage);
use MP3::Info;

$MyPackage::drivers{audio/mpeg} = mp3;

## (etc...)

package main;

my $foo = MyPackage->new(file => foobar.mp3, mime_type => audio/mpeg);
print "foobar.mp3 is ", $foo->duration, " seconds long.n";

Emulex Linux Drivers package provides the sources for Emulexs LPFC (LightPulse Fibre Channel) family of HBAs. The source base is developed and tested specifically for the 2.6 Linux kernel.
This Emulex driver is derived from Emulexs currently shipping driver which supports several application and storage providers.
Intentions:
Emulex will be working with the open source community with the intention of achieving acceptance of this source into the upstream kernel.
Emulex will also continue to work with application and storage provider partners, many of whom are active members of the open source community, to evolve the code base to meet both upstream kernel and continuing business needs.
Enhancements:
- Miscellaneous Cleanups
- Correct some 8bit to 16bit field conversions/comparisons
- Fixes for short cable pulls
- Adjust use of scsi_block_requests and interaction w/ FC transport
- Remove locking wrappers around error handlers
- Fixes to error handlers
- Add support for more members of the Light Pulse 11xxx (4Gb) family
- Bring model descriptions in sync with Emulex standard generic names.
- Add polled-mode support to the driver:
- Added code to adjust lun queue depth to avoid target overloading.

USB Launcher project is a couple of basic programs to drive the M&S USB Missile Launcher.
ctlmissile does all the actual work. Youll need libusb installed to compile it, but assuming you have that typing "make" should do the trick. You can then
do:
ctlmissile up
ctlmissile down
ctlmissile left
ctlmissile right
ctlmissile fire
ctlmissile stop
to do all the things youd expect. Note youll need to be root to use it. I
havent figured out a nice way to use libusb yet as a user. Anyone got some pointers?
Oh, and youll need to not have usbhid installed or itll claim the device itself (I think I can add support so that it gets automatically disconnected from the device, so Ill have a look at that).
usblauncher is a Perl program that uses GTK2 to provide a basic interface for controlling the launcher. It uses ctlmissile. Currently Ive made ctlmissile suid root so I can run usblauncher as my normal user id, but Im not sure about this long term.
Enhancements:
- Added support for Dream Cheeky USB missile launcher from James Puderer.

Nomad II supports the Creative Nomad II, IIc and II MG under Linux running USB for file transfers and other operations.
By default, the ownership of the newly created device file for the Nomad II is owned by root, without group/other read+write permissions.
make nomadii setuid root; on startup, nomadii
detects it is running in this mode and changes the owner of the device file to the original user, and then immediately drops back to the user ID of the original user (in order to minimize the possibility of security issues). This can be made with a number of techniques:
use the devuid, devgid or devmode mount options for usbdevfs, either in your /etc/fstab file or located where the mount call for usbdevfs is made (/etc/rc.d/rc.sysinit on RedHat 7.x); for example use devmode=0666 to open full access to all USB devices (with the attendant insecureness this creates). In a multi-user machine, setting up a group for USB would be the more secure option using this method.
locate and install the usb_perms daemon
use the hotplug package; this subsystem has good support for USB devices with user-level drivers such as this one with its usb.usermap launch method. The module launched by hotplug can be used to set ownerships or permissions on the device file as soon as the Nomad II is connected, and then even launch an xterm running a nomadii session. This is the most delicate of these methods to set up - sample instructions are given in the HOTPLUG file that comes with the source distribution.
Enhancements:
- Rename of utility to nomadii
- Availablility of RPM
- Full support of the Nomad II, IIc and II MG with latest firmware
- Autocorrection of bad data when getting files from the Nomad
- Much improved error detection and reporting
- Split of code into text front end and library
- Better name handling and progress reporting
- Updated support for nomadii-driver
- Better USB device permission options
- Added send/get methods
- Added support for multiple send, get and delete
- Hotplug documentation and scripts
- Many major and minor bug fixes