static void wbfs_load_header(void)
{
head = wbfs_malloc(sizeof(*head));
read_sectors(0,1,head);
if(wbfs_ntohl(head->magic)!=MAGIC)
wbfs_fatal("not a WBFS partition!");
D( wblk_sz_shift, head->blk_sz_log2-2+15 );
D( iwlba_shift, head->blk_sz_log2-9+15 );
D( lba_mask, ((1<<(wblk_sz_shift-blk_sz_shift))-1));
D( nsblk , wbfs_ntohl(head->nsblk) );
D( nblk , nsblk*512LL/(blk_sz*0x8000) );
D( freeblks_size, ALIGN512(nblk/8) );
D( disc_nblk, (143432/(1<<head->blk_sz_log2))+1 );
D( table_size, (disc_nblk)*2 );
D( header_size, ALIGN512(table_size+0x100) );
D( freeblks_o, blk_sz*0x8000-freeblks_size ); // end of first block
D( max_disc, (freeblks_o-512)/header_size );
if(max_disc > MAX_MAXDISC)
max_disc = MAX_MAXDISC;
header = wbfs_malloc(header_size);
tmp_buffer = wbfs_malloc(blk_sz);
}
u32 wbfs_get_list( u8 **headers,u32 num)
{
u32 i;
u32 count = 0;
for(i=0;i<max_disc;i++)
{
if (head->disc_table[i])
{
read_sectors(1+i*header_size/512,header_size/512,header);
u32 magic=wbfs_be32(header+24);
if(magic!=0x5D1C9EA3)
continue;
headers[i] = wbfs_malloc(header_size);
wbfs_memcpy(headers[i],header,header_size);
if(++count == num)
return count;
}
}
return count;
}
wbfs_t*wbfs_open_partition(rw_sector_callback_t read_hdsector,
rw_sector_callback_t write_hdsector,
#ifdef WIN32
close_callback_t close_hd,
#endif
void *callback_data,
int hd_sector_size, int num_hd_sector, u32 part_lba, int reset)
{
wbfs_t *p = wbfs_malloc(sizeof(wbfs_t));
wbfs_head_t *head = wbfs_ioalloc(hd_sector_size?hd_sector_size:512);
//constants, but put here for consistancy
p->wii_sec_sz = 0x8000;
p->wii_sec_sz_s = size_to_shift(0x8000);
p->n_wii_sec = (num_hd_sector/0x8000)*hd_sector_size;
p->n_wii_sec_per_disc = 143432*2;//support for double layers discs..
p->head = head;
p->part_lba = part_lba;
// init the partition
if (reset)
{
u8 sz_s;
wbfs_memset(head,0,hd_sector_size);
head->magic = wbfs_htonl(WBFS_MAGIC);
head->hd_sec_sz_s = size_to_shift(hd_sector_size);
head->n_hd_sec = wbfs_htonl(num_hd_sector);
// choose minimum wblk_sz that fits this partition size
for(sz_s=6;sz_s<11;sz_s++)
{
// ensure that wbfs_sec_sz is big enough to address every blocks using 16 bits
if(p->n_wii_sec <((1U<<16)*(1<<sz_s)))
break;
}
head->wbfs_sec_sz_s = sz_s+p->wii_sec_sz_s;
} else
read_hdsector(callback_data,p->part_lba,1,head);
if (head->magic != wbfs_htonl(WBFS_MAGIC))
ERROR("bad magic");
if(!force_mode && hd_sector_size && head->hd_sec_sz_s != size_to_shift(hd_sector_size))
ERROR("hd sector size doesn't match");
if(!force_mode && num_hd_sector && head->n_hd_sec != wbfs_htonl(num_hd_sector))
ERROR("hd num sector doesn't match");
p->hd_sec_sz = 1<<head->hd_sec_sz_s;
p->hd_sec_sz_s = head->hd_sec_sz_s;
p->n_hd_sec = wbfs_ntohl(head->n_hd_sec);
p->n_wii_sec = (p->n_hd_sec/p->wii_sec_sz)*(p->hd_sec_sz);
p->wbfs_sec_sz_s = head->wbfs_sec_sz_s;
p->wbfs_sec_sz = 1<<p->wbfs_sec_sz_s;
p->n_wbfs_sec = p->n_wii_sec >> (p->wbfs_sec_sz_s - p->wii_sec_sz_s);
p->n_wbfs_sec_per_disc = p->n_wii_sec_per_disc >> (p->wbfs_sec_sz_s - p->wii_sec_sz_s);
p->disc_info_sz = ALIGN_LBA(sizeof(wbfs_disc_info_t) + p->n_wbfs_sec_per_disc*2);
//printf("hd_sector_size %X wii_sector size %X wbfs sector_size %X\n",p->hd_sec_sz,p->wii_sec_sz,p->wbfs_sec_sz);
p->read_hdsector = read_hdsector;
p->write_hdsector = write_hdsector;
#ifdef WIN32
p->close_hd = close_hd;
#endif
p->callback_data = callback_data;
p->freeblks_lba = (p->wbfs_sec_sz - p->n_wbfs_sec/8)>>p->hd_sec_sz_s;
if(!reset)
p->freeblks = 0; // will alloc and read only if needed
else
{
// init with all free blocks
p->freeblks = wbfs_ioalloc(ALIGN_LBA(p->n_wbfs_sec/8));
wbfs_memset(p->freeblks,0xff,p->n_wbfs_sec/8);
}
p->max_disc = (p->freeblks_lba-1)/(p->disc_info_sz>>p->hd_sec_sz_s);
if(p->max_disc > p->hd_sec_sz - sizeof(wbfs_head_t))
p->max_disc = p->hd_sec_sz - sizeof(wbfs_head_t);
p->tmp_buffer = wbfs_ioalloc(p->hd_sec_sz);
p->n_disc_open = 0;
wbfs_sync(p);
return p;
error:
wbfs_free(p);
wbfs_iofree(head);
return 0;
}
