static int chat_readb(FAR struct chat* priv, FAR char* c, int timeout_ms)
{
struct pollfd fds;
int ret;
fds.fd = priv->ctl.fd;
fds.events = POLLIN;
fds.revents = 0;
ret = poll(&fds, 1, timeout_ms);
if (ret <= 0)
{
vdbg("poll timed out\n");
return -ETIMEDOUT;
}
ret = read(priv->ctl.fd, c, 1);
if (ret != 1)
{
vdbg("read failed\n");
return -EPERM;
}
if (priv->ctl.echo)
{
fputc(*c, stderr);
}
vdbg("read \'%c\' (0x%02X)\n", *c, *c);
return 0;
}
static int stm32_rnginitialize()
{
uint32_t regval;
vdbg("Initializing RNG\n");
memset(&g_rngdev, 0, sizeof(struct rng_dev_s));
sem_init(&g_rngdev.rd_devsem, 0, 1);
if (irq_attach(STM32_IRQ_RNG, stm32_interrupt))
{
/* We could not attach the ISR to the interrupt */
vdbg("Could not attach IRQ.\n");
return -EAGAIN;
}
/* Enable interrupts */
regval = getreg32(STM32_RNG_CR);
regval |= RNG_CR_IE;
putreg32(regval, STM32_RNG_CR);
up_enable_irq(STM32_IRQ_RNG);
return OK;
}
static enum svc_state svc_initial__master_started(struct svc *svc, struct svc_work *work) {
vdbg("\n");
svc_timer_init();
mhb_send_pm_status_not(MHB_PM_STATUS_PEER_ON);
if (unipro_p2p_is_link_up()) {
vdbg("link already up\n");
/* Link is already up. No need poll link status. */
svc_send_event(SVC_EVENT_UNIPRO_LINK_UP, 0, 0, 0);
} else {
vdbg("link not up\n");
/* Link is not up. Start up link status check polling */
g_svc.linkup_poll_tid = svc_set_timer(&svc_unipro_link_timeout_handler,
SVC_LINKUP_POLL_INTERVAL);
if (g_svc.linkup_poll_tid == SVC_TIMER_INVALID) {
/* TODO: handle error case */
dbg("ERROR: invalid link timer\n");
}
}
/* Start up a timer for overall Mod detection */
g_svc.mod_detect_tid = svc_set_timer(&svc_mod_detect_timeout_handler,
SVC_MOD_DETECT_TIMEOUT);
if (g_svc.mod_detect_tid == SVC_TIMER_INVALID) {
/* TODO: handle error case */
dbg("ERROR: invalid mod timer\n");
}
return SVC_WAIT_FOR_UNIPRO;
}
static void chat_flush(FAR struct chat* priv)
{
char c;
vdbg("starting\n");
while (chat_readb(priv, (FAR char*) &c, 0) == 0);
vdbg("done\n");
}
static int ehci_arc_resume(struct platform_device *pdev)
{
struct usb_hcd *hcd = platform_get_drvdata(pdev);
struct ehci_hcd *ehci = hcd_to_ehci(hcd);
u32 tmp;
struct fsl_usb2_platform_data *pdata = pdev->dev.platform_data;
dbg("%s pdev=0x%p pdata=0x%p ehci=0x%p hcd=0x%p\n",
__FUNCTION__, pdev, pdata, ehci, hcd);
vdbg("%s ehci->regs=0x%p hcd->regs=0x%p usbmode=0x%x\n",
__FUNCTION__, ehci->regs, hcd->regs, pdata->usbmode);
tmp = USBMODE_CM_HOST;
if (ehci_big_endian_mmio(ehci))
tmp |= USBMODE_BE;
ehci_writel(ehci, tmp, (u32 *)pdata->usbmode);
memcpy(ehci->regs, (void *)&usb_ehci_regs, sizeof(struct ehci_regs));
set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
hcd->state = HC_STATE_RUNNING;
pdev->dev.power.power_state = PMSG_ON;
tmp = ehci_readl(ehci, &ehci->regs->command);
tmp |= CMD_RUN;
ehci_writel(ehci, tmp, &ehci->regs->command);
fsl_platform_set_vbus_power(pdata, 1);
usb_hcd_resume_root_hub(hcd);
return 0;
}
static int ehci_arc_resume(struct platform_device *pdev)
{
struct usb_hcd *hcd = platform_get_drvdata(pdev);
struct ehci_hcd *ehci = hcd_to_ehci(hcd);
u32 cmd;
struct arc_usb_config *config =
(struct arc_usb_config *)pdev->dev.platform_data;
dbg("%s pdev=0x%p config=0x%p ehci=0x%p hcd=0x%p\n",
__FUNCTION__, pdev, config, ehci, hcd);
vdbg("%s ehci->regs=0x%p hcd->regs=0x%p usbmode=0x%x\n",
__FUNCTION__, ehci->regs, hcd->regs, config->usbmode);
writel(USBMODE_CM_HOST, config->usbmode);
memcpy(ehci->regs, (void *)&usb_ehci_regs, sizeof(struct ehci_regs));
hcd->state = HC_STATE_RUNNING;
cmd = readl(&ehci->regs->command);
cmd |= CMD_RUN;
writel(cmd, &ehci->regs->command);
if (config->set_vbus_power)
config->set_vbus_power(1);
return 0;
}
/* true - keep retrying. false - retry exhausted */
static bool handle_mod_retry(svc_timer_t tid) {
if (tid != g_svc.mod_detect_tid) {
vdbg("ignore tid\n");
return true;
}
g_svc.mod_detect_retry++;
if (g_svc.mod_detect_retry == SVC_MOD_DETECT_RETRY) {
lldbg("Mod detection timeout. Giving up.\n");
svc_delete_timer(g_svc.mod_detect_tid);
g_svc.mod_detect_tid = SVC_TIMER_INVALID;
unipro_stop();
mhb_send_pm_status_not(MHB_PM_STATUS_PEER_DISCONNECTED);
} else {
lldbg("Mod detection timeout. Retrying (%d)\n", g_svc.mod_detect_retry);
unipro_reset();
if (!svc_restart_timer(tid)) {
/* TODO: handle error case */
dbg("ERROR: restart timer failed\n");
}
mhb_send_pm_status_not(MHB_PM_STATUS_PEER_RESET);
}
return (g_svc.mod_detect_retry < SVC_MOD_DETECT_RETRY) ? true : false;
}
static enum svc_state svc_wf_unipro__mod_timeout(struct svc *svc, struct svc_work *work) {
vdbg("\n");
svc_timer_t tid = (svc_timer_t)work->parameter0;
return handle_mod_retry(tid) ? SVC_WAIT_FOR_UNIPRO : SVC_DISCONNECTED;
}
static enum svc_state svc__queue_stats(struct svc *svc, struct svc_work *work) {
vdbg("\n");
if (g_svc.stats_tid != SVC_TIMER_INVALID) {
/* The stats timer is already set to expire. No need to start it again. */
vdbg("stats timer already running\n");
return g_svc.state;
}
g_svc.stats_tid = svc_set_timer(&svc_stats_timeout_handler, SVC_STATS_TIMEOUT);
if (g_svc.stats_tid == SVC_TIMER_INVALID) {
vdbg("ERROR: Failed to send stats.\n");
}
return g_svc.state;
}
void
handle_xdg_shell_message(struct wldbg_objects_info *oi,
struct wldbg_resolved_message *rm, int from)
{
struct wldbg_object_info *info;
struct wldbg_resolved_arg *arg;
if (from == CLIENT) {
if (strcmp(rm->wl_message->name, "get_xdg_surface") == 0) {
info = create_xdg_surface_info(rm);
if (!info) {
fprintf(stderr, "Out of memory, loosing informaiton\n");
return;
}
/* new xdg_surface id */
arg = wldbg_resolved_message_next_argument(rm);
/* FIXME check for NULL */
info->id = *arg->data;
/* just check -> do it an assertion */
if (objects_info_get(oi, info->id))
fprintf(stderr, "Already got an object on id %d, "
"but now I'm creating xgd_surface\n", info->id);
/* wl_surface id */
arg = wldbg_resolved_message_next_argument(rm);
((struct wldbg_xdg_surface_info *) info->info)->wl_surface_id = *arg->data;
objects_info_put(oi, info->id, info);
vdbg("Created xdg_surface, id %u\n", info->id);
}
}
}
int nsh_romfsetc(void)
{
int ret;
/* Create a ROM disk for the /etc filesystem */
ret = romdisk_register(CONFIG_NSH_ROMFSDEVNO, romfs_img,
NSECTORS(romfs_img_len), CONFIG_NSH_ROMFSSECTSIZE);
if (ret < 0)
{
dbg("nsh: romdisk_register failed: %d\n", -ret);
return ERROR;
}
/* Mount the file system */
vdbg("Mounting ROMFS filesystem at target=%s with source=%s\n",
CONFIG_NSH_ROMFSMOUNTPT, MOUNT_DEVNAME);
ret = mount(MOUNT_DEVNAME, CONFIG_NSH_ROMFSMOUNTPT, "romfs", MS_RDONLY, NULL);
if (ret < 0)
{
dbg("nsh: mount(%s,%s,romfs) failed: %d\n",
MOUNT_DEVNAME, CONFIG_NSH_ROMFSMOUNTPT, errno);
return ERROR;
}
return OK;
}
void
dbg(const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
vdbg(fmt, ap);
va_end(ap);
}
static enum svc_state svc_connected__gear_shifted(struct svc *svc, struct svc_work *work) {
vdbg("\n");
int err = (int)work->parameter0;
if (g_svc.gearbox) {
gearbox_shift_complete(g_svc.gearbox, err);
}
return g_svc.state;
}
void
dbg(char const *fmt, ...)
{
va_list args;
va_start(args, fmt);
vdbg(fmt, args);
va_end(args);
}
static enum svc_state svc_wf_unipro__link_up(struct svc *svc, struct svc_work *work) {
vdbg("\n");
/* Unipro link is up. Starting "unipro_init" stuff now */
unipro_init_with_event_handler(unipro_evt_handler);
unipro_p2p_detect_linkloss(true);
tsb_unipro_set_init_status(INIT_STATUS_OPERATING);
unipro_attr_local_write(TSB_DME_ES3_SYSTEM_STATUS_14, CONFIG_VERSION, 0);
return SVC_WAIT_FOR_MOD;
}
static enum svc_state svc_initial__slave_started(struct svc *svc, struct svc_work *work) {
vdbg("\n");
svc_timer_init();
mhb_send_pm_status_not(MHB_PM_STATUS_PEER_ON);
unipro_init_with_event_handler(unipro_evt_handler);
return SVC_SLAVE_WAIT_FOR_UNIPRO;
}
int
get_pid_for_socket(int fd)
{
struct ucred cr;
socklen_t len = sizeof cr;
getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &cr, &len);
vdbg("Got fd's %d pid: %d\n", fd, cr.pid);
return cr.pid;
}
static enum svc_state svc_wf_unipro__link_timeout(struct svc *svc, struct svc_work *work) {
vdbg("\n");
svc_timer_t tid = (svc_timer_t)work->parameter0;
if (tid == g_svc.linkup_poll_tid) {
if (unipro_p2p_is_link_up()) {
vdbg("link already up\n");
svc_delete_timer(g_svc.linkup_poll_tid);
g_svc.linkup_poll_tid = SVC_TIMER_INVALID;
svc_send_event(SVC_EVENT_UNIPRO_LINK_UP, 0, 0, 0);
} else {
vdbg("link not up\n");
if (!svc_restart_timer(tid)) {
/* TODO: handle error case */
dbg("ERROR: restart timer failed\n");
}
}
}
return SVC_WAIT_FOR_UNIPRO;
}
static enum svc_state svc__link_down(struct svc *svc, struct svc_work *work) {
vdbg("\n");
/* Cancel timers (if running). */
if (g_svc.linkup_poll_tid != SVC_TIMER_INVALID) {
svc_delete_timer(g_svc.linkup_poll_tid);
g_svc.linkup_poll_tid = SVC_TIMER_INVALID;
}
if (g_svc.mod_detect_tid != SVC_TIMER_INVALID) {
svc_delete_timer(g_svc.mod_detect_tid);
g_svc.mod_detect_tid = SVC_TIMER_INVALID;
}
#if CONFIG_RAMLOG_SYSLOG
mhb_ramlog_disable(true /* force */);
#endif
#if defined(CONFIG_ARCH_CHIP_TSB_I2S_TUNNEL)
(void)i2s_unipro_tunnel_unipro_unregister();
#endif
#if CONFIG_MHB_IPC_SERVER || CONFIG_MHB_IPC_CLIENT
ipc_unregister_unipro();
#endif
if (g_svc.gearbox) {
gearbox_link_down(g_svc.gearbox);
}
/* Disable UniPro interrupt events. */
unipro_p2p_detect_linkloss(false);
/* Reset the UniPro link. */
unipro_reset();
g_svc.linkup_poll_tid = svc_set_timer(&svc_unipro_link_timeout_handler,
SVC_LINKUP_POLL_INTERVAL);
if (g_svc.linkup_poll_tid == SVC_TIMER_INVALID) {
/* TODO: handle error case */
dbg("ERROR: invalid link timer\n");
}
/* Start up a timer for overall Mod detection */
g_svc.mod_detect_tid = svc_set_timer(&svc_mod_detect_timeout_handler,
SVC_MOD_DETECT_TIMEOUT);
if (g_svc.mod_detect_tid == SVC_TIMER_INVALID) {
/* TODO: handle error case */
dbg("ERROR: invalid mod timer\n");
}
return SVC_WAIT_FOR_UNIPRO;
}
static int chat_expect(FAR struct chat* priv, FAR const char* s)
{
char c;
struct timespec abstime;
struct timespec endtime;
int timeout_ms;
int s_len = strlen(s);
int i_match = 0; /* index of the next character to be matched in s */
int ret = 0;
/* Get initial time and set the end time */
clock_gettime(CLOCK_REALTIME, (FAR struct timespec*) &abstime);
endtime.tv_sec = abstime.tv_sec + priv->ctl.timeout;
endtime.tv_nsec = abstime.tv_nsec;
while (!ret && i_match < s_len &&
(abstime.tv_sec < endtime.tv_sec ||
(abstime.tv_sec == endtime.tv_sec &&
abstime.tv_nsec < endtime.tv_nsec)))
{
timeout_ms =
(endtime.tv_sec - abstime.tv_sec) * 1000 +
(endtime.tv_nsec - abstime.tv_nsec) / 1000000;
DEBUGASSERT(timeout_ms >= 0);
ret = chat_readb(priv, &c, timeout_ms);
if (!ret)
{
if (c == s[i_match])
{
/* Continue matching the next character */
i_match++;
}
else
{
/* Match failed; start anew */
i_match = 0;
}
/* Update current time */
clock_gettime(CLOCK_REALTIME, (FAR struct timespec*) &abstime);
}
}
vdbg("result %d\n", ret);
return ret;
}
static enum svc_state svc_wf_mod__mod_timeout(struct svc *svc, struct svc_work *work) {
vdbg("\n");
svc_timer_t tid = (svc_timer_t)work->parameter0;
if (handle_mod_retry(tid)) {
vdbg("retry\n");
/* APBE will be reset && local unipro block is restarted.
Need to wait for unipro link up again */
g_svc.linkup_poll_tid = svc_set_timer(&svc_unipro_link_timeout_handler,
SVC_LINKUP_POLL_INTERVAL);
if (g_svc.linkup_poll_tid == SVC_TIMER_INVALID) {
/* TODO: handle error case */
dbg("ERROR: invalid link timer\n");
}
return SVC_WAIT_FOR_UNIPRO;
}
/* giving up */
return SVC_DISCONNECTED;
}
static enum svc_state svc__send_stats(struct svc *svc, struct svc_work *work) {
vdbg("\n");
if (g_svc.stats_tid != SVC_TIMER_INVALID) {
svc_delete_timer(g_svc.stats_tid);
g_svc.stats_tid = SVC_TIMER_INVALID;
}
mhb_send_unipro_stats_not();
g_svc.stats_pending = false;
return g_svc.state;
}
int nsh_archinitialize(void)
{
#ifdef NSH_HAVEMMCSD
int ret;
/* Card detect */
bool cd_status;
/* Configure the card detect GPIO */
stm32_configgpio(GPIO_SD_CD);
/* Register an interrupt handler for the card detect pin */
stm32_gpiosetevent(GPIO_SD_CD, true, true, true, nsh_cdinterrupt);
/* Mount the SDIO-based MMC/SD block driver */
/* First, get an instance of the SDIO interface */
message("nsh_archinitialize: Initializing SDIO slot %d\n",
CONFIG_NSH_MMCSDSLOTNO);
g_sdiodev = sdio_initialize(CONFIG_NSH_MMCSDSLOTNO);
if (!g_sdiodev)
{
message("nsh_archinitialize: Failed to initialize SDIO slot %d\n",
CONFIG_NSH_MMCSDSLOTNO);
return -ENODEV;
}
/* Now bind the SDIO interface to the MMC/SD driver */
message("nsh_archinitialize: Bind SDIO to the MMC/SD driver, minor=%d\n",
CONFIG_NSH_MMCSDMINOR);
ret = mmcsd_slotinitialize(CONFIG_NSH_MMCSDMINOR, g_sdiodev);
if (ret != OK)
{
message("nsh_archinitialize: Failed to bind SDIO to the MMC/SD driver: %d\n", ret);
return ret;
}
dbg("nsh_archinitialize: Successfully bound SDIO to the MMC/SD driver\n");
/* Use SD card detect pin to check if a card is inserted */
cd_status = !stm32_gpioread(GPIO_SD_CD);
vdbg("Card detect : %hhu\n", cd_status);
sdio_mediachange(g_sdiodev, cd_status);
#endif
return OK;
}
static void svc_handle_event(struct svc *svc, struct svc_work *work) {
if (!svc || !work) {
return;
}
const enum svc_event event = work->event;
if (!svc_event_valid(event)) {
lldbg("ERROR: invalid event, %d\n", event);
return;
}
enum svc_state state = svc->state;
if (!svc_state_valid(state)) {
lldbg("ERROR: invalid state, %d\n", state);
return;
}
vdbg("state: %s (%d), event: %s (%d)\n",
svc_state_to_string(state), state,
svc_event_to_string(event), event);
const svc_event_handler handler = SVC_STATES[state][event];
if (!handler) {
lldbg("state: %s (%d), event: %s (%d)\n",
svc_state_to_string(state), state,
svc_event_to_string(event), event);
return;
}
const enum svc_state new_state = handler(svc, work);
if (new_state == state) {
lldbg("state: %s (%d), event: %s (%d)\n",
svc_state_to_string(state), state,
svc_event_to_string(event), event);
} else {
if (!svc_state_valid(new_state)) {
lldbg("ERROR: handler, %p, returned an invalid state, %d\n",
handler, new_state);
return;
}
lldbg("state: %s (%d), event: %s (%d), new state: %s (%d)\n",
svc_state_to_string(state), state,
svc_event_to_string(event), event,
svc_state_to_string(new_state), new_state);
svc->state = new_state;
}
}
/* Helpers */
static void _svc_bitmask_to_stats(uint32_t *counter, uint32_t value)
{
vdbg("%p %d\n", counter, value);
bool delta = false;
while (value) {
if (value & 0x1) {
(*counter)++;
delta = true;
}
value >>= 1;
counter++;
}
if (delta && !g_svc.stats_pending) {
svc_send_event(SVC_EVENT_QUEUE_STATS, 0, 0, 0);
g_svc.stats_pending = true;
} else {
vdbg("stats pending\n");
}
}
static enum svc_state svc_wf_cports__connected(struct svc *svc, struct svc_work *work) {
vdbg("\n");
unsigned int cport = (unsigned int)work->parameter0;
if (cport != CONFIG_MHB_IPC_CPORT_ID) {
return g_svc.state;
}
#if CONFIG_RAMLOG_SYSLOG
mhb_ramlog_enable();
#endif
mhb_send_pm_status_not(MHB_PM_STATUS_PEER_CONNECTED);
mhb_send_id_not();
return SVC_SLAVE_CONNECTED;
}
static void chat_tokens_free(FAR struct chat_token* first_tok)
{
FAR struct chat_token* next_tok;
while (first_tok)
{
next_tok = first_tok->next;
DEBUGASSERT(first_tok->string != NULL);
free(first_tok->string);
free(first_tok);
first_tok = next_tok;
}
vdbg("tokens freed\n");
}
int svc_init(void) {
vdbg("\n");
g_svc.state = SVC_WAIT_FOR_AP;
g_svc.mod_detect_tid = SVC_TIMER_INVALID;
g_svc.linkup_poll_tid = SVC_TIMER_INVALID;
g_svc.mod_detect_retry = 0;
#if CONFIG_MODS_MHB_SERVER_GEARBOX
g_svc.gearbox = gearbox_initialize();
#endif
mhb_uart_init();
mhb_unipro_init(g_svc.gearbox);
return 0;
}
static void svc_work_callback(FAR void *arg) {
struct svc_work *svc_work = (struct svc_work *)arg;
if (!svc_work) {
lldbg("ERROR: invalid work\n");
return;
}
vdbg("event: %s (%d), %p %p %p\n",
svc_event_to_string(svc_work->event), svc_work->event,
svc_work->parameter0,
svc_work->parameter1,
svc_work->parameter2);
svc_handle_event(svc_work->svc, svc_work);
kmm_free(svc_work);
}
static int chat_send(FAR struct chat* priv, FAR const char* s)
{
int ret = 0;
int len = strlen(s);
/* 'write' returns the number of successfully written characters */
ret = write(priv->ctl.fd, s, len);
vdbg("wrote %d out of %d bytes of \'%s\'\n", ret, len, s);
if (ret > 0)
{
/* Just SUCCESS */
ret = 0;
}
return ret;
}
