?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Realtek cr: Add autosuspend function.
[zen-stable.git] / drivers / staging / keucr / ms.c
blob087ad73ff70f18dee8564de500ef145a50a29f9d
1 #include <linux/slab.h>
2 #include <asm/byteorder.h>
3
4 #include "usb.h"
5 #include "scsiglue.h"
6 #include "transport.h"
7 #include "ms.h"
8
9 /*
10 * MS_ReaderCopyBlock()
11 */
12 int MS_ReaderCopyBlock(struct us_data *us, WORD oldphy, WORD newphy,
13 WORD PhyBlockAddr, BYTE PageNum, PBYTE buf, WORD len)
14 {
15 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
16 int result;
17
18 /* printk(KERN_INFO "MS_ReaderCopyBlock --- PhyBlockAddr = %x,
19 PageNum = %x\n", PhyBlockAddr, PageNum); */
20 result = ENE_LoadBinCode(us, MS_RW_PATTERN);
21 if (result != USB_STOR_XFER_GOOD)
22 return USB_STOR_TRANSPORT_ERROR;
23
24 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
25 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
26 bcb->DataTransferLength = 0x200*len;
27 bcb->Flags = 0x00;
28 bcb->CDB[0] = 0xF0;
29 bcb->CDB[1] = 0x08;
30 bcb->CDB[4] = (BYTE)(oldphy);
31 bcb->CDB[3] = (BYTE)(oldphy>>8);
32 bcb->CDB[2] = 0; /* (BYTE)(oldphy>>16) */
33 bcb->CDB[7] = (BYTE)(newphy);
34 bcb->CDB[6] = (BYTE)(newphy>>8);
35 bcb->CDB[5] = 0; /* (BYTE)(newphy>>16) */
36 bcb->CDB[9] = (BYTE)(PhyBlockAddr);
37 bcb->CDB[8] = (BYTE)(PhyBlockAddr>>8);
38 bcb->CDB[10] = PageNum;
39
40 result = ENE_SendScsiCmd(us, FDIR_WRITE, buf, 0);
41 if (result != USB_STOR_XFER_GOOD)
42 return USB_STOR_TRANSPORT_ERROR;
43
44 return USB_STOR_TRANSPORT_GOOD;
45 }
46
47 /*
48 * MS_ReaderReadPage()
49 */
50 int MS_ReaderReadPage(struct us_data *us, DWORD PhyBlockAddr,
51 BYTE PageNum, PDWORD PageBuf, MS_LibTypeExtdat *ExtraDat)
52 {
53 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
54 int result;
55 BYTE ExtBuf[4];
56 DWORD bn = PhyBlockAddr * 0x20 + PageNum;
57
58 /* printk(KERN_INFO "MS --- MS_ReaderReadPage,
59 PhyBlockAddr = %x, PageNum = %x\n", PhyBlockAddr, PageNum); */
60
61 result = ENE_LoadBinCode(us, MS_RW_PATTERN);
62 if (result != USB_STOR_XFER_GOOD)
63 return USB_STOR_TRANSPORT_ERROR;
64
65 /* Read Page Data */
66 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
67 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
68 bcb->DataTransferLength = 0x200;
69 bcb->Flags = 0x80;
70 bcb->CDB[0] = 0xF1;
71 bcb->CDB[1] = 0x02;
72 bcb->CDB[5] = (BYTE)(bn);
73 bcb->CDB[4] = (BYTE)(bn>>8);
74 bcb->CDB[3] = (BYTE)(bn>>16);
75 bcb->CDB[2] = (BYTE)(bn>>24);
76
77 result = ENE_SendScsiCmd(us, FDIR_READ, PageBuf, 0);
78 if (result != USB_STOR_XFER_GOOD)
79 return USB_STOR_TRANSPORT_ERROR;
80
81 /* Read Extra Data */
82 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
83 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
84 bcb->DataTransferLength = 0x4;
85 bcb->Flags = 0x80;
86 bcb->CDB[0] = 0xF1;
87 bcb->CDB[1] = 0x03;
88 bcb->CDB[5] = (BYTE)(PageNum);
89 bcb->CDB[4] = (BYTE)(PhyBlockAddr);
90 bcb->CDB[3] = (BYTE)(PhyBlockAddr>>8);
91 bcb->CDB[2] = (BYTE)(PhyBlockAddr>>16);
92 bcb->CDB[6] = 0x01;
93
94 result = ENE_SendScsiCmd(us, FDIR_READ, &ExtBuf, 0);
95 if (result != USB_STOR_XFER_GOOD)
96 return USB_STOR_TRANSPORT_ERROR;
97
98 ExtraDat->reserved = 0;
99 ExtraDat->intr = 0x80; /* Not yet,fireware support */
100 ExtraDat->status0 = 0x10; /* Not yet,fireware support */
101 ExtraDat->status1 = 0x00; /* Not yet,fireware support */
102 ExtraDat->ovrflg = ExtBuf[0];
103 ExtraDat->mngflg = ExtBuf[1];
104 ExtraDat->logadr = MemStickLogAddr(ExtBuf[2], ExtBuf[3]);
105
106 return USB_STOR_TRANSPORT_GOOD;
107 }
108
109 /*
110 * MS_ReaderEraseBlock()
111 */
112 int MS_ReaderEraseBlock(struct us_data *us, DWORD PhyBlockAddr)
113 {
114 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
115 int result;
116 DWORD bn = PhyBlockAddr;
117
118 /* printk(KERN_INFO "MS --- MS_ReaderEraseBlock,
119 PhyBlockAddr = %x\n", PhyBlockAddr); */
120 result = ENE_LoadBinCode(us, MS_RW_PATTERN);
121 if (result != USB_STOR_XFER_GOOD)
122 return USB_STOR_TRANSPORT_ERROR;
123
124 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
125 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
126 bcb->DataTransferLength = 0x200;
127 bcb->Flags = 0x80;
128 bcb->CDB[0] = 0xF2;
129 bcb->CDB[1] = 0x06;
130 bcb->CDB[4] = (BYTE)(bn);
131 bcb->CDB[3] = (BYTE)(bn>>8);
132 bcb->CDB[2] = (BYTE)(bn>>16);
133
134 result = ENE_SendScsiCmd(us, FDIR_READ, NULL, 0);
135 if (result != USB_STOR_XFER_GOOD)
136 return USB_STOR_TRANSPORT_ERROR;
137
138 return USB_STOR_TRANSPORT_GOOD;
139 }
140
141 /*
142 * MS_CardInit()
143 */
144 int MS_CardInit(struct us_data *us)
145 {
146 DWORD result = 0;
147 WORD TmpBlock;
148 PBYTE PageBuffer0 = NULL, PageBuffer1 = NULL;
149 MS_LibTypeExtdat extdat;
150 WORD btBlk1st, btBlk2nd;
151 DWORD btBlk1stErred;
152
153 printk(KERN_INFO "MS_CardInit start\n");
154
155 MS_LibFreeAllocatedArea(us);
156
157 PageBuffer0 = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL);
158 PageBuffer1 = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL);
159 if ((PageBuffer0 == NULL) || (PageBuffer1 == NULL)) {
160 result = MS_NO_MEMORY_ERROR;
161 goto exit;
162 }
163
164 btBlk1st = btBlk2nd = MS_LB_NOT_USED;
165 btBlk1stErred = 0;
166
167 for (TmpBlock = 0; TmpBlock < MS_MAX_INITIAL_ERROR_BLOCKS+2;
168 TmpBlock++) {
169 switch (MS_ReaderReadPage(us, TmpBlock, 0,
170 (DWORD *)PageBuffer0, &extdat)) {
171 case MS_STATUS_SUCCESS:
172 break;
173 case MS_STATUS_INT_ERROR:
174 break;
175 case MS_STATUS_ERROR:
176 default:
177 continue;
178 }
179
180 if ((extdat.ovrflg & MS_REG_OVR_BKST) == MS_REG_OVR_BKST_NG)
181 continue;
182
183 if (((extdat.mngflg & MS_REG_MNG_SYSFLG) == MS_REG_MNG_SYSFLG_USER) ||
184 (be16_to_cpu(((MemStickBootBlockPage0 *)PageBuffer0)->header.wBlockID) != MS_BOOT_BLOCK_ID) ||
185 (be16_to_cpu(((MemStickBootBlockPage0 *)PageBuffer0)->header.wFormatVersion) != MS_BOOT_BLOCK_FORMAT_VERSION) ||
186 (((MemStickBootBlockPage0 *)PageBuffer0)->header.bNumberOfDataEntry != MS_BOOT_BLOCK_DATA_ENTRIES))
187 continue;
188
189 if (btBlk1st != MS_LB_NOT_USED) {
190 btBlk2nd = TmpBlock;
191 break;
192 }
193
194 btBlk1st = TmpBlock;
195 memcpy(PageBuffer1, PageBuffer0, MS_BYTES_PER_PAGE);
196 if (extdat.status1 &
197 (MS_REG_ST1_DTER | MS_REG_ST1_EXER | MS_REG_ST1_FGER))
198 btBlk1stErred = 1;
199 }
200
201 if (btBlk1st == MS_LB_NOT_USED) {
202 result = MS_STATUS_ERROR;
203 goto exit;
204 }
205
206 /* write protect */
207 if ((extdat.status0 & MS_REG_ST0_WP) == MS_REG_ST0_WP_ON)
208 MS_LibCtrlSet(us, MS_LIB_CTRL_WRPROTECT);
209
210 result = MS_STATUS_ERROR;
211 /* 1st Boot Block */
212 if (btBlk1stErred == 0)
213 result = MS_LibProcessBootBlock(us, btBlk1st, PageBuffer1);
214 /* 1st */
215 /* 2nd Boot Block */
216 if (result && (btBlk2nd != MS_LB_NOT_USED))
217 result = MS_LibProcessBootBlock(us, btBlk2nd, PageBuffer0);
218
219 if (result) {
220 result = MS_STATUS_ERROR;
221 goto exit;
222 }
223
224 for (TmpBlock = 0; TmpBlock < btBlk1st; TmpBlock++)
225 us->MS_Lib.Phy2LogMap[TmpBlock] = MS_LB_INITIAL_ERROR;
226
227 us->MS_Lib.Phy2LogMap[btBlk1st] = MS_LB_BOOT_BLOCK;
228
229 if (btBlk2nd != MS_LB_NOT_USED) {
230 for (TmpBlock = btBlk1st + 1; TmpBlock < btBlk2nd; TmpBlock++)
231 us->MS_Lib.Phy2LogMap[TmpBlock] = MS_LB_INITIAL_ERROR;
232 us->MS_Lib.Phy2LogMap[btBlk2nd] = MS_LB_BOOT_BLOCK;
233 }
234
235 result = MS_LibScanLogicalBlockNumber(us, btBlk1st);
236 if (result)
237 goto exit;
238
239 for (TmpBlock = MS_PHYSICAL_BLOCKS_PER_SEGMENT;
240 TmpBlock < us->MS_Lib.NumberOfPhyBlock;
241 TmpBlock += MS_PHYSICAL_BLOCKS_PER_SEGMENT) {
242 if (MS_CountFreeBlock(us, TmpBlock) == 0) {
243 MS_LibCtrlSet(us, MS_LIB_CTRL_WRPROTECT);
244 break;
245 }
246 }
247
248 /* write */
249 if (MS_LibAllocWriteBuf(us)) {
250 result = MS_NO_MEMORY_ERROR;
251 goto exit;
252 }
253
254 result = MS_STATUS_SUCCESS;
255
256 exit:
257 kfree(PageBuffer1);
258 kfree(PageBuffer0);
259
260 printk(KERN_INFO "MS_CardInit end\n");
261 return result;
262 }
263
264 /*
265 * MS_LibCheckDisableBlock()
266 */
267 int MS_LibCheckDisableBlock(struct us_data *us, WORD PhyBlock)
268 {
269 PWORD PageBuf = NULL;
270 DWORD result = MS_STATUS_SUCCESS;
271 DWORD blk, index = 0;
272 MS_LibTypeExtdat extdat;
273
274 PageBuf = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL);
275 if (PageBuf == NULL) {
276 result = MS_NO_MEMORY_ERROR;
277 goto exit;
278 }
279
280 MS_ReaderReadPage(us, PhyBlock, 1, (DWORD *)PageBuf, &extdat);
281 do {
282 blk = be16_to_cpu(PageBuf[index]);
283 if (blk == MS_LB_NOT_USED)
284 break;
285 if (blk == us->MS_Lib.Log2PhyMap[0]) {
286 result = MS_ERROR_FLASH_READ;
287 break;
288 }
289 index++;
290 } while (1);
291
292 exit:
293 kfree(PageBuf);
294 return result;
295 }
296
297 /*
298 * MS_LibFreeAllocatedArea()
299 */
300 void MS_LibFreeAllocatedArea(struct us_data *us)
301 {
302 MS_LibFreeWriteBuf(us);
303 MS_LibFreeLogicalMap(us);
304
305 us->MS_Lib.flags = 0;
306 us->MS_Lib.BytesPerSector = 0;
307 us->MS_Lib.SectorsPerCylinder = 0;
308
309 us->MS_Lib.cardType = 0;
310 us->MS_Lib.blockSize = 0;
311 us->MS_Lib.PagesPerBlock = 0;
312
313 us->MS_Lib.NumberOfPhyBlock = 0;
314 us->MS_Lib.NumberOfLogBlock = 0;
315 }
316
317 /*
318 * MS_LibFreeWriteBuf()
319 */
320 void MS_LibFreeWriteBuf(struct us_data *us)
321 {
322 us->MS_Lib.wrtblk = (WORD)-1; /* set to -1 */
323
324 /* memset((fdoExt)->MS_Lib.pagemap, 0,
325 sizeof((fdoExt)->MS_Lib.pagemap)) */
326 MS_LibClearPageMap(us);
327
328 if (us->MS_Lib.blkpag) {
329 kfree((BYTE *)(us->MS_Lib.blkpag)); /* Arnold test ... */
330 us->MS_Lib.blkpag = NULL;
331 }
332
333 if (us->MS_Lib.blkext) {
334 kfree((BYTE *)(us->MS_Lib.blkext)); /* Arnold test ... */
335 us->MS_Lib.blkext = NULL;
336 }
337 }
338
339 /*
340 * MS_LibFreeLogicalMap()
341 */
342 int MS_LibFreeLogicalMap(struct us_data *us)
343 {
344 kfree(us->MS_Lib.Phy2LogMap);
345 us->MS_Lib.Phy2LogMap = NULL;
346
347 kfree(us->MS_Lib.Log2PhyMap);
348 us->MS_Lib.Log2PhyMap = NULL;
349
350 return 0;
351 }
352
353 /*
354 * MS_LibProcessBootBlock()
355 */
356 int MS_LibProcessBootBlock(struct us_data *us, WORD PhyBlock, BYTE *PageData)
357 {
358 MemStickBootBlockSysEnt *SysEntry;
359 MemStickBootBlockSysInf *SysInfo;
360 DWORD i, result;
361 BYTE PageNumber;
362 BYTE *PageBuffer;
363 MS_LibTypeExtdat ExtraData;
364
365
366 PageBuffer = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL);
367 if (PageBuffer == NULL)
368 return (DWORD)-1;
369
370 result = (DWORD)-1;
371
372 SysInfo = &(((MemStickBootBlockPage0 *)PageData)->sysinf);
373
374 if ((SysInfo->bMsClass != MS_SYSINF_MSCLASS_TYPE_1) ||
375 (be16_to_cpu(SysInfo->wPageSize) != MS_SYSINF_PAGE_SIZE) ||
376 ((SysInfo->bSecuritySupport & MS_SYSINF_SECURITY) == MS_SYSINF_SECURITY_SUPPORT) ||
377 (SysInfo->bReserved1 != MS_SYSINF_RESERVED1) ||
378 (SysInfo->bReserved2 != MS_SYSINF_RESERVED2) ||
379 (SysInfo->bFormatType != MS_SYSINF_FORMAT_FAT) ||
380 (SysInfo->bUsage != MS_SYSINF_USAGE_GENERAL))
381 goto exit;
382
383 switch (us->MS_Lib.cardType = SysInfo->bCardType) {
384 case MS_SYSINF_CARDTYPE_RDONLY:
385 MS_LibCtrlSet(us, MS_LIB_CTRL_RDONLY);
386 break;
387 case MS_SYSINF_CARDTYPE_RDWR:
388 MS_LibCtrlReset(us, MS_LIB_CTRL_RDONLY);
389 break;
390 case MS_SYSINF_CARDTYPE_HYBRID:
391 default:
392 goto exit;
393 }
394
395 us->MS_Lib.blockSize = be16_to_cpu(SysInfo->wBlockSize);
396 us->MS_Lib.NumberOfPhyBlock = be16_to_cpu(SysInfo->wBlockNumber);
397 us->MS_Lib.NumberOfLogBlock = be16_to_cpu(SysInfo->wTotalBlockNumber)
398 -2;
399 us->MS_Lib.PagesPerBlock = us->MS_Lib.blockSize * SIZE_OF_KIRO /
400 MS_BYTES_PER_PAGE;
401 us->MS_Lib.NumberOfSegment = us->MS_Lib.NumberOfPhyBlock /
402 MS_PHYSICAL_BLOCKS_PER_SEGMENT;
403 us->MS_Model = be16_to_cpu(SysInfo->wMemorySize);
404
405 /*Allocate to all number of logicalblock and physicalblock */
406 if (MS_LibAllocLogicalMap(us))
407 goto exit;
408
409 /* Mark the book block */
410 MS_LibSetBootBlockMark(us, PhyBlock);
411
412 SysEntry = &(((MemStickBootBlockPage0 *)PageData)->sysent);
413
414 for (i = 0; i < MS_NUMBER_OF_SYSTEM_ENTRY; i++) {
415 DWORD EntryOffset, EntrySize;
416
417 EntryOffset = be32_to_cpu(SysEntry->entry[i].dwStart);
418
419 if (EntryOffset == 0xffffff)
420 continue;
421 EntrySize = be32_to_cpu(SysEntry->entry[i].dwSize);
422
423 if (EntrySize == 0)
424 continue;
425
426 if (EntryOffset + MS_BYTES_PER_PAGE + EntrySize >
427 us->MS_Lib.blockSize * (DWORD)SIZE_OF_KIRO)
428 continue;
429
430 if (i == 0) {
431 BYTE PrevPageNumber = 0;
432 WORD phyblk;
433
434 if (SysEntry->entry[i].bType !=
435 MS_SYSENT_TYPE_INVALID_BLOCK)
436 goto exit;
437
438 while (EntrySize > 0) {
439
440 PageNumber = (BYTE)(EntryOffset /
441 MS_BYTES_PER_PAGE + 1);
442 if (PageNumber != PrevPageNumber) {
443 switch (MS_ReaderReadPage(us, PhyBlock,
444 PageNumber, (DWORD *)PageBuffer,
445 &ExtraData)) {
446 case MS_STATUS_SUCCESS:
447 break;
448 case MS_STATUS_WRITE_PROTECT:
449 case MS_ERROR_FLASH_READ:
450 case MS_STATUS_ERROR:
451 default:
452 goto exit;
453 }
454
455 PrevPageNumber = PageNumber;
456 }
457
458 phyblk = be16_to_cpu(*(WORD *)(PageBuffer +
459 (EntryOffset % MS_BYTES_PER_PAGE)));
460 if (phyblk < 0x0fff)
461 MS_LibSetInitialErrorBlock(us, phyblk);
462
463 EntryOffset += 2;
464 EntrySize -= 2;
465 }
466 } else if (i == 1) { /* CIS/IDI */
467 MemStickBootBlockIDI *idi;
468
469 if (SysEntry->entry[i].bType != MS_SYSENT_TYPE_CIS_IDI)
470 goto exit;
471
472 switch (MS_ReaderReadPage(us, PhyBlock,
473 (BYTE)(EntryOffset / MS_BYTES_PER_PAGE + 1),
474 (DWORD *)PageBuffer, &ExtraData)) {
475 case MS_STATUS_SUCCESS:
476 break;
477 case MS_STATUS_WRITE_PROTECT:
478 case MS_ERROR_FLASH_READ:
479 case MS_STATUS_ERROR:
480 default:
481 goto exit;
482 }
483
484 idi = &((MemStickBootBlockCIS_IDI *)(PageBuffer +
485 (EntryOffset % MS_BYTES_PER_PAGE)))->idi.idi;
486 if (le16_to_cpu(idi->wIDIgeneralConfiguration) !=
487 MS_IDI_GENERAL_CONF)
488 goto exit;
489
490 us->MS_Lib.BytesPerSector =
491 le16_to_cpu(idi->wIDIbytesPerSector);
492 if (us->MS_Lib.BytesPerSector != MS_BYTES_PER_PAGE)
493 goto exit;
494 }
495 } /* End for .. */
496
497 result = 0;
498
499 exit:
500 if (result)
501 MS_LibFreeLogicalMap(us);
502
503 kfree(PageBuffer);
504
505 result = 0;
506 return result;
507 }
508
509 /*
510 * MS_LibAllocLogicalMap()
511 */
512 int MS_LibAllocLogicalMap(struct us_data *us)
513 {
514 DWORD i;
515
516
517 us->MS_Lib.Phy2LogMap = kmalloc(us->MS_Lib.NumberOfPhyBlock *
518 sizeof(WORD), GFP_KERNEL);
519 us->MS_Lib.Log2PhyMap = kmalloc(us->MS_Lib.NumberOfLogBlock *
520 sizeof(WORD), GFP_KERNEL);
521
522 if ((us->MS_Lib.Phy2LogMap == NULL) ||
523 (us->MS_Lib.Log2PhyMap == NULL)) {
524 MS_LibFreeLogicalMap(us);
525 return (DWORD)-1;
526 }
527
528 for (i = 0; i < us->MS_Lib.NumberOfPhyBlock; i++)
529 us->MS_Lib.Phy2LogMap[i] = MS_LB_NOT_USED;
530
531 for (i = 0; i < us->MS_Lib.NumberOfLogBlock; i++)
532 us->MS_Lib.Log2PhyMap[i] = MS_LB_NOT_USED;
533
534 return 0;
535 }
536
537 /*
538 * MS_LibSetBootBlockMark()
539 */
540 int MS_LibSetBootBlockMark(struct us_data *us, WORD phyblk)
541 {
542 return MS_LibSetLogicalBlockMark(us, phyblk, MS_LB_BOOT_BLOCK);
543 }
544
545 /*
546 * MS_LibSetLogicalBlockMark()
547 */
548 int MS_LibSetLogicalBlockMark(struct us_data *us, WORD phyblk, WORD mark)
549 {
550 if (phyblk >= us->MS_Lib.NumberOfPhyBlock)
551 return (DWORD)-1;
552
553 us->MS_Lib.Phy2LogMap[phyblk] = mark;
554
555 return 0;
556 }
557
558 /*
559 * MS_LibSetInitialErrorBlock()
560 */
561 int MS_LibSetInitialErrorBlock(struct us_data *us, WORD phyblk)
562 {
563 return MS_LibSetLogicalBlockMark(us, phyblk, MS_LB_INITIAL_ERROR);
564 }
565
566 /*
567 * MS_LibScanLogicalBlockNumber()
568 */
569 int MS_LibScanLogicalBlockNumber(struct us_data *us, WORD btBlk1st)
570 {
571 WORD PhyBlock, newblk, i;
572 WORD LogStart, LogEnde;
573 MS_LibTypeExtdat extdat;
574 BYTE buf[0x200];
575 DWORD count = 0, index = 0;
576
577 for (PhyBlock = 0; PhyBlock < us->MS_Lib.NumberOfPhyBlock;) {
578 MS_LibPhy2LogRange(PhyBlock, &LogStart, &LogEnde);
579
580 for (i = 0; i < MS_PHYSICAL_BLOCKS_PER_SEGMENT;
581 i++, PhyBlock++) {
582 switch (MS_LibConv2Logical(us, PhyBlock)) {
583 case MS_STATUS_ERROR:
584 continue;
585 default:
586 break;
587 }
588
589 if (count == PhyBlock) {
590 MS_LibReadExtraBlock(us, PhyBlock,
591 0, 0x80, &buf);
592 count += 0x80;
593 }
594 index = (PhyBlock % 0x80) * 4;
595
596 extdat.ovrflg = buf[index];
597 extdat.mngflg = buf[index+1];
598 extdat.logadr = MemStickLogAddr(buf[index+2],
599 buf[index+3]);
600
601 if ((extdat.ovrflg & MS_REG_OVR_BKST) !=
602 MS_REG_OVR_BKST_OK) {
603 MS_LibSetAcquiredErrorBlock(us, PhyBlock);
604 continue;
605 }
606
607 if ((extdat.mngflg & MS_REG_MNG_ATFLG) ==
608 MS_REG_MNG_ATFLG_ATTBL) {
609 MS_LibErasePhyBlock(us, PhyBlock);
610 continue;
611 }
612
613 if (extdat.logadr != MS_LB_NOT_USED) {
614 if ((extdat.logadr < LogStart) ||
615 (LogEnde <= extdat.logadr)) {
616 MS_LibErasePhyBlock(us, PhyBlock);
617 continue;
618 }
619
620 newblk = MS_LibConv2Physical(us, extdat.logadr);
621
622 if (newblk != MS_LB_NOT_USED) {
623 if (extdat.logadr == 0) {
624 MS_LibSetLogicalPair(us,
625 extdat.logadr,
626 PhyBlock);
627 if (MS_LibCheckDisableBlock(us,
628 btBlk1st)) {
629 MS_LibSetLogicalPair(us,
630 extdat.logadr, newblk);
631 continue;
632 }
633 }
634
635 MS_LibReadExtra(us, newblk, 0, &extdat);
636 if ((extdat.ovrflg & MS_REG_OVR_UDST) ==
637 MS_REG_OVR_UDST_UPDATING) {
638 MS_LibErasePhyBlock(us,
639 PhyBlock);
640 continue;
641 } else {
642 MS_LibErasePhyBlock(us, newblk);
643 }
644 }
645
646 MS_LibSetLogicalPair(us, extdat.logadr,
647 PhyBlock);
648 }
649 }
650 } /* End for ... */
651
652 return MS_STATUS_SUCCESS;
653 }
654
655 /*
656 * MS_LibAllocWriteBuf()
657 */
658 int MS_LibAllocWriteBuf(struct us_data *us)
659 {
660 us->MS_Lib.wrtblk = (WORD)-1;
661
662 us->MS_Lib.blkpag = kmalloc(us->MS_Lib.PagesPerBlock *
663 us->MS_Lib.BytesPerSector, GFP_KERNEL);
664 us->MS_Lib.blkext = kmalloc(us->MS_Lib.PagesPerBlock *
665 sizeof(MS_LibTypeExtdat), GFP_KERNEL);
666
667 if ((us->MS_Lib.blkpag == NULL) || (us->MS_Lib.blkext == NULL)) {
668 MS_LibFreeWriteBuf(us);
669 return (DWORD)-1;
670 }
671
672 MS_LibClearWriteBuf(us);
673
674 return 0;
675 }
676
677 /*
678 * MS_LibClearWriteBuf()
679 */
680 void MS_LibClearWriteBuf(struct us_data *us)
681 {
682 int i;
683
684 us->MS_Lib.wrtblk = (WORD)-1;
685 MS_LibClearPageMap(us);
686
687 if (us->MS_Lib.blkpag)
688 memset(us->MS_Lib.blkpag, 0xff,
689 us->MS_Lib.PagesPerBlock * us->MS_Lib.BytesPerSector);
690
691 if (us->MS_Lib.blkext) {
692 for (i = 0; i < us->MS_Lib.PagesPerBlock; i++) {
693 us->MS_Lib.blkext[i].status1 = MS_REG_ST1_DEFAULT;
694 us->MS_Lib.blkext[i].ovrflg = MS_REG_OVR_DEFAULT;
695 us->MS_Lib.blkext[i].mngflg = MS_REG_MNG_DEFAULT;
696 us->MS_Lib.blkext[i].logadr = MS_LB_NOT_USED;
697 }
698 }
699 }
700
701 /*
702 * MS_LibPhy2LogRange()
703 */
704 void MS_LibPhy2LogRange(WORD PhyBlock, WORD *LogStart, WORD *LogEnde)
705 {
706 PhyBlock /= MS_PHYSICAL_BLOCKS_PER_SEGMENT;
707
708 if (PhyBlock) {
709 *LogStart = MS_LOGICAL_BLOCKS_IN_1ST_SEGMENT +
710 (PhyBlock - 1) * MS_LOGICAL_BLOCKS_PER_SEGMENT;/*496*/
711 *LogEnde = *LogStart + MS_LOGICAL_BLOCKS_PER_SEGMENT;/*496*/
712 } else {
713 *LogStart = 0;
714 *LogEnde = MS_LOGICAL_BLOCKS_IN_1ST_SEGMENT;/*494*/
715 }
716 }
717
718 /*
719 * MS_LibReadExtraBlock()
720 */
721 int MS_LibReadExtraBlock(struct us_data *us, DWORD PhyBlock,
722 BYTE PageNum, BYTE blen, void *buf)
723 {
724 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
725 int result;
726
727 /* printk("MS_LibReadExtraBlock --- PhyBlock = %x,
728 PageNum = %x, blen = %x\n", PhyBlock, PageNum, blen); */
729
730 /* Read Extra Data */
731 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
732 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
733 bcb->DataTransferLength = 0x4 * blen;
734 bcb->Flags = 0x80;
735 bcb->CDB[0] = 0xF1;
736 bcb->CDB[1] = 0x03;
737 bcb->CDB[5] = (BYTE)(PageNum);
738 bcb->CDB[4] = (BYTE)(PhyBlock);
739 bcb->CDB[3] = (BYTE)(PhyBlock>>8);
740 bcb->CDB[2] = (BYTE)(PhyBlock>>16);
741 bcb->CDB[6] = blen;
742
743 result = ENE_SendScsiCmd(us, FDIR_READ, buf, 0);
744 if (result != USB_STOR_XFER_GOOD)
745 return USB_STOR_TRANSPORT_ERROR;
746
747 return USB_STOR_TRANSPORT_GOOD;
748 }
749
750 /*
751 * MS_LibReadExtra()
752 */
753 int MS_LibReadExtra(struct us_data *us, DWORD PhyBlock,
754 BYTE PageNum, MS_LibTypeExtdat *ExtraDat)
755 {
756 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
757 int result;
758 BYTE ExtBuf[4];
759
760 /* printk("MS_LibReadExtra --- PhyBlock = %x, PageNum = %x\n"
761 , PhyBlock, PageNum); */
762 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
763 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
764 bcb->DataTransferLength = 0x4;
765 bcb->Flags = 0x80;
766 bcb->CDB[0] = 0xF1;
767 bcb->CDB[1] = 0x03;
768 bcb->CDB[5] = (BYTE)(PageNum);
769 bcb->CDB[4] = (BYTE)(PhyBlock);
770 bcb->CDB[3] = (BYTE)(PhyBlock>>8);
771 bcb->CDB[2] = (BYTE)(PhyBlock>>16);
772 bcb->CDB[6] = 0x01;
773
774 result = ENE_SendScsiCmd(us, FDIR_READ, &ExtBuf, 0);
775 if (result != USB_STOR_XFER_GOOD)
776 return USB_STOR_TRANSPORT_ERROR;
777
778 ExtraDat->reserved = 0;
779 ExtraDat->intr = 0x80; /* Not yet, waiting for fireware support */
780 ExtraDat->status0 = 0x10; /* Not yet, waiting for fireware support */
781 ExtraDat->status1 = 0x00; /* Not yet, waiting for fireware support */
782 ExtraDat->ovrflg = ExtBuf[0];
783 ExtraDat->mngflg = ExtBuf[1];
784 ExtraDat->logadr = MemStickLogAddr(ExtBuf[2], ExtBuf[3]);
785
786 return USB_STOR_TRANSPORT_GOOD;
787 }
788
789 /*
790 * MS_LibSetAcquiredErrorBlock()
791 */
792 int MS_LibSetAcquiredErrorBlock(struct us_data *us, WORD phyblk)
793 {
794 WORD log;
795
796 if (phyblk >= us->MS_Lib.NumberOfPhyBlock)
797 return (DWORD)-1;
798
799 log = us->MS_Lib.Phy2LogMap[phyblk];
800
801 if (log < us->MS_Lib.NumberOfLogBlock)
802 us->MS_Lib.Log2PhyMap[log] = MS_LB_NOT_USED;
803
804 if (us->MS_Lib.Phy2LogMap[phyblk] != MS_LB_INITIAL_ERROR)
805 us->MS_Lib.Phy2LogMap[phyblk] = MS_LB_ACQUIRED_ERROR;
806
807 return 0;
808 }
809
810 /*
811 * MS_LibErasePhyBlock()
812 */
813 int MS_LibErasePhyBlock(struct us_data *us, WORD phyblk)
814 {
815 WORD log;
816
817 if (phyblk >= us->MS_Lib.NumberOfPhyBlock)
818 return MS_STATUS_ERROR;
819
820 log = us->MS_Lib.Phy2LogMap[phyblk];
821
822 if (log < us->MS_Lib.NumberOfLogBlock)
823 us->MS_Lib.Log2PhyMap[log] = MS_LB_NOT_USED;
824
825 us->MS_Lib.Phy2LogMap[phyblk] = MS_LB_NOT_USED;
826
827 if (MS_LibIsWritable(us)) {
828 switch (MS_ReaderEraseBlock(us, phyblk)) {
829 case MS_STATUS_SUCCESS:
830 us->MS_Lib.Phy2LogMap[phyblk] = MS_LB_NOT_USED_ERASED;
831 return MS_STATUS_SUCCESS;
832 case MS_ERROR_FLASH_ERASE:
833 case MS_STATUS_INT_ERROR:
834 MS_LibErrorPhyBlock(us, phyblk);
835 return MS_ERROR_FLASH_ERASE;
836 case MS_STATUS_ERROR:
837 default:
838 MS_LibCtrlSet(us, MS_LIB_CTRL_RDONLY);
839 MS_LibSetAcquiredErrorBlock(us, phyblk);
840 return MS_STATUS_ERROR;
841 }
842 }
843
844 MS_LibSetAcquiredErrorBlock(us, phyblk);
845
846 return MS_STATUS_SUCCESS;
847 }
848
849 /*
850 * MS_LibErrorPhyBlock()
851 */
852 int MS_LibErrorPhyBlock(struct us_data *us, WORD phyblk)
853 {
854 if (phyblk >= us->MS_Lib.NumberOfPhyBlock)
855 return MS_STATUS_ERROR;
856
857 MS_LibSetAcquiredErrorBlock(us, phyblk);
858
859 if (MS_LibIsWritable(us))
860 return MS_LibOverwriteExtra(us, phyblk, 0,
861 (BYTE)(~MS_REG_OVR_BKST & BYTE_MASK));
862
863
864 return MS_STATUS_SUCCESS;
865 }
866
867 /*
868 * MS_LibOverwriteExtra()
869 */
870 int MS_LibOverwriteExtra(struct us_data *us, DWORD PhyBlockAddr,
871 BYTE PageNum, BYTE OverwriteFlag)
872 {
873 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
874 int result;
875
876 /* printk("MS --- MS_LibOverwriteExtra, \
877 PhyBlockAddr = %x, PageNum = %x\n", PhyBlockAddr, PageNum); */
878 result = ENE_LoadBinCode(us, MS_RW_PATTERN);
879 if (result != USB_STOR_XFER_GOOD)
880 return USB_STOR_TRANSPORT_ERROR;
881
882 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
883 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
884 bcb->DataTransferLength = 0x4;
885 bcb->Flags = 0x80;
886 bcb->CDB[0] = 0xF2;
887 bcb->CDB[1] = 0x05;
888 bcb->CDB[5] = (BYTE)(PageNum);
889 bcb->CDB[4] = (BYTE)(PhyBlockAddr);
890 bcb->CDB[3] = (BYTE)(PhyBlockAddr>>8);
891 bcb->CDB[2] = (BYTE)(PhyBlockAddr>>16);
892 bcb->CDB[6] = OverwriteFlag;
893 bcb->CDB[7] = 0xFF;
894 bcb->CDB[8] = 0xFF;
895 bcb->CDB[9] = 0xFF;
896
897 result = ENE_SendScsiCmd(us, FDIR_READ, NULL, 0);
898 if (result != USB_STOR_XFER_GOOD)
899 return USB_STOR_TRANSPORT_ERROR;
900
901 return USB_STOR_TRANSPORT_GOOD;
902 }
903
904 /*
905 * MS_LibForceSetLogicalPair()
906 */
907 int MS_LibForceSetLogicalPair(struct us_data *us, WORD logblk, WORD phyblk)
908 {
909 if (logblk == MS_LB_NOT_USED)
910 return 0;
911
912 if ((logblk >= us->MS_Lib.NumberOfLogBlock) ||
913 (phyblk >= us->MS_Lib.NumberOfPhyBlock))
914 return (DWORD)-1;
915
916 us->MS_Lib.Phy2LogMap[phyblk] = logblk;
917 us->MS_Lib.Log2PhyMap[logblk] = phyblk;
918
919 return 0;
920 }
921
922 /*
923 * MS_LibSetLogicalPair()
924 */
925 int MS_LibSetLogicalPair(struct us_data *us, WORD logblk, WORD phyblk)
926 {
927 if ((logblk >= us->MS_Lib.NumberOfLogBlock) ||
928 (phyblk >= us->MS_Lib.NumberOfPhyBlock))
929 return (DWORD)-1;
930
931 us->MS_Lib.Phy2LogMap[phyblk] = logblk;
932 us->MS_Lib.Log2PhyMap[logblk] = phyblk;
933
934 return 0;
935 }
936
937 /*
938 * MS_CountFreeBlock()
939 */
940 int MS_CountFreeBlock(struct us_data *us, WORD PhyBlock)
941 {
942 DWORD Ende, Count;
943
944 Ende = PhyBlock + MS_PHYSICAL_BLOCKS_PER_SEGMENT;
945 for (Count = 0; PhyBlock < Ende; PhyBlock++) {
946 switch (us->MS_Lib.Phy2LogMap[PhyBlock]) {
947 case MS_LB_NOT_USED:
948 case MS_LB_NOT_USED_ERASED:
949 Count++;
950 default:
951 break;
952 }
953 }
954
955 return Count;
956 }
957
958 /*
959 * MS_LibSearchBlockFromPhysical()
960 */
961 int MS_LibSearchBlockFromPhysical(struct us_data *us, WORD phyblk)
962 {
963 WORD Newblk;
964 WORD blk;
965 MS_LibTypeExtdat extdat;
966
967 if (phyblk >= us->MS_Lib.NumberOfPhyBlock)
968 return MS_LB_ERROR;
969
970 for (blk = phyblk + 1; blk != phyblk; blk++) {
971 if ((blk & MS_PHYSICAL_BLOCKS_PER_SEGMENT_MASK) == 0)
972 blk -= MS_PHYSICAL_BLOCKS_PER_SEGMENT;
973
974 Newblk = us->MS_Lib.Phy2LogMap[blk];
975 if (us->MS_Lib.Phy2LogMap[blk] == MS_LB_NOT_USED_ERASED)
976 return blk;
977 else if (us->MS_Lib.Phy2LogMap[blk] == MS_LB_NOT_USED) {
978 switch (MS_LibReadExtra(us, blk, 0, &extdat)) {
979 case MS_STATUS_SUCCESS:
980 case MS_STATUS_SUCCESS_WITH_ECC:
981 break;
982 case MS_NOCARD_ERROR:
983 return MS_NOCARD_ERROR;
984 case MS_STATUS_INT_ERROR:
985 return MS_LB_ERROR;
986 case MS_ERROR_FLASH_READ:
987 default:
988 MS_LibSetAcquiredErrorBlock(us, blk);
989 /* MS_LibErrorPhyBlock(fdoExt, blk); */
990 continue;
991 } /* End switch */
992
993 if ((extdat.ovrflg & MS_REG_OVR_BKST) !=
994 MS_REG_OVR_BKST_OK) {
995 MS_LibSetAcquiredErrorBlock(us, blk);
996 continue;
997 }
998
999 switch (MS_LibErasePhyBlock(us, blk)) {
1000 case MS_STATUS_SUCCESS:
1001 return blk;
1002 case MS_STATUS_ERROR:
1003 return MS_LB_ERROR;
1004 case MS_ERROR_FLASH_ERASE:
1005 default:
1006 MS_LibErrorPhyBlock(us, blk);
1007 break;
1008 }
1009 }
1010 } /* End for */
1011
1012 return MS_LB_ERROR;
1013 }
1014
1015 /*
1016 * MS_LibSearchBlockFromLogical()
1017 */
1018 int MS_LibSearchBlockFromLogical(struct us_data *us, WORD logblk)
1019 {
1020 WORD phyblk;
1021
1022 phyblk = MS_LibConv2Physical(us, logblk);
1023 if (phyblk >= MS_LB_ERROR) {
1024 if (logblk >= us->MS_Lib.NumberOfLogBlock)
1025 return MS_LB_ERROR;
1026
1027 phyblk = (logblk + MS_NUMBER_OF_BOOT_BLOCK) /
1028 MS_LOGICAL_BLOCKS_PER_SEGMENT;
1029 phyblk *= MS_PHYSICAL_BLOCKS_PER_SEGMENT;
1030 phyblk += MS_PHYSICAL_BLOCKS_PER_SEGMENT - 1;
1031 }
1032
1033 return MS_LibSearchBlockFromPhysical(us, phyblk);
1034 }