Socket APIs: Ethernet/socket.c Source File

Wiznet Socket API

socket.c
Go to the documentation of this file.
1 //*****************************************************************************
2 //
54 //
55 //*****************************************************************************
56 #include "socket.h"
57 
58 //M20150401 : Typing Error
59 //#define SOCK_ANY_PORT_NUM 0xC000;
60 #define SOCK_ANY_PORT_NUM 0xC000
61 
62 static uint16_t sock_any_port = SOCK_ANY_PORT_NUM;
63 static uint16_t sock_io_mode = 0;
64 static uint16_t sock_is_sending = 0;
65 
66 static uint16_t sock_remained_size[_WIZCHIP_SOCK_NUM_] = {0,0,};
67 
68 //M20150601 : For extern decleation
69 //static uint8_t sock_pack_info[_WIZCHIP_SOCK_NUM_] = {0,};
71 //
72 
73 #if _WIZCHIP_ == 5200
74  static uint16_t sock_next_rd[_WIZCHIP_SOCK_NUM_] ={0,};
75 #endif
76 
77 //A20150601 : For integrating with W5300
78 #if _WIZCHIP_ == 5300
79  uint8_t sock_remained_byte[_WIZCHIP_SOCK_NUM_] = {0,}; // set by wiz_recv_data()
80 #endif
81 
82 
83 #define CHECK_SOCKNUM() \
84  do{ \
85  if(sn > _WIZCHIP_SOCK_NUM_) return SOCKERR_SOCKNUM; \
86  }while(0); \
87 
88 #define CHECK_SOCKMODE(mode) \
89  do{ \
90  if((getSn_MR(sn) & 0x0F) != mode) return SOCKERR_SOCKMODE; \
91  }while(0); \
92 
93 #define CHECK_SOCKINIT() \
94  do{ \
95  if((getSn_SR(sn) != SOCK_INIT)) return SOCKERR_SOCKINIT; \
96  }while(0); \
97 
98 #define CHECK_SOCKDATA() \
99  do{ \
100  if(len == 0) return SOCKERR_DATALEN; \
101  }while(0); \
102 
103 
104 
105 int8_t socket(uint8_t sn, uint8_t protocol, uint16_t port, uint8_t flag)
106 {
107  CHECK_SOCKNUM();
108  switch(protocol)
109  {
110  case Sn_MR_TCP :
111  {
112  //M20150601 : Fixed the warning - taddr will never be NULL
113  /*
114  uint8_t taddr[4];
115  getSIPR(taddr);
116  */
117  uint32_t taddr;
118  getSIPR((uint8_t*)&taddr);
119  if(taddr == 0) return SOCKERR_SOCKINIT;
120  }
121  case Sn_MR_UDP :
122  case Sn_MR_MACRAW :
123  break;
124  #if ( _WIZCHIP_ < 5200 )
125  case Sn_MR_IPRAW :
126  case Sn_MR_PPPoE :
127  break;
128  #endif
129  default :
130  return SOCKERR_SOCKMODE;
131  }
132  //M20150601 : For SF_TCP_ALIGN & W5300
133  //if((flag & 0x06) != 0) return SOCKERR_SOCKFLAG;
134  if((flag & 0x04) != 0) return SOCKERR_SOCKFLAG;
135 #if _WIZCHIP_ == 5200
136  if(flag & 0x10) return SOCKERR_SOCKFLAG;
137 #endif
138 
139  if(flag != 0)
140  {
141  switch(protocol)
142  {
143  case Sn_MR_TCP:
144  //M20150601 : For SF_TCP_ALIGN & W5300
145  #if _WIZCHIP_ == 5300
146  if((flag & (SF_TCP_NODELAY|SF_IO_NONBLOCK|SF_TCP_ALIGN))==0) return SOCKERR_SOCKFLAG;
147  #else
148  if((flag & (SF_TCP_NODELAY|SF_IO_NONBLOCK))==0) return SOCKERR_SOCKFLAG;
149  #endif
150 
151  break;
152  case Sn_MR_UDP:
153  if(flag & SF_IGMP_VER2)
154  {
155  if((flag & SF_MULTI_ENABLE)==0) return SOCKERR_SOCKFLAG;
156  }
157  #if _WIZCHIP_ == 5500
158  if(flag & SF_UNI_BLOCK)
159  {
160  if((flag & SF_MULTI_ENABLE) == 0) return SOCKERR_SOCKFLAG;
161  }
162  #endif
163  break;
164  default:
165  break;
166  }
167  }
168  close(sn);
169  //M20150601
170  #if _WIZCHIP_ == 5300
171  setSn_MR(sn, ((uint16_t)(protocol | (flag & 0xF0))) | (((uint16_t)(flag & 0x02)) << 7) );
172  #else
173  setSn_MR(sn, (protocol | (flag & 0xF0)));
174  #endif
175  if(!port)
176  {
177  port = sock_any_port++;
178  if(sock_any_port == 0xFFF0) sock_any_port = SOCK_ANY_PORT_NUM;
179  }
180  setSn_PORT(sn,port);
181  setSn_CR(sn,Sn_CR_OPEN);
182  while(getSn_CR(sn));
183  //A20150401 : For release the previous sock_io_mode
184  sock_io_mode &= ~(1 <<sn);
185  //
186  sock_io_mode |= ((flag & SF_IO_NONBLOCK) << sn);
187  sock_is_sending &= ~(1<<sn);
188  sock_remained_size[sn] = 0;
189  //M20150601 : repalce 0 with PACK_COMPLETED
190  //sock_pack_info[sn] = 0;
192  //
193  while(getSn_SR(sn) == SOCK_CLOSED);
194  return (int8_t)sn;
195 }
196 
197 int8_t close(uint8_t sn)
198 {
199  CHECK_SOCKNUM();
200 //A20160426 : Applied the erratum 1 of W5300
201 #if (_WIZCHIP_ == 5300)
202  //M20160503 : Wrong socket parameter. s -> sn
203  //if( ((getSn_MR(s)& 0x0F) == Sn_MR_TCP) && (getSn_TX_FSR(s) != getSn_TxMAX(s)) )
204  if( ((getSn_MR(sn)& 0x0F) == Sn_MR_TCP) && (getSn_TX_FSR(sn) != getSn_TxMAX(sn)) )
205  {
206  uint8 destip[4] = {0, 0, 0, 1};
207  // TODO
208  // You can wait for completing to sending data;
209  // wait about 1 second;
210  // if you have completed to send data, skip the code of erratum 1
211  // ex> wait_1s();
212  // if (getSn_TX_FSR(s) == getSn_TxMAX(s)) continue;
213  //
214  //M20160503 : The socket() of close() calls close() itself again. It occures a infinite loop - close()->socket()->close()->socket()-> ~
215  //socket(s,Sn_MR_UDP,0x3000,0);
216  //sendto(s,destip,1,destip,0x3000); // send the dummy data to an unknown destination(0.0.0.1).
217  setSn_MR(sn,Sn_MR_UDP);
218  setSn_PORTR(sn, 0x3000);
219  setSn_CR(sn,Sn_CR_OPEN);
220  while(getSn_CR(sn) != 0);
221  while(getSn_SR(sn) != SOCK_UDP);
222  sendto(sn,destip,1,destip,0x3000); // send the dummy data to an unknown destination(0.0.0.1).
223  };
224 #endif
225  setSn_CR(sn,Sn_CR_CLOSE);
226  /* wait to process the command... */
227  while( getSn_CR(sn) );
228  /* clear all interrupt of the socket. */
229  setSn_IR(sn, 0xFF);
230  //A20150401 : Release the sock_io_mode of socket n.
231  sock_io_mode &= ~(1<<sn);
232  //
233  sock_is_sending &= ~(1<<sn);
234  sock_remained_size[sn] = 0;
235  sock_pack_info[sn] = 0;
236  while(getSn_SR(sn) != SOCK_CLOSED);
237  return SOCK_OK;
238 }
239 
240 int8_t listen(uint8_t sn)
241 {
242  CHECK_SOCKNUM();
244  CHECK_SOCKINIT();
246  while(getSn_CR(sn));
247  while(getSn_SR(sn) != SOCK_LISTEN)
248  {
249  if(getSn_CR(sn) == SOCK_CLOSED)
250  {
251  close(sn);
252  return SOCKERR_SOCKCLOSED;
253  }
254  }
255  return SOCK_OK;
256 }
257 
258 
259 int8_t connect(uint8_t sn, uint8_t * addr, uint16_t port)
260 {
261  CHECK_SOCKNUM();
263  CHECK_SOCKINIT();
264  //M20140501 : For avoiding fatal error on memory align mismatched
265  //if( *((uint32_t*)addr) == 0xFFFFFFFF || *((uint32_t*)addr) == 0) return SOCKERR_IPINVALID;
266  {
267  uint32_t taddr;
268  taddr = ((uint32_t)addr[0] & 0x000000FF);
269  taddr = (taddr << 8) + ((uint32_t)addr[1] & 0x000000FF);
270  taddr = (taddr << 8) + ((uint32_t)addr[2] & 0x000000FF);
271  taddr = (taddr << 8) + ((uint32_t)addr[3] & 0x000000FF);
272  if( taddr == 0xFFFFFFFF || taddr == 0) return SOCKERR_IPINVALID;
273  }
274  //
275 
276  if(port == 0) return SOCKERR_PORTZERO;
277  setSn_DIPR(sn,addr);
278  setSn_DPORT(sn,port);
280  while(getSn_CR(sn));
281  if(sock_io_mode & (1<<sn)) return SOCK_BUSY;
282  while(getSn_SR(sn) != SOCK_ESTABLISHED)
283  {
284  if (getSn_IR(sn) & Sn_IR_TIMEOUT)
285  {
286  setSn_IR(sn, Sn_IR_TIMEOUT);
287  return SOCKERR_TIMEOUT;
288  }
289 
290  if (getSn_SR(sn) == SOCK_CLOSED)
291  {
292  return SOCKERR_SOCKCLOSED;
293  }
294  }
295 
296  return SOCK_OK;
297 }
298 
299 int8_t disconnect(uint8_t sn)
300 {
301  CHECK_SOCKNUM();
304  /* wait to process the command... */
305  while(getSn_CR(sn));
306  sock_is_sending &= ~(1<<sn);
307  if(sock_io_mode & (1<<sn)) return SOCK_BUSY;
308  while(getSn_SR(sn) != SOCK_CLOSED)
309  {
310  if(getSn_IR(sn) & Sn_IR_TIMEOUT)
311  {
312  close(sn);
313  return SOCKERR_TIMEOUT;
314  }
315  }
316  return SOCK_OK;
317 }
318 
319 int32_t send(uint8_t sn, uint8_t * buf, uint16_t len)
320 {
321  uint8_t tmp=0;
322  uint16_t freesize=0;
323 
324  CHECK_SOCKNUM();
326  CHECK_SOCKDATA();
327  tmp = getSn_SR(sn);
328  if(tmp != SOCK_ESTABLISHED && tmp != SOCK_CLOSE_WAIT) return SOCKERR_SOCKSTATUS;
329  if( sock_is_sending & (1<<sn) )
330  {
331  tmp = getSn_IR(sn);
332  if(tmp & Sn_IR_SENDOK)
333  {
334  setSn_IR(sn, Sn_IR_SENDOK);
335  //M20150401 : Typing Error
336  //#if _WZICHIP_ == 5200
337  #if _WIZCHIP_ == 5200
338  if(getSn_TX_RD(sn) != sock_next_rd[sn])
339  {
340  setSn_CR(sn,Sn_CR_SEND);
341  while(getSn_CR(sn));
342  return SOCK_BUSY;
343  }
344  #endif
345  sock_is_sending &= ~(1<<sn);
346  }
347  else if(tmp & Sn_IR_TIMEOUT)
348  {
349  close(sn);
350  return SOCKERR_TIMEOUT;
351  }
352  else return SOCK_BUSY;
353  }
354  freesize = getSn_TxMAX(sn);
355  if (len > freesize) len = freesize; // check size not to exceed MAX size.
356  while(1)
357  {
358  freesize = getSn_TX_FSR(sn);
359  tmp = getSn_SR(sn);
360  if ((tmp != SOCK_ESTABLISHED) && (tmp != SOCK_CLOSE_WAIT))
361  {
362  close(sn);
363  return SOCKERR_SOCKSTATUS;
364  }
365  if( (sock_io_mode & (1<<sn)) && (len > freesize) ) return SOCK_BUSY;
366  if(len <= freesize) break;
367  }
368  wiz_send_data(sn, buf, len);
369  #if _WIZCHIP_ == 5200
370  sock_next_rd[sn] = getSn_TX_RD(sn) + len;
371  #endif
372 
373  #if _WIZCHIP_ == 5300
374  setSn_TX_WRSR(sn,len);
375  #endif
376 
377  setSn_CR(sn,Sn_CR_SEND);
378  /* wait to process the command... */
379  while(getSn_CR(sn));
380  sock_is_sending |= (1 << sn);
381  //M20150409 : Explicit Type Casting
382  //return len;
383  return (int32_t)len;
384 }
385 
386 
387 int32_t recv(uint8_t sn, uint8_t * buf, uint16_t len)
388 {
389  uint8_t tmp = 0;
390  uint16_t recvsize = 0;
391 //A20150601 : For integarating with W5300
392 #if _WIZCHIP_ == 5300
393  uint8_t head[2];
394  uint16_t mr;
395 #endif
396 //
397  CHECK_SOCKNUM();
399  CHECK_SOCKDATA();
400 
401  recvsize = getSn_RxMAX(sn);
402  if(recvsize < len) len = recvsize;
403 
404 //A20150601 : For Integrating with W5300
405 #if _WIZCHIP_ == 5300
406  //sock_pack_info[sn] = PACK_COMPLETED; // for clear
407  if(sock_remained_size[sn] == 0)
408  {
409 #endif
410 //
411  while(1)
412  {
413  recvsize = getSn_RX_RSR(sn);
414  tmp = getSn_SR(sn);
415  if (tmp != SOCK_ESTABLISHED)
416  {
417  if(tmp == SOCK_CLOSE_WAIT)
418  {
419  if(recvsize != 0) break;
420  else if(getSn_TX_FSR(sn) == getSn_TxMAX(sn))
421  {
422  close(sn);
423  return SOCKERR_SOCKSTATUS;
424  }
425  }
426  else
427  {
428  close(sn);
429  return SOCKERR_SOCKSTATUS;
430  }
431  }
432  if((sock_io_mode & (1<<sn)) && (recvsize == 0)) return SOCK_BUSY;
433  if(recvsize != 0) break;
434  };
435 #if _WIZCHIP_ == 5300
436  }
437 #endif
438 
439 //A20150601 : For integrating with W5300
440 #if _WIZCHIP_ == 5300
441  if((sock_remained_size[sn] == 0) || (getSn_MR(sn) & Sn_MR_ALIGN))
442  {
443  mr = getMR();
444  if((getSn_MR(sn) & Sn_MR_ALIGN)==0)
445  {
446  wiz_recv_data(sn,head,2);
447  if(mr & MR_FS)
448  recvsize = (((uint16_t)head[1]) << 8) | ((uint16_t)head[0]);
449  else
450  recvsize = (((uint16_t)head[0]) << 8) | ((uint16_t)head[1]);
452  }
453  sock_remained_size[sn] = recvsize;
454  }
455  if(len > sock_remained_size[sn]) len = sock_remained_size[sn];
456  recvsize = len;
457  if(sock_pack_info[sn] & PACK_FIFOBYTE)
458  {
459  *buf = sock_remained_byte[sn];
460  buf++;
461  sock_pack_info[sn] &= ~(PACK_FIFOBYTE);
462  recvsize -= 1;
463  sock_remained_size[sn] -= 1;
464  }
465  if(recvsize != 0)
466  {
467  wiz_recv_data(sn, buf, recvsize);
468  setSn_CR(sn,Sn_CR_RECV);
469  while(getSn_CR(sn));
470  }
471  sock_remained_size[sn] -= recvsize;
472  if(sock_remained_size[sn] != 0)
473  {
475  if(recvsize & 0x1) sock_pack_info[sn] |= PACK_FIFOBYTE;
476  }
477  else sock_pack_info[sn] = PACK_COMPLETED;
478  if(getSn_MR(sn) & Sn_MR_ALIGN) sock_remained_size[sn] = 0;
479  //len = recvsize;
480 #else
481  if(recvsize < len) len = recvsize;
482  wiz_recv_data(sn, buf, len);
483  setSn_CR(sn,Sn_CR_RECV);
484  while(getSn_CR(sn));
485 #endif
486 
487  //M20150409 : Explicit Type Casting
488  //return len;
489  return (int32_t)len;
490 }
491 
492 int32_t sendto(uint8_t sn, uint8_t * buf, uint16_t len, uint8_t * addr, uint16_t port)
493 {
494  uint8_t tmp = 0;
495  uint16_t freesize = 0;
496  uint32_t taddr;
497 
498  CHECK_SOCKNUM();
499  switch(getSn_MR(sn) & 0x0F)
500  {
501  case Sn_MR_UDP:
502  case Sn_MR_MACRAW:
503  break;
504  default:
505  return SOCKERR_SOCKMODE;
506  }
507  CHECK_SOCKDATA();
508  //M20140501 : For avoiding fatal error on memory align mismatched
509  //if(*((uint32_t*)addr) == 0) return SOCKERR_IPINVALID;
510  //{
511  //uint32_t taddr;
512  taddr = ((uint32_t)addr[0]) & 0x000000FF;
513  taddr = (taddr << 8) + ((uint32_t)addr[1] & 0x000000FF);
514  taddr = (taddr << 8) + ((uint32_t)addr[2] & 0x000000FF);
515  taddr = (taddr << 8) + ((uint32_t)addr[3] & 0x000000FF);
516  //}
517  //
518  //if(*((uint32_t*)addr) == 0) return SOCKERR_IPINVALID;
519  if(taddr == 0) return SOCKERR_IPINVALID;
520  if(port == 0) return SOCKERR_PORTZERO;
521  tmp = getSn_SR(sn);
522  if(tmp != SOCK_MACRAW && tmp != SOCK_UDP) return SOCKERR_SOCKSTATUS;
523 
524  setSn_DIPR(sn,addr);
525  setSn_DPORT(sn,port);
526  freesize = getSn_TxMAX(sn);
527  if (len > freesize) len = freesize; // check size not to exceed MAX size.
528  while(1)
529  {
530  freesize = getSn_TX_FSR(sn);
531  if(getSn_SR(sn) == SOCK_CLOSED) return SOCKERR_SOCKCLOSED;
532  if( (sock_io_mode & (1<<sn)) && (len > freesize) ) return SOCK_BUSY;
533  if(len <= freesize) break;
534  };
535  wiz_send_data(sn, buf, len);
536 
537  #if _WIZCHIP_ < 5500 //M20150401 : for WIZCHIP Errata #4, #5 (ARP errata)
538  getSIPR((uint8_t*)&taddr);
539  if(taddr == 0)
540  {
541  getSUBR((uint8_t*)&taddr);
542  setSUBR((uint8_t*)"\x00\x00\x00\x00");
543  }
544  else taddr = 0;
545  #endif
546 
547 //A20150601 : For W5300
548 #if _WIZCHIP_ == 5300
549  setSn_TX_WRSR(sn, len);
550 #endif
551 //
552  setSn_CR(sn,Sn_CR_SEND);
553  /* wait to process the command... */
554  while(getSn_CR(sn));
555  while(1)
556  {
557  tmp = getSn_IR(sn);
558  if(tmp & Sn_IR_SENDOK)
559  {
560  setSn_IR(sn, Sn_IR_SENDOK);
561  break;
562  }
563  //M:20131104
564  //else if(tmp & Sn_IR_TIMEOUT) return SOCKERR_TIMEOUT;
565  else if(tmp & Sn_IR_TIMEOUT)
566  {
567  setSn_IR(sn, Sn_IR_TIMEOUT);
568  //M20150409 : Fixed the lost of sign bits by type casting.
569  //len = (uint16_t)SOCKERR_TIMEOUT;
570  //break;
571  #if _WIZCHIP_ < 5500 //M20150401 : for WIZCHIP Errata #4, #5 (ARP errata)
572  if(taddr) setSUBR((uint8_t*)&taddr);
573  #endif
574  return SOCKERR_TIMEOUT;
575  }
577  }
578  #if _WIZCHIP_ < 5500 //M20150401 : for WIZCHIP Errata #4, #5 (ARP errata)
579  if(taddr) setSUBR((uint8_t*)&taddr);
580  #endif
581  //M20150409 : Explicit Type Casting
582  //return len;
583  return (int32_t)len;
584 }
585 
586 
587 
588 int32_t recvfrom(uint8_t sn, uint8_t * buf, uint16_t len, uint8_t * addr, uint16_t *port)
589 {
590 //M20150601 : For W5300
591 #if _WIZCHIP_ == 5300
592  uint16_t mr;
593  uint16_t mr1;
594 #else
595  uint8_t mr;
596 #endif
597 //
598  uint8_t head[8];
599  uint16_t pack_len=0;
600 
601  CHECK_SOCKNUM();
602  //CHECK_SOCKMODE(Sn_MR_UDP);
603 //A20150601
604 #if _WIZCHIP_ == 5300
605  mr1 = getMR();
606 #endif
607 
608  switch((mr=getSn_MR(sn)) & 0x0F)
609  {
610  case Sn_MR_UDP:
611  case Sn_MR_MACRAW:
612  break;
613  #if ( _WIZCHIP_ < 5200 )
614  case Sn_MR_IPRAW:
615  case Sn_MR_PPPoE:
616  break;
617  #endif
618  default:
619  return SOCKERR_SOCKMODE;
620  }
621  CHECK_SOCKDATA();
622  if(sock_remained_size[sn] == 0)
623  {
624  while(1)
625  {
626  pack_len = getSn_RX_RSR(sn);
627  if(getSn_SR(sn) == SOCK_CLOSED) return SOCKERR_SOCKCLOSED;
628  if( (sock_io_mode & (1<<sn)) && (pack_len == 0) ) return SOCK_BUSY;
629  if(pack_len != 0) break;
630  };
631  }
632 //D20150601 : Move it to bottom
633 // sock_pack_info[sn] = PACK_COMPLETED;
634  switch (mr & 0x07)
635  {
636  case Sn_MR_UDP :
637  if(sock_remained_size[sn] == 0)
638  {
639  wiz_recv_data(sn, head, 8);
640  setSn_CR(sn,Sn_CR_RECV);
641  while(getSn_CR(sn));
642  // read peer's IP address, port number & packet length
643  //A20150601 : For W5300
644  #if _WIZCHIP_ == 5300
645  if(mr1 & MR_FS)
646  {
647  addr[0] = head[1];
648  addr[1] = head[0];
649  addr[2] = head[3];
650  addr[3] = head[2];
651  *port = head[5];
652  *port = (*port << 8) + head[4];
653  sock_remained_size[sn] = head[7];
654  sock_remained_size[sn] = (sock_remained_size[sn] << 8) + head[6];
655  }
656  else
657  {
658  #endif
659  addr[0] = head[0];
660  addr[1] = head[1];
661  addr[2] = head[2];
662  addr[3] = head[3];
663  *port = head[4];
664  *port = (*port << 8) + head[5];
665  sock_remained_size[sn] = head[6];
666  sock_remained_size[sn] = (sock_remained_size[sn] << 8) + head[7];
667  #if _WIZCHIP_ == 5300
668  }
669  #endif
671  }
672  if(len < sock_remained_size[sn]) pack_len = len;
673  else pack_len = sock_remained_size[sn];
674  //A20150601 : For W5300
675  len = pack_len;
676  #if _WIZCHIP_ == 5300
677  if(sock_pack_info[sn] & PACK_FIFOBYTE)
678  {
679  *buf++ = sock_remained_byte[sn];
680  pack_len -= 1;
681  sock_remained_size[sn] -= 1;
682  sock_pack_info[sn] &= ~PACK_FIFOBYTE;
683  }
684  #endif
685  //
686  // Need to packet length check (default 1472)
687  //
688  wiz_recv_data(sn, buf, pack_len); // data copy.
689  break;
690  case Sn_MR_MACRAW :
691  if(sock_remained_size[sn] == 0)
692  {
693  wiz_recv_data(sn, head, 2);
694  setSn_CR(sn,Sn_CR_RECV);
695  while(getSn_CR(sn));
696  // read peer's IP address, port number & packet length
697  sock_remained_size[sn] = head[0];
698  sock_remained_size[sn] = (sock_remained_size[sn] <<8) + head[1];
699  if(sock_remained_size[sn] > 1514)
700  {
701  close(sn);
702  return SOCKFATAL_PACKLEN;
703  }
705  }
706  if(len < sock_remained_size[sn]) pack_len = len;
707  else pack_len = sock_remained_size[sn];
708  wiz_recv_data(sn,buf,pack_len);
709  break;
710  #if ( _WIZCHIP_ < 5200 )
711  case Sn_MR_IPRAW:
712  if(sock_remained_size[sn] == 0)
713  {
714  wiz_recv_data(sn, head, 6);
715  setSn_CR(sn,Sn_CR_RECV);
716  while(getSn_CR(sn));
717  addr[0] = head[0];
718  addr[1] = head[1];
719  addr[2] = head[2];
720  addr[3] = head[3];
721  sock_remained_size[sn] = head[4];
722  //M20150401 : For Typing Error
723  //sock_remaiend_size[sn] = (sock_remained_size[sn] << 8) + head[5];
724  sock_remained_size[sn] = (sock_remained_size[sn] << 8) + head[5];
726  }
727  //
728  // Need to packet length check
729  //
730  if(len < sock_remained_size[sn]) pack_len = len;
731  else pack_len = sock_remained_size[sn];
732  wiz_recv_data(sn, buf, pack_len); // data copy.
733  break;
734  #endif
735  default:
736  wiz_recv_ignore(sn, pack_len); // data copy.
737  sock_remained_size[sn] = pack_len;
738  break;
739  }
740  setSn_CR(sn,Sn_CR_RECV);
741  /* wait to process the command... */
742  while(getSn_CR(sn)) ;
743  sock_remained_size[sn] -= pack_len;
744  //M20150601 :
745  //if(sock_remained_size[sn] != 0) sock_pack_info[sn] |= 0x01;
746  if(sock_remained_size[sn] != 0)
747  {
749  #if _WIZCHIP_ == 5300
750  if(pack_len & 0x01) sock_pack_info[sn] |= PACK_FIFOBYTE;
751  #endif
752  }
753  else sock_pack_info[sn] = PACK_COMPLETED;
754 #if _WIZCHIP_ == 5300
755  pack_len = len;
756 #endif
757  //
758  //M20150409 : Explicit Type Casting
759  //return pack_len;
760  return (int32_t)pack_len;
761 }
762 
763 
764 int8_t ctlsocket(uint8_t sn, ctlsock_type cstype, void* arg)
765 {
766  uint8_t tmp = 0;
767  CHECK_SOCKNUM();
768  switch(cstype)
769  {
770  case CS_SET_IOMODE:
771  tmp = *((uint8_t*)arg);
772  if(tmp == SOCK_IO_NONBLOCK) sock_io_mode |= (1<<sn);
773  else if(tmp == SOCK_IO_BLOCK) sock_io_mode &= ~(1<<sn);
774  else return SOCKERR_ARG;
775  break;
776  case CS_GET_IOMODE:
777  //M20140501 : implict type casting -> explict type casting
778  //*((uint8_t*)arg) = (sock_io_mode >> sn) & 0x0001;
779  *((uint8_t*)arg) = (uint8_t)((sock_io_mode >> sn) & 0x0001);
780  //
781  break;
782  case CS_GET_MAXTXBUF:
783  *((uint16_t*)arg) = getSn_TxMAX(sn);
784  break;
785  case CS_GET_MAXRXBUF:
786  *((uint16_t*)arg) = getSn_RxMAX(sn);
787  break;
788  case CS_CLR_INTERRUPT:
789  if( (*(uint8_t*)arg) > SIK_ALL) return SOCKERR_ARG;
790  setSn_IR(sn,*(uint8_t*)arg);
791  break;
792  case CS_GET_INTERRUPT:
793  *((uint8_t*)arg) = getSn_IR(sn);
794  break;
795  #if _WIZCHIP_ != 5100
796  case CS_SET_INTMASK:
797  if( (*(uint8_t*)arg) > SIK_ALL) return SOCKERR_ARG;
798  setSn_IMR(sn,*(uint8_t*)arg);
799  break;
800  case CS_GET_INTMASK:
801  *((uint8_t*)arg) = getSn_IMR(sn);
802  break;
803  #endif
804  default:
805  return SOCKERR_ARG;
806  }
807  return SOCK_OK;
808 }
809 
810 int8_t setsockopt(uint8_t sn, sockopt_type sotype, void* arg)
811 {
812  // M20131220 : Remove warning
813  //uint8_t tmp;
814  CHECK_SOCKNUM();
815  switch(sotype)
816  {
817  case SO_TTL:
818  setSn_TTL(sn,*(uint8_t*)arg);
819  break;
820  case SO_TOS:
821  setSn_TOS(sn,*(uint8_t*)arg);
822  break;
823  case SO_MSS:
824  setSn_MSSR(sn,*(uint16_t*)arg);
825  break;
826  case SO_DESTIP:
827  setSn_DIPR(sn, (uint8_t*)arg);
828  break;
829  case SO_DESTPORT:
830  setSn_DPORT(sn, *(uint16_t*)arg);
831  break;
832 #if _WIZCHIP_ != 5100
833  case SO_KEEPALIVESEND:
835  #if _WIZCHIP_ > 5200
836  if(getSn_KPALVTR(sn) != 0) return SOCKERR_SOCKOPT;
837  #endif
839  while(getSn_CR(sn) != 0)
840  {
841  // M20131220
842  //if ((tmp = getSn_IR(sn)) & Sn_IR_TIMEOUT)
843  if (getSn_IR(sn) & Sn_IR_TIMEOUT)
844  {
845  setSn_IR(sn, Sn_IR_TIMEOUT);
846  return SOCKERR_TIMEOUT;
847  }
848  }
849  break;
850  #if _WIZCHIP_ > 5200
851  case SO_KEEPALIVEAUTO:
853  setSn_KPALVTR(sn,*(uint8_t*)arg);
854  break;
855  #endif
856 #endif
857  default:
858  return SOCKERR_ARG;
859  }
860  return SOCK_OK;
861 }
862 
863 int8_t getsockopt(uint8_t sn, sockopt_type sotype, void* arg)
864 {
865  CHECK_SOCKNUM();
866  switch(sotype)
867  {
868  case SO_FLAG:
869  *(uint8_t*)arg = getSn_MR(sn) & 0xF0;
870  break;
871  case SO_TTL:
872  *(uint8_t*) arg = getSn_TTL(sn);
873  break;
874  case SO_TOS:
875  *(uint8_t*) arg = getSn_TOS(sn);
876  break;
877  case SO_MSS:
878  *(uint8_t*) arg = getSn_MSSR(sn);
879  break;
880  case SO_DESTIP:
881  getSn_DIPR(sn, (uint8_t*)arg);
882  break;
883  case SO_DESTPORT:
884  *(uint16_t*) arg = getSn_DPORT(sn);
885  break;
886  #if _WIZCHIP_ > 5200
887  case SO_KEEPALIVEAUTO:
889  *(uint16_t*) arg = getSn_KPALVTR(sn);
890  break;
891  #endif
892  case SO_SENDBUF:
893  *(uint16_t*) arg = getSn_TX_FSR(sn);
894  break;
895  case SO_RECVBUF:
896  *(uint16_t*) arg = getSn_RX_RSR(sn);
897  break;
898  case SO_STATUS:
899  *(uint8_t*) arg = getSn_SR(sn);
900  break;
901  case SO_REMAINSIZE:
902  if(getSn_MR(sn) == Sn_MR_TCP)
903  *(uint16_t*)arg = getSn_RX_RSR(sn);
904  else
905  *(uint16_t*)arg = sock_remained_size[sn];
906  break;
907  case SO_PACKINFO:
909  *(uint8_t*)arg = sock_pack_info[sn];
910  break;
911  default:
912  return SOCKERR_SOCKOPT;
913  }
914  return SOCK_OK;
915 }
Set/Get keep-alive auto transmission timer in TCP mode, Not supported in W5100, W5200.
Definition: socket.h:391
Valid only in getsockopt. Get the socket status. Sn_SR, getSn_SR()
Definition: socket.h:396
#define getSn_IR(sn)
Get Sn_IR register.
Definition: w5100.h:1417
#define PACK_COMPLETED
In Non-TCP packet, It indicates to complete to receive a packet. (When W5300, This flag can be applie...
Definition: socket.h:140
Set TTL. Sn_TTL ( setSn_TTL(), getSn_TTL() )
Definition: socket.h:383
int8_t ctlsocket(uint8_t sn, ctlsock_type cstype, void *arg)
Control socket.
Definition: socket.c:764
Valid only in getsockopt. Get the remained packet size in other then TCP mode.
Definition: socket.h:397
#define SOCKERR_SOCKMODE
Invalid socket mode for socket operation.
Definition: socket.h:101
void wiz_recv_ignore(uint8_t sn, uint16_t len)
It discard the received data in RX memory.
get the size of socket buffer allocated in TX memory
Definition: socket.h:365
#define SOCK_UDP
UDP socket.
Definition: w5100.h:982
#define getSIPR(sipr)
Get SIPR.
Definition: w5100.h:1195
uint16_t getSn_RX_RSR(uint8_t sn)
Get Sn_RX_RSR register.
#define SOCK_LISTEN
Listen state.
Definition: w5100.h:909
#define getSn_DIPR(sn, dipr)
Get Sn_DIPR register.
Definition: w5100.h:1488
#define SOCKERR_ARG
Invalid argument.
Definition: socket.h:104
#define setSn_MSSR(sn, mss)
Set Sn_MSSR register.
Definition: w5100.h:1520
#define setSn_TTL(sn, ttl)
Set Sn_TTL register.
Definition: w5100.h:1582
#define Sn_MR_PPPoE
PPPoE.
Definition: w5100.h:669
#define SOCK_OK
Result is OK about socket process.
Definition: socket.h:92
#define PACK_FIFOBYTE
Valid only W5300, It indicate to have read already the Sn_RX_FIFOR.
Definition: socket.h:142
#define SOCK_BUSY
Socket is busy on processing the operation. Valid only Non-block IO Mode.
Definition: socket.h:93
#define SF_MULTI_ENABLE
In Sn_MR_UDP, Enable multicast mode.
Definition: socket.h:119
#define setSn_IR(sn, ir)
Set Sn_IR register.
Definition: w5100.h:1407
#define SOCKERR_SOCKOPT
Invalid socket option.
Definition: socket.h:98
#define getSn_TTL(sn)
Get Sn_TTL register.
Definition: w5100.h:1592
#define SF_TCP_NODELAY
In Sn_MR_TCP, Use to nodelayed ack.
Definition: socket.h:118
#define getSn_TxMAX(sn)
Get the max TX buffer size of socket sn.
Definition: w5100.h:1768
#define SOCKERR_TIMEOUT
Timeout occurred.
Definition: socket.h:107
void wiz_recv_data(uint8_t sn, uint8_t *wizdata, uint16_t len)
It copies data to your buffer from internal RX memory.
#define setSn_MR(sn, mr)
Set Sn_MR register.
Definition: w5100.h:1367
#define Sn_CR_LISTEN
Wait connection request in TCP mode(Server mode)
Definition: w5100.h:741
void wiz_send_data(uint8_t sn, uint8_t *wizdata, uint16_t len)
It copies data to internal TX memory.
#define Sn_CR_CONNECT
Send connection request in TCP mode(Client mode)
Definition: w5100.h:753
#define getSn_CR(sn)
Get Sn_CR register.
Definition: w5100.h:1397
Valid only in setsockopt. Manually send keep-alive packet in TCP mode, Not supported in W5100...
Definition: socket.h:389
int8_t getsockopt(uint8_t sn, sockopt_type sotype, void *arg)
get socket options
Definition: socket.c:863
#define Sn_MR_MACRAW
MAC LAYER RAW SOCK.
Definition: w5100.h:662
uint16_t getSn_TX_FSR(uint8_t sn)
Get Sn_TX_FSR register.
#define Sn_CR_SEND_KEEP
Send keep alive message.
Definition: w5100.h:798
#define getSn_TX_RD(sn)
Get Sn_TX_RD register.
Definition: w5100.h:1653
#define SOCK_MACRAW
MAC raw mode socket.
Definition: w5100.h:998
ctlsock_type
The type of ctlsocket().
Definition: socket.h:361
#define SOCKFATAL_PACKLEN
Invalid packet length. Fatal Error.
Definition: socket.h:111
#define MR_FS
Definition: w5300.h:893
#define Sn_MR_TCP
TCP.
Definition: w5100.h:648
#define Sn_CR_DISCON
Send closing request in TCP mode.
Definition: w5100.h:766
int8_t close(uint8_t sn)
Close a socket.
Definition: socket.c:197
Set MSS. Sn_MSSR ( setSn_MSSR(), getSn_MSSR() )
Definition: socket.h:385
#define PACK_FIRST
In Non-TCP packet, It indicates to start receiving a packet. (When W5300, This flag can be applied) ...
Definition: socket.h:138
get the masked interrupt of socket. refer to sockint_kind, Not supported in W5100 ...
Definition: socket.h:371
all interrupt
Definition: socket.h:354
get the socket interrupt. refer to sockint_kind
Definition: socket.h:368
#define Sn_CR_CLOSE
Close socket.
Definition: w5100.h:772
#define PACK_REMAINED
In Non-TCP packet, It indicates to remain a packet to be received. (When W5300, This flag can be appl...
Definition: socket.h:139
#define getSn_RxMAX(sn)
Get the max RX buffer size of socket sn.
Definition: w5100.h:1758
#define SF_IO_NONBLOCK
Socket nonblock io mode. It used parameter in socket().
Definition: socket.h:133
#define SOCK_CLOSED
Closed.
Definition: w5100.h:893
#define Sn_MR_UDP
UDP.
Definition: w5100.h:654
#define SOCK_ANY_PORT_NUM
Definition: socket.c:60
#define SOCKERR_SOCKCLOSED
Socket unexpectedly closed.
Definition: socket.h:100
#define setSn_TX_WRSR(sn, txwrs)
Set Sn_TX_WRSR register.
Definition: w5300.h:2144
#define setSUBR(subr)
Set SUBR.
Definition: w5100.h:1150
int32_t recv(uint8_t sn, uint8_t *buf, uint16_t len)
Receive data from the connected peer.
Definition: socket.c:387
Valid only in getsockopt. Get the free data size of Socekt TX buffer. Sn_TX_FSR, getSn_TX_FSR() ...
Definition: socket.h:394
#define SOCKERR_SOCKINIT
Socket is not initialized or SIPR is Zero IP address when Sn_MR_TCP.
Definition: socket.h:99
#define SF_UNI_BLOCK
In Sn_MR_UDP with SF_MULTI_ENABLE. Valid only in W5500.
Definition: socket.h:125
#define getSn_MSSR(sn)
Get Sn_MSSR register.
Definition: w5100.h:1532
#define setSn_IMR(sn, imr)
Set Sn_IMR register.
Definition: w5200.h:1963
#define getMR()
Get MR.
Definition: w5100.h:1120
uint8_t sock_pack_info[_WIZCHIP_SOCK_NUM_]
Definition: socket.c:70
#define getSn_DPORT(sn)
Get Sn_DPORT register.
Definition: w5100.h:1510
Set the destination Port number. Sn_DPORT ( setSn_DPORT(), getSn_DPORT() )
Definition: socket.h:387
#define Sn_IR_SENDOK
SEND_OK Interrupt.
Definition: w5100.h:861
clear the interrupt of socket with sockint_kind
Definition: socket.h:367
#define getSn_SR(sn)
Get Sn_SR register.
Definition: w5100.h:1426
#define SOCK_IO_BLOCK
Socket Block IO Mode in setsockopt().
Definition: socket.h:333
Valid only in getsockopt(), For set flag of socket refer to flag in socket().
Definition: socket.h:382
Set TOS. Sn_TOS ( setSn_TOS(), getSn_TOS() )
Definition: socket.h:384
sockopt_type
The type of socket option in setsockopt() or getsockopt()
Definition: socket.h:380
#define Sn_MR_IPRAW
IP LAYER RAW SOCK.
Definition: w5100.h:655
#define setSn_TOS(sn, tos)
Set Sn_TOS register.
Definition: w5100.h:1562
int32_t sendto(uint8_t sn, uint8_t *buf, uint16_t len, uint8_t *addr, uint16_t port)
Sends datagram to the peer with destination IP address and port number passed as parameter.
Definition: socket.c:492
set socket IO mode with SOCK_IO_BLOCK or SOCK_IO_NONBLOCK
Definition: socket.h:363
#define setSn_KPALVTR(sn, kpalvt)
Set Sn_KPALVTR register.
Definition: w5300.h:2102
int8_t setsockopt(uint8_t sn, sockopt_type sotype, void *arg)
set socket options
Definition: socket.c:810
#define SOCK_CLOSE_WAIT
Closing state.
Definition: w5100.h:967
int8_t socket(uint8_t sn, uint8_t protocol, uint16_t port, uint8_t flag)
Open a socket.
Definition: socket.c:105
int8_t disconnect(uint8_t sn)
Try to disconnect a connection socket.
Definition: socket.c:299
#define setSn_DIPR(sn, dipr)
Set Sn_DIPR register.
Definition: w5100.h:1478
#define getSn_KPALVTR(sn)
Get Sn_KPALVTR register.
Definition: w5300.h:2112
#define getSUBR(subr)
Get SUBR.
Definition: w5100.h:1159
#define getSn_TOS(sn)
Get Sn_TOS register.
Definition: w5100.h:1572
#define SOCKERR_SOCKSTATUS
Invalid socket status for socket operation.
Definition: socket.h:103
int32_t recvfrom(uint8_t sn, uint8_t *buf, uint16_t len, uint8_t *addr, uint16_t *port)
Receive datagram of UDP or MACRAW.
Definition: socket.c:588
Valid only in getsockopt. Get the packet information as PACK_FIRST, PACK_REMAINED, and PACK_COMPLETED in other then TCP mode.
Definition: socket.h:398
set the interrupt mask of socket with sockint_kind, Not supported in W5100
Definition: socket.h:370
#define SOCKERR_IPINVALID
Invalid IP address.
Definition: socket.h:106
#define CHECK_SOCKMODE(mode)
Definition: socket.c:88
#define getSn_IMR(sn)
Get Sn_IMR register.
Definition: w5200.h:1973
#define CHECK_SOCKINIT()
Definition: socket.c:93
int8_t listen(uint8_t sn)
Listen to a connection request from a client.
Definition: socket.c:240
#define Sn_MR_ALIGN
Alignment bit of Sn_MR.
Definition: w5300.h:929
#define Sn_CR_RECV
Update RX buffer pointer and receive data.
Definition: w5100.h:806
#define setSn_CR(sn, cr)
Set Sn_CR register.
Definition: w5100.h:1387
get the size of socket buffer allocated in RX memory
Definition: socket.h:366
#define SOCKERR_SOCKFLAG
Invalid socket flag.
Definition: socket.h:102
#define getSn_MR(sn)
Get Sn_MR register.
Definition: w5100.h:1377
#define _WIZCHIP_SOCK_NUM_
The count of independant socket of WIZCHIP.
Definition: wizchip_conf.h:188
#define setSn_PORT(sn, port)
Set Sn_PORT register.
Definition: w5100.h:1436
Valid only in getsockopt. Get the received data size in socket RX buffer. Sn_RX_RSR, getSn_RX_RSR()
Definition: socket.h:395
#define setSn_DPORT(sn, dport)
Set Sn_DPORT register.
Definition: w5100.h:1498
#define Sn_CR_SEND
Update TX buffer pointer and send data.
Definition: w5100.h:780
#define SF_IGMP_VER2
In Sn_MR_UDP with SF_MULTI_ENABLE, Select IGMP version 2.
Definition: socket.h:117
#define Sn_IR_TIMEOUT
TIMEOUT Interrupt.
Definition: w5100.h:867
int8_t connect(uint8_t sn, uint8_t *addr, uint16_t port)
Try to connect a server.
Definition: socket.c:259
#define SOCK_IO_NONBLOCK
Socket Non-block IO Mode in setsockopt().
Definition: socket.h:334
#define SOCKERR_PORTZERO
Port number is zero.
Definition: socket.h:105
#define CHECK_SOCKNUM()
Definition: socket.c:83
SOCKET APIs Header file.
get socket IO mode
Definition: socket.h:364
#define Sn_CR_OPEN
Initialize or open socket.
Definition: w5100.h:730
#define setSn_PORTR(sn, port)
Set Sn_PORTR register.
Definition: w5300.h:1980
#define CHECK_SOCKDATA()
Definition: socket.c:98
#define SOCK_ESTABLISHED
Success to connect.
Definition: w5100.h:935
int32_t send(uint8_t sn, uint8_t *buf, uint16_t len)
Send data to the connected peer in TCP socket.
Definition: socket.c:319
Set the destination IP address. Sn_DIPR ( setSn_DIPR(), getSn_DIPR() )
Definition: socket.h:386
Generated on Wed May 4 2016 16:43:58 for Socket APIs by   doxygen 1.8.9.1