ULONG findMem(APTR ofw, ULONG orig_MSR)
{
ULONG volatile *mem=(APTR)(16*1024*1024);
ULONG msr;
int i;
ULONG dev_handle, res, size;
ULONG mem_info[2];
asm volatile("mfmsr %0":"=r"(msr));
while(ofw && ((ULONG)ofw < 0x10000000))
{
asm volatile("mtmsr %0"::"r"(orig_MSR));
of_init(ofw);
res = of_finddevice("/memory@0", &dev_handle);
if (res)
break;
res = of_getprop(dev_handle, "reg", mem_info, sizeof(mem_info), &size);
if (res) break;
mem = (ULONG *)mem_info[1];
break;
}
asm volatile("mtmsr %0"::"r"(msr));
return (ULONG)mem;
}
extern "C" void
start(void *openFirmwareEntry)
{
char bootargs[512];
// stage2 args - might be set via the command line one day
stage2_args args;
args.heap_size = HEAP_SIZE;
args.arguments = NULL;
of_init((int (*)(void*))openFirmwareEntry);
// check for arguments
if (of_getprop(gChosen, "bootargs", bootargs, sizeof(bootargs))
!= OF_FAILED) {
static const char *sArgs[] = { NULL, NULL };
sArgs[0] = (const char *)bootargs;
args.arguments = sArgs;
args.arguments_count = 1;
}
determine_machine();
console_init();
if ((gMachine & MACHINE_QEMU) != 0)
dprintf("OpenBIOS (QEMU?) OpenFirmware machine detected\n");
else if ((gMachine & MACHINE_PEGASOS) != 0)
dprintf("Pegasos PowerPC machine detected\n");
else
dprintf("Apple PowerPC machine assumed\n");
// Initialize and take over MMU and set the OpenFirmware callbacks - it
// will ask us for memory after that instead of maintaining it itself
// (the kernel will need to adjust the callback later on as well)
arch_mmu_init();
if (boot_arch_cpu_init() != B_OK)
of_exit();
if (init_real_time_clock() != B_OK)
of_exit();
// check for key presses once
sBootOptions = 0;
int key = console_check_for_key();
if (key == 32) {
// space bar: option menu
sBootOptions |= BOOT_OPTION_MENU;
} else if (key == 27) {
// ESC: debug output
sBootOptions |= BOOT_OPTION_DEBUG_OUTPUT;
}
gKernelArgs.platform_args.openfirmware_entry = openFirmwareEntry;
main(&args);
// if everything goes fine, main() never returns
of_exit();
}
int
kbd_get_lmuaddr(void)
{
struct device_node *node;
int plen;
unsigned long *reg = NULL;
of_init();
node = of_find_node_by_type("lmu-controller", 0);
if (node == NULL)
{
node = of_find_node_by_name("lmu-controller", 0);
if (node == NULL)
{
logmsg(LOG_ERR, "Error: no lmu-controller found in device-tree");
return -1;
}
}
reg = of_find_property(node, "reg", &plen);
lmu_info.lmuaddr = (unsigned int) (*reg >> 1);
free(reg);
of_free_node(node);
logdebug("Found LMU controller at address 0x%x\n", lmu_info.lmuaddr);
return 0;
}
int ips_module_init(const char* log_cat)
{
int i;
int ret;
if (ips_zc) {
fprintf(stderr, "%s: already initialized!\n", __func__);
return(SPKERR_BADSEQ);
}
ips_zc = zlog_get_category(log_cat?log_cat:"IPS");
if (!ips_zc) {
fprintf(stderr, "%s: failed to initialize log system!\n", __func__);
// return(SPKERR_LOGSYS);
}
assert(!ips_sriodev);
for (i = 0; i < IPS_MAX_PORTS_IN_DEV; i++) {
ips_epctx_tbl[i] = NULL;
}
pthread_mutex_init(&ips_dma_ch_lock, NULL);
pthread_mutex_init(&ips_zlog_lock, NULL);
of_init();
ret = fsl_srio_uio_init(&ips_sriodev);
IPS_LOGINFO(IPS_EPID_UNKNOWN, "fsl_srio_uio_init: ret=%d", ret);
if (ret) {
return(SPKERR_EAGAIN);
}
zlog_notice(ips_zc, "module initialized.");
return(SPK_SUCCESS);
}
void of_entry(uintptr_t initrd_start, uintptr_t initrd_size, void *entry)
{
uintptr_t *treestart = treebuf;
firmware_entry = entry;
of_init(entry);
of_puts( "\r\n[==== Kenge PowerPC64 OpenFirmware elf-loader ====]\r\n" );
/* Align device tree on a page boundary */
if ((uintptr_t)treestart & 0xfff)
treestart = (uintptr_t *)(((uintptr_t)treestart + 0xfff) & (~0xffful));
of_tree_init( &device_tree, treestart );
tree_size = of_populate_device_tree( &device_tree );
}
void platform_init(unsigned long a1, unsigned long a2, void *promptr)
{
platform_ops.image_hdr = of_image_hdr;
platform_ops.malloc = of_try_claim;
platform_ops.exit = of_exit;
platform_ops.vmlinux_alloc = of_vmlinux_alloc;
dt_ops.finddevice = of_finddevice;
dt_ops.getprop = of_getprop;
dt_ops.setprop = of_setprop;
of_console_init();
of_init(promptr);
loader_info.promptr = promptr;
if (a1 && a2 && a2 != 0xdeadbeef) {
loader_info.initrd_addr = a1;
loader_info.initrd_size = a2;
}
}
int main(int argc, char *argv[])
{
struct srio_dev *sriodev;
struct dma_ch *send_dmadev[SEND_THREAD_NUM];
struct dma_ch *receive_dmadev[RECEIVE_THREAD_NUM];
struct dma_pool *dmapool = NULL;
int i, err;
int maxworkers=2;
struct srio_port_data *port_data;
uint32_t attr_read, attr_write;
struct task_arg_type task_arg_send[SEND_THREAD_NUM];
struct task_arg_type task_arg_receive[RECEIVE_THREAD_NUM];
pthread_t send_id[SEND_THREAD_NUM];
pthread_t receive_id[RECEIVE_THREAD_NUM];
of_init();
err = fsl_srio_uio_init(&sriodev);
if (err < 0)
error(EXIT_FAILURE, -err, "%s(): srio_uio_init()", __func__);
port_num = fsl_srio_get_port_num(sriodev);
memset(&cmd_param, 0, sizeof(cmd_param));
/*ctx add*/
cmd_param.curr_port_id=0;
cmd_param.test_type=0;
cmd_param.test_srio_type=0;
cmd_param.time=60;
cmd_param.passes=1000;
cmd_param.bind=0;
cmd_param.workers=2;
cmd_param.interval=1;
err = cmd_translate(argc, argv,&cmd_param);
if(err==2)
{
return 0;
}
if (err < 0)
{
return -1;
}
if(cmd_param.workers!=maxworkers)
{
printf("workers error!\n");
fflush(stdout);
return -1;
}
port_data = malloc(sizeof(struct srio_port_data) * port_num);
if (!port_data) {
error(0, errno, "%s(): port_data", __func__);
goto err_cmd_malloc;
}
for (i = 0; i < port_num; i++) {
fsl_srio_connection(sriodev, i);
fsl_srio_get_port_info(sriodev, i + 1, &port_data[i].port_info,
&port_data[i].range_virt);
}
err = fsl_srio_port_connected(sriodev);
if (err <= 0) {
error(0, -err, "%s(): fsl_srio_port_connected", __func__);
goto err_srio_connected;
}
uint8_t flag=0;
if(cmd_param.test_type==1)
{
for (i = 0; i < port_num; i++) {
if(srio_link(sriodev,i))
{
printf("port %d sucess!\n",i);
// fsl_srio_drain_enable(sriodev,i);
fflush(stdout);
}
else
{
printf("port %d failed!\n",i);
fflush(stdout);
flag++;
}
}
if(flag != 0)
return -1;
return 0;
}
err = dma_pool_init(&dmapool);
uint8_t port = cmd_param.curr_port_id;
attr_read = srio_test_win_attrv[3];
attr_write = srio_test_win_attrv[cmd_param.test_srio_type];
for (i = 0; i < port_num; i++) {
dma_addr_t port_phys_base =
dmapool->dma_phys_base + SRIO_POOL_PORT_OFFSET * i;
port_data[i].phys.write_recv_data = port_phys_base;
port_data[i].phys.read_recv_data =
port_phys_base + SRIO_POOL_SECT_SIZE;
port_data[i].phys.write_data_prep =
port_phys_base + SRIO_POOL_SECT_SIZE * 2;
port_data[i].phys.res =
port_phys_base + SRIO_POOL_SECT_SIZE * 3;
port_data[i].virt = (typeof(port_data[i].virt))
(dmapool->dma_virt_base + i * SRIO_POOL_PORT_OFFSET);
fsl_srio_set_ibwin(sriodev, i, 1,
port_data[i].phys.write_recv_data,
SRIO_SYS_ADDR, LAWAR_SIZE_16M);
if (fsl_srio_port_connected(sriodev) & (0x1 << i)) {
fsl_srio_set_obwin(sriodev, i, 1,
port_data[i].port_info.range_start,
SRIO_SYS_ADDR, LAWAR_SIZE_16M);
fsl_srio_set_obwin_attr(sriodev, i, 1,
attr_read, attr_write);
} else {
printf("SRIO port %d error!\n", i + 1);
fflush(stdout);
return -errno;
}
fsl_srio_set_err_rate_degraded_threshold(sriodev,i,0);
fsl_srio_set_err_rate_failed_threshold(sriodev,i,0);
// fsl_srio_irq_enable(sriodev);
// fsl_srio_irq_disable(sriodev);
fsl_srio_set_phy_retry_threshold(sriodev,i,0,1);
memset(port_data[i].virt,0,SRIO_POOL_PORT_OFFSET);
printf("phy base:%08x virt base:%08x\n",port_phys_base,port_data[i].virt);
}
err = fsl_srio_set_targetid(sriodev,0,1,0x11);
if(err!=0)
{
printf("sro set targetid failed!\n");
fflush(stdout);
}
err = fsl_srio_set_targetid(sriodev,1,1,0x14);
if(err!=0)
{
printf("sro set targetid failed!\n");
fflush(stdout);
}
err = fsl_srio_set_deviceid(sriodev,0,0x11);
if(err!=0)
{
printf("sro set deviceid failed!\n");
fflush(stdout);
}
err = fsl_srio_set_deviceid(sriodev,1,0x14);
if(err!=0)
{
printf("sro set deviceid failed!\n");
fflush(stdout);
}
/*ctx add*/
sleep(5);
for(i=0; i<2; i++)
{
err = fsl_dma_chan_init(&send_dmadev[i], i, 1);
if (err < 0) {
error(0, -err, "%s(): fsl_dma_chan_init()", __func__);
goto err_srio_connected;
}
fsl_dma_chan_basic_direct_init(send_dmadev[i]);
fsl_dma_chan_bwc(send_dmadev[i], DMA_BWC_1024);
task_arg_send[i].dmadev = send_dmadev[i];
/* ctx add*/
task_arg_send[i].port_data_thread.phys.write_recv_data=port_data[i].phys.write_recv_data+THREAD_WIN_SIZE*1;
task_arg_send[i].port_data_thread.phys.read_recv_data=port_data[i].phys.read_recv_data+THREAD_WIN_SIZE*0;
task_arg_send[i].port_data_thread.phys.write_data_prep=port_data[i].phys.write_data_prep+THREAD_WIN_SIZE*0;
task_arg_send[i].port_data_thread.phys.res=port_data[i].phys.res+THREAD_WIN_SIZE*0;
task_arg_send[i].port_data_thread.virt.write_recv_data = &port_data[i].virt->write_recv_data_t[1][0];
task_arg_send[i].port_data_thread.virt.read_recv_data = &port_data[i].virt->read_recv_data_t[0][0];
task_arg_send[i].port_data_thread.virt.write_data_prep = &port_data[i].virt->write_data_prep_t[0][0];
task_arg_send[i].port_data_thread.virt.res = &port_data[i].virt->res_t[0][0];
task_arg_send[i].port_data_thread.port_info.range_start = port_data[i].port_info.range_start+THREAD_WIN_SIZE*0;
/* cta end*/
task_arg_send[i].port = i;
task_arg_send[i].sriodev = sriodev;
task_arg_send[i].srio_type = cmd_param.test_srio_type;
task_arg_send[i].bind=cmd_param.bind;
task_arg_send[i].time=cmd_param.time;
task_arg_send[i].passes = cmd_param.passes;/*bind cpu*/
if(cmd_param.test_type==2)
{
task_arg_send[i].test_type=0;
}
else if(cmd_param.test_type==3)
{
task_arg_send[i].test_type=1;
}
err = pthread_create(&send_id[i], NULL,t_srio_send, &task_arg_send[i]);
if (err) {
printf("Port %d : Send thread failed!\n",port + 1);
fflush(stdout);
return -errno;
}
}
sleep(2);
for(i=0; i<2; i++)
{
err = fsl_dma_chan_init(&receive_dmadev[i], i, 3);
if (err < 0) {
error(0, -err, "%s(): fsl_dma_chan_init()", __func__);
goto err_srio_connected;
}
fsl_dma_chan_basic_direct_init(receive_dmadev[i]);
fsl_dma_chan_bwc(receive_dmadev[i], DMA_BWC_1024);
task_arg_receive[i].dmadev = receive_dmadev[i];
task_arg_receive[i].port_data_thread.phys.write_recv_data=port_data[i].phys.write_recv_data+THREAD_WIN_SIZE*0;
task_arg_receive[i].port_data_thread.phys.read_recv_data=port_data[i].phys.read_recv_data+THREAD_WIN_SIZE*1;
task_arg_receive[i].port_data_thread.phys.write_data_prep=port_data[i].phys.write_data_prep+THREAD_WIN_SIZE*1;
task_arg_receive[i].port_data_thread.phys.res=port_data[i].phys.res+THREAD_WIN_SIZE*1;
task_arg_receive[i].port_data_thread.virt.write_recv_data = &port_data[i].virt->write_recv_data_t[0][0];
task_arg_receive[i].port_data_thread.virt.read_recv_data = &port_data[i].virt->read_recv_data_t[1][0];
task_arg_receive[i].port_data_thread.virt.write_data_prep = &port_data[i].virt->write_data_prep_t[1][0];
task_arg_receive[i].port_data_thread.virt.res = &port_data[i].virt->res_t[1][0];
task_arg_receive[i].port_data_thread.port_info.range_start = port_data[i].port_info.range_start+THREAD_WIN_SIZE*1;
/* cta end*/
task_arg_receive[i].port = i;
task_arg_receive[i].sriodev = sriodev;
task_arg_receive[i].srio_type = cmd_param.test_srio_type;
task_arg_receive[i].bind=cmd_param.bind;/*bind cpu*/
task_arg_receive[i].time=cmd_param.time;/*bind cpu*/
task_arg_receive[i].passes = cmd_param.passes;/*bind cpu*/
if(cmd_param.test_type==2)
{
err = pthread_create(&receive_id[i], NULL,t_srio_receive, &task_arg_receive[i]);
if (err) {
printf("Port %d : Send thread failed!\n",port + 1);
fflush(stdout);
return -errno;
}
}
}
for(i=0; i<2; i++)
{
if(cmd_param.test_type==2)
{
pthread_join(send_id[i],NULL);
pthread_join(receive_id[i],NULL);
} else if(cmd_param.test_type==3)
{
pthread_join(send_id[i],NULL);
}
}
/*ctx end*/
free(port_data);
for(i=0; i<2; i++)
{
fsl_dma_chan_finish(send_dmadev[i]);
fsl_dma_chan_finish(receive_dmadev[i]);
}
dma_pool_finish(dmapool);
fsl_srio_uio_finish(sriodev);
of_finish();
return EXIT_SUCCESS;
err_srio_connected:
free(port_data);
err_cmd_malloc:
fsl_srio_uio_finish(sriodev);
of_finish();
return err;
}
TITLE_RESULT show_title(game_display& screen, config& tips_of_day)
{
disableTerrainCache();
free_all_caches();
cursor::set(cursor::NORMAL);
const preferences::display_manager disp_manager(&screen);
const hotkey::basic_handler key_handler(&screen);
const font::floating_label_context label_manager;
screen.video().modeChanged(); // resets modeChanged value
// if (background_is_dirty_)
{
draw_background(screen);
}
//- Texts for the menu-buttons.
//- Members of this array must correspond to the enumeration TITLE_RESULT
static const char* button_labels[] = {
//N_("TitleScreen button^Tutorial"),
N_("TitleScreen button^Campaign"),
#ifndef FREE_VERSION
N_("TitleScreen button^Skirmish"),
N_("TitleScreen button^Multiplayer"),
#endif
N_("TitleScreen button^Load"),
// N_("TitleScreen button^Add-ons"),
//#ifndef DISABLE_EDITOR2
//N_("TitleScreen button^Map Editor"),
//#endif
//N_("TitleScreen button^Language"),
N_("TitleScreen button^Preferences"),
N_("Sync Saves"),
#ifndef DISABLE_OPENFEINT
N_("TitleScreen button^OpenFeint"),
#endif
N_("TitleScreen button^Help"),
//N_("TitleScreen button^Quit"),
// Only the above buttons go into the menu-frame
// Next 2 buttons go into frame for the tip-of-the-day:
N_("TitleScreen button^Previous"),
N_("TitleScreen button^Next"),
//N_("TitleScreen button^Help"),
// Next entry is no button, but shown as a mail-icon instead:
//N_("TitleScreen button^Help Wesnoth")
};
//- Texts for the tooltips of the menu-buttons
static const char* help_button_labels[] = {
//N_("Start a tutorial to familiarize yourself with the game"),
N_("Start a new single player campaign"),
#ifndef FREE_VERSION
N_("Play a single scenario against the AI"),
N_("Play multiplayer (hotseat or Internet)"),
#endif
N_("Load a saved game"),
// N_("Download usermade campaigns, eras, or map packs"),
//#ifndef DISABLE_EDITOR2
//N_("Start the map editor"),
//#endif
//N_("Change the language"),
N_("Configure the game's settings"),
N_("Sync saved games"),
#ifndef DISABLE_OPENFEINT
N_("Launch the OpenFeint dashboard"),
#endif
N_("Show Battle for Wesnoth help"),
//N_("Quit the game"),
N_("Show next tip of the day"),
//N_("Upload statistics")
};
//static const size_t nbuttons = sizeof(button_labels)/sizeof(*button_labels);
#ifdef FREE_VERSION
int nbuttons = 10;
#else
int nbuttons = 8;
#endif
#ifdef DISABLE_OPENFEINT
nbuttons--;
#endif
#ifndef __IPAD__
nbuttons--; // because help is off to the left now
#endif
int menu_xbase = CVideo::getx()-108-10; //380; //(game_config::title_buttons_x*screen.w())/1024;
const int menu_xincr = 0;
#ifdef USE_TINY_GUI
//const int menu_ybase = 15; //(330*screen.h())/768 - 50; //15;
const int menu_yincr = 36+5; //(35*3)/4;//15;
const int menu_ybase = (screen.h() - (36+5)*nbuttons - 5) / 2 + 4;
#else
const int menu_ybase = (screen.h() - (36+5)*nbuttons - 5) / 2 + 4;
const int menu_yincr = 36+5;
#endif
#ifdef __IPAD__
menu_xbase -= 10;
#endif
const int padding = 4; //game_config::title_buttons_padding;
std::vector<button> buttons;
size_t b, max_width = 0;
size_t n_menubuttons = 0;
for(b = 0; b != nbuttons; ++b)
{
//#ifdef __IPHONEOS__
// if (b + TUTORIAL == TUTORIAL || b + TUTORIAL == START_MAP_EDITOR || b+TUTORIAL == CHANGE_LANGUAGE)
// continue;
//#endif
buttons.push_back(button(screen.video(),sgettext(button_labels[b])));
buttons.back().set_help_string(sgettext(help_button_labels[b]));
max_width = std::max<size_t>(max_width,buttons.back().width());
n_menubuttons = b;
#ifdef __IPAD__
if(b + NEW_CAMPAIGN == SHOW_HELP) break;
#else
if(b + NEW_CAMPAIGN == SHOW_OPENFEINT) break;
#endif
}
SDL_Rect main_dialog_area = {menu_xbase-padding, menu_ybase-padding, max_width+padding*2,
menu_yincr*(n_menubuttons)+buttons.back().height()+padding*2};
gui::dialog_frame main_frame(screen.video(), "", gui::dialog_frame::titlescreen_style, false);
main_frame.layout(main_dialog_area);
// we only redraw transparent parts when asked,
// to prevent alpha growing
if (background_is_dirty_) {
main_frame.draw_background();
main_frame.draw_border();
}
int i=0;
for(b = 0; b != nbuttons; ++b)
{
//#ifdef __IPHONEOS__
// if (b + TUTORIAL == TUTORIAL || b + TUTORIAL == START_MAP_EDITOR || b+TUTORIAL == CHANGE_LANGUAGE)
// continue;
//#endif
buttons[i].set_width(max_width);
buttons[i].set_location(menu_xbase + i*menu_xincr, menu_ybase + i*menu_yincr);
#ifdef __IPAD__
if(b + NEW_CAMPAIGN == SHOW_HELP) break;
#else
if(b + NEW_CAMPAIGN == SHOW_OPENFEINT) break;
#endif
i++;
}
#ifndef __IPAD__
buttons.push_back(button(screen.video(),sgettext(button_labels[i+1])));
buttons.back().set_help_string(sgettext(help_button_labels[i+1]));
buttons[i+1].set_width(max_width);
buttons[i+1].set_location(5, 320-menu_yincr);
#endif
// b = TIP_PREVIOUS - NEW_CAMPAIGN;
// gui::button previous_tip_button(screen.video(),sgettext(button_labels[b]),button::TYPE_PRESS,"lite_small");
// previous_tip_button.set_help_string( sgettext(button_labels[b] ));
// b = TIP_NEXT - NEW_CAMPAIGN;
// gui::button next_tip_button(screen.video(),sgettext(button_labels[b]),button::TYPE_PRESS,"lite_small");
// next_tip_button.set_help_string( sgettext(button_labels[b] ));
// b = SHOW_HELP - NEW_CAMPAIGN;
// gui::button help_tip_button(screen.video(),sgettext(button_labels[b]),button::TYPE_PRESS,"lite_small");
// help_tip_button.set_help_string( sgettext(button_labels[b] ));
// gui::button beg_button(screen.video(),_("Help Wesnoth"),button::TYPE_IMAGE,"menu-button",button::MINIMUM_SPACE);
// beg_button.set_help_string(_("Help Wesnoth by sending us information"));
// next_tip_of_day(tips_of_day);
// surface_restorer tip_of_day_restorer;
// draw_tip_of_day(screen, tips_of_day, gui::dialog_frame::titlescreen_style,
// &previous_tip_button, &next_tip_button, NULL/*&help_tip_button*/, &main_dialog_area, tip_of_day_restorer);
// const int pad = game_config::title_tip_padding;
// beg_button.set_location(screen.w() - pad - beg_button.location().w,
// screen.h() - pad - beg_button.location().h);
events::raise_draw_event();
LOG_DP << "drew buttons dialog\n";
// draw logo over everything
#ifdef __IPAD__
std::string path = game_config::path + "/data/core/images/misc/logo.png";
#else
std::string path = game_config::path + "/data/core/images/misc/logo_small.png";
#endif
surface logo_surface = IMG_Load(path.c_str());
//blit_surface(480-logo_surface.get()->w, 0, logo_surface);
CKey key;
size_t keyboard_button = nbuttons;
bool key_processed = false;
// update_whole_screen();
background_is_dirty_ = false;
titlescreen_handler ts_handler(key[SDLK_ESCAPE] != 0); //!= 0 to avoid a MSVC warning C4800
LOG_DP << "entering interactive loop...\n";
memory_stats("At titlescreen");
// Initialize OpenFeint now
of_init();
for(;;) {
events::pump();
for(size_t b = 0; b != buttons.size(); ++b) {
if(buttons[b].pressed()) {
free_title();
return static_cast<TITLE_RESULT>(b + NEW_CAMPAIGN);
}
}
/* if(previous_tip_button.pressed()) {
next_tip_of_day(tips_of_day, true);
draw_tip_of_day(screen, tips_of_day, gui::dialog_frame::titlescreen_style,
&previous_tip_button, &next_tip_button, &help_tip_button, &main_dialog_area, tip_of_day_restorer);
}
if(next_tip_button.pressed()) {
next_tip_of_day(tips_of_day, false);
draw_tip_of_day(screen, tips_of_day, gui::dialog_frame::titlescreen_style,
&previous_tip_button, &next_tip_button, &help_tip_button, &main_dialog_area, tip_of_day_restorer);
}
*/
// if(help_tip_button.pressed()) {
// return SHOW_HELP;
// }
// if(beg_button.pressed()) {
// return BEG_FOR_UPLOAD;
// }
if (key[SDLK_UP]) {
if (!key_processed) {
buttons[keyboard_button].set_active(false);
if (keyboard_button == 0) {
keyboard_button = nbuttons - 1;
} else {
keyboard_button--;
}
key_processed = true;
buttons[keyboard_button].set_active(true);
}
} else if (key[SDLK_DOWN]) {
if (!key_processed) {
buttons[keyboard_button].set_active(false);
if (keyboard_button > nbuttons - 1) {
keyboard_button = 0;
} else {
keyboard_button++;
}
key_processed = true;
buttons[keyboard_button].set_active(true);
}
} else {
key_processed = false;
}
events::raise_process_event();
// KP: redraw
draw_background(screen);
main_frame.draw_background();
main_frame.draw_border();
events::raise_draw_event();
//blit_surface(480-logo_surface.get()->w, 0, logo_surface);
#ifdef __IPAD__
blit_surface(-10, 0, logo_surface);
#else
blit_surface(-15, -10, logo_surface);
#endif
screen.flip();
// if (key[SDLK_ESCAPE] && !ts_handler.get_esc_ignore())
// return QUIT_GAME;
if (key[SDLK_F5])
return RELOAD_GAME_DATA;
if (key[SDLK_RETURN] && keyboard_button < nbuttons) {
return static_cast<TITLE_RESULT>(keyboard_button + NEW_CAMPAIGN);
}
// If the resolution has changed due to the user resizing the screen,
// or from changing between windowed and fullscreen:
if(screen.video().modeChanged()) {
return REDRAW_BACKGROUND;
}
screen.delay(10);
}
free_title();
return REDRAW_BACKGROUND;
}
int fvl_srio_init(fvl_srio_init_param_t *srio_param)
{
fvl_srio_context_t *psrio = &g_srio_context;
fvl_srio_portpool_t *ppool;
fvl_srio_ctrlblk_t *pscb,*cscb,*re_cscb;
uint32_t chan_num=srio_param->chan_num;
uint32_t buf_num=srio_param->buf_num;
uint32_t buf_size=srio_param->buf_size;
uint32_t chan_size=srio_param->chan_size;
uint32_t ctl_size= FVL_CTL_WIN_SIZE;
uint32_t port_num=srio_param->port_num;
fvl_dma_pool_t *port_dma_wr = srio_param->port_rd_buf;
fvl_dma_pool_t *port_dma_ctl_wp;
fvl_dma_pool_t *port_dma_ctl_wr;
uint32_t win_size=chan_size*chan_num;
uint32_t ctl_win_size=0x1000;//ctl_size*chan_num;
uint32_t win_law=0,ctl_law=0;
struct srio_dev *sriodev;
int rvl;
if((port_num >= FVL_SRIO_PORT_NUM) || (port_num <0))
{
FVL_LOG("port number error:%d\n",port_num);
return -1;
}
if((chan_num > FVL_PORT_CHAN_NUM_MAX) || ( chan_num<0))
{
FVL_LOG("channel number error:%d\n",chan_num);
return -1;
}
if(!init_flag)
{
of_init();
rvl = fsl_srio_uio_init(&sriodev);
if (rvl < 0)
{
FVL_LOG("%s(): fsl_srio_uio_init return %d\n", __func__, rvl);
return rvl;
}
psrio->sriodev=sriodev;
init_flag=1;
}
else
{
sriodev=psrio->sriodev;
}
//mode slave
head_port[port_num].re_flag=1;
head_port[port_num].uflag=0;
int i=0;
int j=FVL_PORT_CHAN_NUM_MAX*port_num;
FVL_LOG("Slave: chan_num %d\n",chan_num);
for(i=0;i<chan_num;i++)
{
head_channel[j+i].re_flag=1;
head_channel[j+i].uflag=0;
}
psrio->chan_num[port_num]=chan_num;
struct srio_port_info *pinfo;
void *range;
pinfo = &psrio->portpool[port_num].port_info;
fsl_srio_connection(sriodev,port_num);
if (fsl_srio_port_connected(sriodev) & (0x1 << port_num))
{
fsl_srio_get_port_info(sriodev, port_num+1, pinfo, &range);
psrio->portpool[port_num].range_virt = range;
FVL_LOG("Get port %u info, range=%p, range_start=%llx ,range_size=%llx\n", port_num, range, pinfo->range_start,pinfo->range_size);
}
else
{
FVL_LOG("%s(): fsl_srio_connection port %d failed\n", __func__, port_num+1);
return -1;
}
rvl = fsl_srio_port_connected(sriodev);
if (rvl <= 0)
{
FVL_LOG("%s(): fsl_srio_port_connected return %d\n", __func__, rvl);
return -1;
}
FVL_LOG("*****************************************************\n");
rvl = dma_pool_init(&port_dma_ctl_wp,ctl_win_size,ctl_win_size/2);
if(rvl!=0)
{
FVL_LOG("port %d dma_pool_init failed!\n",port_num+1);
return -errno;
}
rvl = dma_pool_init(&port_dma_ctl_wr,ctl_win_size,ctl_win_size/2);
if(rvl!=0)
{
FVL_LOG("port %d dma_pool_init failed!\n",port_num+1);
return -errno;
}
FVL_LOG("*********************dma pool init end**************\n");
uint32_t attr_read, attr_write;
attr_read = srio_test_win_attrv[3];
attr_write = srio_test_win_attrv[0];
FVL_LOG("attr_write = %u, srio_type = 0\n", attr_write);
ppool = &psrio->portpool[port_num];
ppool->write_result = port_dma_wr->dma_phys_base;
ppool->pwrite_result = port_dma_wr->dma_virt_base;
ppool->write_ctl_result = port_dma_ctl_wr->dma_phys_base;
ppool->write_ctl_data = port_dma_ctl_wp->dma_phys_base;
ppool->pwrite_ctl_result = port_dma_ctl_wr->dma_virt_base;
ppool->pwrite_ctl_data = port_dma_ctl_wp->dma_virt_base;
ctl_law=FVL_BASE_LAW+fvl_get_law((ctl_win_size/FVL_BASE_LAW_SIZE)-1);
FVL_LOG("ctl law:%d\n",ctl_law);
fsl_srio_set_ibwin(sriodev, port_num, 2, ppool->write_ctl_result,
FVL_SRIO_CTL_ADDR, ctl_law);
rvl=fsl_srio_set_deviceid(sriodev,port_num,source_id[port_num]);
if(rvl!=0)
{
FVL_LOG("SRIO port %d set source_id faile!\n",port_num);
return -errno;
}
rvl=fsl_srio_set_targetid(sriodev,port_num,1,target_id[port_num]);
if(rvl!=0)
{
FVL_LOG("SRIO port %d set target_id faile!\n",port_num);
return -errno;
}
rvl=fsl_srio_set_targetid(sriodev,port_num,2,target_id[port_num]);
if(rvl!=0)
{
FVL_LOG("SRIO port %d set target_id faile!\n",port_num);
return -errno;
}
fsl_srio_set_err_rate_degraded_threshold(sriodev,port_num,0);
fsl_srio_set_err_rate_failed_threshold(sriodev,port_num,0);
fsl_srio_set_phy_retry_threshold(sriodev,port_num,0,0);
memset(port_dma_wr->dma_virt_base,0x5a,win_size);
memset(port_dma_ctl_wp->dma_virt_base,0,ctl_win_size);
memset(port_dma_ctl_wr->dma_virt_base,0,ctl_win_size);
fvl_srio_channel_t *temp_channel;
for(i=0;i<FVL_PORT_CHAN_NUM_MAX;i++)
{
pscb=fvl_srio_getcb(port_num,i*2);
if(pscb==NULL)
{
FVL_LOG("port:%d channel:%d : dmadev init error.\n",port_num+1,2*i);
return -1;
}
temp_channel=&srio_channel_context[FVL_PORT_CHAN_NUM_MAX*port_num+i];
cscb=&(temp_channel->chanblk);
cscb->dmadev=pscb->dmadev;
cscb->bfnum=pscb->bfnum;
cscb->port = pscb->port;
pscb=fvl_srio_getcb(port_num,i*2+1);
if(pscb==NULL)
{
FVL_LOG("port:%d channel:%d : dmadev init error.\n",port_num+1,2*i+1);
return -1;
}
re_cscb=&(temp_channel->rechanblk);
re_cscb->dmadev=pscb->dmadev;
re_cscb->bfnum=pscb->bfnum;
re_cscb->port = pscb->port;
}
//create thread:
FVL_LOG("port_num:%d\n",port_num);
head_arg[port_num].num = port_num;
head_arg[port_num].cpu = port_num+1;
head_arg[port_num].op_mode = 0;
head_arg[port_num].buf_virt=ppool->pwrite_ctl_result;
rvl = pthread_create(&(psrio->chan_id[port_num]), NULL,fvl_srio_recv_head, &head_arg[port_num]);
if (rvl)
{
FVL_LOG("Create receive packet thread error!\n");
return -errno;
}
FVL_LOG("SRIO Initial complete\n");
return 0;
}
int main(int argc, char *argv[])
{
struct srio_dev *sriodev;
struct dma_ch *dmadev;
struct dma_pool *dmapool = NULL;
int i, err;
struct srio_port_data *port_data;
int cli_argc;
char *cli, **cli_argv;
of_init();
err = fsl_srio_uio_init(&sriodev);
if (err < 0)
error(EXIT_FAILURE, -err, "%s(): srio_uio_init()", __func__);
port_num = fsl_srio_get_port_num(sriodev);
memset(&cmd_param, 0, sizeof(cmd_param));
cmd_param.port = malloc(sizeof(struct cmd_port_param) * port_num);
if (!cmd_param.port) {
error(0, errno, "%s(): command port", __func__);
goto err_cmd_malloc;
}
memset(cmd_param.port, 0, sizeof(struct cmd_port_param));
port_data = malloc(sizeof(struct srio_port_data) * port_num);
if (!port_data) {
error(0, errno, "%s(): port_data", __func__);
goto err_cmd_malloc;
}
for (i = 0; i < port_num; i++) {
fsl_srio_connection(sriodev, i);
fsl_srio_get_port_info(sriodev, i + 1, &port_data[i].port_info,
&port_data[i].range_virt);
}
err = fsl_srio_port_connected(sriodev);
if (err <= 0) {
error(0, -err, "%s(): fsl_srio_port_connected", __func__);
goto err_srio_connected;
}
err = dma_pool_init(&dmapool);
for (i = 0; i < port_num; i++) {
dma_addr_t port_phys_base =
dmapool->dma_phys_base + SRIO_POOL_PORT_OFFSET * i;
port_data[i].phys.write_recv_data = port_phys_base;
port_data[i].phys.read_recv_data =
port_phys_base + SRIO_POOL_SECT_SIZE;
port_data[i].phys.write_data_prep =
port_phys_base + SRIO_POOL_SECT_SIZE * 2;
port_data[i].phys.res =
port_phys_base + SRIO_POOL_SECT_SIZE * 3;
port_data[i].virt = (typeof(port_data[i].virt))
(dmapool->dma_virt_base + i * SRIO_POOL_PORT_OFFSET);
fsl_srio_set_ibwin(sriodev, i, 1,
port_data[i].phys.write_recv_data,
SRIO_SYS_ADDR, LAWAR_SIZE_2M);
}
err = fsl_dma_chan_init(&dmadev, 0, 0);
if (err < 0) {
error(0, -err, "%s(): fsl_dma_chan_init()", __func__);
goto err_srio_connected;
}
err = fsl_dma_chan_init(&dmadev1, 0, 1);
if (err < 0) {
error(0, -err, "%s(): fsl_dma_chan_init()", __func__);
goto err_srio_connected;
}
err = fsl_dma_chan_init(&dmadev2, 1, 1);
if (err < 0) {
error(0, -err, "%s(): fsl_dma_chan_init()", __func__);
goto err_srio_connected;
}
fsl_srio_err_handle_enable(sriodev);
/* Run the CLI loop */
while (1) {
/* Get CLI input */
cli = readline(sra_prompt);
if (unlikely((cli == NULL) || strncmp(cli, "q", 1) == 0))
break;
if (cli[0] == 0) {
free(cli);
continue;
}
cli_argv = history_tokenize(cli);
if (unlikely(cli_argv == NULL)) {
error(EXIT_SUCCESS, 0,
"Out of memory while parsing: %s", cli);
free(cli);
continue;
}
for (cli_argc = 0; cli_argv[cli_argc] != NULL; cli_argc++)
;
add_history(cli);
err = cmd_translate(cli_argc, cli_argv);
if (err < 0)
cmd_format_print();
for (cli_argc = 0; cli_argv[cli_argc] != NULL; cli_argc++)
free(cli_argv[cli_argc]);
free(cli_argv);
free(cli);
if (err < 0)
continue;
fsl_dma_chan_basic_direct_init(dmadev);
cmd_implement(sriodev, dmadev, port_data);
}
free(port_data);
free(cmd_param.port);
fsl_dma_chan_finish(dmadev);
fsl_dma_chan_finish(dmadev1);
fsl_dma_chan_finish(dmadev2);
dma_pool_finish(dmapool);
fsl_srio_uio_finish(sriodev);
of_finish();
return EXIT_SUCCESS;
err_srio_connected:
free(port_data);
free(cmd_param.port);
err_cmd_malloc:
fsl_srio_uio_finish(sriodev);
of_finish();
return err;
}
extern "C" int main(int argcount, char** argvec)
{
#ifdef NO_STDERR
std::freopen("/dev/null", "w", stderr);
std::cerr.sync_with_stdio(true);
#endif
std::cerr << "Frogatto engine version " << preferences::version() << "\n";
LOG( "After print engine version" );
#if defined(TARGET_BLACKBERRY)
chdir("app/native");
std::cout<< "Changed working directory to: " << getcwd(0, 0) << std::endl;
#endif
std::string level_cfg = "titlescreen.cfg";
bool unit_tests_only = false, skip_tests = false;
bool run_benchmarks = false;
std::vector<std::string> benchmarks_list;
std::string utility_program;
std::vector<std::string> util_args;
std::string server = "wesnoth.org";
const char* profile_output = NULL;
std::string profile_output_buf;
std::string orig_level_cfg = level_cfg;
std::string override_level_cfg = "";
int modules_loaded = 0;
std::vector<std::string> argv;
for(int n = 1; n < argcount; ++n) {
argv.push_back(argvec[n]);
if(argv.size() >= 2 && argv[argv.size()-2] == "-NSDocumentRevisionsDebugMode" && argv.back() == "YES") {
//XCode passes these arguments by default when debugging -- make sure they are ignored.
argv.resize(argv.size()-2);
}
}
if(sys::file_exists("./master-config.cfg")) {
variant cfg = json::parse_from_file("./master-config.cfg");
if(cfg.is_map()) {
if( cfg["id"].is_null() == false) {
preferences::set_preferences_path_from_module(cfg["id"].as_string());
//XXX module::set_module_name(cfg["id"].as_string(), cfg["id"].as_string());
}
if(cfg["arguments"].is_null() == false) {
std::vector<std::string> additional_args = cfg["arguments"].as_list_string();
argv.insert(argv.begin(), additional_args.begin(), additional_args.end());
}
}
}
for(int n = 0; n < argv.size(); ++n) {
const int argc = argv.size();
const std::string arg(argv[n]);
std::string arg_name, arg_value;
std::string::const_iterator equal = std::find(arg.begin(), arg.end(), '=');
if(equal != arg.end()) {
arg_name = std::string(arg.begin(), equal);
arg_value = std::string(equal+1, arg.end());
}
if(arg_name == "--module") {
if(load_module(arg_value, &argv) != 0) {
std::cerr << "FAILED TO LOAD MODULE: " << arg_value << "\n";
return -1;
}
++modules_loaded;
}
}
if(modules_loaded == 0) {
if(load_module(DEFAULT_MODULE, &argv) != 0) {
std::cerr << "FAILED TO LOAD MODULE: " << DEFAULT_MODULE << "\n";
return -1;
}
}
preferences::load_preferences();
LOG( "After load_preferences()" );
// load difficulty settings after module, before rest of args.
difficulty::manager();
for(int n = 0; n < argv.size(); ++n) {
const int argc = argv.size();
const std::string arg(argv[n]);
std::string arg_name, arg_value;
std::string::const_iterator equal = std::find(arg.begin(), arg.end(), '=');
if(equal != arg.end()) {
arg_name = std::string(arg.begin(), equal);
arg_value = std::string(equal+1, arg.end());
}
if(arg_name == "--module") {
// ignore already processed.
} else if(arg_name == "--profile" || arg == "--profile") {
profile_output_buf = arg_value;
profile_output = profile_output_buf.c_str();
} else if(arg_name == "--utility") {
utility_program = arg_value;
for(++n; n < argc; ++n) {
const std::string arg(argv[n]);
util_args.push_back(arg);
}
break;
} else if(arg == "--benchmarks") {
run_benchmarks = true;
} else if(arg_name == "--benchmarks") {
run_benchmarks = true;
benchmarks_list = util::split(arg_value);
} else if(arg == "--tests") {
unit_tests_only = true;
} else if(arg == "--no-tests") {
skip_tests = true;
} else if(arg == "--width" && n+1 < argc) {
std::string w(argv[++n]);
preferences::set_actual_screen_width(boost::lexical_cast<int>(w));
} else if(arg == "--height" && n+1 < argc) {
std::string h(argv[++n]);
preferences::set_actual_screen_height(boost::lexical_cast<int>(h));
} else if(arg == "--level" && n+1 < argc) {
override_level_cfg = argv[++n];
} else if(arg == "--host" && n+1 < argc) {
server = argv[++n];
} else if(arg == "--compiled") {
preferences::set_load_compiled(true);
#ifndef NO_EDITOR
} else if(arg == "--edit") {
preferences::set_edit_on_start(true);
#endif
} else if(arg == "--no-compiled") {
preferences::set_load_compiled(false);
#if defined(TARGET_PANDORA)
} else if(arg == "--no-fbo") {
preferences::set_fbo(false);
} else if(arg == "--no-bequ") {
preferences::set_bequ(false);
#endif
} else if(arg == "--help" || arg == "-h") {
print_help(std::string(argvec[0]));
return 0;
} else {
const bool res = preferences::parse_arg(argv[n].c_str());
if(!res) {
std::cerr << "unrecognized arg: '" << arg << "'\n";
return -1;
}
}
}
checksum::manager checksum_manager;
preferences::expand_data_paths();
LOG( "After expand_data_paths()" );
std::cerr << "Preferences dir: " << preferences::user_data_path() << '\n';
//make sure that the user data path exists.
if(!preferences::setup_preferences_dir()) {
std::cerr << "cannot create preferences dir!\n";
}
std::cerr << "\n";
if(utility_program.empty() == false && test::utility_needs_video(utility_program) == false) {
test::run_utility(utility_program, util_args);
return 0;
}
#if defined(TARGET_PANDORA)
EGL_Open();
#endif
#if defined(__ANDROID__)
std::freopen("stdout.txt","w",stdout);
std::freopen("stderr.txt","w",stderr);
std::cerr.sync_with_stdio(true);
#endif
LOG( "Start of main" );
Uint32 sdl_init_flags = SDL_INIT_VIDEO | SDL_INIT_JOYSTICK;
#ifdef _WINDOWS
sdl_init_flags |= SDL_INIT_TIMER;
#endif
if(SDL_Init(sdl_init_flags) < 0) {
std::cerr << "could not init SDL\n";
return -1;
}
LOG( "After SDL_Init" );
#ifdef TARGET_OS_HARMATTAN
g_type_init();
#endif
i18n::init ();
LOG( "After i18n::init()" );
// SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 1);
#if defined(TARGET_OS_IPHONE) || defined(TARGET_BLACKBERRY) || defined(__ANDROID__)
//on the iPhone and PlayBook, try to restore the auto-save if it exists
if(sys::file_exists(preferences::auto_save_file_path()) && sys::read_file(std::string(preferences::auto_save_file_path()) + ".stat") == "1") {
level_cfg = "autosave.cfg";
sys::write_file(std::string(preferences::auto_save_file_path()) + ".stat", "0");
}
#endif
if(override_level_cfg.empty() != true) {
level_cfg = override_level_cfg;
orig_level_cfg = level_cfg;
}
#if TARGET_OS_IPHONE || TARGET_IPHONE_SIMULATOR
int width, height;
iphone_screen_res(&width, &height);
preferences::set_actual_screen_width(width);
preferences::set_actual_screen_height(height);
int multiplier = 2;
if (width > 320)
{
//preferences::set_use_pretty_scaling(true);
multiplier = 1;
}
preferences::set_virtual_screen_width(height*multiplier);
preferences::set_virtual_screen_height(width*multiplier);
preferences::set_control_scheme(height % 1024 ? "iphone_2d" : "ipad_2d");
SDL_WindowID windowID = SDL_CreateWindow (NULL, 0, 0, preferences::actual_screen_width(), preferences::actual_screen_height(),
SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN |
SDL_WINDOW_BORDERLESS);
if (windowID == 0) {
std::cerr << "Could not create window: " << SDL_GetError() << "\n";
return -1;
}
// if (SDL_GL_CreateContext(windowID) == 0) {
// std::cerr << "Could not create GL context: " << SDL_GetError() << "\n";
// return -1;
// }
if (SDL_CreateRenderer(windowID, -1, 0) != 0) {
std::cerr << "Could not create renderer\n";
return -1;
}
#else
#ifdef TARGET_OS_HARMATTAN
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 1);
if (SDL_SetVideoMode(preferences::actual_screen_width(),preferences::actual_screen_height(),0,SDL_OPENGLES | SDL_FULLSCREEN) == NULL) {
std::cerr << "could not set video mode\n";
return -1;
}
preferences::init_oes();
SDL_ShowCursor(0);
#else
#ifndef __APPLE__
graphics::surface wm_icon = graphics::surface_cache::get("window-icon.png");
if(!wm_icon.null()) {
SDL_WM_SetIcon(wm_icon, NULL);
}
#endif
#if defined(TARGET_PANDORA)
if (SDL_SetVideoMode(preferences::actual_screen_width(),preferences::actual_screen_height(),16,SDL_FULLSCREEN) == NULL) {
std::cerr << "could not set video mode\n";
return -1;
}
EGL_Init();
preferences::init_oes();
#elif defined(TARGET_TEGRA)
//if (SDL_SetVideoMode(preferences::actual_screen_width(),preferences::actual_screen_height(),0,preferences::resizable() ? SDL_RESIZABLE : 0|preferences::fullscreen() ? SDL_FULLSCREEN : 0) == NULL) {
if (SDL_SetVideoMode(preferences::actual_screen_width(),preferences::actual_screen_height(),0,SDL_FULLSCREEN) == NULL) {
std::cerr << "could not set video mode\n";
return -1;
}
EGL_Init();
preferences::init_oes();
#elif defined(TARGET_BLACKBERRY)
if (SDL_SetVideoMode(preferences::actual_screen_width(),preferences::actual_screen_height(),0,SDL_OPENGL|SDL_FULLSCREEN) == NULL) {
std::cerr << "could not set video mode\n";
return -1;
}
preferences::init_oes();
#elif defined(__ANDROID__)
SDL_Rect** r = SDL_ListModes(NULL, SDL_FULLSCREEN|SDL_OPENGL);
if( r != (SDL_Rect**)0 && r != (SDL_Rect**)-1 ) {
preferences::set_actual_screen_width(r[0]->w);
preferences::set_actual_screen_height(r[0]->h);
if(r[0]->w < 640) {
preferences::set_virtual_screen_width(r[0]->w*2);
preferences::set_virtual_screen_height(r[0]->h*2);
} else {
preferences::set_virtual_screen_width(r[0]->w);
preferences::set_virtual_screen_height(r[0]->h);
}
preferences::set_control_scheme(r[0]->h >= 1024 ? "ipad_2d" : "android_med");
}
if (SDL_SetVideoMode(preferences::actual_screen_width(),preferences::actual_screen_height(),16,SDL_FULLSCREEN|SDL_OPENGL) == NULL) {
std::cerr << "could not set video mode\n";
return -1;
}
#else
if (SDL_SetVideoMode(preferences::actual_screen_width(),preferences::actual_screen_height(),0,SDL_OPENGL|(preferences::resizable() ? SDL_RESIZABLE : 0)|(preferences::fullscreen() ? SDL_FULLSCREEN : 0)) == NULL) {
std::cerr << "could not set video mode\n";
return -1;
}
#endif
#endif
#endif
// srand(time(NULL));
const stats::manager stats_manager;
#ifndef NO_EDITOR
const external_text_editor::manager editor_manager;
#endif // NO_EDITOR
std::cerr
<< "\n"
<< "OpenGL vendor: " << reinterpret_cast<const char *>(glGetString(GL_VENDOR)) << "\n"
<< "OpenGL version: " << reinterpret_cast<const char *>(glGetString(GL_VERSION)) << "\n"
<< "OpenGL extensions: " << reinterpret_cast<const char *>(glGetString(GL_EXTENSIONS)) << "\n"
<< "\n";
glShadeModel(GL_SMOOTH);
glEnable(GL_BLEND);
glEnable(GL_TEXTURE_2D);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
SDL_WM_SetCaption(module::get_module_pretty_name().c_str(), module::get_module_pretty_name().c_str());
std::cerr << "JOYSTICKS: " << SDL_NumJoysticks() << "\n";
const load_level_manager load_manager;
{ //manager scope
const font::manager font_manager;
const sound::manager sound_manager;
const joystick::manager joystick_manager;
#if !TARGET_OS_IPHONE && !TARGET_IPHONE_SIMULATOR
const SDL_Surface* fb = SDL_GetVideoSurface();
if(fb == NULL) {
return 0;
}
#endif
graphics::texture::manager texture_manager;
#ifndef NO_EDITOR
editor::manager editor_manager;
#endif
variant preloads;
loading_screen loader;
try {
sound::init_music(json::parse_from_file(module::map_file("data/music.cfg")));
std::string filename = "data/fonts." + i18n::get_locale() + ".cfg";
if (!sys::file_exists(filename))
filename = "data/fonts.cfg";
graphical_font::init(json::parse_from_file(module::map_file(filename)));
preloads = json::parse_from_file(module::map_file("data/preload.cfg"));
int preload_items = preloads["preload"].num_elements();
loader.set_number_of_items(preload_items+7); // 7 is the number of items that will be loaded below
custom_object::init();
loader.draw_and_increment(_("Initializing custom object functions"));
init_custom_object_functions(json::parse_from_file(module::map_file("data/functions.cfg")));
loader.draw_and_increment(_("Initializing textures"));
loader.load(preloads);
loader.draw_and_increment(_("Initializing tiles"));
tile_map::init(json::parse_from_file(module::map_file("data/tiles.cfg")));
loader.draw_and_increment(_("Initializing GUI"));
variant gui_node = json::parse_from_file(module::map_file(preferences::load_compiled() ? "data/compiled/gui.cfg" : "data/gui.cfg"));
gui_section::init(gui_node);
loader.draw_and_increment(_("Initializing GUI"));
framed_gui_element::init(gui_node);
} catch(const json::parse_error& e) {
std::cerr << "ERROR PARSING: " << e.error_message() << "\n";
return 0;
}
loader.draw(_("Loading level"));
if(!skip_tests && !test::run_tests()) {
return -1;
}
if(unit_tests_only) {
return 0;
}
#if defined(__APPLE__) && !(TARGET_IPHONE_SIMULATOR || TARGET_OS_IPHONE)
GLint swapInterval = 1;
CGLSetParameter(CGLGetCurrentContext(), kCGLCPSwapInterval, &swapInterval);
#endif
#ifndef SDL_VIDEO_OPENGL_ES
GLenum glew_status = glewInit();
ASSERT_EQ(glew_status, GLEW_OK);
#endif
loader.finish_loading();
//look to see if we got any quit events while loading.
{
SDL_Event event;
while(SDL_PollEvent(&event)) {
if(event.type == SDL_QUIT) {
return 0;
}
}
}
formula_profiler::manager profiler(profile_output);
texture_frame_buffer::init();
if(run_benchmarks) {
if(benchmarks_list.empty() == false) {
test::run_benchmarks(&benchmarks_list);
} else {
test::run_benchmarks();
}
return 0;
} else if(utility_program.empty() == false) {
test::run_utility(utility_program, util_args);
return 0;
}
bool quit = false;
bool of_initialized = false;
while(!quit && !show_title_screen(level_cfg)) {
boost::intrusive_ptr<level> lvl(load_level(level_cfg));
#if TARGET_OS_IPHONE || TARGET_IPHONE_SIMULATOR
if (!of_initialized)
{
of_init();
of_initialized = true;
}
#endif
//see if we're loading a multiplayer level, in which case we
//connect to the server.
multiplayer::manager mp_manager(lvl->is_multiplayer());
if(lvl->is_multiplayer()) {
multiplayer::setup_networked_game(server);
}
if(lvl->is_multiplayer()) {
last_draw_position() = screen_position();
std::string level_cfg = "waiting-room.cfg";
boost::intrusive_ptr<level> wait_lvl(load_level(level_cfg));
wait_lvl->finish_loading();
wait_lvl->set_multiplayer_slot(0);
if(wait_lvl->player()) {
wait_lvl->player()->set_current_level(level_cfg);
}
wait_lvl->set_as_current_level();
level_runner runner(wait_lvl, level_cfg, orig_level_cfg);
multiplayer::sync_start_time(*lvl, boost::bind(&level_runner::play_cycle, &runner));
lvl->set_multiplayer_slot(multiplayer::slot());
}
last_draw_position() = screen_position();
assert(lvl.get());
if(!lvl->music().empty()) {
sound::play_music(lvl->music());
}
if(lvl->player() && level_cfg != "autosave.cfg") {
lvl->player()->set_current_level(level_cfg);
lvl->player()->get_entity().save_game();
}
set_scene_title(lvl->title());
try {
quit = level_runner(lvl, level_cfg, orig_level_cfg).play_level();
level_cfg = orig_level_cfg;
} catch(multiplayer_exception&) {
}
}
level::clear_current_level();
} //end manager scope, make managers destruct before calling SDL_Quit
// controls::debug_dump_controls();
#if defined(TARGET_PANDORA) || defined(TARGET_TEGRA)
EGL_Destroy();
#endif
SDL_Quit();
preferences::save_preferences();
std::cerr << SDL_GetError() << "\n";
#if !defined(TARGET_OS_HARMATTAN) && !defined(TARGET_TEGRA) && !defined(TARGET_BLACKBERRY) && !defined(__ANDROID__)
std::cerr << gluErrorString(glGetError()) << "\n";
#endif
return 0;
}
int main(int argc, char *argv[])
{
struct srio_dev *sriodev;
struct dma_ch *send_dmadev[SEND_THREAD_NUM];
struct dma_ch *receive_dmadev[RECEIVE_THREAD_NUM];
struct dma_pool *dmapool = NULL;
int i, err;
struct srio_port_data *port_data;
uint32_t attr_read, attr_write;
struct task_arg_type task_arg_send[SEND_THREAD_NUM];
struct task_arg_type task_arg_receive[RECEIVE_THREAD_NUM];
pthread_t send_id[SEND_THREAD_NUM];
pthread_t receive_id[RECEIVE_THREAD_NUM];
of_init();
err = fsl_srio_uio_init(&sriodev);
if (err < 0)
error(EXIT_FAILURE, -err, "%s(): srio_uio_init()", __func__);
port_num = fsl_srio_get_port_num(sriodev);
memset(&cmd_param, 0, sizeof(cmd_param));
/*ctx add*/
cmd_param.curr_port_id=0;
cmd_param.start_cpu=1;
cmd_param.passes=10;
cmd_param.test_type=0;
cmd_param.test_srio_type=0;
if (argc<3)
{
cmd_format_print();
return -1;
}
err = cmd_translate(argc, argv,&cmd_param);
if(err==2)
{
return 0;
}
if ((err < 0) ||(argc<3))
{
cmd_format_print();
return -1;
}
port_data = malloc(sizeof(struct srio_port_data) * port_num);
if (!port_data) {
error(0, errno, "%s(): port_data", __func__);
goto err_cmd_malloc;
}
for (i = 0; i < port_num; i++) {
fsl_srio_connection(sriodev, i);
fsl_srio_get_port_info(sriodev, i + 1, &port_data[i].port_info,
&port_data[i].range_virt);
}
err = fsl_srio_port_connected(sriodev);
if (err <= 0) {
error(0, -err, "%s(): fsl_srio_port_connected", __func__);
goto err_srio_connected;
}
uint8_t flag=0;
if(cmd_param.test_type==1)
{
for (i = 0; i < port_num; i++) {
if(srio_link(sriodev,i))
{
printf("port %d sucess!\n",i);
fflush(stdout);
}
else
{
printf("port %d failed!\n",i);
fflush(stdout);
flag++;
}
}
if(flag != 0)
return -1;
return 0;
}
err = dma_pool_init(&dmapool);
uint8_t port = cmd_param.curr_port_id;
attr_read = srio_test_win_attrv[3];
attr_write = srio_test_win_attrv[cmd_param.test_srio_type];
for (i = 0; i < port_num; i++) {
dma_addr_t port_phys_base =
dmapool->dma_phys_base + SRIO_POOL_PORT_OFFSET * i;
port_data[i].phys.write_recv_data = port_phys_base;
port_data[i].phys.read_recv_data =
port_phys_base + SRIO_POOL_SECT_SIZE;
port_data[i].phys.write_data_prep =
port_phys_base + SRIO_POOL_SECT_SIZE * 2;
port_data[i].phys.res =
port_phys_base + SRIO_POOL_SECT_SIZE * 3;
port_data[i].virt = (typeof(port_data[i].virt))
(dmapool->dma_virt_base + i * SRIO_POOL_PORT_OFFSET);
fsl_srio_set_ibwin(sriodev, i, 1,
port_data[i].phys.write_recv_data,
SRIO_SYS_ADDR, LAWAR_SIZE_8M);
fsl_srio_set_ibwin(sriodev, i, 2,
port_data[i].phys.write_recv_data+0x800000,
SRIO_ctl_ADDR, LAWAR_SIZE_8M);
if (fsl_srio_port_connected(sriodev) & (0x1 << i)) {
fsl_srio_set_obwin(sriodev, i, 1,
port_data[i].port_info.range_start,
SRIO_SYS_ADDR, LAWAR_SIZE_8M);
fsl_srio_set_obwin_attr(sriodev, i, 1,
attr_read, attr_write);
fsl_srio_set_obwin(sriodev, i, 2,
port_data[i].port_info.range_start+0x800000,
SRIO_ctl_ADDR, LAWAR_SIZE_8M);
fsl_srio_set_obwin_attr(sriodev, i, 2,
attr_read, attr_write);
} else {
printf("SRIO port %d error!\n", i + 1);
fflush(stdout);
return -errno;
}
memset(port_data[i].virt,0,SRIO_POOL_PORT_OFFSET);
}
err = fsl_srio_set_targetid(sriodev,0,1,0x11);
if(err!=0)
{
printf("sro set targetid failed!\n");
fflush(stdout);
}
err = fsl_srio_set_targetid(sriodev,1,1,0x14);
if(err!=0)
{
printf("sro set targetid failed!\n");
fflush(stdout);
}
err = fsl_srio_set_targetid(sriodev,0,2,0x11);
if(err!=0)
{
printf("sro set targetid failed!\n");
fflush(stdout);
}
err = fsl_srio_set_targetid(sriodev,1,2,0x14);
if(err!=0)
{
printf("sro set targetid failed!\n");
fflush(stdout);
}
/*ctx add*/
sleep(5);
for(i=0;i<1;i++)
{
err = fsl_dma_chan_init(&send_dmadev[i], 0, i);
if (err < 0) {
error(0, -err, "%s(): fsl_dma_chan_init()", __func__);
goto err_srio_connected;
}
err = fsl_dma_chan_init(&receive_dmadev[i], 1, i);
if (err < 0) {
error(0, -err, "%s(): fsl_dma_chan_init()", __func__);
goto err_srio_connected;
}
fsl_dma_chan_basic_direct_init(send_dmadev[i]);
fsl_dma_chan_bwc(send_dmadev[i], DMA_BWC_1024);
task_arg_send[i].dmadev = send_dmadev[i];
fsl_dma_chan_basic_direct_init(receive_dmadev[i]);
fsl_dma_chan_bwc(receive_dmadev[i], DMA_BWC_1024);
task_arg_receive[i].dmadev = receive_dmadev[i];
task_arg_receive[i].port_data_thread.phys.write_recv_data=port_data[1-port].phys.write_recv_data+THREAD_WIN_SIZE*i;
task_arg_receive[i].port_data_thread.phys.read_recv_data=port_data[1-port].phys.read_recv_data+THREAD_WIN_SIZE*i;
task_arg_receive[i].port_data_thread.phys.write_data_prep=port_data[1-port].phys.write_data_prep+THREAD_WIN_SIZE*i;
task_arg_receive[i].port_data_thread.phys.res=port_data[1-port].phys.res+THREAD_WIN_SIZE*i;
task_arg_receive[i].port_data_thread.virt.write_recv_data = &port_data[1-port].virt->write_recv_data_t[i][0];
task_arg_receive[i].port_data_thread.virt.read_recv_data = &port_data[1-port].virt->read_recv_data_t[i][0];
task_arg_receive[i].port_data_thread.virt.write_data_prep = &port_data[1-port].virt->write_data_prep_t[i][0];
task_arg_receive[i].port_data_thread.virt.res = &port_data[1-port].virt->res_t[i][0];
task_arg_receive[i].port_data_thread.port_info.range_start = port_data[1-port].port_info.range_start+THREAD_WIN_SIZE*i;
task_arg_receive[i].port = 1-port;
task_arg_receive[i].srio_type = cmd_param.test_srio_type;
task_arg_receive[i].cpu = cmd_param.start_cpu;/*bind cpu*/
task_arg_receive[i].passes = cmd_param.passes;/*bind cpu*/
/* ctx add*/
task_arg_send[i].port_data_thread.phys.write_recv_data=port_data[port].phys.write_recv_data+THREAD_WIN_SIZE*i;
task_arg_send[i].port_data_thread.phys.read_recv_data=port_data[port].phys.read_recv_data+THREAD_WIN_SIZE*i;
task_arg_send[i].port_data_thread.phys.write_data_prep=port_data[port].phys.write_data_prep+THREAD_WIN_SIZE*i;
task_arg_send[i].port_data_thread.phys.res=port_data[port].phys.res+THREAD_WIN_SIZE*i;
task_arg_send[i].port_data_thread.virt.write_recv_data = &port_data[port].virt->write_recv_data_t[i][0];
task_arg_send[i].port_data_thread.virt.read_recv_data = &port_data[port].virt->read_recv_data_t[i][0];
task_arg_send[i].port_data_thread.virt.write_data_prep = &port_data[port].virt->write_data_prep_t[i][0];
task_arg_send[i].port_data_thread.virt.res = &port_data[port].virt->res_t[i][0];
task_arg_send[i].port_data_thread.port_info.range_start = port_data[port].port_info.range_start+THREAD_WIN_SIZE*i;
/* cta end*/
task_arg_send[i].port = port;
task_arg_send[i].srio_type = cmd_param.test_srio_type;
task_arg_send[i].cpu = cmd_param.start_cpu+1;/*bind cpu*/
task_arg_send[i].passes = cmd_param.passes;/*bind cpu*/
if(cmd_param.test_type==2)
{
task_arg_send[i].test_type=0;
err = pthread_create(&send_id[i], NULL,t_srio_send, &task_arg_send[i]);
if (err) {
printf("Port %d : Send thread failed!\n",port + 1);
fflush(stdout);
return -errno;
}
sleep(1);
err = pthread_create(&receive_id[i],NULL,t_srio_receive,&task_arg_receive[i]);
if (err) {
printf("Port %d : Receive thread failed!\n",2-port);
fflush(stdout);
return -errno;
}
}
else if(cmd_param.test_type==3)
{
task_arg_send[i].test_type=1;
err = pthread_create(&send_id[i], NULL,t_srio_send, &task_arg_send[i]);
if (err) {
printf("Port %d : Send thread failed!\n",port + 1);
fflush(stdout);
return -errno;
}
}
}
/*multiplie*/
for(i=1;i<SEND_THREAD_NUM;i++)
{
err = fsl_dma_chan_init(&send_dmadev[i], 0, i);
if (err < 0) {
error(0, -err, "%s(): fsl_dma_chan_init()", __func__);
goto err_srio_connected;
}
err = fsl_dma_chan_init(&receive_dmadev[i], 1, i);
if (err < 0) {
error(0, -err, "%s(): fsl_dma_chan_init()", __func__);
goto err_srio_connected;
}
fsl_dma_chan_basic_direct_init(send_dmadev[i]);
fsl_dma_chan_bwc(send_dmadev[i], DMA_BWC_1024);
task_arg_send[i].dmadev = send_dmadev[i];
fsl_dma_chan_basic_direct_init(receive_dmadev[i]);
fsl_dma_chan_bwc(receive_dmadev[i], DMA_BWC_1024);
task_arg_receive[i].dmadev = receive_dmadev[i];
task_arg_receive[i].port_data_thread.phys.write_recv_data=port_data[port].phys.write_recv_data+THREAD_WIN_SIZE*i;
task_arg_receive[i].port_data_thread.phys.read_recv_data=port_data[port].phys.read_recv_data+THREAD_WIN_SIZE*i;
task_arg_receive[i].port_data_thread.phys.write_data_prep=port_data[port].phys.write_data_prep+THREAD_WIN_SIZE*i;
task_arg_receive[i].port_data_thread.phys.res=port_data[port].phys.res+THREAD_WIN_SIZE*i;
task_arg_receive[i].port_data_thread.virt.write_recv_data = &port_data[port].virt->write_recv_data_t[i][0];
task_arg_receive[i].port_data_thread.virt.read_recv_data = &port_data[port].virt->read_recv_data_t[i][0];
task_arg_receive[i].port_data_thread.virt.write_data_prep = &port_data[port].virt->write_data_prep_t[i][0];
task_arg_receive[i].port_data_thread.virt.res = &port_data[port].virt->res_t[i][0];
task_arg_receive[i].port_data_thread.port_info.range_start = port_data[port].port_info.range_start+THREAD_WIN_SIZE*i;
task_arg_receive[i].port = port;
task_arg_receive[i].srio_type = cmd_param.test_srio_type;
task_arg_receive[i].cpu = cmd_param.start_cpu+2;
task_arg_receive[i].passes = cmd_param.passes;
task_arg_send[i].port_data_thread.phys.write_recv_data=port_data[1-port].phys.write_recv_data+THREAD_WIN_SIZE*i;
task_arg_send[i].port_data_thread.phys.read_recv_data=port_data[1-port].phys.read_recv_data+THREAD_WIN_SIZE*i;
task_arg_send[i].port_data_thread.phys.write_data_prep=port_data[1-port].phys.write_data_prep+THREAD_WIN_SIZE*i;
task_arg_send[i].port_data_thread.phys.res=port_data[1-port].phys.res+THREAD_WIN_SIZE*i;
task_arg_send[i].port_data_thread.virt.write_recv_data = &port_data[1-port].virt->write_recv_data_t[i][0];
task_arg_send[i].port_data_thread.virt.read_recv_data = &port_data[1-port].virt->read_recv_data_t[i][0];
task_arg_send[i].port_data_thread.virt.write_data_prep = &port_data[1-port].virt->write_data_prep_t[i][0];
task_arg_send[i].port_data_thread.virt.res = &port_data[1-port].virt->res_t[i][0];
task_arg_send[i].port_data_thread.port_info.range_start = port_data[1-port].port_info.range_start+THREAD_WIN_SIZE*i;
task_arg_send[i].port = 1-port;
task_arg_send[i].srio_type = cmd_param.test_srio_type;
task_arg_send[i].cpu = cmd_param.start_cpu+3;
task_arg_send[i].passes = cmd_param.passes;
if(cmd_param.test_type==2)
{
task_arg_send[i].test_type=0;
err = pthread_create(&send_id[i],NULL,t_srio_send,&task_arg_send[i]);
if (err) {
printf("Port %d : Send thread failed!\n",2-port);
fflush(stdout);
return -errno;
}
sleep(1);
err = pthread_create(&receive_id[i], NULL,t_srio_receive, &task_arg_receive[i]);
if (err) {
printf("Port %d : Send thread failed!\n",port + 1);
fflush(stdout);
return -errno;
}
}else if(cmd_param.test_type==3)
{
task_arg_send[i].test_type=1;
err = pthread_create(&send_id[i],NULL,t_srio_send,&task_arg_send[i]);
if (err) {
printf("Port %d : Send thread failed!\n",2-port);
fflush(stdout);
return -errno;
}
}
}
for(i=0;i<2;i++)
{
if(cmd_param.test_type==2)
{
pthread_join(send_id[i],NULL);
pthread_join(receive_id[i],NULL);
}else if(cmd_param.test_type==3)
{
pthread_join(send_id[i],NULL);
}
}
/*ctx end*/
free(port_data);
for(i=0;i<SEND_THREAD_NUM;i++)
{
fsl_dma_chan_finish(send_dmadev[i]);
fsl_dma_chan_finish(receive_dmadev[i]);
}
dma_pool_finish(dmapool);
fsl_srio_uio_finish(sriodev);
of_finish();
return EXIT_SUCCESS;
err_srio_connected:
free(port_data);
err_cmd_malloc:
fsl_srio_uio_finish(sriodev);
of_finish();
return err;
}
unsigned long
decompress_kernel(unsigned long load_addr, int num_words, unsigned long cksum,
RESIDUAL *residual, void *OFW_interface)
{
int timer;
extern unsigned long start;
char *cp, ch;
unsigned long i;
BATU *u;
BATL *l;
unsigned long TotalMemory;
unsigned long orig_MSR;
int dev_handle;
int mem_info[2];
int res, size;
unsigned char board_type;
unsigned char base_mod;
lines = 25;
cols = 80;
orig_x = 0;
orig_y = 24;
/*
* IBM's have the MMU on, so we have to disable it or
* things get really unhappy in the kernel when
* trying to setup the BATs with the MMU on
* -- Cort
*/
flush_instruction_cache();
_put_HID0(_get_HID0() & ~0x0000C000);
_put_MSR((orig_MSR = _get_MSR()) & ~0x0030);
#if defined(CONFIG_SERIAL_CONSOLE)
com_port = (struct NS16550 *)NS16550_init(0);
#endif /* CONFIG_SERIAL_CONSOLE */
vga_init(0xC0000000);
if (residual)
{
/* Is this Motorola PPCBug? */
if ((1 & residual->VitalProductData.FirmwareSupports) &&
(1 == residual->VitalProductData.FirmwareSupplier)) {
board_type = inb(0x800) & 0xF0;
/* If this is genesis 2 board then check for no
* keyboard controller and more than one processor.
*/
if (board_type == 0xe0) {
base_mod = inb(0x803);
/* if a MVME2300/2400 or a Sitka then no keyboard */
if((base_mod == 0xFA) || (base_mod == 0xF9) ||
(base_mod == 0xE1)) {
keyb_present = 0; /* no keyboard */
}
}
}
memcpy(hold_residual,residual,sizeof(RESIDUAL));
} else {
/* Assume 32M in the absence of more info... */
TotalMemory = 0x02000000;
/*
* This is a 'best guess' check. We want to make sure
* we don't try this on a PReP box without OF
* -- Cort
*/
while (OFW_interface && ((unsigned long)OFW_interface < 0x10000000) )
{
/* The MMU needs to be on when we call OFW */
_put_MSR(orig_MSR);
of_init(OFW_interface);
/* get handle to memory description */
res = of_finddevice("/memory@0",
&dev_handle);
// puthex(res); puts("\n");
if (res) break;
/* get the info */
// puts("get info = ");
res = of_getprop(dev_handle,
"reg",
mem_info,
sizeof(mem_info),
&size);
// puthex(res); puts(", info = "); puthex(mem_info[0]);
// puts(" "); puthex(mem_info[1]); puts("\n");
if (res) break;
TotalMemory = mem_info[1];
break;
}
hold_residual->TotalMemory = TotalMemory;
residual = hold_residual;
/* Turn MMU back off */
_put_MSR(orig_MSR & ~0x0030);
}
/* assume the chunk below 8M is free */
end_avail = (char *)0x00800000;
/* tell the user where we were loaded at and where we
* were relocated to for debugging this process
*/
puts("loaded at: "); puthex(load_addr);
puts(" "); puthex((unsigned long)(load_addr + (4*num_words))); puts("\n");
if ( (unsigned long)load_addr != (unsigned long)&start )
{
puts("relocated to: "); puthex((unsigned long)&start);
puts(" ");
puthex((unsigned long)((unsigned long)&start + (4*num_words)));
puts("\n");
}
if ( residual )
{
puts("board data at: "); puthex((unsigned long)residual);
puts(" ");
puthex((unsigned long)((unsigned long)residual + sizeof(RESIDUAL)));
puts("\n");
puts("relocated to: ");
puthex((unsigned long)hold_residual);
puts(" ");
puthex((unsigned long)((unsigned long)hold_residual + sizeof(RESIDUAL)));
puts("\n");
}
/* we have to subtract 0x10000 here to correct for objdump including the
size of the elf header which we strip -- Cort */
zimage_start = (char *)(load_addr - 0x10000 + ZIMAGE_OFFSET);
zimage_size = ZIMAGE_SIZE;
if ( INITRD_OFFSET )
initrd_start = load_addr - 0x10000 + INITRD_OFFSET;
else
initrd_start = 0;
initrd_end = INITRD_SIZE + initrd_start;
/*
* Find a place to stick the zimage and initrd and
* relocate them if we have to. -- Cort
*/
avail_ram = (char *)PAGE_ALIGN((unsigned long)_end);
puts("zimage at: "); puthex((unsigned long)zimage_start);
puts(" "); puthex((unsigned long)(zimage_size+zimage_start)); puts("\n");
if ( (unsigned long)zimage_start <= 0x00800000 )
{
memcpy( (void *)avail_ram, (void *)zimage_start, zimage_size );
zimage_start = (char *)avail_ram;
puts("relocated to: "); puthex((unsigned long)zimage_start);
puts(" ");
puthex((unsigned long)zimage_size+(unsigned long)zimage_start);
puts("\n");
avail_ram += zimage_size;
}
/* relocate initrd */
if ( initrd_start )
{
puts("initrd at: "); puthex(initrd_start);
puts(" "); puthex(initrd_end); puts("\n");
if ( (unsigned long)initrd_start <= 0x00800000 )
{
memcpy( (void *)avail_ram,
(void *)initrd_start, initrd_end-initrd_start );
puts("relocated to: ");
initrd_end = (unsigned long) avail_ram + (initrd_end-initrd_start);
initrd_start = (unsigned long)avail_ram;
puthex((unsigned long)initrd_start);
puts(" ");
puthex((unsigned long)initrd_end);
puts("\n");
}
avail_ram = (char *)PAGE_ALIGN((unsigned long)initrd_end);
}
avail_ram = (char *)0x00400000;
end_avail = (char *)0x00800000;
puts("avail ram: "); puthex((unsigned long)avail_ram); puts(" ");
puthex((unsigned long)end_avail); puts("\n");
if (keyb_present)
CRT_tstc(); /* Forces keyboard to be initialized */
puts("\nLinux/PPC load: ");
timer = 0;
cp = cmd_line;
memcpy (cmd_line, cmd_preset, sizeof(cmd_preset));
while ( *cp ) putc(*cp++);
while (timer++ < 5*1000) {
if (tstc()) {
while ((ch = getc()) != '\n' && ch != '\r') {
if (ch == '\b') {
if (cp != cmd_line) {
cp--;
puts("\b \b");
}
} else {
*cp++ = ch;
putc(ch);
}
}
break; /* Exit 'timer' loop */
}
udelay(1000); /* 1 msec */
}
*cp = 0;
puts("\n");
puts("Uncompressing Linux...");
gunzip(0, 0x400000, zimage_start, &zimage_size);
puts("done.\n");
{
struct bi_record *rec;
rec = (struct bi_record *)PAGE_ALIGN(zimage_size);
rec->tag = BI_FIRST;
rec->size = sizeof(struct bi_record);
rec = (struct bi_record *)((unsigned long)rec + rec->size);
rec->tag = BI_BOOTLOADER_ID;
memcpy( (void *)rec->data, "prepboot", 9);
rec->size = sizeof(struct bi_record) + 8 + 1;
rec = (struct bi_record *)((unsigned long)rec + rec->size);
rec->tag = BI_MACHTYPE;
rec->data[0] = _MACH_prep;
rec->data[1] = 1;
rec->size = sizeof(struct bi_record) + sizeof(unsigned long);
rec = (struct bi_record *)((unsigned long)rec + rec->size);
rec->tag = BI_CMD_LINE;
memcpy( (char *)rec->data, cmd_line, strlen(cmd_line)+1);
rec->size = sizeof(struct bi_record) + strlen(cmd_line) + 1;
rec = (struct bi_record *)((ulong)rec + rec->size);
rec->tag = BI_LAST;
rec->size = sizeof(struct bi_record);
rec = (struct bi_record *)((unsigned long)rec + rec->size);
}
puts("Now booting the kernel\n");
return (unsigned long)hold_residual;
}
int fvl_srio_init_master(fvl_srio_init_param_t *srio_param)
{
fvl_srio_context_t *psrio = &g_srio_context;
fvl_srio_portpool_t *ppool;
fvl_srio_ctrlblk_t *pscb,*cscb,*re_cscb;
fvl_head_thread_t head_arg;
uint32_t chan_num=srio_param->chan_num;
uint32_t port_num=srio_param->port_num;
fvl_dma_pool_t *port_dma_wr = srio_param->port_rd_buf;
fvl_dma_pool_t *port_dma_ctl_wp;
fvl_dma_pool_t *port_dma_ctl_wr;
uint32_t win_size=0; //need change
uint32_t ctl_win_size=0x400000;//ctl_size*chan_num;
uint32_t win_law=0,ctl_law=21;
struct srio_dev *sriodev;
int rvl;
int i=0;
if((port_num >= FVL_SRIO_PORT_NUM) || (port_num <0))
{
FVL_LOG("port number error:%d\n",port_num);
return -1;
}
if((chan_num > FVL_PORT_CHAN_NUM_MAX) || ( chan_num<0))
{
FVL_LOG("channel number error:%d\n",chan_num);
return -1;
}
if(SRIO_PORT_STATUS[port_num]==FVL_INIT_READY)
{
FVL_LOG("The port:%d has been inited ready,don't need to be inited again!\n",port_num);
return -1;
}
if(!init_flag)
{
of_init();
rvl = fsl_srio_uio_init(&sriodev);
if (rvl < 0)
{
FVL_LOG("%s(): fsl_srio_uio_init return %d\n", __func__, rvl);
return rvl;
}
psrio->sriodev=sriodev;
init_flag=1;
}
else
{
sriodev=psrio->sriodev;
}
//mode master
uint32_t offset=0;
int j=FVL_PORT_CHAN_NUM_MAX*port_num;
for(i=0;i<chan_num;i++)
{
uint32_t buf_num=srio_param->buf_num[i];
uint32_t buf_size=(srio_param->buf_size[i]/FVL_BUFSIZE_unit);
uint32_t chan_size=buf_size*buf_num*FVL_BUFSIZE_unit;
head_port[port_num].channel[i].receive_cluster.buf_size=buf_size;
head_port[port_num].channel[i].receive_cluster.buf_num=buf_num;
head_port[port_num].channel[i].receive_cluster.cluster_addr=FVL_SRIO_SYS_ADDR+offset;
head_port[port_num].channel[i].send_cluster.buf_size=buf_size;
head_port[port_num].channel[i].send_cluster.buf_num=buf_num;
head_port[port_num].channel[i].send_cluster.cluster_addr=FVL_SRIO_SYS_ADDR+offset;
head_port[port_num].symbol=FVL_SRIO_SYMBOL;
head_port[port_num].status=FVL_SRIO_STATUS;
head_port[port_num].cmd=FVL_INIT_CMD;
offset=offset+chan_size;
srio_channel_context[(j+i)].chan_size=chan_size;
srio_channel_context[(j+i)].buf_size=srio_param->buf_size[i];
srio_channel_context[(j+i)].buf_num=buf_num;
win_size=win_size+chan_size;
FVL_LOG("channel:%d buf_size:%d buf_num: %d chan_size:%08x\n",(j+i),srio_param->buf_size[i],buf_num,chan_size);
//head channel init
}
psrio->chan_num[port_num] = chan_num;
source_id[port_num]=srio_param->source_id;
target_id[port_num]=srio_param->target_id;
FVL_LOG("port_num:%d target_id:%04x source_id:%04x\n",port_num,target_id[port_num],source_id[port_num]);
//end master
struct srio_port_info *pinfo;
void *range;
pinfo = &psrio->portpool[port_num].port_info;
fsl_srio_connection(sriodev,port_num);
if (fsl_srio_port_connected(sriodev) & (0x1 << port_num))
{
fsl_srio_get_port_info(sriodev, port_num+1, pinfo, &range);
psrio->portpool[port_num].range_virt = range;
}
else
{
FVL_LOG("%s(): fsl_srio_connection port %d failed\n", __func__, port_num+1);
return -1;
}
rvl = fsl_srio_port_connected(sriodev);
if (rvl <= 0)
{
FVL_LOG("%s(): fsl_srio_port_connected return %d\n", __func__, rvl);
return -1;
}
rvl = dma_pool_init(&port_dma_ctl_wp,ctl_win_size,ctl_win_size/2);
if(rvl!=0)
{
FVL_LOG("port %d dma_pool_init failed!\n",port_num+1);
return -errno;
}
rvl = dma_pool_init(&port_dma_ctl_wr,ctl_win_size,ctl_win_size/2);
if(rvl!=0)
{
FVL_LOG("port %d dma_pool_init failed!\n",port_num+1);
return -errno;
}
uint32_t attr_read, attr_write;
attr_read = srio_test_win_attrv[3];
attr_write = srio_test_win_attrv[0];
FVL_LOG("attr_write = %u, srio_type = 0\n", attr_write);
ppool = &psrio->portpool[port_num];
ppool->write_result = port_dma_wr->dma_phys_base;
ppool->pwrite_result = port_dma_wr->dma_virt_base;
ppool->write_ctl_result = port_dma_ctl_wr->dma_phys_base;
ppool->write_ctl_data = port_dma_ctl_wp->dma_phys_base;
ppool->pwrite_ctl_result = port_dma_ctl_wr->dma_virt_base;
ppool->pwrite_ctl_data = port_dma_ctl_wp->dma_virt_base;
win_law=FVL_BASE_LAW+fvl_get_law((win_size/FVL_BASE_LAW_SIZE)-1);
// ctl_law=FVL_BASE_LAW+fvl_get_law((ctl_win_size/FVL_BASE_LAW_SIZE)-1);
FVL_LOG("HOST WIN_LAW:%d CTL_LAW:%d\n",win_law,ctl_law);
fsl_srio_set_ibwin(sriodev, port_num, 1, ppool->write_result,
FVL_SRIO_SYS_ADDR, win_law);
fsl_srio_set_ibwin(sriodev, port_num, 2, ppool->write_ctl_result,
FVL_SRIO_CTL_ADDR, ctl_law);
uint32_t win_offset=FVL_BASE_LAW_SIZE;
for(i=FVL_BASE_LAW;i<win_law;i++)
{
win_offset=win_offset*2;
}
FVL_LOG("HOST WIN_OFFSET:%d\n",win_offset);
ppool->ctl_info_start=ppool->port_info.range_start+win_offset;
if (fsl_srio_port_connected(sriodev) & (0x1 << port_num))
{
//ctl
fsl_srio_set_obwin(sriodev, port_num, 2,
ppool->port_info.range_start+win_offset,
FVL_SRIO_CTL_ADDR, ctl_law);
fsl_srio_set_obwin_attr(sriodev, port_num, 2,
attr_read, attr_write);
//data
fsl_srio_set_obwin(sriodev, port_num, 1,
ppool->port_info.range_start,
FVL_SRIO_SYS_ADDR, win_law);
fsl_srio_set_obwin_attr(sriodev, port_num, 1,
attr_read, attr_write);
}
else
{
FVL_LOG("SRIO port %d error!\n", port_num + 1);
return -errno;
}
rvl=fsl_srio_set_deviceid(sriodev,port_num,source_id[port_num]);
if(rvl!=0)
{
FVL_LOG("SRIO port %d set source_id faile!\n",port_num);
return -errno;
}
rvl=fsl_srio_set_targetid(sriodev,port_num,1,target_id[port_num]);
if(rvl!=0)
{
FVL_LOG("SRIO port %d set target_id faile!\n",port_num);
return -errno;
}
rvl=fsl_srio_set_targetid(sriodev,port_num,2,target_id[port_num]);
if(rvl!=0)
{
FVL_LOG("SRIO port %d set target_id faile!\n",port_num);
return -errno;
}
fsl_srio_set_phy_retry_threshold(sriodev,port_num,0,0);
memset(port_dma_wr->dma_virt_base,0,win_size);
memset(port_dma_ctl_wp->dma_virt_base,0,ctl_win_size);
memset(port_dma_ctl_wr->dma_virt_base,0,ctl_win_size);
fvl_srio_channel_t *temp_channel;
j=FVL_PORT_CHAN_NUM_MAX*port_num;
for(i=0;i<FVL_PORT_CHAN_NUM_MAX;i++)
{
pscb=fvl_srio_getcb(port_num,i*2);
if(pscb==NULL)
{
FVL_LOG("port:%d channel:%d : dmadev init error.\n",port_num+1,2*i);
return -1;
}
temp_channel=&srio_channel_context[(j+i)];
cscb=&(temp_channel->chanblk);
cscb->dmadev=pscb->dmadev;
cscb->bfnum=pscb->bfnum;
cscb->port = pscb->port;
pscb=fvl_srio_getcb(port_num,i*2+1);
if(pscb==NULL)
{
FVL_LOG("port:%d channel:%d : dmadev init error.\n",port_num+1,2*i+1);
return -1;
}
re_cscb=&(temp_channel->rechanblk);
re_cscb->dmadev=pscb->dmadev;
re_cscb->bfnum=pscb->bfnum;
re_cscb->port = pscb->port;
}
pthread_mutex_init(&mutex[port_num],NULL);
//mode master
//need send packet_info out
memcpy(ppool->pwrite_ctl_data,&head_port[port_num],256);
uint64_t dest_phys,src_phys;
src_phys=ppool->write_ctl_data;
dest_phys=ppool->ctl_info_start;
pscb=&psrio->ctrlblk[FVL_PORT_DMA_NUM*port_num+7];
pthread_mutex_lock(&mutex[port_num]);
rvl = fvl_srio_send(pscb->dmadev,src_phys,dest_phys,256);
if(rvl!=0)
{
error_count[port_num]++;
FVL_LOG("DMA do't response times:%lu\n",error_count[port_num]);
}
pthread_mutex_unlock(&mutex[port_num]);
FVL_LOG("PORT_NUM:%d HEAD_INFO_SIZE:256\n",port_num);
head_arg.num = port_num;
head_arg.op_mode = 0;
head_arg.buf_virt=ppool->pwrite_ctl_result;
rvl=fvl_srio_recv_head_master(&head_arg);
if(rvl!=0)
{
FVL_LOG("Host:Port %d is not ready!\n",port_num);
return -1;
}
return 0;
}
extern "C" int
start_gen(int argc, const char **argv, struct image_header *uimage, void *fdt)
{
stage2_args args;
clear_bss();
// call C++ constructors before doing anything else
call_ctors();
args.heap_size = HEAP_SIZE;
args.arguments = NULL;
args.arguments_count = 0;
args.platform.boot_tgz_data = NULL;
args.platform.boot_tgz_size = 0;
args.platform.fdt_data = NULL;
args.platform.fdt_size = 0;
gUImage = uimage;
gFDT = fdt; //XXX: make a copy?
// TODO: check for atags instead and convert them
if (argv) {
// skip the kernel name
++argv;
--argc;
}
// TODO: Ensure cmdline is mapped into memory by MMU before usage.
// if we get passed a uimage, try to find the third blob
// only if we do not have FDT data yet
if (gUImage != NULL
&& !gFDT
&& image_multi_getimg(gUImage, 2,
(uint32*)&args.platform.fdt_data,
&args.platform.fdt_size)) {
// found a blob, assume it is FDT data, when working on a platform
// which does not have an FDT enabled U-Boot
gFDT = args.platform.fdt_data;
}
// We have to cpu_init *before* calling FDT functions
cpu_init();
serial_init(gFDT);
#if defined(__ARM__)
arch_mailbox_init();
#endif
// initialize the OpenFirmware wrapper
of_init(NULL);
console_init();
// if we get passed an FDT, check /chosen for initrd and bootargs
if (gFDT != NULL) {
int node = fdt_path_offset(gFDT, "/chosen");
const void *prop;
int len;
phys_addr_t initrd_start = 0, initrd_end = 0;
if (node >= 0) {
prop = fdt_getprop(gFDT, node, "linux,initrd-start", &len);
if (prop && len == 4)
initrd_start = fdt32_to_cpu(*(uint32_t *)prop);
prop = fdt_getprop(gFDT, node, "linux,initrd-end", &len);
if (prop && len == 4)
initrd_end = fdt32_to_cpu(*(uint32_t *)prop);
if (initrd_end > initrd_start) {
args.platform.boot_tgz_data = (void *)initrd_start;
args.platform.boot_tgz_size = initrd_end - initrd_start;
dprintf("Found boot tgz from FDT @ %p, %" B_PRIu32 " bytes\n",
args.platform.boot_tgz_data, args.platform.boot_tgz_size);
}
// we check for bootargs after remapping the FDT
}
}
// if we get passed a uimage, try to find the second blob
if (gUImage != NULL
&& image_multi_getimg(gUImage, 1,
(uint32*)&args.platform.boot_tgz_data,
&args.platform.boot_tgz_size)) {
dprintf("Found boot tgz from uimage @ %p, %" B_PRIu32 " bytes\n",
args.platform.boot_tgz_data, args.platform.boot_tgz_size);
}
{ //DEBUG:
int i;
dprintf("argc = %d\n", argc);
for (i = 0; i < argc; i++)
dprintf("argv[%d] @%lx = '%s'\n", i, (uint32)argv[i], argv[i]);
dprintf("os: %d\n", (int)gUBootOS);
dprintf("gd @ %p\n", gUBootGlobalData);
if (gUBootGlobalData) {
dprintf("gd->bd @ %p\n", gUBootGlobalData->bd);
dprintf("gd->fb_base @ %p\n", (void*)gUBootGlobalData->fb_base);
}
if (gUImage)
dump_uimage(gUImage);
if (gFDT)
dump_fdt(gFDT);
}
if (args.platform.boot_tgz_size > 0) {
insert_physical_allocated_range((addr_t)args.platform.boot_tgz_data,
args.platform.boot_tgz_size);
}
// save the size of the FDT so we can map it easily after mmu_init
size_t fdtSize = gFDT ? fdt_totalsize(gFDT) : 0;
dprintf("fdtSize: 0x%" B_PRIxSIZE "\n", fdtSize);
mmu_init();
// Handle our tarFS post-mmu
if (args.platform.boot_tgz_size > 0) {
args.platform.boot_tgz_data = (void*)mmu_map_physical_memory((addr_t)
args.platform.boot_tgz_data, args.platform.boot_tgz_size,
kDefaultPageFlags);
}
// .. and our FDT
if (gFDT != NULL)
gFDT = (void*)mmu_map_physical_memory((addr_t)gFDT, fdtSize, kDefaultPageFlags);
// if we get passed an FDT, check /chosen for bootargs now
// to avoid having to copy them.
if (gFDT != NULL) {
int node = fdt_path_offset(gFDT, "/chosen");
const void *prop;
int len;
if (node >= 0) {
prop = fdt_getprop(gFDT, node, "bootargs", &len);
if (prop) {
dprintf("Found bootargs: %s\n", (const char *)prop);
static const char *sArgs[] = { NULL, NULL };
sArgs[0] = (const char *)prop;
// override main() args
args.arguments = sArgs;
args.arguments_count = 1;
}
}
dprintf("args.arguments_count = %" B_PRId32 "\n", args.arguments_count);
for (int i = 0; i < args.arguments_count; i++)
dprintf("args.arguments[%d] @%lx = '%s'\n", i,
(uint32)args.arguments[i], args.arguments[i]);
}
// wait a bit to give the user the opportunity to press a key
// spin(750000);
// reading the keyboard doesn't seem to work in graphics mode
// (maybe a bochs problem)
// sBootOptions = check_for_boot_keys();
//if (sBootOptions & BOOT_OPTION_DEBUG_OUTPUT)
serial_enable();
main(&args);
return 0;
}
/* The main() function/thread creates the worker threads and then waits for
* threads to exit or ctrl-c. All code outside the main() function is used by
* the worker threads. */
int main(int argc, char *argv[])
{
struct worker *workers;
char *endptr;
size_t sz = DMA_MAP_SIZE;
/* Determine number of cores (==number of threads) */
long ncpus = sysconf(_SC_NPROCESSORS_ONLN);
/* Load the device-tree driver */
int loop, tmpret, teardown, ret = of_init();
while (ARGINC() > 0) {
if (!strcmp(*argv, "-n")) {
unsigned long val;
if (!ARGINC()) {
fprintf(stderr, "Missing argument to -n\n");
exit(EXIT_FAILURE);
}
val = strtoul(*argv, &endptr, 0);
if ((val == ULONG_MAX) || (*endptr != '\0')) {
fprintf(stderr, "Invalid argument to -n (%s)\n",
*argv);
exit(EXIT_FAILURE);
}
if (!val || (val > ncpus)) {
fprintf(stderr, "Out of range (-n %lu)\n", val);
exit(EXIT_FAILURE);
}
ncpus = val;
} else if (!strcmp(*argv, "-p")) {
if (!ARGINC()) {
fprintf(stderr, "Missing argument to -p\n");
exit(EXIT_FAILURE);
}
PCD_PATH = *argv;
} else if (!strcmp(*argv, "-c")) {
if (!ARGINC()) {
fprintf(stderr, "Missing argument to -c\n");
exit(EXIT_FAILURE);
}
CFG_PATH = *argv;
} else if (!strcmp(*argv, "-s")) {
unsigned long val;
if (!ARGINC()) {
fprintf(stderr, "Missing argument to -s\n");
exit(EXIT_FAILURE);
}
val = strtoul(*argv, &endptr, 0);
if ((val == ULONG_MAX) || (*endptr != '\0') || !val) {
fprintf(stderr, "Invalid argument to -s (%s)\n",
*argv);
exit(EXIT_FAILURE);
}
sz = (size_t)val;
} else if (!strcmp(*argv, "-sc")) {
short_circuit_mode = 1;
} else if (!strcmp(*argv, "-b")) {
unsigned long val;
if (!ARGINC()) {
fprintf(stderr, "Missing argument to -b\n");
exit(EXIT_FAILURE);
}
val = strtoul(*argv, &endptr, 0);
if ((val == ULONG_MAX) || (*endptr != ':'))
goto b_err;
bpool_cnt[0] = val;
val = strtoul(endptr + 1, &endptr, 0);
if ((val == ULONG_MAX) || (*endptr != ':'))
goto b_err;
bpool_cnt[1] = val;
val = strtoul(endptr + 1, &endptr, 0);
if ((val == ULONG_MAX) || (*endptr != '\0'))
goto b_err;
bpool_cnt[2] = val;
continue;
b_err:
fprintf(stderr, "Invalid argument to -b (%s)\n", *argv);
exit(EXIT_FAILURE);
} else {
fprintf(stderr, "Unknown argument '%s'\n", *argv);
exit(EXIT_FAILURE);
}
}
printf("Starting hello_reflector, ncpus=%ld\n", ncpus);
if (ncpus < 1) {
fprintf(stderr, "Fail: # processors: %ld\n", ncpus);
exit(EXIT_FAILURE);
}
if (ret) {
fprintf(stderr, "Fail: %s: %d\n", "of_init()", ret);
exit(EXIT_FAILURE);
}
/* Parse FMC policy and configuration files for the network
* configuration. This also "extracts" other settings into 'netcfg' that
* are not necessarily from the XML files, such as the pool channels
* that the application is allowed to use (these are currently
* hard-coded into the netcfg code). */
netcfg = usdpaa_netcfg_acquire(PCD_PATH, CFG_PATH);
if (!netcfg) {
fprintf(stderr, "Fail: usdpaa_netcfg_acquire(%s,%s)\n",
PCD_PATH, CFG_PATH);
exit(EXIT_FAILURE);
}
if (!netcfg->num_ethports) {
fprintf(stderr, "Fail: no network interfaces available\n");
exit(EXIT_FAILURE);
}
/* Install ctrl-c handler */
if (signal(SIGINT, handle_sigint) == SIG_ERR) {
fprintf(stderr, "Fail: %s\n", "signal(SIGINT)");
exit(EXIT_FAILURE);
}
/* Allocate the worker structs */
ret = posix_memalign((void **)&workers, MAX_CACHELINE,
ncpus * sizeof(*workers));
if (ret) {
fprintf(stderr, "Fail: %s: %d\n", "posix_memalign()", ret);
exit(EXIT_FAILURE);
}
/* Load the Qman/Bman drivers */
ret = qman_global_init();
if (ret) {
fprintf(stderr, "Fail: %s: %d\n", "qman_global_init()", ret);
exit(EXIT_FAILURE);
}
ret = bman_global_init();
if (ret) {
fprintf(stderr, "Fail: %s: %d\n", "bman_global_init()", ret);
exit(EXIT_FAILURE);
}
ret = qman_alloc_pool_range(&pchannels[0], NUM_POOL_CHANNELS, 1, 0);
if (ret != NUM_POOL_CHANNELS) {
fprintf(stderr, "Fail: no pool channels available\n");
exit(EXIT_FAILURE);
}
/* Compute SDQCR */
for (loop = 0; loop < NUM_POOL_CHANNELS; loop++)
sdqcr |= QM_SDQCR_CHANNELS_POOL_CONV(pchannels[loop]);
/* Load dma_mem driver */
dma_mem_generic = dma_mem_create(DMA_MAP_FLAG_ALLOC, NULL, sz);
if (!dma_mem_generic) {
fprintf(stderr, "Fail: %s:\n", "dma_mem_create()");
exit(EXIT_FAILURE);
}
printf("DMA region created of size %zu (0x%zx)\n", sz, sz);
/* Start up the threads */
for (loop = 0; loop < ncpus; loop++) {
struct worker *worker = &workers[loop];
worker->quit = worker->init_done = 0;
worker->cpu = loop;
ret = pthread_create(&worker->id, NULL, worker_fn, worker);
if (ret) {
fprintf(stderr, "Fail: %s(%d): %d\n", "pthread_create",
loop, ret);
while (--loop >= 0) {
(--worker)->quit = 1;
tmpret = pthread_join(worker->id, NULL);
if (tmpret)
fprintf(stderr, "Fail: %s(%d): %d\n",
"pthread_join", loop, tmpret);
}
exit(EXIT_FAILURE);
}
/* Wait for thread init to complete (the first thread will
* complete global init as part of that) */
while (!worker->init_done) {
pthread_yield();
if (!pthread_tryjoin_np(worker->id, NULL)) {
fprintf(stderr, "Fail: primary thread init\n");
exit(EXIT_FAILURE);
}
}
}
/* Threads are created, now manage them (and catch ctrl-c) */
printf("Hit Ctrl-C (or send SIGINT) to terminate.\n");
teardown = 0;
while (ncpus) {
if (!teardown) {
if (received_sigint) {
/* Ctrl-c signal triggers teardown */
teardown = 1;
printf("Ctrl-C, ending...\n");
/* Non-primary threads should quit first */
for (loop = 1; loop < ncpus; loop++)
workers[loop].quit = 1;
} else
/* No teardown, no signal, this is where we can
* pause */
sleep(1);
} else {
/* Once the primary thread is the only thread, it can
* quit too (global cleanup) */
if (ncpus == 1)
workers[0].quit = 1;
}
/* Reap loop */
loop = 0;
while (loop < ncpus) {
struct worker *worker = &workers[loop];
if (!pthread_tryjoin_np(worker->id, NULL)) {
fprintf(stderr, "Exit: thread %d\n",
worker->cpu);
if (--ncpus > loop)
memmove(worker, worker + 1,
(ncpus - loop) *
sizeof(*worker));
} else
loop++;
}
}
qman_release_pool_range(pchannels[0], NUM_POOL_CHANNELS);
printf("Finished hello_reflector\n");
return 0;
}
int main(int argc, char *argv[])
{
struct srio_dev *sriodev;
struct dma_ch *send_dmadev[SEND_THREAD_NUM];
struct dma_ch *receive_dmadev[RECEIVE_THREAD_NUM];
struct dma_pool *dmapool = NULL;
int i, err;
struct srio_port_data *port_data;
uint32_t attr_read, attr_write;
struct task_arg_type task_arg_send[SEND_THREAD_NUM];
struct task_arg_type task_arg_receive[RECEIVE_THREAD_NUM];
pthread_t send_id[SEND_THREAD_NUM];
pthread_t receive_id[RECEIVE_THREAD_NUM];
of_init();
err = fsl_srio_uio_init(&sriodev);
if (err < 0)
error(EXIT_FAILURE, -err, "%s(): srio_uio_init()", __func__);
port_num = fsl_srio_get_port_num(sriodev);
memset(&cmd_param, 0, sizeof(cmd_param));
cmd_param.port = malloc(sizeof(struct cmd_port_param) * port_num);
if (!cmd_param.port) {
error(0, errno, "%s(): command port", __func__);
goto err_cmd_malloc;
}
memset(cmd_param.port, 0, sizeof(struct cmd_port_param));
/*ctx add*/
err = cmd_translate(argc, argv);
if (err < 0)
cmd_format_print();
printf("packet size:%d\n",sizeof(struct srio_packet));
port_data = malloc(sizeof(struct srio_port_data) * port_num);
if (!port_data) {
error(0, errno, "%s(): port_data", __func__);
goto err_cmd_malloc;
}
for (i = 0; i < port_num; i++) {
fsl_srio_connection(sriodev, i);
fsl_srio_get_port_info(sriodev, i + 1, &port_data[i].port_info,
&port_data[i].range_virt);
}
err = fsl_srio_port_connected(sriodev);
if (err <= 0) {
error(0, -err, "%s(): fsl_srio_port_connected", __func__);
goto err_srio_connected;
}
return 0;
err = dma_pool_init(&dmapool);
uint8_t port = cmd_param.curr_port_id;
attr_read = srio_test_win_attrv[3];
attr_write = srio_test_win_attrv[cmd_param.test_srio_type];
for (i = 0; i < port_num; i++) {
dma_addr_t port_phys_base =
dmapool->dma_phys_base + SRIO_POOL_PORT_OFFSET * i;
port_data[i].phys.write_recv_data = port_phys_base;
port_data[i].phys.read_recv_data =
port_phys_base + SRIO_POOL_SECT_SIZE;
port_data[i].phys.write_data_prep =
port_phys_base + SRIO_POOL_SECT_SIZE * 2;
port_data[i].phys.res =
port_phys_base + SRIO_POOL_SECT_SIZE * 3;
port_data[i].virt = (typeof(port_data[i].virt))
(dmapool->dma_virt_base + i * SRIO_POOL_PORT_OFFSET);
fsl_srio_set_ibwin(sriodev, i, 1,
port_data[i].phys.write_recv_data,
SRIO_SYS_ADDR, LAWAR_SIZE_16M);
if (fsl_srio_port_connected(sriodev) & (0x1 << i)) {
fsl_srio_set_obwin(sriodev, i, 1,
port_data[i].port_info.range_start,
SRIO_SYS_ADDR, LAWAR_SIZE_16M);
fsl_srio_set_obwin_attr(sriodev, i, 1,
attr_read, attr_write);
} else {
printf("SRIO port %d error!\n", i + 1);
return -errno;
}
memset(port_data[i].virt,0,SRIO_POOL_PORT_OFFSET);
}
/*ctx add*/
for(i=0;i<1;i++)
{
err = fsl_dma_chan_init(&send_dmadev[i], 0, i);
if (err < 0) {
error(0, -err, "%s(): fsl_dma_chan_init()", __func__);
goto err_srio_connected;
}
err = fsl_dma_chan_init(&receive_dmadev[i], 1, i);
if (err < 0) {
error(0, -err, "%s(): fsl_dma_chan_init()", __func__);
goto err_srio_connected;
}
fsl_dma_chan_basic_direct_init(send_dmadev[i]);
fsl_dma_chan_bwc(send_dmadev[i], DMA_BWC_1024);
task_arg_send[i].dmadev = send_dmadev[i];
fsl_dma_chan_basic_direct_init(receive_dmadev[i]);
fsl_dma_chan_bwc(receive_dmadev[i], DMA_BWC_1024);
task_arg_receive[i].dmadev = receive_dmadev[i];
task_arg_receive[i].port_data_thread.phys.write_recv_data=port_data[1-port].phys.write_recv_data+THREAD_WIN_SIZE*i;
task_arg_receive[i].port_data_thread.phys.read_recv_data=port_data[1-port].phys.read_recv_data+THREAD_WIN_SIZE*i;
task_arg_receive[i].port_data_thread.phys.write_data_prep=port_data[1-port].phys.write_data_prep+THREAD_WIN_SIZE*i;
task_arg_receive[i].port_data_thread.phys.res=port_data[1-port].phys.res+THREAD_WIN_SIZE*i;
task_arg_receive[i].port_data_thread.virt.write_recv_data = &port_data[1-port].virt->write_recv_data_t[i][0];
task_arg_receive[i].port_data_thread.virt.read_recv_data = &port_data[1-port].virt->read_recv_data_t[i][0];
task_arg_receive[i].port_data_thread.virt.write_data_prep = &port_data[1-port].virt->write_data_prep_t[i][0];
task_arg_receive[i].port_data_thread.virt.res = &port_data[1-port].virt->res_t[i][0];
task_arg_receive[i].port_data_thread.port_info.range_start = port_data[1-port].port_info.range_start+THREAD_WIN_SIZE*i;
task_arg_receive[i].port = 1-port;
task_arg_receive[i].srio_type = cmd_param.test_srio_type;
task_arg_receive[i].cpu = i+SEND_THREAD_NUM+2;/*bind cpu*/
err = pthread_create(&receive_id[i],NULL,t_srio_receive,&task_arg_receive[i]);
if (err) {
printf("Port %d : Receive thread failed!\n",2-port);
return -errno;
}
/* ctx add*/
task_arg_send[i].port_data_thread.phys.write_recv_data=port_data[port].phys.write_recv_data+THREAD_WIN_SIZE*i;
task_arg_send[i].port_data_thread.phys.read_recv_data=port_data[port].phys.read_recv_data+THREAD_WIN_SIZE*i;
task_arg_send[i].port_data_thread.phys.write_data_prep=port_data[port].phys.write_data_prep+THREAD_WIN_SIZE*i;
task_arg_send[i].port_data_thread.phys.res=port_data[port].phys.res+THREAD_WIN_SIZE*i;
task_arg_send[i].port_data_thread.virt.write_recv_data = &port_data[port].virt->write_recv_data_t[i][0];
task_arg_send[i].port_data_thread.virt.read_recv_data = &port_data[port].virt->read_recv_data_t[i][0];
task_arg_send[i].port_data_thread.virt.write_data_prep = &port_data[port].virt->write_data_prep_t[i][0];
task_arg_send[i].port_data_thread.virt.res = &port_data[port].virt->res_t[i][0];
task_arg_send[i].port_data_thread.port_info.range_start = port_data[port].port_info.range_start+THREAD_WIN_SIZE*i;
/* cta end*/
task_arg_send[i].port = port;
task_arg_send[i].srio_type = cmd_param.test_srio_type;
task_arg_send[i].cpu = i+2;/*bind cpu*/
err = pthread_create(&send_id[i], NULL,t_srio_send, &task_arg_send[i]);
if (err) {
printf("Port %d : Send thread failed!\n",port + 1);
return -errno;
}
}
/*multiple*/
for(i=1;i<SEND_THREAD_NUM;i++)
{
err = fsl_dma_chan_init(&send_dmadev[i], 0, i);
if (err < 0) {
error(0, -err, "%s(): fsl_dma_chan_init()", __func__);
goto err_srio_connected;
}
err = fsl_dma_chan_init(&receive_dmadev[i], 1, i);
if (err < 0) {
error(0, -err, "%s(): fsl_dma_chan_init()", __func__);
goto err_srio_connected;
}
fsl_dma_chan_basic_direct_init(send_dmadev[i]);
fsl_dma_chan_bwc(send_dmadev[i], DMA_BWC_1024);
task_arg_send[i].dmadev = send_dmadev[i];
fsl_dma_chan_basic_direct_init(receive_dmadev[i]);
fsl_dma_chan_bwc(receive_dmadev[i], DMA_BWC_1024);
task_arg_receive[i].dmadev = receive_dmadev[i];
/* ctx add*/
task_arg_send[i].port_data_thread.phys.write_recv_data=port_data[port].phys.write_recv_data+THREAD_WIN_SIZE*i;
task_arg_send[i].port_data_thread.phys.read_recv_data=port_data[port].phys.read_recv_data+THREAD_WIN_SIZE*i;
task_arg_send[i].port_data_thread.phys.write_data_prep=port_data[port].phys.write_data_prep+THREAD_WIN_SIZE*i;
task_arg_send[i].port_data_thread.phys.res=port_data[port].phys.res+THREAD_WIN_SIZE*i;
task_arg_send[i].port_data_thread.virt.write_recv_data = &port_data[port].virt->write_recv_data_t[i][0];
task_arg_send[i].port_data_thread.virt.read_recv_data = &port_data[port].virt->read_recv_data_t[i][0];
task_arg_send[i].port_data_thread.virt.write_data_prep = &port_data[port].virt->write_data_prep_t[i][0];
task_arg_send[i].port_data_thread.virt.res = &port_data[port].virt->res_t[i][0];
task_arg_send[i].port_data_thread.port_info.range_start = port_data[port].port_info.range_start+THREAD_WIN_SIZE*i;
/* cta end*/
task_arg_send[i].port = port;
task_arg_send[i].srio_type = cmd_param.test_srio_type;
task_arg_send[i].cpu = i+2;/*bind cpu*/
err = pthread_create(&send_id[i], NULL,t_srio_receive, &task_arg_send[i]);
if (err) {
printf("Port %d : Send thread failed!\n",port + 1);
return -errno;
}
task_arg_receive[i].port_data_thread.phys.write_recv_data=port_data[1-port].phys.write_recv_data+THREAD_WIN_SIZE*i;
task_arg_receive[i].port_data_thread.phys.read_recv_data=port_data[1-port].phys.read_recv_data+THREAD_WIN_SIZE*i;
task_arg_receive[i].port_data_thread.phys.write_data_prep=port_data[1-port].phys.write_data_prep+THREAD_WIN_SIZE*i;
task_arg_receive[i].port_data_thread.phys.res=port_data[1-port].phys.res+THREAD_WIN_SIZE*i;
task_arg_receive[i].port_data_thread.virt.write_recv_data = &port_data[1-port].virt->write_recv_data_t[i][0];
task_arg_receive[i].port_data_thread.virt.read_recv_data = &port_data[1-port].virt->read_recv_data_t[i][0];
task_arg_receive[i].port_data_thread.virt.write_data_prep = &port_data[1-port].virt->write_data_prep_t[i][0];
task_arg_receive[i].port_data_thread.virt.res = &port_data[1-port].virt->res_t[i][0];
task_arg_receive[i].port_data_thread.port_info.range_start = port_data[1-port].port_info.range_start+THREAD_WIN_SIZE*i;
task_arg_receive[i].port = 1-port;
task_arg_receive[i].srio_type = cmd_param.test_srio_type;
task_arg_receive[i].cpu = i+SEND_THREAD_NUM+2;/*bind cpu*/
err = pthread_create(&receive_id[i],NULL,t_srio_send,&task_arg_receive[i]);
if (err) {
printf("Port %d : Receive thread failed!\n",2-port);
return -errno;
}
}
for(i=0;i<SEND_THREAD_NUM;i++)
{
pthread_join(send_id[i],NULL);
pthread_join(receive_id[i],NULL);
}
/*ctx end*/
free(port_data);
free(cmd_param.port);
for(i=0;i<SEND_THREAD_NUM;i++)
{
fsl_dma_chan_finish(send_dmadev[i]);
fsl_dma_chan_finish(receive_dmadev[i]);
}
dma_pool_finish(dmapool);
fsl_srio_uio_finish(sriodev);
of_finish();
return EXIT_SUCCESS;
err_srio_connected:
free(port_data);
free(cmd_param.port);
err_cmd_malloc:
fsl_srio_uio_finish(sriodev);
of_finish();
return err;
}
extern "C" int
start_raw(int argc, const char **argv)
{
stage2_args args;
clear_bss();
// call C++ constructors before doing anything else
call_ctors();
args.heap_size = HEAP_SIZE;
args.arguments = NULL;
args.platform.boot_tgz_data = NULL;
args.platform.boot_tgz_size = 0;
args.platform.fdt_data = NULL;
args.platform.fdt_size = 0;
if (argv) {
// skip the kernel name
args.arguments = ++argv;
args.arguments_count = --argc;
}
// if we get passed a uimage, try to find the third blob
// only if we do not have FDT data yet
if (gUImage != NULL
&& !gFDT
&& image_multi_getimg(gUImage, 2,
(uint32*)&args.platform.fdt_data,
&args.platform.fdt_size)) {
// found a blob, assume it is FDT data, when working on a platform
// which does not have an FDT enabled U-Boot
gFDT = args.platform.fdt_data;
}
serial_init(gFDT);
console_init();
// initialize the OpenFirmware wrapper
of_init(NULL);
cpu_init();
if (args.platform.fdt_data) {
dprintf("Found FDT from uimage @ %p, %" B_PRIu32 " bytes\n",
args.platform.fdt_data, args.platform.fdt_size);
} else if (gFDT) {
/* Fixup args so we can pass the gFDT on to the kernel */
args.platform.fdt_data = gFDT;
args.platform.fdt_size = fdt_totalsize(gFDT);
}
// if we get passed an FDT, check /chosen for initrd and bootargs
if (gFDT != NULL) {
int node = fdt_path_offset(gFDT, "/chosen");
const void *prop;
int len;
phys_addr_t initrd_start = 0, initrd_end = 0;
if (node >= 0) {
prop = fdt_getprop(gFDT, node, "linux,initrd-start", &len);
if (prop && len == 4)
initrd_start = fdt32_to_cpu(*(uint32_t *)prop);
prop = fdt_getprop(gFDT, node, "linux,initrd-end", &len);
if (prop && len == 4)
initrd_end = fdt32_to_cpu(*(uint32_t *)prop);
if (initrd_end > initrd_start) {
args.platform.boot_tgz_data = (void *)initrd_start;
args.platform.boot_tgz_size = initrd_end - initrd_start;
dprintf("Found boot tgz from FDT @ %p, %" B_PRIu32 " bytes\n",
args.platform.boot_tgz_data, args.platform.boot_tgz_size);
}
prop = fdt_getprop(gFDT, node, "bootargs", &len);
if (prop) {
dprintf("Found bootargs: %s\n", (const char *)prop);
static const char *sArgs[] = { NULL, NULL };
sArgs[0] = (const char *)prop;
args.arguments = sArgs;
args.arguments_count = 1;
}
}
}
// if we get passed a uimage, try to find the second blob
if (gUImage != NULL
&& image_multi_getimg(gUImage, 1,
(uint32*)&args.platform.boot_tgz_data,
&args.platform.boot_tgz_size)) {
dprintf("Found boot tgz from uimage @ %p, %" B_PRIu32 " bytes\n",
args.platform.boot_tgz_data, args.platform.boot_tgz_size);
}
{ //DEBUG:
int i;
dprintf("argc = %d\n", argc);
for (i = 0; i < argc; i++)
dprintf("argv[%d] @%lx = '%s'\n", i, (uint32)argv[i], argv[i]);
dprintf("os: %d\n", (int)gUBootOS);
dprintf("gd @ %p\n", gUBootGlobalData);
if (gUBootGlobalData)
dprintf("gd->bd @ %p\n", gUBootGlobalData->bd);
//dprintf("fb_base %p\n", (void*)gUBootGlobalData->fb_base);
if (gUImage)
dump_uimage(gUImage);
if (gFDT)
dump_fdt(gFDT);
}
mmu_init();
// wait a bit to give the user the opportunity to press a key
// spin(750000);
// reading the keyboard doesn't seem to work in graphics mode
// (maybe a bochs problem)
// sBootOptions = check_for_boot_keys();
//if (sBootOptions & BOOT_OPTION_DEBUG_OUTPUT)
serial_enable();
main(&args);
return 0;
}
int fvl_srio_init(fvl_srio_init_param_t *srio_param)
{
fvl_srio_context_t *psrio = &g_srio_context;
fvl_srio_portpool_t *ppool;
uint32_t srio_type=0;//srio_param->srio_type;
uint32_t chan_num=srio_param->chan_num;
uint32_t buf_num=srio_param->buf_num;
uint32_t buf_size=srio_param->buf_size;
uint32_t chan_size=srio_param->chan_size;
uint32_t target_id = srio_param->target_id;
uint32_t port_num=srio_param->port_num;
fvl_dma_pool_t *port_dma_wr = srio_param->port_rd_buf;
fvl_dma_pool_t *port_dma_ctl_wp;
fvl_dma_pool_t *port_dma_ctl_wr;
uint32_t win_size=chan_size*chan_num;
uint32_t ctl_win_size=256*buf_num*chan_num;
uint32_t win_law=0,ctl_law=0;
struct srio_dev *sriodev;
int rvl;
if((port_num >= FVL_SRIO_PORT_NUM) || (port_num <0))
{
FVL_LOG("port number error:%d\n",port_num);
return -1;
}
if((chan_num > FVL_PORT_DMA_NUM) || ( chan_num<0))
{
FVL_LOG("channel number error:%d\n",chan_num);
return -1;
}
if(!init_flag)
{
of_init();
rvl = fsl_srio_uio_init(&sriodev);
if (rvl < 0)
{
FVL_LOG("%s(): fsl_srio_uio_init return %d\n", __func__, rvl);
return rvl;
}
psrio->sriodev=sriodev;
init_flag=1;
}
else
{
sriodev=psrio->sriodev;
}
psrio->buf_num[port_num]=buf_num;
psrio->buf_size[port_num]=buf_size;
psrio->chan_size[port_num]=chan_size;
psrio->ctl_size[port_num]=buf_num*256;
psrio->chan_num[port_num]=chan_num;
struct srio_port_info *pinfo;
void *range;
pinfo = &psrio->portpool[port_num].port_info;
fsl_srio_connection(sriodev,port_num);
if (fsl_srio_port_connected(sriodev) & (0x1 << port_num))
{
fsl_srio_get_port_info(sriodev, port_num+1, pinfo, &range);
psrio->portpool[port_num].range_virt = range;
FVL_LOG("Get port %u info, range=%p, range_start=%llx\n", port_num, range, pinfo->range_start);
}
else
{
FVL_LOG("%s(): fsl_srio_connection port %d failed\n", __func__, port_num+1);
return -1;
}
rvl = fsl_srio_port_connected(sriodev);
if (rvl <= 0)
{
FVL_LOG("%s(): fsl_srio_port_connected return %d\n", __func__, rvl);
return -1;
}
rvl = dma_pool_init(&port_dma_ctl_wp,ctl_win_size,ctl_win_size/2);
if(rvl!=0)
{
FVL_LOG("port %d dma_pool_init failed!\n",port_num+1);
return -errno;
}
rvl = dma_pool_init(&port_dma_ctl_wr,ctl_win_size,ctl_win_size/2);
if(rvl!=0)
{
FVL_LOG("port %d dma_pool_init failed!\n",port_num+1);
return -errno;
}
uint32_t attr_read, attr_write;
attr_read = srio_test_win_attrv[3];
attr_write = srio_test_win_attrv[srio_type];
FVL_LOG("attr_write = %u, srio_type = %u\n", attr_write, srio_type);
ppool = &psrio->portpool[port_num];
ppool->write_result = port_dma_wr->dma_phys_base;
ppool->pwrite_result = port_dma_wr->dma_virt_base;
ppool->write_ctl_result = port_dma_ctl_wr->dma_phys_base;
ppool->write_ctl_data = port_dma_ctl_wp->dma_phys_base;
ppool->pwrite_ctl_result = port_dma_ctl_wr->dma_virt_base;
ppool->pwrite_ctl_data = port_dma_ctl_wp->dma_virt_base;
win_law=FVL_BASE_LAW+fvl_get_law((win_size/FVL_BASE_LAW_SIZE)-1);
ctl_law=FVL_BASE_LAW+fvl_get_law((ctl_win_size/FVL_BASE_LAW_SIZE)-1);
fsl_srio_set_ibwin(sriodev, port_num, 1, ppool->write_result,
FVL_SRIO_SYS_ADDR, win_law);
fsl_srio_set_ibwin(sriodev, port_num, 2, ppool->write_ctl_result,
FVL_SRIO_CTL_ADDR, ctl_law);
uint32_t win_offset=FVL_BASE_LAW_SIZE;
int i=0;
for(i=FVL_BASE_LAW;i<win_law;i++)
{
win_offset=win_offset*2;
}
ppool->ctl_info_start=ppool->port_info.range_start+win_offset;
if (fsl_srio_port_connected(sriodev) & (0x1 << port_num))
{
//data
fsl_srio_set_obwin(sriodev, port_num, 1,
ppool->port_info.range_start,
FVL_SRIO_SYS_ADDR, win_law);
fsl_srio_set_obwin_attr(sriodev, port_num, 1,
attr_read, attr_write);
//ctl
fsl_srio_set_obwin(sriodev, port_num, 2,
ppool->port_info.range_start+win_offset,
FVL_SRIO_CTL_ADDR, ctl_law);
fsl_srio_set_obwin_attr(sriodev, port_num, 2,
attr_read, attr_write);
}
else
{
FVL_LOG("SRIO port %d error!\n", port_num + 1);
return -errno;
}
rvl=fsl_srio_set_deviceid(sriodev,port_num,source_id[port_num]);
if(rvl!=0)
{
FVL_LOG("SRIO port %d set source_id faile!\n",port_num);
return -errno;
}
rvl=fsl_srio_set_targetid(sriodev,port_num,1,target_id);
if(rvl!=0)
{
FVL_LOG("SRIO port %d set target_id faile!\n",port_num);
return -errno;
}
rvl=fsl_srio_set_targetid(sriodev,port_num,2,target_id);
if(rvl!=0)
{
FVL_LOG("SRIO port %d set target_id faile!\n",port_num);
return -errno;
}
memset(port_dma_wr->dma_virt_base,0,win_size);
memset(port_dma_ctl_wp->dma_virt_base,0,ctl_win_size);
memset(port_dma_ctl_wr->dma_virt_base,0,ctl_win_size);
//need send packet_info out
FVL_LOG("###########Init Complete#########\n");
return 0;
}
int fvl_srio_init(fvl_srio_context_t **ppsrio, uint32_t srio_type)
{
fvl_srio_context_t *psrio = &g_srio_context;
fvl_srio_portpool_t *ppool;
struct srio_dev *sriodev;
fvl_dma_pool_t *dmapool = NULL;
fvl_dma_pool_t *dmapool_ctl=NULL;
int port_num;
int rvl;
int i,j;
of_init();
rvl = fsl_srio_uio_init(&sriodev);
if (rvl < 0) {
FVL_LOG("%s(): fsl_srio_uio_init return %d\n", __func__, rvl);
return rvl;
}
port_num = fsl_srio_get_port_num(sriodev);
if(port_num > FVL_SRIO_PORTNUM) {
port_num = FVL_SRIO_PORTNUM;
}
for (i = 0; i < port_num; i++) {
struct srio_port_info *pinfo;
void *range;
pinfo = &psrio->portpool[i].port_info;
fsl_srio_connection(sriodev, i);
if (fsl_srio_port_connected(sriodev) & (0x1 << i)) {
fsl_srio_get_port_info(sriodev, i+1, pinfo, &range);
psrio->portpool[i].range_virt = range;
FVL_LOG("Get port %u info, range=%p, range_start=%llx\n", i, range, pinfo->range_start);
} else {
FVL_LOG("%s(): fsl_srio_connection port %d failed\n", __func__, i);
}
}
rvl = fsl_srio_port_connected(sriodev);
if (rvl <= 0) {
FVL_LOG("%s(): fsl_srio_port_connected return %d\n", __func__, rvl);
fsl_srio_uio_finish(sriodev);
of_finish();
return -1;
}
rvl = dma_pool_init(&dmapool,FVL_SRIO_DMA_POOLSIZE,FVL_SRIO_DMA_POOL_PORT_OFFSET);
rvl = dma_pool_init(&dmapool_ctl,FVL_SRIO_CTL_POOLSIZE,FVL_SRIO_CTL_POOL_PORT_OFFSET);//ctx add
for (i = 0; i < port_num; i++) {
dma_addr_t phy_base;
dma_addr_t phy_base_ctl;
uint8_t *vir_base;
uint8_t *vir_base_ctl;
uint32_t attr_read, attr_write;
attr_read = srio_test_win_attrv[3];
attr_write = srio_test_win_attrv[srio_type];
printf("attr_write = %u, srio_type = %u\n", attr_write, srio_type);
ppool = &psrio->portpool[i];
phy_base = dmapool->dma_phys_base + FVL_SRIO_DMA_POOL_PORT_OFFSET * i;
phy_base_ctl = dmapool_ctl->dma_phys_base+FVL_SRIO_CTL_POOL_PORT_OFFSET*i;//ctxadd
for(j=0;j<FVL_SRIO_BUFFER_NUMBER;j++)//ctx add
{
ppool->write_data[j] = phy_base+FVL_SRIO_DMA_BUFSIZE*j;
ppool->write_ctl_result[j] = phy_base_ctl +FVL_SRIO_CTL_BUFSIZE*j;
ppool->write_ctl_data[j] = phy_base_ctl + FVL_SRIO_CTL_WINSIZE+FVL_SRIO_CTL_BUFSIZE*j;
}
vir_base = dmapool->dma_virt_base + FVL_SRIO_DMA_POOL_PORT_OFFSET * i;
vir_base_ctl = dmapool_ctl->dma_virt_base+FVL_SRIO_CTL_POOL_PORT_OFFSET*i;
for(j=0;j<FVL_SRIO_BUFFER_NUMBER;j++)
{
ppool->pwrite_data[j] = vir_base+FVL_SRIO_DMA_BUFSIZE*j;
ppool->pwrite_ctl_result[j] = vir_base_ctl +FVL_SRIO_CTL_BUFSIZE*j;
ppool->pwrite_ctl_data[j] = vir_base_ctl + FVL_SRIO_CTL_WINSIZE+FVL_SRIO_CTL_BUFSIZE*j;
}
FVL_LOG("Port %d: virt base=%p, phys base=%llx\n", i, vir_base, phy_base);
fsl_srio_set_ibwin(sriodev, i, 1, ppool->write_result[0],
FVL_SRIO_SYS_ADDR, LAWAR_SIZE_64M);
fsl_srio_set_ibwin(sriodev, i, 2, ppool->write_ctl_result[0],
FVL_SRIO_CTL_ADDR, LAWAR_SIZE_4M);
if (fsl_srio_port_connected(sriodev) & (0x1 << i)) {
//data
fsl_srio_set_obwin(sriodev, i, 1,
ppool->port_info.range_start,
FVL_SRIO_SYS_ADDR, LAWAR_SIZE_64M);
fsl_srio_set_obwin_attr(sriodev, i, 1,
attr_read, attr_write);
//ctl
fsl_srio_set_obwin(sriodev, i, 2,
ppool->port_info.range_start+FVL_SRIO_DMA_WINSIZE,
FVL_SRIO_CTL_ADDR, LAWAR_SIZE_4M);
fsl_srio_set_obwin_attr(sriodev, i, 2,
attr_read, attr_write);
} else {
printf("SRIO port %d error!\n", i + 1);
return -errno;
}
memset(vir_base, 0, FVL_SRIO_DMA_POOL_PORT_OFFSET);
memset(vir_base_ctl, 0, FVL_SRIO_CTL_POOL_PORT_OFFSET);
}
rvl = fsl_srio_set_targetid(sriodev,0,1,0x11);
if(rvl !=0)
{
printf("set targetid error!\n");
return -1;
}
rvl = fsl_srio_set_targetid(sriodev,0,2,0x11);
if(rvl !=0)
{
printf("set targetid error!\n");
return -1;
}
rvl = fsl_srio_set_targetid(sriodev,1,1,0x14);
if(rvl !=0)
{
printf("set targetid error!\n");
return -1;
}
rvl = fsl_srio_set_targetid(sriodev,1,2,0x14);
if(rvl !=0)
{
printf("set targetid error!\n");
return -1;
}
rvl = fsl_srio_set_deviceid(sriodev,1,0x11);
if(rvl !=0)
{
printf("set deviceid error!\n");
return -1;
}
rvl = fsl_srio_set_deviceid(sriodev,0,0x14);
if(rvl !=0)
{
printf("set deviceid error!\n");
return -1;
}
*ppsrio = psrio;
return 0;
}
void fsl_cpu_init(int cpu, int global, void_func sync_all)
{
int ret;
curr_cpu_id = cpu;
if (global) {
ret = of_init();
if (ret) {
TRACE("of_init() failed\n");
exit(EXIT_FAILURE);
}
ret = fman_init();
if (ret) {
TRACE("fman_init() failed\n");
exit(EXIT_FAILURE);
}
ret = bman_global_init();
if (ret) {
TRACE("bman_global_init() failed, ret=%d\n", ret);
exit(EXIT_FAILURE);
}
ret = qman_global_init();
if (ret) {
TRACE("qman_global_init() failed, ret=%d\n", ret);
exit(EXIT_FAILURE);
}
dma_mem_generic = dma_mem_create(DMA_MAP_FLAG_ALLOC,
NULL, HLP_DMA_MEM_256M);
if (!dma_mem_generic) {
TRACE("dma_mem_create() failed\n");
exit(EXIT_FAILURE);
}
}
/* sync until the init done for 'fman, qman, bman,
and dma' components */
if (sync_all != NULL)
sync_all();
DEBUG("sync the 1st time\n");
/* Initialise bman/qman portals */
ret = bman_thread_init();
if (ret) {
TRACE("bman_thread_init(%d) failed, ret=%d\n", cpu, ret);
exit(EXIT_FAILURE);
}
ret = qman_thread_init();
if (ret) {
TRACE("qman_thread_init(%d) failed, ret=%d\n", cpu, ret);
exit(EXIT_FAILURE);
}
if (global)
helper_pool_channel_init();
/* sync all cores to wait for buffer pool and FQs init done */
if (sync_all != NULL)
sync_all();
/* init application tx fq, the fqid need be modified during run-time */
local_tx_fq_init();
/* dequeue rx pool channel for current thread */
qman_static_dequeue_add(helper_sdqcr);
DEBUG("sync the 2nd time\n");
}
int fvl_srio_init(fvl_srio_init_param_t *srio_param)
{
fvl_srio_context_t *psrio = &g_srio_context;
fvl_srio_portpool_t *ppool;
fvl_srio_ctrlblk_t *pscb;
uint32_t srio_type=0;//srio_param->srio_type;
uint32_t chan_num=srio_param->chan_num;
uint32_t buf_num=srio_param->buf_num;
uint32_t buf_size=srio_param->buf_size;
uint32_t chan_size=srio_param->chan_size;
uint32_t ctl_size=512;//FVLSRIO_CTL_SIZE;
uint32_t target_id = srio_param->target_id;
uint32_t port_num=srio_param->port_num;
fvl_dma_pool_t *port_dma_wr = srio_param->port_rd_buf;
fvl_dma_pool_t *port_dma_ctl_wp;
fvl_dma_pool_t *port_dma_ctl_wr;
uint32_t win_size=chan_size*chan_num;
uint32_t ctl_win_size=0x1000;//ctl_size*chan_num;
uint32_t win_law=0,ctl_law=0;
struct srio_dev *sriodev;
int rvl;
if((port_num >= FVL_SRIO_PORT_NUM) || (port_num <0))
{
FVL_LOG("port number error:%d\n",port_num);
return -1;
}
if((chan_num > FVL_PORT_DMA_NUM) || ( chan_num<0))
{
FVL_LOG("channel number error:%d\n",chan_num);
return -1;
}
if(!init_flag)
{
of_init();
rvl = fsl_srio_uio_init(&sriodev);
if (rvl < 0)
{
FVL_LOG("%s(): fsl_srio_uio_init return %d\n", __func__, rvl);
return rvl;
}
psrio->sriodev=sriodev;
init_flag=1;
}
else
{
sriodev=psrio->sriodev;
}
//mode slave
head_port[port_num].ctl_re_addr=FVL_SRIO_HEAD_ADDR;
head_port[port_num].chan_num=chan_num;
head_port[port_num].re_flag=1;
head_port[port_num].uflag=0;
int i=0;
for(i=0;i<chan_num;i++)
{
head_channel[i].re_flag=1;
head_channel[i].uflag=0;
}
struct srio_port_info *pinfo;
void *range;
pinfo = &psrio->portpool[port_num].port_info;
fsl_srio_connection(sriodev,port_num);
if (fsl_srio_port_connected(sriodev) & (0x1 << port_num))
{
fsl_srio_get_port_info(sriodev, port_num+1, pinfo, &range);
psrio->portpool[port_num].range_virt = range;
FVL_LOG("Get port %u info, range=%p, range_start=%llx\n", port_num, range, pinfo->range_start);
}
else
{
FVL_LOG("%s(): fsl_srio_connection port %d failed\n", __func__, port_num+1);
return -1;
}
rvl = fsl_srio_port_connected(sriodev);
if (rvl <= 0)
{
FVL_LOG("%s(): fsl_srio_port_connected return %d\n", __func__, rvl);
return -1;
}
rvl = dma_pool_init(&port_dma_ctl_wp,ctl_win_size,ctl_win_size/2);
if(rvl!=0)
{
FVL_LOG("port %d dma_pool_init failed!\n",port_num+1);
return -errno;
}
rvl = dma_pool_init(&port_dma_ctl_wr,ctl_win_size,ctl_win_size/2);
if(rvl!=0)
{
FVL_LOG("port %d dma_pool_init failed!\n",port_num+1);
return -errno;
}
uint32_t attr_read, attr_write;
attr_read = srio_test_win_attrv[3];
attr_write = srio_test_win_attrv[srio_type];
FVL_LOG("attr_write = %u, srio_type = %u\n", attr_write, srio_type);
ppool = &psrio->portpool[port_num];
ppool->write_result = port_dma_wr->dma_phys_base;
ppool->pwrite_result = port_dma_wr->dma_virt_base;
ppool->write_ctl_result = port_dma_ctl_wr->dma_phys_base;
ppool->write_ctl_data = port_dma_ctl_wp->dma_phys_base;
ppool->pwrite_ctl_result = port_dma_ctl_wr->dma_virt_base;
ppool->pwrite_ctl_data = port_dma_ctl_wp->dma_virt_base;
ctl_law=FVL_BASE_LAW+fvl_get_law((ctl_win_size/FVL_BASE_LAW_SIZE)-1);
fsl_srio_set_ibwin(sriodev, port_num, 2, ppool->write_ctl_result,
FVL_SRIO_HEAD_ADDR, ctl_law);
rvl=fsl_srio_set_deviceid(sriodev,port_num,source_id[port_num]);
if(rvl!=0)
{
FVL_LOG("SRIO port %d set source_id faile!\n",port_num);
return -errno;
}
rvl=fsl_srio_set_targetid(sriodev,port_num,1,target_id);
if(rvl!=0)
{
FVL_LOG("SRIO port %d set target_id faile!\n",port_num);
return -errno;
}
rvl=fsl_srio_set_targetid(sriodev,port_num,2,target_id);
if(rvl!=0)
{
FVL_LOG("SRIO port %d set target_id faile!\n",port_num);
return -errno;
}
memset(port_dma_wr->dma_virt_base,0,win_size);
memset(port_dma_ctl_wp->dma_virt_base,0,ctl_win_size);
memset(port_dma_ctl_wr->dma_virt_base,0,ctl_win_size);
//create thread:
fvl_head_thread_t head_arg;
head_arg.num = port_num;
head_arg.op_mode = 0;
head_arg.buf_virt=ppool->pwrite_ctl_result;
rvl = pthread_create(&(psrio->chan_id[port_num]), NULL,fvl_srio_recv_head, &head_arg);
if (rvl)
{
FVL_LOG("Create receive packet thread error!\n");
return -errno;
}
FVL_LOG("SRIO Initial complete\n");
return 0;
}
int fvl_srio_init(fvl_srio_init_param_t *srio_param)
{
fvl_srio_context_t *psrio = &g_srio_context;
fvl_srio_portpool_t *ppool;
fvl_srio_ctrlblk_t *pscb,*cscb,*re_cscb;
fvl_head_thread_t head_arg;
uint32_t chan_num=srio_param->chan_num;
uint32_t buf_num=srio_param->buf_num;
uint32_t buf_size=srio_param->buf_size;
uint32_t chan_size=srio_param->chan_size;
uint32_t ctl_size=FVL_CTL_WIN_SIZE;
uint32_t port_num=srio_param->port_num;
fvl_dma_pool_t *port_dma_wr = srio_param->port_rd_buf;
fvl_dma_pool_t *port_dma_ctl_wp;
fvl_dma_pool_t *port_dma_ctl_wr;
uint32_t win_size=chan_size*chan_num; //need change
uint32_t ctl_win_size=0x400000;//ctl_size*chan_num;
uint32_t win_law=0,ctl_law=0;
struct srio_dev *sriodev;
int rvl;
int i=0;
if((port_num >= FVL_SRIO_PORT_NUM) || (port_num <0))
{
FVL_LOG("port number error:%d\n",port_num);
return -1;
}
if((chan_num > FVL_PORT_CHAN_NUM_MAX) || ( chan_num<0))
{
FVL_LOG("channel number error:%d\n",chan_num);
return -1;
}
if(!init_flag)
{
of_init();
rvl = fsl_srio_uio_init(&sriodev);
if (rvl < 0)
{
FVL_LOG("%s(): fsl_srio_uio_init return %d\n", __func__, rvl);
return rvl;
}
psrio->sriodev=sriodev;
init_flag=1;
}
else
{
sriodev=psrio->sriodev;
}
//mode master
FVL_LOG("buf_size:%d buf_num: %d\n",buf_size,buf_num);
uint32_t offset=0;
for(i=0;i<chan_num;i++)
{
head_port[port_num].data_se_cluster[i].buf_size=buf_size;
head_port[port_num].data_se_cluster[i].buf_num=buf_num;
offset=offset+buf_size*buf_num;
head_port[port_num].data_se_cluster[i].cluster_addr=FVL_SRIO_SYS_ADDR+offset;
head_port[port_num].data_re_cluster[i].buf_size=buf_size;
head_port[port_num].data_re_cluster[i].buf_num=buf_num;
head_port[port_num].data_re_cluster[i].cluster_addr=FVL_SRIO_SYS_ADDR+offset;
head_port[port_num].re_flag=1;
head_port[port_num].uflag=0;
srio_channel_context[(FVL_PORT_CHAN_NUM_MAX*port_num+i)].chan_size=buf_size*buf_num;
}
psrio->chan_num[port_num] = chan_num;
//end master
struct srio_port_info *pinfo;
void *range;
pinfo = &psrio->portpool[port_num].port_info;
fsl_srio_connection(sriodev,port_num);
if (fsl_srio_port_connected(sriodev) & (0x1 << port_num))
{
fsl_srio_get_port_info(sriodev, port_num+1, pinfo, &range);
psrio->portpool[port_num].range_virt = range;
FVL_LOG("Get port %u info, range=%p, range_start=%llx range_size=%llx\n", port_num, range, pinfo->range_start,pinfo->range_size);
}
else
{
FVL_LOG("%s(): fsl_srio_connection port %d failed\n", __func__, port_num+1);
return -1;
}
rvl = fsl_srio_port_connected(sriodev);
if (rvl <= 0)
{
FVL_LOG("%s(): fsl_srio_port_connected return %d\n", __func__, rvl);
return -1;
}
rvl = dma_pool_init(&port_dma_ctl_wp,ctl_win_size,ctl_win_size/2);
if(rvl!=0)
{
FVL_LOG("port %d dma_pool_init failed!\n",port_num+1);
return -errno;
}
rvl = dma_pool_init(&port_dma_ctl_wr,ctl_win_size,ctl_win_size/2);
if(rvl!=0)
{
FVL_LOG("port %d dma_pool_init failed!\n",port_num+1);
return -errno;
}
uint32_t attr_read, attr_write;
attr_read = srio_test_win_attrv[3];
attr_write = srio_test_win_attrv[0];
FVL_LOG("attr_write = %u, srio_type = 0\n", attr_write);
ppool = &psrio->portpool[port_num];
ppool->write_result = port_dma_wr->dma_phys_base;
ppool->pwrite_result = port_dma_wr->dma_virt_base;
ppool->write_ctl_result = port_dma_ctl_wr->dma_phys_base;
ppool->write_ctl_data = port_dma_ctl_wp->dma_phys_base;
ppool->pwrite_ctl_result = port_dma_ctl_wr->dma_virt_base;
ppool->pwrite_ctl_data = port_dma_ctl_wp->dma_virt_base;
win_law=FVL_BASE_LAW+fvl_get_law((win_size/FVL_BASE_LAW_SIZE)-1);
ctl_law=FVL_BASE_LAW+fvl_get_law((ctl_win_size/FVL_BASE_LAW_SIZE)-1);
FVL_LOG("HOST WIN_LAW:%d CTL_LAW:%d\n",win_law,ctl_law);
fsl_srio_set_ibwin(sriodev, port_num, 1, ppool->write_result,
FVL_SRIO_SYS_ADDR, win_law);
fsl_srio_set_ibwin(sriodev, port_num, 2, ppool->write_ctl_result,
FVL_SRIO_CTL_ADDR, ctl_law);
uint32_t win_offset=FVL_BASE_LAW_SIZE;
for(i=FVL_BASE_LAW;i<win_law;i++)
{
win_offset=win_offset*2;
}
FVL_LOG("HOST WIN_OFFSET:%d\n",win_offset);
ppool->ctl_info_start=ppool->port_info.range_start+win_offset;
if (fsl_srio_port_connected(sriodev) & (0x1 << port_num))
{
//ctl
fsl_srio_set_obwin(sriodev, port_num, 2,
ppool->port_info.range_start+win_offset,
FVL_SRIO_CTL_ADDR, ctl_law);
fsl_srio_set_obwin_attr(sriodev, port_num, 2,
attr_read, attr_write);
//data
fsl_srio_set_obwin(sriodev, port_num, 1,
ppool->port_info.range_start,
FVL_SRIO_SYS_ADDR, win_law);
fsl_srio_set_obwin_attr(sriodev, port_num, 1,
attr_read, attr_write);
}
else
{
FVL_LOG("SRIO port %d error!\n", port_num + 1);
return -errno;
}
rvl=fsl_srio_set_deviceid(sriodev,port_num,source_id[port_num]);
if(rvl!=0)
{
FVL_LOG("SRIO port %d set source_id faile!\n",port_num);
return -errno;
}
rvl=fsl_srio_set_targetid(sriodev,port_num,1,target_id[port_num]);
if(rvl!=0)
{
FVL_LOG("SRIO port %d set target_id faile!\n",port_num);
return -errno;
}
rvl=fsl_srio_set_targetid(sriodev,port_num,2,target_id[port_num]);
if(rvl!=0)
{
FVL_LOG("SRIO port %d set target_id faile!\n",port_num);
return -errno;
}
// FVL_LOG("################retry##############\n");
fsl_srio_set_phy_retry_threshold(sriodev,port_num,0,0);
// FVL_LOG("################after retry##############\n");
memset(port_dma_wr->dma_virt_base,0,win_size);
memset(port_dma_ctl_wp->dma_virt_base,0,ctl_win_size);
memset(port_dma_ctl_wr->dma_virt_base,0,ctl_win_size);
fvl_srio_channel_t *temp_channel;
for(i=0;i<FVL_PORT_CHAN_NUM_MAX;i++)
{
pscb=fvl_srio_getcb(port_num,i*2);
if(pscb==NULL)
{
FVL_LOG("port:%d channel:%d : dmadev init error.\n",port_num+1,2*i);
return -1;
}
temp_channel=&srio_channel_context[FVL_PORT_CHAN_NUM_MAX*port_num+i];
FVL_LOG("chan num:%d\n",(FVL_PORT_CHAN_NUM_MAX*port_num+i));
cscb=&(temp_channel->chanblk);
cscb->dmadev=pscb->dmadev;
// FVL_LOG("dmadev addr:%08x\n",pscb->dmadev);
cscb->bfnum=pscb->bfnum;
cscb->port = pscb->port;
pscb=fvl_srio_getcb(port_num,i*2+1);
if(pscb==NULL)
{
FVL_LOG("port:%d channel:%d : dmadev init error.\n",port_num+1,2*i+1);
return -1;
}
re_cscb=&(temp_channel->rechanblk);
re_cscb->dmadev=pscb->dmadev;
// FVL_LOG("dmadev addr:%08x\n",pscb->dmadev);
re_cscb->bfnum=pscb->bfnum;
re_cscb->port = pscb->port;
}
//mode master
//need send packet_info out
memcpy(ppool->pwrite_ctl_data,&head_port[port_num],HEAD_SIZE);
uint64_t dest_phys,src_phys;
src_phys=ppool->write_ctl_data;
dest_phys=ppool->ctl_info_start;
pscb=&psrio->ctrlblk[FVL_PORT_DMA_NUM*port_num+7];
fvl_srio_send(pscb->dmadev,src_phys,dest_phys,HEAD_SIZE);
FVL_LOG("PORT_NUM:%d HEAD_SIZE:%d\n",port_num,HEAD_SIZE);
head_arg.num = port_num;
head_arg.op_mode = 0;
head_arg.buf_virt=ppool->pwrite_ctl_result;
rvl=fvl_srio_recv_head(&head_arg);
if(rvl!=0)
{
FVL_LOG("Host:Port %d is not ready!\n",port_num);
return -1;
}
return 0;
}
int fvl_srio_init(fvl_srio_init_param_t *srio_param)
{
fvl_srio_context_t *psrio = &g_srio_context;
fvl_srio_portpool_t *ppool;
fvl_srio_ctrlblk_t *pscb;
uint32_t srio_type=0;//srio_param->srio_type;
uint32_t chan_num=srio_param->chan_num;
uint32_t buf_num=srio_param->buf_num;
uint32_t buf_size=srio_param->buf_size;
uint32_t chan_size=srio_param->chan_size;
uint32_t ctl_size=1024;//FVLSRIO_CTL_SIZE;
uint32_t port_num=srio_param->port_num;
uint32_t target_id = target1_id[port_num];//srio_param->target_id;
fvl_dma_pool_t *port_dma_wr = srio_param->port_rd_buf;
fvl_dma_pool_t *port_dma_ctl_wp;
fvl_dma_pool_t *port_dma_ctl_wr;
uint32_t win_size=chan_size*chan_num;
uint32_t ctl_win_size=0x1000;//ctl_size*chan_num;
uint32_t win_law=0,ctl_law=0;
struct srio_dev *sriodev;
int rvl;
if((port_num >= FVL_SRIO_PORT_NUM) || (port_num <0))
{
FVL_LOG("port number error:%d\n",port_num);
return -1;
}
if((chan_num > FVL_PORT_DMA_NUM) || ( chan_num<0))
{
FVL_LOG("channel number error:%d\n",chan_num);
return -1;
}
if(!init_flag)
{
of_init();
rvl = fsl_srio_uio_init(&sriodev);
if (rvl < 0)
{
FVL_LOG("%s(): fsl_srio_uio_init return %d\n", __func__, rvl);
return rvl;
}
psrio->sriodev=sriodev;
init_flag=1;
}
else
{
sriodev=psrio->sriodev;
}
//mode master
head_port[port_num].buf_size=buf_size;
head_port[port_num].buf_num=buf_num;
head_port[port_num].chan_size=buf_size*buf_num;
head_port[port_num].data_se_addr=FVL_SRIO_SYS_ADDR;
head_port[port_num].data_re_addr=FVL_SRIO_SYS_ADDR;
head_port[port_num].ctl_se_addr=FVL_SRIO_CTL_ADDR;
head_port[port_num].ctl_re_addr=FVL_SRIO_CTL_ADDR;
head_port[port_num].chan_num=0;
head_port[port_num].re_flag=1;
head_port[port_num].uflag=0;
int i=0;
for(i=0;i<chan_num;i++)
{
head_channel[i].data_se_addr=FVL_SRIO_SYS_ADDR+chan_size*i;
head_channel[i].data_re_addr=FVL_SRIO_SYS_ADDR+chan_size*i;
head_channel[i].ctl_se_addr=FVL_SRIO_CTL_ADDR+HEAD_SIZE+ctl_size*i;
head_channel[i].ctl_se_addr=FVL_SRIO_CTL_ADDR+HEAD_SIZE+ctl_size*i;
head_channel[i].re_flag=1;
head_channel[i].uflag=0;
}
//end master
struct srio_port_info *pinfo;
void *range;
pinfo = &psrio->portpool[port_num].port_info;
fsl_srio_connection(sriodev,port_num);
if (fsl_srio_port_connected(sriodev) & (0x1 << port_num))
{
fsl_srio_get_port_info(sriodev, port_num+1, pinfo, &range);
psrio->portpool[port_num].range_virt = range;
FVL_LOG("Get port %u info, range=%p, range_start=%llx\n", port_num, range, pinfo->range_start);
}
else
{
FVL_LOG("%s(): fsl_srio_connection port %d failed\n", __func__, port_num+1);
return -1;
}
rvl = fsl_srio_port_connected(sriodev);
if (rvl <= 0)
{
FVL_LOG("%s(): fsl_srio_port_connected return %d\n", __func__, rvl);
return -1;
}
rvl = dma_pool_init(&port_dma_ctl_wp,ctl_win_size,ctl_win_size/2);
if(rvl!=0)
{
FVL_LOG("port %d dma_pool_init failed!\n",port_num+1);
return -errno;
}
rvl = dma_pool_init(&port_dma_ctl_wr,ctl_win_size,ctl_win_size/2);
if(rvl!=0)
{
FVL_LOG("port %d dma_pool_init failed!\n",port_num+1);
return -errno;
}
uint32_t attr_read, attr_write;
attr_read = srio_test_win_attrv[3];
attr_write = srio_test_win_attrv[srio_type];
FVL_LOG("attr_write = %u, srio_type = %u\n", attr_write, srio_type);
ppool = &psrio->portpool[port_num];
ppool->write_result = port_dma_wr->dma_phys_base;
ppool->pwrite_result = port_dma_wr->dma_virt_base;
ppool->write_ctl_result = port_dma_ctl_wr->dma_phys_base;
ppool->write_ctl_data = port_dma_ctl_wp->dma_phys_base;
ppool->pwrite_ctl_result = port_dma_ctl_wr->dma_virt_base;
ppool->pwrite_ctl_data = port_dma_ctl_wp->dma_virt_base;
win_law=FVL_BASE_LAW+fvl_get_law((win_size/FVL_BASE_LAW_SIZE)-1);
ctl_law=FVL_BASE_LAW+fvl_get_law((ctl_win_size/FVL_BASE_LAW_SIZE)-1);
FVL_LOG("HOST WIN_LAW:%d CTL_LAW:%d\n",win_law,ctl_law);
fsl_srio_set_ibwin(sriodev, port_num, 1, ppool->write_result,
FVL_SRIO_SYS_ADDR, win_law);
fsl_srio_set_ibwin(sriodev, port_num, 2, ppool->write_ctl_result,
FVL_SRIO_CTL_ADDR, ctl_law);
uint32_t win_offset=FVL_BASE_LAW_SIZE;
for(i=FVL_BASE_LAW;i<win_law;i++)
{
win_offset=win_offset*2;
}
FVL_LOG("HOST WIN_OFFSET:%d\n",win_offset);
ppool->ctl_info_start=ppool->port_info.range_start+win_offset;
if (fsl_srio_port_connected(sriodev) & (0x1 << port_num))
{
//data
fsl_srio_set_obwin(sriodev, port_num, 1,
ppool->port_info.range_start,
FVL_SRIO_SYS_ADDR, win_law);
fsl_srio_set_obwin_attr(sriodev, port_num, 1,
attr_read, attr_write);
//ctl
fsl_srio_set_obwin(sriodev, port_num, 2,
ppool->port_info.range_start+win_offset,
FVL_SRIO_CTL_ADDR, ctl_law);
fsl_srio_set_obwin_attr(sriodev, port_num, 2,
attr_read, attr_write);
}
else
{
FVL_LOG("SRIO port %d error!\n", port_num + 1);
return -errno;
}
rvl=fsl_srio_set_deviceid(sriodev,port_num,source_id[port_num]);
if(rvl!=0)
{
FVL_LOG("SRIO port %d set source_id faile!\n",port_num);
return -errno;
}
rvl=fsl_srio_set_targetid(sriodev,port_num,1,target_id);
if(rvl!=0)
{
FVL_LOG("SRIO port %d set target_id faile!\n",port_num);
return -errno;
}
rvl=fsl_srio_set_targetid(sriodev,port_num,2,target_id);
if(rvl!=0)
{
FVL_LOG("SRIO port %d set target_id faile!\n",port_num);
return -errno;
}
memset(port_dma_wr->dma_virt_base,0,win_size);
memset(port_dma_ctl_wp->dma_virt_base,0,ctl_win_size);
memset(port_dma_ctl_wr->dma_virt_base,0,ctl_win_size);
//mode master
//need send packet_info out
memcpy(ppool->pwrite_ctl_data,&head_port[port_num],HEAD_SIZE);
uint64_t dest_phys,src_phys;
fvl_head_thread_t head_arg;
pscb=fvl_srio_getcb(port_num,0);
if(pscb==NULL)
{
FVL_LOG("port:%d dmadev init error.\n",port_num+1);
return -1;
}
src_phys=ppool->write_ctl_data;
dest_phys=ppool->ctl_info_start;
fvl_srio_send(pscb->dmadev,src_phys,dest_phys,HEAD_SIZE);
//create thread:
head_arg.num = port_num;
head_arg.op_mode = 0;
head_arg.buf_virt=ppool->pwrite_ctl_result;
rvl = pthread_create(&(psrio->chan_id[port_num]), NULL,fvl_srio_recv_head, &head_arg);
if (rvl)
{
FVL_LOG("Create receive packet thread error!\n");
return -errno;
}
return 0;
}
void _start(int arg1, int arg2, void *openfirmware)
{
int chosen;
of_init(openfirmware);
/* open the input and output handle */
chosen = of_finddevice("/chosen");
of_getprop(chosen, "stdin", &of_input_handle, sizeof(of_input_handle));
of_getprop(chosen, "stdout", &of_output_handle, sizeof(of_output_handle));
puts("this is a test\n");
init_serial();
restart:
puts("waiting for command\n");
{
int base_address;
int entry_point;
int length;
int command;
unsigned char *ptr;
void (*func)(int, int, void *);
serial_read_int32(&command);
if(command != 0x99) {
puts("bad command, restarting\n");
goto restart;
}
serial_read_int32(&base_address);
serial_read_int32(&length);
serial_read_int32(&entry_point);
puts("read base and length, claiming\n");
puts("base ");
write_hex(base_address);
puts("\nlength ");
write_hex(length);
puts("\nentry_point ");
write_hex(entry_point);
puts("\n");
ptr = (void *)base_address;
of_claim(base_address, length, 0);
puts("reading data\n");
serial_read(ptr, length);
puts("done reading data, calling function\n");
func = (void *)entry_point;
func(arg1, arg2, openfirmware);
}
of_exit();
}
