Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | |
| 2 | #include <linux/blkdev.h> |
| 3 | #include <linux/init.h> |
| 4 | #include <linux/kernel.h> |
| 5 | #include <linux/module.h> |
| 6 | #include <linux/moduleparam.h> |
| 7 | #include <linux/proc_fs.h> |
| 8 | #include <linux/seq_file.h> |
| 9 | |
| 10 | #include <scsi/scsi_device.h> |
| 11 | #include <scsi/scsi_devinfo.h> |
| 12 | |
| 13 | #include "scsi_priv.h" |
| 14 | |
| 15 | |
| 16 | /* |
| 17 | * scsi_dev_info_list: structure to hold black/white listed devices. |
| 18 | */ |
| 19 | struct scsi_dev_info_list { |
| 20 | struct list_head dev_info_list; |
| 21 | char vendor[8]; |
| 22 | char model[16]; |
| 23 | unsigned flags; |
| 24 | unsigned compatible; /* for use with scsi_static_device_list entries */ |
| 25 | }; |
| 26 | |
| 27 | |
| 28 | static const char spaces[] = " "; /* 16 of them */ |
| 29 | static unsigned scsi_default_dev_flags; |
| 30 | static LIST_HEAD(scsi_dev_info_list); |
| 31 | static char scsi_dev_flags[256]; |
| 32 | |
| 33 | /* |
| 34 | * scsi_static_device_list: deprecated list of devices that require |
| 35 | * settings that differ from the default, includes black-listed (broken) |
| 36 | * devices. The entries here are added to the tail of scsi_dev_info_list |
| 37 | * via scsi_dev_info_list_init. |
| 38 | * |
| 39 | * Do not add to this list, use the command line or proc interface to add |
| 40 | * to the scsi_dev_info_list. This table will eventually go away. |
| 41 | */ |
| 42 | static struct { |
| 43 | char *vendor; |
| 44 | char *model; |
| 45 | char *revision; /* revision known to be bad, unused */ |
| 46 | unsigned flags; |
| 47 | } scsi_static_device_list[] __initdata = { |
| 48 | /* |
| 49 | * The following devices are known not to tolerate a lun != 0 scan |
| 50 | * for one reason or another. Some will respond to all luns, |
| 51 | * others will lock up. |
| 52 | */ |
| 53 | {"Aashima", "IMAGERY 2400SP", "1.03", BLIST_NOLUN}, /* locks up */ |
| 54 | {"CHINON", "CD-ROM CDS-431", "H42", BLIST_NOLUN}, /* locks up */ |
| 55 | {"CHINON", "CD-ROM CDS-535", "Q14", BLIST_NOLUN}, /* locks up */ |
| 56 | {"DENON", "DRD-25X", "V", BLIST_NOLUN}, /* locks up */ |
| 57 | {"HITACHI", "DK312C", "CM81", BLIST_NOLUN}, /* responds to all lun */ |
| 58 | {"HITACHI", "DK314C", "CR21", BLIST_NOLUN}, /* responds to all lun */ |
Brian King | f2536cb | 2006-04-26 13:48:11 -0500 | [diff] [blame] | 59 | {"IBM", "2104-DU3", NULL, BLIST_NOLUN}, /* locks up */ |
| 60 | {"IBM", "2104-TU3", NULL, BLIST_NOLUN}, /* locks up */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 61 | {"IMS", "CDD521/10", "2.06", BLIST_NOLUN}, /* locks up */ |
| 62 | {"MAXTOR", "XT-3280", "PR02", BLIST_NOLUN}, /* locks up */ |
| 63 | {"MAXTOR", "XT-4380S", "B3C", BLIST_NOLUN}, /* locks up */ |
| 64 | {"MAXTOR", "MXT-1240S", "I1.2", BLIST_NOLUN}, /* locks up */ |
| 65 | {"MAXTOR", "XT-4170S", "B5A", BLIST_NOLUN}, /* locks up */ |
| 66 | {"MAXTOR", "XT-8760S", "B7B", BLIST_NOLUN}, /* locks up */ |
| 67 | {"MEDIAVIS", "RENO CD-ROMX2A", "2.03", BLIST_NOLUN}, /* responds to all lun */ |
| 68 | {"MICROTEK", "ScanMakerIII", "2.30", BLIST_NOLUN}, /* responds to all lun */ |
| 69 | {"NEC", "CD-ROM DRIVE:841", "1.0", BLIST_NOLUN},/* locks up */ |
| 70 | {"PHILIPS", "PCA80SC", "V4-2", BLIST_NOLUN}, /* responds to all lun */ |
| 71 | {"RODIME", "RO3000S", "2.33", BLIST_NOLUN}, /* locks up */ |
| 72 | {"SUN", "SENA", NULL, BLIST_NOLUN}, /* responds to all luns */ |
| 73 | /* |
| 74 | * The following causes a failed REQUEST SENSE on lun 1 for |
| 75 | * aha152x controller, which causes SCSI code to reset bus. |
| 76 | */ |
| 77 | {"SANYO", "CRD-250S", "1.20", BLIST_NOLUN}, |
| 78 | /* |
| 79 | * The following causes a failed REQUEST SENSE on lun 1 for |
| 80 | * aha152x controller, which causes SCSI code to reset bus. |
| 81 | */ |
| 82 | {"SEAGATE", "ST157N", "\004|j", BLIST_NOLUN}, |
| 83 | {"SEAGATE", "ST296", "921", BLIST_NOLUN}, /* responds to all lun */ |
| 84 | {"SEAGATE", "ST1581", "6538", BLIST_NOLUN}, /* responds to all lun */ |
| 85 | {"SONY", "CD-ROM CDU-541", "4.3d", BLIST_NOLUN}, |
| 86 | {"SONY", "CD-ROM CDU-55S", "1.0i", BLIST_NOLUN}, |
| 87 | {"SONY", "CD-ROM CDU-561", "1.7x", BLIST_NOLUN}, |
| 88 | {"SONY", "CD-ROM CDU-8012", NULL, BLIST_NOLUN}, |
| 89 | {"SONY", "SDT-5000", "3.17", BLIST_SELECT_NO_ATN}, |
| 90 | {"TANDBERG", "TDC 3600", "U07", BLIST_NOLUN}, /* locks up */ |
| 91 | {"TEAC", "CD-R55S", "1.0H", BLIST_NOLUN}, /* locks up */ |
| 92 | /* |
| 93 | * The following causes a failed REQUEST SENSE on lun 1 for |
| 94 | * seagate controller, which causes SCSI code to reset bus. |
| 95 | */ |
| 96 | {"TEAC", "CD-ROM", "1.06", BLIST_NOLUN}, |
| 97 | {"TEAC", "MT-2ST/45S2-27", "RV M", BLIST_NOLUN}, /* responds to all lun */ |
| 98 | /* |
| 99 | * The following causes a failed REQUEST SENSE on lun 1 for |
| 100 | * seagate controller, which causes SCSI code to reset bus. |
| 101 | */ |
| 102 | {"HP", "C1750A", "3226", BLIST_NOLUN}, /* scanjet iic */ |
| 103 | {"HP", "C1790A", "", BLIST_NOLUN}, /* scanjet iip */ |
| 104 | {"HP", "C2500A", "", BLIST_NOLUN}, /* scanjet iicx */ |
| 105 | {"MEDIAVIS", "CDR-H93MV", "1.31", BLIST_NOLUN}, /* locks up */ |
| 106 | {"MICROTEK", "ScanMaker II", "5.61", BLIST_NOLUN}, /* responds to all lun */ |
| 107 | {"MITSUMI", "CD-R CR-2201CS", "6119", BLIST_NOLUN}, /* locks up */ |
| 108 | {"NEC", "D3856", "0009", BLIST_NOLUN}, |
| 109 | {"QUANTUM", "LPS525S", "3110", BLIST_NOLUN}, /* locks up */ |
| 110 | {"QUANTUM", "PD1225S", "3110", BLIST_NOLUN}, /* locks up */ |
| 111 | {"QUANTUM", "FIREBALL ST4.3S", "0F0C", BLIST_NOLUN}, /* locks up */ |
| 112 | {"RELISYS", "Scorpio", NULL, BLIST_NOLUN}, /* responds to all lun */ |
| 113 | {"SANKYO", "CP525", "6.64", BLIST_NOLUN}, /* causes failed REQ SENSE, extra reset */ |
| 114 | {"TEXEL", "CD-ROM", "1.06", BLIST_NOLUN}, |
James Bottomley | 1c53631 | 2005-09-12 09:15:14 -0500 | [diff] [blame] | 115 | {"transtec", "T5008", "0001", BLIST_NOREPORTLUN }, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 116 | {"YAMAHA", "CDR100", "1.00", BLIST_NOLUN}, /* locks up */ |
| 117 | {"YAMAHA", "CDR102", "1.00", BLIST_NOLUN}, /* locks up */ |
| 118 | {"YAMAHA", "CRW8424S", "1.0", BLIST_NOLUN}, /* locks up */ |
| 119 | {"YAMAHA", "CRW6416S", "1.0c", BLIST_NOLUN}, /* locks up */ |
Dave Jones | 0d7323c | 2005-08-08 19:01:43 -0400 | [diff] [blame] | 120 | {"", "Scanner", "1.80", BLIST_NOLUN}, /* responds to all lun */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 121 | |
| 122 | /* |
| 123 | * Other types of devices that have special flags. |
| 124 | * Note that all USB devices should have the BLIST_INQUIRY_36 flag. |
| 125 | */ |
| 126 | {"3PARdata", "VV", NULL, BLIST_REPORTLUN2}, |
| 127 | {"ADAPTEC", "AACRAID", NULL, BLIST_FORCELUN}, |
| 128 | {"ADAPTEC", "Adaptec 5400S", NULL, BLIST_FORCELUN}, |
| 129 | {"AFT PRO", "-IX CF", "0.0>", BLIST_FORCELUN}, |
| 130 | {"BELKIN", "USB 2 HS-CF", "1.95", BLIST_FORCELUN | BLIST_INQUIRY_36}, |
Matthew Wilcox | 98acfc7 | 2006-03-01 12:04:46 -0700 | [diff] [blame] | 131 | {"BROWNIE", "1600U3P", NULL, BLIST_NOREPORTLUN}, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 132 | {"CANON", "IPUBJD", NULL, BLIST_SPARSELUN}, |
| 133 | {"CBOX3", "USB Storage-SMC", "300A", BLIST_FORCELUN | BLIST_INQUIRY_36}, |
| 134 | {"CMD", "CRA-7280", NULL, BLIST_SPARSELUN}, /* CMD RAID Controller */ |
| 135 | {"CNSI", "G7324", NULL, BLIST_SPARSELUN}, /* Chaparral G7324 RAID */ |
| 136 | {"CNSi", "G8324", NULL, BLIST_SPARSELUN}, /* Chaparral G8324 RAID */ |
James Bottomley | 4d7db04 | 2006-03-31 20:07:45 -0600 | [diff] [blame] | 137 | {"COMPAQ", "ARRAY CONTROLLER", NULL, BLIST_SPARSELUN | BLIST_LARGELUN | |
| 138 | BLIST_MAX_512 | BLIST_REPORTLUN2}, /* Compaq RA4x00 */ |
| 139 | {"COMPAQ", "LOGICAL VOLUME", NULL, BLIST_FORCELUN | BLIST_MAX_512}, /* Compaq RA4x00 */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 140 | {"COMPAQ", "CR3500", NULL, BLIST_FORCELUN}, |
| 141 | {"COMPAQ", "MSA1000", NULL, BLIST_SPARSELUN | BLIST_NOSTARTONADD}, |
| 142 | {"COMPAQ", "MSA1000 VOLUME", NULL, BLIST_SPARSELUN | BLIST_NOSTARTONADD}, |
| 143 | {"COMPAQ", "HSV110", NULL, BLIST_REPORTLUN2 | BLIST_NOSTARTONADD}, |
| 144 | {"DDN", "SAN DataDirector", "*", BLIST_SPARSELUN}, |
James Bottomley | 507caac | 2005-08-09 12:57:11 -0500 | [diff] [blame] | 145 | {"DEC", "HSG80", NULL, BLIST_REPORTLUN2 | BLIST_NOSTARTONADD}, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 146 | {"DELL", "PV660F", NULL, BLIST_SPARSELUN}, |
| 147 | {"DELL", "PV660F PSEUDO", NULL, BLIST_SPARSELUN}, |
| 148 | {"DELL", "PSEUDO DEVICE .", NULL, BLIST_SPARSELUN}, /* Dell PV 530F */ |
| 149 | {"DELL", "PV530F", NULL, BLIST_SPARSELUN}, |
| 150 | {"DELL", "PERCRAID", NULL, BLIST_FORCELUN}, |
| 151 | {"DGC", "RAID", NULL, BLIST_SPARSELUN}, /* Dell PV 650F, storage on LUN 0 */ |
| 152 | {"DGC", "DISK", NULL, BLIST_SPARSELUN}, /* Dell PV 650F, no storage on LUN 0 */ |
| 153 | {"EMC", "SYMMETRIX", NULL, BLIST_SPARSELUN | BLIST_LARGELUN | BLIST_FORCELUN}, |
| 154 | {"EMULEX", "MD21/S2 ESDI", NULL, BLIST_SINGLELUN}, |
| 155 | {"FSC", "CentricStor", "*", BLIST_SPARSELUN | BLIST_LARGELUN}, |
| 156 | {"Generic", "USB SD Reader", "1.00", BLIST_FORCELUN | BLIST_INQUIRY_36}, |
| 157 | {"Generic", "USB Storage-SMC", "0180", BLIST_FORCELUN | BLIST_INQUIRY_36}, |
| 158 | {"Generic", "USB Storage-SMC", "0207", BLIST_FORCELUN | BLIST_INQUIRY_36}, |
| 159 | {"HITACHI", "DF400", "*", BLIST_SPARSELUN}, |
| 160 | {"HITACHI", "DF500", "*", BLIST_SPARSELUN}, |
| 161 | {"HITACHI", "DF600", "*", BLIST_SPARSELUN}, |
| 162 | {"HP", "A6189A", NULL, BLIST_SPARSELUN | BLIST_LARGELUN}, /* HP VA7400 */ |
| 163 | {"HP", "OPEN-", "*", BLIST_SPARSELUN | BLIST_LARGELUN}, /* HP XP Arrays */ |
| 164 | {"HP", "NetRAID-4M", NULL, BLIST_FORCELUN}, |
| 165 | {"HP", "HSV100", NULL, BLIST_REPORTLUN2 | BLIST_NOSTARTONADD}, |
| 166 | {"HP", "C1557A", NULL, BLIST_FORCELUN}, |
| 167 | {"HP", "C3323-300", "4269", BLIST_NOTQ}, |
Thomas Bogendoerfer | c3d8336 | 2006-05-16 06:38:29 +0200 | [diff] [blame] | 168 | {"HP", "C5713A", NULL, BLIST_NOREPORTLUN}, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 169 | {"IBM", "AuSaV1S2", NULL, BLIST_FORCELUN}, |
| 170 | {"IBM", "ProFibre 4000R", "*", BLIST_SPARSELUN | BLIST_LARGELUN}, |
| 171 | {"IBM", "2105", NULL, BLIST_RETRY_HWERROR}, |
| 172 | {"iomega", "jaz 1GB", "J.86", BLIST_NOTQ | BLIST_NOLUN}, |
| 173 | {"IOMEGA", "Io20S *F", NULL, BLIST_KEY}, |
| 174 | {"INSITE", "Floptical F*8I", NULL, BLIST_KEY}, |
| 175 | {"INSITE", "I325VM", NULL, BLIST_KEY}, |
| 176 | {"iRiver", "iFP Mass Driver", NULL, BLIST_NOT_LOCKABLE | BLIST_INQUIRY_36}, |
| 177 | {"LASOUND", "CDX7405", "3.10", BLIST_MAX5LUN | BLIST_SINGLELUN}, |
| 178 | {"MATSHITA", "PD-1", NULL, BLIST_FORCELUN | BLIST_SINGLELUN}, |
| 179 | {"MATSHITA", "DMC-LC5", NULL, BLIST_NOT_LOCKABLE | BLIST_INQUIRY_36}, |
| 180 | {"MATSHITA", "DMC-LC40", NULL, BLIST_NOT_LOCKABLE | BLIST_INQUIRY_36}, |
| 181 | {"Medion", "Flash XL MMC/SD", "2.6D", BLIST_FORCELUN}, |
| 182 | {"MegaRAID", "LD", NULL, BLIST_FORCELUN}, |
| 183 | {"MICROP", "4110", NULL, BLIST_NOTQ}, |
| 184 | {"MYLEX", "DACARMRB", "*", BLIST_REPORTLUN2}, |
| 185 | {"nCipher", "Fastness Crypto", NULL, BLIST_FORCELUN}, |
| 186 | {"NAKAMICH", "MJ-4.8S", NULL, BLIST_FORCELUN | BLIST_SINGLELUN}, |
| 187 | {"NAKAMICH", "MJ-5.16S", NULL, BLIST_FORCELUN | BLIST_SINGLELUN}, |
| 188 | {"NEC", "PD-1 ODX654P", NULL, BLIST_FORCELUN | BLIST_SINGLELUN}, |
| 189 | {"NRC", "MBR-7", NULL, BLIST_FORCELUN | BLIST_SINGLELUN}, |
| 190 | {"NRC", "MBR-7.4", NULL, BLIST_FORCELUN | BLIST_SINGLELUN}, |
| 191 | {"PIONEER", "CD-ROM DRM-600", NULL, BLIST_FORCELUN | BLIST_SINGLELUN}, |
| 192 | {"PIONEER", "CD-ROM DRM-602X", NULL, BLIST_FORCELUN | BLIST_SINGLELUN}, |
| 193 | {"PIONEER", "CD-ROM DRM-604X", NULL, BLIST_FORCELUN | BLIST_SINGLELUN}, |
Karl Magnus Kolstoe | f4fd20b | 2005-10-17 10:05:42 +0200 | [diff] [blame] | 194 | {"PIONEER", "CD-ROM DRM-624X", NULL, BLIST_FORCELUN | BLIST_SINGLELUN}, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 195 | {"REGAL", "CDC-4X", NULL, BLIST_MAX5LUN | BLIST_SINGLELUN}, |
| 196 | {"SanDisk", "ImageMate CF-SD1", NULL, BLIST_FORCELUN}, |
| 197 | {"SEAGATE", "ST34555N", "0930", BLIST_NOTQ}, /* Chokes on tagged INQUIRY */ |
| 198 | {"SEAGATE", "ST3390N", "9546", BLIST_NOTQ}, |
| 199 | {"SGI", "RAID3", "*", BLIST_SPARSELUN}, |
| 200 | {"SGI", "RAID5", "*", BLIST_SPARSELUN}, |
| 201 | {"SGI", "TP9100", "*", BLIST_REPORTLUN2}, |
| 202 | {"SGI", "Universal Xport", "*", BLIST_NO_ULD_ATTACH}, |
Anton Blanchard | 4869040 | 2005-09-06 18:08:14 +1000 | [diff] [blame] | 203 | {"IBM", "Universal Xport", "*", BLIST_NO_ULD_ATTACH}, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 204 | {"SMSC", "USB 2 HS-CF", NULL, BLIST_SPARSELUN | BLIST_INQUIRY_36}, |
| 205 | {"SONY", "CD-ROM CDU-8001", NULL, BLIST_BORKEN}, |
| 206 | {"SONY", "TSL", NULL, BLIST_FORCELUN}, /* DDS3 & DDS4 autoloaders */ |
| 207 | {"ST650211", "CF", NULL, BLIST_RETRY_HWERROR}, |
| 208 | {"SUN", "T300", "*", BLIST_SPARSELUN}, |
| 209 | {"SUN", "T4", "*", BLIST_SPARSELUN}, |
| 210 | {"TEXEL", "CD-ROM", "1.06", BLIST_BORKEN}, |
| 211 | {"TOSHIBA", "CDROM", NULL, BLIST_ISROM}, |
| 212 | {"TOSHIBA", "CD-ROM", NULL, BLIST_ISROM}, |
| 213 | {"USB2.0", "SMARTMEDIA/XD", NULL, BLIST_FORCELUN | BLIST_INQUIRY_36}, |
| 214 | {"WangDAT", "Model 2600", "01.7", BLIST_SELECT_NO_ATN}, |
| 215 | {"WangDAT", "Model 3200", "02.2", BLIST_SELECT_NO_ATN}, |
| 216 | {"WangDAT", "Model 1300", "02.4", BLIST_SELECT_NO_ATN}, |
| 217 | {"WDC WD25", "00JB-00FUA0", NULL, BLIST_NOREPORTLUN}, |
| 218 | {"XYRATEX", "RS", "*", BLIST_SPARSELUN | BLIST_LARGELUN}, |
| 219 | {"Zzyzx", "RocketStor 500S", NULL, BLIST_SPARSELUN}, |
| 220 | {"Zzyzx", "RocketStor 2000", NULL, BLIST_SPARSELUN}, |
| 221 | { NULL, NULL, NULL, 0 }, |
| 222 | }; |
| 223 | |
| 224 | /* |
| 225 | * scsi_strcpy_devinfo: called from scsi_dev_info_list_add to copy into |
| 226 | * devinfo vendor and model strings. |
| 227 | */ |
| 228 | static void scsi_strcpy_devinfo(char *name, char *to, size_t to_length, |
| 229 | char *from, int compatible) |
| 230 | { |
| 231 | size_t from_length; |
| 232 | |
| 233 | from_length = strlen(from); |
| 234 | strncpy(to, from, min(to_length, from_length)); |
| 235 | if (from_length < to_length) { |
| 236 | if (compatible) { |
| 237 | /* |
| 238 | * NUL terminate the string if it is short. |
| 239 | */ |
| 240 | to[from_length] = '\0'; |
| 241 | } else { |
| 242 | /* |
| 243 | * space pad the string if it is short. |
| 244 | */ |
| 245 | strncpy(&to[from_length], spaces, |
| 246 | to_length - from_length); |
| 247 | } |
| 248 | } |
| 249 | if (from_length > to_length) |
| 250 | printk(KERN_WARNING "%s: %s string '%s' is too long\n", |
| 251 | __FUNCTION__, name, from); |
| 252 | } |
| 253 | |
| 254 | /** |
| 255 | * scsi_dev_info_list_add: add one dev_info list entry. |
| 256 | * @vendor: vendor string |
| 257 | * @model: model (product) string |
| 258 | * @strflags: integer string |
| 259 | * @flag: if strflags NULL, use this flag value |
| 260 | * |
| 261 | * Description: |
| 262 | * Create and add one dev_info entry for @vendor, @model, @strflags or |
| 263 | * @flag. If @compatible, add to the tail of the list, do not space |
| 264 | * pad, and set devinfo->compatible. The scsi_static_device_list entries |
| 265 | * are added with @compatible 1 and @clfags NULL. |
| 266 | * |
| 267 | * Returns: 0 OK, -error on failure. |
| 268 | **/ |
| 269 | static int scsi_dev_info_list_add(int compatible, char *vendor, char *model, |
| 270 | char *strflags, int flags) |
| 271 | { |
| 272 | struct scsi_dev_info_list *devinfo; |
| 273 | |
| 274 | devinfo = kmalloc(sizeof(*devinfo), GFP_KERNEL); |
| 275 | if (!devinfo) { |
| 276 | printk(KERN_ERR "%s: no memory\n", __FUNCTION__); |
| 277 | return -ENOMEM; |
| 278 | } |
| 279 | |
| 280 | scsi_strcpy_devinfo("vendor", devinfo->vendor, sizeof(devinfo->vendor), |
| 281 | vendor, compatible); |
| 282 | scsi_strcpy_devinfo("model", devinfo->model, sizeof(devinfo->model), |
| 283 | model, compatible); |
| 284 | |
| 285 | if (strflags) |
| 286 | devinfo->flags = simple_strtoul(strflags, NULL, 0); |
| 287 | else |
| 288 | devinfo->flags = flags; |
| 289 | |
| 290 | devinfo->compatible = compatible; |
| 291 | |
| 292 | if (compatible) |
| 293 | list_add_tail(&devinfo->dev_info_list, &scsi_dev_info_list); |
| 294 | else |
| 295 | list_add(&devinfo->dev_info_list, &scsi_dev_info_list); |
| 296 | |
| 297 | return 0; |
| 298 | } |
| 299 | |
| 300 | /** |
| 301 | * scsi_dev_info_list_add_str: parse dev_list and add to the |
| 302 | * scsi_dev_info_list. |
| 303 | * @dev_list: string of device flags to add |
| 304 | * |
| 305 | * Description: |
| 306 | * Parse dev_list, and add entries to the scsi_dev_info_list. |
| 307 | * dev_list is of the form "vendor:product:flag,vendor:product:flag". |
| 308 | * dev_list is modified via strsep. Can be called for command line |
| 309 | * addition, for proc or mabye a sysfs interface. |
| 310 | * |
| 311 | * Returns: 0 if OK, -error on failure. |
| 312 | **/ |
| 313 | static int scsi_dev_info_list_add_str(char *dev_list) |
| 314 | { |
| 315 | char *vendor, *model, *strflags, *next; |
| 316 | char *next_check; |
| 317 | int res = 0; |
| 318 | |
| 319 | next = dev_list; |
| 320 | if (next && next[0] == '"') { |
| 321 | /* |
| 322 | * Ignore both the leading and trailing quote. |
| 323 | */ |
| 324 | next++; |
| 325 | next_check = ",\""; |
| 326 | } else { |
| 327 | next_check = ","; |
| 328 | } |
| 329 | |
| 330 | /* |
| 331 | * For the leading and trailing '"' case, the for loop comes |
| 332 | * through the last time with vendor[0] == '\0'. |
| 333 | */ |
| 334 | for (vendor = strsep(&next, ":"); vendor && (vendor[0] != '\0') |
| 335 | && (res == 0); vendor = strsep(&next, ":")) { |
| 336 | strflags = NULL; |
| 337 | model = strsep(&next, ":"); |
| 338 | if (model) |
| 339 | strflags = strsep(&next, next_check); |
| 340 | if (!model || !strflags) { |
| 341 | printk(KERN_ERR "%s: bad dev info string '%s' '%s'" |
| 342 | " '%s'\n", __FUNCTION__, vendor, model, |
| 343 | strflags); |
| 344 | res = -EINVAL; |
| 345 | } else |
| 346 | res = scsi_dev_info_list_add(0 /* compatible */, vendor, |
| 347 | model, strflags, 0); |
| 348 | } |
| 349 | return res; |
| 350 | } |
| 351 | |
| 352 | /** |
| 353 | * get_device_flags - get device specific flags from the dynamic device |
| 354 | * list. Called during scan time. |
| 355 | * @vendor: vendor name |
| 356 | * @model: model name |
| 357 | * |
| 358 | * Description: |
| 359 | * Search the scsi_dev_info_list for an entry matching @vendor and |
| 360 | * @model, if found, return the matching flags value, else return |
| 361 | * the host or global default settings. |
| 362 | **/ |
James Bottomley | 7f23e14 | 2005-12-01 12:50:13 -0600 | [diff] [blame] | 363 | int scsi_get_device_flags(struct scsi_device *sdev, |
| 364 | const unsigned char *vendor, |
| 365 | const unsigned char *model) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 366 | { |
| 367 | struct scsi_dev_info_list *devinfo; |
| 368 | unsigned int bflags; |
| 369 | |
| 370 | bflags = sdev->sdev_bflags; |
| 371 | if (!bflags) |
| 372 | bflags = scsi_default_dev_flags; |
| 373 | |
| 374 | list_for_each_entry(devinfo, &scsi_dev_info_list, dev_info_list) { |
| 375 | if (devinfo->compatible) { |
| 376 | /* |
| 377 | * Behave like the older version of get_device_flags. |
| 378 | */ |
| 379 | size_t max; |
| 380 | /* |
| 381 | * XXX why skip leading spaces? If an odd INQUIRY |
| 382 | * value, that should have been part of the |
| 383 | * scsi_static_device_list[] entry, such as " FOO" |
| 384 | * rather than "FOO". Since this code is already |
| 385 | * here, and we don't know what device it is |
| 386 | * trying to work with, leave it as-is. |
| 387 | */ |
| 388 | max = 8; /* max length of vendor */ |
| 389 | while ((max > 0) && *vendor == ' ') { |
| 390 | max--; |
| 391 | vendor++; |
| 392 | } |
| 393 | /* |
| 394 | * XXX removing the following strlen() would be |
| 395 | * good, using it means that for a an entry not in |
| 396 | * the list, we scan every byte of every vendor |
| 397 | * listed in scsi_static_device_list[], and never match |
| 398 | * a single one (and still have to compare at |
| 399 | * least the first byte of each vendor). |
| 400 | */ |
| 401 | if (memcmp(devinfo->vendor, vendor, |
| 402 | min(max, strlen(devinfo->vendor)))) |
| 403 | continue; |
| 404 | /* |
| 405 | * Skip spaces again. |
| 406 | */ |
| 407 | max = 16; /* max length of model */ |
| 408 | while ((max > 0) && *model == ' ') { |
| 409 | max--; |
| 410 | model++; |
| 411 | } |
| 412 | if (memcmp(devinfo->model, model, |
| 413 | min(max, strlen(devinfo->model)))) |
| 414 | continue; |
| 415 | return devinfo->flags; |
| 416 | } else { |
| 417 | if (!memcmp(devinfo->vendor, vendor, |
| 418 | sizeof(devinfo->vendor)) && |
| 419 | !memcmp(devinfo->model, model, |
| 420 | sizeof(devinfo->model))) |
| 421 | return devinfo->flags; |
| 422 | } |
| 423 | } |
| 424 | return bflags; |
| 425 | } |
| 426 | |
| 427 | #ifdef CONFIG_SCSI_PROC_FS |
| 428 | /* |
| 429 | * proc_scsi_dev_info_read: dump the scsi_dev_info_list via |
| 430 | * /proc/scsi/device_info |
| 431 | */ |
| 432 | static int proc_scsi_devinfo_read(char *buffer, char **start, |
| 433 | off_t offset, int length) |
| 434 | { |
| 435 | struct scsi_dev_info_list *devinfo; |
| 436 | int size, len = 0; |
| 437 | off_t begin = 0; |
| 438 | off_t pos = 0; |
| 439 | |
| 440 | list_for_each_entry(devinfo, &scsi_dev_info_list, dev_info_list) { |
| 441 | size = sprintf(buffer + len, "'%.8s' '%.16s' 0x%x\n", |
| 442 | devinfo->vendor, devinfo->model, devinfo->flags); |
| 443 | len += size; |
| 444 | pos = begin + len; |
| 445 | if (pos < offset) { |
| 446 | len = 0; |
| 447 | begin = pos; |
| 448 | } |
| 449 | if (pos > offset + length) |
| 450 | goto stop_output; |
| 451 | } |
| 452 | |
| 453 | stop_output: |
| 454 | *start = buffer + (offset - begin); /* Start of wanted data */ |
| 455 | len -= (offset - begin); /* Start slop */ |
| 456 | if (len > length) |
| 457 | len = length; /* Ending slop */ |
| 458 | return (len); |
| 459 | } |
| 460 | |
| 461 | /* |
| 462 | * proc_scsi_dev_info_write: allow additions to the scsi_dev_info_list via |
| 463 | * /proc. |
| 464 | * |
| 465 | * Use: echo "vendor:model:flag" > /proc/scsi/device_info |
| 466 | * |
| 467 | * To add a black/white list entry for vendor and model with an integer |
| 468 | * value of flag to the scsi device info list. |
| 469 | */ |
| 470 | static int proc_scsi_devinfo_write(struct file *file, const char __user *buf, |
| 471 | unsigned long length, void *data) |
| 472 | { |
| 473 | char *buffer; |
| 474 | int err = length; |
| 475 | |
| 476 | if (!buf || length>PAGE_SIZE) |
| 477 | return -EINVAL; |
| 478 | if (!(buffer = (char *) __get_free_page(GFP_KERNEL))) |
| 479 | return -ENOMEM; |
| 480 | if (copy_from_user(buffer, buf, length)) { |
| 481 | err =-EFAULT; |
| 482 | goto out; |
| 483 | } |
| 484 | |
| 485 | if (length < PAGE_SIZE) |
| 486 | buffer[length] = '\0'; |
| 487 | else if (buffer[PAGE_SIZE-1]) { |
| 488 | err = -EINVAL; |
| 489 | goto out; |
| 490 | } |
| 491 | |
| 492 | scsi_dev_info_list_add_str(buffer); |
| 493 | |
| 494 | out: |
| 495 | free_page((unsigned long)buffer); |
| 496 | return err; |
| 497 | } |
| 498 | #endif /* CONFIG_SCSI_PROC_FS */ |
| 499 | |
| 500 | module_param_string(dev_flags, scsi_dev_flags, sizeof(scsi_dev_flags), 0); |
| 501 | MODULE_PARM_DESC(dev_flags, |
| 502 | "Given scsi_dev_flags=vendor:model:flags[,v:m:f] add black/white" |
| 503 | " list entries for vendor and model with an integer value of flags" |
| 504 | " to the scsi device info list"); |
| 505 | |
| 506 | module_param_named(default_dev_flags, scsi_default_dev_flags, int, S_IRUGO|S_IWUSR); |
| 507 | MODULE_PARM_DESC(default_dev_flags, |
| 508 | "scsi default device flag integer value"); |
| 509 | |
| 510 | /** |
| 511 | * scsi_dev_info_list_delete: called from scsi.c:exit_scsi to remove |
| 512 | * the scsi_dev_info_list. |
| 513 | **/ |
| 514 | void scsi_exit_devinfo(void) |
| 515 | { |
| 516 | struct list_head *lh, *lh_next; |
| 517 | struct scsi_dev_info_list *devinfo; |
| 518 | |
| 519 | #ifdef CONFIG_SCSI_PROC_FS |
| 520 | remove_proc_entry("scsi/device_info", NULL); |
| 521 | #endif |
| 522 | |
| 523 | list_for_each_safe(lh, lh_next, &scsi_dev_info_list) { |
| 524 | devinfo = list_entry(lh, struct scsi_dev_info_list, |
| 525 | dev_info_list); |
| 526 | kfree(devinfo); |
| 527 | } |
| 528 | } |
| 529 | |
| 530 | /** |
| 531 | * scsi_dev_list_init: set up the dynamic device list. |
| 532 | * @dev_list: string of device flags to add |
| 533 | * |
| 534 | * Description: |
| 535 | * Add command line @dev_list entries, then add |
| 536 | * scsi_static_device_list entries to the scsi device info list. |
| 537 | **/ |
| 538 | int __init scsi_init_devinfo(void) |
| 539 | { |
| 540 | #ifdef CONFIG_SCSI_PROC_FS |
| 541 | struct proc_dir_entry *p; |
| 542 | #endif |
| 543 | int error, i; |
| 544 | |
| 545 | error = scsi_dev_info_list_add_str(scsi_dev_flags); |
| 546 | if (error) |
| 547 | return error; |
| 548 | |
| 549 | for (i = 0; scsi_static_device_list[i].vendor; i++) { |
| 550 | error = scsi_dev_info_list_add(1 /* compatibile */, |
| 551 | scsi_static_device_list[i].vendor, |
| 552 | scsi_static_device_list[i].model, |
| 553 | NULL, |
| 554 | scsi_static_device_list[i].flags); |
| 555 | if (error) |
| 556 | goto out; |
| 557 | } |
| 558 | |
| 559 | #ifdef CONFIG_SCSI_PROC_FS |
| 560 | p = create_proc_entry("scsi/device_info", 0, NULL); |
| 561 | if (!p) { |
| 562 | error = -ENOMEM; |
| 563 | goto out; |
| 564 | } |
| 565 | |
| 566 | p->owner = THIS_MODULE; |
| 567 | p->get_info = proc_scsi_devinfo_read; |
| 568 | p->write_proc = proc_scsi_devinfo_write; |
| 569 | #endif /* CONFIG_SCSI_PROC_FS */ |
| 570 | |
| 571 | out: |
| 572 | if (error) |
| 573 | scsi_exit_devinfo(); |
| 574 | return error; |
| 575 | } |