int main (void)
{
int i = 0;
// シリアル通信の作成
serial_t obj = serial_create("COM4",9600);
// 受け取る配列
char buf[DATA_SIZE];
// 受け取ったバイト数
char len;
if ( obj == NULL ) {
fprintf(stderr,"オブジェクト生成に失敗\n");
return EXIT_FAILURE;
}
while (1)
{
// バイト数を受け取るとともに、データを受け取る
len = serial_recv(obj,buf,sizeof(buf));
//if (len) serial_send(obj,(unsigned char *)buf,len);
for (i = 0; i < DATA_SIZE; i++)
{
printf("but[i] : %d\n", i, buf[i]);
}
printf("len : %d\n", len);
Sleep(100);
if ( kbhit() ) break;
}
serial_delete(obj);
return EXIT_SUCCESS;
}
void net_controller_har_hook(int action, void *cb_data) {
controller *ctrl = cb_data;
wtf *data = ctrl->data;
serial ser;
ENetPeer *peer = data->peer;
ENetHost *host = data->host;
ENetPacket *packet;
if (action == ACT_STOP && data->last_action == ACT_STOP) {
data->last_action = -1;
return;
}
if (action == ACT_FLUSH) {
enet_host_flush(host);
return;
}
data->last_action = action;
serial_create(&ser);
serial_write_int8(&ser, EVENT_TYPE_ACTION);
serial_write_int16(&ser, action);
/*DEBUG("controller hook fired with %d", action);*/
/*sprintf(buf, "k%d", action);*/
packet = enet_packet_create(ser.data, ser.len, ENET_PACKET_FLAG_RELIABLE);
if (peer) {
enet_peer_send(peer, 1, packet);
/*enet_host_flush (host);*/
} else {
DEBUG("peer is null~");
}
}
void setupMockSerial()
{
if (!s)
s = serial_create("Mock", 10, BUFF_SIZE,
NULL, NULL, _post_tx_cb, NULL);
serial_flush(s);
mock_resetTxBuffer();
}
static bool init_usart_serial(const uart_id_t uart_id, USART_TypeDef *usart,
const serial_id_t serial_id, const char *name,
const size_t dma_rx_buff_size,
DMA_Stream_TypeDef* dma_rx_stream,
const uint32_t dma_rx_channel,
const size_t dma_tx_buff_size,
DMA_Stream_TypeDef* dma_tx_stream,
const uint32_t dma_tx_channel)
{
volatile struct usart_info *ui = usart_data + uart_id;
struct Serial *s =
serial_create(name, UART_QUEUE_LEN, UART_QUEUE_LEN,
_config_cb, usart, _char_tx_cb,
(void*) ui);
if (!s) {
pr_error(LOG_PFX "Serial Malloc failure!\r\n");
return false;
}
ui->usart = usart;
ui->serial = s;
uint8_t* dma_rx_buff = NULL;
if (dma_rx_stream && dma_rx_buff_size) {
dma_rx_buff = malloc(dma_rx_buff_size);
if (!dma_rx_buff) {
pr_error(LOG_PFX "DMA Rx Buff Malloc failure!\r\n");
return false;
}
ui->dma_rx.buff_size = dma_rx_buff_size;
ui->dma_rx.buff = dma_rx_buff;
ui->dma_rx.ptr = dma_rx_buff;
ui->dma_rx.channel = dma_rx_channel;
ui->dma_rx.stream = dma_rx_stream;
}
uint8_t* dma_tx_buff = NULL;
if (dma_tx_stream && dma_tx_buff_size) {
dma_tx_buff = malloc(dma_tx_buff_size);
if (!dma_tx_buff) {
pr_error(LOG_PFX "DMA Tx Buff Malloc failure!\r\n");
return false;
}
ui->dma_tx.buff_size = dma_tx_buff_size;
ui->dma_tx.buff = dma_tx_buff;
ui->dma_tx.ptr = dma_tx_buff;
ui->dma_tx.channel = dma_tx_channel;
ui->dma_tx.stream = dma_tx_stream;
}
return true;
}
/* Public API */
int USB_CDC_device_init(const int priority, usb_device_data_rx_isr_cb_t* cb)
{
/* Perform a full USB reset */
USB_CDC_force_reenumeration();
/* Create read/write mutexes */
usb_state.serial = serial_create("USB", USB_TX_BUF_CAP, USB_RX_BUF_CAP,
NULL, NULL, NULL, NULL);
if (NULL == usb_state.serial)
return -1;
usb_state.rx_isr_cb = cb;
Set_System();
Set_USBClock();
USB_Interrupts_Config();
USB_Init();
return 0;
}
int main()
{
serial_t obj = serial_create( "COM3", 9600 );
char buf[128], len;
if( obj == NULL )
{
fprintf( stderr, "オブジェクト生成失敗\n" );
exit(1);
}
while(1)
{
len = serial_recv( obj, buf, sizeof(buf) );
printf("buf[0] : %d\n", buf[0]);
printf("buf[1] : %d\n", buf[1]);
printf("buf[2] : %d\n", buf[2]);
}
serial_delete( obj );
return 0;
}
int
serial_posix_setup(const char *device, int baud, serial **serialobj)
{
/* open serial */
*serialobj = serial_create();
if (*serialobj == NULL) {
printf("Unable to instantiate object: serial\n");
goto fail;
}
if (serial_open(*serialobj, device) < 0) {
printf("Unable to open serial devicer\n");
goto fail;
}
if (serial_set_speed(*serialobj, baud) < 0) {
printf("Unable to set serial speedr\n");
goto fail;
}
if (serial_set_timeout(*serialobj, 10000) < 0) {
printf("Unable to set timeoutr\n");
goto fail;
}
if (serial_set_cts_flow(*serialobj, 1) < 0) {
printf("Unable to set flow controlr\n");
goto fail;
}
printf("%s is opened\n", device);
return (0);
fail:
serial_close(*serialobj);
serial_destroy(*serialobj);
return (1);
}
static int samsung_driver_probe(struct vmm_device *dev,
const struct vmm_devtree_nodeid *devid)
{
u32 ucon;
int rc = VMM_EFAIL;
struct samsung_port *port = NULL;
port = vmm_zalloc(sizeof(struct samsung_port));
if (!port) {
rc = VMM_ENOMEM;
goto free_nothing;
}
rc = vmm_devtree_request_regmap(dev->of_node, &port->base, 0,
"Samsung UART");
if (rc) {
goto free_port;
}
/* Make sure all interrupts except Rx are masked. */
port->mask = S3C64XX_UINTM_RXD_MSK;
port->mask = ~port->mask;
vmm_out_le16((void *)(port->base + S3C64XX_UINTM), port->mask);
if (vmm_devtree_read_u32(dev->of_node, "baudrate",
&port->baudrate)) {
port->baudrate = 115200;
}
rc = vmm_devtree_clock_frequency(dev->of_node, &port->input_clock);
if (rc) {
goto free_reg;
}
/* Setup interrupt handler */
port->irq = vmm_devtree_irq_parse_map(dev->of_node, 0);
if (!port->irq) {
rc = VMM_ENODEV;
goto free_reg;
}
if ((rc = vmm_host_irq_register(port->irq, dev->name,
samsung_irq_handler, port))) {
goto free_reg;
}
/* Call low-level init function */
samsung_lowlevel_init(port->base, port->baudrate, port->input_clock);
/* Create Serial Port */
port->p = serial_create(dev, 256, samsung_tx, port);
if (VMM_IS_ERR_OR_NULL(port->p)) {
rc = VMM_PTR_ERR(port->p);
goto free_irq;
}
/* Save port pointer */
dev->priv = port;
/* Unmask RX interrupt */
ucon = vmm_in_le32((void *)(port->base + S3C2410_UCON));
ucon |= S3C2410_UCON_RXIRQMODE;
vmm_out_le32((void *)(port->base + S3C2410_UCON), ucon);
return VMM_OK;
free_irq:
vmm_host_irq_unregister(port->irq, port);
free_reg:
vmm_devtree_regunmap_release(dev->of_node, port->base, 0);
free_port:
vmm_free(port);
free_nothing:
return rc;
}
int main(int argc, char *argv[])
{
uint8_t i;
for(i = 0; i < argc; ++i)
{
if((strcmp(argv[i], "-h") == 0) || (strcmp(argv[i], "--help") == 0))
{
fprintf(stdout, "%s\n", USAGE);
exit(0);
}
if(strcmp(argv[i], "-v") == 0)
{
verbose = true;
fprintf(stdout, "Running in verbose mode\n");
}
if(strcmp(argv[i], "-l") == 0)
{
loopback_mode = true;
fprintf(stdout, "Running in loopback mode\n");
}
}
(void) signal(SIGINT, interrupt);
(void) signal(SIGTERM, interrupt);
lcm = lcm_create(NULL);
while(lcm == NULL)
{
fprintf(stderr, "LCM failed to initialize. Reattempting....\n");
usleep(1000000);
lcm = lcm_create(NULL);
}
// Create Serial Device for XBee
char *xbee_dev_name = "/dev/XBee";
for(i = 0; i < argc; ++i)
{
if(strcmp(argv[i], "-x") == 0)
{
if(i + 1 < argc)
xbee_dev_name = argv[i+1];
break;
}
}
xbee = serial_create(xbee_dev_name, B9600);
if(xbee == NULL)
fprintf(stderr, "XBee device does not exist at %s\n", xbee_dev_name);
else
fprintf(stdout, "XBee device successfully opened at 9600 baud on %s\n", xbee_dev_name);
// Create Serial Device for USB
char *usb_dev_name = "/dev/stack";
for(i = 0; i < argc; ++i)
{
if(strcmp(argv[i], "-u") == 0)
{
if(i + 1 < argc)
usb_dev_name = argv[i+1];
break;
}
}
usb = serial_create(usb_dev_name, B115200);
if(usb == NULL)
fprintf(stderr, "Usb device does not exist at %s\n", usb_dev_name);
else
fprintf(stdout, "Usb device successfully opened at 115200 baud on %s\n", usb_dev_name);
// If no open comm ports and not in loopback mode, quit.
if(!xbee && !usb && !loopback_mode)
{
fprintf(stderr, "Failed to open any comms devices. Exiting...\n");
lcm_destroy(lcm);
exit(1);
}
// Create comms devices
if(xbee)
{
xbee_comms = comms_create(1000, 1000, 1, publish_xbee);
comms_subscribe(xbee_comms, CHANNEL_KILL, handler_kill, NULL);
comms_subscribe(xbee_comms, CHANNEL_CHANNELS, handler_channels, NULL);
comms_subscribe(xbee_comms, CHANNEL_CFG_USB_SN, handler_cfg_usb_serial_num, NULL);
comms_subscribe(xbee_comms, CHANNEL_CFG_DATA_FREQUENCY, handler_cfg_data_frequency, NULL);
pthread_create(&xbee_thread, NULL, xbee_run, NULL);
}
// Create comms devices
if(usb)
{
usb_comms = comms_create(1000, 1000, 1, publish_usb);
comms_subscribe(usb_comms, CHANNEL_KILL, handler_kill, NULL);
comms_subscribe(usb_comms, CHANNEL_CHANNELS, handler_channels, NULL);
comms_subscribe(usb_comms, CHANNEL_CFG_USB_SN, handler_cfg_usb_serial_num, NULL);
comms_subscribe(usb_comms, CHANNEL_CFG_DATA_FREQUENCY, handler_cfg_data_frequency, NULL);
pthread_create(&usb_thread, NULL, usb_run, NULL);
}
kill_t_subscription_t *kill_subs =
kill_t_subscribe(lcm, "KILL_.*_TX", handler_kill_lcm, NULL);
channels_t_subscription_t *channels_subs =
channels_t_subscribe(lcm, "CHANNELS_.*_TX", handler_channels_lcm, NULL);
cfg_data_frequency_t_subscription_t *data_freq_subs =
cfg_data_frequency_t_subscribe(lcm, "CFG_DATA_FREQUENCY_.*_TX",
handler_cfg_data_frequency_lcm, NULL);
cfg_usb_serial_num_t_subscription_t *usb_serial_num_subs =
cfg_usb_serial_num_t_subscribe(lcm, "CFG_USB_SERIAL_NUM_.*_TX",
handler_cfg_usb_serial_num_lcm, NULL);
while(!done)
{
// Set up timeout on lcm_handle to prevent blocking at program exit
int lcm_fd = lcm_get_fileno(lcm);
fd_set fds;
FD_ZERO(&fds);
FD_SET(lcm_fd, &fds);
struct timeval timeout = { 0, 100000 }; // wait 100ms
int status = select(lcm_fd + 1, &fds, NULL, NULL, &timeout);
if(done) break;
if(status != 0 && FD_ISSET(lcm_fd, &fds)) {
if ( lcm_handle(lcm) ) {
fprintf( stderr, "LCM handle error, aborting\n" );
done = true;
}
}
}
fprintf(stdout, "Lcm driver destroyed.\n");
kill_t_unsubscribe(lcm, kill_subs);
channels_t_unsubscribe(lcm, channels_subs);
cfg_data_frequency_t_unsubscribe(lcm, data_freq_subs);
cfg_usb_serial_num_t_unsubscribe(lcm, usb_serial_num_subs);
if(xbee)
{
pthread_cancel(xbee_thread);
comms_destroy(xbee_comms);
serial_destroy(xbee);
fprintf(stdout, "Xbee driver destroyed.\n");
}
if(usb)
{
pthread_cancel(usb_thread);
comms_destroy(usb_comms);
serial_destroy(usb);
fprintf(stdout, "Usb driver destroyed.\n");
}
lcm_destroy(lcm);
return 0;
}
static int imx_driver_probe(struct vmm_device *dev,
const struct vmm_devtree_nodeid *devid)
{
int rc = VMM_EFAIL;
struct clk *clk_ipg = NULL;
struct clk *clk_uart = NULL;
struct imx_port *port = NULL;
unsigned long old_rate = 0;
port = vmm_zalloc(sizeof(struct imx_port));
if (!port) {
rc = VMM_ENOMEM;
goto free_nothing;
}
rc = vmm_devtree_request_regmap(dev->of_node, &port->base, 0,
"iMX UART");
if (rc) {
goto free_port;
}
if (vmm_devtree_read_u32(dev->of_node, "baudrate", &port->baudrate)) {
port->baudrate = 115200;
}
rc = vmm_devtree_clock_frequency(dev->of_node, &port->input_clock);
if (rc) {
goto free_reg;
}
/* Setup clocks */
clk_ipg = of_clk_get(dev->of_node, 0);
clk_uart = of_clk_get(dev->of_node, 1);
if (!VMM_IS_ERR_OR_NULL(clk_ipg)) {
rc = clk_prepare_enable(clk_ipg);
if (rc) {
goto free_reg;
}
}
if (!VMM_IS_ERR_OR_NULL(clk_uart)) {
rc = clk_prepare_enable(clk_uart);
if (rc) {
goto clk_disable_unprepare_ipg;
}
old_rate = clk_get_rate(clk_uart);
if (clk_set_rate(clk_uart, port->input_clock)) {
vmm_printf("Could not set %s clock rate to %u Hz, "
"actual rate: %u Hz\n", __clk_get_name(clk_uart),
port->input_clock, clk_get_rate(clk_uart));
rc = VMM_ERANGE;
goto clk_disable_unprepare_uart;
}
}
/* Register interrupt handler */
port->irq = vmm_devtree_irq_parse_map(dev->of_node, 0);
if (!port->irq) {
rc = VMM_ENODEV;
goto clk_old_rate;
}
if ((rc = vmm_host_irq_register(port->irq, dev->name,
imx_irq_handler, port))) {
goto clk_old_rate;
}
/* Call low-level init function */
imx_lowlevel_init(port->base, port->baudrate, port->input_clock);
/* Create Serial Port */
port->p = serial_create(dev, 256, imx_tx, port);
if (VMM_IS_ERR_OR_NULL(port->p)) {
rc = VMM_PTR_ERR(port->p);
goto free_irq;
}
/* Save port pointer */
dev->priv = port;
/* Unmask Rx, Mask Tx, and Enable UART */
port->mask = vmm_readl((void *)port->base + UCR1);
port->mask |= (UCR1_RRDYEN | UCR1_UARTEN);
port->mask &= ~(UCR1_TRDYEN);
vmm_writel(port->mask, (void *)port->base + UCR1);
return rc;
free_irq:
vmm_host_irq_unregister(port->irq, port);
clk_old_rate:
if (!VMM_IS_ERR_OR_NULL(clk_uart)) {
if (old_rate) {
clk_set_rate(clk_uart, old_rate);
}
}
clk_disable_unprepare_uart:
if (!VMM_IS_ERR_OR_NULL(clk_uart)) {
clk_disable_unprepare(clk_uart);
}
clk_disable_unprepare_ipg:
if (!VMM_IS_ERR_OR_NULL(clk_ipg)) {
clk_disable_unprepare(clk_ipg);
}
free_reg:
vmm_devtree_regunmap_release(dev->of_node, port->base, 0);
free_port:
vmm_free(port);
free_nothing:
return rc;
}
int config_parse_args(config_t *cfg, int argc, char *argv[])
{
int i;
int saw_dump_file = 0;
if (argc < 2) {
debug_printf(CONFIG, WARNING,
"Processors tend to be unhappy with nothing on their bus.\n"
"(Run \"%s --help\" for more info.)\n", argv[0]);
}
for (i = 1; i < argc; ) {
if (!strcmp(argv[i], "--region") || !strcmp(argv[i], "-r")) {
uint32_t base, size;
char *end;
if (argc - i < 4) {
debug_print(CONFIG, FATAL,
"--region: expected <base> <size> <readmemh-file>\n");
return 1;
}
base = strtoul(argv[i + 1], &end, 16);
if (*end != '\0') {
debug_printf(CONFIG, FATAL,
"--region: invalid base \"%s\"\n", argv[i + 1]);
return 1;
}
size = strtoul(argv[i + 2], &end, 16);
if (*end != '\0') {
debug_printf(CONFIG, FATAL,
"--region: invalid size \"%s\"\n", argv[i + 2]);
return 1;
}
if (do_region(cfg->mem, base, size, argv[i + 3])) {
return 1;
}
i += 4;
} else if (!strcmp(argv[i], "--pc") || !strcmp(argv[i], "-p")) {
uint32_t pc;
char *end;
if (argc - i < 2) {
debug_print(CONFIG, FATAL, "--pc: expected <initial-pc>\n");
return 1;
}
pc = strtoul(argv[i + 1], &end, 16);
if (*end != '\0') {
debug_printf(CONFIG, FATAL,
"--pc: invalid pc \"%s\"\n", argv[i + 1]);
return 1;
}
cfg->pc = pc;
i += 2;
} else if (!strcmp(argv[i], "--dump") || !strcmp(argv[i], "-d")) {
if (argc - i < 1) {
debug_print(CONFIG, FATAL, "--dump: expected <dump-file>\n");
return 1;
}
if (saw_dump_file) {
debug_print(CONFIG, FATAL,
"--dump: may not be specified multiple times\n");
return 1;
}
cfg->dump_file = fopen(argv[i + 1], "w");
if (!cfg->dump_file) {
debug_printf(CONFIG, FATAL,
"%s: %s\n", argv[i + 1], strerror(errno));
return 1;
}
saw_dump_file = 1;
i += 2;
} else if (!strcmp(argv[i], "--console") || !strcmp(argv[i], "-c")) {
uint32_t addr;
char *end;
if (argc - i < 2) {
debug_print(CONFIG, FATAL, "--console: expected <addr>\n");
return 1;
}
addr = strtoul(argv[i + 1], &end, 16);
if (*end != '\0') {
debug_printf(CONFIG, FATAL,
"--console: invalid addr \"%s\"\n", argv[i + 1]);
return 1;
}
mem_map(cfg->mem, addr, serial_create(0, 1));
i += 2;
} else if (!strcmp(argv[i], "--filter") || !strcmp(argv[i], "-f")) {
if (argc - i < 2) {
debug_print(CONFIG, FATAL, "--filter: expected <filter>\n");
return 1;
}
cfg->filter = filter_find(argv[i + 1]);
if (!cfg->filter) {
debug_printf(CONFIG, FATAL,
"--filter: unknown filter \"%s\"\n", argv[i + 1]);
return 1;
}
i += 2;
} else if (!strncmp(argv[i], "--filter=", 9)) {
cfg->filter = filter_find(argv[i] + 9);
if (!cfg->filter) {
debug_printf(CONFIG, FATAL,
"--filter: unknown filter \"%s\"\n", argv[i] + 9);
return 1;
}
i += 1;
} else if (!strcmp(argv[i], "--step") || !strcmp(argv[i], "-s")) {
cfg->step = 1;
i += 1;
} else if (!strcmp(argv[i], "--help") || !strcmp(argv[i], "-h")) {
usage(argv[0]);
return 1;
} else if (!strcmp(argv[i], "--quiet") || !strcmp(argv[i], "-q")) {
if (cfg->debug > 0) {
debug_set_level(--cfg->debug);
}
i += 1;
} else if (!strcmp(argv[i], "--verbose") || !strcmp(argv[i], "-v")) {
if (cfg->debug < NUM_DEBUG_LEVELS - 1) {
debug_set_level(++cfg->debug);
}
i += 1;
} else if (!strcmp(argv[i], "--version") || !strcmp(argv[i], "-V")) {
version();
return 1;
} else {
debug_printf(CONFIG, FATAL, "Invalid argument \"%s\"\n", argv[i]);
return 1;
}
}
return 0;
}
int net_controller_tick(controller *ctrl, int ticks, ctrl_event **ev) {
ENetEvent event;
wtf *data = ctrl->data;
ENetHost *host = data->host;
ENetPeer *peer = data->peer;
serial *ser;
/*int handled = 0;*/
while (enet_host_service(host, &event, 0) > 0) {
switch (event.type) {
case ENET_EVENT_TYPE_RECEIVE:
ser = malloc(sizeof(serial));
serial_create(ser);
ser->data = malloc(event.packet->dataLength);
ser->len = event.packet->dataLength;
memcpy(ser->data, event.packet->data, event.packet->dataLength);
switch(serial_read_int8(ser)) {
case EVENT_TYPE_ACTION:
{
// dispatch keypress to scene
int action = serial_read_int16(ser);
controller_cmd(ctrl, action, ev);
/*handled = 1;*/
serial_free(ser);
free(ser);
}
break;
case EVENT_TYPE_HB:
{
// got a tick
int id = serial_read_int8(ser);
if (id == data->id) {
int start = serial_read_int32(ser);
int peerticks = serial_read_int32(ser);
int newrtt = abs(start - ticks);
data->rttbuf[data->rttpos++] = newrtt;
if (data->rttpos >= 100) {
data->rttpos = 0;
data->rttfilled = 1;
}
if (data->rttfilled == 1) {
ctrl->rtt = avg_rtt(data->rttbuf, 100);
data->tick_offset = (peerticks + (ctrl->rtt/2)) - ticks;
/*DEBUG("I am %d ticks away from server: %d %d", data->tick_offset, ticks, peerticks);*/
}
data->outstanding_hb = 0;
data->last_hb = ticks;
serial_free(ser);
} else {
// a heartbeat from the peer, bounce it back
ENetPacket *packet;
// write our own ticks into it
serial_write_int32(ser, ticks);
packet = enet_packet_create(ser->data, ser->len, ENET_PACKET_FLAG_UNSEQUENCED);
if (peer) {
enet_peer_send(peer, 0, packet);
enet_host_flush (host);
}
}
free(ser);
}
break;
case EVENT_TYPE_SYNC:
controller_sync(ctrl, ser, ev);
/*handled = 1;*/
break;
default:
serial_free(ser);
free(ser);
}
enet_packet_destroy(event.packet);
break;
case ENET_EVENT_TYPE_DISCONNECT:
DEBUG("peer disconnected!");
data->disconnected = 1;
controller_close(ctrl, ev);
return 1; // bail the f**k out
break;
default:
break;
}
}
int tick_interval = 5;
if (data->rttfilled) {
tick_interval = 20;
}
if ((data->last_hb == -1 || ticks - data->last_hb > tick_interval) || !data->outstanding_hb) {
data->outstanding_hb = 1;
serial ser;
ENetPacket *packet;
serial_create(&ser);
serial_write_int8(&ser, EVENT_TYPE_HB);
serial_write_int8(&ser, data->id);
serial_write_int32(&ser, ticks);
packet = enet_packet_create(ser.data, ser.len, ENET_PACKET_FLAG_UNSEQUENCED);
if (peer) {
enet_peer_send(peer, 0, packet);
enet_host_flush (host);
} else {
DEBUG("peer is null~");
data->disconnected = 1;
controller_close(ctrl, ev);
}
}
/*if(!handled) {*/
/*controller_cmd(ctrl, ACT_STOP, ev);*/
/*}*/
return 0;
}
static int uart_8250_driver_probe(struct vmm_device *dev,
const struct vmm_devtree_nodeid *devid)
{
int rc;
struct uart_8250_port *port;
physical_addr_t ioport;
const char *aval;
port = vmm_zalloc(sizeof(struct uart_8250_port));
if(!port) {
rc = VMM_ENOMEM;
goto free_nothing;
}
if (vmm_devtree_read_string(dev->node,
VMM_DEVTREE_ADDRESS_TYPE_ATTR_NAME,
&aval)) {
aval = NULL;
}
if (aval && !strcmp(aval, VMM_DEVTREE_ADDRESS_TYPE_VAL_IO)) {
port->use_ioport = TRUE;
} else {
port->use_ioport = FALSE;
}
if (port->use_ioport) {
rc = vmm_devtree_regaddr(dev->node, &ioport, 0);
if (rc) {
goto free_port;
}
port->base = ioport;
} else {
rc = vmm_devtree_request_regmap(dev->node, &port->base, 0,
"UART 8250");
if (rc) {
goto free_port;
}
}
if (vmm_devtree_read_u32(dev->node, "reg-shift",
&port->reg_shift)) {
port->reg_shift = 0;
}
if (vmm_devtree_read_u32(dev->node, "reg-io-width",
&port->reg_width)) {
port->reg_width = 1;
}
if (vmm_devtree_read_u32(dev->node, "baudrate",
&port->baudrate)) {
port->baudrate = 115200;
}
rc = vmm_devtree_clock_frequency(dev->node, &port->input_clock);
if (rc) {
goto free_reg;
}
/* Call low-level init function
* Note: low-level init will make sure that
* interrupts are disabled in IER register.
*/
uart_8250_lowlevel_init(port);
/* Setup interrupt handler */
port->irq = vmm_devtree_irq_parse_map(dev->node, 0);
if (!port->irq) {
rc = VMM_ENODEV;
goto free_reg;
}
if ((rc = vmm_host_irq_register(port->irq, dev->name,
uart_8250_irq_handler, port))) {
goto free_reg;
}
/* Create Serial Port */
port->p = serial_create(dev, 256, uart_8250_tx, port);
if (VMM_IS_ERR_OR_NULL(port->p)) {
rc = VMM_PTR_ERR(port->p);
goto free_irq;
}
/* Save port pointer */
dev->priv = port;
/* Unmask Rx interrupt */
port->ier |= (UART_IER_RLSI | UART_IER_RDI);
uart_8250_out(port, UART_IER_OFFSET, port->ier);
return VMM_OK;
free_irq:
vmm_host_irq_unregister(port->irq, port);
free_reg:
if (!port->use_ioport) {
vmm_devtree_regunmap_release(dev->node, port->base, 0);
}
free_port:
vmm_free(port);
free_nothing:
return rc;
}
static int omap_uart_driver_probe(struct vmm_device *dev,
const struct vmm_devtree_nodeid *devid)
{
int rc;
struct omap_uart_port *port;
port = vmm_zalloc(sizeof(struct omap_uart_port));
if (!port) {
rc = VMM_ENOMEM;
goto free_nothing;
}
rc = vmm_devtree_request_regmap(dev->of_node, &port->base, 0,
"omap-uart");
if (rc) {
goto free_port;
}
if (vmm_devtree_read_u32(dev->of_node, "reg-shift",
&port->reg_shift)) {
port->reg_shift = 0;
}
if (vmm_devtree_read_u32(dev->of_node, "baudrate",
&port->baudrate)) {
port->baudrate = 115200;
}
rc = vmm_devtree_clock_frequency(dev->of_node,
&port->input_clock);
if (rc) {
goto free_reg;
}
omap_uart_startup_configure(port);
port->irq = vmm_devtree_irq_parse_map(dev->of_node, 0);
if (!port->irq) {
rc = VMM_ENODEV;
goto free_reg;
}
if ((rc = vmm_host_irq_register(port->irq, dev->name,
omap_uart_irq_handler, port))) {
goto free_reg;
}
/* Create Serial Port */
port->p = serial_create(dev, 256, omap_uart_tx, port);
if (VMM_IS_ERR_OR_NULL(port->p)) {
rc = VMM_PTR_ERR(port->p);
goto free_irq;
}
/* Save port pointer */
dev->priv = port;
/* Unmask Rx interrupt */
port->ier |= (UART_IER_RDI | UART_IER_RLSI);
omap_serial_out(port, UART_IER, port->ier);
return VMM_OK;
free_irq:
vmm_host_irq_unregister(port->irq, port);
free_reg:
vmm_devtree_regunmap_release(dev->of_node, port->base, 0);
free_port:
vmm_free(port);
free_nothing:
return rc;
}
