static ssize_t imx_mcc_can_test_en(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
u32 can_test_en;
int i = 0, ret = 0;
struct mcc_can_msg msg;
MCC_MEM_SIZE num_of_received_bytes;
MCC_INFO_STRUCT mcc_info;
sscanf(buf, "%d\n", &can_test_en);
if (can_test_en) {
pr_info("imx mcc can communication test begin.\n");
ret = mcc_get_info(MCC_NODE_A9, &mcc_info);
if (ret) {
pr_err("failed to get mcc info.\n");
return -EINVAL;
}
ret = mcc_create_endpoint(&mcc_endpoint_a9_can, MCC_A9_PORT);
if (ret) {
pr_err("failed to create a9 mcc ep.\n");
return -EINVAL;
}
pr_info("\nA9 mcc prepares run, MCC version is %s\n",
mcc_info.version_string);
while (i < 0x10000) {
i++;
/*
* wait for the "sleep" msg from the remote ep.
*/
ret = mcc_recv(&mcc_endpoint_m4_can,
&mcc_endpoint_a9_can, &msg,
sizeof(struct mcc_can_msg),
&num_of_received_bytes, 0xffffffff);
if (ret < 0) {
pr_err("A9 Main task recv error: %d\n", ret);
break;
}
pr_info("%s", msg.data);
}
ret = mcc_destroy_endpoint(&mcc_endpoint_a9_can);
if (ret) {
pr_err("failed to destory a9 mcc ep.\n");
return -EINVAL;
} else {
pr_info("destory a9 mcc ep.\n");
}
}
pr_info("imx mcc test end after %08d times recv tests.\n", i);
return count;
}
static ssize_t imx_mcc_pingpong_en(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
u32 pingpong_en;
int i = 0, ret = 0;
struct timeval tv1, tv2, tv3;
u32 tv_count1 = 0, tv_count2 = 0;
struct mcc_pp_msg msg;
MCC_MEM_SIZE num_of_received_bytes;
MCC_INFO_STRUCT mcc_info;
sscanf(buf, "%d\n", &pingpong_en);
if (pingpong_en) {
pr_info("imx mcc pingpong test begin.\n");
ret = mcc_get_info(MCC_NODE_A9, &mcc_info);
if (ret) {
pr_err("failed to get mcc info.\n");
return -EINVAL;
}
ret = mcc_create_endpoint(&mcc_endpoint_a9_pingpong,
MCC_A9_PORT);
if (ret) {
pr_err("failed to create a9 mcc ep.\n");
return -EINVAL;
}
pr_info("\nA9 mcc prepares run, MCC version is %s\n",
mcc_info.version_string);
msg.data = 1;
while (i < 0x50000) {
i++;
i++;
/*
* wait until the remote endpoint is created by
* the other core
*/
if (pingpong_en > 1)
do_gettimeofday(&tv1);
ret = mcc_send(&mcc_endpoint_a9_pingpong,
&mcc_endpoint_m4_pingpong, &msg,
sizeof(struct mcc_pp_msg),
0xffffffff);
if (ret < 0) {
pr_err("A9 Main task send error: %d\n", ret);
break;
}
if (pingpong_en > 1) {
do_gettimeofday(&tv2);
tv_count1 = (tv2.tv_sec - tv1.tv_sec)
* USEC_PER_SEC
+ tv2.tv_usec - tv1.tv_usec;
}
while (MCC_ERR_ENDPOINT == ret) {
pr_err("\n send err ret %d, re-send\n", ret);
ret = mcc_send(&mcc_endpoint_a9_pingpong,
&mcc_endpoint_m4_pingpong, &msg,
sizeof(struct mcc_pp_msg),
0xffffffff);
msleep(5000);
}
if (pingpong_en > 1)
do_gettimeofday(&tv2);
ret = mcc_recv(&mcc_endpoint_m4_pingpong,
&mcc_endpoint_a9_pingpong, &msg,
sizeof(struct mcc_pp_msg),
&num_of_received_bytes, 0xffffffff);
if (pingpong_en > 1) {
do_gettimeofday(&tv3);
tv_count2 = (tv3.tv_sec - tv2.tv_sec)
* USEC_PER_SEC
+ tv3.tv_usec - tv2.tv_usec;
pr_info("imx mcc: Data transfer speed tests"
"in pingpong. a9 -> m4:%08dus."
"a9 <- m4:%08dus.\n",
tv_count1, tv_count2);
}
if (MCC_SUCCESS != ret) {
pr_err("A9 Main task receive error: %d\n", ret);
break;
} else {
pr_info("%08x Main task received a msg"
" from [%d, %d, %d] endpoint\n", i,
mcc_endpoint_m4_pingpong.core,
mcc_endpoint_m4_pingpong.node,
mcc_endpoint_m4_pingpong.port);
pr_info("Message: Size=0x%08x, data = 0x%08x\n",
num_of_received_bytes, msg.data);
msg.data++;
}
}
ret = mcc_destroy_endpoint(&mcc_endpoint_a9_pingpong);
if (ret) {
pr_err("failed to destory a9 mcc ep.\n");
return ret;
} else {
pr_info("destory a9 mcc ep.\n");
}
pr_info("imx mcc test end after %08d times tests.\n", i/2);
}
if (ret)
return ret;
else
return count;
}
XYPenPlotterController::XYPenPlotterController(QObject *parent) :
QObject(parent)
{
MCC_INFO_STRUCT info_data;
int retval = 0;
uint32_t node_num = mqx_endpoint_a5.node;
retval = mcc_initialize(node_num);
if(retval)
{
qDebug("Error during mcc_initialize, result = %d", retval);
return;
}
retval = mcc_get_info(node_num, &info_data);
if(retval)
{
qDebug("Error during mcc_get_info, result = %d", retval);
return;
}
qDebug("Plotter app");
qDebug("mcc version: %s", info_data.version_string);
retval = mcc_create_endpoint(&mqx_endpoint_a5, mqx_endpoint_a5.port);
if(retval)
{
qDebug("mcc_create_endpoint failes, result = 0x%x", retval);
mcc_destroy(node_num);
return;
}
qDebug("Connecting to plotter...");
msg.data = PLOTTER_WELCOME;
do {
retval = send_msg(&msg);
if(retval == MCC_ERR_ENDPOINT)
{
// Firmware is not loaded!? Load the plotter firmware...
qDebug("Loading firmware...");
QProcess *process = new QProcess(this);
process->start("mqxboot /var/cache/xyplotter/plotter.bin 0x8f000400 0x0f000411");
process->waitForFinished();
// Wait until its ready...
QTime dieTime= QTime::currentTime().addMSecs(100);
while( QTime::currentTime() < dieTime );
}
} while (retval != MCC_SUCCESS);
qDebug("Welocme message sent! Waiting for response...");
if(receive_msg(&rcv_msg, 1000000))
return;
if(rcv_msg.status != PLOTTER_WELCOME)
{
qDebug("Oops! Something went wrong! Plotter response = 0x%x\n", rcv_msg.status);
return;
}
else
{
qDebug("Greeting received. Connected to ploter!\n");
}
qDebug("Homing plotter");
fflush(stdout);
msg.data = PLOTTER_HOME;
if(send_msg(&msg))
return;
timer = new QTimer(this);
connect(timer, SIGNAL(timeout()), this, SLOT(receivePlotterMessages()));
timer->start(100);
}
