Commit | Line | Data |
---|---|---|
e80b0fad MD |
1 | /* |
2 | * Driver for Alauda-based card readers | |
3 | * | |
4 | * Current development and maintenance by: | |
5 | * (c) 2005 Daniel Drake <dsd@gentoo.org> | |
6 | * | |
7 | * The 'Alauda' is a chip manufacturered by RATOC for OEM use. | |
8 | * | |
9 | * Alauda implements a vendor-specific command set to access two media reader | |
10 | * ports (XD, SmartMedia). This driver converts SCSI commands to the commands | |
11 | * which are accepted by these devices. | |
12 | * | |
13 | * The driver was developed through reverse-engineering, with the help of the | |
14 | * sddr09 driver which has many similarities, and with some help from the | |
15 | * (very old) vendor-supplied GPL sma03 driver. | |
16 | * | |
17 | * For protocol info, see http://alauda.sourceforge.net | |
18 | * | |
19 | * This program is free software; you can redistribute it and/or modify it | |
20 | * under the terms of the GNU General Public License as published by the | |
21 | * Free Software Foundation; either version 2, or (at your option) any | |
22 | * later version. | |
23 | * | |
24 | * This program is distributed in the hope that it will be useful, but | |
25 | * WITHOUT ANY WARRANTY; without even the implied warranty of | |
26 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
27 | * General Public License for more details. | |
28 | * | |
29 | * You should have received a copy of the GNU General Public License along | |
30 | * with this program; if not, write to the Free Software Foundation, Inc., | |
31 | * 675 Mass Ave, Cambridge, MA 02139, USA. | |
32 | */ | |
33 | ||
a74bba3b | 34 | #include <linux/module.h> |
5a0e3ad6 | 35 | #include <linux/slab.h> |
a74bba3b | 36 | |
e80b0fad MD |
37 | #include <scsi/scsi.h> |
38 | #include <scsi/scsi_cmnd.h> | |
39 | #include <scsi/scsi_device.h> | |
40 | ||
41 | #include "usb.h" | |
42 | #include "transport.h" | |
43 | #include "protocol.h" | |
44 | #include "debug.h" | |
aa519be3 AM |
45 | #include "scsiglue.h" |
46 | ||
47 | #define DRV_NAME "ums-alauda" | |
a74bba3b | 48 | |
4246b06a MG |
49 | MODULE_DESCRIPTION("Driver for Alauda-based card readers"); |
50 | MODULE_AUTHOR("Daniel Drake <dsd@gentoo.org>"); | |
51 | MODULE_LICENSE("GPL"); | |
52 | ||
a74bba3b AS |
53 | /* |
54 | * Status bytes | |
55 | */ | |
56 | #define ALAUDA_STATUS_ERROR 0x01 | |
57 | #define ALAUDA_STATUS_READY 0x40 | |
58 | ||
59 | /* | |
60 | * Control opcodes (for request field) | |
61 | */ | |
62 | #define ALAUDA_GET_XD_MEDIA_STATUS 0x08 | |
63 | #define ALAUDA_GET_SM_MEDIA_STATUS 0x98 | |
64 | #define ALAUDA_ACK_XD_MEDIA_CHANGE 0x0a | |
65 | #define ALAUDA_ACK_SM_MEDIA_CHANGE 0x9a | |
66 | #define ALAUDA_GET_XD_MEDIA_SIG 0x86 | |
67 | #define ALAUDA_GET_SM_MEDIA_SIG 0x96 | |
68 | ||
69 | /* | |
70 | * Bulk command identity (byte 0) | |
71 | */ | |
72 | #define ALAUDA_BULK_CMD 0x40 | |
73 | ||
74 | /* | |
75 | * Bulk opcodes (byte 1) | |
76 | */ | |
77 | #define ALAUDA_BULK_GET_REDU_DATA 0x85 | |
78 | #define ALAUDA_BULK_READ_BLOCK 0x94 | |
79 | #define ALAUDA_BULK_ERASE_BLOCK 0xa3 | |
80 | #define ALAUDA_BULK_WRITE_BLOCK 0xb4 | |
81 | #define ALAUDA_BULK_GET_STATUS2 0xb7 | |
82 | #define ALAUDA_BULK_RESET_MEDIA 0xe0 | |
83 | ||
84 | /* | |
85 | * Port to operate on (byte 8) | |
86 | */ | |
87 | #define ALAUDA_PORT_XD 0x00 | |
88 | #define ALAUDA_PORT_SM 0x01 | |
89 | ||
90 | /* | |
91 | * LBA and PBA are unsigned ints. Special values. | |
92 | */ | |
93 | #define UNDEF 0xffff | |
94 | #define SPARE 0xfffe | |
95 | #define UNUSABLE 0xfffd | |
96 | ||
97 | struct alauda_media_info { | |
98 | unsigned long capacity; /* total media size in bytes */ | |
99 | unsigned int pagesize; /* page size in bytes */ | |
100 | unsigned int blocksize; /* number of pages per block */ | |
101 | unsigned int uzonesize; /* number of usable blocks per zone */ | |
102 | unsigned int zonesize; /* number of blocks per zone */ | |
103 | unsigned int blockmask; /* mask to get page from address */ | |
104 | ||
105 | unsigned char pageshift; | |
106 | unsigned char blockshift; | |
107 | unsigned char zoneshift; | |
108 | ||
109 | u16 **lba_to_pba; /* logical to physical block map */ | |
110 | u16 **pba_to_lba; /* physical to logical block map */ | |
111 | }; | |
112 | ||
113 | struct alauda_info { | |
114 | struct alauda_media_info port[2]; | |
115 | int wr_ep; /* endpoint to write data out of */ | |
116 | ||
117 | unsigned char sense_key; | |
118 | unsigned long sense_asc; /* additional sense code */ | |
119 | unsigned long sense_ascq; /* additional sense code qualifier */ | |
120 | }; | |
e80b0fad MD |
121 | |
122 | #define short_pack(lsb,msb) ( ((u16)(lsb)) | ( ((u16)(msb))<<8 ) ) | |
123 | #define LSB_of(s) ((s)&0xFF) | |
124 | #define MSB_of(s) ((s)>>8) | |
125 | ||
126 | #define MEDIA_PORT(us) us->srb->device->lun | |
127 | #define MEDIA_INFO(us) ((struct alauda_info *)us->extra)->port[MEDIA_PORT(us)] | |
128 | ||
129 | #define PBA_LO(pba) ((pba & 0xF) << 5) | |
130 | #define PBA_HI(pba) (pba >> 3) | |
131 | #define PBA_ZONE(pba) (pba >> 11) | |
132 | ||
a74bba3b AS |
133 | static int init_alauda(struct us_data *us); |
134 | ||
135 | ||
136 | /* | |
137 | * The table of devices | |
138 | */ | |
139 | #define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \ | |
140 | vendorName, productName, useProtocol, useTransport, \ | |
141 | initFunction, flags) \ | |
142 | { USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \ | |
f61870ee | 143 | .driver_info = (flags) } |
a74bba3b | 144 | |
3358be9a | 145 | static struct usb_device_id alauda_usb_ids[] = { |
a74bba3b AS |
146 | # include "unusual_alauda.h" |
147 | { } /* Terminating entry */ | |
148 | }; | |
149 | MODULE_DEVICE_TABLE(usb, alauda_usb_ids); | |
150 | ||
151 | #undef UNUSUAL_DEV | |
152 | ||
153 | /* | |
154 | * The flags table | |
155 | */ | |
156 | #define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \ | |
157 | vendor_name, product_name, use_protocol, use_transport, \ | |
158 | init_function, Flags) \ | |
159 | { \ | |
160 | .vendorName = vendor_name, \ | |
161 | .productName = product_name, \ | |
162 | .useProtocol = use_protocol, \ | |
163 | .useTransport = use_transport, \ | |
164 | .initFunction = init_function, \ | |
165 | } | |
166 | ||
167 | static struct us_unusual_dev alauda_unusual_dev_list[] = { | |
168 | # include "unusual_alauda.h" | |
169 | { } /* Terminating entry */ | |
170 | }; | |
171 | ||
172 | #undef UNUSUAL_DEV | |
173 | ||
174 | ||
e80b0fad MD |
175 | /* |
176 | * Media handling | |
177 | */ | |
178 | ||
179 | struct alauda_card_info { | |
180 | unsigned char id; /* id byte */ | |
181 | unsigned char chipshift; /* 1<<cs bytes total capacity */ | |
182 | unsigned char pageshift; /* 1<<ps bytes in a page */ | |
183 | unsigned char blockshift; /* 1<<bs pages per block */ | |
184 | unsigned char zoneshift; /* 1<<zs blocks per zone */ | |
185 | }; | |
186 | ||
187 | static struct alauda_card_info alauda_card_ids[] = { | |
188 | /* NAND flash */ | |
189 | { 0x6e, 20, 8, 4, 8}, /* 1 MB */ | |
190 | { 0xe8, 20, 8, 4, 8}, /* 1 MB */ | |
191 | { 0xec, 20, 8, 4, 8}, /* 1 MB */ | |
192 | { 0x64, 21, 8, 4, 9}, /* 2 MB */ | |
193 | { 0xea, 21, 8, 4, 9}, /* 2 MB */ | |
194 | { 0x6b, 22, 9, 4, 9}, /* 4 MB */ | |
195 | { 0xe3, 22, 9, 4, 9}, /* 4 MB */ | |
196 | { 0xe5, 22, 9, 4, 9}, /* 4 MB */ | |
197 | { 0xe6, 23, 9, 4, 10}, /* 8 MB */ | |
198 | { 0x73, 24, 9, 5, 10}, /* 16 MB */ | |
199 | { 0x75, 25, 9, 5, 10}, /* 32 MB */ | |
200 | { 0x76, 26, 9, 5, 10}, /* 64 MB */ | |
201 | { 0x79, 27, 9, 5, 10}, /* 128 MB */ | |
202 | { 0x71, 28, 9, 5, 10}, /* 256 MB */ | |
203 | ||
204 | /* MASK ROM */ | |
205 | { 0x5d, 21, 9, 4, 8}, /* 2 MB */ | |
206 | { 0xd5, 22, 9, 4, 9}, /* 4 MB */ | |
207 | { 0xd6, 23, 9, 4, 10}, /* 8 MB */ | |
208 | { 0x57, 24, 9, 4, 11}, /* 16 MB */ | |
209 | { 0x58, 25, 9, 4, 12}, /* 32 MB */ | |
210 | { 0,} | |
211 | }; | |
212 | ||
0de84696 BP |
213 | static struct alauda_card_info *alauda_card_find_id(unsigned char id) |
214 | { | |
e80b0fad MD |
215 | int i; |
216 | ||
217 | for (i = 0; alauda_card_ids[i].id != 0; i++) | |
218 | if (alauda_card_ids[i].id == id) | |
219 | return &(alauda_card_ids[i]); | |
220 | return NULL; | |
221 | } | |
222 | ||
223 | /* | |
224 | * ECC computation. | |
225 | */ | |
226 | ||
227 | static unsigned char parity[256]; | |
228 | static unsigned char ecc2[256]; | |
229 | ||
0de84696 BP |
230 | static void nand_init_ecc(void) |
231 | { | |
e80b0fad MD |
232 | int i, j, a; |
233 | ||
234 | parity[0] = 0; | |
235 | for (i = 1; i < 256; i++) | |
236 | parity[i] = (parity[i&(i-1)] ^ 1); | |
237 | ||
238 | for (i = 0; i < 256; i++) { | |
239 | a = 0; | |
240 | for (j = 0; j < 8; j++) { | |
241 | if (i & (1<<j)) { | |
242 | if ((j & 1) == 0) | |
243 | a ^= 0x04; | |
244 | if ((j & 2) == 0) | |
245 | a ^= 0x10; | |
246 | if ((j & 4) == 0) | |
247 | a ^= 0x40; | |
248 | } | |
249 | } | |
250 | ecc2[i] = ~(a ^ (a<<1) ^ (parity[i] ? 0xa8 : 0)); | |
251 | } | |
252 | } | |
253 | ||
254 | /* compute 3-byte ecc on 256 bytes */ | |
0de84696 BP |
255 | static void nand_compute_ecc(unsigned char *data, unsigned char *ecc) |
256 | { | |
e80b0fad | 257 | int i, j, a; |
6523f6d2 | 258 | unsigned char par = 0, bit, bits[8] = {0}; |
e80b0fad MD |
259 | |
260 | /* collect 16 checksum bits */ | |
261 | for (i = 0; i < 256; i++) { | |
262 | par ^= data[i]; | |
263 | bit = parity[data[i]]; | |
264 | for (j = 0; j < 8; j++) | |
265 | if ((i & (1<<j)) == 0) | |
266 | bits[j] ^= bit; | |
267 | } | |
268 | ||
269 | /* put 4+4+4 = 12 bits in the ecc */ | |
270 | a = (bits[3] << 6) + (bits[2] << 4) + (bits[1] << 2) + bits[0]; | |
271 | ecc[0] = ~(a ^ (a<<1) ^ (parity[par] ? 0xaa : 0)); | |
272 | ||
273 | a = (bits[7] << 6) + (bits[6] << 4) + (bits[5] << 2) + bits[4]; | |
274 | ecc[1] = ~(a ^ (a<<1) ^ (parity[par] ? 0xaa : 0)); | |
275 | ||
276 | ecc[2] = ecc2[par]; | |
277 | } | |
278 | ||
0de84696 BP |
279 | static int nand_compare_ecc(unsigned char *data, unsigned char *ecc) |
280 | { | |
e80b0fad MD |
281 | return (data[0] == ecc[0] && data[1] == ecc[1] && data[2] == ecc[2]); |
282 | } | |
283 | ||
0de84696 BP |
284 | static void nand_store_ecc(unsigned char *data, unsigned char *ecc) |
285 | { | |
e80b0fad MD |
286 | memcpy(data, ecc, 3); |
287 | } | |
288 | ||
289 | /* | |
290 | * Alauda driver | |
291 | */ | |
292 | ||
293 | /* | |
294 | * Forget our PBA <---> LBA mappings for a particular port | |
295 | */ | |
296 | static void alauda_free_maps (struct alauda_media_info *media_info) | |
297 | { | |
298 | unsigned int shift = media_info->zoneshift | |
299 | + media_info->blockshift + media_info->pageshift; | |
300 | unsigned int num_zones = media_info->capacity >> shift; | |
301 | unsigned int i; | |
302 | ||
303 | if (media_info->lba_to_pba != NULL) | |
304 | for (i = 0; i < num_zones; i++) { | |
305 | kfree(media_info->lba_to_pba[i]); | |
306 | media_info->lba_to_pba[i] = NULL; | |
307 | } | |
308 | ||
309 | if (media_info->pba_to_lba != NULL) | |
310 | for (i = 0; i < num_zones; i++) { | |
311 | kfree(media_info->pba_to_lba[i]); | |
312 | media_info->pba_to_lba[i] = NULL; | |
313 | } | |
314 | } | |
315 | ||
316 | /* | |
317 | * Returns 2 bytes of status data | |
318 | * The first byte describes media status, and second byte describes door status | |
319 | */ | |
320 | static int alauda_get_media_status(struct us_data *us, unsigned char *data) | |
321 | { | |
322 | int rc; | |
323 | unsigned char command; | |
324 | ||
325 | if (MEDIA_PORT(us) == ALAUDA_PORT_XD) | |
326 | command = ALAUDA_GET_XD_MEDIA_STATUS; | |
327 | else | |
328 | command = ALAUDA_GET_SM_MEDIA_STATUS; | |
329 | ||
330 | rc = usb_stor_ctrl_transfer(us, us->recv_ctrl_pipe, | |
331 | command, 0xc0, 0, 1, data, 2); | |
332 | ||
191648d0 | 333 | usb_stor_dbg(us, "Media status %02X %02X\n", data[0], data[1]); |
e80b0fad MD |
334 | |
335 | return rc; | |
336 | } | |
337 | ||
338 | /* | |
339 | * Clears the "media was changed" bit so that we know when it changes again | |
340 | * in the future. | |
341 | */ | |
342 | static int alauda_ack_media(struct us_data *us) | |
343 | { | |
344 | unsigned char command; | |
345 | ||
346 | if (MEDIA_PORT(us) == ALAUDA_PORT_XD) | |
347 | command = ALAUDA_ACK_XD_MEDIA_CHANGE; | |
348 | else | |
349 | command = ALAUDA_ACK_SM_MEDIA_CHANGE; | |
350 | ||
351 | return usb_stor_ctrl_transfer(us, us->send_ctrl_pipe, | |
352 | command, 0x40, 0, 1, NULL, 0); | |
353 | } | |
354 | ||
355 | /* | |
356 | * Retrieves a 4-byte media signature, which indicates manufacturer, capacity, | |
357 | * and some other details. | |
358 | */ | |
359 | static int alauda_get_media_signature(struct us_data *us, unsigned char *data) | |
360 | { | |
361 | unsigned char command; | |
362 | ||
363 | if (MEDIA_PORT(us) == ALAUDA_PORT_XD) | |
364 | command = ALAUDA_GET_XD_MEDIA_SIG; | |
365 | else | |
366 | command = ALAUDA_GET_SM_MEDIA_SIG; | |
367 | ||
368 | return usb_stor_ctrl_transfer(us, us->recv_ctrl_pipe, | |
369 | command, 0xc0, 0, 0, data, 4); | |
370 | } | |
371 | ||
372 | /* | |
373 | * Resets the media status (but not the whole device?) | |
374 | */ | |
375 | static int alauda_reset_media(struct us_data *us) | |
376 | { | |
377 | unsigned char *command = us->iobuf; | |
378 | ||
379 | memset(command, 0, 9); | |
380 | command[0] = ALAUDA_BULK_CMD; | |
381 | command[1] = ALAUDA_BULK_RESET_MEDIA; | |
382 | command[8] = MEDIA_PORT(us); | |
383 | ||
384 | return usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe, | |
385 | command, 9, NULL); | |
386 | } | |
387 | ||
388 | /* | |
389 | * Examines the media and deduces capacity, etc. | |
390 | */ | |
391 | static int alauda_init_media(struct us_data *us) | |
392 | { | |
393 | unsigned char *data = us->iobuf; | |
394 | int ready = 0; | |
395 | struct alauda_card_info *media_info; | |
396 | unsigned int num_zones; | |
397 | ||
398 | while (ready == 0) { | |
399 | msleep(20); | |
400 | ||
401 | if (alauda_get_media_status(us, data) != USB_STOR_XFER_GOOD) | |
402 | return USB_STOR_TRANSPORT_ERROR; | |
403 | ||
404 | if (data[0] & 0x10) | |
405 | ready = 1; | |
406 | } | |
407 | ||
191648d0 | 408 | usb_stor_dbg(us, "We are ready for action!\n"); |
e80b0fad MD |
409 | |
410 | if (alauda_ack_media(us) != USB_STOR_XFER_GOOD) | |
411 | return USB_STOR_TRANSPORT_ERROR; | |
412 | ||
413 | msleep(10); | |
414 | ||
415 | if (alauda_get_media_status(us, data) != USB_STOR_XFER_GOOD) | |
416 | return USB_STOR_TRANSPORT_ERROR; | |
417 | ||
418 | if (data[0] != 0x14) { | |
191648d0 | 419 | usb_stor_dbg(us, "Media not ready after ack\n"); |
e80b0fad MD |
420 | return USB_STOR_TRANSPORT_ERROR; |
421 | } | |
422 | ||
423 | if (alauda_get_media_signature(us, data) != USB_STOR_XFER_GOOD) | |
424 | return USB_STOR_TRANSPORT_ERROR; | |
425 | ||
7adce467 | 426 | usb_stor_dbg(us, "Media signature: %4ph\n", data); |
e80b0fad MD |
427 | media_info = alauda_card_find_id(data[1]); |
428 | if (media_info == NULL) { | |
7adce467 AS |
429 | pr_warn("alauda_init_media: Unrecognised media signature: %4ph\n", |
430 | data); | |
e80b0fad MD |
431 | return USB_STOR_TRANSPORT_ERROR; |
432 | } | |
433 | ||
434 | MEDIA_INFO(us).capacity = 1 << media_info->chipshift; | |
191648d0 JP |
435 | usb_stor_dbg(us, "Found media with capacity: %ldMB\n", |
436 | MEDIA_INFO(us).capacity >> 20); | |
e80b0fad MD |
437 | |
438 | MEDIA_INFO(us).pageshift = media_info->pageshift; | |
439 | MEDIA_INFO(us).blockshift = media_info->blockshift; | |
440 | MEDIA_INFO(us).zoneshift = media_info->zoneshift; | |
441 | ||
442 | MEDIA_INFO(us).pagesize = 1 << media_info->pageshift; | |
443 | MEDIA_INFO(us).blocksize = 1 << media_info->blockshift; | |
444 | MEDIA_INFO(us).zonesize = 1 << media_info->zoneshift; | |
445 | ||
446 | MEDIA_INFO(us).uzonesize = ((1 << media_info->zoneshift) / 128) * 125; | |
447 | MEDIA_INFO(us).blockmask = MEDIA_INFO(us).blocksize - 1; | |
448 | ||
449 | num_zones = MEDIA_INFO(us).capacity >> (MEDIA_INFO(us).zoneshift | |
450 | + MEDIA_INFO(us).blockshift + MEDIA_INFO(us).pageshift); | |
451 | MEDIA_INFO(us).pba_to_lba = kcalloc(num_zones, sizeof(u16*), GFP_NOIO); | |
452 | MEDIA_INFO(us).lba_to_pba = kcalloc(num_zones, sizeof(u16*), GFP_NOIO); | |
453 | ||
454 | if (alauda_reset_media(us) != USB_STOR_XFER_GOOD) | |
455 | return USB_STOR_TRANSPORT_ERROR; | |
456 | ||
457 | return USB_STOR_TRANSPORT_GOOD; | |
458 | } | |
459 | ||
460 | /* | |
461 | * Examines the media status and does the right thing when the media has gone, | |
462 | * appeared, or changed. | |
463 | */ | |
464 | static int alauda_check_media(struct us_data *us) | |
465 | { | |
466 | struct alauda_info *info = (struct alauda_info *) us->extra; | |
467 | unsigned char status[2]; | |
468 | int rc; | |
469 | ||
470 | rc = alauda_get_media_status(us, status); | |
471 | ||
472 | /* Check for no media or door open */ | |
473 | if ((status[0] & 0x80) || ((status[0] & 0x1F) == 0x10) | |
474 | || ((status[1] & 0x01) == 0)) { | |
191648d0 | 475 | usb_stor_dbg(us, "No media, or door open\n"); |
e80b0fad MD |
476 | alauda_free_maps(&MEDIA_INFO(us)); |
477 | info->sense_key = 0x02; | |
478 | info->sense_asc = 0x3A; | |
479 | info->sense_ascq = 0x00; | |
480 | return USB_STOR_TRANSPORT_FAILED; | |
481 | } | |
482 | ||
483 | /* Check for media change */ | |
484 | if (status[0] & 0x08) { | |
191648d0 | 485 | usb_stor_dbg(us, "Media change detected\n"); |
e80b0fad MD |
486 | alauda_free_maps(&MEDIA_INFO(us)); |
487 | alauda_init_media(us); | |
488 | ||
489 | info->sense_key = UNIT_ATTENTION; | |
490 | info->sense_asc = 0x28; | |
491 | info->sense_ascq = 0x00; | |
492 | return USB_STOR_TRANSPORT_FAILED; | |
493 | } | |
494 | ||
495 | return USB_STOR_TRANSPORT_GOOD; | |
496 | } | |
497 | ||
498 | /* | |
499 | * Checks the status from the 2nd status register | |
500 | * Returns 3 bytes of status data, only the first is known | |
501 | */ | |
502 | static int alauda_check_status2(struct us_data *us) | |
503 | { | |
504 | int rc; | |
505 | unsigned char command[] = { | |
506 | ALAUDA_BULK_CMD, ALAUDA_BULK_GET_STATUS2, | |
507 | 0, 0, 0, 0, 3, 0, MEDIA_PORT(us) | |
508 | }; | |
509 | unsigned char data[3]; | |
510 | ||
511 | rc = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe, | |
512 | command, 9, NULL); | |
513 | if (rc != USB_STOR_XFER_GOOD) | |
514 | return rc; | |
515 | ||
516 | rc = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, | |
517 | data, 3, NULL); | |
518 | if (rc != USB_STOR_XFER_GOOD) | |
519 | return rc; | |
520 | ||
7adce467 | 521 | usb_stor_dbg(us, "%3ph\n", data); |
e80b0fad MD |
522 | if (data[0] & ALAUDA_STATUS_ERROR) |
523 | return USB_STOR_XFER_ERROR; | |
524 | ||
525 | return USB_STOR_XFER_GOOD; | |
526 | } | |
527 | ||
528 | /* | |
529 | * Gets the redundancy data for the first page of a PBA | |
530 | * Returns 16 bytes. | |
531 | */ | |
532 | static int alauda_get_redu_data(struct us_data *us, u16 pba, unsigned char *data) | |
533 | { | |
534 | int rc; | |
535 | unsigned char command[] = { | |
536 | ALAUDA_BULK_CMD, ALAUDA_BULK_GET_REDU_DATA, | |
537 | PBA_HI(pba), PBA_ZONE(pba), 0, PBA_LO(pba), 0, 0, MEDIA_PORT(us) | |
538 | }; | |
539 | ||
540 | rc = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe, | |
541 | command, 9, NULL); | |
542 | if (rc != USB_STOR_XFER_GOOD) | |
543 | return rc; | |
544 | ||
545 | return usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, | |
546 | data, 16, NULL); | |
547 | } | |
548 | ||
549 | /* | |
550 | * Finds the first unused PBA in a zone | |
551 | * Returns the absolute PBA of an unused PBA, or 0 if none found. | |
552 | */ | |
553 | static u16 alauda_find_unused_pba(struct alauda_media_info *info, | |
554 | unsigned int zone) | |
555 | { | |
556 | u16 *pba_to_lba = info->pba_to_lba[zone]; | |
557 | unsigned int i; | |
558 | ||
559 | for (i = 0; i < info->zonesize; i++) | |
560 | if (pba_to_lba[i] == UNDEF) | |
561 | return (zone << info->zoneshift) + i; | |
562 | ||
563 | return 0; | |
564 | } | |
565 | ||
566 | /* | |
567 | * Reads the redundancy data for all PBA's in a zone | |
568 | * Produces lba <--> pba mappings | |
569 | */ | |
570 | static int alauda_read_map(struct us_data *us, unsigned int zone) | |
571 | { | |
572 | unsigned char *data = us->iobuf; | |
573 | int result; | |
574 | int i, j; | |
575 | unsigned int zonesize = MEDIA_INFO(us).zonesize; | |
576 | unsigned int uzonesize = MEDIA_INFO(us).uzonesize; | |
577 | unsigned int lba_offset, lba_real, blocknum; | |
578 | unsigned int zone_base_lba = zone * uzonesize; | |
579 | unsigned int zone_base_pba = zone * zonesize; | |
580 | u16 *lba_to_pba = kcalloc(zonesize, sizeof(u16), GFP_NOIO); | |
581 | u16 *pba_to_lba = kcalloc(zonesize, sizeof(u16), GFP_NOIO); | |
582 | if (lba_to_pba == NULL || pba_to_lba == NULL) { | |
583 | result = USB_STOR_TRANSPORT_ERROR; | |
584 | goto error; | |
585 | } | |
586 | ||
191648d0 | 587 | usb_stor_dbg(us, "Mapping blocks for zone %d\n", zone); |
e80b0fad MD |
588 | |
589 | /* 1024 PBA's per zone */ | |
590 | for (i = 0; i < zonesize; i++) | |
591 | lba_to_pba[i] = pba_to_lba[i] = UNDEF; | |
592 | ||
593 | for (i = 0; i < zonesize; i++) { | |
594 | blocknum = zone_base_pba + i; | |
595 | ||
596 | result = alauda_get_redu_data(us, blocknum, data); | |
597 | if (result != USB_STOR_XFER_GOOD) { | |
598 | result = USB_STOR_TRANSPORT_ERROR; | |
599 | goto error; | |
600 | } | |
601 | ||
602 | /* special PBAs have control field 0^16 */ | |
603 | for (j = 0; j < 16; j++) | |
604 | if (data[j] != 0) | |
605 | goto nonz; | |
606 | pba_to_lba[i] = UNUSABLE; | |
191648d0 | 607 | usb_stor_dbg(us, "PBA %d has no logical mapping\n", blocknum); |
e80b0fad MD |
608 | continue; |
609 | ||
610 | nonz: | |
611 | /* unwritten PBAs have control field FF^16 */ | |
612 | for (j = 0; j < 16; j++) | |
613 | if (data[j] != 0xff) | |
614 | goto nonff; | |
615 | continue; | |
616 | ||
617 | nonff: | |
618 | /* normal PBAs start with six FFs */ | |
619 | if (j < 6) { | |
191648d0 JP |
620 | usb_stor_dbg(us, "PBA %d has no logical mapping: reserved area = %02X%02X%02X%02X data status %02X block status %02X\n", |
621 | blocknum, | |
622 | data[0], data[1], data[2], data[3], | |
623 | data[4], data[5]); | |
e80b0fad MD |
624 | pba_to_lba[i] = UNUSABLE; |
625 | continue; | |
626 | } | |
627 | ||
628 | if ((data[6] >> 4) != 0x01) { | |
191648d0 JP |
629 | usb_stor_dbg(us, "PBA %d has invalid address field %02X%02X/%02X%02X\n", |
630 | blocknum, data[6], data[7], | |
631 | data[11], data[12]); | |
e80b0fad MD |
632 | pba_to_lba[i] = UNUSABLE; |
633 | continue; | |
634 | } | |
635 | ||
636 | /* check even parity */ | |
637 | if (parity[data[6] ^ data[7]]) { | |
6f8aa65b FS |
638 | printk(KERN_WARNING |
639 | "alauda_read_map: Bad parity in LBA for block %d" | |
e80b0fad MD |
640 | " (%02X %02X)\n", i, data[6], data[7]); |
641 | pba_to_lba[i] = UNUSABLE; | |
642 | continue; | |
643 | } | |
644 | ||
645 | lba_offset = short_pack(data[7], data[6]); | |
646 | lba_offset = (lba_offset & 0x07FF) >> 1; | |
647 | lba_real = lba_offset + zone_base_lba; | |
648 | ||
649 | /* | |
650 | * Every 1024 physical blocks ("zone"), the LBA numbers | |
651 | * go back to zero, but are within a higher block of LBA's. | |
652 | * Also, there is a maximum of 1000 LBA's per zone. | |
653 | * In other words, in PBA 1024-2047 you will find LBA 0-999 | |
654 | * which are really LBA 1000-1999. This allows for 24 bad | |
655 | * or special physical blocks per zone. | |
656 | */ | |
657 | ||
658 | if (lba_offset >= uzonesize) { | |
6f8aa65b FS |
659 | printk(KERN_WARNING |
660 | "alauda_read_map: Bad low LBA %d for block %d\n", | |
e80b0fad MD |
661 | lba_real, blocknum); |
662 | continue; | |
663 | } | |
664 | ||
665 | if (lba_to_pba[lba_offset] != UNDEF) { | |
6f8aa65b FS |
666 | printk(KERN_WARNING |
667 | "alauda_read_map: " | |
668 | "LBA %d seen for PBA %d and %d\n", | |
e80b0fad MD |
669 | lba_real, lba_to_pba[lba_offset], blocknum); |
670 | continue; | |
671 | } | |
672 | ||
673 | pba_to_lba[i] = lba_real; | |
674 | lba_to_pba[lba_offset] = blocknum; | |
675 | continue; | |
676 | } | |
677 | ||
678 | MEDIA_INFO(us).lba_to_pba[zone] = lba_to_pba; | |
679 | MEDIA_INFO(us).pba_to_lba[zone] = pba_to_lba; | |
680 | result = 0; | |
681 | goto out; | |
682 | ||
683 | error: | |
684 | kfree(lba_to_pba); | |
685 | kfree(pba_to_lba); | |
686 | out: | |
687 | return result; | |
688 | } | |
689 | ||
690 | /* | |
691 | * Checks to see whether we have already mapped a certain zone | |
692 | * If we haven't, the map is generated | |
693 | */ | |
694 | static void alauda_ensure_map_for_zone(struct us_data *us, unsigned int zone) | |
695 | { | |
696 | if (MEDIA_INFO(us).lba_to_pba[zone] == NULL | |
697 | || MEDIA_INFO(us).pba_to_lba[zone] == NULL) | |
698 | alauda_read_map(us, zone); | |
699 | } | |
700 | ||
701 | /* | |
702 | * Erases an entire block | |
703 | */ | |
704 | static int alauda_erase_block(struct us_data *us, u16 pba) | |
705 | { | |
706 | int rc; | |
707 | unsigned char command[] = { | |
708 | ALAUDA_BULK_CMD, ALAUDA_BULK_ERASE_BLOCK, PBA_HI(pba), | |
709 | PBA_ZONE(pba), 0, PBA_LO(pba), 0x02, 0, MEDIA_PORT(us) | |
710 | }; | |
711 | unsigned char buf[2]; | |
712 | ||
191648d0 | 713 | usb_stor_dbg(us, "Erasing PBA %d\n", pba); |
e80b0fad MD |
714 | |
715 | rc = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe, | |
716 | command, 9, NULL); | |
717 | if (rc != USB_STOR_XFER_GOOD) | |
718 | return rc; | |
719 | ||
720 | rc = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, | |
721 | buf, 2, NULL); | |
722 | if (rc != USB_STOR_XFER_GOOD) | |
723 | return rc; | |
724 | ||
191648d0 | 725 | usb_stor_dbg(us, "Erase result: %02X %02X\n", buf[0], buf[1]); |
e80b0fad MD |
726 | return rc; |
727 | } | |
728 | ||
729 | /* | |
730 | * Reads data from a certain offset page inside a PBA, including interleaved | |
731 | * redundancy data. Returns (pagesize+64)*pages bytes in data. | |
732 | */ | |
733 | static int alauda_read_block_raw(struct us_data *us, u16 pba, | |
734 | unsigned int page, unsigned int pages, unsigned char *data) | |
735 | { | |
736 | int rc; | |
737 | unsigned char command[] = { | |
738 | ALAUDA_BULK_CMD, ALAUDA_BULK_READ_BLOCK, PBA_HI(pba), | |
739 | PBA_ZONE(pba), 0, PBA_LO(pba) + page, pages, 0, MEDIA_PORT(us) | |
740 | }; | |
741 | ||
191648d0 | 742 | usb_stor_dbg(us, "pba %d page %d count %d\n", pba, page, pages); |
e80b0fad MD |
743 | |
744 | rc = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe, | |
745 | command, 9, NULL); | |
746 | if (rc != USB_STOR_XFER_GOOD) | |
747 | return rc; | |
748 | ||
749 | return usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, | |
750 | data, (MEDIA_INFO(us).pagesize + 64) * pages, NULL); | |
751 | } | |
752 | ||
753 | /* | |
754 | * Reads data from a certain offset page inside a PBA, excluding redundancy | |
755 | * data. Returns pagesize*pages bytes in data. Note that data must be big enough | |
756 | * to hold (pagesize+64)*pages bytes of data, but you can ignore those 'extra' | |
757 | * trailing bytes outside this function. | |
758 | */ | |
759 | static int alauda_read_block(struct us_data *us, u16 pba, | |
760 | unsigned int page, unsigned int pages, unsigned char *data) | |
761 | { | |
762 | int i, rc; | |
763 | unsigned int pagesize = MEDIA_INFO(us).pagesize; | |
764 | ||
765 | rc = alauda_read_block_raw(us, pba, page, pages, data); | |
766 | if (rc != USB_STOR_XFER_GOOD) | |
767 | return rc; | |
768 | ||
769 | /* Cut out the redundancy data */ | |
770 | for (i = 0; i < pages; i++) { | |
771 | int dest_offset = i * pagesize; | |
772 | int src_offset = i * (pagesize + 64); | |
773 | memmove(data + dest_offset, data + src_offset, pagesize); | |
774 | } | |
775 | ||
776 | return rc; | |
777 | } | |
778 | ||
779 | /* | |
780 | * Writes an entire block of data and checks status after write. | |
781 | * Redundancy data must be already included in data. Data should be | |
782 | * (pagesize+64)*blocksize bytes in length. | |
783 | */ | |
784 | static int alauda_write_block(struct us_data *us, u16 pba, unsigned char *data) | |
785 | { | |
786 | int rc; | |
787 | struct alauda_info *info = (struct alauda_info *) us->extra; | |
788 | unsigned char command[] = { | |
789 | ALAUDA_BULK_CMD, ALAUDA_BULK_WRITE_BLOCK, PBA_HI(pba), | |
790 | PBA_ZONE(pba), 0, PBA_LO(pba), 32, 0, MEDIA_PORT(us) | |
791 | }; | |
792 | ||
191648d0 | 793 | usb_stor_dbg(us, "pba %d\n", pba); |
e80b0fad MD |
794 | |
795 | rc = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe, | |
796 | command, 9, NULL); | |
797 | if (rc != USB_STOR_XFER_GOOD) | |
798 | return rc; | |
799 | ||
800 | rc = usb_stor_bulk_transfer_buf(us, info->wr_ep, data, | |
801 | (MEDIA_INFO(us).pagesize + 64) * MEDIA_INFO(us).blocksize, | |
802 | NULL); | |
803 | if (rc != USB_STOR_XFER_GOOD) | |
804 | return rc; | |
805 | ||
806 | return alauda_check_status2(us); | |
807 | } | |
808 | ||
809 | /* | |
810 | * Write some data to a specific LBA. | |
811 | */ | |
812 | static int alauda_write_lba(struct us_data *us, u16 lba, | |
813 | unsigned int page, unsigned int pages, | |
814 | unsigned char *ptr, unsigned char *blockbuffer) | |
815 | { | |
816 | u16 pba, lbap, new_pba; | |
817 | unsigned char *bptr, *cptr, *xptr; | |
818 | unsigned char ecc[3]; | |
819 | int i, result; | |
820 | unsigned int uzonesize = MEDIA_INFO(us).uzonesize; | |
821 | unsigned int zonesize = MEDIA_INFO(us).zonesize; | |
822 | unsigned int pagesize = MEDIA_INFO(us).pagesize; | |
823 | unsigned int blocksize = MEDIA_INFO(us).blocksize; | |
824 | unsigned int lba_offset = lba % uzonesize; | |
825 | unsigned int new_pba_offset; | |
826 | unsigned int zone = lba / uzonesize; | |
827 | ||
828 | alauda_ensure_map_for_zone(us, zone); | |
829 | ||
830 | pba = MEDIA_INFO(us).lba_to_pba[zone][lba_offset]; | |
831 | if (pba == 1) { | |
832 | /* Maybe it is impossible to write to PBA 1. | |
833 | Fake success, but don't do anything. */ | |
6f8aa65b FS |
834 | printk(KERN_WARNING |
835 | "alauda_write_lba: avoid writing to pba 1\n"); | |
e80b0fad MD |
836 | return USB_STOR_TRANSPORT_GOOD; |
837 | } | |
838 | ||
839 | new_pba = alauda_find_unused_pba(&MEDIA_INFO(us), zone); | |
840 | if (!new_pba) { | |
6f8aa65b FS |
841 | printk(KERN_WARNING |
842 | "alauda_write_lba: Out of unused blocks\n"); | |
e80b0fad MD |
843 | return USB_STOR_TRANSPORT_ERROR; |
844 | } | |
845 | ||
846 | /* read old contents */ | |
847 | if (pba != UNDEF) { | |
848 | result = alauda_read_block_raw(us, pba, 0, | |
849 | blocksize, blockbuffer); | |
850 | if (result != USB_STOR_XFER_GOOD) | |
851 | return result; | |
852 | } else { | |
853 | memset(blockbuffer, 0, blocksize * (pagesize + 64)); | |
854 | } | |
855 | ||
856 | lbap = (lba_offset << 1) | 0x1000; | |
857 | if (parity[MSB_of(lbap) ^ LSB_of(lbap)]) | |
858 | lbap ^= 1; | |
859 | ||
860 | /* check old contents and fill lba */ | |
861 | for (i = 0; i < blocksize; i++) { | |
862 | bptr = blockbuffer + (i * (pagesize + 64)); | |
863 | cptr = bptr + pagesize; | |
864 | nand_compute_ecc(bptr, ecc); | |
865 | if (!nand_compare_ecc(cptr+13, ecc)) { | |
191648d0 JP |
866 | usb_stor_dbg(us, "Warning: bad ecc in page %d- of pba %d\n", |
867 | i, pba); | |
e80b0fad MD |
868 | nand_store_ecc(cptr+13, ecc); |
869 | } | |
870 | nand_compute_ecc(bptr + (pagesize / 2), ecc); | |
871 | if (!nand_compare_ecc(cptr+8, ecc)) { | |
191648d0 JP |
872 | usb_stor_dbg(us, "Warning: bad ecc in page %d+ of pba %d\n", |
873 | i, pba); | |
e80b0fad MD |
874 | nand_store_ecc(cptr+8, ecc); |
875 | } | |
876 | cptr[6] = cptr[11] = MSB_of(lbap); | |
877 | cptr[7] = cptr[12] = LSB_of(lbap); | |
878 | } | |
879 | ||
880 | /* copy in new stuff and compute ECC */ | |
881 | xptr = ptr; | |
882 | for (i = page; i < page+pages; i++) { | |
883 | bptr = blockbuffer + (i * (pagesize + 64)); | |
884 | cptr = bptr + pagesize; | |
885 | memcpy(bptr, xptr, pagesize); | |
886 | xptr += pagesize; | |
887 | nand_compute_ecc(bptr, ecc); | |
888 | nand_store_ecc(cptr+13, ecc); | |
889 | nand_compute_ecc(bptr + (pagesize / 2), ecc); | |
890 | nand_store_ecc(cptr+8, ecc); | |
891 | } | |
892 | ||
893 | result = alauda_write_block(us, new_pba, blockbuffer); | |
894 | if (result != USB_STOR_XFER_GOOD) | |
895 | return result; | |
896 | ||
897 | new_pba_offset = new_pba - (zone * zonesize); | |
898 | MEDIA_INFO(us).pba_to_lba[zone][new_pba_offset] = lba; | |
899 | MEDIA_INFO(us).lba_to_pba[zone][lba_offset] = new_pba; | |
191648d0 | 900 | usb_stor_dbg(us, "Remapped LBA %d to PBA %d\n", lba, new_pba); |
e80b0fad MD |
901 | |
902 | if (pba != UNDEF) { | |
903 | unsigned int pba_offset = pba - (zone * zonesize); | |
904 | result = alauda_erase_block(us, pba); | |
905 | if (result != USB_STOR_XFER_GOOD) | |
906 | return result; | |
907 | MEDIA_INFO(us).pba_to_lba[zone][pba_offset] = UNDEF; | |
908 | } | |
909 | ||
910 | return USB_STOR_TRANSPORT_GOOD; | |
911 | } | |
912 | ||
913 | /* | |
914 | * Read data from a specific sector address | |
915 | */ | |
916 | static int alauda_read_data(struct us_data *us, unsigned long address, | |
917 | unsigned int sectors) | |
918 | { | |
919 | unsigned char *buffer; | |
920 | u16 lba, max_lba; | |
1f6f31a0 | 921 | unsigned int page, len, offset; |
e80b0fad MD |
922 | unsigned int blockshift = MEDIA_INFO(us).blockshift; |
923 | unsigned int pageshift = MEDIA_INFO(us).pageshift; | |
924 | unsigned int blocksize = MEDIA_INFO(us).blocksize; | |
925 | unsigned int pagesize = MEDIA_INFO(us).pagesize; | |
926 | unsigned int uzonesize = MEDIA_INFO(us).uzonesize; | |
1f6f31a0 | 927 | struct scatterlist *sg; |
e80b0fad MD |
928 | int result; |
929 | ||
930 | /* | |
931 | * Since we only read in one block at a time, we have to create | |
932 | * a bounce buffer and move the data a piece at a time between the | |
933 | * bounce buffer and the actual transfer buffer. | |
934 | * We make this buffer big enough to hold temporary redundancy data, | |
935 | * which we use when reading the data blocks. | |
936 | */ | |
937 | ||
938 | len = min(sectors, blocksize) * (pagesize + 64); | |
939 | buffer = kmalloc(len, GFP_NOIO); | |
940 | if (buffer == NULL) { | |
6f8aa65b | 941 | printk(KERN_WARNING "alauda_read_data: Out of memory\n"); |
e80b0fad MD |
942 | return USB_STOR_TRANSPORT_ERROR; |
943 | } | |
944 | ||
945 | /* Figure out the initial LBA and page */ | |
946 | lba = address >> blockshift; | |
947 | page = (address & MEDIA_INFO(us).blockmask); | |
948 | max_lba = MEDIA_INFO(us).capacity >> (blockshift + pageshift); | |
949 | ||
950 | result = USB_STOR_TRANSPORT_GOOD; | |
1f6f31a0 JA |
951 | offset = 0; |
952 | sg = NULL; | |
e80b0fad MD |
953 | |
954 | while (sectors > 0) { | |
955 | unsigned int zone = lba / uzonesize; /* integer division */ | |
956 | unsigned int lba_offset = lba - (zone * uzonesize); | |
957 | unsigned int pages; | |
958 | u16 pba; | |
959 | alauda_ensure_map_for_zone(us, zone); | |
960 | ||
961 | /* Not overflowing capacity? */ | |
962 | if (lba >= max_lba) { | |
191648d0 JP |
963 | usb_stor_dbg(us, "Error: Requested lba %u exceeds maximum %u\n", |
964 | lba, max_lba); | |
e80b0fad MD |
965 | result = USB_STOR_TRANSPORT_ERROR; |
966 | break; | |
967 | } | |
968 | ||
969 | /* Find number of pages we can read in this block */ | |
970 | pages = min(sectors, blocksize - page); | |
971 | len = pages << pageshift; | |
972 | ||
973 | /* Find where this lba lives on disk */ | |
974 | pba = MEDIA_INFO(us).lba_to_pba[zone][lba_offset]; | |
975 | ||
976 | if (pba == UNDEF) { /* this lba was never written */ | |
191648d0 JP |
977 | usb_stor_dbg(us, "Read %d zero pages (LBA %d) page %d\n", |
978 | pages, lba, page); | |
e80b0fad MD |
979 | |
980 | /* This is not really an error. It just means | |
981 | that the block has never been written. | |
982 | Instead of returning USB_STOR_TRANSPORT_ERROR | |
983 | it is better to return all zero data. */ | |
984 | ||
985 | memset(buffer, 0, len); | |
986 | } else { | |
191648d0 JP |
987 | usb_stor_dbg(us, "Read %d pages, from PBA %d (LBA %d) page %d\n", |
988 | pages, pba, lba, page); | |
e80b0fad MD |
989 | |
990 | result = alauda_read_block(us, pba, page, pages, buffer); | |
991 | if (result != USB_STOR_TRANSPORT_GOOD) | |
992 | break; | |
993 | } | |
994 | ||
995 | /* Store the data in the transfer buffer */ | |
996 | usb_stor_access_xfer_buf(buffer, len, us->srb, | |
1f6f31a0 | 997 | &sg, &offset, TO_XFER_BUF); |
e80b0fad MD |
998 | |
999 | page = 0; | |
1000 | lba++; | |
1001 | sectors -= pages; | |
1002 | } | |
1003 | ||
1004 | kfree(buffer); | |
1005 | return result; | |
1006 | } | |
1007 | ||
1008 | /* | |
1009 | * Write data to a specific sector address | |
1010 | */ | |
1011 | static int alauda_write_data(struct us_data *us, unsigned long address, | |
1012 | unsigned int sectors) | |
1013 | { | |
1014 | unsigned char *buffer, *blockbuffer; | |
1f6f31a0 | 1015 | unsigned int page, len, offset; |
e80b0fad MD |
1016 | unsigned int blockshift = MEDIA_INFO(us).blockshift; |
1017 | unsigned int pageshift = MEDIA_INFO(us).pageshift; | |
1018 | unsigned int blocksize = MEDIA_INFO(us).blocksize; | |
1019 | unsigned int pagesize = MEDIA_INFO(us).pagesize; | |
1f6f31a0 | 1020 | struct scatterlist *sg; |
e80b0fad MD |
1021 | u16 lba, max_lba; |
1022 | int result; | |
1023 | ||
1024 | /* | |
1025 | * Since we don't write the user data directly to the device, | |
1026 | * we have to create a bounce buffer and move the data a piece | |
1027 | * at a time between the bounce buffer and the actual transfer buffer. | |
1028 | */ | |
1029 | ||
1030 | len = min(sectors, blocksize) * pagesize; | |
1031 | buffer = kmalloc(len, GFP_NOIO); | |
1032 | if (buffer == NULL) { | |
6f8aa65b | 1033 | printk(KERN_WARNING "alauda_write_data: Out of memory\n"); |
e80b0fad MD |
1034 | return USB_STOR_TRANSPORT_ERROR; |
1035 | } | |
1036 | ||
1037 | /* | |
1038 | * We also need a temporary block buffer, where we read in the old data, | |
1039 | * overwrite parts with the new data, and manipulate the redundancy data | |
1040 | */ | |
1041 | blockbuffer = kmalloc((pagesize + 64) * blocksize, GFP_NOIO); | |
1042 | if (blockbuffer == NULL) { | |
6f8aa65b | 1043 | printk(KERN_WARNING "alauda_write_data: Out of memory\n"); |
e80b0fad MD |
1044 | kfree(buffer); |
1045 | return USB_STOR_TRANSPORT_ERROR; | |
1046 | } | |
1047 | ||
1048 | /* Figure out the initial LBA and page */ | |
1049 | lba = address >> blockshift; | |
1050 | page = (address & MEDIA_INFO(us).blockmask); | |
1051 | max_lba = MEDIA_INFO(us).capacity >> (pageshift + blockshift); | |
1052 | ||
1053 | result = USB_STOR_TRANSPORT_GOOD; | |
1f6f31a0 JA |
1054 | offset = 0; |
1055 | sg = NULL; | |
e80b0fad MD |
1056 | |
1057 | while (sectors > 0) { | |
1058 | /* Write as many sectors as possible in this block */ | |
1059 | unsigned int pages = min(sectors, blocksize - page); | |
1060 | len = pages << pageshift; | |
1061 | ||
1062 | /* Not overflowing capacity? */ | |
1063 | if (lba >= max_lba) { | |
191648d0 JP |
1064 | usb_stor_dbg(us, "Requested lba %u exceeds maximum %u\n", |
1065 | lba, max_lba); | |
e80b0fad MD |
1066 | result = USB_STOR_TRANSPORT_ERROR; |
1067 | break; | |
1068 | } | |
1069 | ||
1070 | /* Get the data from the transfer buffer */ | |
1071 | usb_stor_access_xfer_buf(buffer, len, us->srb, | |
1f6f31a0 | 1072 | &sg, &offset, FROM_XFER_BUF); |
e80b0fad MD |
1073 | |
1074 | result = alauda_write_lba(us, lba, page, pages, buffer, | |
1075 | blockbuffer); | |
1076 | if (result != USB_STOR_TRANSPORT_GOOD) | |
1077 | break; | |
1078 | ||
1079 | page = 0; | |
1080 | lba++; | |
1081 | sectors -= pages; | |
1082 | } | |
1083 | ||
1084 | kfree(buffer); | |
1085 | kfree(blockbuffer); | |
1086 | return result; | |
1087 | } | |
1088 | ||
1089 | /* | |
1090 | * Our interface with the rest of the world | |
1091 | */ | |
1092 | ||
1093 | static void alauda_info_destructor(void *extra) | |
1094 | { | |
1095 | struct alauda_info *info = (struct alauda_info *) extra; | |
1096 | int port; | |
1097 | ||
1098 | if (!info) | |
1099 | return; | |
1100 | ||
1101 | for (port = 0; port < 2; port++) { | |
1102 | struct alauda_media_info *media_info = &info->port[port]; | |
1103 | ||
1104 | alauda_free_maps(media_info); | |
1105 | kfree(media_info->lba_to_pba); | |
1106 | kfree(media_info->pba_to_lba); | |
1107 | } | |
1108 | } | |
1109 | ||
1110 | /* | |
1111 | * Initialize alauda_info struct and find the data-write endpoint | |
1112 | */ | |
a74bba3b | 1113 | static int init_alauda(struct us_data *us) |
e80b0fad MD |
1114 | { |
1115 | struct alauda_info *info; | |
1116 | struct usb_host_interface *altsetting = us->pusb_intf->cur_altsetting; | |
1117 | nand_init_ecc(); | |
1118 | ||
1119 | us->extra = kzalloc(sizeof(struct alauda_info), GFP_NOIO); | |
191648d0 | 1120 | if (!us->extra) |
e80b0fad | 1121 | return USB_STOR_TRANSPORT_ERROR; |
191648d0 | 1122 | |
e80b0fad MD |
1123 | info = (struct alauda_info *) us->extra; |
1124 | us->extra_destructor = alauda_info_destructor; | |
1125 | ||
1126 | info->wr_ep = usb_sndbulkpipe(us->pusb_dev, | |
1127 | altsetting->endpoint[0].desc.bEndpointAddress | |
1128 | & USB_ENDPOINT_NUMBER_MASK); | |
1129 | ||
1130 | return USB_STOR_TRANSPORT_GOOD; | |
1131 | } | |
1132 | ||
a74bba3b | 1133 | static int alauda_transport(struct scsi_cmnd *srb, struct us_data *us) |
e80b0fad MD |
1134 | { |
1135 | int rc; | |
1136 | struct alauda_info *info = (struct alauda_info *) us->extra; | |
1137 | unsigned char *ptr = us->iobuf; | |
1138 | static unsigned char inquiry_response[36] = { | |
1139 | 0x00, 0x80, 0x00, 0x01, 0x1F, 0x00, 0x00, 0x00 | |
1140 | }; | |
1141 | ||
1142 | if (srb->cmnd[0] == INQUIRY) { | |
191648d0 | 1143 | usb_stor_dbg(us, "INQUIRY - Returning bogus response\n"); |
e80b0fad MD |
1144 | memcpy(ptr, inquiry_response, sizeof(inquiry_response)); |
1145 | fill_inquiry_response(us, ptr, 36); | |
1146 | return USB_STOR_TRANSPORT_GOOD; | |
1147 | } | |
1148 | ||
1149 | if (srb->cmnd[0] == TEST_UNIT_READY) { | |
191648d0 | 1150 | usb_stor_dbg(us, "TEST_UNIT_READY\n"); |
e80b0fad MD |
1151 | return alauda_check_media(us); |
1152 | } | |
1153 | ||
1154 | if (srb->cmnd[0] == READ_CAPACITY) { | |
1155 | unsigned int num_zones; | |
1156 | unsigned long capacity; | |
1157 | ||
1158 | rc = alauda_check_media(us); | |
1159 | if (rc != USB_STOR_TRANSPORT_GOOD) | |
1160 | return rc; | |
1161 | ||
1162 | num_zones = MEDIA_INFO(us).capacity >> (MEDIA_INFO(us).zoneshift | |
1163 | + MEDIA_INFO(us).blockshift + MEDIA_INFO(us).pageshift); | |
1164 | ||
1165 | capacity = num_zones * MEDIA_INFO(us).uzonesize | |
1166 | * MEDIA_INFO(us).blocksize; | |
1167 | ||
1168 | /* Report capacity and page size */ | |
1169 | ((__be32 *) ptr)[0] = cpu_to_be32(capacity - 1); | |
1170 | ((__be32 *) ptr)[1] = cpu_to_be32(512); | |
1171 | ||
1172 | usb_stor_set_xfer_buf(ptr, 8, srb); | |
1173 | return USB_STOR_TRANSPORT_GOOD; | |
1174 | } | |
1175 | ||
1176 | if (srb->cmnd[0] == READ_10) { | |
1177 | unsigned int page, pages; | |
1178 | ||
1179 | rc = alauda_check_media(us); | |
1180 | if (rc != USB_STOR_TRANSPORT_GOOD) | |
1181 | return rc; | |
1182 | ||
1183 | page = short_pack(srb->cmnd[3], srb->cmnd[2]); | |
1184 | page <<= 16; | |
1185 | page |= short_pack(srb->cmnd[5], srb->cmnd[4]); | |
1186 | pages = short_pack(srb->cmnd[8], srb->cmnd[7]); | |
1187 | ||
191648d0 | 1188 | usb_stor_dbg(us, "READ_10: page %d pagect %d\n", page, pages); |
e80b0fad MD |
1189 | |
1190 | return alauda_read_data(us, page, pages); | |
1191 | } | |
1192 | ||
1193 | if (srb->cmnd[0] == WRITE_10) { | |
1194 | unsigned int page, pages; | |
1195 | ||
1196 | rc = alauda_check_media(us); | |
1197 | if (rc != USB_STOR_TRANSPORT_GOOD) | |
1198 | return rc; | |
1199 | ||
1200 | page = short_pack(srb->cmnd[3], srb->cmnd[2]); | |
1201 | page <<= 16; | |
1202 | page |= short_pack(srb->cmnd[5], srb->cmnd[4]); | |
1203 | pages = short_pack(srb->cmnd[8], srb->cmnd[7]); | |
1204 | ||
191648d0 | 1205 | usb_stor_dbg(us, "WRITE_10: page %d pagect %d\n", page, pages); |
e80b0fad MD |
1206 | |
1207 | return alauda_write_data(us, page, pages); | |
1208 | } | |
1209 | ||
1210 | if (srb->cmnd[0] == REQUEST_SENSE) { | |
191648d0 | 1211 | usb_stor_dbg(us, "REQUEST_SENSE\n"); |
e80b0fad MD |
1212 | |
1213 | memset(ptr, 0, 18); | |
1214 | ptr[0] = 0xF0; | |
1215 | ptr[2] = info->sense_key; | |
1216 | ptr[7] = 11; | |
1217 | ptr[12] = info->sense_asc; | |
1218 | ptr[13] = info->sense_ascq; | |
1219 | usb_stor_set_xfer_buf(ptr, 18, srb); | |
1220 | ||
1221 | return USB_STOR_TRANSPORT_GOOD; | |
1222 | } | |
1223 | ||
1224 | if (srb->cmnd[0] == ALLOW_MEDIUM_REMOVAL) { | |
1225 | /* sure. whatever. not like we can stop the user from popping | |
1226 | the media out of the device (no locking doors, etc) */ | |
1227 | return USB_STOR_TRANSPORT_GOOD; | |
1228 | } | |
1229 | ||
191648d0 JP |
1230 | usb_stor_dbg(us, "Gah! Unknown command: %d (0x%x)\n", |
1231 | srb->cmnd[0], srb->cmnd[0]); | |
e80b0fad MD |
1232 | info->sense_key = 0x05; |
1233 | info->sense_asc = 0x20; | |
1234 | info->sense_ascq = 0x00; | |
1235 | return USB_STOR_TRANSPORT_FAILED; | |
1236 | } | |
1237 | ||
aa519be3 AM |
1238 | static struct scsi_host_template alauda_host_template; |
1239 | ||
a74bba3b AS |
1240 | static int alauda_probe(struct usb_interface *intf, |
1241 | const struct usb_device_id *id) | |
1242 | { | |
1243 | struct us_data *us; | |
1244 | int result; | |
1245 | ||
1246 | result = usb_stor_probe1(&us, intf, id, | |
aa519be3 AM |
1247 | (id - alauda_usb_ids) + alauda_unusual_dev_list, |
1248 | &alauda_host_template); | |
a74bba3b AS |
1249 | if (result) |
1250 | return result; | |
1251 | ||
1252 | us->transport_name = "Alauda Control/Bulk"; | |
1253 | us->transport = alauda_transport; | |
1254 | us->transport_reset = usb_stor_Bulk_reset; | |
1255 | us->max_lun = 1; | |
1256 | ||
1257 | result = usb_stor_probe2(us); | |
1258 | return result; | |
1259 | } | |
1260 | ||
1261 | static struct usb_driver alauda_driver = { | |
aa519be3 | 1262 | .name = DRV_NAME, |
a74bba3b AS |
1263 | .probe = alauda_probe, |
1264 | .disconnect = usb_stor_disconnect, | |
1265 | .suspend = usb_stor_suspend, | |
1266 | .resume = usb_stor_resume, | |
1267 | .reset_resume = usb_stor_reset_resume, | |
1268 | .pre_reset = usb_stor_pre_reset, | |
1269 | .post_reset = usb_stor_post_reset, | |
1270 | .id_table = alauda_usb_ids, | |
1271 | .soft_unbind = 1, | |
e73b2db6 | 1272 | .no_dynamic_id = 1, |
a74bba3b AS |
1273 | }; |
1274 | ||
aa519be3 | 1275 | module_usb_stor_driver(alauda_driver, alauda_host_template, DRV_NAME); |