2 * Linux driver for SSFDC Flash Translation Layer (Read only)
4 * Author: Claudio Lanconelli <lanconelli.claudio@eptar.com>
6 * Based on NTFL and MTDBLOCK_RO drivers
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation.
13 #include <linux/config.h>
14 #include <linux/kernel.h>
15 #include <linux/module.h>
16 #include <linux/init.h>
17 #include <linux/slab.h>
18 #include <linux/hdreg.h>
19 #include <linux/mtd/mtd.h>
20 #include <linux/mtd/nand.h>
21 #include <linux/mtd/blktrans.h>
23 struct ssfdcr_record
{
24 struct mtd_blktrans_dev mbd
;
27 unsigned char sectors
;
28 unsigned short cylinders
;
29 int cis_block
; /* block n. containing CIS/IDI */
30 int erase_size
; /* phys_block_size */
31 unsigned short *logic_block_map
; /* all zones (max 8192 phys blocks on
33 int map_len
; /* n. phys_blocks on the card */
36 #define SSFDCR_MAJOR 257
37 #define SSFDCR_PARTN_BITS 3
39 #define SECTOR_SIZE 512
40 #define SECTOR_SHIFT 9
43 #define MAX_LOGIC_BLK_PER_ZONE 1000
44 #define MAX_PHYS_BLK_PER_ZONE 1024
46 #define KB(x) ( (x) * 1024L )
47 #define MB(x) ( KB(x) * 1024L )
50 1MB 2MB 4MB 8MB 16MB 32MB 64MB 128MB
51 NCylinder 125 125 250 250 500 500 500 500
52 NHead 4 4 4 4 4 8 8 16
53 NSector 4 8 8 16 16 16 32 32
54 SumSector 2,000 4,000 8,000 16,000 32,000 64,000 128,000 256,000
55 SectorSize 512 512 512 512 512 512 512 512
65 /* Must be ordered by size */
66 static const chs_entry_t chs_table
[] = {
67 { MB( 1), 125, 4, 4 },
68 { MB( 2), 125, 4, 8 },
69 { MB( 4), 250, 4, 8 },
70 { MB( 8), 250, 4, 16 },
71 { MB( 16), 500, 4, 16 },
72 { MB( 32), 500, 8, 16 },
73 { MB( 64), 500, 8, 32 },
74 { MB(128), 500, 16, 32 },
78 static int get_chs(unsigned long size
, unsigned short *cyl
, unsigned char *head
,
85 while (chs_table
[k
].size
> 0 && size
> chs_table
[k
].size
)
88 if (chs_table
[k
].size
> 0) {
90 *cyl
= chs_table
[k
].cyl
;
92 *head
= chs_table
[k
].head
;
94 *sec
= chs_table
[k
].sec
;
101 /* These bytes are the signature for the CIS/IDI sector */
102 static const uint8_t cis_numbers
[] = {
103 0x01, 0x03, 0xD9, 0x01, 0xFF, 0x18, 0x02, 0xDF, 0x01, 0x20
106 /* Read and check for a valid CIS sector */
107 static int get_valid_cis_sector(struct mtd_info
*mtd
)
109 int ret
, k
, cis_sector
;
112 uint8_t sect_buf
[SECTOR_SIZE
];
115 * Look for CIS/IDI sector on the first GOOD block (give up after 4 bad
116 * blocks). If the first good block doesn't contain CIS number the flash
117 * is not SSFDC formatted
120 for (k
= 0, offset
= 0; k
< 4; k
++, offset
+= mtd
->erasesize
) {
121 if (!mtd
->block_isbad(mtd
, offset
)) {
122 ret
= mtd
->read(mtd
, offset
, SECTOR_SIZE
, &retlen
,
125 /* CIS pattern match on the sector buffer */
126 if ( ret
< 0 || retlen
!= SECTOR_SIZE
) {
128 "SSFDC_RO:can't read CIS/IDI sector\n");
129 } else if ( !memcmp(sect_buf
, cis_numbers
,
130 sizeof(cis_numbers
)) ) {
132 cis_sector
= (int)(offset
>> SECTOR_SHIFT
);
134 DEBUG(MTD_DEBUG_LEVEL1
,
135 "SSFDC_RO: CIS/IDI sector not found"
136 " on %s (mtd%d)\n", mtd
->name
,
146 /* Read physical sector (wrapper to MTD_READ) */
147 static int read_physical_sector(struct mtd_info
*mtd
, uint8_t *sect_buf
,
152 loff_t offset
= (loff_t
)sect_no
<< SECTOR_SHIFT
;
154 ret
= mtd
->read(mtd
, offset
, SECTOR_SIZE
, &retlen
, sect_buf
);
155 if (ret
< 0 || retlen
!= SECTOR_SIZE
)
161 /* Read redundancy area (wrapper to MTD_READ_OOB */
162 static int read_raw_oob(struct mtd_info
*mtd
, loff_t offs
, uint8_t *buf
)
164 struct mtd_oob_ops ops
;
167 ops
.mode
= MTD_OOB_RAW
;
169 ops
.ooblen
= mtd
->oobsize
;
174 ret
= mtd
->read_oob(mtd
, offs
, &ops
);
175 if (ret
< 0 || ops
.retlen
!= OOB_SIZE
)
181 /* Parity calculator on a word of n bit size */
182 static int get_parity(int number
, int size
)
188 for (k
= 0; k
< size
; k
++) {
189 parity
+= (number
>> k
);
195 /* Read and validate the logical block address field stored in the OOB */
196 static int get_logical_address(uint8_t *oob_buf
)
198 int block_address
, parity
;
199 int offset
[2] = {6, 11}; /* offset of the 2 address fields within OOB */
204 * Look for the first valid logical address
205 * Valid address has fixed pattern on most significant bits and
208 for (j
= 0; j
< ARRAY_SIZE(offset
); j
++) {
209 block_address
= ((int)oob_buf
[offset
[j
]] << 8) |
210 oob_buf
[offset
[j
]+1];
212 /* Check for the signature bits in the address field (MSBits) */
213 if ((block_address
& ~0x7FF) == 0x1000) {
214 parity
= block_address
& 0x01;
215 block_address
&= 0x7FF;
218 if (get_parity(block_address
, 10) != parity
) {
219 DEBUG(MTD_DEBUG_LEVEL0
,
220 "SSFDC_RO: logical address field%d"
221 "parity error(0x%04X)\n", j
+1,
233 DEBUG(MTD_DEBUG_LEVEL3
, "SSFDC_RO: get_logical_address() %d\n",
236 return block_address
;
239 /* Build the logic block map */
240 static int build_logical_block_map(struct ssfdcr_record
*ssfdc
)
242 unsigned long offset
;
243 uint8_t oob_buf
[OOB_SIZE
];
244 int ret
, block_address
, phys_block
;
245 struct mtd_info
*mtd
= ssfdc
->mbd
.mtd
;
247 DEBUG(MTD_DEBUG_LEVEL1
, "SSFDC_RO: build_block_map() nblks=%d (%luK)\n",
248 ssfdc
->map_len
, (unsigned long)ssfdc
->map_len
*
249 ssfdc
->erase_size
/ 1024 );
251 /* Scan every physical block, skip CIS block */
252 for (phys_block
= ssfdc
->cis_block
+ 1; phys_block
< ssfdc
->map_len
;
254 offset
= (unsigned long)phys_block
* ssfdc
->erase_size
;
255 if (mtd
->block_isbad(mtd
, offset
))
256 continue; /* skip bad blocks */
258 ret
= read_raw_oob(mtd
, offset
, oob_buf
);
260 DEBUG(MTD_DEBUG_LEVEL0
,
261 "SSFDC_RO: mtd read_oob() failed at %lu\n",
265 block_address
= get_logical_address(oob_buf
);
267 /* Skip invalid addresses */
268 if (block_address
>= 0 &&
269 block_address
< MAX_LOGIC_BLK_PER_ZONE
) {
272 zone_index
= phys_block
/ MAX_PHYS_BLK_PER_ZONE
;
273 block_address
+= zone_index
* MAX_LOGIC_BLK_PER_ZONE
;
274 ssfdc
->logic_block_map
[block_address
] =
275 (unsigned short)phys_block
;
277 DEBUG(MTD_DEBUG_LEVEL2
,
278 "SSFDC_RO: build_block_map() phys_block=%d,"
279 "logic_block_addr=%d, zone=%d\n",
280 phys_block
, block_address
, zone_index
);
286 static void ssfdcr_add_mtd(struct mtd_blktrans_ops
*tr
, struct mtd_info
*mtd
)
288 struct ssfdcr_record
*ssfdc
;
291 /* Check for small page NAND flash */
292 if (mtd
->type
!= MTD_NANDFLASH
|| mtd
->oobsize
!= OOB_SIZE
)
295 /* Check for SSDFC format by reading CIS/IDI sector */
296 cis_sector
= get_valid_cis_sector(mtd
);
297 if (cis_sector
== -1)
300 ssfdc
= kzalloc(sizeof(struct ssfdcr_record
), GFP_KERNEL
);
303 "SSFDC_RO: out of memory for data structures\n");
307 ssfdc
->mbd
.mtd
= mtd
;
308 ssfdc
->mbd
.devnum
= -1;
309 ssfdc
->mbd
.blksize
= SECTOR_SIZE
;
311 ssfdc
->mbd
.readonly
= 1;
313 ssfdc
->cis_block
= cis_sector
/ (mtd
->erasesize
>> SECTOR_SHIFT
);
314 ssfdc
->erase_size
= mtd
->erasesize
;
315 ssfdc
->map_len
= mtd
->size
/ mtd
->erasesize
;
317 DEBUG(MTD_DEBUG_LEVEL1
,
318 "SSFDC_RO: cis_block=%d,erase_size=%d,map_len=%d,n_zones=%d\n",
319 ssfdc
->cis_block
, ssfdc
->erase_size
, ssfdc
->map_len
,
320 (ssfdc
->map_len
+ MAX_PHYS_BLK_PER_ZONE
- 1) /
321 MAX_PHYS_BLK_PER_ZONE
);
326 get_chs( mtd
->size
, NULL
, &ssfdc
->heads
, &ssfdc
->sectors
);
327 ssfdc
->cylinders
= (unsigned short)((mtd
->size
>> SECTOR_SHIFT
) /
328 ((long)ssfdc
->sectors
* (long)ssfdc
->heads
));
330 DEBUG(MTD_DEBUG_LEVEL1
, "SSFDC_RO: using C:%d H:%d S:%d == %ld sects\n",
331 ssfdc
->cylinders
, ssfdc
->heads
, ssfdc
->sectors
,
332 (long)ssfdc
->cylinders
* (long)ssfdc
->heads
*
333 (long)ssfdc
->sectors
);
335 ssfdc
->mbd
.size
= (long)ssfdc
->heads
* (long)ssfdc
->cylinders
*
336 (long)ssfdc
->sectors
;
338 /* Allocate logical block map */
339 ssfdc
->logic_block_map
= kmalloc( sizeof(ssfdc
->logic_block_map
[0]) *
340 ssfdc
->map_len
, GFP_KERNEL
);
341 if (!ssfdc
->logic_block_map
) {
343 "SSFDC_RO: out of memory for data structures\n");
346 memset(ssfdc
->logic_block_map
, 0xff, sizeof(ssfdc
->logic_block_map
[0]) *
349 /* Build logical block map */
350 if (build_logical_block_map(ssfdc
) < 0)
353 /* Register device + partitions */
354 if (add_mtd_blktrans_dev(&ssfdc
->mbd
))
357 printk(KERN_INFO
"SSFDC_RO: Found ssfdc%c on mtd%d (%s)\n",
358 ssfdc
->mbd
.devnum
+ 'a', mtd
->index
, mtd
->name
);
362 kfree(ssfdc
->logic_block_map
);
366 static void ssfdcr_remove_dev(struct mtd_blktrans_dev
*dev
)
368 struct ssfdcr_record
*ssfdc
= (struct ssfdcr_record
*)dev
;
370 DEBUG(MTD_DEBUG_LEVEL1
, "SSFDC_RO: remove_dev (i=%d)\n", dev
->devnum
);
372 del_mtd_blktrans_dev(dev
);
373 kfree(ssfdc
->logic_block_map
);
377 static int ssfdcr_readsect(struct mtd_blktrans_dev
*dev
,
378 unsigned long logic_sect_no
, char *buf
)
380 struct ssfdcr_record
*ssfdc
= (struct ssfdcr_record
*)dev
;
381 int sectors_per_block
, offset
, block_address
;
383 sectors_per_block
= ssfdc
->erase_size
>> SECTOR_SHIFT
;
384 offset
= (int)(logic_sect_no
% sectors_per_block
);
385 block_address
= (int)(logic_sect_no
/ sectors_per_block
);
387 DEBUG(MTD_DEBUG_LEVEL3
,
388 "SSFDC_RO: ssfdcr_readsect(%lu) sec_per_blk=%d, ofst=%d,"
389 " block_addr=%d\n", logic_sect_no
, sectors_per_block
, offset
,
392 if (block_address
>= ssfdc
->map_len
)
395 block_address
= ssfdc
->logic_block_map
[block_address
];
397 DEBUG(MTD_DEBUG_LEVEL3
,
398 "SSFDC_RO: ssfdcr_readsect() phys_block_addr=%d\n",
401 if (block_address
< 0xffff) {
402 unsigned long sect_no
;
404 sect_no
= (unsigned long)block_address
* sectors_per_block
+
407 DEBUG(MTD_DEBUG_LEVEL3
,
408 "SSFDC_RO: ssfdcr_readsect() phys_sect_no=%lu\n",
411 if (read_physical_sector( ssfdc
->mbd
.mtd
, buf
, sect_no
) < 0)
414 memset(buf
, 0xff, SECTOR_SIZE
);
420 static int ssfdcr_getgeo(struct mtd_blktrans_dev
*dev
, struct hd_geometry
*geo
)
422 struct ssfdcr_record
*ssfdc
= (struct ssfdcr_record
*)dev
;
424 DEBUG(MTD_DEBUG_LEVEL1
, "SSFDC_RO: ssfdcr_getgeo() C=%d, H=%d, S=%d\n",
425 ssfdc
->cylinders
, ssfdc
->heads
, ssfdc
->sectors
);
427 geo
->heads
= ssfdc
->heads
;
428 geo
->sectors
= ssfdc
->sectors
;
429 geo
->cylinders
= ssfdc
->cylinders
;
434 /****************************************************************************
438 ****************************************************************************/
440 static struct mtd_blktrans_ops ssfdcr_tr
= {
442 .major
= SSFDCR_MAJOR
,
443 .part_bits
= SSFDCR_PARTN_BITS
,
444 .getgeo
= ssfdcr_getgeo
,
445 .readsect
= ssfdcr_readsect
,
446 .add_mtd
= ssfdcr_add_mtd
,
447 .remove_dev
= ssfdcr_remove_dev
,
448 .owner
= THIS_MODULE
,
451 static int __init
init_ssfdcr(void)
453 printk(KERN_INFO
"SSFDC read-only Flash Translation layer\n");
455 return register_mtd_blktrans(&ssfdcr_tr
);
458 static void __exit
cleanup_ssfdcr(void)
460 deregister_mtd_blktrans(&ssfdcr_tr
);
463 module_init(init_ssfdcr
);
464 module_exit(cleanup_ssfdcr
);
466 MODULE_LICENSE("GPL");
467 MODULE_AUTHOR("Claudio Lanconelli <lanconelli.claudio@eptar.com>");
468 MODULE_DESCRIPTION("Flash Translation Layer for read-only SSFDC SmartMedia card");