void nf_readpage(unsigned int block,unsigned int page,unsigned char *dstaddr)
{
unsigned int i;
unsigned int blockpage=(block<<6)+page;
/*计算page绝对地址*/
nand_reset();
enable();
enable_rb();
send_cmd(readp1);
send_addr(0x00);
send_addr(0x00);
send_addr((blockpage)&0xff);
send_addr((blockpage>>8)&0xff);
send_addr((blockpage>>16)&0x01);
send_cmd(readp2);
check_busy();
for(i=0;i<2048;i++)
{
dstaddr[i]=read_byte();
}
disable();
}
static int update_mcu_bin(struct ssp_data *data, int iBinType)
{
int retry = BLMODE_RETRYCOUNT;
int iRet = SUCCESS;
struct stm32fwu_spi_cmd cmd;
cmd.cmd = GO_COMMAND;
cmd.xor_cmd = XOR_GO_COMMAND;
cmd.timeout = 1000;
cmd.ack_pad = (u8)((STM_APP_ADDR >> 24) & 0xFF);
do {
iRet = change_to_bootmode(data);
pr_info("[ssp] bootmode %d retry: %d\n", iRet, 3 - retry);
} while (retry-- > 0 && iRet != BL_ACK );
if(iRet != BL_ACK) {
pr_err("[SSP]: %s - change_to_bootmode %d\n",
__func__, iRet);
return iRet;
}
iRet = fw_erase_stm(data->spi);
if (iRet < 0) {
pr_err("[SSP]: %s - fw_erase_stm %d\n",
__func__, iRet);
return iRet;
}
switch (iBinType) {
case KERNEL_BINARY:
/* HW request: I2C line is reversed */
iRet = load_kernel_fw_bootmode(data->spi,
BL_FW_NAME);
break;
case KERNEL_CRASHED_BINARY:
iRet = load_kernel_fw_bootmode(data->spi,
BL_CRASHED_FW_NAME);
break;
case UMS_BINARY:
iRet = load_ums_fw_bootmode(data->spi,
BL_UMS_FW_NAME);
break;
default:
pr_err("[SSP] binary type error!!\n");
}
/* STM : GO USER ADDR */
stm32fwu_spi_send_cmd(data->spi, &cmd);
if (cmd.ack_loops > 0)
send_addr(data->spi, STM_APP_ADDR, 1);
else
send_addr(data->spi, STM_APP_ADDR, 0);
msleep(SSP_SW_RESET_TIME);
return iRet;
}
void NF_Page_Read(unsigned long addr, unsigned char *buff, int size)
{
int i, len;
// 选中NF
select_chip();
// 清除RnB
clear_RnB();
// 发送0x00命令
send_cmd(0x00);
// 发送2个列地址
send_addr(0x00);
send_addr(0x00);
// 发送3个行地址
send_addr(addr & 0xFF);
send_addr((addr >> 8) & (0xFF));
send_addr((addr >> 16) & (0xFF));
// 发送0x30命令
send_cmd(0x30);
// 等待RnB信号
wait_RnB();
/* 判断出一个合适的size */
if(size > PAGE_SIZE)
len = size > PAGE_SIZE*4 ? PAGE_SIZE*4 : size;
else if(size < PAGE_SIZE)
len = size;
else
len = PAGE_SIZE;
// len = size > PAGE_SIZE ? size : PAGE_SIZE;
// if(len > PAGE_SIZE*4)
// len = PAGE_SIZE*4;
// 读取数据
for(i=0; i < len; i++)
{
*buff++ = NFDATA;
}
//取消选中
delete_chip();
}
static int update_mcu_bin(struct ssp_data *data, int iBinType)
{
int retry = BLMODE_RETRYCOUNT;
int iRet = SUCCESS;
struct stm32fwu_spi_cmd cmd;
cmd.cmd = GO_COMMAND;
cmd.xor_cmd = XOR_GO_COMMAND;
cmd.timeout = 1000;
cmd.ack_pad = (u8)((STM_APP_ADDR >> 24) & 0xFF);
// 1. Start system boot mode
do {
iRet = change_to_bootmode(data);
pr_info("[ssp] bootmode %d retry: %d\n", iRet, 3 - retry);
} while (retry-- > 0 && iRet != BL_ACK );
if(iRet != BL_ACK) {
pr_err("[SSP]: %s - change_to_bootmode %d\n",
__func__, iRet);
return iRet;
}
// 2. Flash erase all
iRet = fw_erase_stm(data->spi);
if (iRet < 0) {
pr_err("[SSP]: %s - fw_erase_stm %d\n",
__func__, iRet);
return iRet;
}
switch (iBinType) {
case KERNEL_BINARY:
/* HW request: I2C line is reversed */
#if defined(CONFIG_SEC_KSPORTS_PROJECT)
iRet = load_kernel_fw_bootmode(data->spi, BL_FW_NAME_TASMAN);
#else
iRet = load_kernel_fw_bootmode(data->spi, BL_FW_NAME);
#endif
break;
case KERNEL_CRASHED_BINARY:
iRet = load_kernel_fw_bootmode(data->spi, BL_CRASHED_FW_NAME);
break;
case UMS_BINARY:
iRet = load_ums_fw_bootmode(data->spi, BL_UMS_FW_NAME);
break;
default:
pr_err("[SSP] binary type error!!\n");
}
/* STM : GO USER ADDR */
stm32fwu_spi_send_cmd(data->spi, &cmd);
send_addr(data->spi, STM_APP_ADDR, 0);
data->spi->mode = SPI_MODE_1;
if (spi_setup(data->spi))
pr_err("failed to setup spi mode for app\n");
usleep_range(1000, 1100);
return iRet;
}
static int fw_read_stm(struct spi_device *spi, u32 fw_addr,
int len, const u8 *buffer)
{
int res;
struct stm32fwu_spi_cmd cmd;
struct stm32fwu_spi_cmd dummy_cmd;
int i;
u8 xor = 0;
u8 send_buff[STM_MAX_BUFFER_SIZE] = {0,};
cmd.cmd = WMEM_COMMAND;
cmd.xor_cmd = XOR_RMEM_COMMAND;
cmd.timeout = DEF_ACKCMD_NUMBER;
cmd.ack_pad = (u8)((fw_addr >> 24) & 0xFF);
res = stm32fwu_spi_send_cmd(spi, &cmd);
if (res != BL_ACK) {
pr_err("[SSP] Error %d sending read_mem cmd\n", res);
return res;
}
if (cmd.ack_loops > 0)
res = send_addr(spi, fw_addr, 1);
else
res = send_addr(spi, fw_addr, 0);
if (res != 0) {
pr_err("[SSP] Error %d sending read_mem Address\n", res);
return res;
}
res = send_byte_count(spi, len, 1);
if (res != 0) {
return -EPROTO;
}
res = stm32fwu_spi_read(spi, buffer, len);
if (res < len) {
return -EIO;
}
return len;
}
static int update_mcu_bin(struct ssp_data *data, int iBinType)
{
int retry = BLMODE_RETRYCOUNT;
int iRet = SUCCESS;
struct stm32fwu_spi_cmd cmd;
cmd.cmd = GO_COMMAND;
cmd.xor_cmd = XOR_GO_COMMAND;
cmd.timeout = 1000;
cmd.ack_pad = (u8)((STM_APP_ADDR >> 24) & 0xFF);
pr_info("[SSP] update_mcu_bin\n");
// 1. Start system boot mode
do {
iRet = change_to_bootmode(data);
pr_info("[SSP] bootmode %d, retry = %d\n", iRet, 3 - retry);
} while (retry-- > 0 && iRet != BL_ACK);
if(iRet != BL_ACK) {
pr_err("[SSP] %s, change_to_bootmode failed %d\n", __func__, iRet);
return iRet;
}
// 2. Flash erase all
iRet = fw_erase_stm(data->spi);
if (iRet < 0) {
pr_err("[SSP] %s, fw_erase_stm failed %d\n", __func__, iRet);
return iRet;
}
pr_info("======[SSP] SCHEDULE!!!!!\n");
schedule(); /*Defence for cpu schedule blocking watchdog*/
msleep(3);
switch (iBinType) {
case KERNEL_BINARY:
/* HW request: I2C line is reversed */
iRet = load_kernel_fw_bootmode(data->spi, BL_FW_NAME);
break;
case KERNEL_CRASHED_BINARY:
iRet = load_kernel_fw_bootmode(data->spi, BL_CRASHED_FW_NAME);
break;
case UMS_BINARY:
iRet = load_ums_fw_bootmode(data->spi, BL_UMS_FW_NAME);
break;
default:
pr_err("[SSP] binary type error!!\n");
}
pr_info("======[SSP] SCHEDULE!!!!!\n");
schedule(); /*Defence for cpu schedule blocking watchdog*/
msleep(3);
/* STM : GO USER ADDR */
stm32fwu_spi_send_cmd(data->spi, &cmd);
send_addr(data->spi, STM_APP_ADDR, 0);
return iRet;
}
int f (int a)
{
if (a > 0)
g (a, 3);
else
g (a, 5);
send_addr (&a);
}
static int update_mcu_bin(struct ssp_data *data, int iBinType)
{
int retry = BLMODE_RETRYCOUNT;
int iRet = SUCCESS;
struct stm32fwu_spi_cmd cmd;
cmd.cmd = GO_COMMAND;
cmd.xor_cmd = XOR_GO_COMMAND;
cmd.timeout = 1000;
cmd.ack_pad = (u8)((STM_APP_ADDR >> 24) & 0xFF);
/* 1. Start system boot mode */
do {
iRet = change_to_bootmode(data);
ssp_info("bootmode %d retry: %d", iRet, 3 - retry);
} while (retry-- > 0 && iRet != BL_ACK);
if (iRet != BL_ACK) {
ssp_errf("change_to_bootmode %d", iRet);
return iRet;
}
/* 2. Flash erase all */
iRet = fw_erase_stm(data->spi);
if (iRet < 0) {
ssp_errf("fw_erase_stm %d", iRet);
return iRet;
}
switch (iBinType) {
case KERNEL_BINARY:
/* HW request: I2C line is reversed */
iRet = load_kernel_fw_bootmode(data->spi, BL_FW_NAME);
break;
case KERNEL_CRASHED_BINARY:
iRet = load_kernel_fw_bootmode(data->spi, BL_CRASHED_FW_NAME);
break;
case UMS_BINARY:
iRet = load_ums_fw_bootmode(data->spi, BL_UMS_FW_NAME);
break;
default:
ssp_err("binary type error!!");
}
/* STM : GO USER ADDR */
stm32fwu_spi_send_cmd(data->spi, &cmd);
send_addr(data->spi, STM_APP_ADDR, 0);
data->spi->mode = SPI_MODE_1;
if (spi_setup(data->spi))
ssp_err("failed to setup spi mode for app");
usleep_range(1000, 1100);
return iRet;
}
static void mgmt_device_found(uint16_t index, uint16_t length,
const void *param, void *user_data)
{
const struct mgmt_ev_device_found *ev = param;
assert(length == sizeof(*ev) + ev->eir_len);
assert(index == opt_src_idx);
// Result sometimes sent too early
if (conn_state != STATE_SCANNING)
return;
resp_begin(rsp_SCAN);
send_addr(&ev->addr);
send_uint(tag_RSSI, -ev->rssi);
send_uint(tag_FLAG, -ev->flags);
if (ev->eir_len)
send_data(ev->eir, ev->eir_len);
resp_end();
}
u32t nand_read(u32t mem_add, u32t nand_add, u32t length){
u32t read_c = 0, i;
unsigned char *c = (unsigned char *)mem_add;
NAND_CHIP_ENABLE;
while (read_c < length) {
nand_reg->NFCMD = 0x00;
send_addr(nand_add + read_c);
nand_reg->NFCMD = 0x30;
NAND_STATE_READY;
for (i = 0; i < PAGE_SIZE && read_c < length;\
i++, read_c++) {
c[read_c] =*(unsigned char volatile*)(&nand_reg->NFDATA);
}
}
NAND_CHIP_DISABLE;
return read_c;
}
static void mgmt_device_connected(uint16_t index, uint16_t length,
const void *param, void *user_data)
{
gchar s[18] = {0};
const struct mgmt_ev_device_connected *ev = param;
assert(index == opt_src_idx);
if (ba2str(&ev->addr.bdaddr, s) != 17)
memset(s, 0xFF, sizeof(s) - 1);
DBG("New device connected : type %d %s state = %d", ev->addr.type, s, conn_state);
if (conn_state != STATE_ADVERTISING)
return;
/* When advertising, indicate that advertising stopped */
set_state(STATE_DISCONNECTED);
/* Send the information about the connection request */
resp_begin(rsp_MGMT);
send_addr(&ev->addr);
resp_end();
}
u32t nand_write(u32t mem_add, u32t nand_add, u32t length){
u32t write_c = 0, i;
unsigned char *c = (unsigned char *)mem_add;
nand_erase(nand_add, length);
NAND_CHIP_ENABLE;
while (write_c < length) {
nand_reg->NFCMD = 0x80;
send_addr(nand_add + write_c);
for (i = 0; i < PAGE_SIZE && write_c < length;\
i++, write_c++) {
*(unsigned char volatile *)&nand_reg->NFDATA = c[write_c];
}
nand_reg->NFCMD = 0x10;
NAND_STATE_READY;
}
NAND_CHIP_DISABLE;
return write_c;
}
static int fw_write_stm(struct spi_device *spi, u32 fw_addr,
int len, const u8 *buffer)
{
int res;
struct stm32fwu_spi_cmd cmd;
struct stm32fwu_spi_cmd dummy_cmd;
int i;
u8 xor = 0;
u8 send_buff[STM_MAX_BUFFER_SIZE] = {0,};
cmd.cmd = WMEM_COMMAND;
cmd.xor_cmd = XOR_WMEM_COMMAND;
cmd.timeout = DEF_ACKCMD_NUMBER;
cmd.ack_pad = (u8)((fw_addr >> 24) & 0xFF);
pr_debug("[SSP]%s\n", __func__);
#if SSP_STM_DEBUG
pr_info("[SSP] sending WMEM_COMMAND\n");
#endif
if (len > STM_MAX_XFER_SIZE) {
pr_err("[SSP] Can't send more than 256 bytes per transaction\n");
return -EINVAL;
}
send_buff[0] = len - 1;
memcpy(&send_buff[1], buffer, len);
for (i = 0; i < (len + 1); i++)
xor ^= send_buff[i];
send_buff[len + 1] = xor;
res = stm32fwu_spi_send_cmd(spi, &cmd);
if (res != BL_ACK) {
pr_err("[SSP] Error %d sending read_mem cmd\n", res);
return res;
}
res = send_addr(spi, fw_addr, 0);
if (res != 0) {
pr_err("[SSP] Error %d sending write_mem Address\n", res);
return res;
}
res = stm32fwu_spi_write(spi, send_buff, len + 2);
if (res < len) {
pr_err("[SSP] Error writing to flash. res = %d\n", res);
return ((res > 0) ? -EIO : res);
}
pr_debug("[SSP]%s 2\n", __func__);
dummy_cmd.timeout = DEF_ACKROOF_NUMBER;
usleep_range(100, 150); /* Samsung added */
res = stm32fwu_spi_wait_for_ack(spi, &dummy_cmd, BL_ACK);
if (res == BL_ACK) {
return len;
}
if (res == BL_NACK) {
pr_err("[SSP] Got NAK waiting for WRITE_MEM to complete\n");
return -EPROTO;
}
pr_err("[SSP] timeout waiting for ACK for WRITE_MEM command\n");
return -ETIME;
}
int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try
{
// Initialize the EC Factory so we can customize the EC
TAO_EC_Default_Factory::init_svcs ();
// Initialize the ORB.
CORBA::ORB_var orb = CORBA::ORB_init (argc, argv);
const ACE_TCHAR *ecname = ACE_TEXT ("EventService");
const ACE_TCHAR *address = ACE_TEXT ("localhost");
const ACE_TCHAR *iorfile = 0;
u_short port = 12345;
u_short listenport = 12345;
int mcast = 1;
for (int i = 0; argv[i] != 0; i++)
{
if (ACE_OS::strcasecmp(argv[i], ACE_TEXT ("-ecname")) == 0)
{
if (argv[i+1] != 0)
ecname = argv[++i];
else
ACE_ERROR_RETURN ((LM_ERROR, "Missing Event channel name\n"),0);
}
else if (ACE_OS::strcasecmp(argv[i], ACE_TEXT ("-address")) == 0)
{
if (argv[i+1] != 0)
address = argv[++i];
else
ACE_ERROR_RETURN ((LM_ERROR, "Missing address\n"),0);
}
else if (ACE_OS::strcasecmp(argv[i], ACE_TEXT ("-port")) == 0)
{
if (argv[i+1] != 0)
port = ACE_OS::atoi(argv[++i]);
else
ACE_ERROR_RETURN ((LM_ERROR, "Missing port\n"),0);
}
else if (ACE_OS::strcasecmp(argv[i], ACE_TEXT ("-listenport")) == 0)
{
if (argv[i+1] != 0)
listenport = ACE_OS::atoi(argv[++i]);
else
ACE_ERROR_RETURN ((LM_ERROR, "Missing port\n"), 0);
}
else if (ACE_OS::strcasecmp(argv[i], ACE_TEXT ("-iorfile")) == 0)
{
if (argv[i+1] != 0)
iorfile = argv[++i];
else
ACE_ERROR_RETURN ((LM_ERROR, "Missing ior file\n"), 0);
}
else if (ACE_OS::strcasecmp(argv[i], ACE_TEXT ("-udp")) == 0)
mcast = 0;
}
// Get the POA
CORBA::Object_var tmpobj = orb->resolve_initial_references ("RootPOA");
PortableServer::POA_var poa = PortableServer::POA::_narrow (tmpobj.in ());
PortableServer::POAManager_var poa_manager = poa->the_POAManager ();
poa_manager->activate ();
// Create a local event channel and register it
TAO_EC_Event_Channel_Attributes attributes (poa.in (), poa.in ());
TAO_EC_Event_Channel ec_impl (attributes);
ec_impl.activate ();
PortableServer::ObjectId_var oid = poa->activate_object(&ec_impl);
tmpobj = poa->id_to_reference(oid.in());
RtecEventChannelAdmin::EventChannel_var ec =
RtecEventChannelAdmin::EventChannel::_narrow(tmpobj.in());
// Find the Naming Service.
tmpobj = orb->resolve_initial_references("NameService");
CosNaming::NamingContextExt_var root_context =
CosNaming::NamingContextExt::_narrow(tmpobj.in());
// Bind the Event Channel using Naming Services
CosNaming::Name_var name =
root_context->to_name (ACE_TEXT_ALWAYS_CHAR (ecname));
root_context->rebind(name.in(), ec.in());
// Get a proxy push consumer from the EventChannel.
RtecEventChannelAdmin::SupplierAdmin_var admin = ec->for_suppliers();
RtecEventChannelAdmin::ProxyPushConsumer_var consumer =
admin->obtain_push_consumer();
// Instantiate an EchoEventSupplier_i servant.
EchoEventSupplier_i servant(orb.in());
// Register it with the RootPOA.
oid = poa->activate_object(&servant);
tmpobj = poa->id_to_reference(oid.in());
RtecEventComm::PushSupplier_var supplier =
RtecEventComm::PushSupplier::_narrow(tmpobj.in());
// Connect to the EC.
ACE_SupplierQOS_Factory qos;
qos.insert (MY_SOURCE_ID, MY_EVENT_TYPE, 0, 1);
consumer->connect_push_supplier (supplier.in (), qos.get_SupplierQOS ());
// Initialize the address server with the desired address. This will
// be used by the sender object and the multicast receiver only if
// one is not otherwise available via the naming service.
ACE_INET_Addr send_addr (port, address);
SimpleAddressServer addr_srv_impl (send_addr);
// Create an instance of the addr server for local use
PortableServer::ObjectId_var addr_srv_oid =
poa->activate_object(&addr_srv_impl);
tmpobj =
poa->id_to_reference(addr_srv_oid.in());
RtecUDPAdmin::AddrServer_var addr_srv =
RtecUDPAdmin::AddrServer::_narrow(tmpobj.in());
// Create and initialize the sender object
PortableServer::Servant_var<TAO_ECG_UDP_Sender> sender =
TAO_ECG_UDP_Sender::create();
TAO_ECG_UDP_Out_Endpoint endpoint;
// need to be explicit about the address type when built with
// IPv6 support, otherwise SOCK_DGram::open defaults to ipv6 when
// given a sap_any address. This causes trouble on at least solaris
// and windows, or at most on not-linux.
if (endpoint.dgram ().open (ACE_Addr::sap_any,
send_addr.get_type()) == -1)
{
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot open send endpoint\n"),
1);
}
// TAO_ECG_UDP_Sender::init() takes a TAO_ECG_Refcounted_Endpoint.
// If we don't clone our endpoint and pass &endpoint, the sender will
// attempt to delete endpoint during shutdown.
TAO_ECG_Refcounted_Endpoint clone (new TAO_ECG_UDP_Out_Endpoint (endpoint));
sender->init (ec.in (), addr_srv.in (), clone);
// Setup the subscription and connect to the EC
ACE_ConsumerQOS_Factory cons_qos_fact;
cons_qos_fact.start_disjunction_group ();
cons_qos_fact.insert (ACE_ES_EVENT_SOURCE_ANY, ACE_ES_EVENT_ANY, 0);
RtecEventChannelAdmin::ConsumerQOS sub = cons_qos_fact.get_ConsumerQOS ();
sender->connect (sub);
// Create and initialize the receiver
PortableServer::Servant_var<TAO_ECG_UDP_Receiver> receiver =
TAO_ECG_UDP_Receiver::create();
// TAO_ECG_UDP_Receiver::init() takes a TAO_ECG_Refcounted_Endpoint.
// If we don't clone our endpoint and pass &endpoint, the receiver will
// attempt to delete endpoint during shutdown.
TAO_ECG_Refcounted_Endpoint clone2 (new TAO_ECG_UDP_Out_Endpoint (endpoint));
receiver->init (ec.in (), clone2, addr_srv.in ());
// Setup the registration and connect to the event channel
ACE_SupplierQOS_Factory supp_qos_fact;
supp_qos_fact.insert (MY_SOURCE_ID, MY_EVENT_TYPE, 0, 1);
RtecEventChannelAdmin::SupplierQOS pub = supp_qos_fact.get_SupplierQOS ();
receiver->connect (pub);
// Create the appropriate event handler and register it with the reactor
auto_ptr<ACE_Event_Handler> eh;
if (mcast) {
auto_ptr<TAO_ECG_Mcast_EH> mcast_eh(new TAO_ECG_Mcast_EH (receiver.in()));
mcast_eh->reactor (orb->orb_core ()->reactor ());
mcast_eh->open (ec.in());
ACE_auto_ptr_reset(eh,mcast_eh.release());
//eh.reset(mcast_eh.release());
} else {
auto_ptr<TAO_ECG_UDP_EH> udp_eh (new TAO_ECG_UDP_EH (receiver.in()));
udp_eh->reactor (orb->orb_core ()->reactor ());
ACE_INET_Addr local_addr (listenport);
if (udp_eh->open (local_addr) == -1)
ACE_ERROR ((LM_ERROR,"Cannot open EH\n"));
ACE_auto_ptr_reset(eh,udp_eh.release());
//eh.reset(udp_eh.release());
}
// Create an event (just a string in this case).
// Create an event set for one event
RtecEventComm::EventSet event (1);
event.length (1);
// Initialize event header.
event[0].header.source = MY_SOURCE_ID;
event[0].header.ttl = 1;
event[0].header.type = MY_EVENT_TYPE;
#if !defined (TAO_LACKS_EVENT_CHANNEL_ANY)
// Initialize data fields in event.
const CORBA::String_var eventData =
CORBA::string_dup (ACE_TEXT_ALWAYS_CHAR (ecname));
event[0].data.any_value <<= eventData;
#else
// Use the octet sequence payload instead
char *tmpstr = const_cast<char *>(ACE_TEXT_ALWAYS_CHAR (ecname));
size_t len = ACE_OS::strlen(tmpstr) +1;
event[0].data.payload.replace (
len,
len,
reinterpret_cast<CORBA::Octet *> (tmpstr));
#endif /* !TAO_LACKS_EVENT_CHANNEL_ANY */
if (iorfile != 0) {
CORBA::String_var str = orb->object_to_string( ec.in() );
std::ofstream iorFile( ACE_TEXT_ALWAYS_CHAR(iorfile) );
iorFile << str.in() << std::endl;
iorFile.close();
}
ACE_DEBUG ((LM_DEBUG,
"Starting main loop\n"));
const int EVENT_DELAY_MS = 1000;
while (1) {
consumer->push (event);
ACE_Time_Value tv(0, 1000 * EVENT_DELAY_MS);
orb->run(tv);
}
orb->destroy();
return 0;
}
catch (const CORBA::Exception& exc)
{
ACE_ERROR ((LM_ERROR,
"Caught CORBA::Exception\n%C (%C)\n",
exc._name (),
exc._rep_id () ));
}
return 1;
}
int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try
{
// Initialize the EC Factory so we can customize the EC
TAO_EC_Default_Factory::init_svcs ();
// Initialize the ORB.
CORBA::ORB_var orb = CORBA::ORB_init(argc, argv);
const ACE_TCHAR* ecname = ACE_TEXT ("EventService");
const ACE_TCHAR* address = ACE_TEXT ("localhost");
const ACE_TCHAR* iorfile = 0;
u_short port = 12345;
u_short listenport = 12345;
int mcast = 1;
for (int i = 0; argv[i] != 0; i++) {
if (ACE_OS::strcmp(argv[i], ACE_TEXT("-ecname")) == 0) {
if (argv[i+1] != 0) {
i++;
ecname = argv[i];
} else {
std::cerr << "Missing Event channel name" << std::endl;
}
} else if (ACE_OS::strcmp(argv[i], ACE_TEXT("-address")) == 0) {
if (argv[i+1] != 0) {
i++;
address = argv[i];
} else {
std::cerr << "Missing address" << std::endl;
}
} else if (ACE_OS::strcmp(argv[i], ACE_TEXT("-port")) == 0) {
if (argv[i+1] != 0) {
i++;
port = ACE_OS::atoi(argv[i]);
} else {
std::cerr << "Missing port" << std::endl;
}
} else if (ACE_OS::strcmp(argv[i], ACE_TEXT("-listenport")) == 0) {
if (argv[i+1] != 0) {
i++;
listenport = ACE_OS::atoi(argv[i]);
} else {
std::cerr << "Missing port" << std::endl;
}
} else if (ACE_OS::strcmp(argv[i], ACE_TEXT("-iorfile")) == 0) {
if (argv[i+1] != 0) {
i++;
iorfile = argv[i];
}
} else if (ACE_OS::strcmp(argv[i], ACE_TEXT("-udp")) == 0) {
mcast = 0;
}
}
// Get the POA
CORBA::Object_var object = orb->resolve_initial_references ("RootPOA");
PortableServer::POA_var poa = PortableServer::POA::_narrow (object.in ());
PortableServer::POAManager_var poa_manager = poa->the_POAManager ();
poa_manager->activate ();
// Create a local event channel and register it
TAO_EC_Event_Channel_Attributes attributes (poa.in (), poa.in ());
PortableServer::Servant_var<TAO_EC_Event_Channel> ec_impl =
new TAO_EC_Event_Channel(attributes);
ec_impl->activate ();
PortableServer::ObjectId_var oid = poa->activate_object(ec_impl.in());
CORBA::Object_var ec_obj = poa->id_to_reference(oid.in());
RtecEventChannelAdmin::EventChannel_var ec =
RtecEventChannelAdmin::EventChannel::_narrow(ec_obj.in());
// Find the Naming Service.
CORBA::Object_var obj = orb->resolve_initial_references("NameService");
CosNaming::NamingContextExt_var root_context = CosNaming::NamingContextExt::_narrow(obj.in());
// Bind the Event Channel using Naming Services
CosNaming::Name_var name = root_context->to_name (ACE_TEXT_ALWAYS_CHAR (ecname));
root_context->rebind(name.in(), ec.in());
// Get a proxy push consumer from the EventChannel.
RtecEventChannelAdmin::SupplierAdmin_var admin = ec->for_suppliers();
RtecEventChannelAdmin::ProxyPushConsumer_var consumer =
admin->obtain_push_consumer();
// Instantiate an EchoEventSupplier_i servant.
PortableServer::Servant_var<EchoEventSupplier_i> servant =
new EchoEventSupplier_i(orb.in());
// Register it with the RootPOA.
oid = poa->activate_object(servant.in());
CORBA::Object_var supplier_obj = poa->id_to_reference(oid.in());
RtecEventComm::PushSupplier_var supplier =
RtecEventComm::PushSupplier::_narrow(supplier_obj.in());
// Connect to the EC.
ACE_SupplierQOS_Factory qos;
qos.insert (MY_SOURCE_ID, MY_EVENT_TYPE, 0, 1);
consumer->connect_push_supplier (supplier.in (), qos.get_SupplierQOS ());
// Initialize the address server with the desired address.
// This will be used by the sender object and the multicast
// receiver.
ACE_INET_Addr send_addr (port, address);
PortableServer::Servant_var<SimpleAddressServer> addr_srv_impl =
new SimpleAddressServer(send_addr);
PortableServer::ObjectId_var addr_srv_oid =
poa->activate_object(addr_srv_impl.in());
CORBA::Object_var addr_srv_obj = poa->id_to_reference(addr_srv_oid.in());
RtecUDPAdmin::AddrServer_var addr_srv =
RtecUDPAdmin::AddrServer::_narrow(addr_srv_obj.in());
// Create and initialize the sender object
PortableServer::Servant_var<TAO_ECG_UDP_Sender> sender =
TAO_ECG_UDP_Sender::create();
TAO_ECG_UDP_Out_Endpoint endpoint;
if (endpoint.dgram ().open (ACE_Addr::sap_any) == -1) {
std::cerr << "Cannot open send endpoint" << std::endl;
return 1;
}
// TAO_ECG_UDP_Sender::init() takes a TAO_ECG_Refcounted_Endpoint.
// If we don't clone our endpoint and pass &endpoint, the sender will
// attempt to delete endpoint during shutdown.
TAO_ECG_Refcounted_Endpoint clone (new TAO_ECG_UDP_Out_Endpoint (endpoint));
sender->init (ec.in (), addr_srv.in (), clone);
// Setup the subscription and connect to the EC
ACE_ConsumerQOS_Factory cons_qos_fact;
cons_qos_fact.start_disjunction_group ();
cons_qos_fact.insert (ACE_ES_EVENT_SOURCE_ANY, ACE_ES_EVENT_ANY, 0);
RtecEventChannelAdmin::ConsumerQOS sub = cons_qos_fact.get_ConsumerQOS ();
sender->connect (sub);
// Create and initialize the receiver
PortableServer::Servant_var<TAO_ECG_UDP_Receiver> receiver =
TAO_ECG_UDP_Receiver::create();
// TAO_ECG_UDP_Receiver::init() takes a TAO_ECG_Refcounted_Endpoint.
// If we don't clone our endpoint and pass &endpoint, the receiver will
// attempt to delete endpoint during shutdown.
TAO_ECG_Refcounted_Endpoint clone2 (new TAO_ECG_UDP_Out_Endpoint (endpoint));
receiver->init (ec.in (), clone2, addr_srv.in ());
// Setup the registration and connect to the event channel
ACE_SupplierQOS_Factory supp_qos_fact;
supp_qos_fact.insert (MY_SOURCE_ID, MY_EVENT_TYPE, 0, 1);
RtecEventChannelAdmin::SupplierQOS pub = supp_qos_fact.get_SupplierQOS ();
receiver->connect (pub);
// Create the appropriate event handler and register it with the reactor
auto_ptr<ACE_Event_Handler> eh;
if (mcast) {
auto_ptr<TAO_ECG_Mcast_EH> mcast_eh(new TAO_ECG_Mcast_EH (receiver.in()));
mcast_eh->reactor (orb->orb_core ()->reactor ());
mcast_eh->open (ec.in());
ACE_auto_ptr_reset(eh,mcast_eh.release());
//eh.reset(mcast_eh.release());
} else {
auto_ptr<TAO_ECG_UDP_EH> udp_eh (new TAO_ECG_UDP_EH (receiver.in()));
udp_eh->reactor (orb->orb_core ()->reactor ());
ACE_INET_Addr local_addr (listenport);
if (udp_eh->open (local_addr) == -1) {
std::cerr << "Cannot open EH" << std::endl;
}
ACE_auto_ptr_reset(eh,udp_eh.release());
//eh.reset(udp_eh.release());
}
// Create an event (just a string in this case).
const CORBA::String_var eventData = CORBA::string_dup (ACE_TEXT_ALWAYS_CHAR (ecname));
// Create an event set for one event
RtecEventComm::EventSet event (1);
event.length (1);
// Initialize event header.
event[0].header.source = MY_SOURCE_ID;
event[0].header.ttl = 1;
event[0].header.type = MY_EVENT_TYPE;
// Initialize data fields in event.
event[0].data.any_value <<= eventData;
if (iorfile != 0) {
CORBA::String_var str = orb->object_to_string( ec.in() );
std::ofstream iorFile( ACE_TEXT_ALWAYS_CHAR(iorfile) );
iorFile << str.in() << std::endl;
iorFile.close();
}
std::cout << "Starting main loop" << std::endl;
const int EVENT_DELAY_MS = 10;
while (1) {
consumer->push (event);
ACE_Time_Value tv(0, 1000 * EVENT_DELAY_MS);
orb->run(tv);
}
orb->destroy();
return 0;
}
catch(const CORBA::Exception& exc)
{
std::cerr << "Caught CORBA::Exception" << std::endl << exc << std::endl;
}
return 1;
}
