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, see <http://www.gnu.org/licenses/>.            *
15  *                                                                           *
16  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED    *
17  * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF      *
18  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.                     *
19  *                                                                           *
20  * http://www.chelsio.com                                                    *
21  *                                                                           *
22  * Copyright (c) 2003 - 2005 Chelsio Communications, Inc.                    *
23  * All rights reserved.                                                      *
24  *                                                                           *
25  * Maintainers: maintainers@chelsio.com                                      *
26  *                                                                           *
27  * Authors: Dimitrios Michailidis   <dm@chelsio.com>                         *
28  *          Tina Yang               <tainay@chelsio.com>                     *
29  *          Felix Marti             <felix@chelsio.com>                      *
30  *          Scott Bardone           <sbardone@chelsio.com>                   *
31  *          Kurt Ottaway            <kottaway@chelsio.com>                   *
32  *          Frank DiMambro          <frank@chelsio.com>                      *
33  *                                                                           *
34  * History:                                                                  *
35  *                                                                           *
36  ****************************************************************************/
37 
38 #include "common.h"
39 #include <linux/module.h>
40 #include <linux/pci.h>
41 #include <linux/netdevice.h>
42 #include <linux/etherdevice.h>
43 #include <linux/if_vlan.h>
44 #include <linux/mii.h>
45 #include <linux/sockios.h>
46 #include <linux/dma-mapping.h>
47 #include <linux/uaccess.h>
48 
49 #include "cpl5_cmd.h"
50 #include "regs.h"
51 #include "gmac.h"
52 #include "cphy.h"
53 #include "sge.h"
54 #include "tp.h"
55 #include "espi.h"
56 #include "elmer0.h"
57 
58 #include <linux/workqueue.h>
59 
60 static inline void schedule_mac_stats_update(struct adapter *ap, int secs)
61 {
62 	schedule_delayed_work(&ap->stats_update_task, secs * HZ);
63 }
64 
65 static inline void cancel_mac_stats_update(struct adapter *ap)
66 {
67 	cancel_delayed_work(&ap->stats_update_task);
68 }
69 
70 #define MAX_CMDQ_ENTRIES	16384
71 #define MAX_CMDQ1_ENTRIES	1024
72 #define MAX_RX_BUFFERS		16384
73 #define MAX_RX_JUMBO_BUFFERS	16384
74 #define MAX_TX_BUFFERS_HIGH	16384U
75 #define MAX_TX_BUFFERS_LOW	1536U
76 #define MAX_TX_BUFFERS		1460U
77 #define MIN_FL_ENTRIES		32
78 
79 #define DFLT_MSG_ENABLE (NETIF_MSG_DRV | NETIF_MSG_PROBE | NETIF_MSG_LINK | \
80 			 NETIF_MSG_TIMER | NETIF_MSG_IFDOWN | NETIF_MSG_IFUP |\
81 			 NETIF_MSG_RX_ERR | NETIF_MSG_TX_ERR)
82 
83 /*
84  * The EEPROM is actually bigger but only the first few bytes are used so we
85  * only report those.
86  */
87 #define EEPROM_SIZE 32
88 
89 MODULE_DESCRIPTION(DRV_DESCRIPTION);
90 MODULE_AUTHOR("Chelsio Communications");
91 MODULE_LICENSE("GPL");
92 
93 static int dflt_msg_enable = DFLT_MSG_ENABLE;
94 
95 module_param(dflt_msg_enable, int, 0);
96 MODULE_PARM_DESC(dflt_msg_enable, "Chelsio T1 default message enable bitmap");
97 
98 #define HCLOCK 0x0
99 #define LCLOCK 0x1
100 
101 /* T1 cards powersave mode */
102 static int t1_clock(struct adapter *adapter, int mode);
103 static int t1powersave = 1;	/* HW default is powersave mode. */
104 
105 module_param(t1powersave, int, 0);
106 MODULE_PARM_DESC(t1powersave, "Enable/Disable T1 powersaving mode");
107 
108 static int disable_msi = 0;
109 module_param(disable_msi, int, 0);
110 MODULE_PARM_DESC(disable_msi, "Disable Message Signaled Interrupt (MSI)");
111 
112 /*
113  * Setup MAC to receive the types of packets we want.
114  */
115 static void t1_set_rxmode(struct net_device *dev)
116 {
117 	struct adapter *adapter = dev->ml_priv;
118 	struct cmac *mac = adapter->port[dev->if_port].mac;
119 	struct t1_rx_mode rm;
120 
121 	rm.dev = dev;
122 	mac->ops->set_rx_mode(mac, &rm);
123 }
124 
125 static void link_report(struct port_info *p)
126 {
127 	if (!netif_carrier_ok(p->dev))
128 		netdev_info(p->dev, "link down\n");
129 	else {
130 		const char *s = "10Mbps";
131 
132 		switch (p->link_config.speed) {
133 			case SPEED_10000: s = "10Gbps"; break;
134 			case SPEED_1000:  s = "1000Mbps"; break;
135 			case SPEED_100:   s = "100Mbps"; break;
136 		}
137 
138 		netdev_info(p->dev, "link up, %s, %s-duplex\n",
139 			    s, p->link_config.duplex == DUPLEX_FULL
140 			    ? "full" : "half");
141 	}
142 }
143 
144 void t1_link_negotiated(struct adapter *adapter, int port_id, int link_stat,
145 			int speed, int duplex, int pause)
146 {
147 	struct port_info *p = &adapter->port[port_id];
148 
149 	if (link_stat != netif_carrier_ok(p->dev)) {
150 		if (link_stat)
151 			netif_carrier_on(p->dev);
152 		else
153 			netif_carrier_off(p->dev);
154 		link_report(p);
155 
156 		/* multi-ports: inform toe */
157 		if ((speed > 0) && (adapter->params.nports > 1)) {
158 			unsigned int sched_speed = 10;
159 			switch (speed) {
160 			case SPEED_1000:
161 				sched_speed = 1000;
162 				break;
163 			case SPEED_100:
164 				sched_speed = 100;
165 				break;
166 			case SPEED_10:
167 				sched_speed = 10;
168 				break;
169 			}
170 			t1_sched_update_parms(adapter->sge, port_id, 0, sched_speed);
171 		}
172 	}
173 }
174 
175 static void link_start(struct port_info *p)
176 {
177 	struct cmac *mac = p->mac;
178 
179 	mac->ops->reset(mac);
180 	if (mac->ops->macaddress_set)
181 		mac->ops->macaddress_set(mac, p->dev->dev_addr);
182 	t1_set_rxmode(p->dev);
183 	t1_link_start(p->phy, mac, &p->link_config);
184 	mac->ops->enable(mac, MAC_DIRECTION_RX | MAC_DIRECTION_TX);
185 }
186 
187 static void enable_hw_csum(struct adapter *adapter)
188 {
189 	if (adapter->port[0].dev->hw_features & NETIF_F_TSO)
190 		t1_tp_set_ip_checksum_offload(adapter->tp, 1);	/* for TSO only */
191 	t1_tp_set_tcp_checksum_offload(adapter->tp, 1);
192 }
193 
194 /*
195  * Things to do upon first use of a card.
196  * This must run with the rtnl lock held.
197  */
198 static int cxgb_up(struct adapter *adapter)
199 {
200 	int err = 0;
201 
202 	if (!(adapter->flags & FULL_INIT_DONE)) {
203 		err = t1_init_hw_modules(adapter);
204 		if (err)
205 			goto out_err;
206 
207 		enable_hw_csum(adapter);
208 		adapter->flags |= FULL_INIT_DONE;
209 	}
210 
211 	t1_interrupts_clear(adapter);
212 
213 	adapter->params.has_msi = !disable_msi && !pci_enable_msi(adapter->pdev);
214 	err = request_irq(adapter->pdev->irq, t1_interrupt,
215 			  adapter->params.has_msi ? 0 : IRQF_SHARED,
216 			  adapter->name, adapter);
217 	if (err) {
218 		if (adapter->params.has_msi)
219 			pci_disable_msi(adapter->pdev);
220 
221 		goto out_err;
222 	}
223 
224 	t1_sge_start(adapter->sge);
225 	t1_interrupts_enable(adapter);
226 out_err:
227 	return err;
228 }
229 
230 /*
231  * Release resources when all the ports have been stopped.
232  */
233 static void cxgb_down(struct adapter *adapter)
234 {
235 	t1_sge_stop(adapter->sge);
236 	t1_interrupts_disable(adapter);
237 	free_irq(adapter->pdev->irq, adapter);
238 	if (adapter->params.has_msi)
239 		pci_disable_msi(adapter->pdev);
240 }
241 
242 static int cxgb_open(struct net_device *dev)
243 {
244 	int err;
245 	struct adapter *adapter = dev->ml_priv;
246 	int other_ports = adapter->open_device_map & PORT_MASK;
247 
248 	napi_enable(&adapter->napi);
249 	if (!adapter->open_device_map && (err = cxgb_up(adapter)) < 0) {
250 		napi_disable(&adapter->napi);
251 		return err;
252 	}
253 
254 	__set_bit(dev->if_port, &adapter->open_device_map);
255 	link_start(&adapter->port[dev->if_port]);
256 	netif_start_queue(dev);
257 	if (!other_ports && adapter->params.stats_update_period)
258 		schedule_mac_stats_update(adapter,
259 					  adapter->params.stats_update_period);
260 
261 	t1_vlan_mode(adapter, dev->features);
262 	return 0;
263 }
264 
265 static int cxgb_close(struct net_device *dev)
266 {
267 	struct adapter *adapter = dev->ml_priv;
268 	struct port_info *p = &adapter->port[dev->if_port];
269 	struct cmac *mac = p->mac;
270 
271 	netif_stop_queue(dev);
272 	napi_disable(&adapter->napi);
273 	mac->ops->disable(mac, MAC_DIRECTION_TX | MAC_DIRECTION_RX);
274 	netif_carrier_off(dev);
275 
276 	clear_bit(dev->if_port, &adapter->open_device_map);
277 	if (adapter->params.stats_update_period &&
278 	    !(adapter->open_device_map & PORT_MASK)) {
279 		/* Stop statistics accumulation. */
280 		smp_mb__after_atomic();
281 		spin_lock(&adapter->work_lock);   /* sync with update task */
282 		spin_unlock(&adapter->work_lock);
283 		cancel_mac_stats_update(adapter);
284 	}
285 
286 	if (!adapter->open_device_map)
287 		cxgb_down(adapter);
288 	return 0;
289 }
290 
291 static struct net_device_stats *t1_get_stats(struct net_device *dev)
292 {
293 	struct adapter *adapter = dev->ml_priv;
294 	struct port_info *p = &adapter->port[dev->if_port];
295 	struct net_device_stats *ns = &dev->stats;
296 	const struct cmac_statistics *pstats;
297 
298 	/* Do a full update of the MAC stats */
299 	pstats = p->mac->ops->statistics_update(p->mac,
300 						MAC_STATS_UPDATE_FULL);
301 
302 	ns->tx_packets = pstats->TxUnicastFramesOK +
303 		pstats->TxMulticastFramesOK + pstats->TxBroadcastFramesOK;
304 
305 	ns->rx_packets = pstats->RxUnicastFramesOK +
306 		pstats->RxMulticastFramesOK + pstats->RxBroadcastFramesOK;
307 
308 	ns->tx_bytes = pstats->TxOctetsOK;
309 	ns->rx_bytes = pstats->RxOctetsOK;
310 
311 	ns->tx_errors = pstats->TxLateCollisions + pstats->TxLengthErrors +
312 		pstats->TxUnderrun + pstats->TxFramesAbortedDueToXSCollisions;
313 	ns->rx_errors = pstats->RxDataErrors + pstats->RxJabberErrors +
314 		pstats->RxFCSErrors + pstats->RxAlignErrors +
315 		pstats->RxSequenceErrors + pstats->RxFrameTooLongErrors +
316 		pstats->RxSymbolErrors + pstats->RxRuntErrors;
317 
318 	ns->multicast  = pstats->RxMulticastFramesOK;
319 	ns->collisions = pstats->TxTotalCollisions;
320 
321 	/* detailed rx_errors */
322 	ns->rx_length_errors = pstats->RxFrameTooLongErrors +
323 		pstats->RxJabberErrors;
324 	ns->rx_over_errors   = 0;
325 	ns->rx_crc_errors    = pstats->RxFCSErrors;
326 	ns->rx_frame_errors  = pstats->RxAlignErrors;
327 	ns->rx_fifo_errors   = 0;
328 	ns->rx_missed_errors = 0;
329 
330 	/* detailed tx_errors */
331 	ns->tx_aborted_errors   = pstats->TxFramesAbortedDueToXSCollisions;
332 	ns->tx_carrier_errors   = 0;
333 	ns->tx_fifo_errors      = pstats->TxUnderrun;
334 	ns->tx_heartbeat_errors = 0;
335 	ns->tx_window_errors    = pstats->TxLateCollisions;
336 	return ns;
337 }
338 
339 static u32 get_msglevel(struct net_device *dev)
340 {
341 	struct adapter *adapter = dev->ml_priv;
342 
343 	return adapter->msg_enable;
344 }
345 
346 static void set_msglevel(struct net_device *dev, u32 val)
347 {
348 	struct adapter *adapter = dev->ml_priv;
349 
350 	adapter->msg_enable = val;
351 }
352 
353 static const char stats_strings[][ETH_GSTRING_LEN] = {
354 	"TxOctetsOK",
355 	"TxOctetsBad",
356 	"TxUnicastFramesOK",
357 	"TxMulticastFramesOK",
358 	"TxBroadcastFramesOK",
359 	"TxPauseFrames",
360 	"TxFramesWithDeferredXmissions",
361 	"TxLateCollisions",
362 	"TxTotalCollisions",
363 	"TxFramesAbortedDueToXSCollisions",
364 	"TxUnderrun",
365 	"TxLengthErrors",
366 	"TxInternalMACXmitError",
367 	"TxFramesWithExcessiveDeferral",
368 	"TxFCSErrors",
369 	"TxJumboFramesOk",
370 	"TxJumboOctetsOk",
371 
372 	"RxOctetsOK",
373 	"RxOctetsBad",
374 	"RxUnicastFramesOK",
375 	"RxMulticastFramesOK",
376 	"RxBroadcastFramesOK",
377 	"RxPauseFrames",
378 	"RxFCSErrors",
379 	"RxAlignErrors",
380 	"RxSymbolErrors",
381 	"RxDataErrors",
382 	"RxSequenceErrors",
383 	"RxRuntErrors",
384 	"RxJabberErrors",
385 	"RxInternalMACRcvError",
386 	"RxInRangeLengthErrors",
387 	"RxOutOfRangeLengthField",
388 	"RxFrameTooLongErrors",
389 	"RxJumboFramesOk",
390 	"RxJumboOctetsOk",
391 
392 	/* Port stats */
393 	"RxCsumGood",
394 	"TxCsumOffload",
395 	"TxTso",
396 	"RxVlan",
397 	"TxVlan",
398 	"TxNeedHeadroom",
399 
400 	/* Interrupt stats */
401 	"rx drops",
402 	"pure_rsps",
403 	"unhandled irqs",
404 	"respQ_empty",
405 	"respQ_overflow",
406 	"freelistQ_empty",
407 	"pkt_too_big",
408 	"pkt_mismatch",
409 	"cmdQ_full0",
410 	"cmdQ_full1",
411 
412 	"espi_DIP2ParityErr",
413 	"espi_DIP4Err",
414 	"espi_RxDrops",
415 	"espi_TxDrops",
416 	"espi_RxOvfl",
417 	"espi_ParityErr"
418 };
419 
420 #define T2_REGMAP_SIZE (3 * 1024)
421 
422 static int get_regs_len(struct net_device *dev)
423 {
424 	return T2_REGMAP_SIZE;
425 }
426 
427 static void get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
428 {
429 	struct adapter *adapter = dev->ml_priv;
430 
431 	strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
432 	strlcpy(info->bus_info, pci_name(adapter->pdev),
433 		sizeof(info->bus_info));
434 }
435 
436 static int get_sset_count(struct net_device *dev, int sset)
437 {
438 	switch (sset) {
439 	case ETH_SS_STATS:
440 		return ARRAY_SIZE(stats_strings);
441 	default:
442 		return -EOPNOTSUPP;
443 	}
444 }
445 
446 static void get_strings(struct net_device *dev, u32 stringset, u8 *data)
447 {
448 	if (stringset == ETH_SS_STATS)
449 		memcpy(data, stats_strings, sizeof(stats_strings));
450 }
451 
452 static void get_stats(struct net_device *dev, struct ethtool_stats *stats,
453 		      u64 *data)
454 {
455 	struct adapter *adapter = dev->ml_priv;
456 	struct cmac *mac = adapter->port[dev->if_port].mac;
457 	const struct cmac_statistics *s;
458 	const struct sge_intr_counts *t;
459 	struct sge_port_stats ss;
460 
461 	s = mac->ops->statistics_update(mac, MAC_STATS_UPDATE_FULL);
462 	t = t1_sge_get_intr_counts(adapter->sge);
463 	t1_sge_get_port_stats(adapter->sge, dev->if_port, &ss);
464 
465 	*data++ = s->TxOctetsOK;
466 	*data++ = s->TxOctetsBad;
467 	*data++ = s->TxUnicastFramesOK;
468 	*data++ = s->TxMulticastFramesOK;
469 	*data++ = s->TxBroadcastFramesOK;
470 	*data++ = s->TxPauseFrames;
471 	*data++ = s->TxFramesWithDeferredXmissions;
472 	*data++ = s->TxLateCollisions;
473 	*data++ = s->TxTotalCollisions;
474 	*data++ = s->TxFramesAbortedDueToXSCollisions;
475 	*data++ = s->TxUnderrun;
476 	*data++ = s->TxLengthErrors;
477 	*data++ = s->TxInternalMACXmitError;
478 	*data++ = s->TxFramesWithExcessiveDeferral;
479 	*data++ = s->TxFCSErrors;
480 	*data++ = s->TxJumboFramesOK;
481 	*data++ = s->TxJumboOctetsOK;
482 
483 	*data++ = s->RxOctetsOK;
484 	*data++ = s->RxOctetsBad;
485 	*data++ = s->RxUnicastFramesOK;
486 	*data++ = s->RxMulticastFramesOK;
487 	*data++ = s->RxBroadcastFramesOK;
488 	*data++ = s->RxPauseFrames;
489 	*data++ = s->RxFCSErrors;
490 	*data++ = s->RxAlignErrors;
491 	*data++ = s->RxSymbolErrors;
492 	*data++ = s->RxDataErrors;
493 	*data++ = s->RxSequenceErrors;
494 	*data++ = s->RxRuntErrors;
495 	*data++ = s->RxJabberErrors;
496 	*data++ = s->RxInternalMACRcvError;
497 	*data++ = s->RxInRangeLengthErrors;
498 	*data++ = s->RxOutOfRangeLengthField;
499 	*data++ = s->RxFrameTooLongErrors;
500 	*data++ = s->RxJumboFramesOK;
501 	*data++ = s->RxJumboOctetsOK;
502 
503 	*data++ = ss.rx_cso_good;
504 	*data++ = ss.tx_cso;
505 	*data++ = ss.tx_tso;
506 	*data++ = ss.vlan_xtract;
507 	*data++ = ss.vlan_insert;
508 	*data++ = ss.tx_need_hdrroom;
509 
510 	*data++ = t->rx_drops;
511 	*data++ = t->pure_rsps;
512 	*data++ = t->unhandled_irqs;
513 	*data++ = t->respQ_empty;
514 	*data++ = t->respQ_overflow;
515 	*data++ = t->freelistQ_empty;
516 	*data++ = t->pkt_too_big;
517 	*data++ = t->pkt_mismatch;
518 	*data++ = t->cmdQ_full[0];
519 	*data++ = t->cmdQ_full[1];
520 
521 	if (adapter->espi) {
522 		const struct espi_intr_counts *e;
523 
524 		e = t1_espi_get_intr_counts(adapter->espi);
525 		*data++ = e->DIP2_parity_err;
526 		*data++ = e->DIP4_err;
527 		*data++ = e->rx_drops;
528 		*data++ = e->tx_drops;
529 		*data++ = e->rx_ovflw;
530 		*data++ = e->parity_err;
531 	}
532 }
533 
534 static inline void reg_block_dump(struct adapter *ap, void *buf,
535 				  unsigned int start, unsigned int end)
536 {
537 	u32 *p = buf + start;
538 
539 	for ( ; start <= end; start += sizeof(u32))
540 		*p++ = readl(ap->regs + start);
541 }
542 
543 static void get_regs(struct net_device *dev, struct ethtool_regs *regs,
544 		     void *buf)
545 {
546 	struct adapter *ap = dev->ml_priv;
547 
548 	/*
549 	 * Version scheme: bits 0..9: chip version, bits 10..15: chip revision
550 	 */
551 	regs->version = 2;
552 
553 	memset(buf, 0, T2_REGMAP_SIZE);
554 	reg_block_dump(ap, buf, 0, A_SG_RESPACCUTIMER);
555 	reg_block_dump(ap, buf, A_MC3_CFG, A_MC4_INT_CAUSE);
556 	reg_block_dump(ap, buf, A_TPI_ADDR, A_TPI_PAR);
557 	reg_block_dump(ap, buf, A_TP_IN_CONFIG, A_TP_TX_DROP_COUNT);
558 	reg_block_dump(ap, buf, A_RAT_ROUTE_CONTROL, A_RAT_INTR_CAUSE);
559 	reg_block_dump(ap, buf, A_CSPI_RX_AE_WM, A_CSPI_INTR_ENABLE);
560 	reg_block_dump(ap, buf, A_ESPI_SCH_TOKEN0, A_ESPI_GOSTAT);
561 	reg_block_dump(ap, buf, A_ULP_ULIMIT, A_ULP_PIO_CTRL);
562 	reg_block_dump(ap, buf, A_PL_ENABLE, A_PL_CAUSE);
563 	reg_block_dump(ap, buf, A_MC5_CONFIG, A_MC5_MASK_WRITE_CMD);
564 }
565 
566 static int get_link_ksettings(struct net_device *dev,
567 			      struct ethtool_link_ksettings *cmd)
568 {
569 	struct adapter *adapter = dev->ml_priv;
570 	struct port_info *p = &adapter->port[dev->if_port];
571 	u32 supported, advertising;
572 
573 	supported = p->link_config.supported;
574 	advertising = p->link_config.advertising;
575 
576 	if (netif_carrier_ok(dev)) {
577 		cmd->base.speed = p->link_config.speed;
578 		cmd->base.duplex = p->link_config.duplex;
579 	} else {
580 		cmd->base.speed = SPEED_UNKNOWN;
581 		cmd->base.duplex = DUPLEX_UNKNOWN;
582 	}
583 
584 	cmd->base.port = (supported & SUPPORTED_TP) ? PORT_TP : PORT_FIBRE;
585 	cmd->base.phy_address = p->phy->mdio.prtad;
586 	cmd->base.autoneg = p->link_config.autoneg;
587 
588 	ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.supported,
589 						supported);
590 	ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.advertising,
591 						advertising);
592 
593 	return 0;
594 }
595 
596 static int speed_duplex_to_caps(int speed, int duplex)
597 {
598 	int cap = 0;
599 
600 	switch (speed) {
601 	case SPEED_10:
602 		if (duplex == DUPLEX_FULL)
603 			cap = SUPPORTED_10baseT_Full;
604 		else
605 			cap = SUPPORTED_10baseT_Half;
606 		break;
607 	case SPEED_100:
608 		if (duplex == DUPLEX_FULL)
609 			cap = SUPPORTED_100baseT_Full;
610 		else
611 			cap = SUPPORTED_100baseT_Half;
612 		break;
613 	case SPEED_1000:
614 		if (duplex == DUPLEX_FULL)
615 			cap = SUPPORTED_1000baseT_Full;
616 		else
617 			cap = SUPPORTED_1000baseT_Half;
618 		break;
619 	case SPEED_10000:
620 		if (duplex == DUPLEX_FULL)
621 			cap = SUPPORTED_10000baseT_Full;
622 	}
623 	return cap;
624 }
625 
626 #define ADVERTISED_MASK (ADVERTISED_10baseT_Half | ADVERTISED_10baseT_Full | \
627 		      ADVERTISED_100baseT_Half | ADVERTISED_100baseT_Full | \
628 		      ADVERTISED_1000baseT_Half | ADVERTISED_1000baseT_Full | \
629 		      ADVERTISED_10000baseT_Full)
630 
631 static int set_link_ksettings(struct net_device *dev,
632 			      const struct ethtool_link_ksettings *cmd)
633 {
634 	struct adapter *adapter = dev->ml_priv;
635 	struct port_info *p = &adapter->port[dev->if_port];
636 	struct link_config *lc = &p->link_config;
637 	u32 advertising;
638 
639 	ethtool_convert_link_mode_to_legacy_u32(&advertising,
640 						cmd->link_modes.advertising);
641 
642 	if (!(lc->supported & SUPPORTED_Autoneg))
643 		return -EOPNOTSUPP;             /* can't change speed/duplex */
644 
645 	if (cmd->base.autoneg == AUTONEG_DISABLE) {
646 		u32 speed = cmd->base.speed;
647 		int cap = speed_duplex_to_caps(speed, cmd->base.duplex);
648 
649 		if (!(lc->supported & cap) || (speed == SPEED_1000))
650 			return -EINVAL;
651 		lc->requested_speed = speed;
652 		lc->requested_duplex = cmd->base.duplex;
653 		lc->advertising = 0;
654 	} else {
655 		advertising &= ADVERTISED_MASK;
656 		if (advertising & (advertising - 1))
657 			advertising = lc->supported;
658 		advertising &= lc->supported;
659 		if (!advertising)
660 			return -EINVAL;
661 		lc->requested_speed = SPEED_INVALID;
662 		lc->requested_duplex = DUPLEX_INVALID;
663 		lc->advertising = advertising | ADVERTISED_Autoneg;
664 	}
665 	lc->autoneg = cmd->base.autoneg;
666 	if (netif_running(dev))
667 		t1_link_start(p->phy, p->mac, lc);
668 	return 0;
669 }
670 
671 static void get_pauseparam(struct net_device *dev,
672 			   struct ethtool_pauseparam *epause)
673 {
674 	struct adapter *adapter = dev->ml_priv;
675 	struct port_info *p = &adapter->port[dev->if_port];
676 
677 	epause->autoneg = (p->link_config.requested_fc & PAUSE_AUTONEG) != 0;
678 	epause->rx_pause = (p->link_config.fc & PAUSE_RX) != 0;
679 	epause->tx_pause = (p->link_config.fc & PAUSE_TX) != 0;
680 }
681 
682 static int set_pauseparam(struct net_device *dev,
683 			  struct ethtool_pauseparam *epause)
684 {
685 	struct adapter *adapter = dev->ml_priv;
686 	struct port_info *p = &adapter->port[dev->if_port];
687 	struct link_config *lc = &p->link_config;
688 
689 	if (epause->autoneg == AUTONEG_DISABLE)
690 		lc->requested_fc = 0;
691 	else if (lc->supported & SUPPORTED_Autoneg)
692 		lc->requested_fc = PAUSE_AUTONEG;
693 	else
694 		return -EINVAL;
695 
696 	if (epause->rx_pause)
697 		lc->requested_fc |= PAUSE_RX;
698 	if (epause->tx_pause)
699 		lc->requested_fc |= PAUSE_TX;
700 	if (lc->autoneg == AUTONEG_ENABLE) {
701 		if (netif_running(dev))
702 			t1_link_start(p->phy, p->mac, lc);
703 	} else {
704 		lc->fc = lc->requested_fc & (PAUSE_RX | PAUSE_TX);
705 		if (netif_running(dev))
706 			p->mac->ops->set_speed_duplex_fc(p->mac, -1, -1,
707 							 lc->fc);
708 	}
709 	return 0;
710 }
711 
712 static void get_sge_param(struct net_device *dev, struct ethtool_ringparam *e)
713 {
714 	struct adapter *adapter = dev->ml_priv;
715 	int jumbo_fl = t1_is_T1B(adapter) ? 1 : 0;
716 
717 	e->rx_max_pending = MAX_RX_BUFFERS;
718 	e->rx_jumbo_max_pending = MAX_RX_JUMBO_BUFFERS;
719 	e->tx_max_pending = MAX_CMDQ_ENTRIES;
720 
721 	e->rx_pending = adapter->params.sge.freelQ_size[!jumbo_fl];
722 	e->rx_jumbo_pending = adapter->params.sge.freelQ_size[jumbo_fl];
723 	e->tx_pending = adapter->params.sge.cmdQ_size[0];
724 }
725 
726 static int set_sge_param(struct net_device *dev, struct ethtool_ringparam *e)
727 {
728 	struct adapter *adapter = dev->ml_priv;
729 	int jumbo_fl = t1_is_T1B(adapter) ? 1 : 0;
730 
731 	if (e->rx_pending > MAX_RX_BUFFERS || e->rx_mini_pending ||
732 	    e->rx_jumbo_pending > MAX_RX_JUMBO_BUFFERS ||
733 	    e->tx_pending > MAX_CMDQ_ENTRIES ||
734 	    e->rx_pending < MIN_FL_ENTRIES ||
735 	    e->rx_jumbo_pending < MIN_FL_ENTRIES ||
736 	    e->tx_pending < (adapter->params.nports + 1) * (MAX_SKB_FRAGS + 1))
737 		return -EINVAL;
738 
739 	if (adapter->flags & FULL_INIT_DONE)
740 		return -EBUSY;
741 
742 	adapter->params.sge.freelQ_size[!jumbo_fl] = e->rx_pending;
743 	adapter->params.sge.freelQ_size[jumbo_fl] = e->rx_jumbo_pending;
744 	adapter->params.sge.cmdQ_size[0] = e->tx_pending;
745 	adapter->params.sge.cmdQ_size[1] = e->tx_pending > MAX_CMDQ1_ENTRIES ?
746 		MAX_CMDQ1_ENTRIES : e->tx_pending;
747 	return 0;
748 }
749 
750 static int set_coalesce(struct net_device *dev, struct ethtool_coalesce *c)
751 {
752 	struct adapter *adapter = dev->ml_priv;
753 
754 	adapter->params.sge.rx_coalesce_usecs = c->rx_coalesce_usecs;
755 	adapter->params.sge.coalesce_enable = c->use_adaptive_rx_coalesce;
756 	adapter->params.sge.sample_interval_usecs = c->rate_sample_interval;
757 	t1_sge_set_coalesce_params(adapter->sge, &adapter->params.sge);
758 	return 0;
759 }
760 
761 static int get_coalesce(struct net_device *dev, struct ethtool_coalesce *c)
762 {
763 	struct adapter *adapter = dev->ml_priv;
764 
765 	c->rx_coalesce_usecs = adapter->params.sge.rx_coalesce_usecs;
766 	c->rate_sample_interval = adapter->params.sge.sample_interval_usecs;
767 	c->use_adaptive_rx_coalesce = adapter->params.sge.coalesce_enable;
768 	return 0;
769 }
770 
771 static int get_eeprom_len(struct net_device *dev)
772 {
773 	struct adapter *adapter = dev->ml_priv;
774 
775 	return t1_is_asic(adapter) ? EEPROM_SIZE : 0;
776 }
777 
778 #define EEPROM_MAGIC(ap) \
779 	(PCI_VENDOR_ID_CHELSIO | ((ap)->params.chip_version << 16))
780 
781 static int get_eeprom(struct net_device *dev, struct ethtool_eeprom *e,
782 		      u8 *data)
783 {
784 	int i;
785 	u8 buf[EEPROM_SIZE] __attribute__((aligned(4)));
786 	struct adapter *adapter = dev->ml_priv;
787 
788 	e->magic = EEPROM_MAGIC(adapter);
789 	for (i = e->offset & ~3; i < e->offset + e->len; i += sizeof(u32))
790 		t1_seeprom_read(adapter, i, (__le32 *)&buf[i]);
791 	memcpy(data, buf + e->offset, e->len);
792 	return 0;
793 }
794 
795 static const struct ethtool_ops t1_ethtool_ops = {
796 	.supported_coalesce_params = ETHTOOL_COALESCE_RX_USECS |
797 				     ETHTOOL_COALESCE_USE_ADAPTIVE_RX |
798 				     ETHTOOL_COALESCE_RATE_SAMPLE_INTERVAL,
799 	.get_drvinfo       = get_drvinfo,
800 	.get_msglevel      = get_msglevel,
801 	.set_msglevel      = set_msglevel,
802 	.get_ringparam     = get_sge_param,
803 	.set_ringparam     = set_sge_param,
804 	.get_coalesce      = get_coalesce,
805 	.set_coalesce      = set_coalesce,
806 	.get_eeprom_len    = get_eeprom_len,
807 	.get_eeprom        = get_eeprom,
808 	.get_pauseparam    = get_pauseparam,
809 	.set_pauseparam    = set_pauseparam,
810 	.get_link          = ethtool_op_get_link,
811 	.get_strings       = get_strings,
812 	.get_sset_count	   = get_sset_count,
813 	.get_ethtool_stats = get_stats,
814 	.get_regs_len      = get_regs_len,
815 	.get_regs          = get_regs,
816 	.get_link_ksettings = get_link_ksettings,
817 	.set_link_ksettings = set_link_ksettings,
818 };
819 
820 static int t1_ioctl(struct net_device *dev, struct ifreq *req, int cmd)
821 {
822 	struct adapter *adapter = dev->ml_priv;
823 	struct mdio_if_info *mdio = &adapter->port[dev->if_port].phy->mdio;
824 
825 	return mdio_mii_ioctl(mdio, if_mii(req), cmd);
826 }
827 
828 static int t1_change_mtu(struct net_device *dev, int new_mtu)
829 {
830 	int ret;
831 	struct adapter *adapter = dev->ml_priv;
832 	struct cmac *mac = adapter->port[dev->if_port].mac;
833 
834 	if (!mac->ops->set_mtu)
835 		return -EOPNOTSUPP;
836 	if ((ret = mac->ops->set_mtu(mac, new_mtu)))
837 		return ret;
838 	dev->mtu = new_mtu;
839 	return 0;
840 }
841 
842 static int t1_set_mac_addr(struct net_device *dev, void *p)
843 {
844 	struct adapter *adapter = dev->ml_priv;
845 	struct cmac *mac = adapter->port[dev->if_port].mac;
846 	struct sockaddr *addr = p;
847 
848 	if (!mac->ops->macaddress_set)
849 		return -EOPNOTSUPP;
850 
851 	memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
852 	mac->ops->macaddress_set(mac, dev->dev_addr);
853 	return 0;
854 }
855 
856 static netdev_features_t t1_fix_features(struct net_device *dev,
857 	netdev_features_t features)
858 {
859 	/*
860 	 * Since there is no support for separate rx/tx vlan accel
861 	 * enable/disable make sure tx flag is always in same state as rx.
862 	 */
863 	if (features & NETIF_F_HW_VLAN_CTAG_RX)
864 		features |= NETIF_F_HW_VLAN_CTAG_TX;
865 	else
866 		features &= ~NETIF_F_HW_VLAN_CTAG_TX;
867 
868 	return features;
869 }
870 
871 static int t1_set_features(struct net_device *dev, netdev_features_t features)
872 {
873 	netdev_features_t changed = dev->features ^ features;
874 	struct adapter *adapter = dev->ml_priv;
875 
876 	if (changed & NETIF_F_HW_VLAN_CTAG_RX)
877 		t1_vlan_mode(adapter, features);
878 
879 	return 0;
880 }
881 #ifdef CONFIG_NET_POLL_CONTROLLER
882 static void t1_netpoll(struct net_device *dev)
883 {
884 	unsigned long flags;
885 	struct adapter *adapter = dev->ml_priv;
886 
887 	local_irq_save(flags);
888 	t1_interrupt(adapter->pdev->irq, adapter);
889 	local_irq_restore(flags);
890 }
891 #endif
892 
893 /*
894  * Periodic accumulation of MAC statistics.  This is used only if the MAC
895  * does not have any other way to prevent stats counter overflow.
896  */
897 static void mac_stats_task(struct work_struct *work)
898 {
899 	int i;
900 	struct adapter *adapter =
901 		container_of(work, struct adapter, stats_update_task.work);
902 
903 	for_each_port(adapter, i) {
904 		struct port_info *p = &adapter->port[i];
905 
906 		if (netif_running(p->dev))
907 			p->mac->ops->statistics_update(p->mac,
908 						       MAC_STATS_UPDATE_FAST);
909 	}
910 
911 	/* Schedule the next statistics update if any port is active. */
912 	spin_lock(&adapter->work_lock);
913 	if (adapter->open_device_map & PORT_MASK)
914 		schedule_mac_stats_update(adapter,
915 					  adapter->params.stats_update_period);
916 	spin_unlock(&adapter->work_lock);
917 }
918 
919 /*
920  * Processes elmer0 external interrupts in process context.
921  */
922 static void ext_intr_task(struct work_struct *work)
923 {
924 	struct adapter *adapter =
925 		container_of(work, struct adapter, ext_intr_handler_task);
926 
927 	t1_elmer0_ext_intr_handler(adapter);
928 
929 	/* Now reenable external interrupts */
930 	spin_lock_irq(&adapter->async_lock);
931 	adapter->slow_intr_mask |= F_PL_INTR_EXT;
932 	writel(F_PL_INTR_EXT, adapter->regs + A_PL_CAUSE);
933 	writel(adapter->slow_intr_mask | F_PL_INTR_SGE_DATA,
934 		   adapter->regs + A_PL_ENABLE);
935 	spin_unlock_irq(&adapter->async_lock);
936 }
937 
938 /*
939  * Interrupt-context handler for elmer0 external interrupts.
940  */
941 void t1_elmer0_ext_intr(struct adapter *adapter)
942 {
943 	/*
944 	 * Schedule a task to handle external interrupts as we require
945 	 * a process context.  We disable EXT interrupts in the interim
946 	 * and let the task reenable them when it's done.
947 	 */
948 	adapter->slow_intr_mask &= ~F_PL_INTR_EXT;
949 	writel(adapter->slow_intr_mask | F_PL_INTR_SGE_DATA,
950 		   adapter->regs + A_PL_ENABLE);
951 	schedule_work(&adapter->ext_intr_handler_task);
952 }
953 
954 void t1_fatal_err(struct adapter *adapter)
955 {
956 	if (adapter->flags & FULL_INIT_DONE) {
957 		t1_sge_stop(adapter->sge);
958 		t1_interrupts_disable(adapter);
959 	}
960 	pr_alert("%s: encountered fatal error, operation suspended\n",
961 		 adapter->name);
962 }
963 
964 static const struct net_device_ops cxgb_netdev_ops = {
965 	.ndo_open		= cxgb_open,
966 	.ndo_stop		= cxgb_close,
967 	.ndo_start_xmit		= t1_start_xmit,
968 	.ndo_get_stats		= t1_get_stats,
969 	.ndo_validate_addr	= eth_validate_addr,
970 	.ndo_set_rx_mode	= t1_set_rxmode,
971 	.ndo_do_ioctl		= t1_ioctl,
972 	.ndo_change_mtu		= t1_change_mtu,
973 	.ndo_set_mac_address	= t1_set_mac_addr,
974 	.ndo_fix_features	= t1_fix_features,
975 	.ndo_set_features	= t1_set_features,
976 #ifdef CONFIG_NET_POLL_CONTROLLER
977 	.ndo_poll_controller	= t1_netpoll,
978 #endif
979 };
980 
981 static int init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
982 {
983 	int i, err, pci_using_dac = 0;
984 	unsigned long mmio_start, mmio_len;
985 	const struct board_info *bi;
986 	struct adapter *adapter = NULL;
987 	struct port_info *pi;
988 
989 	err = pci_enable_device(pdev);
990 	if (err)
991 		return err;
992 
993 	if (!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM)) {
994 		pr_err("%s: cannot find PCI device memory base address\n",
995 		       pci_name(pdev));
996 		err = -ENODEV;
997 		goto out_disable_pdev;
998 	}
999 
1000 	if (!dma_set_mask(&pdev->dev, DMA_BIT_MASK(64))) {
1001 		pci_using_dac = 1;
1002 
1003 		if (dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(64))) {
1004 			pr_err("%s: unable to obtain 64-bit DMA for coherent allocations\n",
1005 			       pci_name(pdev));
1006 			err = -ENODEV;
1007 			goto out_disable_pdev;
1008 		}
1009 
1010 	} else if ((err = dma_set_mask(&pdev->dev, DMA_BIT_MASK(32))) != 0) {
1011 		pr_err("%s: no usable DMA configuration\n", pci_name(pdev));
1012 		goto out_disable_pdev;
1013 	}
1014 
1015 	err = pci_request_regions(pdev, DRV_NAME);
1016 	if (err) {
1017 		pr_err("%s: cannot obtain PCI resources\n", pci_name(pdev));
1018 		goto out_disable_pdev;
1019 	}
1020 
1021 	pci_set_master(pdev);
1022 
1023 	mmio_start = pci_resource_start(pdev, 0);
1024 	mmio_len = pci_resource_len(pdev, 0);
1025 	bi = t1_get_board_info(ent->driver_data);
1026 
1027 	for (i = 0; i < bi->port_number; ++i) {
1028 		struct net_device *netdev;
1029 
1030 		netdev = alloc_etherdev(adapter ? 0 : sizeof(*adapter));
1031 		if (!netdev) {
1032 			err = -ENOMEM;
1033 			goto out_free_dev;
1034 		}
1035 
1036 		SET_NETDEV_DEV(netdev, &pdev->dev);
1037 
1038 		if (!adapter) {
1039 			adapter = netdev_priv(netdev);
1040 			adapter->pdev = pdev;
1041 			adapter->port[0].dev = netdev;  /* so we don't leak it */
1042 
1043 			adapter->regs = ioremap(mmio_start, mmio_len);
1044 			if (!adapter->regs) {
1045 				pr_err("%s: cannot map device registers\n",
1046 				       pci_name(pdev));
1047 				err = -ENOMEM;
1048 				goto out_free_dev;
1049 			}
1050 
1051 			if (t1_get_board_rev(adapter, bi, &adapter->params)) {
1052 				err = -ENODEV;	  /* Can't handle this chip rev */
1053 				goto out_free_dev;
1054 			}
1055 
1056 			adapter->name = pci_name(pdev);
1057 			adapter->msg_enable = dflt_msg_enable;
1058 			adapter->mmio_len = mmio_len;
1059 
1060 			spin_lock_init(&adapter->tpi_lock);
1061 			spin_lock_init(&adapter->work_lock);
1062 			spin_lock_init(&adapter->async_lock);
1063 			spin_lock_init(&adapter->mac_lock);
1064 
1065 			INIT_WORK(&adapter->ext_intr_handler_task,
1066 				  ext_intr_task);
1067 			INIT_DELAYED_WORK(&adapter->stats_update_task,
1068 					  mac_stats_task);
1069 
1070 			pci_set_drvdata(pdev, netdev);
1071 		}
1072 
1073 		pi = &adapter->port[i];
1074 		pi->dev = netdev;
1075 		netif_carrier_off(netdev);
1076 		netdev->irq = pdev->irq;
1077 		netdev->if_port = i;
1078 		netdev->mem_start = mmio_start;
1079 		netdev->mem_end = mmio_start + mmio_len - 1;
1080 		netdev->ml_priv = adapter;
1081 		netdev->hw_features |= NETIF_F_SG | NETIF_F_IP_CSUM |
1082 			NETIF_F_RXCSUM;
1083 		netdev->features |= NETIF_F_SG | NETIF_F_IP_CSUM |
1084 			NETIF_F_RXCSUM | NETIF_F_LLTX;
1085 
1086 		if (pci_using_dac)
1087 			netdev->features |= NETIF_F_HIGHDMA;
1088 		if (vlan_tso_capable(adapter)) {
1089 			netdev->features |=
1090 				NETIF_F_HW_VLAN_CTAG_TX |
1091 				NETIF_F_HW_VLAN_CTAG_RX;
1092 			netdev->hw_features |= NETIF_F_HW_VLAN_CTAG_RX;
1093 
1094 			/* T204: disable TSO */
1095 			if (!(is_T2(adapter)) || bi->port_number != 4) {
1096 				netdev->hw_features |= NETIF_F_TSO;
1097 				netdev->features |= NETIF_F_TSO;
1098 			}
1099 		}
1100 
1101 		netdev->netdev_ops = &cxgb_netdev_ops;
1102 		netdev->hard_header_len += (netdev->hw_features & NETIF_F_TSO) ?
1103 			sizeof(struct cpl_tx_pkt_lso) : sizeof(struct cpl_tx_pkt);
1104 
1105 		netif_napi_add(netdev, &adapter->napi, t1_poll, 64);
1106 
1107 		netdev->ethtool_ops = &t1_ethtool_ops;
1108 
1109 		switch (bi->board) {
1110 		case CHBT_BOARD_CHT110:
1111 		case CHBT_BOARD_N110:
1112 		case CHBT_BOARD_N210:
1113 		case CHBT_BOARD_CHT210:
1114 			netdev->max_mtu = PM3393_MAX_FRAME_SIZE -
1115 					  (ETH_HLEN + ETH_FCS_LEN);
1116 			break;
1117 		case CHBT_BOARD_CHN204:
1118 			netdev->max_mtu = VSC7326_MAX_MTU;
1119 			break;
1120 		default:
1121 			netdev->max_mtu = ETH_DATA_LEN;
1122 			break;
1123 		}
1124 	}
1125 
1126 	if (t1_init_sw_modules(adapter, bi) < 0) {
1127 		err = -ENODEV;
1128 		goto out_free_dev;
1129 	}
1130 
1131 	/*
1132 	 * The card is now ready to go.  If any errors occur during device
1133 	 * registration we do not fail the whole card but rather proceed only
1134 	 * with the ports we manage to register successfully.  However we must
1135 	 * register at least one net device.
1136 	 */
1137 	for (i = 0; i < bi->port_number; ++i) {
1138 		err = register_netdev(adapter->port[i].dev);
1139 		if (err)
1140 			pr_warn("%s: cannot register net device %s, skipping\n",
1141 				pci_name(pdev), adapter->port[i].dev->name);
1142 		else {
1143 			/*
1144 			 * Change the name we use for messages to the name of
1145 			 * the first successfully registered interface.
1146 			 */
1147 			if (!adapter->registered_device_map)
1148 				adapter->name = adapter->port[i].dev->name;
1149 
1150 			__set_bit(i, &adapter->registered_device_map);
1151 		}
1152 	}
1153 	if (!adapter->registered_device_map) {
1154 		pr_err("%s: could not register any net devices\n",
1155 		       pci_name(pdev));
1156 		goto out_release_adapter_res;
1157 	}
1158 
1159 	pr_info("%s: %s (rev %d), %s %dMHz/%d-bit\n",
1160 		adapter->name, bi->desc, adapter->params.chip_revision,
1161 		adapter->params.pci.is_pcix ? "PCIX" : "PCI",
1162 		adapter->params.pci.speed, adapter->params.pci.width);
1163 
1164 	/*
1165 	 * Set the T1B ASIC and memory clocks.
1166 	 */
1167 	if (t1powersave)
1168 		adapter->t1powersave = LCLOCK;	/* HW default is powersave mode. */
1169 	else
1170 		adapter->t1powersave = HCLOCK;
1171 	if (t1_is_T1B(adapter))
1172 		t1_clock(adapter, t1powersave);
1173 
1174 	return 0;
1175 
1176 out_release_adapter_res:
1177 	t1_free_sw_modules(adapter);
1178 out_free_dev:
1179 	if (adapter) {
1180 		if (adapter->regs)
1181 			iounmap(adapter->regs);
1182 		for (i = bi->port_number - 1; i >= 0; --i)
1183 			if (adapter->port[i].dev)
1184 				free_netdev(adapter->port[i].dev);
1185 	}
1186 	pci_release_regions(pdev);
1187 out_disable_pdev:
1188 	pci_disable_device(pdev);
1189 	return err;
1190 }
1191 
1192 static void bit_bang(struct adapter *adapter, int bitdata, int nbits)
1193 {
1194 	int data;
1195 	int i;
1196 	u32 val;
1197 
1198 	enum {
1199 		S_CLOCK = 1 << 3,
1200 		S_DATA = 1 << 4
1201 	};
1202 
1203 	for (i = (nbits - 1); i > -1; i--) {
1204 
1205 		udelay(50);
1206 
1207 		data = ((bitdata >> i) & 0x1);
1208 		__t1_tpi_read(adapter, A_ELMER0_GPO, &val);
1209 
1210 		if (data)
1211 			val |= S_DATA;
1212 		else
1213 			val &= ~S_DATA;
1214 
1215 		udelay(50);
1216 
1217 		/* Set SCLOCK low */
1218 		val &= ~S_CLOCK;
1219 		__t1_tpi_write(adapter, A_ELMER0_GPO, val);
1220 
1221 		udelay(50);
1222 
1223 		/* Write SCLOCK high */
1224 		val |= S_CLOCK;
1225 		__t1_tpi_write(adapter, A_ELMER0_GPO, val);
1226 
1227 	}
1228 }
1229 
1230 static int t1_clock(struct adapter *adapter, int mode)
1231 {
1232 	u32 val;
1233 	int M_CORE_VAL;
1234 	int M_MEM_VAL;
1235 
1236 	enum {
1237 		M_CORE_BITS	= 9,
1238 		T_CORE_VAL	= 0,
1239 		T_CORE_BITS	= 2,
1240 		N_CORE_VAL	= 0,
1241 		N_CORE_BITS	= 2,
1242 		M_MEM_BITS	= 9,
1243 		T_MEM_VAL	= 0,
1244 		T_MEM_BITS	= 2,
1245 		N_MEM_VAL	= 0,
1246 		N_MEM_BITS	= 2,
1247 		NP_LOAD		= 1 << 17,
1248 		S_LOAD_MEM	= 1 << 5,
1249 		S_LOAD_CORE	= 1 << 6,
1250 		S_CLOCK		= 1 << 3
1251 	};
1252 
1253 	if (!t1_is_T1B(adapter))
1254 		return -ENODEV;	/* Can't re-clock this chip. */
1255 
1256 	if (mode & 2)
1257 		return 0;	/* show current mode. */
1258 
1259 	if ((adapter->t1powersave & 1) == (mode & 1))
1260 		return -EALREADY;	/* ASIC already running in mode. */
1261 
1262 	if ((mode & 1) == HCLOCK) {
1263 		M_CORE_VAL = 0x14;
1264 		M_MEM_VAL = 0x18;
1265 		adapter->t1powersave = HCLOCK;	/* overclock */
1266 	} else {
1267 		M_CORE_VAL = 0xe;
1268 		M_MEM_VAL = 0x10;
1269 		adapter->t1powersave = LCLOCK;	/* underclock */
1270 	}
1271 
1272 	/* Don't interrupt this serial stream! */
1273 	spin_lock(&adapter->tpi_lock);
1274 
1275 	/* Initialize for ASIC core */
1276 	__t1_tpi_read(adapter, A_ELMER0_GPO, &val);
1277 	val |= NP_LOAD;
1278 	udelay(50);
1279 	__t1_tpi_write(adapter, A_ELMER0_GPO, val);
1280 	udelay(50);
1281 	__t1_tpi_read(adapter, A_ELMER0_GPO, &val);
1282 	val &= ~S_LOAD_CORE;
1283 	val &= ~S_CLOCK;
1284 	__t1_tpi_write(adapter, A_ELMER0_GPO, val);
1285 	udelay(50);
1286 
1287 	/* Serial program the ASIC clock synthesizer */
1288 	bit_bang(adapter, T_CORE_VAL, T_CORE_BITS);
1289 	bit_bang(adapter, N_CORE_VAL, N_CORE_BITS);
1290 	bit_bang(adapter, M_CORE_VAL, M_CORE_BITS);
1291 	udelay(50);
1292 
1293 	/* Finish ASIC core */
1294 	__t1_tpi_read(adapter, A_ELMER0_GPO, &val);
1295 	val |= S_LOAD_CORE;
1296 	udelay(50);
1297 	__t1_tpi_write(adapter, A_ELMER0_GPO, val);
1298 	udelay(50);
1299 	__t1_tpi_read(adapter, A_ELMER0_GPO, &val);
1300 	val &= ~S_LOAD_CORE;
1301 	udelay(50);
1302 	__t1_tpi_write(adapter, A_ELMER0_GPO, val);
1303 	udelay(50);
1304 
1305 	/* Initialize for memory */
1306 	__t1_tpi_read(adapter, A_ELMER0_GPO, &val);
1307 	val |= NP_LOAD;
1308 	udelay(50);
1309 	__t1_tpi_write(adapter, A_ELMER0_GPO, val);
1310 	udelay(50);
1311 	__t1_tpi_read(adapter, A_ELMER0_GPO, &val);
1312 	val &= ~S_LOAD_MEM;
1313 	val &= ~S_CLOCK;
1314 	udelay(50);
1315 	__t1_tpi_write(adapter, A_ELMER0_GPO, val);
1316 	udelay(50);
1317 
1318 	/* Serial program the memory clock synthesizer */
1319 	bit_bang(adapter, T_MEM_VAL, T_MEM_BITS);
1320 	bit_bang(adapter, N_MEM_VAL, N_MEM_BITS);
1321 	bit_bang(adapter, M_MEM_VAL, M_MEM_BITS);
1322 	udelay(50);
1323 
1324 	/* Finish memory */
1325 	__t1_tpi_read(adapter, A_ELMER0_GPO, &val);
1326 	val |= S_LOAD_MEM;
1327 	udelay(50);
1328 	__t1_tpi_write(adapter, A_ELMER0_GPO, val);
1329 	udelay(50);
1330 	__t1_tpi_read(adapter, A_ELMER0_GPO, &val);
1331 	val &= ~S_LOAD_MEM;
1332 	udelay(50);
1333 	__t1_tpi_write(adapter, A_ELMER0_GPO, val);
1334 
1335 	spin_unlock(&adapter->tpi_lock);
1336 
1337 	return 0;
1338 }
1339 
1340 static inline void t1_sw_reset(struct pci_dev *pdev)
1341 {
1342 	pci_write_config_dword(pdev, A_PCICFG_PM_CSR, 3);
1343 	pci_write_config_dword(pdev, A_PCICFG_PM_CSR, 0);
1344 }
1345 
1346 static void remove_one(struct pci_dev *pdev)
1347 {
1348 	struct net_device *dev = pci_get_drvdata(pdev);
1349 	struct adapter *adapter = dev->ml_priv;
1350 	int i;
1351 
1352 	for_each_port(adapter, i) {
1353 		if (test_bit(i, &adapter->registered_device_map))
1354 			unregister_netdev(adapter->port[i].dev);
1355 	}
1356 
1357 	t1_free_sw_modules(adapter);
1358 	iounmap(adapter->regs);
1359 
1360 	while (--i >= 0) {
1361 		if (adapter->port[i].dev)
1362 			free_netdev(adapter->port[i].dev);
1363 	}
1364 
1365 	pci_release_regions(pdev);
1366 	pci_disable_device(pdev);
1367 	t1_sw_reset(pdev);
1368 }
1369 
1370 static struct pci_driver cxgb_pci_driver = {
1371 	.name     = DRV_NAME,
1372 	.id_table = t1_pci_tbl,
1373 	.probe    = init_one,
1374 	.remove   = remove_one,
1375 };
1376 
1377 module_pci_driver(cxgb_pci_driver);
1378