djsundog
/
circuitpython
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

stm32: Switch Wiznet to use lib/wiznet5k and extmod/network_wiznet5k. 

Instead of the old Wiznet driver in drivers/wiznet5k.
This commit is contained in:
robert-hh 2022-08-03 18:01:11 +02:00 committed by Damien George
parent b1efc1340a
commit 717924001d
3 changed files with 10 additions and 985 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
ports/stm32/Makefile
View File

@ -460,19 +460,22 @@ LIBS += $(TOP)/drivers/cyw43/libcyw43.a
endif
ifneq ($(MICROPY_PY_NETWORK_WIZNET5K),0)
WIZNET5K_DIR=drivers/wiznet5k
INC += -I$(TOP)/$(WIZNET5K_DIR)
WIZNET5K_DIR=lib/wiznet5k
GIT_SUBMODULES += lib/wiznet5k
INC += -I$(TOP)/$(WIZNET5K_DIR) -I$(TOP)/$(WIZNET5K_DIR)/Ethernet
CFLAGS_MOD += -DMICROPY_PY_NETWORK_WIZNET5K=$(MICROPY_PY_NETWORK_WIZNET5K) -D_WIZCHIP_=$(MICROPY_PY_NETWORK_WIZNET5K)
CFLAGS_MOD += -DWIZCHIP_PREFIXED_EXPORTS=1
ifeq ($(MICROPY_PY_LWIP),1)
# When using MACRAW mode (with lwIP), maximum buffer space must be used for the raw socket
CFLAGS_MOD += -DWIZCHIP_USE_MAX_BUFFER
endif
SRC_MOD += network_wiznet5k.c modnwwiznet5k.c
SRC_MOD += extmod/network_wiznet5k.c
SRC_MOD += $(addprefix $(WIZNET5K_DIR)/,\
ethernet/w$(MICROPY_PY_NETWORK_WIZNET5K)/w$(MICROPY_PY_NETWORK_WIZNET5K).c \
ethernet/wizchip_conf.c \
ethernet/socket.c \
internet/dns/dns.c \
Ethernet/W$(MICROPY_PY_NETWORK_WIZNET5K)/w$(MICROPY_PY_NETWORK_WIZNET5K).c \
Ethernet/wizchip_conf.c \
Ethernet/socket.c \
Internet/DNS/dns.c \
Internet/DHCP/dhcp.c \
)
endif

513
ports/stm32/modnwwiznet5k.c
View File

@ -1,513 +0,0 @@
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2014 Damien P. George
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include "py/objlist.h"
#include "py/runtime.h"
#include "py/stream.h"
#include "py/mperrno.h"
#include "py/mphal.h"
#include "shared/netutils/netutils.h"
#include "extmod/modnetwork.h"
#include "pin.h"
#include "spi.h"
#if MICROPY_PY_NETWORK_WIZNET5K && !MICROPY_PY_LWIP
#include "ethernet/wizchip_conf.h"
#include "ethernet/socket.h"
#include "internet/dns/dns.h"
/// \moduleref network
typedef struct _wiznet5k_obj_t {
mp_obj_base_t base;
mp_uint_t cris_state;
const spi_t *spi;
const pin_obj_t *cs;
const pin_obj_t *rst;
uint8_t socket_used;
} wiznet5k_obj_t;
STATIC wiznet5k_obj_t wiznet5k_obj;
STATIC void wiz_cris_enter(void) {
wiznet5k_obj.cris_state = MICROPY_BEGIN_ATOMIC_SECTION();
}
STATIC void wiz_cris_exit(void) {
MICROPY_END_ATOMIC_SECTION(wiznet5k_obj.cris_state);
}
STATIC void wiz_cs_select(void) {
mp_hal_pin_low(wiznet5k_obj.cs);
}
STATIC void wiz_cs_deselect(void) {
mp_hal_pin_high(wiznet5k_obj.cs);
}
STATIC void wiz_spi_read(uint8_t *buf, uint32_t len) {
HAL_StatusTypeDef status = HAL_SPI_Receive(wiznet5k_obj.spi->spi, buf, len, 5000);
(void)status;
}
STATIC void wiz_spi_write(const uint8_t *buf, uint32_t len) {
HAL_StatusTypeDef status = HAL_SPI_Transmit(wiznet5k_obj.spi->spi, (uint8_t *)buf, len, 5000);
(void)status;
}
STATIC int wiznet5k_gethostbyname(mp_obj_t nic, const char *name, mp_uint_t len, uint8_t *out_ip) {
uint8_t dns_ip[MOD_NETWORK_IPADDR_BUF_SIZE] = {8, 8, 8, 8};
uint8_t *buf = m_new(uint8_t, MAX_DNS_BUF_SIZE);
DNS_init(0, buf);
mp_int_t ret = DNS_run(dns_ip, (uint8_t *)name, out_ip);
m_del(uint8_t, buf, MAX_DNS_BUF_SIZE);
if (ret == 1) {
// success
return 0;
} else {
// failure
return -2;
}
}
STATIC int wiznet5k_socket_socket(mod_network_socket_obj_t *socket, int *_errno) {
if (socket->domain != MOD_NETWORK_AF_INET) {
*_errno = MP_EAFNOSUPPORT;
return -1;
}
switch (socket->type) {
case MOD_NETWORK_SOCK_STREAM:
socket->type = Sn_MR_TCP;
break;
case MOD_NETWORK_SOCK_DGRAM:
socket->type = Sn_MR_UDP;
break;
default:
*_errno = MP_EINVAL;
return -1;
}
if (socket->fileno == -1) {
// get first unused socket number
for (mp_uint_t sn = 0; sn < _WIZCHIP_SOCK_NUM_; sn++) {
if ((wiznet5k_obj.socket_used & (1 << sn)) == 0) {
wiznet5k_obj.socket_used |= (1 << sn);
socket->fileno = sn;
break;
}
}
if (socket->fileno == -1) {
// too many open sockets
*_errno = MP_EMFILE;
return -1;
}
}
// WIZNET does not have a concept of pure "open socket". You need to know
// if it's a server or client at the time of creation of the socket.
// So, we defer the open until we know what kind of socket we want.
// use "domain" to indicate that this socket has not yet been opened
socket->domain = 0;
return 0;
}
STATIC void wiznet5k_socket_close(mod_network_socket_obj_t *socket) {
uint8_t sn = (uint8_t)socket->fileno;
if (sn < _WIZCHIP_SOCK_NUM_) {
wiznet5k_obj.socket_used &= ~(1 << sn);
WIZCHIP_EXPORT(close)(sn);
}
}
STATIC int wiznet5k_socket_bind(mod_network_socket_obj_t *socket, byte *ip, mp_uint_t port, int *_errno) {
// open the socket in server mode (if port != 0)
mp_int_t ret = WIZCHIP_EXPORT(socket)(socket->fileno, socket->type, port, 0);
if (ret < 0) {
wiznet5k_socket_close(socket);
*_errno = -ret;
return -1;
}
// indicate that this socket has been opened
socket->domain = 1;
// success
return 0;
}
STATIC int wiznet5k_socket_listen(mod_network_socket_obj_t *socket, mp_int_t backlog, int *_errno) {
mp_int_t ret = WIZCHIP_EXPORT(listen)(socket->fileno);
if (ret < 0) {
wiznet5k_socket_close(socket);
*_errno = -ret;
return -1;
}
return 0;
}
STATIC int wiznet5k_socket_accept(mod_network_socket_obj_t *socket, mod_network_socket_obj_t *socket2, byte *ip, mp_uint_t *port, int *_errno) {
for (;;) {
int sr = getSn_SR((uint8_t)socket->fileno);
if (sr == SOCK_ESTABLISHED) {
socket2->domain = socket->domain;
socket2->type = socket->type;
socket2->fileno = socket->fileno;
getSn_DIPR((uint8_t)socket2->fileno, ip);
*port = getSn_PORT(socket2->fileno);
// WIZnet turns the listening socket into the client socket, so we
// need to re-bind and re-listen on another socket for the server.
// TODO handle errors, especially no-more-sockets error
socket->domain = MOD_NETWORK_AF_INET;
socket->fileno = -1;
int _errno2;
if (wiznet5k_socket_socket(socket, &_errno2) != 0) {
// printf("(bad resocket %d)\n", _errno2);
} else if (wiznet5k_socket_bind(socket, NULL, *port, &_errno2) != 0) {
// printf("(bad rebind %d)\n", _errno2);
} else if (wiznet5k_socket_listen(socket, 0, &_errno2) != 0) {
// printf("(bad relisten %d)\n", _errno2);
}
return 0;
}
if (sr == SOCK_CLOSED || sr == SOCK_CLOSE_WAIT) {
wiznet5k_socket_close(socket);
*_errno = MP_ENOTCONN; // ??
return -1;
}
mp_hal_delay_ms(1);
}
}
STATIC int wiznet5k_socket_connect(mod_network_socket_obj_t *socket, byte *ip, mp_uint_t port, int *_errno) {
// use "bind" function to open the socket in client mode
if (wiznet5k_socket_bind(socket, ip, 0, _errno) != 0) {
return -1;
}
// now connect
MP_THREAD_GIL_EXIT();
mp_int_t ret = WIZCHIP_EXPORT(connect)(socket->fileno, ip, port);
MP_THREAD_GIL_ENTER();
if (ret < 0) {
wiznet5k_socket_close(socket);
*_errno = -ret;
return -1;
}
// success
return 0;
}
STATIC mp_uint_t wiznet5k_socket_send(mod_network_socket_obj_t *socket, const byte *buf, mp_uint_t len, int *_errno) {
MP_THREAD_GIL_EXIT();
mp_int_t ret = WIZCHIP_EXPORT(send)(socket->fileno, (byte *)buf, len);
MP_THREAD_GIL_ENTER();
// TODO convert Wiz errno's to POSIX ones
if (ret < 0) {
wiznet5k_socket_close(socket);
*_errno = -ret;
return -1;
}
return ret;
}
STATIC mp_uint_t wiznet5k_socket_recv(mod_network_socket_obj_t *socket, byte *buf, mp_uint_t len, int *_errno) {
MP_THREAD_GIL_EXIT();
mp_int_t ret = WIZCHIP_EXPORT(recv)(socket->fileno, buf, len);
MP_THREAD_GIL_ENTER();
// TODO convert Wiz errno's to POSIX ones
if (ret < 0) {
wiznet5k_socket_close(socket);
*_errno = -ret;
return -1;
}
return ret;
}
STATIC mp_uint_t wiznet5k_socket_sendto(mod_network_socket_obj_t *socket, const byte *buf, mp_uint_t len, byte *ip, mp_uint_t port, int *_errno) {
if (socket->domain == 0) {
// socket not opened; use "bind" function to open the socket in client mode
if (wiznet5k_socket_bind(socket, ip, 0, _errno) != 0) {
return -1;
}
}
MP_THREAD_GIL_EXIT();
mp_int_t ret = WIZCHIP_EXPORT(sendto)(socket->fileno, (byte *)buf, len, ip, port);
MP_THREAD_GIL_ENTER();
if (ret < 0) {
wiznet5k_socket_close(socket);
*_errno = -ret;
return -1;
}
return ret;
}
STATIC mp_uint_t wiznet5k_socket_recvfrom(mod_network_socket_obj_t *socket, byte *buf, mp_uint_t len, byte *ip, mp_uint_t *port, int *_errno) {
uint16_t port2;
MP_THREAD_GIL_EXIT();
mp_int_t ret = WIZCHIP_EXPORT(recvfrom)(socket->fileno, buf, len, ip, &port2);
MP_THREAD_GIL_ENTER();
*port = port2;
if (ret < 0) {
wiznet5k_socket_close(socket);
*_errno = -ret;
return -1;
}
return ret;
}
STATIC int wiznet5k_socket_setsockopt(mod_network_socket_obj_t *socket, mp_uint_t level, mp_uint_t opt, const void *optval, mp_uint_t optlen, int *_errno) {
// TODO
*_errno = MP_EINVAL;
return -1;
}
STATIC int wiznet5k_socket_settimeout(mod_network_socket_obj_t *socket, mp_uint_t timeout_ms, int *_errno) {
// TODO
*_errno = MP_EINVAL;
return -1;
/*
if (timeout_ms == 0) {
// set non-blocking mode
uint8_t arg = SOCK_IO_NONBLOCK;
WIZCHIP_EXPORT(ctlsocket)(socket->fileno, CS_SET_IOMODE, &arg);
}
*/
}
STATIC int wiznet5k_socket_ioctl(mod_network_socket_obj_t *socket, mp_uint_t request, mp_uint_t arg, int *_errno) {
if (request == MP_STREAM_POLL) {
int ret = 0;
if (arg & MP_STREAM_POLL_RD && getSn_RX_RSR(socket->fileno) != 0) {
ret |= MP_STREAM_POLL_RD;
}
if (arg & MP_STREAM_POLL_WR && getSn_TX_FSR(socket->fileno) != 0) {
ret |= MP_STREAM_POLL_WR;
}
return ret;
} else {
*_errno = MP_EINVAL;
return MP_STREAM_ERROR;
}
}
#if 0
STATIC void wiznet5k_socket_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in, mp_print_kind_t kind) {
wiznet5k_socket_obj_t *self = self_in;
print(env, "<WIZNET5K.socket sn=%u MR=0x%02x>", self->sn, getSn_MR(self->sn));
}
STATIC mp_obj_t wiznet5k_socket_disconnect(mp_obj_t self_in) {
mp_int_t ret = WIZCHIP_EXPORT(disconnect)(self->sn);
return 0;
}
#endif
/******************************************************************************/
// MicroPython bindings
/// \classmethod \constructor(spi, pin_cs, pin_rst)
/// Create and return a WIZNET5K object.
STATIC mp_obj_t wiznet5k_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
// check arguments
mp_arg_check_num(n_args, n_kw, 3, 3, false);
// init the wiznet5k object
wiznet5k_obj.base.type = (mp_obj_type_t *)&mod_network_nic_type_wiznet5k;
wiznet5k_obj.cris_state = 0;
wiznet5k_obj.spi = spi_from_mp_obj(args[0]);
wiznet5k_obj.cs = pin_find(args[1]);
wiznet5k_obj.rst = pin_find(args[2]);
wiznet5k_obj.socket_used = 0;
/*!< SPI configuration */
SPI_InitTypeDef *init = &wiznet5k_obj.spi->spi->Init;
init->Mode = SPI_MODE_MASTER;
init->Direction = SPI_DIRECTION_2LINES;
init->DataSize = SPI_DATASIZE_8BIT;
init->CLKPolarity = SPI_POLARITY_LOW; // clock is low when idle
init->CLKPhase = SPI_PHASE_1EDGE; // data latched on first edge, which is rising edge for low-idle
init->NSS = SPI_NSS_SOFT;
init->BaudRatePrescaler = SPI_BAUDRATEPRESCALER_2; // clock freq = f_PCLK / this_prescale_value; Wiz820i can do up to 80MHz
init->FirstBit = SPI_FIRSTBIT_MSB;
init->TIMode = SPI_TIMODE_DISABLED;
init->CRCCalculation = SPI_CRCCALCULATION_DISABLED;
init->CRCPolynomial = 7; // unused
spi_init(wiznet5k_obj.spi, false);
mp_hal_pin_output(wiznet5k_obj.cs);
mp_hal_pin_output(wiznet5k_obj.rst);
mp_hal_pin_low(wiznet5k_obj.rst);
mp_hal_delay_ms(1); // datasheet says 2us
mp_hal_pin_high(wiznet5k_obj.rst);
mp_hal_delay_ms(160); // datasheet says 150ms
reg_wizchip_cris_cbfunc(wiz_cris_enter, wiz_cris_exit);
reg_wizchip_cs_cbfunc(wiz_cs_select, wiz_cs_deselect);
reg_wizchip_spi_cbfunc(wiz_spi_read, wiz_spi_write);
uint8_t sn_size[16] = {2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2}; // 2k buffer for each socket
ctlwizchip(CW_INIT_WIZCHIP, sn_size);
// set some sensible default values; they are configurable using ifconfig method
wiz_NetInfo netinfo = {
.mac = {0x00, 0x08, 0xdc, 0xab, 0xcd, 0xef},
.ip = {192, 168, 0, 18},
.sn = {255, 255, 255, 0},
.gw = {192, 168, 0, 1},
.dns = {8, 8, 8, 8}, // Google public DNS
.dhcp = NETINFO_STATIC,
};
ctlnetwork(CN_SET_NETINFO, (void *)&netinfo);
// seems we need a small delay after init
mp_hal_delay_ms(250);
// register with network module
mod_network_register_nic(&wiznet5k_obj);
// return wiznet5k object
return &wiznet5k_obj;
}
/// \method regs()
/// Dump WIZNET5K registers.
STATIC mp_obj_t wiznet5k_regs(mp_obj_t self_in) {
// wiznet5k_obj_t *self = self_in;
printf("Wiz CREG:");
for (int i = 0; i < 0x50; ++i) {
if (i % 16 == 0) {
printf("\n %04x:", i);
}
#if MICROPY_PY_NETWORK_WIZNET5K == 5200
uint32_t reg = i;
#else
uint32_t reg = _W5500_IO_BASE_ | i << 8;
#endif
printf(" %02x", WIZCHIP_READ(reg));
}
for (int sn = 0; sn < 4; ++sn) {
printf("\nWiz SREG[%d]:", sn);
for (int i = 0; i < 0x30; ++i) {
if (i % 16 == 0) {
printf("\n %04x:", i);
}
#if MICROPY_PY_NETWORK_WIZNET5K == 5200
uint32_t reg = WIZCHIP_SREG_ADDR(sn, i);
#else
uint32_t reg = _W5500_IO_BASE_ | i << 8 | WIZCHIP_SREG_BLOCK(sn) << 3;
#endif
printf(" %02x", WIZCHIP_READ(reg));
}
}
printf("\n");
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(wiznet5k_regs_obj, wiznet5k_regs);
STATIC mp_obj_t wiznet5k_isconnected(mp_obj_t self_in) {
(void)self_in;
return mp_obj_new_bool(wizphy_getphylink() == PHY_LINK_ON);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(wiznet5k_isconnected_obj, wiznet5k_isconnected);
/// \method ifconfig([(ip, subnet, gateway, dns)])
/// Get/set IP address, subnet mask, gateway and DNS.
STATIC mp_obj_t wiznet5k_ifconfig(size_t n_args, const mp_obj_t *args) {
wiz_NetInfo netinfo;
ctlnetwork(CN_GET_NETINFO, &netinfo);
if (n_args == 1) {
// get
mp_obj_t tuple[4] = {
netutils_format_ipv4_addr(netinfo.ip, NETUTILS_BIG),
netutils_format_ipv4_addr(netinfo.sn, NETUTILS_BIG),
netutils_format_ipv4_addr(netinfo.gw, NETUTILS_BIG),
netutils_format_ipv4_addr(netinfo.dns, NETUTILS_BIG),
};
return mp_obj_new_tuple(4, tuple);
} else {
// set
mp_obj_t *items;
mp_obj_get_array_fixed_n(args[1], 4, &items);
netutils_parse_ipv4_addr(items[0], netinfo.ip, NETUTILS_BIG);
netutils_parse_ipv4_addr(items[1], netinfo.sn, NETUTILS_BIG);
netutils_parse_ipv4_addr(items[2], netinfo.gw, NETUTILS_BIG);
netutils_parse_ipv4_addr(items[3], netinfo.dns, NETUTILS_BIG);
ctlnetwork(CN_SET_NETINFO, &netinfo);
return mp_const_none;
}
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(wiznet5k_ifconfig_obj, 1, 2, wiznet5k_ifconfig);
STATIC const mp_rom_map_elem_t wiznet5k_locals_dict_table[] = {
{ MP_ROM_QSTR(MP_QSTR_regs), MP_ROM_PTR(&wiznet5k_regs_obj) },
{ MP_ROM_QSTR(MP_QSTR_ifconfig), MP_ROM_PTR(&wiznet5k_ifconfig_obj) },
{ MP_ROM_QSTR(MP_QSTR_isconnected), MP_ROM_PTR(&wiznet5k_isconnected_obj) },
};
STATIC MP_DEFINE_CONST_DICT(wiznet5k_locals_dict, wiznet5k_locals_dict_table);
const mod_network_nic_type_t mod_network_nic_type_wiznet5k = {
.base = {
{ &mp_type_type },
.name = MP_QSTR_WIZNET5K,
.make_new = wiznet5k_make_new,
.locals_dict = (mp_obj_dict_t *)&wiznet5k_locals_dict,
},
.gethostbyname = wiznet5k_gethostbyname,
.socket = wiznet5k_socket_socket,
.close = wiznet5k_socket_close,
.bind = wiznet5k_socket_bind,
.listen = wiznet5k_socket_listen,
.accept = wiznet5k_socket_accept,
.connect = wiznet5k_socket_connect,
.send = wiznet5k_socket_send,
.recv = wiznet5k_socket_recv,
.sendto = wiznet5k_socket_sendto,
.recvfrom = wiznet5k_socket_recvfrom,
.setsockopt = wiznet5k_socket_setsockopt,
.settimeout = wiznet5k_socket_settimeout,
.ioctl = wiznet5k_socket_ioctl,
};
#endif // MICROPY_PY_NETWORK_WIZNET5K && !MICROPY_PY_LWIP

465
ports/stm32/network_wiznet5k.c
View File

@ -1,465 +0,0 @@
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2014-2018 Damien P. George
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include <stdio.h>
#include <string.h>
#include "py/runtime.h"
#include "py/mphal.h"
#include "extmod/modnetwork.h"
#include "spi.h"
#if MICROPY_PY_NETWORK_WIZNET5K && MICROPY_PY_LWIP
#include "shared/netutils/netutils.h"
#include "drivers/wiznet5k/ethernet/socket.h"
#include "lwip/err.h"
#include "lwip/dns.h"
#include "lwip/dhcp.h"
#include "netif/etharp.h"
#define TRACE_ETH_TX (0x0002)
#define TRACE_ETH_RX (0x0004)
/*******************************************************************************/
// Wiznet5k Ethernet driver in MACRAW mode
typedef struct _wiznet5k_obj_t {
mp_obj_base_t base;
mp_uint_t cris_state;
const spi_t *spi;
mp_hal_pin_obj_t cs;
mp_hal_pin_obj_t rst;
uint8_t eth_frame[1514];
uint32_t trace_flags;
struct netif netif;
struct dhcp dhcp_struct;
} wiznet5k_obj_t;
// Global object holding the Wiznet5k state
STATIC wiznet5k_obj_t wiznet5k_obj;
STATIC void wiznet5k_lwip_init(wiznet5k_obj_t *self);
STATIC void wiz_cris_enter(void) {
wiznet5k_obj.cris_state = MICROPY_BEGIN_ATOMIC_SECTION();
}
STATIC void wiz_cris_exit(void) {
MICROPY_END_ATOMIC_SECTION(wiznet5k_obj.cris_state);
}
STATIC void wiz_cs_select(void) {
mp_hal_pin_low(wiznet5k_obj.cs);
}
STATIC void wiz_cs_deselect(void) {
mp_hal_pin_high(wiznet5k_obj.cs);
}
STATIC void wiz_spi_read(uint8_t *buf, uint32_t len) {
HAL_StatusTypeDef status = HAL_SPI_Receive(wiznet5k_obj.spi->spi, buf, len, 5000);
(void)status;
}
STATIC void wiz_spi_write(const uint8_t *buf, uint32_t len) {
HAL_StatusTypeDef status = HAL_SPI_Transmit(wiznet5k_obj.spi->spi, (uint8_t *)buf, len, 5000);
(void)status;
}
STATIC void wiznet5k_init(void) {
// SPI configuration
SPI_InitTypeDef *init = &wiznet5k_obj.spi->spi->Init;
init->Mode = SPI_MODE_MASTER;
init->Direction = SPI_DIRECTION_2LINES;
init->DataSize = SPI_DATASIZE_8BIT;
init->CLKPolarity = SPI_POLARITY_LOW; // clock is low when idle
init->CLKPhase = SPI_PHASE_1EDGE; // data latched on first edge, which is rising edge for low-idle
init->NSS = SPI_NSS_SOFT;
init->BaudRatePrescaler = SPI_BAUDRATEPRESCALER_2; // clock freq = f_PCLK / this_prescale_value; Wiz820i can do up to 80MHz
init->FirstBit = SPI_FIRSTBIT_MSB;
init->TIMode = SPI_TIMODE_DISABLED;
init->CRCCalculation = SPI_CRCCALCULATION_DISABLED;
init->CRCPolynomial = 7; // unused
spi_init(wiznet5k_obj.spi, false);
mp_hal_pin_output(wiznet5k_obj.cs);
mp_hal_pin_output(wiznet5k_obj.rst);
// Reset the chip
mp_hal_pin_low(wiznet5k_obj.rst);
mp_hal_delay_ms(1); // datasheet says 2us
mp_hal_pin_high(wiznet5k_obj.rst);
mp_hal_delay_ms(150); // datasheet says 150ms
// Set physical interface callbacks
reg_wizchip_cris_cbfunc(wiz_cris_enter, wiz_cris_exit);
reg_wizchip_cs_cbfunc(wiz_cs_select, wiz_cs_deselect);
reg_wizchip_spi_cbfunc(wiz_spi_read, wiz_spi_write);
// Configure 16k buffers for fast MACRAW
uint8_t sn_size[16] = {16, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0};
ctlwizchip(CW_INIT_WIZCHIP, sn_size);
// Seems we need a small delay after init
mp_hal_delay_ms(250);
// If the device doesn't have a MAC address then set one
uint8_t mac[6];
getSHAR(mac);
if ((mac[0] | mac[1] | mac[2] | mac[3] | mac[4] | mac[5]) == 0) {
mp_hal_get_mac(MP_HAL_MAC_ETH0, mac);
setSHAR(mac);
}
// Hook the Wiznet into lwIP
wiznet5k_lwip_init(&wiznet5k_obj);
}
STATIC void wiznet5k_deinit(void) {
for (struct netif *netif = netif_list; netif != NULL; netif = netif->next) {
if (netif == &wiznet5k_obj.netif) {
netif_remove(netif);
netif->flags = 0;
break;
}
}
}
STATIC void wiznet5k_get_mac_address(wiznet5k_obj_t *self, uint8_t mac[6]) {
(void)self;
getSHAR(mac);
}
STATIC void wiznet5k_send_ethernet(wiznet5k_obj_t *self, size_t len, const uint8_t *buf) {
uint8_t ip[4] = {1, 1, 1, 1}; // dummy
int ret = WIZCHIP_EXPORT(sendto)(0, (byte *)buf, len, ip, 11); // dummy port
if (ret != len) {
printf("wiznet5k_send_ethernet: fatal error %d\n", ret);
netif_set_link_down(&self->netif);
netif_set_down(&self->netif);
}
}
// Stores the frame in self->eth_frame and returns number of bytes in the frame, 0 for no frame
STATIC uint16_t wiznet5k_recv_ethernet(wiznet5k_obj_t *self) {
uint16_t len = getSn_RX_RSR(0);
if (len == 0) {
return 0;
}
byte ip[4];
uint16_t port;
int ret = WIZCHIP_EXPORT(recvfrom)(0, self->eth_frame, 1514, ip, &port);
if (ret <= 0) {
printf("wiznet5k_poll: fatal error len=%u ret=%d\n", len, ret);
netif_set_link_down(&self->netif);
netif_set_down(&self->netif);
return 0;
}
return ret;
}
/*******************************************************************************/
// Wiznet5k lwIP interface
STATIC err_t wiznet5k_netif_output(struct netif *netif, struct pbuf *p) {
wiznet5k_obj_t *self = netif->state;
pbuf_copy_partial(p, self->eth_frame, p->tot_len, 0);
if (self->trace_flags & TRACE_ETH_TX) {
netutils_ethernet_trace(MP_PYTHON_PRINTER, p->tot_len, self->eth_frame, NETUTILS_TRACE_IS_TX | NETUTILS_TRACE_NEWLINE);
}
wiznet5k_send_ethernet(self, p->tot_len, self->eth_frame);
return ERR_OK;
}
STATIC err_t wiznet5k_netif_init(struct netif *netif) {
netif->linkoutput = wiznet5k_netif_output;
netif->output = etharp_output;
netif->mtu = 1500;
netif->flags = NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP | NETIF_FLAG_ETHERNET | NETIF_FLAG_IGMP;
wiznet5k_get_mac_address(netif->state, netif->hwaddr);
netif->hwaddr_len = sizeof(netif->hwaddr);
int ret = WIZCHIP_EXPORT(socket)(0, Sn_MR_MACRAW, 0, 0);
if (ret != 0) {
printf("WIZNET fatal error in netifinit: %d\n", ret);
return ERR_IF;
}
// Enable MAC filtering so we only get frames destined for us, to reduce load on lwIP
setSn_MR(0, getSn_MR(0) | Sn_MR_MFEN);
return ERR_OK;
}
STATIC void wiznet5k_lwip_init(wiznet5k_obj_t *self) {
ip_addr_t ipconfig[4];
ipconfig[0].addr = 0;
ipconfig[1].addr = 0;
ipconfig[2].addr = 0;
ipconfig[3].addr = 0;
netif_add(&self->netif, &ipconfig[0], &ipconfig[1], &ipconfig[2], self, wiznet5k_netif_init, ethernet_input);
self->netif.name[0] = 'e';
self->netif.name[1] = '0';
netif_set_default(&self->netif);
dns_setserver(0, &ipconfig[3]);
dhcp_set_struct(&self->netif, &self->dhcp_struct);
// Setting NETIF_FLAG_UP then clearing it is a workaround for dhcp_start and the
// LWIP_DHCP_CHECK_LINK_UP option, so that the DHCP client schedules itself to
// automatically start when the interface later goes up.
self->netif.flags |= NETIF_FLAG_UP;
dhcp_start(&self->netif);
self->netif.flags &= ~NETIF_FLAG_UP;
}
void wiznet5k_poll(void) {
wiznet5k_obj_t *self = &wiznet5k_obj;
if (!(self->netif.flags & NETIF_FLAG_LINK_UP)) {
return;
}
uint16_t len;
while ((len = wiznet5k_recv_ethernet(self)) > 0) {
if (self->trace_flags & TRACE_ETH_RX) {
netutils_ethernet_trace(MP_PYTHON_PRINTER, len, self->eth_frame, NETUTILS_TRACE_NEWLINE);
}
struct pbuf *p = pbuf_alloc(PBUF_RAW, len, PBUF_POOL);
if (p != NULL) {
pbuf_take(p, self->eth_frame, len);
if (self->netif.input(p, &self->netif) != ERR_OK) {
pbuf_free(p);
}
}
}
}
/*******************************************************************************/
// MicroPython bindings
// WIZNET5K([spi, pin_cs, pin_rst])
STATIC mp_obj_t wiznet5k_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
// check arguments
mp_arg_check_num(n_args, n_kw, 3, 3, false);
const spi_t *spi = spi_from_mp_obj(args[0]);
mp_hal_pin_obj_t cs = pin_find(args[1]);
mp_hal_pin_obj_t rst = pin_find(args[2]);
// Access the existing object, if it has been constructed with the same hardware interface
if (wiznet5k_obj.base.type == (mp_obj_type_t *)&mod_network_nic_type_wiznet5k) {
if (!(wiznet5k_obj.spi == spi && wiznet5k_obj.cs == cs && wiznet5k_obj.rst == rst
&& wiznet5k_obj.netif.flags != 0)) {
wiznet5k_deinit();
}
}
// Init the wiznet5k object
wiznet5k_obj.base.type = (mp_obj_type_t *)&mod_network_nic_type_wiznet5k;
wiznet5k_obj.cris_state = 0;
wiznet5k_obj.spi = spi;
wiznet5k_obj.cs = cs;
wiznet5k_obj.rst = rst;
wiznet5k_obj.trace_flags = 0;
// Return wiznet5k object
return MP_OBJ_FROM_PTR(&wiznet5k_obj);
}
STATIC mp_obj_t wiznet5k_regs(mp_obj_t self_in) {
(void)self_in;
printf("Wiz CREG:");
for (int i = 0; i < 0x50; ++i) {
if (i % 16 == 0) {
printf("\n %04x:", i);
}
#if MICROPY_PY_NETWORK_WIZNET5K == 5200
uint32_t reg = i;
#else
uint32_t reg = _W5500_IO_BASE_ | i << 8;
#endif
printf(" %02x", WIZCHIP_READ(reg));
}
for (int sn = 0; sn < 4; ++sn) {
printf("\nWiz SREG[%d]:", sn);
for (int i = 0; i < 0x30; ++i) {
if (i % 16 == 0) {
printf("\n %04x:", i);
}
#if MICROPY_PY_NETWORK_WIZNET5K == 5200
uint32_t reg = WIZCHIP_SREG_ADDR(sn, i);
#else
uint32_t reg = _W5500_IO_BASE_ | i << 8 | WIZCHIP_SREG_BLOCK(sn) << 3;
#endif
printf(" %02x", WIZCHIP_READ(reg));
}
}
printf("\n");
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(wiznet5k_regs_obj, wiznet5k_regs);
STATIC mp_obj_t wiznet5k_isconnected(mp_obj_t self_in) {
wiznet5k_obj_t *self = MP_OBJ_TO_PTR(self_in);
return mp_obj_new_bool(
wizphy_getphylink() == PHY_LINK_ON
&& (self->netif.flags & NETIF_FLAG_UP)
&& self->netif.ip_addr.addr != 0
);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(wiznet5k_isconnected_obj, wiznet5k_isconnected);
STATIC mp_obj_t wiznet5k_active(size_t n_args, const mp_obj_t *args) {
wiznet5k_obj_t *self = MP_OBJ_TO_PTR(args[0]);
if (n_args == 1) {
return mp_obj_new_bool(self->netif.flags & NETIF_FLAG_UP);
} else {
if (mp_obj_is_true(args[1])) {
if (!(self->netif.flags & NETIF_FLAG_UP)) {
wiznet5k_init();
netif_set_link_up(&self->netif);
netif_set_up(&self->netif);
}
} else {
if (self->netif.flags & NETIF_FLAG_UP) {
netif_set_down(&self->netif);
netif_set_link_down(&self->netif);
wiznet5k_deinit();
}
}
return mp_const_none;
}
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(wiznet5k_active_obj, 1, 2, wiznet5k_active);
STATIC mp_obj_t wiznet5k_ifconfig(size_t n_args, const mp_obj_t *args) {
wiznet5k_obj_t *self = MP_OBJ_TO_PTR(args[0]);
return mod_network_nic_ifconfig(&self->netif, n_args - 1, args + 1);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(wiznet5k_ifconfig_obj, 1, 2, wiznet5k_ifconfig);
STATIC mp_obj_t wiznet5k_status(size_t n_args, const mp_obj_t *args) {
wiznet5k_obj_t *self = MP_OBJ_TO_PTR(args[0]);
(void)self;
if (n_args == 1) {
// No arguments: return link status
if (self->netif.flags && wizphy_getphylink() == PHY_LINK_ON) {
if ((self->netif.flags & NETIF_FLAG_UP) && self->netif.ip_addr.addr != 0) {
return MP_OBJ_NEW_SMALL_INT(2);
} else {
return MP_OBJ_NEW_SMALL_INT(1);
}
} else {
return MP_OBJ_NEW_SMALL_INT(0);
}
}
mp_raise_ValueError(MP_ERROR_TEXT("unknown config param"));
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(wiznet5k_status_obj, 1, 2, wiznet5k_status);
STATIC mp_obj_t wiznet5k_config(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs) {
wiznet5k_obj_t *self = MP_OBJ_TO_PTR(args[0]);
if (kwargs->used == 0) {
// Get config value
if (n_args != 2) {
mp_raise_TypeError(MP_ERROR_TEXT("must query one param"));
}
switch (mp_obj_str_get_qstr(args[1])) {
case MP_QSTR_mac: {
uint8_t buf[6];
wiznet5k_get_mac_address(self, buf);
return mp_obj_new_bytes(buf, 6);
}
default:
mp_raise_ValueError(MP_ERROR_TEXT("unknown config param"));
}
} else {
// Set config value(s)
if (n_args != 1) {
mp_raise_TypeError(MP_ERROR_TEXT("can't specify pos and kw args"));
}
for (size_t i = 0; i < kwargs->alloc; ++i) {
if (MP_MAP_SLOT_IS_FILLED(kwargs, i)) {
mp_map_elem_t *e = &kwargs->table[i];
switch (mp_obj_str_get_qstr(e->key)) {
case MP_QSTR_mac: {
mp_buffer_info_t buf;
mp_get_buffer_raise(e->value, &buf, MP_BUFFER_READ);
if (buf.len != 6) {
mp_raise_ValueError(NULL);
}
setSHAR(buf.buf);
memcpy(self->netif.hwaddr, buf.buf, 6);
break;
}
case MP_QSTR_trace: {
self->trace_flags = mp_obj_get_int(e->value);
break;
}
default:
mp_raise_ValueError(MP_ERROR_TEXT("unknown config param"));
}
}
}
return mp_const_none;
}
}
STATIC MP_DEFINE_CONST_FUN_OBJ_KW(wiznet5k_config_obj, 1, wiznet5k_config);
STATIC mp_obj_t send_ethernet_wrapper(mp_obj_t self_in, mp_obj_t buf_in) {
wiznet5k_obj_t *self = MP_OBJ_TO_PTR(self_in);
mp_buffer_info_t buf;
mp_get_buffer_raise(buf_in, &buf, MP_BUFFER_READ);
wiznet5k_send_ethernet(self, buf.len, buf.buf);
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_2(send_ethernet_obj, send_ethernet_wrapper);
STATIC const mp_rom_map_elem_t wiznet5k_locals_dict_table[] = {
{ MP_ROM_QSTR(MP_QSTR_regs), MP_ROM_PTR(&wiznet5k_regs_obj) },
{ MP_ROM_QSTR(MP_QSTR_isconnected), MP_ROM_PTR(&wiznet5k_isconnected_obj) },
{ MP_ROM_QSTR(MP_QSTR_active), MP_ROM_PTR(&wiznet5k_active_obj) },
{ MP_ROM_QSTR(MP_QSTR_ifconfig), MP_ROM_PTR(&wiznet5k_ifconfig_obj) },
{ MP_ROM_QSTR(MP_QSTR_status), MP_ROM_PTR(&wiznet5k_status_obj) },
{ MP_ROM_QSTR(MP_QSTR_config), MP_ROM_PTR(&wiznet5k_config_obj) },
{ MP_ROM_QSTR(MP_QSTR_send_ethernet), MP_ROM_PTR(&send_ethernet_obj) },
};
STATIC MP_DEFINE_CONST_DICT(wiznet5k_locals_dict, wiznet5k_locals_dict_table);
const mp_obj_type_t mod_network_nic_type_wiznet5k = {
{ &mp_type_type },
.name = MP_QSTR_WIZNET5K,
.make_new = wiznet5k_make_new,
.locals_dict = (mp_obj_dict_t *)&wiznet5k_locals_dict,
};
#endif // MICROPY_PY_NETWORK_WIZNET5K && MICROPY_PY_LWIP