[MTD] Remove strange u_int32_t types from FTL

Signed-off-by: David Woodhouse <David.Woodhouse@intel.com>

[MTD] Remove strange u_int32_t types from FTL
Signed-off-by: David Woodhouse <David.Woodhouse@intel.com>
David Woodhouse
1 parent 0f07a0be39
Showing 2 changed files with 69 additions and 69 deletions Side-by-side Diff
drivers/mtd/ftl.c
include/linux/mtd/ftl.h
@@ -109,25 +109,25 @@
 /* Each memory region corresponds to a minor device */
 typedef struct partition_t {
     struct mtd_blktrans_dev mbd;
-    u_int32_t		state;
-    u_int32_t		*VirtualBlockMap;
-    u_int32_t		*VirtualPageMap;
-    u_int32_t		FreeTotal;
+    uint32_t		state;
+    uint32_t		*VirtualBlockMap;
+    uint32_t		*VirtualPageMap;
+    uint32_t		FreeTotal;
     struct eun_info_t {
-	u_int32_t		Offset;
-	u_int32_t		EraseCount;
-	u_int32_t		Free;
-	u_int32_t		Deleted;
+	uint32_t		Offset;
+	uint32_t		EraseCount;
+	uint32_t		Free;
+	uint32_t		Deleted;
     } *EUNInfo;
     struct xfer_info_t {
-	u_int32_t		Offset;
-	u_int32_t		EraseCount;
-	u_int16_t		state;
+	uint32_t		Offset;
+	uint32_t		EraseCount;
+	uint16_t		state;
     } *XferInfo;
-    u_int16_t		bam_index;
-    u_int32_t		*bam_cache;
-    u_int16_t		DataUnits;
-    u_int32_t		BlocksPerUnit;
+    uint16_t		bam_index;
+    uint32_t		*bam_cache;
+    uint16_t		DataUnits;
+    uint32_t		BlocksPerUnit;
     erase_unit_header_t	header;
 } partition_t;
  
@@ -199,8 +199,8 @@
 static int build_maps(partition_t *part)
 {
     erase_unit_header_t header;
-    u_int16_t xvalid, xtrans, i;
-    u_int blocks, j;
+    uint16_t xvalid, xtrans, i;
+    unsigned blocks, j;
     int hdr_ok, ret = -1;
     ssize_t retval;
     loff_t offset;
  
  
@@ -269,14 +269,14 @@
  
     /* Set up virtual page map */
     blocks = le32_to_cpu(header.FormattedSize) >> header.BlockSize;
-    part->VirtualBlockMap = vmalloc(blocks * sizeof(u_int32_t));
+    part->VirtualBlockMap = vmalloc(blocks * sizeof(uint32_t));
     if (!part->VirtualBlockMap)
 	    goto out_XferInfo;
  
-    memset(part->VirtualBlockMap, 0xff, blocks * sizeof(u_int32_t));
+    memset(part->VirtualBlockMap, 0xff, blocks * sizeof(uint32_t));
     part->BlocksPerUnit = (1 << header.EraseUnitSize) >> header.BlockSize;
  
-    part->bam_cache = kmalloc(part->BlocksPerUnit * sizeof(u_int32_t),
+    part->bam_cache = kmalloc(part->BlocksPerUnit * sizeof(uint32_t),
 			      GFP_KERNEL);
     if (!part->bam_cache)
 	    goto out_VirtualBlockMap;
@@ -290,7 +290,7 @@
 	offset = part->EUNInfo[i].Offset + le32_to_cpu(header.BAMOffset);
  
 	ret = part->mbd.mtd->read(part->mbd.mtd, offset,
-			      part->BlocksPerUnit * sizeof(u_int32_t), &retval,
+			      part->BlocksPerUnit * sizeof(uint32_t), &retval,
 			      (unsigned char *)part->bam_cache);
  
 	if (ret)
@@ -332,7 +332,7 @@
 ======================================================================*/
  
 static int erase_xfer(partition_t *part,
-		      u_int16_t xfernum)
+		      uint16_t xfernum)
 {
     int ret;
     struct xfer_info_t *xfer;
@@ -408,7 +408,7 @@
     erase_unit_header_t header;
     struct xfer_info_t *xfer;
     int nbam, ret;
-    u_int32_t ctl;
+    uint32_t ctl;
     ssize_t retlen;
     loff_t offset;
  
  
  
@@ -430,15 +430,15 @@
     }
  
     /* Write the BAM stub */
-    nbam = (part->BlocksPerUnit * sizeof(u_int32_t) +
+    nbam = (part->BlocksPerUnit * sizeof(uint32_t) +
 	    le32_to_cpu(part->header.BAMOffset) + SECTOR_SIZE - 1) / SECTOR_SIZE;
  
     offset = xfer->Offset + le32_to_cpu(part->header.BAMOffset);
     ctl = cpu_to_le32(BLOCK_CONTROL);
  
-    for (i = 0; i < nbam; i++, offset += sizeof(u_int32_t)) {
+    for (i = 0; i < nbam; i++, offset += sizeof(uint32_t)) {
  
-	ret = part->mbd.mtd->write(part->mbd.mtd, offset, sizeof(u_int32_t),
+	ret = part->mbd.mtd->write(part->mbd.mtd, offset, sizeof(uint32_t),
 			       &retlen, (u_char *)&ctl);
  
 	if (ret)
  
  
@@ -461,18 +461,18 @@
  
 ======================================================================*/
  
-static int copy_erase_unit(partition_t *part, u_int16_t srcunit,
-			   u_int16_t xferunit)
+static int copy_erase_unit(partition_t *part, uint16_t srcunit,
+			   uint16_t xferunit)
 {
     u_char buf[SECTOR_SIZE];
     struct eun_info_t *eun;
     struct xfer_info_t *xfer;
-    u_int32_t src, dest, free, i;
-    u_int16_t unit;
+    uint32_t src, dest, free, i;
+    uint16_t unit;
     int ret;
     ssize_t retlen;
     loff_t offset;
-    u_int16_t srcunitswap = cpu_to_le16(srcunit);
+    uint16_t srcunitswap = cpu_to_le16(srcunit);
  
     eun = &part->EUNInfo[srcunit];
     xfer = &part->XferInfo[xferunit];
@@ -486,7 +486,7 @@
 	offset = eun->Offset + le32_to_cpu(part->header.BAMOffset);
  
 	ret = part->mbd.mtd->read(part->mbd.mtd, offset,
-			      part->BlocksPerUnit * sizeof(u_int32_t),
+			      part->BlocksPerUnit * sizeof(uint32_t),
 			      &retlen, (u_char *) (part->bam_cache));
  
 	/* mark the cache bad, in case we get an error later */
@@ -503,7 +503,7 @@
     offset = xfer->Offset + 20; /* Bad! */
     unit = cpu_to_le16(0x7fff);
  
-    ret = part->mbd.mtd->write(part->mbd.mtd, offset, sizeof(u_int16_t),
+    ret = part->mbd.mtd->write(part->mbd.mtd, offset, sizeof(uint16_t),
 			   &retlen, (u_char *) &unit);
  
     if (ret) {
@@ -560,7 +560,7 @@
  
  
     /* All clear? Then update the LogicalEUN again */
-    ret = part->mbd.mtd->write(part->mbd.mtd, xfer->Offset + 20, sizeof(u_int16_t),
+    ret = part->mbd.mtd->write(part->mbd.mtd, xfer->Offset + 20, sizeof(uint16_t),
 			   &retlen, (u_char *)&srcunitswap);
  
     if (ret) {
@@ -605,8 +605,8 @@
  
 static int reclaim_block(partition_t *part)
 {
-    u_int16_t i, eun, xfer;
-    u_int32_t best;
+    uint16_t i, eun, xfer;
+    uint32_t best;
     int queued, ret;
  
     DEBUG(0, "ftl_cs: reclaiming space...\n");
  
@@ -723,10 +723,10 @@
 }
 #endif
  
-static u_int32_t find_free(partition_t *part)
+static uint32_t find_free(partition_t *part)
 {
-    u_int16_t stop, eun;
-    u_int32_t blk;
+    uint16_t stop, eun;
+    uint32_t blk;
     size_t retlen;
     int ret;
  
@@ -749,7 +749,7 @@
  
 	ret = part->mbd.mtd->read(part->mbd.mtd,
 		       part->EUNInfo[eun].Offset + le32_to_cpu(part->header.BAMOffset),
-		       part->BlocksPerUnit * sizeof(u_int32_t),
+		       part->BlocksPerUnit * sizeof(uint32_t),
 		       &retlen, (u_char *) (part->bam_cache));
  
 	if (ret) {
@@ -786,7 +786,7 @@
 static int ftl_read(partition_t *part, caddr_t buffer,
 		    u_long sector, u_long nblocks)
 {
-    u_int32_t log_addr, bsize;
+    uint32_t log_addr, bsize;
     u_long i;
     int ret;
     size_t offset, retlen;
  
  
  
@@ -829,14 +829,14 @@
  
 ======================================================================*/
  
-static int set_bam_entry(partition_t *part, u_int32_t log_addr,
-			 u_int32_t virt_addr)
+static int set_bam_entry(partition_t *part, uint32_t log_addr,
+			 uint32_t virt_addr)
 {
-    u_int32_t bsize, blk, le_virt_addr;
+    uint32_t bsize, blk, le_virt_addr;
 #ifdef PSYCHO_DEBUG
-    u_int32_t old_addr;
+    uint32_t old_addr;
 #endif
-    u_int16_t eun;
+    uint16_t eun;
     int ret;
     size_t retlen, offset;
  
  
@@ -845,11 +845,11 @@
     bsize = 1 << part->header.EraseUnitSize;
     eun = log_addr / bsize;
     blk = (log_addr % bsize) / SECTOR_SIZE;
-    offset = (part->EUNInfo[eun].Offset + blk * sizeof(u_int32_t) +
+    offset = (part->EUNInfo[eun].Offset + blk * sizeof(uint32_t) +
 		  le32_to_cpu(part->header.BAMOffset));
  
 #ifdef PSYCHO_DEBUG
-    ret = part->mbd.mtd->read(part->mbd.mtd, offset, sizeof(u_int32_t),
+    ret = part->mbd.mtd->read(part->mbd.mtd, offset, sizeof(uint32_t),
                         &retlen, (u_char *)&old_addr);
     if (ret) {
 	printk(KERN_WARNING"ftl: Error reading old_addr in set_bam_entry: %d\n",ret);
@@ -886,7 +886,7 @@
 #endif
 	part->bam_cache[blk] = le_virt_addr;
     }
-    ret = part->mbd.mtd->write(part->mbd.mtd, offset, sizeof(u_int32_t),
+    ret = part->mbd.mtd->write(part->mbd.mtd, offset, sizeof(uint32_t),
                             &retlen, (u_char *)&le_virt_addr);
  
     if (ret) {
@@ -900,7 +900,7 @@
 static int ftl_write(partition_t *part, caddr_t buffer,
 		     u_long sector, u_long nblocks)
 {
-    u_int32_t bsize, log_addr, virt_addr, old_addr, blk;
+    uint32_t bsize, log_addr, virt_addr, old_addr, blk;
     u_long i;
     int ret;
     size_t retlen, offset;
@@ -32,25 +32,25 @@
 #define _LINUX_FTL_H
  
 typedef struct erase_unit_header_t {
-    u_int8_t	LinkTargetTuple[5];
-    u_int8_t	DataOrgTuple[10];
-    u_int8_t	NumTransferUnits;
-    u_int32_t	EraseCount;
-    u_int16_t	LogicalEUN;
-    u_int8_t	BlockSize;
-    u_int8_t	EraseUnitSize;
-    u_int16_t	FirstPhysicalEUN;
-    u_int16_t	NumEraseUnits;
-    u_int32_t	FormattedSize;
-    u_int32_t	FirstVMAddress;
-    u_int16_t	NumVMPages;
-    u_int8_t	Flags;
-    u_int8_t	Code;
-    u_int32_t	SerialNumber;
-    u_int32_t	AltEUHOffset;
-    u_int32_t	BAMOffset;
-    u_int8_t	Reserved[12];
-    u_int8_t	EndTuple[2];
+    uint8_t	LinkTargetTuple[5];
+    uint8_t	DataOrgTuple[10];
+    uint8_t	NumTransferUnits;
+    uint32_t	EraseCount;
+    uint16_t	LogicalEUN;
+    uint8_t	BlockSize;
+    uint8_t	EraseUnitSize;
+    uint16_t	FirstPhysicalEUN;
+    uint16_t	NumEraseUnits;
+    uint32_t	FormattedSize;
+    uint32_t	FirstVMAddress;
+    uint16_t	NumVMPages;
+    uint8_t	Flags;
+    uint8_t	Code;
+    uint32_t	SerialNumber;
+    uint32_t	AltEUHOffset;
+    uint32_t	BAMOffset;
+    uint8_t	Reserved[12];
+    uint8_t	EndTuple[2];
 } erase_unit_header_t;
  
 /* Flags in erase_unit_header_t */
...	...	@@ -109,25 +109,25 @@
109	109	/* Each memory region corresponds to a minor device */
110	110	typedef struct partition_t {
111	111	struct mtd_blktrans_dev mbd;
112		- u_int32_t state;
113		- u_int32_t *VirtualBlockMap;
114		- u_int32_t *VirtualPageMap;
115		- u_int32_t FreeTotal;
	112	+ uint32_t state;
	113	+ uint32_t *VirtualBlockMap;
	114	+ uint32_t *VirtualPageMap;
	115	+ uint32_t FreeTotal;
116	116	struct eun_info_t {
117		- u_int32_t Offset;
118		- u_int32_t EraseCount;
119		- u_int32_t Free;
120		- u_int32_t Deleted;
	117	+ uint32_t Offset;
	118	+ uint32_t EraseCount;
	119	+ uint32_t Free;
	120	+ uint32_t Deleted;
121	121	} *EUNInfo;
122	122	struct xfer_info_t {
123		- u_int32_t Offset;
124		- u_int32_t EraseCount;
125		- u_int16_t state;
	123	+ uint32_t Offset;
	124	+ uint32_t EraseCount;
	125	+ uint16_t state;
126	126	} *XferInfo;
127		- u_int16_t bam_index;
128		- u_int32_t *bam_cache;
129		- u_int16_t DataUnits;
130		- u_int32_t BlocksPerUnit;
	127	+ uint16_t bam_index;
	128	+ uint32_t *bam_cache;
	129	+ uint16_t DataUnits;
	130	+ uint32_t BlocksPerUnit;
131	131	erase_unit_header_t header;
132	132	} partition_t;
133	133
...	...	@@ -199,8 +199,8 @@
199	199	static int build_maps(partition_t *part)
200	200	{
201	201	erase_unit_header_t header;
202		- u_int16_t xvalid, xtrans, i;
203		- u_int blocks, j;
	202	+ uint16_t xvalid, xtrans, i;
	203	+ unsigned blocks, j;
204	204	int hdr_ok, ret = -1;
205	205	ssize_t retval;
206	206	loff_t offset;
207	207
208	208
...	...	@@ -269,14 +269,14 @@
269	269
270	270	/* Set up virtual page map */
271	271	blocks = le32_to_cpu(header.FormattedSize) >> header.BlockSize;
272		- part->VirtualBlockMap = vmalloc(blocks * sizeof(u_int32_t));
	272	+ part->VirtualBlockMap = vmalloc(blocks * sizeof(uint32_t));
273	273	if (!part->VirtualBlockMap)
274	274	goto out_XferInfo;
275	275
276		- memset(part->VirtualBlockMap, 0xff, blocks * sizeof(u_int32_t));
	276	+ memset(part->VirtualBlockMap, 0xff, blocks * sizeof(uint32_t));
277	277	part->BlocksPerUnit = (1 << header.EraseUnitSize) >> header.BlockSize;
278	278
279		- part->bam_cache = kmalloc(part->BlocksPerUnit * sizeof(u_int32_t),
	279	+ part->bam_cache = kmalloc(part->BlocksPerUnit * sizeof(uint32_t),
280	280	GFP_KERNEL);
281	281	if (!part->bam_cache)
282	282	goto out_VirtualBlockMap;
...	...	@@ -290,7 +290,7 @@
290	290	offset = part->EUNInfo[i].Offset + le32_to_cpu(header.BAMOffset);
291	291
292	292	ret = part->mbd.mtd->read(part->mbd.mtd, offset,
293		- part->BlocksPerUnit * sizeof(u_int32_t), &retval,
	293	+ part->BlocksPerUnit * sizeof(uint32_t), &retval,
294	294	(unsigned char *)part->bam_cache);
295	295
296	296	if (ret)
...	...	@@ -332,7 +332,7 @@
332	332	======================================================================*/
333	333
334	334	static int erase_xfer(partition_t *part,
335		- u_int16_t xfernum)
	335	+ uint16_t xfernum)
336	336	{
337	337	int ret;
338	338	struct xfer_info_t *xfer;
...	...	@@ -408,7 +408,7 @@
408	408	erase_unit_header_t header;
409	409	struct xfer_info_t *xfer;
410	410	int nbam, ret;
411		- u_int32_t ctl;
	411	+ uint32_t ctl;
412	412	ssize_t retlen;
413	413	loff_t offset;
414	414
415	415
416	416
...	...	@@ -430,15 +430,15 @@
430	430	}
431	431
432	432	/* Write the BAM stub */
433		- nbam = (part->BlocksPerUnit * sizeof(u_int32_t) +
	433	+ nbam = (part->BlocksPerUnit * sizeof(uint32_t) +
434	434	le32_to_cpu(part->header.BAMOffset) + SECTOR_SIZE - 1) / SECTOR_SIZE;
435	435
436	436	offset = xfer->Offset + le32_to_cpu(part->header.BAMOffset);
437	437	ctl = cpu_to_le32(BLOCK_CONTROL);
438	438
439		- for (i = 0; i < nbam; i++, offset += sizeof(u_int32_t)) {
	439	+ for (i = 0; i < nbam; i++, offset += sizeof(uint32_t)) {
440	440
441		- ret = part->mbd.mtd->write(part->mbd.mtd, offset, sizeof(u_int32_t),
	441	+ ret = part->mbd.mtd->write(part->mbd.mtd, offset, sizeof(uint32_t),
442	442	&retlen, (u_char *)&ctl);
443	443
444	444	if (ret)
445	445
446	446
...	...	@@ -461,18 +461,18 @@
461	461
462	462	======================================================================*/
463	463
464		-static int copy_erase_unit(partition_t *part, u_int16_t srcunit,
465		- u_int16_t xferunit)
	464	+static int copy_erase_unit(partition_t *part, uint16_t srcunit,
	465	+ uint16_t xferunit)
466	466	{
467	467	u_char buf[SECTOR_SIZE];
468	468	struct eun_info_t *eun;
469	469	struct xfer_info_t *xfer;
470		- u_int32_t src, dest, free, i;
471		- u_int16_t unit;
	470	+ uint32_t src, dest, free, i;
	471	+ uint16_t unit;
472	472	int ret;
473	473	ssize_t retlen;
474	474	loff_t offset;
475		- u_int16_t srcunitswap = cpu_to_le16(srcunit);
	475	+ uint16_t srcunitswap = cpu_to_le16(srcunit);
476	476
477	477	eun = &part->EUNInfo[srcunit];
478	478	xfer = &part->XferInfo[xferunit];
...	...	@@ -486,7 +486,7 @@
486	486	offset = eun->Offset + le32_to_cpu(part->header.BAMOffset);
487	487
488	488	ret = part->mbd.mtd->read(part->mbd.mtd, offset,
489		- part->BlocksPerUnit * sizeof(u_int32_t),
	489	+ part->BlocksPerUnit * sizeof(uint32_t),
490	490	&retlen, (u_char *) (part->bam_cache));
491	491
492	492	/* mark the cache bad, in case we get an error later */
...	...	@@ -503,7 +503,7 @@
503	503	offset = xfer->Offset + 20; /* Bad! */
504	504	unit = cpu_to_le16(0x7fff);
505	505
506		- ret = part->mbd.mtd->write(part->mbd.mtd, offset, sizeof(u_int16_t),
	506	+ ret = part->mbd.mtd->write(part->mbd.mtd, offset, sizeof(uint16_t),
507	507	&retlen, (u_char *) &unit);
508	508
509	509	if (ret) {
...	...	@@ -560,7 +560,7 @@
560	560
561	561
562	562	/* All clear? Then update the LogicalEUN again */
563		- ret = part->mbd.mtd->write(part->mbd.mtd, xfer->Offset + 20, sizeof(u_int16_t),
	563	+ ret = part->mbd.mtd->write(part->mbd.mtd, xfer->Offset + 20, sizeof(uint16_t),
564	564	&retlen, (u_char *)&srcunitswap);
565	565
566	566	if (ret) {
...	...	@@ -605,8 +605,8 @@
605	605
606	606	static int reclaim_block(partition_t *part)
607	607	{
608		- u_int16_t i, eun, xfer;
609		- u_int32_t best;
	608	+ uint16_t i, eun, xfer;
	609	+ uint32_t best;
610	610	int queued, ret;
611	611
612	612	DEBUG(0, "ftl_cs: reclaiming space...\n");
613	613
...	...	@@ -723,10 +723,10 @@
723	723	}
724	724	#endif
725	725
726		-static u_int32_t find_free(partition_t *part)
	726	+static uint32_t find_free(partition_t *part)
727	727	{
728		- u_int16_t stop, eun;
729		- u_int32_t blk;
	728	+ uint16_t stop, eun;
	729	+ uint32_t blk;
730	730	size_t retlen;
731	731	int ret;
732	732
...	...	@@ -749,7 +749,7 @@
749	749
750	750	ret = part->mbd.mtd->read(part->mbd.mtd,
751	751	part->EUNInfo[eun].Offset + le32_to_cpu(part->header.BAMOffset),
752		- part->BlocksPerUnit * sizeof(u_int32_t),
	752	+ part->BlocksPerUnit * sizeof(uint32_t),
753	753	&retlen, (u_char *) (part->bam_cache));
754	754
755	755	if (ret) {
...	...	@@ -786,7 +786,7 @@
786	786	static int ftl_read(partition_t *part, caddr_t buffer,
787	787	u_long sector, u_long nblocks)
788	788	{
789		- u_int32_t log_addr, bsize;
	789	+ uint32_t log_addr, bsize;
790	790	u_long i;
791	791	int ret;
792	792	size_t offset, retlen;
793	793
794	794
795	795
...	...	@@ -829,14 +829,14 @@
829	829
830	830	======================================================================*/
831	831
832		-static int set_bam_entry(partition_t *part, u_int32_t log_addr,
833		- u_int32_t virt_addr)
	832	+static int set_bam_entry(partition_t *part, uint32_t log_addr,
	833	+ uint32_t virt_addr)
834	834	{
835		- u_int32_t bsize, blk, le_virt_addr;
	835	+ uint32_t bsize, blk, le_virt_addr;
836	836	#ifdef PSYCHO_DEBUG
837		- u_int32_t old_addr;
	837	+ uint32_t old_addr;
838	838	#endif
839		- u_int16_t eun;
	839	+ uint16_t eun;
840	840	int ret;
841	841	size_t retlen, offset;
842	842
843	843
...	...	@@ -845,11 +845,11 @@
845	845	bsize = 1 << part->header.EraseUnitSize;
846	846	eun = log_addr / bsize;
847	847	blk = (log_addr % bsize) / SECTOR_SIZE;
848		- offset = (part->EUNInfo[eun].Offset + blk * sizeof(u_int32_t) +
	848	+ offset = (part->EUNInfo[eun].Offset + blk * sizeof(uint32_t) +
849	849	le32_to_cpu(part->header.BAMOffset));
850	850
851	851	#ifdef PSYCHO_DEBUG
852		- ret = part->mbd.mtd->read(part->mbd.mtd, offset, sizeof(u_int32_t),
	852	+ ret = part->mbd.mtd->read(part->mbd.mtd, offset, sizeof(uint32_t),
853	853	&retlen, (u_char *)&old_addr);
854	854	if (ret) {
855	855	printk(KERN_WARNING"ftl: Error reading old_addr in set_bam_entry: %d\n",ret);
...	...	@@ -886,7 +886,7 @@
886	886	#endif
887	887	part->bam_cache[blk] = le_virt_addr;
888	888	}
889		- ret = part->mbd.mtd->write(part->mbd.mtd, offset, sizeof(u_int32_t),
	889	+ ret = part->mbd.mtd->write(part->mbd.mtd, offset, sizeof(uint32_t),
890	890	&retlen, (u_char *)&le_virt_addr);
891	891
892	892	if (ret) {
...	...	@@ -900,7 +900,7 @@
900	900	static int ftl_write(partition_t *part, caddr_t buffer,
901	901	u_long sector, u_long nblocks)
902	902	{
903		- u_int32_t bsize, log_addr, virt_addr, old_addr, blk;
	903	+ uint32_t bsize, log_addr, virt_addr, old_addr, blk;
904	904	u_long i;
905	905	int ret;
906	906	size_t retlen, offset;
...	...	@@ -32,25 +32,25 @@
32	32	#define _LINUX_FTL_H
33	33
34	34	typedef struct erase_unit_header_t {
35		- u_int8_t LinkTargetTuple[5];
36		- u_int8_t DataOrgTuple[10];
37		- u_int8_t NumTransferUnits;
38		- u_int32_t EraseCount;
39		- u_int16_t LogicalEUN;
40		- u_int8_t BlockSize;
41		- u_int8_t EraseUnitSize;
42		- u_int16_t FirstPhysicalEUN;
43		- u_int16_t NumEraseUnits;
44		- u_int32_t FormattedSize;
45		- u_int32_t FirstVMAddress;
46		- u_int16_t NumVMPages;
47		- u_int8_t Flags;
48		- u_int8_t Code;
49		- u_int32_t SerialNumber;
50		- u_int32_t AltEUHOffset;
51		- u_int32_t BAMOffset;
52		- u_int8_t Reserved[12];
53		- u_int8_t EndTuple[2];
	35	+ uint8_t LinkTargetTuple[5];
	36	+ uint8_t DataOrgTuple[10];
	37	+ uint8_t NumTransferUnits;
	38	+ uint32_t EraseCount;
	39	+ uint16_t LogicalEUN;
	40	+ uint8_t BlockSize;
	41	+ uint8_t EraseUnitSize;
	42	+ uint16_t FirstPhysicalEUN;
	43	+ uint16_t NumEraseUnits;
	44	+ uint32_t FormattedSize;
	45	+ uint32_t FirstVMAddress;
	46	+ uint16_t NumVMPages;
	47	+ uint8_t Flags;
	48	+ uint8_t Code;
	49	+ uint32_t SerialNumber;
	50	+ uint32_t AltEUHOffset;
	51	+ uint32_t BAMOffset;
	52	+ uint8_t Reserved[12];
	53	+ uint8_t EndTuple[2];
54	54	} erase_unit_header_t;
55	55
56	56	/* Flags in erase_unit_header_t */