ia64/linux-2.6.18-xen.hg

view drivers/net/chelsio/cxgb2.c @ 897:329ea0ccb344

balloon: try harder to balloon up under memory pressure.

Currently if the balloon driver is unable to increase the guest's
reservation it assumes the failure was due to reaching its full
allocation, gives up on the ballooning operation and records the limit
it reached as the "hard limit". The driver will not try again until
the target is set again (even to the same value).

However it is possible that ballooning has in fact failed due to
memory pressure in the host and therefore it is desirable to keep
attempting to reach the target in case memory becomes available. The
most likely scenario is that some guests are ballooning down while
others are ballooning up and therefore there is temporary memory
pressure while things stabilise. You would not expect a well behaved
toolstack to ask a domain to balloon to more than its allocation nor
would you expect it to deliberately over-commit memory by setting
balloon targets which exceed the total host memory.

This patch drops the concept of a hard limit and causes the balloon
driver to retry increasing the reservation on a timer in the same
manner as when decreasing the reservation.

Also if we partially succeed in increasing the reservation
(i.e. receive less pages than we asked for) then we may as well keep
those pages rather than returning them to Xen.

Signed-off-by: Ian Campbell <ian.campbell@citrix.com>
author Keir Fraser <keir.fraser@citrix.com>
date Fri Jun 05 14:01:20 2009 +0100 (2009-06-05)
parents 831230e53067
children
line source
1 /*****************************************************************************
2 * *
3 * File: cxgb2.c *
4 * $Revision: 1.25 $ *
5 * $Date: 2005/06/22 00:43:25 $ *
6 * Description: *
7 * Chelsio 10Gb Ethernet Driver. *
8 * *
9 * This program is free software; you can redistribute it and/or modify *
10 * it under the terms of the GNU General Public License, version 2, as *
11 * published by the Free Software Foundation. *
12 * *
13 * You should have received a copy of the GNU General Public License along *
14 * with this program; if not, write to the Free Software Foundation, Inc., *
15 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
16 * *
17 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED *
18 * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF *
19 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. *
20 * *
21 * http://www.chelsio.com *
22 * *
23 * Copyright (c) 2003 - 2005 Chelsio Communications, Inc. *
24 * All rights reserved. *
25 * *
26 * Maintainers: maintainers@chelsio.com *
27 * *
28 * Authors: Dimitrios Michailidis <dm@chelsio.com> *
29 * Tina Yang <tainay@chelsio.com> *
30 * Felix Marti <felix@chelsio.com> *
31 * Scott Bardone <sbardone@chelsio.com> *
32 * Kurt Ottaway <kottaway@chelsio.com> *
33 * Frank DiMambro <frank@chelsio.com> *
34 * *
35 * History: *
36 * *
37 ****************************************************************************/
39 #include "common.h"
40 #include <linux/module.h>
41 #include <linux/init.h>
42 #include <linux/pci.h>
43 #include <linux/netdevice.h>
44 #include <linux/etherdevice.h>
45 #include <linux/if_vlan.h>
46 #include <linux/mii.h>
47 #include <linux/sockios.h>
48 #include <linux/proc_fs.h>
49 #include <linux/dma-mapping.h>
50 #include <asm/uaccess.h>
52 #include "cpl5_cmd.h"
53 #include "regs.h"
54 #include "gmac.h"
55 #include "cphy.h"
56 #include "sge.h"
57 #include "espi.h"
59 #ifdef work_struct
60 #include <linux/tqueue.h>
61 #define INIT_WORK INIT_TQUEUE
62 #define schedule_work schedule_task
63 #define flush_scheduled_work flush_scheduled_tasks
65 static inline void schedule_mac_stats_update(struct adapter *ap, int secs)
66 {
67 mod_timer(&ap->stats_update_timer, jiffies + secs * HZ);
68 }
70 static inline void cancel_mac_stats_update(struct adapter *ap)
71 {
72 del_timer_sync(&ap->stats_update_timer);
73 flush_scheduled_tasks();
74 }
76 /*
77 * Stats update timer for 2.4. It schedules a task to do the actual update as
78 * we need to access MAC statistics in process context.
79 */
80 static void mac_stats_timer(unsigned long data)
81 {
82 struct adapter *ap = (struct adapter *)data;
84 schedule_task(&ap->stats_update_task);
85 }
86 #else
87 #include <linux/workqueue.h>
89 static inline void schedule_mac_stats_update(struct adapter *ap, int secs)
90 {
91 schedule_delayed_work(&ap->stats_update_task, secs * HZ);
92 }
94 static inline void cancel_mac_stats_update(struct adapter *ap)
95 {
96 cancel_delayed_work(&ap->stats_update_task);
97 }
98 #endif
100 #define MAX_CMDQ_ENTRIES 16384
101 #define MAX_CMDQ1_ENTRIES 1024
102 #define MAX_RX_BUFFERS 16384
103 #define MAX_RX_JUMBO_BUFFERS 16384
104 #define MAX_TX_BUFFERS_HIGH 16384U
105 #define MAX_TX_BUFFERS_LOW 1536U
106 #define MIN_FL_ENTRIES 32
108 #define PORT_MASK ((1 << MAX_NPORTS) - 1)
110 #define DFLT_MSG_ENABLE (NETIF_MSG_DRV | NETIF_MSG_PROBE | NETIF_MSG_LINK | \
111 NETIF_MSG_TIMER | NETIF_MSG_IFDOWN | NETIF_MSG_IFUP |\
112 NETIF_MSG_RX_ERR | NETIF_MSG_TX_ERR)
114 /*
115 * The EEPROM is actually bigger but only the first few bytes are used so we
116 * only report those.
117 */
118 #define EEPROM_SIZE 32
120 MODULE_DESCRIPTION(DRV_DESCRIPTION);
121 MODULE_AUTHOR("Chelsio Communications");
122 MODULE_LICENSE("GPL");
124 static int dflt_msg_enable = DFLT_MSG_ENABLE;
126 module_param(dflt_msg_enable, int, 0);
127 MODULE_PARM_DESC(dflt_msg_enable, "Chelsio T1 message enable bitmap");
130 static const char pci_speed[][4] = {
131 "33", "66", "100", "133"
132 };
134 /*
135 * Setup MAC to receive the types of packets we want.
136 */
137 static void t1_set_rxmode(struct net_device *dev)
138 {
139 struct adapter *adapter = dev->priv;
140 struct cmac *mac = adapter->port[dev->if_port].mac;
141 struct t1_rx_mode rm;
143 rm.dev = dev;
144 rm.idx = 0;
145 rm.list = dev->mc_list;
146 mac->ops->set_rx_mode(mac, &rm);
147 }
149 static void link_report(struct port_info *p)
150 {
151 if (!netif_carrier_ok(p->dev))
152 printk(KERN_INFO "%s: link down\n", p->dev->name);
153 else {
154 const char *s = "10Mbps";
156 switch (p->link_config.speed) {
157 case SPEED_10000: s = "10Gbps"; break;
158 case SPEED_1000: s = "1000Mbps"; break;
159 case SPEED_100: s = "100Mbps"; break;
160 }
162 printk(KERN_INFO "%s: link up, %s, %s-duplex\n",
163 p->dev->name, s,
164 p->link_config.duplex == DUPLEX_FULL ? "full" : "half");
165 }
166 }
168 void t1_link_changed(struct adapter *adapter, int port_id, int link_stat,
169 int speed, int duplex, int pause)
170 {
171 struct port_info *p = &adapter->port[port_id];
173 if (link_stat != netif_carrier_ok(p->dev)) {
174 if (link_stat)
175 netif_carrier_on(p->dev);
176 else
177 netif_carrier_off(p->dev);
178 link_report(p);
180 }
181 }
183 static void link_start(struct port_info *p)
184 {
185 struct cmac *mac = p->mac;
187 mac->ops->reset(mac);
188 if (mac->ops->macaddress_set)
189 mac->ops->macaddress_set(mac, p->dev->dev_addr);
190 t1_set_rxmode(p->dev);
191 t1_link_start(p->phy, mac, &p->link_config);
192 mac->ops->enable(mac, MAC_DIRECTION_RX | MAC_DIRECTION_TX);
193 }
195 static void enable_hw_csum(struct adapter *adapter)
196 {
197 if (adapter->flags & TSO_CAPABLE)
198 t1_tp_set_ip_checksum_offload(adapter, 1); /* for TSO only */
199 t1_tp_set_tcp_checksum_offload(adapter, 1);
200 }
202 /*
203 * Things to do upon first use of a card.
204 * This must run with the rtnl lock held.
205 */
206 static int cxgb_up(struct adapter *adapter)
207 {
208 int err = 0;
210 if (!(adapter->flags & FULL_INIT_DONE)) {
211 err = t1_init_hw_modules(adapter);
212 if (err)
213 goto out_err;
215 enable_hw_csum(adapter);
216 adapter->flags |= FULL_INIT_DONE;
217 }
219 t1_interrupts_clear(adapter);
220 if ((err = request_irq(adapter->pdev->irq,
221 t1_select_intr_handler(adapter), IRQF_SHARED,
222 adapter->name, adapter))) {
223 goto out_err;
224 }
225 t1_sge_start(adapter->sge);
226 t1_interrupts_enable(adapter);
227 out_err:
228 return err;
229 }
231 /*
232 * Release resources when all the ports have been stopped.
233 */
234 static void cxgb_down(struct adapter *adapter)
235 {
236 t1_sge_stop(adapter->sge);
237 t1_interrupts_disable(adapter);
238 free_irq(adapter->pdev->irq, adapter);
239 }
241 static int cxgb_open(struct net_device *dev)
242 {
243 int err;
244 struct adapter *adapter = dev->priv;
245 int other_ports = adapter->open_device_map & PORT_MASK;
247 if (!adapter->open_device_map && (err = cxgb_up(adapter)) < 0)
248 return err;
250 __set_bit(dev->if_port, &adapter->open_device_map);
251 link_start(&adapter->port[dev->if_port]);
252 netif_start_queue(dev);
253 if (!other_ports && adapter->params.stats_update_period)
254 schedule_mac_stats_update(adapter,
255 adapter->params.stats_update_period);
256 return 0;
257 }
259 static int cxgb_close(struct net_device *dev)
260 {
261 struct adapter *adapter = dev->priv;
262 struct port_info *p = &adapter->port[dev->if_port];
263 struct cmac *mac = p->mac;
265 netif_stop_queue(dev);
266 mac->ops->disable(mac, MAC_DIRECTION_TX | MAC_DIRECTION_RX);
267 netif_carrier_off(dev);
269 clear_bit(dev->if_port, &adapter->open_device_map);
270 if (adapter->params.stats_update_period &&
271 !(adapter->open_device_map & PORT_MASK)) {
272 /* Stop statistics accumulation. */
273 smp_mb__after_clear_bit();
274 spin_lock(&adapter->work_lock); /* sync with update task */
275 spin_unlock(&adapter->work_lock);
276 cancel_mac_stats_update(adapter);
277 }
279 if (!adapter->open_device_map)
280 cxgb_down(adapter);
281 return 0;
282 }
284 static struct net_device_stats *t1_get_stats(struct net_device *dev)
285 {
286 struct adapter *adapter = dev->priv;
287 struct port_info *p = &adapter->port[dev->if_port];
288 struct net_device_stats *ns = &p->netstats;
289 const struct cmac_statistics *pstats;
291 /* Do a full update of the MAC stats */
292 pstats = p->mac->ops->statistics_update(p->mac,
293 MAC_STATS_UPDATE_FULL);
295 ns->tx_packets = pstats->TxUnicastFramesOK +
296 pstats->TxMulticastFramesOK + pstats->TxBroadcastFramesOK;
298 ns->rx_packets = pstats->RxUnicastFramesOK +
299 pstats->RxMulticastFramesOK + pstats->RxBroadcastFramesOK;
301 ns->tx_bytes = pstats->TxOctetsOK;
302 ns->rx_bytes = pstats->RxOctetsOK;
304 ns->tx_errors = pstats->TxLateCollisions + pstats->TxLengthErrors +
305 pstats->TxUnderrun + pstats->TxFramesAbortedDueToXSCollisions;
306 ns->rx_errors = pstats->RxDataErrors + pstats->RxJabberErrors +
307 pstats->RxFCSErrors + pstats->RxAlignErrors +
308 pstats->RxSequenceErrors + pstats->RxFrameTooLongErrors +
309 pstats->RxSymbolErrors + pstats->RxRuntErrors;
311 ns->multicast = pstats->RxMulticastFramesOK;
312 ns->collisions = pstats->TxTotalCollisions;
314 /* detailed rx_errors */
315 ns->rx_length_errors = pstats->RxFrameTooLongErrors +
316 pstats->RxJabberErrors;
317 ns->rx_over_errors = 0;
318 ns->rx_crc_errors = pstats->RxFCSErrors;
319 ns->rx_frame_errors = pstats->RxAlignErrors;
320 ns->rx_fifo_errors = 0;
321 ns->rx_missed_errors = 0;
323 /* detailed tx_errors */
324 ns->tx_aborted_errors = pstats->TxFramesAbortedDueToXSCollisions;
325 ns->tx_carrier_errors = 0;
326 ns->tx_fifo_errors = pstats->TxUnderrun;
327 ns->tx_heartbeat_errors = 0;
328 ns->tx_window_errors = pstats->TxLateCollisions;
329 return ns;
330 }
332 static u32 get_msglevel(struct net_device *dev)
333 {
334 struct adapter *adapter = dev->priv;
336 return adapter->msg_enable;
337 }
339 static void set_msglevel(struct net_device *dev, u32 val)
340 {
341 struct adapter *adapter = dev->priv;
343 adapter->msg_enable = val;
344 }
346 static char stats_strings[][ETH_GSTRING_LEN] = {
347 "TxOctetsOK",
348 "TxOctetsBad",
349 "TxUnicastFramesOK",
350 "TxMulticastFramesOK",
351 "TxBroadcastFramesOK",
352 "TxPauseFrames",
353 "TxFramesWithDeferredXmissions",
354 "TxLateCollisions",
355 "TxTotalCollisions",
356 "TxFramesAbortedDueToXSCollisions",
357 "TxUnderrun",
358 "TxLengthErrors",
359 "TxInternalMACXmitError",
360 "TxFramesWithExcessiveDeferral",
361 "TxFCSErrors",
363 "RxOctetsOK",
364 "RxOctetsBad",
365 "RxUnicastFramesOK",
366 "RxMulticastFramesOK",
367 "RxBroadcastFramesOK",
368 "RxPauseFrames",
369 "RxFCSErrors",
370 "RxAlignErrors",
371 "RxSymbolErrors",
372 "RxDataErrors",
373 "RxSequenceErrors",
374 "RxRuntErrors",
375 "RxJabberErrors",
376 "RxInternalMACRcvError",
377 "RxInRangeLengthErrors",
378 "RxOutOfRangeLengthField",
379 "RxFrameTooLongErrors",
381 "TSO",
382 "VLANextractions",
383 "VLANinsertions",
384 "RxCsumGood",
385 "TxCsumOffload",
386 "RxDrops"
388 "respQ_empty",
389 "respQ_overflow",
390 "freelistQ_empty",
391 "pkt_too_big",
392 "pkt_mismatch",
393 "cmdQ_full0",
394 "cmdQ_full1",
395 "tx_ipfrags",
396 "tx_reg_pkts",
397 "tx_lso_pkts",
398 "tx_do_cksum",
400 "espi_DIP2ParityErr",
401 "espi_DIP4Err",
402 "espi_RxDrops",
403 "espi_TxDrops",
404 "espi_RxOvfl",
405 "espi_ParityErr"
406 };
408 #define T2_REGMAP_SIZE (3 * 1024)
410 static int get_regs_len(struct net_device *dev)
411 {
412 return T2_REGMAP_SIZE;
413 }
415 static void get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
416 {
417 struct adapter *adapter = dev->priv;
419 strcpy(info->driver, DRV_NAME);
420 strcpy(info->version, DRV_VERSION);
421 strcpy(info->fw_version, "N/A");
422 strcpy(info->bus_info, pci_name(adapter->pdev));
423 }
425 static int get_stats_count(struct net_device *dev)
426 {
427 return ARRAY_SIZE(stats_strings);
428 }
430 static void get_strings(struct net_device *dev, u32 stringset, u8 *data)
431 {
432 if (stringset == ETH_SS_STATS)
433 memcpy(data, stats_strings, sizeof(stats_strings));
434 }
436 static void get_stats(struct net_device *dev, struct ethtool_stats *stats,
437 u64 *data)
438 {
439 struct adapter *adapter = dev->priv;
440 struct cmac *mac = adapter->port[dev->if_port].mac;
441 const struct cmac_statistics *s;
442 const struct sge_port_stats *ss;
443 const struct sge_intr_counts *t;
445 s = mac->ops->statistics_update(mac, MAC_STATS_UPDATE_FULL);
446 ss = t1_sge_get_port_stats(adapter->sge, dev->if_port);
447 t = t1_sge_get_intr_counts(adapter->sge);
449 *data++ = s->TxOctetsOK;
450 *data++ = s->TxOctetsBad;
451 *data++ = s->TxUnicastFramesOK;
452 *data++ = s->TxMulticastFramesOK;
453 *data++ = s->TxBroadcastFramesOK;
454 *data++ = s->TxPauseFrames;
455 *data++ = s->TxFramesWithDeferredXmissions;
456 *data++ = s->TxLateCollisions;
457 *data++ = s->TxTotalCollisions;
458 *data++ = s->TxFramesAbortedDueToXSCollisions;
459 *data++ = s->TxUnderrun;
460 *data++ = s->TxLengthErrors;
461 *data++ = s->TxInternalMACXmitError;
462 *data++ = s->TxFramesWithExcessiveDeferral;
463 *data++ = s->TxFCSErrors;
465 *data++ = s->RxOctetsOK;
466 *data++ = s->RxOctetsBad;
467 *data++ = s->RxUnicastFramesOK;
468 *data++ = s->RxMulticastFramesOK;
469 *data++ = s->RxBroadcastFramesOK;
470 *data++ = s->RxPauseFrames;
471 *data++ = s->RxFCSErrors;
472 *data++ = s->RxAlignErrors;
473 *data++ = s->RxSymbolErrors;
474 *data++ = s->RxDataErrors;
475 *data++ = s->RxSequenceErrors;
476 *data++ = s->RxRuntErrors;
477 *data++ = s->RxJabberErrors;
478 *data++ = s->RxInternalMACRcvError;
479 *data++ = s->RxInRangeLengthErrors;
480 *data++ = s->RxOutOfRangeLengthField;
481 *data++ = s->RxFrameTooLongErrors;
483 *data++ = ss->tso;
484 *data++ = ss->vlan_xtract;
485 *data++ = ss->vlan_insert;
486 *data++ = ss->rx_cso_good;
487 *data++ = ss->tx_cso;
488 *data++ = ss->rx_drops;
490 *data++ = (u64)t->respQ_empty;
491 *data++ = (u64)t->respQ_overflow;
492 *data++ = (u64)t->freelistQ_empty;
493 *data++ = (u64)t->pkt_too_big;
494 *data++ = (u64)t->pkt_mismatch;
495 *data++ = (u64)t->cmdQ_full[0];
496 *data++ = (u64)t->cmdQ_full[1];
497 *data++ = (u64)t->tx_ipfrags;
498 *data++ = (u64)t->tx_reg_pkts;
499 *data++ = (u64)t->tx_lso_pkts;
500 *data++ = (u64)t->tx_do_cksum;
501 }
503 static inline void reg_block_dump(struct adapter *ap, void *buf,
504 unsigned int start, unsigned int end)
505 {
506 u32 *p = buf + start;
508 for ( ; start <= end; start += sizeof(u32))
509 *p++ = readl(ap->regs + start);
510 }
512 static void get_regs(struct net_device *dev, struct ethtool_regs *regs,
513 void *buf)
514 {
515 struct adapter *ap = dev->priv;
517 /*
518 * Version scheme: bits 0..9: chip version, bits 10..15: chip revision
519 */
520 regs->version = 2;
522 memset(buf, 0, T2_REGMAP_SIZE);
523 reg_block_dump(ap, buf, 0, A_SG_RESPACCUTIMER);
524 }
526 static int get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
527 {
528 struct adapter *adapter = dev->priv;
529 struct port_info *p = &adapter->port[dev->if_port];
531 cmd->supported = p->link_config.supported;
532 cmd->advertising = p->link_config.advertising;
534 if (netif_carrier_ok(dev)) {
535 cmd->speed = p->link_config.speed;
536 cmd->duplex = p->link_config.duplex;
537 } else {
538 cmd->speed = -1;
539 cmd->duplex = -1;
540 }
542 cmd->port = (cmd->supported & SUPPORTED_TP) ? PORT_TP : PORT_FIBRE;
543 cmd->phy_address = p->phy->addr;
544 cmd->transceiver = XCVR_EXTERNAL;
545 cmd->autoneg = p->link_config.autoneg;
546 cmd->maxtxpkt = 0;
547 cmd->maxrxpkt = 0;
548 return 0;
549 }
551 static int speed_duplex_to_caps(int speed, int duplex)
552 {
553 int cap = 0;
555 switch (speed) {
556 case SPEED_10:
557 if (duplex == DUPLEX_FULL)
558 cap = SUPPORTED_10baseT_Full;
559 else
560 cap = SUPPORTED_10baseT_Half;
561 break;
562 case SPEED_100:
563 if (duplex == DUPLEX_FULL)
564 cap = SUPPORTED_100baseT_Full;
565 else
566 cap = SUPPORTED_100baseT_Half;
567 break;
568 case SPEED_1000:
569 if (duplex == DUPLEX_FULL)
570 cap = SUPPORTED_1000baseT_Full;
571 else
572 cap = SUPPORTED_1000baseT_Half;
573 break;
574 case SPEED_10000:
575 if (duplex == DUPLEX_FULL)
576 cap = SUPPORTED_10000baseT_Full;
577 }
578 return cap;
579 }
581 #define ADVERTISED_MASK (ADVERTISED_10baseT_Half | ADVERTISED_10baseT_Full | \
582 ADVERTISED_100baseT_Half | ADVERTISED_100baseT_Full | \
583 ADVERTISED_1000baseT_Half | ADVERTISED_1000baseT_Full | \
584 ADVERTISED_10000baseT_Full)
586 static int set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
587 {
588 struct adapter *adapter = dev->priv;
589 struct port_info *p = &adapter->port[dev->if_port];
590 struct link_config *lc = &p->link_config;
592 if (!(lc->supported & SUPPORTED_Autoneg))
593 return -EOPNOTSUPP; /* can't change speed/duplex */
595 if (cmd->autoneg == AUTONEG_DISABLE) {
596 int cap = speed_duplex_to_caps(cmd->speed, cmd->duplex);
598 if (!(lc->supported & cap) || cmd->speed == SPEED_1000)
599 return -EINVAL;
600 lc->requested_speed = cmd->speed;
601 lc->requested_duplex = cmd->duplex;
602 lc->advertising = 0;
603 } else {
604 cmd->advertising &= ADVERTISED_MASK;
605 if (cmd->advertising & (cmd->advertising - 1))
606 cmd->advertising = lc->supported;
607 cmd->advertising &= lc->supported;
608 if (!cmd->advertising)
609 return -EINVAL;
610 lc->requested_speed = SPEED_INVALID;
611 lc->requested_duplex = DUPLEX_INVALID;
612 lc->advertising = cmd->advertising | ADVERTISED_Autoneg;
613 }
614 lc->autoneg = cmd->autoneg;
615 if (netif_running(dev))
616 t1_link_start(p->phy, p->mac, lc);
617 return 0;
618 }
620 static void get_pauseparam(struct net_device *dev,
621 struct ethtool_pauseparam *epause)
622 {
623 struct adapter *adapter = dev->priv;
624 struct port_info *p = &adapter->port[dev->if_port];
626 epause->autoneg = (p->link_config.requested_fc & PAUSE_AUTONEG) != 0;
627 epause->rx_pause = (p->link_config.fc & PAUSE_RX) != 0;
628 epause->tx_pause = (p->link_config.fc & PAUSE_TX) != 0;
629 }
631 static int set_pauseparam(struct net_device *dev,
632 struct ethtool_pauseparam *epause)
633 {
634 struct adapter *adapter = dev->priv;
635 struct port_info *p = &adapter->port[dev->if_port];
636 struct link_config *lc = &p->link_config;
638 if (epause->autoneg == AUTONEG_DISABLE)
639 lc->requested_fc = 0;
640 else if (lc->supported & SUPPORTED_Autoneg)
641 lc->requested_fc = PAUSE_AUTONEG;
642 else
643 return -EINVAL;
645 if (epause->rx_pause)
646 lc->requested_fc |= PAUSE_RX;
647 if (epause->tx_pause)
648 lc->requested_fc |= PAUSE_TX;
649 if (lc->autoneg == AUTONEG_ENABLE) {
650 if (netif_running(dev))
651 t1_link_start(p->phy, p->mac, lc);
652 } else {
653 lc->fc = lc->requested_fc & (PAUSE_RX | PAUSE_TX);
654 if (netif_running(dev))
655 p->mac->ops->set_speed_duplex_fc(p->mac, -1, -1,
656 lc->fc);
657 }
658 return 0;
659 }
661 static u32 get_rx_csum(struct net_device *dev)
662 {
663 struct adapter *adapter = dev->priv;
665 return (adapter->flags & RX_CSUM_ENABLED) != 0;
666 }
668 static int set_rx_csum(struct net_device *dev, u32 data)
669 {
670 struct adapter *adapter = dev->priv;
672 if (data)
673 adapter->flags |= RX_CSUM_ENABLED;
674 else
675 adapter->flags &= ~RX_CSUM_ENABLED;
676 return 0;
677 }
679 static int set_tso(struct net_device *dev, u32 value)
680 {
681 struct adapter *adapter = dev->priv;
683 if (!(adapter->flags & TSO_CAPABLE))
684 return value ? -EOPNOTSUPP : 0;
685 return ethtool_op_set_tso(dev, value);
686 }
688 static void get_sge_param(struct net_device *dev, struct ethtool_ringparam *e)
689 {
690 struct adapter *adapter = dev->priv;
691 int jumbo_fl = t1_is_T1B(adapter) ? 1 : 0;
693 e->rx_max_pending = MAX_RX_BUFFERS;
694 e->rx_mini_max_pending = 0;
695 e->rx_jumbo_max_pending = MAX_RX_JUMBO_BUFFERS;
696 e->tx_max_pending = MAX_CMDQ_ENTRIES;
698 e->rx_pending = adapter->params.sge.freelQ_size[!jumbo_fl];
699 e->rx_mini_pending = 0;
700 e->rx_jumbo_pending = adapter->params.sge.freelQ_size[jumbo_fl];
701 e->tx_pending = adapter->params.sge.cmdQ_size[0];
702 }
704 static int set_sge_param(struct net_device *dev, struct ethtool_ringparam *e)
705 {
706 struct adapter *adapter = dev->priv;
707 int jumbo_fl = t1_is_T1B(adapter) ? 1 : 0;
709 if (e->rx_pending > MAX_RX_BUFFERS || e->rx_mini_pending ||
710 e->rx_jumbo_pending > MAX_RX_JUMBO_BUFFERS ||
711 e->tx_pending > MAX_CMDQ_ENTRIES ||
712 e->rx_pending < MIN_FL_ENTRIES ||
713 e->rx_jumbo_pending < MIN_FL_ENTRIES ||
714 e->tx_pending < (adapter->params.nports + 1) * (MAX_SKB_FRAGS + 1))
715 return -EINVAL;
717 if (adapter->flags & FULL_INIT_DONE)
718 return -EBUSY;
720 adapter->params.sge.freelQ_size[!jumbo_fl] = e->rx_pending;
721 adapter->params.sge.freelQ_size[jumbo_fl] = e->rx_jumbo_pending;
722 adapter->params.sge.cmdQ_size[0] = e->tx_pending;
723 adapter->params.sge.cmdQ_size[1] = e->tx_pending > MAX_CMDQ1_ENTRIES ?
724 MAX_CMDQ1_ENTRIES : e->tx_pending;
725 return 0;
726 }
728 static int set_coalesce(struct net_device *dev, struct ethtool_coalesce *c)
729 {
730 struct adapter *adapter = dev->priv;
732 /*
733 * If RX coalescing is requested we use NAPI, otherwise interrupts.
734 * This choice can be made only when all ports and the TOE are off.
735 */
736 if (adapter->open_device_map == 0)
737 adapter->params.sge.polling = c->use_adaptive_rx_coalesce;
739 if (adapter->params.sge.polling) {
740 adapter->params.sge.rx_coalesce_usecs = 0;
741 } else {
742 adapter->params.sge.rx_coalesce_usecs = c->rx_coalesce_usecs;
743 }
744 adapter->params.sge.coalesce_enable = c->use_adaptive_rx_coalesce;
745 adapter->params.sge.sample_interval_usecs = c->rate_sample_interval;
746 t1_sge_set_coalesce_params(adapter->sge, &adapter->params.sge);
747 return 0;
748 }
750 static int get_coalesce(struct net_device *dev, struct ethtool_coalesce *c)
751 {
752 struct adapter *adapter = dev->priv;
754 c->rx_coalesce_usecs = adapter->params.sge.rx_coalesce_usecs;
755 c->rate_sample_interval = adapter->params.sge.sample_interval_usecs;
756 c->use_adaptive_rx_coalesce = adapter->params.sge.coalesce_enable;
757 return 0;
758 }
760 static int get_eeprom_len(struct net_device *dev)
761 {
762 return EEPROM_SIZE;
763 }
765 #define EEPROM_MAGIC(ap) \
766 (PCI_VENDOR_ID_CHELSIO | ((ap)->params.chip_version << 16))
768 static int get_eeprom(struct net_device *dev, struct ethtool_eeprom *e,
769 u8 *data)
770 {
771 int i;
772 u8 buf[EEPROM_SIZE] __attribute__((aligned(4)));
773 struct adapter *adapter = dev->priv;
775 e->magic = EEPROM_MAGIC(adapter);
776 for (i = e->offset & ~3; i < e->offset + e->len; i += sizeof(u32))
777 t1_seeprom_read(adapter, i, (u32 *)&buf[i]);
778 memcpy(data, buf + e->offset, e->len);
779 return 0;
780 }
782 static struct ethtool_ops t1_ethtool_ops = {
783 .get_settings = get_settings,
784 .set_settings = set_settings,
785 .get_drvinfo = get_drvinfo,
786 .get_msglevel = get_msglevel,
787 .set_msglevel = set_msglevel,
788 .get_ringparam = get_sge_param,
789 .set_ringparam = set_sge_param,
790 .get_coalesce = get_coalesce,
791 .set_coalesce = set_coalesce,
792 .get_eeprom_len = get_eeprom_len,
793 .get_eeprom = get_eeprom,
794 .get_pauseparam = get_pauseparam,
795 .set_pauseparam = set_pauseparam,
796 .get_rx_csum = get_rx_csum,
797 .set_rx_csum = set_rx_csum,
798 .get_tx_csum = ethtool_op_get_tx_csum,
799 .set_tx_csum = ethtool_op_set_tx_csum,
800 .get_sg = ethtool_op_get_sg,
801 .set_sg = ethtool_op_set_sg,
802 .get_link = ethtool_op_get_link,
803 .get_strings = get_strings,
804 .get_stats_count = get_stats_count,
805 .get_ethtool_stats = get_stats,
806 .get_regs_len = get_regs_len,
807 .get_regs = get_regs,
808 .get_tso = ethtool_op_get_tso,
809 .set_tso = set_tso,
810 };
812 static void cxgb_proc_cleanup(struct adapter *adapter,
813 struct proc_dir_entry *dir)
814 {
815 const char *name;
816 name = adapter->name;
817 remove_proc_entry(name, dir);
818 }
819 //#define chtoe_setup_toedev(adapter) NULL
820 #define update_mtu_tab(adapter)
821 #define write_smt_entry(adapter, idx)
823 static int t1_ioctl(struct net_device *dev, struct ifreq *req, int cmd)
824 {
825 struct adapter *adapter = dev->priv;
826 struct mii_ioctl_data *data = if_mii(req);
828 switch (cmd) {
829 case SIOCGMIIPHY:
830 data->phy_id = adapter->port[dev->if_port].phy->addr;
831 /* FALLTHRU */
832 case SIOCGMIIREG: {
833 struct cphy *phy = adapter->port[dev->if_port].phy;
834 u32 val;
836 if (!phy->mdio_read)
837 return -EOPNOTSUPP;
838 phy->mdio_read(adapter, data->phy_id, 0, data->reg_num & 0x1f,
839 &val);
840 data->val_out = val;
841 break;
842 }
843 case SIOCSMIIREG: {
844 struct cphy *phy = adapter->port[dev->if_port].phy;
846 if (!capable(CAP_NET_ADMIN))
847 return -EPERM;
848 if (!phy->mdio_write)
849 return -EOPNOTSUPP;
850 phy->mdio_write(adapter, data->phy_id, 0, data->reg_num & 0x1f,
851 data->val_in);
852 break;
853 }
855 default:
856 return -EOPNOTSUPP;
857 }
858 return 0;
859 }
861 static int t1_change_mtu(struct net_device *dev, int new_mtu)
862 {
863 int ret;
864 struct adapter *adapter = dev->priv;
865 struct cmac *mac = adapter->port[dev->if_port].mac;
867 if (!mac->ops->set_mtu)
868 return -EOPNOTSUPP;
869 if (new_mtu < 68)
870 return -EINVAL;
871 if ((ret = mac->ops->set_mtu(mac, new_mtu)))
872 return ret;
873 dev->mtu = new_mtu;
874 return 0;
875 }
877 static int t1_set_mac_addr(struct net_device *dev, void *p)
878 {
879 struct adapter *adapter = dev->priv;
880 struct cmac *mac = adapter->port[dev->if_port].mac;
881 struct sockaddr *addr = p;
883 if (!mac->ops->macaddress_set)
884 return -EOPNOTSUPP;
886 memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
887 mac->ops->macaddress_set(mac, dev->dev_addr);
888 return 0;
889 }
891 #if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)
892 static void vlan_rx_register(struct net_device *dev,
893 struct vlan_group *grp)
894 {
895 struct adapter *adapter = dev->priv;
897 spin_lock_irq(&adapter->async_lock);
898 adapter->vlan_grp = grp;
899 t1_set_vlan_accel(adapter, grp != NULL);
900 spin_unlock_irq(&adapter->async_lock);
901 }
903 static void vlan_rx_kill_vid(struct net_device *dev, unsigned short vid)
904 {
905 struct adapter *adapter = dev->priv;
907 spin_lock_irq(&adapter->async_lock);
908 if (adapter->vlan_grp)
909 adapter->vlan_grp->vlan_devices[vid] = NULL;
910 spin_unlock_irq(&adapter->async_lock);
911 }
912 #endif
914 #ifdef CONFIG_NET_POLL_CONTROLLER
915 static void t1_netpoll(struct net_device *dev)
916 {
917 unsigned long flags;
918 struct adapter *adapter = dev->priv;
920 local_irq_save(flags);
921 t1_select_intr_handler(adapter)(adapter->pdev->irq, adapter, NULL);
922 local_irq_restore(flags);
923 }
924 #endif
926 /*
927 * Periodic accumulation of MAC statistics. This is used only if the MAC
928 * does not have any other way to prevent stats counter overflow.
929 */
930 static void mac_stats_task(void *data)
931 {
932 int i;
933 struct adapter *adapter = data;
935 for_each_port(adapter, i) {
936 struct port_info *p = &adapter->port[i];
938 if (netif_running(p->dev))
939 p->mac->ops->statistics_update(p->mac,
940 MAC_STATS_UPDATE_FAST);
941 }
943 /* Schedule the next statistics update if any port is active. */
944 spin_lock(&adapter->work_lock);
945 if (adapter->open_device_map & PORT_MASK)
946 schedule_mac_stats_update(adapter,
947 adapter->params.stats_update_period);
948 spin_unlock(&adapter->work_lock);
949 }
951 /*
952 * Processes elmer0 external interrupts in process context.
953 */
954 static void ext_intr_task(void *data)
955 {
956 struct adapter *adapter = data;
958 elmer0_ext_intr_handler(adapter);
960 /* Now reenable external interrupts */
961 spin_lock_irq(&adapter->async_lock);
962 adapter->slow_intr_mask |= F_PL_INTR_EXT;
963 writel(F_PL_INTR_EXT, adapter->regs + A_PL_CAUSE);
964 writel(adapter->slow_intr_mask | F_PL_INTR_SGE_DATA,
965 adapter->regs + A_PL_ENABLE);
966 spin_unlock_irq(&adapter->async_lock);
967 }
969 /*
970 * Interrupt-context handler for elmer0 external interrupts.
971 */
972 void t1_elmer0_ext_intr(struct adapter *adapter)
973 {
974 /*
975 * Schedule a task to handle external interrupts as we require
976 * a process context. We disable EXT interrupts in the interim
977 * and let the task reenable them when it's done.
978 */
979 adapter->slow_intr_mask &= ~F_PL_INTR_EXT;
980 writel(adapter->slow_intr_mask | F_PL_INTR_SGE_DATA,
981 adapter->regs + A_PL_ENABLE);
982 schedule_work(&adapter->ext_intr_handler_task);
983 }
985 void t1_fatal_err(struct adapter *adapter)
986 {
987 if (adapter->flags & FULL_INIT_DONE) {
988 t1_sge_stop(adapter->sge);
989 t1_interrupts_disable(adapter);
990 }
991 CH_ALERT("%s: encountered fatal error, operation suspended\n",
992 adapter->name);
993 }
995 static int __devinit init_one(struct pci_dev *pdev,
996 const struct pci_device_id *ent)
997 {
998 static int version_printed;
1000 int i, err, pci_using_dac = 0;
1001 unsigned long mmio_start, mmio_len;
1002 const struct board_info *bi;
1003 struct adapter *adapter = NULL;
1004 struct port_info *pi;
1006 if (!version_printed) {
1007 printk(KERN_INFO "%s - version %s\n", DRV_DESCRIPTION,
1008 DRV_VERSION);
1009 ++version_printed;
1012 err = pci_enable_device(pdev);
1013 if (err)
1014 return err;
1016 if (!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM)) {
1017 CH_ERR("%s: cannot find PCI device memory base address\n",
1018 pci_name(pdev));
1019 err = -ENODEV;
1020 goto out_disable_pdev;
1023 if (!pci_set_dma_mask(pdev, DMA_64BIT_MASK)) {
1024 pci_using_dac = 1;
1026 if (pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK)) {
1027 CH_ERR("%s: unable to obtain 64-bit DMA for"
1028 "consistent allocations\n", pci_name(pdev));
1029 err = -ENODEV;
1030 goto out_disable_pdev;
1033 } else if ((err = pci_set_dma_mask(pdev, DMA_32BIT_MASK)) != 0) {
1034 CH_ERR("%s: no usable DMA configuration\n", pci_name(pdev));
1035 goto out_disable_pdev;
1038 err = pci_request_regions(pdev, DRV_NAME);
1039 if (err) {
1040 CH_ERR("%s: cannot obtain PCI resources\n", pci_name(pdev));
1041 goto out_disable_pdev;
1044 pci_set_master(pdev);
1046 mmio_start = pci_resource_start(pdev, 0);
1047 mmio_len = pci_resource_len(pdev, 0);
1048 bi = t1_get_board_info(ent->driver_data);
1050 for (i = 0; i < bi->port_number; ++i) {
1051 struct net_device *netdev;
1053 netdev = alloc_etherdev(adapter ? 0 : sizeof(*adapter));
1054 if (!netdev) {
1055 err = -ENOMEM;
1056 goto out_free_dev;
1059 SET_MODULE_OWNER(netdev);
1060 SET_NETDEV_DEV(netdev, &pdev->dev);
1062 if (!adapter) {
1063 adapter = netdev->priv;
1064 adapter->pdev = pdev;
1065 adapter->port[0].dev = netdev; /* so we don't leak it */
1067 adapter->regs = ioremap(mmio_start, mmio_len);
1068 if (!adapter->regs) {
1069 CH_ERR("%s: cannot map device registers\n",
1070 pci_name(pdev));
1071 err = -ENOMEM;
1072 goto out_free_dev;
1075 if (t1_get_board_rev(adapter, bi, &adapter->params)) {
1076 err = -ENODEV; /* Can't handle this chip rev */
1077 goto out_free_dev;
1080 adapter->name = pci_name(pdev);
1081 adapter->msg_enable = dflt_msg_enable;
1082 adapter->mmio_len = mmio_len;
1084 init_MUTEX(&adapter->mib_mutex);
1085 spin_lock_init(&adapter->tpi_lock);
1086 spin_lock_init(&adapter->work_lock);
1087 spin_lock_init(&adapter->async_lock);
1089 INIT_WORK(&adapter->ext_intr_handler_task,
1090 ext_intr_task, adapter);
1091 INIT_WORK(&adapter->stats_update_task, mac_stats_task,
1092 adapter);
1093 #ifdef work_struct
1094 init_timer(&adapter->stats_update_timer);
1095 adapter->stats_update_timer.function = mac_stats_timer;
1096 adapter->stats_update_timer.data =
1097 (unsigned long)adapter;
1098 #endif
1100 pci_set_drvdata(pdev, netdev);
1103 pi = &adapter->port[i];
1104 pi->dev = netdev;
1105 netif_carrier_off(netdev);
1106 netdev->irq = pdev->irq;
1107 netdev->if_port = i;
1108 netdev->mem_start = mmio_start;
1109 netdev->mem_end = mmio_start + mmio_len - 1;
1110 netdev->priv = adapter;
1111 netdev->features |= NETIF_F_SG | NETIF_F_IP_CSUM;
1112 netdev->features |= NETIF_F_LLTX;
1114 adapter->flags |= RX_CSUM_ENABLED | TCP_CSUM_CAPABLE;
1115 if (pci_using_dac)
1116 netdev->features |= NETIF_F_HIGHDMA;
1117 if (vlan_tso_capable(adapter)) {
1118 #if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)
1119 adapter->flags |= VLAN_ACCEL_CAPABLE;
1120 netdev->features |=
1121 NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX;
1122 netdev->vlan_rx_register = vlan_rx_register;
1123 netdev->vlan_rx_kill_vid = vlan_rx_kill_vid;
1124 #endif
1125 adapter->flags |= TSO_CAPABLE;
1126 netdev->features |= NETIF_F_TSO;
1129 netdev->open = cxgb_open;
1130 netdev->stop = cxgb_close;
1131 netdev->hard_start_xmit = t1_start_xmit;
1132 netdev->hard_header_len += (adapter->flags & TSO_CAPABLE) ?
1133 sizeof(struct cpl_tx_pkt_lso) :
1134 sizeof(struct cpl_tx_pkt);
1135 netdev->get_stats = t1_get_stats;
1136 netdev->set_multicast_list = t1_set_rxmode;
1137 netdev->do_ioctl = t1_ioctl;
1138 netdev->change_mtu = t1_change_mtu;
1139 netdev->set_mac_address = t1_set_mac_addr;
1140 #ifdef CONFIG_NET_POLL_CONTROLLER
1141 netdev->poll_controller = t1_netpoll;
1142 #endif
1143 netdev->weight = 64;
1145 SET_ETHTOOL_OPS(netdev, &t1_ethtool_ops);
1148 if (t1_init_sw_modules(adapter, bi) < 0) {
1149 err = -ENODEV;
1150 goto out_free_dev;
1153 /*
1154 * The card is now ready to go. If any errors occur during device
1155 * registration we do not fail the whole card but rather proceed only
1156 * with the ports we manage to register successfully. However we must
1157 * register at least one net device.
1158 */
1159 for (i = 0; i < bi->port_number; ++i) {
1160 err = register_netdev(adapter->port[i].dev);
1161 if (err)
1162 CH_WARN("%s: cannot register net device %s, skipping\n",
1163 pci_name(pdev), adapter->port[i].dev->name);
1164 else {
1165 /*
1166 * Change the name we use for messages to the name of
1167 * the first successfully registered interface.
1168 */
1169 if (!adapter->registered_device_map)
1170 adapter->name = adapter->port[i].dev->name;
1172 __set_bit(i, &adapter->registered_device_map);
1175 if (!adapter->registered_device_map) {
1176 CH_ERR("%s: could not register any net devices\n",
1177 pci_name(pdev));
1178 goto out_release_adapter_res;
1181 printk(KERN_INFO "%s: %s (rev %d), %s %dMHz/%d-bit\n", adapter->name,
1182 bi->desc, adapter->params.chip_revision,
1183 adapter->params.pci.is_pcix ? "PCIX" : "PCI",
1184 adapter->params.pci.speed, adapter->params.pci.width);
1185 return 0;
1187 out_release_adapter_res:
1188 t1_free_sw_modules(adapter);
1189 out_free_dev:
1190 if (adapter) {
1191 if (adapter->regs) iounmap(adapter->regs);
1192 for (i = bi->port_number - 1; i >= 0; --i)
1193 if (adapter->port[i].dev) {
1194 cxgb_proc_cleanup(adapter, proc_root_driver);
1195 kfree(adapter->port[i].dev);
1198 pci_release_regions(pdev);
1199 out_disable_pdev:
1200 pci_disable_device(pdev);
1201 pci_set_drvdata(pdev, NULL);
1202 return err;
1205 static inline void t1_sw_reset(struct pci_dev *pdev)
1207 pci_write_config_dword(pdev, A_PCICFG_PM_CSR, 3);
1208 pci_write_config_dword(pdev, A_PCICFG_PM_CSR, 0);
1211 static void __devexit remove_one(struct pci_dev *pdev)
1213 struct net_device *dev = pci_get_drvdata(pdev);
1215 if (dev) {
1216 int i;
1217 struct adapter *adapter = dev->priv;
1219 for_each_port(adapter, i)
1220 if (test_bit(i, &adapter->registered_device_map))
1221 unregister_netdev(adapter->port[i].dev);
1223 t1_free_sw_modules(adapter);
1224 iounmap(adapter->regs);
1225 while (--i >= 0)
1226 if (adapter->port[i].dev) {
1227 cxgb_proc_cleanup(adapter, proc_root_driver);
1228 kfree(adapter->port[i].dev);
1230 pci_release_regions(pdev);
1231 pci_disable_device(pdev);
1232 pci_set_drvdata(pdev, NULL);
1233 t1_sw_reset(pdev);
1237 static struct pci_driver driver = {
1238 .name = DRV_NAME,
1239 .id_table = t1_pci_tbl,
1240 .probe = init_one,
1241 .remove = __devexit_p(remove_one),
1242 };
1244 static int __init t1_init_module(void)
1246 return pci_module_init(&driver);
1249 static void __exit t1_cleanup_module(void)
1251 pci_unregister_driver(&driver);
1254 module_init(t1_init_module);
1255 module_exit(t1_cleanup_module);