Lines Matching refs:part
93 static int build_block_map(struct partition *part, int block_no)
95 struct block *block = &part->blocks[block_no];
98 block->offset = part->block_size * block_no;
100 if (le16_to_cpu(part->header_cache[0]) != RFD_MAGIC) {
107 for (i=0; i<part->data_sectors_per_block; i++) {
110 entry = le16_to_cpu(part->header_cache[HEADER_MAP_OFFSET + i]);
123 if (entry >= part->sector_count) {
127 part->mbd.mtd->name, block_no, i, entry);
131 if (part->sector_map[entry] != -1) {
134 part->mbd.mtd->name, entry);
135 part->errors = 1;
139 part->sector_map[entry] = block->offset +
140 (i + part->header_sectors_per_block) * SECTOR_SIZE;
145 if (block->free_sectors == part->data_sectors_per_block)
146 part->reserved_block = block_no;
151 static int scan_header(struct partition *part)
158 sectors_per_block = part->block_size / SECTOR_SIZE;
159 part->total_blocks = (u32)part->mbd.mtd->size / part->block_size;
161 if (part->total_blocks < 2)
165 part->header_sectors_per_block =
169 part->data_sectors_per_block = sectors_per_block -
170 part->header_sectors_per_block;
172 part->header_size = (HEADER_MAP_OFFSET +
173 part->data_sectors_per_block) * sizeof(u16);
175 part->cylinders = (part->data_sectors_per_block *
176 (part->total_blocks - 1) - 1) / SECTORS_PER_TRACK;
178 part->sector_count = part->cylinders * SECTORS_PER_TRACK;
180 part->current_block = -1;
181 part->reserved_block = -1;
182 part->is_reclaiming = 0;
184 part->header_cache = kmalloc(part->header_size, GFP_KERNEL);
185 if (!part->header_cache)
188 part->blocks = kcalloc(part->total_blocks, sizeof(struct block),
190 if (!part->blocks)
193 part->sector_map = vmalloc(array_size(sizeof(u_long),
194 part->sector_count));
195 if (!part->sector_map) {
197 "sector map", part->mbd.mtd->name);
201 for (i=0; i<part->sector_count; i++)
202 part->sector_map[i] = -1;
204 for (i=0, blocks_found=0; i<part->total_blocks; i++) {
205 rc = mtd_read(part->mbd.mtd, i * part->block_size,
206 part->header_size, &retlen,
207 (u_char *)part->header_cache);
209 if (!rc && retlen != part->header_size)
215 if (!build_block_map(part, i))
221 part->mbd.mtd->name);
226 if (part->reserved_block == -1) {
228 part->mbd.mtd->name);
230 part->errors = 1;
236 vfree(part->sector_map);
237 kfree(part->header_cache);
238 kfree(part->blocks);
245 struct partition *part = (struct partition*)dev;
250 if (sector >= part->sector_count)
253 addr = part->sector_map[sector];
255 rc = mtd_read(part->mbd.mtd, addr, SECTOR_SIZE, &retlen,
262 "0x%lx\n", part->mbd.mtd->name, addr);
271 static int erase_block(struct partition *part, int block)
280 erase->addr = part->blocks[block].offset;
281 erase->len = part->block_size;
283 part->blocks[block].state = BLOCK_ERASING;
284 part->blocks[block].free_sectors = 0;
286 rc = mtd_erase(part->mbd.mtd, erase);
290 (unsigned long long)erase->len, part->mbd.mtd->name);
291 part->blocks[block].state = BLOCK_FAILED;
292 part->blocks[block].free_sectors = 0;
293 part->blocks[block].used_sectors = 0;
298 part->blocks[block].state = BLOCK_ERASED;
299 part->blocks[block].free_sectors = part->data_sectors_per_block;
300 part->blocks[block].used_sectors = 0;
301 part->blocks[block].erases++;
303 rc = mtd_write(part->mbd.mtd, part->blocks[block].offset,
310 part->mbd.mtd->name, part->blocks[block].offset);
311 part->blocks[block].state = BLOCK_FAILED;
313 part->blocks[block].state = BLOCK_OK;
322 static int move_block_contents(struct partition *part, int block_no, u_long *old_sector)
329 part->is_reclaiming = 1;
335 map = kmalloc(part->header_size, GFP_KERNEL);
339 rc = mtd_read(part->mbd.mtd, part->blocks[block_no].offset,
340 part->header_size, &retlen, (u_char *)map);
342 if (!rc && retlen != part->header_size)
347 "0x%lx\n", part->mbd.mtd->name,
348 part->blocks[block_no].offset);
353 for (i=0; i<part->data_sectors_per_block; i++) {
365 if (entry >= part->sector_count)
368 addr = part->blocks[block_no].offset +
369 (i + part->header_sectors_per_block) * SECTOR_SIZE;
373 if (!part->blocks[block_no].used_sectors--) {
374 rc = erase_block(part, block_no);
379 rc = mtd_read(part->mbd.mtd, addr, SECTOR_SIZE, &retlen,
388 part->mbd.mtd->name);
393 rc = rfd_ftl_writesect((struct mtd_blktrans_dev*)part,
405 part->is_reclaiming = 0;
410 static int reclaim_block(struct partition *part, u_long *old_sector)
416 mtd_sync(part->mbd.mtd);
421 old_sector_block = *old_sector / part->block_size;
425 for (block=0; block<part->total_blocks; block++) {
428 if (block == part->reserved_block)
436 if (part->blocks[block].free_sectors)
439 this_score = part->blocks[block].used_sectors;
445 if (part->blocks[block].used_sectors ==
446 part->data_sectors_per_block)
450 this_score += part->blocks[block].erases;
461 part->current_block = -1;
462 part->reserved_block = best_block;
466 part->blocks[best_block].used_sectors,
467 part->blocks[best_block].free_sectors);
469 if (part->blocks[best_block].used_sectors)
470 rc = move_block_contents(part, best_block, old_sector);
472 rc = erase_block(part, best_block);
482 static int find_free_block(struct partition *part)
486 block = part->current_block == -1 ?
487 jiffies % part->total_blocks : part->current_block;
491 if (part->blocks[block].free_sectors &&
492 block != part->reserved_block)
495 if (part->blocks[block].state == BLOCK_UNUSED)
496 erase_block(part, block);
498 if (++block >= part->total_blocks)
506 static int find_writable_block(struct partition *part, u_long *old_sector)
511 block = find_free_block(part);
514 if (!part->is_reclaiming) {
515 rc = reclaim_block(part, old_sector);
519 block = find_free_block(part);
528 rc = mtd_read(part->mbd.mtd, part->blocks[block].offset,
529 part->header_size, &retlen,
530 (u_char *)part->header_cache);
532 if (!rc && retlen != part->header_size)
537 "0x%lx\n", part->mbd.mtd->name,
538 part->blocks[block].offset);
542 part->current_block = block;
548 static int mark_sector_deleted(struct partition *part, u_long old_addr)
555 block = old_addr / part->block_size;
556 offset = (old_addr % part->block_size) / SECTOR_SIZE -
557 part->header_sectors_per_block;
559 addr = part->blocks[block].offset +
561 rc = mtd_write(part->mbd.mtd, addr, sizeof(del), &retlen,
569 "0x%lx\n", part->mbd.mtd->name, addr);
572 if (block == part->current_block)
573 part->header_cache[offset + HEADER_MAP_OFFSET] = del;
575 part->blocks[block].used_sectors--;
577 if (!part->blocks[block].used_sectors &&
578 !part->blocks[block].free_sectors)
579 rc = erase_block(part, block);
585 static int find_free_sector(const struct partition *part, const struct block *block)
589 i = stop = part->data_sectors_per_block - block->free_sectors;
592 if (le16_to_cpu(part->header_cache[HEADER_MAP_OFFSET + i])
596 if (++i == part->data_sectors_per_block)
606 struct partition *part = (struct partition*)dev;
614 if (part->current_block == -1 ||
615 !part->blocks[part->current_block].free_sectors) {
617 rc = find_writable_block(part, old_addr);
622 block = &part->blocks[part->current_block];
624 i = find_free_sector(part, block);
631 addr = (i + part->header_sectors_per_block) * SECTOR_SIZE +
633 rc = mtd_write(part->mbd.mtd, addr, SECTOR_SIZE, &retlen,
641 part->mbd.mtd->name, addr);
645 part->sector_map[sector] = addr;
649 part->header_cache[i + HEADER_MAP_OFFSET] = entry;
652 rc = mtd_write(part->mbd.mtd, addr, sizeof(entry), &retlen,
660 part->mbd.mtd->name, addr);
672 struct partition *part = (struct partition*)dev;
679 if (part->reserved_block == -1) {
684 if (sector >= part->sector_count) {
689 old_addr = part->sector_map[sector];
702 part->sector_map[sector] = -1;
705 rc = mark_sector_deleted(part, old_addr);
713 struct partition *part = (struct partition*)dev;
717 geo->cylinders = part->cylinders;
724 struct partition *part;
729 part = kzalloc(sizeof(struct partition), GFP_KERNEL);
730 if (!part)
733 part->mbd.mtd = mtd;
736 part->block_size = block_size;
742 part->block_size = mtd->erasesize;
745 if (scan_header(part) == 0) {
746 part->mbd.size = part->sector_count;
747 part->mbd.tr = tr;
748 part->mbd.devnum = -1;
750 part->mbd.readonly = 1;
751 else if (part->errors) {
754 part->mbd.readonly = 1;
760 if (!add_mtd_blktrans_dev((void*)part))
764 kfree(part);
769 struct partition *part = (struct partition*)dev;
772 for (i=0; i<part->total_blocks; i++) {
774 part->mbd.mtd->name, i, part->blocks[i].erases);
778 vfree(part->sector_map);
779 kfree(part->header_cache);
780 kfree(part->blocks);