LCOV - code coverage report
Current view: top level - lkbce/drivers/usb/storage - usual-tables.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 16 16 100.0 %
Date: 2017-01-25 Functions: 1 1 100.0 %

          Line data    Source code
       1             : /* Driver for USB Mass Storage devices
       2             :  * Usual Tables File for usb-storage and libusual
       3             :  *
       4             :  * Copyright (C) 2009 Alan Stern (stern@rowland.harvard.edu)
       5             :  *
       6             :  * Please see http://www.one-eyed-alien.net/~mdharm/linux-usb for more
       7             :  * information about this driver.
       8             :  *
       9             :  * This program is free software; you can redistribute it and/or modify it
      10             :  * under the terms of the GNU General Public License as published by the
      11             :  * Free Software Foundation; either version 2, or (at your option) any
      12             :  * later version.
      13             :  *
      14             :  * This program is distributed in the hope that it will be useful, but
      15             :  * WITHOUT ANY WARRANTY; without even the implied warranty of
      16             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      17             :  * General Public License for more details.
      18             :  *
      19             :  * You should have received a copy of the GNU General Public License along
      20             :  * with this program; if not, write to the Free Software Foundation, Inc.,
      21             :  * 675 Mass Ave, Cambridge, MA 02139, USA.
      22             :  */
      23             : 
      24             : #include <linux/kernel.h>
      25             : #include <linux/module.h>
      26             : #include <linux/usb.h>
      27             : #include <linux/usb_usual.h>
      28             : 
      29             : 
      30             : /*
      31             :  * The table of devices
      32             :  */
      33             : #define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
      34             :                     vendorName, productName, useProtocol, useTransport, \
      35             :                     initFunction, flags) \
      36             : { USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
      37             :   .driver_info = (flags)|(USB_US_TYPE_STOR<<24) }
      38             : 
      39             : #define COMPLIANT_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
      40             :                     vendorName, productName, useProtocol, useTransport, \
      41             :                     initFunction, flags) \
      42             : { USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
      43             :   .driver_info = (flags) }
      44             : 
      45             : #define USUAL_DEV(useProto, useTrans, useType) \
      46             : { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, useProto, useTrans), \
      47             :   .driver_info = ((useType)<<24) }
      48             : 
      49           1 : struct usb_device_id usb_storage_usb_ids[] = {
      50           1 : #       include "unusual_devs.h"
      51             :         { }             /* Terminating entry */
      52             : };
      53             : EXPORT_SYMBOL_GPL(usb_storage_usb_ids);
      54             : 
      55             : MODULE_DEVICE_TABLE(usb, usb_storage_usb_ids);
      56             : 
      57             : #undef UNUSUAL_DEV
      58             : #undef COMPLIANT_DEV
      59             : #undef USUAL_DEV
      60             : 
      61             : 
      62             : /*
      63             :  * The table of devices to ignore
      64             :  */
      65             : struct ignore_entry {
      66             :         u16     vid, pid, bcdmin, bcdmax;
      67             : };
      68             : 
      69             : #define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
      70             :                     vendorName, productName, useProtocol, useTransport, \
      71             :                     initFunction, flags) \
      72             : {                                       \
      73             :         .vid    = id_vendor,            \
      74             :         .pid    = id_product,           \
      75             :         .bcdmin = bcdDeviceMin,         \
      76             :         .bcdmax = bcdDeviceMax,         \
      77             : }
      78             : 
      79           1 : static struct ignore_entry ignore_ids[] = {
      80             : #       include "unusual_alauda.h"
      81             : #       include "unusual_cypress.h"
      82             : #       include "unusual_datafab.h"
      83             : #       include "unusual_freecom.h"
      84             : #       include "unusual_isd200.h"
      85             : #       include "unusual_jumpshot.h"
      86             : #       include "unusual_karma.h"
      87             : #       include "unusual_onetouch.h"
      88             : #       include "unusual_sddr09.h"
      89             : #       include "unusual_sddr55.h"
      90             : #       include "unusual_usbat.h"
      91             :         { }             /* Terminating entry */
      92             : };
      93             : 
      94             : #undef UNUSUAL_DEV
      95             : 
      96             : 
      97             : /* Return an error if a device is in the ignore_ids list */
      98             : int usb_usual_ignore_device(struct usb_interface *intf)
      99             : {
     100           1 :         struct usb_device *udev;
     101           1 :         unsigned vid, pid, bcd;
     102           1 :         struct ignore_entry *p;
     103           1 : 
     104           3 :         udev = interface_to_usbdev(intf);
     105           2 :         vid = le16_to_cpu(udev->descriptor.idVendor);
     106           1 :         pid = le16_to_cpu(udev->descriptor.idProduct);
     107           1 :         bcd = le16_to_cpu(udev->descriptor.bcdDevice);
     108             : 
     109           6 :         for (p = ignore_ids; p->vid; ++p) {
     110          14 :                 if (p->vid == vid && p->pid == pid &&
     111           1 :                                 p->bcdmin <= bcd && p->bcdmax >= bcd)
     112           1 :                         return -ENXIO;
     113             :         }
     114           1 :         return 0;
     115             : }
     116             : EXPORT_SYMBOL_GPL(usb_usual_ignore_device);

Generated by: LCOV version 1.10