?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[SCSI] aic79xx: remove extra newline from info message
[linux-2.6/zen-sources.git] / drivers / net / qla3xxx.c
bloba142cdfd947b961f0420ce74a0339de272c5b8b0
1 /*
2 * QLogic QLA3xxx NIC HBA Driver
3 * Copyright (c) 2003-2006 QLogic Corporation
4 *
5 * See LICENSE.qla3xxx for copyright and licensing details.
6 */
7
8 #include <linux/kernel.h>
9 #include <linux/init.h>
10 #include <linux/types.h>
11 #include <linux/module.h>
12 #include <linux/list.h>
13 #include <linux/pci.h>
14 #include <linux/dma-mapping.h>
15 #include <linux/sched.h>
16 #include <linux/slab.h>
17 #include <linux/dmapool.h>
18 #include <linux/mempool.h>
19 #include <linux/spinlock.h>
20 #include <linux/kthread.h>
21 #include <linux/interrupt.h>
22 #include <linux/errno.h>
23 #include <linux/ioport.h>
24 #include <linux/ip.h>
25 #include <linux/in.h>
26 #include <linux/if_arp.h>
27 #include <linux/if_ether.h>
28 #include <linux/netdevice.h>
29 #include <linux/etherdevice.h>
30 #include <linux/ethtool.h>
31 #include <linux/skbuff.h>
32 #include <linux/rtnetlink.h>
33 #include <linux/if_vlan.h>
34 #include <linux/init.h>
35 #include <linux/delay.h>
36 #include <linux/mm.h>
37
38 #include "qla3xxx.h"
39
40 #define DRV_NAME "qla3xxx"
41 #define DRV_STRING "QLogic ISP3XXX Network Driver"
42 #define DRV_VERSION "v2.02.00-k36"
43 #define PFX DRV_NAME " "
44
45 static const char ql3xxx_driver_name[] = DRV_NAME;
46 static const char ql3xxx_driver_version[] = DRV_VERSION;
47
48 MODULE_AUTHOR("QLogic Corporation");
49 MODULE_DESCRIPTION("QLogic ISP3XXX Network Driver " DRV_VERSION " ");
50 MODULE_LICENSE("GPL");
51 MODULE_VERSION(DRV_VERSION);
52
53 static const u32 default_msg
54 = NETIF_MSG_DRV | NETIF_MSG_PROBE | NETIF_MSG_LINK
55 | NETIF_MSG_IFUP | NETIF_MSG_IFDOWN;
56
57 static int debug = -1; /* defaults above */
58 module_param(debug, int, 0);
59 MODULE_PARM_DESC(debug, "Debug level (0=none,...,16=all)");
60
61 static int msi;
62 module_param(msi, int, 0);
63 MODULE_PARM_DESC(msi, "Turn on Message Signaled Interrupts.");
64
65 static struct pci_device_id ql3xxx_pci_tbl[] __devinitdata = {
66 {PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, QL3022_DEVICE_ID)},
67 {PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, QL3032_DEVICE_ID)},
68 /* required last entry */
69 {0,}
70 };
71
72 MODULE_DEVICE_TABLE(pci, ql3xxx_pci_tbl);
73
74 /*
75 * Caller must take hw_lock.
76 */
77 static int ql_sem_spinlock(struct ql3_adapter *qdev,
78 u32 sem_mask, u32 sem_bits)
79 {
80 struct ql3xxx_port_registers __iomem *port_regs = qdev->mem_map_registers;
81 u32 value;
82 unsigned int seconds = 3;
83
84 do {
85 writel((sem_mask | sem_bits),
86 &port_regs->CommonRegs.semaphoreReg);
87 value = readl(&port_regs->CommonRegs.semaphoreReg);
88 if ((value & (sem_mask >> 16)) == sem_bits)
89 return 0;
90 ssleep(1);
91 } while(--seconds);
92 return -1;
93 }
94
95 static void ql_sem_unlock(struct ql3_adapter *qdev, u32 sem_mask)
96 {
97 struct ql3xxx_port_registers __iomem *port_regs = qdev->mem_map_registers;
98 writel(sem_mask, &port_regs->CommonRegs.semaphoreReg);
99 readl(&port_regs->CommonRegs.semaphoreReg);
100 }
101
102 static int ql_sem_lock(struct ql3_adapter *qdev, u32 sem_mask, u32 sem_bits)
103 {
104 struct ql3xxx_port_registers __iomem *port_regs = qdev->mem_map_registers;
105 u32 value;
106
107 writel((sem_mask | sem_bits), &port_regs->CommonRegs.semaphoreReg);
108 value = readl(&port_regs->CommonRegs.semaphoreReg);
109 return ((value & (sem_mask >> 16)) == sem_bits);
110 }
111
112 /*
113 * Caller holds hw_lock.
114 */
115 static int ql_wait_for_drvr_lock(struct ql3_adapter *qdev)
116 {
117 int i = 0;
118
119 while (1) {
120 if (!ql_sem_lock(qdev,
121 QL_DRVR_SEM_MASK,
122 (QL_RESOURCE_BITS_BASE_CODE | (qdev->mac_index)
123 * 2) << 1)) {
124 if (i < 10) {
125 ssleep(1);
126 i++;
127 } else {
128 printk(KERN_ERR PFX "%s: Timed out waiting for "
129 "driver lock...\n",
130 qdev->ndev->name);
131 return 0;
132 }
133 } else {
134 printk(KERN_DEBUG PFX
135 "%s: driver lock acquired.\n",
136 qdev->ndev->name);
137 return 1;
138 }
139 }
140 }
141
142 static void ql_set_register_page(struct ql3_adapter *qdev, u32 page)
143 {
144 struct ql3xxx_port_registers __iomem *port_regs = qdev->mem_map_registers;
145
146 writel(((ISP_CONTROL_NP_MASK << 16) | page),
147 &port_regs->CommonRegs.ispControlStatus);
148 readl(&port_regs->CommonRegs.ispControlStatus);
149 qdev->current_page = page;
150 }
151
152 static u32 ql_read_common_reg_l(struct ql3_adapter *qdev,
153 u32 __iomem * reg)
154 {
155 u32 value;
156 unsigned long hw_flags;
157
158 spin_lock_irqsave(&qdev->hw_lock, hw_flags);
159 value = readl(reg);
160 spin_unlock_irqrestore(&qdev->hw_lock, hw_flags);
161
162 return value;
163 }
164
165 static u32 ql_read_common_reg(struct ql3_adapter *qdev,
166 u32 __iomem * reg)
167 {
168 return readl(reg);
169 }
170
171 static u32 ql_read_page0_reg_l(struct ql3_adapter *qdev, u32 __iomem *reg)
172 {
173 u32 value;
174 unsigned long hw_flags;
175
176 spin_lock_irqsave(&qdev->hw_lock, hw_flags);
177
178 if (qdev->current_page != 0)
179 ql_set_register_page(qdev,0);
180 value = readl(reg);
181
182 spin_unlock_irqrestore(&qdev->hw_lock, hw_flags);
183 return value;
184 }
185
186 static u32 ql_read_page0_reg(struct ql3_adapter *qdev, u32 __iomem *reg)
187 {
188 if (qdev->current_page != 0)
189 ql_set_register_page(qdev,0);
190 return readl(reg);
191 }
192
193 static void ql_write_common_reg_l(struct ql3_adapter *qdev,
194 u32 __iomem *reg, u32 value)
195 {
196 unsigned long hw_flags;
197
198 spin_lock_irqsave(&qdev->hw_lock, hw_flags);
199 writel(value, reg);
200 readl(reg);
201 spin_unlock_irqrestore(&qdev->hw_lock, hw_flags);
202 return;
203 }
204
205 static void ql_write_common_reg(struct ql3_adapter *qdev,
206 u32 __iomem *reg, u32 value)
207 {
208 writel(value, reg);
209 readl(reg);
210 return;
211 }
212
213 static void ql_write_nvram_reg(struct ql3_adapter *qdev,
214 u32 __iomem *reg, u32 value)
215 {
216 writel(value, reg);
217 readl(reg);
218 udelay(1);
219 return;
220 }
221
222 static void ql_write_page0_reg(struct ql3_adapter *qdev,
223 u32 __iomem *reg, u32 value)
224 {
225 if (qdev->current_page != 0)
226 ql_set_register_page(qdev,0);
227 writel(value, reg);
228 readl(reg);
229 return;
230 }
231
232 /*
233 * Caller holds hw_lock. Only called during init.
234 */
235 static void ql_write_page1_reg(struct ql3_adapter *qdev,
236 u32 __iomem *reg, u32 value)
237 {
238 if (qdev->current_page != 1)
239 ql_set_register_page(qdev,1);
240 writel(value, reg);
241 readl(reg);
242 return;
243 }
244
245 /*
246 * Caller holds hw_lock. Only called during init.
247 */
248 static void ql_write_page2_reg(struct ql3_adapter *qdev,
249 u32 __iomem *reg, u32 value)
250 {
251 if (qdev->current_page != 2)
252 ql_set_register_page(qdev,2);
253 writel(value, reg);
254 readl(reg);
255 return;
256 }
257
258 static void ql_disable_interrupts(struct ql3_adapter *qdev)
259 {
260 struct ql3xxx_port_registers __iomem *port_regs = qdev->mem_map_registers;
261
262 ql_write_common_reg_l(qdev, &port_regs->CommonRegs.ispInterruptMaskReg,
263 (ISP_IMR_ENABLE_INT << 16));
264
265 }
266
267 static void ql_enable_interrupts(struct ql3_adapter *qdev)
268 {
269 struct ql3xxx_port_registers __iomem *port_regs = qdev->mem_map_registers;
270
271 ql_write_common_reg_l(qdev, &port_regs->CommonRegs.ispInterruptMaskReg,
272 ((0xff << 16) | ISP_IMR_ENABLE_INT));
273
274 }
275
276 static void ql_release_to_lrg_buf_free_list(struct ql3_adapter *qdev,
277 struct ql_rcv_buf_cb *lrg_buf_cb)
278 {
279 u64 map;
280 lrg_buf_cb->next = NULL;
281
282 if (qdev->lrg_buf_free_tail == NULL) { /* The list is empty */
283 qdev->lrg_buf_free_head = qdev->lrg_buf_free_tail = lrg_buf_cb;
284 } else {
285 qdev->lrg_buf_free_tail->next = lrg_buf_cb;
286 qdev->lrg_buf_free_tail = lrg_buf_cb;
287 }
288
289 if (!lrg_buf_cb->skb) {
290 lrg_buf_cb->skb = dev_alloc_skb(qdev->lrg_buffer_len);
291 if (unlikely(!lrg_buf_cb->skb)) {
292 printk(KERN_ERR PFX "%s: failed dev_alloc_skb().\n",
293 qdev->ndev->name);
294 qdev->lrg_buf_skb_check++;
295 } else {
296 /*
297 * We save some space to copy the ethhdr from first
298 * buffer
299 */
300 skb_reserve(lrg_buf_cb->skb, QL_HEADER_SPACE);
301 map = pci_map_single(qdev->pdev,
302 lrg_buf_cb->skb->data,
303 qdev->lrg_buffer_len -
304 QL_HEADER_SPACE,
305 PCI_DMA_FROMDEVICE);
306 lrg_buf_cb->buf_phy_addr_low =
307 cpu_to_le32(LS_64BITS(map));
308 lrg_buf_cb->buf_phy_addr_high =
309 cpu_to_le32(MS_64BITS(map));
310 pci_unmap_addr_set(lrg_buf_cb, mapaddr, map);
311 pci_unmap_len_set(lrg_buf_cb, maplen,
312 qdev->lrg_buffer_len -
313 QL_HEADER_SPACE);
314 }
315 }
316
317 qdev->lrg_buf_free_count++;
318 }
319
320 static struct ql_rcv_buf_cb *ql_get_from_lrg_buf_free_list(struct ql3_adapter
321 *qdev)
322 {
323 struct ql_rcv_buf_cb *lrg_buf_cb;
324
325 if ((lrg_buf_cb = qdev->lrg_buf_free_head) != NULL) {
326 if ((qdev->lrg_buf_free_head = lrg_buf_cb->next) == NULL)
327 qdev->lrg_buf_free_tail = NULL;
328 qdev->lrg_buf_free_count--;
329 }
330
331 return lrg_buf_cb;
332 }
333
334 static u32 addrBits = EEPROM_NO_ADDR_BITS;
335 static u32 dataBits = EEPROM_NO_DATA_BITS;
336
337 static void fm93c56a_deselect(struct ql3_adapter *qdev);
338 static void eeprom_readword(struct ql3_adapter *qdev, u32 eepromAddr,
339 unsigned short *value);
340
341 /*
342 * Caller holds hw_lock.
343 */
344 static void fm93c56a_select(struct ql3_adapter *qdev)
345 {
346 struct ql3xxx_port_registers __iomem *port_regs =
347 qdev->mem_map_registers;
348
349 qdev->eeprom_cmd_data = AUBURN_EEPROM_CS_1;
350 ql_write_nvram_reg(qdev, &port_regs->CommonRegs.serialPortInterfaceReg,
351 ISP_NVRAM_MASK | qdev->eeprom_cmd_data);
352 ql_write_nvram_reg(qdev, &port_regs->CommonRegs.serialPortInterfaceReg,
353 ((ISP_NVRAM_MASK << 16) | qdev->eeprom_cmd_data));
354 }
355
356 /*
357 * Caller holds hw_lock.
358 */
359 static void fm93c56a_cmd(struct ql3_adapter *qdev, u32 cmd, u32 eepromAddr)
360 {
361 int i;
362 u32 mask;
363 u32 dataBit;
364 u32 previousBit;
365 struct ql3xxx_port_registers __iomem *port_regs =
366 qdev->mem_map_registers;
367
368 /* Clock in a zero, then do the start bit */
369 ql_write_nvram_reg(qdev, &port_regs->CommonRegs.serialPortInterfaceReg,
370 ISP_NVRAM_MASK | qdev->eeprom_cmd_data |
371 AUBURN_EEPROM_DO_1);
372 ql_write_nvram_reg(qdev, &port_regs->CommonRegs.serialPortInterfaceReg,
373 ISP_NVRAM_MASK | qdev->
374 eeprom_cmd_data | AUBURN_EEPROM_DO_1 |
375 AUBURN_EEPROM_CLK_RISE);
376 ql_write_nvram_reg(qdev, &port_regs->CommonRegs.serialPortInterfaceReg,
377 ISP_NVRAM_MASK | qdev->
378 eeprom_cmd_data | AUBURN_EEPROM_DO_1 |
379 AUBURN_EEPROM_CLK_FALL);
380
381 mask = 1 << (FM93C56A_CMD_BITS - 1);
382 /* Force the previous data bit to be different */
383 previousBit = 0xffff;
384 for (i = 0; i < FM93C56A_CMD_BITS; i++) {
385 dataBit =
386 (cmd & mask) ? AUBURN_EEPROM_DO_1 : AUBURN_EEPROM_DO_0;
387 if (previousBit != dataBit) {
388 /*
389 * If the bit changed, then change the DO state to
390 * match
391 */
392 ql_write_nvram_reg(qdev,
393 &port_regs->CommonRegs.
394 serialPortInterfaceReg,
395 ISP_NVRAM_MASK | qdev->
396 eeprom_cmd_data | dataBit);
397 previousBit = dataBit;
398 }
399 ql_write_nvram_reg(qdev,
400 &port_regs->CommonRegs.
401 serialPortInterfaceReg,
402 ISP_NVRAM_MASK | qdev->
403 eeprom_cmd_data | dataBit |
404 AUBURN_EEPROM_CLK_RISE);
405 ql_write_nvram_reg(qdev,
406 &port_regs->CommonRegs.
407 serialPortInterfaceReg,
408 ISP_NVRAM_MASK | qdev->
409 eeprom_cmd_data | dataBit |
410 AUBURN_EEPROM_CLK_FALL);
411 cmd = cmd << 1;
412 }
413
414 mask = 1 << (addrBits - 1);
415 /* Force the previous data bit to be different */
416 previousBit = 0xffff;
417 for (i = 0; i < addrBits; i++) {
418 dataBit =
419 (eepromAddr & mask) ? AUBURN_EEPROM_DO_1 :
420 AUBURN_EEPROM_DO_0;
421 if (previousBit != dataBit) {
422 /*
423 * If the bit changed, then change the DO state to
424 * match
425 */
426 ql_write_nvram_reg(qdev,
427 &port_regs->CommonRegs.
428 serialPortInterfaceReg,
429 ISP_NVRAM_MASK | qdev->
430 eeprom_cmd_data | dataBit);
431 previousBit = dataBit;
432 }
433 ql_write_nvram_reg(qdev,
434 &port_regs->CommonRegs.
435 serialPortInterfaceReg,
436 ISP_NVRAM_MASK | qdev->
437 eeprom_cmd_data | dataBit |
438 AUBURN_EEPROM_CLK_RISE);
439 ql_write_nvram_reg(qdev,
440 &port_regs->CommonRegs.
441 serialPortInterfaceReg,
442 ISP_NVRAM_MASK | qdev->
443 eeprom_cmd_data | dataBit |
444 AUBURN_EEPROM_CLK_FALL);
445 eepromAddr = eepromAddr << 1;
446 }
447 }
448
449 /*
450 * Caller holds hw_lock.
451 */
452 static void fm93c56a_deselect(struct ql3_adapter *qdev)
453 {
454 struct ql3xxx_port_registers __iomem *port_regs =
455 qdev->mem_map_registers;
456 qdev->eeprom_cmd_data = AUBURN_EEPROM_CS_0;
457 ql_write_nvram_reg(qdev, &port_regs->CommonRegs.serialPortInterfaceReg,
458 ISP_NVRAM_MASK | qdev->eeprom_cmd_data);
459 }
460
461 /*
462 * Caller holds hw_lock.
463 */
464 static void fm93c56a_datain(struct ql3_adapter *qdev, unsigned short *value)
465 {
466 int i;
467 u32 data = 0;
468 u32 dataBit;
469 struct ql3xxx_port_registers __iomem *port_regs =
470 qdev->mem_map_registers;
471
472 /* Read the data bits */
473 /* The first bit is a dummy. Clock right over it. */
474 for (i = 0; i < dataBits; i++) {
475 ql_write_nvram_reg(qdev,
476 &port_regs->CommonRegs.
477 serialPortInterfaceReg,
478 ISP_NVRAM_MASK | qdev->eeprom_cmd_data |
479 AUBURN_EEPROM_CLK_RISE);
480 ql_write_nvram_reg(qdev,
481 &port_regs->CommonRegs.
482 serialPortInterfaceReg,
483 ISP_NVRAM_MASK | qdev->eeprom_cmd_data |
484 AUBURN_EEPROM_CLK_FALL);
485 dataBit =
486 (ql_read_common_reg
487 (qdev,
488 &port_regs->CommonRegs.
489 serialPortInterfaceReg) & AUBURN_EEPROM_DI_1) ? 1 : 0;
490 data = (data << 1) | dataBit;
491 }
492 *value = (u16) data;
493 }
494
495 /*
496 * Caller holds hw_lock.
497 */
498 static void eeprom_readword(struct ql3_adapter *qdev,
499 u32 eepromAddr, unsigned short *value)
500 {
501 fm93c56a_select(qdev);
502 fm93c56a_cmd(qdev, (int)FM93C56A_READ, eepromAddr);
503 fm93c56a_datain(qdev, value);
504 fm93c56a_deselect(qdev);
505 }
506
507 static void ql_swap_mac_addr(u8 * macAddress)
508 {
509 #ifdef __BIG_ENDIAN
510 u8 temp;
511 temp = macAddress[0];
512 macAddress[0] = macAddress[1];
513 macAddress[1] = temp;
514 temp = macAddress[2];
515 macAddress[2] = macAddress[3];
516 macAddress[3] = temp;
517 temp = macAddress[4];
518 macAddress[4] = macAddress[5];
519 macAddress[5] = temp;
520 #endif
521 }
522
523 static int ql_get_nvram_params(struct ql3_adapter *qdev)
524 {
525 u16 *pEEPROMData;
526 u16 checksum = 0;
527 u32 index;
528 unsigned long hw_flags;
529
530 spin_lock_irqsave(&qdev->hw_lock, hw_flags);
531
532 pEEPROMData = (u16 *) & qdev->nvram_data;
533 qdev->eeprom_cmd_data = 0;
534 if(ql_sem_spinlock(qdev, QL_NVRAM_SEM_MASK,
535 (QL_RESOURCE_BITS_BASE_CODE | (qdev->mac_index) *
536 2) << 10)) {
537 printk(KERN_ERR PFX"%s: Failed ql_sem_spinlock().\n",
538 __func__);
539 spin_unlock_irqrestore(&qdev->hw_lock, hw_flags);
540 return -1;
541 }
542
543 for (index = 0; index < EEPROM_SIZE; index++) {
544 eeprom_readword(qdev, index, pEEPROMData);
545 checksum += *pEEPROMData;
546 pEEPROMData++;
547 }
548 ql_sem_unlock(qdev, QL_NVRAM_SEM_MASK);
549
550 if (checksum != 0) {
551 printk(KERN_ERR PFX "%s: checksum should be zero, is %x!!\n",
552 qdev->ndev->name, checksum);
553 spin_unlock_irqrestore(&qdev->hw_lock, hw_flags);
554 return -1;
555 }
556
557 /*
558 * We have a problem with endianness for the MAC addresses
559 * and the two 8-bit values version, and numPorts. We
560 * have to swap them on big endian systems.
561 */
562 ql_swap_mac_addr(qdev->nvram_data.funcCfg_fn0.macAddress);
563 ql_swap_mac_addr(qdev->nvram_data.funcCfg_fn1.macAddress);
564 ql_swap_mac_addr(qdev->nvram_data.funcCfg_fn2.macAddress);
565 ql_swap_mac_addr(qdev->nvram_data.funcCfg_fn3.macAddress);
566 pEEPROMData = (u16 *) & qdev->nvram_data.version;
567 *pEEPROMData = le16_to_cpu(*pEEPROMData);
568
569 spin_unlock_irqrestore(&qdev->hw_lock, hw_flags);
570 return checksum;
571 }
572
573 static const u32 PHYAddr[2] = {
574 PORT0_PHY_ADDRESS, PORT1_PHY_ADDRESS
575 };
576
577 static int ql_wait_for_mii_ready(struct ql3_adapter *qdev)
578 {
579 struct ql3xxx_port_registers __iomem *port_regs =
580 qdev->mem_map_registers;
581 u32 temp;
582 int count = 1000;
583
584 while (count) {
585 temp = ql_read_page0_reg(qdev, &port_regs->macMIIStatusReg);
586 if (!(temp & MAC_MII_STATUS_BSY))
587 return 0;
588 udelay(10);
589 count--;
590 }
591 return -1;
592 }
593
594 static void ql_mii_enable_scan_mode(struct ql3_adapter *qdev)
595 {
596 struct ql3xxx_port_registers __iomem *port_regs =
597 qdev->mem_map_registers;
598 u32 scanControl;
599
600 if (qdev->numPorts > 1) {
601 /* Auto scan will cycle through multiple ports */
602 scanControl = MAC_MII_CONTROL_AS | MAC_MII_CONTROL_SC;
603 } else {
604 scanControl = MAC_MII_CONTROL_SC;
605 }
606
607 /*
608 * Scan register 1 of PHY/PETBI,
609 * Set up to scan both devices
610 * The autoscan starts from the first register, completes
611 * the last one before rolling over to the first
612 */
613 ql_write_page0_reg(qdev, &port_regs->macMIIMgmtAddrReg,
614 PHYAddr[0] | MII_SCAN_REGISTER);
615
616 ql_write_page0_reg(qdev, &port_regs->macMIIMgmtControlReg,
617 (scanControl) |
618 ((MAC_MII_CONTROL_SC | MAC_MII_CONTROL_AS) << 16));
619 }
620
621 static u8 ql_mii_disable_scan_mode(struct ql3_adapter *qdev)
622 {
623 u8 ret;
624 struct ql3xxx_port_registers __iomem *port_regs =
625 qdev->mem_map_registers;
626
627 /* See if scan mode is enabled before we turn it off */
628 if (ql_read_page0_reg(qdev, &port_regs->macMIIMgmtControlReg) &
629 (MAC_MII_CONTROL_AS | MAC_MII_CONTROL_SC)) {
630 /* Scan is enabled */
631 ret = 1;
632 } else {
633 /* Scan is disabled */
634 ret = 0;
635 }
636
637 /*
638 * When disabling scan mode you must first change the MII register
639 * address
640 */
641 ql_write_page0_reg(qdev, &port_regs->macMIIMgmtAddrReg,
642 PHYAddr[0] | MII_SCAN_REGISTER);
643
644 ql_write_page0_reg(qdev, &port_regs->macMIIMgmtControlReg,
645 ((MAC_MII_CONTROL_SC | MAC_MII_CONTROL_AS |
646 MAC_MII_CONTROL_RC) << 16));
647
648 return ret;
649 }
650
651 static int ql_mii_write_reg_ex(struct ql3_adapter *qdev,
652 u16 regAddr, u16 value, u32 mac_index)
653 {
654 struct ql3xxx_port_registers __iomem *port_regs =
655 qdev->mem_map_registers;
656 u8 scanWasEnabled;
657
658 scanWasEnabled = ql_mii_disable_scan_mode(qdev);
659
660 if (ql_wait_for_mii_ready(qdev)) {
661 if (netif_msg_link(qdev))
662 printk(KERN_WARNING PFX
663 "%s Timed out waiting for management port to "
664 "get free before issuing command.\n",
665 qdev->ndev->name);
666 return -1;
667 }
668
669 ql_write_page0_reg(qdev, &port_regs->macMIIMgmtAddrReg,
670 PHYAddr[mac_index] | regAddr);
671
672 ql_write_page0_reg(qdev, &port_regs->macMIIMgmtDataReg, value);
673
674 /* Wait for write to complete 9/10/04 SJP */
675 if (ql_wait_for_mii_ready(qdev)) {
676 if (netif_msg_link(qdev))
677 printk(KERN_WARNING PFX
678 "%s: Timed out waiting for management port to"
679 "get free before issuing command.\n",
680 qdev->ndev->name);
681 return -1;
682 }
683
684 if (scanWasEnabled)
685 ql_mii_enable_scan_mode(qdev);
686
687 return 0;
688 }
689
690 static int ql_mii_read_reg_ex(struct ql3_adapter *qdev, u16 regAddr,
691 u16 * value, u32 mac_index)
692 {
693 struct ql3xxx_port_registers __iomem *port_regs =
694 qdev->mem_map_registers;
695 u8 scanWasEnabled;
696 u32 temp;
697
698 scanWasEnabled = ql_mii_disable_scan_mode(qdev);
699
700 if (ql_wait_for_mii_ready(qdev)) {
701 if (netif_msg_link(qdev))
702 printk(KERN_WARNING PFX
703 "%s: Timed out waiting for management port to "
704 "get free before issuing command.\n",
705 qdev->ndev->name);
706 return -1;
707 }
708
709 ql_write_page0_reg(qdev, &port_regs->macMIIMgmtAddrReg,
710 PHYAddr[mac_index] | regAddr);
711
712 ql_write_page0_reg(qdev, &port_regs->macMIIMgmtControlReg,
713 (MAC_MII_CONTROL_RC << 16));
714
715 ql_write_page0_reg(qdev, &port_regs->macMIIMgmtControlReg,
716 (MAC_MII_CONTROL_RC << 16) | MAC_MII_CONTROL_RC);
717
718 /* Wait for the read to complete */
719 if (ql_wait_for_mii_ready(qdev)) {
720 if (netif_msg_link(qdev))
721 printk(KERN_WARNING PFX
722 "%s: Timed out waiting for management port to "
723 "get free after issuing command.\n",
724 qdev->ndev->name);
725 return -1;
726 }
727
728 temp = ql_read_page0_reg(qdev, &port_regs->macMIIMgmtDataReg);
729 *value = (u16) temp;
730
731 if (scanWasEnabled)
732 ql_mii_enable_scan_mode(qdev);
733
734 return 0;
735 }
736
737 static int ql_mii_write_reg(struct ql3_adapter *qdev, u16 regAddr, u16 value)
738 {
739 struct ql3xxx_port_registers __iomem *port_regs =
740 qdev->mem_map_registers;
741
742 ql_mii_disable_scan_mode(qdev);
743
744 if (ql_wait_for_mii_ready(qdev)) {
745 if (netif_msg_link(qdev))
746 printk(KERN_WARNING PFX
747 "%s: Timed out waiting for management port to "
748 "get free before issuing command.\n",
749 qdev->ndev->name);
750 return -1;
751 }
752
753 ql_write_page0_reg(qdev, &port_regs->macMIIMgmtAddrReg,
754 qdev->PHYAddr | regAddr);
755
756 ql_write_page0_reg(qdev, &port_regs->macMIIMgmtDataReg, value);
757
758 /* Wait for write to complete. */
759 if (ql_wait_for_mii_ready(qdev)) {
760 if (netif_msg_link(qdev))
761 printk(KERN_WARNING PFX
762 "%s: Timed out waiting for management port to "
763 "get free before issuing command.\n",
764 qdev->ndev->name);
765 return -1;
766 }
767
768 ql_mii_enable_scan_mode(qdev);
769
770 return 0;
771 }
772
773 static int ql_mii_read_reg(struct ql3_adapter *qdev, u16 regAddr, u16 *value)
774 {
775 u32 temp;
776 struct ql3xxx_port_registers __iomem *port_regs =
777 qdev->mem_map_registers;
778
779 ql_mii_disable_scan_mode(qdev);
780
781 if (ql_wait_for_mii_ready(qdev)) {
782 if (netif_msg_link(qdev))
783 printk(KERN_WARNING PFX
784 "%s: Timed out waiting for management port to "
785 "get free before issuing command.\n",
786 qdev->ndev->name);
787 return -1;
788 }
789
790 ql_write_page0_reg(qdev, &port_regs->macMIIMgmtAddrReg,
791 qdev->PHYAddr | regAddr);
792
793 ql_write_page0_reg(qdev, &port_regs->macMIIMgmtControlReg,
794 (MAC_MII_CONTROL_RC << 16));
795
796 ql_write_page0_reg(qdev, &port_regs->macMIIMgmtControlReg,
797 (MAC_MII_CONTROL_RC << 16) | MAC_MII_CONTROL_RC);
798
799 /* Wait for the read to complete */
800 if (ql_wait_for_mii_ready(qdev)) {
801 if (netif_msg_link(qdev))
802 printk(KERN_WARNING PFX
803 "%s: Timed out waiting for management port to "
804 "get free before issuing command.\n",
805 qdev->ndev->name);
806 return -1;
807 }
808
809 temp = ql_read_page0_reg(qdev, &port_regs->macMIIMgmtDataReg);
810 *value = (u16) temp;
811
812 ql_mii_enable_scan_mode(qdev);
813
814 return 0;
815 }
816
817 static void ql_petbi_reset(struct ql3_adapter *qdev)
818 {
819 ql_mii_write_reg(qdev, PETBI_CONTROL_REG, PETBI_CTRL_SOFT_RESET);
820 }
821
822 static void ql_petbi_start_neg(struct ql3_adapter *qdev)
823 {
824 u16 reg;
825
826 /* Enable Auto-negotiation sense */
827 ql_mii_read_reg(qdev, PETBI_TBI_CTRL, &reg);
828 reg |= PETBI_TBI_AUTO_SENSE;
829 ql_mii_write_reg(qdev, PETBI_TBI_CTRL, reg);
830
831 ql_mii_write_reg(qdev, PETBI_NEG_ADVER,
832 PETBI_NEG_PAUSE | PETBI_NEG_DUPLEX);
833
834 ql_mii_write_reg(qdev, PETBI_CONTROL_REG,
835 PETBI_CTRL_AUTO_NEG | PETBI_CTRL_RESTART_NEG |
836 PETBI_CTRL_FULL_DUPLEX | PETBI_CTRL_SPEED_1000);
837
838 }
839
840 static void ql_petbi_reset_ex(struct ql3_adapter *qdev, u32 mac_index)
841 {
842 ql_mii_write_reg_ex(qdev, PETBI_CONTROL_REG, PETBI_CTRL_SOFT_RESET,
843 mac_index);
844 }
845
846 static void ql_petbi_start_neg_ex(struct ql3_adapter *qdev, u32 mac_index)
847 {
848 u16 reg;
849
850 /* Enable Auto-negotiation sense */
851 ql_mii_read_reg_ex(qdev, PETBI_TBI_CTRL, &reg, mac_index);
852 reg |= PETBI_TBI_AUTO_SENSE;
853 ql_mii_write_reg_ex(qdev, PETBI_TBI_CTRL, reg, mac_index);
854
855 ql_mii_write_reg_ex(qdev, PETBI_NEG_ADVER,
856 PETBI_NEG_PAUSE | PETBI_NEG_DUPLEX, mac_index);
857
858 ql_mii_write_reg_ex(qdev, PETBI_CONTROL_REG,
859 PETBI_CTRL_AUTO_NEG | PETBI_CTRL_RESTART_NEG |
860 PETBI_CTRL_FULL_DUPLEX | PETBI_CTRL_SPEED_1000,
861 mac_index);
862 }
863
864 static void ql_petbi_init(struct ql3_adapter *qdev)
865 {
866 ql_petbi_reset(qdev);
867 ql_petbi_start_neg(qdev);
868 }
869
870 static void ql_petbi_init_ex(struct ql3_adapter *qdev, u32 mac_index)
871 {
872 ql_petbi_reset_ex(qdev, mac_index);
873 ql_petbi_start_neg_ex(qdev, mac_index);
874 }
875
876 static int ql_is_petbi_neg_pause(struct ql3_adapter *qdev)
877 {
878 u16 reg;
879
880 if (ql_mii_read_reg(qdev, PETBI_NEG_PARTNER, &reg) < 0)
881 return 0;
882
883 return (reg & PETBI_NEG_PAUSE_MASK) == PETBI_NEG_PAUSE;
884 }
885
886 static int ql_phy_get_speed(struct ql3_adapter *qdev)
887 {
888 u16 reg;
889
890 if (ql_mii_read_reg(qdev, AUX_CONTROL_STATUS, &reg) < 0)
891 return 0;
892
893 reg = (((reg & 0x18) >> 3) & 3);
894
895 if (reg == 2)
896 return SPEED_1000;
897 else if (reg == 1)
898 return SPEED_100;
899 else if (reg == 0)
900 return SPEED_10;
901 else
902 return -1;
903 }
904
905 static int ql_is_full_dup(struct ql3_adapter *qdev)
906 {
907 u16 reg;
908
909 if (ql_mii_read_reg(qdev, AUX_CONTROL_STATUS, &reg) < 0)
910 return 0;
911
912 return (reg & PHY_AUX_DUPLEX_STAT) != 0;
913 }
914
915 static int ql_is_phy_neg_pause(struct ql3_adapter *qdev)
916 {
917 u16 reg;
918
919 if (ql_mii_read_reg(qdev, PHY_NEG_PARTNER, &reg) < 0)
920 return 0;
921
922 return (reg & PHY_NEG_PAUSE) != 0;
923 }
924
925 /*
926 * Caller holds hw_lock.
927 */
928 static void ql_mac_enable(struct ql3_adapter *qdev, u32 enable)
929 {
930 struct ql3xxx_port_registers __iomem *port_regs =
931 qdev->mem_map_registers;
932 u32 value;
933
934 if (enable)
935 value = (MAC_CONFIG_REG_PE | (MAC_CONFIG_REG_PE << 16));
936 else
937 value = (MAC_CONFIG_REG_PE << 16);
938
939 if (qdev->mac_index)
940 ql_write_page0_reg(qdev, &port_regs->mac1ConfigReg, value);
941 else
942 ql_write_page0_reg(qdev, &port_regs->mac0ConfigReg, value);
943 }
944
945 /*
946 * Caller holds hw_lock.
947 */
948 static void ql_mac_cfg_soft_reset(struct ql3_adapter *qdev, u32 enable)
949 {
950 struct ql3xxx_port_registers __iomem *port_regs =
951 qdev->mem_map_registers;
952 u32 value;
953
954 if (enable)
955 value = (MAC_CONFIG_REG_SR | (MAC_CONFIG_REG_SR << 16));
956 else
957 value = (MAC_CONFIG_REG_SR << 16);
958
959 if (qdev->mac_index)
960 ql_write_page0_reg(qdev, &port_regs->mac1ConfigReg, value);
961 else
962 ql_write_page0_reg(qdev, &port_regs->mac0ConfigReg, value);
963 }
964
965 /*
966 * Caller holds hw_lock.
967 */
968 static void ql_mac_cfg_gig(struct ql3_adapter *qdev, u32 enable)
969 {
970 struct ql3xxx_port_registers __iomem *port_regs =
971 qdev->mem_map_registers;
972 u32 value;
973
974 if (enable)
975 value = (MAC_CONFIG_REG_GM | (MAC_CONFIG_REG_GM << 16));
976 else
977 value = (MAC_CONFIG_REG_GM << 16);
978
979 if (qdev->mac_index)
980 ql_write_page0_reg(qdev, &port_regs->mac1ConfigReg, value);
981 else
982 ql_write_page0_reg(qdev, &port_regs->mac0ConfigReg, value);
983 }
984
985 /*
986 * Caller holds hw_lock.
987 */
988 static void ql_mac_cfg_full_dup(struct ql3_adapter *qdev, u32 enable)
989 {
990 struct ql3xxx_port_registers __iomem *port_regs =
991 qdev->mem_map_registers;
992 u32 value;
993
994 if (enable)
995 value = (MAC_CONFIG_REG_FD | (MAC_CONFIG_REG_FD << 16));
996 else
997 value = (MAC_CONFIG_REG_FD << 16);
998
999 if (qdev->mac_index)
1000 ql_write_page0_reg(qdev, &port_regs->mac1ConfigReg, value);
1001 else
1002 ql_write_page0_reg(qdev, &port_regs->mac0ConfigReg, value);
1003 }
1004
1005 /*
1006 * Caller holds hw_lock.
1007 */
1008 static void ql_mac_cfg_pause(struct ql3_adapter *qdev, u32 enable)
1009 {
1010 struct ql3xxx_port_registers __iomem *port_regs =
1011 qdev->mem_map_registers;
1012 u32 value;
1013
1014 if (enable)
1015 value =
1016 ((MAC_CONFIG_REG_TF | MAC_CONFIG_REG_RF) |
1017 ((MAC_CONFIG_REG_TF | MAC_CONFIG_REG_RF) << 16));
1018 else
1019 value = ((MAC_CONFIG_REG_TF | MAC_CONFIG_REG_RF) << 16);
1020
1021 if (qdev->mac_index)
1022 ql_write_page0_reg(qdev, &port_regs->mac1ConfigReg, value);
1023 else
1024 ql_write_page0_reg(qdev, &port_regs->mac0ConfigReg, value);
1025 }
1026
1027 /*
1028 * Caller holds hw_lock.
1029 */
1030 static int ql_is_fiber(struct ql3_adapter *qdev)
1031 {
1032 struct ql3xxx_port_registers __iomem *port_regs =
1033 qdev->mem_map_registers;
1034 u32 bitToCheck = 0;
1035 u32 temp;
1036
1037 switch (qdev->mac_index) {
1038 case 0:
1039 bitToCheck = PORT_STATUS_SM0;
1040 break;
1041 case 1:
1042 bitToCheck = PORT_STATUS_SM1;
1043 break;
1044 }
1045
1046 temp = ql_read_page0_reg(qdev, &port_regs->portStatus);
1047 return (temp & bitToCheck) != 0;
1048 }
1049
1050 static int ql_is_auto_cfg(struct ql3_adapter *qdev)
1051 {
1052 u16 reg;
1053 ql_mii_read_reg(qdev, 0x00, &reg);
1054 return (reg & 0x1000) != 0;
1055 }
1056
1057 /*
1058 * Caller holds hw_lock.
1059 */
1060 static int ql_is_auto_neg_complete(struct ql3_adapter *qdev)
1061 {
1062 struct ql3xxx_port_registers __iomem *port_regs =
1063 qdev->mem_map_registers;
1064 u32 bitToCheck = 0;
1065 u32 temp;
1066
1067 switch (qdev->mac_index) {
1068 case 0:
1069 bitToCheck = PORT_STATUS_AC0;
1070 break;
1071 case 1:
1072 bitToCheck = PORT_STATUS_AC1;
1073 break;
1074 }
1075
1076 temp = ql_read_page0_reg(qdev, &port_regs->portStatus);
1077 if (temp & bitToCheck) {
1078 if (netif_msg_link(qdev))
1079 printk(KERN_INFO PFX
1080 "%s: Auto-Negotiate complete.\n",
1081 qdev->ndev->name);
1082 return 1;
1083 } else {
1084 if (netif_msg_link(qdev))
1085 printk(KERN_WARNING PFX
1086 "%s: Auto-Negotiate incomplete.\n",
1087 qdev->ndev->name);
1088 return 0;
1089 }
1090 }
1091
1092 /*
1093 * ql_is_neg_pause() returns 1 if pause was negotiated to be on
1094 */
1095 static int ql_is_neg_pause(struct ql3_adapter *qdev)
1096 {
1097 if (ql_is_fiber(qdev))
1098 return ql_is_petbi_neg_pause(qdev);
1099 else
1100 return ql_is_phy_neg_pause(qdev);
1101 }
1102
1103 static int ql_auto_neg_error(struct ql3_adapter *qdev)
1104 {
1105 struct ql3xxx_port_registers __iomem *port_regs =
1106 qdev->mem_map_registers;
1107 u32 bitToCheck = 0;
1108 u32 temp;
1109
1110 switch (qdev->mac_index) {
1111 case 0:
1112 bitToCheck = PORT_STATUS_AE0;
1113 break;
1114 case 1:
1115 bitToCheck = PORT_STATUS_AE1;
1116 break;
1117 }
1118 temp = ql_read_page0_reg(qdev, &port_regs->portStatus);
1119 return (temp & bitToCheck) != 0;
1120 }
1121
1122 static u32 ql_get_link_speed(struct ql3_adapter *qdev)
1123 {
1124 if (ql_is_fiber(qdev))
1125 return SPEED_1000;
1126 else
1127 return ql_phy_get_speed(qdev);
1128 }
1129
1130 static int ql_is_link_full_dup(struct ql3_adapter *qdev)
1131 {
1132 if (ql_is_fiber(qdev))
1133 return 1;
1134 else
1135 return ql_is_full_dup(qdev);
1136 }
1137
1138 /*
1139 * Caller holds hw_lock.
1140 */
1141 static int ql_link_down_detect(struct ql3_adapter *qdev)
1142 {
1143 struct ql3xxx_port_registers __iomem *port_regs =
1144 qdev->mem_map_registers;
1145 u32 bitToCheck = 0;
1146 u32 temp;
1147
1148 switch (qdev->mac_index) {
1149 case 0:
1150 bitToCheck = ISP_CONTROL_LINK_DN_0;
1151 break;
1152 case 1:
1153 bitToCheck = ISP_CONTROL_LINK_DN_1;
1154 break;
1155 }
1156
1157 temp =
1158 ql_read_common_reg(qdev, &port_regs->CommonRegs.ispControlStatus);
1159 return (temp & bitToCheck) != 0;
1160 }
1161
1162 /*
1163 * Caller holds hw_lock.
1164 */
1165 static int ql_link_down_detect_clear(struct ql3_adapter *qdev)
1166 {
1167 struct ql3xxx_port_registers __iomem *port_regs =
1168 qdev->mem_map_registers;
1169
1170 switch (qdev->mac_index) {
1171 case 0:
1172 ql_write_common_reg(qdev,
1173 &port_regs->CommonRegs.ispControlStatus,
1174 (ISP_CONTROL_LINK_DN_0) |
1175 (ISP_CONTROL_LINK_DN_0 << 16));
1176 break;
1177
1178 case 1:
1179 ql_write_common_reg(qdev,
1180 &port_regs->CommonRegs.ispControlStatus,
1181 (ISP_CONTROL_LINK_DN_1) |
1182 (ISP_CONTROL_LINK_DN_1 << 16));
1183 break;
1184
1185 default:
1186 return 1;
1187 }
1188
1189 return 0;
1190 }
1191
1192 /*
1193 * Caller holds hw_lock.
1194 */
1195 static int ql_this_adapter_controls_port(struct ql3_adapter *qdev,
1196 u32 mac_index)
1197 {
1198 struct ql3xxx_port_registers __iomem *port_regs =
1199 qdev->mem_map_registers;
1200 u32 bitToCheck = 0;
1201 u32 temp;
1202
1203 switch (mac_index) {
1204 case 0:
1205 bitToCheck = PORT_STATUS_F1_ENABLED;
1206 break;
1207 case 1:
1208 bitToCheck = PORT_STATUS_F3_ENABLED;
1209 break;
1210 default:
1211 break;
1212 }
1213
1214 temp = ql_read_page0_reg(qdev, &port_regs->portStatus);
1215 if (temp & bitToCheck) {
1216 if (netif_msg_link(qdev))
1217 printk(KERN_DEBUG PFX
1218 "%s: is not link master.\n", qdev->ndev->name);
1219 return 0;
1220 } else {
1221 if (netif_msg_link(qdev))
1222 printk(KERN_DEBUG PFX
1223 "%s: is link master.\n", qdev->ndev->name);
1224 return 1;
1225 }
1226 }
1227
1228 static void ql_phy_reset_ex(struct ql3_adapter *qdev, u32 mac_index)
1229 {
1230 ql_mii_write_reg_ex(qdev, CONTROL_REG, PHY_CTRL_SOFT_RESET, mac_index);
1231 }
1232
1233 static void ql_phy_start_neg_ex(struct ql3_adapter *qdev, u32 mac_index)
1234 {
1235 u16 reg;
1236
1237 ql_mii_write_reg_ex(qdev, PHY_NEG_ADVER,
1238 PHY_NEG_PAUSE | PHY_NEG_ADV_SPEED | 1, mac_index);
1239
1240 ql_mii_read_reg_ex(qdev, CONTROL_REG, &reg, mac_index);
1241 ql_mii_write_reg_ex(qdev, CONTROL_REG, reg | PHY_CTRL_RESTART_NEG,
1242 mac_index);
1243 }
1244
1245 static void ql_phy_init_ex(struct ql3_adapter *qdev, u32 mac_index)
1246 {
1247 ql_phy_reset_ex(qdev, mac_index);
1248 ql_phy_start_neg_ex(qdev, mac_index);
1249 }
1250
1251 /*
1252 * Caller holds hw_lock.
1253 */
1254 static u32 ql_get_link_state(struct ql3_adapter *qdev)
1255 {
1256 struct ql3xxx_port_registers __iomem *port_regs =
1257 qdev->mem_map_registers;
1258 u32 bitToCheck = 0;
1259 u32 temp, linkState;
1260
1261 switch (qdev->mac_index) {
1262 case 0:
1263 bitToCheck = PORT_STATUS_UP0;
1264 break;
1265 case 1:
1266 bitToCheck = PORT_STATUS_UP1;
1267 break;
1268 }
1269 temp = ql_read_page0_reg(qdev, &port_regs->portStatus);
1270 if (temp & bitToCheck) {
1271 linkState = LS_UP;
1272 } else {
1273 linkState = LS_DOWN;
1274 if (netif_msg_link(qdev))
1275 printk(KERN_WARNING PFX
1276 "%s: Link is down.\n", qdev->ndev->name);
1277 }
1278 return linkState;
1279 }
1280
1281 static int ql_port_start(struct ql3_adapter *qdev)
1282 {
1283 if(ql_sem_spinlock(qdev, QL_PHY_GIO_SEM_MASK,
1284 (QL_RESOURCE_BITS_BASE_CODE | (qdev->mac_index) *
1285 2) << 7))
1286 return -1;
1287
1288 if (ql_is_fiber(qdev)) {
1289 ql_petbi_init(qdev);
1290 } else {
1291 /* Copper port */
1292 ql_phy_init_ex(qdev, qdev->mac_index);
1293 }
1294
1295 ql_sem_unlock(qdev, QL_PHY_GIO_SEM_MASK);
1296 return 0;
1297 }
1298
1299 static int ql_finish_auto_neg(struct ql3_adapter *qdev)
1300 {
1301
1302 if(ql_sem_spinlock(qdev, QL_PHY_GIO_SEM_MASK,
1303 (QL_RESOURCE_BITS_BASE_CODE | (qdev->mac_index) *
1304 2) << 7))
1305 return -1;
1306
1307 if (!ql_auto_neg_error(qdev)) {
1308 if (test_bit(QL_LINK_MASTER,&qdev->flags)) {
1309 /* configure the MAC */
1310 if (netif_msg_link(qdev))
1311 printk(KERN_DEBUG PFX
1312 "%s: Configuring link.\n",
1313 qdev->ndev->
1314 name);
1315 ql_mac_cfg_soft_reset(qdev, 1);
1316 ql_mac_cfg_gig(qdev,
1317 (ql_get_link_speed
1318 (qdev) ==
1319 SPEED_1000));
1320 ql_mac_cfg_full_dup(qdev,
1321 ql_is_link_full_dup
1322 (qdev));
1323 ql_mac_cfg_pause(qdev,
1324 ql_is_neg_pause
1325 (qdev));
1326 ql_mac_cfg_soft_reset(qdev, 0);
1327
1328 /* enable the MAC */
1329 if (netif_msg_link(qdev))
1330 printk(KERN_DEBUG PFX
1331 "%s: Enabling mac.\n",
1332 qdev->ndev->
1333 name);
1334 ql_mac_enable(qdev, 1);
1335 }
1336
1337 if (netif_msg_link(qdev))
1338 printk(KERN_DEBUG PFX
1339 "%s: Change port_link_state LS_DOWN to LS_UP.\n",
1340 qdev->ndev->name);
1341 qdev->port_link_state = LS_UP;
1342 netif_start_queue(qdev->ndev);
1343 netif_carrier_on(qdev->ndev);
1344 if (netif_msg_link(qdev))
1345 printk(KERN_INFO PFX
1346 "%s: Link is up at %d Mbps, %s duplex.\n",
1347 qdev->ndev->name,
1348 ql_get_link_speed(qdev),
1349 ql_is_link_full_dup(qdev)
1350 ? "full" : "half");
1351
1352 } else { /* Remote error detected */
1353
1354 if (test_bit(QL_LINK_MASTER,&qdev->flags)) {
1355 if (netif_msg_link(qdev))
1356 printk(KERN_DEBUG PFX
1357 "%s: Remote error detected. "
1358 "Calling ql_port_start().\n",
1359 qdev->ndev->
1360 name);
1361 /*
1362 * ql_port_start() is shared code and needs
1363 * to lock the PHY on it's own.
1364 */
1365 ql_sem_unlock(qdev, QL_PHY_GIO_SEM_MASK);
1366 if(ql_port_start(qdev)) {/* Restart port */
1367 return -1;
1368 } else
1369 return 0;
1370 }
1371 }
1372 ql_sem_unlock(qdev, QL_PHY_GIO_SEM_MASK);
1373 return 0;
1374 }
1375
1376 static void ql_link_state_machine(struct ql3_adapter *qdev)
1377 {
1378 u32 curr_link_state;
1379 unsigned long hw_flags;
1380
1381 spin_lock_irqsave(&qdev->hw_lock, hw_flags);
1382
1383 curr_link_state = ql_get_link_state(qdev);
1384
1385 if (test_bit(QL_RESET_ACTIVE,&qdev->flags)) {
1386 if (netif_msg_link(qdev))
1387 printk(KERN_INFO PFX
1388 "%s: Reset in progress, skip processing link "
1389 "state.\n", qdev->ndev->name);
1390 return;
1391 }
1392
1393 switch (qdev->port_link_state) {
1394 default:
1395 if (test_bit(QL_LINK_MASTER,&qdev->flags)) {
1396 ql_port_start(qdev);
1397 }
1398 qdev->port_link_state = LS_DOWN;
1399 /* Fall Through */
1400
1401 case LS_DOWN:
1402 if (netif_msg_link(qdev))
1403 printk(KERN_DEBUG PFX
1404 "%s: port_link_state = LS_DOWN.\n",
1405 qdev->ndev->name);
1406 if (curr_link_state == LS_UP) {
1407 if (netif_msg_link(qdev))
1408 printk(KERN_DEBUG PFX
1409 "%s: curr_link_state = LS_UP.\n",
1410 qdev->ndev->name);
1411 if (ql_is_auto_neg_complete(qdev))
1412 ql_finish_auto_neg(qdev);
1413
1414 if (qdev->port_link_state == LS_UP)
1415 ql_link_down_detect_clear(qdev);
1416
1417 }
1418 break;
1419
1420 case LS_UP:
1421 /*
1422 * See if the link is currently down or went down and came
1423 * back up
1424 */
1425 if ((curr_link_state == LS_DOWN) || ql_link_down_detect(qdev)) {
1426 if (netif_msg_link(qdev))
1427 printk(KERN_INFO PFX "%s: Link is down.\n",
1428 qdev->ndev->name);
1429 qdev->port_link_state = LS_DOWN;
1430 }
1431 break;
1432 }
1433 spin_unlock_irqrestore(&qdev->hw_lock, hw_flags);
1434 }
1435
1436 /*
1437 * Caller must take hw_lock and QL_PHY_GIO_SEM.
1438 */
1439 static void ql_get_phy_owner(struct ql3_adapter *qdev)
1440 {
1441 if (ql_this_adapter_controls_port(qdev, qdev->mac_index))
1442 set_bit(QL_LINK_MASTER,&qdev->flags);
1443 else
1444 clear_bit(QL_LINK_MASTER,&qdev->flags);
1445 }
1446
1447 /*
1448 * Caller must take hw_lock and QL_PHY_GIO_SEM.
1449 */
1450 static void ql_init_scan_mode(struct ql3_adapter *qdev)
1451 {
1452 ql_mii_enable_scan_mode(qdev);
1453
1454 if (test_bit(QL_LINK_OPTICAL,&qdev->flags)) {
1455 if (ql_this_adapter_controls_port(qdev, qdev->mac_index))
1456 ql_petbi_init_ex(qdev, qdev->mac_index);
1457 } else {
1458 if (ql_this_adapter_controls_port(qdev, qdev->mac_index))
1459 ql_phy_init_ex(qdev, qdev->mac_index);
1460 }
1461 }
1462
1463 /*
1464 * MII_Setup needs to be called before taking the PHY out of reset so that the
1465 * management interface clock speed can be set properly. It would be better if
1466 * we had a way to disable MDC until after the PHY is out of reset, but we
1467 * don't have that capability.
1468 */
1469 static int ql_mii_setup(struct ql3_adapter *qdev)
1470 {
1471 u32 reg;
1472 struct ql3xxx_port_registers __iomem *port_regs =
1473 qdev->mem_map_registers;
1474
1475 if(ql_sem_spinlock(qdev, QL_PHY_GIO_SEM_MASK,
1476 (QL_RESOURCE_BITS_BASE_CODE | (qdev->mac_index) *
1477 2) << 7))
1478 return -1;
1479
1480 if (qdev->device_id == QL3032_DEVICE_ID)
1481 ql_write_page0_reg(qdev,
1482 &port_regs->macMIIMgmtControlReg, 0x0f00000);
1483
1484 /* Divide 125MHz clock by 28 to meet PHY timing requirements */
1485 reg = MAC_MII_CONTROL_CLK_SEL_DIV28;
1486
1487 ql_write_page0_reg(qdev, &port_regs->macMIIMgmtControlReg,
1488 reg | ((MAC_MII_CONTROL_CLK_SEL_MASK) << 16));
1489
1490 ql_sem_unlock(qdev, QL_PHY_GIO_SEM_MASK);
1491 return 0;
1492 }
1493
1494 static u32 ql_supported_modes(struct ql3_adapter *qdev)
1495 {
1496 u32 supported;
1497
1498 if (test_bit(QL_LINK_OPTICAL,&qdev->flags)) {
1499 supported = SUPPORTED_1000baseT_Full | SUPPORTED_FIBRE
1500 | SUPPORTED_Autoneg;
1501 } else {
1502 supported = SUPPORTED_10baseT_Half
1503 | SUPPORTED_10baseT_Full
1504 | SUPPORTED_100baseT_Half
1505 | SUPPORTED_100baseT_Full
1506 | SUPPORTED_1000baseT_Half
1507 | SUPPORTED_1000baseT_Full
1508 | SUPPORTED_Autoneg | SUPPORTED_TP;
1509 }
1510
1511 return supported;
1512 }
1513
1514 static int ql_get_auto_cfg_status(struct ql3_adapter *qdev)
1515 {
1516 int status;
1517 unsigned long hw_flags;
1518 spin_lock_irqsave(&qdev->hw_lock, hw_flags);
1519 if(ql_sem_spinlock(qdev, QL_PHY_GIO_SEM_MASK,
1520 (QL_RESOURCE_BITS_BASE_CODE | (qdev->mac_index) *
1521 2) << 7))
1522 return 0;
1523 status = ql_is_auto_cfg(qdev);
1524 ql_sem_unlock(qdev, QL_PHY_GIO_SEM_MASK);
1525 spin_unlock_irqrestore(&qdev->hw_lock, hw_flags);
1526 return status;
1527 }
1528
1529 static u32 ql_get_speed(struct ql3_adapter *qdev)
1530 {
1531 u32 status;
1532 unsigned long hw_flags;
1533 spin_lock_irqsave(&qdev->hw_lock, hw_flags);
1534 if(ql_sem_spinlock(qdev, QL_PHY_GIO_SEM_MASK,
1535 (QL_RESOURCE_BITS_BASE_CODE | (qdev->mac_index) *
1536 2) << 7))
1537 return 0;
1538 status = ql_get_link_speed(qdev);
1539 ql_sem_unlock(qdev, QL_PHY_GIO_SEM_MASK);
1540 spin_unlock_irqrestore(&qdev->hw_lock, hw_flags);
1541 return status;
1542 }
1543
1544 static int ql_get_full_dup(struct ql3_adapter *qdev)
1545 {
1546 int status;
1547 unsigned long hw_flags;
1548 spin_lock_irqsave(&qdev->hw_lock, hw_flags);
1549 if(ql_sem_spinlock(qdev, QL_PHY_GIO_SEM_MASK,
1550 (QL_RESOURCE_BITS_BASE_CODE | (qdev->mac_index) *
1551 2) << 7))
1552 return 0;
1553 status = ql_is_link_full_dup(qdev);
1554 ql_sem_unlock(qdev, QL_PHY_GIO_SEM_MASK);
1555 spin_unlock_irqrestore(&qdev->hw_lock, hw_flags);
1556 return status;
1557 }
1558
1559
1560 static int ql_get_settings(struct net_device *ndev, struct ethtool_cmd *ecmd)
1561 {
1562 struct ql3_adapter *qdev = netdev_priv(ndev);
1563
1564 ecmd->transceiver = XCVR_INTERNAL;
1565 ecmd->supported = ql_supported_modes(qdev);
1566
1567 if (test_bit(QL_LINK_OPTICAL,&qdev->flags)) {
1568 ecmd->port = PORT_FIBRE;
1569 } else {
1570 ecmd->port = PORT_TP;
1571 ecmd->phy_address = qdev->PHYAddr;
1572 }
1573 ecmd->advertising = ql_supported_modes(qdev);
1574 ecmd->autoneg = ql_get_auto_cfg_status(qdev);
1575 ecmd->speed = ql_get_speed(qdev);
1576 ecmd->duplex = ql_get_full_dup(qdev);
1577 return 0;
1578 }
1579
1580 static void ql_get_drvinfo(struct net_device *ndev,
1581 struct ethtool_drvinfo *drvinfo)
1582 {
1583 struct ql3_adapter *qdev = netdev_priv(ndev);
1584 strncpy(drvinfo->driver, ql3xxx_driver_name, 32);
1585 strncpy(drvinfo->version, ql3xxx_driver_version, 32);
1586 strncpy(drvinfo->fw_version, "N/A", 32);
1587 strncpy(drvinfo->bus_info, pci_name(qdev->pdev), 32);
1588 drvinfo->n_stats = 0;
1589 drvinfo->testinfo_len = 0;
1590 drvinfo->regdump_len = 0;
1591 drvinfo->eedump_len = 0;
1592 }
1593
1594 static u32 ql_get_msglevel(struct net_device *ndev)
1595 {
1596 struct ql3_adapter *qdev = netdev_priv(ndev);
1597 return qdev->msg_enable;
1598 }
1599
1600 static void ql_set_msglevel(struct net_device *ndev, u32 value)
1601 {
1602 struct ql3_adapter *qdev = netdev_priv(ndev);
1603 qdev->msg_enable = value;
1604 }
1605
1606 static const struct ethtool_ops ql3xxx_ethtool_ops = {
1607 .get_settings = ql_get_settings,
1608 .get_drvinfo = ql_get_drvinfo,
1609 .get_perm_addr = ethtool_op_get_perm_addr,
1610 .get_link = ethtool_op_get_link,
1611 .get_msglevel = ql_get_msglevel,
1612 .set_msglevel = ql_set_msglevel,
1613 };
1614
1615 static int ql_populate_free_queue(struct ql3_adapter *qdev)
1616 {
1617 struct ql_rcv_buf_cb *lrg_buf_cb = qdev->lrg_buf_free_head;
1618 u64 map;
1619
1620 while (lrg_buf_cb) {
1621 if (!lrg_buf_cb->skb) {
1622 lrg_buf_cb->skb = dev_alloc_skb(qdev->lrg_buffer_len);
1623 if (unlikely(!lrg_buf_cb->skb)) {
1624 printk(KERN_DEBUG PFX
1625 "%s: Failed dev_alloc_skb().\n",
1626 qdev->ndev->name);
1627 break;
1628 } else {
1629 /*
1630 * We save some space to copy the ethhdr from
1631 * first buffer
1632 */
1633 skb_reserve(lrg_buf_cb->skb, QL_HEADER_SPACE);
1634 map = pci_map_single(qdev->pdev,
1635 lrg_buf_cb->skb->data,
1636 qdev->lrg_buffer_len -
1637 QL_HEADER_SPACE,
1638 PCI_DMA_FROMDEVICE);
1639 lrg_buf_cb->buf_phy_addr_low =
1640 cpu_to_le32(LS_64BITS(map));
1641 lrg_buf_cb->buf_phy_addr_high =
1642 cpu_to_le32(MS_64BITS(map));
1643 pci_unmap_addr_set(lrg_buf_cb, mapaddr, map);
1644 pci_unmap_len_set(lrg_buf_cb, maplen,
1645 qdev->lrg_buffer_len -
1646 QL_HEADER_SPACE);
1647 --qdev->lrg_buf_skb_check;
1648 if (!qdev->lrg_buf_skb_check)
1649 return 1;
1650 }
1651 }
1652 lrg_buf_cb = lrg_buf_cb->next;
1653 }
1654 return 0;
1655 }
1656
1657 /*
1658 * Caller holds hw_lock.
1659 */
1660 static void ql_update_lrg_bufq_prod_index(struct ql3_adapter *qdev)
1661 {
1662 struct bufq_addr_element *lrg_buf_q_ele;
1663 int i;
1664 struct ql_rcv_buf_cb *lrg_buf_cb;
1665 struct ql3xxx_port_registers __iomem *port_regs = qdev->mem_map_registers;
1666
1667 if ((qdev->lrg_buf_free_count >= 8)
1668 && (qdev->lrg_buf_release_cnt >= 16)) {
1669
1670 if (qdev->lrg_buf_skb_check)
1671 if (!ql_populate_free_queue(qdev))
1672 return;
1673
1674 lrg_buf_q_ele = qdev->lrg_buf_next_free;
1675
1676 while ((qdev->lrg_buf_release_cnt >= 16)
1677 && (qdev->lrg_buf_free_count >= 8)) {
1678
1679 for (i = 0; i < 8; i++) {
1680 lrg_buf_cb =
1681 ql_get_from_lrg_buf_free_list(qdev);
1682 lrg_buf_q_ele->addr_high =
1683 lrg_buf_cb->buf_phy_addr_high;
1684 lrg_buf_q_ele->addr_low =
1685 lrg_buf_cb->buf_phy_addr_low;
1686 lrg_buf_q_ele++;
1687
1688 qdev->lrg_buf_release_cnt--;
1689 }
1690
1691 qdev->lrg_buf_q_producer_index++;
1692
1693 if (qdev->lrg_buf_q_producer_index == NUM_LBUFQ_ENTRIES)
1694 qdev->lrg_buf_q_producer_index = 0;
1695
1696 if (qdev->lrg_buf_q_producer_index ==
1697 (NUM_LBUFQ_ENTRIES - 1)) {
1698 lrg_buf_q_ele = qdev->lrg_buf_q_virt_addr;
1699 }
1700 }
1701
1702 qdev->lrg_buf_next_free = lrg_buf_q_ele;
1703
1704 ql_write_common_reg(qdev,
1705 &port_regs->CommonRegs.
1706 rxLargeQProducerIndex,
1707 qdev->lrg_buf_q_producer_index);
1708 }
1709 }
1710
1711 static void ql_process_mac_tx_intr(struct ql3_adapter *qdev,
1712 struct ob_mac_iocb_rsp *mac_rsp)
1713 {
1714 struct ql_tx_buf_cb *tx_cb;
1715 int i;
1716
1717 tx_cb = &qdev->tx_buf[mac_rsp->transaction_id];
1718 pci_unmap_single(qdev->pdev,
1719 pci_unmap_addr(&tx_cb->map[0], mapaddr),
1720 pci_unmap_len(&tx_cb->map[0], maplen),
1721 PCI_DMA_TODEVICE);
1722 tx_cb->seg_count--;
1723 if (tx_cb->seg_count) {
1724 for (i = 1; i < tx_cb->seg_count; i++) {
1725 pci_unmap_page(qdev->pdev,
1726 pci_unmap_addr(&tx_cb->map[i],
1727 mapaddr),
1728 pci_unmap_len(&tx_cb->map[i], maplen),
1729 PCI_DMA_TODEVICE);
1730 }
1731 }
1732 qdev->stats.tx_packets++;
1733 qdev->stats.tx_bytes += tx_cb->skb->len;
1734 dev_kfree_skb_irq(tx_cb->skb);
1735 tx_cb->skb = NULL;
1736 atomic_inc(&qdev->tx_count);
1737 }
1738
1739 /*
1740 * The difference between 3022 and 3032 for inbound completions:
1741 * 3022 uses two buffers per completion. The first buffer contains
1742 * (some) header info, the second the remainder of the headers plus
1743 * the data. For this chip we reserve some space at the top of the
1744 * receive buffer so that the header info in buffer one can be
1745 * prepended to the buffer two. Buffer two is the sent up while
1746 * buffer one is returned to the hardware to be reused.
1747 * 3032 receives all of it's data and headers in one buffer for a
1748 * simpler process. 3032 also supports checksum verification as
1749 * can be seen in ql_process_macip_rx_intr().
1750 */
1751 static void ql_process_mac_rx_intr(struct ql3_adapter *qdev,
1752 struct ib_mac_iocb_rsp *ib_mac_rsp_ptr)
1753 {
1754 long int offset;
1755 u32 lrg_buf_phy_addr_low = 0;
1756 struct ql_rcv_buf_cb *lrg_buf_cb1 = NULL;
1757 struct ql_rcv_buf_cb *lrg_buf_cb2 = NULL;
1758 u32 *curr_ial_ptr;
1759 struct sk_buff *skb;
1760 u16 length = le16_to_cpu(ib_mac_rsp_ptr->length);
1761
1762 /*
1763 * Get the inbound address list (small buffer).
1764 */
1765 offset = qdev->small_buf_index * QL_SMALL_BUFFER_SIZE;
1766 if (++qdev->small_buf_index == NUM_SMALL_BUFFERS)
1767 qdev->small_buf_index = 0;
1768
1769 curr_ial_ptr = (u32 *) (qdev->small_buf_virt_addr + offset);
1770 qdev->last_rsp_offset = qdev->small_buf_phy_addr_low + offset;
1771 qdev->small_buf_release_cnt++;
1772
1773 if (qdev->device_id == QL3022_DEVICE_ID) {
1774 /* start of first buffer (3022 only) */
1775 lrg_buf_phy_addr_low = le32_to_cpu(*curr_ial_ptr);
1776 lrg_buf_cb1 = &qdev->lrg_buf[qdev->lrg_buf_index];
1777 qdev->lrg_buf_release_cnt++;
1778 if (++qdev->lrg_buf_index == NUM_LARGE_BUFFERS) {
1779 qdev->lrg_buf_index = 0;
1780 }
1781 curr_ial_ptr++; /* 64-bit pointers require two incs. */
1782 curr_ial_ptr++;
1783 }
1784
1785 /* start of second buffer */
1786 lrg_buf_phy_addr_low = le32_to_cpu(*curr_ial_ptr);
1787 lrg_buf_cb2 = &qdev->lrg_buf[qdev->lrg_buf_index];
1788
1789 /*
1790 * Second buffer gets sent up the stack.
1791 */
1792 qdev->lrg_buf_release_cnt++;
1793 if (++qdev->lrg_buf_index == NUM_LARGE_BUFFERS)
1794 qdev->lrg_buf_index = 0;
1795 skb = lrg_buf_cb2->skb;
1796
1797 qdev->stats.rx_packets++;
1798 qdev->stats.rx_bytes += length;
1799
1800 skb_put(skb, length);
1801 pci_unmap_single(qdev->pdev,
1802 pci_unmap_addr(lrg_buf_cb2, mapaddr),
1803 pci_unmap_len(lrg_buf_cb2, maplen),
1804 PCI_DMA_FROMDEVICE);
1805 prefetch(skb->data);
1806 skb->dev = qdev->ndev;
1807 skb->ip_summed = CHECKSUM_NONE;
1808 skb->protocol = eth_type_trans(skb, qdev->ndev);
1809
1810 netif_receive_skb(skb);
1811 qdev->ndev->last_rx = jiffies;
1812 lrg_buf_cb2->skb = NULL;
1813
1814 if (qdev->device_id == QL3022_DEVICE_ID)
1815 ql_release_to_lrg_buf_free_list(qdev, lrg_buf_cb1);
1816 ql_release_to_lrg_buf_free_list(qdev, lrg_buf_cb2);
1817 }
1818
1819 static void ql_process_macip_rx_intr(struct ql3_adapter *qdev,
1820 struct ib_ip_iocb_rsp *ib_ip_rsp_ptr)
1821 {
1822 long int offset;
1823 u32 lrg_buf_phy_addr_low = 0;
1824 struct ql_rcv_buf_cb *lrg_buf_cb1 = NULL;
1825 struct ql_rcv_buf_cb *lrg_buf_cb2 = NULL;
1826 u32 *curr_ial_ptr;
1827 struct sk_buff *skb1 = NULL, *skb2;
1828 struct net_device *ndev = qdev->ndev;
1829 u16 length = le16_to_cpu(ib_ip_rsp_ptr->length);
1830 u16 size = 0;
1831
1832 /*
1833 * Get the inbound address list (small buffer).
1834 */
1835
1836 offset = qdev->small_buf_index * QL_SMALL_BUFFER_SIZE;
1837 if (++qdev->small_buf_index == NUM_SMALL_BUFFERS)
1838 qdev->small_buf_index = 0;
1839 curr_ial_ptr = (u32 *) (qdev->small_buf_virt_addr + offset);
1840 qdev->last_rsp_offset = qdev->small_buf_phy_addr_low + offset;
1841 qdev->small_buf_release_cnt++;
1842
1843 if (qdev->device_id == QL3022_DEVICE_ID) {
1844 /* start of first buffer on 3022 */
1845 lrg_buf_phy_addr_low = le32_to_cpu(*curr_ial_ptr);
1846 lrg_buf_cb1 = &qdev->lrg_buf[qdev->lrg_buf_index];
1847 qdev->lrg_buf_release_cnt++;
1848 if (++qdev->lrg_buf_index == NUM_LARGE_BUFFERS)
1849 qdev->lrg_buf_index = 0;
1850 skb1 = lrg_buf_cb1->skb;
1851 curr_ial_ptr++; /* 64-bit pointers require two incs. */
1852 curr_ial_ptr++;
1853 size = ETH_HLEN;
1854 if (*((u16 *) skb1->data) != 0xFFFF)
1855 size += VLAN_ETH_HLEN - ETH_HLEN;
1856 }
1857
1858 /* start of second buffer */
1859 lrg_buf_phy_addr_low = le32_to_cpu(*curr_ial_ptr);
1860 lrg_buf_cb2 = &qdev->lrg_buf[qdev->lrg_buf_index];
1861 skb2 = lrg_buf_cb2->skb;
1862 qdev->lrg_buf_release_cnt++;
1863 if (++qdev->lrg_buf_index == NUM_LARGE_BUFFERS)
1864 qdev->lrg_buf_index = 0;
1865
1866 skb_put(skb2, length); /* Just the second buffer length here. */
1867 pci_unmap_single(qdev->pdev,
1868 pci_unmap_addr(lrg_buf_cb2, mapaddr),
1869 pci_unmap_len(lrg_buf_cb2, maplen),
1870 PCI_DMA_FROMDEVICE);
1871 prefetch(skb2->data);
1872
1873 skb2->ip_summed = CHECKSUM_NONE;
1874 if (qdev->device_id == QL3022_DEVICE_ID) {
1875 /*
1876 * Copy the ethhdr from first buffer to second. This
1877 * is necessary for 3022 IP completions.
1878 */
1879 memcpy(skb_push(skb2, size), skb1->data + VLAN_ID_LEN, size);
1880 } else {
1881 u16 checksum = le16_to_cpu(ib_ip_rsp_ptr->checksum);
1882 if (checksum &
1883 (IB_IP_IOCB_RSP_3032_ICE |
1884 IB_IP_IOCB_RSP_3032_CE |
1885 IB_IP_IOCB_RSP_3032_NUC)) {
1886 printk(KERN_ERR
1887 "%s: Bad checksum for this %s packet, checksum = %x.\n",
1888 __func__,
1889 ((checksum &
1890 IB_IP_IOCB_RSP_3032_TCP) ? "TCP" :
1891 "UDP"),checksum);
1892 } else if (checksum & IB_IP_IOCB_RSP_3032_TCP) {
1893 skb2->ip_summed = CHECKSUM_UNNECESSARY;
1894 }
1895 }
1896 skb2->dev = qdev->ndev;
1897 skb2->protocol = eth_type_trans(skb2, qdev->ndev);
1898
1899 netif_receive_skb(skb2);
1900 qdev->stats.rx_packets++;
1901 qdev->stats.rx_bytes += length;
1902 ndev->last_rx = jiffies;
1903 lrg_buf_cb2->skb = NULL;
1904
1905 if (qdev->device_id == QL3022_DEVICE_ID)
1906 ql_release_to_lrg_buf_free_list(qdev, lrg_buf_cb1);
1907 ql_release_to_lrg_buf_free_list(qdev, lrg_buf_cb2);
1908 }
1909
1910 static int ql_tx_rx_clean(struct ql3_adapter *qdev,
1911 int *tx_cleaned, int *rx_cleaned, int work_to_do)
1912 {
1913 struct ql3xxx_port_registers __iomem *port_regs = qdev->mem_map_registers;
1914 struct net_rsp_iocb *net_rsp;
1915 struct net_device *ndev = qdev->ndev;
1916 unsigned long hw_flags;
1917
1918 /* While there are entries in the completion queue. */
1919 while ((cpu_to_le32(*(qdev->prsp_producer_index)) !=
1920 qdev->rsp_consumer_index) && (*rx_cleaned < work_to_do)) {
1921
1922 net_rsp = qdev->rsp_current;
1923 switch (net_rsp->opcode) {
1924
1925 case OPCODE_OB_MAC_IOCB_FN0:
1926 case OPCODE_OB_MAC_IOCB_FN2:
1927 ql_process_mac_tx_intr(qdev, (struct ob_mac_iocb_rsp *)
1928 net_rsp);
1929 (*tx_cleaned)++;
1930 break;
1931
1932 case OPCODE_IB_MAC_IOCB:
1933 case OPCODE_IB_3032_MAC_IOCB:
1934 ql_process_mac_rx_intr(qdev, (struct ib_mac_iocb_rsp *)
1935 net_rsp);
1936 (*rx_cleaned)++;
1937 break;
1938
1939 case OPCODE_IB_IP_IOCB:
1940 case OPCODE_IB_3032_IP_IOCB:
1941 ql_process_macip_rx_intr(qdev, (struct ib_ip_iocb_rsp *)
1942 net_rsp);
1943 (*rx_cleaned)++;
1944 break;
1945 default:
1946 {
1947 u32 *tmp = (u32 *) net_rsp;
1948 printk(KERN_ERR PFX
1949 "%s: Hit default case, not "
1950 "handled!\n"
1951 " dropping the packet, opcode = "
1952 "%x.\n",
1953 ndev->name, net_rsp->opcode);
1954 printk(KERN_ERR PFX
1955 "0x%08lx 0x%08lx 0x%08lx 0x%08lx \n",
1956 (unsigned long int)tmp[0],
1957 (unsigned long int)tmp[1],
1958 (unsigned long int)tmp[2],
1959 (unsigned long int)tmp[3]);
1960 }
1961 }
1962
1963 qdev->rsp_consumer_index++;
1964
1965 if (qdev->rsp_consumer_index == NUM_RSP_Q_ENTRIES) {
1966 qdev->rsp_consumer_index = 0;
1967 qdev->rsp_current = qdev->rsp_q_virt_addr;
1968 } else {
1969 qdev->rsp_current++;
1970 }
1971 }
1972
1973 spin_lock_irqsave(&qdev->hw_lock, hw_flags);
1974
1975 ql_update_lrg_bufq_prod_index(qdev);
1976
1977 if (qdev->small_buf_release_cnt >= 16) {
1978 while (qdev->small_buf_release_cnt >= 16) {
1979 qdev->small_buf_q_producer_index++;
1980
1981 if (qdev->small_buf_q_producer_index ==
1982 NUM_SBUFQ_ENTRIES)
1983 qdev->small_buf_q_producer_index = 0;
1984 qdev->small_buf_release_cnt -= 8;
1985 }
1986
1987 ql_write_common_reg(qdev,
1988 &port_regs->CommonRegs.
1989 rxSmallQProducerIndex,
1990 qdev->small_buf_q_producer_index);
1991 }
1992
1993 ql_write_common_reg(qdev,
1994 &port_regs->CommonRegs.rspQConsumerIndex,
1995 qdev->rsp_consumer_index);
1996 spin_unlock_irqrestore(&qdev->hw_lock, hw_flags);
1997
1998 if (unlikely(netif_queue_stopped(qdev->ndev))) {
1999 if (netif_queue_stopped(qdev->ndev) &&
2000 (atomic_read(&qdev->tx_count) > (NUM_REQ_Q_ENTRIES / 4)))
2001 netif_wake_queue(qdev->ndev);
2002 }
2003
2004 return *tx_cleaned + *rx_cleaned;
2005 }
2006
2007 static int ql_poll(struct net_device *ndev, int *budget)
2008 {
2009 struct ql3_adapter *qdev = netdev_priv(ndev);
2010 int work_to_do = min(*budget, ndev->quota);
2011 int rx_cleaned = 0, tx_cleaned = 0;
2012
2013 if (!netif_carrier_ok(ndev))
2014 goto quit_polling;
2015
2016 ql_tx_rx_clean(qdev, &tx_cleaned, &rx_cleaned, work_to_do);
2017 *budget -= rx_cleaned;
2018 ndev->quota -= rx_cleaned;
2019
2020 if ((!tx_cleaned && !rx_cleaned) || !netif_running(ndev)) {
2021 quit_polling:
2022 netif_rx_complete(ndev);
2023 ql_enable_interrupts(qdev);
2024 return 0;
2025 }
2026 return 1;
2027 }
2028
2029 static irqreturn_t ql3xxx_isr(int irq, void *dev_id)
2030 {
2031
2032 struct net_device *ndev = dev_id;
2033 struct ql3_adapter *qdev = netdev_priv(ndev);
2034 struct ql3xxx_port_registers __iomem *port_regs = qdev->mem_map_registers;
2035 u32 value;
2036 int handled = 1;
2037 u32 var;
2038
2039 port_regs = qdev->mem_map_registers;
2040
2041 value =
2042 ql_read_common_reg_l(qdev, &port_regs->CommonRegs.ispControlStatus);
2043
2044 if (value & (ISP_CONTROL_FE | ISP_CONTROL_RI)) {
2045 spin_lock(&qdev->adapter_lock);
2046 netif_stop_queue(qdev->ndev);
2047 netif_carrier_off(qdev->ndev);
2048 ql_disable_interrupts(qdev);
2049 qdev->port_link_state = LS_DOWN;
2050 set_bit(QL_RESET_ACTIVE,&qdev->flags) ;
2051
2052 if (value & ISP_CONTROL_FE) {
2053 /*
2054 * Chip Fatal Error.
2055 */
2056 var =
2057 ql_read_page0_reg_l(qdev,
2058 &port_regs->PortFatalErrStatus);
2059 printk(KERN_WARNING PFX
2060 "%s: Resetting chip. PortFatalErrStatus "
2061 "register = 0x%x\n", ndev->name, var);
2062 set_bit(QL_RESET_START,&qdev->flags) ;
2063 } else {
2064 /*
2065 * Soft Reset Requested.
2066 */
2067 set_bit(QL_RESET_PER_SCSI,&qdev->flags) ;
2068 printk(KERN_ERR PFX
2069 "%s: Another function issued a reset to the "
2070 "chip. ISR value = %x.\n", ndev->name, value);
2071 }
2072 queue_delayed_work(qdev->workqueue, &qdev->reset_work, 0);
2073 spin_unlock(&qdev->adapter_lock);
2074 } else if (value & ISP_IMR_DISABLE_CMPL_INT) {
2075 ql_disable_interrupts(qdev);
2076 if (likely(netif_rx_schedule_prep(ndev)))
2077 __netif_rx_schedule(ndev);
2078 else
2079 ql_enable_interrupts(qdev);
2080 } else {
2081 return IRQ_NONE;
2082 }
2083
2084 return IRQ_RETVAL(handled);
2085 }
2086
2087 /*
2088 * Get the total number of segments needed for the
2089 * given number of fragments. This is necessary because
2090 * outbound address lists (OAL) will be used when more than
2091 * two frags are given. Each address list has 5 addr/len
2092 * pairs. The 5th pair in each AOL is used to point to
2093 * the next AOL if more frags are coming.
2094 * That is why the frags:segment count ratio is not linear.
2095 */
2096 static int ql_get_seg_count(unsigned short frags)
2097 {
2098 switch(frags) {
2099 case 0: return 1; /* just the skb->data seg */
2100 case 1: return 2; /* skb->data + 1 frag */
2101 case 2: return 3; /* skb->data + 2 frags */
2102 case 3: return 5; /* skb->data + 1 frag + 1 AOL containting 2 frags */
2103 case 4: return 6;
2104 case 5: return 7;
2105 case 6: return 8;
2106 case 7: return 10;
2107 case 8: return 11;
2108 case 9: return 12;
2109 case 10: return 13;
2110 case 11: return 15;
2111 case 12: return 16;
2112 case 13: return 17;
2113 case 14: return 18;
2114 case 15: return 20;
2115 case 16: return 21;
2116 case 17: return 22;
2117 case 18: return 23;
2118 }
2119 return -1;
2120 }
2121
2122 static void ql_hw_csum_setup(struct sk_buff *skb,
2123 struct ob_mac_iocb_req *mac_iocb_ptr)
2124 {
2125 struct ethhdr *eth;
2126 struct iphdr *ip = NULL;
2127 u8 offset = ETH_HLEN;
2128
2129 eth = (struct ethhdr *)(skb->data);
2130
2131 if (eth->h_proto == __constant_htons(ETH_P_IP)) {
2132 ip = (struct iphdr *)&skb->data[ETH_HLEN];
2133 } else if (eth->h_proto == htons(ETH_P_8021Q) &&
2134 ((struct vlan_ethhdr *)skb->data)->
2135 h_vlan_encapsulated_proto == __constant_htons(ETH_P_IP)) {
2136 ip = (struct iphdr *)&skb->data[VLAN_ETH_HLEN];
2137 offset = VLAN_ETH_HLEN;
2138 }
2139
2140 if (ip) {
2141 if (ip->protocol == IPPROTO_TCP) {
2142 mac_iocb_ptr->flags1 |= OB_3032MAC_IOCB_REQ_TC;
2143 mac_iocb_ptr->ip_hdr_off = offset;
2144 mac_iocb_ptr->ip_hdr_len = ip->ihl;
2145 } else if (ip->protocol == IPPROTO_UDP) {
2146 mac_iocb_ptr->flags1 |= OB_3032MAC_IOCB_REQ_UC;
2147 mac_iocb_ptr->ip_hdr_off = offset;
2148 mac_iocb_ptr->ip_hdr_len = ip->ihl;
2149 }
2150 }
2151 }
2152
2153 /*
2154 * The difference between 3022 and 3032 sends:
2155 * 3022 only supports a simple single segment transmission.
2156 * 3032 supports checksumming and scatter/gather lists (fragments).
2157 * The 3032 supports sglists by using the 3 addr/len pairs (ALP)
2158 * in the IOCB plus a chain of outbound address lists (OAL) that
2159 * each contain 5 ALPs. The last ALP of the IOCB (3rd) or OAL (5th)
2160 * will used to point to an OAL when more ALP entries are required.
2161 * The IOCB is always the top of the chain followed by one or more
2162 * OALs (when necessary).
2163 */
2164 static int ql3xxx_send(struct sk_buff *skb, struct net_device *ndev)
2165 {
2166 struct ql3_adapter *qdev = (struct ql3_adapter *)netdev_priv(ndev);
2167 struct ql3xxx_port_registers __iomem *port_regs = qdev->mem_map_registers;
2168 struct ql_tx_buf_cb *tx_cb;
2169 u32 tot_len = skb->len;
2170 struct oal *oal;
2171 struct oal_entry *oal_entry;
2172 int len;
2173 struct ob_mac_iocb_req *mac_iocb_ptr;
2174 u64 map;
2175 int seg_cnt, seg = 0;
2176 int frag_cnt = (int)skb_shinfo(skb)->nr_frags;
2177
2178 if (unlikely(atomic_read(&qdev->tx_count) < 2)) {
2179 if (!netif_queue_stopped(ndev))
2180 netif_stop_queue(ndev);
2181 return NETDEV_TX_BUSY;
2182 }
2183 tx_cb = &qdev->tx_buf[qdev->req_producer_index] ;
2184 seg_cnt = tx_cb->seg_count = ql_get_seg_count((skb_shinfo(skb)->nr_frags));
2185 if(seg_cnt == -1) {
2186 printk(KERN_ERR PFX"%s: invalid segment count!\n",__func__);
2187 return NETDEV_TX_OK;
2188
2189 }
2190 mac_iocb_ptr = tx_cb->queue_entry;
2191 memset((void *)mac_iocb_ptr, 0, sizeof(struct ob_mac_iocb_req));
2192 mac_iocb_ptr->opcode = qdev->mac_ob_opcode;
2193 mac_iocb_ptr->flags |= qdev->mb_bit_mask;
2194 mac_iocb_ptr->transaction_id = qdev->req_producer_index;
2195 mac_iocb_ptr->data_len = cpu_to_le16((u16) tot_len);
2196 tx_cb->skb = skb;
2197 if (skb->ip_summed == CHECKSUM_PARTIAL)
2198 ql_hw_csum_setup(skb, mac_iocb_ptr);
2199 len = skb_headlen(skb);
2200 map = pci_map_single(qdev->pdev, skb->data, len, PCI_DMA_TODEVICE);
2201 oal_entry = (struct oal_entry *)&mac_iocb_ptr->buf_addr0_low;
2202 oal_entry->dma_lo = cpu_to_le32(LS_64BITS(map));
2203 oal_entry->dma_hi = cpu_to_le32(MS_64BITS(map));
2204 oal_entry->len = cpu_to_le32(len);
2205 pci_unmap_addr_set(&tx_cb->map[seg], mapaddr, map);
2206 pci_unmap_len_set(&tx_cb->map[seg], maplen, len);
2207 seg++;
2208
2209 if (!skb_shinfo(skb)->nr_frags) {
2210 /* Terminate the last segment. */
2211 oal_entry->len =
2212 cpu_to_le32(le32_to_cpu(oal_entry->len) | OAL_LAST_ENTRY);
2213 } else {
2214 int i;
2215 oal = tx_cb->oal;
2216 for (i=0; i<frag_cnt; i++,seg++) {
2217 skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
2218 oal_entry++;
2219 if ((seg == 2 && seg_cnt > 3) || /* Check for continuation */
2220 (seg == 7 && seg_cnt > 8) || /* requirements. It's strange */
2221 (seg == 12 && seg_cnt > 13) || /* but necessary. */
2222 (seg == 17 && seg_cnt > 18)) {
2223 /* Continuation entry points to outbound address list. */
2224 map = pci_map_single(qdev->pdev, oal,
2225 sizeof(struct oal),
2226 PCI_DMA_TODEVICE);
2227 oal_entry->dma_lo = cpu_to_le32(LS_64BITS(map));
2228 oal_entry->dma_hi = cpu_to_le32(MS_64BITS(map));
2229 oal_entry->len =
2230 cpu_to_le32(sizeof(struct oal) |
2231 OAL_CONT_ENTRY);
2232 pci_unmap_addr_set(&tx_cb->map[seg], mapaddr,
2233 map);
2234 pci_unmap_len_set(&tx_cb->map[seg], maplen,
2235 len);
2236 oal_entry = (struct oal_entry *)oal;
2237 oal++;
2238 seg++;
2239 }
2240
2241 map =
2242 pci_map_page(qdev->pdev, frag->page,
2243 frag->page_offset, frag->size,
2244 PCI_DMA_TODEVICE);
2245 oal_entry->dma_lo = cpu_to_le32(LS_64BITS(map));
2246 oal_entry->dma_hi = cpu_to_le32(MS_64BITS(map));
2247 oal_entry->len = cpu_to_le32(frag->size);
2248 pci_unmap_addr_set(&tx_cb->map[seg], mapaddr, map);
2249 pci_unmap_len_set(&tx_cb->map[seg], maplen,
2250 frag->size);
2251 }
2252 /* Terminate the last segment. */
2253 oal_entry->len =
2254 cpu_to_le32(le32_to_cpu(oal_entry->len) | OAL_LAST_ENTRY);
2255 }
2256 wmb();
2257 qdev->req_producer_index++;
2258 if (qdev->req_producer_index == NUM_REQ_Q_ENTRIES)
2259 qdev->req_producer_index = 0;
2260 wmb();
2261 ql_write_common_reg_l(qdev,
2262 &port_regs->CommonRegs.reqQProducerIndex,
2263 qdev->req_producer_index);
2264
2265 ndev->trans_start = jiffies;
2266 if (netif_msg_tx_queued(qdev))
2267 printk(KERN_DEBUG PFX "%s: tx queued, slot %d, len %d\n",
2268 ndev->name, qdev->req_producer_index, skb->len);
2269
2270 atomic_dec(&qdev->tx_count);
2271 return NETDEV_TX_OK;
2272 }
2273
2274 static int ql_alloc_net_req_rsp_queues(struct ql3_adapter *qdev)
2275 {
2276 qdev->req_q_size =
2277 (u32) (NUM_REQ_Q_ENTRIES * sizeof(struct ob_mac_iocb_req));
2278
2279 qdev->req_q_virt_addr =
2280 pci_alloc_consistent(qdev->pdev,
2281 (size_t) qdev->req_q_size,
2282 &qdev->req_q_phy_addr);
2283
2284 if ((qdev->req_q_virt_addr == NULL) ||
2285 LS_64BITS(qdev->req_q_phy_addr) & (qdev->req_q_size - 1)) {
2286 printk(KERN_ERR PFX "%s: reqQ failed.\n",
2287 qdev->ndev->name);
2288 return -ENOMEM;
2289 }
2290
2291 qdev->rsp_q_size = NUM_RSP_Q_ENTRIES * sizeof(struct net_rsp_iocb);
2292
2293 qdev->rsp_q_virt_addr =
2294 pci_alloc_consistent(qdev->pdev,
2295 (size_t) qdev->rsp_q_size,
2296 &qdev->rsp_q_phy_addr);
2297
2298 if ((qdev->rsp_q_virt_addr == NULL) ||
2299 LS_64BITS(qdev->rsp_q_phy_addr) & (qdev->rsp_q_size - 1)) {
2300 printk(KERN_ERR PFX
2301 "%s: rspQ allocation failed\n",
2302 qdev->ndev->name);
2303 pci_free_consistent(qdev->pdev, (size_t) qdev->req_q_size,
2304 qdev->req_q_virt_addr,
2305 qdev->req_q_phy_addr);
2306 return -ENOMEM;
2307 }
2308
2309 set_bit(QL_ALLOC_REQ_RSP_Q_DONE,&qdev->flags);
2310
2311 return 0;
2312 }
2313
2314 static void ql_free_net_req_rsp_queues(struct ql3_adapter *qdev)
2315 {
2316 if (!test_bit(QL_ALLOC_REQ_RSP_Q_DONE,&qdev->flags)) {
2317 printk(KERN_INFO PFX
2318 "%s: Already done.\n", qdev->ndev->name);
2319 return;
2320 }
2321
2322 pci_free_consistent(qdev->pdev,
2323 qdev->req_q_size,
2324 qdev->req_q_virt_addr, qdev->req_q_phy_addr);
2325
2326 qdev->req_q_virt_addr = NULL;
2327
2328 pci_free_consistent(qdev->pdev,
2329 qdev->rsp_q_size,
2330 qdev->rsp_q_virt_addr, qdev->rsp_q_phy_addr);
2331
2332 qdev->rsp_q_virt_addr = NULL;
2333
2334 clear_bit(QL_ALLOC_REQ_RSP_Q_DONE,&qdev->flags);
2335 }
2336
2337 static int ql_alloc_buffer_queues(struct ql3_adapter *qdev)
2338 {
2339 /* Create Large Buffer Queue */
2340 qdev->lrg_buf_q_size =
2341 NUM_LBUFQ_ENTRIES * sizeof(struct lrg_buf_q_entry);
2342 if (qdev->lrg_buf_q_size < PAGE_SIZE)
2343 qdev->lrg_buf_q_alloc_size = PAGE_SIZE;
2344 else
2345 qdev->lrg_buf_q_alloc_size = qdev->lrg_buf_q_size * 2;
2346
2347 qdev->lrg_buf_q_alloc_virt_addr =
2348 pci_alloc_consistent(qdev->pdev,
2349 qdev->lrg_buf_q_alloc_size,
2350 &qdev->lrg_buf_q_alloc_phy_addr);
2351
2352 if (qdev->lrg_buf_q_alloc_virt_addr == NULL) {
2353 printk(KERN_ERR PFX
2354 "%s: lBufQ failed\n", qdev->ndev->name);
2355 return -ENOMEM;
2356 }
2357 qdev->lrg_buf_q_virt_addr = qdev->lrg_buf_q_alloc_virt_addr;
2358 qdev->lrg_buf_q_phy_addr = qdev->lrg_buf_q_alloc_phy_addr;
2359
2360 /* Create Small Buffer Queue */
2361 qdev->small_buf_q_size =
2362 NUM_SBUFQ_ENTRIES * sizeof(struct lrg_buf_q_entry);
2363 if (qdev->small_buf_q_size < PAGE_SIZE)
2364 qdev->small_buf_q_alloc_size = PAGE_SIZE;
2365 else
2366 qdev->small_buf_q_alloc_size = qdev->small_buf_q_size * 2;
2367
2368 qdev->small_buf_q_alloc_virt_addr =
2369 pci_alloc_consistent(qdev->pdev,
2370 qdev->small_buf_q_alloc_size,
2371 &qdev->small_buf_q_alloc_phy_addr);
2372
2373 if (qdev->small_buf_q_alloc_virt_addr == NULL) {
2374 printk(KERN_ERR PFX
2375 "%s: Small Buffer Queue allocation failed.\n",
2376 qdev->ndev->name);
2377 pci_free_consistent(qdev->pdev, qdev->lrg_buf_q_alloc_size,
2378 qdev->lrg_buf_q_alloc_virt_addr,
2379 qdev->lrg_buf_q_alloc_phy_addr);
2380 return -ENOMEM;
2381 }
2382
2383 qdev->small_buf_q_virt_addr = qdev->small_buf_q_alloc_virt_addr;
2384 qdev->small_buf_q_phy_addr = qdev->small_buf_q_alloc_phy_addr;
2385 set_bit(QL_ALLOC_BUFQS_DONE,&qdev->flags);
2386 return 0;
2387 }
2388
2389 static void ql_free_buffer_queues(struct ql3_adapter *qdev)
2390 {
2391 if (!test_bit(QL_ALLOC_BUFQS_DONE,&qdev->flags)) {
2392 printk(KERN_INFO PFX
2393 "%s: Already done.\n", qdev->ndev->name);
2394 return;
2395 }
2396
2397 pci_free_consistent(qdev->pdev,
2398 qdev->lrg_buf_q_alloc_size,
2399 qdev->lrg_buf_q_alloc_virt_addr,
2400 qdev->lrg_buf_q_alloc_phy_addr);
2401
2402 qdev->lrg_buf_q_virt_addr = NULL;
2403
2404 pci_free_consistent(qdev->pdev,
2405 qdev->small_buf_q_alloc_size,
2406 qdev->small_buf_q_alloc_virt_addr,
2407 qdev->small_buf_q_alloc_phy_addr);
2408
2409 qdev->small_buf_q_virt_addr = NULL;
2410
2411 clear_bit(QL_ALLOC_BUFQS_DONE,&qdev->flags);
2412 }
2413
2414 static int ql_alloc_small_buffers(struct ql3_adapter *qdev)
2415 {
2416 int i;
2417 struct bufq_addr_element *small_buf_q_entry;
2418
2419 /* Currently we allocate on one of memory and use it for smallbuffers */
2420 qdev->small_buf_total_size =
2421 (QL_ADDR_ELE_PER_BUFQ_ENTRY * NUM_SBUFQ_ENTRIES *
2422 QL_SMALL_BUFFER_SIZE);
2423
2424 qdev->small_buf_virt_addr =
2425 pci_alloc_consistent(qdev->pdev,
2426 qdev->small_buf_total_size,
2427 &qdev->small_buf_phy_addr);
2428
2429 if (qdev->small_buf_virt_addr == NULL) {
2430 printk(KERN_ERR PFX
2431 "%s: Failed to get small buffer memory.\n",
2432 qdev->ndev->name);
2433 return -ENOMEM;
2434 }
2435
2436 qdev->small_buf_phy_addr_low = LS_64BITS(qdev->small_buf_phy_addr);
2437 qdev->small_buf_phy_addr_high = MS_64BITS(qdev->small_buf_phy_addr);
2438
2439 small_buf_q_entry = qdev->small_buf_q_virt_addr;
2440
2441 qdev->last_rsp_offset = qdev->small_buf_phy_addr_low;
2442
2443 /* Initialize the small buffer queue. */
2444 for (i = 0; i < (QL_ADDR_ELE_PER_BUFQ_ENTRY * NUM_SBUFQ_ENTRIES); i++) {
2445 small_buf_q_entry->addr_high =
2446 cpu_to_le32(qdev->small_buf_phy_addr_high);
2447 small_buf_q_entry->addr_low =
2448 cpu_to_le32(qdev->small_buf_phy_addr_low +
2449 (i * QL_SMALL_BUFFER_SIZE));
2450 small_buf_q_entry++;
2451 }
2452 qdev->small_buf_index = 0;
2453 set_bit(QL_ALLOC_SMALL_BUF_DONE,&qdev->flags);
2454 return 0;
2455 }
2456
2457 static void ql_free_small_buffers(struct ql3_adapter *qdev)
2458 {
2459 if (!test_bit(QL_ALLOC_SMALL_BUF_DONE,&qdev->flags)) {
2460 printk(KERN_INFO PFX
2461 "%s: Already done.\n", qdev->ndev->name);
2462 return;
2463 }
2464 if (qdev->small_buf_virt_addr != NULL) {
2465 pci_free_consistent(qdev->pdev,
2466 qdev->small_buf_total_size,
2467 qdev->small_buf_virt_addr,
2468 qdev->small_buf_phy_addr);
2469
2470 qdev->small_buf_virt_addr = NULL;
2471 }
2472 }
2473
2474 static void ql_free_large_buffers(struct ql3_adapter *qdev)
2475 {
2476 int i = 0;
2477 struct ql_rcv_buf_cb *lrg_buf_cb;
2478
2479 for (i = 0; i < NUM_LARGE_BUFFERS; i++) {
2480 lrg_buf_cb = &qdev->lrg_buf[i];
2481 if (lrg_buf_cb->skb) {
2482 dev_kfree_skb(lrg_buf_cb->skb);
2483 pci_unmap_single(qdev->pdev,
2484 pci_unmap_addr(lrg_buf_cb, mapaddr),
2485 pci_unmap_len(lrg_buf_cb, maplen),
2486 PCI_DMA_FROMDEVICE);
2487 memset(lrg_buf_cb, 0, sizeof(struct ql_rcv_buf_cb));
2488 } else {
2489 break;
2490 }
2491 }
2492 }
2493
2494 static void ql_init_large_buffers(struct ql3_adapter *qdev)
2495 {
2496 int i;
2497 struct ql_rcv_buf_cb *lrg_buf_cb;
2498 struct bufq_addr_element *buf_addr_ele = qdev->lrg_buf_q_virt_addr;
2499
2500 for (i = 0; i < NUM_LARGE_BUFFERS; i++) {
2501 lrg_buf_cb = &qdev->lrg_buf[i];
2502 buf_addr_ele->addr_high = lrg_buf_cb->buf_phy_addr_high;
2503 buf_addr_ele->addr_low = lrg_buf_cb->buf_phy_addr_low;
2504 buf_addr_ele++;
2505 }
2506 qdev->lrg_buf_index = 0;
2507 qdev->lrg_buf_skb_check = 0;
2508 }
2509
2510 static int ql_alloc_large_buffers(struct ql3_adapter *qdev)
2511 {
2512 int i;
2513 struct ql_rcv_buf_cb *lrg_buf_cb;
2514 struct sk_buff *skb;
2515 u64 map;
2516
2517 for (i = 0; i < NUM_LARGE_BUFFERS; i++) {
2518 skb = dev_alloc_skb(qdev->lrg_buffer_len);
2519 if (unlikely(!skb)) {
2520 /* Better luck next round */
2521 printk(KERN_ERR PFX
2522 "%s: large buff alloc failed, "
2523 "for %d bytes at index %d.\n",
2524 qdev->ndev->name,
2525 qdev->lrg_buffer_len * 2, i);
2526 ql_free_large_buffers(qdev);
2527 return -ENOMEM;
2528 } else {
2529
2530 lrg_buf_cb = &qdev->lrg_buf[i];
2531 memset(lrg_buf_cb, 0, sizeof(struct ql_rcv_buf_cb));
2532 lrg_buf_cb->index = i;
2533 lrg_buf_cb->skb = skb;
2534 /*
2535 * We save some space to copy the ethhdr from first
2536 * buffer
2537 */
2538 skb_reserve(skb, QL_HEADER_SPACE);
2539 map = pci_map_single(qdev->pdev,
2540 skb->data,
2541 qdev->lrg_buffer_len -
2542 QL_HEADER_SPACE,
2543 PCI_DMA_FROMDEVICE);
2544 pci_unmap_addr_set(lrg_buf_cb, mapaddr, map);
2545 pci_unmap_len_set(lrg_buf_cb, maplen,
2546 qdev->lrg_buffer_len -
2547 QL_HEADER_SPACE);
2548 lrg_buf_cb->buf_phy_addr_low =
2549 cpu_to_le32(LS_64BITS(map));
2550 lrg_buf_cb->buf_phy_addr_high =
2551 cpu_to_le32(MS_64BITS(map));
2552 }
2553 }
2554 return 0;
2555 }
2556
2557 static void ql_free_send_free_list(struct ql3_adapter *qdev)
2558 {
2559 struct ql_tx_buf_cb *tx_cb;
2560 int i;
2561
2562 tx_cb = &qdev->tx_buf[0];
2563 for (i = 0; i < NUM_REQ_Q_ENTRIES; i++) {
2564 if (tx_cb->oal) {
2565 kfree(tx_cb->oal);
2566 tx_cb->oal = NULL;
2567 }
2568 tx_cb++;
2569 }
2570 }
2571
2572 static int ql_create_send_free_list(struct ql3_adapter *qdev)
2573 {
2574 struct ql_tx_buf_cb *tx_cb;
2575 int i;
2576 struct ob_mac_iocb_req *req_q_curr =
2577 qdev->req_q_virt_addr;
2578
2579 /* Create free list of transmit buffers */
2580 for (i = 0; i < NUM_REQ_Q_ENTRIES; i++) {
2581
2582 tx_cb = &qdev->tx_buf[i];
2583 tx_cb->skb = NULL;
2584 tx_cb->queue_entry = req_q_curr;
2585 req_q_curr++;
2586 tx_cb->oal = kmalloc(512, GFP_KERNEL);
2587 if (tx_cb->oal == NULL)
2588 return -1;
2589 }
2590 return 0;
2591 }
2592
2593 static int ql_alloc_mem_resources(struct ql3_adapter *qdev)
2594 {
2595 if (qdev->ndev->mtu == NORMAL_MTU_SIZE)
2596 qdev->lrg_buffer_len = NORMAL_MTU_SIZE;
2597 else if (qdev->ndev->mtu == JUMBO_MTU_SIZE) {
2598 qdev->lrg_buffer_len = JUMBO_MTU_SIZE;
2599 } else {
2600 printk(KERN_ERR PFX
2601 "%s: Invalid mtu size. Only 1500 and 9000 are accepted.\n",
2602 qdev->ndev->name);
2603 return -ENOMEM;
2604 }
2605 qdev->lrg_buffer_len += VLAN_ETH_HLEN + VLAN_ID_LEN + QL_HEADER_SPACE;
2606 qdev->max_frame_size =
2607 (qdev->lrg_buffer_len - QL_HEADER_SPACE) + ETHERNET_CRC_SIZE;
2608
2609 /*
2610 * First allocate a page of shared memory and use it for shadow
2611 * locations of Network Request Queue Consumer Address Register and
2612 * Network Completion Queue Producer Index Register
2613 */
2614 qdev->shadow_reg_virt_addr =
2615 pci_alloc_consistent(qdev->pdev,
2616 PAGE_SIZE, &qdev->shadow_reg_phy_addr);
2617
2618 if (qdev->shadow_reg_virt_addr != NULL) {
2619 qdev->preq_consumer_index = (u16 *) qdev->shadow_reg_virt_addr;
2620 qdev->req_consumer_index_phy_addr_high =
2621 MS_64BITS(qdev->shadow_reg_phy_addr);
2622 qdev->req_consumer_index_phy_addr_low =
2623 LS_64BITS(qdev->shadow_reg_phy_addr);
2624
2625 qdev->prsp_producer_index =
2626 (u32 *) (((u8 *) qdev->preq_consumer_index) + 8);
2627 qdev->rsp_producer_index_phy_addr_high =
2628 qdev->req_consumer_index_phy_addr_high;
2629 qdev->rsp_producer_index_phy_addr_low =
2630 qdev->req_consumer_index_phy_addr_low + 8;
2631 } else {
2632 printk(KERN_ERR PFX
2633 "%s: shadowReg Alloc failed.\n", qdev->ndev->name);
2634 return -ENOMEM;
2635 }
2636
2637 if (ql_alloc_net_req_rsp_queues(qdev) != 0) {
2638 printk(KERN_ERR PFX
2639 "%s: ql_alloc_net_req_rsp_queues failed.\n",
2640 qdev->ndev->name);
2641 goto err_req_rsp;
2642 }
2643
2644 if (ql_alloc_buffer_queues(qdev) != 0) {
2645 printk(KERN_ERR PFX
2646 "%s: ql_alloc_buffer_queues failed.\n",
2647 qdev->ndev->name);
2648 goto err_buffer_queues;
2649 }
2650
2651 if (ql_alloc_small_buffers(qdev) != 0) {
2652 printk(KERN_ERR PFX
2653 "%s: ql_alloc_small_buffers failed\n", qdev->ndev->name);
2654 goto err_small_buffers;
2655 }
2656
2657 if (ql_alloc_large_buffers(qdev) != 0) {
2658 printk(KERN_ERR PFX
2659 "%s: ql_alloc_large_buffers failed\n", qdev->ndev->name);
2660 goto err_small_buffers;
2661 }
2662
2663 /* Initialize the large buffer queue. */
2664 ql_init_large_buffers(qdev);
2665 if (ql_create_send_free_list(qdev))
2666 goto err_free_list;
2667
2668 qdev->rsp_current = qdev->rsp_q_virt_addr;
2669
2670 return 0;
2671 err_free_list:
2672 ql_free_send_free_list(qdev);
2673 err_small_buffers:
2674 ql_free_buffer_queues(qdev);
2675 err_buffer_queues:
2676 ql_free_net_req_rsp_queues(qdev);
2677 err_req_rsp:
2678 pci_free_consistent(qdev->pdev,
2679 PAGE_SIZE,
2680 qdev->shadow_reg_virt_addr,
2681 qdev->shadow_reg_phy_addr);
2682
2683 return -ENOMEM;
2684 }
2685
2686 static void ql_free_mem_resources(struct ql3_adapter *qdev)
2687 {
2688 ql_free_send_free_list(qdev);
2689 ql_free_large_buffers(qdev);
2690 ql_free_small_buffers(qdev);
2691 ql_free_buffer_queues(qdev);
2692 ql_free_net_req_rsp_queues(qdev);
2693 if (qdev->shadow_reg_virt_addr != NULL) {
2694 pci_free_consistent(qdev->pdev,
2695 PAGE_SIZE,
2696 qdev->shadow_reg_virt_addr,
2697 qdev->shadow_reg_phy_addr);
2698 qdev->shadow_reg_virt_addr = NULL;
2699 }
2700 }
2701
2702 static int ql_init_misc_registers(struct ql3_adapter *qdev)
2703 {
2704 struct ql3xxx_local_ram_registers __iomem *local_ram =
2705 (void __iomem *)qdev->mem_map_registers;
2706
2707 if(ql_sem_spinlock(qdev, QL_DDR_RAM_SEM_MASK,
2708 (QL_RESOURCE_BITS_BASE_CODE | (qdev->mac_index) *
2709 2) << 4))
2710 return -1;
2711
2712 ql_write_page2_reg(qdev,
2713 &local_ram->bufletSize, qdev->nvram_data.bufletSize);
2714
2715 ql_write_page2_reg(qdev,
2716 &local_ram->maxBufletCount,
2717 qdev->nvram_data.bufletCount);
2718
2719 ql_write_page2_reg(qdev,
2720 &local_ram->freeBufletThresholdLow,
2721 (qdev->nvram_data.tcpWindowThreshold25 << 16) |
2722 (qdev->nvram_data.tcpWindowThreshold0));
2723
2724 ql_write_page2_reg(qdev,
2725 &local_ram->freeBufletThresholdHigh,
2726 qdev->nvram_data.tcpWindowThreshold50);
2727
2728 ql_write_page2_reg(qdev,
2729 &local_ram->ipHashTableBase,
2730 (qdev->nvram_data.ipHashTableBaseHi << 16) |
2731 qdev->nvram_data.ipHashTableBaseLo);
2732 ql_write_page2_reg(qdev,
2733 &local_ram->ipHashTableCount,
2734 qdev->nvram_data.ipHashTableSize);
2735 ql_write_page2_reg(qdev,
2736 &local_ram->tcpHashTableBase,
2737 (qdev->nvram_data.tcpHashTableBaseHi << 16) |
2738 qdev->nvram_data.tcpHashTableBaseLo);
2739 ql_write_page2_reg(qdev,
2740 &local_ram->tcpHashTableCount,
2741 qdev->nvram_data.tcpHashTableSize);
2742 ql_write_page2_reg(qdev,
2743 &local_ram->ncbBase,
2744 (qdev->nvram_data.ncbTableBaseHi << 16) |
2745 qdev->nvram_data.ncbTableBaseLo);
2746 ql_write_page2_reg(qdev,
2747 &local_ram->maxNcbCount,
2748 qdev->nvram_data.ncbTableSize);
2749 ql_write_page2_reg(qdev,
2750 &local_ram->drbBase,
2751 (qdev->nvram_data.drbTableBaseHi << 16) |
2752 qdev->nvram_data.drbTableBaseLo);
2753 ql_write_page2_reg(qdev,
2754 &local_ram->maxDrbCount,
2755 qdev->nvram_data.drbTableSize);
2756 ql_sem_unlock(qdev, QL_DDR_RAM_SEM_MASK);
2757 return 0;
2758 }
2759
2760 static int ql_adapter_initialize(struct ql3_adapter *qdev)
2761 {
2762 u32 value;
2763 struct ql3xxx_port_registers __iomem *port_regs = qdev->mem_map_registers;
2764 struct ql3xxx_host_memory_registers __iomem *hmem_regs =
2765 (void __iomem *)port_regs;
2766 u32 delay = 10;
2767 int status = 0;
2768
2769 if(ql_mii_setup(qdev))
2770 return -1;
2771
2772 /* Bring out PHY out of reset */
2773 ql_write_common_reg(qdev, &port_regs->CommonRegs.serialPortInterfaceReg,
2774 (ISP_SERIAL_PORT_IF_WE |
2775 (ISP_SERIAL_PORT_IF_WE << 16)));
2776
2777 qdev->port_link_state = LS_DOWN;
2778 netif_carrier_off(qdev->ndev);
2779
2780 /* V2 chip fix for ARS-39168. */
2781 ql_write_common_reg(qdev, &port_regs->CommonRegs.serialPortInterfaceReg,
2782 (ISP_SERIAL_PORT_IF_SDE |
2783 (ISP_SERIAL_PORT_IF_SDE << 16)));
2784
2785 /* Request Queue Registers */
2786 *((u32 *) (qdev->preq_consumer_index)) = 0;
2787 atomic_set(&qdev->tx_count,NUM_REQ_Q_ENTRIES);
2788 qdev->req_producer_index = 0;
2789
2790 ql_write_page1_reg(qdev,
2791 &hmem_regs->reqConsumerIndexAddrHigh,
2792 qdev->req_consumer_index_phy_addr_high);
2793 ql_write_page1_reg(qdev,
2794 &hmem_regs->reqConsumerIndexAddrLow,
2795 qdev->req_consumer_index_phy_addr_low);
2796
2797 ql_write_page1_reg(qdev,
2798 &hmem_regs->reqBaseAddrHigh,
2799 MS_64BITS(qdev->req_q_phy_addr));
2800 ql_write_page1_reg(qdev,
2801 &hmem_regs->reqBaseAddrLow,
2802 LS_64BITS(qdev->req_q_phy_addr));
2803 ql_write_page1_reg(qdev, &hmem_regs->reqLength, NUM_REQ_Q_ENTRIES);
2804
2805 /* Response Queue Registers */
2806 *((u16 *) (qdev->prsp_producer_index)) = 0;
2807 qdev->rsp_consumer_index = 0;
2808 qdev->rsp_current = qdev->rsp_q_virt_addr;
2809
2810 ql_write_page1_reg(qdev,
2811 &hmem_regs->rspProducerIndexAddrHigh,
2812 qdev->rsp_producer_index_phy_addr_high);
2813
2814 ql_write_page1_reg(qdev,
2815 &hmem_regs->rspProducerIndexAddrLow,
2816 qdev->rsp_producer_index_phy_addr_low);
2817
2818 ql_write_page1_reg(qdev,
2819 &hmem_regs->rspBaseAddrHigh,
2820 MS_64BITS(qdev->rsp_q_phy_addr));
2821
2822 ql_write_page1_reg(qdev,
2823 &hmem_regs->rspBaseAddrLow,
2824 LS_64BITS(qdev->rsp_q_phy_addr));
2825
2826 ql_write_page1_reg(qdev, &hmem_regs->rspLength, NUM_RSP_Q_ENTRIES);
2827
2828 /* Large Buffer Queue */
2829 ql_write_page1_reg(qdev,
2830 &hmem_regs->rxLargeQBaseAddrHigh,
2831 MS_64BITS(qdev->lrg_buf_q_phy_addr));
2832
2833 ql_write_page1_reg(qdev,
2834 &hmem_regs->rxLargeQBaseAddrLow,
2835 LS_64BITS(qdev->lrg_buf_q_phy_addr));
2836
2837 ql_write_page1_reg(qdev, &hmem_regs->rxLargeQLength, NUM_LBUFQ_ENTRIES);
2838
2839 ql_write_page1_reg(qdev,
2840 &hmem_regs->rxLargeBufferLength,
2841 qdev->lrg_buffer_len);
2842
2843 /* Small Buffer Queue */
2844 ql_write_page1_reg(qdev,
2845 &hmem_regs->rxSmallQBaseAddrHigh,
2846 MS_64BITS(qdev->small_buf_q_phy_addr));
2847
2848 ql_write_page1_reg(qdev,
2849 &hmem_regs->rxSmallQBaseAddrLow,
2850 LS_64BITS(qdev->small_buf_q_phy_addr));
2851
2852 ql_write_page1_reg(qdev, &hmem_regs->rxSmallQLength, NUM_SBUFQ_ENTRIES);
2853 ql_write_page1_reg(qdev,
2854 &hmem_regs->rxSmallBufferLength,
2855 QL_SMALL_BUFFER_SIZE);
2856
2857 qdev->small_buf_q_producer_index = NUM_SBUFQ_ENTRIES - 1;
2858 qdev->small_buf_release_cnt = 8;
2859 qdev->lrg_buf_q_producer_index = NUM_LBUFQ_ENTRIES - 1;
2860 qdev->lrg_buf_release_cnt = 8;
2861 qdev->lrg_buf_next_free =
2862 (struct bufq_addr_element *)qdev->lrg_buf_q_virt_addr;
2863 qdev->small_buf_index = 0;
2864 qdev->lrg_buf_index = 0;
2865 qdev->lrg_buf_free_count = 0;
2866 qdev->lrg_buf_free_head = NULL;
2867 qdev->lrg_buf_free_tail = NULL;
2868
2869 ql_write_common_reg(qdev,
2870 &port_regs->CommonRegs.
2871 rxSmallQProducerIndex,
2872 qdev->small_buf_q_producer_index);
2873 ql_write_common_reg(qdev,
2874 &port_regs->CommonRegs.
2875 rxLargeQProducerIndex,
2876 qdev->lrg_buf_q_producer_index);
2877
2878 /*
2879 * Find out if the chip has already been initialized. If it has, then
2880 * we skip some of the initialization.
2881 */
2882 clear_bit(QL_LINK_MASTER, &qdev->flags);
2883 value = ql_read_page0_reg(qdev, &port_regs->portStatus);
2884 if ((value & PORT_STATUS_IC) == 0) {
2885
2886 /* Chip has not been configured yet, so let it rip. */
2887 if(ql_init_misc_registers(qdev)) {
2888 status = -1;
2889 goto out;
2890 }
2891
2892 if (qdev->mac_index)
2893 ql_write_page0_reg(qdev,
2894 &port_regs->mac1MaxFrameLengthReg,
2895 qdev->max_frame_size);
2896 else
2897 ql_write_page0_reg(qdev,
2898 &port_regs->mac0MaxFrameLengthReg,
2899 qdev->max_frame_size);
2900
2901 value = qdev->nvram_data.tcpMaxWindowSize;
2902 ql_write_page0_reg(qdev, &port_regs->tcpMaxWindow, value);
2903
2904 value = (0xFFFF << 16) | qdev->nvram_data.extHwConfig;
2905
2906 if(ql_sem_spinlock(qdev, QL_FLASH_SEM_MASK,
2907 (QL_RESOURCE_BITS_BASE_CODE | (qdev->mac_index)
2908 * 2) << 13)) {
2909 status = -1;
2910 goto out;
2911 }
2912 ql_write_page0_reg(qdev, &port_regs->ExternalHWConfig, value);
2913 ql_write_page0_reg(qdev, &port_regs->InternalChipConfig,
2914 (((INTERNAL_CHIP_SD | INTERNAL_CHIP_WE) <<
2915 16) | (INTERNAL_CHIP_SD |
2916 INTERNAL_CHIP_WE)));
2917 ql_sem_unlock(qdev, QL_FLASH_SEM_MASK);
2918 }
2919
2920
2921 if(ql_sem_spinlock(qdev, QL_PHY_GIO_SEM_MASK,
2922 (QL_RESOURCE_BITS_BASE_CODE | (qdev->mac_index) *
2923 2) << 7)) {
2924 status = -1;
2925 goto out;
2926 }
2927
2928 ql_init_scan_mode(qdev);
2929 ql_get_phy_owner(qdev);
2930
2931 /* Load the MAC Configuration */
2932
2933 /* Program lower 32 bits of the MAC address */
2934 ql_write_page0_reg(qdev, &port_regs->macAddrIndirectPtrReg,
2935 (MAC_ADDR_INDIRECT_PTR_REG_RP_MASK << 16));
2936 ql_write_page0_reg(qdev, &port_regs->macAddrDataReg,
2937 ((qdev->ndev->dev_addr[2] << 24)
2938 | (qdev->ndev->dev_addr[3] << 16)
2939 | (qdev->ndev->dev_addr[4] << 8)
2940 | qdev->ndev->dev_addr[5]));
2941
2942 /* Program top 16 bits of the MAC address */
2943 ql_write_page0_reg(qdev, &port_regs->macAddrIndirectPtrReg,
2944 ((MAC_ADDR_INDIRECT_PTR_REG_RP_MASK << 16) | 1));
2945 ql_write_page0_reg(qdev, &port_regs->macAddrDataReg,
2946 ((qdev->ndev->dev_addr[0] << 8)
2947 | qdev->ndev->dev_addr[1]));
2948
2949 /* Enable Primary MAC */
2950 ql_write_page0_reg(qdev, &port_regs->macAddrIndirectPtrReg,
2951 ((MAC_ADDR_INDIRECT_PTR_REG_PE << 16) |
2952 MAC_ADDR_INDIRECT_PTR_REG_PE));
2953
2954 /* Clear Primary and Secondary IP addresses */
2955 ql_write_page0_reg(qdev, &port_regs->ipAddrIndexReg,
2956 ((IP_ADDR_INDEX_REG_MASK << 16) |
2957 (qdev->mac_index << 2)));
2958 ql_write_page0_reg(qdev, &port_regs->ipAddrDataReg, 0);
2959
2960 ql_write_page0_reg(qdev, &port_regs->ipAddrIndexReg,
2961 ((IP_ADDR_INDEX_REG_MASK << 16) |
2962 ((qdev->mac_index << 2) + 1)));
2963 ql_write_page0_reg(qdev, &port_regs->ipAddrDataReg, 0);
2964
2965 ql_sem_unlock(qdev, QL_PHY_GIO_SEM_MASK);
2966
2967 /* Indicate Configuration Complete */
2968 ql_write_page0_reg(qdev,
2969 &port_regs->portControl,
2970 ((PORT_CONTROL_CC << 16) | PORT_CONTROL_CC));
2971
2972 do {
2973 value = ql_read_page0_reg(qdev, &port_regs->portStatus);
2974 if (value & PORT_STATUS_IC)
2975 break;
2976 msleep(500);
2977 } while (--delay);
2978
2979 if (delay == 0) {
2980 printk(KERN_ERR PFX
2981 "%s: Hw Initialization timeout.\n", qdev->ndev->name);
2982 status = -1;
2983 goto out;
2984 }
2985
2986 /* Enable Ethernet Function */
2987 if (qdev->device_id == QL3032_DEVICE_ID) {
2988 value =
2989 (QL3032_PORT_CONTROL_EF | QL3032_PORT_CONTROL_KIE |
2990 QL3032_PORT_CONTROL_EIv6 | QL3032_PORT_CONTROL_EIv4);
2991 ql_write_page0_reg(qdev, &port_regs->functionControl,
2992 ((value << 16) | value));
2993 } else {
2994 value =
2995 (PORT_CONTROL_EF | PORT_CONTROL_ET | PORT_CONTROL_EI |
2996 PORT_CONTROL_HH);
2997 ql_write_page0_reg(qdev, &port_regs->portControl,
2998 ((value << 16) | value));
2999 }
3000
3001
3002 out:
3003 return status;
3004 }
3005
3006 /*
3007 * Caller holds hw_lock.
3008 */
3009 static int ql_adapter_reset(struct ql3_adapter *qdev)
3010 {
3011 struct ql3xxx_port_registers __iomem *port_regs = qdev->mem_map_registers;
3012 int status = 0;
3013 u16 value;
3014 int max_wait_time;
3015
3016 set_bit(QL_RESET_ACTIVE, &qdev->flags);
3017 clear_bit(QL_RESET_DONE, &qdev->flags);
3018
3019 /*
3020 * Issue soft reset to chip.
3021 */
3022 printk(KERN_DEBUG PFX
3023 "%s: Issue soft reset to chip.\n",
3024 qdev->ndev->name);
3025 ql_write_common_reg(qdev,
3026 &port_regs->CommonRegs.ispControlStatus,
3027 ((ISP_CONTROL_SR << 16) | ISP_CONTROL_SR));
3028
3029 /* Wait 3 seconds for reset to complete. */
3030 printk(KERN_DEBUG PFX
3031 "%s: Wait 10 milliseconds for reset to complete.\n",
3032 qdev->ndev->name);
3033
3034 /* Wait until the firmware tells us the Soft Reset is done */
3035 max_wait_time = 5;
3036 do {
3037 value =
3038 ql_read_common_reg(qdev,
3039 &port_regs->CommonRegs.ispControlStatus);
3040 if ((value & ISP_CONTROL_SR) == 0)
3041 break;
3042
3043 ssleep(1);
3044 } while ((--max_wait_time));
3045
3046 /*
3047 * Also, make sure that the Network Reset Interrupt bit has been
3048 * cleared after the soft reset has taken place.
3049 */
3050 value =
3051 ql_read_common_reg(qdev, &port_regs->CommonRegs.ispControlStatus);
3052 if (value & ISP_CONTROL_RI) {
3053 printk(KERN_DEBUG PFX
3054 "ql_adapter_reset: clearing RI after reset.\n");
3055 ql_write_common_reg(qdev,
3056 &port_regs->CommonRegs.
3057 ispControlStatus,
3058 ((ISP_CONTROL_RI << 16) | ISP_CONTROL_RI));
3059 }
3060
3061 if (max_wait_time == 0) {
3062 /* Issue Force Soft Reset */
3063 ql_write_common_reg(qdev,
3064 &port_regs->CommonRegs.
3065 ispControlStatus,
3066 ((ISP_CONTROL_FSR << 16) |
3067 ISP_CONTROL_FSR));
3068 /*
3069 * Wait until the firmware tells us the Force Soft Reset is
3070 * done
3071 */
3072 max_wait_time = 5;
3073 do {
3074 value =
3075 ql_read_common_reg(qdev,
3076 &port_regs->CommonRegs.
3077 ispControlStatus);
3078 if ((value & ISP_CONTROL_FSR) == 0) {
3079 break;
3080 }
3081 ssleep(1);
3082 } while ((--max_wait_time));
3083 }
3084 if (max_wait_time == 0)
3085 status = 1;
3086
3087 clear_bit(QL_RESET_ACTIVE, &qdev->flags);
3088 set_bit(QL_RESET_DONE, &qdev->flags);
3089 return status;
3090 }
3091
3092 static void ql_set_mac_info(struct ql3_adapter *qdev)
3093 {
3094 struct ql3xxx_port_registers __iomem *port_regs = qdev->mem_map_registers;
3095 u32 value, port_status;
3096 u8 func_number;
3097
3098 /* Get the function number */
3099 value =
3100 ql_read_common_reg_l(qdev, &port_regs->CommonRegs.ispControlStatus);
3101 func_number = (u8) ((value >> 4) & OPCODE_FUNC_ID_MASK);
3102 port_status = ql_read_page0_reg(qdev, &port_regs->portStatus);
3103 switch (value & ISP_CONTROL_FN_MASK) {
3104 case ISP_CONTROL_FN0_NET:
3105 qdev->mac_index = 0;
3106 qdev->mac_ob_opcode = OUTBOUND_MAC_IOCB | func_number;
3107 qdev->tcp_ob_opcode = OUTBOUND_TCP_IOCB | func_number;
3108 qdev->update_ob_opcode = UPDATE_NCB_IOCB | func_number;
3109 qdev->mb_bit_mask = FN0_MA_BITS_MASK;
3110 qdev->PHYAddr = PORT0_PHY_ADDRESS;
3111 if (port_status & PORT_STATUS_SM0)
3112 set_bit(QL_LINK_OPTICAL,&qdev->flags);
3113 else
3114 clear_bit(QL_LINK_OPTICAL,&qdev->flags);
3115 break;
3116
3117 case ISP_CONTROL_FN1_NET:
3118 qdev->mac_index = 1;
3119 qdev->mac_ob_opcode = OUTBOUND_MAC_IOCB | func_number;
3120 qdev->tcp_ob_opcode = OUTBOUND_TCP_IOCB | func_number;
3121 qdev->update_ob_opcode = UPDATE_NCB_IOCB | func_number;
3122 qdev->mb_bit_mask = FN1_MA_BITS_MASK;
3123 qdev->PHYAddr = PORT1_PHY_ADDRESS;
3124 if (port_status & PORT_STATUS_SM1)
3125 set_bit(QL_LINK_OPTICAL,&qdev->flags);
3126 else
3127 clear_bit(QL_LINK_OPTICAL,&qdev->flags);
3128 break;
3129
3130 case ISP_CONTROL_FN0_SCSI:
3131 case ISP_CONTROL_FN1_SCSI:
3132 default:
3133 printk(KERN_DEBUG PFX
3134 "%s: Invalid function number, ispControlStatus = 0x%x\n",
3135 qdev->ndev->name,value);
3136 break;
3137 }
3138 qdev->numPorts = qdev->nvram_data.numPorts;
3139 }
3140
3141 static void ql_display_dev_info(struct net_device *ndev)
3142 {
3143 struct ql3_adapter *qdev = (struct ql3_adapter *)netdev_priv(ndev);
3144 struct pci_dev *pdev = qdev->pdev;
3145
3146 printk(KERN_INFO PFX
3147 "\n%s Adapter %d RevisionID %d found %s on PCI slot %d.\n",
3148 DRV_NAME, qdev->index, qdev->chip_rev_id,
3149 (qdev->device_id == QL3032_DEVICE_ID) ? "QLA3032" : "QLA3022",
3150 qdev->pci_slot);
3151 printk(KERN_INFO PFX
3152 "%s Interface.\n",
3153 test_bit(QL_LINK_OPTICAL,&qdev->flags) ? "OPTICAL" : "COPPER");
3154
3155 /*
3156 * Print PCI bus width/type.
3157 */
3158 printk(KERN_INFO PFX
3159 "Bus interface is %s %s.\n",
3160 ((qdev->pci_width == 64) ? "64-bit" : "32-bit"),
3161 ((qdev->pci_x) ? "PCI-X" : "PCI"));
3162
3163 printk(KERN_INFO PFX
3164 "mem IO base address adjusted = 0x%p\n",
3165 qdev->mem_map_registers);
3166 printk(KERN_INFO PFX "Interrupt number = %d\n", pdev->irq);
3167
3168 if (netif_msg_probe(qdev))
3169 printk(KERN_INFO PFX
3170 "%s: MAC address %02x:%02x:%02x:%02x:%02x:%02x\n",
3171 ndev->name, ndev->dev_addr[0], ndev->dev_addr[1],
3172 ndev->dev_addr[2], ndev->dev_addr[3], ndev->dev_addr[4],
3173 ndev->dev_addr[5]);
3174 }
3175
3176 static int ql_adapter_down(struct ql3_adapter *qdev, int do_reset)
3177 {
3178 struct net_device *ndev = qdev->ndev;
3179 int retval = 0;
3180
3181 netif_stop_queue(ndev);
3182 netif_carrier_off(ndev);
3183
3184 clear_bit(QL_ADAPTER_UP,&qdev->flags);
3185 clear_bit(QL_LINK_MASTER,&qdev->flags);
3186
3187 ql_disable_interrupts(qdev);
3188
3189 free_irq(qdev->pdev->irq, ndev);
3190
3191 if (qdev->msi && test_bit(QL_MSI_ENABLED,&qdev->flags)) {
3192 printk(KERN_INFO PFX
3193 "%s: calling pci_disable_msi().\n", qdev->ndev->name);
3194 clear_bit(QL_MSI_ENABLED,&qdev->flags);
3195 pci_disable_msi(qdev->pdev);
3196 }
3197
3198 del_timer_sync(&qdev->adapter_timer);
3199
3200 netif_poll_disable(ndev);
3201
3202 if (do_reset) {
3203 int soft_reset;
3204 unsigned long hw_flags;
3205
3206 spin_lock_irqsave(&qdev->hw_lock, hw_flags);
3207 if (ql_wait_for_drvr_lock(qdev)) {
3208 if ((soft_reset = ql_adapter_reset(qdev))) {
3209 printk(KERN_ERR PFX
3210 "%s: ql_adapter_reset(%d) FAILED!\n",
3211 ndev->name, qdev->index);
3212 }
3213 printk(KERN_ERR PFX
3214 "%s: Releaseing driver lock via chip reset.\n",ndev->name);
3215 } else {
3216 printk(KERN_ERR PFX
3217 "%s: Could not acquire driver lock to do "
3218 "reset!\n", ndev->name);
3219 retval = -1;
3220 }
3221 spin_unlock_irqrestore(&qdev->hw_lock, hw_flags);
3222 }
3223 ql_free_mem_resources(qdev);
3224 return retval;
3225 }
3226
3227 static int ql_adapter_up(struct ql3_adapter *qdev)
3228 {
3229 struct net_device *ndev = qdev->ndev;
3230 int err;
3231 unsigned long irq_flags = IRQF_SAMPLE_RANDOM | IRQF_SHARED;
3232 unsigned long hw_flags;
3233
3234 if (ql_alloc_mem_resources(qdev)) {
3235 printk(KERN_ERR PFX
3236 "%s Unable to allocate buffers.\n", ndev->name);
3237 return -ENOMEM;
3238 }
3239
3240 if (qdev->msi) {
3241 if (pci_enable_msi(qdev->pdev)) {
3242 printk(KERN_ERR PFX
3243 "%s: User requested MSI, but MSI failed to "
3244 "initialize. Continuing without MSI.\n",
3245 qdev->ndev->name);
3246 qdev->msi = 0;
3247 } else {
3248 printk(KERN_INFO PFX "%s: MSI Enabled...\n", qdev->ndev->name);
3249 set_bit(QL_MSI_ENABLED,&qdev->flags);
3250 irq_flags &= ~IRQF_SHARED;
3251 }
3252 }
3253
3254 if ((err = request_irq(qdev->pdev->irq,
3255 ql3xxx_isr,
3256 irq_flags, ndev->name, ndev))) {
3257 printk(KERN_ERR PFX
3258 "%s: Failed to reserve interrupt %d already in use.\n",
3259 ndev->name, qdev->pdev->irq);
3260 goto err_irq;
3261 }
3262
3263 spin_lock_irqsave(&qdev->hw_lock, hw_flags);
3264
3265 if ((err = ql_wait_for_drvr_lock(qdev))) {
3266 if ((err = ql_adapter_initialize(qdev))) {
3267 printk(KERN_ERR PFX
3268 "%s: Unable to initialize adapter.\n",
3269 ndev->name);
3270 goto err_init;
3271 }
3272 printk(KERN_ERR PFX
3273 "%s: Releaseing driver lock.\n",ndev->name);
3274 ql_sem_unlock(qdev, QL_DRVR_SEM_MASK);
3275 } else {
3276 printk(KERN_ERR PFX
3277 "%s: Could not aquire driver lock.\n",
3278 ndev->name);
3279 goto err_lock;
3280 }
3281
3282 spin_unlock_irqrestore(&qdev->hw_lock, hw_flags);
3283
3284 set_bit(QL_ADAPTER_UP,&qdev->flags);
3285
3286 mod_timer(&qdev->adapter_timer, jiffies + HZ * 1);
3287
3288 netif_poll_enable(ndev);
3289 ql_enable_interrupts(qdev);
3290 return 0;
3291
3292 err_init:
3293 ql_sem_unlock(qdev, QL_DRVR_SEM_MASK);
3294 err_lock:
3295 free_irq(qdev->pdev->irq, ndev);
3296 err_irq:
3297 if (qdev->msi && test_bit(QL_MSI_ENABLED,&qdev->flags)) {
3298 printk(KERN_INFO PFX
3299 "%s: calling pci_disable_msi().\n",
3300 qdev->ndev->name);
3301 clear_bit(QL_MSI_ENABLED,&qdev->flags);
3302 pci_disable_msi(qdev->pdev);
3303 }
3304 return err;
3305 }
3306
3307 static int ql_cycle_adapter(struct ql3_adapter *qdev, int reset)
3308 {
3309 if( ql_adapter_down(qdev,reset) || ql_adapter_up(qdev)) {
3310 printk(KERN_ERR PFX
3311 "%s: Driver up/down cycle failed, "
3312 "closing device\n",qdev->ndev->name);
3313 dev_close(qdev->ndev);
3314 return -1;
3315 }
3316 return 0;
3317 }
3318
3319 static int ql3xxx_close(struct net_device *ndev)
3320 {
3321 struct ql3_adapter *qdev = netdev_priv(ndev);
3322
3323 /*
3324 * Wait for device to recover from a reset.
3325 * (Rarely happens, but possible.)
3326 */
3327 while (!test_bit(QL_ADAPTER_UP,&qdev->flags))
3328 msleep(50);
3329
3330 ql_adapter_down(qdev,QL_DO_RESET);
3331 return 0;
3332 }
3333
3334 static int ql3xxx_open(struct net_device *ndev)
3335 {
3336 struct ql3_adapter *qdev = netdev_priv(ndev);
3337 return (ql_adapter_up(qdev));
3338 }
3339
3340 static struct net_device_stats *ql3xxx_get_stats(struct net_device *dev)
3341 {
3342 struct ql3_adapter *qdev = (struct ql3_adapter *)dev->priv;
3343 return &qdev->stats;
3344 }
3345
3346 static int ql3xxx_change_mtu(struct net_device *ndev, int new_mtu)
3347 {
3348 struct ql3_adapter *qdev = netdev_priv(ndev);
3349 printk(KERN_ERR PFX "%s: new mtu size = %d.\n", ndev->name, new_mtu);
3350 if (new_mtu != NORMAL_MTU_SIZE && new_mtu != JUMBO_MTU_SIZE) {
3351 printk(KERN_ERR PFX
3352 "%s: mtu size of %d is not valid. Use exactly %d or "
3353 "%d.\n", ndev->name, new_mtu, NORMAL_MTU_SIZE,
3354 JUMBO_MTU_SIZE);
3355 return -EINVAL;
3356 }
3357
3358 if (!netif_running(ndev)) {
3359 ndev->mtu = new_mtu;
3360 return 0;
3361 }
3362
3363 ndev->mtu = new_mtu;
3364 return ql_cycle_adapter(qdev,QL_DO_RESET);
3365 }
3366
3367 static void ql3xxx_set_multicast_list(struct net_device *ndev)
3368 {
3369 /*
3370 * We are manually parsing the list in the net_device structure.
3371 */
3372 return;
3373 }
3374
3375 static int ql3xxx_set_mac_address(struct net_device *ndev, void *p)
3376 {
3377 struct ql3_adapter *qdev = (struct ql3_adapter *)netdev_priv(ndev);
3378 struct ql3xxx_port_registers __iomem *port_regs =
3379 qdev->mem_map_registers;
3380 struct sockaddr *addr = p;
3381 unsigned long hw_flags;
3382
3383 if (netif_running(ndev))
3384 return -EBUSY;
3385
3386 if (!is_valid_ether_addr(addr->sa_data))
3387 return -EADDRNOTAVAIL;
3388
3389 memcpy(ndev->dev_addr, addr->sa_data, ndev->addr_len);
3390
3391 spin_lock_irqsave(&qdev->hw_lock, hw_flags);
3392 /* Program lower 32 bits of the MAC address */
3393 ql_write_page0_reg(qdev, &port_regs->macAddrIndirectPtrReg,
3394 (MAC_ADDR_INDIRECT_PTR_REG_RP_MASK << 16));
3395 ql_write_page0_reg(qdev, &port_regs->macAddrDataReg,
3396 ((ndev->dev_addr[2] << 24) | (ndev->
3397 dev_addr[3] << 16) |
3398 (ndev->dev_addr[4] << 8) | ndev->dev_addr[5]));
3399
3400 /* Program top 16 bits of the MAC address */
3401 ql_write_page0_reg(qdev, &port_regs->macAddrIndirectPtrReg,
3402 ((MAC_ADDR_INDIRECT_PTR_REG_RP_MASK << 16) | 1));
3403 ql_write_page0_reg(qdev, &port_regs->macAddrDataReg,
3404 ((ndev->dev_addr[0] << 8) | ndev->dev_addr[1]));
3405 spin_unlock_irqrestore(&qdev->hw_lock, hw_flags);
3406
3407 return 0;
3408 }
3409
3410 static void ql3xxx_tx_timeout(struct net_device *ndev)
3411 {
3412 struct ql3_adapter *qdev = (struct ql3_adapter *)netdev_priv(ndev);
3413
3414 printk(KERN_ERR PFX "%s: Resetting...\n", ndev->name);
3415 /*
3416 * Stop the queues, we've got a problem.
3417 */
3418 netif_stop_queue(ndev);
3419
3420 /*
3421 * Wake up the worker to process this event.
3422 */
3423 queue_delayed_work(qdev->workqueue, &qdev->tx_timeout_work, 0);
3424 }
3425
3426 static void ql_reset_work(struct work_struct *work)
3427 {
3428 struct ql3_adapter *qdev =
3429 container_of(work, struct ql3_adapter, reset_work.work);
3430 struct net_device *ndev = qdev->ndev;
3431 u32 value;
3432 struct ql_tx_buf_cb *tx_cb;
3433 int max_wait_time, i;
3434 struct ql3xxx_port_registers __iomem *port_regs = qdev->mem_map_registers;
3435 unsigned long hw_flags;
3436
3437 if (test_bit((QL_RESET_PER_SCSI | QL_RESET_START),&qdev->flags)) {
3438 clear_bit(QL_LINK_MASTER,&qdev->flags);
3439
3440 /*
3441 * Loop through the active list and return the skb.
3442 */
3443 for (i = 0; i < NUM_REQ_Q_ENTRIES; i++) {
3444 int j;
3445 tx_cb = &qdev->tx_buf[i];
3446 if (tx_cb->skb) {
3447 printk(KERN_DEBUG PFX
3448 "%s: Freeing lost SKB.\n",
3449 qdev->ndev->name);
3450 pci_unmap_single(qdev->pdev,
3451 pci_unmap_addr(&tx_cb->map[0], mapaddr),
3452 pci_unmap_len(&tx_cb->map[0], maplen),
3453 PCI_DMA_TODEVICE);
3454 for(j=1;j<tx_cb->seg_count;j++) {
3455 pci_unmap_page(qdev->pdev,
3456 pci_unmap_addr(&tx_cb->map[j],mapaddr),
3457 pci_unmap_len(&tx_cb->map[j],maplen),
3458 PCI_DMA_TODEVICE);
3459 }
3460 dev_kfree_skb(tx_cb->skb);
3461 tx_cb->skb = NULL;
3462 }
3463 }
3464
3465 printk(KERN_ERR PFX
3466 "%s: Clearing NRI after reset.\n", qdev->ndev->name);
3467 spin_lock_irqsave(&qdev->hw_lock, hw_flags);
3468 ql_write_common_reg(qdev,
3469 &port_regs->CommonRegs.
3470 ispControlStatus,
3471 ((ISP_CONTROL_RI << 16) | ISP_CONTROL_RI));
3472 /*
3473 * Wait the for Soft Reset to Complete.
3474 */
3475 max_wait_time = 10;
3476 do {
3477 value = ql_read_common_reg(qdev,
3478 &port_regs->CommonRegs.
3479
3480 ispControlStatus);
3481 if ((value & ISP_CONTROL_SR) == 0) {
3482 printk(KERN_DEBUG PFX
3483 "%s: reset completed.\n",
3484 qdev->ndev->name);
3485 break;
3486 }
3487
3488 if (value & ISP_CONTROL_RI) {
3489 printk(KERN_DEBUG PFX
3490 "%s: clearing NRI after reset.\n",
3491 qdev->ndev->name);
3492 ql_write_common_reg(qdev,
3493 &port_regs->
3494 CommonRegs.
3495 ispControlStatus,
3496 ((ISP_CONTROL_RI <<
3497 16) | ISP_CONTROL_RI));
3498 }
3499
3500 ssleep(1);
3501 } while (--max_wait_time);
3502 spin_unlock_irqrestore(&qdev->hw_lock, hw_flags);
3503
3504 if (value & ISP_CONTROL_SR) {
3505
3506 /*
3507 * Set the reset flags and clear the board again.
3508 * Nothing else to do...
3509 */
3510 printk(KERN_ERR PFX
3511 "%s: Timed out waiting for reset to "
3512 "complete.\n", ndev->name);
3513 printk(KERN_ERR PFX
3514 "%s: Do a reset.\n", ndev->name);
3515 clear_bit(QL_RESET_PER_SCSI,&qdev->flags);
3516 clear_bit(QL_RESET_START,&qdev->flags);
3517 ql_cycle_adapter(qdev,QL_DO_RESET);
3518 return;
3519 }
3520
3521 clear_bit(QL_RESET_ACTIVE,&qdev->flags);
3522 clear_bit(QL_RESET_PER_SCSI,&qdev->flags);
3523 clear_bit(QL_RESET_START,&qdev->flags);
3524 ql_cycle_adapter(qdev,QL_NO_RESET);
3525 }
3526 }
3527
3528 static void ql_tx_timeout_work(struct work_struct *work)
3529 {
3530 struct ql3_adapter *qdev =
3531 container_of(work, struct ql3_adapter, tx_timeout_work.work);
3532
3533 ql_cycle_adapter(qdev, QL_DO_RESET);
3534 }
3535
3536 static void ql_get_board_info(struct ql3_adapter *qdev)
3537 {
3538 struct ql3xxx_port_registers __iomem *port_regs = qdev->mem_map_registers;
3539 u32 value;
3540
3541 value = ql_read_page0_reg_l(qdev, &port_regs->portStatus);
3542
3543 qdev->chip_rev_id = ((value & PORT_STATUS_REV_ID_MASK) >> 12);
3544 if (value & PORT_STATUS_64)
3545 qdev->pci_width = 64;
3546 else
3547 qdev->pci_width = 32;
3548 if (value & PORT_STATUS_X)
3549 qdev->pci_x = 1;
3550 else
3551 qdev->pci_x = 0;
3552 qdev->pci_slot = (u8) PCI_SLOT(qdev->pdev->devfn);
3553 }
3554
3555 static void ql3xxx_timer(unsigned long ptr)
3556 {
3557 struct ql3_adapter *qdev = (struct ql3_adapter *)ptr;
3558
3559 if (test_bit(QL_RESET_ACTIVE,&qdev->flags)) {
3560 printk(KERN_DEBUG PFX
3561 "%s: Reset in progress.\n",
3562 qdev->ndev->name);
3563 goto end;
3564 }
3565
3566 ql_link_state_machine(qdev);
3567
3568 /* Restart timer on 2 second interval. */
3569 end:
3570 mod_timer(&qdev->adapter_timer, jiffies + HZ * 1);
3571 }
3572
3573 static int __devinit ql3xxx_probe(struct pci_dev *pdev,
3574 const struct pci_device_id *pci_entry)
3575 {
3576 struct net_device *ndev = NULL;
3577 struct ql3_adapter *qdev = NULL;
3578 static int cards_found = 0;
3579 int pci_using_dac, err;
3580
3581 err = pci_enable_device(pdev);
3582 if (err) {
3583 printk(KERN_ERR PFX "%s cannot enable PCI device\n",
3584 pci_name(pdev));
3585 goto err_out;
3586 }
3587
3588 err = pci_request_regions(pdev, DRV_NAME);
3589 if (err) {
3590 printk(KERN_ERR PFX "%s cannot obtain PCI resources\n",
3591 pci_name(pdev));
3592 goto err_out_disable_pdev;
3593 }
3594
3595 pci_set_master(pdev);
3596
3597 if (!pci_set_dma_mask(pdev, DMA_64BIT_MASK)) {
3598 pci_using_dac = 1;
3599 err = pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK);
3600 } else if (!(err = pci_set_dma_mask(pdev, DMA_32BIT_MASK))) {
3601 pci_using_dac = 0;
3602 err = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
3603 }
3604
3605 if (err) {
3606 printk(KERN_ERR PFX "%s no usable DMA configuration\n",
3607 pci_name(pdev));
3608 goto err_out_free_regions;
3609 }
3610
3611 ndev = alloc_etherdev(sizeof(struct ql3_adapter));
3612 if (!ndev)
3613 goto err_out_free_regions;
3614
3615 SET_MODULE_OWNER(ndev);
3616 SET_NETDEV_DEV(ndev, &pdev->dev);
3617
3618 pci_set_drvdata(pdev, ndev);
3619
3620 qdev = netdev_priv(ndev);
3621 qdev->index = cards_found;
3622 qdev->ndev = ndev;
3623 qdev->pdev = pdev;
3624 qdev->device_id = pci_entry->device;
3625 qdev->port_link_state = LS_DOWN;
3626 if (msi)
3627 qdev->msi = 1;
3628
3629 qdev->msg_enable = netif_msg_init(debug, default_msg);
3630
3631 if (pci_using_dac)
3632 ndev->features |= NETIF_F_HIGHDMA;
3633 if (qdev->device_id == QL3032_DEVICE_ID)
3634 ndev->features |= (NETIF_F_HW_CSUM | NETIF_F_SG);
3635
3636 qdev->mem_map_registers =
3637 ioremap_nocache(pci_resource_start(pdev, 1),
3638 pci_resource_len(qdev->pdev, 1));
3639 if (!qdev->mem_map_registers) {
3640 printk(KERN_ERR PFX "%s: cannot map device registers\n",
3641 pci_name(pdev));
3642 goto err_out_free_ndev;
3643 }
3644
3645 spin_lock_init(&qdev->adapter_lock);
3646 spin_lock_init(&qdev->hw_lock);
3647
3648 /* Set driver entry points */
3649 ndev->open = ql3xxx_open;
3650 ndev->hard_start_xmit = ql3xxx_send;
3651 ndev->stop = ql3xxx_close;
3652 ndev->get_stats = ql3xxx_get_stats;
3653 ndev->change_mtu = ql3xxx_change_mtu;
3654 ndev->set_multicast_list = ql3xxx_set_multicast_list;
3655 SET_ETHTOOL_OPS(ndev, &ql3xxx_ethtool_ops);
3656 ndev->set_mac_address = ql3xxx_set_mac_address;
3657 ndev->tx_timeout = ql3xxx_tx_timeout;
3658 ndev->watchdog_timeo = 5 * HZ;
3659
3660 ndev->poll = &ql_poll;
3661 ndev->weight = 64;
3662
3663 ndev->irq = pdev->irq;
3664
3665 /* make sure the EEPROM is good */
3666 if (ql_get_nvram_params(qdev)) {
3667 printk(KERN_ALERT PFX
3668 "ql3xxx_probe: Adapter #%d, Invalid NVRAM parameters.\n",
3669 qdev->index);
3670 goto err_out_iounmap;
3671 }
3672
3673 ql_set_mac_info(qdev);
3674
3675 /* Validate and set parameters */
3676 if (qdev->mac_index) {
3677 memcpy(ndev->dev_addr, &qdev->nvram_data.funcCfg_fn2.macAddress,
3678 ETH_ALEN);
3679 } else {
3680 memcpy(ndev->dev_addr, &qdev->nvram_data.funcCfg_fn0.macAddress,
3681 ETH_ALEN);
3682 }
3683 memcpy(ndev->perm_addr, ndev->dev_addr, ndev->addr_len);
3684
3685 ndev->tx_queue_len = NUM_REQ_Q_ENTRIES;
3686
3687 /* Turn off support for multicasting */
3688 ndev->flags &= ~IFF_MULTICAST;
3689
3690 /* Record PCI bus information. */
3691 ql_get_board_info(qdev);
3692
3693 /*
3694 * Set the Maximum Memory Read Byte Count value. We do this to handle
3695 * jumbo frames.
3696 */
3697 if (qdev->pci_x) {
3698 pci_write_config_word(pdev, (int)0x4e, (u16) 0x0036);
3699 }
3700
3701 err = register_netdev(ndev);
3702 if (err) {
3703 printk(KERN_ERR PFX "%s: cannot register net device\n",
3704 pci_name(pdev));
3705 goto err_out_iounmap;
3706 }
3707
3708 /* we're going to reset, so assume we have no link for now */
3709
3710 netif_carrier_off(ndev);
3711 netif_stop_queue(ndev);
3712
3713 qdev->workqueue = create_singlethread_workqueue(ndev->name);
3714 INIT_DELAYED_WORK(&qdev->reset_work, ql_reset_work);
3715 INIT_DELAYED_WORK(&qdev->tx_timeout_work, ql_tx_timeout_work);
3716
3717 init_timer(&qdev->adapter_timer);
3718 qdev->adapter_timer.function = ql3xxx_timer;
3719 qdev->adapter_timer.expires = jiffies + HZ * 2; /* two second delay */
3720 qdev->adapter_timer.data = (unsigned long)qdev;
3721
3722 if(!cards_found) {
3723 printk(KERN_ALERT PFX "%s\n", DRV_STRING);
3724 printk(KERN_ALERT PFX "Driver name: %s, Version: %s.\n",
3725 DRV_NAME, DRV_VERSION);
3726 }
3727 ql_display_dev_info(ndev);
3728
3729 cards_found++;
3730 return 0;
3731
3732 err_out_iounmap:
3733 iounmap(qdev->mem_map_registers);
3734 err_out_free_ndev:
3735 free_netdev(ndev);
3736 err_out_free_regions:
3737 pci_release_regions(pdev);
3738 err_out_disable_pdev:
3739 pci_disable_device(pdev);
3740 pci_set_drvdata(pdev, NULL);
3741 err_out:
3742 return err;
3743 }
3744
3745 static void __devexit ql3xxx_remove(struct pci_dev *pdev)
3746 {
3747 struct net_device *ndev = pci_get_drvdata(pdev);
3748 struct ql3_adapter *qdev = netdev_priv(ndev);
3749
3750 unregister_netdev(ndev);
3751 qdev = netdev_priv(ndev);
3752
3753 ql_disable_interrupts(qdev);
3754
3755 if (qdev->workqueue) {
3756 cancel_delayed_work(&qdev->reset_work);
3757 cancel_delayed_work(&qdev->tx_timeout_work);
3758 destroy_workqueue(qdev->workqueue);
3759 qdev->workqueue = NULL;
3760 }
3761
3762 iounmap(qdev->mem_map_registers);
3763 pci_release_regions(pdev);
3764 pci_set_drvdata(pdev, NULL);
3765 free_netdev(ndev);
3766 }
3767
3768 static struct pci_driver ql3xxx_driver = {
3769
3770 .name = DRV_NAME,
3771 .id_table = ql3xxx_pci_tbl,
3772 .probe = ql3xxx_probe,
3773 .remove = __devexit_p(ql3xxx_remove),
3774 };
3775
3776 static int __init ql3xxx_init_module(void)
3777 {
3778 return pci_register_driver(&ql3xxx_driver);
3779 }
3780
3781 static void __exit ql3xxx_exit(void)
3782 {
3783 pci_unregister_driver(&ql3xxx_driver);
3784 }
3785
3786 module_init(ql3xxx_init_module);
3787 module_exit(ql3xxx_exit);
Stable & featurefull patchset based on Linus's git branch