static boot_state_t bs_dev_init(void *arg)
{
timestamp_add_now(TS_DEVICE_INITIALIZE);
/* And of course initialize devices on the bus */
dev_initialize();
return BS_POST_DEVICE;
}
/*****************************************************************************
*Name :
*Description :
*Parameter :
*Return :
*Note :
*****************************************************************************/
int add_nand(struct nand_blk_ops *tr, struct _nand_phy_partition* phy_partition)
{
int i;
__u32 cur_offset = 0;
struct _nftl_blk *nftl_blk;
struct _nand_dev *nand_dev;
struct _nand_disk* disk;
struct _nand_disk* head_disk;
struct nand_kobject* nand_kobj;
uint16 PartitionNO;
PartitionNO = get_partitionNO(phy_partition);
nftl_blk = kmalloc(sizeof(struct _nftl_blk), GFP_KERNEL);
if (!nftl_blk)
{
nand_dbg_err("init kmalloc fail 3!\n");
return 1;
}
nftl_blk->nand = build_nand_partition(phy_partition);
if (nftl_initialize(nftl_blk,PartitionNO))
{
nand_dbg_err("nftl_initialize failed\n");
return 1;
}
nftl_blk->blk_lock = kmalloc(sizeof(struct mutex), GFP_KERNEL);
if (!nftl_blk->blk_lock)
{
nand_dbg_err("init kmalloc fail 2!\n");
return 1;
}
mutex_init(nftl_blk->blk_lock);
nftl_blk->nftl_thread = kthread_run(nftl_thread, nftl_blk, "%sd", "nftl");
if (IS_ERR(nftl_blk->nftl_thread))
{
nand_dbg_err("init kthread_run fail!\n");
return 1;
}
add_nftl_blk_list(&tr->nftl_blk_head,nftl_blk);
nand_kobj = kzalloc(sizeof(struct nand_kobject), GFP_KERNEL);
if (!nand_kobj)
{
nand_dbg_err("init kmalloc fail 1!\n");
return 1;
}
nand_kobj->nftl_blk = nftl_blk;
if(kobject_init_and_add(&nand_kobj->kobj,&ktype,NULL,"nand_driver%d",PartitionNO) != 0 ) {
nand_dbg_err("init nand sysfs fail!\n");
return 1;
}
disk = get_disk_from_phy_partition(phy_partition);
for(i=0;i<MAX_PART_COUNT_PER_FTL;i++)
{
//nand_dbg_err("disk->name %s\n",(char *)(disk->name));
//nand_dbg_err("disk->type %x\n",disk[i].type);
//nand_dbg_err("disk->size %x\n",disk[i].size);
}
head_disk = get_disk_from_phy_partition(phy_partition);
for(i=0;i<MAX_PART_COUNT_PER_FTL;i++)
{
disk = head_disk + i;
if(disk->type == 0xffffffff)
{
break;
}
nand_dev = kmalloc(sizeof(struct _nand_dev), GFP_KERNEL);
if (!nand_dev)
{
nand_dbg_err("init kmalloc fail!\n");
return 1;
}
add_nand_dev_list(&tr->nand_dev_head,nand_dev);
nand_dev->nbd.nandr = &mytr;
if(dev_initialize(nand_dev,nftl_blk,cur_offset,disk->size) != 0)
{
//nand_dbg_err("dev_initialize failed\n");
return 1;
}
nand_dev->nbd.size = (unsigned int)nand_dev->size;
nand_dev->nbd.priv = (void*)nand_dev;
//memcpy(nand_dev->nbd.name,disk->name,strlen(disk->name)+1);
if((PartitionNO == 0) && (i==0))
{
dev_num = -1;
}
else
{
dev_num++;
nand_dev->nbd.devnum = dev_num;
if (add_nand_blktrans_dev(&nand_dev->nbd))
{
nand_dbg_err("nftl add blk disk dev failed\n");
return 1;
}
}
cur_offset += disk->size;
}
return 0;
}
static int do_sata(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
int rc = 0;
if (argc == 2 && strcmp(argv[1], "stop") == 0)
return sata_stop();
if (argc == 2 && strcmp(argv[1], "init") == 0)
{
if (dev_curr != -1)
sata_stop();
return dev_initialize();
// return sata_initialize();
}
/* If the user has not yet run `sata init`, do it now */
if (dev_curr == -1)
if (dev_initialize())
return 1;
switch (argc)
{
case 0:
case 1:
return CMD_RET_USAGE;
case 2:
if (strncmp(argv[1],"inf", 3) == 0)
{
int i;
puts('\n');
for (i = 0; i < CONFIG_SYS_MAX_DEVICE; ++i)
{
if (dev_desc[i].type == DEV_TYPE_UNKNOWN)
continue;
printf ("SATA device %d: ", i);
dev_print(&dev_desc[i]);
}
return 0;
}
else if (strncmp(argv[1],"dev", 3) == 0)
{
if ((dev_curr < 0) || (dev_curr >= CONFIG_SYS_MAX_DEVICE))
{
puts("\nno SATA devices available\n");
return 1;
}
printf("\nSATA device %d: ", dev_curr);
dev_print(&dev_desc[dev_curr]);
return 0;
}
else if (strncmp(argv[1],"part",4) == 0)
{
int dev, ok;
for (ok = 0, dev = 0; dev < CONFIG_SYS_MAX_DEVICE; ++dev)
{
if (dev_desc[dev].part_type != PART_TYPE_UNKNOWN)
{
++ok;
if (dev)
puts ('\n');
print_part(&dev_desc[dev]);
}
}
if (!ok)
{
puts("\nno SATA devices available\n");
rc ++;
}
return rc;
}
return CMD_RET_USAGE;
case 3:
if (strncmp(argv[1], "dev", 3) == 0)
{
int dev = (int)strtoul(argv[2], NULL, 10);
printf("\nSATA device %d: ", dev);
if (dev >= CONFIG_SYS_MAX_DEVICE)
{
puts ("unknown device\n");
return 1;
}
dev_print(&dev_desc[dev]);
if (dev_desc[dev].type == DEV_TYPE_UNKNOWN)
return 1;
dev_curr = dev;
puts("... is now current device\n");
return 0;
}
else if (strncmp(argv[1], "part", 4) == 0)
{
int dev = (int)strtoul(argv[2], NULL, 10);
if (dev_desc[dev].part_type != PART_TYPE_UNKNOWN)
{
print_part(&dev_desc[dev]);
}
else
{
printf("\nSATA device %d not available\n", dev);
rc = 1;
}
return rc;
}
return CMD_RET_USAGE;
default: /* at least 4 args */
if (strcmp(argv[1], "read") == 0)
{
ulong addr = strtoull(argv[2], NULL, 16);
ulong cnt = strtoull(argv[4], NULL, 16);
ulong n;
lbaint_t blk = strtoull(argv[3], NULL, 16);
printf("\nSATA read: device %d block # %ld, count %ld ... ", dev_curr, blk, cnt);
// n = sata_read(dev_curr, blk, cnt, (uint32_t *)addr);
/* flush cache after read */
// flush_cache(addr, cnt * dev_desc[dev_curr].blksz);
printf("%ld blocks read: %s\n",
n, (n==cnt) ? "OK" : "ERROR");
return (n == cnt) ? 0 : 1;
}
else if (strcmp(argv[1], "write") == 0)
{
ulong addr = strtoull(argv[2], NULL, 16);
ulong cnt = strtoull(argv[4], NULL, 16);
ulong n;
lbaint_t blk = strtoull(argv[3], NULL, 16);
printf("\nSATA write: device %d block # %ld, count %ld ... ", dev_curr, blk, cnt);
n = dev_bwrite(dev_curr, blk, cnt, (uint32_t *)addr);
printf("%ld blocks written: %s\n",
n, (n == cnt) ? "OK" : "ERROR");
return (n == cnt) ? 0 : 1;
}
else
{
return CMD_RET_USAGE;
}
return rc;
}
}
void hardwaremain(int boot_complete)
{
struct lb_memory *lb_mem;
void *payload;
timestamp_stash(TS_START_RAMSTAGE);
post_code(POST_ENTRY_RAMSTAGE);
#if CONFIG_COVERAGE
coverage_init();
#endif
/* console_init() MUST PRECEDE ALL printk()! */
console_init();
post_code(POST_CONSOLE_READY);
printk(BIOS_NOTICE, "coreboot-%s%s %s %s...\n",
coreboot_version, coreboot_extra_version, coreboot_build,
(boot_complete)?"rebooting":"booting");
post_code(POST_CONSOLE_BOOT_MSG);
/* If we have already booted attempt a hard reboot */
if (boot_complete) {
hard_reset();
}
/* FIXME: Is there a better way to handle this? */
init_timer();
timestamp_stash(TS_DEVICE_ENUMERATE);
/* Initialize chips early, they might disable unused devices. */
dev_initialize_chips();
/* Find the devices we don't have hard coded knowledge about. */
dev_enumerate();
post_code(POST_DEVICE_ENUMERATION_COMPLETE);
timestamp_stash(TS_DEVICE_CONFIGURE);
/* Now compute and assign the bus resources. */
dev_configure();
post_code(POST_DEVICE_CONFIGURATION_COMPLETE);
timestamp_stash(TS_DEVICE_ENABLE);
/* Now actually enable devices on the bus */
dev_enable();
post_code(POST_DEVICES_ENABLED);
timestamp_stash(TS_DEVICE_INITIALIZE);
/* And of course initialize devices on the bus */
dev_initialize();
post_code(POST_DEVICES_INITIALIZED);
timestamp_stash(TS_DEVICE_DONE);
cbmem_initialize();
#if CONFIG_CONSOLE_CBMEM
cbmemc_reinit();
#endif
timestamp_sync();
#if CONFIG_HAVE_ACPI_RESUME
suspend_resume();
post_code(0x8a);
#endif
timestamp_add_now(TS_CBMEM_POST);
if (cbmem_post_handling)
cbmem_post_handling();
timestamp_add_now(TS_WRITE_TABLES);
/* Now that we have collected all of our information
* write our configuration tables.
*/
lb_mem = write_tables();
timestamp_add_now(TS_LOAD_PAYLOAD);
payload = cbfs_load_payload(CBFS_DEFAULT_MEDIA,
CONFIG_CBFS_PREFIX "/payload");
if (! payload)
die("Could not find a payload\n");
selfboot(lb_mem, payload);
printk(BIOS_EMERG, "Boot failed");
}
