Socket APIs: Ethernet/wizchip_conf.c Source File

Wiznet Socket API

Socket APIs
Ethernet
 //****************************************************************************/ 
 // Issued by Mathias ClauBen.
 //
 //*****************************************************************************/
 //A20140501 : for use the type - ptrdiff_t
 #include <stddef.h>
 //
 
 #include "wizchip_conf.h"
 
 //M20150401 : Remove ; in the default callback function such as wizchip_cris_enter(), wizchip_cs_select() and etc.
 
 //void wizchip_cris_enter(void) {};
 void wizchip_cris_enter(void) {}
 
 //void wizchip_cris_exit(void) {};
 void wizchip_cris_exit(void) {}
 
 //void wizchip_cs_select(void) {};
 void wizchip_cs_select(void) {}
 
 //void wizchip_cs_deselect(void) {};
 void wizchip_cs_deselect(void) {}
 
  //M20150601 : Rename the function for integrating with W5300
 //uint8_t wizchip_bus_readbyte(uint32_t AddrSel) { return * ((volatile uint8_t *)((ptrdiff_t) AddrSel)); }
 iodata_t wizchip_bus_readdata(uint32_t AddrSel) { return * ((volatile iodata_t *)((ptrdiff_t) AddrSel)); }
 
 //M20150601 : Rename the function for integrating with W5300
 //void wizchip_bus_writebyte(uint32_t AddrSel, uint8_t wb) { *((volatile uint8_t*)((ptrdiff_t)AddrSel)) = wb; }
 void wizchip_bus_writedata(uint32_t AddrSel, iodata_t wb) { *((volatile iodata_t*)((ptrdiff_t)AddrSel)) = wb; }
 
 //uint8_t wizchip_spi_readbyte(void) {return 0;};
 uint8_t wizchip_spi_readbyte(void) {return 0;}
 
 //void wizchip_spi_writebyte(uint8_t wb) {};
 void wizchip_spi_writebyte(uint8_t wb) {}
 
 //void wizchip_spi_readburst(uint8_t* pBuf, uint16_t len) {}; 
 void wizchip_spi_readburst(uint8_t* pBuf, uint16_t len) {}
 
 //void wizchip_spi_writeburst(uint8_t* pBuf, uint16_t len) {};
 void wizchip_spi_writeburst(uint8_t* pBuf, uint16_t len) {}
 
 //
 //M20150401 : For a compiler didnot support a member of structure
 // Replace the assignment of struct members with the assingment of array
 //
 /*
 _WIZCHIP WIZCHIP =
  {
  .id = _WIZCHIP_ID_,
  .if_mode = _WIZCHIP_IO_MODE_,
  .CRIS._enter = wizchip_cris_enter,
  .CRIS._exit = wizchip_cris_exit,
  .CS._select = wizchip_cs_select,
  .CS._deselect = wizchip_cs_deselect,
  .IF.BUS._read_byte = wizchip_bus_readbyte,
  .IF.BUS._write_byte = wizchip_bus_writebyte
 // .IF.SPI._read_byte = wizchip_spi_readbyte,
 // .IF.SPI._write_byte = wizchip_spi_writebyte
  };
 */ 
 _WIZCHIP WIZCHIP =
  {
  _WIZCHIP_IO_MODE_,
  _WIZCHIP_ID_ ,
  wizchip_cris_enter,
  wizchip_cris_exit,
  wizchip_cs_select,
  wizchip_cs_deselect,
  //M20150601 : Rename the function 
  //wizchip_bus_readbyte,
  //wizchip_bus_writebyte
  wizchip_bus_readdata,
  wizchip_bus_writedata,
 // wizchip_spi_readbyte,
 // wizchip_spi_writebyte
  };
 
 
 static uint8_t _DNS_[4]; // DNS server ip address
 static dhcp_mode _DHCP_; // DHCP mode
 
 void reg_wizchip_cris_cbfunc(void(*cris_en)(void), void(*cris_ex)(void))
 {
  if(!cris_en || !cris_ex)
  {
  WIZCHIP.CRIS._enter = wizchip_cris_enter;
  WIZCHIP.CRIS._exit = wizchip_cris_exit;
  }
  else
  {
  WIZCHIP.CRIS._enter = cris_en;
  WIZCHIP.CRIS._exit = cris_ex;
  }
 }
 
 void reg_wizchip_cs_cbfunc(void(*cs_sel)(void), void(*cs_desel)(void))
 {
  if(!cs_sel || !cs_desel)
  {
  WIZCHIP.CS._select = wizchip_cs_select;
  WIZCHIP.CS._deselect = wizchip_cs_deselect;
  }
  else
  {
  WIZCHIP.CS._select = cs_sel;
  WIZCHIP.CS._deselect = cs_desel;
  }
 }
 
 //M20150515 : For integrating with W5300
 //void reg_wizchip_bus_cbfunc(uint8_t(*bus_rb)(uint32_t addr), void (*bus_wb)(uint32_t addr, uint8_t wb))
 void reg_wizchip_bus_cbfunc(iodata_t(*bus_rb)(uint32_t addr), void (*bus_wb)(uint32_t addr, iodata_t wb))
 {
  while(!(WIZCHIP.if_mode & _WIZCHIP_IO_MODE_BUS_));
  //M20150601 : Rename call back function for integrating with W5300
  /*
  if(!bus_rb || !bus_wb)
  {
  WIZCHIP.IF.BUS._read_byte = wizchip_bus_readbyte;
  WIZCHIP.IF.BUS._write_byte = wizchip_bus_writebyte;
  }
  else
  {
  WIZCHIP.IF.BUS._read_byte = bus_rb;
  WIZCHIP.IF.BUS._write_byte = bus_wb;
  }
  */
  if(!bus_rb || !bus_wb)
  {
  WIZCHIP.IF.BUS._read_data = wizchip_bus_readdata;
  WIZCHIP.IF.BUS._write_data = wizchip_bus_writedata;
  }
  else
  {
  WIZCHIP.IF.BUS._read_data = bus_rb;
  WIZCHIP.IF.BUS._write_data = bus_wb;
  }
 }
 
 void reg_wizchip_spi_cbfunc(uint8_t (*spi_rb)(void), void (*spi_wb)(uint8_t wb))
 {
  while(!(WIZCHIP.if_mode & _WIZCHIP_IO_MODE_SPI_));
  
  if(!spi_rb || !spi_wb)
  {
  WIZCHIP.IF.SPI._read_byte = wizchip_spi_readbyte;
  WIZCHIP.IF.SPI._write_byte = wizchip_spi_writebyte;
  }
  else
  {
  WIZCHIP.IF.SPI._read_byte = spi_rb;
  WIZCHIP.IF.SPI._write_byte = spi_wb;
  }
 }
 
 // 20140626 Eric Added for SPI burst operations
 void reg_wizchip_spiburst_cbfunc(void (*spi_rb)(uint8_t* pBuf, uint16_t len), void (*spi_wb)(uint8_t* pBuf, uint16_t len))
 {
  while(!(WIZCHIP.if_mode & _WIZCHIP_IO_MODE_SPI_));
 
  if(!spi_rb || !spi_wb)
  {
  WIZCHIP.IF.SPI._read_burst = wizchip_spi_readburst;
  WIZCHIP.IF.SPI._write_burst = wizchip_spi_writeburst;
  }
  else
  {
  WIZCHIP.IF.SPI._read_burst = spi_rb;
  WIZCHIP.IF.SPI._write_burst = spi_wb;
  }
 }
 
 int8_t ctlwizchip(ctlwizchip_type cwtype, void* arg)
 {
 #if _WIZCHIP_ == 5200 || _WIZCHIP_ == 5500
  uint8_t tmp = 0;
 #endif
  uint8_t* ptmp[2] = {0,0};
  switch(cwtype)
  {
  case CW_RESET_WIZCHIP:
  wizchip_sw_reset();
  break;
  case CW_INIT_WIZCHIP:
  if(arg != 0) 
  {
  ptmp[0] = (uint8_t*)arg;
  ptmp[1] = ptmp[0] + _WIZCHIP_SOCK_NUM_;
  }
  return wizchip_init(ptmp[0], ptmp[1]);
  case CW_CLR_INTERRUPT:
  wizchip_clrinterrupt(*((intr_kind*)arg));
  break;
  case CW_GET_INTERRUPT:
  *((intr_kind*)arg) = wizchip_getinterrupt();
  break;
  case CW_SET_INTRMASK:
  wizchip_setinterruptmask(*((intr_kind*)arg));
  break; 
  case CW_GET_INTRMASK:
  *((intr_kind*)arg) = wizchip_getinterruptmask();
  break;
  //M20150601 : This can be supported by W5200, W5500
  //#if _WIZCHIP_ > 5100
  #if (_WIZCHIP_ == 5200 || _WIZCHIP_ == 5500)
  case CW_SET_INTRTIME:
  setINTLEVEL(*(uint16_t*)arg);
  break;
  case CW_GET_INTRTIME:
  *(uint16_t*)arg = getINTLEVEL();
  break;
  #endif
  case CW_GET_ID:
  ((uint8_t*)arg)[0] = WIZCHIP.id[0];
  ((uint8_t*)arg)[1] = WIZCHIP.id[1];
  ((uint8_t*)arg)[2] = WIZCHIP.id[2];
  ((uint8_t*)arg)[3] = WIZCHIP.id[3];
  ((uint8_t*)arg)[4] = WIZCHIP.id[4];
  ((uint8_t*)arg)[5] = 0;
  break;
  #if _WIZCHIP_ == 5500
  case CW_RESET_PHY:
  wizphy_reset();
  break;
  case CW_SET_PHYCONF:
  wizphy_setphyconf((wiz_PhyConf*)arg);
  break;
  case CW_GET_PHYCONF:
  wizphy_getphyconf((wiz_PhyConf*)arg);
  break;
  case CW_GET_PHYSTATUS:
  break;
  case CW_SET_PHYPOWMODE:
  return wizphy_setphypmode(*(uint8_t*)arg);
  #endif
  #if _WIZCHIP_ == 5200 || _WIZCHIP_ == 5500
  case CW_GET_PHYPOWMODE:
  tmp = wizphy_getphypmode();
  if((int8_t)tmp == -1) return -1;
  *(uint8_t*)arg = tmp;
  break;
  case CW_GET_PHYLINK:
  tmp = wizphy_getphylink();
  if((int8_t)tmp == -1) return -1;
  *(uint8_t*)arg = tmp;
  break;
  #endif 
  default:
  return -1;
  }
  return 0;
 }
 
 
 int8_t ctlnetwork(ctlnetwork_type cntype, void* arg)
 {
  
  switch(cntype)
  {
  case CN_SET_NETINFO:
  wizchip_setnetinfo((wiz_NetInfo*)arg);
  break;
  case CN_GET_NETINFO:
  wizchip_getnetinfo((wiz_NetInfo*)arg);
  break;
  case CN_SET_NETMODE:
  return wizchip_setnetmode(*(netmode_type*)arg);
  case CN_GET_NETMODE:
  *(netmode_type*)arg = wizchip_getnetmode();
  break;
  case CN_SET_TIMEOUT:
  wizchip_settimeout((wiz_NetTimeout*)arg);
  break;
  case CN_GET_TIMEOUT:
  wizchip_gettimeout((wiz_NetTimeout*)arg);
  break;
  default:
  return -1;
  }
  return 0;
 }
 
 void wizchip_sw_reset(void)
 {
  uint8_t gw[4], sn[4], sip[4];
  uint8_t mac[6];
 //A20150601
 #if _WIZCHIP_IO_MODE_ == _WIZCHIP_IO_MODE_BUS_INDIR_
  uint16_t mr = (uint16_t)getMR();
  setMR(mr | MR_IND);
 #endif
 //
  getSHAR(mac);
  getGAR(gw); getSUBR(sn); getSIPR(sip);
  setMR(MR_RST);
  getMR(); // for delay
 //A2015051 : For indirect bus mode 
 #if _WIZCHIP_IO_MODE_ == _WIZCHIP_IO_MODE_BUS_INDIR_
  setMR(mr | MR_IND);
 #endif
 //
  setSHAR(mac);
  setGAR(gw);
  setSUBR(sn);
  setSIPR(sip);
 }
 
 int8_t wizchip_init(uint8_t* txsize, uint8_t* rxsize)
 {
  int8_t i;
  int8_t tmp = 0;
  wizchip_sw_reset();
  if(txsize)
  {
  tmp = 0;
  //M20150601 : For integrating with W5300
  #if _WIZCHIP_ == 5300
  for(i = 0 ; i < _WIZCHIP_SOCK_NUM_; i++)
  {
  if(txsize[i] >= 64) return -1; //No use 64KB even if W5300 support max 64KB memory allocation
  tmp += txsize[i];
  if(tmp > 128) return -1;
  }
  if(tmp % 8) return -1;
  #else 
  for(i = 0 ; i < _WIZCHIP_SOCK_NUM_; i++)
  {
  tmp += txsize[i];
  if(tmp > 16) return -1;
  }
  #endif
  for(i = 0 ; i < _WIZCHIP_SOCK_NUM_; i++)
  setSn_TXBUF_SIZE(i, txsize[i]);
  }
  if(rxsize)
  {
  tmp = 0;
  #if _WIZCHIP_ == 5300
  for(i = 0 ; i < _WIZCHIP_SOCK_NUM_; i++)
  {
  if(rxsize[i] >= 64) return -1; //No use 64KB even if W5300 support max 64KB memory allocation 
  tmp += rxsize[i];
  if(tmp > 128) return -1;
  }
  if(tmp % 8) return -1;
  #else 
  for(i = 0 ; i < _WIZCHIP_SOCK_NUM_; i++)
  {
  tmp += rxsize[i];
  if(tmp > 16) return -1;
  }
  #endif
 
  for(i = 0 ; i < _WIZCHIP_SOCK_NUM_; i++)
  setSn_RXBUF_SIZE(i, rxsize[i]);
  }
  return 0;
 }
 
 void wizchip_clrinterrupt(intr_kind intr)
 {
  uint8_t ir = (uint8_t)intr;
  uint8_t sir = (uint8_t)((uint16_t)intr >> 8);
 #if _WIZCHIP_ < 5500
  ir |= (1<<4); // IK_WOL
 #endif
 #if _WIZCHIP_ == 5200
  ir |= (1 << 6);
 #endif
  
 #if _WIZCHIP_ < 5200
  sir &= 0x0F;
 #endif
 
 #if _WIZCHIP_ == 5100
  ir |= sir;
  setIR(ir);
 //A20150601 : For integrating with W5300
 #elif _WIZCHIP_ == 5300
  setIR( ((((uint16_t)ir) << 8) | (((uint16_t)sir) & 0x00FF)) );
 #else
  setIR(ir);
  setSIR(sir);
 #endif 
 }
 
 intr_kind wizchip_getinterrupt(void)
 {
  uint8_t ir = 0;
  uint8_t sir = 0;
  uint16_t ret = 0;
 #if _WIZCHIP_ == 5100
  ir = getIR();
  sir = ir & 0x0F;
 //A20150601 : For integrating with W5300
 #elif _WIZCHIP_ == 5300
  ret = getIR();
  ir = (uint8_t)(ret >> 8);
  sir = (uint8_t)ret;
 #else
  ir = getIR();
  sir = getSIR();
 #endif 
 
 //M20150601 : For Integrating with W5300
 //#if _WIZCHIP_ < 5500
 #if _WIZCHIP_ < 5200
  ir &= ~(1<<4); // IK_WOL
 #endif
 #if _WIZCHIP_ == 5200
  ir &= ~(1 << 6);
 #endif
  ret = sir;
  ret = (ret << 8) + ir;
  return (intr_kind)ret;
 }
 
 void wizchip_setinterruptmask(intr_kind intr)
 {
  uint8_t imr = (uint8_t)intr;
  uint8_t simr = (uint8_t)((uint16_t)intr >> 8);
 #if _WIZCHIP_ < 5500
  imr &= ~(1<<4); // IK_WOL
 #endif
 #if _WIZCHIP_ == 5200
  imr &= ~(1 << 6);
 #endif
  
 #if _WIZCHIP_ == 5100
  simr &= 0x0F;
  imr |= simr;
  setIMR(imr);
 //A20150601 : For integrating with W5300
 #elif _WIZCHIP_ == 5300
  setIMR( ((((uint16_t)imr) << 8) | (((uint16_t)simr) & 0x00FF)) );
 #else
  setIMR(imr);
  setSIMR(simr);
 #endif 
 }
 
 intr_kind wizchip_getinterruptmask(void)
 {
  uint8_t imr = 0;
  uint8_t simr = 0;
  uint16_t ret = 0;
 #if _WIZCHIP_ == 5100
  imr = getIMR();
  simr = imr & 0x0F;
 //A20150601 : For integrating with W5300
 #elif _WIZCHIP_ == 5300
  ret = getIMR();
  imr = (uint8_t)(ret >> 8);
  simr = (uint8_t)ret;
 #else
  imr = getIMR();
  simr = getSIMR();
 #endif 
 
 #if _WIZCHIP_ < 5500
  imr &= ~(1<<4); // IK_WOL
 #endif
 #if _WIZCHIP_ == 5200
  imr &= ~(1 << 6); // IK_DEST_UNREACH
 #endif
  ret = simr;
  ret = (ret << 8) + imr;
  return (intr_kind)ret;
 }
 
 int8_t wizphy_getphylink(void)
 {
  int8_t tmp;
 #if _WIZCHIP_ == 5200
  if(getPHYSTATUS() & PHYSTATUS_LINK)
  tmp = PHY_LINK_ON;
  else
  tmp = PHY_LINK_OFF;
 #elif _WIZCHIP_ == 5500
  if(getPHYCFGR() & PHYCFGR_LNK_ON)
  tmp = PHY_LINK_ON;
  else
  tmp = PHY_LINK_OFF;
 #else
  tmp = -1;
 #endif
  return tmp;
 }
 
 #if _WIZCHIP_ > 5100
 
 int8_t wizphy_getphypmode(void)
 {
  int8_t tmp = 0;
  #if _WIZCHIP_ == 5200
  if(getPHYSTATUS() & PHYSTATUS_POWERDOWN)
  tmp = PHY_POWER_DOWN;
  else 
  tmp = PHY_POWER_NORM;
  #elif _WIZCHIP_ == 5500
  if(getPHYCFGR() & PHYCFGR_OPMDC_PDOWN)
  tmp = PHY_POWER_DOWN;
  else 
  tmp = PHY_POWER_NORM;
  #else
  tmp = -1;
  #endif
  return tmp;
 }
 #endif
 
 #if _WIZCHIP_ == 5500
 void wizphy_reset(void)
 {
  uint8_t tmp = getPHYCFGR();
  tmp &= PHYCFGR_RST;
  setPHYCFGR(tmp);
  tmp = getPHYCFGR(); 
  tmp |= ~PHYCFGR_RST;
  setPHYCFGR(tmp);
 }
 
 void wizphy_setphyconf(wiz_PhyConf* phyconf)
 {
  uint8_t tmp = 0;
  if(phyconf->by == PHY_CONFBY_SW)
  tmp |= PHYCFGR_OPMD;
  else
  tmp &= ~PHYCFGR_OPMD;
  if(phyconf->mode == PHY_MODE_AUTONEGO)
  tmp |= PHYCFGR_OPMDC_ALLA;
  else
  {
  if(phyconf->duplex == PHY_DUPLEX_FULL)
  {
  if(phyconf->speed == PHY_SPEED_100)
  tmp |= PHYCFGR_OPMDC_100F;
  else
  tmp |= PHYCFGR_OPMDC_10F;
  } 
  else
  {
  if(phyconf->speed == PHY_SPEED_100)
  tmp |= PHYCFGR_OPMDC_100H;
  else
  tmp |= PHYCFGR_OPMDC_10H;
  }
  }
  setPHYCFGR(tmp);
  wizphy_reset();
 }
 
 void wizphy_getphyconf(wiz_PhyConf* phyconf)
 {
  uint8_t tmp = 0;
  tmp = getPHYCFGR();
  phyconf->by = (tmp & PHYCFGR_OPMD) ? PHY_CONFBY_SW : PHY_CONFBY_HW;
  switch(tmp & PHYCFGR_OPMDC_ALLA)
  {
  case PHYCFGR_OPMDC_ALLA:
  case PHYCFGR_OPMDC_100FA: 
  phyconf->mode = PHY_MODE_AUTONEGO;
  break;
  default:
  phyconf->mode = PHY_MODE_MANUAL;
  break;
  }
  switch(tmp & PHYCFGR_OPMDC_ALLA)
  {
  case PHYCFGR_OPMDC_100FA:
  case PHYCFGR_OPMDC_100F:
  case PHYCFGR_OPMDC_100H:
  phyconf->speed = PHY_SPEED_100;
  break;
  default:
  phyconf->speed = PHY_SPEED_10;
  break;
  }
  switch(tmp & PHYCFGR_OPMDC_ALLA)
  {
  case PHYCFGR_OPMDC_100FA:
  case PHYCFGR_OPMDC_100F:
  case PHYCFGR_OPMDC_10F:
  phyconf->duplex = PHY_DUPLEX_FULL;
  break;
  default:
  phyconf->duplex = PHY_DUPLEX_HALF;
  break;
  }
 }
 
 void wizphy_getphystat(wiz_PhyConf* phyconf)
 {
  uint8_t tmp = getPHYCFGR();
  phyconf->duplex = (tmp & PHYCFGR_DPX_FULL) ? PHY_DUPLEX_FULL : PHY_DUPLEX_HALF;
  phyconf->speed = (tmp & PHYCFGR_SPD_100) ? PHY_SPEED_100 : PHY_SPEED_10;
 }
 
 int8_t wizphy_setphypmode(uint8_t pmode)
 {
  uint8_t tmp = 0;
  tmp = getPHYCFGR();
  if((tmp & PHYCFGR_OPMD)== 0) return -1;
  tmp &= ~PHYCFGR_OPMDC_ALLA; 
  if( pmode == PHY_POWER_DOWN)
  tmp |= PHYCFGR_OPMDC_PDOWN;
  else
  tmp |= PHYCFGR_OPMDC_ALLA;
  setPHYCFGR(tmp);
  wizphy_reset();
  tmp = getPHYCFGR();
  if( pmode == PHY_POWER_DOWN)
  {
  if(tmp & PHYCFGR_OPMDC_PDOWN) return 0;
  }
  else
  {
  if(tmp & PHYCFGR_OPMDC_ALLA) return 0;
  }
  return -1;
 }
 #endif
 
 
 void wizchip_setnetinfo(wiz_NetInfo* pnetinfo)
 {
  setSHAR(pnetinfo->mac);
  setGAR(pnetinfo->gw);
  setSUBR(pnetinfo->sn);
  setSIPR(pnetinfo->ip);
  _DNS_[0] = pnetinfo->dns[0];
  _DNS_[1] = pnetinfo->dns[1];
  _DNS_[2] = pnetinfo->dns[2];
  _DNS_[3] = pnetinfo->dns[3];
  _DHCP_ = pnetinfo->dhcp;
 }
 
 void wizchip_getnetinfo(wiz_NetInfo* pnetinfo)
 {
  getSHAR(pnetinfo->mac);
  getGAR(pnetinfo->gw);
  getSUBR(pnetinfo->sn);
  getSIPR(pnetinfo->ip);
  pnetinfo->dns[0]= _DNS_[0];
  pnetinfo->dns[1]= _DNS_[1];
  pnetinfo->dns[2]= _DNS_[2];
  pnetinfo->dns[3]= _DNS_[3];
  pnetinfo->dhcp = _DHCP_;
 }
 
 int8_t wizchip_setnetmode(netmode_type netmode)
 {
  uint8_t tmp = 0;
 #if _WIZCHIP_ != 5500 
  if(netmode & ~(NM_WAKEONLAN | NM_PPPOE | NM_PINGBLOCK)) return -1;
 #else
  if(netmode & ~(NM_WAKEONLAN | NM_PPPOE | NM_PINGBLOCK | NM_FORCEARP)) return -1;
 #endif 
  tmp = getMR();
  tmp |= (uint8_t)netmode;
  setMR(tmp);
  return 0;
 }
 
 netmode_type wizchip_getnetmode(void)
 {
  return (netmode_type) getMR();
 }
 
 void wizchip_settimeout(wiz_NetTimeout* nettime)
 {
  setRCR(nettime->retry_cnt);
  setRTR(nettime->time_100us);
 }
 
 void wizchip_gettimeout(wiz_NetTimeout* nettime)
 {
  nettime->retry_cnt = getRCR();
  nettime->time_100us = getRTR();
 }
Generated on Wed May 4 2016 16:43:58 for Socket APIs by
1.8.9.1
previous page start next page