aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/usb/storage
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/usb/storage')
-rw-r--r--drivers/usb/storage/Kconfig40
-rw-r--r--drivers/usb/storage/Makefile39
-rw-r--r--drivers/usb/storage/ene_ub6250.c803
-rw-r--r--drivers/usb/storage/isd200.c3
-rw-r--r--drivers/usb/storage/realtek_cr.c675
-rw-r--r--drivers/usb/storage/scsiglue.c22
-rw-r--r--drivers/usb/storage/sddr09.c2
-rw-r--r--drivers/usb/storage/shuttle_usbat.c2
-rw-r--r--drivers/usb/storage/sierra_ms.c4
-rw-r--r--drivers/usb/storage/transport.c39
-rw-r--r--drivers/usb/storage/uas.c776
-rw-r--r--drivers/usb/storage/unusual_alauda.h4
-rw-r--r--drivers/usb/storage/unusual_cypress.h9
-rw-r--r--drivers/usb/storage/unusual_datafab.h20
-rw-r--r--drivers/usb/storage/unusual_devs.h638
-rw-r--r--drivers/usb/storage/unusual_ene_ub6250.h26
-rw-r--r--drivers/usb/storage/unusual_freecom.h2
-rw-r--r--drivers/usb/storage/unusual_isd200.h12
-rw-r--r--drivers/usb/storage/unusual_jumpshot.h2
-rw-r--r--drivers/usb/storage/unusual_karma.h2
-rw-r--r--drivers/usb/storage/unusual_onetouch.h4
-rw-r--r--drivers/usb/storage/unusual_realtek.h41
-rw-r--r--drivers/usb/storage/unusual_sddr09.h12
-rw-r--r--drivers/usb/storage/unusual_sddr55.h8
-rw-r--r--drivers/usb/storage/unusual_usbat.h8
-rw-r--r--drivers/usb/storage/usb.c50
-rw-r--r--drivers/usb/storage/usb.h2
-rw-r--r--drivers/usb/storage/usual-tables.c2
28 files changed, 2869 insertions, 378 deletions
diff --git a/drivers/usb/storage/Kconfig b/drivers/usb/storage/Kconfig
index 8a372bac0e43..97987255be75 100644
--- a/drivers/usb/storage/Kconfig
+++ b/drivers/usb/storage/Kconfig
@@ -31,12 +31,22 @@ config USB_STORAGE_DEBUG
31 Say Y here in order to have the USB Mass Storage code generate 31 Say Y here in order to have the USB Mass Storage code generate
32 verbose debugging messages. 32 verbose debugging messages.
33 33
34config USB_STORAGE_REALTEK
35 tristate "Realtek Card Reader support"
36 depends on USB_STORAGE
37 help
38 Say Y here to include additional code to support the power-saving function
39 for Realtek RTS51xx USB card readers.
40
41 If this driver is compiled as a module, it will be named ums-realtek.
42
43
34config USB_STORAGE_DATAFAB 44config USB_STORAGE_DATAFAB
35 tristate "Datafab Compact Flash Reader support" 45 tristate "Datafab Compact Flash Reader support"
36 depends on USB_STORAGE 46 depends on USB_STORAGE
37 help 47 help
38 Support for certain Datafab CompactFlash readers. 48 Support for certain Datafab CompactFlash readers.
39 Datafab has a web page at <http://www.datafabusa.com/>. 49 Datafab has a web page at <http://www.datafab.com/>.
40 50
41 If this driver is compiled as a module, it will be named ums-datafab. 51 If this driver is compiled as a module, it will be named ums-datafab.
42 52
@@ -172,6 +182,34 @@ config USB_STORAGE_CYPRESS_ATACB
172 182
173 If this driver is compiled as a module, it will be named ums-cypress. 183 If this driver is compiled as a module, it will be named ums-cypress.
174 184
185config USB_STORAGE_ENE_UB6250
186 tristate "USB ENE card reader support"
187 depends on USB && SCSI
188 depends on USB_STORAGE
189 ---help---
190 Say Y here if you wish to control a ENE SD Card reader.
191 To use SM/MS card, please build driver/staging/keucr/keucr.ko
192
193 This option depends on 'SCSI' support being enabled, but you
194 probably also need 'SCSI device support: SCSI disk support'
195 (BLK_DEV_SD) for most USB storage devices.
196
197 To compile this driver as a module, choose M here: the
198 module will be called ums-eneub6250.
199
200config USB_UAS
201 tristate "USB Attached SCSI"
202 depends on USB && SCSI
203 help
204 The USB Attached SCSI protocol is supported by some USB
205 storage devices. It permits higher performance by supporting
206 multiple outstanding commands.
207
208 If you don't know whether you have a UAS device, it is safe to
209 say 'Y' or 'M' here and the kernel will use the right driver.
210
211 If you compile this driver as a module, it will be named uas.
212
175config USB_LIBUSUAL 213config USB_LIBUSUAL
176 bool "The shared table of common (or usual) storage devices" 214 bool "The shared table of common (or usual) storage devices"
177 depends on USB 215 depends on USB
diff --git a/drivers/usb/storage/Makefile b/drivers/usb/storage/Makefile
index ef7e5a8ceab5..82e6416a2d47 100644
--- a/drivers/usb/storage/Makefile
+++ b/drivers/usb/storage/Makefile
@@ -5,42 +5,47 @@
5# Rewritten to use lists instead of if-statements. 5# Rewritten to use lists instead of if-statements.
6# 6#
7 7
8EXTRA_CFLAGS := -Idrivers/scsi 8ccflags-y := -Idrivers/scsi
9 9
10obj-$(CONFIG_USB_UAS) += uas.o
10obj-$(CONFIG_USB_STORAGE) += usb-storage.o 11obj-$(CONFIG_USB_STORAGE) += usb-storage.o
11 12
12usb-storage-obj-$(CONFIG_USB_STORAGE_DEBUG) += debug.o 13usb-storage-y := scsiglue.o protocol.o transport.o usb.o
14usb-storage-y += initializers.o sierra_ms.o option_ms.o
13 15
14usb-storage-objs := scsiglue.o protocol.o transport.o usb.o \ 16usb-storage-$(CONFIG_USB_STORAGE_DEBUG) += debug.o
15 initializers.o sierra_ms.o option_ms.o $(usb-storage-obj-y)
16 17
17ifeq ($(CONFIG_USB_LIBUSUAL),) 18ifeq ($(CONFIG_USB_LIBUSUAL),)
18 usb-storage-objs += usual-tables.o 19 usb-storage-y += usual-tables.o
19else 20else
20 obj-$(CONFIG_USB) += usb-libusual.o 21 obj-$(CONFIG_USB) += usb-libusual.o
21 usb-libusual-objs := libusual.o usual-tables.o 22 usb-libusual-y := libusual.o usual-tables.o
22endif 23endif
23 24
24obj-$(CONFIG_USB_STORAGE_ALAUDA) += ums-alauda.o 25obj-$(CONFIG_USB_STORAGE_ALAUDA) += ums-alauda.o
25obj-$(CONFIG_USB_STORAGE_CYPRESS_ATACB) += ums-cypress.o 26obj-$(CONFIG_USB_STORAGE_CYPRESS_ATACB) += ums-cypress.o
26obj-$(CONFIG_USB_STORAGE_DATAFAB) += ums-datafab.o 27obj-$(CONFIG_USB_STORAGE_DATAFAB) += ums-datafab.o
28obj-$(CONFIG_USB_STORAGE_ENE_UB6250) += ums-eneub6250.o
27obj-$(CONFIG_USB_STORAGE_FREECOM) += ums-freecom.o 29obj-$(CONFIG_USB_STORAGE_FREECOM) += ums-freecom.o
28obj-$(CONFIG_USB_STORAGE_ISD200) += ums-isd200.o 30obj-$(CONFIG_USB_STORAGE_ISD200) += ums-isd200.o
29obj-$(CONFIG_USB_STORAGE_JUMPSHOT) += ums-jumpshot.o 31obj-$(CONFIG_USB_STORAGE_JUMPSHOT) += ums-jumpshot.o
30obj-$(CONFIG_USB_STORAGE_KARMA) += ums-karma.o 32obj-$(CONFIG_USB_STORAGE_KARMA) += ums-karma.o
31obj-$(CONFIG_USB_STORAGE_ONETOUCH) += ums-onetouch.o 33obj-$(CONFIG_USB_STORAGE_ONETOUCH) += ums-onetouch.o
34obj-$(CONFIG_USB_STORAGE_REALTEK) += ums-realtek.o
32obj-$(CONFIG_USB_STORAGE_SDDR09) += ums-sddr09.o 35obj-$(CONFIG_USB_STORAGE_SDDR09) += ums-sddr09.o
33obj-$(CONFIG_USB_STORAGE_SDDR55) += ums-sddr55.o 36obj-$(CONFIG_USB_STORAGE_SDDR55) += ums-sddr55.o
34obj-$(CONFIG_USB_STORAGE_USBAT) += ums-usbat.o 37obj-$(CONFIG_USB_STORAGE_USBAT) += ums-usbat.o
35 38
36ums-alauda-objs := alauda.o 39ums-alauda-y := alauda.o
37ums-cypress-objs := cypress_atacb.o 40ums-cypress-y := cypress_atacb.o
38ums-datafab-objs := datafab.o 41ums-datafab-y := datafab.o
39ums-freecom-objs := freecom.o 42ums-eneub6250-y := ene_ub6250.o
40ums-isd200-objs := isd200.o 43ums-freecom-y := freecom.o
41ums-jumpshot-objs := jumpshot.o 44ums-isd200-y := isd200.o
42ums-karma-objs := karma.o 45ums-jumpshot-y := jumpshot.o
43ums-onetouch-objs := onetouch.o 46ums-karma-y := karma.o
44ums-sddr09-objs := sddr09.o 47ums-onetouch-y := onetouch.o
45ums-sddr55-objs := sddr55.o 48ums-realtek-y := realtek_cr.o
46ums-usbat-objs := shuttle_usbat.o 49ums-sddr09-y := sddr09.o
50ums-sddr55-y := sddr55.o
51ums-usbat-y := shuttle_usbat.o
diff --git a/drivers/usb/storage/ene_ub6250.c b/drivers/usb/storage/ene_ub6250.c
new file mode 100644
index 000000000000..31645afff5fc
--- /dev/null
+++ b/drivers/usb/storage/ene_ub6250.c
@@ -0,0 +1,803 @@
1/*
2 *
3 * This program is free software; you can redistribute it and/or modify it
4 * under the terms of the GNU General Public License as published by the
5 * Free Software Foundation; either version 2, or (at your option) any
6 * later version.
7 *
8 * This program is distributed in the hope that it will be useful, but
9 * WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 * General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License along
14 * with this program; if not, write to the Free Software Foundation, Inc.,
15 * 675 Mass Ave, Cambridge, MA 02139, USA.
16 */
17#include <linux/jiffies.h>
18#include <linux/errno.h>
19#include <linux/module.h>
20#include <linux/slab.h>
21
22#include <scsi/scsi.h>
23#include <scsi/scsi_cmnd.h>
24
25#include <linux/firmware.h>
26
27#include "usb.h"
28#include "transport.h"
29#include "protocol.h"
30#include "debug.h"
31
32MODULE_DESCRIPTION("Driver for ENE UB6250 reader");
33MODULE_LICENSE("GPL");
34
35
36/*
37 * The table of devices
38 */
39#define UNUSUAL_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)|(USB_US_TYPE_STOR<<24) }
44
45struct usb_device_id ene_ub6250_usb_ids[] = {
46# include "unusual_ene_ub6250.h"
47 { } /* Terminating entry */
48};
49MODULE_DEVICE_TABLE(usb, ene_ub6250_usb_ids);
50
51#undef UNUSUAL_DEV
52
53/*
54 * The flags table
55 */
56#define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \
57 vendor_name, product_name, use_protocol, use_transport, \
58 init_function, Flags) \
59{ \
60 .vendorName = vendor_name, \
61 .productName = product_name, \
62 .useProtocol = use_protocol, \
63 .useTransport = use_transport, \
64 .initFunction = init_function, \
65}
66
67static struct us_unusual_dev ene_ub6250_unusual_dev_list[] = {
68# include "unusual_ene_ub6250.h"
69 { } /* Terminating entry */
70};
71
72#undef UNUSUAL_DEV
73
74
75
76/* ENE bin code len */
77#define ENE_BIN_CODE_LEN 0x800
78/* EnE HW Register */
79#define REG_CARD_STATUS 0xFF83
80#define REG_HW_TRAP1 0xFF89
81
82/* SRB Status */
83#define SS_SUCCESS 0x00 /* No Sense */
84#define SS_NOT_READY 0x02
85#define SS_MEDIUM_ERR 0x03
86#define SS_HW_ERR 0x04
87#define SS_ILLEGAL_REQUEST 0x05
88#define SS_UNIT_ATTENTION 0x06
89
90/* ENE Load FW Pattern */
91#define SD_INIT1_PATTERN 1
92#define SD_INIT2_PATTERN 2
93#define SD_RW_PATTERN 3
94#define MS_INIT_PATTERN 4
95#define MSP_RW_PATTERN 5
96#define MS_RW_PATTERN 6
97#define SM_INIT_PATTERN 7
98#define SM_RW_PATTERN 8
99
100#define FDIR_WRITE 0
101#define FDIR_READ 1
102
103
104struct SD_STATUS {
105 u8 Insert:1;
106 u8 Ready:1;
107 u8 MediaChange:1;
108 u8 IsMMC:1;
109 u8 HiCapacity:1;
110 u8 HiSpeed:1;
111 u8 WtP:1;
112 u8 Reserved:1;
113};
114
115struct MS_STATUS {
116 u8 Insert:1;
117 u8 Ready:1;
118 u8 MediaChange:1;
119 u8 IsMSPro:1;
120 u8 IsMSPHG:1;
121 u8 Reserved1:1;
122 u8 WtP:1;
123 u8 Reserved2:1;
124};
125
126struct SM_STATUS {
127 u8 Insert:1;
128 u8 Ready:1;
129 u8 MediaChange:1;
130 u8 Reserved:3;
131 u8 WtP:1;
132 u8 IsMS:1;
133};
134
135
136/* SD Block Length */
137/* 2^9 = 512 Bytes, The HW maximum read/write data length */
138#define SD_BLOCK_LEN 9
139
140struct ene_ub6250_info {
141 /* for 6250 code */
142 struct SD_STATUS SD_Status;
143 struct MS_STATUS MS_Status;
144 struct SM_STATUS SM_Status;
145
146 /* ----- SD Control Data ---------------- */
147 /*SD_REGISTER SD_Regs; */
148 u16 SD_Block_Mult;
149 u8 SD_READ_BL_LEN;
150 u16 SD_C_SIZE;
151 u8 SD_C_SIZE_MULT;
152
153 /* SD/MMC New spec. */
154 u8 SD_SPEC_VER;
155 u8 SD_CSD_VER;
156 u8 SD20_HIGH_CAPACITY;
157 u32 HC_C_SIZE;
158 u8 MMC_SPEC_VER;
159 u8 MMC_BusWidth;
160 u8 MMC_HIGH_CAPACITY;
161
162 /*----- MS Control Data ---------------- */
163 bool MS_SWWP;
164 u32 MSP_TotalBlock;
165 /*MS_LibControl MS_Lib;*/
166 bool MS_IsRWPage;
167 u16 MS_Model;
168
169 /*----- SM Control Data ---------------- */
170 u8 SM_DeviceID;
171 u8 SM_CardID;
172
173 unsigned char *testbuf;
174 u8 BIN_FLAG;
175 u32 bl_num;
176 int SrbStatus;
177
178 /*------Power Managerment ---------------*/
179 bool Power_IsResum;
180};
181
182static int ene_sd_init(struct us_data *us);
183static int ene_load_bincode(struct us_data *us, unsigned char flag);
184
185static void ene_ub6250_info_destructor(void *extra)
186{
187 if (!extra)
188 return;
189}
190
191static int ene_send_scsi_cmd(struct us_data *us, u8 fDir, void *buf, int use_sg)
192{
193 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
194 struct bulk_cs_wrap *bcs = (struct bulk_cs_wrap *) us->iobuf;
195
196 int result;
197 unsigned int residue;
198 unsigned int cswlen = 0, partial = 0;
199 unsigned int transfer_length = bcb->DataTransferLength;
200
201 /* US_DEBUGP("transport --- ene_send_scsi_cmd\n"); */
202 /* send cmd to out endpoint */
203 result = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe,
204 bcb, US_BULK_CB_WRAP_LEN, NULL);
205 if (result != USB_STOR_XFER_GOOD) {
206 US_DEBUGP("send cmd to out endpoint fail ---\n");
207 return USB_STOR_TRANSPORT_ERROR;
208 }
209
210 if (buf) {
211 unsigned int pipe = fDir;
212
213 if (fDir == FDIR_READ)
214 pipe = us->recv_bulk_pipe;
215 else
216 pipe = us->send_bulk_pipe;
217
218 /* Bulk */
219 if (use_sg) {
220 result = usb_stor_bulk_srb(us, pipe, us->srb);
221 } else {
222 result = usb_stor_bulk_transfer_sg(us, pipe, buf,
223 transfer_length, 0, &partial);
224 }
225 if (result != USB_STOR_XFER_GOOD) {
226 US_DEBUGP("data transfer fail ---\n");
227 return USB_STOR_TRANSPORT_ERROR;
228 }
229 }
230
231 /* Get CSW for device status */
232 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, bcs,
233 US_BULK_CS_WRAP_LEN, &cswlen);
234
235 if (result == USB_STOR_XFER_SHORT && cswlen == 0) {
236 US_DEBUGP("Received 0-length CSW; retrying...\n");
237 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
238 bcs, US_BULK_CS_WRAP_LEN, &cswlen);
239 }
240
241 if (result == USB_STOR_XFER_STALLED) {
242 /* get the status again */
243 US_DEBUGP("Attempting to get CSW (2nd try)...\n");
244 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
245 bcs, US_BULK_CS_WRAP_LEN, NULL);
246 }
247
248 if (result != USB_STOR_XFER_GOOD)
249 return USB_STOR_TRANSPORT_ERROR;
250
251 /* check bulk status */
252 residue = le32_to_cpu(bcs->Residue);
253
254 /* try to compute the actual residue, based on how much data
255 * was really transferred and what the device tells us */
256 if (residue && !(us->fflags & US_FL_IGNORE_RESIDUE)) {
257 residue = min(residue, transfer_length);
258 if (us->srb != NULL)
259 scsi_set_resid(us->srb, max(scsi_get_resid(us->srb),
260 (int)residue));
261 }
262
263 if (bcs->Status != US_BULK_STAT_OK)
264 return USB_STOR_TRANSPORT_ERROR;
265
266 return USB_STOR_TRANSPORT_GOOD;
267}
268
269static int sd_scsi_test_unit_ready(struct us_data *us, struct scsi_cmnd *srb)
270{
271 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
272
273 if (info->SD_Status.Insert && info->SD_Status.Ready)
274 return USB_STOR_TRANSPORT_GOOD;
275 else {
276 ene_sd_init(us);
277 return USB_STOR_TRANSPORT_GOOD;
278 }
279
280 return USB_STOR_TRANSPORT_GOOD;
281}
282
283static int sd_scsi_inquiry(struct us_data *us, struct scsi_cmnd *srb)
284{
285 unsigned char data_ptr[36] = {
286 0x00, 0x80, 0x02, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x55,
287 0x53, 0x42, 0x32, 0x2E, 0x30, 0x20, 0x20, 0x43, 0x61,
288 0x72, 0x64, 0x52, 0x65, 0x61, 0x64, 0x65, 0x72, 0x20,
289 0x20, 0x20, 0x20, 0x20, 0x20, 0x30, 0x31, 0x30, 0x30 };
290
291 usb_stor_set_xfer_buf(data_ptr, 36, srb);
292 return USB_STOR_TRANSPORT_GOOD;
293}
294
295static int sd_scsi_mode_sense(struct us_data *us, struct scsi_cmnd *srb)
296{
297 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
298 unsigned char mediaNoWP[12] = {
299 0x0b, 0x00, 0x00, 0x08, 0x00, 0x00,
300 0x71, 0xc0, 0x00, 0x00, 0x02, 0x00 };
301 unsigned char mediaWP[12] = {
302 0x0b, 0x00, 0x80, 0x08, 0x00, 0x00,
303 0x71, 0xc0, 0x00, 0x00, 0x02, 0x00 };
304
305 if (info->SD_Status.WtP)
306 usb_stor_set_xfer_buf(mediaWP, 12, srb);
307 else
308 usb_stor_set_xfer_buf(mediaNoWP, 12, srb);
309
310
311 return USB_STOR_TRANSPORT_GOOD;
312}
313
314static int sd_scsi_read_capacity(struct us_data *us, struct scsi_cmnd *srb)
315{
316 u32 bl_num;
317 u16 bl_len;
318 unsigned int offset = 0;
319 unsigned char buf[8];
320 struct scatterlist *sg = NULL;
321 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
322
323 US_DEBUGP("sd_scsi_read_capacity\n");
324 if (info->SD_Status.HiCapacity) {
325 bl_len = 0x200;
326 if (info->SD_Status.IsMMC)
327 bl_num = info->HC_C_SIZE-1;
328 else
329 bl_num = (info->HC_C_SIZE + 1) * 1024 - 1;
330 } else {
331 bl_len = 1<<(info->SD_READ_BL_LEN);
332 bl_num = info->SD_Block_Mult * (info->SD_C_SIZE + 1)
333 * (1 << (info->SD_C_SIZE_MULT + 2)) - 1;
334 }
335 info->bl_num = bl_num;
336 US_DEBUGP("bl_len = %x\n", bl_len);
337 US_DEBUGP("bl_num = %x\n", bl_num);
338
339 /*srb->request_bufflen = 8; */
340 buf[0] = (bl_num >> 24) & 0xff;
341 buf[1] = (bl_num >> 16) & 0xff;
342 buf[2] = (bl_num >> 8) & 0xff;
343 buf[3] = (bl_num >> 0) & 0xff;
344 buf[4] = (bl_len >> 24) & 0xff;
345 buf[5] = (bl_len >> 16) & 0xff;
346 buf[6] = (bl_len >> 8) & 0xff;
347 buf[7] = (bl_len >> 0) & 0xff;
348
349 usb_stor_access_xfer_buf(buf, 8, srb, &sg, &offset, TO_XFER_BUF);
350
351 return USB_STOR_TRANSPORT_GOOD;
352}
353
354static int sd_scsi_read(struct us_data *us, struct scsi_cmnd *srb)
355{
356 int result;
357 unsigned char *cdb = srb->cmnd;
358 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
359 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
360
361 u32 bn = ((cdb[2] << 24) & 0xff000000) | ((cdb[3] << 16) & 0x00ff0000) |
362 ((cdb[4] << 8) & 0x0000ff00) | ((cdb[5] << 0) & 0x000000ff);
363 u16 blen = ((cdb[7] << 8) & 0xff00) | ((cdb[8] << 0) & 0x00ff);
364 u32 bnByte = bn * 0x200;
365 u32 blenByte = blen * 0x200;
366
367 if (bn > info->bl_num)
368 return USB_STOR_TRANSPORT_ERROR;
369
370 result = ene_load_bincode(us, SD_RW_PATTERN);
371 if (result != USB_STOR_XFER_GOOD) {
372 US_DEBUGP("Load SD RW pattern Fail !!\n");
373 return USB_STOR_TRANSPORT_ERROR;
374 }
375
376 if (info->SD_Status.HiCapacity)
377 bnByte = bn;
378
379 /* set up the command wrapper */
380 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
381 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
382 bcb->DataTransferLength = blenByte;
383 bcb->Flags = 0x80;
384 bcb->CDB[0] = 0xF1;
385 bcb->CDB[5] = (unsigned char)(bnByte);
386 bcb->CDB[4] = (unsigned char)(bnByte>>8);
387 bcb->CDB[3] = (unsigned char)(bnByte>>16);
388 bcb->CDB[2] = (unsigned char)(bnByte>>24);
389
390 result = ene_send_scsi_cmd(us, FDIR_READ, scsi_sglist(srb), 1);
391 return result;
392}
393
394static int sd_scsi_write(struct us_data *us, struct scsi_cmnd *srb)
395{
396 int result;
397 unsigned char *cdb = srb->cmnd;
398 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
399 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
400
401 u32 bn = ((cdb[2] << 24) & 0xff000000) | ((cdb[3] << 16) & 0x00ff0000) |
402 ((cdb[4] << 8) & 0x0000ff00) | ((cdb[5] << 0) & 0x000000ff);
403 u16 blen = ((cdb[7] << 8) & 0xff00) | ((cdb[8] << 0) & 0x00ff);
404 u32 bnByte = bn * 0x200;
405 u32 blenByte = blen * 0x200;
406
407 if (bn > info->bl_num)
408 return USB_STOR_TRANSPORT_ERROR;
409
410 result = ene_load_bincode(us, SD_RW_PATTERN);
411 if (result != USB_STOR_XFER_GOOD) {
412 US_DEBUGP("Load SD RW pattern Fail !!\n");
413 return USB_STOR_TRANSPORT_ERROR;
414 }
415
416 if (info->SD_Status.HiCapacity)
417 bnByte = bn;
418
419 /* set up the command wrapper */
420 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
421 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
422 bcb->DataTransferLength = blenByte;
423 bcb->Flags = 0x00;
424 bcb->CDB[0] = 0xF0;
425 bcb->CDB[5] = (unsigned char)(bnByte);
426 bcb->CDB[4] = (unsigned char)(bnByte>>8);
427 bcb->CDB[3] = (unsigned char)(bnByte>>16);
428 bcb->CDB[2] = (unsigned char)(bnByte>>24);
429
430 result = ene_send_scsi_cmd(us, FDIR_WRITE, scsi_sglist(srb), 1);
431 return result;
432}
433
434static int ene_get_card_type(struct us_data *us, u16 index, void *buf)
435{
436 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
437 int result;
438
439 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
440 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
441 bcb->DataTransferLength = 0x01;
442 bcb->Flags = 0x80;
443 bcb->CDB[0] = 0xED;
444 bcb->CDB[2] = (unsigned char)(index>>8);
445 bcb->CDB[3] = (unsigned char)index;
446
447 result = ene_send_scsi_cmd(us, FDIR_READ, buf, 0);
448 return result;
449}
450
451static int ene_get_card_status(struct us_data *us, u8 *buf)
452{
453 u16 tmpreg;
454 u32 reg4b;
455 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
456
457 /*US_DEBUGP("transport --- ENE_ReadSDReg\n");*/
458 reg4b = *(u32 *)&buf[0x18];
459 info->SD_READ_BL_LEN = (u8)((reg4b >> 8) & 0x0f);
460
461 tmpreg = (u16) reg4b;
462 reg4b = *(u32 *)(&buf[0x14]);
463 if (info->SD_Status.HiCapacity && !info->SD_Status.IsMMC)
464 info->HC_C_SIZE = (reg4b >> 8) & 0x3fffff;
465
466 info->SD_C_SIZE = ((tmpreg & 0x03) << 10) | (u16)(reg4b >> 22);
467 info->SD_C_SIZE_MULT = (u8)(reg4b >> 7) & 0x07;
468 if (info->SD_Status.HiCapacity && info->SD_Status.IsMMC)
469 info->HC_C_SIZE = *(u32 *)(&buf[0x100]);
470
471 if (info->SD_READ_BL_LEN > SD_BLOCK_LEN) {
472 info->SD_Block_Mult = 1 << (info->SD_READ_BL_LEN-SD_BLOCK_LEN);
473 info->SD_READ_BL_LEN = SD_BLOCK_LEN;
474 } else {
475 info->SD_Block_Mult = 1;
476 }
477
478 return USB_STOR_TRANSPORT_GOOD;
479}
480
481static int ene_load_bincode(struct us_data *us, unsigned char flag)
482{
483 int err;
484 char *fw_name = NULL;
485 unsigned char *buf = NULL;
486 const struct firmware *sd_fw = NULL;
487 int result = USB_STOR_TRANSPORT_ERROR;
488 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
489 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
490
491 if (info->BIN_FLAG == flag)
492 return USB_STOR_TRANSPORT_GOOD;
493
494 switch (flag) {
495 /* For SD */
496 case SD_INIT1_PATTERN:
497 US_DEBUGP("SD_INIT1_PATTERN\n");
498 fw_name = "ene-ub6250/sd_init1.bin";
499 break;
500 case SD_INIT2_PATTERN:
501 US_DEBUGP("SD_INIT2_PATTERN\n");
502 fw_name = "ene-ub6250/sd_init2.bin";
503 break;
504 case SD_RW_PATTERN:
505 US_DEBUGP("SD_RDWR_PATTERN\n");
506 fw_name = "ene-ub6250/sd_rdwr.bin";
507 break;
508 default:
509 US_DEBUGP("----------- Unknown PATTERN ----------\n");
510 goto nofw;
511 }
512
513 err = request_firmware(&sd_fw, fw_name, &us->pusb_dev->dev);
514 if (err) {
515 US_DEBUGP("load firmware %s failed\n", fw_name);
516 goto nofw;
517 }
518 buf = kmalloc(sd_fw->size, GFP_KERNEL);
519 if (buf == NULL) {
520 US_DEBUGP("Malloc memory for fireware failed!\n");
521 goto nofw;
522 }
523 memcpy(buf, sd_fw->data, sd_fw->size);
524 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
525 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
526 bcb->DataTransferLength = sd_fw->size;
527 bcb->Flags = 0x00;
528 bcb->CDB[0] = 0xEF;
529
530 result = ene_send_scsi_cmd(us, FDIR_WRITE, buf, 0);
531 info->BIN_FLAG = flag;
532 kfree(buf);
533
534nofw:
535 if (sd_fw != NULL) {
536 release_firmware(sd_fw);
537 sd_fw = NULL;
538 }
539
540 return result;
541}
542
543static int ene_sd_init(struct us_data *us)
544{
545 int result;
546 u8 buf[0x200];
547 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
548 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
549
550 US_DEBUGP("transport --- ENE_SDInit\n");
551 /* SD Init Part-1 */
552 result = ene_load_bincode(us, SD_INIT1_PATTERN);
553 if (result != USB_STOR_XFER_GOOD) {
554 US_DEBUGP("Load SD Init Code Part-1 Fail !!\n");
555 return USB_STOR_TRANSPORT_ERROR;
556 }
557
558 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
559 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
560 bcb->Flags = 0x80;
561 bcb->CDB[0] = 0xF2;
562
563 result = ene_send_scsi_cmd(us, FDIR_READ, NULL, 0);
564 if (result != USB_STOR_XFER_GOOD) {
565 US_DEBUGP("Execution SD Init Code Fail !!\n");
566 return USB_STOR_TRANSPORT_ERROR;
567 }
568
569 /* SD Init Part-2 */
570 result = ene_load_bincode(us, SD_INIT2_PATTERN);
571 if (result != USB_STOR_XFER_GOOD) {
572 US_DEBUGP("Load SD Init Code Part-2 Fail !!\n");
573 return USB_STOR_TRANSPORT_ERROR;
574 }
575
576 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
577 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
578 bcb->DataTransferLength = 0x200;
579 bcb->Flags = 0x80;
580 bcb->CDB[0] = 0xF1;
581
582 result = ene_send_scsi_cmd(us, FDIR_READ, &buf, 0);
583 if (result != USB_STOR_XFER_GOOD) {
584 US_DEBUGP("Execution SD Init Code Fail !!\n");
585 return USB_STOR_TRANSPORT_ERROR;
586 }
587
588 info->SD_Status = *(struct SD_STATUS *)&buf[0];
589 if (info->SD_Status.Insert && info->SD_Status.Ready) {
590 ene_get_card_status(us, (unsigned char *)&buf);
591 US_DEBUGP("Insert = %x\n", info->SD_Status.Insert);
592 US_DEBUGP("Ready = %x\n", info->SD_Status.Ready);
593 US_DEBUGP("IsMMC = %x\n", info->SD_Status.IsMMC);
594 US_DEBUGP("HiCapacity = %x\n", info->SD_Status.HiCapacity);
595 US_DEBUGP("HiSpeed = %x\n", info->SD_Status.HiSpeed);
596 US_DEBUGP("WtP = %x\n", info->SD_Status.WtP);
597 } else {
598 US_DEBUGP("SD Card Not Ready --- %x\n", buf[0]);
599 return USB_STOR_TRANSPORT_ERROR;
600 }
601 return USB_STOR_TRANSPORT_GOOD;
602}
603
604
605static int ene_init(struct us_data *us)
606{
607 int result;
608 u8 misc_reg03 = 0;
609 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
610
611 result = ene_get_card_type(us, REG_CARD_STATUS, &misc_reg03);
612 if (result != USB_STOR_XFER_GOOD)
613 return USB_STOR_TRANSPORT_ERROR;
614
615 if (misc_reg03 & 0x01) {
616 if (!info->SD_Status.Ready) {
617 result = ene_sd_init(us);
618 if (result != USB_STOR_XFER_GOOD)
619 return USB_STOR_TRANSPORT_ERROR;
620 }
621 }
622
623 return result;
624}
625
626/*----- sd_scsi_irp() ---------*/
627static int sd_scsi_irp(struct us_data *us, struct scsi_cmnd *srb)
628{
629 int result;
630 struct ene_ub6250_info *info = (struct ene_ub6250_info *)us->extra;
631
632 info->SrbStatus = SS_SUCCESS;
633 switch (srb->cmnd[0]) {
634 case TEST_UNIT_READY:
635 result = sd_scsi_test_unit_ready(us, srb);
636 break; /* 0x00 */
637 case INQUIRY:
638 result = sd_scsi_inquiry(us, srb);
639 break; /* 0x12 */
640 case MODE_SENSE:
641 result = sd_scsi_mode_sense(us, srb);
642 break; /* 0x1A */
643 /*
644 case START_STOP:
645 result = SD_SCSI_Start_Stop(us, srb);
646 break; //0x1B
647 */
648 case READ_CAPACITY:
649 result = sd_scsi_read_capacity(us, srb);
650 break; /* 0x25 */
651 case READ_10:
652 result = sd_scsi_read(us, srb);
653 break; /* 0x28 */
654 case WRITE_10:
655 result = sd_scsi_write(us, srb);
656 break; /* 0x2A */
657 default:
658 info->SrbStatus = SS_ILLEGAL_REQUEST;
659 result = USB_STOR_TRANSPORT_FAILED;
660 break;
661 }
662 return result;
663}
664
665static int ene_transport(struct scsi_cmnd *srb, struct us_data *us)
666{
667 int result = 0;
668 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
669
670 /*US_DEBUG(usb_stor_show_command(srb)); */
671 scsi_set_resid(srb, 0);
672 if (unlikely(!info->SD_Status.Ready))
673 result = ene_init(us);
674 else
675 result = sd_scsi_irp(us, srb);
676
677 return 0;
678}
679
680
681static int ene_ub6250_probe(struct usb_interface *intf,
682 const struct usb_device_id *id)
683{
684 int result;
685 u8 misc_reg03 = 0;
686 struct us_data *us;
687
688 result = usb_stor_probe1(&us, intf, id,
689 (id - ene_ub6250_usb_ids) + ene_ub6250_unusual_dev_list);
690 if (result)
691 return result;
692
693 /* FIXME: where should the code alloc extra buf ? */
694 if (!us->extra) {
695 us->extra = kzalloc(sizeof(struct ene_ub6250_info), GFP_KERNEL);
696 if (!us->extra)
697 return -ENOMEM;
698 us->extra_destructor = ene_ub6250_info_destructor;
699 }
700
701 us->transport_name = "ene_ub6250";
702 us->transport = ene_transport;
703 us->max_lun = 0;
704
705 result = usb_stor_probe2(us);
706 if (result)
707 return result;
708
709 /* probe card type */
710 result = ene_get_card_type(us, REG_CARD_STATUS, &misc_reg03);
711 if (result != USB_STOR_XFER_GOOD) {
712 usb_stor_disconnect(intf);
713 return USB_STOR_TRANSPORT_ERROR;
714 }
715
716 if (!(misc_reg03 & 0x01)) {
717 result = -ENODEV;
718 printk(KERN_NOTICE "ums_eneub6250: The driver only supports SD card. "
719 "To use SM/MS card, please build driver/staging/keucr\n");
720 usb_stor_disconnect(intf);
721 }
722
723 return result;
724}
725
726
727#ifdef CONFIG_PM
728
729static int ene_ub6250_resume(struct usb_interface *iface)
730{
731 u8 tmp = 0;
732 struct us_data *us = usb_get_intfdata(iface);
733 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
734
735 mutex_lock(&us->dev_mutex);
736
737 US_DEBUGP("%s\n", __func__);
738 if (us->suspend_resume_hook)
739 (us->suspend_resume_hook)(us, US_RESUME);
740
741 mutex_unlock(&us->dev_mutex);
742
743 info->Power_IsResum = true;
744 /*info->SD_Status.Ready = 0; */
745 info->SD_Status = *(struct SD_STATUS *)&tmp;
746 info->MS_Status = *(struct MS_STATUS *)&tmp;
747 info->SM_Status = *(struct SM_STATUS *)&tmp;
748
749 return 0;
750}
751
752static int ene_ub6250_reset_resume(struct usb_interface *iface)
753{
754 u8 tmp = 0;
755 struct us_data *us = usb_get_intfdata(iface);
756 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
757 US_DEBUGP("%s\n", __func__);
758 /* Report the reset to the SCSI core */
759 usb_stor_reset_resume(iface);
760
761 /* FIXME: Notify the subdrivers that they need to reinitialize
762 * the device */
763 info->Power_IsResum = true;
764 /*info->SD_Status.Ready = 0; */
765 info->SD_Status = *(struct SD_STATUS *)&tmp;
766 info->MS_Status = *(struct MS_STATUS *)&tmp;
767 info->SM_Status = *(struct SM_STATUS *)&tmp;
768
769 return 0;
770}
771
772#else
773
774#define ene_ub6250_resume NULL
775#define ene_ub6250_reset_resume NULL
776
777#endif
778
779static struct usb_driver ene_ub6250_driver = {
780 .name = "ums_eneub6250",
781 .probe = ene_ub6250_probe,
782 .disconnect = usb_stor_disconnect,
783 .suspend = usb_stor_suspend,
784 .resume = ene_ub6250_resume,
785 .reset_resume = ene_ub6250_reset_resume,
786 .pre_reset = usb_stor_pre_reset,
787 .post_reset = usb_stor_post_reset,
788 .id_table = ene_ub6250_usb_ids,
789 .soft_unbind = 1,
790};
791
792static int __init ene_ub6250_init(void)
793{
794 return usb_register(&ene_ub6250_driver);
795}
796
797static void __exit ene_ub6250_exit(void)
798{
799 usb_deregister(&ene_ub6250_driver);
800}
801
802module_init(ene_ub6250_init);
803module_exit(ene_ub6250_exit);
diff --git a/drivers/usb/storage/isd200.c b/drivers/usb/storage/isd200.c
index 6b9982cd5423..ffc4193e9505 100644
--- a/drivers/usb/storage/isd200.c
+++ b/drivers/usb/storage/isd200.c
@@ -499,7 +499,6 @@ static int isd200_action( struct us_data *us, int action,
499 memset(&ata, 0, sizeof(ata)); 499 memset(&ata, 0, sizeof(ata));
500 srb->cmnd = info->cmnd; 500 srb->cmnd = info->cmnd;
501 srb->device = &srb_dev; 501 srb->device = &srb_dev;
502 ++srb->serial_number;
503 502
504 ata.generic.SignatureByte0 = info->ConfigData.ATAMajorCommand; 503 ata.generic.SignatureByte0 = info->ConfigData.ATAMajorCommand;
505 ata.generic.SignatureByte1 = info->ConfigData.ATAMinorCommand; 504 ata.generic.SignatureByte1 = info->ConfigData.ATAMinorCommand;
@@ -1510,7 +1509,7 @@ static int isd200_Initialization(struct us_data *us)
1510 * Protocol and Transport for the ISD200 ASIC 1509 * Protocol and Transport for the ISD200 ASIC
1511 * 1510 *
1512 * This protocol and transport are for ATA devices connected to an ISD200 1511 * This protocol and transport are for ATA devices connected to an ISD200
1513 * ASIC. An ATAPI device that is conected as a slave device will be 1512 * ASIC. An ATAPI device that is connected as a slave device will be
1514 * detected in the driver initialization function and the protocol will 1513 * detected in the driver initialization function and the protocol will
1515 * be changed to an ATAPI protocol (Transparent SCSI). 1514 * be changed to an ATAPI protocol (Transparent SCSI).
1516 * 1515 *
diff --git a/drivers/usb/storage/realtek_cr.c b/drivers/usb/storage/realtek_cr.c
new file mode 100644
index 000000000000..d509a4a7d74f
--- /dev/null
+++ b/drivers/usb/storage/realtek_cr.c
@@ -0,0 +1,675 @@
1/* Driver for Realtek RTS51xx USB card reader
2 *
3 * Copyright(c) 2009 Realtek Semiconductor Corp. All rights reserved.
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License as published by the
7 * Free Software Foundation; either version 2, or (at your option) any
8 * later version.
9 *
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License along
16 * with this program; if not, see <http://www.gnu.org/licenses/>.
17 *
18 * Author:
19 * wwang (wei_wang@realsil.com.cn)
20 * No. 450, Shenhu Road, Suzhou Industry Park, Suzhou, China
21 */
22
23#include <linux/module.h>
24#include <linux/blkdev.h>
25#include <linux/kthread.h>
26#include <linux/sched.h>
27#include <linux/workqueue.h>
28#include <linux/kernel.h>
29#include <linux/version.h>
30
31#include <scsi/scsi.h>
32#include <scsi/scsi_cmnd.h>
33#include <scsi/scsi_device.h>
34#include <linux/cdrom.h>
35
36#include <linux/usb.h>
37#include <linux/slab.h>
38#include <linux/usb_usual.h>
39
40#include "usb.h"
41#include "transport.h"
42#include "protocol.h"
43#include "debug.h"
44
45MODULE_DESCRIPTION("Driver for Realtek USB Card Reader");
46MODULE_AUTHOR("wwang <wei_wang@realsil.com.cn>");
47MODULE_LICENSE("GPL");
48MODULE_VERSION("1.03");
49
50static int auto_delink_en = 1;
51module_param(auto_delink_en, int, S_IRUGO | S_IWUSR);
52MODULE_PARM_DESC(auto_delink_en, "enable auto delink");
53
54struct rts51x_status {
55 u16 vid;
56 u16 pid;
57 u8 cur_lun;
58 u8 card_type;
59 u8 total_lun;
60 u16 fw_ver;
61 u8 phy_exist;
62 u8 multi_flag;
63 u8 multi_card;
64 u8 log_exist;
65 union {
66 u8 detailed_type1;
67 u8 detailed_type2;
68 } detailed_type;
69 u8 function[2];
70};
71
72struct rts51x_chip {
73 u16 vendor_id;
74 u16 product_id;
75 char max_lun;
76
77 struct rts51x_status *status;
78 int status_len;
79
80 u32 flag;
81};
82
83/* flag definition */
84#define FLIDX_AUTO_DELINK 0x01
85
86#define SCSI_LUN(srb) ((srb)->device->lun)
87
88/* Bit Operation */
89#define SET_BIT(data, idx) ((data) |= 1 << (idx))
90#define CLR_BIT(data, idx) ((data) &= ~(1 << (idx)))
91#define CHK_BIT(data, idx) ((data) & (1 << (idx)))
92
93#define SET_AUTO_DELINK(chip) ((chip)->flag |= FLIDX_AUTO_DELINK)
94#define CLR_AUTO_DELINK(chip) ((chip)->flag &= ~FLIDX_AUTO_DELINK)
95#define CHK_AUTO_DELINK(chip) ((chip)->flag & FLIDX_AUTO_DELINK)
96
97#define RTS51X_GET_VID(chip) ((chip)->vendor_id)
98#define RTS51X_GET_PID(chip) ((chip)->product_id)
99
100#define FW_VERSION(chip) ((chip)->status[0].fw_ver)
101#define STATUS_LEN(chip) ((chip)->status_len)
102
103/* Check card reader function */
104#define SUPPORT_DETAILED_TYPE1(chip) \
105 CHK_BIT((chip)->status[0].function[0], 1)
106#define SUPPORT_OT(chip) \
107 CHK_BIT((chip)->status[0].function[0], 2)
108#define SUPPORT_OC(chip) \
109 CHK_BIT((chip)->status[0].function[0], 3)
110#define SUPPORT_AUTO_DELINK(chip) \
111 CHK_BIT((chip)->status[0].function[0], 4)
112#define SUPPORT_SDIO(chip) \
113 CHK_BIT((chip)->status[0].function[1], 0)
114#define SUPPORT_DETAILED_TYPE2(chip) \
115 CHK_BIT((chip)->status[0].function[1], 1)
116
117#define CHECK_PID(chip, pid) (RTS51X_GET_PID(chip) == (pid))
118#define CHECK_FW_VER(chip, fw_ver) (FW_VERSION(chip) == (fw_ver))
119#define CHECK_ID(chip, pid, fw_ver) \
120 (CHECK_PID((chip), (pid)) && CHECK_FW_VER((chip), (fw_ver)))
121
122#define wait_timeout_x(task_state, msecs) \
123do { \
124 set_current_state((task_state)); \
125 schedule_timeout((msecs) * HZ / 1000); \
126} while (0)
127
128#define wait_timeout(msecs) \
129 wait_timeout_x(TASK_INTERRUPTIBLE, (msecs))
130
131static int init_realtek_cr(struct us_data *us);
132
133/*
134 * The table of devices
135 */
136#define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
137 vendorName, productName, useProtocol, useTransport, \
138 initFunction, flags) \
139{\
140 USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
141 .driver_info = (flags)|(USB_US_TYPE_STOR<<24)\
142}
143
144static const struct usb_device_id realtek_cr_ids[] = {
145# include "unusual_realtek.h"
146 { } /* Terminating entry */
147};
148MODULE_DEVICE_TABLE(usb, realtek_cr_ids);
149
150#undef UNUSUAL_DEV
151
152/*
153 * The flags table
154 */
155#define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \
156 vendor_name, product_name, use_protocol, use_transport, \
157 init_function, Flags) \
158{ \
159 .vendorName = vendor_name, \
160 .productName = product_name, \
161 .useProtocol = use_protocol, \
162 .useTransport = use_transport, \
163 .initFunction = init_function, \
164}
165
166static struct us_unusual_dev realtek_cr_unusual_dev_list[] = {
167# include "unusual_realtek.h"
168 { } /* Terminating entry */
169};
170
171#undef UNUSUAL_DEV
172
173static int rts51x_bulk_transport(struct us_data *us, u8 lun,
174 u8 *cmd, int cmd_len, u8 *buf, int buf_len,
175 enum dma_data_direction dir, int *act_len)
176{
177 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
178 struct bulk_cs_wrap *bcs = (struct bulk_cs_wrap *) us->iobuf;
179 int result;
180 unsigned int residue;
181 unsigned int cswlen;
182 unsigned int cbwlen = US_BULK_CB_WRAP_LEN;
183
184 /* set up the command wrapper */
185 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
186 bcb->DataTransferLength = cpu_to_le32(buf_len);
187 bcb->Flags = (dir == DMA_FROM_DEVICE) ? 1 << 7 : 0;
188 bcb->Tag = ++us->tag;
189 bcb->Lun = lun;
190 bcb->Length = cmd_len;
191
192 /* copy the command payload */
193 memset(bcb->CDB, 0, sizeof(bcb->CDB));
194 memcpy(bcb->CDB, cmd, bcb->Length);
195
196 /* send it to out endpoint */
197 result = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe,
198 bcb, cbwlen, NULL);
199 if (result != USB_STOR_XFER_GOOD)
200 return USB_STOR_TRANSPORT_ERROR;
201
202 /* DATA STAGE */
203 /* send/receive data payload, if there is any */
204
205 if (buf && buf_len) {
206 unsigned int pipe = (dir == DMA_FROM_DEVICE) ?
207 us->recv_bulk_pipe : us->send_bulk_pipe;
208 result = usb_stor_bulk_transfer_buf(us, pipe,
209 buf, buf_len, NULL);
210 if (result == USB_STOR_XFER_ERROR)
211 return USB_STOR_TRANSPORT_ERROR;
212 }
213
214 /* get CSW for device status */
215 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
216 bcs, US_BULK_CS_WRAP_LEN, &cswlen);
217 if (result != USB_STOR_XFER_GOOD)
218 return USB_STOR_TRANSPORT_ERROR;
219
220 /* check bulk status */
221 if (bcs->Signature != cpu_to_le32(US_BULK_CS_SIGN)) {
222 US_DEBUGP("Signature mismatch: got %08X, expecting %08X\n",
223 le32_to_cpu(bcs->Signature),
224 US_BULK_CS_SIGN);
225 return USB_STOR_TRANSPORT_ERROR;
226 }
227
228 residue = bcs->Residue;
229 if (bcs->Tag != us->tag)
230 return USB_STOR_TRANSPORT_ERROR;
231
232 /* try to compute the actual residue, based on how much data
233 * was really transferred and what the device tells us */
234 if (residue)
235 residue = residue < buf_len ? residue : buf_len;
236
237 if (act_len)
238 *act_len = buf_len - residue;
239
240 /* based on the status code, we report good or bad */
241 switch (bcs->Status) {
242 case US_BULK_STAT_OK:
243 /* command good -- note that data could be short */
244 return USB_STOR_TRANSPORT_GOOD;
245
246 case US_BULK_STAT_FAIL:
247 /* command failed */
248 return USB_STOR_TRANSPORT_FAILED;
249
250 case US_BULK_STAT_PHASE:
251 /* phase error -- note that a transport reset will be
252 * invoked by the invoke_transport() function
253 */
254 return USB_STOR_TRANSPORT_ERROR;
255 }
256
257 /* we should never get here, but if we do, we're in trouble */
258 return USB_STOR_TRANSPORT_ERROR;
259}
260
261/* Determine what the maximum LUN supported is */
262static int rts51x_get_max_lun(struct us_data *us)
263{
264 int result;
265
266 /* issue the command */
267 us->iobuf[0] = 0;
268 result = usb_stor_control_msg(us, us->recv_ctrl_pipe,
269 US_BULK_GET_MAX_LUN,
270 USB_DIR_IN | USB_TYPE_CLASS |
271 USB_RECIP_INTERFACE,
272 0, us->ifnum, us->iobuf, 1, 10*HZ);
273
274 US_DEBUGP("GetMaxLUN command result is %d, data is %d\n",
275 result, us->iobuf[0]);
276
277 /* if we have a successful request, return the result */
278 if (result > 0)
279 return us->iobuf[0];
280
281 return 0;
282}
283
284static int rts51x_read_mem(struct us_data *us, u16 addr, u8 *data, u16 len)
285{
286 int retval;
287 u8 cmnd[12] = {0};
288
289 US_DEBUGP("%s, addr = 0x%x, len = %d\n", __func__, addr, len);
290
291 cmnd[0] = 0xF0;
292 cmnd[1] = 0x0D;
293 cmnd[2] = (u8)(addr >> 8);
294 cmnd[3] = (u8)addr;
295 cmnd[4] = (u8)(len >> 8);
296 cmnd[5] = (u8)len;
297
298 retval = rts51x_bulk_transport(us, 0, cmnd, 12,
299 data, len, DMA_FROM_DEVICE, NULL);
300 if (retval != USB_STOR_TRANSPORT_GOOD)
301 return -EIO;
302
303 return 0;
304}
305
306static int rts51x_write_mem(struct us_data *us, u16 addr, u8 *data, u16 len)
307{
308 int retval;
309 u8 cmnd[12] = {0};
310
311 US_DEBUGP("%s, addr = 0x%x, len = %d\n", __func__, addr, len);
312
313 cmnd[0] = 0xF0;
314 cmnd[1] = 0x0E;
315 cmnd[2] = (u8)(addr >> 8);
316 cmnd[3] = (u8)addr;
317 cmnd[4] = (u8)(len >> 8);
318 cmnd[5] = (u8)len;
319
320 retval = rts51x_bulk_transport(us, 0, cmnd, 12,
321 data, len, DMA_TO_DEVICE, NULL);
322 if (retval != USB_STOR_TRANSPORT_GOOD)
323 return -EIO;
324
325 return 0;
326}
327
328static int rts51x_read_status(struct us_data *us,
329 u8 lun, u8 *status, int len, int *actlen)
330{
331 int retval;
332 u8 cmnd[12] = {0};
333
334 US_DEBUGP("%s, lun = %d\n", __func__, lun);
335
336 cmnd[0] = 0xF0;
337 cmnd[1] = 0x09;
338
339 retval = rts51x_bulk_transport(us, lun, cmnd, 12,
340 status, len, DMA_FROM_DEVICE, actlen);
341 if (retval != USB_STOR_TRANSPORT_GOOD)
342 return -EIO;
343
344 return 0;
345}
346
347static int rts51x_check_status(struct us_data *us, u8 lun)
348{
349 struct rts51x_chip *chip = (struct rts51x_chip *)(us->extra);
350 int retval;
351 u8 buf[16];
352
353 retval = rts51x_read_status(us, lun, buf, 16, &(chip->status_len));
354 if (retval < 0)
355 return -EIO;
356
357 US_DEBUGP("chip->status_len = %d\n", chip->status_len);
358
359 chip->status[lun].vid = ((u16)buf[0] << 8) | buf[1];
360 chip->status[lun].pid = ((u16)buf[2] << 8) | buf[3];
361 chip->status[lun].cur_lun = buf[4];
362 chip->status[lun].card_type = buf[5];
363 chip->status[lun].total_lun = buf[6];
364 chip->status[lun].fw_ver = ((u16)buf[7] << 8) | buf[8];
365 chip->status[lun].phy_exist = buf[9];
366 chip->status[lun].multi_flag = buf[10];
367 chip->status[lun].multi_card = buf[11];
368 chip->status[lun].log_exist = buf[12];
369 if (chip->status_len == 16) {
370 chip->status[lun].detailed_type.detailed_type1 = buf[13];
371 chip->status[lun].function[0] = buf[14];
372 chip->status[lun].function[1] = buf[15];
373 }
374
375 return 0;
376}
377
378static int enable_oscillator(struct us_data *us)
379{
380 int retval;
381 u8 value;
382
383 retval = rts51x_read_mem(us, 0xFE77, &value, 1);
384 if (retval < 0)
385 return -EIO;
386
387 value |= 0x04;
388 retval = rts51x_write_mem(us, 0xFE77, &value, 1);
389 if (retval < 0)
390 return -EIO;
391
392 retval = rts51x_read_mem(us, 0xFE77, &value, 1);
393 if (retval < 0)
394 return -EIO;
395
396 if (!(value & 0x04))
397 return -EIO;
398
399 return 0;
400}
401
402static int do_config_autodelink(struct us_data *us, int enable, int force)
403{
404 int retval;
405 u8 value;
406
407 retval = rts51x_read_mem(us, 0xFE47, &value, 1);
408 if (retval < 0)
409 return -EIO;
410
411 if (enable) {
412 if (force)
413 value |= 0x03;
414 else
415 value |= 0x01;
416 } else {
417 value &= ~0x03;
418 }
419
420 US_DEBUGP("In %s,set 0xfe47 to 0x%x\n", __func__, value);
421
422 retval = rts51x_write_mem(us, 0xFE47, &value, 1);
423 if (retval < 0)
424 return -EIO;
425
426 return 0;
427}
428
429static int config_autodelink_after_power_on(struct us_data *us)
430{
431 struct rts51x_chip *chip = (struct rts51x_chip *)(us->extra);
432 int retval;
433 u8 value;
434
435 if (!CHK_AUTO_DELINK(chip))
436 return 0;
437
438 retval = rts51x_read_mem(us, 0xFE47, &value, 1);
439 if (retval < 0)
440 return -EIO;
441
442 if (auto_delink_en) {
443 CLR_BIT(value, 0);
444 CLR_BIT(value, 1);
445 SET_BIT(value, 2);
446
447 if (CHECK_ID(chip, 0x0138, 0x3882))
448 CLR_BIT(value, 2);
449
450 SET_BIT(value, 7);
451
452 retval = rts51x_write_mem(us, 0xFE47, &value, 1);
453 if (retval < 0)
454 return -EIO;
455
456 retval = enable_oscillator(us);
457 if (retval == 0)
458 (void)do_config_autodelink(us, 1, 0);
459 } else {
460 /* Autodelink controlled by firmware */
461
462 SET_BIT(value, 2);
463
464 if (CHECK_ID(chip, 0x0138, 0x3882))
465 CLR_BIT(value, 2);
466
467 if (CHECK_ID(chip, 0x0159, 0x5889) ||
468 CHECK_ID(chip, 0x0138, 0x3880)) {
469 CLR_BIT(value, 0);
470 CLR_BIT(value, 7);
471 }
472
473 retval = rts51x_write_mem(us, 0xFE47, &value, 1);
474 if (retval < 0)
475 return -EIO;
476
477 if (CHECK_ID(chip, 0x0159, 0x5888)) {
478 value = 0xFF;
479 retval = rts51x_write_mem(us, 0xFE79, &value, 1);
480 if (retval < 0)
481 return -EIO;
482
483 value = 0x01;
484 retval = rts51x_write_mem(us, 0x48, &value, 1);
485 if (retval < 0)
486 return -EIO;
487 }
488 }
489
490 return 0;
491}
492
493static int config_autodelink_before_power_down(struct us_data *us)
494{
495 struct rts51x_chip *chip = (struct rts51x_chip *)(us->extra);
496 int retval;
497 u8 value;
498
499 if (!CHK_AUTO_DELINK(chip))
500 return 0;
501
502 if (auto_delink_en) {
503 retval = rts51x_read_mem(us, 0xFE77, &value, 1);
504 if (retval < 0)
505 return -EIO;
506
507 SET_BIT(value, 2);
508 retval = rts51x_write_mem(us, 0xFE77, &value, 1);
509 if (retval < 0)
510 return -EIO;
511
512 if (CHECK_ID(chip, 0x0159, 0x5888)) {
513 value = 0x01;
514 retval = rts51x_write_mem(us, 0x48, &value, 1);
515 if (retval < 0)
516 return -EIO;
517 }
518
519 retval = rts51x_read_mem(us, 0xFE47, &value, 1);
520 if (retval < 0)
521 return -EIO;
522
523 SET_BIT(value, 0);
524 if (CHECK_ID(chip, 0x0138, 0x3882))
525 SET_BIT(value, 2);
526 retval = rts51x_write_mem(us, 0xFE77, &value, 1);
527 if (retval < 0)
528 return -EIO;
529 } else {
530 if (CHECK_ID(chip, 0x0159, 0x5889) ||
531 CHECK_ID(chip, 0x0138, 0x3880) ||
532 CHECK_ID(chip, 0x0138, 0x3882)) {
533 retval = rts51x_read_mem(us, 0xFE47, &value, 1);
534 if (retval < 0)
535 return -EIO;
536
537 if (CHECK_ID(chip, 0x0159, 0x5889) ||
538 CHECK_ID(chip, 0x0138, 0x3880)) {
539 SET_BIT(value, 0);
540 SET_BIT(value, 7);
541 }
542
543 if (CHECK_ID(chip, 0x0138, 0x3882))
544 SET_BIT(value, 2);
545
546 retval = rts51x_write_mem(us, 0xFE47, &value, 1);
547 if (retval < 0)
548 return -EIO;
549 }
550
551 if (CHECK_ID(chip, 0x0159, 0x5888)) {
552 value = 0x01;
553 retval = rts51x_write_mem(us, 0x48, &value, 1);
554 if (retval < 0)
555 return -EIO;
556 }
557 }
558
559 return 0;
560}
561
562static void realtek_cr_destructor(void *extra)
563{
564 struct rts51x_chip *chip = (struct rts51x_chip *)extra;
565
566 if (!chip)
567 return;
568
569 kfree(chip->status);
570}
571
572#ifdef CONFIG_PM
573static void realtek_pm_hook(struct us_data *us, int pm_state)
574{
575 if (pm_state == US_SUSPEND)
576 (void)config_autodelink_before_power_down(us);
577}
578#endif
579
580static int init_realtek_cr(struct us_data *us)
581{
582 struct rts51x_chip *chip;
583 int size, i, retval;
584
585 chip = kzalloc(sizeof(struct rts51x_chip), GFP_KERNEL);
586 if (!chip)
587 return -ENOMEM;
588
589 us->extra = chip;
590 us->extra_destructor = realtek_cr_destructor;
591#ifdef CONFIG_PM
592 us->suspend_resume_hook = realtek_pm_hook;
593#endif
594
595 us->max_lun = chip->max_lun = rts51x_get_max_lun(us);
596
597 US_DEBUGP("chip->max_lun = %d\n", chip->max_lun);
598
599 size = (chip->max_lun + 1) * sizeof(struct rts51x_status);
600 chip->status = kzalloc(size, GFP_KERNEL);
601 if (!chip->status)
602 goto INIT_FAIL;
603
604 for (i = 0; i <= (int)(chip->max_lun); i++) {
605 retval = rts51x_check_status(us, (u8)i);
606 if (retval < 0)
607 goto INIT_FAIL;
608 }
609
610 if (CHECK_FW_VER(chip, 0x5888) || CHECK_FW_VER(chip, 0x5889) ||
611 CHECK_FW_VER(chip, 0x5901))
612 SET_AUTO_DELINK(chip);
613 if (STATUS_LEN(chip) == 16) {
614 if (SUPPORT_AUTO_DELINK(chip))
615 SET_AUTO_DELINK(chip);
616 }
617
618 US_DEBUGP("chip->flag = 0x%x\n", chip->flag);
619
620 (void)config_autodelink_after_power_on(us);
621
622 return 0;
623
624INIT_FAIL:
625 if (us->extra) {
626 kfree(chip->status);
627 kfree(us->extra);
628 us->extra = NULL;
629 }
630
631 return -EIO;
632}
633
634static int realtek_cr_probe(struct usb_interface *intf,
635 const struct usb_device_id *id)
636{
637 struct us_data *us;
638 int result;
639
640 US_DEBUGP("Probe Realtek Card Reader!\n");
641
642 result = usb_stor_probe1(&us, intf, id,
643 (id - realtek_cr_ids) + realtek_cr_unusual_dev_list);
644 if (result)
645 return result;
646
647 result = usb_stor_probe2(us);
648 return result;
649}
650
651static struct usb_driver realtek_cr_driver = {
652 .name = "ums-realtek",
653 .probe = realtek_cr_probe,
654 .disconnect = usb_stor_disconnect,
655 .suspend = usb_stor_suspend,
656 .resume = usb_stor_resume,
657 .reset_resume = usb_stor_reset_resume,
658 .pre_reset = usb_stor_pre_reset,
659 .post_reset = usb_stor_post_reset,
660 .id_table = realtek_cr_ids,
661 .soft_unbind = 1,
662};
663
664static int __init realtek_cr_init(void)
665{
666 return usb_register(&realtek_cr_driver);
667}
668
669static void __exit realtek_cr_exit(void)
670{
671 usb_deregister(&realtek_cr_driver);
672}
673
674module_init(realtek_cr_init);
675module_exit(realtek_cr_exit);
diff --git a/drivers/usb/storage/scsiglue.c b/drivers/usb/storage/scsiglue.c
index d8d98cfecada..13b8bcdf3dba 100644
--- a/drivers/usb/storage/scsiglue.c
+++ b/drivers/usb/storage/scsiglue.c
@@ -113,7 +113,7 @@ static int slave_alloc (struct scsi_device *sdev)
113 * Let the scanning code know if this target merely sets 113 * Let the scanning code know if this target merely sets
114 * Peripheral Device Type to 0x1f to indicate no LUN. 114 * Peripheral Device Type to 0x1f to indicate no LUN.
115 */ 115 */
116 if (us->subclass == US_SC_UFI) 116 if (us->subclass == USB_SC_UFI)
117 sdev->sdev_target->pdt_1f_for_no_lun = 1; 117 sdev->sdev_target->pdt_1f_for_no_lun = 1;
118 118
119 return 0; 119 return 0;
@@ -123,7 +123,7 @@ static int slave_configure(struct scsi_device *sdev)
123{ 123{
124 struct us_data *us = host_to_us(sdev->host); 124 struct us_data *us = host_to_us(sdev->host);
125 125
126 /* Many devices have trouble transfering more than 32KB at a time, 126 /* Many devices have trouble transferring more than 32KB at a time,
127 * while others have trouble with more than 64K. At this time we 127 * while others have trouble with more than 64K. At this time we
128 * are limiting both to 32K (64 sectores). 128 * are limiting both to 32K (64 sectores).
129 */ 129 */
@@ -176,7 +176,7 @@ static int slave_configure(struct scsi_device *sdev)
176 /* Disk-type devices use MODE SENSE(6) if the protocol 176 /* Disk-type devices use MODE SENSE(6) if the protocol
177 * (SubClass) is Transparent SCSI, otherwise they use 177 * (SubClass) is Transparent SCSI, otherwise they use
178 * MODE SENSE(10). */ 178 * MODE SENSE(10). */
179 if (us->subclass != US_SC_SCSI && us->subclass != US_SC_CYP_ATACB) 179 if (us->subclass != USB_SC_SCSI && us->subclass != USB_SC_CYP_ATACB)
180 sdev->use_10_for_ms = 1; 180 sdev->use_10_for_ms = 1;
181 181
182 /* Many disks only accept MODE SENSE transfer lengths of 182 /* Many disks only accept MODE SENSE transfer lengths of
@@ -209,6 +209,10 @@ static int slave_configure(struct scsi_device *sdev)
209 if (us->fflags & US_FL_CAPACITY_HEURISTICS) 209 if (us->fflags & US_FL_CAPACITY_HEURISTICS)
210 sdev->guess_capacity = 1; 210 sdev->guess_capacity = 1;
211 211
212 /* Some devices cannot handle READ_CAPACITY_16 */
213 if (us->fflags & US_FL_NO_READ_CAPACITY_16)
214 sdev->no_read_capacity_16 = 1;
215
212 /* assume SPC3 or latter devices support sense size > 18 */ 216 /* assume SPC3 or latter devices support sense size > 18 */
213 if (sdev->scsi_level > SCSI_SPC_2) 217 if (sdev->scsi_level > SCSI_SPC_2)
214 us->fflags |= US_FL_SANE_SENSE; 218 us->fflags |= US_FL_SANE_SENSE;
@@ -245,7 +249,7 @@ static int slave_configure(struct scsi_device *sdev)
245 * capacity will be decremented or is correct. */ 249 * capacity will be decremented or is correct. */
246 if (!(us->fflags & (US_FL_FIX_CAPACITY | US_FL_CAPACITY_OK | 250 if (!(us->fflags & (US_FL_FIX_CAPACITY | US_FL_CAPACITY_OK |
247 US_FL_SCM_MULT_TARG)) && 251 US_FL_SCM_MULT_TARG)) &&
248 us->protocol == US_PR_BULK) 252 us->protocol == USB_PR_BULK)
249 us->use_last_sector_hacks = 1; 253 us->use_last_sector_hacks = 1;
250 } else { 254 } else {
251 255
@@ -253,6 +257,10 @@ static int slave_configure(struct scsi_device *sdev)
253 * or to force 192-byte transfer lengths for MODE SENSE. 257 * or to force 192-byte transfer lengths for MODE SENSE.
254 * But they do need to use MODE SENSE(10). */ 258 * But they do need to use MODE SENSE(10). */
255 sdev->use_10_for_ms = 1; 259 sdev->use_10_for_ms = 1;
260
261 /* Some (fake) usb cdrom devices don't like READ_DISC_INFO */
262 if (us->fflags & US_FL_NO_READ_DISC_INFO)
263 sdev->no_read_disc_info = 1;
256 } 264 }
257 265
258 /* The CB and CBI transports have no way to pass LUN values 266 /* The CB and CBI transports have no way to pass LUN values
@@ -261,7 +269,7 @@ static int slave_configure(struct scsi_device *sdev)
261 * scsi_level == 0 (UNKNOWN). Hence such devices must necessarily 269 * scsi_level == 0 (UNKNOWN). Hence such devices must necessarily
262 * be single-LUN. 270 * be single-LUN.
263 */ 271 */
264 if ((us->protocol == US_PR_CB || us->protocol == US_PR_CBI) && 272 if ((us->protocol == USB_PR_CB || us->protocol == USB_PR_CBI) &&
265 sdev->scsi_level == SCSI_UNKNOWN) 273 sdev->scsi_level == SCSI_UNKNOWN)
266 us->max_lun = 0; 274 us->max_lun = 0;
267 275
@@ -277,7 +285,7 @@ static int slave_configure(struct scsi_device *sdev)
277 285
278/* queue a command */ 286/* queue a command */
279/* This is always called with scsi_lock(host) held */ 287/* This is always called with scsi_lock(host) held */
280static int queuecommand(struct scsi_cmnd *srb, 288static int queuecommand_lck(struct scsi_cmnd *srb,
281 void (*done)(struct scsi_cmnd *)) 289 void (*done)(struct scsi_cmnd *))
282{ 290{
283 struct us_data *us = host_to_us(srb->device->host); 291 struct us_data *us = host_to_us(srb->device->host);
@@ -307,6 +315,8 @@ static int queuecommand(struct scsi_cmnd *srb,
307 return 0; 315 return 0;
308} 316}
309 317
318static DEF_SCSI_QCMD(queuecommand)
319
310/*********************************************************************** 320/***********************************************************************
311 * Error handling functions 321 * Error handling functions
312 ***********************************************************************/ 322 ***********************************************************************/
diff --git a/drivers/usb/storage/sddr09.c b/drivers/usb/storage/sddr09.c
index ab5f9f37575a..bcb9a709d349 100644
--- a/drivers/usb/storage/sddr09.c
+++ b/drivers/usb/storage/sddr09.c
@@ -1760,7 +1760,7 @@ static int sddr09_probe(struct usb_interface *intf,
1760 if (result) 1760 if (result)
1761 return result; 1761 return result;
1762 1762
1763 if (us->protocol == US_PR_DPCM_USB) { 1763 if (us->protocol == USB_PR_DPCM_USB) {
1764 us->transport_name = "Control/Bulk-EUSB/SDDR09"; 1764 us->transport_name = "Control/Bulk-EUSB/SDDR09";
1765 us->transport = dpcm_transport; 1765 us->transport = dpcm_transport;
1766 us->transport_reset = usb_stor_CB_reset; 1766 us->transport_reset = usb_stor_CB_reset;
diff --git a/drivers/usb/storage/shuttle_usbat.c b/drivers/usb/storage/shuttle_usbat.c
index bd3f415893d8..0b00091d2ae9 100644
--- a/drivers/usb/storage/shuttle_usbat.c
+++ b/drivers/usb/storage/shuttle_usbat.c
@@ -340,7 +340,7 @@ static int usbat_check_status(struct us_data *us)
340} 340}
341 341
342/* 342/*
343 * Stores critical information in internal registers in prepartion for the execution 343 * Stores critical information in internal registers in preparation for the execution
344 * of a conditional usbat_read_blocks or usbat_write_blocks call. 344 * of a conditional usbat_read_blocks or usbat_write_blocks call.
345 */ 345 */
346static int usbat_set_shuttle_features(struct us_data *us, 346static int usbat_set_shuttle_features(struct us_data *us,
diff --git a/drivers/usb/storage/sierra_ms.c b/drivers/usb/storage/sierra_ms.c
index 57fc2f532cab..1deca07c8265 100644
--- a/drivers/usb/storage/sierra_ms.c
+++ b/drivers/usb/storage/sierra_ms.c
@@ -121,18 +121,16 @@ static ssize_t show_truinst(struct device *dev, struct device_attribute *attr,
121 } 121 }
122 return result; 122 return result;
123} 123}
124static DEVICE_ATTR(truinst, S_IWUGO | S_IRUGO, show_truinst, NULL); 124static DEVICE_ATTR(truinst, S_IRUGO, show_truinst, NULL);
125 125
126int sierra_ms_init(struct us_data *us) 126int sierra_ms_init(struct us_data *us)
127{ 127{
128 int result, retries; 128 int result, retries;
129 signed long delay_t;
130 struct swoc_info *swocInfo; 129 struct swoc_info *swocInfo;
131 struct usb_device *udev; 130 struct usb_device *udev;
132 struct Scsi_Host *sh; 131 struct Scsi_Host *sh;
133 struct scsi_device *sd; 132 struct scsi_device *sd;
134 133
135 delay_t = 2;
136 retries = 3; 134 retries = 3;
137 result = 0; 135 result = 0;
138 udev = us->pusb_dev; 136 udev = us->pusb_dev;
diff --git a/drivers/usb/storage/transport.c b/drivers/usb/storage/transport.c
index 64ec073e89de..e8ae21b2d387 100644
--- a/drivers/usb/storage/transport.c
+++ b/drivers/usb/storage/transport.c
@@ -642,7 +642,7 @@ void usb_stor_invoke_transport(struct scsi_cmnd *srb, struct us_data *us)
642 * unless the operation involved a data-in transfer. Devices 642 * unless the operation involved a data-in transfer. Devices
643 * can signal most data-in errors by stalling the bulk-in pipe. 643 * can signal most data-in errors by stalling the bulk-in pipe.
644 */ 644 */
645 if ((us->protocol == US_PR_CB || us->protocol == US_PR_DPCM_USB) && 645 if ((us->protocol == USB_PR_CB || us->protocol == USB_PR_DPCM_USB) &&
646 srb->sc_data_direction != DMA_FROM_DEVICE) { 646 srb->sc_data_direction != DMA_FROM_DEVICE) {
647 US_DEBUGP("-- CB transport device requiring auto-sense\n"); 647 US_DEBUGP("-- CB transport device requiring auto-sense\n");
648 need_auto_sense = 1; 648 need_auto_sense = 1;
@@ -701,8 +701,8 @@ Retry_Sense:
701 scsi_eh_prep_cmnd(srb, &ses, NULL, 0, sense_size); 701 scsi_eh_prep_cmnd(srb, &ses, NULL, 0, sense_size);
702 702
703 /* FIXME: we must do the protocol translation here */ 703 /* FIXME: we must do the protocol translation here */
704 if (us->subclass == US_SC_RBC || us->subclass == US_SC_SCSI || 704 if (us->subclass == USB_SC_RBC || us->subclass == USB_SC_SCSI ||
705 us->subclass == US_SC_CYP_ATACB) 705 us->subclass == USB_SC_CYP_ATACB)
706 srb->cmd_len = 6; 706 srb->cmd_len = 6;
707 else 707 else
708 srb->cmd_len = 12; 708 srb->cmd_len = 12;
@@ -819,6 +819,35 @@ Retry_Sense:
819 } 819 }
820 } 820 }
821 821
822 /*
823 * Some devices don't work or return incorrect data the first
824 * time they get a READ(10) command, or for the first READ(10)
825 * after a media change. If the INITIAL_READ10 flag is set,
826 * keep track of whether READ(10) commands succeed. If the
827 * previous one succeeded and this one failed, set the REDO_READ10
828 * flag to force a retry.
829 */
830 if (unlikely((us->fflags & US_FL_INITIAL_READ10) &&
831 srb->cmnd[0] == READ_10)) {
832 if (srb->result == SAM_STAT_GOOD) {
833 set_bit(US_FLIDX_READ10_WORKED, &us->dflags);
834 } else if (test_bit(US_FLIDX_READ10_WORKED, &us->dflags)) {
835 clear_bit(US_FLIDX_READ10_WORKED, &us->dflags);
836 set_bit(US_FLIDX_REDO_READ10, &us->dflags);
837 }
838
839 /*
840 * Next, if the REDO_READ10 flag is set, return a result
841 * code that will cause the SCSI core to retry the READ(10)
842 * command immediately.
843 */
844 if (test_bit(US_FLIDX_REDO_READ10, &us->dflags)) {
845 clear_bit(US_FLIDX_REDO_READ10, &us->dflags);
846 srb->result = DID_IMM_RETRY << 16;
847 srb->sense_buffer[0] = 0;
848 }
849 }
850
822 /* Did we transfer less than the minimum amount required? */ 851 /* Did we transfer less than the minimum amount required? */
823 if ((srb->result == SAM_STAT_GOOD || srb->sense_buffer[2] == 0) && 852 if ((srb->result == SAM_STAT_GOOD || srb->sense_buffer[2] == 0) &&
824 scsi_bufflen(srb) - scsi_get_resid(srb) < srb->underflow) 853 scsi_bufflen(srb) - scsi_get_resid(srb) < srb->underflow)
@@ -926,7 +955,7 @@ int usb_stor_CB_transport(struct scsi_cmnd *srb, struct us_data *us)
926 /* NOTE: CB does not have a status stage. Silly, I know. So 955 /* NOTE: CB does not have a status stage. Silly, I know. So
927 * we have to catch this at a higher level. 956 * we have to catch this at a higher level.
928 */ 957 */
929 if (us->protocol != US_PR_CBI) 958 if (us->protocol != USB_PR_CBI)
930 return USB_STOR_TRANSPORT_GOOD; 959 return USB_STOR_TRANSPORT_GOOD;
931 960
932 result = usb_stor_intr_transfer(us, us->iobuf, 2); 961 result = usb_stor_intr_transfer(us, us->iobuf, 2);
@@ -942,7 +971,7 @@ int usb_stor_CB_transport(struct scsi_cmnd *srb, struct us_data *us)
942 * that this means we could be ignoring a real error on these 971 * that this means we could be ignoring a real error on these
943 * commands, but that can't be helped. 972 * commands, but that can't be helped.
944 */ 973 */
945 if (us->subclass == US_SC_UFI) { 974 if (us->subclass == USB_SC_UFI) {
946 if (srb->cmnd[0] == REQUEST_SENSE || 975 if (srb->cmnd[0] == REQUEST_SENSE ||
947 srb->cmnd[0] == INQUIRY) 976 srb->cmnd[0] == INQUIRY)
948 return USB_STOR_TRANSPORT_GOOD; 977 return USB_STOR_TRANSPORT_GOOD;
diff --git a/drivers/usb/storage/uas.c b/drivers/usb/storage/uas.c
new file mode 100644
index 000000000000..23f0dd9c36d4
--- /dev/null
+++ b/drivers/usb/storage/uas.c
@@ -0,0 +1,776 @@
1/*
2 * USB Attached SCSI
3 * Note that this is not the same as the USB Mass Storage driver
4 *
5 * Copyright Matthew Wilcox for Intel Corp, 2010
6 * Copyright Sarah Sharp for Intel Corp, 2010
7 *
8 * Distributed under the terms of the GNU GPL, version two.
9 */
10
11#include <linux/blkdev.h>
12#include <linux/slab.h>
13#include <linux/types.h>
14#include <linux/usb.h>
15#include <linux/usb/storage.h>
16
17#include <scsi/scsi.h>
18#include <scsi/scsi_dbg.h>
19#include <scsi/scsi_cmnd.h>
20#include <scsi/scsi_device.h>
21#include <scsi/scsi_host.h>
22#include <scsi/scsi_tcq.h>
23
24/* Common header for all IUs */
25struct iu {
26 __u8 iu_id;
27 __u8 rsvd1;
28 __be16 tag;
29};
30
31enum {
32 IU_ID_COMMAND = 0x01,
33 IU_ID_STATUS = 0x03,
34 IU_ID_RESPONSE = 0x04,
35 IU_ID_TASK_MGMT = 0x05,
36 IU_ID_READ_READY = 0x06,
37 IU_ID_WRITE_READY = 0x07,
38};
39
40struct command_iu {
41 __u8 iu_id;
42 __u8 rsvd1;
43 __be16 tag;
44 __u8 prio_attr;
45 __u8 rsvd5;
46 __u8 len;
47 __u8 rsvd7;
48 struct scsi_lun lun;
49 __u8 cdb[16]; /* XXX: Overflow-checking tools may misunderstand */
50};
51
52/*
53 * Also used for the Read Ready and Write Ready IUs since they have the
54 * same first four bytes
55 */
56struct sense_iu {
57 __u8 iu_id;
58 __u8 rsvd1;
59 __be16 tag;
60 __be16 status_qual;
61 __u8 status;
62 __u8 rsvd7[7];
63 __be16 len;
64 __u8 sense[SCSI_SENSE_BUFFERSIZE];
65};
66
67/*
68 * The r00-r01c specs define this version of the SENSE IU data structure.
69 * It's still in use by several different firmware releases.
70 */
71struct sense_iu_old {
72 __u8 iu_id;
73 __u8 rsvd1;
74 __be16 tag;
75 __be16 len;
76 __u8 status;
77 __u8 service_response;
78 __u8 sense[SCSI_SENSE_BUFFERSIZE];
79};
80
81enum {
82 CMD_PIPE_ID = 1,
83 STATUS_PIPE_ID = 2,
84 DATA_IN_PIPE_ID = 3,
85 DATA_OUT_PIPE_ID = 4,
86
87 UAS_SIMPLE_TAG = 0,
88 UAS_HEAD_TAG = 1,
89 UAS_ORDERED_TAG = 2,
90 UAS_ACA = 4,
91};
92
93struct uas_dev_info {
94 struct usb_interface *intf;
95 struct usb_device *udev;
96 int qdepth;
97 unsigned cmd_pipe, status_pipe, data_in_pipe, data_out_pipe;
98 unsigned use_streams:1;
99 unsigned uas_sense_old:1;
100};
101
102enum {
103 ALLOC_STATUS_URB = (1 << 0),
104 SUBMIT_STATUS_URB = (1 << 1),
105 ALLOC_DATA_IN_URB = (1 << 2),
106 SUBMIT_DATA_IN_URB = (1 << 3),
107 ALLOC_DATA_OUT_URB = (1 << 4),
108 SUBMIT_DATA_OUT_URB = (1 << 5),
109 ALLOC_CMD_URB = (1 << 6),
110 SUBMIT_CMD_URB = (1 << 7),
111};
112
113/* Overrides scsi_pointer */
114struct uas_cmd_info {
115 unsigned int state;
116 unsigned int stream;
117 struct urb *cmd_urb;
118 struct urb *status_urb;
119 struct urb *data_in_urb;
120 struct urb *data_out_urb;
121 struct list_head list;
122};
123
124/* I hate forward declarations, but I actually have a loop */
125static int uas_submit_urbs(struct scsi_cmnd *cmnd,
126 struct uas_dev_info *devinfo, gfp_t gfp);
127
128static DEFINE_SPINLOCK(uas_work_lock);
129static LIST_HEAD(uas_work_list);
130
131static void uas_do_work(struct work_struct *work)
132{
133 struct uas_cmd_info *cmdinfo;
134 struct list_head list;
135
136 spin_lock_irq(&uas_work_lock);
137 list_replace_init(&uas_work_list, &list);
138 spin_unlock_irq(&uas_work_lock);
139
140 list_for_each_entry(cmdinfo, &list, list) {
141 struct scsi_pointer *scp = (void *)cmdinfo;
142 struct scsi_cmnd *cmnd = container_of(scp,
143 struct scsi_cmnd, SCp);
144 uas_submit_urbs(cmnd, cmnd->device->hostdata, GFP_NOIO);
145 }
146}
147
148static DECLARE_WORK(uas_work, uas_do_work);
149
150static void uas_sense(struct urb *urb, struct scsi_cmnd *cmnd)
151{
152 struct sense_iu *sense_iu = urb->transfer_buffer;
153 struct scsi_device *sdev = cmnd->device;
154
155 if (urb->actual_length > 16) {
156 unsigned len = be16_to_cpup(&sense_iu->len);
157 if (len + 16 != urb->actual_length) {
158 int newlen = min(len + 16, urb->actual_length) - 16;
159 if (newlen < 0)
160 newlen = 0;
161 sdev_printk(KERN_INFO, sdev, "%s: urb length %d "
162 "disagrees with IU sense data length %d, "
163 "using %d bytes of sense data\n", __func__,
164 urb->actual_length, len, newlen);
165 len = newlen;
166 }
167 memcpy(cmnd->sense_buffer, sense_iu->sense, len);
168 }
169
170 cmnd->result = sense_iu->status;
171 if (sdev->current_cmnd)
172 sdev->current_cmnd = NULL;
173 cmnd->scsi_done(cmnd);
174 usb_free_urb(urb);
175}
176
177static void uas_sense_old(struct urb *urb, struct scsi_cmnd *cmnd)
178{
179 struct sense_iu_old *sense_iu = urb->transfer_buffer;
180 struct scsi_device *sdev = cmnd->device;
181
182 if (urb->actual_length > 8) {
183 unsigned len = be16_to_cpup(&sense_iu->len) - 2;
184 if (len + 8 != urb->actual_length) {
185 int newlen = min(len + 8, urb->actual_length) - 8;
186 if (newlen < 0)
187 newlen = 0;
188 sdev_printk(KERN_INFO, sdev, "%s: urb length %d "
189 "disagrees with IU sense data length %d, "
190 "using %d bytes of sense data\n", __func__,
191 urb->actual_length, len, newlen);
192 len = newlen;
193 }
194 memcpy(cmnd->sense_buffer, sense_iu->sense, len);
195 }
196
197 cmnd->result = sense_iu->status;
198 if (sdev->current_cmnd)
199 sdev->current_cmnd = NULL;
200 cmnd->scsi_done(cmnd);
201 usb_free_urb(urb);
202}
203
204static void uas_xfer_data(struct urb *urb, struct scsi_cmnd *cmnd,
205 unsigned direction)
206{
207 struct uas_cmd_info *cmdinfo = (void *)&cmnd->SCp;
208 int err;
209
210 cmdinfo->state = direction | SUBMIT_STATUS_URB;
211 err = uas_submit_urbs(cmnd, cmnd->device->hostdata, GFP_ATOMIC);
212 if (err) {
213 spin_lock(&uas_work_lock);
214 list_add_tail(&cmdinfo->list, &uas_work_list);
215 spin_unlock(&uas_work_lock);
216 schedule_work(&uas_work);
217 }
218}
219
220static void uas_stat_cmplt(struct urb *urb)
221{
222 struct iu *iu = urb->transfer_buffer;
223 struct scsi_device *sdev = urb->context;
224 struct uas_dev_info *devinfo = sdev->hostdata;
225 struct scsi_cmnd *cmnd;
226 u16 tag;
227
228 if (urb->status) {
229 dev_err(&urb->dev->dev, "URB BAD STATUS %d\n", urb->status);
230 usb_free_urb(urb);
231 return;
232 }
233
234 tag = be16_to_cpup(&iu->tag) - 1;
235 if (sdev->current_cmnd)
236 cmnd = sdev->current_cmnd;
237 else
238 cmnd = scsi_find_tag(sdev, tag);
239 if (!cmnd)
240 return;
241
242 switch (iu->iu_id) {
243 case IU_ID_STATUS:
244 if (urb->actual_length < 16)
245 devinfo->uas_sense_old = 1;
246 if (devinfo->uas_sense_old)
247 uas_sense_old(urb, cmnd);
248 else
249 uas_sense(urb, cmnd);
250 break;
251 case IU_ID_READ_READY:
252 uas_xfer_data(urb, cmnd, SUBMIT_DATA_IN_URB);
253 break;
254 case IU_ID_WRITE_READY:
255 uas_xfer_data(urb, cmnd, SUBMIT_DATA_OUT_URB);
256 break;
257 default:
258 scmd_printk(KERN_ERR, cmnd,
259 "Bogus IU (%d) received on status pipe\n", iu->iu_id);
260 }
261}
262
263static void uas_data_cmplt(struct urb *urb)
264{
265 struct scsi_data_buffer *sdb = urb->context;
266 sdb->resid = sdb->length - urb->actual_length;
267 usb_free_urb(urb);
268}
269
270static struct urb *uas_alloc_data_urb(struct uas_dev_info *devinfo, gfp_t gfp,
271 unsigned int pipe, u16 stream_id,
272 struct scsi_data_buffer *sdb,
273 enum dma_data_direction dir)
274{
275 struct usb_device *udev = devinfo->udev;
276 struct urb *urb = usb_alloc_urb(0, gfp);
277
278 if (!urb)
279 goto out;
280 usb_fill_bulk_urb(urb, udev, pipe, NULL, sdb->length, uas_data_cmplt,
281 sdb);
282 if (devinfo->use_streams)
283 urb->stream_id = stream_id;
284 urb->num_sgs = udev->bus->sg_tablesize ? sdb->table.nents : 0;
285 urb->sg = sdb->table.sgl;
286 out:
287 return urb;
288}
289
290static struct urb *uas_alloc_sense_urb(struct uas_dev_info *devinfo, gfp_t gfp,
291 struct scsi_cmnd *cmnd, u16 stream_id)
292{
293 struct usb_device *udev = devinfo->udev;
294 struct urb *urb = usb_alloc_urb(0, gfp);
295 struct sense_iu *iu;
296
297 if (!urb)
298 goto out;
299
300 iu = kzalloc(sizeof(*iu), gfp);
301 if (!iu)
302 goto free;
303
304 usb_fill_bulk_urb(urb, udev, devinfo->status_pipe, iu, sizeof(*iu),
305 uas_stat_cmplt, cmnd->device);
306 urb->stream_id = stream_id;
307 urb->transfer_flags |= URB_FREE_BUFFER;
308 out:
309 return urb;
310 free:
311 usb_free_urb(urb);
312 return NULL;
313}
314
315static struct urb *uas_alloc_cmd_urb(struct uas_dev_info *devinfo, gfp_t gfp,
316 struct scsi_cmnd *cmnd, u16 stream_id)
317{
318 struct usb_device *udev = devinfo->udev;
319 struct scsi_device *sdev = cmnd->device;
320 struct urb *urb = usb_alloc_urb(0, gfp);
321 struct command_iu *iu;
322 int len;
323
324 if (!urb)
325 goto out;
326
327 len = cmnd->cmd_len - 16;
328 if (len < 0)
329 len = 0;
330 len = ALIGN(len, 4);
331 iu = kzalloc(sizeof(*iu) + len, gfp);
332 if (!iu)
333 goto free;
334
335 iu->iu_id = IU_ID_COMMAND;
336 iu->tag = cpu_to_be16(stream_id);
337 iu->prio_attr = UAS_SIMPLE_TAG;
338 iu->len = len;
339 int_to_scsilun(sdev->lun, &iu->lun);
340 memcpy(iu->cdb, cmnd->cmnd, cmnd->cmd_len);
341
342 usb_fill_bulk_urb(urb, udev, devinfo->cmd_pipe, iu, sizeof(*iu) + len,
343 usb_free_urb, NULL);
344 urb->transfer_flags |= URB_FREE_BUFFER;
345 out:
346 return urb;
347 free:
348 usb_free_urb(urb);
349 return NULL;
350}
351
352/*
353 * Why should I request the Status IU before sending the Command IU? Spec
354 * says to, but also says the device may receive them in any order. Seems
355 * daft to me.
356 */
357
358static int uas_submit_urbs(struct scsi_cmnd *cmnd,
359 struct uas_dev_info *devinfo, gfp_t gfp)
360{
361 struct uas_cmd_info *cmdinfo = (void *)&cmnd->SCp;
362
363 if (cmdinfo->state & ALLOC_STATUS_URB) {
364 cmdinfo->status_urb = uas_alloc_sense_urb(devinfo, gfp, cmnd,
365 cmdinfo->stream);
366 if (!cmdinfo->status_urb)
367 return SCSI_MLQUEUE_DEVICE_BUSY;
368 cmdinfo->state &= ~ALLOC_STATUS_URB;
369 }
370
371 if (cmdinfo->state & SUBMIT_STATUS_URB) {
372 if (usb_submit_urb(cmdinfo->status_urb, gfp)) {
373 scmd_printk(KERN_INFO, cmnd,
374 "sense urb submission failure\n");
375 return SCSI_MLQUEUE_DEVICE_BUSY;
376 }
377 cmdinfo->state &= ~SUBMIT_STATUS_URB;
378 }
379
380 if (cmdinfo->state & ALLOC_DATA_IN_URB) {
381 cmdinfo->data_in_urb = uas_alloc_data_urb(devinfo, gfp,
382 devinfo->data_in_pipe, cmdinfo->stream,
383 scsi_in(cmnd), DMA_FROM_DEVICE);
384 if (!cmdinfo->data_in_urb)
385 return SCSI_MLQUEUE_DEVICE_BUSY;
386 cmdinfo->state &= ~ALLOC_DATA_IN_URB;
387 }
388
389 if (cmdinfo->state & SUBMIT_DATA_IN_URB) {
390 if (usb_submit_urb(cmdinfo->data_in_urb, gfp)) {
391 scmd_printk(KERN_INFO, cmnd,
392 "data in urb submission failure\n");
393 return SCSI_MLQUEUE_DEVICE_BUSY;
394 }
395 cmdinfo->state &= ~SUBMIT_DATA_IN_URB;
396 }
397
398 if (cmdinfo->state & ALLOC_DATA_OUT_URB) {
399 cmdinfo->data_out_urb = uas_alloc_data_urb(devinfo, gfp,
400 devinfo->data_out_pipe, cmdinfo->stream,
401 scsi_out(cmnd), DMA_TO_DEVICE);
402 if (!cmdinfo->data_out_urb)
403 return SCSI_MLQUEUE_DEVICE_BUSY;
404 cmdinfo->state &= ~ALLOC_DATA_OUT_URB;
405 }
406
407 if (cmdinfo->state & SUBMIT_DATA_OUT_URB) {
408 if (usb_submit_urb(cmdinfo->data_out_urb, gfp)) {
409 scmd_printk(KERN_INFO, cmnd,
410 "data out urb submission failure\n");
411 return SCSI_MLQUEUE_DEVICE_BUSY;
412 }
413 cmdinfo->state &= ~SUBMIT_DATA_OUT_URB;
414 }
415
416 if (cmdinfo->state & ALLOC_CMD_URB) {
417 cmdinfo->cmd_urb = uas_alloc_cmd_urb(devinfo, gfp, cmnd,
418 cmdinfo->stream);
419 if (!cmdinfo->cmd_urb)
420 return SCSI_MLQUEUE_DEVICE_BUSY;
421 cmdinfo->state &= ~ALLOC_CMD_URB;
422 }
423
424 if (cmdinfo->state & SUBMIT_CMD_URB) {
425 if (usb_submit_urb(cmdinfo->cmd_urb, gfp)) {
426 scmd_printk(KERN_INFO, cmnd,
427 "cmd urb submission failure\n");
428 return SCSI_MLQUEUE_DEVICE_BUSY;
429 }
430 cmdinfo->state &= ~SUBMIT_CMD_URB;
431 }
432
433 return 0;
434}
435
436static int uas_queuecommand_lck(struct scsi_cmnd *cmnd,
437 void (*done)(struct scsi_cmnd *))
438{
439 struct scsi_device *sdev = cmnd->device;
440 struct uas_dev_info *devinfo = sdev->hostdata;
441 struct uas_cmd_info *cmdinfo = (void *)&cmnd->SCp;
442 int err;
443
444 BUILD_BUG_ON(sizeof(struct uas_cmd_info) > sizeof(struct scsi_pointer));
445
446 if (!cmdinfo->status_urb && sdev->current_cmnd)
447 return SCSI_MLQUEUE_DEVICE_BUSY;
448
449 if (blk_rq_tagged(cmnd->request)) {
450 cmdinfo->stream = cmnd->request->tag + 1;
451 } else {
452 sdev->current_cmnd = cmnd;
453 cmdinfo->stream = 1;
454 }
455
456 cmnd->scsi_done = done;
457
458 cmdinfo->state = ALLOC_STATUS_URB | SUBMIT_STATUS_URB |
459 ALLOC_CMD_URB | SUBMIT_CMD_URB;
460
461 switch (cmnd->sc_data_direction) {
462 case DMA_FROM_DEVICE:
463 cmdinfo->state |= ALLOC_DATA_IN_URB | SUBMIT_DATA_IN_URB;
464 break;
465 case DMA_BIDIRECTIONAL:
466 cmdinfo->state |= ALLOC_DATA_IN_URB | SUBMIT_DATA_IN_URB;
467 case DMA_TO_DEVICE:
468 cmdinfo->state |= ALLOC_DATA_OUT_URB | SUBMIT_DATA_OUT_URB;
469 case DMA_NONE:
470 break;
471 }
472
473 if (!devinfo->use_streams) {
474 cmdinfo->state &= ~(SUBMIT_DATA_IN_URB | SUBMIT_DATA_OUT_URB);
475 cmdinfo->stream = 0;
476 }
477
478 err = uas_submit_urbs(cmnd, devinfo, GFP_ATOMIC);
479 if (err) {
480 /* If we did nothing, give up now */
481 if (cmdinfo->state & SUBMIT_STATUS_URB) {
482 usb_free_urb(cmdinfo->status_urb);
483 return SCSI_MLQUEUE_DEVICE_BUSY;
484 }
485 spin_lock(&uas_work_lock);
486 list_add_tail(&cmdinfo->list, &uas_work_list);
487 spin_unlock(&uas_work_lock);
488 schedule_work(&uas_work);
489 }
490
491 return 0;
492}
493
494static DEF_SCSI_QCMD(uas_queuecommand)
495
496static int uas_eh_abort_handler(struct scsi_cmnd *cmnd)
497{
498 struct scsi_device *sdev = cmnd->device;
499 sdev_printk(KERN_INFO, sdev, "%s tag %d\n", __func__,
500 cmnd->request->tag);
501
502/* XXX: Send ABORT TASK Task Management command */
503 return FAILED;
504}
505
506static int uas_eh_device_reset_handler(struct scsi_cmnd *cmnd)
507{
508 struct scsi_device *sdev = cmnd->device;
509 sdev_printk(KERN_INFO, sdev, "%s tag %d\n", __func__,
510 cmnd->request->tag);
511
512/* XXX: Send LOGICAL UNIT RESET Task Management command */
513 return FAILED;
514}
515
516static int uas_eh_target_reset_handler(struct scsi_cmnd *cmnd)
517{
518 struct scsi_device *sdev = cmnd->device;
519 sdev_printk(KERN_INFO, sdev, "%s tag %d\n", __func__,
520 cmnd->request->tag);
521
522/* XXX: Can we reset just the one USB interface?
523 * Would calling usb_set_interface() have the right effect?
524 */
525 return FAILED;
526}
527
528static int uas_eh_bus_reset_handler(struct scsi_cmnd *cmnd)
529{
530 struct scsi_device *sdev = cmnd->device;
531 struct uas_dev_info *devinfo = sdev->hostdata;
532 struct usb_device *udev = devinfo->udev;
533
534 sdev_printk(KERN_INFO, sdev, "%s tag %d\n", __func__,
535 cmnd->request->tag);
536
537 if (usb_reset_device(udev))
538 return SUCCESS;
539
540 return FAILED;
541}
542
543static int uas_slave_alloc(struct scsi_device *sdev)
544{
545 sdev->hostdata = (void *)sdev->host->hostdata[0];
546 return 0;
547}
548
549static int uas_slave_configure(struct scsi_device *sdev)
550{
551 struct uas_dev_info *devinfo = sdev->hostdata;
552 scsi_set_tag_type(sdev, MSG_ORDERED_TAG);
553 scsi_activate_tcq(sdev, devinfo->qdepth - 1);
554 return 0;
555}
556
557static struct scsi_host_template uas_host_template = {
558 .module = THIS_MODULE,
559 .name = "uas",
560 .queuecommand = uas_queuecommand,
561 .slave_alloc = uas_slave_alloc,
562 .slave_configure = uas_slave_configure,
563 .eh_abort_handler = uas_eh_abort_handler,
564 .eh_device_reset_handler = uas_eh_device_reset_handler,
565 .eh_target_reset_handler = uas_eh_target_reset_handler,
566 .eh_bus_reset_handler = uas_eh_bus_reset_handler,
567 .can_queue = 65536, /* Is there a limit on the _host_ ? */
568 .this_id = -1,
569 .sg_tablesize = SG_NONE,
570 .cmd_per_lun = 1, /* until we override it */
571 .skip_settle_delay = 1,
572 .ordered_tag = 1,
573};
574
575static struct usb_device_id uas_usb_ids[] = {
576 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, USB_SC_SCSI, USB_PR_BULK) },
577 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, USB_SC_SCSI, USB_PR_UAS) },
578 /* 0xaa is a prototype device I happen to have access to */
579 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, USB_SC_SCSI, 0xaa) },
580 { }
581};
582MODULE_DEVICE_TABLE(usb, uas_usb_ids);
583
584static int uas_is_interface(struct usb_host_interface *intf)
585{
586 return (intf->desc.bInterfaceClass == USB_CLASS_MASS_STORAGE &&
587 intf->desc.bInterfaceSubClass == USB_SC_SCSI &&
588 intf->desc.bInterfaceProtocol == USB_PR_UAS);
589}
590
591static int uas_switch_interface(struct usb_device *udev,
592 struct usb_interface *intf)
593{
594 int i;
595
596 if (uas_is_interface(intf->cur_altsetting))
597 return 0;
598
599 for (i = 0; i < intf->num_altsetting; i++) {
600 struct usb_host_interface *alt = &intf->altsetting[i];
601 if (alt == intf->cur_altsetting)
602 continue;
603 if (uas_is_interface(alt))
604 return usb_set_interface(udev,
605 alt->desc.bInterfaceNumber,
606 alt->desc.bAlternateSetting);
607 }
608
609 return -ENODEV;
610}
611
612static void uas_configure_endpoints(struct uas_dev_info *devinfo)
613{
614 struct usb_host_endpoint *eps[4] = { };
615 struct usb_interface *intf = devinfo->intf;
616 struct usb_device *udev = devinfo->udev;
617 struct usb_host_endpoint *endpoint = intf->cur_altsetting->endpoint;
618 unsigned i, n_endpoints = intf->cur_altsetting->desc.bNumEndpoints;
619
620 devinfo->uas_sense_old = 0;
621
622 for (i = 0; i < n_endpoints; i++) {
623 unsigned char *extra = endpoint[i].extra;
624 int len = endpoint[i].extralen;
625 while (len > 1) {
626 if (extra[1] == USB_DT_PIPE_USAGE) {
627 unsigned pipe_id = extra[2];
628 if (pipe_id > 0 && pipe_id < 5)
629 eps[pipe_id - 1] = &endpoint[i];
630 break;
631 }
632 len -= extra[0];
633 extra += extra[0];
634 }
635 }
636
637 /*
638 * Assume that if we didn't find a control pipe descriptor, we're
639 * using a device with old firmware that happens to be set up like
640 * this.
641 */
642 if (!eps[0]) {
643 devinfo->cmd_pipe = usb_sndbulkpipe(udev, 1);
644 devinfo->status_pipe = usb_rcvbulkpipe(udev, 1);
645 devinfo->data_in_pipe = usb_rcvbulkpipe(udev, 2);
646 devinfo->data_out_pipe = usb_sndbulkpipe(udev, 2);
647
648 eps[1] = usb_pipe_endpoint(udev, devinfo->status_pipe);
649 eps[2] = usb_pipe_endpoint(udev, devinfo->data_in_pipe);
650 eps[3] = usb_pipe_endpoint(udev, devinfo->data_out_pipe);
651 } else {
652 devinfo->cmd_pipe = usb_sndbulkpipe(udev,
653 eps[0]->desc.bEndpointAddress);
654 devinfo->status_pipe = usb_rcvbulkpipe(udev,
655 eps[1]->desc.bEndpointAddress);
656 devinfo->data_in_pipe = usb_rcvbulkpipe(udev,
657 eps[2]->desc.bEndpointAddress);
658 devinfo->data_out_pipe = usb_sndbulkpipe(udev,
659 eps[3]->desc.bEndpointAddress);
660 }
661
662 devinfo->qdepth = usb_alloc_streams(devinfo->intf, eps + 1, 3, 256,
663 GFP_KERNEL);
664 if (devinfo->qdepth < 0) {
665 devinfo->qdepth = 256;
666 devinfo->use_streams = 0;
667 } else {
668 devinfo->use_streams = 1;
669 }
670}
671
672/*
673 * XXX: What I'd like to do here is register a SCSI host for each USB host in
674 * the system. Follow usb-storage's design of registering a SCSI host for
675 * each USB device for the moment. Can implement this by walking up the
676 * USB hierarchy until we find a USB host.
677 */
678static int uas_probe(struct usb_interface *intf, const struct usb_device_id *id)
679{
680 int result;
681 struct Scsi_Host *shost;
682 struct uas_dev_info *devinfo;
683 struct usb_device *udev = interface_to_usbdev(intf);
684
685 if (uas_switch_interface(udev, intf))
686 return -ENODEV;
687
688 devinfo = kmalloc(sizeof(struct uas_dev_info), GFP_KERNEL);
689 if (!devinfo)
690 return -ENOMEM;
691
692 result = -ENOMEM;
693 shost = scsi_host_alloc(&uas_host_template, sizeof(void *));
694 if (!shost)
695 goto free;
696
697 shost->max_cmd_len = 16 + 252;
698 shost->max_id = 1;
699 shost->sg_tablesize = udev->bus->sg_tablesize;
700
701 result = scsi_add_host(shost, &intf->dev);
702 if (result)
703 goto free;
704 shost->hostdata[0] = (unsigned long)devinfo;
705
706 devinfo->intf = intf;
707 devinfo->udev = udev;
708 uas_configure_endpoints(devinfo);
709
710 scsi_scan_host(shost);
711 usb_set_intfdata(intf, shost);
712 return result;
713 free:
714 kfree(devinfo);
715 if (shost)
716 scsi_host_put(shost);
717 return result;
718}
719
720static int uas_pre_reset(struct usb_interface *intf)
721{
722/* XXX: Need to return 1 if it's not our device in error handling */
723 return 0;
724}
725
726static int uas_post_reset(struct usb_interface *intf)
727{
728/* XXX: Need to return 1 if it's not our device in error handling */
729 return 0;
730}
731
732static void uas_disconnect(struct usb_interface *intf)
733{
734 struct usb_device *udev = interface_to_usbdev(intf);
735 struct usb_host_endpoint *eps[3];
736 struct Scsi_Host *shost = usb_get_intfdata(intf);
737 struct uas_dev_info *devinfo = (void *)shost->hostdata[0];
738
739 scsi_remove_host(shost);
740
741 eps[0] = usb_pipe_endpoint(udev, devinfo->status_pipe);
742 eps[1] = usb_pipe_endpoint(udev, devinfo->data_in_pipe);
743 eps[2] = usb_pipe_endpoint(udev, devinfo->data_out_pipe);
744 usb_free_streams(intf, eps, 3, GFP_KERNEL);
745
746 kfree(devinfo);
747}
748
749/*
750 * XXX: Should this plug into libusual so we can auto-upgrade devices from
751 * Bulk-Only to UAS?
752 */
753static struct usb_driver uas_driver = {
754 .name = "uas",
755 .probe = uas_probe,
756 .disconnect = uas_disconnect,
757 .pre_reset = uas_pre_reset,
758 .post_reset = uas_post_reset,
759 .id_table = uas_usb_ids,
760};
761
762static int uas_init(void)
763{
764 return usb_register(&uas_driver);
765}
766
767static void uas_exit(void)
768{
769 usb_deregister(&uas_driver);
770}
771
772module_init(uas_init);
773module_exit(uas_exit);
774
775MODULE_LICENSE("GPL");
776MODULE_AUTHOR("Matthew Wilcox and Sarah Sharp");
diff --git a/drivers/usb/storage/unusual_alauda.h b/drivers/usb/storage/unusual_alauda.h
index 8c412f885dd2..fa3e9edaa2cf 100644
--- a/drivers/usb/storage/unusual_alauda.h
+++ b/drivers/usb/storage/unusual_alauda.h
@@ -21,11 +21,11 @@
21UNUSUAL_DEV( 0x0584, 0x0008, 0x0102, 0x0102, 21UNUSUAL_DEV( 0x0584, 0x0008, 0x0102, 0x0102,
22 "Fujifilm", 22 "Fujifilm",
23 "DPC-R1 (Alauda)", 23 "DPC-R1 (Alauda)",
24 US_SC_SCSI, US_PR_ALAUDA, init_alauda, 0), 24 USB_SC_SCSI, USB_PR_ALAUDA, init_alauda, 0),
25 25
26UNUSUAL_DEV( 0x07b4, 0x010a, 0x0102, 0x0102, 26UNUSUAL_DEV( 0x07b4, 0x010a, 0x0102, 0x0102,
27 "Olympus", 27 "Olympus",
28 "MAUSB-10 (Alauda)", 28 "MAUSB-10 (Alauda)",
29 US_SC_SCSI, US_PR_ALAUDA, init_alauda, 0), 29 USB_SC_SCSI, USB_PR_ALAUDA, init_alauda, 0),
30 30
31#endif /* defined(CONFIG_USB_STORAGE_ALAUDA) || ... */ 31#endif /* defined(CONFIG_USB_STORAGE_ALAUDA) || ... */
diff --git a/drivers/usb/storage/unusual_cypress.h b/drivers/usb/storage/unusual_cypress.h
index 44be6d75dab6..2c8553026222 100644
--- a/drivers/usb/storage/unusual_cypress.h
+++ b/drivers/usb/storage/unusual_cypress.h
@@ -23,12 +23,17 @@
23UNUSUAL_DEV( 0x04b4, 0x6830, 0x0000, 0x9999, 23UNUSUAL_DEV( 0x04b4, 0x6830, 0x0000, 0x9999,
24 "Cypress", 24 "Cypress",
25 "Cypress AT2LP", 25 "Cypress AT2LP",
26 US_SC_CYP_ATACB, US_PR_DEVICE, NULL, 0), 26 USB_SC_CYP_ATACB, USB_PR_DEVICE, NULL, 0),
27 27
28/* CY7C68310 : support atacb and atacb2 */ 28/* CY7C68310 : support atacb and atacb2 */
29UNUSUAL_DEV( 0x04b4, 0x6831, 0x0000, 0x9999, 29UNUSUAL_DEV( 0x04b4, 0x6831, 0x0000, 0x9999,
30 "Cypress", 30 "Cypress",
31 "Cypress ISD-300LP", 31 "Cypress ISD-300LP",
32 US_SC_CYP_ATACB, US_PR_DEVICE, NULL, 0), 32 USB_SC_CYP_ATACB, USB_PR_DEVICE, NULL, 0),
33
34UNUSUAL_DEV( 0x14cd, 0x6116, 0x0000, 0x9999,
35 "Super Top",
36 "USB 2.0 SATA BRIDGE",
37 USB_SC_CYP_ATACB, USB_PR_DEVICE, NULL, 0),
33 38
34#endif /* defined(CONFIG_USB_STORAGE_CYPRESS_ATACB) || ... */ 39#endif /* defined(CONFIG_USB_STORAGE_CYPRESS_ATACB) || ... */
diff --git a/drivers/usb/storage/unusual_datafab.h b/drivers/usb/storage/unusual_datafab.h
index c9298ce9f223..582a603c78be 100644
--- a/drivers/usb/storage/unusual_datafab.h
+++ b/drivers/usb/storage/unusual_datafab.h
@@ -21,7 +21,7 @@
21UNUSUAL_DEV( 0x07c4, 0xa000, 0x0000, 0x0015, 21UNUSUAL_DEV( 0x07c4, 0xa000, 0x0000, 0x0015,
22 "Datafab", 22 "Datafab",
23 "MDCFE-B USB CF Reader", 23 "MDCFE-B USB CF Reader",
24 US_SC_SCSI, US_PR_DATAFAB, NULL, 24 USB_SC_SCSI, USB_PR_DATAFAB, NULL,
25 0), 25 0),
26 26
27/* 27/*
@@ -38,45 +38,45 @@ UNUSUAL_DEV( 0x07c4, 0xa000, 0x0000, 0x0015,
38UNUSUAL_DEV( 0x07c4, 0xa001, 0x0000, 0xffff, 38UNUSUAL_DEV( 0x07c4, 0xa001, 0x0000, 0xffff,
39 "SIIG/Datafab", 39 "SIIG/Datafab",
40 "SIIG/Datafab Memory Stick+CF Reader/Writer", 40 "SIIG/Datafab Memory Stick+CF Reader/Writer",
41 US_SC_SCSI, US_PR_DATAFAB, NULL, 41 USB_SC_SCSI, USB_PR_DATAFAB, NULL,
42 0), 42 0),
43 43
44/* Reported by Josef Reisinger <josef.reisinger@netcologne.de> */ 44/* Reported by Josef Reisinger <josef.reisinger@netcologne.de> */
45UNUSUAL_DEV( 0x07c4, 0xa002, 0x0000, 0xffff, 45UNUSUAL_DEV( 0x07c4, 0xa002, 0x0000, 0xffff,
46 "Datafab/Unknown", 46 "Datafab/Unknown",
47 "MD2/MD3 Disk enclosure", 47 "MD2/MD3 Disk enclosure",
48 US_SC_SCSI, US_PR_DATAFAB, NULL, 48 USB_SC_SCSI, USB_PR_DATAFAB, NULL,
49 US_FL_SINGLE_LUN), 49 US_FL_SINGLE_LUN),
50 50
51UNUSUAL_DEV( 0x07c4, 0xa003, 0x0000, 0xffff, 51UNUSUAL_DEV( 0x07c4, 0xa003, 0x0000, 0xffff,
52 "Datafab/Unknown", 52 "Datafab/Unknown",
53 "Datafab-based Reader", 53 "Datafab-based Reader",
54 US_SC_SCSI, US_PR_DATAFAB, NULL, 54 USB_SC_SCSI, USB_PR_DATAFAB, NULL,
55 0), 55 0),
56 56
57UNUSUAL_DEV( 0x07c4, 0xa004, 0x0000, 0xffff, 57UNUSUAL_DEV( 0x07c4, 0xa004, 0x0000, 0xffff,
58 "Datafab/Unknown", 58 "Datafab/Unknown",
59 "Datafab-based Reader", 59 "Datafab-based Reader",
60 US_SC_SCSI, US_PR_DATAFAB, NULL, 60 USB_SC_SCSI, USB_PR_DATAFAB, NULL,
61 0), 61 0),
62 62
63UNUSUAL_DEV( 0x07c4, 0xa005, 0x0000, 0xffff, 63UNUSUAL_DEV( 0x07c4, 0xa005, 0x0000, 0xffff,
64 "PNY/Datafab", 64 "PNY/Datafab",
65 "PNY/Datafab CF+SM Reader", 65 "PNY/Datafab CF+SM Reader",
66 US_SC_SCSI, US_PR_DATAFAB, NULL, 66 USB_SC_SCSI, USB_PR_DATAFAB, NULL,
67 0), 67 0),
68 68
69UNUSUAL_DEV( 0x07c4, 0xa006, 0x0000, 0xffff, 69UNUSUAL_DEV( 0x07c4, 0xa006, 0x0000, 0xffff,
70 "Simple Tech/Datafab", 70 "Simple Tech/Datafab",
71 "Simple Tech/Datafab CF+SM Reader", 71 "Simple Tech/Datafab CF+SM Reader",
72 US_SC_SCSI, US_PR_DATAFAB, NULL, 72 USB_SC_SCSI, USB_PR_DATAFAB, NULL,
73 0), 73 0),
74 74
75/* Submitted by Olaf Hering <olh@suse.de> */ 75/* Submitted by Olaf Hering <olh@suse.de> */
76UNUSUAL_DEV( 0x07c4, 0xa109, 0x0000, 0xffff, 76UNUSUAL_DEV( 0x07c4, 0xa109, 0x0000, 0xffff,
77 "Datafab Systems, Inc.", 77 "Datafab Systems, Inc.",
78 "USB to CF + SM Combo (LC1)", 78 "USB to CF + SM Combo (LC1)",
79 US_SC_SCSI, US_PR_DATAFAB, NULL, 79 USB_SC_SCSI, USB_PR_DATAFAB, NULL,
80 0), 80 0),
81 81
82/* Reported by Felix Moeller <felix@derklecks.de> 82/* Reported by Felix Moeller <felix@derklecks.de>
@@ -86,13 +86,13 @@ UNUSUAL_DEV( 0x07c4, 0xa109, 0x0000, 0xffff,
86UNUSUAL_DEV( 0x07c4, 0xa10b, 0x0000, 0xffff, 86UNUSUAL_DEV( 0x07c4, 0xa10b, 0x0000, 0xffff,
87 "DataFab Systems Inc.", 87 "DataFab Systems Inc.",
88 "USB CF+MS", 88 "USB CF+MS",
89 US_SC_SCSI, US_PR_DATAFAB, NULL, 89 USB_SC_SCSI, USB_PR_DATAFAB, NULL,
90 0), 90 0),
91 91
92UNUSUAL_DEV( 0x0c0b, 0xa109, 0x0000, 0xffff, 92UNUSUAL_DEV( 0x0c0b, 0xa109, 0x0000, 0xffff,
93 "Acomdata", 93 "Acomdata",
94 "CF", 94 "CF",
95 US_SC_SCSI, US_PR_DATAFAB, NULL, 95 USB_SC_SCSI, USB_PR_DATAFAB, NULL,
96 US_FL_SINGLE_LUN), 96 US_FL_SINGLE_LUN),
97 97
98#endif /* defined(CONFIG_USB_STORAGE_DATAFAB) || ... */ 98#endif /* defined(CONFIG_USB_STORAGE_DATAFAB) || ... */
diff --git a/drivers/usb/storage/unusual_devs.h b/drivers/usb/storage/unusual_devs.h
index 2c897eefadde..ccff3483eebc 100644
--- a/drivers/usb/storage/unusual_devs.h
+++ b/drivers/usb/storage/unusual_devs.h
@@ -63,26 +63,26 @@
63UNUSUAL_DEV( 0x03eb, 0x2002, 0x0100, 0x0100, 63UNUSUAL_DEV( 0x03eb, 0x2002, 0x0100, 0x0100,
64 "ATMEL", 64 "ATMEL",
65 "SND1 Storage", 65 "SND1 Storage",
66 US_SC_DEVICE, US_PR_DEVICE, NULL, 66 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
67 US_FL_IGNORE_RESIDUE), 67 US_FL_IGNORE_RESIDUE),
68 68
69/* Reported by Rodolfo Quesada <rquesada@roqz.net> */ 69/* Reported by Rodolfo Quesada <rquesada@roqz.net> */
70UNUSUAL_DEV( 0x03ee, 0x6906, 0x0003, 0x0003, 70UNUSUAL_DEV( 0x03ee, 0x6906, 0x0003, 0x0003,
71 "VIA Technologies Inc.", 71 "VIA Technologies Inc.",
72 "Mitsumi multi cardreader", 72 "Mitsumi multi cardreader",
73 US_SC_DEVICE, US_PR_DEVICE, NULL, 73 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
74 US_FL_IGNORE_RESIDUE ), 74 US_FL_IGNORE_RESIDUE ),
75 75
76UNUSUAL_DEV( 0x03f0, 0x0107, 0x0200, 0x0200, 76UNUSUAL_DEV( 0x03f0, 0x0107, 0x0200, 0x0200,
77 "HP", 77 "HP",
78 "CD-Writer+", 78 "CD-Writer+",
79 US_SC_8070, US_PR_CB, NULL, 0), 79 USB_SC_8070, USB_PR_CB, NULL, 0),
80 80
81/* Reported by Ben Efros <ben@pc-doctor.com> */ 81/* Reported by Ben Efros <ben@pc-doctor.com> */
82UNUSUAL_DEV( 0x03f0, 0x070c, 0x0000, 0x0000, 82UNUSUAL_DEV( 0x03f0, 0x070c, 0x0000, 0x0000,
83 "HP", 83 "HP",
84 "Personal Media Drive", 84 "Personal Media Drive",
85 US_SC_DEVICE, US_PR_DEVICE, NULL, 85 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
86 US_FL_SANE_SENSE ), 86 US_FL_SANE_SENSE ),
87 87
88/* Reported by Grant Grundler <grundler@parisc-linux.org> 88/* Reported by Grant Grundler <grundler@parisc-linux.org>
@@ -91,7 +91,7 @@ UNUSUAL_DEV( 0x03f0, 0x070c, 0x0000, 0x0000,
91UNUSUAL_DEV( 0x03f0, 0x4002, 0x0001, 0x0001, 91UNUSUAL_DEV( 0x03f0, 0x4002, 0x0001, 0x0001,
92 "HP", 92 "HP",
93 "PhotoSmart R707", 93 "PhotoSmart R707",
94 US_SC_DEVICE, US_PR_DEVICE, NULL, US_FL_FIX_CAPACITY), 94 USB_SC_DEVICE, USB_PR_DEVICE, NULL, US_FL_FIX_CAPACITY),
95 95
96/* Reported by Sebastian Kapfer <sebastian_kapfer@gmx.net> 96/* Reported by Sebastian Kapfer <sebastian_kapfer@gmx.net>
97 * and Olaf Hering <olh@suse.de> (different bcd's, same vendor/product) 97 * and Olaf Hering <olh@suse.de> (different bcd's, same vendor/product)
@@ -100,14 +100,14 @@ UNUSUAL_DEV( 0x03f0, 0x4002, 0x0001, 0x0001,
100UNUSUAL_DEV( 0x0409, 0x0040, 0x0000, 0x9999, 100UNUSUAL_DEV( 0x0409, 0x0040, 0x0000, 0x9999,
101 "NEC", 101 "NEC",
102 "NEC USB UF000x", 102 "NEC USB UF000x",
103 US_SC_DEVICE, US_PR_DEVICE, NULL, 103 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
104 US_FL_SINGLE_LUN ), 104 US_FL_SINGLE_LUN ),
105 105
106/* Patch submitted by Mihnea-Costin Grigore <mihnea@zulu.ro> */ 106/* Patch submitted by Mihnea-Costin Grigore <mihnea@zulu.ro> */
107UNUSUAL_DEV( 0x040d, 0x6205, 0x0003, 0x0003, 107UNUSUAL_DEV( 0x040d, 0x6205, 0x0003, 0x0003,
108 "VIA Technologies Inc.", 108 "VIA Technologies Inc.",
109 "USB 2.0 Card Reader", 109 "USB 2.0 Card Reader",
110 US_SC_DEVICE, US_PR_DEVICE, NULL, 110 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
111 US_FL_IGNORE_RESIDUE ), 111 US_FL_IGNORE_RESIDUE ),
112 112
113/* Deduced by Jonathan Woithe <jwoithe@physics.adelaide.edu.au> 113/* Deduced by Jonathan Woithe <jwoithe@physics.adelaide.edu.au>
@@ -117,40 +117,40 @@ UNUSUAL_DEV( 0x040d, 0x6205, 0x0003, 0x0003,
117UNUSUAL_DEV( 0x0411, 0x001c, 0x0113, 0x0113, 117UNUSUAL_DEV( 0x0411, 0x001c, 0x0113, 0x0113,
118 "Buffalo", 118 "Buffalo",
119 "DUB-P40G HDD", 119 "DUB-P40G HDD",
120 US_SC_DEVICE, US_PR_DEVICE, NULL, 120 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
121 US_FL_FIX_INQUIRY ), 121 US_FL_FIX_INQUIRY ),
122 122
123/* Submitted by Ernestas Vaiciukevicius <ernisv@gmail.com> */ 123/* Submitted by Ernestas Vaiciukevicius <ernisv@gmail.com> */
124UNUSUAL_DEV( 0x0419, 0x0100, 0x0100, 0x0100, 124UNUSUAL_DEV( 0x0419, 0x0100, 0x0100, 0x0100,
125 "Samsung Info. Systems America, Inc.", 125 "Samsung Info. Systems America, Inc.",
126 "MP3 Player", 126 "MP3 Player",
127 US_SC_DEVICE, US_PR_DEVICE, NULL, 127 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
128 US_FL_IGNORE_RESIDUE ), 128 US_FL_IGNORE_RESIDUE ),
129 129
130/* Reported by Orgad Shaneh <orgads@gmail.com> */ 130/* Reported by Orgad Shaneh <orgads@gmail.com> */
131UNUSUAL_DEV( 0x0419, 0xaace, 0x0100, 0x0100, 131UNUSUAL_DEV( 0x0419, 0xaace, 0x0100, 0x0100,
132 "Samsung", "MP3 Player", 132 "Samsung", "MP3 Player",
133 US_SC_DEVICE, US_PR_DEVICE, NULL, 133 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
134 US_FL_IGNORE_RESIDUE ), 134 US_FL_IGNORE_RESIDUE ),
135 135
136/* Reported by Christian Leber <christian@leber.de> */ 136/* Reported by Christian Leber <christian@leber.de> */
137UNUSUAL_DEV( 0x0419, 0xaaf5, 0x0100, 0x0100, 137UNUSUAL_DEV( 0x0419, 0xaaf5, 0x0100, 0x0100,
138 "TrekStor", 138 "TrekStor",
139 "i.Beat 115 2.0", 139 "i.Beat 115 2.0",
140 US_SC_DEVICE, US_PR_DEVICE, NULL, 140 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
141 US_FL_IGNORE_RESIDUE | US_FL_NOT_LOCKABLE ), 141 US_FL_IGNORE_RESIDUE | US_FL_NOT_LOCKABLE ),
142 142
143/* Reported by Stefan Werner <dustbln@gmx.de> */ 143/* Reported by Stefan Werner <dustbln@gmx.de> */
144UNUSUAL_DEV( 0x0419, 0xaaf6, 0x0100, 0x0100, 144UNUSUAL_DEV( 0x0419, 0xaaf6, 0x0100, 0x0100,
145 "TrekStor", 145 "TrekStor",
146 "i.Beat Joy 2.0", 146 "i.Beat Joy 2.0",
147 US_SC_DEVICE, US_PR_DEVICE, NULL, 147 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
148 US_FL_IGNORE_RESIDUE ), 148 US_FL_IGNORE_RESIDUE ),
149 149
150/* Reported by Pete Zaitcev <zaitcev@redhat.com>, bz#176584 */ 150/* Reported by Pete Zaitcev <zaitcev@redhat.com>, bz#176584 */
151UNUSUAL_DEV( 0x0420, 0x0001, 0x0100, 0x0100, 151UNUSUAL_DEV( 0x0420, 0x0001, 0x0100, 0x0100,
152 "GENERIC", "MP3 PLAYER", /* MyMusix PD-205 on the outside. */ 152 "GENERIC", "MP3 PLAYER", /* MyMusix PD-205 on the outside. */
153 US_SC_DEVICE, US_PR_DEVICE, NULL, 153 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
154 US_FL_IGNORE_RESIDUE ), 154 US_FL_IGNORE_RESIDUE ),
155 155
156/* Reported by Andrew Nayenko <relan@bk.ru> 156/* Reported by Andrew Nayenko <relan@bk.ru>
@@ -158,28 +158,28 @@ UNUSUAL_DEV( 0x0420, 0x0001, 0x0100, 0x0100,
158UNUSUAL_DEV( 0x0421, 0x0019, 0x0592, 0x0610, 158UNUSUAL_DEV( 0x0421, 0x0019, 0x0592, 0x0610,
159 "Nokia", 159 "Nokia",
160 "Nokia 6288", 160 "Nokia 6288",
161 US_SC_DEVICE, US_PR_DEVICE, NULL, 161 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
162 US_FL_MAX_SECTORS_64 ), 162 US_FL_MAX_SECTORS_64 ),
163 163
164/* Reported by Mario Rettig <mariorettig@web.de> */ 164/* Reported by Mario Rettig <mariorettig@web.de> */
165UNUSUAL_DEV( 0x0421, 0x042e, 0x0100, 0x0100, 165UNUSUAL_DEV( 0x0421, 0x042e, 0x0100, 0x0100,
166 "Nokia", 166 "Nokia",
167 "Nokia 3250", 167 "Nokia 3250",
168 US_SC_DEVICE, US_PR_DEVICE, NULL, 168 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
169 US_FL_IGNORE_RESIDUE | US_FL_FIX_CAPACITY ), 169 US_FL_IGNORE_RESIDUE | US_FL_FIX_CAPACITY ),
170 170
171/* Reported by <honkkis@gmail.com> */ 171/* Reported by <honkkis@gmail.com> */
172UNUSUAL_DEV( 0x0421, 0x0433, 0x0100, 0x0100, 172UNUSUAL_DEV( 0x0421, 0x0433, 0x0100, 0x0100,
173 "Nokia", 173 "Nokia",
174 "E70", 174 "E70",
175 US_SC_DEVICE, US_PR_DEVICE, NULL, 175 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
176 US_FL_IGNORE_RESIDUE | US_FL_FIX_CAPACITY ), 176 US_FL_IGNORE_RESIDUE | US_FL_FIX_CAPACITY ),
177 177
178/* Reported by Jon Hart <Jon.Hart@web.de> */ 178/* Reported by Jon Hart <Jon.Hart@web.de> */
179UNUSUAL_DEV( 0x0421, 0x0434, 0x0100, 0x0100, 179UNUSUAL_DEV( 0x0421, 0x0434, 0x0100, 0x0100,
180 "Nokia", 180 "Nokia",
181 "E60", 181 "E60",
182 US_SC_DEVICE, US_PR_DEVICE, NULL, 182 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
183 US_FL_FIX_CAPACITY | US_FL_IGNORE_RESIDUE ), 183 US_FL_FIX_CAPACITY | US_FL_IGNORE_RESIDUE ),
184 184
185/* Reported by Sumedha Swamy <sumedhaswamy@gmail.com> and 185/* Reported by Sumedha Swamy <sumedhaswamy@gmail.com> and
@@ -187,7 +187,7 @@ UNUSUAL_DEV( 0x0421, 0x0434, 0x0100, 0x0100,
187UNUSUAL_DEV( 0x0421, 0x0444, 0x0100, 0x0100, 187UNUSUAL_DEV( 0x0421, 0x0444, 0x0100, 0x0100,
188 "Nokia", 188 "Nokia",
189 "N91", 189 "N91",
190 US_SC_DEVICE, US_PR_DEVICE, NULL, 190 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
191 US_FL_IGNORE_RESIDUE | US_FL_FIX_CAPACITY ), 191 US_FL_IGNORE_RESIDUE | US_FL_FIX_CAPACITY ),
192 192
193/* Reported by Jiri Slaby <jirislaby@gmail.com> and 193/* Reported by Jiri Slaby <jirislaby@gmail.com> and
@@ -195,42 +195,42 @@ UNUSUAL_DEV( 0x0421, 0x0444, 0x0100, 0x0100,
195UNUSUAL_DEV( 0x0421, 0x0446, 0x0100, 0x0100, 195UNUSUAL_DEV( 0x0421, 0x0446, 0x0100, 0x0100,
196 "Nokia", 196 "Nokia",
197 "N80", 197 "N80",
198 US_SC_DEVICE, US_PR_DEVICE, NULL, 198 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
199 US_FL_IGNORE_RESIDUE | US_FL_FIX_CAPACITY ), 199 US_FL_IGNORE_RESIDUE | US_FL_FIX_CAPACITY ),
200 200
201/* Reported by Matthew Bloch <matthew@bytemark.co.uk> */ 201/* Reported by Matthew Bloch <matthew@bytemark.co.uk> */
202UNUSUAL_DEV( 0x0421, 0x044e, 0x0100, 0x0100, 202UNUSUAL_DEV( 0x0421, 0x044e, 0x0100, 0x0100,
203 "Nokia", 203 "Nokia",
204 "E61", 204 "E61",
205 US_SC_DEVICE, US_PR_DEVICE, NULL, 205 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
206 US_FL_IGNORE_RESIDUE | US_FL_FIX_CAPACITY ), 206 US_FL_IGNORE_RESIDUE | US_FL_FIX_CAPACITY ),
207 207
208/* Reported by Bardur Arantsson <bardur@scientician.net> */ 208/* Reported by Bardur Arantsson <bardur@scientician.net> */
209UNUSUAL_DEV( 0x0421, 0x047c, 0x0370, 0x0610, 209UNUSUAL_DEV( 0x0421, 0x047c, 0x0370, 0x0610,
210 "Nokia", 210 "Nokia",
211 "6131", 211 "6131",
212 US_SC_DEVICE, US_PR_DEVICE, NULL, 212 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
213 US_FL_MAX_SECTORS_64 ), 213 US_FL_MAX_SECTORS_64 ),
214 214
215/* Reported by Manuel Osdoba <manuel.osdoba@tu-ilmenau.de> */ 215/* Reported by Manuel Osdoba <manuel.osdoba@tu-ilmenau.de> */
216UNUSUAL_DEV( 0x0421, 0x0492, 0x0452, 0x9999, 216UNUSUAL_DEV( 0x0421, 0x0492, 0x0452, 0x9999,
217 "Nokia", 217 "Nokia",
218 "Nokia 6233", 218 "Nokia 6233",
219 US_SC_DEVICE, US_PR_DEVICE, NULL, 219 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
220 US_FL_MAX_SECTORS_64 ), 220 US_FL_MAX_SECTORS_64 ),
221 221
222/* Reported by Alex Corcoles <alex@corcoles.net> */ 222/* Reported by Alex Corcoles <alex@corcoles.net> */
223UNUSUAL_DEV( 0x0421, 0x0495, 0x0370, 0x0370, 223UNUSUAL_DEV( 0x0421, 0x0495, 0x0370, 0x0370,
224 "Nokia", 224 "Nokia",
225 "6234", 225 "6234",
226 US_SC_DEVICE, US_PR_DEVICE, NULL, 226 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
227 US_FL_MAX_SECTORS_64 ), 227 US_FL_MAX_SECTORS_64 ),
228 228
229#ifdef NO_SDDR09 229#ifdef NO_SDDR09
230UNUSUAL_DEV( 0x0436, 0x0005, 0x0100, 0x0100, 230UNUSUAL_DEV( 0x0436, 0x0005, 0x0100, 0x0100,
231 "Microtech", 231 "Microtech",
232 "CameraMate", 232 "CameraMate",
233 US_SC_SCSI, US_PR_CB, NULL, 233 USB_SC_SCSI, USB_PR_CB, NULL,
234 US_FL_SINGLE_LUN ), 234 US_FL_SINGLE_LUN ),
235#endif 235#endif
236 236
@@ -239,7 +239,7 @@ UNUSUAL_DEV( 0x0436, 0x0005, 0x0100, 0x0100,
239UNUSUAL_DEV( 0x0451, 0x5416, 0x0100, 0x0100, 239UNUSUAL_DEV( 0x0451, 0x5416, 0x0100, 0x0100,
240 "Neuros Audio", 240 "Neuros Audio",
241 "USB 2.0 HD 2.5", 241 "USB 2.0 HD 2.5",
242 US_SC_DEVICE, US_PR_BULK, NULL, 242 USB_SC_DEVICE, USB_PR_BULK, NULL,
243 US_FL_NEED_OVERRIDE ), 243 US_FL_NEED_OVERRIDE ),
244 244
245/* 245/*
@@ -250,7 +250,7 @@ UNUSUAL_DEV( 0x0451, 0x5416, 0x0100, 0x0100,
250UNUSUAL_DEV( 0x0457, 0x0150, 0x0100, 0x0100, 250UNUSUAL_DEV( 0x0457, 0x0150, 0x0100, 0x0100,
251 "USBest Technology", /* sold by Transcend */ 251 "USBest Technology", /* sold by Transcend */
252 "USB Mass Storage Device", 252 "USB Mass Storage Device",
253 US_SC_DEVICE, US_PR_DEVICE, NULL, US_FL_NOT_LOCKABLE ), 253 USB_SC_DEVICE, USB_PR_DEVICE, NULL, US_FL_NOT_LOCKABLE ),
254 254
255/* 255/*
256* Bohdan Linda <bohdan.linda@gmail.com> 256* Bohdan Linda <bohdan.linda@gmail.com>
@@ -260,7 +260,7 @@ UNUSUAL_DEV( 0x0457, 0x0150, 0x0100, 0x0100,
260UNUSUAL_DEV( 0x0457, 0x0151, 0x0100, 0x0100, 260UNUSUAL_DEV( 0x0457, 0x0151, 0x0100, 0x0100,
261 "USB 2.0", 261 "USB 2.0",
262 "Flash Disk", 262 "Flash Disk",
263 US_SC_DEVICE, US_PR_DEVICE, NULL, 263 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
264 US_FL_NOT_LOCKABLE ), 264 US_FL_NOT_LOCKABLE ),
265 265
266/* Reported by Tamas Kerecsen <kerecsen@bigfoot.com> 266/* Reported by Tamas Kerecsen <kerecsen@bigfoot.com>
@@ -272,7 +272,7 @@ UNUSUAL_DEV( 0x0457, 0x0151, 0x0100, 0x0100,
272UNUSUAL_DEV( 0x045e, 0xffff, 0x0000, 0x0000, 272UNUSUAL_DEV( 0x045e, 0xffff, 0x0000, 0x0000,
273 "Mitac", 273 "Mitac",
274 "GPS", 274 "GPS",
275 US_SC_DEVICE, US_PR_DEVICE, NULL, 275 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
276 US_FL_MAX_SECTORS_64 ), 276 US_FL_MAX_SECTORS_64 ),
277 277
278/* 278/*
@@ -284,32 +284,32 @@ UNUSUAL_DEV( 0x045e, 0xffff, 0x0000, 0x0000,
284UNUSUAL_DEV( 0x046b, 0xff40, 0x0100, 0x0100, 284UNUSUAL_DEV( 0x046b, 0xff40, 0x0100, 0x0100,
285 "AMI", 285 "AMI",
286 "Virtual Floppy", 286 "Virtual Floppy",
287 US_SC_DEVICE, US_PR_DEVICE, NULL, 287 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
288 US_FL_NO_WP_DETECT), 288 US_FL_NO_WP_DETECT),
289 289
290/* Patch submitted by Philipp Friedrich <philipp@void.at> */ 290/* Patch submitted by Philipp Friedrich <philipp@void.at> */
291UNUSUAL_DEV( 0x0482, 0x0100, 0x0100, 0x0100, 291UNUSUAL_DEV( 0x0482, 0x0100, 0x0100, 0x0100,
292 "Kyocera", 292 "Kyocera",
293 "Finecam S3x", 293 "Finecam S3x",
294 US_SC_8070, US_PR_CB, NULL, US_FL_FIX_INQUIRY), 294 USB_SC_8070, USB_PR_CB, NULL, US_FL_FIX_INQUIRY),
295 295
296/* Patch submitted by Philipp Friedrich <philipp@void.at> */ 296/* Patch submitted by Philipp Friedrich <philipp@void.at> */
297UNUSUAL_DEV( 0x0482, 0x0101, 0x0100, 0x0100, 297UNUSUAL_DEV( 0x0482, 0x0101, 0x0100, 0x0100,
298 "Kyocera", 298 "Kyocera",
299 "Finecam S4", 299 "Finecam S4",
300 US_SC_8070, US_PR_CB, NULL, US_FL_FIX_INQUIRY), 300 USB_SC_8070, USB_PR_CB, NULL, US_FL_FIX_INQUIRY),
301 301
302/* Patch submitted by Stephane Galles <stephane.galles@free.fr> */ 302/* Patch submitted by Stephane Galles <stephane.galles@free.fr> */
303UNUSUAL_DEV( 0x0482, 0x0103, 0x0100, 0x0100, 303UNUSUAL_DEV( 0x0482, 0x0103, 0x0100, 0x0100,
304 "Kyocera", 304 "Kyocera",
305 "Finecam S5", 305 "Finecam S5",
306 US_SC_DEVICE, US_PR_DEVICE, NULL, US_FL_FIX_INQUIRY), 306 USB_SC_DEVICE, USB_PR_DEVICE, NULL, US_FL_FIX_INQUIRY),
307 307
308/* Patch submitted by Jens Taprogge <jens.taprogge@taprogge.org> */ 308/* Patch submitted by Jens Taprogge <jens.taprogge@taprogge.org> */
309UNUSUAL_DEV( 0x0482, 0x0107, 0x0100, 0x0100, 309UNUSUAL_DEV( 0x0482, 0x0107, 0x0100, 0x0100,
310 "Kyocera", 310 "Kyocera",
311 "CONTAX SL300R T*", 311 "CONTAX SL300R T*",
312 US_SC_DEVICE, US_PR_DEVICE, NULL, 312 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
313 US_FL_FIX_CAPACITY | US_FL_NOT_LOCKABLE), 313 US_FL_FIX_CAPACITY | US_FL_NOT_LOCKABLE),
314 314
315/* Reported by Paul Stewart <stewart@wetlogic.net> 315/* Reported by Paul Stewart <stewart@wetlogic.net>
@@ -317,7 +317,7 @@ UNUSUAL_DEV( 0x0482, 0x0107, 0x0100, 0x0100,
317UNUSUAL_DEV( 0x04a4, 0x0004, 0x0001, 0x0001, 317UNUSUAL_DEV( 0x04a4, 0x0004, 0x0001, 0x0001,
318 "Hitachi", 318 "Hitachi",
319 "DVD-CAM DZ-MV100A Camcorder", 319 "DVD-CAM DZ-MV100A Camcorder",
320 US_SC_SCSI, US_PR_CB, NULL, US_FL_SINGLE_LUN), 320 USB_SC_SCSI, USB_PR_CB, NULL, US_FL_SINGLE_LUN),
321 321
322/* BENQ DC5330 322/* BENQ DC5330
323 * Reported by Manuel Fombuena <mfombuena@ya.com> and 323 * Reported by Manuel Fombuena <mfombuena@ya.com> and
@@ -325,7 +325,7 @@ UNUSUAL_DEV( 0x04a4, 0x0004, 0x0001, 0x0001,
325UNUSUAL_DEV( 0x04a5, 0x3010, 0x0100, 0x0100, 325UNUSUAL_DEV( 0x04a5, 0x3010, 0x0100, 0x0100,
326 "Tekom Technologies, Inc", 326 "Tekom Technologies, Inc",
327 "300_CAMERA", 327 "300_CAMERA",
328 US_SC_DEVICE, US_PR_DEVICE, NULL, 328 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
329 US_FL_IGNORE_RESIDUE ), 329 US_FL_IGNORE_RESIDUE ),
330 330
331/* Patch for Nikon coolpix 2000 331/* Patch for Nikon coolpix 2000
@@ -333,14 +333,14 @@ UNUSUAL_DEV( 0x04a5, 0x3010, 0x0100, 0x0100,
333UNUSUAL_DEV( 0x04b0, 0x0301, 0x0010, 0x0010, 333UNUSUAL_DEV( 0x04b0, 0x0301, 0x0010, 0x0010,
334 "NIKON", 334 "NIKON",
335 "NIKON DSC E2000", 335 "NIKON DSC E2000",
336 US_SC_DEVICE, US_PR_DEVICE,NULL, 336 USB_SC_DEVICE, USB_PR_DEVICE,NULL,
337 US_FL_NOT_LOCKABLE ), 337 US_FL_NOT_LOCKABLE ),
338 338
339/* Reported by Doug Maxey (dwm@austin.ibm.com) */ 339/* Reported by Doug Maxey (dwm@austin.ibm.com) */
340UNUSUAL_DEV( 0x04b3, 0x4001, 0x0110, 0x0110, 340UNUSUAL_DEV( 0x04b3, 0x4001, 0x0110, 0x0110,
341 "IBM", 341 "IBM",
342 "IBM RSA2", 342 "IBM RSA2",
343 US_SC_DEVICE, US_PR_CB, NULL, 343 USB_SC_DEVICE, USB_PR_CB, NULL,
344 US_FL_MAX_SECTORS_MIN), 344 US_FL_MAX_SECTORS_MIN),
345 345
346/* Reported by Simon Levitt <simon@whattf.com> 346/* Reported by Simon Levitt <simon@whattf.com>
@@ -348,14 +348,14 @@ UNUSUAL_DEV( 0x04b3, 0x4001, 0x0110, 0x0110,
348UNUSUAL_DEV( 0x04b8, 0x0601, 0x0100, 0x0100, 348UNUSUAL_DEV( 0x04b8, 0x0601, 0x0100, 0x0100,
349 "Epson", 349 "Epson",
350 "875DC Storage", 350 "875DC Storage",
351 US_SC_SCSI, US_PR_CB, NULL, US_FL_FIX_INQUIRY), 351 USB_SC_SCSI, USB_PR_CB, NULL, US_FL_FIX_INQUIRY),
352 352
353/* Reported by Khalid Aziz <khalid@gonehiking.org> 353/* Reported by Khalid Aziz <khalid@gonehiking.org>
354 * This entry is needed because the device reports Sub=ff */ 354 * This entry is needed because the device reports Sub=ff */
355UNUSUAL_DEV( 0x04b8, 0x0602, 0x0110, 0x0110, 355UNUSUAL_DEV( 0x04b8, 0x0602, 0x0110, 0x0110,
356 "Epson", 356 "Epson",
357 "785EPX Storage", 357 "785EPX Storage",
358 US_SC_SCSI, US_PR_BULK, NULL, US_FL_SINGLE_LUN), 358 USB_SC_SCSI, USB_PR_BULK, NULL, US_FL_SINGLE_LUN),
359 359
360/* Not sure who reported this originally but 360/* Not sure who reported this originally but
361 * Pavel Machek <pavel@ucw.cz> reported that the extra US_FL_SINGLE_LUN 361 * Pavel Machek <pavel@ucw.cz> reported that the extra US_FL_SINGLE_LUN
@@ -363,7 +363,7 @@ UNUSUAL_DEV( 0x04b8, 0x0602, 0x0110, 0x0110,
363UNUSUAL_DEV( 0x04cb, 0x0100, 0x0000, 0x2210, 363UNUSUAL_DEV( 0x04cb, 0x0100, 0x0000, 0x2210,
364 "Fujifilm", 364 "Fujifilm",
365 "FinePix 1400Zoom", 365 "FinePix 1400Zoom",
366 US_SC_UFI, US_PR_DEVICE, NULL, US_FL_FIX_INQUIRY | US_FL_SINGLE_LUN), 366 USB_SC_UFI, USB_PR_DEVICE, NULL, US_FL_FIX_INQUIRY | US_FL_SINGLE_LUN),
367 367
368/* Reported by Ondrej Zary <linux@rainbow-software.org> 368/* Reported by Ondrej Zary <linux@rainbow-software.org>
369 * The device reports one sector more and breaks when that sector is accessed 369 * The device reports one sector more and breaks when that sector is accessed
@@ -371,7 +371,7 @@ UNUSUAL_DEV( 0x04cb, 0x0100, 0x0000, 0x2210,
371UNUSUAL_DEV( 0x04ce, 0x0002, 0x026c, 0x026c, 371UNUSUAL_DEV( 0x04ce, 0x0002, 0x026c, 0x026c,
372 "ScanLogic", 372 "ScanLogic",
373 "SL11R-IDE", 373 "SL11R-IDE",
374 US_SC_DEVICE, US_PR_DEVICE, NULL, 374 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
375 US_FL_FIX_CAPACITY), 375 US_FL_FIX_CAPACITY),
376 376
377/* Reported by Kriston Fincher <kriston@airmail.net> 377/* Reported by Kriston Fincher <kriston@airmail.net>
@@ -382,27 +382,27 @@ UNUSUAL_DEV( 0x04ce, 0x0002, 0x026c, 0x026c,
382UNUSUAL_DEV( 0x04da, 0x0901, 0x0100, 0x0200, 382UNUSUAL_DEV( 0x04da, 0x0901, 0x0100, 0x0200,
383 "Panasonic", 383 "Panasonic",
384 "LS-120 Camera", 384 "LS-120 Camera",
385 US_SC_UFI, US_PR_DEVICE, NULL, 0), 385 USB_SC_UFI, USB_PR_DEVICE, NULL, 0),
386 386
387/* From Yukihiro Nakai, via zaitcev@yahoo.com. 387/* From Yukihiro Nakai, via zaitcev@yahoo.com.
388 * This is needed for CB instead of CBI */ 388 * This is needed for CB instead of CBI */
389UNUSUAL_DEV( 0x04da, 0x0d05, 0x0000, 0x0000, 389UNUSUAL_DEV( 0x04da, 0x0d05, 0x0000, 0x0000,
390 "Sharp CE-CW05", 390 "Sharp CE-CW05",
391 "CD-R/RW Drive", 391 "CD-R/RW Drive",
392 US_SC_8070, US_PR_CB, NULL, 0), 392 USB_SC_8070, USB_PR_CB, NULL, 0),
393 393
394/* Reported by Adriaan Penning <a.penning@luon.net> */ 394/* Reported by Adriaan Penning <a.penning@luon.net> */
395UNUSUAL_DEV( 0x04da, 0x2372, 0x0000, 0x9999, 395UNUSUAL_DEV( 0x04da, 0x2372, 0x0000, 0x9999,
396 "Panasonic", 396 "Panasonic",
397 "DMC-LCx Camera", 397 "DMC-LCx Camera",
398 US_SC_DEVICE, US_PR_DEVICE, NULL, 398 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
399 US_FL_FIX_CAPACITY | US_FL_NOT_LOCKABLE ), 399 US_FL_FIX_CAPACITY | US_FL_NOT_LOCKABLE ),
400 400
401/* Reported by Simeon Simeonov <simeonov_2000@yahoo.com> */ 401/* Reported by Simeon Simeonov <simeonov_2000@yahoo.com> */
402UNUSUAL_DEV( 0x04da, 0x2373, 0x0000, 0x9999, 402UNUSUAL_DEV( 0x04da, 0x2373, 0x0000, 0x9999,
403 "LEICA", 403 "LEICA",
404 "D-LUX Camera", 404 "D-LUX Camera",
405 US_SC_DEVICE, US_PR_DEVICE, NULL, 405 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
406 US_FL_FIX_CAPACITY | US_FL_NOT_LOCKABLE ), 406 US_FL_FIX_CAPACITY | US_FL_NOT_LOCKABLE ),
407 407
408/* Most of the following entries were developed with the help of 408/* Most of the following entries were developed with the help of
@@ -411,19 +411,19 @@ UNUSUAL_DEV( 0x04da, 0x2373, 0x0000, 0x9999,
411UNUSUAL_DEV( 0x04e6, 0x0001, 0x0200, 0x0200, 411UNUSUAL_DEV( 0x04e6, 0x0001, 0x0200, 0x0200,
412 "Matshita", 412 "Matshita",
413 "LS-120", 413 "LS-120",
414 US_SC_8020, US_PR_CB, NULL, 0), 414 USB_SC_8020, USB_PR_CB, NULL, 0),
415 415
416UNUSUAL_DEV( 0x04e6, 0x0002, 0x0100, 0x0100, 416UNUSUAL_DEV( 0x04e6, 0x0002, 0x0100, 0x0100,
417 "Shuttle", 417 "Shuttle",
418 "eUSCSI Bridge", 418 "eUSCSI Bridge",
419 US_SC_DEVICE, US_PR_DEVICE, usb_stor_euscsi_init, 419 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_euscsi_init,
420 US_FL_SCM_MULT_TARG ), 420 US_FL_SCM_MULT_TARG ),
421 421
422#ifdef NO_SDDR09 422#ifdef NO_SDDR09
423UNUSUAL_DEV( 0x04e6, 0x0005, 0x0100, 0x0208, 423UNUSUAL_DEV( 0x04e6, 0x0005, 0x0100, 0x0208,
424 "SCM Microsystems", 424 "SCM Microsystems",
425 "eUSB CompactFlash Adapter", 425 "eUSB CompactFlash Adapter",
426 US_SC_SCSI, US_PR_CB, NULL, 426 USB_SC_SCSI, USB_PR_CB, NULL,
427 US_FL_SINGLE_LUN), 427 US_FL_SINGLE_LUN),
428#endif 428#endif
429 429
@@ -431,56 +431,63 @@ UNUSUAL_DEV( 0x04e6, 0x0005, 0x0100, 0x0208,
431UNUSUAL_DEV( 0x04e6, 0x0006, 0x0100, 0x0100, 431UNUSUAL_DEV( 0x04e6, 0x0006, 0x0100, 0x0100,
432 "SCM Microsystems Inc.", 432 "SCM Microsystems Inc.",
433 "eUSB MMC Adapter", 433 "eUSB MMC Adapter",
434 US_SC_SCSI, US_PR_CB, NULL, 434 USB_SC_SCSI, USB_PR_CB, NULL,
435 US_FL_SINGLE_LUN), 435 US_FL_SINGLE_LUN),
436 436
437/* Reported by Daniel Nouri <dpunktnpunkt@web.de> */ 437/* Reported by Daniel Nouri <dpunktnpunkt@web.de> */
438UNUSUAL_DEV( 0x04e6, 0x0006, 0x0205, 0x0205, 438UNUSUAL_DEV( 0x04e6, 0x0006, 0x0205, 0x0205,
439 "Shuttle", 439 "Shuttle",
440 "eUSB MMC Adapter", 440 "eUSB MMC Adapter",
441 US_SC_SCSI, US_PR_DEVICE, NULL, 441 USB_SC_SCSI, USB_PR_DEVICE, NULL,
442 US_FL_SINGLE_LUN), 442 US_FL_SINGLE_LUN),
443 443
444UNUSUAL_DEV( 0x04e6, 0x0007, 0x0100, 0x0200, 444UNUSUAL_DEV( 0x04e6, 0x0007, 0x0100, 0x0200,
445 "Sony", 445 "Sony",
446 "Hifd", 446 "Hifd",
447 US_SC_SCSI, US_PR_CB, NULL, 447 USB_SC_SCSI, USB_PR_CB, NULL,
448 US_FL_SINGLE_LUN), 448 US_FL_SINGLE_LUN),
449 449
450UNUSUAL_DEV( 0x04e6, 0x0009, 0x0200, 0x0200, 450UNUSUAL_DEV( 0x04e6, 0x0009, 0x0200, 0x0200,
451 "Shuttle", 451 "Shuttle",
452 "eUSB ATA/ATAPI Adapter", 452 "eUSB ATA/ATAPI Adapter",
453 US_SC_8020, US_PR_CB, NULL, 0), 453 USB_SC_8020, USB_PR_CB, NULL, 0),
454 454
455UNUSUAL_DEV( 0x04e6, 0x000a, 0x0200, 0x0200, 455UNUSUAL_DEV( 0x04e6, 0x000a, 0x0200, 0x0200,
456 "Shuttle", 456 "Shuttle",
457 "eUSB CompactFlash Adapter", 457 "eUSB CompactFlash Adapter",
458 US_SC_8020, US_PR_CB, NULL, 0), 458 USB_SC_8020, USB_PR_CB, NULL, 0),
459 459
460UNUSUAL_DEV( 0x04e6, 0x000B, 0x0100, 0x0100, 460UNUSUAL_DEV( 0x04e6, 0x000B, 0x0100, 0x0100,
461 "Shuttle", 461 "Shuttle",
462 "eUSCSI Bridge", 462 "eUSCSI Bridge",
463 US_SC_SCSI, US_PR_BULK, usb_stor_euscsi_init, 463 USB_SC_SCSI, USB_PR_BULK, usb_stor_euscsi_init,
464 US_FL_SCM_MULT_TARG ), 464 US_FL_SCM_MULT_TARG ),
465 465
466UNUSUAL_DEV( 0x04e6, 0x000C, 0x0100, 0x0100, 466UNUSUAL_DEV( 0x04e6, 0x000C, 0x0100, 0x0100,
467 "Shuttle", 467 "Shuttle",
468 "eUSCSI Bridge", 468 "eUSCSI Bridge",
469 US_SC_SCSI, US_PR_BULK, usb_stor_euscsi_init, 469 USB_SC_SCSI, USB_PR_BULK, usb_stor_euscsi_init,
470 US_FL_SCM_MULT_TARG ), 470 US_FL_SCM_MULT_TARG ),
471 471
472UNUSUAL_DEV( 0x04e6, 0x0101, 0x0200, 0x0200, 472UNUSUAL_DEV( 0x04e6, 0x0101, 0x0200, 0x0200,
473 "Shuttle", 473 "Shuttle",
474 "CD-RW Device", 474 "CD-RW Device",
475 US_SC_8020, US_PR_CB, NULL, 0), 475 USB_SC_8020, USB_PR_CB, NULL, 0),
476 476
477/* Reported by Dmitry Khlystov <adminimus@gmail.com> */ 477/* Reported by Dmitry Khlystov <adminimus@gmail.com> */
478UNUSUAL_DEV( 0x04e8, 0x507c, 0x0220, 0x0220, 478UNUSUAL_DEV( 0x04e8, 0x507c, 0x0220, 0x0220,
479 "Samsung", 479 "Samsung",
480 "YP-U3", 480 "YP-U3",
481 US_SC_DEVICE, US_PR_DEVICE, NULL, 481 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
482 US_FL_MAX_SECTORS_64), 482 US_FL_MAX_SECTORS_64),
483 483
484/* Reported by Vitaly Kuznetsov <vitty@altlinux.ru> */
485UNUSUAL_DEV( 0x04e8, 0x5122, 0x0000, 0x9999,
486 "Samsung",
487 "YP-CP3",
488 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
489 US_FL_MAX_SECTORS_64 | US_FL_BULK_IGNORE_TAG),
490
484/* Entry and supporting patch by Theodore Kilgore <kilgota@auburn.edu>. 491/* Entry and supporting patch by Theodore Kilgore <kilgota@auburn.edu>.
485 * Device uses standards-violating 32-byte Bulk Command Block Wrappers and 492 * Device uses standards-violating 32-byte Bulk Command Block Wrappers and
486 * reports itself as "Proprietary SCSI Bulk." Cf. device entry 0x084d:0x0011. 493 * reports itself as "Proprietary SCSI Bulk." Cf. device entry 0x084d:0x0011.
@@ -488,14 +495,14 @@ UNUSUAL_DEV( 0x04e8, 0x507c, 0x0220, 0x0220,
488UNUSUAL_DEV( 0x04fc, 0x80c2, 0x0100, 0x0100, 495UNUSUAL_DEV( 0x04fc, 0x80c2, 0x0100, 0x0100,
489 "Kobian Mercury", 496 "Kobian Mercury",
490 "Binocam DCB-132", 497 "Binocam DCB-132",
491 US_SC_DEVICE, US_PR_DEVICE, NULL, 498 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
492 US_FL_BULK32), 499 US_FL_BULK32),
493 500
494/* Reported by Bob Sass <rls@vectordb.com> -- only rev 1.33 tested */ 501/* Reported by Bob Sass <rls@vectordb.com> -- only rev 1.33 tested */
495UNUSUAL_DEV( 0x050d, 0x0115, 0x0133, 0x0133, 502UNUSUAL_DEV( 0x050d, 0x0115, 0x0133, 0x0133,
496 "Belkin", 503 "Belkin",
497 "USB SCSI Adaptor", 504 "USB SCSI Adaptor",
498 US_SC_SCSI, US_PR_BULK, usb_stor_euscsi_init, 505 USB_SC_SCSI, USB_PR_BULK, usb_stor_euscsi_init,
499 US_FL_SCM_MULT_TARG ), 506 US_FL_SCM_MULT_TARG ),
500 507
501/* Iomega Clik! Drive 508/* Iomega Clik! Drive
@@ -505,14 +512,14 @@ UNUSUAL_DEV( 0x050d, 0x0115, 0x0133, 0x0133,
505UNUSUAL_DEV( 0x0525, 0xa140, 0x0100, 0x0100, 512UNUSUAL_DEV( 0x0525, 0xa140, 0x0100, 0x0100,
506 "Iomega", 513 "Iomega",
507 "USB Clik! 40", 514 "USB Clik! 40",
508 US_SC_8070, US_PR_DEVICE, NULL, 515 USB_SC_8070, USB_PR_DEVICE, NULL,
509 US_FL_FIX_INQUIRY ), 516 US_FL_FIX_INQUIRY ),
510 517
511/* Added by Alan Stern <stern@rowland.harvard.edu> */ 518/* Added by Alan Stern <stern@rowland.harvard.edu> */
512COMPLIANT_DEV(0x0525, 0xa4a5, 0x0000, 0x9999, 519COMPLIANT_DEV(0x0525, 0xa4a5, 0x0000, 0x9999,
513 "Linux", 520 "Linux",
514 "File-backed Storage Gadget", 521 "File-backed Storage Gadget",
515 US_SC_DEVICE, US_PR_DEVICE, NULL, 522 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
516 US_FL_CAPACITY_OK ), 523 US_FL_CAPACITY_OK ),
517 524
518/* Yakumo Mega Image 37 525/* Yakumo Mega Image 37
@@ -520,7 +527,7 @@ COMPLIANT_DEV(0x0525, 0xa4a5, 0x0000, 0x9999,
520UNUSUAL_DEV( 0x052b, 0x1801, 0x0100, 0x0100, 527UNUSUAL_DEV( 0x052b, 0x1801, 0x0100, 0x0100,
521 "Tekom Technologies, Inc", 528 "Tekom Technologies, Inc",
522 "300_CAMERA", 529 "300_CAMERA",
523 US_SC_DEVICE, US_PR_DEVICE, NULL, 530 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
524 US_FL_IGNORE_RESIDUE ), 531 US_FL_IGNORE_RESIDUE ),
525 532
526/* Another Yakumo camera. 533/* Another Yakumo camera.
@@ -528,14 +535,14 @@ UNUSUAL_DEV( 0x052b, 0x1801, 0x0100, 0x0100,
528UNUSUAL_DEV( 0x052b, 0x1804, 0x0100, 0x0100, 535UNUSUAL_DEV( 0x052b, 0x1804, 0x0100, 0x0100,
529 "Tekom Technologies, Inc", 536 "Tekom Technologies, Inc",
530 "300_CAMERA", 537 "300_CAMERA",
531 US_SC_DEVICE, US_PR_DEVICE, NULL, 538 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
532 US_FL_IGNORE_RESIDUE ), 539 US_FL_IGNORE_RESIDUE ),
533 540
534/* Reported by Iacopo Spalletti <avvisi@spalletti.it> */ 541/* Reported by Iacopo Spalletti <avvisi@spalletti.it> */
535UNUSUAL_DEV( 0x052b, 0x1807, 0x0100, 0x0100, 542UNUSUAL_DEV( 0x052b, 0x1807, 0x0100, 0x0100,
536 "Tekom Technologies, Inc", 543 "Tekom Technologies, Inc",
537 "300_CAMERA", 544 "300_CAMERA",
538 US_SC_DEVICE, US_PR_DEVICE, NULL, 545 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
539 US_FL_IGNORE_RESIDUE ), 546 US_FL_IGNORE_RESIDUE ),
540 547
541/* Yakumo Mega Image 47 548/* Yakumo Mega Image 47
@@ -543,7 +550,7 @@ UNUSUAL_DEV( 0x052b, 0x1807, 0x0100, 0x0100,
543UNUSUAL_DEV( 0x052b, 0x1905, 0x0100, 0x0100, 550UNUSUAL_DEV( 0x052b, 0x1905, 0x0100, 0x0100,
544 "Tekom Technologies, Inc", 551 "Tekom Technologies, Inc",
545 "400_CAMERA", 552 "400_CAMERA",
546 US_SC_DEVICE, US_PR_DEVICE, NULL, 553 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
547 US_FL_IGNORE_RESIDUE ), 554 US_FL_IGNORE_RESIDUE ),
548 555
549/* Reported by Paul Ortyl <ortylp@3miasto.net> 556/* Reported by Paul Ortyl <ortylp@3miasto.net>
@@ -551,13 +558,13 @@ UNUSUAL_DEV( 0x052b, 0x1905, 0x0100, 0x0100,
551UNUSUAL_DEV( 0x052b, 0x1911, 0x0100, 0x0100, 558UNUSUAL_DEV( 0x052b, 0x1911, 0x0100, 0x0100,
552 "Tekom Technologies, Inc", 559 "Tekom Technologies, Inc",
553 "400_CAMERA", 560 "400_CAMERA",
554 US_SC_DEVICE, US_PR_DEVICE, NULL, 561 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
555 US_FL_IGNORE_RESIDUE ), 562 US_FL_IGNORE_RESIDUE ),
556 563
557UNUSUAL_DEV( 0x054c, 0x0010, 0x0106, 0x0450, 564UNUSUAL_DEV( 0x054c, 0x0010, 0x0106, 0x0450,
558 "Sony", 565 "Sony",
559 "DSC-S30/S70/S75/505V/F505/F707/F717/P8", 566 "DSC-S30/S70/S75/505V/F505/F707/F717/P8",
560 US_SC_SCSI, US_PR_DEVICE, NULL, 567 USB_SC_SCSI, USB_PR_DEVICE, NULL,
561 US_FL_SINGLE_LUN | US_FL_NOT_LOCKABLE | US_FL_NO_WP_DETECT ), 568 US_FL_SINGLE_LUN | US_FL_NOT_LOCKABLE | US_FL_NO_WP_DETECT ),
562 569
563/* Submitted by Lars Jacob <jacob.lars@googlemail.com> 570/* Submitted by Lars Jacob <jacob.lars@googlemail.com>
@@ -565,7 +572,7 @@ UNUSUAL_DEV( 0x054c, 0x0010, 0x0106, 0x0450,
565UNUSUAL_DEV( 0x054c, 0x0010, 0x0500, 0x0610, 572UNUSUAL_DEV( 0x054c, 0x0010, 0x0500, 0x0610,
566 "Sony", 573 "Sony",
567 "DSC-T1/T5/H5", 574 "DSC-T1/T5/H5",
568 US_SC_8070, US_PR_DEVICE, NULL, 575 USB_SC_8070, USB_PR_DEVICE, NULL,
569 US_FL_SINGLE_LUN ), 576 US_FL_SINGLE_LUN ),
570 577
571 578
@@ -573,88 +580,88 @@ UNUSUAL_DEV( 0x054c, 0x0010, 0x0500, 0x0610,
573UNUSUAL_DEV( 0x054c, 0x0025, 0x0100, 0x0100, 580UNUSUAL_DEV( 0x054c, 0x0025, 0x0100, 0x0100,
574 "Sony", 581 "Sony",
575 "Memorystick NW-MS7", 582 "Memorystick NW-MS7",
576 US_SC_DEVICE, US_PR_DEVICE, NULL, 583 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
577 US_FL_SINGLE_LUN ), 584 US_FL_SINGLE_LUN ),
578 585
579/* Submitted by Olaf Hering, <olh@suse.de> SuSE Bugzilla #49049 */ 586/* Submitted by Olaf Hering, <olh@suse.de> SuSE Bugzilla #49049 */
580UNUSUAL_DEV( 0x054c, 0x002c, 0x0501, 0x2000, 587UNUSUAL_DEV( 0x054c, 0x002c, 0x0501, 0x2000,
581 "Sony", 588 "Sony",
582 "USB Floppy Drive", 589 "USB Floppy Drive",
583 US_SC_DEVICE, US_PR_DEVICE, NULL, 590 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
584 US_FL_SINGLE_LUN ), 591 US_FL_SINGLE_LUN ),
585 592
586UNUSUAL_DEV( 0x054c, 0x002d, 0x0100, 0x0100, 593UNUSUAL_DEV( 0x054c, 0x002d, 0x0100, 0x0100,
587 "Sony", 594 "Sony",
588 "Memorystick MSAC-US1", 595 "Memorystick MSAC-US1",
589 US_SC_DEVICE, US_PR_DEVICE, NULL, 596 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
590 US_FL_SINGLE_LUN ), 597 US_FL_SINGLE_LUN ),
591 598
592/* Submitted by Klaus Mueller <k.mueller@intershop.de> */ 599/* Submitted by Klaus Mueller <k.mueller@intershop.de> */
593UNUSUAL_DEV( 0x054c, 0x002e, 0x0106, 0x0310, 600UNUSUAL_DEV( 0x054c, 0x002e, 0x0106, 0x0310,
594 "Sony", 601 "Sony",
595 "Handycam", 602 "Handycam",
596 US_SC_SCSI, US_PR_DEVICE, NULL, 603 USB_SC_SCSI, USB_PR_DEVICE, NULL,
597 US_FL_SINGLE_LUN ), 604 US_FL_SINGLE_LUN ),
598 605
599/* Submitted by Rajesh Kumble Nayak <nayak@obs-nice.fr> */ 606/* Submitted by Rajesh Kumble Nayak <nayak@obs-nice.fr> */
600UNUSUAL_DEV( 0x054c, 0x002e, 0x0500, 0x0500, 607UNUSUAL_DEV( 0x054c, 0x002e, 0x0500, 0x0500,
601 "Sony", 608 "Sony",
602 "Handycam HC-85", 609 "Handycam HC-85",
603 US_SC_UFI, US_PR_DEVICE, NULL, 610 USB_SC_UFI, USB_PR_DEVICE, NULL,
604 US_FL_SINGLE_LUN ), 611 US_FL_SINGLE_LUN ),
605 612
606UNUSUAL_DEV( 0x054c, 0x0032, 0x0000, 0x9999, 613UNUSUAL_DEV( 0x054c, 0x0032, 0x0000, 0x9999,
607 "Sony", 614 "Sony",
608 "Memorystick MSC-U01N", 615 "Memorystick MSC-U01N",
609 US_SC_DEVICE, US_PR_DEVICE, NULL, 616 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
610 US_FL_SINGLE_LUN ), 617 US_FL_SINGLE_LUN ),
611 618
612/* Submitted by Michal Mlotek <mlotek@foobar.pl> */ 619/* Submitted by Michal Mlotek <mlotek@foobar.pl> */
613UNUSUAL_DEV( 0x054c, 0x0058, 0x0000, 0x9999, 620UNUSUAL_DEV( 0x054c, 0x0058, 0x0000, 0x9999,
614 "Sony", 621 "Sony",
615 "PEG N760c Memorystick", 622 "PEG N760c Memorystick",
616 US_SC_DEVICE, US_PR_DEVICE, NULL, 623 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
617 US_FL_FIX_INQUIRY ), 624 US_FL_FIX_INQUIRY ),
618 625
619UNUSUAL_DEV( 0x054c, 0x0069, 0x0000, 0x9999, 626UNUSUAL_DEV( 0x054c, 0x0069, 0x0000, 0x9999,
620 "Sony", 627 "Sony",
621 "Memorystick MSC-U03", 628 "Memorystick MSC-U03",
622 US_SC_UFI, US_PR_CB, NULL, 629 USB_SC_UFI, USB_PR_CB, NULL,
623 US_FL_SINGLE_LUN ), 630 US_FL_SINGLE_LUN ),
624 631
625/* Submitted by Nathan Babb <nathan@lexi.com> */ 632/* Submitted by Nathan Babb <nathan@lexi.com> */
626UNUSUAL_DEV( 0x054c, 0x006d, 0x0000, 0x9999, 633UNUSUAL_DEV( 0x054c, 0x006d, 0x0000, 0x9999,
627 "Sony", 634 "Sony",
628 "PEG Mass Storage", 635 "PEG Mass Storage",
629 US_SC_DEVICE, US_PR_DEVICE, NULL, 636 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
630 US_FL_FIX_INQUIRY ), 637 US_FL_FIX_INQUIRY ),
631 638
632/* Submitted by Frank Engel <frankie@cse.unsw.edu.au> */ 639/* Submitted by Frank Engel <frankie@cse.unsw.edu.au> */
633UNUSUAL_DEV( 0x054c, 0x0099, 0x0000, 0x9999, 640UNUSUAL_DEV( 0x054c, 0x0099, 0x0000, 0x9999,
634 "Sony", 641 "Sony",
635 "PEG Mass Storage", 642 "PEG Mass Storage",
636 US_SC_DEVICE, US_PR_DEVICE, NULL, 643 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
637 US_FL_FIX_INQUIRY ), 644 US_FL_FIX_INQUIRY ),
638 645
639/* Submitted by Mike Alborn <malborn@deandra.homeip.net> */ 646/* Submitted by Mike Alborn <malborn@deandra.homeip.net> */
640UNUSUAL_DEV( 0x054c, 0x016a, 0x0000, 0x9999, 647UNUSUAL_DEV( 0x054c, 0x016a, 0x0000, 0x9999,
641 "Sony", 648 "Sony",
642 "PEG Mass Storage", 649 "PEG Mass Storage",
643 US_SC_DEVICE, US_PR_DEVICE, NULL, 650 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
644 US_FL_FIX_INQUIRY ), 651 US_FL_FIX_INQUIRY ),
645 652
646/* floppy reports multiple luns */ 653/* floppy reports multiple luns */
647UNUSUAL_DEV( 0x055d, 0x2020, 0x0000, 0x0210, 654UNUSUAL_DEV( 0x055d, 0x2020, 0x0000, 0x0210,
648 "SAMSUNG", 655 "SAMSUNG",
649 "SFD-321U [FW 0C]", 656 "SFD-321U [FW 0C]",
650 US_SC_DEVICE, US_PR_DEVICE, NULL, 657 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
651 US_FL_SINGLE_LUN ), 658 US_FL_SINGLE_LUN ),
652 659
653/* We keep this entry to force the transport; firmware 3.00 and later is ok. */ 660/* We keep this entry to force the transport; firmware 3.00 and later is ok. */
654UNUSUAL_DEV( 0x057b, 0x0000, 0x0000, 0x0299, 661UNUSUAL_DEV( 0x057b, 0x0000, 0x0000, 0x0299,
655 "Y-E Data", 662 "Y-E Data",
656 "Flashbuster-U", 663 "Flashbuster-U",
657 US_SC_DEVICE, US_PR_CB, NULL, 664 USB_SC_DEVICE, USB_PR_CB, NULL,
658 US_FL_SINGLE_LUN), 665 US_FL_SINGLE_LUN),
659 666
660/* Reported by Johann Cardon <johann.cardon@free.fr> 667/* Reported by Johann Cardon <johann.cardon@free.fr>
@@ -664,20 +671,20 @@ UNUSUAL_DEV( 0x057b, 0x0000, 0x0000, 0x0299,
664UNUSUAL_DEV( 0x057b, 0x0022, 0x0000, 0x9999, 671UNUSUAL_DEV( 0x057b, 0x0022, 0x0000, 0x9999,
665 "Y-E Data", 672 "Y-E Data",
666 "Silicon Media R/W", 673 "Silicon Media R/W",
667 US_SC_DEVICE, US_PR_DEVICE, NULL, 0), 674 USB_SC_DEVICE, USB_PR_DEVICE, NULL, 0),
668 675
669/* Reported by RTE <raszilki@yandex.ru> */ 676/* Reported by RTE <raszilki@yandex.ru> */
670UNUSUAL_DEV( 0x058f, 0x6387, 0x0141, 0x0141, 677UNUSUAL_DEV( 0x058f, 0x6387, 0x0141, 0x0141,
671 "JetFlash", 678 "JetFlash",
672 "TS1GJF2A/120", 679 "TS1GJF2A/120",
673 US_SC_DEVICE, US_PR_DEVICE, NULL, 680 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
674 US_FL_MAX_SECTORS_64 ), 681 US_FL_MAX_SECTORS_64 ),
675 682
676/* Fabrizio Fellini <fello@libero.it> */ 683/* Fabrizio Fellini <fello@libero.it> */
677UNUSUAL_DEV( 0x0595, 0x4343, 0x0000, 0x2210, 684UNUSUAL_DEV( 0x0595, 0x4343, 0x0000, 0x2210,
678 "Fujifilm", 685 "Fujifilm",
679 "Digital Camera EX-20 DSC", 686 "Digital Camera EX-20 DSC",
680 US_SC_8070, US_PR_DEVICE, NULL, 0 ), 687 USB_SC_8070, USB_PR_DEVICE, NULL, 0 ),
681 688
682/* Reported by Andre Welter <a.r.welter@gmx.de> 689/* Reported by Andre Welter <a.r.welter@gmx.de>
683 * This antique device predates the release of the Bulk-only Transport 690 * This antique device predates the release of the Bulk-only Transport
@@ -688,14 +695,14 @@ UNUSUAL_DEV( 0x0595, 0x4343, 0x0000, 0x2210,
688UNUSUAL_DEV( 0x059b, 0x0001, 0x0100, 0x0100, 695UNUSUAL_DEV( 0x059b, 0x0001, 0x0100, 0x0100,
689 "Iomega", 696 "Iomega",
690 "ZIP 100", 697 "ZIP 100",
691 US_SC_DEVICE, US_PR_DEVICE, NULL, 698 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
692 US_FL_SINGLE_LUN ), 699 US_FL_SINGLE_LUN ),
693 700
694/* Reported by <Hendryk.Pfeiffer@gmx.de> */ 701/* Reported by <Hendryk.Pfeiffer@gmx.de> */
695UNUSUAL_DEV( 0x059f, 0x0643, 0x0000, 0x0000, 702UNUSUAL_DEV( 0x059f, 0x0643, 0x0000, 0x0000,
696 "LaCie", 703 "LaCie",
697 "DVD+-RW", 704 "DVD+-RW",
698 US_SC_DEVICE, US_PR_DEVICE, NULL, 705 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
699 US_FL_GO_SLOW ), 706 US_FL_GO_SLOW ),
700 707
701/* Submitted by Joel Bourquard <numlock@freesurf.ch> 708/* Submitted by Joel Bourquard <numlock@freesurf.ch>
@@ -705,7 +712,7 @@ UNUSUAL_DEV( 0x059f, 0x0643, 0x0000, 0x0000,
705UNUSUAL_DEV( 0x05ab, 0x0060, 0x1104, 0x1110, 712UNUSUAL_DEV( 0x05ab, 0x0060, 0x1104, 0x1110,
706 "In-System", 713 "In-System",
707 "PyroGate External CD-ROM Enclosure (FCD-523)", 714 "PyroGate External CD-ROM Enclosure (FCD-523)",
708 US_SC_SCSI, US_PR_BULK, NULL, 715 USB_SC_SCSI, USB_PR_BULK, NULL,
709 US_FL_NEED_OVERRIDE ), 716 US_FL_NEED_OVERRIDE ),
710 717
711/* Submitted by Sven Anderson <sven-linux@anderson.de> 718/* Submitted by Sven Anderson <sven-linux@anderson.de>
@@ -717,26 +724,26 @@ UNUSUAL_DEV( 0x05ab, 0x0060, 0x1104, 0x1110,
717UNUSUAL_DEV( 0x05ac, 0x1202, 0x0000, 0x9999, 724UNUSUAL_DEV( 0x05ac, 0x1202, 0x0000, 0x9999,
718 "Apple", 725 "Apple",
719 "iPod", 726 "iPod",
720 US_SC_DEVICE, US_PR_DEVICE, NULL, 727 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
721 US_FL_FIX_CAPACITY ), 728 US_FL_FIX_CAPACITY ),
722 729
723/* Reported by Avi Kivity <avi@argo.co.il> */ 730/* Reported by Avi Kivity <avi@argo.co.il> */
724UNUSUAL_DEV( 0x05ac, 0x1203, 0x0000, 0x9999, 731UNUSUAL_DEV( 0x05ac, 0x1203, 0x0000, 0x9999,
725 "Apple", 732 "Apple",
726 "iPod", 733 "iPod",
727 US_SC_DEVICE, US_PR_DEVICE, NULL, 734 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
728 US_FL_FIX_CAPACITY ), 735 US_FL_FIX_CAPACITY ),
729 736
730UNUSUAL_DEV( 0x05ac, 0x1204, 0x0000, 0x9999, 737UNUSUAL_DEV( 0x05ac, 0x1204, 0x0000, 0x9999,
731 "Apple", 738 "Apple",
732 "iPod", 739 "iPod",
733 US_SC_DEVICE, US_PR_DEVICE, NULL, 740 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
734 US_FL_FIX_CAPACITY | US_FL_NOT_LOCKABLE ), 741 US_FL_FIX_CAPACITY | US_FL_NOT_LOCKABLE ),
735 742
736UNUSUAL_DEV( 0x05ac, 0x1205, 0x0000, 0x9999, 743UNUSUAL_DEV( 0x05ac, 0x1205, 0x0000, 0x9999,
737 "Apple", 744 "Apple",
738 "iPod", 745 "iPod",
739 US_SC_DEVICE, US_PR_DEVICE, NULL, 746 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
740 US_FL_FIX_CAPACITY ), 747 US_FL_FIX_CAPACITY ),
741 748
742/* 749/*
@@ -746,7 +753,7 @@ UNUSUAL_DEV( 0x05ac, 0x1205, 0x0000, 0x9999,
746UNUSUAL_DEV( 0x05ac, 0x120a, 0x0000, 0x9999, 753UNUSUAL_DEV( 0x05ac, 0x120a, 0x0000, 0x9999,
747 "Apple", 754 "Apple",
748 "iPod", 755 "iPod",
749 US_SC_DEVICE, US_PR_DEVICE, NULL, 756 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
750 US_FL_FIX_CAPACITY ), 757 US_FL_FIX_CAPACITY ),
751 758
752/* Reported by Dan Williams <dcbw@redhat.com> 759/* Reported by Dan Williams <dcbw@redhat.com>
@@ -758,14 +765,14 @@ UNUSUAL_DEV( 0x05ac, 0x120a, 0x0000, 0x9999,
758UNUSUAL_DEV( 0x05c6, 0x1000, 0x0000, 0x9999, 765UNUSUAL_DEV( 0x05c6, 0x1000, 0x0000, 0x9999,
759 "Option N.V.", 766 "Option N.V.",
760 "Mass Storage", 767 "Mass Storage",
761 US_SC_DEVICE, US_PR_DEVICE, option_ms_init, 768 USB_SC_DEVICE, USB_PR_DEVICE, option_ms_init,
762 0), 769 0),
763 770
764/* Reported by Blake Matheny <bmatheny@purdue.edu> */ 771/* Reported by Blake Matheny <bmatheny@purdue.edu> */
765UNUSUAL_DEV( 0x05dc, 0xb002, 0x0000, 0x0113, 772UNUSUAL_DEV( 0x05dc, 0xb002, 0x0000, 0x0113,
766 "Lexar", 773 "Lexar",
767 "USB CF Reader", 774 "USB CF Reader",
768 US_SC_DEVICE, US_PR_DEVICE, NULL, 775 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
769 US_FL_FIX_INQUIRY ), 776 US_FL_FIX_INQUIRY ),
770 777
771/* The following two entries are for a Genesys USB to IDE 778/* The following two entries are for a Genesys USB to IDE
@@ -782,20 +789,20 @@ UNUSUAL_DEV( 0x05dc, 0xb002, 0x0000, 0x0113,
782UNUSUAL_DEV( 0x05e3, 0x0701, 0x0000, 0xffff, 789UNUSUAL_DEV( 0x05e3, 0x0701, 0x0000, 0xffff,
783 "Genesys Logic", 790 "Genesys Logic",
784 "USB to IDE Optical", 791 "USB to IDE Optical",
785 US_SC_DEVICE, US_PR_DEVICE, NULL, 792 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
786 US_FL_GO_SLOW | US_FL_MAX_SECTORS_64 | US_FL_IGNORE_RESIDUE ), 793 US_FL_GO_SLOW | US_FL_MAX_SECTORS_64 | US_FL_IGNORE_RESIDUE ),
787 794
788UNUSUAL_DEV( 0x05e3, 0x0702, 0x0000, 0xffff, 795UNUSUAL_DEV( 0x05e3, 0x0702, 0x0000, 0xffff,
789 "Genesys Logic", 796 "Genesys Logic",
790 "USB to IDE Disk", 797 "USB to IDE Disk",
791 US_SC_DEVICE, US_PR_DEVICE, NULL, 798 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
792 US_FL_GO_SLOW | US_FL_MAX_SECTORS_64 | US_FL_IGNORE_RESIDUE ), 799 US_FL_GO_SLOW | US_FL_MAX_SECTORS_64 | US_FL_IGNORE_RESIDUE ),
793 800
794/* Reported by Ben Efros <ben@pc-doctor.com> */ 801/* Reported by Ben Efros <ben@pc-doctor.com> */
795UNUSUAL_DEV( 0x05e3, 0x0723, 0x9451, 0x9451, 802UNUSUAL_DEV( 0x05e3, 0x0723, 0x9451, 0x9451,
796 "Genesys Logic", 803 "Genesys Logic",
797 "USB to SATA", 804 "USB to SATA",
798 US_SC_DEVICE, US_PR_DEVICE, NULL, 805 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
799 US_FL_SANE_SENSE ), 806 US_FL_SANE_SENSE ),
800 807
801/* Reported by Hanno Boeck <hanno@gmx.de> 808/* Reported by Hanno Boeck <hanno@gmx.de>
@@ -803,33 +810,33 @@ UNUSUAL_DEV( 0x05e3, 0x0723, 0x9451, 0x9451,
803UNUSUAL_DEV( 0x0636, 0x0003, 0x0000, 0x9999, 810UNUSUAL_DEV( 0x0636, 0x0003, 0x0000, 0x9999,
804 "Vivitar", 811 "Vivitar",
805 "Vivicam 35Xx", 812 "Vivicam 35Xx",
806 US_SC_SCSI, US_PR_BULK, NULL, 813 USB_SC_SCSI, USB_PR_BULK, NULL,
807 US_FL_FIX_INQUIRY ), 814 US_FL_FIX_INQUIRY ),
808 815
809UNUSUAL_DEV( 0x0644, 0x0000, 0x0100, 0x0100, 816UNUSUAL_DEV( 0x0644, 0x0000, 0x0100, 0x0100,
810 "TEAC", 817 "TEAC",
811 "Floppy Drive", 818 "Floppy Drive",
812 US_SC_UFI, US_PR_CB, NULL, 0 ), 819 USB_SC_UFI, USB_PR_CB, NULL, 0 ),
813 820
814/* Reported by Darsen Lu <darsen@micro.ee.nthu.edu.tw> */ 821/* Reported by Darsen Lu <darsen@micro.ee.nthu.edu.tw> */
815UNUSUAL_DEV( 0x066f, 0x8000, 0x0001, 0x0001, 822UNUSUAL_DEV( 0x066f, 0x8000, 0x0001, 0x0001,
816 "SigmaTel", 823 "SigmaTel",
817 "USBMSC Audio Player", 824 "USBMSC Audio Player",
818 US_SC_DEVICE, US_PR_DEVICE, NULL, 825 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
819 US_FL_FIX_CAPACITY ), 826 US_FL_FIX_CAPACITY ),
820 827
821/* Reported by Daniel Kukula <daniel.kuku@gmail.com> */ 828/* Reported by Daniel Kukula <daniel.kuku@gmail.com> */
822UNUSUAL_DEV( 0x067b, 0x1063, 0x0100, 0x0100, 829UNUSUAL_DEV( 0x067b, 0x1063, 0x0100, 0x0100,
823 "Prolific Technology, Inc.", 830 "Prolific Technology, Inc.",
824 "Prolific Storage Gadget", 831 "Prolific Storage Gadget",
825 US_SC_DEVICE, US_PR_DEVICE, NULL, 832 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
826 US_FL_BAD_SENSE ), 833 US_FL_BAD_SENSE ),
827 834
828/* Reported by Rogerio Brito <rbrito@ime.usp.br> */ 835/* Reported by Rogerio Brito <rbrito@ime.usp.br> */
829UNUSUAL_DEV( 0x067b, 0x2317, 0x0001, 0x001, 836UNUSUAL_DEV( 0x067b, 0x2317, 0x0001, 0x001,
830 "Prolific Technology, Inc.", 837 "Prolific Technology, Inc.",
831 "Mass Storage Device", 838 "Mass Storage Device",
832 US_SC_DEVICE, US_PR_DEVICE, NULL, 839 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
833 US_FL_NOT_LOCKABLE ), 840 US_FL_NOT_LOCKABLE ),
834 841
835/* Reported by Richard -=[]=- <micro_flyer@hotmail.com> */ 842/* Reported by Richard -=[]=- <micro_flyer@hotmail.com> */
@@ -838,46 +845,47 @@ UNUSUAL_DEV( 0x067b, 0x2317, 0x0001, 0x001,
838UNUSUAL_DEV( 0x067b, 0x2507, 0x0001, 0x0100, 845UNUSUAL_DEV( 0x067b, 0x2507, 0x0001, 0x0100,
839 "Prolific Technology Inc.", 846 "Prolific Technology Inc.",
840 "Mass Storage Device", 847 "Mass Storage Device",
841 US_SC_DEVICE, US_PR_DEVICE, NULL, 848 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
842 US_FL_FIX_CAPACITY | US_FL_GO_SLOW ), 849 US_FL_FIX_CAPACITY | US_FL_GO_SLOW ),
843 850
844/* Reported by Alex Butcher <alex.butcher@assursys.co.uk> */ 851/* Reported by Alex Butcher <alex.butcher@assursys.co.uk> */
845UNUSUAL_DEV( 0x067b, 0x3507, 0x0001, 0x0101, 852UNUSUAL_DEV( 0x067b, 0x3507, 0x0001, 0x0101,
846 "Prolific Technology Inc.", 853 "Prolific Technology Inc.",
847 "ATAPI-6 Bridge Controller", 854 "ATAPI-6 Bridge Controller",
848 US_SC_DEVICE, US_PR_DEVICE, NULL, 855 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
849 US_FL_FIX_CAPACITY | US_FL_GO_SLOW ), 856 US_FL_FIX_CAPACITY | US_FL_GO_SLOW ),
850 857
851/* Submitted by Benny Sjostrand <benny@hostmobility.com> */ 858/* Submitted by Benny Sjostrand <benny@hostmobility.com> */
852UNUSUAL_DEV( 0x0686, 0x4011, 0x0001, 0x0001, 859UNUSUAL_DEV( 0x0686, 0x4011, 0x0001, 0x0001,
853 "Minolta", 860 "Minolta",
854 "Dimage F300", 861 "Dimage F300",
855 US_SC_SCSI, US_PR_BULK, NULL, 0 ), 862 USB_SC_SCSI, USB_PR_BULK, NULL, 0 ),
856 863
857/* Reported by Miguel A. Fosas <amn3s1a@ono.com> */ 864/* Reported by Miguel A. Fosas <amn3s1a@ono.com> */
858UNUSUAL_DEV( 0x0686, 0x4017, 0x0001, 0x0001, 865UNUSUAL_DEV( 0x0686, 0x4017, 0x0001, 0x0001,
859 "Minolta", 866 "Minolta",
860 "DIMAGE E223", 867 "DIMAGE E223",
861 US_SC_SCSI, US_PR_DEVICE, NULL, 0 ), 868 USB_SC_SCSI, USB_PR_DEVICE, NULL, 0 ),
862 869
863UNUSUAL_DEV( 0x0693, 0x0005, 0x0100, 0x0100, 870UNUSUAL_DEV( 0x0693, 0x0005, 0x0100, 0x0100,
864 "Hagiwara", 871 "Hagiwara",
865 "Flashgate", 872 "Flashgate",
866 US_SC_SCSI, US_PR_BULK, NULL, 0 ), 873 USB_SC_SCSI, USB_PR_BULK, NULL, 0 ),
867 874
868/* Reported by David Hamilton <niftimusmaximus@lycos.com> */ 875/* Reported by David Hamilton <niftimusmaximus@lycos.com> */
869UNUSUAL_DEV( 0x069b, 0x3004, 0x0001, 0x0001, 876UNUSUAL_DEV( 0x069b, 0x3004, 0x0001, 0x0001,
870 "Thomson Multimedia Inc.", 877 "Thomson Multimedia Inc.",
871 "RCA RD1080 MP3 Player", 878 "RCA RD1080 MP3 Player",
872 US_SC_DEVICE, US_PR_DEVICE, NULL, 879 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
873 US_FL_FIX_CAPACITY ), 880 US_FL_FIX_CAPACITY ),
874 881
875/* Reported by Adrian Pilchowiec <adi1981@epf.pl> */ 882/* Reported by Adrian Pilchowiec <adi1981@epf.pl> */
876UNUSUAL_DEV( 0x071b, 0x3203, 0x0000, 0x0000, 883UNUSUAL_DEV( 0x071b, 0x3203, 0x0000, 0x0000,
877 "RockChip", 884 "RockChip",
878 "MP3", 885 "MP3",
879 US_SC_DEVICE, US_PR_DEVICE, NULL, 886 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
880 US_FL_NO_WP_DETECT | US_FL_MAX_SECTORS_64), 887 US_FL_NO_WP_DETECT | US_FL_MAX_SECTORS_64 |
888 US_FL_NO_READ_CAPACITY_16),
881 889
882/* Reported by Jean-Baptiste Onofre <jb@nanthrax.net> 890/* Reported by Jean-Baptiste Onofre <jb@nanthrax.net>
883 * Support the following product : 891 * Support the following product :
@@ -886,7 +894,7 @@ UNUSUAL_DEV( 0x071b, 0x3203, 0x0000, 0x0000,
886UNUSUAL_DEV( 0x071b, 0x32bb, 0x0000, 0x0000, 894UNUSUAL_DEV( 0x071b, 0x32bb, 0x0000, 0x0000,
887 "RockChip", 895 "RockChip",
888 "MTP", 896 "MTP",
889 US_SC_DEVICE, US_PR_DEVICE, NULL, 897 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
890 US_FL_NO_WP_DETECT | US_FL_MAX_SECTORS_64), 898 US_FL_NO_WP_DETECT | US_FL_MAX_SECTORS_64),
891 899
892/* Reported by Massimiliano Ghilardi <massimiliano.ghilardi@gmail.com> 900/* Reported by Massimiliano Ghilardi <massimiliano.ghilardi@gmail.com>
@@ -902,59 +910,59 @@ UNUSUAL_DEV( 0x071b, 0x32bb, 0x0000, 0x0000,
902UNUSUAL_DEV( 0x071b, 0x3203, 0x0100, 0x0100, 910UNUSUAL_DEV( 0x071b, 0x3203, 0x0100, 0x0100,
903 "RockChip", 911 "RockChip",
904 "ROCK MP3", 912 "ROCK MP3",
905 US_SC_DEVICE, US_PR_DEVICE, NULL, 913 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
906 US_FL_MAX_SECTORS_64), 914 US_FL_MAX_SECTORS_64),
907 915
908/* Reported by Olivier Blondeau <zeitoun@gmail.com> */ 916/* Reported by Olivier Blondeau <zeitoun@gmail.com> */
909UNUSUAL_DEV( 0x0727, 0x0306, 0x0100, 0x0100, 917UNUSUAL_DEV( 0x0727, 0x0306, 0x0100, 0x0100,
910 "ATMEL", 918 "ATMEL",
911 "SND1 Storage", 919 "SND1 Storage",
912 US_SC_DEVICE, US_PR_DEVICE, NULL, 920 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
913 US_FL_IGNORE_RESIDUE), 921 US_FL_IGNORE_RESIDUE),
914 922
915/* Submitted by Roman Hodek <roman@hodek.net> */ 923/* Submitted by Roman Hodek <roman@hodek.net> */
916UNUSUAL_DEV( 0x0781, 0x0001, 0x0200, 0x0200, 924UNUSUAL_DEV( 0x0781, 0x0001, 0x0200, 0x0200,
917 "Sandisk", 925 "Sandisk",
918 "ImageMate SDDR-05a", 926 "ImageMate SDDR-05a",
919 US_SC_SCSI, US_PR_CB, NULL, 927 USB_SC_SCSI, USB_PR_CB, NULL,
920 US_FL_SINGLE_LUN ), 928 US_FL_SINGLE_LUN ),
921 929
922UNUSUAL_DEV( 0x0781, 0x0002, 0x0009, 0x0009, 930UNUSUAL_DEV( 0x0781, 0x0002, 0x0009, 0x0009,
923 "SanDisk Corporation", 931 "SanDisk Corporation",
924 "ImageMate CompactFlash USB", 932 "ImageMate CompactFlash USB",
925 US_SC_DEVICE, US_PR_DEVICE, NULL, 933 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
926 US_FL_FIX_CAPACITY ), 934 US_FL_FIX_CAPACITY ),
927 935
928UNUSUAL_DEV( 0x0781, 0x0100, 0x0100, 0x0100, 936UNUSUAL_DEV( 0x0781, 0x0100, 0x0100, 0x0100,
929 "Sandisk", 937 "Sandisk",
930 "ImageMate SDDR-12", 938 "ImageMate SDDR-12",
931 US_SC_SCSI, US_PR_CB, NULL, 939 USB_SC_SCSI, USB_PR_CB, NULL,
932 US_FL_SINGLE_LUN ), 940 US_FL_SINGLE_LUN ),
933 941
934/* Reported by Eero Volotinen <eero@ping-viini.org> */ 942/* Reported by Eero Volotinen <eero@ping-viini.org> */
935UNUSUAL_DEV( 0x07ab, 0xfccd, 0x0000, 0x9999, 943UNUSUAL_DEV( 0x07ab, 0xfccd, 0x0000, 0x9999,
936 "Freecom Technologies", 944 "Freecom Technologies",
937 "FHD-Classic", 945 "FHD-Classic",
938 US_SC_DEVICE, US_PR_DEVICE, NULL, 946 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
939 US_FL_FIX_CAPACITY), 947 US_FL_FIX_CAPACITY),
940 948
941UNUSUAL_DEV( 0x07af, 0x0004, 0x0100, 0x0133, 949UNUSUAL_DEV( 0x07af, 0x0004, 0x0100, 0x0133,
942 "Microtech", 950 "Microtech",
943 "USB-SCSI-DB25", 951 "USB-SCSI-DB25",
944 US_SC_DEVICE, US_PR_DEVICE, usb_stor_euscsi_init, 952 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_euscsi_init,
945 US_FL_SCM_MULT_TARG ), 953 US_FL_SCM_MULT_TARG ),
946 954
947UNUSUAL_DEV( 0x07af, 0x0005, 0x0100, 0x0100, 955UNUSUAL_DEV( 0x07af, 0x0005, 0x0100, 0x0100,
948 "Microtech", 956 "Microtech",
949 "USB-SCSI-HD50", 957 "USB-SCSI-HD50",
950 US_SC_DEVICE, US_PR_DEVICE, usb_stor_euscsi_init, 958 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_euscsi_init,
951 US_FL_SCM_MULT_TARG ), 959 US_FL_SCM_MULT_TARG ),
952 960
953#ifdef NO_SDDR09 961#ifdef NO_SDDR09
954UNUSUAL_DEV( 0x07af, 0x0006, 0x0100, 0x0100, 962UNUSUAL_DEV( 0x07af, 0x0006, 0x0100, 0x0100,
955 "Microtech", 963 "Microtech",
956 "CameraMate", 964 "CameraMate",
957 US_SC_SCSI, US_PR_CB, NULL, 965 USB_SC_SCSI, USB_PR_CB, NULL,
958 US_FL_SINGLE_LUN ), 966 US_FL_SINGLE_LUN ),
959#endif 967#endif
960 968
@@ -967,7 +975,7 @@ UNUSUAL_DEV( 0x07af, 0x0006, 0x0100, 0x0100,
967UNUSUAL_DEV( 0x07c4, 0xa400, 0x0000, 0xffff, 975UNUSUAL_DEV( 0x07c4, 0xa400, 0x0000, 0xffff,
968 "Datafab", 976 "Datafab",
969 "KECF-USB", 977 "KECF-USB",
970 US_SC_DEVICE, US_PR_DEVICE, NULL, 978 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
971 US_FL_FIX_INQUIRY | US_FL_FIX_CAPACITY ), 979 US_FL_FIX_INQUIRY | US_FL_FIX_CAPACITY ),
972 980
973/* Reported by Rauch Wolke <rauchwolke@gmx.net> 981/* Reported by Rauch Wolke <rauchwolke@gmx.net>
@@ -976,7 +984,7 @@ UNUSUAL_DEV( 0x07c4, 0xa400, 0x0000, 0xffff,
976UNUSUAL_DEV( 0x07c4, 0xa4a5, 0x0000, 0xffff, 984UNUSUAL_DEV( 0x07c4, 0xa4a5, 0x0000, 0xffff,
977 "Simple Tech/Datafab", 985 "Simple Tech/Datafab",
978 "CF+SM Reader", 986 "CF+SM Reader",
979 US_SC_DEVICE, US_PR_DEVICE, NULL, 987 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
980 US_FL_IGNORE_RESIDUE | US_FL_MAX_SECTORS_64 ), 988 US_FL_IGNORE_RESIDUE | US_FL_MAX_SECTORS_64 ),
981 989
982/* Casio QV 2x00/3x00/4000/8000 digital still cameras are not conformant 990/* Casio QV 2x00/3x00/4000/8000 digital still cameras are not conformant
@@ -986,42 +994,42 @@ UNUSUAL_DEV( 0x07c4, 0xa4a5, 0x0000, 0xffff,
986 * - They don't like the INQUIRY command. So we must handle this command 994 * - They don't like the INQUIRY command. So we must handle this command
987 * of the SCSI layer ourselves. 995 * of the SCSI layer ourselves.
988 * - Some cameras with idProduct=0x1001 and bcdDevice=0x1000 have 996 * - Some cameras with idProduct=0x1001 and bcdDevice=0x1000 have
989 * bInterfaceProtocol=0x00 (US_PR_CBI) while others have 0x01 (US_PR_CB). 997 * bInterfaceProtocol=0x00 (USB_PR_CBI) while others have 0x01 (USB_PR_CB).
990 * So don't remove the US_PR_CB override! 998 * So don't remove the USB_PR_CB override!
991 * - Cameras with bcdDevice=0x9009 require the US_SC_8070 override. 999 * - Cameras with bcdDevice=0x9009 require the USB_SC_8070 override.
992 */ 1000 */
993UNUSUAL_DEV( 0x07cf, 0x1001, 0x1000, 0x9999, 1001UNUSUAL_DEV( 0x07cf, 0x1001, 0x1000, 0x9999,
994 "Casio", 1002 "Casio",
995 "QV DigitalCamera", 1003 "QV DigitalCamera",
996 US_SC_8070, US_PR_CB, NULL, 1004 USB_SC_8070, USB_PR_CB, NULL,
997 US_FL_NEED_OVERRIDE | US_FL_FIX_INQUIRY ), 1005 US_FL_NEED_OVERRIDE | US_FL_FIX_INQUIRY ),
998 1006
999/* Submitted by Hartmut Wahl <hwahl@hwahl.de>*/ 1007/* Submitted by Hartmut Wahl <hwahl@hwahl.de>*/
1000UNUSUAL_DEV( 0x0839, 0x000a, 0x0001, 0x0001, 1008UNUSUAL_DEV( 0x0839, 0x000a, 0x0001, 0x0001,
1001 "Samsung", 1009 "Samsung",
1002 "Digimax 410", 1010 "Digimax 410",
1003 US_SC_DEVICE, US_PR_DEVICE, NULL, 1011 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1004 US_FL_FIX_INQUIRY), 1012 US_FL_FIX_INQUIRY),
1005 1013
1006/* Reported by Luciano Rocha <luciano@eurotux.com> */ 1014/* Reported by Luciano Rocha <luciano@eurotux.com> */
1007UNUSUAL_DEV( 0x0840, 0x0082, 0x0001, 0x0001, 1015UNUSUAL_DEV( 0x0840, 0x0082, 0x0001, 0x0001,
1008 "Argosy", 1016 "Argosy",
1009 "Storage", 1017 "Storage",
1010 US_SC_DEVICE, US_PR_DEVICE, NULL, 1018 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1011 US_FL_FIX_CAPACITY), 1019 US_FL_FIX_CAPACITY),
1012 1020
1013/* Reported and patched by Nguyen Anh Quynh <aquynh@gmail.com> */ 1021/* Reported and patched by Nguyen Anh Quynh <aquynh@gmail.com> */
1014UNUSUAL_DEV( 0x0840, 0x0084, 0x0001, 0x0001, 1022UNUSUAL_DEV( 0x0840, 0x0084, 0x0001, 0x0001,
1015 "Argosy", 1023 "Argosy",
1016 "Storage", 1024 "Storage",
1017 US_SC_DEVICE, US_PR_DEVICE, NULL, 1025 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1018 US_FL_FIX_CAPACITY), 1026 US_FL_FIX_CAPACITY),
1019 1027
1020/* Reported by Martijn Hijdra <martijn.hijdra@gmail.com> */ 1028/* Reported by Martijn Hijdra <martijn.hijdra@gmail.com> */
1021UNUSUAL_DEV( 0x0840, 0x0085, 0x0001, 0x0001, 1029UNUSUAL_DEV( 0x0840, 0x0085, 0x0001, 0x0001,
1022 "Argosy", 1030 "Argosy",
1023 "Storage", 1031 "Storage",
1024 US_SC_DEVICE, US_PR_DEVICE, NULL, 1032 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1025 US_FL_FIX_CAPACITY), 1033 US_FL_FIX_CAPACITY),
1026 1034
1027/* Entry and supporting patch by Theodore Kilgore <kilgota@auburn.edu>. 1035/* Entry and supporting patch by Theodore Kilgore <kilgota@auburn.edu>.
@@ -1033,9 +1041,18 @@ UNUSUAL_DEV( 0x0840, 0x0085, 0x0001, 0x0001,
1033UNUSUAL_DEV( 0x084d, 0x0011, 0x0110, 0x0110, 1041UNUSUAL_DEV( 0x084d, 0x0011, 0x0110, 0x0110,
1034 "Grandtech", 1042 "Grandtech",
1035 "DC2MEGA", 1043 "DC2MEGA",
1036 US_SC_DEVICE, US_PR_DEVICE, NULL, 1044 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1037 US_FL_BULK32), 1045 US_FL_BULK32),
1038 1046
1047/* Reported by <ttkspam@free.fr>
1048 * The device reports a vendor-specific device class, requiring an
1049 * explicit vendor/product match.
1050 */
1051UNUSUAL_DEV( 0x0851, 0x1542, 0x0002, 0x0002,
1052 "MagicPixel",
1053 "FW_Omega2",
1054 USB_SC_DEVICE, USB_PR_DEVICE, NULL, 0),
1055
1039/* Andrew Lunn <andrew@lunn.ch> 1056/* Andrew Lunn <andrew@lunn.ch>
1040 * PanDigital Digital Picture Frame. Does not like ALLOW_MEDIUM_REMOVAL 1057 * PanDigital Digital Picture Frame. Does not like ALLOW_MEDIUM_REMOVAL
1041 * on LUN 4. 1058 * on LUN 4.
@@ -1044,14 +1061,14 @@ UNUSUAL_DEV( 0x084d, 0x0011, 0x0110, 0x0110,
1044UNUSUAL_DEV( 0x0851, 0x1543, 0x0200, 0x0200, 1061UNUSUAL_DEV( 0x0851, 0x1543, 0x0200, 0x0200,
1045 "PanDigital", 1062 "PanDigital",
1046 "Photo Frame", 1063 "Photo Frame",
1047 US_SC_DEVICE, US_PR_DEVICE, NULL, 1064 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1048 US_FL_NOT_LOCKABLE), 1065 US_FL_NOT_LOCKABLE),
1049 1066
1050/* Submitted by Jan De Luyck <lkml@kcore.org> */ 1067/* Submitted by Jan De Luyck <lkml@kcore.org> */
1051UNUSUAL_DEV( 0x08bd, 0x1100, 0x0000, 0x0000, 1068UNUSUAL_DEV( 0x08bd, 0x1100, 0x0000, 0x0000,
1052 "CITIZEN", 1069 "CITIZEN",
1053 "X1DE-USB", 1070 "X1DE-USB",
1054 US_SC_DEVICE, US_PR_DEVICE, NULL, 1071 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1055 US_FL_SINGLE_LUN), 1072 US_FL_SINGLE_LUN),
1056 1073
1057/* Submitted by Dylan Taft <d13f00l@gmail.com> 1074/* Submitted by Dylan Taft <d13f00l@gmail.com>
@@ -1060,7 +1077,7 @@ UNUSUAL_DEV( 0x08bd, 0x1100, 0x0000, 0x0000,
1060UNUSUAL_DEV( 0x08ca, 0x3103, 0x0100, 0x0100, 1077UNUSUAL_DEV( 0x08ca, 0x3103, 0x0100, 0x0100,
1061 "AIPTEK", 1078 "AIPTEK",
1062 "Aiptek USB Keychain MP3 Player", 1079 "Aiptek USB Keychain MP3 Player",
1063 US_SC_DEVICE, US_PR_DEVICE, NULL, 1080 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1064 US_FL_IGNORE_RESIDUE), 1081 US_FL_IGNORE_RESIDUE),
1065 1082
1066/* Entry needed for flags. Moreover, all devices with this ID use 1083/* Entry needed for flags. Moreover, all devices with this ID use
@@ -1071,7 +1088,7 @@ UNUSUAL_DEV( 0x08ca, 0x3103, 0x0100, 0x0100,
1071UNUSUAL_DEV( 0x090a, 0x1001, 0x0100, 0x0100, 1088UNUSUAL_DEV( 0x090a, 0x1001, 0x0100, 0x0100,
1072 "Trumpion", 1089 "Trumpion",
1073 "t33520 USB Flash Card Controller", 1090 "t33520 USB Flash Card Controller",
1074 US_SC_DEVICE, US_PR_BULK, NULL, 1091 USB_SC_DEVICE, USB_PR_BULK, NULL,
1075 US_FL_NEED_OVERRIDE ), 1092 US_FL_NEED_OVERRIDE ),
1076 1093
1077/* Reported by Filippo Bardelli <filibard@libero.it> 1094/* Reported by Filippo Bardelli <filibard@libero.it>
@@ -1080,23 +1097,33 @@ UNUSUAL_DEV( 0x090a, 0x1001, 0x0100, 0x0100,
1080UNUSUAL_DEV( 0x090a, 0x1050, 0x0100, 0x0100, 1097UNUSUAL_DEV( 0x090a, 0x1050, 0x0100, 0x0100,
1081 "Trumpion Microelectronics, Inc.", 1098 "Trumpion Microelectronics, Inc.",
1082 "33520 USB Digital Voice Recorder", 1099 "33520 USB Digital Voice Recorder",
1083 US_SC_UFI, US_PR_DEVICE, NULL, 1100 USB_SC_UFI, USB_PR_DEVICE, NULL,
1084 0), 1101 0),
1085 1102
1086/* Trumpion Microelectronics MP3 player (felipe_alfaro@linuxmail.org) */ 1103/* Trumpion Microelectronics MP3 player (felipe_alfaro@linuxmail.org) */
1087UNUSUAL_DEV( 0x090a, 0x1200, 0x0000, 0x9999, 1104UNUSUAL_DEV( 0x090a, 0x1200, 0x0000, 0x9999,
1088 "Trumpion", 1105 "Trumpion",
1089 "MP3 player", 1106 "MP3 player",
1090 US_SC_RBC, US_PR_BULK, NULL, 1107 USB_SC_RBC, USB_PR_BULK, NULL,
1091 0 ), 1108 0 ),
1092 1109
1093/* aeb */ 1110/* aeb */
1094UNUSUAL_DEV( 0x090c, 0x1132, 0x0000, 0xffff, 1111UNUSUAL_DEV( 0x090c, 0x1132, 0x0000, 0xffff,
1095 "Feiya", 1112 "Feiya",
1096 "5-in-1 Card Reader", 1113 "5-in-1 Card Reader",
1097 US_SC_DEVICE, US_PR_DEVICE, NULL, 1114 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1098 US_FL_FIX_CAPACITY ), 1115 US_FL_FIX_CAPACITY ),
1099 1116
1117/* Reported by Paul Hartman <paul.hartman+linux@gmail.com>
1118 * This card reader returns "Illegal Request, Logical Block Address
1119 * Out of Range" for the first READ(10) after a new card is inserted.
1120 */
1121UNUSUAL_DEV( 0x090c, 0x6000, 0x0100, 0x0100,
1122 "Feiya",
1123 "SD/SDHC Card Reader",
1124 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1125 US_FL_INITIAL_READ10 ),
1126
1100/* This Pentax still camera is not conformant 1127/* This Pentax still camera is not conformant
1101 * to the USB storage specification: - 1128 * to the USB storage specification: -
1102 * - It does not like the INQUIRY command. So we must handle this command 1129 * - It does not like the INQUIRY command. So we must handle this command
@@ -1107,7 +1134,7 @@ UNUSUAL_DEV( 0x090c, 0x1132, 0x0000, 0xffff,
1107UNUSUAL_DEV( 0x0a17, 0x0004, 0x1000, 0x1000, 1134UNUSUAL_DEV( 0x0a17, 0x0004, 0x1000, 0x1000,
1108 "Pentax", 1135 "Pentax",
1109 "Optio 2/3/400", 1136 "Optio 2/3/400",
1110 US_SC_DEVICE, US_PR_DEVICE, NULL, 1137 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1111 US_FL_FIX_INQUIRY ), 1138 US_FL_FIX_INQUIRY ),
1112 1139
1113/* These are virtual windows driver CDs, which the zd1211rw driver 1140/* These are virtual windows driver CDs, which the zd1211rw driver
@@ -1115,13 +1142,13 @@ UNUSUAL_DEV( 0x0a17, 0x0004, 0x1000, 0x1000,
1115UNUSUAL_DEV( 0x0ace, 0x2011, 0x0101, 0x0101, 1142UNUSUAL_DEV( 0x0ace, 0x2011, 0x0101, 0x0101,
1116 "ZyXEL", 1143 "ZyXEL",
1117 "G-220F USB-WLAN Install", 1144 "G-220F USB-WLAN Install",
1118 US_SC_DEVICE, US_PR_DEVICE, NULL, 1145 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1119 US_FL_IGNORE_DEVICE ), 1146 US_FL_IGNORE_DEVICE ),
1120 1147
1121UNUSUAL_DEV( 0x0ace, 0x20ff, 0x0101, 0x0101, 1148UNUSUAL_DEV( 0x0ace, 0x20ff, 0x0101, 0x0101,
1122 "SiteCom", 1149 "SiteCom",
1123 "WL-117 USB-WLAN Install", 1150 "WL-117 USB-WLAN Install",
1124 US_SC_DEVICE, US_PR_DEVICE, NULL, 1151 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1125 US_FL_IGNORE_DEVICE ), 1152 US_FL_IGNORE_DEVICE ),
1126 1153
1127/* Reported by Dan Williams <dcbw@redhat.com> 1154/* Reported by Dan Williams <dcbw@redhat.com>
@@ -1133,7 +1160,7 @@ UNUSUAL_DEV( 0x0ace, 0x20ff, 0x0101, 0x0101,
1133UNUSUAL_DEV( 0x0af0, 0x6971, 0x0000, 0x9999, 1160UNUSUAL_DEV( 0x0af0, 0x6971, 0x0000, 0x9999,
1134 "Option N.V.", 1161 "Option N.V.",
1135 "Mass Storage", 1162 "Mass Storage",
1136 US_SC_DEVICE, US_PR_DEVICE, option_ms_init, 1163 USB_SC_DEVICE, USB_PR_DEVICE, option_ms_init,
1137 0), 1164 0),
1138 1165
1139/* Reported by F. Aben <f.aben@option.com> 1166/* Reported by F. Aben <f.aben@option.com>
@@ -1143,7 +1170,7 @@ UNUSUAL_DEV( 0x0af0, 0x6971, 0x0000, 0x9999,
1143UNUSUAL_DEV( 0x0af0, 0x7401, 0x0000, 0x0000, 1170UNUSUAL_DEV( 0x0af0, 0x7401, 0x0000, 0x0000,
1144 "Option", 1171 "Option",
1145 "GI 0401 SD-Card", 1172 "GI 0401 SD-Card",
1146 US_SC_DEVICE, US_PR_DEVICE, NULL, 1173 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1147 0 ), 1174 0 ),
1148 1175
1149/* Reported by Jan Dumon <j.dumon@option.com> 1176/* Reported by Jan Dumon <j.dumon@option.com>
@@ -1153,104 +1180,104 @@ UNUSUAL_DEV( 0x0af0, 0x7401, 0x0000, 0x0000,
1153UNUSUAL_DEV( 0x0af0, 0x7501, 0x0000, 0x0000, 1180UNUSUAL_DEV( 0x0af0, 0x7501, 0x0000, 0x0000,
1154 "Option", 1181 "Option",
1155 "GI 0431 SD-Card", 1182 "GI 0431 SD-Card",
1156 US_SC_DEVICE, US_PR_DEVICE, NULL, 1183 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1157 0 ), 1184 0 ),
1158 1185
1159UNUSUAL_DEV( 0x0af0, 0x7701, 0x0000, 0x0000, 1186UNUSUAL_DEV( 0x0af0, 0x7701, 0x0000, 0x0000,
1160 "Option", 1187 "Option",
1161 "GI 0451 SD-Card", 1188 "GI 0451 SD-Card",
1162 US_SC_DEVICE, US_PR_DEVICE, NULL, 1189 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1163 0 ), 1190 0 ),
1164 1191
1165UNUSUAL_DEV( 0x0af0, 0x7706, 0x0000, 0x0000, 1192UNUSUAL_DEV( 0x0af0, 0x7706, 0x0000, 0x0000,
1166 "Option", 1193 "Option",
1167 "GI 0451 SD-Card", 1194 "GI 0451 SD-Card",
1168 US_SC_DEVICE, US_PR_DEVICE, NULL, 1195 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1169 0 ), 1196 0 ),
1170 1197
1171UNUSUAL_DEV( 0x0af0, 0x7901, 0x0000, 0x0000, 1198UNUSUAL_DEV( 0x0af0, 0x7901, 0x0000, 0x0000,
1172 "Option", 1199 "Option",
1173 "GI 0452 SD-Card", 1200 "GI 0452 SD-Card",
1174 US_SC_DEVICE, US_PR_DEVICE, NULL, 1201 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1175 0 ), 1202 0 ),
1176 1203
1177UNUSUAL_DEV( 0x0af0, 0x7A01, 0x0000, 0x0000, 1204UNUSUAL_DEV( 0x0af0, 0x7A01, 0x0000, 0x0000,
1178 "Option", 1205 "Option",
1179 "GI 0461 SD-Card", 1206 "GI 0461 SD-Card",
1180 US_SC_DEVICE, US_PR_DEVICE, NULL, 1207 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1181 0 ), 1208 0 ),
1182 1209
1183UNUSUAL_DEV( 0x0af0, 0x7A05, 0x0000, 0x0000, 1210UNUSUAL_DEV( 0x0af0, 0x7A05, 0x0000, 0x0000,
1184 "Option", 1211 "Option",
1185 "GI 0461 SD-Card", 1212 "GI 0461 SD-Card",
1186 US_SC_DEVICE, US_PR_DEVICE, NULL, 1213 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1187 0 ), 1214 0 ),
1188 1215
1189UNUSUAL_DEV( 0x0af0, 0x8300, 0x0000, 0x0000, 1216UNUSUAL_DEV( 0x0af0, 0x8300, 0x0000, 0x0000,
1190 "Option", 1217 "Option",
1191 "GI 033x SD-Card", 1218 "GI 033x SD-Card",
1192 US_SC_DEVICE, US_PR_DEVICE, NULL, 1219 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1193 0 ), 1220 0 ),
1194 1221
1195UNUSUAL_DEV( 0x0af0, 0x8302, 0x0000, 0x0000, 1222UNUSUAL_DEV( 0x0af0, 0x8302, 0x0000, 0x0000,
1196 "Option", 1223 "Option",
1197 "GI 033x SD-Card", 1224 "GI 033x SD-Card",
1198 US_SC_DEVICE, US_PR_DEVICE, NULL, 1225 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1199 0 ), 1226 0 ),
1200 1227
1201UNUSUAL_DEV( 0x0af0, 0x8304, 0x0000, 0x0000, 1228UNUSUAL_DEV( 0x0af0, 0x8304, 0x0000, 0x0000,
1202 "Option", 1229 "Option",
1203 "GI 033x SD-Card", 1230 "GI 033x SD-Card",
1204 US_SC_DEVICE, US_PR_DEVICE, NULL, 1231 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1205 0 ), 1232 0 ),
1206 1233
1207UNUSUAL_DEV( 0x0af0, 0xc100, 0x0000, 0x0000, 1234UNUSUAL_DEV( 0x0af0, 0xc100, 0x0000, 0x0000,
1208 "Option", 1235 "Option",
1209 "GI 070x SD-Card", 1236 "GI 070x SD-Card",
1210 US_SC_DEVICE, US_PR_DEVICE, NULL, 1237 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1211 0 ), 1238 0 ),
1212 1239
1213UNUSUAL_DEV( 0x0af0, 0xd057, 0x0000, 0x0000, 1240UNUSUAL_DEV( 0x0af0, 0xd057, 0x0000, 0x0000,
1214 "Option", 1241 "Option",
1215 "GI 1505 SD-Card", 1242 "GI 1505 SD-Card",
1216 US_SC_DEVICE, US_PR_DEVICE, NULL, 1243 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1217 0 ), 1244 0 ),
1218 1245
1219UNUSUAL_DEV( 0x0af0, 0xd058, 0x0000, 0x0000, 1246UNUSUAL_DEV( 0x0af0, 0xd058, 0x0000, 0x0000,
1220 "Option", 1247 "Option",
1221 "GI 1509 SD-Card", 1248 "GI 1509 SD-Card",
1222 US_SC_DEVICE, US_PR_DEVICE, NULL, 1249 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1223 0 ), 1250 0 ),
1224 1251
1225UNUSUAL_DEV( 0x0af0, 0xd157, 0x0000, 0x0000, 1252UNUSUAL_DEV( 0x0af0, 0xd157, 0x0000, 0x0000,
1226 "Option", 1253 "Option",
1227 "GI 1515 SD-Card", 1254 "GI 1515 SD-Card",
1228 US_SC_DEVICE, US_PR_DEVICE, NULL, 1255 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1229 0 ), 1256 0 ),
1230 1257
1231UNUSUAL_DEV( 0x0af0, 0xd257, 0x0000, 0x0000, 1258UNUSUAL_DEV( 0x0af0, 0xd257, 0x0000, 0x0000,
1232 "Option", 1259 "Option",
1233 "GI 1215 SD-Card", 1260 "GI 1215 SD-Card",
1234 US_SC_DEVICE, US_PR_DEVICE, NULL, 1261 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1235 0 ), 1262 0 ),
1236 1263
1237UNUSUAL_DEV( 0x0af0, 0xd357, 0x0000, 0x0000, 1264UNUSUAL_DEV( 0x0af0, 0xd357, 0x0000, 0x0000,
1238 "Option", 1265 "Option",
1239 "GI 1505 SD-Card", 1266 "GI 1505 SD-Card",
1240 US_SC_DEVICE, US_PR_DEVICE, NULL, 1267 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1241 0 ), 1268 0 ),
1242 1269
1243/* Reported by Ben Efros <ben@pc-doctor.com> */ 1270/* Reported by Ben Efros <ben@pc-doctor.com> */
1244UNUSUAL_DEV( 0x0bc2, 0x3010, 0x0000, 0x0000, 1271UNUSUAL_DEV( 0x0bc2, 0x3010, 0x0000, 0x0000,
1245 "Seagate", 1272 "Seagate",
1246 "FreeAgent Pro", 1273 "FreeAgent Pro",
1247 US_SC_DEVICE, US_PR_DEVICE, NULL, 1274 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1248 US_FL_SANE_SENSE ), 1275 US_FL_SANE_SENSE ),
1249 1276
1250UNUSUAL_DEV( 0x0d49, 0x7310, 0x0000, 0x9999, 1277UNUSUAL_DEV( 0x0d49, 0x7310, 0x0000, 0x9999,
1251 "Maxtor", 1278 "Maxtor",
1252 "USB to SATA", 1279 "USB to SATA",
1253 US_SC_DEVICE, US_PR_DEVICE, NULL, 1280 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1254 US_FL_SANE_SENSE), 1281 US_FL_SANE_SENSE),
1255 1282
1256/* 1283/*
@@ -1260,14 +1287,14 @@ UNUSUAL_DEV( 0x0d49, 0x7310, 0x0000, 0x9999,
1260UNUSUAL_DEV( 0x0c45, 0x1060, 0x0100, 0x0100, 1287UNUSUAL_DEV( 0x0c45, 0x1060, 0x0100, 0x0100,
1261 "Unknown", 1288 "Unknown",
1262 "Unknown", 1289 "Unknown",
1263 US_SC_DEVICE, US_PR_DEVICE, NULL, 1290 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1264 US_FL_SINGLE_LUN ), 1291 US_FL_SINGLE_LUN ),
1265 1292
1266/* Submitted by Joris Struyve <joris@struyve.be> */ 1293/* Submitted by Joris Struyve <joris@struyve.be> */
1267UNUSUAL_DEV( 0x0d96, 0x410a, 0x0001, 0xffff, 1294UNUSUAL_DEV( 0x0d96, 0x410a, 0x0001, 0xffff,
1268 "Medion", 1295 "Medion",
1269 "MD 7425", 1296 "MD 7425",
1270 US_SC_DEVICE, US_PR_DEVICE, NULL, 1297 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1271 US_FL_FIX_INQUIRY), 1298 US_FL_FIX_INQUIRY),
1272 1299
1273/* 1300/*
@@ -1278,13 +1305,13 @@ UNUSUAL_DEV( 0x0d96, 0x410a, 0x0001, 0xffff,
1278UNUSUAL_DEV( 0x0d96, 0x5200, 0x0001, 0x0200, 1305UNUSUAL_DEV( 0x0d96, 0x5200, 0x0001, 0x0200,
1279 "Jenoptik", 1306 "Jenoptik",
1280 "JD 5200 z3", 1307 "JD 5200 z3",
1281 US_SC_DEVICE, US_PR_DEVICE, NULL, US_FL_FIX_INQUIRY), 1308 USB_SC_DEVICE, USB_PR_DEVICE, NULL, US_FL_FIX_INQUIRY),
1282 1309
1283/* Reported by Jason Johnston <killean@shaw.ca> */ 1310/* Reported by Jason Johnston <killean@shaw.ca> */
1284UNUSUAL_DEV( 0x0dc4, 0x0073, 0x0000, 0x0000, 1311UNUSUAL_DEV( 0x0dc4, 0x0073, 0x0000, 0x0000,
1285 "Macpower Technology Co.LTD.", 1312 "Macpower Technology Co.LTD.",
1286 "USB 2.0 3.5\" DEVICE", 1313 "USB 2.0 3.5\" DEVICE",
1287 US_SC_DEVICE, US_PR_DEVICE, NULL, 1314 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1288 US_FL_FIX_CAPACITY), 1315 US_FL_FIX_CAPACITY),
1289 1316
1290/* Reported by Lubomir Blaha <tritol@trilogic.cz> 1317/* Reported by Lubomir Blaha <tritol@trilogic.cz>
@@ -1295,7 +1322,7 @@ UNUSUAL_DEV( 0x0dc4, 0x0073, 0x0000, 0x0000,
1295UNUSUAL_DEV( 0x0dd8, 0x1060, 0x0000, 0xffff, 1322UNUSUAL_DEV( 0x0dd8, 0x1060, 0x0000, 0xffff,
1296 "Netac", 1323 "Netac",
1297 "USB-CF-Card", 1324 "USB-CF-Card",
1298 US_SC_DEVICE, US_PR_DEVICE, NULL, 1325 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1299 US_FL_FIX_INQUIRY ), 1326 US_FL_FIX_INQUIRY ),
1300 1327
1301/* Reported by Edward Chapman (taken from linux-usb mailing list) 1328/* Reported by Edward Chapman (taken from linux-usb mailing list)
@@ -1303,7 +1330,7 @@ UNUSUAL_DEV( 0x0dd8, 0x1060, 0x0000, 0xffff,
1303UNUSUAL_DEV( 0x0dd8, 0xd202, 0x0000, 0x9999, 1330UNUSUAL_DEV( 0x0dd8, 0xd202, 0x0000, 0x9999,
1304 "Netac", 1331 "Netac",
1305 "USB Flash Disk", 1332 "USB Flash Disk",
1306 US_SC_DEVICE, US_PR_DEVICE, NULL, 1333 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1307 US_FL_IGNORE_RESIDUE ), 1334 US_FL_IGNORE_RESIDUE ),
1308 1335
1309 1336
@@ -1312,28 +1339,28 @@ UNUSUAL_DEV( 0x0dd8, 0xd202, 0x0000, 0x9999,
1312UNUSUAL_DEV( 0x0dda, 0x0001, 0x0012, 0x0012, 1339UNUSUAL_DEV( 0x0dda, 0x0001, 0x0012, 0x0012,
1313 "WINWARD", 1340 "WINWARD",
1314 "Music Disk", 1341 "Music Disk",
1315 US_SC_DEVICE, US_PR_DEVICE, NULL, 1342 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1316 US_FL_IGNORE_RESIDUE ), 1343 US_FL_IGNORE_RESIDUE ),
1317 1344
1318/* Reported by Ian McConnell <ian at emit.demon.co.uk> */ 1345/* Reported by Ian McConnell <ian at emit.demon.co.uk> */
1319UNUSUAL_DEV( 0x0dda, 0x0301, 0x0012, 0x0012, 1346UNUSUAL_DEV( 0x0dda, 0x0301, 0x0012, 0x0012,
1320 "PNP_MP3", 1347 "PNP_MP3",
1321 "PNP_MP3 PLAYER", 1348 "PNP_MP3 PLAYER",
1322 US_SC_DEVICE, US_PR_DEVICE, NULL, 1349 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1323 US_FL_IGNORE_RESIDUE ), 1350 US_FL_IGNORE_RESIDUE ),
1324 1351
1325/* Reported by Jim McCloskey <mcclosk@ucsc.edu> */ 1352/* Reported by Jim McCloskey <mcclosk@ucsc.edu> */
1326UNUSUAL_DEV( 0x0e21, 0x0520, 0x0100, 0x0100, 1353UNUSUAL_DEV( 0x0e21, 0x0520, 0x0100, 0x0100,
1327 "Cowon Systems", 1354 "Cowon Systems",
1328 "iAUDIO M5", 1355 "iAUDIO M5",
1329 US_SC_DEVICE, US_PR_BULK, NULL, 1356 USB_SC_DEVICE, USB_PR_BULK, NULL,
1330 US_FL_NEED_OVERRIDE ), 1357 US_FL_NEED_OVERRIDE ),
1331 1358
1332/* Submitted by Antoine Mairesse <antoine.mairesse@free.fr> */ 1359/* Submitted by Antoine Mairesse <antoine.mairesse@free.fr> */
1333UNUSUAL_DEV( 0x0ed1, 0x6660, 0x0100, 0x0300, 1360UNUSUAL_DEV( 0x0ed1, 0x6660, 0x0100, 0x0300,
1334 "USB", 1361 "USB",
1335 "Solid state disk", 1362 "Solid state disk",
1336 US_SC_DEVICE, US_PR_DEVICE, NULL, 1363 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1337 US_FL_FIX_INQUIRY ), 1364 US_FL_FIX_INQUIRY ),
1338 1365
1339/* Submitted by Daniel Drake <dsd@gentoo.org> 1366/* Submitted by Daniel Drake <dsd@gentoo.org>
@@ -1341,14 +1368,14 @@ UNUSUAL_DEV( 0x0ed1, 0x6660, 0x0100, 0x0300,
1341UNUSUAL_DEV( 0x0ea0, 0x2168, 0x0110, 0x0110, 1368UNUSUAL_DEV( 0x0ea0, 0x2168, 0x0110, 0x0110,
1342 "Ours Technology", 1369 "Ours Technology",
1343 "Flash Disk", 1370 "Flash Disk",
1344 US_SC_DEVICE, US_PR_DEVICE, NULL, 1371 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1345 US_FL_IGNORE_RESIDUE ), 1372 US_FL_IGNORE_RESIDUE ),
1346 1373
1347/* Reported by Rastislav Stanik <rs_kernel@yahoo.com> */ 1374/* Reported by Rastislav Stanik <rs_kernel@yahoo.com> */
1348UNUSUAL_DEV( 0x0ea0, 0x6828, 0x0110, 0x0110, 1375UNUSUAL_DEV( 0x0ea0, 0x6828, 0x0110, 0x0110,
1349 "USB", 1376 "USB",
1350 "Flash Disk", 1377 "Flash Disk",
1351 US_SC_DEVICE, US_PR_DEVICE, NULL, 1378 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1352 US_FL_IGNORE_RESIDUE ), 1379 US_FL_IGNORE_RESIDUE ),
1353 1380
1354/* Reported by Benjamin Schiller <sbenni@gmx.de> 1381/* Reported by Benjamin Schiller <sbenni@gmx.de>
@@ -1356,7 +1383,7 @@ UNUSUAL_DEV( 0x0ea0, 0x6828, 0x0110, 0x0110,
1356UNUSUAL_DEV( 0x0ed1, 0x7636, 0x0103, 0x0103, 1383UNUSUAL_DEV( 0x0ed1, 0x7636, 0x0103, 0x0103,
1357 "Typhoon", 1384 "Typhoon",
1358 "My DJ 1820", 1385 "My DJ 1820",
1359 US_SC_DEVICE, US_PR_DEVICE, NULL, 1386 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1360 US_FL_IGNORE_RESIDUE | US_FL_GO_SLOW | US_FL_MAX_SECTORS_64), 1387 US_FL_IGNORE_RESIDUE | US_FL_GO_SLOW | US_FL_MAX_SECTORS_64),
1361 1388
1362/* Patch by Leonid Petrov mail at lpetrov.net 1389/* Patch by Leonid Petrov mail at lpetrov.net
@@ -1367,7 +1394,7 @@ UNUSUAL_DEV( 0x0ed1, 0x7636, 0x0103, 0x0103,
1367UNUSUAL_DEV( 0x0f19, 0x0103, 0x0100, 0x0100, 1394UNUSUAL_DEV( 0x0f19, 0x0103, 0x0100, 0x0100,
1368 "Oracom Co., Ltd", 1395 "Oracom Co., Ltd",
1369 "ORC-200M", 1396 "ORC-200M",
1370 US_SC_DEVICE, US_PR_DEVICE, NULL, 1397 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1371 US_FL_IGNORE_RESIDUE ), 1398 US_FL_IGNORE_RESIDUE ),
1372 1399
1373/* David Kuehling <dvdkhlng@gmx.de>: 1400/* David Kuehling <dvdkhlng@gmx.de>:
@@ -1377,21 +1404,28 @@ UNUSUAL_DEV( 0x0f19, 0x0103, 0x0100, 0x0100,
1377UNUSUAL_DEV( 0x0f19, 0x0105, 0x0100, 0x0100, 1404UNUSUAL_DEV( 0x0f19, 0x0105, 0x0100, 0x0100,
1378 "C-MEX", 1405 "C-MEX",
1379 "A-VOX", 1406 "A-VOX",
1380 US_SC_DEVICE, US_PR_DEVICE, NULL, 1407 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1381 US_FL_IGNORE_RESIDUE ), 1408 US_FL_IGNORE_RESIDUE ),
1382 1409
1410/* Submitted by Nick Holloway */
1411UNUSUAL_DEV( 0x0f88, 0x042e, 0x0100, 0x0100,
1412 "VTech",
1413 "Kidizoom",
1414 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1415 US_FL_FIX_CAPACITY ),
1416
1383/* Reported by Michael Stattmann <michael@stattmann.com> */ 1417/* Reported by Michael Stattmann <michael@stattmann.com> */
1384UNUSUAL_DEV( 0x0fce, 0xd008, 0x0000, 0x0000, 1418UNUSUAL_DEV( 0x0fce, 0xd008, 0x0000, 0x0000,
1385 "Sony Ericsson", 1419 "Sony Ericsson",
1386 "V800-Vodafone 802", 1420 "V800-Vodafone 802",
1387 US_SC_DEVICE, US_PR_DEVICE, NULL, 1421 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1388 US_FL_NO_WP_DETECT ), 1422 US_FL_NO_WP_DETECT ),
1389 1423
1390/* Reported by The Solutor <thesolutor@gmail.com> */ 1424/* Reported by The Solutor <thesolutor@gmail.com> */
1391UNUSUAL_DEV( 0x0fce, 0xd0e1, 0x0000, 0x0000, 1425UNUSUAL_DEV( 0x0fce, 0xd0e1, 0x0000, 0x0000,
1392 "Sony Ericsson", 1426 "Sony Ericsson",
1393 "MD400", 1427 "MD400",
1394 US_SC_DEVICE, US_PR_DEVICE, NULL, 1428 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1395 US_FL_IGNORE_DEVICE), 1429 US_FL_IGNORE_DEVICE),
1396 1430
1397/* Reported by Jan Mate <mate@fiit.stuba.sk> 1431/* Reported by Jan Mate <mate@fiit.stuba.sk>
@@ -1399,21 +1433,21 @@ UNUSUAL_DEV( 0x0fce, 0xd0e1, 0x0000, 0x0000,
1399UNUSUAL_DEV( 0x0fce, 0xe030, 0x0000, 0x0000, 1433UNUSUAL_DEV( 0x0fce, 0xe030, 0x0000, 0x0000,
1400 "Sony Ericsson", 1434 "Sony Ericsson",
1401 "P990i", 1435 "P990i",
1402 US_SC_DEVICE, US_PR_DEVICE, NULL, 1436 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1403 US_FL_FIX_CAPACITY | US_FL_IGNORE_RESIDUE ), 1437 US_FL_FIX_CAPACITY | US_FL_IGNORE_RESIDUE ),
1404 1438
1405/* Reported by Emmanuel Vasilakis <evas@forthnet.gr> */ 1439/* Reported by Emmanuel Vasilakis <evas@forthnet.gr> */
1406UNUSUAL_DEV( 0x0fce, 0xe031, 0x0000, 0x0000, 1440UNUSUAL_DEV( 0x0fce, 0xe031, 0x0000, 0x0000,
1407 "Sony Ericsson", 1441 "Sony Ericsson",
1408 "M600i", 1442 "M600i",
1409 US_SC_DEVICE, US_PR_DEVICE, NULL, 1443 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1410 US_FL_IGNORE_RESIDUE | US_FL_FIX_CAPACITY ), 1444 US_FL_IGNORE_RESIDUE | US_FL_FIX_CAPACITY ),
1411 1445
1412/* Reported by Ricardo Barberis <ricardo@dattatec.com> */ 1446/* Reported by Ricardo Barberis <ricardo@dattatec.com> */
1413UNUSUAL_DEV( 0x0fce, 0xe092, 0x0000, 0x0000, 1447UNUSUAL_DEV( 0x0fce, 0xe092, 0x0000, 0x0000,
1414 "Sony Ericsson", 1448 "Sony Ericsson",
1415 "P1i", 1449 "P1i",
1416 US_SC_DEVICE, US_PR_DEVICE, NULL, 1450 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1417 US_FL_IGNORE_RESIDUE ), 1451 US_FL_IGNORE_RESIDUE ),
1418 1452
1419/* Reported by Kevin Cernekee <kpc-usbdev@gelato.uiuc.edu> 1453/* Reported by Kevin Cernekee <kpc-usbdev@gelato.uiuc.edu>
@@ -1425,13 +1459,13 @@ UNUSUAL_DEV( 0x0fce, 0xe092, 0x0000, 0x0000,
1425UNUSUAL_DEV( 0x1019, 0x0c55, 0x0000, 0x0110, 1459UNUSUAL_DEV( 0x1019, 0x0c55, 0x0000, 0x0110,
1426 "Desknote", 1460 "Desknote",
1427 "UCR-61S2B", 1461 "UCR-61S2B",
1428 US_SC_DEVICE, US_PR_DEVICE, usb_stor_ucr61s2b_init, 1462 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_ucr61s2b_init,
1429 0 ), 1463 0 ),
1430 1464
1431UNUSUAL_DEV( 0x1058, 0x0704, 0x0000, 0x9999, 1465UNUSUAL_DEV( 0x1058, 0x0704, 0x0000, 0x9999,
1432 "Western Digital", 1466 "Western Digital",
1433 "External HDD", 1467 "External HDD",
1434 US_SC_DEVICE, US_PR_DEVICE, NULL, 1468 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1435 US_FL_SANE_SENSE), 1469 US_FL_SANE_SENSE),
1436 1470
1437/* Reported by Fabio Venturi <f.venturi@tdnet.it> 1471/* Reported by Fabio Venturi <f.venturi@tdnet.it>
@@ -1440,7 +1474,7 @@ UNUSUAL_DEV( 0x1058, 0x0704, 0x0000, 0x9999,
1440UNUSUAL_DEV( 0x10d6, 0x2200, 0x0100, 0x0100, 1474UNUSUAL_DEV( 0x10d6, 0x2200, 0x0100, 0x0100,
1441 "Actions Semiconductor", 1475 "Actions Semiconductor",
1442 "Mtp device", 1476 "Mtp device",
1443 US_SC_DEVICE, US_PR_DEVICE, NULL, 1477 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1444 0), 1478 0),
1445 1479
1446/* Reported by Pascal Terjan <pterjan@mandriva.com> 1480/* Reported by Pascal Terjan <pterjan@mandriva.com>
@@ -1449,7 +1483,7 @@ UNUSUAL_DEV( 0x10d6, 0x2200, 0x0100, 0x0100,
1449UNUSUAL_DEV( 0x1186, 0x3e04, 0x0000, 0x0000, 1483UNUSUAL_DEV( 0x1186, 0x3e04, 0x0000, 0x0000,
1450 "D-Link", 1484 "D-Link",
1451 "USB Mass Storage", 1485 "USB Mass Storage",
1452 US_SC_DEVICE, US_PR_DEVICE, option_ms_init, US_FL_IGNORE_DEVICE), 1486 USB_SC_DEVICE, USB_PR_DEVICE, option_ms_init, US_FL_IGNORE_DEVICE),
1453 1487
1454/* Reported by Kevin Lloyd <linux@sierrawireless.com> 1488/* Reported by Kevin Lloyd <linux@sierrawireless.com>
1455 * Entry is needed for the initializer function override, 1489 * Entry is needed for the initializer function override,
@@ -1459,7 +1493,7 @@ UNUSUAL_DEV( 0x1186, 0x3e04, 0x0000, 0x0000,
1459UNUSUAL_DEV( 0x1199, 0x0fff, 0x0000, 0x9999, 1493UNUSUAL_DEV( 0x1199, 0x0fff, 0x0000, 0x9999,
1460 "Sierra Wireless", 1494 "Sierra Wireless",
1461 "USB MMC Storage", 1495 "USB MMC Storage",
1462 US_SC_DEVICE, US_PR_DEVICE, sierra_ms_init, 1496 USB_SC_DEVICE, USB_PR_DEVICE, sierra_ms_init,
1463 0), 1497 0),
1464 1498
1465/* Reported by Jaco Kroon <jaco@kroon.co.za> 1499/* Reported by Jaco Kroon <jaco@kroon.co.za>
@@ -1469,7 +1503,7 @@ UNUSUAL_DEV( 0x1199, 0x0fff, 0x0000, 0x9999,
1469UNUSUAL_DEV( 0x1210, 0x0003, 0x0100, 0x0100, 1503UNUSUAL_DEV( 0x1210, 0x0003, 0x0100, 0x0100,
1470 "Digitech HMG", 1504 "Digitech HMG",
1471 "DigiTech Mass Storage", 1505 "DigiTech Mass Storage",
1472 US_SC_DEVICE, US_PR_DEVICE, NULL, 1506 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1473 US_FL_IGNORE_RESIDUE ), 1507 US_FL_IGNORE_RESIDUE ),
1474 1508
1475/* Reported by fangxiaozhi <huananhu@huawei.com> 1509/* Reported by fangxiaozhi <huananhu@huawei.com>
@@ -1478,353 +1512,353 @@ UNUSUAL_DEV( 0x1210, 0x0003, 0x0100, 0x0100,
1478UNUSUAL_DEV( 0x12d1, 0x1001, 0x0000, 0x0000, 1512UNUSUAL_DEV( 0x12d1, 0x1001, 0x0000, 0x0000,
1479 "HUAWEI MOBILE", 1513 "HUAWEI MOBILE",
1480 "Mass Storage", 1514 "Mass Storage",
1481 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1515 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1482 0), 1516 0),
1483UNUSUAL_DEV( 0x12d1, 0x1003, 0x0000, 0x0000, 1517UNUSUAL_DEV( 0x12d1, 0x1003, 0x0000, 0x0000,
1484 "HUAWEI MOBILE", 1518 "HUAWEI MOBILE",
1485 "Mass Storage", 1519 "Mass Storage",
1486 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1520 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1487 0), 1521 0),
1488UNUSUAL_DEV( 0x12d1, 0x1004, 0x0000, 0x0000, 1522UNUSUAL_DEV( 0x12d1, 0x1004, 0x0000, 0x0000,
1489 "HUAWEI MOBILE", 1523 "HUAWEI MOBILE",
1490 "Mass Storage", 1524 "Mass Storage",
1491 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1525 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1492 0), 1526 0),
1493UNUSUAL_DEV( 0x12d1, 0x1401, 0x0000, 0x0000, 1527UNUSUAL_DEV( 0x12d1, 0x1401, 0x0000, 0x0000,
1494 "HUAWEI MOBILE", 1528 "HUAWEI MOBILE",
1495 "Mass Storage", 1529 "Mass Storage",
1496 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1530 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1497 0), 1531 0),
1498UNUSUAL_DEV( 0x12d1, 0x1402, 0x0000, 0x0000, 1532UNUSUAL_DEV( 0x12d1, 0x1402, 0x0000, 0x0000,
1499 "HUAWEI MOBILE", 1533 "HUAWEI MOBILE",
1500 "Mass Storage", 1534 "Mass Storage",
1501 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1535 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1502 0), 1536 0),
1503UNUSUAL_DEV( 0x12d1, 0x1403, 0x0000, 0x0000, 1537UNUSUAL_DEV( 0x12d1, 0x1403, 0x0000, 0x0000,
1504 "HUAWEI MOBILE", 1538 "HUAWEI MOBILE",
1505 "Mass Storage", 1539 "Mass Storage",
1506 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1540 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1507 0), 1541 0),
1508UNUSUAL_DEV( 0x12d1, 0x1404, 0x0000, 0x0000, 1542UNUSUAL_DEV( 0x12d1, 0x1404, 0x0000, 0x0000,
1509 "HUAWEI MOBILE", 1543 "HUAWEI MOBILE",
1510 "Mass Storage", 1544 "Mass Storage",
1511 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1545 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1512 0), 1546 0),
1513UNUSUAL_DEV( 0x12d1, 0x1405, 0x0000, 0x0000, 1547UNUSUAL_DEV( 0x12d1, 0x1405, 0x0000, 0x0000,
1514 "HUAWEI MOBILE", 1548 "HUAWEI MOBILE",
1515 "Mass Storage", 1549 "Mass Storage",
1516 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1550 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1517 0), 1551 0),
1518UNUSUAL_DEV( 0x12d1, 0x1406, 0x0000, 0x0000, 1552UNUSUAL_DEV( 0x12d1, 0x1406, 0x0000, 0x0000,
1519 "HUAWEI MOBILE", 1553 "HUAWEI MOBILE",
1520 "Mass Storage", 1554 "Mass Storage",
1521 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1555 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1522 0), 1556 0),
1523UNUSUAL_DEV( 0x12d1, 0x1407, 0x0000, 0x0000, 1557UNUSUAL_DEV( 0x12d1, 0x1407, 0x0000, 0x0000,
1524 "HUAWEI MOBILE", 1558 "HUAWEI MOBILE",
1525 "Mass Storage", 1559 "Mass Storage",
1526 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1560 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1527 0), 1561 0),
1528UNUSUAL_DEV( 0x12d1, 0x1408, 0x0000, 0x0000, 1562UNUSUAL_DEV( 0x12d1, 0x1408, 0x0000, 0x0000,
1529 "HUAWEI MOBILE", 1563 "HUAWEI MOBILE",
1530 "Mass Storage", 1564 "Mass Storage",
1531 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1565 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1532 0), 1566 0),
1533UNUSUAL_DEV( 0x12d1, 0x1409, 0x0000, 0x0000, 1567UNUSUAL_DEV( 0x12d1, 0x1409, 0x0000, 0x0000,
1534 "HUAWEI MOBILE", 1568 "HUAWEI MOBILE",
1535 "Mass Storage", 1569 "Mass Storage",
1536 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1570 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1537 0), 1571 0),
1538UNUSUAL_DEV( 0x12d1, 0x140A, 0x0000, 0x0000, 1572UNUSUAL_DEV( 0x12d1, 0x140A, 0x0000, 0x0000,
1539 "HUAWEI MOBILE", 1573 "HUAWEI MOBILE",
1540 "Mass Storage", 1574 "Mass Storage",
1541 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1575 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1542 0), 1576 0),
1543UNUSUAL_DEV( 0x12d1, 0x140B, 0x0000, 0x0000, 1577UNUSUAL_DEV( 0x12d1, 0x140B, 0x0000, 0x0000,
1544 "HUAWEI MOBILE", 1578 "HUAWEI MOBILE",
1545 "Mass Storage", 1579 "Mass Storage",
1546 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1580 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1547 0), 1581 0),
1548UNUSUAL_DEV( 0x12d1, 0x140C, 0x0000, 0x0000, 1582UNUSUAL_DEV( 0x12d1, 0x140C, 0x0000, 0x0000,
1549 "HUAWEI MOBILE", 1583 "HUAWEI MOBILE",
1550 "Mass Storage", 1584 "Mass Storage",
1551 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1585 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1552 0), 1586 0),
1553UNUSUAL_DEV( 0x12d1, 0x140D, 0x0000, 0x0000, 1587UNUSUAL_DEV( 0x12d1, 0x140D, 0x0000, 0x0000,
1554 "HUAWEI MOBILE", 1588 "HUAWEI MOBILE",
1555 "Mass Storage", 1589 "Mass Storage",
1556 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1590 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1557 0), 1591 0),
1558UNUSUAL_DEV( 0x12d1, 0x140E, 0x0000, 0x0000, 1592UNUSUAL_DEV( 0x12d1, 0x140E, 0x0000, 0x0000,
1559 "HUAWEI MOBILE", 1593 "HUAWEI MOBILE",
1560 "Mass Storage", 1594 "Mass Storage",
1561 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1595 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1562 0), 1596 0),
1563UNUSUAL_DEV( 0x12d1, 0x140F, 0x0000, 0x0000, 1597UNUSUAL_DEV( 0x12d1, 0x140F, 0x0000, 0x0000,
1564 "HUAWEI MOBILE", 1598 "HUAWEI MOBILE",
1565 "Mass Storage", 1599 "Mass Storage",
1566 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1600 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1567 0), 1601 0),
1568UNUSUAL_DEV( 0x12d1, 0x1410, 0x0000, 0x0000, 1602UNUSUAL_DEV( 0x12d1, 0x1410, 0x0000, 0x0000,
1569 "HUAWEI MOBILE", 1603 "HUAWEI MOBILE",
1570 "Mass Storage", 1604 "Mass Storage",
1571 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1605 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1572 0), 1606 0),
1573UNUSUAL_DEV( 0x12d1, 0x1411, 0x0000, 0x0000, 1607UNUSUAL_DEV( 0x12d1, 0x1411, 0x0000, 0x0000,
1574 "HUAWEI MOBILE", 1608 "HUAWEI MOBILE",
1575 "Mass Storage", 1609 "Mass Storage",
1576 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1610 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1577 0), 1611 0),
1578UNUSUAL_DEV( 0x12d1, 0x1412, 0x0000, 0x0000, 1612UNUSUAL_DEV( 0x12d1, 0x1412, 0x0000, 0x0000,
1579 "HUAWEI MOBILE", 1613 "HUAWEI MOBILE",
1580 "Mass Storage", 1614 "Mass Storage",
1581 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1615 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1582 0), 1616 0),
1583UNUSUAL_DEV( 0x12d1, 0x1413, 0x0000, 0x0000, 1617UNUSUAL_DEV( 0x12d1, 0x1413, 0x0000, 0x0000,
1584 "HUAWEI MOBILE", 1618 "HUAWEI MOBILE",
1585 "Mass Storage", 1619 "Mass Storage",
1586 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1620 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1587 0), 1621 0),
1588UNUSUAL_DEV( 0x12d1, 0x1414, 0x0000, 0x0000, 1622UNUSUAL_DEV( 0x12d1, 0x1414, 0x0000, 0x0000,
1589 "HUAWEI MOBILE", 1623 "HUAWEI MOBILE",
1590 "Mass Storage", 1624 "Mass Storage",
1591 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1625 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1592 0), 1626 0),
1593UNUSUAL_DEV( 0x12d1, 0x1415, 0x0000, 0x0000, 1627UNUSUAL_DEV( 0x12d1, 0x1415, 0x0000, 0x0000,
1594 "HUAWEI MOBILE", 1628 "HUAWEI MOBILE",
1595 "Mass Storage", 1629 "Mass Storage",
1596 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1630 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1597 0), 1631 0),
1598UNUSUAL_DEV( 0x12d1, 0x1416, 0x0000, 0x0000, 1632UNUSUAL_DEV( 0x12d1, 0x1416, 0x0000, 0x0000,
1599 "HUAWEI MOBILE", 1633 "HUAWEI MOBILE",
1600 "Mass Storage", 1634 "Mass Storage",
1601 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1635 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1602 0), 1636 0),
1603UNUSUAL_DEV( 0x12d1, 0x1417, 0x0000, 0x0000, 1637UNUSUAL_DEV( 0x12d1, 0x1417, 0x0000, 0x0000,
1604 "HUAWEI MOBILE", 1638 "HUAWEI MOBILE",
1605 "Mass Storage", 1639 "Mass Storage",
1606 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1640 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1607 0), 1641 0),
1608UNUSUAL_DEV( 0x12d1, 0x1418, 0x0000, 0x0000, 1642UNUSUAL_DEV( 0x12d1, 0x1418, 0x0000, 0x0000,
1609 "HUAWEI MOBILE", 1643 "HUAWEI MOBILE",
1610 "Mass Storage", 1644 "Mass Storage",
1611 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1645 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1612 0), 1646 0),
1613UNUSUAL_DEV( 0x12d1, 0x1419, 0x0000, 0x0000, 1647UNUSUAL_DEV( 0x12d1, 0x1419, 0x0000, 0x0000,
1614 "HUAWEI MOBILE", 1648 "HUAWEI MOBILE",
1615 "Mass Storage", 1649 "Mass Storage",
1616 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1650 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1617 0), 1651 0),
1618UNUSUAL_DEV( 0x12d1, 0x141A, 0x0000, 0x0000, 1652UNUSUAL_DEV( 0x12d1, 0x141A, 0x0000, 0x0000,
1619 "HUAWEI MOBILE", 1653 "HUAWEI MOBILE",
1620 "Mass Storage", 1654 "Mass Storage",
1621 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1655 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1622 0), 1656 0),
1623UNUSUAL_DEV( 0x12d1, 0x141B, 0x0000, 0x0000, 1657UNUSUAL_DEV( 0x12d1, 0x141B, 0x0000, 0x0000,
1624 "HUAWEI MOBILE", 1658 "HUAWEI MOBILE",
1625 "Mass Storage", 1659 "Mass Storage",
1626 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1660 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1627 0), 1661 0),
1628UNUSUAL_DEV( 0x12d1, 0x141C, 0x0000, 0x0000, 1662UNUSUAL_DEV( 0x12d1, 0x141C, 0x0000, 0x0000,
1629 "HUAWEI MOBILE", 1663 "HUAWEI MOBILE",
1630 "Mass Storage", 1664 "Mass Storage",
1631 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1665 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1632 0), 1666 0),
1633UNUSUAL_DEV( 0x12d1, 0x141D, 0x0000, 0x0000, 1667UNUSUAL_DEV( 0x12d1, 0x141D, 0x0000, 0x0000,
1634 "HUAWEI MOBILE", 1668 "HUAWEI MOBILE",
1635 "Mass Storage", 1669 "Mass Storage",
1636 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1670 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1637 0), 1671 0),
1638UNUSUAL_DEV( 0x12d1, 0x141E, 0x0000, 0x0000, 1672UNUSUAL_DEV( 0x12d1, 0x141E, 0x0000, 0x0000,
1639 "HUAWEI MOBILE", 1673 "HUAWEI MOBILE",
1640 "Mass Storage", 1674 "Mass Storage",
1641 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1675 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1642 0), 1676 0),
1643UNUSUAL_DEV( 0x12d1, 0x141F, 0x0000, 0x0000, 1677UNUSUAL_DEV( 0x12d1, 0x141F, 0x0000, 0x0000,
1644 "HUAWEI MOBILE", 1678 "HUAWEI MOBILE",
1645 "Mass Storage", 1679 "Mass Storage",
1646 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1680 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1647 0), 1681 0),
1648UNUSUAL_DEV( 0x12d1, 0x1420, 0x0000, 0x0000, 1682UNUSUAL_DEV( 0x12d1, 0x1420, 0x0000, 0x0000,
1649 "HUAWEI MOBILE", 1683 "HUAWEI MOBILE",
1650 "Mass Storage", 1684 "Mass Storage",
1651 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1685 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1652 0), 1686 0),
1653UNUSUAL_DEV( 0x12d1, 0x1421, 0x0000, 0x0000, 1687UNUSUAL_DEV( 0x12d1, 0x1421, 0x0000, 0x0000,
1654 "HUAWEI MOBILE", 1688 "HUAWEI MOBILE",
1655 "Mass Storage", 1689 "Mass Storage",
1656 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1690 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1657 0), 1691 0),
1658UNUSUAL_DEV( 0x12d1, 0x1422, 0x0000, 0x0000, 1692UNUSUAL_DEV( 0x12d1, 0x1422, 0x0000, 0x0000,
1659 "HUAWEI MOBILE", 1693 "HUAWEI MOBILE",
1660 "Mass Storage", 1694 "Mass Storage",
1661 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1695 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1662 0), 1696 0),
1663UNUSUAL_DEV( 0x12d1, 0x1423, 0x0000, 0x0000, 1697UNUSUAL_DEV( 0x12d1, 0x1423, 0x0000, 0x0000,
1664 "HUAWEI MOBILE", 1698 "HUAWEI MOBILE",
1665 "Mass Storage", 1699 "Mass Storage",
1666 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1700 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1667 0), 1701 0),
1668UNUSUAL_DEV( 0x12d1, 0x1424, 0x0000, 0x0000, 1702UNUSUAL_DEV( 0x12d1, 0x1424, 0x0000, 0x0000,
1669 "HUAWEI MOBILE", 1703 "HUAWEI MOBILE",
1670 "Mass Storage", 1704 "Mass Storage",
1671 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1705 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1672 0), 1706 0),
1673UNUSUAL_DEV( 0x12d1, 0x1425, 0x0000, 0x0000, 1707UNUSUAL_DEV( 0x12d1, 0x1425, 0x0000, 0x0000,
1674 "HUAWEI MOBILE", 1708 "HUAWEI MOBILE",
1675 "Mass Storage", 1709 "Mass Storage",
1676 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1710 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1677 0), 1711 0),
1678UNUSUAL_DEV( 0x12d1, 0x1426, 0x0000, 0x0000, 1712UNUSUAL_DEV( 0x12d1, 0x1426, 0x0000, 0x0000,
1679 "HUAWEI MOBILE", 1713 "HUAWEI MOBILE",
1680 "Mass Storage", 1714 "Mass Storage",
1681 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1715 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1682 0), 1716 0),
1683UNUSUAL_DEV( 0x12d1, 0x1427, 0x0000, 0x0000, 1717UNUSUAL_DEV( 0x12d1, 0x1427, 0x0000, 0x0000,
1684 "HUAWEI MOBILE", 1718 "HUAWEI MOBILE",
1685 "Mass Storage", 1719 "Mass Storage",
1686 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1720 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1687 0), 1721 0),
1688UNUSUAL_DEV( 0x12d1, 0x1428, 0x0000, 0x0000, 1722UNUSUAL_DEV( 0x12d1, 0x1428, 0x0000, 0x0000,
1689 "HUAWEI MOBILE", 1723 "HUAWEI MOBILE",
1690 "Mass Storage", 1724 "Mass Storage",
1691 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1725 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1692 0), 1726 0),
1693UNUSUAL_DEV( 0x12d1, 0x1429, 0x0000, 0x0000, 1727UNUSUAL_DEV( 0x12d1, 0x1429, 0x0000, 0x0000,
1694 "HUAWEI MOBILE", 1728 "HUAWEI MOBILE",
1695 "Mass Storage", 1729 "Mass Storage",
1696 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1730 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1697 0), 1731 0),
1698UNUSUAL_DEV( 0x12d1, 0x142A, 0x0000, 0x0000, 1732UNUSUAL_DEV( 0x12d1, 0x142A, 0x0000, 0x0000,
1699 "HUAWEI MOBILE", 1733 "HUAWEI MOBILE",
1700 "Mass Storage", 1734 "Mass Storage",
1701 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1735 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1702 0), 1736 0),
1703UNUSUAL_DEV( 0x12d1, 0x142B, 0x0000, 0x0000, 1737UNUSUAL_DEV( 0x12d1, 0x142B, 0x0000, 0x0000,
1704 "HUAWEI MOBILE", 1738 "HUAWEI MOBILE",
1705 "Mass Storage", 1739 "Mass Storage",
1706 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1740 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1707 0), 1741 0),
1708UNUSUAL_DEV( 0x12d1, 0x142C, 0x0000, 0x0000, 1742UNUSUAL_DEV( 0x12d1, 0x142C, 0x0000, 0x0000,
1709 "HUAWEI MOBILE", 1743 "HUAWEI MOBILE",
1710 "Mass Storage", 1744 "Mass Storage",
1711 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1745 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1712 0), 1746 0),
1713UNUSUAL_DEV( 0x12d1, 0x142D, 0x0000, 0x0000, 1747UNUSUAL_DEV( 0x12d1, 0x142D, 0x0000, 0x0000,
1714 "HUAWEI MOBILE", 1748 "HUAWEI MOBILE",
1715 "Mass Storage", 1749 "Mass Storage",
1716 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1750 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1717 0), 1751 0),
1718UNUSUAL_DEV( 0x12d1, 0x142E, 0x0000, 0x0000, 1752UNUSUAL_DEV( 0x12d1, 0x142E, 0x0000, 0x0000,
1719 "HUAWEI MOBILE", 1753 "HUAWEI MOBILE",
1720 "Mass Storage", 1754 "Mass Storage",
1721 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1755 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1722 0), 1756 0),
1723UNUSUAL_DEV( 0x12d1, 0x142F, 0x0000, 0x0000, 1757UNUSUAL_DEV( 0x12d1, 0x142F, 0x0000, 0x0000,
1724 "HUAWEI MOBILE", 1758 "HUAWEI MOBILE",
1725 "Mass Storage", 1759 "Mass Storage",
1726 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1760 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1727 0), 1761 0),
1728UNUSUAL_DEV( 0x12d1, 0x1430, 0x0000, 0x0000, 1762UNUSUAL_DEV( 0x12d1, 0x1430, 0x0000, 0x0000,
1729 "HUAWEI MOBILE", 1763 "HUAWEI MOBILE",
1730 "Mass Storage", 1764 "Mass Storage",
1731 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1765 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1732 0), 1766 0),
1733UNUSUAL_DEV( 0x12d1, 0x1431, 0x0000, 0x0000, 1767UNUSUAL_DEV( 0x12d1, 0x1431, 0x0000, 0x0000,
1734 "HUAWEI MOBILE", 1768 "HUAWEI MOBILE",
1735 "Mass Storage", 1769 "Mass Storage",
1736 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1770 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1737 0), 1771 0),
1738UNUSUAL_DEV( 0x12d1, 0x1432, 0x0000, 0x0000, 1772UNUSUAL_DEV( 0x12d1, 0x1432, 0x0000, 0x0000,
1739 "HUAWEI MOBILE", 1773 "HUAWEI MOBILE",
1740 "Mass Storage", 1774 "Mass Storage",
1741 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1775 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1742 0), 1776 0),
1743UNUSUAL_DEV( 0x12d1, 0x1433, 0x0000, 0x0000, 1777UNUSUAL_DEV( 0x12d1, 0x1433, 0x0000, 0x0000,
1744 "HUAWEI MOBILE", 1778 "HUAWEI MOBILE",
1745 "Mass Storage", 1779 "Mass Storage",
1746 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1780 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1747 0), 1781 0),
1748UNUSUAL_DEV( 0x12d1, 0x1434, 0x0000, 0x0000, 1782UNUSUAL_DEV( 0x12d1, 0x1434, 0x0000, 0x0000,
1749 "HUAWEI MOBILE", 1783 "HUAWEI MOBILE",
1750 "Mass Storage", 1784 "Mass Storage",
1751 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1785 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1752 0), 1786 0),
1753UNUSUAL_DEV( 0x12d1, 0x1435, 0x0000, 0x0000, 1787UNUSUAL_DEV( 0x12d1, 0x1435, 0x0000, 0x0000,
1754 "HUAWEI MOBILE", 1788 "HUAWEI MOBILE",
1755 "Mass Storage", 1789 "Mass Storage",
1756 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1790 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1757 0), 1791 0),
1758UNUSUAL_DEV( 0x12d1, 0x1436, 0x0000, 0x0000, 1792UNUSUAL_DEV( 0x12d1, 0x1436, 0x0000, 0x0000,
1759 "HUAWEI MOBILE", 1793 "HUAWEI MOBILE",
1760 "Mass Storage", 1794 "Mass Storage",
1761 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1795 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1762 0), 1796 0),
1763UNUSUAL_DEV( 0x12d1, 0x1437, 0x0000, 0x0000, 1797UNUSUAL_DEV( 0x12d1, 0x1437, 0x0000, 0x0000,
1764 "HUAWEI MOBILE", 1798 "HUAWEI MOBILE",
1765 "Mass Storage", 1799 "Mass Storage",
1766 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1800 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1767 0), 1801 0),
1768UNUSUAL_DEV( 0x12d1, 0x1438, 0x0000, 0x0000, 1802UNUSUAL_DEV( 0x12d1, 0x1438, 0x0000, 0x0000,
1769 "HUAWEI MOBILE", 1803 "HUAWEI MOBILE",
1770 "Mass Storage", 1804 "Mass Storage",
1771 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1805 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1772 0), 1806 0),
1773UNUSUAL_DEV( 0x12d1, 0x1439, 0x0000, 0x0000, 1807UNUSUAL_DEV( 0x12d1, 0x1439, 0x0000, 0x0000,
1774 "HUAWEI MOBILE", 1808 "HUAWEI MOBILE",
1775 "Mass Storage", 1809 "Mass Storage",
1776 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1810 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1777 0), 1811 0),
1778UNUSUAL_DEV( 0x12d1, 0x143A, 0x0000, 0x0000, 1812UNUSUAL_DEV( 0x12d1, 0x143A, 0x0000, 0x0000,
1779 "HUAWEI MOBILE", 1813 "HUAWEI MOBILE",
1780 "Mass Storage", 1814 "Mass Storage",
1781 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1815 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1782 0), 1816 0),
1783UNUSUAL_DEV( 0x12d1, 0x143B, 0x0000, 0x0000, 1817UNUSUAL_DEV( 0x12d1, 0x143B, 0x0000, 0x0000,
1784 "HUAWEI MOBILE", 1818 "HUAWEI MOBILE",
1785 "Mass Storage", 1819 "Mass Storage",
1786 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1820 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1787 0), 1821 0),
1788UNUSUAL_DEV( 0x12d1, 0x143C, 0x0000, 0x0000, 1822UNUSUAL_DEV( 0x12d1, 0x143C, 0x0000, 0x0000,
1789 "HUAWEI MOBILE", 1823 "HUAWEI MOBILE",
1790 "Mass Storage", 1824 "Mass Storage",
1791 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1825 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1792 0), 1826 0),
1793UNUSUAL_DEV( 0x12d1, 0x143D, 0x0000, 0x0000, 1827UNUSUAL_DEV( 0x12d1, 0x143D, 0x0000, 0x0000,
1794 "HUAWEI MOBILE", 1828 "HUAWEI MOBILE",
1795 "Mass Storage", 1829 "Mass Storage",
1796 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1830 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1797 0), 1831 0),
1798UNUSUAL_DEV( 0x12d1, 0x143E, 0x0000, 0x0000, 1832UNUSUAL_DEV( 0x12d1, 0x143E, 0x0000, 0x0000,
1799 "HUAWEI MOBILE", 1833 "HUAWEI MOBILE",
1800 "Mass Storage", 1834 "Mass Storage",
1801 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1835 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1802 0), 1836 0),
1803UNUSUAL_DEV( 0x12d1, 0x143F, 0x0000, 0x0000, 1837UNUSUAL_DEV( 0x12d1, 0x143F, 0x0000, 0x0000,
1804 "HUAWEI MOBILE", 1838 "HUAWEI MOBILE",
1805 "Mass Storage", 1839 "Mass Storage",
1806 US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init, 1840 USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
1807 0), 1841 0),
1808 1842
1809/* Reported by Vilius Bilinkevicius <vilisas AT xxx DOT lt) */ 1843/* Reported by Vilius Bilinkevicius <vilisas AT xxx DOT lt) */
1810UNUSUAL_DEV( 0x132b, 0x000b, 0x0001, 0x0001, 1844UNUSUAL_DEV( 0x132b, 0x000b, 0x0001, 0x0001,
1811 "Minolta", 1845 "Minolta",
1812 "Dimage Z10", 1846 "Dimage Z10",
1813 US_SC_DEVICE, US_PR_DEVICE, NULL, 1847 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1814 0 ), 1848 0 ),
1815 1849
1816/* Reported by Kotrla Vitezslav <kotrla@ceb.cz> */ 1850/* Reported by Kotrla Vitezslav <kotrla@ceb.cz> */
1817UNUSUAL_DEV( 0x1370, 0x6828, 0x0110, 0x0110, 1851UNUSUAL_DEV( 0x1370, 0x6828, 0x0110, 0x0110,
1818 "SWISSBIT", 1852 "SWISSBIT",
1819 "Black Silver", 1853 "Black Silver",
1820 US_SC_DEVICE, US_PR_DEVICE, NULL, 1854 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1821 US_FL_IGNORE_RESIDUE ), 1855 US_FL_IGNORE_RESIDUE ),
1822 1856
1823/* Reported by Francesco Foresti <frafore@tiscali.it> */ 1857/* Reported by Francesco Foresti <frafore@tiscali.it> */
1824UNUSUAL_DEV( 0x14cd, 0x6600, 0x0201, 0x0201, 1858UNUSUAL_DEV( 0x14cd, 0x6600, 0x0201, 0x0201,
1825 "Super Top", 1859 "Super Top",
1826 "IDE DEVICE", 1860 "IDE DEVICE",
1827 US_SC_DEVICE, US_PR_DEVICE, NULL, 1861 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1828 US_FL_IGNORE_RESIDUE ), 1862 US_FL_IGNORE_RESIDUE ),
1829 1863
1830/* Reported by Alexandre Oliva <oliva@lsd.ic.unicamp.br> 1864/* Reported by Alexandre Oliva <oliva@lsd.ic.unicamp.br>
@@ -1833,7 +1867,7 @@ UNUSUAL_DEV( 0x14cd, 0x6600, 0x0201, 0x0201,
1833UNUSUAL_DEV( 0x152d, 0x2329, 0x0100, 0x0100, 1867UNUSUAL_DEV( 0x152d, 0x2329, 0x0100, 0x0100,
1834 "JMicron", 1868 "JMicron",
1835 "USB to ATA/ATAPI Bridge", 1869 "USB to ATA/ATAPI Bridge",
1836 US_SC_DEVICE, US_PR_DEVICE, NULL, 1870 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1837 US_FL_IGNORE_RESIDUE | US_FL_SANE_SENSE ), 1871 US_FL_IGNORE_RESIDUE | US_FL_SANE_SENSE ),
1838 1872
1839/* Reported by Robert Schedel <r.schedel@yahoo.de> 1873/* Reported by Robert Schedel <r.schedel@yahoo.de>
@@ -1841,7 +1875,7 @@ UNUSUAL_DEV( 0x152d, 0x2329, 0x0100, 0x0100,
1841UNUSUAL_DEV( 0x1652, 0x6600, 0x0201, 0x0201, 1875UNUSUAL_DEV( 0x1652, 0x6600, 0x0201, 0x0201,
1842 "Teac", 1876 "Teac",
1843 "HD-35PUK-B", 1877 "HD-35PUK-B",
1844 US_SC_DEVICE, US_PR_DEVICE, NULL, 1878 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1845 US_FL_IGNORE_RESIDUE ), 1879 US_FL_IGNORE_RESIDUE ),
1846 1880
1847/* Reported by Hans de Goede <hdegoede@redhat.com> 1881/* Reported by Hans de Goede <hdegoede@redhat.com>
@@ -1851,18 +1885,48 @@ UNUSUAL_DEV( 0x1652, 0x6600, 0x0201, 0x0201,
1851UNUSUAL_DEV( 0x1908, 0x1315, 0x0000, 0x0000, 1885UNUSUAL_DEV( 0x1908, 0x1315, 0x0000, 0x0000,
1852 "BUILDWIN", 1886 "BUILDWIN",
1853 "Photo Frame", 1887 "Photo Frame",
1854 US_SC_DEVICE, US_PR_DEVICE, NULL, 1888 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1855 US_FL_BAD_SENSE ), 1889 US_FL_BAD_SENSE ),
1856UNUSUAL_DEV( 0x1908, 0x1320, 0x0000, 0x0000, 1890UNUSUAL_DEV( 0x1908, 0x1320, 0x0000, 0x0000,
1857 "BUILDWIN", 1891 "BUILDWIN",
1858 "Photo Frame", 1892 "Photo Frame",
1859 US_SC_DEVICE, US_PR_DEVICE, NULL, 1893 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1860 US_FL_BAD_SENSE ), 1894 US_FL_BAD_SENSE ),
1895UNUSUAL_DEV( 0x1908, 0x3335, 0x0200, 0x0200,
1896 "BUILDWIN",
1897 "Photo Frame",
1898 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1899 US_FL_NO_READ_DISC_INFO ),
1900
1901/* Reported by Sven Geggus <sven-usbst@geggus.net>
1902 * This encrypted pen drive returns bogus data for the initial READ(10).
1903 */
1904UNUSUAL_DEV( 0x1b1c, 0x1ab5, 0x0200, 0x0200,
1905 "Corsair",
1906 "Padlock v2",
1907 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1908 US_FL_INITIAL_READ10 ),
1909
1910/* Patch by Richard Schütz <r.schtz@t-online.de>
1911 * This external hard drive enclosure uses a JMicron chip which
1912 * needs the US_FL_IGNORE_RESIDUE flag to work properly. */
1913UNUSUAL_DEV( 0x1e68, 0x001b, 0x0000, 0x0000,
1914 "TrekStor GmbH & Co. KG",
1915 "DataStation maxi g.u",
1916 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1917 US_FL_IGNORE_RESIDUE | US_FL_SANE_SENSE ),
1918
1919/* Reported by Jasper Mackenzie <scarletpimpernal@hotmail.com> */
1920UNUSUAL_DEV( 0x1e74, 0x4621, 0x0000, 0x0000,
1921 "Coby Electronics",
1922 "MP3 Player",
1923 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1924 US_FL_BULK_IGNORE_TAG | US_FL_MAX_SECTORS_64 ),
1861 1925
1862UNUSUAL_DEV( 0x2116, 0x0320, 0x0001, 0x0001, 1926UNUSUAL_DEV( 0x2116, 0x0320, 0x0001, 0x0001,
1863 "ST", 1927 "ST",
1864 "2A", 1928 "2A",
1865 US_SC_DEVICE, US_PR_DEVICE, NULL, 1929 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1866 US_FL_FIX_CAPACITY), 1930 US_FL_FIX_CAPACITY),
1867 1931
1868/* patch submitted by Davide Perini <perini.davide@dpsoftware.org> 1932/* patch submitted by Davide Perini <perini.davide@dpsoftware.org>
@@ -1871,7 +1935,7 @@ UNUSUAL_DEV( 0x2116, 0x0320, 0x0001, 0x0001,
1871UNUSUAL_DEV( 0x22b8, 0x3010, 0x0001, 0x0001, 1935UNUSUAL_DEV( 0x22b8, 0x3010, 0x0001, 0x0001,
1872 "Motorola", 1936 "Motorola",
1873 "RAZR V3x", 1937 "RAZR V3x",
1874 US_SC_DEVICE, US_PR_DEVICE, NULL, 1938 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1875 US_FL_FIX_CAPACITY | US_FL_IGNORE_RESIDUE ), 1939 US_FL_FIX_CAPACITY | US_FL_IGNORE_RESIDUE ),
1876 1940
1877/* 1941/*
@@ -1882,14 +1946,14 @@ UNUSUAL_DEV( 0x22b8, 0x3010, 0x0001, 0x0001,
1882UNUSUAL_DEV( 0x22b8, 0x6426, 0x0101, 0x0101, 1946UNUSUAL_DEV( 0x22b8, 0x6426, 0x0101, 0x0101,
1883 "Motorola", 1947 "Motorola",
1884 "MSnc.", 1948 "MSnc.",
1885 US_SC_DEVICE, US_PR_DEVICE, NULL, 1949 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1886 US_FL_FIX_INQUIRY | US_FL_FIX_CAPACITY | US_FL_BULK_IGNORE_TAG), 1950 US_FL_FIX_INQUIRY | US_FL_FIX_CAPACITY | US_FL_BULK_IGNORE_TAG),
1887 1951
1888/* Reported by Radovan Garabik <garabik@kassiopeia.juls.savba.sk> */ 1952/* Reported by Radovan Garabik <garabik@kassiopeia.juls.savba.sk> */
1889UNUSUAL_DEV( 0x2735, 0x100b, 0x0000, 0x9999, 1953UNUSUAL_DEV( 0x2735, 0x100b, 0x0000, 0x9999,
1890 "MPIO", 1954 "MPIO",
1891 "HS200", 1955 "HS200",
1892 US_SC_DEVICE, US_PR_DEVICE, NULL, 1956 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1893 US_FL_GO_SLOW ), 1957 US_FL_GO_SLOW ),
1894 1958
1895/* Reported by Frederic Marchal <frederic.marchal@wowcompany.com> 1959/* Reported by Frederic Marchal <frederic.marchal@wowcompany.com>
@@ -1898,21 +1962,21 @@ UNUSUAL_DEV( 0x2735, 0x100b, 0x0000, 0x9999,
1898UNUSUAL_DEV( 0x3340, 0xffff, 0x0000, 0x0000, 1962UNUSUAL_DEV( 0x3340, 0xffff, 0x0000, 0x0000,
1899 "Mitac", 1963 "Mitac",
1900 "Mio DigiWalker USB Sync", 1964 "Mio DigiWalker USB Sync",
1901 US_SC_DEVICE,US_PR_DEVICE,NULL, 1965 USB_SC_DEVICE,USB_PR_DEVICE,NULL,
1902 US_FL_MAX_SECTORS_64 ), 1966 US_FL_MAX_SECTORS_64 ),
1903 1967
1904/* Reported by Andrey Rahmatullin <wrar@altlinux.org> */ 1968/* Reported by Andrey Rahmatullin <wrar@altlinux.org> */
1905UNUSUAL_DEV( 0x4102, 0x1020, 0x0100, 0x0100, 1969UNUSUAL_DEV( 0x4102, 0x1020, 0x0100, 0x0100,
1906 "iRiver", 1970 "iRiver",
1907 "MP3 T10", 1971 "MP3 T10",
1908 US_SC_DEVICE, US_PR_DEVICE, NULL, 1972 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1909 US_FL_IGNORE_RESIDUE ), 1973 US_FL_IGNORE_RESIDUE ),
1910 1974
1911/* Reported by Sergey Pinaev <dfo@antex.ru> */ 1975/* Reported by Sergey Pinaev <dfo@antex.ru> */
1912UNUSUAL_DEV( 0x4102, 0x1059, 0x0000, 0x0000, 1976UNUSUAL_DEV( 0x4102, 0x1059, 0x0000, 0x0000,
1913 "iRiver", 1977 "iRiver",
1914 "P7K", 1978 "P7K",
1915 US_SC_DEVICE, US_PR_DEVICE, NULL, 1979 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1916 US_FL_MAX_SECTORS_64 ), 1980 US_FL_MAX_SECTORS_64 ),
1917 1981
1918/* 1982/*
@@ -1922,41 +1986,41 @@ UNUSUAL_DEV( 0x4102, 0x1059, 0x0000, 0x0000,
1922UNUSUAL_DEV( 0x4146, 0xba01, 0x0100, 0x0100, 1986UNUSUAL_DEV( 0x4146, 0xba01, 0x0100, 0x0100,
1923 "Iomega", 1987 "Iomega",
1924 "Micro Mini 1GB", 1988 "Micro Mini 1GB",
1925 US_SC_DEVICE, US_PR_DEVICE, NULL, US_FL_NOT_LOCKABLE ), 1989 USB_SC_DEVICE, USB_PR_DEVICE, NULL, US_FL_NOT_LOCKABLE ),
1926 1990
1927/* Reported by Andrew Simmons <andrew.simmons@gmail.com> */ 1991/* Reported by Andrew Simmons <andrew.simmons@gmail.com> */
1928UNUSUAL_DEV( 0xed06, 0x4500, 0x0001, 0x0001, 1992UNUSUAL_DEV( 0xed06, 0x4500, 0x0001, 0x0001,
1929 "DataStor", 1993 "DataStor",
1930 "USB4500 FW1.04", 1994 "USB4500 FW1.04",
1931 US_SC_DEVICE, US_PR_DEVICE, NULL, 1995 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
1932 US_FL_CAPACITY_HEURISTICS), 1996 US_FL_CAPACITY_HEURISTICS),
1933 1997
1934/* Reported by Alessio Treglia <quadrispro@ubuntu.com> */ 1998/* Reported by Alessio Treglia <quadrispro@ubuntu.com> */
1935UNUSUAL_DEV( 0xed10, 0x7636, 0x0001, 0x0001, 1999UNUSUAL_DEV( 0xed10, 0x7636, 0x0001, 0x0001,
1936 "TGE", 2000 "TGE",
1937 "Digital MP3 Audio Player", 2001 "Digital MP3 Audio Player",
1938 US_SC_DEVICE, US_PR_DEVICE, NULL, US_FL_NOT_LOCKABLE ), 2002 USB_SC_DEVICE, USB_PR_DEVICE, NULL, US_FL_NOT_LOCKABLE ),
1939 2003
1940/* Control/Bulk transport for all SubClass values */ 2004/* Control/Bulk transport for all SubClass values */
1941USUAL_DEV(US_SC_RBC, US_PR_CB, USB_US_TYPE_STOR), 2005USUAL_DEV(USB_SC_RBC, USB_PR_CB, USB_US_TYPE_STOR),
1942USUAL_DEV(US_SC_8020, US_PR_CB, USB_US_TYPE_STOR), 2006USUAL_DEV(USB_SC_8020, USB_PR_CB, USB_US_TYPE_STOR),
1943USUAL_DEV(US_SC_QIC, US_PR_CB, USB_US_TYPE_STOR), 2007USUAL_DEV(USB_SC_QIC, USB_PR_CB, USB_US_TYPE_STOR),
1944USUAL_DEV(US_SC_UFI, US_PR_CB, USB_US_TYPE_STOR), 2008USUAL_DEV(USB_SC_UFI, USB_PR_CB, USB_US_TYPE_STOR),
1945USUAL_DEV(US_SC_8070, US_PR_CB, USB_US_TYPE_STOR), 2009USUAL_DEV(USB_SC_8070, USB_PR_CB, USB_US_TYPE_STOR),
1946USUAL_DEV(US_SC_SCSI, US_PR_CB, USB_US_TYPE_STOR), 2010USUAL_DEV(USB_SC_SCSI, USB_PR_CB, USB_US_TYPE_STOR),
1947 2011
1948/* Control/Bulk/Interrupt transport for all SubClass values */ 2012/* Control/Bulk/Interrupt transport for all SubClass values */
1949USUAL_DEV(US_SC_RBC, US_PR_CBI, USB_US_TYPE_STOR), 2013USUAL_DEV(USB_SC_RBC, USB_PR_CBI, USB_US_TYPE_STOR),
1950USUAL_DEV(US_SC_8020, US_PR_CBI, USB_US_TYPE_STOR), 2014USUAL_DEV(USB_SC_8020, USB_PR_CBI, USB_US_TYPE_STOR),
1951USUAL_DEV(US_SC_QIC, US_PR_CBI, USB_US_TYPE_STOR), 2015USUAL_DEV(USB_SC_QIC, USB_PR_CBI, USB_US_TYPE_STOR),
1952USUAL_DEV(US_SC_UFI, US_PR_CBI, USB_US_TYPE_STOR), 2016USUAL_DEV(USB_SC_UFI, USB_PR_CBI, USB_US_TYPE_STOR),
1953USUAL_DEV(US_SC_8070, US_PR_CBI, USB_US_TYPE_STOR), 2017USUAL_DEV(USB_SC_8070, USB_PR_CBI, USB_US_TYPE_STOR),
1954USUAL_DEV(US_SC_SCSI, US_PR_CBI, USB_US_TYPE_STOR), 2018USUAL_DEV(USB_SC_SCSI, USB_PR_CBI, USB_US_TYPE_STOR),
1955 2019
1956/* Bulk-only transport for all SubClass values */ 2020/* Bulk-only transport for all SubClass values */
1957USUAL_DEV(US_SC_RBC, US_PR_BULK, USB_US_TYPE_STOR), 2021USUAL_DEV(USB_SC_RBC, USB_PR_BULK, USB_US_TYPE_STOR),
1958USUAL_DEV(US_SC_8020, US_PR_BULK, USB_US_TYPE_STOR), 2022USUAL_DEV(USB_SC_8020, USB_PR_BULK, USB_US_TYPE_STOR),
1959USUAL_DEV(US_SC_QIC, US_PR_BULK, USB_US_TYPE_STOR), 2023USUAL_DEV(USB_SC_QIC, USB_PR_BULK, USB_US_TYPE_STOR),
1960USUAL_DEV(US_SC_UFI, US_PR_BULK, USB_US_TYPE_STOR), 2024USUAL_DEV(USB_SC_UFI, USB_PR_BULK, USB_US_TYPE_STOR),
1961USUAL_DEV(US_SC_8070, US_PR_BULK, USB_US_TYPE_STOR), 2025USUAL_DEV(USB_SC_8070, USB_PR_BULK, USB_US_TYPE_STOR),
1962USUAL_DEV(US_SC_SCSI, US_PR_BULK, 0), 2026USUAL_DEV(USB_SC_SCSI, USB_PR_BULK, 0),
diff --git a/drivers/usb/storage/unusual_ene_ub6250.h b/drivers/usb/storage/unusual_ene_ub6250.h
new file mode 100644
index 000000000000..5667f5d365c6
--- /dev/null
+++ b/drivers/usb/storage/unusual_ene_ub6250.h
@@ -0,0 +1,26 @@
1/*
2 *
3 * This program is free software; you can redistribute it and/or modify it
4 * under the terms of the GNU General Public License as published by the
5 * Free Software Foundation; either version 2, or (at your option) any
6 * later version.
7 *
8 * This program is distributed in the hope that it will be useful, but
9 * WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 * General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License along
14 * with this program; if not, write to the Free Software Foundation, Inc.,
15 * 675 Mass Ave, Cambridge, MA 02139, USA.
16 */
17
18#if defined(CONFIG_USB_STORAGE_ENE_UB6250) || \
19 defined(CONFIG_USB_STORAGE_ENE_UB6250_MODULE)
20
21UNUSUAL_DEV(0x0cf2, 0x6250, 0x0000, 0x9999,
22 "ENE",
23 "ENE UB6250 reader",
24 USB_SC_DEVICE, USB_PR_DEVICE, NULL, 0),
25
26#endif /* defined(CONFIG_USB_STORAGE_ENE_UB6250) || ... */
diff --git a/drivers/usb/storage/unusual_freecom.h b/drivers/usb/storage/unusual_freecom.h
index 375867942391..59a261155b98 100644
--- a/drivers/usb/storage/unusual_freecom.h
+++ b/drivers/usb/storage/unusual_freecom.h
@@ -21,6 +21,6 @@
21UNUSUAL_DEV( 0x07ab, 0xfc01, 0x0000, 0x9999, 21UNUSUAL_DEV( 0x07ab, 0xfc01, 0x0000, 0x9999,
22 "Freecom", 22 "Freecom",
23 "USB-IDE", 23 "USB-IDE",
24 US_SC_QIC, US_PR_FREECOM, init_freecom, 0), 24 USB_SC_QIC, USB_PR_FREECOM, init_freecom, 0),
25 25
26#endif /* defined(CONFIG_USB_STORAGE_FREECOM) || ... */ 26#endif /* defined(CONFIG_USB_STORAGE_FREECOM) || ... */
diff --git a/drivers/usb/storage/unusual_isd200.h b/drivers/usb/storage/unusual_isd200.h
index 0d99dde3382a..14cca0c48302 100644
--- a/drivers/usb/storage/unusual_isd200.h
+++ b/drivers/usb/storage/unusual_isd200.h
@@ -21,37 +21,37 @@
21UNUSUAL_DEV( 0x054c, 0x002b, 0x0100, 0x0110, 21UNUSUAL_DEV( 0x054c, 0x002b, 0x0100, 0x0110,
22 "Sony", 22 "Sony",
23 "Portable USB Harddrive V2", 23 "Portable USB Harddrive V2",
24 US_SC_ISD200, US_PR_BULK, isd200_Initialization, 24 USB_SC_ISD200, USB_PR_BULK, isd200_Initialization,
25 0), 25 0),
26 26
27UNUSUAL_DEV( 0x05ab, 0x0031, 0x0100, 0x0110, 27UNUSUAL_DEV( 0x05ab, 0x0031, 0x0100, 0x0110,
28 "In-System", 28 "In-System",
29 "USB/IDE Bridge (ATA/ATAPI)", 29 "USB/IDE Bridge (ATA/ATAPI)",
30 US_SC_ISD200, US_PR_BULK, isd200_Initialization, 30 USB_SC_ISD200, USB_PR_BULK, isd200_Initialization,
31 0), 31 0),
32 32
33UNUSUAL_DEV( 0x05ab, 0x0301, 0x0100, 0x0110, 33UNUSUAL_DEV( 0x05ab, 0x0301, 0x0100, 0x0110,
34 "In-System", 34 "In-System",
35 "Portable USB Harddrive V2", 35 "Portable USB Harddrive V2",
36 US_SC_ISD200, US_PR_BULK, isd200_Initialization, 36 USB_SC_ISD200, USB_PR_BULK, isd200_Initialization,
37 0), 37 0),
38 38
39UNUSUAL_DEV( 0x05ab, 0x0351, 0x0100, 0x0110, 39UNUSUAL_DEV( 0x05ab, 0x0351, 0x0100, 0x0110,
40 "In-System", 40 "In-System",
41 "Portable USB Harddrive V2", 41 "Portable USB Harddrive V2",
42 US_SC_ISD200, US_PR_BULK, isd200_Initialization, 42 USB_SC_ISD200, USB_PR_BULK, isd200_Initialization,
43 0), 43 0),
44 44
45UNUSUAL_DEV( 0x05ab, 0x5701, 0x0100, 0x0110, 45UNUSUAL_DEV( 0x05ab, 0x5701, 0x0100, 0x0110,
46 "In-System", 46 "In-System",
47 "USB Storage Adapter V2", 47 "USB Storage Adapter V2",
48 US_SC_ISD200, US_PR_BULK, isd200_Initialization, 48 USB_SC_ISD200, USB_PR_BULK, isd200_Initialization,
49 0), 49 0),
50 50
51UNUSUAL_DEV( 0x0bf6, 0xa001, 0x0100, 0x0110, 51UNUSUAL_DEV( 0x0bf6, 0xa001, 0x0100, 0x0110,
52 "ATI", 52 "ATI",
53 "USB Cable 205", 53 "USB Cable 205",
54 US_SC_ISD200, US_PR_BULK, isd200_Initialization, 54 USB_SC_ISD200, USB_PR_BULK, isd200_Initialization,
55 0), 55 0),
56 56
57#endif /* defined(CONFIG_USB_STORAGE_ISD200) || ... */ 57#endif /* defined(CONFIG_USB_STORAGE_ISD200) || ... */
diff --git a/drivers/usb/storage/unusual_jumpshot.h b/drivers/usb/storage/unusual_jumpshot.h
index 2e549b1c2c62..54be78b5d643 100644
--- a/drivers/usb/storage/unusual_jumpshot.h
+++ b/drivers/usb/storage/unusual_jumpshot.h
@@ -21,7 +21,7 @@
21UNUSUAL_DEV( 0x05dc, 0x0001, 0x0000, 0x0001, 21UNUSUAL_DEV( 0x05dc, 0x0001, 0x0000, 0x0001,
22 "Lexar", 22 "Lexar",
23 "Jumpshot USB CF Reader", 23 "Jumpshot USB CF Reader",
24 US_SC_SCSI, US_PR_JUMPSHOT, NULL, 24 USB_SC_SCSI, USB_PR_JUMPSHOT, NULL,
25 US_FL_NEED_OVERRIDE), 25 US_FL_NEED_OVERRIDE),
26 26
27#endif /* defined(CONFIG_USB_STORAGE_JUMPSHOT) || ... */ 27#endif /* defined(CONFIG_USB_STORAGE_JUMPSHOT) || ... */
diff --git a/drivers/usb/storage/unusual_karma.h b/drivers/usb/storage/unusual_karma.h
index 12ae3a03e802..6df03972a22c 100644
--- a/drivers/usb/storage/unusual_karma.h
+++ b/drivers/usb/storage/unusual_karma.h
@@ -21,6 +21,6 @@
21UNUSUAL_DEV( 0x045a, 0x5210, 0x0101, 0x0101, 21UNUSUAL_DEV( 0x045a, 0x5210, 0x0101, 0x0101,
22 "Rio", 22 "Rio",
23 "Rio Karma", 23 "Rio Karma",
24 US_SC_SCSI, US_PR_KARMA, rio_karma_init, 0), 24 USB_SC_SCSI, USB_PR_KARMA, rio_karma_init, 0),
25 25
26#endif /* defined(CONFIG_USB_STORAGE_KARMA) || ... */ 26#endif /* defined(CONFIG_USB_STORAGE_KARMA) || ... */
diff --git a/drivers/usb/storage/unusual_onetouch.h b/drivers/usb/storage/unusual_onetouch.h
index bd9306b637df..0abb819c7405 100644
--- a/drivers/usb/storage/unusual_onetouch.h
+++ b/drivers/usb/storage/unusual_onetouch.h
@@ -24,13 +24,13 @@
24UNUSUAL_DEV( 0x0d49, 0x7000, 0x0000, 0x9999, 24UNUSUAL_DEV( 0x0d49, 0x7000, 0x0000, 0x9999,
25 "Maxtor", 25 "Maxtor",
26 "OneTouch External Harddrive", 26 "OneTouch External Harddrive",
27 US_SC_DEVICE, US_PR_DEVICE, onetouch_connect_input, 27 USB_SC_DEVICE, USB_PR_DEVICE, onetouch_connect_input,
28 0), 28 0),
29 29
30UNUSUAL_DEV( 0x0d49, 0x7010, 0x0000, 0x9999, 30UNUSUAL_DEV( 0x0d49, 0x7010, 0x0000, 0x9999,
31 "Maxtor", 31 "Maxtor",
32 "OneTouch External Harddrive", 32 "OneTouch External Harddrive",
33 US_SC_DEVICE, US_PR_DEVICE, onetouch_connect_input, 33 USB_SC_DEVICE, USB_PR_DEVICE, onetouch_connect_input,
34 0), 34 0),
35 35
36#endif /* defined(CONFIG_USB_STORAGE_ONETOUCH) || ... */ 36#endif /* defined(CONFIG_USB_STORAGE_ONETOUCH) || ... */
diff --git a/drivers/usb/storage/unusual_realtek.h b/drivers/usb/storage/unusual_realtek.h
new file mode 100644
index 000000000000..e41f50c95ed4
--- /dev/null
+++ b/drivers/usb/storage/unusual_realtek.h
@@ -0,0 +1,41 @@
1/* Driver for Realtek RTS51xx USB card reader
2 *
3 * Copyright(c) 2009 Realtek Semiconductor Corp. All rights reserved.
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License as published by the
7 * Free Software Foundation; either version 2, or (at your option) any
8 * later version.
9 *
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License along
16 * with this program; if not, see <http://www.gnu.org/licenses/>.
17 *
18 * Author:
19 * wwang (wei_wang@realsil.com.cn)
20 * No. 450, Shenhu Road, Suzhou Industry Park, Suzhou, China
21 */
22
23#if defined(CONFIG_USB_STORAGE_REALTEK) || \
24 defined(CONFIG_USB_STORAGE_REALTEK_MODULE)
25
26UNUSUAL_DEV(0x0bda, 0x0138, 0x0000, 0x9999,
27 "Realtek",
28 "USB Card Reader",
29 USB_SC_DEVICE, USB_PR_DEVICE, init_realtek_cr, 0),
30
31UNUSUAL_DEV(0x0bda, 0x0158, 0x0000, 0x9999,
32 "Realtek",
33 "USB Card Reader",
34 USB_SC_DEVICE, USB_PR_DEVICE, init_realtek_cr, 0),
35
36UNUSUAL_DEV(0x0bda, 0x0159, 0x0000, 0x9999,
37 "Realtek",
38 "USB Card Reader",
39 USB_SC_DEVICE, USB_PR_DEVICE, init_realtek_cr, 0),
40
41#endif /* defined(CONFIG_USB_STORAGE_REALTEK) || ... */
diff --git a/drivers/usb/storage/unusual_sddr09.h b/drivers/usb/storage/unusual_sddr09.h
index 50cab511a4d7..59a7e37b6c11 100644
--- a/drivers/usb/storage/unusual_sddr09.h
+++ b/drivers/usb/storage/unusual_sddr09.h
@@ -21,36 +21,36 @@
21UNUSUAL_DEV( 0x0436, 0x0005, 0x0100, 0x0100, 21UNUSUAL_DEV( 0x0436, 0x0005, 0x0100, 0x0100,
22 "Microtech", 22 "Microtech",
23 "CameraMate (DPCM_USB)", 23 "CameraMate (DPCM_USB)",
24 US_SC_SCSI, US_PR_DPCM_USB, NULL, 0), 24 USB_SC_SCSI, USB_PR_DPCM_USB, NULL, 0),
25 25
26UNUSUAL_DEV( 0x04e6, 0x0003, 0x0000, 0x9999, 26UNUSUAL_DEV( 0x04e6, 0x0003, 0x0000, 0x9999,
27 "Sandisk", 27 "Sandisk",
28 "ImageMate SDDR09", 28 "ImageMate SDDR09",
29 US_SC_SCSI, US_PR_EUSB_SDDR09, usb_stor_sddr09_init, 29 USB_SC_SCSI, USB_PR_EUSB_SDDR09, usb_stor_sddr09_init,
30 0), 30 0),
31 31
32/* This entry is from Andries.Brouwer@cwi.nl */ 32/* This entry is from Andries.Brouwer@cwi.nl */
33UNUSUAL_DEV( 0x04e6, 0x0005, 0x0100, 0x0208, 33UNUSUAL_DEV( 0x04e6, 0x0005, 0x0100, 0x0208,
34 "SCM Microsystems", 34 "SCM Microsystems",
35 "eUSB SmartMedia / CompactFlash Adapter", 35 "eUSB SmartMedia / CompactFlash Adapter",
36 US_SC_SCSI, US_PR_DPCM_USB, usb_stor_sddr09_dpcm_init, 36 USB_SC_SCSI, USB_PR_DPCM_USB, usb_stor_sddr09_dpcm_init,
37 0), 37 0),
38 38
39UNUSUAL_DEV( 0x066b, 0x0105, 0x0100, 0x0100, 39UNUSUAL_DEV( 0x066b, 0x0105, 0x0100, 0x0100,
40 "Olympus", 40 "Olympus",
41 "Camedia MAUSB-2", 41 "Camedia MAUSB-2",
42 US_SC_SCSI, US_PR_EUSB_SDDR09, usb_stor_sddr09_init, 42 USB_SC_SCSI, USB_PR_EUSB_SDDR09, usb_stor_sddr09_init,
43 0), 43 0),
44 44
45UNUSUAL_DEV( 0x0781, 0x0200, 0x0000, 0x9999, 45UNUSUAL_DEV( 0x0781, 0x0200, 0x0000, 0x9999,
46 "Sandisk", 46 "Sandisk",
47 "ImageMate SDDR-09", 47 "ImageMate SDDR-09",
48 US_SC_SCSI, US_PR_EUSB_SDDR09, usb_stor_sddr09_init, 48 USB_SC_SCSI, USB_PR_EUSB_SDDR09, usb_stor_sddr09_init,
49 0), 49 0),
50 50
51UNUSUAL_DEV( 0x07af, 0x0006, 0x0100, 0x0100, 51UNUSUAL_DEV( 0x07af, 0x0006, 0x0100, 0x0100,
52 "Microtech", 52 "Microtech",
53 "CameraMate (DPCM_USB)", 53 "CameraMate (DPCM_USB)",
54 US_SC_SCSI, US_PR_DPCM_USB, NULL, 0), 54 USB_SC_SCSI, USB_PR_DPCM_USB, NULL, 0),
55 55
56#endif /* defined(CONFIG_USB_STORAGE_SDDR09) || ... */ 56#endif /* defined(CONFIG_USB_STORAGE_SDDR09) || ... */
diff --git a/drivers/usb/storage/unusual_sddr55.h b/drivers/usb/storage/unusual_sddr55.h
index ae81ef7a1cfd..fcb7e12c598f 100644
--- a/drivers/usb/storage/unusual_sddr55.h
+++ b/drivers/usb/storage/unusual_sddr55.h
@@ -22,23 +22,23 @@
22UNUSUAL_DEV( 0x07c4, 0xa103, 0x0000, 0x9999, 22UNUSUAL_DEV( 0x07c4, 0xa103, 0x0000, 0x9999,
23 "Datafab", 23 "Datafab",
24 "MDSM-B reader", 24 "MDSM-B reader",
25 US_SC_SCSI, US_PR_SDDR55, NULL, 25 USB_SC_SCSI, USB_PR_SDDR55, NULL,
26 US_FL_FIX_INQUIRY), 26 US_FL_FIX_INQUIRY),
27 27
28/* SM part - aeb <Andries.Brouwer@cwi.nl> */ 28/* SM part - aeb <Andries.Brouwer@cwi.nl> */
29UNUSUAL_DEV( 0x07c4, 0xa109, 0x0000, 0xffff, 29UNUSUAL_DEV( 0x07c4, 0xa109, 0x0000, 0xffff,
30 "Datafab Systems, Inc.", 30 "Datafab Systems, Inc.",
31 "USB to CF + SM Combo (LC1)", 31 "USB to CF + SM Combo (LC1)",
32 US_SC_SCSI, US_PR_SDDR55, NULL, 0), 32 USB_SC_SCSI, USB_PR_SDDR55, NULL, 0),
33 33
34UNUSUAL_DEV( 0x0c0b, 0xa109, 0x0000, 0xffff, 34UNUSUAL_DEV( 0x0c0b, 0xa109, 0x0000, 0xffff,
35 "Acomdata", 35 "Acomdata",
36 "SM", 36 "SM",
37 US_SC_SCSI, US_PR_SDDR55, NULL, 0), 37 USB_SC_SCSI, USB_PR_SDDR55, NULL, 0),
38 38
39UNUSUAL_DEV( 0x55aa, 0xa103, 0x0000, 0x9999, 39UNUSUAL_DEV( 0x55aa, 0xa103, 0x0000, 0x9999,
40 "Sandisk", 40 "Sandisk",
41 "ImageMate SDDR55", 41 "ImageMate SDDR55",
42 US_SC_SCSI, US_PR_SDDR55, NULL, 0), 42 USB_SC_SCSI, USB_PR_SDDR55, NULL, 0),
43 43
44#endif /* defined(CONFIG_USB_STORAGE_SDDR55) || ... */ 44#endif /* defined(CONFIG_USB_STORAGE_SDDR55) || ... */
diff --git a/drivers/usb/storage/unusual_usbat.h b/drivers/usb/storage/unusual_usbat.h
index 80e869f10180..38e79c4e6d6a 100644
--- a/drivers/usb/storage/unusual_usbat.h
+++ b/drivers/usb/storage/unusual_usbat.h
@@ -21,23 +21,23 @@
21UNUSUAL_DEV( 0x03f0, 0x0207, 0x0001, 0x0001, 21UNUSUAL_DEV( 0x03f0, 0x0207, 0x0001, 0x0001,
22 "HP", 22 "HP",
23 "CD-Writer+ 8200e", 23 "CD-Writer+ 8200e",
24 US_SC_8070, US_PR_USBAT, init_usbat_cd, 0), 24 USB_SC_8070, USB_PR_USBAT, init_usbat_cd, 0),
25 25
26UNUSUAL_DEV( 0x03f0, 0x0307, 0x0001, 0x0001, 26UNUSUAL_DEV( 0x03f0, 0x0307, 0x0001, 0x0001,
27 "HP", 27 "HP",
28 "CD-Writer+ CD-4e", 28 "CD-Writer+ CD-4e",
29 US_SC_8070, US_PR_USBAT, init_usbat_cd, 0), 29 USB_SC_8070, USB_PR_USBAT, init_usbat_cd, 0),
30 30
31UNUSUAL_DEV( 0x04e6, 0x1010, 0x0000, 0x9999, 31UNUSUAL_DEV( 0x04e6, 0x1010, 0x0000, 0x9999,
32 "Shuttle/SCM", 32 "Shuttle/SCM",
33 "USBAT-02", 33 "USBAT-02",
34 US_SC_SCSI, US_PR_USBAT, init_usbat_flash, 34 USB_SC_SCSI, USB_PR_USBAT, init_usbat_flash,
35 US_FL_SINGLE_LUN), 35 US_FL_SINGLE_LUN),
36 36
37UNUSUAL_DEV( 0x0781, 0x0005, 0x0005, 0x0005, 37UNUSUAL_DEV( 0x0781, 0x0005, 0x0005, 0x0005,
38 "Sandisk", 38 "Sandisk",
39 "ImageMate SDDR-05b", 39 "ImageMate SDDR-05b",
40 US_SC_SCSI, US_PR_USBAT, init_usbat_flash, 40 USB_SC_SCSI, USB_PR_USBAT, init_usbat_flash,
41 US_FL_SINGLE_LUN), 41 US_FL_SINGLE_LUN),
42 42
43#endif /* defined(CONFIG_USB_STORAGE_USBAT) || ... */ 43#endif /* defined(CONFIG_USB_STORAGE_USBAT) || ... */
diff --git a/drivers/usb/storage/usb.c b/drivers/usb/storage/usb.c
index 90bb0175a152..0ca095820f3e 100644
--- a/drivers/usb/storage/usb.c
+++ b/drivers/usb/storage/usb.c
@@ -439,7 +439,9 @@ static void adjust_quirks(struct us_data *us)
439 US_FL_CAPACITY_HEURISTICS | US_FL_IGNORE_DEVICE | 439 US_FL_CAPACITY_HEURISTICS | US_FL_IGNORE_DEVICE |
440 US_FL_NOT_LOCKABLE | US_FL_MAX_SECTORS_64 | 440 US_FL_NOT_LOCKABLE | US_FL_MAX_SECTORS_64 |
441 US_FL_CAPACITY_OK | US_FL_IGNORE_RESIDUE | 441 US_FL_CAPACITY_OK | US_FL_IGNORE_RESIDUE |
442 US_FL_SINGLE_LUN | US_FL_NO_WP_DETECT); 442 US_FL_SINGLE_LUN | US_FL_NO_WP_DETECT |
443 US_FL_NO_READ_DISC_INFO | US_FL_NO_READ_CAPACITY_16 |
444 US_FL_INITIAL_READ10);
443 445
444 p = quirks; 446 p = quirks;
445 while (*p) { 447 while (*p) {
@@ -471,6 +473,12 @@ static void adjust_quirks(struct us_data *us)
471 case 'c': 473 case 'c':
472 f |= US_FL_FIX_CAPACITY; 474 f |= US_FL_FIX_CAPACITY;
473 break; 475 break;
476 case 'd':
477 f |= US_FL_NO_READ_DISC_INFO;
478 break;
479 case 'e':
480 f |= US_FL_NO_READ_CAPACITY_16;
481 break;
474 case 'h': 482 case 'h':
475 f |= US_FL_CAPACITY_HEURISTICS; 483 f |= US_FL_CAPACITY_HEURISTICS;
476 break; 484 break;
@@ -483,6 +491,9 @@ static void adjust_quirks(struct us_data *us)
483 case 'm': 491 case 'm':
484 f |= US_FL_MAX_SECTORS_64; 492 f |= US_FL_MAX_SECTORS_64;
485 break; 493 break;
494 case 'n':
495 f |= US_FL_INITIAL_READ10;
496 break;
486 case 'o': 497 case 'o':
487 f |= US_FL_CAPACITY_OK; 498 f |= US_FL_CAPACITY_OK;
488 break; 499 break;
@@ -512,10 +523,10 @@ static int get_device_info(struct us_data *us, const struct usb_device_id *id,
512 523
513 /* Store the entries */ 524 /* Store the entries */
514 us->unusual_dev = unusual_dev; 525 us->unusual_dev = unusual_dev;
515 us->subclass = (unusual_dev->useProtocol == US_SC_DEVICE) ? 526 us->subclass = (unusual_dev->useProtocol == USB_SC_DEVICE) ?
516 idesc->bInterfaceSubClass : 527 idesc->bInterfaceSubClass :
517 unusual_dev->useProtocol; 528 unusual_dev->useProtocol;
518 us->protocol = (unusual_dev->useTransport == US_PR_DEVICE) ? 529 us->protocol = (unusual_dev->useTransport == USB_PR_DEVICE) ?
519 idesc->bInterfaceProtocol : 530 idesc->bInterfaceProtocol :
520 unusual_dev->useTransport; 531 unusual_dev->useTransport;
521 us->fflags = USB_US_ORIG_FLAGS(id->driver_info); 532 us->fflags = USB_US_ORIG_FLAGS(id->driver_info);
@@ -552,10 +563,10 @@ static int get_device_info(struct us_data *us, const struct usb_device_id *id,
552 struct usb_device_descriptor *ddesc = &dev->descriptor; 563 struct usb_device_descriptor *ddesc = &dev->descriptor;
553 int msg = -1; 564 int msg = -1;
554 565
555 if (unusual_dev->useProtocol != US_SC_DEVICE && 566 if (unusual_dev->useProtocol != USB_SC_DEVICE &&
556 us->subclass == idesc->bInterfaceSubClass) 567 us->subclass == idesc->bInterfaceSubClass)
557 msg += 1; 568 msg += 1;
558 if (unusual_dev->useTransport != US_PR_DEVICE && 569 if (unusual_dev->useTransport != USB_PR_DEVICE &&
559 us->protocol == idesc->bInterfaceProtocol) 570 us->protocol == idesc->bInterfaceProtocol)
560 msg += 2; 571 msg += 2;
561 if (msg >= 0 && !(us->fflags & US_FL_NEED_OVERRIDE)) 572 if (msg >= 0 && !(us->fflags & US_FL_NEED_OVERRIDE))
@@ -582,21 +593,21 @@ static int get_device_info(struct us_data *us, const struct usb_device_id *id,
582static void get_transport(struct us_data *us) 593static void get_transport(struct us_data *us)
583{ 594{
584 switch (us->protocol) { 595 switch (us->protocol) {
585 case US_PR_CB: 596 case USB_PR_CB:
586 us->transport_name = "Control/Bulk"; 597 us->transport_name = "Control/Bulk";
587 us->transport = usb_stor_CB_transport; 598 us->transport = usb_stor_CB_transport;
588 us->transport_reset = usb_stor_CB_reset; 599 us->transport_reset = usb_stor_CB_reset;
589 us->max_lun = 7; 600 us->max_lun = 7;
590 break; 601 break;
591 602
592 case US_PR_CBI: 603 case USB_PR_CBI:
593 us->transport_name = "Control/Bulk/Interrupt"; 604 us->transport_name = "Control/Bulk/Interrupt";
594 us->transport = usb_stor_CB_transport; 605 us->transport = usb_stor_CB_transport;
595 us->transport_reset = usb_stor_CB_reset; 606 us->transport_reset = usb_stor_CB_reset;
596 us->max_lun = 7; 607 us->max_lun = 7;
597 break; 608 break;
598 609
599 case US_PR_BULK: 610 case USB_PR_BULK:
600 us->transport_name = "Bulk"; 611 us->transport_name = "Bulk";
601 us->transport = usb_stor_Bulk_transport; 612 us->transport = usb_stor_Bulk_transport;
602 us->transport_reset = usb_stor_Bulk_reset; 613 us->transport_reset = usb_stor_Bulk_reset;
@@ -608,35 +619,35 @@ static void get_transport(struct us_data *us)
608static void get_protocol(struct us_data *us) 619static void get_protocol(struct us_data *us)
609{ 620{
610 switch (us->subclass) { 621 switch (us->subclass) {
611 case US_SC_RBC: 622 case USB_SC_RBC:
612 us->protocol_name = "Reduced Block Commands (RBC)"; 623 us->protocol_name = "Reduced Block Commands (RBC)";
613 us->proto_handler = usb_stor_transparent_scsi_command; 624 us->proto_handler = usb_stor_transparent_scsi_command;
614 break; 625 break;
615 626
616 case US_SC_8020: 627 case USB_SC_8020:
617 us->protocol_name = "8020i"; 628 us->protocol_name = "8020i";
618 us->proto_handler = usb_stor_pad12_command; 629 us->proto_handler = usb_stor_pad12_command;
619 us->max_lun = 0; 630 us->max_lun = 0;
620 break; 631 break;
621 632
622 case US_SC_QIC: 633 case USB_SC_QIC:
623 us->protocol_name = "QIC-157"; 634 us->protocol_name = "QIC-157";
624 us->proto_handler = usb_stor_pad12_command; 635 us->proto_handler = usb_stor_pad12_command;
625 us->max_lun = 0; 636 us->max_lun = 0;
626 break; 637 break;
627 638
628 case US_SC_8070: 639 case USB_SC_8070:
629 us->protocol_name = "8070i"; 640 us->protocol_name = "8070i";
630 us->proto_handler = usb_stor_pad12_command; 641 us->proto_handler = usb_stor_pad12_command;
631 us->max_lun = 0; 642 us->max_lun = 0;
632 break; 643 break;
633 644
634 case US_SC_SCSI: 645 case USB_SC_SCSI:
635 us->protocol_name = "Transparent SCSI"; 646 us->protocol_name = "Transparent SCSI";
636 us->proto_handler = usb_stor_transparent_scsi_command; 647 us->proto_handler = usb_stor_transparent_scsi_command;
637 break; 648 break;
638 649
639 case US_SC_UFI: 650 case USB_SC_UFI:
640 us->protocol_name = "Uniform Floppy Interface (UFI)"; 651 us->protocol_name = "Uniform Floppy Interface (UFI)";
641 us->proto_handler = usb_stor_ufi_command; 652 us->proto_handler = usb_stor_ufi_command;
642 break; 653 break;
@@ -679,7 +690,7 @@ static int get_pipes(struct us_data *us)
679 } 690 }
680 } 691 }
681 692
682 if (!ep_in || !ep_out || (us->protocol == US_PR_CBI && !ep_int)) { 693 if (!ep_in || !ep_out || (us->protocol == USB_PR_CBI && !ep_int)) {
683 US_DEBUGP("Endpoint sanity check failed! Rejecting dev.\n"); 694 US_DEBUGP("Endpoint sanity check failed! Rejecting dev.\n");
684 return -EIO; 695 return -EIO;
685 } 696 }
@@ -834,7 +845,7 @@ static int usb_stor_scan_thread(void * __us)
834 if (!test_bit(US_FLIDX_DONT_SCAN, &us->dflags)) { 845 if (!test_bit(US_FLIDX_DONT_SCAN, &us->dflags)) {
835 846
836 /* For bulk-only devices, determine the max LUN value */ 847 /* For bulk-only devices, determine the max LUN value */
837 if (us->protocol == US_PR_BULK && 848 if (us->protocol == USB_PR_BULK &&
838 !(us->fflags & US_FL_SINGLE_LUN)) { 849 !(us->fflags & US_FL_SINGLE_LUN)) {
839 mutex_lock(&us->dev_mutex); 850 mutex_lock(&us->dev_mutex);
840 us->max_lun = usb_stor_Bulk_max_lun(us); 851 us->max_lun = usb_stor_Bulk_max_lun(us);
@@ -946,6 +957,13 @@ int usb_stor_probe2(struct us_data *us)
946 if (result) 957 if (result)
947 goto BadDevice; 958 goto BadDevice;
948 959
960 /*
961 * If the device returns invalid data for the first READ(10)
962 * command, indicate the command should be retried.
963 */
964 if (us->fflags & US_FL_INITIAL_READ10)
965 set_bit(US_FLIDX_REDO_READ10, &us->dflags);
966
949 /* Acquire all the other resources and add the host */ 967 /* Acquire all the other resources and add the host */
950 result = usb_stor_acquire_resources(us); 968 result = usb_stor_acquire_resources(us);
951 if (result) 969 if (result)
diff --git a/drivers/usb/storage/usb.h b/drivers/usb/storage/usb.h
index 89d3bfff98df..7b0f2113632e 100644
--- a/drivers/usb/storage/usb.h
+++ b/drivers/usb/storage/usb.h
@@ -73,6 +73,8 @@ struct us_unusual_dev {
73#define US_FLIDX_RESETTING 4 /* device reset in progress */ 73#define US_FLIDX_RESETTING 4 /* device reset in progress */
74#define US_FLIDX_TIMED_OUT 5 /* SCSI midlayer timed out */ 74#define US_FLIDX_TIMED_OUT 5 /* SCSI midlayer timed out */
75#define US_FLIDX_DONT_SCAN 6 /* don't scan (disconnect) */ 75#define US_FLIDX_DONT_SCAN 6 /* don't scan (disconnect) */
76#define US_FLIDX_REDO_READ10 7 /* redo READ(10) command */
77#define US_FLIDX_READ10_WORKED 8 /* previous READ(10) succeeded */
76 78
77#define USB_STOR_STRING_LEN 32 79#define USB_STOR_STRING_LEN 32
78 80
diff --git a/drivers/usb/storage/usual-tables.c b/drivers/usb/storage/usual-tables.c
index 468bde7d1971..b96927914f89 100644
--- a/drivers/usb/storage/usual-tables.c
+++ b/drivers/usb/storage/usual-tables.c
@@ -80,11 +80,13 @@ static struct ignore_entry ignore_ids[] = {
80# include "unusual_alauda.h" 80# include "unusual_alauda.h"
81# include "unusual_cypress.h" 81# include "unusual_cypress.h"
82# include "unusual_datafab.h" 82# include "unusual_datafab.h"
83# include "unusual_ene_ub6250.h"
83# include "unusual_freecom.h" 84# include "unusual_freecom.h"
84# include "unusual_isd200.h" 85# include "unusual_isd200.h"
85# include "unusual_jumpshot.h" 86# include "unusual_jumpshot.h"
86# include "unusual_karma.h" 87# include "unusual_karma.h"
87# include "unusual_onetouch.h" 88# include "unusual_onetouch.h"
89# include "unusual_realtek.h"
88# include "unusual_sddr09.h" 90# include "unusual_sddr09.h"
89# include "unusual_sddr55.h" 91# include "unusual_sddr55.h"
90# include "unusual_usbat.h" 92# include "unusual_usbat.h"
generated by cgit v1.2.2 (git 2.25.0) at 2025-07-27 01:30:41 -0400