W5500
w5500.c
Go to the documentation of this file.
1 //*****************************************************************************
2 //
39 //
40 //*****************************************************************************
41 #include <stdio.h>
42 #include "w5500.h"
43 
44 
45 #define _W5500_SPI_VDM_OP_ 0x00
46 #define _W5500_SPI_FDM_OP_LEN1_ 0x01
47 #define _W5500_SPI_FDM_OP_LEN2_ 0x02
48 #define _W5500_SPI_FDM_OP_LEN4_ 0x03
49 
51 {
53 }
54 
56 {
57  WIZCHIP.CRIS._exit();
58 }
59 
60 uint8_t WIZCHIP_READ(uint32_t AddrSel)
61 {
62  uint8_t ret;
63 
65  WIZCHIP.CS._select();
66 
67 #if( (_WIZCHIP_IO_MODE_ & _WIZCHIP_IO_MODE_SPI_))
68 
69  #if ( _WIZCHIP_IO_MODE_ == _WIZCHIP_IO_MODE_SPI_VDM_ )
70  AddrSel |= (_W5500_SPI_READ_ | _W5500_SPI_VDM_OP_);
71  #elif( _WIZCHIP_IO_MODE_ == _WIZCHIP_IO_MODE_SPI_FDM_ )
73  #else
74  #error "Unsupported _WIZCHIP_IO_SPI_ in W5500 !!!"
75  #endif
76 
77  WIZCHIP.IF.SPI._write_byte((AddrSel & 0x00FF0000) >> 16);
78  WIZCHIP.IF.SPI._write_byte((AddrSel & 0x0000FF00) >> 8);
79  WIZCHIP.IF.SPI._write_byte((AddrSel & 0x000000FF) >> 0);
80  ret = WIZCHIP.IF.SPI._read_byte();
81 
82 #elif ( (_WIZCHIP_IO_MODE_ & _WIZCHIP_IO_MODE_BUS_) )
83 
84  #if (_WIZCHIP_IO_MODE_ == _WIZCHIP_IO_MODE_BUS_DIR_)
85 
86  #elif(_WIZCHIP_IO_MODE_ == _WIZCHIP_IO_MODE_BUS_INDIR_)
87 
88  #else
89  #error "Unsupported _WIZCHIP_IO_MODE_BUS_ in W5500 !!!"
90  #endif
91 #else
92  #error "Unknown _WIZCHIP_IO_MODE_ in W5000. !!!"
93 #endif
94 
97  return ret;
98 }
99 
100 void WIZCHIP_WRITE(uint32_t AddrSel, uint8_t wb )
101 {
103  WIZCHIP.CS._select();
104 
105 #if( (_WIZCHIP_IO_MODE_ & _WIZCHIP_IO_MODE_SPI_))
106 
107  #if ( _WIZCHIP_IO_MODE_ == _WIZCHIP_IO_MODE_SPI_VDM_ )
108  AddrSel |= (_W5500_SPI_WRITE_ | _W5500_SPI_VDM_OP_);
109  #elif( _WIZCHIP_IO_MODE_ == _WIZCHIP_IO_MODE_SPI_FDM_ )
111  #else
112  #error "Unsupported _WIZCHIP_IO_SPI_ in W5500 !!!"
113  #endif
114 
115  WIZCHIP.IF.SPI._write_byte((AddrSel & 0x00FF0000) >> 16);
116  WIZCHIP.IF.SPI._write_byte((AddrSel & 0x0000FF00) >> 8);
117  WIZCHIP.IF.SPI._write_byte((AddrSel & 0x000000FF) >> 0);
118  WIZCHIP.IF.SPI._write_byte(wb);
119 
120 #elif ( (_WIZCHIP_IO_MODE_ & _WIZCHIP_IO_MODE_BUS_) )
121 
122  #if (_WIZCHIP_IO_MODE_ == _WIZCHIP_IO_MODE_BUS_DIR_)
123 
124  #elif(_WIZCHIP_IO_MODE_ == _WIZCHIP_IO_MODE_BUS_INDIR_)
125 
126  #else
127  #error "Unsupported _WIZCHIP_IO_MODE_BUS_ in W5500 !!!"
128  #endif
129 #else
130  #error "Unknown _WIZCHIP_IO_MODE_ in W5500. !!!"
131 #endif
132 
133  WIZCHIP.CS._deselect();
135 }
136 
137 void WIZCHIP_READ_BUF (uint32_t AddrSel, uint8_t* pBuf, uint16_t len)
138 {
139  uint16_t i = 0;
140  uint16_t j = 0;
142  WIZCHIP.CS._select();
143 
144 #if( (_WIZCHIP_IO_MODE_ & _WIZCHIP_IO_MODE_SPI_))
145 
146  #if ( _WIZCHIP_IO_MODE_ == _WIZCHIP_IO_MODE_SPI_VDM_ )
147  AddrSel |= (_W5500_SPI_READ_ | _W5500_SPI_VDM_OP_);
148  WIZCHIP.IF.SPI._write_byte((AddrSel & 0x00FF0000) >> 16);
149  WIZCHIP.IF.SPI._write_byte((AddrSel & 0x0000FF00) >> 8);
150  WIZCHIP.IF.SPI._write_byte((AddrSel & 0x000000FF) >> 0);
151  for(i = 0; i < len; i++)
152  pBuf[i] = WIZCHIP.IF.SPI._read_byte();
153  #elif( _WIZCHIP_IO_MODE_ == _WIZCHIP_IO_MODE_SPI_FDM_ )
155  for(i = 0; i < len/4; i++)
156  {
157  WIZCHIP.IF.SPI._write_byte((AddrSel & 0x00FF0000) >> 16);
158  WIZCHIP.IF.SPI._write_byte((AddrSel & 0x0000FF00) >> 8);
159  WIZCHIP.IF.SPI._write_byte((AddrSel & 0x000000FF) >> 0);
160  pBuf[i*4] = WIZCHIP.IF.SPI._read_byte();
161  pBuf[i*4+1] = WIZCHIP.IF.SPI._read_byte();
162  pBuf[i*4+2] = WIZCHIP.IF.SPI._read_byte();
163  pBuf[i*4+3] = WIZCHIP.IF.SPI._read_byte();
164  //AddrSel += (4 << 8); // offset address + 4
165  AddrSel = WIZCHIP_OFFSET_INC(AddrSel,4);
166  }
167  len %= 4; // for the rest data
168  if(len)
169  {
170  AddrSel -= 1; // change _W5500_SPI_FDM_OP_LEN4_ to _W5500_SPI_FDM_OP_LEN2_
171  i *= 4;
172  for(j = 0; j < len/2 ; j++)
173  {
174  WIZCHIP.IF.SPI._write_byte((AddrSel & 0x00FF0000) >> 16);
175  WIZCHIP.IF.SPI._write_byte((AddrSel & 0x0000FF00) >> 8);
176  WIZCHIP.IF.SPI._write_byte((AddrSel & 0x000000FF) >> 0);
177  pBuf[i] = WIZCHIP.IF.SPI._read_byte();
178  pBuf[i+1] = WIZCHIP.IF.SPI._read_byte();
179  i += 2;
180  //AddrSel += (2 << 8); // offset address + 2
181  AddrSel = WIZCHIP_OFFSET_INC(AddrSel,2);
182  }
183  len %= 2;
184  if(len)
185  {
186  AddrSel -= 1; // change _W5500_SPI_FDM_OP_LEN2_ to _W5500_SPI_FDM_OP_LEN1_
187  WIZCHIP.IF.SPI._write_byte((AddrSel & 0x00FF0000) >> 16);
188  WIZCHIP.IF.SPI._write_byte((AddrSel & 0x0000FF00) >> 8);
189  WIZCHIP.IF.SPI._write_byte((AddrSel & 0x000000FF) >> 0);
190  pBuf[i] = WIZCHIP.IF.SPI._read_byte();
191  }
192  }
193  #else
194  #error "Unsupported _WIZCHIP_IO_SPI_ in W5500 !!!"
195  #endif
196 
197 #elif ( (_WIZCHIP_IO_MODE_ & _WIZCHIP_IO_MODE_BUS_) )
198 
199  #if (_WIZCHIP_IO_MODE_ == _WIZCHIP_IO_MODE_BUS_DIR_)
200 
201  #elif(_WIZCHIP_IO_MODE_ == _WIZCHIP_IO_MODE_BUS_INDIR_)
202 
203  #else
204  #error "Unsupported _WIZCHIP_IO_MODE_BUS_ in W5500 !!!"
205  #endif
206 #else
207  #error "Unknown _WIZCHIP_IO_MODE_ in W5500. !!!!"
208 #endif
209 
210  WIZCHIP.CS._deselect();
212 }
213 
214 void WIZCHIP_WRITE_BUF(uint32_t AddrSel, uint8_t* pBuf, uint16_t len)
215 {
216  uint16_t i = 0;
217  uint16_t j = 0;
219  WIZCHIP.CS._select();
220 
221 #if( (_WIZCHIP_IO_MODE_ & _WIZCHIP_IO_MODE_SPI_))
222 
223  #if ( _WIZCHIP_IO_MODE_ == _WIZCHIP_IO_MODE_SPI_VDM_ )
224  AddrSel |= (_W5500_SPI_WRITE_ | _W5500_SPI_VDM_OP_);
225  WIZCHIP.IF.SPI._write_byte((AddrSel & 0x00FF0000) >> 16);
226  WIZCHIP.IF.SPI._write_byte((AddrSel & 0x0000FF00) >> 8);
227  WIZCHIP.IF.SPI._write_byte((AddrSel & 0x000000FF) >> 0);
228  for(i = 0; i < len; i++)
229  WIZCHIP.IF.SPI._write_byte(pBuf[i]);
230  #elif( _WIZCHIP_IO_MODE_ == _WIZCHIP_IO_MODE_SPI_FDM_ )
232  for(i = 0; i < len/4; i++)
233  {
234  WIZCHIP.IF.SPI._write_byte((AddrSel & 0x00FF0000) >> 16);
235  WIZCHIP.IF.SPI._write_byte((AddrSel & 0x0000FF00) >> 8);
236  WIZCHIP.IF.SPI._write_byte((AddrSel & 0x000000FF) >> 0);
237  WIZCHIP.IF.SPI._write_byte(pBuf[i*4] );
238  WIZCHIP.IF.SPI._write_byte(pBuf[i*4+1]);
239  WIZCHIP.IF.SPI._write_byte(pBuf[i*4+2]);
240  WIZCHIP.IF.SPI._write_byte(pBuf[i*4+3]);
241  //AddrSel += (4 << 8); // offset address + 4
242  AddrSel = WIZCHIP_OFFSET_INC(AddrSel,4);
243  }
244  len %= 4; // for the rest data
245  if(len)
246  {
247  AddrSel -= 1; // change _W5500_SPI_FDM_OP_LEN4_ to _W5500_SPI_FDM_OP_LEN2_
248  i *= 4;
249  for(j = 0; j < len/2 ; j++)
250  {
251  WIZCHIP.IF.SPI._write_byte((AddrSel & 0x00FF0000) >> 16);
252  WIZCHIP.IF.SPI._write_byte((AddrSel & 0x0000FF00) >> 8);
253  WIZCHIP.IF.SPI._write_byte((AddrSel & 0x000000FF) >> 0);
254  WIZCHIP.IF.SPI._write_byte(pBuf[i] );
255  WIZCHIP.IF.SPI._write_byte(pBuf[i+1]);
256  i += 2;
257  //AddrSel += (2 << 8); // offset address + 2
258  AddrSel = WIZCHIP_OFFSET_INC(AddrSel, 2);
259  }
260  len %= 2;
261  if(len)
262  {
263  AddrSel -= 1; // change _W5500_SPI_FDM_OP_LEN2_ to _W5500_SPI_FDM_OP_LEN1_
264  WIZCHIP.IF.SPI._write_byte((AddrSel & 0x00FF0000) >> 16);
265  WIZCHIP.IF.SPI._write_byte((AddrSel & 0x0000FF00) >> 8);
266  WIZCHIP.IF.SPI._write_byte((AddrSel & 0x000000FF) >> 0);
267  WIZCHIP.IF.SPI._write_byte(pBuf[i]);
268  }
269  }
270  #else
271  #error "Unsupported _WIZCHIP_IO_SPI_ in W5500 !!!"
272  #endif
273 
274 #elif ( (_WIZCHIP_IO_MODE_ & _WIZCHIP_IO_MODE_BUS_) )
275 
276  #if (_WIZCHIP_IO_MODE_ == _WIZCHIP_IO_MODE_BUS_DIR_)
277 
278  #elif(_WIZCHIP_IO_MODE_ == _WIZCHIP_IO_MODE_BUS_INDIR_)
279 
280  #else
281  #error "Unsupported _WIZCHIP_IO_MODE_BUS_ in W5500 !!!"
282  #endif
283 #else
284  #error "Unknown _WIZCHIP_IO_MODE_ in W5500. !!!!"
285 #endif
286 
287  WIZCHIP.CS._deselect();
289 }
290 
291 
293 // Common Register IO function //
295 
296 void setMR(uint8_t mr)
297 {
298  WIZCHIP_WRITE(MR,mr);
299 }
300 
301 uint8_t getMR(void)
302 {
303  return WIZCHIP_READ(MR);
304 }
305 
306 void setGAR(uint8_t* gar)
307 {
308  WIZCHIP_WRITE_BUF(GAR,gar,4);
309 }
310 
311 void getGAR(uint8_t* gar)
312 {
313  WIZCHIP_READ_BUF(GAR,gar,4);
314 }
315 
316 void setSUBR(uint8_t * subr)
317 {
318  WIZCHIP_WRITE_BUF(SUBR, subr,4);
319 }
320 
321 void getSUBR(uint8_t * subr)
322 {
323  WIZCHIP_READ_BUF(SUBR, subr, 4);
324 }
325 
326 void setSHAR(uint8_t * shar)
327 {
328  WIZCHIP_WRITE_BUF(SHAR, shar, 6);
329 }
330 
331 void getSHAR(uint8_t * shar)
332 {
333  WIZCHIP_READ_BUF(SHAR, shar, 6);
334 }
335 
336 void setSIPR(uint8_t * sipr)
337 {
338  WIZCHIP_WRITE_BUF(SIPR, sipr, 4);
339 }
340 
341 void getSIPR(uint8_t * sipr)
342 {
343  WIZCHIP_READ_BUF(SIPR, sipr, 4);
344 }
345 
346 void setINTLEVEL(uint16_t intlevel)
347 {
348  WIZCHIP_WRITE(INTLEVEL, (uint8_t)(intlevel >> 8));
349  WIZCHIP_WRITE(WIZCHIP_OFFSET_INC(INTLEVEL,1), (uint8_t) intlevel);
350 }
351 
352 uint16_t getINTLEVEL(void)
353 {
354  uint16_t intlv = 0;
355  intlv = WIZCHIP_READ(INTLEVEL);
356  intlv = (intlv << 8) + WIZCHIP_READ(WIZCHIP_OFFSET_INC(INTLEVEL,1));
357  return intlv;
358 }
359 
360 void setIR(uint8_t ir)
361 {
362  WIZCHIP_WRITE(IR, (ir & 0xF0));
363 }
364 
365 uint8_t getIR(void)
366 {
367  return (WIZCHIP_READ(IR) & 0xF0);
368 }
369 
370 void setIMR(uint8_t imr)
371 {
372  WIZCHIP_WRITE(IMR, imr);
373 }
374 
375 uint8_t getIMR(void)
376 {
377  return WIZCHIP_READ(IMR);
378 }
379 
380 void setSIR(uint8_t sir)
381 {
382  WIZCHIP_WRITE(SIR, sir);
383 }
384 
385 uint8_t getSIR(void)
386 {
387  return WIZCHIP_READ(SIR);
388 }
389 
390 void setSIMR(uint8_t simr)
391 {
392  WIZCHIP_WRITE(SIMR, simr);
393 }
394 
395 uint8_t getSIMR(void)
396 {
397  return WIZCHIP_READ(SIMR);
398 }
399 
400 void setRTR(uint16_t rtr)
401 {
402  WIZCHIP_WRITE(RTR, (uint8_t)(rtr >> 8));
403  WIZCHIP_WRITE(WIZCHIP_OFFSET_INC(RTR,1), (uint8_t) rtr);
404 }
405 
406 uint16_t getRTR(void)
407 {
408  uint16_t rtr;
409  rtr = WIZCHIP_READ(RTR);
410  rtr = (rtr << 8) + WIZCHIP_READ(WIZCHIP_OFFSET_INC(RTR,1));
411  return rtr;
412 }
413 
414 void setRCR(uint8_t rcr)
415 {
416  WIZCHIP_WRITE(RCR, rcr);
417 }
418 
419 uint8_t getRCR(void)
420 {
421  return WIZCHIP_READ(RCR);
422 }
423 
424 void setPTIMER(uint8_t ptimer)
425 {
426  WIZCHIP_WRITE(PTIMER, ptimer);
427 }
428 
429 uint8_t getPTIMER(void)
430 {
431  return WIZCHIP_READ(PTIMER);
432 }
433 
434 void setPMAGIC(uint8_t pmagic)
435 {
436  WIZCHIP_WRITE(PMAGIC, pmagic);
437 }
438 
439 uint8_t getPMAGIC(void)
440 {
441  return WIZCHIP_READ(PMAGIC);
442 }
443 
444 void setPHAR(uint8_t* phar)
445 {
446  WIZCHIP_WRITE_BUF(PHAR, phar, 6);
447 }
448 
449 void getPHAR(uint8_t* phar)
450 {
451  WIZCHIP_READ_BUF(PHAR, phar, 6);
452 }
453 
454 void setPSID(uint16_t psid)
455 {
456  WIZCHIP_WRITE(PSID, (uint8_t)(psid >> 8));
457  WIZCHIP_WRITE(WIZCHIP_OFFSET_INC(PSID,1), (uint8_t) psid);
458 }
459 
460 uint16_t getPSID(void)
461 {
462  uint16_t psid;
463  psid = WIZCHIP_READ(PSID);
464  psid = (psid << 8) + WIZCHIP_READ(WIZCHIP_OFFSET_INC(PSID,1));
465  return psid;
466 }
467 
468 void setPMRU(uint16_t pmru)
469 {
470  WIZCHIP_WRITE(PMRU, (uint8_t)(pmru>>8));
471  WIZCHIP_WRITE(WIZCHIP_OFFSET_INC(PMRU,1), (uint8_t) pmru);
472 }
473 
474 uint16_t getPMRU(void)
475 {
476  uint16_t pmru;
477  pmru = WIZCHIP_READ(PMRU);
478  pmru = (pmru << 8) + WIZCHIP_READ(WIZCHIP_OFFSET_INC(PMRU,1));
479  return pmru;
480 }
481 
482 //
483 void getUIPR(uint8_t* uipr)
484 {
485  WIZCHIP_READ_BUF(UIPR,uipr,6);
486 }
487 
488 uint16_t getUPORTR(void)
489 {
490  uint16_t uportr;
491  uportr = WIZCHIP_READ(UPORTR);
492  uportr = (uportr << 8) + WIZCHIP_READ(WIZCHIP_OFFSET_INC(UPORTR,1));
493  return uportr;
494 }
495 void setPHYCFGR(uint8_t phycfgr)
496 {
497  WIZCHIP_WRITE(PHYCFGR, phycfgr);
498 }
499 
500 uint8_t getPHYCFGR(void)
501 {
502  return WIZCHIP_READ(PHYCFGR);
503 }
504 
505 uint8_t getVERSIONR(void)
506 {
507  return WIZCHIP_READ(VERSIONR);
508 }
510 
512 // Socket N regsiter IO function //
514 void setSn_MR(uint8_t sn, uint8_t mr)
515 {
516  WIZCHIP_WRITE(Sn_MR(sn),mr);
517 }
518 
519 uint8_t getSn_MR(uint8_t sn)
520 {
521  return WIZCHIP_READ(Sn_MR(sn));
522 }
523 
524 void setSn_CR(uint8_t sn, uint8_t cr)
525 {
526  WIZCHIP_WRITE(Sn_CR(sn), cr);
527 }
528 
529 uint8_t getSn_CR(uint8_t sn)
530 {
531  return WIZCHIP_READ(Sn_CR(sn));
532 }
533 
534 void setSn_IR(uint8_t sn, uint8_t ir)
535 {
536  WIZCHIP_WRITE(Sn_IR(sn), ir);
537 }
538 
539 uint8_t getSn_IR(uint8_t sn)
540 {
541  return WIZCHIP_READ(Sn_IR(sn));
542 }
543 
544 void setSn_IMR(uint8_t sn, uint8_t imr)
545 {
546  WIZCHIP_WRITE(Sn_IMR(sn), (imr & 0xF0));
547 }
548 
549 uint8_t getSn_IMR(uint8_t sn)
550 {
551  return (WIZCHIP_READ(Sn_IMR(sn)) & 0xF0);
552 }
553 
554 //
555 uint8_t getSn_SR(uint8_t sn)
556 {
557  return WIZCHIP_READ(Sn_SR(sn));
558 }
559 
560 void setSn_PORT(uint8_t sn, uint16_t port)
561 {
562  WIZCHIP_WRITE(Sn_PORT(sn), (uint8_t)(port >> 8));
563  WIZCHIP_WRITE(WIZCHIP_OFFSET_INC(Sn_PORT(sn),1), (uint8_t) port);
564 }
565 
566 uint16_t getSn_PORT(uint8_t sn)
567 {
568  uint16_t port;
569  port = WIZCHIP_READ(Sn_PORT(sn));
570  port = (port << 8) + WIZCHIP_READ(WIZCHIP_OFFSET_INC(Sn_PORT(sn),1));
571  return port;
572 }
573 
574 void setSn_DHAR(uint8_t sn, uint8_t* dhar)
575 {
576  WIZCHIP_WRITE_BUF(Sn_DHAR(sn), dhar, 6);
577 }
578 
579 void getSn_DHAR(uint8_t sn, uint8_t* dhar)
580 {
581  WIZCHIP_READ_BUF(Sn_DHAR(sn), dhar, 6);
582 }
583 
584 void setSn_DIPR(uint8_t sn, uint8_t* dipr)
585 {
586  WIZCHIP_WRITE_BUF(Sn_DIPR(sn), dipr, 4);
587 }
588 
589 void getSn_DIPR(uint8_t sn, uint8_t* dipr)
590 {
591  WIZCHIP_READ_BUF(Sn_DIPR(sn), dipr, 4);
592 }
593 
594 void setSn_DPORT(uint8_t sn, uint16_t dport)
595 {
596  WIZCHIP_WRITE(Sn_DPORT(sn), (uint8_t) (dport>>8));
597  WIZCHIP_WRITE(WIZCHIP_OFFSET_INC(Sn_DPORT(sn),1), (uint8_t) dport);
598 }
599 
600 uint16_t getSn_DPORT(uint8_t sn)
601 {
602  uint16_t port;
603  port = WIZCHIP_READ(Sn_DPORT(sn));
604  port = (port<<8) + WIZCHIP_READ(WIZCHIP_OFFSET_INC(Sn_DPORT(sn),1));
605  return port;
606 }
607 
608 void setSn_MSSR(uint8_t sn, uint16_t mss)
609 {
610  WIZCHIP_WRITE(Sn_MSSR(sn), (uint8_t)(mss>>8));
611  WIZCHIP_WRITE(WIZCHIP_OFFSET_INC(Sn_MSSR(sn),1), (uint8_t) mss);
612 }
613 
614 uint16_t getSn_MSSR(uint8_t sn)
615 {
616  uint16_t mss;
617  mss = WIZCHIP_READ(Sn_MSSR(sn));
618  mss = (mss << 8) + WIZCHIP_READ(WIZCHIP_OFFSET_INC(Sn_MSSR(sn),1));
619  return mss;
620 }
621 
622 void setSn_TOS(uint8_t sn, uint8_t tos)
623 {
624  WIZCHIP_WRITE(Sn_TOS(sn), tos);
625 }
626 
627 uint8_t getSn_TOS(uint8_t sn)
628 {
629  return WIZCHIP_READ(Sn_TOS(sn));
630 }
631 
632 
633 void setSn_TTL(uint8_t sn, uint8_t ttl)
634 {
635  WIZCHIP_WRITE(Sn_TTL(sn), ttl);
636 }
637 
638 uint8_t getSn_TTL(uint8_t sn)
639 {
640  return WIZCHIP_READ(Sn_TTL(sn));
641 }
642 
643 void setSn_RXBUF_SIZE(uint8_t sn, uint8_t rxbufsize)
644 {
645  WIZCHIP_WRITE(Sn_RXBUF_SIZE(sn),rxbufsize);
646 }
647 
648 uint8_t getSn_RXBUF_SIZE(uint8_t sn)
649 {
650  return WIZCHIP_READ(Sn_RXBUF_SIZE(sn));
651 }
652 
653 void setSn_TXBUF_SIZE(uint8_t sn, uint8_t txbufsize)
654 {
655  WIZCHIP_WRITE(Sn_TXBUF_SIZE(sn), txbufsize);
656 }
657 
658 uint8_t getSn_TXBUF_SIZE(uint8_t sn)
659 {
660  return WIZCHIP_READ(Sn_TXBUF_SIZE(sn));
661 }
662 
663 //
664 uint16_t getSn_TX_FSR(uint8_t sn)
665 {
666  uint16_t val=0,val1=0;
667  do
668  {
669  val1 = WIZCHIP_READ(Sn_TX_FSR(sn));
670  val1 = (val1 << 8) + WIZCHIP_READ(WIZCHIP_OFFSET_INC(Sn_TX_FSR(sn),1));
671  if (val1 != 0)
672  {
673  val = WIZCHIP_READ(Sn_TX_FSR(sn));
674  val = (val << 8) + WIZCHIP_READ(WIZCHIP_OFFSET_INC(Sn_TX_FSR(sn),1));
675  }
676  }while (val != val1);
677  return val;
678 }
679 
680 //
681 uint16_t getSn_TX_RD(uint8_t sn)
682 {
683  uint16_t txrd;
684  txrd = WIZCHIP_READ(Sn_TX_RD(sn));
685  txrd = (txrd << 8) + WIZCHIP_READ(WIZCHIP_OFFSET_INC(Sn_TX_RD(sn),1));
686  return txrd;
687 }
688 
689 void setSn_TX_WR(uint8_t sn, uint16_t txwr)
690 {
691  WIZCHIP_WRITE(Sn_TX_WR(sn), (uint8_t)(txwr>>8));
692  WIZCHIP_WRITE(WIZCHIP_OFFSET_INC(Sn_TX_WR(sn),1), (uint8_t) txwr);
693 }
694 
695 uint16_t getSn_TX_WR(uint8_t sn)
696 {
697  uint16_t txwr;
698  txwr = WIZCHIP_READ(Sn_TX_WR(sn));
699  txwr = (txwr<<8) + WIZCHIP_READ(WIZCHIP_OFFSET_INC(Sn_TX_WR(sn),1));
700  return txwr;
701 }
702 
703 //
704 uint16_t getSn_RX_RSR(uint8_t sn)
705 {
706  uint16_t val=0,val1=0;
707  do
708  {
709  val1 = WIZCHIP_READ(Sn_RX_RSR(sn));
710  val1 = (val1 << 8) + WIZCHIP_READ(WIZCHIP_OFFSET_INC(Sn_RX_RSR(sn),1));
711  if (val1 != 0)
712  {
713  val = WIZCHIP_READ(Sn_RX_RSR(sn));
714  val = (val << 8) + WIZCHIP_READ(WIZCHIP_OFFSET_INC(Sn_RX_RSR(sn),1));
715  }
716  }while (val != val1);
717  return val;
718 }
719 
720 void setSn_RX_RD(uint8_t sn, uint16_t rxrd)
721 {
722  WIZCHIP_WRITE(Sn_RX_RD(sn), (uint8_t)(rxrd>>8));
723  WIZCHIP_WRITE(WIZCHIP_OFFSET_INC(Sn_RX_RD(sn),1), (uint8_t) rxrd);
724 }
725 
726 uint16_t getSn_RX_RD(uint8_t sn)
727 {
728  uint16_t rxrd;
729  rxrd = WIZCHIP_READ(Sn_RX_RD(sn));
730  rxrd = (rxrd<<8) + WIZCHIP_READ(WIZCHIP_OFFSET_INC(Sn_RX_RD(sn),1));
731  return rxrd;
732 }
733 
734 //
735 uint16_t getSn_RX_WR(uint8_t sn)
736 {
737  uint16_t rxwr;
738  rxwr = WIZCHIP_READ(Sn_RX_WR(sn));
739  rxwr = (rxwr<<8) + WIZCHIP_READ(WIZCHIP_OFFSET_INC(Sn_RX_WR(sn),1));
740  return rxwr;
741 }
742 
743 
744 void setSn_FRAG(uint8_t sn, uint16_t frag)
745 {
746 
747  WIZCHIP_WRITE(Sn_FRAG(sn), (uint8_t)(frag >>8));
748  WIZCHIP_WRITE(WIZCHIP_OFFSET_INC(Sn_FRAG(sn),1), (uint8_t) frag);
749 }
750 
751 uint16_t getSn_FRAG(uint8_t sn)
752 {
753  uint16_t frag;
754  frag = WIZCHIP_READ(Sn_FRAG(sn));
755  frag = (frag << 8) + WIZCHIP_READ(WIZCHIP_OFFSET_INC(Sn_FRAG(sn),1));
756  return frag;
757 }
758 
759 void setSn_KPALVTR(uint8_t sn, uint8_t kpalvt)
760 {
761  WIZCHIP_WRITE(Sn_KPALVTR(sn), kpalvt);
762 
763 }
764 
765 uint8_t getSn_KPALVTR(uint8_t sn)
766 {
767  return WIZCHIP_READ(Sn_KPALVTR(sn));
768 }
770 
771 
772 
774 // Sn_TXBUF & Sn_RXBUF IO function //
776 void wiz_send_data(uint8_t sn, uint8_t *wizdata, uint16_t len)
777 {
778  uint16_t ptr = 0;
779  uint32_t addrsel = 0;
780  if(len == 0) return;
781  ptr = getSn_TX_WR(sn);
782 
783  addrsel = (ptr << 8) + (WIZCHIP_TXBUF_BLOCK(sn) << 3);
784  WIZCHIP_WRITE_BUF(addrsel,wizdata, len);
785 
786  ptr += len;
787  setSn_TX_WR(sn,ptr);
788 }
789 
790 void wiz_recv_data(uint8_t sn, uint8_t *wizdata, uint16_t len)
791 {
792  uint16_t ptr = 0;
793  uint32_t addrsel = 0;
794 
795  if(len == 0) return;
796  ptr = getSn_RX_RD(sn);
797  addrsel = (ptr << 8) + (WIZCHIP_RXBUF_BLOCK(sn) << 3);
798 
799  WIZCHIP_READ_BUF(addrsel, wizdata, len);
800  ptr += len;
801 
802  setSn_RX_RD(sn,ptr);
803 }
804 
805 
806 void wiz_recv_ignore(uint8_t sn, uint16_t len)
807 {
808  uint16_t ptr = 0;
809  ptr = getSn_RX_RD(sn);
810  ptr += len;
811  setSn_RX_RD(sn,ptr);
812 }
813 
814 /*
815 uint8 incr_windowfull_retry_cnt(uint8 s);
816 void init_windowfull_retry_cnt(uint8 s);
817 */
818