usb/atm/xusbatm.c

0001 // SPDX-License-Identifier: GPL-2.0+
0002 /******************************************************************************
0003  *  xusbatm.c - dumb usbatm-based driver for modems initialized in userspace
0004  *
0005  *  Copyright (C) 2005 Duncan Sands, Roman Kagan (rkagan % mail ! ru)
0006  ******************************************************************************/
0007
0008 #include <linux/module.h>
0009 #include <linux/etherdevice.h>      /* for eth_random_addr() */
0010
0011 #include "usbatm.h"
0012
0013
0014 #define XUSBATM_DRIVERS_MAX 8
0015
0016 #define XUSBATM_PARM(name, type, parmtype, desc) \
0017     static type name[XUSBATM_DRIVERS_MAX]; \
0018     static unsigned int num_##name; \
0019     module_param_array(name, parmtype, &num_##name, 0444); \
0020     MODULE_PARM_DESC(name, desc)
0021
0022 XUSBATM_PARM(vendor, unsigned short, ushort, "USB device vendor");
0023 XUSBATM_PARM(product, unsigned short, ushort, "USB device product");
0024
0025 XUSBATM_PARM(rx_endpoint, unsigned char, byte, "rx endpoint number");
0026 XUSBATM_PARM(tx_endpoint, unsigned char, byte, "tx endpoint number");
0027 XUSBATM_PARM(rx_padding, unsigned char, byte, "rx padding (default 0)");
0028 XUSBATM_PARM(tx_padding, unsigned char, byte, "tx padding (default 0)");
0029 XUSBATM_PARM(rx_altsetting, unsigned char, byte, "rx altsetting (default 0)");
0030 XUSBATM_PARM(tx_altsetting, unsigned char, byte, "rx altsetting (default 0)");
0031
0032 static const char xusbatm_driver_name[] = "xusbatm";
0033
0034 static struct usbatm_driver xusbatm_drivers[XUSBATM_DRIVERS_MAX];
0035 static struct usb_device_id xusbatm_usb_ids[XUSBATM_DRIVERS_MAX + 1];
0036 static struct usb_driver xusbatm_usb_driver;
0037
0038 static struct usb_interface *xusbatm_find_intf(struct usb_device *usb_dev, int altsetting, u8 ep)
0039 {
0040     struct usb_host_interface *alt;
0041     struct usb_interface *intf;
0042     int i, j;
0043
0044     for (i = 0; i < usb_dev->actconfig->desc.bNumInterfaces; i++)
0045         if ((intf = usb_dev->actconfig->interface[i]) && (alt = usb_altnum_to_altsetting(intf, altsetting)))
0046             for (j = 0; j < alt->desc.bNumEndpoints; j++)
0047                 if (alt->endpoint[j].desc.bEndpointAddress == ep)
0048                     return intf;
0049     return NULL;
0050 }
0051
0052 static int xusbatm_capture_intf(struct usbatm_data *usbatm, struct usb_device *usb_dev,
0053         struct usb_interface *intf, int altsetting, int claim)
0054 {
0055     int ifnum = intf->altsetting->desc.bInterfaceNumber;
0056     int ret;
0057
0058     if (claim && (ret = usb_driver_claim_interface(&xusbatm_usb_driver, intf, usbatm))) {
0059         usb_err(usbatm, "%s: failed to claim interface %2d (%d)!\n", __func__, ifnum, ret);
0060         return ret;
0061     }
0062     ret = usb_set_interface(usb_dev, ifnum, altsetting);
0063     if (ret) {
0064         usb_err(usbatm, "%s: altsetting %2d for interface %2d failed (%d)!\n", __func__, altsetting, ifnum, ret);
0065         return ret;
0066     }
0067     return 0;
0068 }
0069
0070 static void xusbatm_release_intf(struct usb_device *usb_dev, struct usb_interface *intf, int claimed)
0071 {
0072     if (claimed) {
0073         usb_set_intfdata(intf, NULL);
0074         usb_driver_release_interface(&xusbatm_usb_driver, intf);
0075     }
0076 }
0077
0078 static int xusbatm_bind(struct usbatm_data *usbatm,
0079             struct usb_interface *intf, const struct usb_device_id *id)
0080 {
0081     struct usb_device *usb_dev = interface_to_usbdev(intf);
0082     int drv_ix = id - xusbatm_usb_ids;
0083     int rx_alt = rx_altsetting[drv_ix];
0084     int tx_alt = tx_altsetting[drv_ix];
0085     struct usb_interface *rx_intf = xusbatm_find_intf(usb_dev, rx_alt, rx_endpoint[drv_ix]);
0086     struct usb_interface *tx_intf = xusbatm_find_intf(usb_dev, tx_alt, tx_endpoint[drv_ix]);
0087     int ret;
0088
0089     usb_dbg(usbatm, "%s: binding driver %d: vendor %04x product %04x"
0090         " rx: ep %02x padd %d alt %2d tx: ep %02x padd %d alt %2d\n",
0091         __func__, drv_ix, vendor[drv_ix], product[drv_ix],
0092         rx_endpoint[drv_ix], rx_padding[drv_ix], rx_alt,
0093         tx_endpoint[drv_ix], tx_padding[drv_ix], tx_alt);
0094
0095     if (!rx_intf || !tx_intf) {
0096         if (!rx_intf)
0097             usb_dbg(usbatm, "%s: no interface contains endpoint %02x in altsetting %2d\n",
0098                 __func__, rx_endpoint[drv_ix], rx_alt);
0099         if (!tx_intf)
0100             usb_dbg(usbatm, "%s: no interface contains endpoint %02x in altsetting %2d\n",
0101                 __func__, tx_endpoint[drv_ix], tx_alt);
0102         return -ENODEV;
0103     }
0104
0105     if ((rx_intf != intf) && (tx_intf != intf))
0106         return -ENODEV;
0107
0108     if ((rx_intf == tx_intf) && (rx_alt != tx_alt)) {
0109         usb_err(usbatm, "%s: altsettings clash on interface %2d (%2d vs %2d)!\n", __func__,
0110                 rx_intf->altsetting->desc.bInterfaceNumber, rx_alt, tx_alt);
0111         return -EINVAL;
0112     }
0113
0114     usb_dbg(usbatm, "%s: rx If#=%2d; tx If#=%2d\n", __func__,
0115             rx_intf->altsetting->desc.bInterfaceNumber,
0116             tx_intf->altsetting->desc.bInterfaceNumber);
0117
0118     ret = xusbatm_capture_intf(usbatm, usb_dev, rx_intf, rx_alt, rx_intf != intf);
0119     if (ret)
0120         return ret;
0121
0122     if ((tx_intf != rx_intf) && (ret = xusbatm_capture_intf(usbatm, usb_dev, tx_intf, tx_alt, tx_intf != intf))) {
0123         xusbatm_release_intf(usb_dev, rx_intf, rx_intf != intf);
0124         return ret;
0125     }
0126
0127     return 0;
0128 }
0129
0130 static void xusbatm_unbind(struct usbatm_data *usbatm,
0131                struct usb_interface *intf)
0132 {
0133     struct usb_device *usb_dev = interface_to_usbdev(intf);
0134     int i;
0135
0136     usb_dbg(usbatm, "%s entered\n", __func__);
0137
0138     for (i = 0; i < usb_dev->actconfig->desc.bNumInterfaces; i++) {
0139         struct usb_interface *cur_intf = usb_dev->actconfig->interface[i];
0140
0141         if (cur_intf && (usb_get_intfdata(cur_intf) == usbatm)) {
0142             usb_set_intfdata(cur_intf, NULL);
0143             usb_driver_release_interface(&xusbatm_usb_driver, cur_intf);
0144         }
0145     }
0146 }
0147
0148 static int xusbatm_atm_start(struct usbatm_data *usbatm,
0149                  struct atm_dev *atm_dev)
0150 {
0151     atm_dbg(usbatm, "%s entered\n", __func__);
0152
0153     /* use random MAC as we've no way to get it from the device */
0154     eth_random_addr(atm_dev->esi);
0155
0156     return 0;
0157 }
0158
0159
0160 static int xusbatm_usb_probe(struct usb_interface *intf,
0161                  const struct usb_device_id *id)
0162 {
0163     return usbatm_usb_probe(intf, id,
0164                 xusbatm_drivers + (id - xusbatm_usb_ids));
0165 }
0166
0167 static struct usb_driver xusbatm_usb_driver = {
0168     .name       = xusbatm_driver_name,
0169     .probe      = xusbatm_usb_probe,
0170     .disconnect = usbatm_usb_disconnect,
0171     .id_table   = xusbatm_usb_ids
0172 };
0173
0174 static int __init xusbatm_init(void)
0175 {
0176     int i;
0177
0178     if (!num_vendor ||
0179         num_vendor != num_product ||
0180         num_vendor != num_rx_endpoint ||
0181         num_vendor != num_tx_endpoint) {
0182         pr_warn("xusbatm: malformed module parameters\n");
0183         return -EINVAL;
0184     }
0185
0186     for (i = 0; i < num_vendor; i++) {
0187         rx_endpoint[i] |= USB_DIR_IN;
0188         tx_endpoint[i] &= USB_ENDPOINT_NUMBER_MASK;
0189
0190         xusbatm_usb_ids[i].match_flags  = USB_DEVICE_ID_MATCH_DEVICE;
0191         xusbatm_usb_ids[i].idVendor = vendor[i];
0192         xusbatm_usb_ids[i].idProduct    = product[i];
0193
0194         xusbatm_drivers[i].driver_name  = xusbatm_driver_name;
0195         xusbatm_drivers[i].bind     = xusbatm_bind;
0196         xusbatm_drivers[i].unbind   = xusbatm_unbind;
0197         xusbatm_drivers[i].atm_start    = xusbatm_atm_start;
0198         xusbatm_drivers[i].bulk_in  = rx_endpoint[i];
0199         xusbatm_drivers[i].bulk_out = tx_endpoint[i];
0200         xusbatm_drivers[i].rx_padding   = rx_padding[i];
0201         xusbatm_drivers[i].tx_padding   = tx_padding[i];
0202     }
0203
0204     return usb_register(&xusbatm_usb_driver);
0205 }
0206 module_init(xusbatm_init);
0207
0208 static void __exit xusbatm_exit(void)
0209 {
0210     usb_deregister(&xusbatm_usb_driver);
0211 }
0212 module_exit(xusbatm_exit);
0213
0214 MODULE_AUTHOR("Roman Kagan, Duncan Sands");
0215 MODULE_DESCRIPTION("Driver for USB ADSL modems initialized in userspace");
0216 MODULE_LICENSE("GPL");