bertos/net/pocketcmd.c

   1 /**
   2  * \file
   3  * <!--
   4  * This file is part of BeRTOS.
   5  *
   6  * Bertos is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  19  *
  20  * As a special exception, you may use this file as part of a free software
  21  * library without restriction.  Specifically, if other files instantiate
  22  * templates or use macros or inline functions from this file, or you compile
  23  * this file and link it with other files to produce an executable, this
  24  * file does not by itself cause the resulting executable to be covered by
  25  * the GNU General Public License.  This exception does not however
  26  * invalidate any other reasons why the executable file might be covered by
  27  * the GNU General Public License.
  28  *
  29  * Copyright 2007 Develer S.r.l. (http://www.develer.com/)
  30  * -->
  31  *
  32  * \brief pocketBus protocol Command layer implementation.
  33  *
  34  * This module implements command layer over pocketBus
  35  * protocol.
  36  * Payload packets received by pocketBus are first checked for
  37  * address matching.
  38  * If a packet is addressed to us we look for a suitable
  39  * callback function to call.
  40  *
  41  * The received payload format is as follows:
  42  * <pre>
  43  * +----------------------------------------+
  44  * |  CMD |            DATA                 |
  45  * +----------------------------------------+
  46  * |      |                                 |
  47  * +  2B  +           0..N Byte             +
  48  * </pre>
  49  *
  50  * The CMD ID used is the same supplied by the master when
  51  * the command was sent.
  52  *
  53  * \version $Id$
  54  *
  55  * \author Francesco Sacchi <batt@develer.com>
  56  */
  57
  58 #include "pocketcmd.h"
  59 #include "pocketbus.h"
  60
  61 #include <cfg/macros.h>
  62 #include <cfg/debug.h>
  63 #include <cfg/module.h>
  64
  65 #include <drv/timer.h>
  66
  67 #include <cpu/byteorder.h>
  68 #include <cpu/detect.h>
  69
  70 #include <string.h>
  71
  72 /**
  73  * pocketBus Command poll function.
  74  * Call it to read and process pocketBus commands.
  75  */
  76 void pocketcmd_poll(struct PocketCmdCtx *ctx)
  77 {
  78         PocketMsg msg;
  79
  80         /* Try to read a packet from pocketBus */
  81         while (pocketbus_recv(ctx->bus_ctx, &msg))
  82         {
  83                 /* Check address */
  84                 if (msg.addr == ctx->addr ||
  85                     msg.addr == POCKETBUS_BROADCAST_ADDR)
  86                 {
  87
  88                         #if CPU_AVR
  89                                 const PocketCmdHdr *hdr = (const PocketCmdHdr *)msg.payload;
  90                         #else
  91                                 #if !CPU_ARM
  92                                         #warning Fix alignment problem..
  93                                         /*
  94                                          * The code below make one memcopy, this the only way to
  95                                          * solve alignment problem on ARM. If you are use other
  96                                          * architecture you should find other way to optimize
  97                                          * this code.
  98                                          */
  99                                 #endif
 100                                 PocketCmdHdr hd;
 101                                 memcpy(&hd, msg.payload, sizeof(PocketCmdHdr));
 102                                 const PocketCmdHdr *hdr =  &hd;
 103                         #endif
 104
 105                         pocketcmd_t cmd = be16_to_cpu(hdr->cmd);
 106
 107                         /* We're no longer waiting for a reply (in case we were) */
 108                         if (cmd == ctx->waiting)
 109                                 ctx->waiting = PKTCMD_NULL;
 110
 111                         /* Check for command callback */
 112                         pocketcmd_hook_t callback = ctx->search(cmd);
 113
 114                         /* Call it if exists */
 115                         if (callback)
 116                         {
 117                                 PocketCmdMsg cmd_msg;
 118
 119                                 cmd_msg.cmd_ctx = ctx;
 120                                 cmd_msg.cmd = cmd;
 121                                 cmd_msg.len = msg.len - sizeof(PocketCmdHdr);
 122                                 cmd_msg.buf = msg.payload + sizeof(PocketCmdHdr);
 123
 124                                 callback(&cmd_msg);
 125                         }
 126                 }
 127         }
 128 }
 129
 130 /**
 131  * Send command \a cmd to/from slave adding \a len arguments in \a buf.
 132  * Address used is contained in \a ctx->addr .
 133  * If we are master and the message has a reply, you must set \a wait_reply to true.
 134  * \return true if all is ok, false if we are already waiting a replay from another slave.
 135  */
 136 bool pocketcmd_send(struct PocketCmdCtx *ctx, pocketcmd_t cmd, const void *buf, size_t len, bool wait_reply)
 137 {
 138         /* Check if we are waiting a reply from someone */
 139         if (ctx->waiting != PKTCMD_NULL)
 140         {
 141                 /* Check is reply timeout is elapsed */
 142                 if (timer_clock() - ctx->reply_timer < ms_to_ticks(PKTCMD_REPLY_TIMEOUT))
 143                 {
 144                         TRACEMSG("Pkt discard! waiting cmd[%04X]\n", ctx->waiting);
 145                         return false;
 146                 }
 147                 else
 148                 {
 149                         TRACEMSG("Timeout waiting cmd[%04X]\n", ctx->waiting);
 150                         ctx->waiting = PKTCMD_NULL;
 151                 }
 152         }
 153
 154         /* Endianess! */
 155         cmd = cpu_to_be16(cmd);
 156
 157         /* Send packet */
 158         pocketbus_begin(ctx->bus_ctx, ctx->addr);
 159         pocketbus_write(ctx->bus_ctx, &cmd, sizeof(cmd));
 160         pocketbus_write(ctx->bus_ctx, buf, len);
 161         pocketbus_end(ctx->bus_ctx);
 162
 163         if (wait_reply)
 164         {
 165                 ctx->waiting = cmd;
 166                 ctx->reply_timer = timer_clock();
 167         }
 168         return true;
 169 }
 170
 171 /**
 172  * Init pocketBus command layer.
 173  * \a ctx is pocketBus command layer context.
 174  * \a bus_ctx is pocketBus context.
 175  * \a addr is slave address (see pocketcmd_setAddr for details.)
 176  * \a search is the lookup function used to search command ID callbacks.
 177  */
 178 void pocketcmd_init(struct PocketCmdCtx *ctx, struct PocketBusCtx *bus_ctx, pocketbus_addr_t addr, pocketcmd_lookup_t search)
 179 {
 180         ASSERT(ctx);
 181         ASSERT(bus_ctx);
 182         ASSERT(search);
 183         MOD_CHECK(timer);
 184
 185         memset(ctx, 0, sizeof(*ctx));
 186         ctx->bus_ctx = bus_ctx;
 187         ctx->search = search;
 188         pocketcmd_setAddr(ctx, addr);
 189 }
 190
 191 /**
 192  * Helper function used to reply to master with an ACK.
 193  */
 194 void pocketcmd_replyAck(struct PocketCmdMsg *msg)
 195 {
 196         uint8_t ack[] = { POCKETBUS_ACK };
 197
 198         pocketcmd_slaveReply(msg->cmd_ctx, msg->cmd, ack, sizeof(ack));
 199 }
 200
 201 /**
 202  * Helper function used to reply to master with a NAK.
 203  */
 204 void pocketcmd_replyNak(struct PocketCmdMsg *msg)
 205 {
 206         uint8_t nak[] = { POCKETBUS_NAK };
 207
 208         pocketcmd_slaveReply(msg->cmd_ctx, msg->cmd, nak, sizeof(nak));
 209 }
 210