/* Functions used by new usb-serial code. */
static int __init sierra_init(void)
{
int retval;
retval = usb_serial_register(&sierra_1port_device);
if (retval)
goto failed_1port_device_register;
retval = usb_serial_register(&sierra_3port_device);
if (retval)
goto failed_3port_device_register;
retval = usb_register(&sierra_driver);
if (retval)
goto failed_driver_register;
info(DRIVER_DESC ": " DRIVER_VERSION);
return 0;
failed_driver_register:
usb_serial_deregister(&sierra_3port_device);
failed_3port_device_register:
usb_serial_deregister(&sierra_1port_device);
failed_1port_device_register:
return retval;
}
static int __init visor_init (void)
{
struct urb *urb;
int i;
usb_serial_register (&handspring_device);
usb_serial_register (&clie_3_5_device);
/* create our write urb pool and transfer buffers */
spin_lock_init (&write_urb_pool_lock);
for (i = 0; i < NUM_URBS; ++i) {
urb = usb_alloc_urb(0);
write_urb_pool[i] = urb;
if (urb == NULL) {
err("No more urbs???");
continue;
}
urb->transfer_buffer = NULL;
urb->transfer_buffer = kmalloc (URB_TRANSFER_BUFFER_SIZE, GFP_KERNEL);
if (!urb->transfer_buffer) {
err (__FUNCTION__ " - out of memory for urb buffers.");
continue;
}
}
info(DRIVER_DESC " " DRIVER_VERSION);
return 0;
}
/*===========================================================================
METHOD:
GobiInit (Free Method)
DESCRIPTION:
Register the driver and device
PARAMETERS:
RETURN VALUE:
int - negative error code on failure
zero on success
===========================================================================*/
static int __init GobiInit( void )
{
int nRetval = 0;
gpClose = NULL;
gGobiDevice.num_ports = NUM_BULK_EPS;
// Registering driver to USB serial core layer
nRetval = usb_serial_register( &gGobiDevice );
if (nRetval != 0)
{
return nRetval;
}
// Registering driver to USB core layer
nRetval = usb_register( &GobiDriver );
if (nRetval != 0)
{
usb_serial_deregister( &gGobiDevice );
return nRetval;
}
// This will be shown whenever driver is loaded
printk( KERN_INFO "%s: %s\n", DRIVER_DESC, DRIVER_VERSION );
return nRetval;
}
static int __init ir_init(void)
{
int retval;
if (buffer_size) {
ir_device.bulk_in_size = buffer_size;
ir_device.bulk_out_size = buffer_size;
}
retval = usb_serial_register(&ir_device);
if (retval)
goto failed_usb_serial_register;
retval = usb_register(&ir_driver);
if (retval)
goto failed_usb_register;
printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
DRIVER_DESC "\n");
return 0;
failed_usb_register:
usb_serial_deregister(&ir_device);
failed_usb_serial_register:
return retval;
}
static int __init safe_init(void)
{
int i, retval;
// printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
;
/* if we have vendor / product parameters patch them into id list */
if (vendor || product) {
// printk(KERN_INFO KBUILD_MODNAME ": vendor: %x product: %x\n",
;
for (i = 0; i < ARRAY_SIZE(id_table); i++) {
if (!id_table[i].idVendor && !id_table[i].idProduct) {
id_table[i].idVendor = vendor;
id_table[i].idProduct = product;
break;
}
}
}
retval = usb_serial_register(&safe_device);
if (retval)
goto failed_usb_serial_register;
retval = usb_register(&safe_driver);
if (retval)
goto failed_usb_register;
return 0;
failed_usb_register:
usb_serial_deregister(&safe_device);
failed_usb_serial_register:
return retval;
}
static int modem_probe(struct platform_device *pdev)
{
int retval;
spin_lock_init(&modem.lock);
INIT_DELAYED_WORK(&modem.delayed_pwr_shutdown, modem_power_off);
modem.connected = false;
modem.regulator = regulator_get(NULL, "vusb_modem_ipc");
if (IS_ERR(modem.regulator)) {
modem.regulator = NULL;
}
else {
/* If a regulator is available for driving the other end of the modem
interface, set a timer to turn it off if it does not enumerate. This
is done to conserve power if the modem does not enumerate due to
it's USB interface being turned off. */
regulator_enable(modem.regulator);
(void)schedule_delayed_work(&modem.delayed_pwr_shutdown,
msecs_to_jiffies(PWR_DOWN_TIMEOUT_MS));
}
modem_wake_irq = platform_get_irq(pdev, 0);
retval = usb_serial_register(&modem_device);
if (retval)
return retval;
retval = usb_register(&modem_driver);
if (retval)
usb_serial_deregister(&modem_device);
return retval;
}
static int __init ssu100_init(void)
{
int retval;
dbg("%s", __func__);
/* register with usb-serial */
retval = usb_serial_register(&ssu100_device);
if (retval)
goto failed_usb_sio_register;
retval = usb_register(&ssu100_driver);
if (retval)
goto failed_usb_register;
printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
DRIVER_DESC "\n");
return 0;
failed_usb_register:
usb_serial_deregister(&ssu100_device);
failed_usb_sio_register:
return retval;
}
static int __init visor_init (void)
{
struct urb *urb;
int i;
/* Only if parameters were passed to us */
if ((vendor > 0) && (product > 0)) {
struct usb_device_id usb_dev_temp[]=
{{USB_DEVICE(vendor, product)}};
id_param_table[0] = usb_dev_temp[0];
info("Untested USB device specified at time of module insertion");
info("Warning: This is not guaranteed to work");
info("Using a newer kernel is preferred to this method");
info("Adding Palm OS protocol 4.x support for unknown device: 0x%x/0x%x",
param_device.id_table[0].idVendor, param_device.id_table[0].idProduct);
param_register = 1;
usb_serial_register (¶m_device);
}
usb_serial_register (&handspring_device);
usb_serial_register (&clie_3_5_device);
/* create our write urb pool and transfer buffers */
spin_lock_init (&write_urb_pool_lock);
for (i = 0; i < NUM_URBS; ++i) {
urb = usb_alloc_urb(0);
write_urb_pool[i] = urb;
if (urb == NULL) {
err("No more urbs???");
continue;
}
urb->transfer_buffer = NULL;
urb->transfer_buffer = kmalloc (URB_TRANSFER_BUFFER_SIZE, GFP_KERNEL);
if (!urb->transfer_buffer) {
err("%s - out of memory for urb buffers.", __FUNCTION__);
continue;
}
}
info(DRIVER_DESC " " DRIVER_VERSION);
return 0;
}
static int usb_ipw_init(void)
{
int retval;
retval = usb_serial_register(&ipw_device);
if (retval)
return retval;
info(DRIVER_DESC " " DRIVER_VERSION);
return 0;
}
static int __init moto_flashqsc_init(void)
{
int retval;
retval = usb_serial_register(&moto_flashqsc_device);
if (retval)
return retval;
retval = usb_register(&moto_flashqsc_driver);
if (retval)
usb_serial_deregister(&moto_flashqsc_device);
return retval;
}
static int __init zio_init(void)
{
int retval;
retval = usb_serial_register(&zio_device);
if (retval)
return retval;
retval = usb_register(&zio_driver);
if (retval)
usb_serial_deregister(&zio_device);
return retval;
}
static int do_usbserial(struct command *cmdtp, int argc, char *argv[])
{
int opt;
struct usb_serial_pdata pdata;
char *argstr;
char *manufacturer = "barebox";
char *productname = CONFIG_BOARDINFO;
u16 idVendor = 0, idProduct = 0;
int mode = 0;
while ((opt = getopt(argc, argv, "m:p:V:P:asd")) > 0) {
switch (opt) {
case 'm':
manufacturer = optarg;
break;
case 'p':
productname = optarg;
break;
case 'V':
idVendor = simple_strtoul(optarg, NULL, 0);
break;
case 'P':
idProduct = simple_strtoul(optarg, NULL, 0);
break;
case 'a':
mode = 0;
break;
#ifdef HAVE_OBEX
case 'o':
mode = 1;
break;
#endif
case 's':
mode = 2;
break;
case 'd':
usb_serial_unregister();
return 0;
}
}
argstr = argv[optind];
pdata.manufacturer = manufacturer;
pdata.productname = productname;
pdata.idVendor = idVendor;
pdata.idProduct = idProduct;
pdata.mode = mode;
return usb_serial_register(&pdata);
}
static int __init usi_init(void)
{
int retval;
printk("====usi_init====\n");
retval = usb_serial_register(&usi_device);
if (retval)
return retval;
retval = usb_register(&usi_driver);
if (retval)
usb_serial_deregister(&usi_device);
return retval;
}
static int __init airprime_init(void)
{
int retval;
airprime_device.num_ports =
(endpoints > 0 && endpoints <= MAX_BULK_EPS) ? endpoints : NUM_BULK_EPS;
retval = usb_serial_register(&airprime_device);
if (retval)
return retval;
retval = usb_register(&airprime_driver);
if (retval)
usb_serial_deregister(&airprime_device);
return retval;
}
static int __init qcinit(void)
{
int retval;
retval = usb_serial_register(&qcdevice);
if (retval)
return retval;
retval = usb_register(&qcdriver);
if (retval) {
usb_serial_deregister(&qcdevice);
return retval;
}
return 0;
}
static int __init aircable_init (void)
{
int retval;
retval = usb_serial_register(&aircable_device);
if (retval)
goto failed_serial_register;
retval = usb_register(&aircable_driver);
if (retval)
goto failed_usb_register;
return 0;
failed_serial_register:
usb_serial_deregister(&aircable_device);
failed_usb_register:
return retval;
}
static int __init escvp_init(void)
{
int ret;
ret = usb_serial_register(&escvp_device);
if (ret) {
printk(KERN_ERR "escvp: registeration failed\n");
return ret;
}
ret = usb_register(&escvp_driver);
if (ret) {
usb_serial_deregister(&escvp_device);
printk(KERN_ERR "escvp: registeration failed\n");
return ret;
};
return 0;
}
static int __init mct_u232_init (void)
{
int retval;
retval = usb_serial_register(&mct_u232_device);
if (retval)
goto failed_usb_serial_register;
retval = usb_register(&mct_u232_driver);
if (retval)
goto failed_usb_register;
info(DRIVER_DESC " " DRIVER_VERSION);
return 0;
failed_usb_register:
usb_serial_deregister(&mct_u232_device);
failed_usb_serial_register:
return retval;
}
static int __init omninet_init (void)
{
int retval;
retval = usb_serial_register(&zyxel_omninet_device);
if (retval)
goto failed_usb_serial_register;
retval = usb_register(&omninet_driver);
if (retval)
goto failed_usb_register;
info(DRIVER_VERSION ":" DRIVER_DESC);
return 0;
failed_usb_register:
usb_serial_deregister(&zyxel_omninet_device);
failed_usb_serial_register:
return retval;
}
static int __init usb_ipw_init(void)
{
int retval;
retval = usb_serial_register(&ipw_device);
if (retval)
return retval;
retval = usb_register(&usb_ipw_driver);
if (retval) {
usb_serial_deregister(&ipw_device);
return retval;
}
printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
DRIVER_DESC "\n");
return 0;
}
static int __init belkin_sa_init(void)
{
int retval;
retval = usb_serial_register(&belkin_device);
if (retval)
goto failed_usb_serial_register;
retval = usb_register(&belkin_driver);
if (retval)
goto failed_usb_register;
// printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
;
return 0;
failed_usb_register:
usb_serial_deregister(&belkin_device);
failed_usb_serial_register:
return retval;
}
static int __init mct_u232_init(void)
{
int retval;
retval = usb_serial_register(&mct_u232_device);
if (retval)
goto failed_usb_serial_register;
retval = usb_register(&mct_u232_driver);
if (retval)
goto failed_usb_register;
printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
DRIVER_DESC "\n");
return 0;
failed_usb_register:
usb_serial_deregister(&mct_u232_device);
failed_usb_serial_register:
return retval;
}
static int __init empeg_init(void)
{
struct urb *urb;
int i, retval;
/* create our write urb pool and transfer buffers */
spin_lock_init(&write_urb_pool_lock);
for (i = 0; i < NUM_URBS; ++i) {
urb = usb_alloc_urb(0, GFP_KERNEL);
write_urb_pool[i] = urb;
if (urb == NULL) {
printk(KERN_ERR "empeg: No more urbs???\n");
continue;
}
urb->transfer_buffer = kmalloc(URB_TRANSFER_BUFFER_SIZE,
GFP_KERNEL);
if (!urb->transfer_buffer) {
printk(KERN_ERR "empeg: %s - out of memory for urb "
"buffers.", __func__);
continue;
}
}
retval = usb_serial_register(&empeg_device);
if (retval)
goto failed_usb_serial_register;
retval = usb_register(&empeg_driver);
if (retval)
goto failed_usb_register;
printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
DRIVER_DESC "\n");
return 0;
failed_usb_register:
usb_serial_deregister(&empeg_device);
failed_usb_serial_register:
for (i = 0; i < NUM_URBS; ++i) {
if (write_urb_pool[i]) {
kfree(write_urb_pool[i]->transfer_buffer);
usb_free_urb(write_urb_pool[i]);
}
}
return retval;
}
static int __init siemens_usb_mpi_init(void)
{
int retval;
retval = usb_serial_register(&siemens_usb_mpi_device);
if (retval)
goto failed_usb_serial_register;
retval = usb_register(&siemens_usb_mpi_driver);
if (retval)
goto failed_usb_register;
printk(KERN_INFO DRIVER_DESC "\n");
printk(KERN_INFO DRIVER_VERSION " " DRIVER_AUTHOR "\n");
return retval;
failed_usb_register:
usb_serial_deregister(&siemens_usb_mpi_device);
failed_usb_serial_register:
return retval;
}
static int __init qcinit(void)
{
int retval;
printk(KERN_INFO "qcserial: loaded");
retval = usb_serial_register(&qcdevice);
if (retval)
return retval;
retval = usb_register(&qcdriver);
if (retval) {
usb_serial_deregister(&qcdevice);
return retval;
}
return 0;
}
static int __init cyberjack_init (void)
{
int retval;
retval = usb_serial_register(&cyberjack_device);
if (retval)
goto failed_usb_serial_register;
retval = usb_register(&cyberjack_driver);
if (retval)
goto failed_usb_register;
info(DRIVER_VERSION " " DRIVER_AUTHOR);
info(DRIVER_DESC);
return 0;
failed_usb_register:
usb_serial_deregister(&cyberjack_device);
failed_usb_serial_register:
return retval;
}
static int __init cp2101_init (void)
{
int retval;
retval = usb_serial_register(&cp2101_device);
if (retval)
return retval; /* Failed to register */
retval = usb_register(&cp2101_driver);
if (retval) {
/* Failed to register */
usb_serial_deregister(&cp2101_device);
return retval;
}
/* Success */
info(DRIVER_DESC " " DRIVER_VERSION);
return 0;
}
static int __init cp210x_init(void)
{
int retval;
retval = usb_serial_register(&cp210x_device);
if (retval)
return retval; /* Failed to register */
retval = usb_register(&cp210x_driver);
if (retval) {
/* Failed to register */
usb_serial_deregister(&cp210x_device);
return retval;
}
/* Success */
printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
DRIVER_DESC "\n");
return 0;
}
int usb_serial_generic_register (int _debug)
{
int retval = 0;
debug = _debug;
#ifdef CONFIG_USB_SERIAL_GENERIC
generic_device_ids[0].idVendor = vendor;
generic_device_ids[0].idProduct = product;
generic_device_ids[0].match_flags = USB_DEVICE_ID_MATCH_VENDOR | USB_DEVICE_ID_MATCH_PRODUCT;
/* register our generic driver with ourselves */
retval = usb_serial_register (&usb_serial_generic_device);
if (retval)
goto exit;
retval = usb_register(&generic_driver);
if (retval)
usb_serial_deregister(&usb_serial_generic_device);
exit:
#endif
return retval;
}
static int __init ipaq_init(void)
{
int retval;
retval = usb_serial_register(&ipaq_device);
if (retval)
goto failed_usb_serial_register;
if (vendor) {
ipaq_id_table[0].idVendor = vendor;
ipaq_id_table[0].idProduct = product;
}
retval = usb_register(&ipaq_driver);
if (retval)
goto failed_usb_register;
// printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
;
return 0;
failed_usb_register:
usb_serial_deregister(&ipaq_device);
failed_usb_serial_register:
return retval;
}