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