开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
if_robo.c
资源名称：bcm4702.rar　[点击查看]
上传用户：yuanda199
上传日期：2022-06-26
资源大小：412k
文件大小：12k
源码类别：

VxWorks

开发平台：

C/C++

if_robo.c：源码内容
  1. /*
  2.  * BCM53xx RoboSwitch utility functions
  3.  *
  4.  * Copyright (C) 2002 Broadcom Corporation
  5.  *
  6.  * $Id: if_robo.c,v 1.1 Broadcom SDK $
  7.  */
  9. #if 0
  10. #include <typedefs.h>
  11. #include <osl.h>
  12. #include <sbutils.h>
  13. #include <nvutils.h>
  14. #include <proto/ethernet.h>
  15. #include <etc53xx.h>
  16. #include "if_robo.h"
  17. #endif
  19. /* Missing Defines */
  20. #define OSL_IN_INTERRUPT()    1
  21. #define OSL_SLEEP(a) udelay((a))
  23. void
  24. udelay(uint usec)
  25. {
  26.     volatile int i;
  28.     for(i = 0; i < 5*usec; i++);
  29. }
  30. /* Missing Defines */
  31. int clkLen = 20;
  32. void *robo = 0;
  33. void *hSb = 0;
  34. #define robo_debug   0
  35. #if 1
  36. #undef OSL_DELAY
  37. #define OSL_DELAY(a) udelay(a)
  38. #endif
  40. robo_driver_t *robo_driver;
  42. robo_driver_t drv_table[] = {
  43.   { NULL, robosw_rreg, robosw_wreg },  
  44.   { NULL, NULL, NULL }
  45. };
  48. #define ROBO_POLL_DELAY_US 200000
  50. /* Get access to the RoboSwitch */
  51. robo_info_t *
  52. robosw_attach(void *sbh, uint32 reset, uint32 ssl, uint32 clk, uint32 mosi, uint32 miso)
  53. {
  54. robo_info_t *robo;
  55. #if 0
  56.   unsigned int flags = atoi(nvram_safe_get("boardflags"));
  57. #endif
  59.   /* set up type of register access based on board type */
  60. #if 0
  61.   if (flags & ENET_SPI) {
  62.     robo_driver = &drv_table[0];
  63.   } else if (flags & ENET_PMII) {
  64.     robo_driver = &drv_table[1];
  65.   } else {
  66. #endif
  67.     /* default to SPI*/
  68.     robo_driver = &drv_table[0];
  69. #if 0
  70.   }
  71. #endif
  73.   /* Allocate private state */
  74. if (!(robo = MALLOC(sizeof(robo_info_t)))) {
  75. printf("robo_attach: out of memory");
  76. return NULL;
  77. }
  78. bzero((char *) robo, sizeof(robo_info_t));
  79. robo->reset = reset; 
  80. robo->sbh = sbh;
  81. robo->ssl = ssl;
  82. robo->clk = clk;
  83. robo->mosi = mosi;
  84. robo->miso = miso;
  85. robo->cid = robo->page = -1;
  87. /* Initialize GPIO outputs */
  88. sb_gpioout(robo->sbh, robo->reset|robo->ssl | robo->clk | robo->mosi,
  89.    robo->ssl|robo->reset);
  90. sb_gpioouten(robo->sbh, robo->reset|robo->ssl | robo->clk | robo->mosi 
  91. | robo->miso, robo->reset|robo->ssl | robo->clk | robo->mosi);
  93. #ifdef _KERNEL_
  94. /* Initialize lock */
  95. spin_lock_init(&robo->lock);
  96. #endif
  97. return robo;
  98. }
  103. /* Release access to the RoboSwitch */
  104. void
  105. robosw_detach(robo_info_t *robo)
  106. {
  107. /* Disable GPIO outputs */
  108. sb_gpioouten(robo->sbh, robo->reset|robo->ssl | robo->clk | robo->mosi, 0);
  110. /* Free private state */
  111. MFREE(robo, sizeof(robo_info_t));
  112. }
  114. /* Enable serial access to the chip */
  115. static void
  116. robo_enable(robo_info_t *robo)
  117. {
  118. void *regs;
  120. /* Save current core index */
  121. robo->coreidx = sb_coreidx(robo->sbh);
  123. /* Switch to GPIO core for faster access */
  124. regs = sb_gpiosetcore(robo->sbh);
  125. ASSERT(regs);
  126. }
  128. /* Disable serial access to the chip */
  129. static void
  130. robo_disable(robo_info_t *robo)
  131. {
  132. /* Switch back to original core */
  133. sb_setcoreidx(robo->sbh, robo->coreidx);
  134. }
  136. /* Write a byte stream to the chip */
  137. static void
  138. robo_write(robo_info_t *robo, uint8 *buf, uint len)
  139. {
  140. uint i;
  141. uint8 mask;
  143. if (robo_debug) {
  144.     printf("%s: ", __FUNCTION__);
  145.     for (i=0; i<len ; i++) printf("0x%02X ", buf[i]);
  146.         printf("n");
  147. }
  148. for (i = 0; i < len; i++) {
  149. /* Bit bang from MSB to LSB */
  150. for (mask = 0x80; mask; mask >>= 1) {
  151. /* Clock low */
  152. sb_gpioout(robo->sbh, robo->clk, 0);
  153. OSL_DELAY(clkLen);
  155. /* Output on rising edge */
  156. if (mask & buf[i])
  157. sb_gpioout(robo->sbh, robo->mosi, robo->mosi);
  158. else
  159. sb_gpioout(robo->sbh, robo->mosi, 0);
  161. /* Clock high */
  162. sb_gpioout(robo->sbh, robo->clk, robo->clk);
  163. OSL_DELAY(clkLen);
  164. }
  165. }
  166. }
  168. /* Handy macros for writing fixed length values */
  169. #define robo_write8(robo, b) { uint8 val = (uint8) (b); robo_write((robo), &val, sizeof(val)); }
  170. #define robo_write16(robo, w) { uint16 val = (uint16) (w); robo_write((robo), &val, sizeof(val)); }
  171. #define robo_write32(robo, l) { uint32 val = (uint32) (l); robo_write((robo), &val, sizeof(val)); }
  173. /* Read a byte stream from the chip */
  174. static void
  175. robo_read(robo_info_t *robo, uint8 *buf, uint len)
  176. {
  177. uint i;
  178. uint8 rack, mask, byte;
  180. for (i = 0, rack = 0; i < len;) {
  181. /* Bit bang from MSB to LSB */
  182. for (mask = 0x80, byte = 0; mask; mask >>= 1) {
  183. /* Clock low */
  184. sb_gpioout(robo->sbh, robo->clk, 0);
  185. OSL_DELAY(clkLen);
  187.     sb_gpioout(robo->sbh, robo->mosi, 0);
  189. /* Sample */
  190. if (sb_gpioin(robo->sbh) & robo->miso)
  191. byte |= mask;
  193. /* Clock high */
  194. sb_gpioout(robo->sbh, robo->clk, robo->clk);
  195. OSL_DELAY(clkLen);
  197. }
  199.    buf[i] = byte;
  200.    i++;
  201. }
  202. if (robo_debug) {
  203.     for (; i>0; i--) printf("0x%02x ", buf[i-1]);
  204.     printf("n");
  205. }
  206. }
  208. /* poll for RACK */
  209. static int
  210. robo_poll_for_RACK(robo_info_t *robo)
  211. {
  212. uint i, timeout;
  213. uint8 byte;
  215. /* Timeout after 100 tries without RACK */
  216. for (i = 0, timeout = 100; timeout;) {
  217.     robo_read(robo, &byte, sizeof(byte));
  218. /* RACK when bit 0 is high */
  219. if (byte & 0x01)
  220. break;
  221. else
  222. {
  223.     timeout--;
  224.     /* sleep, unless in interrupt mode */
  225.     if (OSL_IN_INTERRUPT())
  226.     {
  227. #ifndef _CFE_
  228.         udelay(ROBO_POLL_DELAY_US);
  229. #else
  230. et_delay(ROBO_POLL_DELAY_US);
  231. #endif
  232. /*             OSL_DELAY(ROBO_POLL_DELAY_US);   */
  233.     }
  234.     else
  235.     {
  236.         OSL_SLEEP(ROBO_POLL_DELAY_US);
  237.          }
  238.         }
  239. }
  241. if (timeout == 0) {
  242. printf("robo_read: timeout");
  243. return -1;
  244. }
  245. return 0;
  247. }
  249. /* poll for MDIO_START low */
  250. static int
  251. robo_poll_for_MDIO_START(robo_info_t *robo, uint8 cid)
  252. {
  253. uint i, timeout;
  254. uint8 byte;
  255. uint data;
  257. /* Timeout after 100 tries without MDIO_START low */
  258. for (i = 0, timeout = 100; timeout;) {
  259.      sb_gpioout(robo->sbh, robo->ssl, 0);
  260.      robo_write8(robo, 0x60 | ((cid & 0x7) << 1));
  261.      robo_write8(robo, 0xfe);
  262.      robo_read((robo), &byte, sizeof(char));
  263.      sb_gpioout(robo->sbh, robo->ssl, robo->ssl);
  265. /* MDIO_START is bit 2 of SPI_STS */
  266. if (!(byte & 0x4))
  267. break;
  268. else
  269. {
  270.     timeout--;
  271.     data = (uint)byte;
  272.     /* sleep, unless in interrupt mode */
  273.     if (OSL_IN_INTERRUPT())
  274.     {
  275. #ifndef _CFE_
  276.         udelay(ROBO_POLL_DELAY_US);
  277. #else
  278. et_delay(ROBO_POLL_DELAY_US);
  279. #endif
  281. /*             OSL_DELAY(ROBO_POLL_DELAY_US); */
  282.     }
  283.     else
  284.     {
  285.         OSL_SLEEP(ROBO_POLL_DELAY_US);
  286.          }
  287.         }
  288. }
  290. if (timeout == 0) {
  291. printf("robo_read: timeout");
  292. return -1;
  293. }
  294. return 0;
  295. }
  297. /* Handy macros for reading fixed length values */
  298. #define robo_read8(robo) { uint8 val; robo_read((robo), &val, sizeof(val)); val; }
  299. #define robo_read16(robo) { uint16 val; robo_read((robo), &val, sizeof(val)); val; }
  300. #define robo_read32(robo) { uint32 val; robo_read((robo), &val, sizeof(val)); val; }
  302. /* Select new chip and page */
  303. static void
  304. robo_select(robo_info_t *robo, uint8 cid, uint8 page)
  305. {
  306. /* Chip and page already selected */
  307. if (robo->cid == (int) cid && robo->page == (int) page)
  308. return;
  309. robo->cid = (int) cid;
  310. robo->page = (int) page;
  312. /* Enable CS */
  313. sb_gpioout(robo->sbh, robo->ssl, 0);
  314. OSL_DELAY(clkLen);
  316. /* Select new chip */
  317. robo_write8(robo, 0x61 | ((cid & 0x7) << 1));
  319. /* Select new page */
  320. robo_write8(robo, 0xff);
  321. robo_write8(robo, page);
  323. /* Disable CS */
  324. sb_gpioout(robo->sbh, robo->ssl, robo->ssl);
  325. OSL_DELAY(clkLen);
  326. }
  328. /* Write chip register */
  329. void
  330. robosw_wreg(robo_info_t *robo, uint8 cid, uint8 page, uint8 addr, uint8 *buf, uint len)
  331. {
  332. #ifdef _KERNEL_
  333.         unsigned long flags;
  334. spin_lock_irqsave(&robo->lock, flags);
  335. #endif
  336.     
  337. robo_enable(robo);
  338.   if (robo_poll_for_MDIO_START(robo, cid))
  339.   {
  340.       /* timeout */
  341.     robo_select(robo, cid, page);
  342.       return;
  343.   }
  345. /* Select chip and page */
  346. robo_select(robo, cid, page);
  348. /* Enable CS */
  349. sb_gpioout(robo->sbh, robo->ssl, 0);
  350. OSL_DELAY(clkLen);
  352. /* Write */
  353. robo_write8(robo, 0x61 | ((cid & 0x7) << 1));
  354. robo_write8(robo, addr);
  355. robo_write(robo, buf, len);
  357. /* Disable CS */
  358. sb_gpioout(robo->sbh, robo->ssl, robo->ssl);
  359. OSL_DELAY(clkLen);
  361. robo_disable(robo);
  363. #ifdef _KERNEL_
  364. spin_unlock_irqrestore(&robo->lock, flags);
  365. #endif
  367. }
  369. /* Read chip register */
  370. void
  371. robosw_rreg(robo_info_t *robo, uint8 cid, uint8 page, uint8 addr, uint8 *buf, uint len)
  372. {
  374. #ifdef _KERNEL_
  375.         unsigned long flags;
  376. spin_lock_irqsave(&robo->lock, flags);
  377. #endif
  378.   robo_enable(robo);
  379.   
  380.   if (robo_poll_for_MDIO_START(robo,cid))
  381.       /* timeout */
  382.       return;
  384. /* Select chip and page */
  385. robo_select(robo, cid, page);
  387. /* Enable CS */
  388. sb_gpioout(robo->sbh, robo->ssl, 0);
  390.         /*delay so uP have sufficient time to prepare data */
  391. OSL_DELAY(clkLen);    
  393. /* Fast read */
  394. robo_write8(robo, 0x10 | ((cid & 0x7) << 1));
  395. OSL_DELAY(clkLen);
  396. robo_write8(robo, addr);
  397. OSL_DELAY(clkLen);
  398. if (robo_poll_for_RACK(robo))
  399.     /* timeout */
  400.     return;
  401.   robo_read(robo, buf, len);
  403. /* Disable CS */
  404. sb_gpioout(robo->sbh, robo->ssl, robo->ssl);
  405. OSL_DELAY(clkLen);
  407. robo_disable(robo);
  409. #ifdef _KERNEL_
  410. spin_unlock_irqrestore(&robo->lock, flags);
  411. #endif
  413. }
  415. #define sb_doattach(a, b, c, d, e, f)  sb_attach((a), (b), (c), (e), (f))
  416. /* generic kernel variant of sb_attach() */
  417. void*
  418. sb_robo_kattach()
  419. {
  420. #if 0
  421.     char *unused;
  422.     int varsz;
  424.     return (sb_doattach(BCM4710_DEVICE_ID, NULL, (void*)REG_MAP(SB_ENUM_BASE, SB_CORE_SIZE),
  425.         SB_BUS, &unused, &varsz));
  426. #else
  427.     return (sb_kattach (BCM4710_DEVICE_ID, 0));
  428. #endif
  429. }
  432. /*
  433.  * Init API
  434.  */
  435. void *
  436. bcm_robo_api_init()
  437. {
  438.     if (!(hSb = sb_robo_kattach()))
  439.         return 0;
  440.     if (!(robo = robosw_attach(hSb, 1, (1 << 2), (1 << 3), (1 << 4), (1 << 5))))
  441.         return 0;
  442.     /* sema_init (&robo_sema, 1);*/
  443.     return robo;
  444. }
  446. uint8 tr_buf[256];
  447. int
  448. tr_wreg(uint8 cid, uint8 page, uint8 addr, uint len)
  449. {
  450.     int i;
  451.     uint8 *buf;
  453.     if (robo == NULL) { bcm_robo_api_init(); }
  455.     buf = tr_buf;
  456.     robosw_wreg(robo, cid, page, addr, buf, len);
  457.     printf("robo = %p cid = %d page = %d addr = %02x len = %dn",
  458.             robo, cid, page, addr, len);
  459.     for(i = 0; i < len; i++) {
  460.         if (!(i % 16)) printf("n");
  461.         printf(" %02X", (unsigned int)buf[i] & 0xFF);
  462.     }
  463.     return(0);
  464. }
  466. int
  467. tr_rreg(uint8 cid, uint8 page, uint8 addr, uint len)
  468. {
  469.     uint8 buf[256];
  470.     int i;
  472.     if (robo == NULL) { bcm_robo_api_init(); }
  473.     robosw_rreg(robo, cid, page, addr, buf, len);
  474.     printf("robo = %p cid = %d page = %d addr = %02x len = %dn",
  475.             robo, cid, page, addr, len);
  476.     for(i = 0; i < len; i++) {
  477.         if (!(i % 16)) printf("n");
  478.         printf(" %02X", (unsigned int)buf[i] & 0xFF);
  479.     }
  480.     return(0);
  481. }
  484. int
  485. robo_tcl_wreg(uint8 cid, uint8 page, uint8 addr, uint8 *buf, uint len)
  486. {
  487.     int i;
  489.     if (robo == NULL) { bcm_robo_api_init(); }
  490.     if (gSPIEnable)
  491.         robosw_wreg(robo, cid, page, addr, buf, len);
  492.     else 
  493. robo_mdio_wreg(cid, page, addr, buf, len);
  495.     if (robo_debug) {
  496.         printf("Write Reg: robo = %p cid = %d page = %d addr = %02x len = %dn",
  497.                 robo, cid, page, addr, len);
  498.         for(i = 0; i < len; i++) {
  499.             if (!(i % 16)) printf("n");
  500.             printf(" %02X", (unsigned int)buf[i] & 0xFF);
  501.         }
  502.     }
  503.     return(0);
  504. }
  506. int
  507. robo_tcl_rreg(uint8 cid, uint8 page, uint8 addr, uint8* buf, uint len)
  508. {
  509.     int i;
  511.     if (robo == NULL) { bcm_robo_api_init(); }
  512.     if (gSPIEnable)
  513.         robosw_rreg(robo, cid, page, addr, buf, len);
  514.     else
  515.    robo_mdio_rreg(cid, page, addr, buf, len);
  517.     if (robo_debug) {
  518.         printf("Read Reg: robo = %p cid = %d page = %d addr = %02x len = %dn",
  519.                 robo, cid, page, addr, len);
  520.         for(i = 0; i < len; i++) {
  521.             if (!(i % 16)) printf("n");
  522.             printf(" %02X", (unsigned int)buf[i] & 0xFF);
  523.         }
  524.     }
  525.     return(0);
  526. }
  528. /* reset robo chips*/
  529. int robo_reset(void)
  530. { robo_info_t *p ;
  532. if (robo == NULL) {
  533.     if (!bcm_robo_api_init()) {
  534. printf("Err: unable to attach to robo devicen"); 
  535. return (1);
  536.     }
  537. }
  538. p = (robo_info_t *) robo;
  540. sb_gpioout(p->sbh, p->reset, p->reset);
  541. OSL_DELAY(10);
  542. sb_gpioout(p->sbh, p->reset, 0);
  543. OSL_DELAY(10);
  544. sb_gpioout(p->sbh, p->reset, p->reset);
  545. robosw_detach(robo);
  546. robo = 0;
  547. robo_mdio_reset();
  548. return(0);
  549. }