1 /*
2  * Copyright (c) 2005-2008 Chelsio, Inc. All rights reserved.
3  *
4  * This software is available to you under a choice of one of two
5  * licenses.  You may choose to be licensed under the terms of the GNU
6  * General Public License (GPL) Version 2, available from the file
7  * COPYING in the main directory of this source tree, or the
8  * OpenIB.org BSD license below:
9  *
10  *     Redistribution and use in source and binary forms, with or
11  *     without modification, are permitted provided that the following
12  *     conditions are met:
13  *
14  *      - Redistributions of source code must retain the above
15  *        copyright notice, this list of conditions and the following
16  *        disclaimer.
17  *
18  *      - Redistributions in binary form must reproduce the above
19  *        copyright notice, this list of conditions and the following
20  *        disclaimer in the documentation and/or other materials
21  *        provided with the distribution.
22  *
23  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
24  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
25  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
26  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
27  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
28  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
29  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
30  * SOFTWARE.
31  */
32 
33 #include "common.h"
34 #include "regs.h"
35 
36 enum {
37 	/* MDIO_DEV_PMA_PMD registers */
38 	AQ_LINK_STAT	= 0xe800,
39 	AQ_IMASK_PMA	= 0xf000,
40 
41 	/* MDIO_DEV_XGXS registers */
42 	AQ_XAUI_RX_CFG	= 0xc400,
43 	AQ_XAUI_TX_CFG	= 0xe400,
44 
45 	/* MDIO_DEV_ANEG registers */
46 	AQ_1G_CTRL	= 0xc400,
47 	AQ_ANEG_STAT	= 0xc800,
48 
49 	/* MDIO_DEV_VEND1 registers */
50 	AQ_FW_VERSION	= 0x0020,
51 	AQ_IFLAG_GLOBAL	= 0xfc00,
52 	AQ_IMASK_GLOBAL	= 0xff00,
53 };
54 
55 enum {
56 	IMASK_PMA	= 1 << 2,
57 	IMASK_GLOBAL	= 1 << 15,
58 	ADV_1G_FULL	= 1 << 15,
59 	ADV_1G_HALF	= 1 << 14,
60 	ADV_10G_FULL	= 1 << 12,
61 	AQ_RESET	= (1 << 14) | (1 << 15),
62 	AQ_LOWPOWER	= 1 << 12,
63 };
64 
65 static int aq100x_reset(struct cphy *phy, int wait)
66 {
67 	/*
68 	 * Ignore the caller specified wait time; always wait for the reset to
69 	 * complete. Can take up to 3s.
70 	 */
71 	int err = t3_phy_reset(phy, MDIO_MMD_VEND1, 3000);
72 
73 	if (err)
74 		CH_WARN(phy->adapter, "PHY%d: reset failed (0x%x).\n",
75 			phy->mdio.prtad, err);
76 
77 	return err;
78 }
79 
80 static int aq100x_intr_enable(struct cphy *phy)
81 {
82 	int err = t3_mdio_write(phy, MDIO_MMD_PMAPMD, AQ_IMASK_PMA, IMASK_PMA);
83 	if (err)
84 		return err;
85 
86 	err = t3_mdio_write(phy, MDIO_MMD_VEND1, AQ_IMASK_GLOBAL, IMASK_GLOBAL);
87 	return err;
88 }
89 
90 static int aq100x_intr_disable(struct cphy *phy)
91 {
92 	return t3_mdio_write(phy, MDIO_MMD_VEND1, AQ_IMASK_GLOBAL, 0);
93 }
94 
95 static int aq100x_intr_clear(struct cphy *phy)
96 {
97 	unsigned int v;
98 
99 	t3_mdio_read(phy, MDIO_MMD_VEND1, AQ_IFLAG_GLOBAL, &v);
100 	t3_mdio_read(phy, MDIO_MMD_PMAPMD, MDIO_STAT1, &v);
101 
102 	return 0;
103 }
104 
105 static int aq100x_intr_handler(struct cphy *phy)
106 {
107 	int err;
108 	unsigned int cause, v;
109 
110 	err = t3_mdio_read(phy, MDIO_MMD_VEND1, AQ_IFLAG_GLOBAL, &cause);
111 	if (err)
112 		return err;
113 
114 	/* Read (and reset) the latching version of the status */
115 	t3_mdio_read(phy, MDIO_MMD_PMAPMD, MDIO_STAT1, &v);
116 
117 	return cphy_cause_link_change;
118 }
119 
120 static int aq100x_power_down(struct cphy *phy, int off)
121 {
122 	return mdio_set_flag(&phy->mdio, phy->mdio.prtad,
123 			     MDIO_MMD_PMAPMD, MDIO_CTRL1,
124 			     MDIO_CTRL1_LPOWER, off);
125 }
126 
127 static int aq100x_autoneg_enable(struct cphy *phy)
128 {
129 	int err;
130 
131 	err = aq100x_power_down(phy, 0);
132 	if (!err)
133 		err = mdio_set_flag(&phy->mdio, phy->mdio.prtad,
134 				    MDIO_MMD_AN, MDIO_CTRL1,
135 				    BMCR_ANENABLE | BMCR_ANRESTART, 1);
136 
137 	return err;
138 }
139 
140 static int aq100x_autoneg_restart(struct cphy *phy)
141 {
142 	int err;
143 
144 	err = aq100x_power_down(phy, 0);
145 	if (!err)
146 		err = mdio_set_flag(&phy->mdio, phy->mdio.prtad,
147 				    MDIO_MMD_AN, MDIO_CTRL1,
148 				    BMCR_ANENABLE | BMCR_ANRESTART, 1);
149 
150 	return err;
151 }
152 
153 static int aq100x_advertise(struct cphy *phy, unsigned int advertise_map)
154 {
155 	unsigned int adv;
156 	int err;
157 
158 	/* 10G advertisement */
159 	adv = 0;
160 	if (advertise_map & ADVERTISED_10000baseT_Full)
161 		adv |= ADV_10G_FULL;
162 	err = t3_mdio_change_bits(phy, MDIO_MMD_AN, MDIO_AN_10GBT_CTRL,
163 				  ADV_10G_FULL, adv);
164 	if (err)
165 		return err;
166 
167 	/* 1G advertisement */
168 	adv = 0;
169 	if (advertise_map & ADVERTISED_1000baseT_Full)
170 		adv |= ADV_1G_FULL;
171 	if (advertise_map & ADVERTISED_1000baseT_Half)
172 		adv |= ADV_1G_HALF;
173 	err = t3_mdio_change_bits(phy, MDIO_MMD_AN, AQ_1G_CTRL,
174 				  ADV_1G_FULL | ADV_1G_HALF, adv);
175 	if (err)
176 		return err;
177 
178 	/* 100M, pause advertisement */
179 	adv = 0;
180 	if (advertise_map & ADVERTISED_100baseT_Half)
181 		adv |= ADVERTISE_100HALF;
182 	if (advertise_map & ADVERTISED_100baseT_Full)
183 		adv |= ADVERTISE_100FULL;
184 	if (advertise_map & ADVERTISED_Pause)
185 		adv |= ADVERTISE_PAUSE_CAP;
186 	if (advertise_map & ADVERTISED_Asym_Pause)
187 		adv |= ADVERTISE_PAUSE_ASYM;
188 	err = t3_mdio_change_bits(phy, MDIO_MMD_AN, MDIO_AN_ADVERTISE,
189 				  0xfe0, adv);
190 
191 	return err;
192 }
193 
194 static int aq100x_set_loopback(struct cphy *phy, int mmd, int dir, int enable)
195 {
196 	return mdio_set_flag(&phy->mdio, phy->mdio.prtad,
197 			     MDIO_MMD_PMAPMD, MDIO_CTRL1,
198 			     BMCR_LOOPBACK, enable);
199 }
200 
201 static int aq100x_set_speed_duplex(struct cphy *phy, int speed, int duplex)
202 {
203 	/* no can do */
204 	return -1;
205 }
206 
207 static int aq100x_get_link_status(struct cphy *phy, int *link_ok,
208 				  int *speed, int *duplex, int *fc)
209 {
210 	int err;
211 	unsigned int v;
212 
213 	if (link_ok) {
214 		err = t3_mdio_read(phy, MDIO_MMD_PMAPMD, AQ_LINK_STAT, &v);
215 		if (err)
216 			return err;
217 
218 		*link_ok = v & 1;
219 		if (!*link_ok)
220 			return 0;
221 	}
222 
223 	err = t3_mdio_read(phy, MDIO_MMD_AN, AQ_ANEG_STAT, &v);
224 	if (err)
225 		return err;
226 
227 	if (speed) {
228 		switch (v & 0x6) {
229 		case 0x6:
230 			*speed = SPEED_10000;
231 			break;
232 		case 0x4:
233 			*speed = SPEED_1000;
234 			break;
235 		case 0x2:
236 			*speed = SPEED_100;
237 			break;
238 		case 0x0:
239 			*speed = SPEED_10;
240 			break;
241 		}
242 	}
243 
244 	if (duplex)
245 		*duplex = v & 1 ? DUPLEX_FULL : DUPLEX_HALF;
246 
247 	return 0;
248 }
249 
250 static const struct cphy_ops aq100x_ops = {
251 	.reset             = aq100x_reset,
252 	.intr_enable       = aq100x_intr_enable,
253 	.intr_disable      = aq100x_intr_disable,
254 	.intr_clear        = aq100x_intr_clear,
255 	.intr_handler      = aq100x_intr_handler,
256 	.autoneg_enable    = aq100x_autoneg_enable,
257 	.autoneg_restart   = aq100x_autoneg_restart,
258 	.advertise         = aq100x_advertise,
259 	.set_loopback      = aq100x_set_loopback,
260 	.set_speed_duplex  = aq100x_set_speed_duplex,
261 	.get_link_status   = aq100x_get_link_status,
262 	.power_down        = aq100x_power_down,
263 	.mmds 		   = MDIO_DEVS_PMAPMD | MDIO_DEVS_PCS | MDIO_DEVS_PHYXS,
264 };
265 
266 int t3_aq100x_phy_prep(struct cphy *phy, struct adapter *adapter, int phy_addr,
267 		       const struct mdio_ops *mdio_ops)
268 {
269 	unsigned int v, v2, gpio, wait;
270 	int err;
271 
272 	cphy_init(phy, adapter, phy_addr, &aq100x_ops, mdio_ops,
273 		  SUPPORTED_1000baseT_Full | SUPPORTED_10000baseT_Full |
274 		  SUPPORTED_TP | SUPPORTED_Autoneg | SUPPORTED_AUI,
275 		  "1000/10GBASE-T");
276 
277 	/*
278 	 * The PHY has been out of reset ever since the system powered up.  So
279 	 * we do a hard reset over here.
280 	 */
281 	gpio = phy_addr ? F_GPIO10_OUT_VAL : F_GPIO6_OUT_VAL;
282 	t3_set_reg_field(adapter, A_T3DBG_GPIO_EN, gpio, 0);
283 	msleep(1);
284 	t3_set_reg_field(adapter, A_T3DBG_GPIO_EN, gpio, gpio);
285 
286 	/*
287 	 * Give it enough time to load the firmware and get ready for mdio.
288 	 */
289 	msleep(1000);
290 	wait = 500; /* in 10ms increments */
291 	do {
292 		err = t3_mdio_read(phy, MDIO_MMD_VEND1, MDIO_CTRL1, &v);
293 		if (err || v == 0xffff) {
294 
295 			/* Allow prep_adapter to succeed when ffff is read */
296 
297 			CH_WARN(adapter, "PHY%d: reset failed (0x%x, 0x%x).\n",
298 				phy_addr, err, v);
299 			goto done;
300 		}
301 
302 		v &= AQ_RESET;
303 		if (v)
304 			msleep(10);
305 	} while (v && --wait);
306 	if (v) {
307 		CH_WARN(adapter, "PHY%d: reset timed out (0x%x).\n",
308 			phy_addr, v);
309 
310 		goto done; /* let prep_adapter succeed */
311 	}
312 
313 	/* Datasheet says 3s max but this has been observed */
314 	wait = (500 - wait) * 10 + 1000;
315 	if (wait > 3000)
316 		CH_WARN(adapter, "PHY%d: reset took %ums\n", phy_addr, wait);
317 
318 	/* Firmware version check. */
319 	t3_mdio_read(phy, MDIO_MMD_VEND1, AQ_FW_VERSION, &v);
320 	if (v != 101)
321 		CH_WARN(adapter, "PHY%d: unsupported firmware %d\n",
322 			phy_addr, v);
323 
324 	/*
325 	 * The PHY should start in really-low-power mode.  Prepare it for normal
326 	 * operations.
327 	 */
328 	err = t3_mdio_read(phy, MDIO_MMD_VEND1, MDIO_CTRL1, &v);
329 	if (err)
330 		return err;
331 	if (v & AQ_LOWPOWER) {
332 		err = t3_mdio_change_bits(phy, MDIO_MMD_VEND1, MDIO_CTRL1,
333 					  AQ_LOWPOWER, 0);
334 		if (err)
335 			return err;
336 		msleep(10);
337 	} else
338 		CH_WARN(adapter, "PHY%d does not start in low power mode.\n",
339 			phy_addr);
340 
341 	/*
342 	 * Verify XAUI settings, but let prep succeed no matter what.
343 	 */
344 	v = v2 = 0;
345 	t3_mdio_read(phy, MDIO_MMD_PHYXS, AQ_XAUI_RX_CFG, &v);
346 	t3_mdio_read(phy, MDIO_MMD_PHYXS, AQ_XAUI_TX_CFG, &v2);
347 	if (v != 0x1b || v2 != 0x1b)
348 		CH_WARN(adapter,
349 			"PHY%d: incorrect XAUI settings (0x%x, 0x%x).\n",
350 			phy_addr, v, v2);
351 
352 done:
353 	return err;
354 }
355