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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
rclanmtl.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：56k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

rclanmtl.c：源码内容
  1. /*
  2. ** *************************************************************************
  3. **
  4. **
  5. **     R C L A N M T L . C             $Revision: 6 $
  6. **
  7. **
  8. **  RedCreek I2O LAN Message Transport Layer program module.
  9. **
  10. **  ---------------------------------------------------------------------
  11. **  ---     Copyright (c) 1997-1999, RedCreek Communications Inc.     ---
  12. **  ---                   All rights reserved.                        ---
  13. **  ---------------------------------------------------------------------
  14. **
  15. **  File Description:
  16. **
  17. **  Host side I2O (Intelligent I/O) LAN message transport layer.
  18. **
  19. **  This program is free software; you can redistribute it and/or modify
  20. **  it under the terms of the GNU General Public License as published by
  21. **  the Free Software Foundation; either version 2 of the License, or
  22. **  (at your option) any later version.
  24. **  This program is distributed in the hope that it will be useful,
  25. **  but WITHOUT ANY WARRANTY; without even the implied warranty of
  26. **  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  27. **  GNU General Public License for more details.
  29. **  You should have received a copy of the GNU General Public License
  30. **  along with this program; if not, write to the Free Software
  31. **  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  32. **
  33. ** 1998-1999, LAN API was modified and enhanced by Alice Hennessy.
  34. **
  35. ** Sometime in 1997, LAN API was written from scratch by Wendell Nichols.
  36. ** *************************************************************************
  37. */
  39. #define DEBUG 1
  41. #define RC_LINUX_MODULE
  42. #include "rclanmtl.h"
  44.  /* RedCreek LAN device Target ID */
  45. #define RC_LAN_TARGET_ID  0x10
  46.  /* RedCreek's OSM default LAN receive Initiator */
  47. #define DEFAULT_RECV_INIT_CONTEXT  0xA17
  49. /*
  50. ** I2O message structures
  51. */
  53. #define    I2O_TID_SZ                                  12
  54. #define    I2O_FUNCTION_SZ                             8
  56. /* Transaction Reply Lists (TRL) Control Word structure */
  58. #define    I2O_TRL_FLAGS_SINGLE_FIXED_LENGTH           0x00
  59. #define    I2O_TRL_FLAGS_SINGLE_VARIABLE_LENGTH        0x40
  60. #define    I2O_TRL_FLAGS_MULTIPLE_FIXED_LENGTH         0x80
  62. /* LAN Class specific functions */
  64. #define    I2O_LAN_PACKET_SEND                         0x3B
  65. #define    I2O_LAN_SDU_SEND                            0x3D
  66. #define    I2O_LAN_RECEIVE_POST                        0x3E
  67. #define    I2O_LAN_RESET                               0x35
  68. #define    I2O_LAN_SHUTDOWN                            0x37
  70. /* Private Class specfic function */
  71. #define    I2O_PRIVATE                                 0xFF
  73. /*  I2O Executive Function Codes.  */
  75. #define    I2O_EXEC_ADAPTER_ASSIGN                     0xB3
  76. #define    I2O_EXEC_ADAPTER_READ                       0xB2
  77. #define    I2O_EXEC_ADAPTER_RELEASE                    0xB5
  78. #define    I2O_EXEC_BIOS_INFO_SET                      0xA5
  79. #define    I2O_EXEC_BOOT_DEVICE_SET                    0xA7
  80. #define    I2O_EXEC_CONFIG_VALIDATE                    0xBB
  81. #define    I2O_EXEC_CONN_SETUP                         0xCA
  82. #define    I2O_EXEC_DEVICE_ASSIGN                      0xB7
  83. #define    I2O_EXEC_DEVICE_RELEASE                     0xB9
  84. #define    I2O_EXEC_HRT_GET                            0xA8
  85. #define    I2O_EXEC_IOP_CLEAR                          0xBE
  86. #define    I2O_EXEC_IOP_CONNECT                        0xC9
  87. #define    I2O_EXEC_IOP_RESET                          0xBD
  88. #define    I2O_EXEC_LCT_NOTIFY                         0xA2
  89. #define    I2O_EXEC_OUTBOUND_INIT                      0xA1
  90. #define    I2O_EXEC_PATH_ENABLE                        0xD3
  91. #define    I2O_EXEC_PATH_QUIESCE                       0xC5
  92. #define    I2O_EXEC_PATH_RESET                         0xD7
  93. #define    I2O_EXEC_STATIC_MF_CREATE                   0xDD
  94. #define    I2O_EXEC_STATIC_MF_RELEASE                  0xDF
  95. #define    I2O_EXEC_STATUS_GET                         0xA0
  96. #define    I2O_EXEC_SW_DOWNLOAD                        0xA9
  97. #define    I2O_EXEC_SW_UPLOAD                          0xAB
  98. #define    I2O_EXEC_SW_REMOVE                          0xAD
  99. #define    I2O_EXEC_SYS_ENABLE                         0xD1
  100. #define    I2O_EXEC_SYS_MODIFY                         0xC1
  101. #define    I2O_EXEC_SYS_QUIESCE                        0xC3
  102. #define    I2O_EXEC_SYS_TAB_SET                        0xA3
  104.  /* Init Outbound Q status */
  105. #define    I2O_EXEC_OUTBOUND_INIT_IN_PROGRESS          0x01
  106. #define    I2O_EXEC_OUTBOUND_INIT_REJECTED             0x02
  107. #define    I2O_EXEC_OUTBOUND_INIT_FAILED               0x03
  108. #define    I2O_EXEC_OUTBOUND_INIT_COMPLETE             0x04
  110. #define    I2O_UTIL_NOP                                0x00
  112. /* I2O Get Status State values */
  114. #define    I2O_IOP_STATE_INITIALIZING                  0x01
  115. #define    I2O_IOP_STATE_RESET                         0x02
  116. #define    I2O_IOP_STATE_HOLD                          0x04
  117. #define    I2O_IOP_STATE_READY                         0x05
  118. #define    I2O_IOP_STATE_OPERATIONAL                   0x08
  119. #define    I2O_IOP_STATE_FAILED                        0x10
  120. #define    I2O_IOP_STATE_FAULTED                       0x11
  122. /* Defines for Request Status Codes:  Table 3-1 Reply Status Codes.  */
  124. #define    I2O_REPLY_STATUS_SUCCESS                    0x00
  125. #define    I2O_REPLY_STATUS_ABORT_DIRTY                0x01
  126. #define    I2O_REPLY_STATUS_ABORT_NO_DATA_TRANSFER     0x02
  127. #define    I2O_REPLY_STATUS_ABORT_PARTIAL_TRANSFER     0x03
  128. #define    I2O_REPLY_STATUS_ERROR_DIRTY                0x04
  129. #define    I2O_REPLY_STATUS_ERROR_NO_DATA_TRANSFER     0x05
  130. #define    I2O_REPLY_STATUS_ERROR_PARTIAL_TRANSFER     0x06
  131. #define    I2O_REPLY_STATUS_PROCESS_ABORT_DIRTY        0x07
  132. #define    I2O_REPLY_STATUS_PROCESS_ABORT_NO_DATA_TRANSFER   0x08
  133. #define    I2O_REPLY_STATUS_PROCESS_ABORT_PARTIAL_TRANSFER   0x09
  134. #define    I2O_REPLY_STATUS_TRANSACTION_ERROR          0x0A
  135. #define    I2O_REPLY_STATUS_PROGRESS_REPORT            0x80
  137. /* DetailedStatusCode defines for ALL messages: Table 3-2 Detailed Status Codes.*/
  139. #define    I2O_DETAIL_STATUS_SUCCESS                        0x0000
  140. #define    I2O_DETAIL_STATUS_BAD_KEY                        0x0001
  141. #define    I2O_DETAIL_STATUS_CHAIN_BUFFER_TOO_LARGE         0x0002
  142. #define    I2O_DETAIL_STATUS_DEVICE_BUSY                    0x0003
  143. #define    I2O_DETAIL_STATUS_DEVICE_LOCKED                  0x0004
  144. #define    I2O_DETAIL_STATUS_DEVICE_NOT_AVAILABLE           0x0005
  145. #define    I2O_DETAIL_STATUS_DEVICE_RESET                   0x0006
  146. #define    I2O_DETAIL_STATUS_INAPPROPRIATE_FUNCTION         0x0007
  147. #define    I2O_DETAIL_STATUS_INSUFFICIENT_RESOURCE_HARD     0x0008
  148. #define    I2O_DETAIL_STATUS_INSUFFICIENT_RESOURCE_SOFT     0x0009
  149. #define    I2O_DETAIL_STATUS_INVALID_INITIATOR_ADDRESS      0x000A
  150. #define    I2O_DETAIL_STATUS_INVALID_MESSAGE_FLAGS          0x000B
  151. #define    I2O_DETAIL_STATUS_INVALID_OFFSET                 0x000C
  152. #define    I2O_DETAIL_STATUS_INVALID_PARAMETER              0x000D
  153. #define    I2O_DETAIL_STATUS_INVALID_REQUEST                0x000E
  154. #define    I2O_DETAIL_STATUS_INVALID_TARGET_ADDRESS         0x000F
  155. #define    I2O_DETAIL_STATUS_MESSAGE_TOO_LARGE              0x0010
  156. #define    I2O_DETAIL_STATUS_MESSAGE_TOO_SMALL              0x0011
  157. #define    I2O_DETAIL_STATUS_MISSING_PARAMETER              0x0012
  158. #define    I2O_DETAIL_STATUS_NO_SUCH_PAGE                   0x0013
  159. #define    I2O_DETAIL_STATUS_REPLY_BUFFER_FULL              0x0014
  160. #define    I2O_DETAIL_STATUS_TCL_ERROR                      0x0015
  161. #define    I2O_DETAIL_STATUS_TIMEOUT                        0x0016
  162. #define    I2O_DETAIL_STATUS_UNKNOWN_ERROR                  0x0017
  163. #define    I2O_DETAIL_STATUS_UNKNOWN_FUNCTION               0x0018
  164. #define    I2O_DETAIL_STATUS_UNSUPPORTED_FUNCTION           0x0019
  165. #define    I2O_DETAIL_STATUS_UNSUPPORTED_VERSION            0x001A
  167.  /* I2O msg header defines for VersionOffset */
  168. #define I2OMSGVER_1_5   0x0001
  169. #define SGL_OFFSET_0    I2OMSGVER_1_5
  170. #define SGL_OFFSET_4    (0x0040 | I2OMSGVER_1_5)
  171. #define TRL_OFFSET_5    (0x0050 | I2OMSGVER_1_5)
  172. #define TRL_OFFSET_6    (0x0060 | I2OMSGVER_1_5)
  174.  /* I2O msg header defines for MsgFlags */
  175. #define MSG_STATIC      0x0100
  176. #define MSG_64BIT_CNTXT 0x0200
  177. #define MSG_MULTI_TRANS 0x1000
  178. #define MSG_FAIL        0x2000
  179. #define MSG_LAST        0x4000
  180. #define MSG_REPLY       0x8000
  182.   /* normal LAN request message MsgFlags and VersionOffset (0x1041) */
  183. #define LAN_MSG_REQST  (MSG_MULTI_TRANS | SGL_OFFSET_4)
  185.  /* minimum size msg */
  186. #define THREE_WORD_MSG_SIZE 0x00030000
  187. #define FOUR_WORD_MSG_SIZE  0x00040000
  188. #define FIVE_WORD_MSG_SIZE  0x00050000
  189. #define SIX_WORD_MSG_SIZE   0x00060000
  190. #define SEVEN_WORD_MSG_SIZE 0x00070000
  191. #define EIGHT_WORD_MSG_SIZE 0x00080000
  192. #define NINE_WORD_MSG_SIZE  0x00090000
  194. /* Special TID Assignments */
  196. #define I2O_IOP_TID   0
  197. #define I2O_HOST_TID  0xB91
  199.  /* RedCreek I2O private message codes */
  200. #define RC_PRIVATE_GET_MAC_ADDR     0x0001/**/ /* OBSOLETE */
  201. #define RC_PRIVATE_SET_MAC_ADDR     0x0002
  202. #define RC_PRIVATE_GET_NIC_STATS    0x0003
  203. #define RC_PRIVATE_GET_LINK_STATUS  0x0004
  204. #define RC_PRIVATE_SET_LINK_SPEED   0x0005
  205. #define RC_PRIVATE_SET_IP_AND_MASK  0x0006
  206. /* #define RC_PRIVATE_GET_IP_AND_MASK  0x0007 *//* OBSOLETE */
  207. #define RC_PRIVATE_GET_LINK_SPEED   0x0008
  208. #define RC_PRIVATE_GET_FIRMWARE_REV 0x0009
  209. /* #define RC_PRIVATE_GET_MAC_ADDR     0x000A */
  210. #define RC_PRIVATE_GET_IP_AND_MASK  0x000B
  211. #define RC_PRIVATE_DEBUG_MSG        0x000C
  212. #define RC_PRIVATE_REPORT_DRIVER_CAPABILITY  0x000D
  213. #define RC_PRIVATE_SET_PROMISCUOUS_MODE  0x000e
  214. #define RC_PRIVATE_GET_PROMISCUOUS_MODE  0x000f
  215. #define RC_PRIVATE_SET_BROADCAST_MODE    0x0010
  216. #define RC_PRIVATE_GET_BROADCAST_MODE    0x0011
  218. #define RC_PRIVATE_REBOOT           0x00FF
  220. /* I2O message header */
  221. typedef struct _I2O_MESSAGE_FRAME {
  222. U8 VersionOffset;
  223. U8 MsgFlags;
  224. U16 MessageSize;
  225. BF TargetAddress:I2O_TID_SZ;
  226. BF InitiatorAddress:I2O_TID_SZ;
  227. BF Function:I2O_FUNCTION_SZ;
  228. U32 InitiatorContext;
  229. /* SGL[] */
  230. } I2O_MESSAGE_FRAME, *PI2O_MESSAGE_FRAME;
  232.  /* assumed a 16K minus 256 byte space for outbound queue message frames */
  233. #define MSG_FRAME_SIZE  512
  234. #define NMBR_MSG_FRAMES 30
  236.  /* 
  237.     ** in reserved space right after PAB in host memory is area for returning
  238.     ** values from card 
  239.   */
  241. /*
  242. ** typedef NICSTAT
  243. **
  244. ** Data structure for NIC statistics retruned from PCI card.  Data copied from
  245. ** here to user allocated RCLINKSTATS (see rclanmtl.h) structure.
  246. */
  247. typedef struct tag_NicStat {
  248. unsigned long TX_good;
  249. unsigned long TX_maxcol;
  250. unsigned long TX_latecol;
  251. unsigned long TX_urun;
  252. unsigned long TX_crs; /* lost carrier sense */
  253. unsigned long TX_def; /* transmit deferred */
  254. unsigned long TX_singlecol; /* single collisions */
  255. unsigned long TX_multcol;
  256. unsigned long TX_totcol;
  257. unsigned long Rcv_good;
  258. unsigned long Rcv_CRCerr;
  259. unsigned long Rcv_alignerr;
  260. unsigned long Rcv_reserr; /* rnr'd pkts */
  261. unsigned long Rcv_orun;
  262. unsigned long Rcv_cdt;
  263. unsigned long Rcv_runt;
  264. unsigned long dump_status; /* last field directly from the chip */
  265. } NICSTAT, *P_NICSTAT;
  267. #define DUMP_DONE   0x0000A005 /* completed statistical dump */
  268. #define DUMP_CLEAR  0x0000A007 /* completed stat dump and clear counters */
  270. static volatile int msgFlag;
  272. /* local function prototypes */
  273. static void ProcessOutboundI2OMsg (PPAB pPab, U32 phyMsgAddr);
  274. static int FillI2OMsgSGLFromTCB (PU32 pMsg, PRCTCB pXmitCntrlBlock);
  275. static int GetI2OStatus (PPAB pPab);
  276. static int SendI2OOutboundQInitMsg (PPAB pPab);
  277. static int SendEnableSysMsg (PPAB pPab);
  279. /*
  280. ** =========================================================================
  281. ** RCInitI2OMsgLayer()
  282. **
  283. ** Initialize the RedCreek I2O Module and adapter.
  284. **
  285. ** Inputs:  dev - the devices net_device struct
  286. **          TransmitCallbackFunction - address of transmit callback function
  287. **          ReceiveCallbackFunction  - address of receive  callback function
  288. **
  289. ** private message block is allocated by user.  It must be in locked pages.
  290. ** p_msgbuf and p_phymsgbuf point to the same location.  Must be contigous
  291. ** memory block of a minimum of 16K byte and long word aligned.
  292. ** =========================================================================
  293. */
  294. RC_RETURN
  295. RCInitI2OMsgLayer (struct net_device *dev,
  296.    PFNTXCALLBACK TransmitCallbackFunction,
  297.    PFNRXCALLBACK ReceiveCallbackFunction,
  298.    PFNCALLBACK RebootCallbackFunction)
  299. {
  300. int result;
  301. PPAB pPab;
  302. PDPA pDpa = dev->priv;
  303. U32 pciBaseAddr = dev->base_addr;
  304. PU8 p_msgbuf = pDpa->PLanApiPA;
  305. PU8 p_phymsgbuf = (PU8) virt_to_bus ((void *) p_msgbuf);
  307. dprintk
  308.     ("InitI2O: Adapter:0x%x ATU:0x%x msgbuf:0x%x phymsgbuf:0x%xn"
  309.      "TransmitCallbackFunction:0x%x  ReceiveCallbackFunction:0x%xn",
  310.      pDpa->id, pciBaseAddr, (u32) p_msgbuf, (u32) p_phymsgbuf,
  311.      (u32) TransmitCallbackFunction, (u32) ReceiveCallbackFunction);
  313. /* Check if this interface already initialized - if so, shut it down */
  314. if (pDpa->pPab != NULL) {
  315. dprintk (KERN_WARNING
  316. "pDpa->pPab [%d] != NULLn",
  317. pDpa->id);
  318. /*          RCResetLANCard(pDpa->id, 0, (PU32)NULL, (PFNCALLBACK)NULL); */
  319. pDpa->pPab = NULL;
  320. }
  322. /* store adapter instance values in adapter block.
  323.  * Adapter block is at beginning of message buffer */
  325. pPab = kmalloc (sizeof (*pPab), GFP_KERNEL);
  326. if (!pPab) {
  327. dprintk (KERN_ERR 
  328. "RCInitI2OMsgLayer: Could not allocate memory for PAB struct!n");
  329. result = RC_RTN_MALLOC_ERROR;
  330. goto err_out;
  331. }
  333. memset (pPab, 0, sizeof (*pPab));
  334. pDpa->pPab = pPab;
  335. pPab->p_atu = (PATU) pciBaseAddr;
  336. pPab->pPci45LinBaseAddr = (PU8) pciBaseAddr;
  338. /* Set outbound message frame addr */
  339. pPab->outMsgBlockPhyAddr = (U32) p_phymsgbuf;
  340. pPab->pLinOutMsgBlock = (PU8) p_msgbuf;
  342. /* store callback function addresses */
  343. pPab->pTransCallbackFunc = TransmitCallbackFunction;
  344. pPab->pRecvCallbackFunc = ReceiveCallbackFunction;
  345. pPab->pRebootCallbackFunc = RebootCallbackFunction;
  346. pPab->pCallbackFunc = (PFNCALLBACK) NULL;
  348. /*
  349.    ** Initialize I2O IOP
  350.  */
  351. result = GetI2OStatus (pPab);
  353. if (result != RC_RTN_NO_ERROR)
  354. goto err_out_dealloc;
  356. if (pPab->IOPState == I2O_IOP_STATE_OPERATIONAL) {
  357. dprintk (KERN_INFO "pPab->IOPState == op: resetting adaptern");
  358. RCResetLANCard (dev, 0, (PU32) NULL, (PFNCALLBACK) NULL);
  359. }
  361. result = SendI2OOutboundQInitMsg (pPab);
  363. if (result != RC_RTN_NO_ERROR)
  364. goto err_out_dealloc;
  366. result = SendEnableSysMsg (pPab);
  368. if (result != RC_RTN_NO_ERROR)
  369. goto err_out_dealloc;
  371. return RC_RTN_NO_ERROR;
  373.       err_out_dealloc:
  374. kfree (pPab);
  375.       err_out:
  376. return result;
  377. }
  379. /*
  380. ** =========================================================================
  381. ** Disable and Enable I2O interrupts.  I2O interrupts are enabled at Init time
  382. ** but can be disabled and re-enabled through these two function calls.
  383. ** Packets will still be put into any posted received buffers and packets will
  384. ** be sent through RCI2OSendPacket() functions.  Disabling I2O interrupts
  385. ** will prevent hardware interrupt to host even though the outbound I2O msg
  386. ** queue is not emtpy.
  387. ** =========================================================================
  388. */
  389. #define i960_OUT_POST_Q_INT_BIT        0x0008 /* bit set masks interrupts */
  391. RC_RETURN
  392. RCDisableI2OInterrupts (struct net_device * dev)
  393. {
  394. PPAB pPab = ((PDPA) dev->priv)->pPab;
  396. if (pPab == NULL)
  397. return RC_RTN_ADPTR_NOT_REGISTERED;
  399. pPab->p_atu->OutIntMask |= i960_OUT_POST_Q_INT_BIT;
  401. return RC_RTN_NO_ERROR;
  402. }
  404. RC_RETURN
  405. RCEnableI2OInterrupts (struct net_device * dev)
  406. {
  407. PPAB pPab = ((PDPA) dev->priv)->pPab;
  409. if (pPab == NULL)
  410. return RC_RTN_ADPTR_NOT_REGISTERED;
  412. pPab->p_atu->OutIntMask &= ~i960_OUT_POST_Q_INT_BIT;
  414. return RC_RTN_NO_ERROR;
  416. }
  418. /*
  419. ** =========================================================================
  420. ** RCI2OSendPacket()
  421. ** =========================================================================
  422. */
  423. RC_RETURN
  424. RCI2OSendPacket (struct net_device * dev, U32 InitiatorContext,
  425.  PRCTCB pTransCtrlBlock)
  426. {
  427. U32 msgOffset;
  428. PU32 pMsg;
  429. int size;
  430. PPAB pPab = ((PDPA) dev->priv)->pPab;
  432. dprintk ("RCI2OSendPacket()...n");
  434. if (pPab == NULL)
  435. return RC_RTN_ADPTR_NOT_REGISTERED;
  437. /* get Inbound free Q entry - reading from In Q gets free Q entry */
  438. /* offset to Msg Frame in PCI msg block */
  440. msgOffset = pPab->p_atu->InQueue;
  442. if (msgOffset == 0xFFFFFFFF) {
  443. dprintk ("RCI2OSendPacket(): Inbound Free Q empty!n");
  444. return RC_RTN_FREE_Q_EMPTY;
  445. }
  447. /* calc virtual address of msg - virtual already mapped to physical */
  448. pMsg = (PU32) (pPab->pPci45LinBaseAddr + msgOffset);
  450. size = FillI2OMsgSGLFromTCB (pMsg + 4, pTransCtrlBlock);
  452. if (size == -1) { /* error processing TCB - send NOP msg */
  453. dprintk ("RCI2OSendPacket(): Error Rrocess TCB!n");
  454. pMsg[0] = THREE_WORD_MSG_SIZE | SGL_OFFSET_0;
  455. pMsg[1] =
  456.     I2O_UTIL_NOP << 24 | I2O_HOST_TID << 12 | RC_LAN_TARGET_ID;
  457. return RC_RTN_TCB_ERROR;
  458. } else { /* send over msg header */
  460. pMsg[0] = (size + 4) << 16 | LAN_MSG_REQST; /* send over message size and flags */
  461. pMsg[1] =
  462.     I2O_LAN_PACKET_SEND << 24 | I2O_HOST_TID << 12 |
  463.     RC_LAN_TARGET_ID;
  464. pMsg[2] = InitiatorContext;
  465. pMsg[3] = 0; /* batch reply */
  466. /* post to Inbound Post Q */
  467. pPab->p_atu->InQueue = msgOffset;
  468. return RC_RTN_NO_ERROR;
  469. }
  470. }
  472. /*
  473. ** =========================================================================
  474. ** RCI2OPostRecvBuffer()
  475. **
  476. ** inputs:  pBufrCntrlBlock - pointer to buffer control block
  477. **
  478. ** returns TRUE if successful in sending message, else FALSE.
  479. ** =========================================================================
  480. */
  481. RC_RETURN
  482. RCPostRecvBuffers (struct net_device * dev, PRCTCB pTransCtrlBlock)
  483. {
  484. U32 msgOffset;
  485. PU32 pMsg;
  486. int size;
  487. PPAB pPab = ((PDPA) dev->priv)->pPab;
  489. dprintk ("RCPostRecvBuffers()...n");
  491. /* search for DeviceHandle */
  493. if (pPab == NULL)
  494. return RC_RTN_ADPTR_NOT_REGISTERED;
  496. /* get Inbound free Q entry - reading from In Q gets free Q entry */
  497. /* offset to Msg Frame in PCI msg block */
  498. msgOffset = pPab->p_atu->InQueue;
  500. if (msgOffset == 0xFFFFFFFF) {
  501. dprintk ("RCPostRecvBuffers(): Inbound Free Q empty!n");
  502. return RC_RTN_FREE_Q_EMPTY;
  503. }
  504. /* calc virtual address of msg - virtual already mapped to physical */
  505. pMsg = (PU32) (pPab->pPci45LinBaseAddr + msgOffset);
  507. size = FillI2OMsgSGLFromTCB (pMsg + 4, pTransCtrlBlock);
  509. if (size == -1) { /* error prcessing TCB - send 3 DWORD private msg == NOP */
  510. dprintk
  511.     ("RCPostRecvBuffers(): Error Processing TCB! size = %dn",
  512.      size);
  513. pMsg[0] = THREE_WORD_MSG_SIZE | SGL_OFFSET_0;
  514. pMsg[1] =
  515.     I2O_UTIL_NOP << 24 | I2O_HOST_TID << 12 | RC_LAN_TARGET_ID;
  516. /* post to Post Q */
  517. pPab->p_atu->InQueue = msgOffset;
  518. return RC_RTN_TCB_ERROR;
  519. } else { /* send over size msg header */
  521. pMsg[0] = (size + 4) << 16 | LAN_MSG_REQST; /* send over message size and flags */
  522. pMsg[1] =
  523.     I2O_LAN_RECEIVE_POST << 24 | I2O_HOST_TID << 12 |
  524.     RC_LAN_TARGET_ID;
  525. pMsg[2] = DEFAULT_RECV_INIT_CONTEXT;
  526. pMsg[3] = *(PU32) pTransCtrlBlock; /* number of packet buffers */
  527. /* post to Post Q */
  528. pPab->p_atu->InQueue = msgOffset;
  529. return RC_RTN_NO_ERROR;
  530. }
  531. }
  533. /*
  534. ** =========================================================================
  535. ** RCProcI2OMsgQ()
  536. **
  537. ** Process I2O outbound message queue until empty.
  538. ** =========================================================================
  539. */
  540. void
  541. RCProcI2OMsgQ (struct net_device *dev)
  542. {
  543. U32 phyAddrMsg;
  544. PU8 p8Msg;
  545. PU32 p32;
  546. U16 count;
  547. PPAB pPab = ((PDPA) dev->priv)->pPab;
  548. unsigned char debug_msg[20];
  550. if (pPab == NULL)
  551. return;
  553. phyAddrMsg = pPab->p_atu->OutQueue;
  555. while (phyAddrMsg != 0xFFFFFFFF) {
  556. p8Msg =
  557.     pPab->pLinOutMsgBlock + (phyAddrMsg -
  558.      pPab->outMsgBlockPhyAddr);
  559. p32 = (PU32) p8Msg;
  561. dprintk ("msg: 0x%x  0x%x n", p8Msg[7], p32[5]);
  563. /* Send Packet Reply Msg */
  564. if (I2O_LAN_PACKET_SEND == p8Msg[7]) { /* function code byte */
  565. count = *(PU16) (p8Msg + 2);
  566. count -= p8Msg[0] >> 4;
  567. /* status, count, context[], adapter */
  568. (*pPab->pTransCallbackFunc) (p8Msg[19], count, p32 + 5,
  569.      dev);
  570. } else if (I2O_LAN_RECEIVE_POST == p8Msg[7]) { /* Receive Packet Reply Msg */
  571. dprintk
  572.     ("I2O_RECV_REPLY pPab:0x%x p8Msg:0x%x p32:0x%xn",
  573.      (u32) pPab, (u32) p8Msg, (u32) p32);
  574. dprintk ("msg: 0x%x:0x%x:0x%x:0x%xn",
  575.  p32[0], p32[1], p32[2], p32[3]);
  576. dprintk ("     0x%x:0x%x:0x%x:0x%xn",
  577.  p32[4], p32[5], p32[6], p32[7]);
  578. dprintk ("     0x%x:0X%x:0x%x:0x%xn",
  579.  p32[8], p32[9], p32[10], p32[11]);
  580. /*  status, count, buckets remaining, packetParmBlock, adapter */
  581. (*pPab->pRecvCallbackFunc) (p8Msg[19], p8Msg[12],
  582.     p32[5], p32 + 6, dev);
  583. } else if (I2O_LAN_RESET == p8Msg[7]
  584.    || I2O_LAN_SHUTDOWN == p8Msg[7])
  585. if (pPab->pCallbackFunc)
  586. (*pPab->pCallbackFunc) (p8Msg[19], 0, 0, dev);
  587. else
  588. pPab->pCallbackFunc = (PFNCALLBACK) 1;
  589. else if (I2O_PRIVATE == p8Msg[7]) {
  590. dprintk ("i2o private 0x%x, 0x%x n", p8Msg[7], p32[5]);
  591. switch (p32[5]) {
  592. case RC_PRIVATE_DEBUG_MSG:
  593. msgFlag = 1;
  594. dprintk ("Received I2O_PRIVATE msgn");
  595. debug_msg[15] = (p32[6] & 0xff000000) >> 24;
  596. debug_msg[14] = (p32[6] & 0x00ff0000) >> 16;
  597. debug_msg[13] = (p32[6] & 0x0000ff00) >> 8;
  598. debug_msg[12] = (p32[6] & 0x000000ff);
  600. debug_msg[11] = (p32[7] & 0xff000000) >> 24;
  601. debug_msg[10] = (p32[7] & 0x00ff0000) >> 16;
  602. debug_msg[9] = (p32[7] & 0x0000ff00) >> 8;
  603. debug_msg[8] = (p32[7] & 0x000000ff);
  605. debug_msg[7] = (p32[8] & 0xff000000) >> 24;
  606. debug_msg[6] = (p32[8] & 0x00ff0000) >> 16;
  607. debug_msg[5] = (p32[8] & 0x0000ff00) >> 8;
  608. debug_msg[4] = (p32[8] & 0x000000ff);
  610. debug_msg[3] = (p32[9] & 0xff000000) >> 24;
  611. debug_msg[2] = (p32[9] & 0x00ff0000) >> 16;
  612. debug_msg[1] = (p32[9] & 0x0000ff00) >> 8;
  613. debug_msg[0] = (p32[9] & 0x000000ff);
  615. debug_msg[16] = '';
  616. dprintk ("%s", debug_msg);
  617. break;
  618. case RC_PRIVATE_REBOOT:
  619. dprintk ("Adapter reboot initiated...n");
  620. if (pPab->pRebootCallbackFunc)
  621. (*pPab->pRebootCallbackFunc) (0, 0, 0,
  622.       dev);
  623. break;
  624. default:
  625. dprintk (KERN_WARNING
  626. "Unknown private I2O msg received: 0x%xn",
  627. p32[5]);
  628. break;
  629. }
  630. }
  632. /* 
  633.    ** Process other Msg's
  634.  */
  635. else
  636. ProcessOutboundI2OMsg (pPab, phyAddrMsg);
  638. /* return MFA to outbound free Q */
  639. pPab->p_atu->OutQueue = phyAddrMsg;
  641. /* any more msgs? */
  642. phyAddrMsg = pPab->p_atu->OutQueue;
  643. }
  644. }
  646. /*
  647. ** =========================================================================
  648. **  Returns LAN interface statistical counters to space provided by caller at
  649. **  StatsReturnAddr.  Returns 0 if success, else RC_RETURN code.
  650. **  This function will call the WaitCallback function provided by
  651. **  user while waiting for card to respond.
  652. ** =========================================================================
  653. */
  654. RC_RETURN
  655. RCGetLinkStatistics (struct net_device *dev,
  656.      P_RCLINKSTATS StatsReturnAddr,
  657.      PFNWAITCALLBACK WaitCallback)
  658. {
  659. U32 msgOffset;
  660. volatile PU32 pMsg;
  661. volatile PU32 p32, pReturnAddr;
  662. P_NICSTAT pStats;
  663. int i;
  664. PPAB pPab = ((PDPA) dev->priv)->pPab;
  666. /*dprintk("Get82558Stats() StatsReturnAddr:0x%xn", StatsReturnAddr); */
  668. if (pPab == NULL)
  669. return RC_RTN_ADPTR_NOT_REGISTERED;
  671. msgOffset = pPab->p_atu->InQueue;
  673. if (msgOffset == 0xFFFFFFFF) {
  674. dprintk ("Get8255XStats(): Inbound Free Q empty!n");
  675. return RC_RTN_FREE_Q_EMPTY;
  676. }
  678. /* calc virtual address of msg - virtual already mapped to physical */
  679. pMsg = (PU32) (pPab->pPci45LinBaseAddr + msgOffset);
  681. /*dprintk("Get82558Stats - pMsg = 0x%x, InQ msgOffset = 0x%xn", pMsg, msgOffset);*/
  682. /*dprintk("Get82558Stats - pMsg = 0x%08X, InQ msgOffset = 0x%08Xn", pMsg, msgOffset);*/
  684. pMsg[0] = SIX_WORD_MSG_SIZE | SGL_OFFSET_0;
  685. pMsg[1] = I2O_PRIVATE << 24 | I2O_HOST_TID << 12 | RC_LAN_TARGET_ID;
  686. pMsg[2] = DEFAULT_RECV_INIT_CONTEXT;
  687. pMsg[3] = 0x112; /* transaction context */
  688. pMsg[4] = RC_PCI45_VENDOR_ID << 16 | RC_PRIVATE_GET_NIC_STATS;
  689. pMsg[5] = pPab->outMsgBlockPhyAddr;
  691. // p32 = (PU32) pPab->outMsgBlockPhyAddr;
  692. p32 = (PU32)pPab->pLinOutMsgBlock;
  693. pStats = (P_NICSTAT) pPab->pLinOutMsgBlock;
  694. pStats->dump_status = 0xFFFFFFFF;
  696. /* post to Inbound Post Q */
  697. pPab->p_atu->InQueue = msgOffset;
  699. i = 0;
  700. while (pStats->dump_status == 0xFFFFFFFF) {
  701. if (i++ > 0xff) {
  702. dprintk ("Timeout waiting for NIC statisticsn");
  703. return RC_RTN_MSG_REPLY_TIMEOUT;
  704. }
  705. udelay(50);
  706. }
  707. pReturnAddr = (PU32) StatsReturnAddr;
  709. /* copy Nic stats to user's structure */
  710. for (i = 0; i < (int) sizeof (RCLINKSTATS) / 4; i++)
  711. pReturnAddr[i] = p32[i];
  713. return RC_RTN_NO_ERROR;
  714. }
  716. /*
  717. ** =========================================================================
  718. ** Get82558LinkStatus()
  719. ** =========================================================================
  720. */
  721. RC_RETURN
  722. RCGetLinkStatus (struct net_device * dev, PU32 ReturnAddr,
  723.  PFNWAITCALLBACK WaitCallback)
  724. {
  725. int i;
  726. U32 msgOffset;
  727. volatile PU32 pMsg;
  728. volatile PU32 p32;
  729. PPAB pPab = ((PDPA) dev->priv)->pPab;
  731. dprintk ("Get82558LinkStatus() ReturnPhysAddr:0x%xn",
  732.  (u32) ReturnAddr);
  734. if (pPab == NULL)
  735. return RC_RTN_ADPTR_NOT_REGISTERED;
  737. msgOffset = pPab->p_atu->InQueue;
  739. if (msgOffset == 0xFFFFFFFF) {
  740. dprintk ("Get82558LinkStatus(): Inbound Free Q empty!n");
  741. return RC_RTN_FREE_Q_EMPTY;
  742. }
  744. /* calc virtual address of msg - virtual already mapped to physical */
  745. pMsg = (PU32) (pPab->pPci45LinBaseAddr + msgOffset);
  746. /*dprintk("Get82558LinkStatus - pMsg = 0x%x, InQ msgOffset = 0x%xn", pMsg, msgOffset);*/
  747. /*dprintk("Get82558LinkStatus - pMsg = 0x%08X, InQ msgOffset = 0x%08Xn", pMsg, msgOffset);*/
  749. pMsg[0] = SIX_WORD_MSG_SIZE | SGL_OFFSET_0;
  750. pMsg[1] = I2O_PRIVATE << 24 | I2O_HOST_TID << 12 | RC_LAN_TARGET_ID;
  751. pMsg[2] = DEFAULT_RECV_INIT_CONTEXT;
  752. pMsg[3] = 0x112; /* transaction context */
  753. pMsg[4] = RC_PCI45_VENDOR_ID << 16 | RC_PRIVATE_GET_LINK_STATUS;
  754. pMsg[5] = pPab->outMsgBlockPhyAddr;
  756. p32 = (PU32) pPab->pLinOutMsgBlock;
  757. *p32 = 0xFFFFFFFF;
  759. /* post to Inbound Post Q */
  760. pPab->p_atu->InQueue = msgOffset;
  762. i = 0;
  763. while (*p32 == 0xFFFFFFFF) {
  764. if (i++ > 0xff) {
  765. dprintk ("Timeout waiting for link statusn");
  766. return RC_RTN_MSG_REPLY_TIMEOUT;
  767. }
  768. udelay(50);
  769. }
  771. *ReturnAddr = *p32; /* 1 = up 0 = down */
  773. return RC_RTN_NO_ERROR;
  775. }
  777. /*
  778. ** =========================================================================
  779. ** RCGetMAC()
  780. **
  781. ** get the MAC address the adapter is listening for in non-promiscous mode.
  782. ** MAC address is in media format.
  783. ** =========================================================================
  784. */
  785. RC_RETURN
  786. RCGetMAC (struct net_device * dev, PFNWAITCALLBACK WaitCallback)
  787. {
  788. U32 off, i;
  789. PU8 mac = dev->dev_addr;
  790. PU32 p;
  791. U32 temp[2];
  792. PPAB pPab = ((PDPA) dev->priv)->pPab;
  793. PATU p_atu;
  795. if (pPab == NULL)
  796. return RC_RTN_ADPTR_NOT_REGISTERED;
  798. p_atu = pPab->p_atu;
  800. p_atu->EtherMacLow = 0; /* first zero return data */
  801. p_atu->EtherMacHi = 0;
  803. off = p_atu->InQueue; /* get addresss of message */
  805. if (0xFFFFFFFF == off)
  806. return RC_RTN_FREE_Q_EMPTY;
  808. p = (PU32) (pPab->pPci45LinBaseAddr + off);
  810. dprintk ("RCGetMAC: p_atu 0x%08x, off 0x%08x, p 0x%08xn",
  811.  (uint) p_atu, (uint) off, (uint) p);
  812. /* setup private message */
  813. p[0] = FIVE_WORD_MSG_SIZE | SGL_OFFSET_0;
  814. p[1] = I2O_PRIVATE << 24 | I2O_HOST_TID << 12 | RC_LAN_TARGET_ID;
  815. p[2] = 0; /* initiator context */
  816. p[3] = 0x218; /* transaction context */
  817. p[4] = RC_PCI45_VENDOR_ID << 16 | RC_PRIVATE_GET_MAC_ADDR;
  819. p_atu->InQueue = off; /* send it to the I2O device */
  820. dprintk ("RCGetMAC: p_atu 0x%08x, off 0x%08x, p 0x%08xn",
  821.  (uint) p_atu, (uint) off, (uint) p);
  823. /* wait for the rcpci45 board to update the info */
  824. i = 0;
  825. while (0 == p_atu->EtherMacLow) {
  826. if (i++ > 0xff) {
  827. dprintk ("rc_getmac: Timeoutn");
  828. return RC_RTN_MSG_REPLY_TIMEOUT;
  829. }
  830. udelay(50);
  831. }
  833. /* read the mac address  */
  834. temp[0] = p_atu->EtherMacLow;
  835. temp[1] = p_atu->EtherMacHi;
  836. memcpy ((char *) mac, (char *) temp, 6);
  838. dprintk ("rc_getmac: 0x%xn", (u32) mac);
  840. return RC_RTN_NO_ERROR;
  841. }
  843. /*
  844. ** =========================================================================
  845. ** RCSetMAC()
  846. **
  847. ** set MAC address the adapter is listening for in non-promiscous mode.
  848. ** MAC address is in media format.
  849. ** =========================================================================
  850. */
  851. RC_RETURN
  852. RCSetMAC (struct net_device * dev, PU8 mac)
  853. {
  854. U32 off;
  855. PU32 pMsg;
  856. PPAB pPab = ((PDPA) dev->priv)->pPab;
  858. if (pPab == NULL)
  859. return RC_RTN_ADPTR_NOT_REGISTERED;
  861. off = pPab->p_atu->InQueue; /* get addresss of message */
  863. if (0xFFFFFFFF == off)
  864. return RC_RTN_FREE_Q_EMPTY;
  866. pMsg = (PU32) (pPab->pPci45LinBaseAddr + off);
  868. /* setup private message */
  869. pMsg[0] = SEVEN_WORD_MSG_SIZE | SGL_OFFSET_0;
  870. pMsg[1] = I2O_PRIVATE << 24 | I2O_HOST_TID << 12 | RC_LAN_TARGET_ID;
  871. pMsg[2] = 0; /* initiator context */
  872. pMsg[3] = 0x219; /* transaction context */
  873. pMsg[4] = RC_PCI45_VENDOR_ID << 16 | RC_PRIVATE_SET_MAC_ADDR;
  874. pMsg[5] = *(unsigned *) mac; /* first four bytes */
  875. pMsg[6] = *(unsigned *) (mac + 4); /* last two bytes */
  877. pPab->p_atu->InQueue = off; /* send it to the I2O device */
  879. return RC_RTN_NO_ERROR;
  880. }
  882. /*
  883. ** =========================================================================
  884. ** RCSetLinkSpeed()
  885. **
  886. ** set ethernet link speed. 
  887. ** input: speedControl - determines action to take as follows
  888. **          0 = reset and auto-negotiate (NWay)
  889. **          1 = Full Duplex 100BaseT
  890. **          2 = Half duplex 100BaseT
  891. **          3 = Full Duplex  10BaseT
  892. **          4 = Half duplex  10BaseT
  893. **          all other values are ignore (do nothing)
  894. ** =========================================================================
  895. */
  896. RC_RETURN
  897. RCSetLinkSpeed (struct net_device * dev, U16 LinkSpeedCode)
  898. {
  899. U32 off;
  900. PU32 pMsg;
  901. PPAB pPab = ((PDPA) dev->priv)->pPab;
  903. if (pPab == NULL)
  904. return RC_RTN_ADPTR_NOT_REGISTERED;
  906. off = pPab->p_atu->InQueue; /* get addresss of message */
  908. if (0xFFFFFFFF == off)
  909. return RC_RTN_FREE_Q_EMPTY;
  911. pMsg = (PU32) (pPab->pPci45LinBaseAddr + off);
  913. /* setup private message */
  914. pMsg[0] = SIX_WORD_MSG_SIZE | SGL_OFFSET_0;
  915. pMsg[1] = I2O_PRIVATE << 24 | I2O_HOST_TID << 12 | RC_LAN_TARGET_ID;
  916. pMsg[2] = 0; /* initiator context */
  917. pMsg[3] = 0x219; /* transaction context */
  918. pMsg[4] = RC_PCI45_VENDOR_ID << 16 | RC_PRIVATE_SET_LINK_SPEED;
  919. pMsg[5] = LinkSpeedCode; /* link speed code */
  921. pPab->p_atu->InQueue = off; /* send it to the I2O device */
  923. return RC_RTN_NO_ERROR;
  924. }
  926. /*
  927. ** =========================================================================
  928. ** RCSetPromiscuousMode()
  929. **
  930. ** Defined values for Mode:
  931. **  0 - turn off promiscuous mode
  932. **  1 - turn on  promiscuous mode
  933. **
  934. ** =========================================================================
  935. */
  936. RC_RETURN
  937. RCSetPromiscuousMode (struct net_device * dev, U16 Mode)
  938. {
  939. U32 off;
  940. PU32 pMsg;
  941. PPAB pPab = ((PDPA) dev->priv)->pPab;
  943. if (pPab == NULL)
  944. return RC_RTN_ADPTR_NOT_REGISTERED;
  946. off = pPab->p_atu->InQueue; /* get addresss of message */
  948. if (0xFFFFFFFF == off)
  949. return RC_RTN_FREE_Q_EMPTY;
  951. pMsg = (PU32) (pPab->pPci45LinBaseAddr + off);
  953. /* setup private message */
  954. pMsg[0] = SIX_WORD_MSG_SIZE | SGL_OFFSET_0;
  955. pMsg[1] = I2O_PRIVATE << 24 | I2O_HOST_TID << 12 | RC_LAN_TARGET_ID;
  956. pMsg[2] = 0; /* initiator context */
  957. pMsg[3] = 0x219; /* transaction context */
  958. pMsg[4] = RC_PCI45_VENDOR_ID << 16 | RC_PRIVATE_SET_PROMISCUOUS_MODE;
  959. pMsg[5] = Mode; /* promiscuous mode setting */
  961. pPab->p_atu->InQueue = off; /* send it to the device */
  963. return RC_RTN_NO_ERROR;
  964. }
  966. /*
  967. ** =========================================================================
  968. ** RCGetPromiscuousMode()
  969. **
  970. ** get promiscuous mode setting
  971. **
  972. ** Possible return values placed in pMode:
  973. **  0 = promisuous mode not set
  974. **  1 = promisuous mode is set
  975. **
  976. ** =========================================================================
  977. */
  978. RC_RETURN
  979. RCGetPromiscuousMode (struct net_device * dev, PU32 pMode,
  980.       PFNWAITCALLBACK WaitCallback)
  981. {
  982. PU32 pMsg;
  983. volatile PU32 p32;
  984. U32 msgOffset, i;
  985. PPAB pPab = ((PDPA) dev->priv)->pPab;
  987. msgOffset = pPab->p_atu->InQueue;
  989. if (msgOffset == 0xFFFFFFFF) {
  990. dprintk (KERN_WARNING
  991. "RCGetLinkSpeed(): Inbound Free Q empty!n");
  992. return RC_RTN_FREE_Q_EMPTY;
  993. }
  995. /* calc virtual address of msg - virtual already mapped to physical */
  996. pMsg = (PU32) (pPab->pPci45LinBaseAddr + msgOffset);
  998. /* virtual pointer to return buffer - clear first two dwords */
  999. p32 = (volatile PU32) pPab->pLinOutMsgBlock;
  1000. p32[0] = 0xff;
  1002. /* setup private message */
  1003. pMsg[0] = SIX_WORD_MSG_SIZE | SGL_OFFSET_0;
  1004. pMsg[1] = I2O_PRIVATE << 24 | I2O_HOST_TID << 12 | RC_LAN_TARGET_ID;
  1005. pMsg[2] = 0; /* initiator context */
  1006. pMsg[3] = 0x219; /* transaction context */
  1007. pMsg[4] = RC_PCI45_VENDOR_ID << 16 | RC_PRIVATE_GET_PROMISCUOUS_MODE;
  1008. /* phys address to return status - area right after PAB */
  1009. pMsg[5] = pPab->outMsgBlockPhyAddr;
  1011. /* post to Inbound Post Q */
  1013. pPab->p_atu->InQueue = msgOffset;
  1015. i = 0;
  1017. /* wait for response */
  1018. while (p32[0] == 0xff) {
  1019. if (i++ > 0xff) {
  1020. dprintk ("Timeout waiting for promiscuous moden");
  1021. return RC_RTN_NO_LINK_SPEED;
  1022. }
  1023. udelay(50);
  1024. }
  1026. /* get mode */
  1027. *pMode = (U8) ((volatile PU8) p32)[0] & 0x0f;
  1029. return RC_RTN_NO_ERROR;
  1030. }
  1032. /*
  1033. ** =========================================================================
  1034. ** RCSetBroadcastMode()
  1035. **
  1036. ** Defined values for Mode:
  1037. **  0 - turn off promiscuous mode
  1038. **  1 - turn on  promiscuous mode
  1039. **
  1040. ** =========================================================================
  1041. */
  1042. RC_RETURN
  1043. RCSetBroadcastMode (struct net_device * dev, U16 Mode)
  1044. {
  1045. U32 off;
  1046. PU32 pMsg;
  1047. PPAB pPab = ((PDPA) dev->priv)->pPab;
  1049. if (pPab == NULL)
  1050. return RC_RTN_ADPTR_NOT_REGISTERED;
  1052. off = pPab->p_atu->InQueue; /* get addresss of message */
  1054. if (0xFFFFFFFF == off)
  1055. return RC_RTN_FREE_Q_EMPTY;
  1057. pMsg = (PU32) (pPab->pPci45LinBaseAddr + off);
  1059. /* setup private message */
  1060. pMsg[0] = SIX_WORD_MSG_SIZE | SGL_OFFSET_0;
  1061. pMsg[1] = I2O_PRIVATE << 24 | I2O_HOST_TID << 12 | RC_LAN_TARGET_ID;
  1062. pMsg[2] = 0; /* initiator context */
  1063. pMsg[3] = 0x219; /* transaction context */
  1064. pMsg[4] = RC_PCI45_VENDOR_ID << 16 | RC_PRIVATE_SET_BROADCAST_MODE;
  1065. pMsg[5] = Mode; /* promiscuous mode setting */
  1067. pPab->p_atu->InQueue = off; /* send it to the device */
  1069. return RC_RTN_NO_ERROR;
  1070. }
  1072. /*
  1073. ** =========================================================================
  1074. ** RCGetBroadcastMode()
  1075. **
  1076. ** get promiscuous mode setting
  1077. **
  1078. ** Possible return values placed in pMode:
  1079. **  0 = promisuous mode not set
  1080. **  1 = promisuous mode is set
  1081. **
  1082. ** =========================================================================
  1083. */
  1084. RC_RETURN
  1085. RCGetBroadcastMode (struct net_device * dev, PU32 pMode,
  1086.     PFNWAITCALLBACK WaitCallback)
  1087. {
  1088. U32 msgOffset;
  1089. PU32 pMsg;
  1090. volatile PU32 p32;
  1091. PPAB pPab = ((PDPA) dev->priv)->pPab;
  1093. msgOffset = pPab->p_atu->InQueue;
  1095. if (msgOffset == 0xFFFFFFFF) {
  1096. dprintk (KERN_WARNING
  1097. "RCGetLinkSpeed(): Inbound Free Q empty!n");
  1098. return RC_RTN_FREE_Q_EMPTY;
  1099. }
  1101. /* calc virtual address of msg - virtual already mapped to physical */
  1102. pMsg = (PU32) (pPab->pPci45LinBaseAddr + msgOffset);
  1104. /* virtual pointer to return buffer - clear first two dwords */
  1105. p32 = (volatile PU32) pPab->pLinOutMsgBlock;
  1106. p32[0] = 0xff;
  1108. /* setup private message */
  1109. pMsg[0] = SIX_WORD_MSG_SIZE | SGL_OFFSET_0;
  1110. pMsg[1] = I2O_PRIVATE << 24 | I2O_HOST_TID << 12 | RC_LAN_TARGET_ID;
  1111. pMsg[2] = 0; /* initiator context */
  1112. pMsg[3] = 0x219; /* transaction context */
  1113. pMsg[4] = RC_PCI45_VENDOR_ID << 16 | RC_PRIVATE_GET_BROADCAST_MODE;
  1114. /* phys address to return status - area right after PAB */
  1115. pMsg[5] = pPab->outMsgBlockPhyAddr;
  1117. /* post to Inbound Post Q */
  1119. pPab->p_atu->InQueue = msgOffset;
  1121. /* wait for response */
  1122. if (p32[0] == 0xff) {
  1123. dprintk (KERN_WARNING
  1124. "Timeout waiting for promiscuous moden");
  1125. return RC_RTN_NO_LINK_SPEED;
  1126. }
  1128. /* get mode */
  1129. *pMode = (U8) ((volatile PU8) p32)[0] & 0x0f;
  1131. return RC_RTN_NO_ERROR;
  1132. }
  1134. /*
  1135. ** =========================================================================
  1136. ** RCGetLinkSpeed()
  1137. **
  1138. ** get ethernet link speed. 
  1139. **
  1140. ** 0 = Unknown
  1141. ** 1 = Full Duplex 100BaseT
  1142. ** 2 = Half duplex 100BaseT
  1143. ** 3 = Full Duplex  10BaseT
  1144. ** 4 = Half duplex  10BaseT
  1145. **
  1146. ** =========================================================================
  1147. */
  1148. RC_RETURN
  1149. RCGetLinkSpeed (struct net_device * dev, PU32 pLinkSpeedCode,
  1150. PFNWAITCALLBACK WaitCallback)
  1151. {
  1152. U32 msgOffset, i;
  1153. PU32 pMsg;
  1154. volatile PU32 p32;
  1155. U8 IOPLinkSpeed;
  1156. PPAB pPab = ((PDPA) dev->priv)->pPab;
  1158. msgOffset = pPab->p_atu->InQueue;
  1160. if (msgOffset == 0xFFFFFFFF) {
  1161. dprintk (KERN_WARNING
  1162. "RCGetLinkSpeed(): Inbound Free Q empty!n");
  1163. return RC_RTN_FREE_Q_EMPTY;
  1164. }
  1166. /* calc virtual address of msg - virtual already mapped to physical */
  1167. pMsg = (PU32) (pPab->pPci45LinBaseAddr + msgOffset);
  1169. /* virtual pointer to return buffer - clear first two dwords */
  1170. p32 = (volatile PU32) pPab->pLinOutMsgBlock;
  1171. p32[0] = 0xff;
  1173. /* setup private message */
  1174. pMsg[0] = SIX_WORD_MSG_SIZE | SGL_OFFSET_0;
  1175. pMsg[1] = I2O_PRIVATE << 24 | I2O_HOST_TID << 12 | RC_LAN_TARGET_ID;
  1176. pMsg[2] = 0; /* initiator context */
  1177. pMsg[3] = 0x219; /* transaction context */
  1178. pMsg[4] = RC_PCI45_VENDOR_ID << 16 | RC_PRIVATE_GET_LINK_SPEED;
  1179. /* phys address to return status - area right after PAB */
  1180. pMsg[5] = pPab->outMsgBlockPhyAddr;
  1182. /* post to Inbound Post Q */
  1184. pPab->p_atu->InQueue = msgOffset;
  1186. /* wait for response */
  1187. i = 0;
  1188. while (p32[0] == 0xff) {
  1189. if (i++ > 0xff) {
  1190. dprintk ("Timeout waiting for link speedn");
  1191. return RC_RTN_NO_LINK_SPEED;
  1192. }
  1193. udelay(50);
  1194. }
  1195. /* get Link speed */
  1196. IOPLinkSpeed = (U8) ((volatile PU8) p32)[0] & 0x0f;
  1197. *pLinkSpeedCode = IOPLinkSpeed;
  1199. return RC_RTN_NO_ERROR;
  1200. }
  1202. /*
  1203. ** =========================================================================
  1204. ** RCReportDriverCapability(struct net_device *dev, U32 capability)
  1205. **
  1206. ** Currently defined bits:
  1207. ** WARM_REBOOT_CAPABLE   0x01
  1208. **
  1209. ** =========================================================================
  1210. */
  1211. RC_RETURN
  1212. RCReportDriverCapability (struct net_device * dev, U32 capability)
  1213. {
  1214. U32 off;
  1215. PU32 pMsg;
  1216. PPAB pPab = ((PDPA) dev->priv)->pPab;
  1218. if (pPab == NULL)
  1219. return RC_RTN_ADPTR_NOT_REGISTERED;
  1221. off = pPab->p_atu->InQueue; /* get addresss of message */
  1223. if (0xFFFFFFFF == off)
  1224. return RC_RTN_FREE_Q_EMPTY;
  1226. pMsg = (PU32) (pPab->pPci45LinBaseAddr + off);
  1228. /* setup private message */
  1229. pMsg[0] = SIX_WORD_MSG_SIZE | SGL_OFFSET_0;
  1230. pMsg[1] = I2O_PRIVATE << 24 | I2O_HOST_TID << 12 | RC_LAN_TARGET_ID;
  1231. pMsg[2] = 0; /* initiator context */
  1232. pMsg[3] = 0x219; /* transaction context */
  1233. pMsg[4] =
  1234.     RC_PCI45_VENDOR_ID << 16 | RC_PRIVATE_REPORT_DRIVER_CAPABILITY;
  1235. pMsg[5] = capability;
  1237. pPab->p_atu->InQueue = off; /* send it to the I2O device */
  1239. return RC_RTN_NO_ERROR;
  1240. }
  1242. /*
  1243. ** =========================================================================
  1244. ** RCGetFirmwareVer()
  1245. **
  1246. ** Return firmware version in the form "SoftwareVersion : Bt BootVersion"
  1247. **
  1248. ** =========================================================================
  1249. */
  1250. RC_RETURN
  1251. RCGetFirmwareVer (struct net_device * dev, PU8 pFirmString,
  1252.   PFNWAITCALLBACK WaitCallback)
  1253. {
  1254. U32 msgOffset, i;
  1255. PU32 pMsg;
  1256. volatile PU32 p32;
  1257. PPAB pPab = ((PDPA) dev->priv)->pPab;
  1259. msgOffset = pPab->p_atu->InQueue;
  1260. if (msgOffset == 0xFFFFFFFF) {
  1261. dprintk ("RCGetFirmwareVer(): Inbound Free Q empty!n");
  1262. return RC_RTN_FREE_Q_EMPTY;
  1263. }
  1265. /* calc virtual address of msg - virtual already mapped to physical */
  1266. pMsg = (PU32) (pPab->pPci45LinBaseAddr + msgOffset);
  1268. /* virtual pointer to return buffer - clear first two dwords */
  1269. p32 = (volatile PU32) pPab->pLinOutMsgBlock;
  1270. p32[0] = 0xff;
  1272. /* setup private message */
  1273. pMsg[0] = SIX_WORD_MSG_SIZE | SGL_OFFSET_0;
  1274. pMsg[1] = I2O_PRIVATE << 24 | I2O_HOST_TID << 12 | RC_LAN_TARGET_ID;
  1275. pMsg[2] = 0; /* initiator context */
  1276. pMsg[3] = 0x219; /* transaction context */
  1277. pMsg[4] = RC_PCI45_VENDOR_ID << 16 | RC_PRIVATE_GET_FIRMWARE_REV;
  1278. /* phys address to return status - area right after PAB */
  1279. pMsg[5] = pPab->outMsgBlockPhyAddr;
  1281. /* post to Inbound Post Q */
  1283. pPab->p_atu->InQueue = msgOffset;
  1285. /* wait for response */
  1286. i = 0;
  1287. while (p32[0] == 0xff) {
  1288. if (i++ > 0xff) {
  1289. dprintk ("Timeout waiting for link speedn");
  1290. return RC_RTN_NO_FIRM_VER;
  1291. }
  1292. udelay(50);
  1293. }
  1294. strcpy (pFirmString, (PU8) p32);
  1295. return RC_RTN_NO_ERROR;
  1296. }
  1298. /*
  1299. ** =========================================================================
  1300. ** RCResetLANCard()
  1301. **
  1302. ** ResourceFlags indicates whether to return buffer resource explicitly
  1303. ** to host or keep and reuse.
  1304. ** CallbackFunction (if not NULL) is the function to be called when 
  1305. ** reset is complete.
  1306. ** If CallbackFunction is NULL, ReturnAddr will have a 1 placed in it when
  1307. ** reset is done (if not NULL).
  1308. **
  1309. ** =========================================================================
  1310. */
  1311. RC_RETURN
  1312. RCResetLANCard (struct net_device * dev, U16 ResourceFlags, PU32 ReturnAddr,
  1313. PFNCALLBACK CallbackFunction)
  1314. {
  1315. unsigned long off;
  1316. PU32 pMsg;
  1317. PPAB pPab = ((PDPA) dev->priv)->pPab;
  1318. long timeout = 0;
  1320. if (pPab == NULL)
  1321. return RC_RTN_ADPTR_NOT_REGISTERED;
  1323. off = pPab->p_atu->InQueue; /* get addresss of message */
  1325. if (0xFFFFFFFF == off)
  1326. return RC_RTN_FREE_Q_EMPTY;
  1328. pPab->pCallbackFunc = CallbackFunction;
  1330. pMsg = (PU32) (pPab->pPci45LinBaseAddr + off);
  1332. /* setup message */
  1333. pMsg[0] = FOUR_WORD_MSG_SIZE | SGL_OFFSET_0;
  1334. pMsg[1] = I2O_LAN_RESET << 24 | I2O_HOST_TID << 12 | RC_LAN_TARGET_ID;
  1335. pMsg[2] = DEFAULT_RECV_INIT_CONTEXT;
  1336. pMsg[3] = ResourceFlags << 16; /* resource flags */
  1338. pPab->p_atu->InQueue = off; /* send it to the I2O device */
  1340. if (CallbackFunction == (PFNCALLBACK) NULL) {
  1341. /* call RCProcI2OMsgQ() until something in pPab->pCallbackFunc
  1342.    or until timer goes off */
  1343. while (pPab->pCallbackFunc == (PFNCALLBACK) NULL) {
  1344. RCProcI2OMsgQ (dev);
  1345. mdelay (1);
  1346. timeout++;
  1347. if (timeout > 200) {
  1348. break;
  1349. }
  1350. }
  1351. if (ReturnAddr != (PU32) NULL)
  1352. *ReturnAddr = (U32) pPab->pCallbackFunc;
  1353. }
  1355. return RC_RTN_NO_ERROR;
  1356. }
  1358. /*
  1359. ** =========================================================================
  1360. ** RCResetIOP()
  1361. **
  1362. ** Send StatusGet Msg, wait for results return directly to buffer.
  1363. **
  1364. ** =========================================================================
  1365. */
  1366. RC_RETURN
  1367. RCResetIOP (struct net_device * dev)
  1368. {
  1369. U32 msgOffset, i;
  1370. PU32 pMsg;
  1371. PPAB pPab = ((PDPA) dev->priv)->pPab;
  1372. volatile PU32 p32;
  1374. msgOffset = pPab->p_atu->InQueue;
  1376. if (msgOffset == 0xFFFFFFFF) {
  1377. return RC_RTN_FREE_Q_EMPTY;
  1378. }
  1380. /* calc virtual address of msg - virtual already mapped to physical */
  1381. pMsg = (PU32) (pPab->pPci45LinBaseAddr + msgOffset);
  1383. pMsg[0] = NINE_WORD_MSG_SIZE | SGL_OFFSET_0;
  1384. pMsg[1] = I2O_EXEC_IOP_RESET << 24 | I2O_HOST_TID << 12 | I2O_IOP_TID;
  1385. pMsg[2] = 0; /* universal context */
  1386. pMsg[3] = 0; /* universal context */
  1387. pMsg[4] = 0; /* universal context */
  1388. pMsg[5] = 0; /* universal context */
  1389. /* phys address to return status - area right after PAB */
  1390. pMsg[6] = pPab->outMsgBlockPhyAddr;
  1391. pMsg[7] = 0;
  1392. pMsg[8] = 1; /*  return 1 byte */
  1394. /* virtual pointer to return buffer - clear first two dwords */
  1395. p32 = (volatile PU32) pPab->pLinOutMsgBlock;
  1396. p32[0] = 0;
  1397. p32[1] = 0;
  1399. /* post to Inbound Post Q */
  1401. pPab->p_atu->InQueue = msgOffset;
  1403. /* wait for response */
  1404. i = 0;
  1405. while (!p32[0] && !p32[1]) {
  1406. if (i++ > 0xff) {
  1407. dprintk ("RCResetIOP timeoutn");
  1408. return RC_RTN_MSG_REPLY_TIMEOUT;
  1409. }
  1410. udelay(100);
  1411. }
  1412. return RC_RTN_NO_ERROR;
  1413. }
  1415. /*
  1416. ** =========================================================================
  1417. ** RCShutdownLANCard()
  1418. **
  1419. ** ResourceFlags indicates whether to return buffer resource explicitly
  1420. ** to host or keep and reuse.
  1421. ** CallbackFunction (if not NULL) is the function to be called when 
  1422. ** shutdown is complete.
  1423. ** If CallbackFunction is NULL, ReturnAddr will have a 1 placed in it when
  1424. ** shutdown is done (if not NULL).
  1425. **
  1426. ** =========================================================================
  1427. */
  1428. RC_RETURN
  1429. RCShutdownLANCard (struct net_device * dev, U16 ResourceFlags,
  1430.    PU32 ReturnAddr, PFNCALLBACK CallbackFunction)
  1431. {
  1432. volatile PU32 pMsg;
  1433. U32 off;
  1434. PPAB pPab = ((PDPA) dev->priv)->pPab;
  1435. long timeout = 0;
  1437. if (pPab == NULL)
  1438. return RC_RTN_ADPTR_NOT_REGISTERED;
  1440. off = pPab->p_atu->InQueue; /* get addresss of message */
  1442. if (0xFFFFFFFF == off)
  1443. return RC_RTN_FREE_Q_EMPTY;
  1445. pPab->pCallbackFunc = CallbackFunction;
  1447. pMsg = (PU32) (pPab->pPci45LinBaseAddr + off);
  1449. /* setup message */
  1450. pMsg[0] = FOUR_WORD_MSG_SIZE | SGL_OFFSET_0;
  1451. pMsg[1] =
  1452.     I2O_LAN_SHUTDOWN << 24 | I2O_HOST_TID << 12 | RC_LAN_TARGET_ID;
  1453. pMsg[2] = DEFAULT_RECV_INIT_CONTEXT;
  1454. pMsg[3] = ResourceFlags << 16; /* resource flags */
  1456. pPab->p_atu->InQueue = off; /* send it to the I2O device */
  1458. if (CallbackFunction == (PFNCALLBACK) NULL) {
  1459. /* call RCProcI2OMsgQ() until something in pPab->pCallbackFunc
  1460.    or until timer goes off */
  1461. while (pPab->pCallbackFunc == (PFNCALLBACK) NULL) {
  1462. RCProcI2OMsgQ (dev);
  1463. mdelay (1);
  1464. timeout++;
  1465. if (timeout > 200) {
  1466. dprintk (KERN_WARNING
  1467. "RCShutdownLANCard(): timeoutn");
  1468. break;
  1469. }
  1470. }
  1471. if (ReturnAddr != (PU32) NULL)
  1472. *ReturnAddr = (U32) pPab->pCallbackFunc;
  1473. }
  1474. return RC_RTN_NO_ERROR;
  1475. }
  1477. /*
  1478. ** =========================================================================
  1479. ** RCSetRavlinIPandMask()
  1480. **
  1481. ** Set the Ravlin 45/PCI cards IP address and network mask.
  1482. **
  1483. ** IP address and mask must be in network byte order.
  1484. ** For example, IP address 1.2.3.4 and mask 255.255.255.0 would be
  1485. ** 0x04030201 and 0x00FFFFFF on a little endian machine.
  1486. **
  1487. ** =========================================================================
  1488. */
  1489. RC_RETURN
  1490. RCSetRavlinIPandMask (struct net_device * dev, U32 ipAddr, U32 netMask)
  1491. {
  1492. volatile PU32 pMsg;
  1493. U32 off;
  1494. PPAB pPab = ((PDPA) dev->priv)->pPab;
  1496. if (pPab == NULL)
  1497. return RC_RTN_ADPTR_NOT_REGISTERED;
  1499. off = pPab->p_atu->InQueue; /* get addresss of message */
  1501. if (0xFFFFFFFF == off)
  1502. return RC_RTN_FREE_Q_EMPTY;
  1504. pMsg = (PU32) (pPab->pPci45LinBaseAddr + off);
  1506. /* setup private message */
  1507. pMsg[0] = SEVEN_WORD_MSG_SIZE | SGL_OFFSET_0;
  1508. pMsg[1] = I2O_PRIVATE << 24 | I2O_HOST_TID << 12 | RC_LAN_TARGET_ID;
  1509. pMsg[2] = 0; /* initiator context */
  1510. pMsg[3] = 0x219; /* transaction context */
  1511. pMsg[4] = RC_PCI45_VENDOR_ID << 16 | RC_PRIVATE_SET_IP_AND_MASK;
  1512. pMsg[5] = ipAddr;
  1513. pMsg[6] = netMask;
  1515. pPab->p_atu->InQueue = off; /* send it to the I2O device */
  1516. return RC_RTN_NO_ERROR;
  1518. }
  1520. /*
  1521. ** =========================================================================
  1522. ** RCGetRavlinIPandMask()
  1523. **
  1524. ** get the IP address and MASK from the card
  1525. ** 
  1526. ** =========================================================================
  1527. */
  1528. RC_RETURN
  1529. RCGetRavlinIPandMask (struct net_device * dev, PU32 pIpAddr, PU32 pNetMask,
  1530.       PFNWAITCALLBACK WaitCallback)
  1531. {
  1532. U32 off, i;
  1533. PU32 pMsg, p32;
  1534. PPAB pPab = ((PDPA) dev->priv)->pPab;
  1535. PATU p_atu;
  1537. dprintk
  1538.     ("RCGetRavlinIPandMask: pIpAddr is 0x%x, *IpAddr is 0x%xn",
  1539.      (u32) pIpAddr, *pIpAddr);
  1541. if (pPab == NULL)
  1542. return RC_RTN_ADPTR_NOT_REGISTERED;
  1544. p_atu = pPab->p_atu;
  1545. off = p_atu->InQueue; /* get addresss of message */
  1547. if (0xFFFFFFFF == off)
  1548. return RC_RTN_FREE_Q_EMPTY;
  1550. p32 = (volatile PU32) pPab->pLinOutMsgBlock;
  1551. *p32 = 0xFFFFFFFF;
  1553. pMsg = (PU32) (pPab->pPci45LinBaseAddr + off);
  1555. dprintk
  1556.     ("RCGetRavlinIPandMask: p_atu 0x%x, off 0x%x, p32 0x%xn",
  1557.      (u32) p_atu, off, (u32) p32);
  1558. /* setup private message */
  1559. pMsg[0] = FIVE_WORD_MSG_SIZE | SGL_OFFSET_0;
  1560. pMsg[1] = I2O_PRIVATE << 24 | I2O_HOST_TID << 12 | RC_LAN_TARGET_ID;
  1561. pMsg[2] = 0; /* initiator context */
  1562. pMsg[3] = 0x218; /* transaction context */
  1563. pMsg[4] = RC_PCI45_VENDOR_ID << 16 | RC_PRIVATE_GET_IP_AND_MASK;
  1564. pMsg[5] = pPab->outMsgBlockPhyAddr;
  1566. p_atu->InQueue = off; /* send it to the I2O device */
  1567. dprintk
  1568.     ("RCGetRavlinIPandMask: p_atu 0x%x, off 0x%x, p32 0x%xn",
  1569.      (u32) p_atu, off, (u32) p32);
  1571. /* wait for the rcpci45 board to update the info */
  1572. i = 0;
  1573. while (0xffffffff == *p32) {
  1574. if (i++ > 0xff) {
  1575. dprintk ("RCGetRavlinIPandMask: Timeoutn");
  1576. return RC_RTN_MSG_REPLY_TIMEOUT;
  1577. }
  1578. udelay(50);
  1579. }
  1581. dprintk
  1582.     ("RCGetRavlinIPandMask: after time outnp32[0] (IpAddr) 0x%x, p32[1] (IPmask) 0x%xn",
  1583.      p32[0], p32[1]);
  1585. /* send IP and mask to user's space  */
  1586. *pIpAddr = p32[0];
  1587. *pNetMask = p32[1];
  1589. dprintk
  1590.     ("RCGetRavlinIPandMask: pIpAddr is 0x%x, *IpAddr is 0x%xn",
  1591.      (u32) pIpAddr, *pIpAddr);
  1593. return RC_RTN_NO_ERROR;
  1594. }
  1596. /* 
  1597. ** /////////////////////////////////////////////////////////////////////////
  1598. ** /////////////////////////////////////////////////////////////////////////
  1599. **
  1600. **                        local functions
  1601. **
  1602. ** /////////////////////////////////////////////////////////////////////////
  1603. ** /////////////////////////////////////////////////////////////////////////
  1604. */
  1606. /*
  1607. ** =========================================================================
  1608. ** SendI2OOutboundQInitMsg()
  1609. **
  1610. ** =========================================================================
  1611. */
  1612. static int
  1613. SendI2OOutboundQInitMsg (PPAB pPab)
  1614. {
  1615. U32 msgOffset, phyOutQFrames, i;
  1616. volatile PU32 pMsg;
  1617. volatile PU32 p32;
  1619. msgOffset = pPab->p_atu->InQueue;
  1621. if (msgOffset == 0xFFFFFFFF) {
  1622. dprintk ("SendI2OOutboundQInitMsg(): Inbound Free Q empty!n");
  1623. return RC_RTN_FREE_Q_EMPTY;
  1624. }
  1626. /* calc virtual address of msg - virtual already mapped to physical */
  1627. pMsg = (PU32) (pPab->pPci45LinBaseAddr + msgOffset);
  1629. dprintk
  1630.     ("SendI2OOutboundQInitMsg - pMsg = 0x%x, InQ msgOffset = 0x%xn",
  1631.      (u32) pMsg, msgOffset);
  1633. pMsg[0] = EIGHT_WORD_MSG_SIZE | TRL_OFFSET_6;
  1634. pMsg[1] =
  1635.     I2O_EXEC_OUTBOUND_INIT << 24 | I2O_HOST_TID << 12 | I2O_IOP_TID;
  1636. pMsg[2] = DEFAULT_RECV_INIT_CONTEXT;
  1637. pMsg[3] = 0x106; /* transaction context */
  1638. pMsg[4] = 4096; /* Host page frame size */
  1639. pMsg[5] = MSG_FRAME_SIZE << 16 | 0x80; /* outbound msg frame size and Initcode */
  1640. pMsg[6] = 0xD0000004; /* simple sgl element LE, EOB */
  1641. /* phys address to return status - area right after PAB */
  1642. pMsg[7] = pPab->outMsgBlockPhyAddr;
  1644. /* virtual pointer to return buffer - clear first two dwords */
  1645. p32 = (PU32) pPab->pLinOutMsgBlock;
  1646. p32[0] = 0;
  1648. /* post to Inbound Post Q */
  1649. pPab->p_atu->InQueue = msgOffset;
  1651. /* wait for response */
  1652. i = 0;
  1653. while (!p32[0]) {
  1654. if (i++ > 0xff) {
  1655. printk("rc: InitOutQ timeoutn");
  1656. return RC_RTN_NO_I2O_STATUS;
  1657. }
  1658. udelay(50);
  1659. }
  1660. if (p32[0] != I2O_EXEC_OUTBOUND_INIT_COMPLETE) {
  1661. printk("rc: exec outbound init failed (%x)n",
  1662. p32[0]);
  1663. return RC_RTN_NO_I2O_STATUS;
  1664. }
  1665. /* load PCI outbound free Q with MF physical addresses */
  1666. phyOutQFrames = pPab->outMsgBlockPhyAddr;
  1668. for (i = 0; i < NMBR_MSG_FRAMES; i++) {
  1669. pPab->p_atu->OutQueue = phyOutQFrames;
  1670. phyOutQFrames += MSG_FRAME_SIZE;
  1671. }
  1672. return RC_RTN_NO_ERROR;
  1673. }
  1675. /*
  1676. ** =========================================================================
  1677. ** GetI2OStatus()
  1678. **
  1679. ** Send StatusGet Msg, wait for results return directly to buffer.
  1680. **
  1681. ** =========================================================================
  1682. */
  1683. static int
  1684. GetI2OStatus (PPAB pPab)
  1685. {
  1686. U32 msgOffset, i;
  1687. PU32 pMsg;
  1688. volatile PU32 p32;
  1690. msgOffset = pPab->p_atu->InQueue;
  1691. dprintk ("GetI2OStatus: msg offset = 0x%xn", msgOffset);
  1692. if (msgOffset == 0xFFFFFFFF) {
  1693. dprintk ("GetI2OStatus(): Inbound Free Q empty!n");
  1694. return RC_RTN_FREE_Q_EMPTY;
  1695. }
  1697. /* calc virtual address of msg - virtual already mapped to physical */
  1698. pMsg = (PU32) (pPab->pPci45LinBaseAddr + msgOffset);
  1700. pMsg[0] = NINE_WORD_MSG_SIZE | SGL_OFFSET_0;
  1701. pMsg[1] = I2O_EXEC_STATUS_GET << 24 | I2O_HOST_TID << 12 | I2O_IOP_TID;
  1702. pMsg[2] = 0; /* universal context */
  1703. pMsg[3] = 0; /* universal context */
  1704. pMsg[4] = 0; /* universal context */
  1705. pMsg[5] = 0; /* universal context */
  1706. /* phys address to return status - area right after PAB */
  1707. pMsg[6] = pPab->outMsgBlockPhyAddr;
  1708. pMsg[7] = 0;
  1709. pMsg[8] = 88; /*  return 88 bytes */
  1711. /* virtual pointer to return buffer - clear first two dwords */
  1712. p32 = (volatile PU32) pPab->pLinOutMsgBlock;
  1713. p32[0] = 0;
  1714. p32[1] = 0;
  1716. dprintk
  1717.     ("GetI2OStatus - pMsg:0x%x, msgOffset:0x%x, [1]:0x%x, [6]:0x%xn",
  1718.      (u32) pMsg, msgOffset, pMsg[1], pMsg[6]);
  1720. /* post to Inbound Post Q */
  1721. pPab->p_atu->InQueue = msgOffset;
  1723. dprintk ("Return status to p32 = 0x%xn", (u32) p32);
  1725. /* wait for response */
  1726. i = 0;
  1727. while (!p32[0] || !p32[1]) {
  1728. if (i++ > 0xff) {
  1729. dprintk ("Timeout waiting for status from IOPn");
  1730. return RC_RTN_NO_I2O_STATUS;
  1731. }
  1732. udelay(50);
  1733. }
  1735. dprintk ("0x%x:0x%x:0x%x:0x%xn", p32[0], p32[1],
  1736.  p32[2], p32[3]);
  1737. dprintk ("0x%x:0x%x:0x%x:0x%xn", p32[4], p32[5],
  1738.  p32[6], p32[7]);
  1739. dprintk ("0x%x:0x%x:0x%x:0x%xn", p32[8], p32[9],
  1740.  p32[10], p32[11]);
  1741. /* get IOP state */
  1742. pPab->IOPState = ((volatile PU8) p32)[10];
  1743. pPab->InboundMFrameSize = ((volatile PU16) p32)[6];
  1745. dprintk ("IOP state 0x%x InFrameSize = 0x%xn",
  1746.  pPab->IOPState, pPab->InboundMFrameSize);
  1747. return RC_RTN_NO_ERROR;
  1748. }
  1750. /*
  1751. ** =========================================================================
  1752. ** SendEnableSysMsg()
  1753. **
  1754. **
  1755. ** =========================================================================
  1756. */
  1757. static int
  1758. SendEnableSysMsg (PPAB pPab)
  1759. {
  1760. U32 msgOffset;
  1761. volatile PU32 pMsg;
  1763. msgOffset = pPab->p_atu->InQueue;
  1765. if (msgOffset == 0xFFFFFFFF) {
  1766. dprintk ("SendEnableSysMsg(): Inbound Free Q empty!n");
  1767. return RC_RTN_FREE_Q_EMPTY;
  1768. }
  1770. /* calc virtual address of msg - virtual already mapped to physical */
  1771. pMsg = (PU32) (pPab->pPci45LinBaseAddr + msgOffset);
  1773. dprintk
  1774.     ("SendEnableSysMsg - pMsg = 0x%x, InQ msgOffset = 0x%xn",
  1775.      (u32) pMsg, msgOffset);
  1777. pMsg[0] = FOUR_WORD_MSG_SIZE | SGL_OFFSET_0;
  1778. pMsg[1] = I2O_EXEC_SYS_ENABLE << 24 | I2O_HOST_TID << 12 | I2O_IOP_TID;
  1779. pMsg[2] = DEFAULT_RECV_INIT_CONTEXT;
  1780. pMsg[3] = 0x110; /* transaction context */
  1781. pMsg[4] = 0x50657465; /*  RedCreek Private */
  1783. /* post to Inbound Post Q */
  1784. pPab->p_atu->InQueue = msgOffset;
  1786. return RC_RTN_NO_ERROR;
  1787. }
  1789. /*
  1790. ** =========================================================================
  1791. ** FillI2OMsgFromTCB()
  1792. **
  1793. ** inputs   pMsgU32 - virtual pointer (mapped to physical) of message frame
  1794. **          pXmitCntrlBlock - pointer to caller buffer control block.
  1795. **
  1796. ** fills in LAN SGL after Transaction Control Word or Bucket Count.
  1797. ** =========================================================================
  1798. */
  1799. static int
  1800. FillI2OMsgSGLFromTCB (PU32 pMsgFrame, PRCTCB pTransCtrlBlock)
  1801. {
  1802. unsigned int nmbrBuffers, nmbrSeg, nmbrDwords, context, flags;
  1803. PU32 pTCB, pMsg;
  1805. /* SGL element flags */
  1806. #define EOB        0x40000000
  1807. #define LE         0x80000000
  1808. #define SIMPLE_SGL 0x10000000
  1809. #define BC_PRESENT 0x01000000
  1811. pTCB = (PU32) pTransCtrlBlock;
  1812. pMsg = pMsgFrame;
  1813. nmbrDwords = 0;
  1815. dprintk ("FillI2OMsgSGLFromTCBXn");
  1816. dprintk ("TCB  0x%x:0x%x:0x%x:0x%x:0x%xn",
  1817.  pTCB[0], pTCB[1], pTCB[2], pTCB[3], pTCB[4]);
  1818. dprintk ("pTCB 0x%x, pMsg 0x%xn", (u32) pTCB, (u32) pMsg);
  1820. nmbrBuffers = *pTCB++;
  1822. if (!nmbrBuffers) {
  1823. return -1;
  1824. }
  1826. do {
  1827. context = *pTCB++; /* buffer tag (context) */
  1828. nmbrSeg = *pTCB++; /* number of segments */
  1830. if (!nmbrSeg) {
  1831. return -1;
  1832. }
  1834. flags = SIMPLE_SGL | BC_PRESENT;
  1836. if (1 == nmbrSeg) {
  1837. flags |= EOB;
  1839. if (1 == nmbrBuffers)
  1840. flags |= LE;
  1841. }
  1843. /* 1st SGL buffer element has context */
  1844. pMsg[0] = pTCB[0] | flags; /* send over count (segment size) */
  1845. pMsg[1] = context;
  1846. pMsg[2] = pTCB[1]; /* send buffer segment physical address */
  1847. nmbrDwords += 3;
  1848. pMsg += 3;
  1849. pTCB += 2;
  1851. if (--nmbrSeg) {
  1852. do {
  1853. flags = SIMPLE_SGL;
  1855. if (1 == nmbrSeg) {
  1856. flags |= EOB;
  1858. if (1 == nmbrBuffers)
  1859. flags |= LE;
  1860. }
  1862. pMsg[0] = pTCB[0] | flags; /* send over count */
  1863. pMsg[1] = pTCB[1]; /* send buffer segment physical address */
  1864. nmbrDwords += 2;
  1865. pTCB += 2;
  1866. pMsg += 2;
  1868. } while (--nmbrSeg);
  1869. }
  1871. } while (--nmbrBuffers);
  1873. return nmbrDwords;
  1874. }
  1876. /*
  1877. ** =========================================================================
  1878. ** ProcessOutboundI2OMsg()
  1879. **
  1880. ** process I2O reply message
  1881. ** * change to msg structure *
  1882. ** =========================================================================
  1883. */
  1884. static void
  1885. ProcessOutboundI2OMsg (PPAB pPab, U32 phyAddrMsg)
  1886. {
  1887. PU8 p8Msg;
  1888. PU32 p32;
  1889. /*      U16 count; */
  1891. p8Msg = pPab->pLinOutMsgBlock + (phyAddrMsg - pPab->outMsgBlockPhyAddr);
  1892. p32 = (PU32) p8Msg;
  1894. dprintk
  1895.     ("VXD: ProcessOutboundI2OMsg - pPab 0x%x, phyAdr 0x%x, linAdr 0x%xn",
  1896.      (u32) pPab, phyAddrMsg, (u32) p8Msg);
  1897. dprintk ("msg :0x%x:0x%x:0x%x:0x%xn", p32[0], p32[1],
  1898.  p32[2], p32[3]);
  1899. dprintk ("msg :0x%x:0x%x:0x%x:0x%xn", p32[4], p32[5],
  1900.  p32[6], p32[7]);
  1902. if (p32[4] >> 24 != I2O_REPLY_STATUS_SUCCESS) {
  1903. dprintk ("Message reply status not successn");
  1904. return;
  1905. }
  1907. switch (p8Msg[7]) { /* function code byte */
  1908. case I2O_EXEC_SYS_TAB_SET:
  1909. msgFlag = 1;
  1910. dprintk ("Received I2O_EXEC_SYS_TAB_SET replyn");
  1911. break;
  1913. case I2O_EXEC_HRT_GET:
  1914. msgFlag = 1;
  1915. dprintk ("Received I2O_EXEC_HRT_GET replyn");
  1916. break;
  1918. case I2O_EXEC_LCT_NOTIFY:
  1919. msgFlag = 1;
  1920. dprintk ("Received I2O_EXEC_LCT_NOTIFY replyn");
  1921. break;
  1923. case I2O_EXEC_SYS_ENABLE:
  1924. msgFlag = 1;
  1925. dprintk ("Received I2O_EXEC_SYS_ENABLE replyn");
  1926. break;
  1928. default:
  1929. dprintk ("Received UNKNOWN replyn");
  1930. break;
  1931. }
  1932. }