network.c

Go to the documentation of this file.

/***
 * This file is part of OpenHome, an open source home automation system.
 * Copyright (C) 2003 Jan Klötzke
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include <avr/eeprom.h>
#include <avr/pgmspace.h>
#include <inttypes.h>
#include "net/link.h"
#include "net/network.h"
#include "net.h"
#include "utils.h"

// local variables
static net_ind_t ind;

// eeprom variables
uint16_t ee_addr_logic __attribute__(( section(".eeprom") ));
uint16_t ee_addr_group[8] __attribute__(( section(".eeprom") ));

// address length tables
static prog_uchar dest_length_table[] = {2,1,4,0};
static prog_uchar src_length_table[] = {2,2,4,0};

// header bit masks
#define DAF_MASK        0x03
#define SAF_MASK        0x0c
#define PDU_MASK        0x30

// external functions (transport layer)
extern void net_ind(uint8_t *buf, uint8_t len, const net_ind_t *ind);
extern void net_con(void);

/********************************************************************************
 * functions called from link layer
 */

uint8_t lnk_ind(uint8_t *buf, uint8_t len)
{
        uint8_t i, src_offset, src_len, result;
        
        // is this packet for us?
        result = 0;
        switch (buf[0] & DAF_MASK) {
                case NAF_LOGIC:
                        if (*(uint16_t*)(buf+1) == eeprom_read_word(&ee_addr_logic)) {
                                ind.rat = AT_LOGIC;
                                result = 1;
                                goto addr_match;
                        }
                        break;
                case NAF_GROUP:
                        for (i=0;i<8;i++) 
                                if (buf[1] == eeprom_read_byte(&ee_addr_group[i])) {
                                        ind.rat = AT_GROUP0+i;
                                        goto addr_match;
                                }
                        break;
                case NAF_PHYSIC:
                        if (*(uint32_t*)(buf+1) == NET_PHYSICAL_ADDR) {
                                result = 1;
                                ind.rat = AT_PHYSIC;
                                goto addr_match;
                        }
                        break;
                case NAF_BROADCAST:
                        ind.rat = AT_PHYSIC;
                        goto addr_match;
                default:
                        break;
        }
        return 0;

addr_match:
        ind.pdu = (buf[0]>>4) & 0x03;
        ind.src.format = (buf[0] & SAF_MASK) >> 2;
        src_len = __LPM(&src_length_table[ind.src.format]);
        src_offset = __LPM(&dest_length_table[buf[0] & DAF_MASK])+1;
        buf += src_offset;
        for (i=0;i<src_len;i++) ind.src.addr[i] = *buf++;
        len -= src_len+src_offset;
        net_ind(buf, len, &ind);
        return result;
}

void lnk_con(void)
{
        net_con();
}

/********************************************************************************
 * Public functions
 */

uint8_t net_requ(net_buf_t *buf, const net_requ_t *requ)
{
        uint8_t hdr, i;
        
        // can we queue packet?
        if (!lnk_clear_to_send()) return 0;
        
        // prepare header
        hdr = (requ->pdu << 4) | requ->dest.format;
        
        // prepend source address
        if (requ->src == AT_LOGIC) {
                hdr |= NAF_LOGIC << 2;
                buf_prep_int(buf, eeprom_read_word(&ee_addr_logic));
        } else if (requ->src == AT_PHYSIC) {
                hdr |= NAF_PHYSIC << 2;
                buf_prep_long(buf, NET_PHYSICAL_ADDR);
        } else {
                hdr |= NAF_GROUP << 2;
                buf_prep_int(buf, eeprom_read_word(&ee_addr_group[requ->src-AT_GROUP0]));
        }
        
        // prepend destination address
        i = __LPM(&dest_length_table[requ->dest.format]);
        while (i > 0) buf_prep_char(buf, requ->dest.addr[--i]);
        
        // prepend header
        buf_prep_char(buf, hdr);
        
        // and go...
        if (lnk_ind(buf->data, buf->len)) {
                net_con();
                return 1;
        } else {
                return lnk_requ(buf, requ->backlog);
        }
}

uint8_t net_compare_src_addr(const net_addr_t *addr1, const net_addr_t *addr2)
{
        uint8_t i, len;
        
        if (addr1->format != addr2->format) return 0;
        len = __LPM(&src_length_table[addr1->format]);
        for (i=0;i<len;i++) if (addr1->addr[i] != addr2->addr[i]) return 0;
        return 1;
}

uint8_t net_get_local_member_id(uint8_t group)
{
        return eeprom_read_byte(&ee_addr_group[group-AT_GROUP0]+1);
}

uint8_t net_clear_to_send(void)
{
        return lnk_clear_to_send();
}

void net_set_logic_addr(uint16_t addr)
{
        eeprom_write_word(&ee_addr_logic, addr);
}

uint16_t net_get_logic_addr(void)
{
        return eeprom_read_word(&ee_addr_logic);
}

void net_set_group_addr(uint8_t group, uint16_t addr)
{
        eeprom_write_word(&ee_addr_group[group], addr);
}

uint16_t net_get_group_addr(uint8_t group)
{
        return eeprom_read_word(&ee_addr_group[group]);
}

---