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

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

Linux/Unix编程

开发平台：

Unix_Linux

mptlan.c：源码内容
  1. /*
  2.  *  linux/drivers/message/fusion/mptlan.c
  3.  *      IP Over Fibre Channel device driver.
  4.  *      For use with PCI chip/adapter(s):
  5.  *          LSIFC9xx/LSI409xx Fibre Channel
  6.  *      running LSI Logic Fusion MPT (Message Passing Technology) firmware.
  7.  *
  8.  *  Credits:
  9.  *      This driver would not exist if not for Alan Cox's development
  10.  *      of the linux i2o driver.
  11.  *
  12.  *      Special thanks goes to the I2O LAN driver people at the
  13.  *      University of Helsinki, who, unbeknownst to them, provided
  14.  *      the inspiration and initial structure for this driver.
  15.  *
  16.  *      A huge debt of gratitude is owed to David S. Miller (DaveM)
  17.  *      for fixing much of the stupid and broken stuff in the early
  18.  *      driver while porting to sparc64 platform.  THANK YOU!
  19.  *
  20.  *      A really huge debt of gratitude is owed to Eddie C. Dost
  21.  *      for gobs of hard work fixing and optimizing LAN code.
  22.  *      THANK YOU!
  23.  *
  24.  *      (see also mptbase.c)
  25.  *
  26.  *  Copyright (c) 2000-2002 LSI Logic Corporation
  27.  *  Originally By: Noah Romer
  28.  *
  29.  *  $Id: mptlan.c,v 1.52 2002/05/06 13:45:07 sshirron Exp $
  30.  */
  31. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  32. /*
  33.     This program is free software; you can redistribute it and/or modify
  34.     it under the terms of the GNU General Public License as published by
  35.     the Free Software Foundation; version 2 of the License.
  37.     This program is distributed in the hope that it will be useful,
  38.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  39.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  40.     GNU General Public License for more details.
  42.     NO WARRANTY
  43.     THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
  44.     CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
  45.     LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
  46.     MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
  47.     solely responsible for determining the appropriateness of using and
  48.     distributing the Program and assumes all risks associated with its
  49.     exercise of rights under this Agreement, including but not limited to
  50.     the risks and costs of program errors, damage to or loss of data,
  51.     programs or equipment, and unavailability or interruption of operations.
  53.     DISCLAIMER OF LIABILITY
  54.     NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
  55.     DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  56.     DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
  57.     ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
  58.     TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  59.     USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
  60.     HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
  62.     You should have received a copy of the GNU General Public License
  63.     along with this program; if not, write to the Free Software
  64.     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  65. */
  67. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  68. /*
  69.  * Define statements used for debugging
  70.  */
  71. //#define MPT_LAN_IO_DEBUG
  73. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  75. #include "mptlan.h"
  76. #include <linux/init.h>
  77. #include <linux/module.h>
  78. #include <linux/fs.h>
  80. #define MYNAM "mptlan"
  82. MODULE_LICENSE("GPL");
  84. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  85. /*
  86.  * MPT LAN message sizes without variable part.
  87.  */
  88. #define MPT_LAN_RECEIVE_POST_REQUEST_SIZE 
  89. (sizeof(LANReceivePostRequest_t) - sizeof(SGE_MPI_UNION))
  91. #define MPT_LAN_TRANSACTION32_SIZE 
  92. (sizeof(SGETransaction32_t) - sizeof(u32))
  94. /*
  95.  *  Fusion MPT LAN private structures
  96.  */
  98. struct NAA_Hosed {
  99. u16 NAA;
  100. u8 ieee[FC_ALEN];
  101. struct NAA_Hosed *next;
  102. };
  104. struct BufferControl {
  105. struct sk_buff *skb;
  106. dma_addr_t dma;
  107. unsigned int len;
  108. };
  110. struct mpt_lan_priv {
  111. MPT_ADAPTER *mpt_dev;
  112. u8 pnum; /* Port number in the IOC. This is not a Unix network port! */
  114. atomic_t buckets_out; /* number of unused buckets on IOC */
  115. int bucketthresh; /* Send more when this many left */
  117. int *mpt_txfidx; /* Free Tx Context list */
  118. int mpt_txfidx_tail;
  119. spinlock_t txfidx_lock;
  121. int *mpt_rxfidx; /* Free Rx Context list */
  122. int mpt_rxfidx_tail;
  123. spinlock_t rxfidx_lock;
  125. struct BufferControl *RcvCtl; /* Receive BufferControl structs */
  126. struct BufferControl *SendCtl; /* Send BufferControl structs */
  128. int max_buckets_out; /* Max buckets to send to IOC */
  129. int tx_max_out; /* IOC's Tx queue len */
  131. u32 total_posted;
  132. u32 total_received;
  133. struct net_device_stats stats; /* Per device statistics */
  135. struct tq_struct post_buckets_task;
  136. unsigned long post_buckets_active;
  137. };
  139. struct mpt_lan_ohdr {
  140. u16 dtype;
  141. u8 daddr[FC_ALEN];
  142. u16 stype;
  143. u8 saddr[FC_ALEN];
  144. };
  146. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  148. /*
  149.  *  Forward protos...
  150.  */
  151. static int  lan_reply (MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf,
  152.        MPT_FRAME_HDR *reply);
  153. static int  mpt_lan_open(struct net_device *dev);
  154. static int  mpt_lan_reset(struct net_device *dev);
  155. static int  mpt_lan_close(struct net_device *dev);
  156. static void mpt_lan_post_receive_buckets(void *dev_id);
  157. static void mpt_lan_wake_post_buckets_task(struct net_device *dev, 
  158.    int priority);
  159. static int  mpt_lan_receive_post_turbo(struct net_device *dev, u32 tmsg);
  160. static int  mpt_lan_receive_post_reply(struct net_device *dev,
  161.        LANReceivePostReply_t *pRecvRep);
  162. static int  mpt_lan_send_turbo(struct net_device *dev, u32 tmsg);
  163. static int  mpt_lan_send_reply(struct net_device *dev,
  164.        LANSendReply_t *pSendRep);
  165. static int  mpt_lan_ioc_reset(MPT_ADAPTER *ioc, int reset_phase);
  166. static int  mpt_lan_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply);
  167. static unsigned short mpt_lan_type_trans(struct sk_buff *skb,
  168.  struct net_device *dev);
  170. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  171. /*
  172.  *  Fusion MPT LAN private data
  173.  */
  174. static int LanCtx = -1;
  176. static u32 max_buckets_out = 127;
  177. static u32 tx_max_out_p = 127 - 16;
  179. static struct net_device *mpt_landev[MPT_MAX_ADAPTERS+1];
  181. #ifdef QLOGIC_NAA_WORKAROUND
  182. static struct NAA_Hosed *mpt_bad_naa = NULL;
  183. rwlock_t bad_naa_lock;
  184. #endif
  186. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  187. /*
  188.  * Fusion MPT LAN external data
  189.  */
  190. extern int mpt_lan_index;
  192. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  193. /**
  194.  * lan_reply - Handle all data sent from the hardware.
  195.  * @ioc: Pointer to MPT_ADAPTER structure
  196.  * @mf: Pointer to original MPT request frame (NULL if TurboReply)
  197.  * @reply: Pointer to MPT reply frame
  198.  *
  199.  * Returns 1 indicating original alloc'd request frame ptr
  200.  * should be freed, or 0 if it shouldn't.
  201.  */
  202. static int
  203. lan_reply (MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *reply)
  204. {
  205. struct net_device *dev = mpt_landev[ioc->id];
  206. int FreeReqFrame = 0;
  208. dioprintk((KERN_INFO MYNAM ": %s/%s: Got reply.n",
  209.   IOC_AND_NETDEV_NAMES_s_s(dev)));
  211. // dioprintk((KERN_INFO MYNAM "@lan_reply: mf = %p, reply = %pn",
  212. // mf, reply));
  214. if (mf == NULL) {
  215. u32 tmsg = CAST_PTR_TO_U32(reply);
  217. dioprintk((KERN_INFO MYNAM ": %s/%s: @lan_reply, tmsg %08xn",
  218. IOC_AND_NETDEV_NAMES_s_s(dev),
  219. tmsg));
  221. switch (GET_LAN_FORM(tmsg)) {
  223. // NOTE!  (Optimization) First case here is now caught in
  224. //  mptbase.c::mpt_interrupt() routine and callcack here
  225. //  is now skipped for this case!  20001218 -sralston
  226. #if 0
  227. case LAN_REPLY_FORM_MESSAGE_CONTEXT:
  228. // dioprintk((KERN_INFO MYNAM "/lan_reply: "
  229. //   "MessageContext turbo reply receivedn"));
  230. FreeReqFrame = 1;
  231. break;
  232. #endif
  234. case LAN_REPLY_FORM_SEND_SINGLE:
  235. // dioprintk((MYNAM "/lan_reply: "
  236. //   "calling mpt_lan_send_reply (turbo)n"));
  238. // Potential BUG here?  -sralston
  239. // FreeReqFrame = mpt_lan_send_turbo(dev, tmsg);
  240. //  If/when mpt_lan_send_turbo would return 1 here,
  241. //  calling routine (mptbase.c|mpt_interrupt)
  242. //  would Oops because mf has already been set
  243. //  to NULL.  So after return from this func,
  244. //  mpt_interrupt() will attempt to put (NULL) mf ptr
  245. //  item back onto it's adapter FreeQ - Oops!:-(
  246. //  It's Ok, since mpt_lan_send_turbo() *currently*
  247. //  always returns 0, but..., just in case:
  249. (void) mpt_lan_send_turbo(dev, tmsg);
  250. FreeReqFrame = 0;
  252. break;
  254. case LAN_REPLY_FORM_RECEIVE_SINGLE:
  255. // dioprintk((KERN_INFO MYNAM "@lan_reply: "
  256. //   "rcv-Turbo = %08xn", tmsg));
  257. mpt_lan_receive_post_turbo(dev, tmsg);
  258. break;
  260. default:
  261. printk (KERN_ERR MYNAM "/lan_reply: Got a turbo reply "
  262. "that I don't know what to do withn");
  264. /* CHECKME!  Hmmm...  FreeReqFrame is 0 here; is that right? */
  266. break;
  267. }
  269. return FreeReqFrame;
  270. }
  272. // msg = (u32 *) reply;
  273. // dioprintk((KERN_INFO MYNAM "@lan_reply: msg = %08x %08x %08x %08xn",
  274. //   le32_to_cpu(msg[0]), le32_to_cpu(msg[1]),
  275. //   le32_to_cpu(msg[2]), le32_to_cpu(msg[3])));
  276. // dioprintk((KERN_INFO MYNAM "@lan_reply: Function = %02xhn",
  277. //   reply->u.hdr.Function));
  279. switch (reply->u.hdr.Function) {
  281. case MPI_FUNCTION_LAN_SEND:
  282. {
  283. LANSendReply_t *pSendRep;
  285. pSendRep = (LANSendReply_t *) reply;
  286. FreeReqFrame = mpt_lan_send_reply(dev, pSendRep);
  287. break;
  288. }
  290. case MPI_FUNCTION_LAN_RECEIVE:
  291. {
  292. LANReceivePostReply_t *pRecvRep;
  294. pRecvRep = (LANReceivePostReply_t *) reply;
  295. if (pRecvRep->NumberOfContexts) {
  296. mpt_lan_receive_post_reply(dev, pRecvRep);
  297. if (!(pRecvRep->MsgFlags & MPI_MSGFLAGS_CONTINUATION_REPLY))
  298. FreeReqFrame = 1;
  299. } else
  300. dioprintk((KERN_INFO MYNAM "@lan_reply: zero context "
  301.   "ReceivePostReply received.n"));
  302. break;
  303. }
  305. case MPI_FUNCTION_LAN_RESET:
  306. /* Just a default reply. Might want to check it to
  307.  * make sure that everything went ok.
  308.  */
  309. FreeReqFrame = 1;
  310. break;
  312. case MPI_FUNCTION_EVENT_NOTIFICATION:
  313. case MPI_FUNCTION_EVENT_ACK:
  314. /* UPDATE!  20010120 -sralston
  315.  *  _EVENT_NOTIFICATION should NOT come down this path any more.
  316.  *  Should be routed to mpt_lan_event_process(), but just in case...
  317.  */
  318. FreeReqFrame = 1;
  319. break;
  321. default:
  322. printk (KERN_ERR MYNAM "/lan_reply: Got a non-turbo "
  323. "reply that I don't know what to do withn");
  325. /* CHECKME!  Hmmm...  FreeReqFrame is 0 here; is that right? */
  326. FreeReqFrame = 1;
  328. break;
  329. }
  331. return FreeReqFrame;
  332. }
  334. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  335. static int
  336. mpt_lan_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
  337. {
  338. struct net_device *dev = mpt_landev[ioc->id];
  339. struct mpt_lan_priv *priv = (struct mpt_lan_priv *) dev->priv;
  341. dlprintk((KERN_INFO MYNAM ": IOC %s_reset routed to LAN driver!n",
  342. reset_phase==MPT_IOC_PRE_RESET ? "pre" : "post"));
  344. if (priv->mpt_rxfidx == NULL)
  345. return (1);
  347. if (reset_phase == MPT_IOC_PRE_RESET) {
  348. int i;
  349. unsigned long flags;
  351. netif_stop_queue(dev);
  353. dlprintk ((KERN_INFO "mptlan/ioc_reset: called netif_stop_queue for %s.n", dev->name));
  355. atomic_set(&priv->buckets_out, 0);
  357. /* Reset Rx Free Tail index and re-populate the queue. */
  358. spin_lock_irqsave(&priv->rxfidx_lock, flags);
  359. priv->mpt_rxfidx_tail = -1;
  360. for (i = 0; i < priv->max_buckets_out; i++)
  361. priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = i;
  362. spin_unlock_irqrestore(&priv->rxfidx_lock, flags);
  363. } else {
  364. mpt_lan_post_receive_buckets(dev);
  365. netif_wake_queue(dev);
  366. }
  368. return 1;
  369. }
  371. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  372. static int
  373. mpt_lan_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
  374. {
  375. dlprintk((KERN_INFO MYNAM ": MPT event routed to LAN driver!n"));
  377. switch (le32_to_cpu(pEvReply->Event)) {
  378. case MPI_EVENT_NONE: /* 00 */
  379. case MPI_EVENT_LOG_DATA: /* 01 */
  380. case MPI_EVENT_STATE_CHANGE: /* 02 */
  381. case MPI_EVENT_UNIT_ATTENTION: /* 03 */
  382. case MPI_EVENT_IOC_BUS_RESET: /* 04 */
  383. case MPI_EVENT_EXT_BUS_RESET: /* 05 */
  384. case MPI_EVENT_RESCAN: /* 06 */
  385. /* Ok, do we need to do anything here? As far as
  386.    I can tell, this is when a new device gets added
  387.    to the loop. */
  388. case MPI_EVENT_LINK_STATUS_CHANGE: /* 07 */
  389. case MPI_EVENT_LOOP_STATE_CHANGE: /* 08 */
  390. case MPI_EVENT_LOGOUT: /* 09 */
  391. case MPI_EVENT_EVENT_CHANGE: /* 0A */
  392. default:
  393. break;
  394. }
  396. /*
  397.  *  NOTE: pEvent->AckRequired handling now done in mptbase.c;
  398.  *  Do NOT do it here now!
  399.  */
  401. return 1;
  402. }
  404. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  405. static int
  406. mpt_lan_open(struct net_device *dev)
  407. {
  408. struct mpt_lan_priv *priv = (struct mpt_lan_priv *) dev->priv;
  409. int i;
  411. if (mpt_lan_reset(dev) != 0) {
  412. MPT_ADAPTER *mpt_dev = priv->mpt_dev;
  414. printk (KERN_WARNING MYNAM "/lan_open: lan_reset failed.");
  416. if (mpt_dev->active)
  417. printk ("The ioc is active. Perhaps it needs to be"
  418. " reset?n");
  419. else
  420. printk ("The ioc in inactive, most likely in the "
  421. "process of being reset. Please try again in "
  422. "a moment.n");
  423. }
  425. priv->mpt_txfidx = kmalloc(priv->tx_max_out * sizeof(int), GFP_KERNEL);
  426. if (priv->mpt_txfidx == NULL)
  427. goto out;
  428. priv->mpt_txfidx_tail = -1;
  430. priv->SendCtl = kmalloc(priv->tx_max_out * sizeof(struct BufferControl),
  431. GFP_KERNEL);
  432. if (priv->SendCtl == NULL)
  433. goto out_mpt_txfidx;
  434. for (i = 0; i < priv->tx_max_out; i++) {
  435. memset(&priv->SendCtl[i], 0, sizeof(struct BufferControl));
  436. priv->mpt_txfidx[++priv->mpt_txfidx_tail] = i;
  437. }
  439. dlprintk((KERN_INFO MYNAM "@lo: Finished initializing SendCtln"));
  441. priv->mpt_rxfidx = kmalloc(priv->max_buckets_out * sizeof(int),
  442.    GFP_KERNEL);
  443. if (priv->mpt_rxfidx == NULL)
  444. goto out_SendCtl;
  445. priv->mpt_rxfidx_tail = -1;
  447. priv->RcvCtl = kmalloc(priv->max_buckets_out *
  448. sizeof(struct BufferControl),
  449.        GFP_KERNEL);
  450. if (priv->RcvCtl == NULL)
  451. goto out_mpt_rxfidx;
  452. for (i = 0; i < priv->max_buckets_out; i++) {
  453. memset(&priv->RcvCtl[i], 0, sizeof(struct BufferControl));
  454. priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = i;
  455. }
  457. /**/ dlprintk((KERN_INFO MYNAM "/lo: txfidx contains - "));
  458. /**/ for (i = 0; i < priv->tx_max_out; i++)
  459. /**/ dlprintk((" %xh", priv->mpt_txfidx[i]));
  460. /**/ dlprintk(("n"));
  462. dlprintk((KERN_INFO MYNAM "/lo: Finished initializing RcvCtln"));
  464. mpt_lan_post_receive_buckets(dev);
  465. printk(KERN_INFO MYNAM ": %s/%s: interface up & activen",
  466. IOC_AND_NETDEV_NAMES_s_s(dev));
  468. if (mpt_event_register(LanCtx, mpt_lan_event_process) != 0) {
  469. printk (KERN_WARNING MYNAM "/lo: Unable to register for Event"
  470. " Notifications. This is a bad thing! We're not going "
  471. "to go ahead, but I'd be leery of system stability at "
  472. "this point.n");
  473. }
  475. netif_start_queue(dev);
  476. dlprintk((KERN_INFO MYNAM "/lo: Done.n"));
  478. return 0;
  479. out_mpt_rxfidx:
  480. kfree(priv->mpt_rxfidx);
  481. priv->mpt_rxfidx = NULL;
  482. out_SendCtl:
  483. kfree(priv->SendCtl);
  484. priv->SendCtl = NULL;
  485. out_mpt_txfidx:
  486. kfree(priv->mpt_txfidx);
  487. priv->mpt_txfidx = NULL;
  488. out: return -ENOMEM;
  489. }
  491. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  492. /* Send a LanReset message to the FW. This should result in the FW returning
  493.    any buckets it still has. */
  494. static int
  495. mpt_lan_reset(struct net_device *dev)
  496. {
  497. MPT_FRAME_HDR *mf;
  498. LANResetRequest_t *pResetReq;
  499. struct mpt_lan_priv *priv = (struct mpt_lan_priv *)dev->priv;
  501. mf = mpt_get_msg_frame(LanCtx, priv->mpt_dev->id);
  503. if (mf == NULL) {
  504. /* dlprintk((KERN_ERR MYNAM "/reset: Evil funkiness abounds! "
  505. "Unable to allocate a request frame.n"));
  506. */
  507. return -1;
  508. }
  510. pResetReq = (LANResetRequest_t *) mf;
  512. pResetReq->Function = MPI_FUNCTION_LAN_RESET;
  513. pResetReq->ChainOffset = 0;
  514. pResetReq->Reserved = 0;
  515. pResetReq->PortNumber = priv->pnum;
  516. pResetReq->MsgFlags = 0;
  517. pResetReq->Reserved2 = 0;
  519. mpt_put_msg_frame(LanCtx, priv->mpt_dev->id, mf);
  521. return 0;
  522. }
  524. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  525. static int
  526. mpt_lan_close(struct net_device *dev)
  527. {
  528. struct mpt_lan_priv *priv = (struct mpt_lan_priv *) dev->priv;
  529. MPT_ADAPTER *mpt_dev = priv->mpt_dev;
  530. unsigned int timeout;
  531. int i;
  533. dlprintk((KERN_INFO MYNAM ": mpt_lan_close calledn"));
  535. mpt_event_deregister(LanCtx);
  537. dlprintk((KERN_INFO MYNAM ":lan_close: Posted %d buckets "
  538.   "since driver was loaded, %d still outn",
  539.   priv->total_posted,atomic_read(&priv->buckets_out)));
  541. netif_stop_queue(dev);
  543. mpt_lan_reset(dev);
  545. timeout = 2 * HZ;
  546. while (atomic_read(&priv->buckets_out) && --timeout) {
  547. set_current_state(TASK_INTERRUPTIBLE);
  548. schedule_timeout(1);
  549. }
  551. for (i = 0; i < priv->max_buckets_out; i++) {
  552. if (priv->RcvCtl[i].skb != NULL) {
  553. /**/ dlprintk((KERN_INFO MYNAM "/lan_close: bucket %05x "
  554. /**/   "is still outn", i));
  555. pci_unmap_single(mpt_dev->pcidev, priv->RcvCtl[i].dma,
  556.  priv->RcvCtl[i].len,
  557.  PCI_DMA_FROMDEVICE);
  558. dev_kfree_skb(priv->RcvCtl[i].skb);
  559. }
  560. }
  562. kfree (priv->RcvCtl);
  563. kfree (priv->mpt_rxfidx);
  565. for (i = 0; i < priv->tx_max_out; i++) {
  566. if (priv->SendCtl[i].skb != NULL) {
  567. pci_unmap_single(mpt_dev->pcidev, priv->SendCtl[i].dma,
  568.  priv->SendCtl[i].len,
  569.  PCI_DMA_TODEVICE);
  570. dev_kfree_skb(priv->SendCtl[i].skb);
  571. }
  572. }
  574. kfree(priv->SendCtl);
  575. kfree(priv->mpt_txfidx);
  577. atomic_set(&priv->buckets_out, 0);
  579. printk(KERN_INFO MYNAM ": %s/%s: interface down & inactiven",
  580. IOC_AND_NETDEV_NAMES_s_s(dev));
  582. return 0;
  583. }
  585. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  586. static struct net_device_stats *
  587. mpt_lan_get_stats(struct net_device *dev)
  588. {
  589. struct mpt_lan_priv *priv = (struct mpt_lan_priv *)dev->priv;
  591. return (struct net_device_stats *) &priv->stats;
  592. }
  594. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  595. static int
  596. mpt_lan_change_mtu(struct net_device *dev, int new_mtu)
  597. {
  598. if ((new_mtu < MPT_LAN_MIN_MTU) || (new_mtu > MPT_LAN_MAX_MTU))
  599. return -EINVAL;
  600. dev->mtu = new_mtu;
  601. return 0;
  602. }
  604. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  605. /* Tx timeout handler. */
  606. static void
  607. mpt_lan_tx_timeout(struct net_device *dev)
  608. {
  609. struct mpt_lan_priv *priv = (struct mpt_lan_priv *) dev->priv;
  610. MPT_ADAPTER *mpt_dev = priv->mpt_dev;
  612. if (mpt_dev->active) {
  613. dlprintk (("mptlan/tx_timeout: calling netif_wake_queue for %s.n", dev->name));
  614. netif_wake_queue(dev);
  615. }
  616. }
  618. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  619. //static inline int
  620. static int
  621. mpt_lan_send_turbo(struct net_device *dev, u32 tmsg)
  622. {
  623. struct mpt_lan_priv *priv = (struct mpt_lan_priv *) dev->priv;
  624. MPT_ADAPTER *mpt_dev = priv->mpt_dev;
  625. struct sk_buff *sent;
  626. unsigned long flags;
  627. u32 ctx;
  629. ctx = GET_LAN_BUFFER_CONTEXT(tmsg);
  630. sent = priv->SendCtl[ctx].skb;
  632. priv->stats.tx_packets++;
  633. priv->stats.tx_bytes += sent->len;
  635. dioprintk((KERN_INFO MYNAM ": %s/%s: @%s, skb %p sent.n",
  636. IOC_AND_NETDEV_NAMES_s_s(dev),
  637. __FUNCTION__, sent));
  639. priv->SendCtl[ctx].skb = NULL;
  640. pci_unmap_single(mpt_dev->pcidev, priv->SendCtl[ctx].dma,
  641.  priv->SendCtl[ctx].len, PCI_DMA_TODEVICE);
  642. dev_kfree_skb_irq(sent);
  644. spin_lock_irqsave(&priv->txfidx_lock, flags);
  645. priv->mpt_txfidx[++priv->mpt_txfidx_tail] = ctx;
  646. spin_unlock_irqrestore(&priv->txfidx_lock, flags);
  648. netif_wake_queue(dev);
  649. return 0;
  650. }
  652. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  653. static int
  654. mpt_lan_send_reply(struct net_device *dev, LANSendReply_t *pSendRep)
  655. {
  656. struct mpt_lan_priv *priv = (struct mpt_lan_priv *) dev->priv;
  657. MPT_ADAPTER *mpt_dev = priv->mpt_dev;
  658. struct sk_buff *sent;
  659. unsigned long flags;
  660. int FreeReqFrame = 0;
  661. u32 *pContext;
  662. u32 ctx;
  663. u8 count;
  665. count = pSendRep->NumberOfContexts;
  667. dioprintk((KERN_INFO MYNAM ": send_reply: IOCStatus: %04xn",
  668.  le16_to_cpu(pSendRep->IOCStatus)));
  670. /* Add check for Loginfo Flag in IOCStatus */
  672. switch (le16_to_cpu(pSendRep->IOCStatus) & MPI_IOCSTATUS_MASK) {
  673. case MPI_IOCSTATUS_SUCCESS:
  674. priv->stats.tx_packets += count;
  675. break;
  677. case MPI_IOCSTATUS_LAN_CANCELED:
  678. case MPI_IOCSTATUS_LAN_TRANSMIT_ABORTED:
  679. break;
  681. case MPI_IOCSTATUS_INVALID_SGL:
  682. priv->stats.tx_errors += count;
  683. printk (KERN_ERR MYNAM ": %s/%s: ERROR - Invalid SGL sent to IOC!n",
  684. IOC_AND_NETDEV_NAMES_s_s(dev));
  685. goto out;
  687. default:
  688. priv->stats.tx_errors += count;
  689. break;
  690. }
  692. pContext = &pSendRep->BufferContext;
  694. spin_lock_irqsave(&priv->txfidx_lock, flags);
  695. while (count > 0) {
  696. ctx = GET_LAN_BUFFER_CONTEXT(le32_to_cpu(*pContext));
  698. sent = priv->SendCtl[ctx].skb;
  699. priv->stats.tx_bytes += sent->len;
  701. dioprintk((KERN_INFO MYNAM ": %s/%s: @%s, skb %p sent.n",
  702. IOC_AND_NETDEV_NAMES_s_s(dev),
  703. __FUNCTION__, sent));
  705. priv->SendCtl[ctx].skb = NULL;
  706. pci_unmap_single(mpt_dev->pcidev, priv->SendCtl[ctx].dma,
  707.  priv->SendCtl[ctx].len, PCI_DMA_TODEVICE);
  708. dev_kfree_skb_irq(sent);
  710. priv->mpt_txfidx[++priv->mpt_txfidx_tail] = ctx;
  712. pContext++;
  713. count--;
  714. }
  715. spin_unlock_irqrestore(&priv->txfidx_lock, flags);
  717. out:
  718. if (!(pSendRep->MsgFlags & MPI_MSGFLAGS_CONTINUATION_REPLY))
  719. FreeReqFrame = 1;
  721. netif_wake_queue(dev);
  722. return FreeReqFrame;
  723. }
  725. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  726. static int
  727. mpt_lan_sdu_send (struct sk_buff *skb, struct net_device *dev)
  728. {
  729. struct mpt_lan_priv *priv = (struct mpt_lan_priv *) dev->priv;
  730. MPT_ADAPTER *mpt_dev = priv->mpt_dev;
  731. MPT_FRAME_HDR *mf;
  732. LANSendRequest_t *pSendReq;
  733. SGETransaction32_t *pTrans;
  734. SGESimple64_t *pSimple;
  735. dma_addr_t dma;
  736. unsigned long flags;
  737. int ctx;
  738. u16 cur_naa = 0x1000;
  740. dioprintk((KERN_INFO MYNAM ": %s called, skb_addr = %pn",
  741. __FUNCTION__, skb));
  743. spin_lock_irqsave(&priv->txfidx_lock, flags);
  744. if (priv->mpt_txfidx_tail < 0) {
  745. netif_stop_queue(dev);
  746. spin_unlock_irqrestore(&priv->txfidx_lock, flags);
  748. printk (KERN_ERR "%s: no tx context available: %un",
  749. __FUNCTION__, priv->mpt_txfidx_tail);
  750. return 1;
  751. }
  753. mf = mpt_get_msg_frame(LanCtx, mpt_dev->id);
  754. if (mf == NULL) {
  755. netif_stop_queue(dev);
  756. spin_unlock_irqrestore(&priv->txfidx_lock, flags);
  758. printk (KERN_ERR "%s: Unable to alloc request framen",
  759. __FUNCTION__);
  760. return 1;
  761. }
  763. ctx = priv->mpt_txfidx[priv->mpt_txfidx_tail--];
  764. spin_unlock_irqrestore(&priv->txfidx_lock, flags);
  766. // dioprintk((KERN_INFO MYNAM ": %s/%s: Creating new msg frame (send).n",
  767. // IOC_AND_NETDEV_NAMES_s_s(dev)));
  769. pSendReq = (LANSendRequest_t *) mf;
  771. /* Set the mac.raw pointer, since this apparently isn't getting
  772.  * done before we get the skb. Pull the data pointer past the mac data.
  773.  */
  774. skb->mac.raw = skb->data;
  775. skb_pull(skb, 12);
  777.         dma = pci_map_single(mpt_dev->pcidev, skb->data, skb->len,
  778.      PCI_DMA_TODEVICE);
  780. priv->SendCtl[ctx].skb = skb;
  781. priv->SendCtl[ctx].dma = dma;
  782. priv->SendCtl[ctx].len = skb->len;
  784. /* Message Header */
  785. pSendReq->Reserved    = 0;
  786. pSendReq->Function    = MPI_FUNCTION_LAN_SEND;
  787. pSendReq->ChainOffset = 0;
  788. pSendReq->Reserved2   = 0;
  789. pSendReq->MsgFlags    = 0;
  790. pSendReq->PortNumber  = priv->pnum;
  792. /* Transaction Context Element */
  793. pTrans = (SGETransaction32_t *) pSendReq->SG_List;
  795. /* No Flags, 8 bytes of Details, 32bit Context (bloody turbo replies) */
  796. pTrans->ContextSize   = sizeof(u32);
  797. pTrans->DetailsLength = 2 * sizeof(u32);
  798. pTrans->Flags         = 0;
  799. pTrans->TransactionContext[0] = cpu_to_le32(ctx);
  801. // dioprintk((KERN_INFO MYNAM ": %s/%s: BC = %08x, skb = %p, buff = %pn",
  802. // IOC_AND_NETDEV_NAMES_s_s(dev),
  803. // ctx, skb, skb->data));
  805. #ifdef QLOGIC_NAA_WORKAROUND
  806. {
  807. struct NAA_Hosed *nh;
  809. /* Munge the NAA for Tx packets to QLogic boards, which don't follow
  810.    RFC 2625. The longer I look at this, the more my opinion of Qlogic
  811.    drops. */
  812. read_lock_irq(&bad_naa_lock);
  813. for (nh = mpt_bad_naa; nh != NULL; nh=nh->next) {
  814. if ((nh->ieee[0] == skb->mac.raw[0]) &&
  815.     (nh->ieee[1] == skb->mac.raw[1]) &&
  816.     (nh->ieee[2] == skb->mac.raw[2]) &&
  817.     (nh->ieee[3] == skb->mac.raw[3]) &&
  818.     (nh->ieee[4] == skb->mac.raw[4]) &&
  819.     (nh->ieee[5] == skb->mac.raw[5])) {
  820. cur_naa = nh->NAA;
  821. dlprintk ((KERN_INFO "mptlan/sdu_send: using NAA value "
  822.   "= %04x.n", cur_naa));
  823. break;
  824. }
  825. }
  826. read_unlock_irq(&bad_naa_lock);
  827. }
  828. #endif
  830. pTrans->TransactionDetails[0] = cpu_to_le32((cur_naa         << 16) |
  831.     (skb->mac.raw[0] <<  8) |
  832.     (skb->mac.raw[1] <<  0));
  833. pTrans->TransactionDetails[1] = cpu_to_le32((skb->mac.raw[2] << 24) |
  834.     (skb->mac.raw[3] << 16) |
  835.     (skb->mac.raw[4] <<  8) |
  836.     (skb->mac.raw[5] <<  0));
  838. pSimple = (SGESimple64_t *) &pTrans->TransactionDetails[2];
  840. /* If we ever decide to send more than one Simple SGE per LANSend, then
  841.    we will need to make sure that LAST_ELEMENT only gets set on the
  842.    last one. Otherwise, bad voodoo and evil funkiness will commence. */
  843. pSimple->FlagsLength = cpu_to_le32(
  844. ((MPI_SGE_FLAGS_LAST_ELEMENT |
  845.   MPI_SGE_FLAGS_END_OF_BUFFER |
  846.   MPI_SGE_FLAGS_SIMPLE_ELEMENT |
  847.   MPI_SGE_FLAGS_SYSTEM_ADDRESS |
  848.   MPI_SGE_FLAGS_HOST_TO_IOC |
  849.   MPI_SGE_FLAGS_64_BIT_ADDRESSING |
  850.   MPI_SGE_FLAGS_END_OF_LIST) << MPI_SGE_FLAGS_SHIFT) |
  851. skb->len);
  852. pSimple->Address.Low = cpu_to_le32((u32) dma);
  853. if (sizeof(dma_addr_t) > sizeof(u32))
  854. pSimple->Address.High = cpu_to_le32((u32) ((u64) dma >> 32));
  855. else
  856. pSimple->Address.High = 0;
  858. mpt_put_msg_frame (LanCtx, mpt_dev->id, mf);
  859. dev->trans_start = jiffies;
  861. dioprintk((KERN_INFO MYNAM ": %s/%s: Sending packet. FlagsLength = %08x.n",
  862. IOC_AND_NETDEV_NAMES_s_s(dev),
  863. le32_to_cpu(pSimple->FlagsLength)));
  865. return 0;
  866. }
  868. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  869. static inline void
  870. mpt_lan_wake_post_buckets_task(struct net_device *dev, int priority)
  871. /* 
  872.  * @priority: 0 = put it on the timer queue, 1 = put it on the immediate queue
  873.  */
  874. {
  875. struct mpt_lan_priv *priv = dev->priv;
  877. if (test_and_set_bit(0, &priv->post_buckets_active) == 0) {
  878. if (priority) {
  879. queue_task(&priv->post_buckets_task, &tq_immediate);
  880. mark_bh(IMMEDIATE_BH);
  881. } else {
  882. queue_task(&priv->post_buckets_task, &tq_timer);
  883. dioprintk((KERN_INFO MYNAM ": post_buckets queued on "
  884.    "timer.n"));
  885. }
  886.         dioprintk((KERN_INFO MYNAM ": %s/%s: Queued post_buckets task.n",
  887.    IOC_AND_NETDEV_NAMES_s_s(dev) ));
  888. }
  889. }
  891. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  892. static inline int
  893. mpt_lan_receive_skb(struct net_device *dev, struct sk_buff *skb)
  894. {
  895. struct mpt_lan_priv *priv = dev->priv;
  897. skb->protocol = mpt_lan_type_trans(skb, dev);
  899. dioprintk((KERN_INFO MYNAM ": %s/%s: Incoming packet (%d bytes) "
  900.  "delivered to upper level.n",
  901. IOC_AND_NETDEV_NAMES_s_s(dev), skb->len));
  903. priv->stats.rx_bytes += skb->len;
  904. priv->stats.rx_packets++;
  906. skb->dev = dev;
  907. netif_rx(skb);
  909. dioprintk((MYNAM "/receive_skb: %d buckets remainingn",
  910.  atomic_read(&priv->buckets_out)));
  912. if (atomic_read(&priv->buckets_out) < priv->bucketthresh)
  913. mpt_lan_wake_post_buckets_task(dev, 1);
  915. dioprintk((KERN_INFO MYNAM "/receive_post_reply: %d buckets "
  916.   "remaining, %d received back since sodn",
  917.   atomic_read(&priv->buckets_out), priv->total_received));
  919. return 0;
  920. }
  922. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  923. //static inline int
  924. static int
  925. mpt_lan_receive_post_turbo(struct net_device *dev, u32 tmsg)
  926. {
  927. struct mpt_lan_priv *priv = dev->priv;
  928. MPT_ADAPTER *mpt_dev = priv->mpt_dev;
  929. struct sk_buff *skb, *old_skb;
  930. unsigned long flags;
  931. u32 ctx, len;
  933. ctx = GET_LAN_BUCKET_CONTEXT(tmsg);
  934. skb = priv->RcvCtl[ctx].skb;
  936. len = GET_LAN_PACKET_LENGTH(tmsg);
  938. if (len < MPT_LAN_RX_COPYBREAK) {
  939. old_skb = skb;
  941. skb = (struct sk_buff *)dev_alloc_skb(len);
  942. if (!skb) {
  943. printk (KERN_ERR MYNAM ": %s/%s: ERROR - Can't allocate skb! (%s@%d)n",
  944. IOC_AND_NETDEV_NAMES_s_s(dev),
  945. __FILE__, __LINE__);
  946. return -ENOMEM;
  947. }
  949. pci_dma_sync_single(mpt_dev->pcidev, priv->RcvCtl[ctx].dma,
  950.     priv->RcvCtl[ctx].len, PCI_DMA_FROMDEVICE);
  952. memcpy(skb_put(skb, len), old_skb->data, len);
  954. goto out;
  955. }
  957. skb_put(skb, len);
  959. priv->RcvCtl[ctx].skb = NULL;
  961. pci_unmap_single(mpt_dev->pcidev, priv->RcvCtl[ctx].dma,
  962.  priv->RcvCtl[ctx].len, PCI_DMA_FROMDEVICE);
  964. out:
  965. spin_lock_irqsave(&priv->rxfidx_lock, flags);
  966. priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = ctx;
  967. spin_unlock_irqrestore(&priv->rxfidx_lock, flags);
  969. atomic_dec(&priv->buckets_out);
  970. priv->total_received++;
  972. return mpt_lan_receive_skb(dev, skb);
  973. }
  975. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  976. static int
  977. mpt_lan_receive_post_free(struct net_device *dev,
  978.   LANReceivePostReply_t *pRecvRep)
  979. {
  980. struct mpt_lan_priv *priv = dev->priv;
  981. MPT_ADAPTER *mpt_dev = priv->mpt_dev;
  982. unsigned long flags;
  983. struct sk_buff *skb;
  984. u32 ctx;
  985. int count;
  986. int i;
  988. count = pRecvRep->NumberOfContexts;
  990. /**/ dlprintk((KERN_INFO MYNAM "/receive_post_reply: "
  991.   "IOC returned %d buckets, freeing them...n", count));
  993. spin_lock_irqsave(&priv->rxfidx_lock, flags);
  994. for (i = 0; i < count; i++) {
  995. ctx = le32_to_cpu(pRecvRep->BucketContext[i]);
  997. skb = priv->RcvCtl[ctx].skb;
  999. // dlprintk((KERN_INFO MYNAM ": %s: dev_name = %sn",
  1000. // IOC_AND_NETDEV_NAMES_s_s(dev)));
  1001. // dlprintk((KERN_INFO MYNAM "@rpr[2], priv = %p, buckets_out addr = %p",
  1002. // priv, &(priv->buckets_out)));
  1003. // dlprintk((KERN_INFO MYNAM "@rpr[2] TC + 3n"));
  1005. priv->RcvCtl[ctx].skb = NULL;
  1006. pci_unmap_single(mpt_dev->pcidev, priv->RcvCtl[ctx].dma,
  1007.  priv->RcvCtl[ctx].len, PCI_DMA_FROMDEVICE);
  1008. dev_kfree_skb_any(skb);
  1010. priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = ctx;
  1011. }
  1012. spin_unlock_irqrestore(&priv->rxfidx_lock, flags);
  1014. atomic_sub(count, &priv->buckets_out);
  1016. // for (i = 0; i < priv->max_buckets_out; i++)
  1017. // if (priv->RcvCtl[i].skb != NULL)
  1018. // dlprintk((KERN_INFO MYNAM "@rpr: bucket %03x "
  1019. //   "is still outn", i));
  1021. /* dlprintk((KERN_INFO MYNAM "/receive_post_reply: freed %d bucketsn",
  1022.   count));
  1023. */
  1024. /**/ dlprintk((KERN_INFO MYNAM "@receive_post_reply: %d buckets "
  1025. /**/   "remaining, %d received back since sod.n",
  1026. /**/   atomic_read(&priv->buckets_out), priv->total_received));
  1027. return 0;
  1028. }
  1030. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  1031. static int
  1032. mpt_lan_receive_post_reply(struct net_device *dev,
  1033.    LANReceivePostReply_t *pRecvRep)
  1034. {
  1035. struct mpt_lan_priv *priv = dev->priv;
  1036. MPT_ADAPTER *mpt_dev = priv->mpt_dev;
  1037. struct sk_buff *skb, *old_skb;
  1038. unsigned long flags;
  1039. u32 len, ctx, offset;
  1040. u32 remaining = le32_to_cpu(pRecvRep->BucketsRemaining);
  1041. int count;
  1042. int i, l;
  1044. dioprintk((KERN_INFO MYNAM ": mpt_lan_receive_post_reply calledn"));
  1045. dioprintk((KERN_INFO MYNAM ": receive_post_reply: IOCStatus: %04xn",
  1046.  le16_to_cpu(pRecvRep->IOCStatus)));
  1048. if ((le16_to_cpu(pRecvRep->IOCStatus) & MPI_IOCSTATUS_MASK) ==
  1049. MPI_IOCSTATUS_LAN_CANCELED)
  1050. return mpt_lan_receive_post_free(dev, pRecvRep);
  1052. len = le32_to_cpu(pRecvRep->PacketLength);
  1053. if (len == 0) {
  1054. printk (KERN_ERR MYNAM ": %s/%s: ERROR - Got a non-TURBO "
  1055. "ReceivePostReply w/ PacketLength zero!n",
  1056. IOC_AND_NETDEV_NAMES_s_s(dev));
  1057. printk (KERN_ERR MYNAM ": MsgFlags = %02x, IOCStatus = %04xn",
  1058. pRecvRep->MsgFlags, le16_to_cpu(pRecvRep->IOCStatus));
  1059. return -1;
  1060. }
  1062. ctx    = le32_to_cpu(pRecvRep->BucketContext[0]);
  1063. count  = pRecvRep->NumberOfContexts;
  1064. skb    = priv->RcvCtl[ctx].skb;
  1066. offset = le32_to_cpu(pRecvRep->PacketOffset);
  1067. // if (offset != 0) {
  1068. // printk (KERN_INFO MYNAM ": %s/%s: Got a ReceivePostReply "
  1069. // "w/ PacketOffset %un",
  1070. // IOC_AND_NETDEV_NAMES_s_s(dev),
  1071. // offset);
  1072. // }
  1074. dioprintk((KERN_INFO MYNAM ": %s/%s: @rpr, offset = %d, len = %dn",
  1075. IOC_AND_NETDEV_NAMES_s_s(dev),
  1076. offset, len));
  1078. if (count > 1) {
  1079. int szrem = len;
  1081. // dioprintk((KERN_INFO MYNAM ": %s/%s: Multiple buckets returned "
  1082. // "for single packet, concatenating...n",
  1083. // IOC_AND_NETDEV_NAMES_s_s(dev)));
  1085. skb = (struct sk_buff *)dev_alloc_skb(len);
  1086. if (!skb) {
  1087. printk (KERN_ERR MYNAM ": %s/%s: ERROR - Can't allocate skb! (%s@%d)n",
  1088. IOC_AND_NETDEV_NAMES_s_s(dev),
  1089. __FILE__, __LINE__);
  1090. return -ENOMEM;
  1091. }
  1093. spin_lock_irqsave(&priv->rxfidx_lock, flags);
  1094. for (i = 0; i < count; i++) {
  1096. ctx = le32_to_cpu(pRecvRep->BucketContext[i]);
  1097. old_skb = priv->RcvCtl[ctx].skb;
  1099. l = priv->RcvCtl[ctx].len;
  1100. if (szrem < l)
  1101. l = szrem;
  1103. // dioprintk((KERN_INFO MYNAM ": %s/%s: Buckets = %d, len = %un",
  1104. // IOC_AND_NETDEV_NAMES_s_s(dev),
  1105. // i, l));
  1107. pci_dma_sync_single(mpt_dev->pcidev,
  1108.     priv->RcvCtl[ctx].dma,
  1109.     priv->RcvCtl[ctx].len,
  1110.     PCI_DMA_FROMDEVICE);
  1111. memcpy(skb_put(skb, l), old_skb->data, l);
  1113. priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = ctx;
  1114. szrem -= l;
  1115. }
  1116. spin_unlock_irqrestore(&priv->rxfidx_lock, flags);
  1118. } else if (len < MPT_LAN_RX_COPYBREAK) {
  1120. old_skb = skb;
  1122. skb = (struct sk_buff *)dev_alloc_skb(len);
  1123. if (!skb) {
  1124. printk (KERN_ERR MYNAM ": %s/%s: ERROR - Can't allocate skb! (%s@%d)n",
  1125. IOC_AND_NETDEV_NAMES_s_s(dev),
  1126. __FILE__, __LINE__);
  1127. return -ENOMEM;
  1128. }
  1130. pci_dma_sync_single(mpt_dev->pcidev, priv->RcvCtl[ctx].dma,
  1131.     priv->RcvCtl[ctx].len, PCI_DMA_FROMDEVICE);
  1133. memcpy(skb_put(skb, len), old_skb->data, len);
  1135. spin_lock_irqsave(&priv->rxfidx_lock, flags);
  1136. priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = ctx;
  1137. spin_unlock_irqrestore(&priv->rxfidx_lock, flags);
  1139. } else {
  1140. spin_lock_irqsave(&priv->rxfidx_lock, flags);
  1142. priv->RcvCtl[ctx].skb = NULL;
  1144. pci_unmap_single(mpt_dev->pcidev, priv->RcvCtl[ctx].dma,
  1145.  priv->RcvCtl[ctx].len, PCI_DMA_FROMDEVICE);
  1146. priv->RcvCtl[ctx].dma = 0;
  1148. priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = ctx;
  1149. spin_unlock_irqrestore(&priv->rxfidx_lock, flags);
  1151. skb_put(skb,len);
  1152. }
  1154. atomic_sub(count, &priv->buckets_out);
  1155. priv->total_received += count;
  1157. if (priv->mpt_rxfidx_tail >= MPT_LAN_MAX_BUCKETS_OUT) {
  1158. printk (KERN_ERR MYNAM ": %s/%s: Yoohoo! mpt_rxfidx_tail = %d, "
  1159. "MPT_LAN_MAX_BUCKETS_OUT = %dn",
  1160. IOC_AND_NETDEV_NAMES_s_s(dev),
  1161. priv->mpt_rxfidx_tail,
  1162. MPT_LAN_MAX_BUCKETS_OUT);
  1164. panic("Damn it Jim! I'm a doctor, not a programmer! "
  1165. "Oh, wait a sec, I am a programmer. "
  1166. "And, who's Jim?!?!n"
  1167. "Arrgghh! We've done it again!n");
  1168. }
  1170. if (remaining == 0)
  1171. printk (KERN_WARNING MYNAM ": %s/%s: WARNING - IOC out of buckets! "
  1172. "(priv->buckets_out = %d)n",
  1173. IOC_AND_NETDEV_NAMES_s_s(dev),
  1174. atomic_read(&priv->buckets_out));
  1175. else if (remaining < 10)
  1176. printk (KERN_INFO MYNAM ": %s/%s: IOC says %d buckets left. "
  1177. "(priv->buckets_out = %d)n",
  1178. IOC_AND_NETDEV_NAMES_s_s(dev),
  1179. remaining, atomic_read(&priv->buckets_out));
  1181. if ((remaining < priv->bucketthresh) &&
  1182.     ((atomic_read(&priv->buckets_out) - remaining) > 
  1183.      MPT_LAN_BUCKETS_REMAIN_MISMATCH_THRESH)) {
  1185. printk (KERN_WARNING MYNAM " Mismatch between driver's "
  1186. "buckets_out count and fw's BucketsRemaining "
  1187. "count has crossed the threshold, issuing a "
  1188. "LanReset to clear the fw's hashtable. You may "
  1189. "want to check your /var/log/messages for "CRC "
  1190. "error" event notifications.n");
  1192. mpt_lan_reset(dev);
  1193. mpt_lan_wake_post_buckets_task(dev, 0);
  1194. }
  1196. return mpt_lan_receive_skb(dev, skb);
  1197. }
  1199. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  1200. /* Simple SGE's only at the moment */
  1202. static void
  1203. mpt_lan_post_receive_buckets(void *dev_id)
  1204. {
  1205. struct net_device *dev = dev_id;
  1206. struct mpt_lan_priv *priv = dev->priv;
  1207. MPT_ADAPTER *mpt_dev = priv->mpt_dev;
  1208. MPT_FRAME_HDR *mf;
  1209. LANReceivePostRequest_t *pRecvReq;
  1210. SGETransaction32_t *pTrans;
  1211. SGESimple64_t *pSimple;
  1212. struct sk_buff *skb;
  1213. dma_addr_t dma;
  1214. u32 curr, buckets, count, max;
  1215. u32 len = (dev->mtu + dev->hard_header_len + 4);
  1216. unsigned long flags;
  1217. int i;
  1219. curr = atomic_read(&priv->buckets_out);
  1220. buckets = (priv->max_buckets_out - curr);
  1222. dioprintk((KERN_INFO MYNAM ": %s/%s: @%s, Start_buckets = %u, buckets_out = %un",
  1223. IOC_AND_NETDEV_NAMES_s_s(dev),
  1224. __FUNCTION__, buckets, curr));
  1226. max = (mpt_dev->req_sz - MPT_LAN_RECEIVE_POST_REQUEST_SIZE) /
  1227. (MPT_LAN_TRANSACTION32_SIZE + sizeof(SGESimple64_t));
  1229. while (buckets) {
  1230. mf = mpt_get_msg_frame(LanCtx, mpt_dev->id);
  1231. if (mf == NULL) {
  1232. printk (KERN_ERR "%s: Unable to alloc request framen",
  1233. __FUNCTION__);
  1234. dioprintk((KERN_ERR "%s: %u buckets remainingn",
  1235.  __FUNCTION__, buckets));
  1236. goto out;
  1237. }
  1238. pRecvReq = (LANReceivePostRequest_t *) mf;
  1240. count = buckets;
  1241. if (count > max)
  1242. count = max;
  1244. pRecvReq->Function    = MPI_FUNCTION_LAN_RECEIVE;
  1245. pRecvReq->ChainOffset = 0;
  1246. pRecvReq->MsgFlags    = 0;
  1247. pRecvReq->PortNumber  = priv->pnum;
  1249. pTrans = (SGETransaction32_t *) pRecvReq->SG_List;
  1250. pSimple = NULL;
  1252. for (i = 0; i < count; i++) {
  1253. int ctx;
  1255. spin_lock_irqsave(&priv->rxfidx_lock, flags);
  1256. if (priv->mpt_rxfidx_tail < 0) {
  1257. printk (KERN_ERR "%s: Can't alloc contextn",
  1258. __FUNCTION__);
  1259. spin_unlock_irqrestore(&priv->rxfidx_lock,
  1260.        flags);
  1261. break;
  1262. }
  1264. ctx = priv->mpt_rxfidx[priv->mpt_rxfidx_tail--];
  1266. skb = priv->RcvCtl[ctx].skb;
  1267. if (skb && (priv->RcvCtl[ctx].len != len)) {
  1268. pci_unmap_single(mpt_dev->pcidev,
  1269.  priv->RcvCtl[ctx].dma,
  1270.  priv->RcvCtl[ctx].len,
  1271.  PCI_DMA_FROMDEVICE);
  1272. dev_kfree_skb(priv->RcvCtl[ctx].skb);
  1273. skb = priv->RcvCtl[ctx].skb = NULL;
  1274. }
  1276. if (skb == NULL) {
  1277. skb = dev_alloc_skb(len);
  1278. if (skb == NULL) {
  1279. printk (KERN_WARNING
  1280. MYNAM "/%s: Can't alloc skbn",
  1281. __FUNCTION__);
  1282. priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = ctx;
  1283. spin_unlock_irqrestore(&priv->rxfidx_lock, flags);
  1284. break;
  1285. }
  1287. dma = pci_map_single(mpt_dev->pcidev, skb->data,
  1288.      len, PCI_DMA_FROMDEVICE);
  1290. priv->RcvCtl[ctx].skb = skb;
  1291. priv->RcvCtl[ctx].dma = dma;
  1292. priv->RcvCtl[ctx].len = len;
  1293. }
  1295. spin_unlock_irqrestore(&priv->rxfidx_lock, flags);
  1297. pTrans->ContextSize   = sizeof(u32);
  1298. pTrans->DetailsLength = 0;
  1299. pTrans->Flags         = 0;
  1300. pTrans->TransactionContext[0] = cpu_to_le32(ctx);
  1302. pSimple = (SGESimple64_t *) pTrans->TransactionDetails;
  1304. pSimple->FlagsLength = cpu_to_le32(
  1305. ((MPI_SGE_FLAGS_END_OF_BUFFER |
  1306.   MPI_SGE_FLAGS_SIMPLE_ELEMENT |
  1307.   MPI_SGE_FLAGS_64_BIT_ADDRESSING) << MPI_SGE_FLAGS_SHIFT) | len);
  1308. pSimple->Address.Low = cpu_to_le32((u32) priv->RcvCtl[ctx].dma);
  1309. if (sizeof(dma_addr_t) > sizeof(u32))
  1310. pSimple->Address.High = cpu_to_le32((u32) ((u64) priv->RcvCtl[ctx].dma >> 32));
  1311. else
  1312. pSimple->Address.High = 0;
  1314. pTrans = (SGETransaction32_t *) (pSimple + 1);
  1315. }
  1317. if (pSimple == NULL) {
  1318. /**/ printk (KERN_WARNING MYNAM "/%s: No buckets postedn",
  1319. /**/ __FUNCTION__);
  1320. mpt_free_msg_frame(LanCtx, mpt_dev->id, mf);
  1321. goto out;
  1322. }
  1324. pSimple->FlagsLength |= cpu_to_le32(MPI_SGE_FLAGS_END_OF_LIST << MPI_SGE_FLAGS_SHIFT);
  1326. pRecvReq->BucketCount = cpu_to_le32(i);
  1328. /* printk(KERN_INFO MYNAM ": posting bucketsn   ");
  1329.  * for (i = 0; i < j + 2; i ++)
  1330.  *     printk (" %08x", le32_to_cpu(msg[i]));
  1331.  * printk ("n");
  1332.  */
  1334. mpt_put_msg_frame(LanCtx, mpt_dev->id, mf);
  1336. priv->total_posted += i;
  1337. buckets -= i;
  1338. atomic_add(i, &priv->buckets_out);
  1339. }
  1341. out:
  1342. dioprintk((KERN_INFO MYNAM "/%s: End_buckets = %u, priv->buckets_out = %un",
  1343.   __FUNCTION__, buckets, atomic_read(&priv->buckets_out)));
  1344. dioprintk((KERN_INFO MYNAM "/%s: Posted %u buckets and received %u backn",
  1345. __FUNCTION__, priv->total_posted, priv->total_received));
  1347. clear_bit(0, &priv->post_buckets_active);
  1348. }
  1350. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  1351. struct net_device *
  1352. mpt_register_lan_device (MPT_ADAPTER *mpt_dev, int pnum)
  1353. {
  1354. struct net_device *dev = NULL;
  1355. struct mpt_lan_priv *priv = NULL;
  1356. u8 HWaddr[FC_ALEN], *a;
  1358. dev = init_fcdev(NULL, sizeof(struct mpt_lan_priv));
  1359. if (!dev)
  1360. return (NULL);
  1361. dev->mtu = MPT_LAN_MTU;
  1363. priv = (struct mpt_lan_priv *) dev->priv;
  1365. priv->mpt_dev = mpt_dev;
  1366. priv->pnum = pnum;
  1368. memset(&priv->post_buckets_task, 0, sizeof(struct tq_struct));
  1369. priv->post_buckets_task.routine = mpt_lan_post_receive_buckets;
  1370. priv->post_buckets_task.data = dev;
  1371. priv->post_buckets_active = 0;
  1373. dlprintk((KERN_INFO MYNAM "@%d: bucketlen = %dn",
  1374. __LINE__, dev->mtu + dev->hard_header_len + 4));
  1376. atomic_set(&priv->buckets_out, 0);
  1377. priv->total_posted = 0;
  1378. priv->total_received = 0;
  1379. priv->max_buckets_out = max_buckets_out;
  1380. if (mpt_dev->pfacts[0].MaxLanBuckets < max_buckets_out)
  1381. priv->max_buckets_out = mpt_dev->pfacts[0].MaxLanBuckets;
  1383. dlprintk((KERN_INFO MYNAM "@%d: MaxLanBuckets=%d, max_buckets_out/priv=%d/%dn",
  1384. __LINE__,
  1385. mpt_dev->pfacts[0].MaxLanBuckets,
  1386. max_buckets_out,
  1387. priv->max_buckets_out));
  1389. priv->bucketthresh = priv->max_buckets_out * 2 / 3;
  1390. priv->txfidx_lock = SPIN_LOCK_UNLOCKED;
  1391. priv->rxfidx_lock = SPIN_LOCK_UNLOCKED;
  1393. memset(&priv->stats, 0, sizeof(priv->stats));
  1395. /*  Grab pre-fetched LANPage1 stuff. :-) */
  1396. a = (u8 *) &mpt_dev->lan_cnfg_page1.HardwareAddressLow;
  1398. HWaddr[0] = a[5];
  1399. HWaddr[1] = a[4];
  1400. HWaddr[2] = a[3];
  1401. HWaddr[3] = a[2];
  1402. HWaddr[4] = a[1];
  1403. HWaddr[5] = a[0];
  1405. dev->addr_len = FC_ALEN;
  1406. memcpy(dev->dev_addr, HWaddr, FC_ALEN);
  1407. memset(dev->broadcast, 0xff, FC_ALEN);
  1409. /* The Tx queue is 127 deep on the 909.
  1410.  * Give ourselves some breathing room.
  1411.  */
  1412. priv->tx_max_out = (tx_max_out_p <= MPT_TX_MAX_OUT_LIM) ?
  1413.     tx_max_out_p : MPT_TX_MAX_OUT_LIM;
  1415. dev->open = mpt_lan_open;
  1416. dev->stop = mpt_lan_close;
  1417. dev->get_stats = mpt_lan_get_stats;
  1418. dev->set_multicast_list = NULL;
  1419. dev->change_mtu = mpt_lan_change_mtu;
  1420. dev->hard_start_xmit = mpt_lan_sdu_send;
  1422. /* Not in 2.3.42. Need 2.3.45+ */
  1423. dev->tx_timeout = mpt_lan_tx_timeout;
  1424. dev->watchdog_timeo = MPT_LAN_TX_TIMEOUT;
  1426. dlprintk((KERN_INFO MYNAM ": Finished registering dev "
  1427. "and setting initial valuesn"));
  1429. SET_MODULE_OWNER(dev);
  1431. return dev;
  1432. }
  1434. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  1435. int __init
  1436. mpt_lan_init (void)
  1437. {
  1438. struct net_device *dev;
  1439. MPT_ADAPTER *curadapter;
  1440. int i, j;
  1442. show_mptmod_ver(LANAME, LANVER);
  1444. #ifdef QLOGIC_NAA_WORKAROUND
  1445. /* Init the global r/w lock for the bad_naa list. We want to do this
  1446.    before any boards are initialized and may be used. */
  1447. rwlock_init(&bad_naa_lock);
  1448. #endif
  1450. if ((LanCtx = mpt_register(lan_reply, MPTLAN_DRIVER)) <= 0) {
  1451. printk (KERN_ERR MYNAM ": Failed to register with MPT base drivern");
  1452. return -EBUSY;
  1453. }
  1455. /* Set the callback index to be used by driver core for turbo replies */
  1456. mpt_lan_index = LanCtx;
  1458. dlprintk((KERN_INFO MYNAM ": assigned context of %dn", LanCtx));
  1460. if (mpt_reset_register(LanCtx, mpt_lan_ioc_reset) == 0) {
  1461. dlprintk((KERN_INFO MYNAM ": Registered for IOC reset notificationsn"));
  1462. } else {
  1463. printk(KERN_ERR MYNAM ": Eieee! unable to register a reset "
  1464.        "handler with mptbase! The world is at an end! "
  1465.        "Everything is fading to black! Goodbye.n");
  1466. return -EBUSY;
  1467. }
  1469. for (j = 0; j < MPT_MAX_ADAPTERS; j++) {
  1470. mpt_landev[j] = NULL;
  1471. }
  1473. curadapter = mpt_adapter_find_first();
  1474. while (curadapter != NULL) {
  1475. for (i = 0; i < curadapter->facts.NumberOfPorts; i++) {
  1476. printk (KERN_INFO MYNAM ": %s: PortNum=%x, ProtocolFlags=%02Xh (%c%c%c%c)n",
  1477. curadapter->name,
  1478. curadapter->pfacts[i].PortNumber,
  1479. curadapter->pfacts[i].ProtocolFlags,
  1480. MPT_PROTOCOL_FLAGS_c_c_c_c(curadapter->pfacts[i].ProtocolFlags));
  1482. if (curadapter->pfacts[i].ProtocolFlags & MPI_PORTFACTS_PROTOCOL_LAN) {
  1483. dev = mpt_register_lan_device (curadapter, i);
  1484. if (dev != NULL) {
  1485. printk (KERN_INFO MYNAM ": %s: Fusion MPT LAN device registered as '%s'n",
  1486. curadapter->name, dev->name);
  1487. printk (KERN_INFO MYNAM ": %s/%s: LanAddr = %02X:%02X:%02X:%02X:%02X:%02Xn",
  1488. IOC_AND_NETDEV_NAMES_s_s(dev),
  1489. dev->dev_addr[0], dev->dev_addr[1],
  1490. dev->dev_addr[2], dev->dev_addr[3],
  1491. dev->dev_addr[4], dev->dev_addr[5]);
  1492. // printk (KERN_INFO MYNAM ": %s/%s: Max_TX_outstanding = %dn",
  1493. // IOC_AND_NETDEV_NAMES_s_s(dev),
  1494. // NETDEV_TO_LANPRIV_PTR(dev)->tx_max_out);
  1495. j = curadapter->id;
  1496. mpt_landev[j] = dev;
  1497. dlprintk((KERN_INFO MYNAM "/init: dev_addr=%p, mpt_landev[%d]=%pn",
  1498. dev, j,  mpt_landev[j]));
  1500. } else {
  1501. printk (KERN_ERR MYNAM ": %s: Unable to register port%d as a LAN devicen",
  1502. curadapter->name,
  1503. curadapter->pfacts[i].PortNumber);
  1504. }
  1505. } else {
  1506. printk (KERN_INFO MYNAM ": %s: Hmmm... LAN protocol seems to be disabled on this adapter port!n",
  1507. curadapter->name);
  1508. }
  1509. }
  1510. curadapter = mpt_adapter_find_next(curadapter);
  1511. }
  1513. return 0;
  1514. }
  1516. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  1517. void __init mpt_lan_exit(void)
  1518. {
  1519. int i;
  1521. mpt_reset_deregister(LanCtx);
  1523. for (i = 0; mpt_landev[i] != NULL; i++) {
  1524. struct net_device *dev = mpt_landev[i];
  1526. printk (KERN_INFO MYNAM ": %s/%s: Fusion MPT LAN device unregisteredn",
  1527.        IOC_AND_NETDEV_NAMES_s_s(dev));
  1528. unregister_fcdev(dev);
  1529. mpt_landev[i] = (struct net_device *) 0xdeadbeef; /* Debug */
  1530. }
  1532. if (LanCtx >= 0) {
  1533. mpt_deregister(LanCtx);
  1534. LanCtx = -1;
  1535. mpt_lan_index = 0;
  1536. }
  1538. /* deregister any send/receive handler structs. I2Oism? */
  1539. }
  1541. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  1543. MODULE_PARM(tx_max_out_p, "i");
  1544. MODULE_PARM(max_buckets_out, "i"); // Debug stuff. FIXME!
  1546. module_init(mpt_lan_init);
  1547. module_exit(mpt_lan_exit);
  1549. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  1550. static unsigned short
  1551. mpt_lan_type_trans(struct sk_buff *skb, struct net_device *dev)
  1552. {
  1553. struct mpt_lan_ohdr *fch = (struct mpt_lan_ohdr *)skb->data;
  1554. struct fcllc *fcllc;
  1556. skb->mac.raw = skb->data;
  1557. skb_pull(skb, sizeof(struct mpt_lan_ohdr));
  1559. if (fch->dtype == htons(0xffff)) {
  1560. u32 *p = (u32 *) fch;
  1562. swab32s(p + 0);
  1563. swab32s(p + 1);
  1564. swab32s(p + 2);
  1565. swab32s(p + 3);
  1567. printk (KERN_WARNING MYNAM ": %s: WARNING - Broadcast swap F/W bug detected!n",
  1568. NETDEV_PTR_TO_IOC_NAME_s(dev));
  1569. printk (KERN_WARNING MYNAM ": Please update sender @ MAC_addr = %02x:%02x:%02x:%02x:%02x:%02xn",
  1570. fch->saddr[0], fch->saddr[1], fch->saddr[2],
  1571. fch->saddr[3], fch->saddr[4], fch->saddr[5]);
  1572. }
  1574. if (*fch->daddr & 1) {
  1575. if (!memcmp(fch->daddr, dev->broadcast, FC_ALEN)) {
  1576. skb->pkt_type = PACKET_BROADCAST;
  1577. } else {
  1578. skb->pkt_type = PACKET_MULTICAST;
  1579. }
  1580. } else {
  1581. if (memcmp(fch->daddr, dev->dev_addr, FC_ALEN)) {
  1582. skb->pkt_type = PACKET_OTHERHOST;
  1583. } else {
  1584. skb->pkt_type = PACKET_HOST;
  1585. }
  1586. }
  1588. fcllc = (struct fcllc *)skb->data;
  1590. #ifdef QLOGIC_NAA_WORKAROUND
  1591. {
  1592. u16 source_naa = fch->stype, found = 0;
  1594. /* Workaround for QLogic not following RFC 2625 in regards to the NAA
  1595.    value. */
  1597. if ((source_naa & 0xF000) == 0)
  1598. source_naa = swab16(source_naa);
  1600. if (fcllc->ethertype == htons(ETH_P_ARP))
  1601.     dlprintk ((KERN_INFO "mptlan/type_trans: got arp req/rep w/ naa of "
  1602.       "%04x.n", source_naa));
  1604. if ((fcllc->ethertype == htons(ETH_P_ARP)) &&
  1605.    ((source_naa >> 12) !=  MPT_LAN_NAA_RFC2625)){
  1606. struct NAA_Hosed *nh, *prevnh;
  1607. int i;
  1609. dlprintk ((KERN_INFO "mptlan/type_trans: ARP Req/Rep from "
  1610.   "system with non-RFC 2625 NAA value (%04x).n",
  1611.   source_naa));
  1613. write_lock_irq(&bad_naa_lock);
  1614. for (prevnh = nh = mpt_bad_naa; nh != NULL;
  1615.      prevnh=nh, nh=nh->next) {
  1616. if ((nh->ieee[0] == fch->saddr[0]) &&
  1617.     (nh->ieee[1] == fch->saddr[1]) &&
  1618.     (nh->ieee[2] == fch->saddr[2]) &&
  1619.     (nh->ieee[3] == fch->saddr[3]) &&
  1620.     (nh->ieee[4] == fch->saddr[4]) &&
  1621.     (nh->ieee[5] == fch->saddr[5])) {
  1622. found = 1;
  1623. dlprintk ((KERN_INFO "mptlan/type_trans: ARP Re"
  1624.  "q/Rep w/ bad NAA from system already"
  1625.  " in DB.n"));
  1626. break;
  1627. }
  1628. }
  1630. if ((!found) && (nh == NULL)) {
  1632. nh = kmalloc(sizeof(struct NAA_Hosed), GFP_KERNEL);
  1633. dlprintk ((KERN_INFO "mptlan/type_trans: ARP Req/Rep w/"
  1634.  " bad NAA from system not yet in DB.n"));
  1636. if (nh != NULL) {
  1637. nh->next = NULL;
  1638. if (!mpt_bad_naa)
  1639. mpt_bad_naa = nh;
  1640. if (prevnh)
  1641. prevnh->next = nh;
  1643. nh->NAA = source_naa; /* Set the S_NAA value. */
  1644. for (i = 0; i < FC_ALEN; i++)
  1645. nh->ieee[i] = fch->saddr[i];
  1646. dlprintk ((KERN_INFO "Got ARP from %02x:%02x:%02x:%02x:"
  1647.   "%02x:%02x with non-compliant S_NAA value.n",
  1648.   fch->saddr[0], fch->saddr[1], fch->saddr[2],
  1649.   fch->saddr[3], fch->saddr[4],fch->saddr[5]));
  1650. } else {
  1651. printk (KERN_ERR "mptlan/type_trans: Unable to"
  1652. " kmalloc a NAA_Hosed struct.n");
  1653. }
  1654. } else if (!found) {
  1655. printk (KERN_ERR "mptlan/type_trans: found not"
  1656. " set, but nh isn't null. Evil "
  1657. "funkiness abounds.n");
  1658. }
  1659. write_unlock_irq(&bad_naa_lock);
  1660. }
  1661. }
  1662. #endif
  1664. /* Strip the SNAP header from ARP packets since we don't
  1665.  * pass them through to the 802.2/SNAP layers.
  1666.  */
  1667. if (fcllc->dsap == EXTENDED_SAP &&
  1668. (fcllc->ethertype == htons(ETH_P_IP) ||
  1669.  fcllc->ethertype == htons(ETH_P_ARP))) {
  1670. skb_pull(skb, sizeof(struct fcllc));
  1671. return fcllc->ethertype;
  1672. }
  1674. return htons(ETH_P_802_2);
  1675. }
  1677. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/