diff options
| -rw-r--r-- | extmod/network_wiznet5k.c | 1042 |
1 files changed, 1042 insertions, 0 deletions
diff --git a/extmod/network_wiznet5k.c b/extmod/network_wiznet5k.c new file mode 100644 index 000000000..e14d8bdd6 --- /dev/null +++ b/extmod/network_wiznet5k.c @@ -0,0 +1,1042 @@ +/* + * 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 <stdlib.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 "extmod/machine_spi.h" +#include "extmod/virtpin.h" +#include "modmachine.h" +#include "drivers/bus/spi.h" + +#if MICROPY_PY_WIZNET5K + +#include "lib/wiznet5k/Ethernet/wizchip_conf.h" + +// The WIZNET5K module supports two usage modes: +// * Raw ethernet transport with LwIP integrated in micropython +// * Provided TCP Stack on controller presented as modnetwork / socket interface + +#define WIZNET5K_WITH_LWIP_STACK (MICROPY_PY_LWIP) +#define WIZNET5K_PROVIDED_STACK (!MICROPY_PY_LWIP) + +#if WIZNET5K_WITH_LWIP_STACK +// Uses LwIP for TCP Stack with Wiznet in MACRAW mode + +#include "shared/netutils/netutils.h" +#include "lib/wiznet5k/Ethernet/wizchip_conf.h" +#include "lib/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) + +#else // WIZNET5K_PROVIDED_STACK +// Uses TCP Stack provided in Wiznet controller +// TODO: Not all micropython modnetwork / socket features are provided + +#include "lib/wiznet5k/Ethernet/socket.h" +#include "lib/wiznet5k/Internet/DNS/dns.h" +#include "lib/wiznet5k/Internet/DHCP/dhcp.h" + +#endif + +#ifndef printf +#define printf(...) mp_printf(MP_PYTHON_PRINTER, __VA_ARGS__) +#endif + +#ifndef MICROPY_HW_WIZNET_SPI_BAUDRATE +#define MICROPY_HW_WIZNET_SPI_BAUDRATE (2000000) +#endif + +#ifndef WIZCHIP_SREG_ADDR +#if (_WIZCHIP_ == 5500) +#define WIZCHIP_SREG_ADDR(sn, addr) (_W5500_IO_BASE_ + (addr << 8) + (WIZCHIP_SREG_BLOCK(sn) << 3)) +#else +#define WIZCHIP_SREG_ADDR(sn, addr) (_WIZCHIP_IO_BASE_ + WIZCHIP_SREG_BLOCK(sn) + (addr)) +#endif +#endif + +extern struct _machine_spi_obj_t *spi_from_mp_obj(mp_obj_t o); + +typedef struct _wiznet5k_obj_t { + mp_obj_base_t base; + mp_uint_t cris_state; + struct _machine_spi_obj_t *spi; + mp_hal_pin_obj_t cs; + mp_hal_pin_obj_t rst; + #if WIZNET5K_WITH_LWIP_STACK + mp_hal_pin_obj_t pin_intn; + bool use_interrupt; + uint8_t eth_frame[1514]; + uint32_t trace_flags; + struct netif netif; + struct dhcp dhcp_struct; + #else // WIZNET5K_PROVIDED_STACK + wiz_NetInfo netinfo; + uint8_t socket_used; + bool active; + #endif +} wiznet5k_obj_t; + +#if WIZNET5K_WITH_LWIP_STACK +#define IS_ACTIVE(self) (self->netif.flags & NETIF_FLAG_UP) +#else // WIZNET5K_PROVIDED_STACK +#define IS_ACTIVE(self) (self->active) +#endif + +// Global object holding the Wiznet5k state +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); +} + +void mpy_wiznet_yield(void) { + // Used in socket.c via -DWIZCHIP_YIELD=mpy_wiznet_yield in make/cmake + #if MICROPY_PY_THREAD + MICROPY_THREAD_YIELD(); + #else + mp_handle_pending(true); + #endif +} + +STATIC void wiz_spi_read(uint8_t *buf, uint16_t len) { + ((mp_machine_spi_p_t *)machine_spi_type.protocol)->transfer((mp_obj_base_t *)wiznet5k_obj.spi, len, buf, buf); +} + +STATIC void wiz_spi_write(const uint8_t *buf, uint16_t len) { + ((mp_machine_spi_p_t *)machine_spi_type.protocol)->transfer((mp_obj_base_t *)wiznet5k_obj.spi, len, buf, NULL); +} + +STATIC uint8_t wiz_spi_readbyte() { + uint8_t buf = 0; + ((mp_machine_spi_p_t *)machine_spi_type.protocol)->transfer((mp_obj_base_t *)wiznet5k_obj.spi, 1, &buf, &buf); + return buf; +} + +STATIC void wiz_spi_writebyte(const uint8_t buf) { + ((mp_machine_spi_p_t *)machine_spi_type.protocol)->transfer((mp_obj_base_t *)wiznet5k_obj.spi, 1, &buf, NULL); +} + +STATIC void wiznet5k_get_mac_address(wiznet5k_obj_t *self, uint8_t mac[6]) { + (void)self; + getSHAR(mac); +} + +#if WIZNET5K_WITH_LWIP_STACK + +void wiznet5k_try_poll(void); +STATIC void wiznet5k_lwip_init(wiznet5k_obj_t *self); + +STATIC mp_obj_t mpy_wiznet_read_int(mp_obj_t none_in) { + (void)none_in; + wizchip_clrinterrupt(IK_SOCK_0); + setSn_IR(0, Sn_IR_RECV); + + // Handle incoming data + wiznet5k_try_poll(); + return mp_const_none; +} +STATIC MP_DEFINE_CONST_FUN_OBJ_1(mpy_wiznet_read_int_obj, mpy_wiznet_read_int); + +STATIC void wiznet5k_config_interrupt(bool enabled) { + if (!wiznet5k_obj.use_interrupt) { + return; + } + mp_hal_pin_interrupt( + wiznet5k_obj.pin_intn, + MP_OBJ_FROM_PTR(&mpy_wiznet_read_int_obj), + (enabled)? MP_HAL_PIN_TRIGGER_FALL : MP_HAL_PIN_TRIGGER_NONE, + true + ); +} + +STATIC void wiznet5k_init(void) { + // Configure wiznet for raw ethernet frame usage. + + // 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); + + if (wiznet5k_obj.use_interrupt) { + // Enable Wiznet interrupts for socket 0 + wizchip_setinterruptmask(IK_SOCK_0); + // Enable data receive interrupt + setSn_IMR(0, Sn_IR_RECV); + #if _WIZCHIP_ == W5100S + // Enable interrupt pin + setMR(MR2_G_IEN); + #endif + + mp_hal_pin_input(wiznet5k_obj.pin_intn); + wiznet5k_config_interrupt(true); + } + + // Hook the Wiznet into lwIP + wiznet5k_lwip_init(&wiznet5k_obj); + + netif_set_link_up(&wiznet5k_obj.netif); + netif_set_up(&wiznet5k_obj.netif); +} + +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_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_recv_ethernet: 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_UP) || + !(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); + } + } + } +} + +#endif // MICROPY_PY_LWIP + +#if WIZNET5K_PROVIDED_STACK + +STATIC void wiz_dhcp_assign(void) { + getIPfromDHCP(wiznet5k_obj.netinfo.ip); + getGWfromDHCP(wiznet5k_obj.netinfo.gw); + getSNfromDHCP(wiznet5k_obj.netinfo.sn); + getDNSfromDHCP(wiznet5k_obj.netinfo.dns); + ctlnetwork(CN_SET_NETINFO, (void *)&wiznet5k_obj.netinfo); +} + +STATIC void wiz_dhcp_update(void) { + ; +} + + +STATIC void wiz_dhcp_conflict(void) { + ; +} + +STATIC void wiznet5k_init(void) { + // Configure wiznet provided TCP / socket interface + + reg_dhcp_cbfunc(wiz_dhcp_assign, wiz_dhcp_update, wiz_dhcp_conflict); + + 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); + + ctlnetwork(CN_SET_NETINFO, (void *)&wiznet5k_obj.netinfo); + + // set some sensible default values; they are configurable using ifconfig method + wiz_NetInfo netinfo = { + .mac = {0, 0, 0, 0, 0, 0}, + .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, + }; + wiznet5k_obj.netinfo = netinfo; + + // register with network module + mod_network_register_nic(&wiznet5k_obj); + + wiznet5k_obj.active = true; +} + +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(2, 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; + } +} + +STATIC void wiznet5k_dhcp_init(wiznet5k_obj_t *self) { + uint8_t test_buf[2048]; + uint8_t ret = 0; + uint8_t dhcp_retry = 0; + + while (ret != DHCP_IP_LEASED) { + mp_uint_t timeout = mp_hal_ticks_ms() + 3000; + DHCP_init(1, test_buf); + + while (1) { + ret = DHCP_run(); + if (ret == DHCP_IP_LEASED) { + break; + } else if (ret == DHCP_FAILED || mp_hal_ticks_ms() > timeout) { + dhcp_retry++; + break; + } + mpy_wiznet_yield(); + } + + if (dhcp_retry > 3) { + mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("timeout waiting for DHCP to get IP address")); + break; + } + } + + if (ret == DHCP_IP_LEASED) { + ctlnetwork(CN_GET_NETINFO, &self->netinfo); + } +} + +#endif // WIZNET5K_PROVIDED_STACK + +/*******************************************************************************/ +// MicroPython bindings + +// WIZNET5K(spi, pin_cs, pin_rst[, pin_intn]) +// 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) { + struct _machine_spi_obj_t *spi; + mp_hal_pin_obj_t cs; + mp_hal_pin_obj_t rst; + + #if WIZNET5K_WITH_LWIP_STACK + mp_hal_pin_obj_t pin_intn = (mp_hal_pin_obj_t)NULL; + bool use_interrupt = false; + + // Bring down interface while configuring + wiznet5k_obj.netif.flags = 0; + #endif + + #ifdef MICROPY_HW_WIZNET_SPI_ID + // check arguments + mp_arg_check_num(n_args, n_kw, 0, 3, false); + // Allow auto-configuration of SPI if defined for board and no args passed + if (n_args == 0) { + // Initialize SPI. + mp_obj_t spi_obj = MP_OBJ_NEW_SMALL_INT(MICROPY_HW_WIZNET_SPI_SCK); + mp_obj_t miso_obj = MP_OBJ_NEW_SMALL_INT(MICROPY_HW_WIZNET_SPI_MISO); + mp_obj_t mosi_obj = MP_OBJ_NEW_SMALL_INT(MICROPY_HW_WIZNET_SPI_MOSI); + mp_obj_t args[] = { + MP_OBJ_NEW_SMALL_INT(MICROPY_HW_WIZNET_SPI_ID), + MP_OBJ_NEW_SMALL_INT(MICROPY_HW_WIZNET_SPI_BAUDRATE), + MP_ROM_QSTR(MP_QSTR_sck), mp_pin_make_new(NULL, 1, 0, &spi_obj), + MP_ROM_QSTR(MP_QSTR_miso), mp_pin_make_new(NULL, 1, 0, &miso_obj), + MP_ROM_QSTR(MP_QSTR_mosi), mp_pin_make_new(NULL, 1, 0, &mosi_obj), + }; + spi = machine_spi_type.make_new((mp_obj_t)&machine_spi_type, 2, 3, args); + + cs = mp_hal_get_pin_obj(mp_pin_make_new(NULL, 1, 0, (mp_obj_t[]) {MP_OBJ_NEW_SMALL_INT(MICROPY_HW_WIZNET_PIN_CS)})); + rst = mp_hal_get_pin_obj(mp_pin_make_new(NULL, 1, 0, (mp_obj_t[]) {MP_OBJ_NEW_SMALL_INT(MICROPY_HW_WIZNET_PIN_RST)})); + #if WIZNET5K_WITH_LWIP_STACK && defined(MICROPY_HW_WIZNET_PIN_INTN) + pin_intn = mp_hal_get_pin_obj(mp_pin_make_new(NULL, 1, 0, (mp_obj_t[]) {MP_OBJ_NEW_SMALL_INT(MICROPY_HW_WIZNET_PIN_INTN)})); + use_interrupt = true; + #endif + + } else + #endif + { + // If passing in args, must supply spi, pin_cs, pin_rst and optionally pin_intn + #if WIZNET5K_WITH_LWIP_STACK + mp_arg_check_num(n_args, n_kw, 3, 4, false); + #else + mp_arg_check_num(n_args, n_kw, 3, 3, false); + #endif + spi = spi_from_mp_obj(args[0]); + cs = mp_hal_get_pin_obj(args[1]); + rst = mp_hal_get_pin_obj(args[2]); + #if WIZNET5K_WITH_LWIP_STACK + if (n_args > 3) { + pin_intn = mp_hal_get_pin_obj(args[3]); + use_interrupt = true; + } + #endif + } + + mp_hal_pin_output(cs); + mp_hal_pin_output(rst); + + // 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; + #if WIZNET5K_WITH_LWIP_STACK + wiznet5k_obj.pin_intn = pin_intn; + wiznet5k_obj.use_interrupt = use_interrupt; + wiznet5k_obj.trace_flags = 0; + #else // WIZNET5K_PROVIDED_STACK + wiznet5k_obj.active = false; + wiznet5k_obj.socket_used = 0; + #endif + + // Return wiznet5k object + return MP_OBJ_FROM_PTR(&wiznet5k_obj); +} + +// regs() +// Dump WIZNET5K registers. +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 _WIZCHIP_ == 5500 + uint32_t reg = _W5500_IO_BASE_ | i << 8; + #else + uint32_t reg = i; + #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 _WIZCHIP_ == 5500 + uint32_t reg = _W5500_IO_BASE_ | i << 8 | WIZCHIP_SREG_BLOCK(sn) << 3; + #else + uint32_t reg = WIZCHIP_SREG_ADDR(sn, i); + #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 + && IS_ACTIVE(self) + #if WIZNET5K_WITH_LWIP_STACK + && self->netif.ip_addr.addr != 0 + #endif + ); +} +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(IS_ACTIVE(self)); + } else { + if (mp_obj_is_true(args[1])) { + if (!IS_ACTIVE(self)) { + /*!< Wiznet initialisation */ + // 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(160); // 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_readbyte, wiz_spi_writebyte); + reg_wizchip_spiburst_cbfunc(wiz_spi_read, wiz_spi_write); + + // Configure lwip/provided specific settings + wiznet5k_init(); + + // If the device doesn't have a MAC address then set one + #if WIZNET5K_WITH_LWIP_STACK + uint8_t *mac = self->netif.hwaddr; + #else // WIZNET5K_PROVIDED_STACK + uint8_t *mac = wiznet5k_obj.netinfo.mac; + #endif + 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); + } + + // seems we need a small delay after init + mp_hal_delay_ms(250); + + } + } else { + #if WIZNET5K_WITH_LWIP_STACK + netif_set_down(&self->netif); + netif_set_link_down(&self->netif); + wiznet5k_deinit(); + #else // WIZNET5K_PROVIDED_STACK + self->active = false; + wizchip_sw_reset(); + #endif + } + return mp_const_none; + } +} +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(wiznet5k_active_obj, 1, 2, wiznet5k_active); + +#if WIZNET5K_PROVIDED_STACK +// 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; + wiznet5k_obj_t *self = MP_OBJ_TO_PTR(args[0]); + ctlnetwork(CN_GET_NETINFO, &netinfo); + if (n_args == 1) { + // Get IP addresses + 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 if (args[1] == MP_OBJ_NEW_QSTR(MP_QSTR_dhcp)) { + // Start the DHCP client + self->netinfo.dhcp = NETINFO_DHCP; + wiznet5k_dhcp_init((void *)self); + mp_obj_t tuple[4] = { + netutils_format_ipv4_addr(self->netinfo.ip, NETUTILS_BIG), + netutils_format_ipv4_addr(self->netinfo.sn, NETUTILS_BIG), + netutils_format_ipv4_addr(self->netinfo.gw, NETUTILS_BIG), + netutils_format_ipv4_addr(self->netinfo.dns, NETUTILS_BIG), + + }; + return mp_obj_new_tuple(4, tuple); + + } else { + // Set static IP addresses + self->netinfo.dhcp = NETINFO_STATIC; + 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); +#endif // WIZNET5K_PROVIDED_STACK + +#if WIZNET5K_WITH_LWIP_STACK + +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 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); + +#endif // MICROPY_PY_LWIP + +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 (wizphy_getphylink() == PHY_LINK_ON) { + if (IS_ACTIVE(self)) { + 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 status 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); + #if WIZNET5K_WITH_LWIP_STACK + memcpy(self->netif.hwaddr, buf.buf, 6); + #endif + break; + } + #if WIZNET5K_WITH_LWIP_STACK + case MP_QSTR_trace: { + self->trace_flags = mp_obj_get_int(e->value); + break; + } + #endif + 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 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) }, + #if WIZNET5K_WITH_LWIP_STACK + { MP_ROM_QSTR(MP_QSTR_send_ethernet), MP_ROM_PTR(&send_ethernet_obj) }, + #endif +}; +STATIC MP_DEFINE_CONST_DICT(wiznet5k_locals_dict, wiznet5k_locals_dict_table); + +#if WIZNET5K_WITH_LWIP_STACK +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, +}; +#else // WIZNET5K_PROVIDED_STACK +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 + +#endif // MICROPY_PY_WIZNET5K |