Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit 333c5ec0184c96f3d4adec4623966ca0745ebc51

Authored by Cho, Yu-Chen
Committed by Greg Kroah-Hartman
1 parent 02bb4b9e4c
Exists in master and in 7 other branches imx_3.0.35_4.1.0, imx_3.10.17_1.0.1_ga, imx_3.10.53_1.1.0_ga, imx_3.14.28_1.0.0_ga, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga, smarc-l5.0.0_1.0.0-ga

staging/keucr: fix keucr ms coding style 

fix keucr ms.c and ms.h coding style

Signed-off-by: Cho, Yu-Chen <acho@novell.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>

Showing 2 changed files with 566 additions and 465 deletions Side-by-side Diff

drivers/staging/keucr/ms.c
Diff comments   View file @ 333c5ec
Changes suppressed. Click to show
... ... @@ -6,13 +6,17 @@
6 6 #include "transport.h"
7 7 #include "ms.h"
8 8  
9   -//----- MS_ReaderCopyBlock() ------------------------------------------
10   -int MS_ReaderCopyBlock(struct us_data *us, WORD oldphy, WORD newphy, WORD PhyBlockAddr, BYTE PageNum, PBYTE buf, WORD len)
  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)
11 14 {
12 15 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
13 16 int result;
14 17  
15   - //printk("MS_ReaderCopyBlock --- PhyBlockAddr = %x, PageNum = %x\n", PhyBlockAddr, PageNum);
  18 + /* printk(KERN_INFO "MS_ReaderCopyBlock --- PhyBlockAddr = %x,
  19 + PageNum = %x\n", PhyBlockAddr, PageNum); */
16 20 result = ENE_LoadBinCode(us, MS_RW_PATTERN);
17 21 if (result != USB_STOR_XFER_GOOD)
18 22 return USB_STOR_TRANSPORT_ERROR;
19 23  
20 24  
... ... @@ -40,21 +44,25 @@
40 44 return USB_STOR_TRANSPORT_GOOD;
41 45 }
42 46  
43   -//----- MS_ReaderReadPage() ------------------------------------------
44   -int MS_ReaderReadPage(struct us_data *us, DWORD PhyBlockAddr, BYTE PageNum, PDWORD PageBuf, MS_LibTypeExtdat *ExtraDat)
  47 +/*
  48 + * MS_ReaderReadPage()
  49 + */
  50 +int MS_ReaderReadPage(struct us_data *us, DWORD PhyBlockAddr,
  51 + BYTE PageNum, PDWORD PageBuf, MS_LibTypeExtdat *ExtraDat)
45 52 {
46 53 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
47 54 int result;
48 55 BYTE ExtBuf[4];
49 56 DWORD bn = PhyBlockAddr * 0x20 + PageNum;
50 57  
51   - //printk("MS --- MS_ReaderReadPage, PhyBlockAddr = %x, PageNum = %x\n", PhyBlockAddr, PageNum);
  58 + /* printk(KERN_INFO "MS --- MS_ReaderReadPage,
  59 + PhyBlockAddr = %x, PageNum = %x\n", PhyBlockAddr, PageNum); */
52 60  
53 61 result = ENE_LoadBinCode(us, MS_RW_PATTERN);
54 62 if (result != USB_STOR_XFER_GOOD)
55 63 return USB_STOR_TRANSPORT_ERROR;
56 64  
57   - // Read Page Data
  65 + /* Read Page Data */
58 66 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
59 67 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
60 68 bcb->DataTransferLength = 0x200;
61 69  
... ... @@ -65,12 +73,12 @@
65 73 bcb->CDB[4] = (BYTE)(bn>>8);
66 74 bcb->CDB[3] = (BYTE)(bn>>16);
67 75 bcb->CDB[2] = (BYTE)(bn>>24);
68   -
  76 +
69 77 result = ENE_SendScsiCmd(us, FDIR_READ, PageBuf, 0);
70 78 if (result != USB_STOR_XFER_GOOD)
71 79 return USB_STOR_TRANSPORT_ERROR;
72 80  
73   - // Read Extra Data
  81 + /* Read Extra Data */
74 82 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
75 83 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
76 84 bcb->DataTransferLength = 0x4;
... ... @@ -88,9 +96,9 @@
88 96 return USB_STOR_TRANSPORT_ERROR;
89 97  
90 98 ExtraDat->reserved = 0;
91   - ExtraDat->intr = 0x80; // Not yet, ๅ…ˆๅ‡่จญ, ็ญ‰ fireware support
92   - ExtraDat->status0 = 0x10; // Not yet, ๅ…ˆๅ‡่จญ, ็ญ‰ fireware support
93   - ExtraDat->status1 = 0x00; // Not yet, ๅ…ˆๅ‡่จญ, ็ญ‰ fireware support
  99 + ExtraDat->intr = 0x80; /* Not yet,fireware support */
  100 + ExtraDat->status0 = 0x10; /* Not yet,fireware support */
  101 + ExtraDat->status1 = 0x00; /* Not yet,fireware support */
94 102 ExtraDat->ovrflg = ExtBuf[0];
95 103 ExtraDat->mngflg = ExtBuf[1];
96 104 ExtraDat->logadr = MemStickLogAddr(ExtBuf[2], ExtBuf[3]);
97 105  
... ... @@ -98,14 +106,17 @@
98 106 return USB_STOR_TRANSPORT_GOOD;
99 107 }
100 108  
101   -//----- MS_ReaderEraseBlock() ----------------------------------------
  109 +/*
  110 + * MS_ReaderEraseBlock()
  111 + */
102 112 int MS_ReaderEraseBlock(struct us_data *us, DWORD PhyBlockAddr)
103 113 {
104 114 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
105 115 int result;
106 116 DWORD bn = PhyBlockAddr;
107 117  
108   - //printk("MS --- MS_ReaderEraseBlock, PhyBlockAddr = %x\n", PhyBlockAddr);
  118 + /* printk(KERN_INFO "MS --- MS_ReaderEraseBlock,
  119 + PhyBlockAddr = %x\n", PhyBlockAddr); */
109 120 result = ENE_LoadBinCode(us, MS_RW_PATTERN);
110 121 if (result != USB_STOR_XFER_GOOD)
111 122 return USB_STOR_TRANSPORT_ERROR;
... ... @@ -119,7 +130,7 @@
119 130 bcb->CDB[4] = (BYTE)(bn);
120 131 bcb->CDB[3] = (BYTE)(bn>>8);
121 132 bcb->CDB[2] = (BYTE)(bn>>16);
122   -
  133 +
123 134 result = ENE_SendScsiCmd(us, FDIR_READ, NULL, 0);
124 135 if (result != USB_STOR_XFER_GOOD)
125 136 return USB_STOR_TRANSPORT_ERROR;
126 137  
127 138  
128 139  
... ... @@ -127,23 +138,25 @@
127 138 return USB_STOR_TRANSPORT_GOOD;
128 139 }
129 140  
130   -//----- MS_CardInit() ------------------------------------------------
  141 +/*
  142 + * MS_CardInit()
  143 + */
131 144 int MS_CardInit(struct us_data *us)
132 145 {
133   - DWORD result=0;
  146 + DWORD result = 0;
134 147 WORD TmpBlock;
135 148 PBYTE PageBuffer0 = NULL, PageBuffer1 = NULL;
136 149 MS_LibTypeExtdat extdat;
137 150 WORD btBlk1st, btBlk2nd;
138 151 DWORD btBlk1stErred;
139 152  
140   - printk("MS_CardInit start\n");
  153 + printk(KERN_INFO "MS_CardInit start\n");
141 154  
142 155 MS_LibFreeAllocatedArea(us);
143 156  
144   - if (((PageBuffer0 = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL)) == NULL) ||
145   - ((PageBuffer1 = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL)) == NULL))
146   - {
  157 + PageBuffer0 = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL);
  158 + PageBuffer1 = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL);
  159 + if ((PageBuffer0 == NULL) || (PageBuffer1 == NULL)) {
147 160 result = MS_NO_MEMORY_ERROR;
148 161 goto exit;
149 162 }
150 163  
151 164  
... ... @@ -151,16 +164,16 @@
151 164 btBlk1st = btBlk2nd = MS_LB_NOT_USED;
152 165 btBlk1stErred = 0;
153 166  
154   - for (TmpBlock=0; TmpBlock < MS_MAX_INITIAL_ERROR_BLOCKS+2; TmpBlock++)
155   - {
156   - switch (MS_ReaderReadPage(us, TmpBlock, 0, (DWORD *)PageBuffer0, &extdat))
157   - {
158   - case MS_STATUS_SUCCESS:
  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:
159 172 break;
160   - case MS_STATUS_INT_ERROR:
  173 + case MS_STATUS_INT_ERROR:
161 174 break;
162   - case MS_STATUS_ERROR:
163   - default:
  175 + case MS_STATUS_ERROR:
  176 + default:
164 177 continue;
165 178 }
166 179  
167 180  
168 181  
169 182  
170 183  
171 184  
172 185  
... ... @@ -173,38 +186,37 @@
173 186 (((MemStickBootBlockPage0 *)PageBuffer0)->header.bNumberOfDataEntry != MS_BOOT_BLOCK_DATA_ENTRIES))
174 187 continue;
175 188  
176   - if (btBlk1st != MS_LB_NOT_USED)
177   - {
  189 + if (btBlk1st != MS_LB_NOT_USED) {
178 190 btBlk2nd = TmpBlock;
179 191 break;
180 192 }
181 193  
182 194 btBlk1st = TmpBlock;
183 195 memcpy(PageBuffer1, PageBuffer0, MS_BYTES_PER_PAGE);
184   - if (extdat.status1 & (MS_REG_ST1_DTER | MS_REG_ST1_EXER | MS_REG_ST1_FGER))
  196 + if (extdat.status1 &
  197 + (MS_REG_ST1_DTER | MS_REG_ST1_EXER | MS_REG_ST1_FGER))
185 198 btBlk1stErred = 1;
186 199 }
187 200  
188   - if (btBlk1st == MS_LB_NOT_USED)
189   - {
  201 + if (btBlk1st == MS_LB_NOT_USED) {
190 202 result = MS_STATUS_ERROR;
191 203 goto exit;
192 204 }
193 205  
194   - // write protect
  206 + /* write protect */
195 207 if ((extdat.status0 & MS_REG_ST0_WP) == MS_REG_ST0_WP_ON)
196 208 MS_LibCtrlSet(us, MS_LIB_CTRL_WRPROTECT);
197 209  
198 210 result = MS_STATUS_ERROR;
199   - // 1st Boot Block
  211 + /* 1st Boot Block */
200 212 if (btBlk1stErred == 0)
201   - result = MS_LibProcessBootBlock(us, btBlk1st, PageBuffer1); // 1st
202   - // 2nd Boot Block
  213 + result = MS_LibProcessBootBlock(us, btBlk1st, PageBuffer1);
  214 + /* 1st */
  215 + /* 2nd Boot Block */
203 216 if (result && (btBlk2nd != MS_LB_NOT_USED))
204 217 result = MS_LibProcessBootBlock(us, btBlk2nd, PageBuffer0);
205 218  
206   - if (result)
207   - {
  219 + if (result) {
208 220 result = MS_STATUS_ERROR;
209 221 goto exit;
210 222 }
... ... @@ -214,8 +226,7 @@
214 226  
215 227 us->MS_Lib.Phy2LogMap[btBlk1st] = MS_LB_BOOT_BLOCK;
216 228  
217   - if (btBlk2nd != MS_LB_NOT_USED)
218   - {
  229 + if (btBlk2nd != MS_LB_NOT_USED) {
219 230 for (TmpBlock = btBlk1st + 1; TmpBlock < btBlk2nd; TmpBlock++)
220 231 us->MS_Lib.Phy2LogMap[TmpBlock] = MS_LB_INITIAL_ERROR;
221 232 us->MS_Lib.Phy2LogMap[btBlk2nd] = MS_LB_BOOT_BLOCK;
222 233  
... ... @@ -225,18 +236,17 @@
225 236 if (result)
226 237 goto exit;
227 238  
228   - for (TmpBlock=MS_PHYSICAL_BLOCKS_PER_SEGMENT; TmpBlock<us->MS_Lib.NumberOfPhyBlock; TmpBlock+=MS_PHYSICAL_BLOCKS_PER_SEGMENT)
229   - {
230   - if (MS_CountFreeBlock(us, TmpBlock) == 0)
231   - {
  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) {
232 243 MS_LibCtrlSet(us, MS_LIB_CTRL_WRPROTECT);
233 244 break;
234 245 }
235 246 }
236 247  
237   - // write
238   - if (MS_LibAllocWriteBuf(us))
239   - {
  248 + /* write */
  249 + if (MS_LibAllocWriteBuf(us)) {
240 250 result = MS_NO_MEMORY_ERROR;
241 251 goto exit;
242 252 }
243 253  
244 254  
245 255  
246 256  
247 257  
248 258  
249 259  
250 260  
... ... @@ -245,46 +255,48 @@
245 255  
246 256 exit:
247 257 kfree(PageBuffer1);
248   - kfree(PageBuffer0);
  258 + kfree(PageBuffer0);
249 259  
250   - printk("MS_CardInit end\n");
  260 + printk(KERN_INFO "MS_CardInit end\n");
251 261 return result;
252 262 }
253 263  
254   -//----- MS_LibCheckDisableBlock() ------------------------------------
  264 +/*
  265 + * MS_LibCheckDisableBlock()
  266 + */
255 267 int MS_LibCheckDisableBlock(struct us_data *us, WORD PhyBlock)
256 268 {
257   - PWORD PageBuf=NULL;
258   - DWORD result=MS_STATUS_SUCCESS;
259   - DWORD blk, index=0;
  269 + PWORD PageBuf = NULL;
  270 + DWORD result = MS_STATUS_SUCCESS;
  271 + DWORD blk, index = 0;
260 272 MS_LibTypeExtdat extdat;
261 273  
262   - if (((PageBuf = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL)) == NULL))
263   - {
  274 + PageBuf = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL);
  275 + if (PageBuf == NULL) {
264 276 result = MS_NO_MEMORY_ERROR;
265 277 goto exit;
266 278 }
267 279  
268 280 MS_ReaderReadPage(us, PhyBlock, 1, (DWORD *)PageBuf, &extdat);
269   - do
270   - {
  281 + do {
271 282 blk = be16_to_cpu(PageBuf[index]);
272 283 if (blk == MS_LB_NOT_USED)
273 284 break;
274   - if (blk == us->MS_Lib.Log2PhyMap[0])
275   - {
  285 + if (blk == us->MS_Lib.Log2PhyMap[0]) {
276 286 result = MS_ERROR_FLASH_READ;
277 287 break;
278 288 }
279 289 index++;
280   - } while(1);
  290 + } while (1);
281 291  
282 292 exit:
283 293 kfree(PageBuf);
284 294 return result;
285 295 }
286 296  
287   -//----- MS_LibFreeAllocatedArea() ------------------------------------
  297 +/*
  298 + * MS_LibFreeAllocatedArea()
  299 + */
288 300 void MS_LibFreeAllocatedArea(struct us_data *us)
289 301 {
290 302 MS_LibFreeWriteBuf(us);
291 303  
292 304  
293 305  
294 306  
... ... @@ -302,26 +314,31 @@
302 314 us->MS_Lib.NumberOfLogBlock = 0;
303 315 }
304 316  
305   -//----- MS_LibFreeWriteBuf() -----------------------------------------
  317 +/*
  318 + * MS_LibFreeWriteBuf()
  319 + */
306 320 void MS_LibFreeWriteBuf(struct us_data *us)
307 321 {
308   - us->MS_Lib.wrtblk = (WORD)-1; //set to -1
309   - MS_LibClearPageMap(us); // memset((fdoExt)->MS_Lib.pagemap, 0, sizeof((fdoExt)->MS_Lib.pagemap))
  322 + us->MS_Lib.wrtblk = (WORD)-1; /* set to -1 */
310 323  
311   - if (us->MS_Lib.blkpag)
312   - {
313   - kfree((BYTE *)(us->MS_Lib.blkpag)); // Arnold test ...
  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 ... */
314 330 us->MS_Lib.blkpag = NULL;
315 331 }
316 332  
317   - if (us->MS_Lib.blkext)
318   - {
319   - kfree((BYTE *)(us->MS_Lib.blkext)); // Arnold test ...
  333 + if (us->MS_Lib.blkext) {
  334 + kfree((BYTE *)(us->MS_Lib.blkext)); /* Arnold test ... */
320 335 us->MS_Lib.blkext = NULL;
321 336 }
322 337 }
323 338  
324   -//----- MS_LibFreeLogicalMap() ---------------------------------------
  339 +/*
  340 + * MS_LibFreeLogicalMap()
  341 + */
325 342 int MS_LibFreeLogicalMap(struct us_data *us)
326 343 {
327 344 kfree(us->MS_Lib.Phy2LogMap);
328 345  
... ... @@ -330,10 +347,12 @@
330 347 kfree(us->MS_Lib.Log2PhyMap);
331 348 us->MS_Lib.Log2PhyMap = NULL;
332 349  
333   - return 0;
  350 + return 0;
334 351 }
335 352  
336   -//----- MS_LibProcessBootBlock() -------------------------------------
  353 +/*
  354 + * MS_LibProcessBootBlock()
  355 + */
337 356 int MS_LibProcessBootBlock(struct us_data *us, WORD PhyBlock, BYTE *PageData)
338 357 {
339 358 MemStickBootBlockSysEnt *SysEntry;
340 359  
341 360  
342 361  
343 362  
344 363  
345 364  
346 365  
347 366  
348 367  
349 368  
350 369  
351 370  
352 371  
353 372  
354 373  
355 374  
356 375  
357 376  
358 377  
359 378  
360 379  
361 380  
362 381  
363 382  
364 383  
... ... @@ -343,144 +362,165 @@
343 362 BYTE *PageBuffer;
344 363 MS_LibTypeExtdat ExtraData;
345 364  
346   - if ((PageBuffer = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL))==NULL)
  365 +
  366 + PageBuffer = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL);
  367 + if (PageBuffer == NULL)
347 368 return (DWORD)-1;
348 369  
349 370 result = (DWORD)-1;
350 371  
351   - SysInfo= &(((MemStickBootBlockPage0 *)PageData)->sysinf);
  372 + SysInfo = &(((MemStickBootBlockPage0 *)PageData)->sysinf);
352 373  
353   - if ((SysInfo->bMsClass != MS_SYSINF_MSCLASS_TYPE_1) ||
354   - (be16_to_cpu(SysInfo->wPageSize) != MS_SYSINF_PAGE_SIZE) ||
  374 + if ((SysInfo->bMsClass != MS_SYSINF_MSCLASS_TYPE_1) ||
  375 + (be16_to_cpu(SysInfo->wPageSize) != MS_SYSINF_PAGE_SIZE) ||
355 376 ((SysInfo->bSecuritySupport & MS_SYSINF_SECURITY) == MS_SYSINF_SECURITY_SUPPORT) ||
356   - (SysInfo->bReserved1 != MS_SYSINF_RESERVED1) ||
357   - (SysInfo->bReserved2 != MS_SYSINF_RESERVED2) ||
358   - (SysInfo->bFormatType!= MS_SYSINF_FORMAT_FAT) ||
  377 + (SysInfo->bReserved1 != MS_SYSINF_RESERVED1) ||
  378 + (SysInfo->bReserved2 != MS_SYSINF_RESERVED2) ||
  379 + (SysInfo->bFormatType != MS_SYSINF_FORMAT_FAT) ||
359 380 (SysInfo->bUsage != MS_SYSINF_USAGE_GENERAL))
360 381 goto exit;
361 382  
362   - switch (us->MS_Lib.cardType = SysInfo->bCardType)
363   - {
364   - case MS_SYSINF_CARDTYPE_RDONLY:
365   - MS_LibCtrlSet(us, MS_LIB_CTRL_RDONLY);
366   - break;
367   - case MS_SYSINF_CARDTYPE_RDWR:
368   - MS_LibCtrlReset(us, MS_LIB_CTRL_RDONLY);
369   - break;
370   - case MS_SYSINF_CARDTYPE_HYBRID:
371   - default:
372   - goto exit;
  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;
373 393 }
374 394  
375 395 us->MS_Lib.blockSize = be16_to_cpu(SysInfo->wBlockSize);
376 396 us->MS_Lib.NumberOfPhyBlock = be16_to_cpu(SysInfo->wBlockNumber);
377   - us->MS_Lib.NumberOfLogBlock = be16_to_cpu(SysInfo->wTotalBlockNumber) - 2;
378   - us->MS_Lib.PagesPerBlock = us->MS_Lib.blockSize * SIZE_OF_KIRO / MS_BYTES_PER_PAGE;
379   - us->MS_Lib.NumberOfSegment = us->MS_Lib.NumberOfPhyBlock / MS_PHYSICAL_BLOCKS_PER_SEGMENT;
  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;
380 403 us->MS_Model = be16_to_cpu(SysInfo->wMemorySize);
381 404  
382   - if (MS_LibAllocLogicalMap(us)) //Allocate to all number of logicalblock and physicalblock
  405 + /*Allocate to all number of logicalblock and physicalblock */
  406 + if (MS_LibAllocLogicalMap(us))
383 407 goto exit;
384 408  
385   - MS_LibSetBootBlockMark(us, PhyBlock); //Mark the book block
  409 + /* Mark the book block */
  410 + MS_LibSetBootBlockMark(us, PhyBlock);
386 411  
387 412 SysEntry = &(((MemStickBootBlockPage0 *)PageData)->sysent);
388 413  
389   - for (i=0; i<MS_NUMBER_OF_SYSTEM_ENTRY; i++)
390   - {
  414 + for (i = 0; i < MS_NUMBER_OF_SYSTEM_ENTRY; i++) {
391 415 DWORD EntryOffset, EntrySize;
392 416  
393   - if ((EntryOffset = be32_to_cpu(SysEntry->entry[i].dwStart)) == 0xffffff)
  417 + EntryOffset = be32_to_cpu(SysEntry->entry[i].dwStart);
  418 +
  419 + if (EntryOffset == 0xffffff)
394 420 continue;
  421 + EntrySize = be32_to_cpu(SysEntry->entry[i].dwSize);
395 422  
396   - if ((EntrySize = be32_to_cpu(SysEntry->entry[i].dwSize)) == 0)
  423 + if (EntrySize == 0)
397 424 continue;
398 425  
399   - if (EntryOffset + MS_BYTES_PER_PAGE + EntrySize > us->MS_Lib.blockSize * (DWORD)SIZE_OF_KIRO)
  426 + if (EntryOffset + MS_BYTES_PER_PAGE + EntrySize >
  427 + us->MS_Lib.blockSize * (DWORD)SIZE_OF_KIRO)
400 428 continue;
401 429  
402   - if (i == 0)
403   - {
  430 + if (i == 0) {
404 431 BYTE PrevPageNumber = 0;
405 432 WORD phyblk;
406 433  
407   - if (SysEntry->entry[i].bType != MS_SYSENT_TYPE_INVALID_BLOCK)
  434 + if (SysEntry->entry[i].bType !=
  435 + MS_SYSENT_TYPE_INVALID_BLOCK)
408 436 goto exit;
409 437  
410   - while (EntrySize > 0)
411   - {
412   - if ((PageNumber = (BYTE)(EntryOffset / MS_BYTES_PER_PAGE + 1)) != PrevPageNumber)
413   - {
414   - switch (MS_ReaderReadPage(us, PhyBlock, PageNumber, (DWORD *)PageBuffer, &ExtraData))
415   - {
416   - case MS_STATUS_SUCCESS:
417   - break;
418   - case MS_STATUS_WRITE_PROTECT:
419   - case MS_ERROR_FLASH_READ:
420   - case MS_STATUS_ERROR:
421   - default:
422   - goto exit;
  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;
423 453 }
424 454  
425 455 PrevPageNumber = PageNumber;
426 456 }
427 457  
428   - if ((phyblk = be16_to_cpu(*(WORD *)(PageBuffer + (EntryOffset % MS_BYTES_PER_PAGE)))) < 0x0fff)
  458 + phyblk = be16_to_cpu(*(WORD *)(PageBuffer +
  459 + (EntryOffset % MS_BYTES_PER_PAGE)));
  460 + if (phyblk < 0x0fff)
429 461 MS_LibSetInitialErrorBlock(us, phyblk);
430 462  
431 463 EntryOffset += 2;
432 464 EntrySize -= 2;
433 465 }
434   - }
435   - else if (i == 1)
436   - { // CIS/IDI
  466 + } else if (i == 1) { /* CIS/IDI */
437 467 MemStickBootBlockIDI *idi;
438 468  
439 469 if (SysEntry->entry[i].bType != MS_SYSENT_TYPE_CIS_IDI)
440 470 goto exit;
441 471  
442   - switch (MS_ReaderReadPage(us, PhyBlock, (BYTE)(EntryOffset / MS_BYTES_PER_PAGE + 1), (DWORD *)PageBuffer, &ExtraData))
443   - {
444   - case MS_STATUS_SUCCESS:
445   - break;
446   - case MS_STATUS_WRITE_PROTECT:
447   - case MS_ERROR_FLASH_READ:
448   - case MS_STATUS_ERROR:
449   - default:
450   - goto exit;
  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;
451 482 }
452 483  
453   - idi = &((MemStickBootBlockCIS_IDI *)(PageBuffer + (EntryOffset % MS_BYTES_PER_PAGE)))->idi.idi;
454   - if (le16_to_cpu(idi->wIDIgeneralConfiguration) != MS_IDI_GENERAL_CONF)
  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)
455 488 goto exit;
456 489  
457   - us->MS_Lib.BytesPerSector = le16_to_cpu(idi->wIDIbytesPerSector);
  490 + us->MS_Lib.BytesPerSector =
  491 + le16_to_cpu(idi->wIDIbytesPerSector);
458 492 if (us->MS_Lib.BytesPerSector != MS_BYTES_PER_PAGE)
459 493 goto exit;
460 494 }
461   - } // End for ..
  495 + } /* End for .. */
462 496  
463 497 result = 0;
464 498  
465 499 exit:
466   - if (result) MS_LibFreeLogicalMap(us);
  500 + if (result)
  501 + MS_LibFreeLogicalMap(us);
  502 +
467 503 kfree(PageBuffer);
468 504  
469 505 result = 0;
470 506 return result;
471 507 }
472 508  
473   -//----- MS_LibAllocLogicalMap() --------------------------------------
  509 +/*
  510 + * MS_LibAllocLogicalMap()
  511 + */
474 512 int MS_LibAllocLogicalMap(struct us_data *us)
475 513 {
476 514 DWORD i;
477 515  
478 516  
479   - us->MS_Lib.Phy2LogMap = kmalloc(us->MS_Lib.NumberOfPhyBlock * sizeof(WORD), GFP_KERNEL);
480   - us->MS_Lib.Log2PhyMap = kmalloc(us->MS_Lib.NumberOfLogBlock * sizeof(WORD), GFP_KERNEL);
  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);
481 521  
482   - if ((us->MS_Lib.Phy2LogMap == NULL) || (us->MS_Lib.Log2PhyMap == NULL))
483   - {
  522 + if ((us->MS_Lib.Phy2LogMap == NULL) ||
  523 + (us->MS_Lib.Log2PhyMap == NULL)) {
484 524 MS_LibFreeLogicalMap(us);
485 525 return (DWORD)-1;
486 526 }
487 527  
488 528  
489 529  
490 530  
491 531  
492 532  
493 533  
494 534  
495 535  
496 536  
497 537  
498 538  
499 539  
500 540  
501 541  
502 542  
503 543  
504 544  
505 545  
506 546  
507 547  
508 548  
509 549  
510 550  
511 551  
512 552  
... ... @@ -489,128 +529,142 @@
489 529 us->MS_Lib.Phy2LogMap[i] = MS_LB_NOT_USED;
490 530  
491 531 for (i = 0; i < us->MS_Lib.NumberOfLogBlock; i++)
492   - us->MS_Lib.Log2PhyMap[i] = MS_LB_NOT_USED;
  532 + us->MS_Lib.Log2PhyMap[i] = MS_LB_NOT_USED;
493 533  
494 534 return 0;
495 535 }
496 536  
497   -//----- MS_LibSetBootBlockMark() -------------------------------------
  537 +/*
  538 + * MS_LibSetBootBlockMark()
  539 + */
498 540 int MS_LibSetBootBlockMark(struct us_data *us, WORD phyblk)
499 541 {
500   - return MS_LibSetLogicalBlockMark(us, phyblk, MS_LB_BOOT_BLOCK);
  542 + return MS_LibSetLogicalBlockMark(us, phyblk, MS_LB_BOOT_BLOCK);
501 543 }
502 544  
503   -//----- MS_LibSetLogicalBlockMark() ----------------------------------
  545 +/*
  546 + * MS_LibSetLogicalBlockMark()
  547 + */
504 548 int MS_LibSetLogicalBlockMark(struct us_data *us, WORD phyblk, WORD mark)
505 549 {
506   - if (phyblk >= us->MS_Lib.NumberOfPhyBlock)
507   - return (DWORD)-1;
  550 + if (phyblk >= us->MS_Lib.NumberOfPhyBlock)
  551 + return (DWORD)-1;
508 552  
509   - us->MS_Lib.Phy2LogMap[phyblk] = mark;
  553 + us->MS_Lib.Phy2LogMap[phyblk] = mark;
510 554  
511   - return 0;
  555 + return 0;
512 556 }
513 557  
514   -//----- MS_LibSetInitialErrorBlock() ---------------------------------
  558 +/*
  559 + * MS_LibSetInitialErrorBlock()
  560 + */
515 561 int MS_LibSetInitialErrorBlock(struct us_data *us, WORD phyblk)
516 562 {
517   - return MS_LibSetLogicalBlockMark(us, phyblk, MS_LB_INITIAL_ERROR);
  563 + return MS_LibSetLogicalBlockMark(us, phyblk, MS_LB_INITIAL_ERROR);
518 564 }
519 565  
520   -//----- MS_LibScanLogicalBlockNumber() -------------------------------
  566 +/*
  567 + * MS_LibScanLogicalBlockNumber()
  568 + */
521 569 int MS_LibScanLogicalBlockNumber(struct us_data *us, WORD btBlk1st)
522 570 {
523 571 WORD PhyBlock, newblk, i;
524 572 WORD LogStart, LogEnde;
525 573 MS_LibTypeExtdat extdat;
526 574 BYTE buf[0x200];
527   - DWORD count=0, index=0;
  575 + DWORD count = 0, index = 0;
528 576  
529   - for (PhyBlock = 0; PhyBlock < us->MS_Lib.NumberOfPhyBlock;)
530   - {
  577 + for (PhyBlock = 0; PhyBlock < us->MS_Lib.NumberOfPhyBlock;) {
531 578 MS_LibPhy2LogRange(PhyBlock, &LogStart, &LogEnde);
532 579  
533   - for (i=0; i<MS_PHYSICAL_BLOCKS_PER_SEGMENT; i++, PhyBlock++)
534   - {
535   - switch (MS_LibConv2Logical(us, PhyBlock))
536   - {
537   - case MS_STATUS_ERROR:
538   - continue;
539   - default:
540   - break;
  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;
541 587 }
542 588  
543   - if (count == PhyBlock)
544   - {
545   - MS_LibReadExtraBlock(us, PhyBlock, 0, 0x80, &buf);
  589 + if (count == PhyBlock) {
  590 + MS_LibReadExtraBlock(us, PhyBlock,
  591 + 0, 0x80, &buf);
546 592 count += 0x80;
547 593 }
548 594 index = (PhyBlock % 0x80) * 4;
549 595  
550 596 extdat.ovrflg = buf[index];
551 597 extdat.mngflg = buf[index+1];
552   - extdat.logadr = MemStickLogAddr(buf[index+2], buf[index+3]);
  598 + extdat.logadr = MemStickLogAddr(buf[index+2],
  599 + buf[index+3]);
553 600  
554   - if ((extdat.ovrflg & MS_REG_OVR_BKST) != MS_REG_OVR_BKST_OK)
555   - {
  601 + if ((extdat.ovrflg & MS_REG_OVR_BKST) !=
  602 + MS_REG_OVR_BKST_OK) {
556 603 MS_LibSetAcquiredErrorBlock(us, PhyBlock);
557 604 continue;
558 605 }
559 606  
560   - if ((extdat.mngflg & MS_REG_MNG_ATFLG) == MS_REG_MNG_ATFLG_ATTBL)
561   - {
  607 + if ((extdat.mngflg & MS_REG_MNG_ATFLG) ==
  608 + MS_REG_MNG_ATFLG_ATTBL) {
562 609 MS_LibErasePhyBlock(us, PhyBlock);
563 610 continue;
564 611 }
565 612  
566   - if (extdat.logadr != MS_LB_NOT_USED)
567   - {
568   - if ((extdat.logadr < LogStart) || (LogEnde <= extdat.logadr))
569   - {
  613 + if (extdat.logadr != MS_LB_NOT_USED) {
  614 + if ((extdat.logadr < LogStart) ||
  615 + (LogEnde <= extdat.logadr)) {
570 616 MS_LibErasePhyBlock(us, PhyBlock);
571 617 continue;
572 618 }
573 619  
574   - if ((newblk = MS_LibConv2Physical(us, extdat.logadr)) != MS_LB_NOT_USED)
575   - {
576   - if (extdat.logadr==0)
577   - {
578   - MS_LibSetLogicalPair(us, extdat.logadr, PhyBlock);
579   - if ( MS_LibCheckDisableBlock(us, btBlk1st) )
580   - {
581   - MS_LibSetLogicalPair(us, extdat.logadr, newblk);
  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);
582 631 continue;
583 632 }
584 633 }
585 634  
586 635 MS_LibReadExtra(us, newblk, 0, &extdat);
587   - if ((extdat.ovrflg & MS_REG_OVR_UDST) == MS_REG_OVR_UDST_UPDATING)
588   - {
589   - MS_LibErasePhyBlock(us, PhyBlock);
  636 + if ((extdat.ovrflg & MS_REG_OVR_UDST) ==
  637 + MS_REG_OVR_UDST_UPDATING) {
  638 + MS_LibErasePhyBlock(us,
  639 + PhyBlock);
590 640 continue;
591   - }
592   - else
  641 + } else {
593 642 MS_LibErasePhyBlock(us, newblk);
  643 + }
594 644 }
595 645  
596   - MS_LibSetLogicalPair(us, extdat.logadr, PhyBlock);
  646 + MS_LibSetLogicalPair(us, extdat.logadr,
  647 + PhyBlock);
597 648 }
598 649 }
599   - } //End for ...
  650 + } /* End for ... */
600 651  
601 652 return MS_STATUS_SUCCESS;
602 653 }
603 654  
604   -//----- MS_LibAllocWriteBuf() ----------------------------------------
  655 +/*
  656 + * MS_LibAllocWriteBuf()
  657 + */
605 658 int MS_LibAllocWriteBuf(struct us_data *us)
606 659 {
607 660 us->MS_Lib.wrtblk = (WORD)-1;
608 661  
609   - us->MS_Lib.blkpag = kmalloc(us->MS_Lib.PagesPerBlock * us->MS_Lib.BytesPerSector, GFP_KERNEL);
610   - us->MS_Lib.blkext = kmalloc(us->MS_Lib.PagesPerBlock * sizeof(MS_LibTypeExtdat), GFP_KERNEL);
  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);
611 666  
612   - if ((us->MS_Lib.blkpag == NULL) || (us->MS_Lib.blkext == NULL))
613   - {
  667 + if ((us->MS_Lib.blkpag == NULL) || (us->MS_Lib.blkext == NULL)) {
614 668 MS_LibFreeWriteBuf(us);
615 669 return (DWORD)-1;
616 670 }
... ... @@ -620,7 +674,9 @@
620 674 return 0;
621 675 }
622 676  
623   -//----- MS_LibClearWriteBuf() ----------------------------------------
  677 +/*
  678 + * MS_LibClearWriteBuf()
  679 + */
624 680 void MS_LibClearWriteBuf(struct us_data *us)
625 681 {
626 682 int i;
627 683  
... ... @@ -629,12 +685,11 @@
629 685 MS_LibClearPageMap(us);
630 686  
631 687 if (us->MS_Lib.blkpag)
632   - memset(us->MS_Lib.blkpag, 0xff, us->MS_Lib.PagesPerBlock * us->MS_Lib.BytesPerSector);
  688 + memset(us->MS_Lib.blkpag, 0xff,
  689 + us->MS_Lib.PagesPerBlock * us->MS_Lib.BytesPerSector);
633 690  
634   - if (us->MS_Lib.blkext)
635   - {
636   - for (i = 0; i < us->MS_Lib.PagesPerBlock; i++)
637   - {
  691 + if (us->MS_Lib.blkext) {
  692 + for (i = 0; i < us->MS_Lib.PagesPerBlock; i++) {
638 693 us->MS_Lib.blkext[i].status1 = MS_REG_ST1_DEFAULT;
639 694 us->MS_Lib.blkext[i].ovrflg = MS_REG_OVR_DEFAULT;
640 695 us->MS_Lib.blkext[i].mngflg = MS_REG_MNG_DEFAULT;
641 696  
642 697  
643 698  
644 699  
645 700  
... ... @@ -643,32 +698,36 @@
643 698 }
644 699 }
645 700  
646   -//----- MS_LibPhy2LogRange() -----------------------------------------
  701 +/*
  702 + * MS_LibPhy2LogRange()
  703 + */
647 704 void MS_LibPhy2LogRange(WORD PhyBlock, WORD *LogStart, WORD *LogEnde)
648 705 {
649 706 PhyBlock /= MS_PHYSICAL_BLOCKS_PER_SEGMENT;
650 707  
651   - if (PhyBlock)
652   - {
653   - *LogStart = MS_LOGICAL_BLOCKS_IN_1ST_SEGMENT + (PhyBlock - 1) * MS_LOGICAL_BLOCKS_PER_SEGMENT;//496
654   - *LogEnde = *LogStart + MS_LOGICAL_BLOCKS_PER_SEGMENT;//496
655   - }
656   - else
657   - {
  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 {
658 713 *LogStart = 0;
659   - *LogEnde = MS_LOGICAL_BLOCKS_IN_1ST_SEGMENT;//494
  714 + *LogEnde = MS_LOGICAL_BLOCKS_IN_1ST_SEGMENT;/*494*/
660 715 }
661 716 }
662 717  
663   -//----- MS_LibReadExtraBlock() --------------------------------------------
664   -int MS_LibReadExtraBlock(struct us_data *us, DWORD PhyBlock, BYTE PageNum, BYTE blen, void *buf)
  718 +/*
  719 + * MS_LibReadExtraBlock()
  720 + */
  721 +int MS_LibReadExtraBlock(struct us_data *us, DWORD PhyBlock,
  722 + BYTE PageNum, BYTE blen, void *buf)
665 723 {
666 724 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
667 725 int result;
668 726  
669   - //printk("MS_LibReadExtraBlock --- PhyBlock = %x, PageNum = %x, blen = %x\n", PhyBlock, PageNum, blen);
  727 + /* printk("MS_LibReadExtraBlock --- PhyBlock = %x,
  728 + PageNum = %x, blen = %x\n", PhyBlock, PageNum, blen); */
670 729  
671   - // Read Extra Data
  730 + /* Read Extra Data */
672 731 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
673 732 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
674 733 bcb->DataTransferLength = 0x4 * blen;
675 734  
... ... @@ -688,14 +747,18 @@
688 747 return USB_STOR_TRANSPORT_GOOD;
689 748 }
690 749  
691   -//----- MS_LibReadExtra() --------------------------------------------
692   -int MS_LibReadExtra(struct us_data *us, DWORD PhyBlock, BYTE PageNum, MS_LibTypeExtdat *ExtraDat)
  750 +/*
  751 + * MS_LibReadExtra()
  752 + */
  753 +int MS_LibReadExtra(struct us_data *us, DWORD PhyBlock,
  754 + BYTE PageNum, MS_LibTypeExtdat *ExtraDat)
693 755 {
694 756 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
695 757 int result;
696 758 BYTE ExtBuf[4];
697 759  
698   - //printk("MS_LibReadExtra --- PhyBlock = %x, PageNum = %x\n", PhyBlock, PageNum);
  760 + /* printk("MS_LibReadExtra --- PhyBlock = %x, PageNum = %x\n"
  761 + , PhyBlock, PageNum); */
699 762 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
700 763 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
701 764 bcb->DataTransferLength = 0x4;
702 765  
703 766  
704 767  
... ... @@ -707,23 +770,25 @@
707 770 bcb->CDB[3] = (BYTE)(PhyBlock>>8);
708 771 bcb->CDB[2] = (BYTE)(PhyBlock>>16);
709 772 bcb->CDB[6] = 0x01;
710   -
  773 +
711 774 result = ENE_SendScsiCmd(us, FDIR_READ, &ExtBuf, 0);
712 775 if (result != USB_STOR_XFER_GOOD)
713 776 return USB_STOR_TRANSPORT_ERROR;
714 777  
715 778 ExtraDat->reserved = 0;
716   - ExtraDat->intr = 0x80; // Not yet, waiting for fireware support
717   - ExtraDat->status0 = 0x10; // Not yet, waiting for fireware support
718   - ExtraDat->status1 = 0x00; // Not yet, waiting for fireware support
  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 */
719 782 ExtraDat->ovrflg = ExtBuf[0];
720 783 ExtraDat->mngflg = ExtBuf[1];
721 784 ExtraDat->logadr = MemStickLogAddr(ExtBuf[2], ExtBuf[3]);
722   -
  785 +
723 786 return USB_STOR_TRANSPORT_GOOD;
724 787 }
725 788  
726   -//----- MS_LibSetAcquiredErrorBlock() --------------------------------
  789 +/*
  790 + * MS_LibSetAcquiredErrorBlock()
  791 + */
727 792 int MS_LibSetAcquiredErrorBlock(struct us_data *us, WORD phyblk)
728 793 {
729 794 WORD log;
... ... @@ -731,7 +796,9 @@
731 796 if (phyblk >= us->MS_Lib.NumberOfPhyBlock)
732 797 return (DWORD)-1;
733 798  
734   - if ((log = us->MS_Lib.Phy2LogMap[phyblk]) < us->MS_Lib.NumberOfLogBlock)
  799 + log = us->MS_Lib.Phy2LogMap[phyblk];
  800 +
  801 + if (log < us->MS_Lib.NumberOfLogBlock)
735 802 us->MS_Lib.Log2PhyMap[log] = MS_LB_NOT_USED;
736 803  
737 804 if (us->MS_Lib.Phy2LogMap[phyblk] != MS_LB_INITIAL_ERROR)
... ... @@ -740,7 +807,9 @@
740 807 return 0;
741 808 }
742 809  
743   -//----- MS_LibErasePhyBlock() ----------------------------------------
  810 +/*
  811 + * MS_LibErasePhyBlock()
  812 + */
744 813 int MS_LibErasePhyBlock(struct us_data *us, WORD phyblk)
745 814 {
746 815 WORD log;
747 816  
... ... @@ -748,27 +817,27 @@
748 817 if (phyblk >= us->MS_Lib.NumberOfPhyBlock)
749 818 return MS_STATUS_ERROR;
750 819  
751   - if ((log = us->MS_Lib.Phy2LogMap[phyblk]) < us->MS_Lib.NumberOfLogBlock)
  820 + log = us->MS_Lib.Phy2LogMap[phyblk];
  821 +
  822 + if (log < us->MS_Lib.NumberOfLogBlock)
752 823 us->MS_Lib.Log2PhyMap[log] = MS_LB_NOT_USED;
753 824  
754 825 us->MS_Lib.Phy2LogMap[phyblk] = MS_LB_NOT_USED;
755 826  
756   - if (MS_LibIsWritable(us))
757   - {
758   - switch (MS_ReaderEraseBlock(us, phyblk))
759   - {
760   - case MS_STATUS_SUCCESS:
761   - us->MS_Lib.Phy2LogMap[phyblk] = MS_LB_NOT_USED_ERASED;
762   - return MS_STATUS_SUCCESS;
763   - case MS_ERROR_FLASH_ERASE:
764   - case MS_STATUS_INT_ERROR :
765   - MS_LibErrorPhyBlock(us, phyblk);
766   - return MS_ERROR_FLASH_ERASE;
767   - case MS_STATUS_ERROR:
768   - default:
769   - MS_LibCtrlSet(us, MS_LIB_CTRL_RDONLY);
770   - MS_LibSetAcquiredErrorBlock(us, phyblk);
771   - return MS_STATUS_ERROR;
  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;
772 841 }
773 842 }
774 843  
775 844  
776 845  
777 846  
778 847  
779 848  
780 849  
... ... @@ -777,29 +846,35 @@
777 846 return MS_STATUS_SUCCESS;
778 847 }
779 848  
780   -//----- MS_LibErrorPhyBlock() ----------------------------------------
  849 +/*
  850 + * MS_LibErrorPhyBlock()
  851 + */
781 852 int MS_LibErrorPhyBlock(struct us_data *us, WORD phyblk)
782 853 {
783   - if (phyblk >= us->MS_Lib.NumberOfPhyBlock)
784   - return MS_STATUS_ERROR;
  854 + if (phyblk >= us->MS_Lib.NumberOfPhyBlock)
  855 + return MS_STATUS_ERROR;
785 856  
786   - MS_LibSetAcquiredErrorBlock(us, phyblk);
  857 + MS_LibSetAcquiredErrorBlock(us, phyblk);
787 858  
788   - if (MS_LibIsWritable(us))
789   - return MS_LibOverwriteExtra(us, phyblk, 0,
  859 + if (MS_LibIsWritable(us))
  860 + return MS_LibOverwriteExtra(us, phyblk, 0,
790 861 (BYTE)(~MS_REG_OVR_BKST & BYTE_MASK));
791 862  
792 863  
793   - return MS_STATUS_SUCCESS;
  864 + return MS_STATUS_SUCCESS;
794 865 }
795 866  
796   -//----- MS_LibOverwriteExtra() ---------------------------------------
797   -int MS_LibOverwriteExtra(struct us_data *us, DWORD PhyBlockAddr, BYTE PageNum, BYTE OverwriteFlag)
  867 +/*
  868 + * MS_LibOverwriteExtra()
  869 + */
  870 +int MS_LibOverwriteExtra(struct us_data *us, DWORD PhyBlockAddr,
  871 + BYTE PageNum, BYTE OverwriteFlag)
798 872 {
799 873 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
800 874 int result;
801 875  
802   - //printk("MS --- MS_LibOverwriteExtra, PhyBlockAddr = %x, PageNum = %x\n", PhyBlockAddr, PageNum);
  876 + /* printk("MS --- MS_LibOverwriteExtra, \
  877 + PhyBlockAddr = %x, PageNum = %x\n", PhyBlockAddr, PageNum); */
803 878 result = ENE_LoadBinCode(us, MS_RW_PATTERN);
804 879 if (result != USB_STOR_XFER_GOOD)
805 880 return USB_STOR_TRANSPORT_ERROR;
... ... @@ -818,7 +893,7 @@
818 893 bcb->CDB[7] = 0xFF;
819 894 bcb->CDB[8] = 0xFF;
820 895 bcb->CDB[9] = 0xFF;
821   -
  896 +
822 897 result = ENE_SendScsiCmd(us, FDIR_READ, NULL, 0);
823 898 if (result != USB_STOR_XFER_GOOD)
824 899 return USB_STOR_TRANSPORT_ERROR;
825 900  
... ... @@ -826,13 +901,16 @@
826 901 return USB_STOR_TRANSPORT_GOOD;
827 902 }
828 903  
829   -//----- MS_LibForceSetLogicalPair() ----------------------------------
  904 +/*
  905 + * MS_LibForceSetLogicalPair()
  906 + */
830 907 int MS_LibForceSetLogicalPair(struct us_data *us, WORD logblk, WORD phyblk)
831 908 {
832 909 if (logblk == MS_LB_NOT_USED)
833 910 return 0;
834 911  
835   - if ((logblk >= us->MS_Lib.NumberOfLogBlock) || (phyblk >= us->MS_Lib.NumberOfPhyBlock))
  912 + if ((logblk >= us->MS_Lib.NumberOfLogBlock) ||
  913 + (phyblk >= us->MS_Lib.NumberOfPhyBlock))
836 914 return (DWORD)-1;
837 915  
838 916 us->MS_Lib.Phy2LogMap[phyblk] = logblk;
839 917  
... ... @@ -841,10 +919,13 @@
841 919 return 0;
842 920 }
843 921  
844   -//----- MS_LibSetLogicalPair() ---------------------------------------
  922 +/*
  923 + * MS_LibSetLogicalPair()
  924 + */
845 925 int MS_LibSetLogicalPair(struct us_data *us, WORD logblk, WORD phyblk)
846 926 {
847   - if ((logblk >= us->MS_Lib.NumberOfLogBlock) || (phyblk >= us->MS_Lib.NumberOfPhyBlock))
  927 + if ((logblk >= us->MS_Lib.NumberOfLogBlock) ||
  928 + (phyblk >= us->MS_Lib.NumberOfPhyBlock))
848 929 return (DWORD)-1;
849 930  
850 931 us->MS_Lib.Phy2LogMap[phyblk] = logblk;
851 932  
852 933  
... ... @@ -853,28 +934,30 @@
853 934 return 0;
854 935 }
855 936  
856   -//----- MS_CountFreeBlock() ------------------------------------------
  937 +/*
  938 + * MS_CountFreeBlock()
  939 + */
857 940 int MS_CountFreeBlock(struct us_data *us, WORD PhyBlock)
858 941 {
859 942 DWORD Ende, Count;
860 943  
861 944 Ende = PhyBlock + MS_PHYSICAL_BLOCKS_PER_SEGMENT;
862   - for (Count = 0; PhyBlock < Ende; PhyBlock++)
863   - {
864   - switch (us->MS_Lib.Phy2LogMap[PhyBlock])
865   - {
866   - case MS_LB_NOT_USED:
867   - case MS_LB_NOT_USED_ERASED:
868   - Count++;
869   - default:
870   - break;
  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;
871 952 }
872 953 }
873 954  
874 955 return Count;
875 956 }
876 957  
877   -//----- MS_LibSearchBlockFromPhysical() ------------------------------
  958 +/*
  959 + * MS_LibSearchBlockFromPhysical()
  960 + */
878 961 int MS_LibSearchBlockFromPhysical(struct us_data *us, WORD phyblk)
879 962 {
880 963 WORD Newblk;
881 964  
882 965  
883 966  
884 967  
885 968  
886 969  
887 970  
... ... @@ -884,65 +967,65 @@
884 967 if (phyblk >= us->MS_Lib.NumberOfPhyBlock)
885 968 return MS_LB_ERROR;
886 969  
887   - for (blk = phyblk + 1; blk != phyblk; blk++)
888   - {
  970 + for (blk = phyblk + 1; blk != phyblk; blk++) {
889 971 if ((blk & MS_PHYSICAL_BLOCKS_PER_SEGMENT_MASK) == 0)
890 972 blk -= MS_PHYSICAL_BLOCKS_PER_SEGMENT;
891 973  
892 974 Newblk = us->MS_Lib.Phy2LogMap[blk];
893 975 if (us->MS_Lib.Phy2LogMap[blk] == MS_LB_NOT_USED_ERASED)
894 976 return blk;
895   - else if (us->MS_Lib.Phy2LogMap[blk] == MS_LB_NOT_USED)
896   - {
897   - switch (MS_LibReadExtra(us, blk, 0, &extdat))
898   - {
899   - case MS_STATUS_SUCCESS :
900   - case MS_STATUS_SUCCESS_WITH_ECC:
901   - break;
902   - case MS_NOCARD_ERROR:
903   - return MS_NOCARD_ERROR;
904   - case MS_STATUS_INT_ERROR:
905   - return MS_LB_ERROR;
906   - case MS_ERROR_FLASH_READ:
907   - default:
908   - MS_LibSetAcquiredErrorBlock(us, blk); // MS_LibErrorPhyBlock(fdoExt, blk);
909   - continue;
910   - } // End switch
  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 */
911 992  
912   - if ((extdat.ovrflg & MS_REG_OVR_BKST) != MS_REG_OVR_BKST_OK)
913   - {
  993 + if ((extdat.ovrflg & MS_REG_OVR_BKST) !=
  994 + MS_REG_OVR_BKST_OK) {
914 995 MS_LibSetAcquiredErrorBlock(us, blk);
915 996 continue;
916 997 }
917 998  
918   - switch (MS_LibErasePhyBlock(us, blk))
919   - {
920   - case MS_STATUS_SUCCESS:
921   - return blk;
922   - case MS_STATUS_ERROR:
923   - return MS_LB_ERROR;
924   - case MS_ERROR_FLASH_ERASE:
925   - default:
926   - MS_LibErrorPhyBlock(us, blk);
927   - break;
  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;
928 1008 }
929 1009 }
930   - } // End for
  1010 + } /* End for */
931 1011  
932 1012 return MS_LB_ERROR;
933 1013 }
934 1014  
935   -//----- MS_LibSearchBlockFromLogical() -------------------------------
  1015 +/*
  1016 + * MS_LibSearchBlockFromLogical()
  1017 + */
936 1018 int MS_LibSearchBlockFromLogical(struct us_data *us, WORD logblk)
937 1019 {
938 1020 WORD phyblk;
939 1021  
940   - if ((phyblk=MS_LibConv2Physical(us, logblk)) >= MS_LB_ERROR)
941   - {
  1022 + phyblk = MS_LibConv2Physical(us, logblk);
  1023 + if (phyblk >= MS_LB_ERROR) {
942 1024 if (logblk >= us->MS_Lib.NumberOfLogBlock)
943 1025 return MS_LB_ERROR;
944 1026  
945   - phyblk = (logblk + MS_NUMBER_OF_BOOT_BLOCK) / MS_LOGICAL_BLOCKS_PER_SEGMENT;
  1027 + phyblk = (logblk + MS_NUMBER_OF_BOOT_BLOCK) /
  1028 + MS_LOGICAL_BLOCKS_PER_SEGMENT;
946 1029 phyblk *= MS_PHYSICAL_BLOCKS_PER_SEGMENT;
947 1030 phyblk += MS_PHYSICAL_BLOCKS_PER_SEGMENT - 1;
948 1031 }
drivers/staging/keucr/ms.h
Diff comments   View file @ 333c5ec
... ... @@ -4,41 +4,41 @@
4 4 #include <linux/blkdev.h>
5 5 #include "common.h"
6 6  
7   -// MemoryStick Register
8   -// Status Register 0
9   -#define MS_REG_ST0_MB 0x80 // media busy
10   -#define MS_REG_ST0_FB0 0x40 // flush busy 0
11   -#define MS_REG_ST0_BE 0x20 // buffer empty
12   -#define MS_REG_ST0_BF 0x10 // buffer full
13   -#define MS_REG_ST0_SL 0x02 // sleep
14   -#define MS_REG_ST0_WP 0x01 // write protected
  7 +/* MemoryStick Register */
  8 +/* Status Register 0 */
  9 +#define MS_REG_ST0_MB 0x80 /* media busy */
  10 +#define MS_REG_ST0_FB0 0x40 /* flush busy 0 */
  11 +#define MS_REG_ST0_BE 0x20 /* buffer empty */
  12 +#define MS_REG_ST0_BF 0x10 /* buffer full */
  13 +#define MS_REG_ST0_SL 0x02 /* sleep */
  14 +#define MS_REG_ST0_WP 0x01 /* write protected */
15 15 #define MS_REG_ST0_WP_ON MS_REG_ST0_WP
16 16 #define MS_REG_ST0_WP_OFF 0x00
17 17  
18   -// Status Register 1
19   -#define MS_REG_ST1_MB 0x80 // media busy
20   -#define MS_REG_ST1_FB1 0x40 // flush busy 1
21   -#define MS_REG_ST1_DTER 0x20 // error on data(corrected)
22   -#define MS_REG_ST1_UCDT 0x10 // unable to correct data
23   -#define MS_REG_ST1_EXER 0x08 // error on extra(corrected)
24   -#define MS_REG_ST1_UCEX 0x04 // unable to correct extra
25   -#define MS_REG_ST1_FGER 0x02 // error on overwrite flag(corrected)
26   -#define MS_REG_ST1_UCFG 0x01 // unable to correct overwrite flag
27   -#define MS_REG_ST1_DEFAULT (MS_REG_ST1_MB | MS_REG_ST1_FB1 | \
28   - MS_REG_ST1_DTER | MS_REG_ST1_UCDT | \
29   - MS_REG_ST1_EXER | MS_REG_ST1_UCEX | \
30   - MS_REG_ST1_FGER | MS_REG_ST1_UCFG)
  18 +/* Status Register 1 */
  19 +#define MS_REG_ST1_MB 0x80 /* media busy */
  20 +#define MS_REG_ST1_FB1 0x40 /* flush busy 1 */
  21 +#define MS_REG_ST1_DTER 0x20 /* error on data(corrected) */
  22 +#define MS_REG_ST1_UCDT 0x10 /* unable to correct data */
  23 +#define MS_REG_ST1_EXER 0x08 /* error on extra(corrected) */
  24 +#define MS_REG_ST1_UCEX 0x04 /* unable to correct extra */
  25 +#define MS_REG_ST1_FGER 0x02 /* error on overwrite flag(corrected) */
  26 +#define MS_REG_ST1_UCFG 0x01 /* unable to correct overwrite flag */
  27 +#define MS_REG_ST1_DEFAULT (MS_REG_ST1_MB | MS_REG_ST1_FB1 | \
  28 + MS_REG_ST1_DTER | MS_REG_ST1_UCDT | \
  29 + MS_REG_ST1_EXER | MS_REG_ST1_UCEX | \
  30 + MS_REG_ST1_FGER | MS_REG_ST1_UCFG)
31 31  
32   -// System Parameter
33   -#define MS_REG_SYSPAR_BAMD 0x80 // block address mode
34   -#define MS_REG_SYSPAR_BAND_LINEAR MS_REG_SYSPAR_BAMD // linear mode
35   -#define MS_REG_SYSPAR_BAND_CHIP 0x00 // chip mode
36   -#define MS_REG_SYSPAR_ATEN 0x40 // attribute ROM enable
37   -#define MS_REG_SYSPAR_ATEN_ENABLE MS_REG_SYSPAR_ATEN // enable
38   -#define MS_REG_SYSPAR_ATEN_DISABLE 0x00 // disable
  32 +/* System Parameter */
  33 +#define MS_REG_SYSPAR_BAMD 0x80 /* block address mode */
  34 +#define MS_REG_SYSPAR_BAND_LINEAR MS_REG_SYSPAR_BAMD /* linear mode */
  35 +#define MS_REG_SYSPAR_BAND_CHIP 0x00 /* chip mode */
  36 +#define MS_REG_SYSPAR_ATEN 0x40 /* attribute ROM enable */
  37 +#define MS_REG_SYSPAR_ATEN_ENABLE MS_REG_SYSPAR_ATEN /* enable */
  38 +#define MS_REG_SYSPAR_ATEN_DISABLE 0x00 /* disable */
39 39 #define MS_REG_SYSPAR_RESERVED 0x2f
40 40  
41   -// Command Parameter
  41 +/* Command Parameter */
42 42 #define MS_REG_CMDPAR_CP2 0x80
43 43 #define MS_REG_CMDPAR_CP1 0x40
44 44 #define MS_REG_CMDPAR_CP0 0x20
45 45  
46 46  
47 47  
48 48  
49 49  
... ... @@ -48,44 +48,44 @@
48 48 #define MS_REG_CMDPAR_OVERWRITE MS_REG_CMDPAR_CP2
49 49 #define MS_REG_CMDPAR_RESERVED 0x1f
50 50  
51   -// Overwrite Area
52   -#define MS_REG_OVR_BKST 0x80 // block status
53   -#define MS_REG_OVR_BKST_OK MS_REG_OVR_BKST // OK
54   -#define MS_REG_OVR_BKST_NG 0x00 // NG
55   -#define MS_REG_OVR_PGST0 0x40 // page status
  51 +/* Overwrite Area */
  52 +#define MS_REG_OVR_BKST 0x80 /* block status */
  53 +#define MS_REG_OVR_BKST_OK MS_REG_OVR_BKST /* OK */
  54 +#define MS_REG_OVR_BKST_NG 0x00 /* NG */
  55 +#define MS_REG_OVR_PGST0 0x40 /* page status */
56 56 #define MS_REG_OVR_PGST1 0x20
57   -#define MS_REG_OVR_PGST_MASK (MS_REG_OVR_PGST0 | MS_REG_OVR_PGST1)
58   -#define MS_REG_OVR_PGST_OK (MS_REG_OVR_PGST0 | MS_REG_OVR_PGST1) // OK
59   -#define MS_REG_OVR_PGST_NG MS_REG_OVR_PGST1 // NG
60   -#define MS_REG_OVR_PGST_DATA_ERROR 0x00 // data error
61   -#define MS_REG_OVR_UDST 0x10 // update status
62   -#define MS_REG_OVR_UDST_UPDATING 0x00 // updating
  57 +#define MS_REG_OVR_PGST_MASK (MS_REG_OVR_PGST0 | MS_REG_OVR_PGST1)
  58 +#define MS_REG_OVR_PGST_OK (MS_REG_OVR_PGST0 | MS_REG_OVR_PGST1) /* OK */
  59 +#define MS_REG_OVR_PGST_NG MS_REG_OVR_PGST1 /* NG */
  60 +#define MS_REG_OVR_PGST_DATA_ERROR 0x00 /* data error */
  61 +#define MS_REG_OVR_UDST 0x10 /* update status */
  62 +#define MS_REG_OVR_UDST_UPDATING 0x00 /* updating */
63 63 #define MS_REG_OVR_UDST_NO_UPDATE MS_REG_OVR_UDST
64 64 #define MS_REG_OVR_RESERVED 0x08
65 65 #define MS_REG_OVR_DEFAULT (MS_REG_OVR_BKST_OK | \
66   - MS_REG_OVR_PGST_OK | \
67   - MS_REG_OVR_UDST_NO_UPDATE | \
68   - MS_REG_OVR_RESERVED)
69   -// Management Flag
70   -#define MS_REG_MNG_SCMS0 0x20 // serial copy management system
  66 + MS_REG_OVR_PGST_OK | \
  67 + MS_REG_OVR_UDST_NO_UPDATE | \
  68 + MS_REG_OVR_RESERVED)
  69 +/* Management Flag */
  70 +#define MS_REG_MNG_SCMS0 0x20 /* serial copy management system */
71 71 #define MS_REG_MNG_SCMS1 0x10
72   -#define MS_REG_MNG_SCMS_MASK (MS_REG_MNG_SCMS0 | MS_REG_MNG_SCMS1)
73   -#define MS_REG_MNG_SCMS_COPY_OK (MS_REG_MNG_SCMS0 | MS_REG_MNG_SCMS1)
  72 +#define MS_REG_MNG_SCMS_MASK (MS_REG_MNG_SCMS0 | MS_REG_MNG_SCMS1)
  73 +#define MS_REG_MNG_SCMS_COPY_OK (MS_REG_MNG_SCMS0 | MS_REG_MNG_SCMS1)
74 74 #define MS_REG_MNG_SCMS_ONE_COPY MS_REG_MNG_SCMS1
75 75 #define MS_REG_MNG_SCMS_NO_COPY 0x00
76   -#define MS_REG_MNG_ATFLG 0x08 // address transfer table flag
77   -#define MS_REG_MNG_ATFLG_OTHER MS_REG_MNG_ATFLG // other
78   -#define MS_REG_MNG_ATFLG_ATTBL 0x00 // address transfer table
79   -#define MS_REG_MNG_SYSFLG 0x04 // system flag
80   -#define MS_REG_MNG_SYSFLG_USER MS_REG_MNG_SYSFLG // user block
81   -#define MS_REG_MNG_SYSFLG_BOOT 0x00 // system block
  76 +#define MS_REG_MNG_ATFLG 0x08 /* address transfer table flag */
  77 +#define MS_REG_MNG_ATFLG_OTHER MS_REG_MNG_ATFLG /* other */
  78 +#define MS_REG_MNG_ATFLG_ATTBL 0x00 /* address transfer table */
  79 +#define MS_REG_MNG_SYSFLG 0x04 /* system flag */
  80 +#define MS_REG_MNG_SYSFLG_USER MS_REG_MNG_SYSFLG /* user block */
  81 +#define MS_REG_MNG_SYSFLG_BOOT 0x00 /* system block */
82 82 #define MS_REG_MNG_RESERVED 0xc3
83 83 #define MS_REG_MNG_DEFAULT (MS_REG_MNG_SCMS_COPY_OK | \
84 84 MS_REG_MNG_ATFLG_OTHER | \
85 85 MS_REG_MNG_SYSFLG_USER | \
86 86 MS_REG_MNG_RESERVED)
87 87  
88   -// Error codes
  88 +/* Error codes */
89 89 #define MS_STATUS_SUCCESS 0x0000
90 90 #define MS_ERROR_OUT_OF_SPACE 0x0103
91 91 #define MS_STATUS_WRITE_PROTECT 0x0106
92 92  
93 93  
94 94  
95 95  
... ... @@ -110,29 +110,41 @@
110 110 #define MS_LB_ACQUIRED_ERROR 0xfff4
111 111 #define MS_LB_NOT_USED_ERASED 0xfff5
112 112  
113   -#define MS_LibConv2Physical(pdx, LogBlock) (((LogBlock) >= (pdx)->MS_Lib.NumberOfLogBlock) ? MS_STATUS_ERROR : (pdx)->MS_Lib.Log2PhyMap[LogBlock])
114   -#define MS_LibConv2Logical(pdx, PhyBlock) (((PhyBlock) >= (pdx)->MS_Lib.NumberOfPhyBlock) ? MS_STATUS_ERROR : (pdx)->MS_Lib.Phy2LogMap[PhyBlock]) //ยฌdphy->log table
  113 +#define MS_LibConv2Physical(pdx, LogBlock) \
  114 + (((LogBlock) >= (pdx)->MS_Lib.NumberOfLogBlock) ? \
  115 + MS_STATUS_ERROR : (pdx)->MS_Lib.Log2PhyMap[LogBlock])
  116 +#define MS_LibConv2Logical(pdx, PhyBlock) \
  117 + (((PhyBlock) >= (pdx)->MS_Lib.NumberOfPhyBlock) ? \
  118 + MS_STATUS_ERROR : (pdx)->MS_Lib.Phy2LogMap[PhyBlock])
  119 + /*dphy->log table */
115 120  
116 121 #define MS_LIB_CTRL_RDONLY 0
117 122 #define MS_LIB_CTRL_WRPROTECT 1
118   -#define MS_LibCtrlCheck(pdx, Flag) ((pdx)->MS_Lib.flags & (1 << (Flag)))
  123 +#define MS_LibCtrlCheck(pdx, Flag) ((pdx)->MS_Lib.flags & (1 << (Flag)))
119 124  
120   -#define MS_LibCtrlSet(pdx, Flag) (pdx)->MS_Lib.flags |= (1 << (Flag))
121   -#define MS_LibCtrlReset(pdx, Flag) (pdx)->MS_Lib.flags &= ~(1 << (Flag))
122   -#define MS_LibIsWritable(pdx) ((MS_LibCtrlCheck((pdx), MS_LIB_CTRL_RDONLY) == 0) && (MS_LibCtrlCheck(pdx, MS_LIB_CTRL_WRPROTECT) == 0))
  125 +#define MS_LibCtrlSet(pdx, Flag) ((pdx)->MS_Lib.flags |= (1 << (Flag)))
  126 +#define MS_LibCtrlReset(pdx, Flag) ((pdx)->MS_Lib.flags &= ~(1 << (Flag)))
  127 +#define MS_LibIsWritable(pdx) \
  128 + ((MS_LibCtrlCheck((pdx), MS_LIB_CTRL_RDONLY) == 0) && \
  129 + (MS_LibCtrlCheck(pdx, MS_LIB_CTRL_WRPROTECT) == 0))
123 130  
124 131 #define MS_MAX_PAGES_PER_BLOCK 32
125 132 #define MS_LIB_BITS_PER_BYTE 8
126 133  
127   -#define MS_LibPageMapIdx(n) ((n) / MS_LIB_BITS_PER_BYTE)
128   -#define MS_LibPageMapBit(n) (1 << ((n) % MS_LIB_BITS_PER_BYTE))
129   -#define MS_LibCheckPageMapBit(pdx, n) ((pdx)->MS_Lib.pagemap[MS_LibPageMapIdx(n)] & MS_LibPageMapBit(n))
130   -#define MS_LibSetPageMapBit(pdx, n) ((pdx)->MS_Lib.pagemap[MS_LibPageMapIdx(n)] |= MS_LibPageMapBit(n))
131   -#define MS_LibResetPageMapBit(pdx, n) ((pdx)->MS_Lib.pagemap[MS_LibPageMapIdx(n)] &= ~MS_LibPageMapBit(n))
132   -#define MS_LibClearPageMap(pdx) memset((pdx)->MS_Lib.pagemap, 0, sizeof((pdx)->MS_Lib.pagemap))
  134 +#define MS_LibPageMapIdx(n) ((n) / MS_LIB_BITS_PER_BYTE)
  135 +#define MS_LibPageMapBit(n) (1 << ((n) % MS_LIB_BITS_PER_BYTE))
  136 +#define MS_LibCheckPageMapBit(pdx, n) \
  137 + ((pdx)->MS_Lib.pagemap[MS_LibPageMapIdx(n)] & MS_LibPageMapBit(n))
  138 +#define MS_LibSetPageMapBit(pdx, n) \
  139 + ((pdx)->MS_Lib.pagemap[MS_LibPageMapIdx(n)] |= MS_LibPageMapBit(n))
  140 +#define MS_LibResetPageMapBit(pdx, n) \
  141 + ((pdx)->MS_Lib.pagemap[MS_LibPageMapIdx(n)] &= ~MS_LibPageMapBit(n))
  142 +#define MS_LibClearPageMap(pdx) \
  143 + memset((pdx)->MS_Lib.pagemap, 0, sizeof((pdx)->MS_Lib.pagemap))
133 144  
134 145  
135   -#define MemStickLogAddr(logadr1, logadr0) ((((WORD)(logadr1)) << 8) | (logadr0))
  146 +#define MemStickLogAddr(logadr1, logadr0) \
  147 + ((((WORD)(logadr1)) << 8) | (logadr0))
136 148  
137 149 #define MS_BYTES_PER_PAGE 512
138 150  
... ... @@ -144,7 +156,7 @@
144 156 #define MS_NUMBER_OF_SYSTEM_BLOCK 4
145 157 #define MS_LOGICAL_BLOCKS_PER_SEGMENT 496
146 158 #define MS_LOGICAL_BLOCKS_IN_1ST_SEGMENT 494
147   -#define MS_PHYSICAL_BLOCKS_PER_SEGMENT 0x200 // 512
  159 +#define MS_PHYSICAL_BLOCKS_PER_SEGMENT 0x200 /* 512 */
148 160 #define MS_PHYSICAL_BLOCKS_PER_SEGMENT_MASK 0x1ff
149 161  
150 162 #define MS_SECTOR_SIZE 512
151 163  
152 164  
153 165  
154 166  
155 167  
156 168  
157 169  
158 170  
159 171  
160 172  
... ... @@ -165,51 +177,53 @@
165 177 #define MS_SYSINF_SECURITY 0x01
166 178 #define MS_SYSINF_SECURITY_NO_SUPPORT MS_SYSINF_SECURITY
167 179 #define MS_SYSINF_SECURITY_SUPPORT 0
168   -#define MS_SYSINF_FORMAT_MAT 0 // ?
  180 +#define MS_SYSINF_FORMAT_MAT 0 /* ? */
169 181 #define MS_SYSINF_FORMAT_FAT 1
170 182 #define MS_SYSINF_USAGE_GENERAL 0
171   -#define MS_SYSINF_PAGE_SIZE MS_BYTES_PER_PAGE // fixed
  183 +#define MS_SYSINF_PAGE_SIZE MS_BYTES_PER_PAGE /* fixed */
172 184 #define MS_SYSINF_RESERVED1 1
173 185 #define MS_SYSINF_RESERVED2 1
174 186  
175 187 #define MS_SYSENT_TYPE_INVALID_BLOCK 0x01
176   -#define MS_SYSENT_TYPE_CIS_IDI 0x0a // CIS/IDI
  188 +#define MS_SYSENT_TYPE_CIS_IDI 0x0a /* CIS/IDI */
177 189  
178 190 #define SIZE_OF_KIRO 1024
179 191  
180   -// BOOT BLOCK
  192 +/* BOOT BLOCK */
181 193 #define MS_NUMBER_OF_SYSTEM_ENTRY 4
182 194  
183   -//----- MemStickRegisters --------------------------------------------
184   -// Status registers (16 bytes)
  195 +/*
  196 + * MemStickRegisters
  197 + */
  198 +/* Status registers (16 bytes) */
185 199 typedef struct {
186   - BYTE Reserved0; // 00
187   - BYTE INTRegister; // 01
188   - BYTE StatusRegister0; // 02
189   - BYTE StatusRegister1; // 03
190   - BYTE Reserved1[12]; // 04-0F
  200 + BYTE Reserved0; /* 00 */
  201 + BYTE INTRegister; /* 01 */
  202 + BYTE StatusRegister0; /* 02 */
  203 + BYTE StatusRegister1; /* 03 */
  204 + BYTE Reserved1[12]; /* 04-0F */
191 205 } MemStickStatusRegisters;
192 206  
193   -// Parameter registers (6 bytes)
  207 +/* Parameter registers (6 bytes) */
194 208 typedef struct {
195   - BYTE SystemParameter; // 10
196   - BYTE BlockAddress2; // 11
197   - BYTE BlockAddress1; // 12
198   - BYTE BlockAddress0; // 13
199   - BYTE CMDParameter; // 14
200   - BYTE PageAddress; // 15
  209 + BYTE SystemParameter; /* 10 */
  210 + BYTE BlockAddress2; /* 11 */
  211 + BYTE BlockAddress1; /* 12 */
  212 + BYTE BlockAddress0; /* 13 */
  213 + BYTE CMDParameter; /* 14 */
  214 + BYTE PageAddress; /* 15 */
201 215 } MemStickParameterRegisters;
202 216  
203   -// Extra registers (9 bytes)
  217 +/* Extra registers (9 bytes) */
204 218 typedef struct {
205   - BYTE OverwriteFlag; // 16
206   - BYTE ManagementFlag; // 17
207   - BYTE LogicalAddress1; // 18
208   - BYTE LogicalAddress0; // 19
209   - BYTE ReservedArea[5]; // 1A-1E
  219 + BYTE OverwriteFlag; /* 16 */
  220 + BYTE ManagementFlag; /* 17 */
  221 + BYTE LogicalAddress1; /* 18 */
  222 + BYTE LogicalAddress0; /* 19 */
  223 + BYTE ReservedArea[5]; /* 1A-1E */
210 224 } MemStickExtraDataRegisters;
211 225  
212   -// All registers in Memory Stick (32 bytes, includes 1 byte padding)
  226 +/* All registers in Memory Stick (32 bytes, includes 1 byte padding) */
213 227 typedef struct {
214 228 MemStickStatusRegisters status;
215 229 MemStickParameterRegisters param;
... ... @@ -217,7 +231,9 @@
217 231 BYTE padding;
218 232 } MemStickRegisters, *PMemStickRegisters;
219 233  
220   -//----- MemStickBootBlockPage0 ---------------------------------------
  234 +/*
  235 + * MemStickBootBlockPage0
  236 + */
221 237 typedef struct {
222 238 WORD wBlockID;
223 239 WORD wFormatVersion;
... ... @@ -238,13 +254,13 @@
238 254 } MemStickBootBlockSysEnt;
239 255  
240 256 typedef struct {
241   - BYTE bMsClass; // must be 1
242   - BYTE bCardType; // see below
243   - WORD wBlockSize; // n KB
244   - WORD wBlockNumber; // number of physical block
245   - WORD wTotalBlockNumber; // number of logical block
246   - WORD wPageSize; // must be 0x200
247   - BYTE bExtraSize; // 0x10
  257 + BYTE bMsClass; /* must be 1 */
  258 + BYTE bCardType; /* see below */
  259 + WORD wBlockSize; /* n KB */
  260 + WORD wBlockNumber; /* number of physical block */
  261 + WORD wTotalBlockNumber; /* number of logical block */
  262 + WORD wPageSize; /* must be 0x200 */
  263 + BYTE bExtraSize; /* 0x10 */
248 264 BYTE bSecuritySupport;
249 265 BYTE bAssemblyDate[8];
250 266 BYTE bFactoryArea[4];
... ... @@ -258,10 +274,10 @@
258 274 BYTE bVCC;
259 275 BYTE bVPP;
260 276 WORD wControllerChipNumber;
261   - WORD wControllerFunction; // New MS
262   - BYTE bReserved3[9]; // New MS
263   - BYTE bParallelSupport; // New MS
264   - WORD wFormatValue; // New MS
  277 + WORD wControllerFunction; /* New MS */
  278 + BYTE bReserved3[9]; /* New MS */
  279 + BYTE bParallelSupport; /* New MS */
  280 + WORD wFormatValue; /* New MS */
265 281 BYTE bFormatType;
266 282 BYTE bUsage;
267 283 BYTE bDeviceType;
268 284  
269 285  
... ... @@ -277,60 +293,62 @@
277 293 MemStickBootBlockSysInf sysinf;
278 294 } MemStickBootBlockPage0;
279 295  
280   -//----- MemStickBootBlockCIS_IDI -------------------------------------
  296 +/*
  297 + * MemStickBootBlockCIS_IDI
  298 + */
281 299 typedef struct {
282   - BYTE bCistplDEVICE[6]; // 0
283   - BYTE bCistplDEVICE0C[6]; // 6
284   - BYTE bCistplJEDECC[4]; // 12
285   - BYTE bCistplMANFID[6]; // 16
286   - BYTE bCistplVER1[32]; // 22
287   - BYTE bCistplFUNCID[4]; // 54
288   - BYTE bCistplFUNCE0[4]; // 58
289   - BYTE bCistplFUNCE1[5]; // 62
290   - BYTE bCistplCONF[7]; // 67
291   - BYTE bCistplCFTBLENT0[10]; // 74
292   - BYTE bCistplCFTBLENT1[8]; // 84
293   - BYTE bCistplCFTBLENT2[12]; // 92
294   - BYTE bCistplCFTBLENT3[8]; // 104
295   - BYTE bCistplCFTBLENT4[17]; // 112
296   - BYTE bCistplCFTBLENT5[8]; // 129
297   - BYTE bCistplCFTBLENT6[17]; // 137
298   - BYTE bCistplCFTBLENT7[8]; // 154
299   - BYTE bCistplNOLINK[3]; // 162
  300 + BYTE bCistplDEVICE[6]; /* 0 */
  301 + BYTE bCistplDEVICE0C[6]; /* 6 */
  302 + BYTE bCistplJEDECC[4]; /* 12 */
  303 + BYTE bCistplMANFID[6]; /* 16 */
  304 + BYTE bCistplVER1[32]; /* 22 */
  305 + BYTE bCistplFUNCID[4]; /* 54 */
  306 + BYTE bCistplFUNCE0[4]; /* 58 */
  307 + BYTE bCistplFUNCE1[5]; /* 62 */
  308 + BYTE bCistplCONF[7]; /* 67 */
  309 + BYTE bCistplCFTBLENT0[10]; /* 74 */
  310 + BYTE bCistplCFTBLENT1[8]; /* 84 */
  311 + BYTE bCistplCFTBLENT2[12]; /* 92 */
  312 + BYTE bCistplCFTBLENT3[8]; /* 104 */
  313 + BYTE bCistplCFTBLENT4[17]; /* 112 */
  314 + BYTE bCistplCFTBLENT5[8]; /* 129 */
  315 + BYTE bCistplCFTBLENT6[17]; /* 137 */
  316 + BYTE bCistplCFTBLENT7[8]; /* 154 */
  317 + BYTE bCistplNOLINK[3]; /* 162 */
300 318 } MemStickBootBlockCIS;
301 319  
302 320 typedef struct {
303 321 #define MS_IDI_GENERAL_CONF 0x848A
304   - WORD wIDIgeneralConfiguration; // 0
305   - WORD wIDInumberOfCylinder; // 1
306   - WORD wIDIreserved0; // 2
307   - WORD wIDInumberOfHead; // 3
308   - WORD wIDIbytesPerTrack; // 4
309   - WORD wIDIbytesPerSector; // 5
310   - WORD wIDIsectorsPerTrack; // 6
311   - WORD wIDItotalSectors[2]; // 7-8 high,low
312   - WORD wIDIreserved1[11]; // 9-19
313   - WORD wIDIbufferType; // 20
314   - WORD wIDIbufferSize; // 21
315   - WORD wIDIlongCmdECC; // 22
316   - WORD wIDIfirmVersion[4]; // 23-26
317   - WORD wIDImodelName[20]; // 27-46
318   - WORD wIDIreserved2; // 47
319   - WORD wIDIlongWordSupported; // 48
320   - WORD wIDIdmaSupported; // 49
321   - WORD wIDIreserved3; // 50
322   - WORD wIDIpioTiming; // 51
323   - WORD wIDIdmaTiming; // 52
324   - WORD wIDItransferParameter; // 53
325   - WORD wIDIformattedCylinder; // 54
326   - WORD wIDIformattedHead; // 55
327   - WORD wIDIformattedSectorsPerTrack; // 56
328   - WORD wIDIformattedTotalSectors[2]; // 57-58
329   - WORD wIDImultiSector; // 59
330   - WORD wIDIlbaSectors[2]; // 60-61
331   - WORD wIDIsingleWordDMA; // 62
332   - WORD wIDImultiWordDMA; // 63
333   - WORD wIDIreserved4[192]; // 64-255
  322 + WORD wIDIgeneralConfiguration; /* 0 */
  323 + WORD wIDInumberOfCylinder; /* 1 */
  324 + WORD wIDIreserved0; /* 2 */
  325 + WORD wIDInumberOfHead; /* 3 */
  326 + WORD wIDIbytesPerTrack; /* 4 */
  327 + WORD wIDIbytesPerSector; /* 5 */
  328 + WORD wIDIsectorsPerTrack; /* 6 */
  329 + WORD wIDItotalSectors[2]; /* 7-8 high,low */
  330 + WORD wIDIreserved1[11]; /* 9-19 */
  331 + WORD wIDIbufferType; /* 20 */
  332 + WORD wIDIbufferSize; /* 21 */
  333 + WORD wIDIlongCmdECC; /* 22 */
  334 + WORD wIDIfirmVersion[4]; /* 23-26 */
  335 + WORD wIDImodelName[20]; /* 27-46 */
  336 + WORD wIDIreserved2; /* 47 */
  337 + WORD wIDIlongWordSupported; /* 48 */
  338 + WORD wIDIdmaSupported; /* 49 */
  339 + WORD wIDIreserved3; /* 50 */
  340 + WORD wIDIpioTiming; /* 51 */
  341 + WORD wIDIdmaTiming; /* 52 */
  342 + WORD wIDItransferParameter; /* 53 */
  343 + WORD wIDIformattedCylinder; /* 54 */
  344 + WORD wIDIformattedHead; /* 55 */
  345 + WORD wIDIformattedSectorsPerTrack; /* 56 */
  346 + WORD wIDIformattedTotalSectors[2]; /* 57-58 */
  347 + WORD wIDImultiSector; /* 59 */
  348 + WORD wIDIlbaSectors[2]; /* 60-61 */
  349 + WORD wIDIsingleWordDMA; /* 62 */
  350 + WORD wIDImultiWordDMA; /* 63 */
  351 + WORD wIDIreserved4[192]; /* 64-255 */
334 352 } MemStickBootBlockIDI;
335 353  
336 354 typedef struct {
... ... @@ -346,7 +364,9 @@
346 364  
347 365 } MemStickBootBlockCIS_IDI;
348 366  
349   -//----- MS_LibControl ------------------------------------------------
  367 +/*
  368 + * MS_LibControl
  369 + */
350 370 typedef struct {
351 371 BYTE reserved;
352 372 BYTE intr;
353 373  
... ... @@ -362,14 +382,14 @@
362 382 DWORD BytesPerSector;
363 383 DWORD NumberOfCylinder;
364 384 DWORD SectorsPerCylinder;
365   - WORD cardType; // R/W, RO, Hybrid
  385 + WORD cardType; /* R/W, RO, Hybrid */
366 386 WORD blockSize;
367 387 WORD PagesPerBlock;
368 388 WORD NumberOfPhyBlock;
369 389 WORD NumberOfLogBlock;
370 390 WORD NumberOfSegment;
371   - WORD *Phy2LogMap; // phy2log table
372   - WORD *Log2PhyMap; // log2phy table
  391 + WORD *Phy2LogMap; /* phy2log table */
  392 + WORD *Log2PhyMap; /* log2phy table */
373 393 WORD wrtblk;
374 394 BYTE pagemap[(MS_MAX_PAGES_PER_BLOCK + (MS_LIB_BITS_PER_BYTE-1)) /
375 395 MS_LIB_BITS_PER_BYTE];