samples: ipm sample using mailbox for Quark SE

# Sensor Subsystem

SS_APP = sensor

# Application Processor

APP = ap

all: sensor_app ap_app

sensor_app:

	$(MAKE) -C $(SS_APP) O=$(CURDIR)/outdir/$(SS_APP)

ap_app:

	$(MAKE) -C $(APP) O=$(CURDIR)/outdir/$(APP)

flash: sensor_app ap_app

	$(MAKE) -C $(SS_APP) O=outdir/$(SS_APP) flash

	$(MAKE) -C $(APP) O=outdir/$(APP) flash

pristine:

	@rm -rf $(CURDIR)/outdir

BOARD ?= arduino_101

CONF_FILE = prj.conf

include ${ZEPHYR_BASE}/Makefile.inc

CONFIG_PRINTK=y

CONFIG_ARC_INIT=y

CONFIG_IPM=y

CONFIG_IPM_QUARK_SE=y

CONFIG_IPM_QUARK_SE_MASTER=y

CONFIG_IPM_CONSOLE_RECEIVER=y

CONFIG_TIMESLICE_SIZE=1

CONFIG_MAIN_STACK_SIZE=2048

ccflags-y += ${PROJECTINCLUDE}

ccflags-y +=-I$(ZEPHYR_BASE)/include/drivers

ccflags-y +=-I$(ZEPHYR_BASE)/drivers -I$(ZEPHYR_BASE)/arch/x86

obj-y = hello.o

/*

 * Copyright (c) 2012-2014 Wind River Systems, Inc.

 * Copyright (c) 2016 Intel Corporation

 *

 * SPDX-License-Identifier: Apache-2.0

 */

#include <misc/printk.h>

#include <zephyr.h>

#include <ipm.h>

#include <ipm/ipm_quark_se.h>

QUARK_SE_IPM_DEFINE(ping_ipm, 0, QUARK_SE_IPM_OUTBOUND);

QUARK_SE_IPM_DEFINE(message_ipm0, 1, QUARK_SE_IPM_OUTBOUND);

QUARK_SE_IPM_DEFINE(message_ipm1, 2, QUARK_SE_IPM_OUTBOUND);

QUARK_SE_IPM_DEFINE(message_ipm2, 3, QUARK_SE_IPM_OUTBOUND);

/* specify delay between greetings (in ms); compute equivalent in ticks */

#define SLEEPTIME               1000

#define SCSS_REGISTER_BASE      0xB0800000

#define SCSS_SS_STS             0x0604

#define PING_TIME               1000

#define STACKSIZE               2000

#define MSG_FIBER_PRI           6

#define MAIN_FIBER_PRI          2

#define PING_FIBER_PRI          4

#define TASK_PRIO               7

char thread_stacks[2][STACKSIZE];

uint32_t scss_reg(uint32_t offset)

{

	volatile uint32_t *ret = (volatile uint32_t *)(SCSS_REGISTER_BASE +

						       offset);

	return *ret;

}

static const char dat1[] = "abcdefghijklmno";

static const char dat2[] = "pqrstuvwxyz0123";

void message_source(struct device *ipm)

{

	uint8_t counter = 0;

	printk("sending messages for IPM device %p\n", ipm);

	while (1) {

		ipm_send(ipm, 1, counter++, dat1, 16);

		ipm_send(ipm, 1, counter++, dat2, 16);

	}

}

void message_source_task_0(void)

{

	message_source(device_get_binding("message_ipm0"));

}

void message_source_task_1(void)

{

	message_source(device_get_binding("message_ipm1"));

}

void message_source_task_2(void)

{

	message_source(device_get_binding("message_ipm2"));

}

void ping_source_thread(void *arg1, void *arg2, void *arg3)

{

	ARG_UNUSED(arg1);

	ARG_UNUSED(arg2);

	ARG_UNUSED(arg3);

	struct device *ipm = device_get_binding("ping_ipm");

	while (1) {

		k_sleep(PING_TIME);

		printk("pinging sensor subsystem (ARC) for counter status\n");

		ipm_send(ipm, 1, 0, NULL, 0);

	}

}

void main_thread(void *arg1, void *arg2, void *arg3)

{

	ARG_UNUSED(arg1);

	ARG_UNUSED(arg2);

	ARG_UNUSED(arg3);

	int ctr = 0;

	uint32_t ss_sts;

	while (1) {

		/* say "hello" */

		printk("Hello from application processor (x86)! (%d) ", ctr++);

		ss_sts = scss_reg(SCSS_SS_STS);

		switch (ss_sts) {

		case 0x4000:

			printk("Sensor Subsystem (ARC) is halted");

			break;

		case 0x0400:

			printk("Sensor Subsystem (ARC) is sleeping");

			break;

		case 0:

			printk("Sensor Subsystem (ARC) is running");

			break;

		default:

			printk("Sensor Subsystem (ARC) status: %x", ss_sts);

			break;

		}

		printk(", mailbox status: %x mask %x\n", scss_reg(0xac0),

		       scss_reg(0x4a0));

		/* wait a while, then let other task have a turn */

		k_sleep(SLEEPTIME);

	}

}

K_THREAD_DEFINE(MSG_TASK0, STACKSIZE, message_source_task_0, NULL, NULL, NULL,

		TASK_PRIO, 0, K_NO_WAIT);

K_THREAD_DEFINE(MSG_TASK1, STACKSIZE, message_source_task_1, NULL, NULL, NULL,

		TASK_PRIO, 0, K_NO_WAIT);

K_THREAD_DEFINE(MSG_TASK2, STACKSIZE, message_source_task_2, NULL, NULL, NULL,

		TASK_PRIO, 0, K_NO_WAIT);

void main(void)

{

	printk("===== app started ========\n");

	k_thread_spawn(&thread_stacks[0][0], STACKSIZE, main_thread,

		       0, 0, 0, K_PRIO_COOP(MAIN_FIBER_PRI), 0, 0);

	k_thread_spawn(&thread_stacks[1][0], STACKSIZE, ping_source_thread,

		       0, 0, 0, K_PRIO_COOP(PING_FIBER_PRI), 0, 0);

}