Eric Lee / smarc-ti-linux-kernel

Download as
Browse Code ยป

Commit cd7faf359dc0eeb672c820d2308a71b1c1fbadf9

Authored by Guenter Roeck
Committed by Greg Kroah-Hartman
1 parent af8c0e0612
Exists in ti-linux-3.14.y and in 2 other branches processor-sdk-linux-01.00.00, smarc-ti-linux-3.14.y

net: phy: Don't call phy_resume if phy_init_hw failed 

[ Upstream commit b394745df2d9d4c30bf1bcc55773bec6f3bc7c67 ]

After the call to phy_init_hw failed in phy_attach_direct, phy_detach is called
to detach the phy device from its network device. If the attached driver is a
generic phy driver, this also detaches the driver. Subsequently phy_resume
is called, which assumes without checking that a driver is attached to the
device. This will result in a crash such as

Unable to handle kernel paging request for data at address 0xffffffffffffff90
Faulting instruction address: 0xc0000000003a0e18
Oops: Kernel access of bad area, sig: 11 [#1]
...
NIP [c0000000003a0e18] .phy_attach_direct+0x68/0x17c
LR [c0000000003a0e6c] .phy_attach_direct+0xbc/0x17c
Call Trace:
[c0000003fc0475d0] [c0000000003a0e6c] .phy_attach_direct+0xbc/0x17c (unreliable)
[c0000003fc047670] [c0000000003a0ff8] .phy_connect_direct+0x28/0x98
[c0000003fc047700] [c0000000003f0074] .of_phy_connect+0x4c/0xa4

Only call phy_resume if phy_init_hw was successful.

Signed-off-by: Guenter Roeck <linux@roeck-us.net>
Acked-by: Florian Fainelli <f.fainelli@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

Showing 1 changed file with 2 additions and 2 deletions Inline Diff

drivers/net/phy/phy_device.c
Diff comments   View file @ cd7faf3
1 /* Framework for finding and configuring PHYs. 1 /* Framework for finding and configuring PHYs.
2 * Also contains generic PHY driver 2 * Also contains generic PHY driver
3 * 3 *
4 * Author: Andy Fleming 4 * Author: Andy Fleming
5 * 5 *
6 * Copyright (c) 2004 Freescale Semiconductor, Inc. 6 * Copyright (c) 2004 Freescale Semiconductor, Inc.
7 * 7 *
8 * This program is free software; you can redistribute it and/or modify it 8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by the 9 * under the terms of the GNU General Public License as published by the
10 * Free Software Foundation; either version 2 of the License, or (at your 10 * Free Software Foundation; either version 2 of the License, or (at your
11 * option) any later version. 11 * option) any later version.
12 * 12 *
13 */ 13 */
14 14
15 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 15 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
16 16
17 #include <linux/kernel.h> 17 #include <linux/kernel.h>
18 #include <linux/string.h> 18 #include <linux/string.h>
19 #include <linux/errno.h> 19 #include <linux/errno.h>
20 #include <linux/unistd.h> 20 #include <linux/unistd.h>
21 #include <linux/slab.h> 21 #include <linux/slab.h>
22 #include <linux/interrupt.h> 22 #include <linux/interrupt.h>
23 #include <linux/init.h> 23 #include <linux/init.h>
24 #include <linux/delay.h> 24 #include <linux/delay.h>
25 #include <linux/netdevice.h> 25 #include <linux/netdevice.h>
26 #include <linux/etherdevice.h> 26 #include <linux/etherdevice.h>
27 #include <linux/skbuff.h> 27 #include <linux/skbuff.h>
28 #include <linux/mm.h> 28 #include <linux/mm.h>
29 #include <linux/module.h> 29 #include <linux/module.h>
30 #include <linux/mii.h> 30 #include <linux/mii.h>
31 #include <linux/ethtool.h> 31 #include <linux/ethtool.h>
32 #include <linux/phy.h> 32 #include <linux/phy.h>
33 #include <linux/mdio.h> 33 #include <linux/mdio.h>
34 #include <linux/io.h> 34 #include <linux/io.h>
35 #include <linux/uaccess.h> 35 #include <linux/uaccess.h>
36 36
37 #include <asm/irq.h> 37 #include <asm/irq.h>
38 38
39 MODULE_DESCRIPTION("PHY library"); 39 MODULE_DESCRIPTION("PHY library");
40 MODULE_AUTHOR("Andy Fleming"); 40 MODULE_AUTHOR("Andy Fleming");
41 MODULE_LICENSE("GPL"); 41 MODULE_LICENSE("GPL");
42 42
43 void phy_device_free(struct phy_device *phydev) 43 void phy_device_free(struct phy_device *phydev)
44 { 44 {
45 put_device(&phydev->dev); 45 put_device(&phydev->dev);
46 } 46 }
47 EXPORT_SYMBOL(phy_device_free); 47 EXPORT_SYMBOL(phy_device_free);
48 48
49 static void phy_device_release(struct device *dev) 49 static void phy_device_release(struct device *dev)
50 { 50 {
51 kfree(to_phy_device(dev)); 51 kfree(to_phy_device(dev));
52 } 52 }
53 53
54 enum genphy_driver { 54 enum genphy_driver {
55 GENPHY_DRV_1G, 55 GENPHY_DRV_1G,
56 GENPHY_DRV_10G, 56 GENPHY_DRV_10G,
57 GENPHY_DRV_MAX 57 GENPHY_DRV_MAX
58 }; 58 };
59 59
60 static struct phy_driver genphy_driver[GENPHY_DRV_MAX]; 60 static struct phy_driver genphy_driver[GENPHY_DRV_MAX];
61 61
62 static LIST_HEAD(phy_fixup_list); 62 static LIST_HEAD(phy_fixup_list);
63 static DEFINE_MUTEX(phy_fixup_lock); 63 static DEFINE_MUTEX(phy_fixup_lock);
64 64
65 /** 65 /**
66 * phy_register_fixup - creates a new phy_fixup and adds it to the list 66 * phy_register_fixup - creates a new phy_fixup and adds it to the list
67 * @bus_id: A string which matches phydev->dev.bus_id (or PHY_ANY_ID) 67 * @bus_id: A string which matches phydev->dev.bus_id (or PHY_ANY_ID)
68 * @phy_uid: Used to match against phydev->phy_id (the UID of the PHY) 68 * @phy_uid: Used to match against phydev->phy_id (the UID of the PHY)
69 * It can also be PHY_ANY_UID 69 * It can also be PHY_ANY_UID
70 * @phy_uid_mask: Applied to phydev->phy_id and fixup->phy_uid before 70 * @phy_uid_mask: Applied to phydev->phy_id and fixup->phy_uid before
71 * comparison 71 * comparison
72 * @run: The actual code to be run when a matching PHY is found 72 * @run: The actual code to be run when a matching PHY is found
73 */ 73 */
74 int phy_register_fixup(const char *bus_id, u32 phy_uid, u32 phy_uid_mask, 74 int phy_register_fixup(const char *bus_id, u32 phy_uid, u32 phy_uid_mask,
75 int (*run)(struct phy_device *)) 75 int (*run)(struct phy_device *))
76 { 76 {
77 struct phy_fixup *fixup = kzalloc(sizeof(*fixup), GFP_KERNEL); 77 struct phy_fixup *fixup = kzalloc(sizeof(*fixup), GFP_KERNEL);
78 78
79 if (!fixup) 79 if (!fixup)
80 return -ENOMEM; 80 return -ENOMEM;
81 81
82 strlcpy(fixup->bus_id, bus_id, sizeof(fixup->bus_id)); 82 strlcpy(fixup->bus_id, bus_id, sizeof(fixup->bus_id));
83 fixup->phy_uid = phy_uid; 83 fixup->phy_uid = phy_uid;
84 fixup->phy_uid_mask = phy_uid_mask; 84 fixup->phy_uid_mask = phy_uid_mask;
85 fixup->run = run; 85 fixup->run = run;
86 86
87 mutex_lock(&phy_fixup_lock); 87 mutex_lock(&phy_fixup_lock);
88 list_add_tail(&fixup->list, &phy_fixup_list); 88 list_add_tail(&fixup->list, &phy_fixup_list);
89 mutex_unlock(&phy_fixup_lock); 89 mutex_unlock(&phy_fixup_lock);
90 90
91 return 0; 91 return 0;
92 } 92 }
93 EXPORT_SYMBOL(phy_register_fixup); 93 EXPORT_SYMBOL(phy_register_fixup);
94 94
95 /* Registers a fixup to be run on any PHY with the UID in phy_uid */ 95 /* Registers a fixup to be run on any PHY with the UID in phy_uid */
96 int phy_register_fixup_for_uid(u32 phy_uid, u32 phy_uid_mask, 96 int phy_register_fixup_for_uid(u32 phy_uid, u32 phy_uid_mask,
97 int (*run)(struct phy_device *)) 97 int (*run)(struct phy_device *))
98 { 98 {
99 return phy_register_fixup(PHY_ANY_ID, phy_uid, phy_uid_mask, run); 99 return phy_register_fixup(PHY_ANY_ID, phy_uid, phy_uid_mask, run);
100 } 100 }
101 EXPORT_SYMBOL(phy_register_fixup_for_uid); 101 EXPORT_SYMBOL(phy_register_fixup_for_uid);
102 102
103 /* Registers a fixup to be run on the PHY with id string bus_id */ 103 /* Registers a fixup to be run on the PHY with id string bus_id */
104 int phy_register_fixup_for_id(const char *bus_id, 104 int phy_register_fixup_for_id(const char *bus_id,
105 int (*run)(struct phy_device *)) 105 int (*run)(struct phy_device *))
106 { 106 {
107 return phy_register_fixup(bus_id, PHY_ANY_UID, 0xffffffff, run); 107 return phy_register_fixup(bus_id, PHY_ANY_UID, 0xffffffff, run);
108 } 108 }
109 EXPORT_SYMBOL(phy_register_fixup_for_id); 109 EXPORT_SYMBOL(phy_register_fixup_for_id);
110 110
111 /* Returns 1 if fixup matches phydev in bus_id and phy_uid. 111 /* Returns 1 if fixup matches phydev in bus_id and phy_uid.
112 * Fixups can be set to match any in one or more fields. 112 * Fixups can be set to match any in one or more fields.
113 */ 113 */
114 static int phy_needs_fixup(struct phy_device *phydev, struct phy_fixup *fixup) 114 static int phy_needs_fixup(struct phy_device *phydev, struct phy_fixup *fixup)
115 { 115 {
116 if (strcmp(fixup->bus_id, dev_name(&phydev->dev)) != 0) 116 if (strcmp(fixup->bus_id, dev_name(&phydev->dev)) != 0)
117 if (strcmp(fixup->bus_id, PHY_ANY_ID) != 0) 117 if (strcmp(fixup->bus_id, PHY_ANY_ID) != 0)
118 return 0; 118 return 0;
119 119
120 if ((fixup->phy_uid & fixup->phy_uid_mask) != 120 if ((fixup->phy_uid & fixup->phy_uid_mask) !=
121 (phydev->phy_id & fixup->phy_uid_mask)) 121 (phydev->phy_id & fixup->phy_uid_mask))
122 if (fixup->phy_uid != PHY_ANY_UID) 122 if (fixup->phy_uid != PHY_ANY_UID)
123 return 0; 123 return 0;
124 124
125 return 1; 125 return 1;
126 } 126 }
127 127
128 /* Runs any matching fixups for this phydev */ 128 /* Runs any matching fixups for this phydev */
129 static int phy_scan_fixups(struct phy_device *phydev) 129 static int phy_scan_fixups(struct phy_device *phydev)
130 { 130 {
131 struct phy_fixup *fixup; 131 struct phy_fixup *fixup;
132 132
133 mutex_lock(&phy_fixup_lock); 133 mutex_lock(&phy_fixup_lock);
134 list_for_each_entry(fixup, &phy_fixup_list, list) { 134 list_for_each_entry(fixup, &phy_fixup_list, list) {
135 if (phy_needs_fixup(phydev, fixup)) { 135 if (phy_needs_fixup(phydev, fixup)) {
136 int err = fixup->run(phydev); 136 int err = fixup->run(phydev);
137 137
138 if (err < 0) { 138 if (err < 0) {
139 mutex_unlock(&phy_fixup_lock); 139 mutex_unlock(&phy_fixup_lock);
140 return err; 140 return err;
141 } 141 }
142 } 142 }
143 } 143 }
144 mutex_unlock(&phy_fixup_lock); 144 mutex_unlock(&phy_fixup_lock);
145 145
146 return 0; 146 return 0;
147 } 147 }
148 148
149 struct phy_device *phy_device_create(struct mii_bus *bus, int addr, int phy_id, 149 struct phy_device *phy_device_create(struct mii_bus *bus, int addr, int phy_id,
150 bool is_c45, 150 bool is_c45,
151 struct phy_c45_device_ids *c45_ids) 151 struct phy_c45_device_ids *c45_ids)
152 { 152 {
153 struct phy_device *dev; 153 struct phy_device *dev;
154 154
155 /* We allocate the device, and initialize the default values */ 155 /* We allocate the device, and initialize the default values */
156 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 156 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
157 if (NULL == dev) 157 if (NULL == dev)
158 return (struct phy_device *)PTR_ERR((void *)-ENOMEM); 158 return (struct phy_device *)PTR_ERR((void *)-ENOMEM);
159 159
160 dev->dev.release = phy_device_release; 160 dev->dev.release = phy_device_release;
161 161
162 dev->speed = 0; 162 dev->speed = 0;
163 dev->duplex = -1; 163 dev->duplex = -1;
164 dev->pause = 0; 164 dev->pause = 0;
165 dev->asym_pause = 0; 165 dev->asym_pause = 0;
166 dev->link = 1; 166 dev->link = 1;
167 dev->interface = PHY_INTERFACE_MODE_GMII; 167 dev->interface = PHY_INTERFACE_MODE_GMII;
168 168
169 dev->autoneg = AUTONEG_ENABLE; 169 dev->autoneg = AUTONEG_ENABLE;
170 170
171 dev->is_c45 = is_c45; 171 dev->is_c45 = is_c45;
172 dev->addr = addr; 172 dev->addr = addr;
173 dev->phy_id = phy_id; 173 dev->phy_id = phy_id;
174 if (c45_ids) 174 if (c45_ids)
175 dev->c45_ids = *c45_ids; 175 dev->c45_ids = *c45_ids;
176 dev->bus = bus; 176 dev->bus = bus;
177 dev->dev.parent = bus->parent; 177 dev->dev.parent = bus->parent;
178 dev->dev.bus = &mdio_bus_type; 178 dev->dev.bus = &mdio_bus_type;
179 dev->irq = bus->irq != NULL ? bus->irq[addr] : PHY_POLL; 179 dev->irq = bus->irq != NULL ? bus->irq[addr] : PHY_POLL;
180 dev_set_name(&dev->dev, PHY_ID_FMT, bus->id, addr); 180 dev_set_name(&dev->dev, PHY_ID_FMT, bus->id, addr);
181 181
182 dev->state = PHY_DOWN; 182 dev->state = PHY_DOWN;
183 183
184 mutex_init(&dev->lock); 184 mutex_init(&dev->lock);
185 INIT_DELAYED_WORK(&dev->state_queue, phy_state_machine); 185 INIT_DELAYED_WORK(&dev->state_queue, phy_state_machine);
186 INIT_WORK(&dev->phy_queue, phy_change); 186 INIT_WORK(&dev->phy_queue, phy_change);
187 187
188 /* Request the appropriate module unconditionally; don't 188 /* Request the appropriate module unconditionally; don't
189 * bother trying to do so only if it isn't already loaded, 189 * bother trying to do so only if it isn't already loaded,
190 * because that gets complicated. A hotplug event would have 190 * because that gets complicated. A hotplug event would have
191 * done an unconditional modprobe anyway. 191 * done an unconditional modprobe anyway.
192 * We don't do normal hotplug because it won't work for MDIO 192 * We don't do normal hotplug because it won't work for MDIO
193 * -- because it relies on the device staying around for long 193 * -- because it relies on the device staying around for long
194 * enough for the driver to get loaded. With MDIO, the NIC 194 * enough for the driver to get loaded. With MDIO, the NIC
195 * driver will get bored and give up as soon as it finds that 195 * driver will get bored and give up as soon as it finds that
196 * there's no driver _already_ loaded. 196 * there's no driver _already_ loaded.
197 */ 197 */
198 request_module(MDIO_MODULE_PREFIX MDIO_ID_FMT, MDIO_ID_ARGS(phy_id)); 198 request_module(MDIO_MODULE_PREFIX MDIO_ID_FMT, MDIO_ID_ARGS(phy_id));
199 199
200 device_initialize(&dev->dev); 200 device_initialize(&dev->dev);
201 201
202 return dev; 202 return dev;
203 } 203 }
204 EXPORT_SYMBOL(phy_device_create); 204 EXPORT_SYMBOL(phy_device_create);
205 205
206 /** 206 /**
207 * get_phy_c45_ids - reads the specified addr for its 802.3-c45 IDs. 207 * get_phy_c45_ids - reads the specified addr for its 802.3-c45 IDs.
208 * @bus: the target MII bus 208 * @bus: the target MII bus
209 * @addr: PHY address on the MII bus 209 * @addr: PHY address on the MII bus
210 * @phy_id: where to store the ID retrieved. 210 * @phy_id: where to store the ID retrieved.
211 * @c45_ids: where to store the c45 ID information. 211 * @c45_ids: where to store the c45 ID information.
212 * 212 *
213 * If the PHY devices-in-package appears to be valid, it and the 213 * If the PHY devices-in-package appears to be valid, it and the
214 * corresponding identifiers are stored in @c45_ids, zero is stored 214 * corresponding identifiers are stored in @c45_ids, zero is stored
215 * in @phy_id. Otherwise 0xffffffff is stored in @phy_id. Returns 215 * in @phy_id. Otherwise 0xffffffff is stored in @phy_id. Returns
216 * zero on success. 216 * zero on success.
217 * 217 *
218 */ 218 */
219 static int get_phy_c45_ids(struct mii_bus *bus, int addr, u32 *phy_id, 219 static int get_phy_c45_ids(struct mii_bus *bus, int addr, u32 *phy_id,
220 struct phy_c45_device_ids *c45_ids) { 220 struct phy_c45_device_ids *c45_ids) {
221 int phy_reg; 221 int phy_reg;
222 int i, reg_addr; 222 int i, reg_addr;
223 const int num_ids = ARRAY_SIZE(c45_ids->device_ids); 223 const int num_ids = ARRAY_SIZE(c45_ids->device_ids);
224 224
225 /* Find first non-zero Devices In package. Device 225 /* Find first non-zero Devices In package. Device
226 * zero is reserved, so don't probe it. 226 * zero is reserved, so don't probe it.
227 */ 227 */
228 for (i = 1; 228 for (i = 1;
229 i < num_ids && c45_ids->devices_in_package == 0; 229 i < num_ids && c45_ids->devices_in_package == 0;
230 i++) { 230 i++) {
231 reg_addr = MII_ADDR_C45 | i << 16 | 6; 231 reg_addr = MII_ADDR_C45 | i << 16 | 6;
232 phy_reg = mdiobus_read(bus, addr, reg_addr); 232 phy_reg = mdiobus_read(bus, addr, reg_addr);
233 if (phy_reg < 0) 233 if (phy_reg < 0)
234 return -EIO; 234 return -EIO;
235 c45_ids->devices_in_package = (phy_reg & 0xffff) << 16; 235 c45_ids->devices_in_package = (phy_reg & 0xffff) << 16;
236 236
237 reg_addr = MII_ADDR_C45 | i << 16 | 5; 237 reg_addr = MII_ADDR_C45 | i << 16 | 5;
238 phy_reg = mdiobus_read(bus, addr, reg_addr); 238 phy_reg = mdiobus_read(bus, addr, reg_addr);
239 if (phy_reg < 0) 239 if (phy_reg < 0)
240 return -EIO; 240 return -EIO;
241 c45_ids->devices_in_package |= (phy_reg & 0xffff); 241 c45_ids->devices_in_package |= (phy_reg & 0xffff);
242 242
243 /* If mostly Fs, there is no device there, 243 /* If mostly Fs, there is no device there,
244 * let's get out of here. 244 * let's get out of here.
245 */ 245 */
246 if ((c45_ids->devices_in_package & 0x1fffffff) == 0x1fffffff) { 246 if ((c45_ids->devices_in_package & 0x1fffffff) == 0x1fffffff) {
247 *phy_id = 0xffffffff; 247 *phy_id = 0xffffffff;
248 return 0; 248 return 0;
249 } 249 }
250 } 250 }
251 251
252 /* Now probe Device Identifiers for each device present. */ 252 /* Now probe Device Identifiers for each device present. */
253 for (i = 1; i < num_ids; i++) { 253 for (i = 1; i < num_ids; i++) {
254 if (!(c45_ids->devices_in_package & (1 << i))) 254 if (!(c45_ids->devices_in_package & (1 << i)))
255 continue; 255 continue;
256 256
257 reg_addr = MII_ADDR_C45 | i << 16 | MII_PHYSID1; 257 reg_addr = MII_ADDR_C45 | i << 16 | MII_PHYSID1;
258 phy_reg = mdiobus_read(bus, addr, reg_addr); 258 phy_reg = mdiobus_read(bus, addr, reg_addr);
259 if (phy_reg < 0) 259 if (phy_reg < 0)
260 return -EIO; 260 return -EIO;
261 c45_ids->device_ids[i] = (phy_reg & 0xffff) << 16; 261 c45_ids->device_ids[i] = (phy_reg & 0xffff) << 16;
262 262
263 reg_addr = MII_ADDR_C45 | i << 16 | MII_PHYSID2; 263 reg_addr = MII_ADDR_C45 | i << 16 | MII_PHYSID2;
264 phy_reg = mdiobus_read(bus, addr, reg_addr); 264 phy_reg = mdiobus_read(bus, addr, reg_addr);
265 if (phy_reg < 0) 265 if (phy_reg < 0)
266 return -EIO; 266 return -EIO;
267 c45_ids->device_ids[i] |= (phy_reg & 0xffff); 267 c45_ids->device_ids[i] |= (phy_reg & 0xffff);
268 } 268 }
269 *phy_id = 0; 269 *phy_id = 0;
270 return 0; 270 return 0;
271 } 271 }
272 272
273 /** 273 /**
274 * get_phy_id - reads the specified addr for its ID. 274 * get_phy_id - reads the specified addr for its ID.
275 * @bus: the target MII bus 275 * @bus: the target MII bus
276 * @addr: PHY address on the MII bus 276 * @addr: PHY address on the MII bus
277 * @phy_id: where to store the ID retrieved. 277 * @phy_id: where to store the ID retrieved.
278 * @is_c45: If true the PHY uses the 802.3 clause 45 protocol 278 * @is_c45: If true the PHY uses the 802.3 clause 45 protocol
279 * @c45_ids: where to store the c45 ID information. 279 * @c45_ids: where to store the c45 ID information.
280 * 280 *
281 * Description: In the case of a 802.3-c22 PHY, reads the ID registers 281 * Description: In the case of a 802.3-c22 PHY, reads the ID registers
282 * of the PHY at @addr on the @bus, stores it in @phy_id and returns 282 * of the PHY at @addr on the @bus, stores it in @phy_id and returns
283 * zero on success. 283 * zero on success.
284 * 284 *
285 * In the case of a 802.3-c45 PHY, get_phy_c45_ids() is invoked, and 285 * In the case of a 802.3-c45 PHY, get_phy_c45_ids() is invoked, and
286 * its return value is in turn returned. 286 * its return value is in turn returned.
287 * 287 *
288 */ 288 */
289 static int get_phy_id(struct mii_bus *bus, int addr, u32 *phy_id, 289 static int get_phy_id(struct mii_bus *bus, int addr, u32 *phy_id,
290 bool is_c45, struct phy_c45_device_ids *c45_ids) 290 bool is_c45, struct phy_c45_device_ids *c45_ids)
291 { 291 {
292 int phy_reg; 292 int phy_reg;
293 293
294 if (is_c45) 294 if (is_c45)
295 return get_phy_c45_ids(bus, addr, phy_id, c45_ids); 295 return get_phy_c45_ids(bus, addr, phy_id, c45_ids);
296 296
297 /* Grab the bits from PHYIR1, and put them in the upper half */ 297 /* Grab the bits from PHYIR1, and put them in the upper half */
298 phy_reg = mdiobus_read(bus, addr, MII_PHYSID1); 298 phy_reg = mdiobus_read(bus, addr, MII_PHYSID1);
299 if (phy_reg < 0) 299 if (phy_reg < 0)
300 return -EIO; 300 return -EIO;
301 301
302 *phy_id = (phy_reg & 0xffff) << 16; 302 *phy_id = (phy_reg & 0xffff) << 16;
303 303
304 /* Grab the bits from PHYIR2, and put them in the lower half */ 304 /* Grab the bits from PHYIR2, and put them in the lower half */
305 phy_reg = mdiobus_read(bus, addr, MII_PHYSID2); 305 phy_reg = mdiobus_read(bus, addr, MII_PHYSID2);
306 if (phy_reg < 0) 306 if (phy_reg < 0)
307 return -EIO; 307 return -EIO;
308 308
309 *phy_id |= (phy_reg & 0xffff); 309 *phy_id |= (phy_reg & 0xffff);
310 310
311 return 0; 311 return 0;
312 } 312 }
313 313
314 /** 314 /**
315 * get_phy_device - reads the specified PHY device and returns its @phy_device 315 * get_phy_device - reads the specified PHY device and returns its @phy_device
316 * struct 316 * struct
317 * @bus: the target MII bus 317 * @bus: the target MII bus
318 * @addr: PHY address on the MII bus 318 * @addr: PHY address on the MII bus
319 * @is_c45: If true the PHY uses the 802.3 clause 45 protocol 319 * @is_c45: If true the PHY uses the 802.3 clause 45 protocol
320 * 320 *
321 * Description: Reads the ID registers of the PHY at @addr on the 321 * Description: Reads the ID registers of the PHY at @addr on the
322 * @bus, then allocates and returns the phy_device to represent it. 322 * @bus, then allocates and returns the phy_device to represent it.
323 */ 323 */
324 struct phy_device *get_phy_device(struct mii_bus *bus, int addr, bool is_c45) 324 struct phy_device *get_phy_device(struct mii_bus *bus, int addr, bool is_c45)
325 { 325 {
326 struct phy_c45_device_ids c45_ids = {0}; 326 struct phy_c45_device_ids c45_ids = {0};
327 u32 phy_id = 0; 327 u32 phy_id = 0;
328 int r; 328 int r;
329 329
330 r = get_phy_id(bus, addr, &phy_id, is_c45, &c45_ids); 330 r = get_phy_id(bus, addr, &phy_id, is_c45, &c45_ids);
331 if (r) 331 if (r)
332 return ERR_PTR(r); 332 return ERR_PTR(r);
333 333
334 /* If the phy_id is mostly Fs, there is no device there */ 334 /* If the phy_id is mostly Fs, there is no device there */
335 if ((phy_id & 0x1fffffff) == 0x1fffffff) 335 if ((phy_id & 0x1fffffff) == 0x1fffffff)
336 return NULL; 336 return NULL;
337 337
338 return phy_device_create(bus, addr, phy_id, is_c45, &c45_ids); 338 return phy_device_create(bus, addr, phy_id, is_c45, &c45_ids);
339 } 339 }
340 EXPORT_SYMBOL(get_phy_device); 340 EXPORT_SYMBOL(get_phy_device);
341 341
342 /** 342 /**
343 * phy_device_register - Register the phy device on the MDIO bus 343 * phy_device_register - Register the phy device on the MDIO bus
344 * @phydev: phy_device structure to be added to the MDIO bus 344 * @phydev: phy_device structure to be added to the MDIO bus
345 */ 345 */
346 int phy_device_register(struct phy_device *phydev) 346 int phy_device_register(struct phy_device *phydev)
347 { 347 {
348 int err; 348 int err;
349 349
350 /* Don't register a phy if one is already registered at this address */ 350 /* Don't register a phy if one is already registered at this address */
351 if (phydev->bus->phy_map[phydev->addr]) 351 if (phydev->bus->phy_map[phydev->addr])
352 return -EINVAL; 352 return -EINVAL;
353 phydev->bus->phy_map[phydev->addr] = phydev; 353 phydev->bus->phy_map[phydev->addr] = phydev;
354 354
355 /* Run all of the fixups for this PHY */ 355 /* Run all of the fixups for this PHY */
356 err = phy_init_hw(phydev); 356 err = phy_init_hw(phydev);
357 if (err) { 357 if (err) {
358 pr_err("PHY %d failed to initialize\n", phydev->addr); 358 pr_err("PHY %d failed to initialize\n", phydev->addr);
359 goto out; 359 goto out;
360 } 360 }
361 361
362 err = device_add(&phydev->dev); 362 err = device_add(&phydev->dev);
363 if (err) { 363 if (err) {
364 pr_err("PHY %d failed to add\n", phydev->addr); 364 pr_err("PHY %d failed to add\n", phydev->addr);
365 goto out; 365 goto out;
366 } 366 }
367 367
368 return 0; 368 return 0;
369 369
370 out: 370 out:
371 phydev->bus->phy_map[phydev->addr] = NULL; 371 phydev->bus->phy_map[phydev->addr] = NULL;
372 return err; 372 return err;
373 } 373 }
374 EXPORT_SYMBOL(phy_device_register); 374 EXPORT_SYMBOL(phy_device_register);
375 375
376 /** 376 /**
377 * phy_find_first - finds the first PHY device on the bus 377 * phy_find_first - finds the first PHY device on the bus
378 * @bus: the target MII bus 378 * @bus: the target MII bus
379 */ 379 */
380 struct phy_device *phy_find_first(struct mii_bus *bus) 380 struct phy_device *phy_find_first(struct mii_bus *bus)
381 { 381 {
382 int addr; 382 int addr;
383 383
384 for (addr = 0; addr < PHY_MAX_ADDR; addr++) { 384 for (addr = 0; addr < PHY_MAX_ADDR; addr++) {
385 if (bus->phy_map[addr]) 385 if (bus->phy_map[addr])
386 return bus->phy_map[addr]; 386 return bus->phy_map[addr];
387 } 387 }
388 return NULL; 388 return NULL;
389 } 389 }
390 EXPORT_SYMBOL(phy_find_first); 390 EXPORT_SYMBOL(phy_find_first);
391 391
392 /** 392 /**
393 * phy_prepare_link - prepares the PHY layer to monitor link status 393 * phy_prepare_link - prepares the PHY layer to monitor link status
394 * @phydev: target phy_device struct 394 * @phydev: target phy_device struct
395 * @handler: callback function for link status change notifications 395 * @handler: callback function for link status change notifications
396 * 396 *
397 * Description: Tells the PHY infrastructure to handle the 397 * Description: Tells the PHY infrastructure to handle the
398 * gory details on monitoring link status (whether through 398 * gory details on monitoring link status (whether through
399 * polling or an interrupt), and to call back to the 399 * polling or an interrupt), and to call back to the
400 * connected device driver when the link status changes. 400 * connected device driver when the link status changes.
401 * If you want to monitor your own link state, don't call 401 * If you want to monitor your own link state, don't call
402 * this function. 402 * this function.
403 */ 403 */
404 static void phy_prepare_link(struct phy_device *phydev, 404 static void phy_prepare_link(struct phy_device *phydev,
405 void (*handler)(struct net_device *)) 405 void (*handler)(struct net_device *))
406 { 406 {
407 phydev->adjust_link = handler; 407 phydev->adjust_link = handler;
408 } 408 }
409 409
410 /** 410 /**
411 * phy_connect_direct - connect an ethernet device to a specific phy_device 411 * phy_connect_direct - connect an ethernet device to a specific phy_device
412 * @dev: the network device to connect 412 * @dev: the network device to connect
413 * @phydev: the pointer to the phy device 413 * @phydev: the pointer to the phy device
414 * @handler: callback function for state change notifications 414 * @handler: callback function for state change notifications
415 * @interface: PHY device's interface 415 * @interface: PHY device's interface
416 */ 416 */
417 int phy_connect_direct(struct net_device *dev, struct phy_device *phydev, 417 int phy_connect_direct(struct net_device *dev, struct phy_device *phydev,
418 void (*handler)(struct net_device *), 418 void (*handler)(struct net_device *),
419 phy_interface_t interface) 419 phy_interface_t interface)
420 { 420 {
421 int rc; 421 int rc;
422 422
423 rc = phy_attach_direct(dev, phydev, phydev->dev_flags, interface); 423 rc = phy_attach_direct(dev, phydev, phydev->dev_flags, interface);
424 if (rc) 424 if (rc)
425 return rc; 425 return rc;
426 426
427 phy_prepare_link(phydev, handler); 427 phy_prepare_link(phydev, handler);
428 phy_start_machine(phydev); 428 phy_start_machine(phydev);
429 if (phydev->irq > 0) 429 if (phydev->irq > 0)
430 phy_start_interrupts(phydev); 430 phy_start_interrupts(phydev);
431 431
432 return 0; 432 return 0;
433 } 433 }
434 EXPORT_SYMBOL(phy_connect_direct); 434 EXPORT_SYMBOL(phy_connect_direct);
435 435
436 /** 436 /**
437 * phy_connect - connect an ethernet device to a PHY device 437 * phy_connect - connect an ethernet device to a PHY device
438 * @dev: the network device to connect 438 * @dev: the network device to connect
439 * @bus_id: the id string of the PHY device to connect 439 * @bus_id: the id string of the PHY device to connect
440 * @handler: callback function for state change notifications 440 * @handler: callback function for state change notifications
441 * @interface: PHY device's interface 441 * @interface: PHY device's interface
442 * 442 *
443 * Description: Convenience function for connecting ethernet 443 * Description: Convenience function for connecting ethernet
444 * devices to PHY devices. The default behavior is for 444 * devices to PHY devices. The default behavior is for
445 * the PHY infrastructure to handle everything, and only notify 445 * the PHY infrastructure to handle everything, and only notify
446 * the connected driver when the link status changes. If you 446 * the connected driver when the link status changes. If you
447 * don't want, or can't use the provided functionality, you may 447 * don't want, or can't use the provided functionality, you may
448 * choose to call only the subset of functions which provide 448 * choose to call only the subset of functions which provide
449 * the desired functionality. 449 * the desired functionality.
450 */ 450 */
451 struct phy_device *phy_connect(struct net_device *dev, const char *bus_id, 451 struct phy_device *phy_connect(struct net_device *dev, const char *bus_id,
452 void (*handler)(struct net_device *), 452 void (*handler)(struct net_device *),
453 phy_interface_t interface) 453 phy_interface_t interface)
454 { 454 {
455 struct phy_device *phydev; 455 struct phy_device *phydev;
456 struct device *d; 456 struct device *d;
457 int rc; 457 int rc;
458 458
459 /* Search the list of PHY devices on the mdio bus for the 459 /* Search the list of PHY devices on the mdio bus for the
460 * PHY with the requested name 460 * PHY with the requested name
461 */ 461 */
462 d = bus_find_device_by_name(&mdio_bus_type, NULL, bus_id); 462 d = bus_find_device_by_name(&mdio_bus_type, NULL, bus_id);
463 if (!d) { 463 if (!d) {
464 pr_err("PHY %s not found\n", bus_id); 464 pr_err("PHY %s not found\n", bus_id);
465 return ERR_PTR(-ENODEV); 465 return ERR_PTR(-ENODEV);
466 } 466 }
467 phydev = to_phy_device(d); 467 phydev = to_phy_device(d);
468 468
469 rc = phy_connect_direct(dev, phydev, handler, interface); 469 rc = phy_connect_direct(dev, phydev, handler, interface);
470 if (rc) 470 if (rc)
471 return ERR_PTR(rc); 471 return ERR_PTR(rc);
472 472
473 return phydev; 473 return phydev;
474 } 474 }
475 EXPORT_SYMBOL(phy_connect); 475 EXPORT_SYMBOL(phy_connect);
476 476
477 /** 477 /**
478 * phy_disconnect - disable interrupts, stop state machine, and detach a PHY 478 * phy_disconnect - disable interrupts, stop state machine, and detach a PHY
479 * device 479 * device
480 * @phydev: target phy_device struct 480 * @phydev: target phy_device struct
481 */ 481 */
482 void phy_disconnect(struct phy_device *phydev) 482 void phy_disconnect(struct phy_device *phydev)
483 { 483 {
484 if (phydev->irq > 0) 484 if (phydev->irq > 0)
485 phy_stop_interrupts(phydev); 485 phy_stop_interrupts(phydev);
486 486
487 phy_stop_machine(phydev); 487 phy_stop_machine(phydev);
488 488
489 phydev->adjust_link = NULL; 489 phydev->adjust_link = NULL;
490 490
491 phy_detach(phydev); 491 phy_detach(phydev);
492 } 492 }
493 EXPORT_SYMBOL(phy_disconnect); 493 EXPORT_SYMBOL(phy_disconnect);
494 494
495 /** 495 /**
496 * phy_poll_reset - Safely wait until a PHY reset has properly completed 496 * phy_poll_reset - Safely wait until a PHY reset has properly completed
497 * @phydev: The PHY device to poll 497 * @phydev: The PHY device to poll
498 * 498 *
499 * Description: According to IEEE 802.3, Section 2, Subsection 22.2.4.1.1, as 499 * Description: According to IEEE 802.3, Section 2, Subsection 22.2.4.1.1, as
500 * published in 2008, a PHY reset may take up to 0.5 seconds. The MII BMCR 500 * published in 2008, a PHY reset may take up to 0.5 seconds. The MII BMCR
501 * register must be polled until the BMCR_RESET bit clears. 501 * register must be polled until the BMCR_RESET bit clears.
502 * 502 *
503 * Furthermore, any attempts to write to PHY registers may have no effect 503 * Furthermore, any attempts to write to PHY registers may have no effect
504 * or even generate MDIO bus errors until this is complete. 504 * or even generate MDIO bus errors until this is complete.
505 * 505 *
506 * Some PHYs (such as the Marvell 88E1111) don't entirely conform to the 506 * Some PHYs (such as the Marvell 88E1111) don't entirely conform to the
507 * standard and do not fully reset after the BMCR_RESET bit is set, and may 507 * standard and do not fully reset after the BMCR_RESET bit is set, and may
508 * even *REQUIRE* a soft-reset to properly restart autonegotiation. In an 508 * even *REQUIRE* a soft-reset to properly restart autonegotiation. In an
509 * effort to support such broken PHYs, this function is separate from the 509 * effort to support such broken PHYs, this function is separate from the
510 * standard phy_init_hw() which will zero all the other bits in the BMCR 510 * standard phy_init_hw() which will zero all the other bits in the BMCR
511 * and reapply all driver-specific and board-specific fixups. 511 * and reapply all driver-specific and board-specific fixups.
512 */ 512 */
513 static int phy_poll_reset(struct phy_device *phydev) 513 static int phy_poll_reset(struct phy_device *phydev)
514 { 514 {
515 /* Poll until the reset bit clears (50ms per retry == 0.6 sec) */ 515 /* Poll until the reset bit clears (50ms per retry == 0.6 sec) */
516 unsigned int retries = 12; 516 unsigned int retries = 12;
517 int ret; 517 int ret;
518 518
519 do { 519 do {
520 msleep(50); 520 msleep(50);
521 ret = phy_read(phydev, MII_BMCR); 521 ret = phy_read(phydev, MII_BMCR);
522 if (ret < 0) 522 if (ret < 0)
523 return ret; 523 return ret;
524 } while (ret & BMCR_RESET && --retries); 524 } while (ret & BMCR_RESET && --retries);
525 if (ret & BMCR_RESET) 525 if (ret & BMCR_RESET)
526 return -ETIMEDOUT; 526 return -ETIMEDOUT;
527 527
528 /* Some chips (smsc911x) may still need up to another 1ms after the 528 /* Some chips (smsc911x) may still need up to another 1ms after the
529 * BMCR_RESET bit is cleared before they are usable. 529 * BMCR_RESET bit is cleared before they are usable.
530 */ 530 */
531 msleep(1); 531 msleep(1);
532 return 0; 532 return 0;
533 } 533 }
534 534
535 int phy_init_hw(struct phy_device *phydev) 535 int phy_init_hw(struct phy_device *phydev)
536 { 536 {
537 int ret; 537 int ret;
538 538
539 if (!phydev->drv || !phydev->drv->config_init) 539 if (!phydev->drv || !phydev->drv->config_init)
540 return 0; 540 return 0;
541 541
542 ret = phy_write(phydev, MII_BMCR, BMCR_RESET); 542 ret = phy_write(phydev, MII_BMCR, BMCR_RESET);
543 if (ret < 0) 543 if (ret < 0)
544 return ret; 544 return ret;
545 545
546 ret = phy_poll_reset(phydev); 546 ret = phy_poll_reset(phydev);
547 if (ret < 0) 547 if (ret < 0)
548 return ret; 548 return ret;
549 549
550 ret = phy_scan_fixups(phydev); 550 ret = phy_scan_fixups(phydev);
551 if (ret < 0) 551 if (ret < 0)
552 return ret; 552 return ret;
553 553
554 return phydev->drv->config_init(phydev); 554 return phydev->drv->config_init(phydev);
555 } 555 }
556 EXPORT_SYMBOL(phy_init_hw); 556 EXPORT_SYMBOL(phy_init_hw);
557 557
558 /** 558 /**
559 * phy_attach_direct - attach a network device to a given PHY device pointer 559 * phy_attach_direct - attach a network device to a given PHY device pointer
560 * @dev: network device to attach 560 * @dev: network device to attach
561 * @phydev: Pointer to phy_device to attach 561 * @phydev: Pointer to phy_device to attach
562 * @flags: PHY device's dev_flags 562 * @flags: PHY device's dev_flags
563 * @interface: PHY device's interface 563 * @interface: PHY device's interface
564 * 564 *
565 * Description: Called by drivers to attach to a particular PHY 565 * Description: Called by drivers to attach to a particular PHY
566 * device. The phy_device is found, and properly hooked up 566 * device. The phy_device is found, and properly hooked up
567 * to the phy_driver. If no driver is attached, then a 567 * to the phy_driver. If no driver is attached, then a
568 * generic driver is used. The phy_device is given a ptr to 568 * generic driver is used. The phy_device is given a ptr to
569 * the attaching device, and given a callback for link status 569 * the attaching device, and given a callback for link status
570 * change. The phy_device is returned to the attaching driver. 570 * change. The phy_device is returned to the attaching driver.
571 */ 571 */
572 int phy_attach_direct(struct net_device *dev, struct phy_device *phydev, 572 int phy_attach_direct(struct net_device *dev, struct phy_device *phydev,
573 u32 flags, phy_interface_t interface) 573 u32 flags, phy_interface_t interface)
574 { 574 {
575 struct device *d = &phydev->dev; 575 struct device *d = &phydev->dev;
576 int err; 576 int err;
577 577
578 /* Assume that if there is no driver, that it doesn't 578 /* Assume that if there is no driver, that it doesn't
579 * exist, and we should use the genphy driver. 579 * exist, and we should use the genphy driver.
580 */ 580 */
581 if (NULL == d->driver) { 581 if (NULL == d->driver) {
582 if (phydev->is_c45) 582 if (phydev->is_c45)
583 d->driver = &genphy_driver[GENPHY_DRV_10G].driver; 583 d->driver = &genphy_driver[GENPHY_DRV_10G].driver;
584 else 584 else
585 d->driver = &genphy_driver[GENPHY_DRV_1G].driver; 585 d->driver = &genphy_driver[GENPHY_DRV_1G].driver;
586 586
587 err = d->driver->probe(d); 587 err = d->driver->probe(d);
588 if (err >= 0) 588 if (err >= 0)
589 err = device_bind_driver(d); 589 err = device_bind_driver(d);
590 590
591 if (err) 591 if (err)
592 return err; 592 return err;
593 } 593 }
594 594
595 if (phydev->attached_dev) { 595 if (phydev->attached_dev) {
596 dev_err(&dev->dev, "PHY already attached\n"); 596 dev_err(&dev->dev, "PHY already attached\n");
597 return -EBUSY; 597 return -EBUSY;
598 } 598 }
599 599
600 phydev->attached_dev = dev; 600 phydev->attached_dev = dev;
601 dev->phydev = phydev; 601 dev->phydev = phydev;
602 602
603 phydev->dev_flags = flags; 603 phydev->dev_flags = flags;
604 604
605 phydev->interface = interface; 605 phydev->interface = interface;
606 606
607 phydev->state = PHY_READY; 607 phydev->state = PHY_READY;
608 608
609 /* Do initial configuration here, now that 609 /* Do initial configuration here, now that
610 * we have certain key parameters 610 * we have certain key parameters
611 * (dev_flags and interface) 611 * (dev_flags and interface)
612 */ 612 */
613 err = phy_init_hw(phydev); 613 err = phy_init_hw(phydev);
614 if (err) 614 if (err)
615 phy_detach(phydev); 615 phy_detach(phydev);
616 616 else
617 phy_resume(phydev); 617 phy_resume(phydev);
618 618
619 return err; 619 return err;
620 } 620 }
621 EXPORT_SYMBOL(phy_attach_direct); 621 EXPORT_SYMBOL(phy_attach_direct);
622 622
623 /** 623 /**
624 * phy_attach - attach a network device to a particular PHY device 624 * phy_attach - attach a network device to a particular PHY device
625 * @dev: network device to attach 625 * @dev: network device to attach
626 * @bus_id: Bus ID of PHY device to attach 626 * @bus_id: Bus ID of PHY device to attach
627 * @interface: PHY device's interface 627 * @interface: PHY device's interface
628 * 628 *
629 * Description: Same as phy_attach_direct() except that a PHY bus_id 629 * Description: Same as phy_attach_direct() except that a PHY bus_id
630 * string is passed instead of a pointer to a struct phy_device. 630 * string is passed instead of a pointer to a struct phy_device.
631 */ 631 */
632 struct phy_device *phy_attach(struct net_device *dev, const char *bus_id, 632 struct phy_device *phy_attach(struct net_device *dev, const char *bus_id,
633 phy_interface_t interface) 633 phy_interface_t interface)
634 { 634 {
635 struct bus_type *bus = &mdio_bus_type; 635 struct bus_type *bus = &mdio_bus_type;
636 struct phy_device *phydev; 636 struct phy_device *phydev;
637 struct device *d; 637 struct device *d;
638 int rc; 638 int rc;
639 639
640 /* Search the list of PHY devices on the mdio bus for the 640 /* Search the list of PHY devices on the mdio bus for the
641 * PHY with the requested name 641 * PHY with the requested name
642 */ 642 */
643 d = bus_find_device_by_name(bus, NULL, bus_id); 643 d = bus_find_device_by_name(bus, NULL, bus_id);
644 if (!d) { 644 if (!d) {
645 pr_err("PHY %s not found\n", bus_id); 645 pr_err("PHY %s not found\n", bus_id);
646 return ERR_PTR(-ENODEV); 646 return ERR_PTR(-ENODEV);
647 } 647 }
648 phydev = to_phy_device(d); 648 phydev = to_phy_device(d);
649 649
650 rc = phy_attach_direct(dev, phydev, phydev->dev_flags, interface); 650 rc = phy_attach_direct(dev, phydev, phydev->dev_flags, interface);
651 if (rc) 651 if (rc)
652 return ERR_PTR(rc); 652 return ERR_PTR(rc);
653 653
654 return phydev; 654 return phydev;
655 } 655 }
656 EXPORT_SYMBOL(phy_attach); 656 EXPORT_SYMBOL(phy_attach);
657 657
658 /** 658 /**
659 * phy_detach - detach a PHY device from its network device 659 * phy_detach - detach a PHY device from its network device
660 * @phydev: target phy_device struct 660 * @phydev: target phy_device struct
661 */ 661 */
662 void phy_detach(struct phy_device *phydev) 662 void phy_detach(struct phy_device *phydev)
663 { 663 {
664 int i; 664 int i;
665 phydev->attached_dev->phydev = NULL; 665 phydev->attached_dev->phydev = NULL;
666 phydev->attached_dev = NULL; 666 phydev->attached_dev = NULL;
667 phy_suspend(phydev); 667 phy_suspend(phydev);
668 668
669 /* If the device had no specific driver before (i.e. - it 669 /* If the device had no specific driver before (i.e. - it
670 * was using the generic driver), we unbind the device 670 * was using the generic driver), we unbind the device
671 * from the generic driver so that there's a chance a 671 * from the generic driver so that there's a chance a
672 * real driver could be loaded 672 * real driver could be loaded
673 */ 673 */
674 for (i = 0; i < ARRAY_SIZE(genphy_driver); i++) { 674 for (i = 0; i < ARRAY_SIZE(genphy_driver); i++) {
675 if (phydev->dev.driver == &genphy_driver[i].driver) { 675 if (phydev->dev.driver == &genphy_driver[i].driver) {
676 device_release_driver(&phydev->dev); 676 device_release_driver(&phydev->dev);
677 break; 677 break;
678 } 678 }
679 } 679 }
680 } 680 }
681 EXPORT_SYMBOL(phy_detach); 681 EXPORT_SYMBOL(phy_detach);
682 682
683 int phy_suspend(struct phy_device *phydev) 683 int phy_suspend(struct phy_device *phydev)
684 { 684 {
685 struct phy_driver *phydrv = to_phy_driver(phydev->dev.driver); 685 struct phy_driver *phydrv = to_phy_driver(phydev->dev.driver);
686 struct ethtool_wolinfo wol = { .cmd = ETHTOOL_GWOL }; 686 struct ethtool_wolinfo wol = { .cmd = ETHTOOL_GWOL };
687 687
688 /* If the device has WOL enabled, we cannot suspend the PHY */ 688 /* If the device has WOL enabled, we cannot suspend the PHY */
689 phy_ethtool_get_wol(phydev, &wol); 689 phy_ethtool_get_wol(phydev, &wol);
690 if (wol.wolopts) 690 if (wol.wolopts)
691 return -EBUSY; 691 return -EBUSY;
692 692
693 if (phydrv->suspend) 693 if (phydrv->suspend)
694 return phydrv->suspend(phydev); 694 return phydrv->suspend(phydev);
695 return 0; 695 return 0;
696 } 696 }
697 697
698 int phy_resume(struct phy_device *phydev) 698 int phy_resume(struct phy_device *phydev)
699 { 699 {
700 struct phy_driver *phydrv = to_phy_driver(phydev->dev.driver); 700 struct phy_driver *phydrv = to_phy_driver(phydev->dev.driver);
701 701
702 if (phydrv->resume) 702 if (phydrv->resume)
703 return phydrv->resume(phydev); 703 return phydrv->resume(phydev);
704 return 0; 704 return 0;
705 } 705 }
706 706
707 /* Generic PHY support and helper functions */ 707 /* Generic PHY support and helper functions */
708 708
709 /** 709 /**
710 * genphy_config_advert - sanitize and advertise auto-negotiation parameters 710 * genphy_config_advert - sanitize and advertise auto-negotiation parameters
711 * @phydev: target phy_device struct 711 * @phydev: target phy_device struct
712 * 712 *
713 * Description: Writes MII_ADVERTISE with the appropriate values, 713 * Description: Writes MII_ADVERTISE with the appropriate values,
714 * after sanitizing the values to make sure we only advertise 714 * after sanitizing the values to make sure we only advertise
715 * what is supported. Returns < 0 on error, 0 if the PHY's advertisement 715 * what is supported. Returns < 0 on error, 0 if the PHY's advertisement
716 * hasn't changed, and > 0 if it has changed. 716 * hasn't changed, and > 0 if it has changed.
717 */ 717 */
718 static int genphy_config_advert(struct phy_device *phydev) 718 static int genphy_config_advert(struct phy_device *phydev)
719 { 719 {
720 u32 advertise; 720 u32 advertise;
721 int oldadv, adv, bmsr; 721 int oldadv, adv, bmsr;
722 int err, changed = 0; 722 int err, changed = 0;
723 723
724 /* Only allow advertising what this PHY supports */ 724 /* Only allow advertising what this PHY supports */
725 phydev->advertising &= phydev->supported; 725 phydev->advertising &= phydev->supported;
726 advertise = phydev->advertising; 726 advertise = phydev->advertising;
727 727
728 /* Setup standard advertisement */ 728 /* Setup standard advertisement */
729 adv = phy_read(phydev, MII_ADVERTISE); 729 adv = phy_read(phydev, MII_ADVERTISE);
730 if (adv < 0) 730 if (adv < 0)
731 return adv; 731 return adv;
732 732
733 oldadv = adv; 733 oldadv = adv;
734 adv &= ~(ADVERTISE_ALL | ADVERTISE_100BASE4 | ADVERTISE_PAUSE_CAP | 734 adv &= ~(ADVERTISE_ALL | ADVERTISE_100BASE4 | ADVERTISE_PAUSE_CAP |
735 ADVERTISE_PAUSE_ASYM); 735 ADVERTISE_PAUSE_ASYM);
736 adv |= ethtool_adv_to_mii_adv_t(advertise); 736 adv |= ethtool_adv_to_mii_adv_t(advertise);
737 737
738 if (adv != oldadv) { 738 if (adv != oldadv) {
739 err = phy_write(phydev, MII_ADVERTISE, adv); 739 err = phy_write(phydev, MII_ADVERTISE, adv);
740 740
741 if (err < 0) 741 if (err < 0)
742 return err; 742 return err;
743 changed = 1; 743 changed = 1;
744 } 744 }
745 745
746 bmsr = phy_read(phydev, MII_BMSR); 746 bmsr = phy_read(phydev, MII_BMSR);
747 if (bmsr < 0) 747 if (bmsr < 0)
748 return bmsr; 748 return bmsr;
749 749
750 /* Per 802.3-2008, Section 22.2.4.2.16 Extended status all 750 /* Per 802.3-2008, Section 22.2.4.2.16 Extended status all
751 * 1000Mbits/sec capable PHYs shall have the BMSR_ESTATEN bit set to a 751 * 1000Mbits/sec capable PHYs shall have the BMSR_ESTATEN bit set to a
752 * logical 1. 752 * logical 1.
753 */ 753 */
754 if (!(bmsr & BMSR_ESTATEN)) 754 if (!(bmsr & BMSR_ESTATEN))
755 return changed; 755 return changed;
756 756
757 /* Configure gigabit if it's supported */ 757 /* Configure gigabit if it's supported */
758 adv = phy_read(phydev, MII_CTRL1000); 758 adv = phy_read(phydev, MII_CTRL1000);
759 if (adv < 0) 759 if (adv < 0)
760 return adv; 760 return adv;
761 761
762 oldadv = adv; 762 oldadv = adv;
763 adv &= ~(ADVERTISE_1000FULL | ADVERTISE_1000HALF); 763 adv &= ~(ADVERTISE_1000FULL | ADVERTISE_1000HALF);
764 764
765 if (phydev->supported & (SUPPORTED_1000baseT_Half | 765 if (phydev->supported & (SUPPORTED_1000baseT_Half |
766 SUPPORTED_1000baseT_Full)) { 766 SUPPORTED_1000baseT_Full)) {
767 adv |= ethtool_adv_to_mii_ctrl1000_t(advertise); 767 adv |= ethtool_adv_to_mii_ctrl1000_t(advertise);
768 if (adv != oldadv) 768 if (adv != oldadv)
769 changed = 1; 769 changed = 1;
770 } 770 }
771 771
772 err = phy_write(phydev, MII_CTRL1000, adv); 772 err = phy_write(phydev, MII_CTRL1000, adv);
773 if (err < 0) 773 if (err < 0)
774 return err; 774 return err;
775 775
776 return changed; 776 return changed;
777 } 777 }
778 778
779 /** 779 /**
780 * genphy_setup_forced - configures/forces speed/duplex from @phydev 780 * genphy_setup_forced - configures/forces speed/duplex from @phydev
781 * @phydev: target phy_device struct 781 * @phydev: target phy_device struct
782 * 782 *
783 * Description: Configures MII_BMCR to force speed/duplex 783 * Description: Configures MII_BMCR to force speed/duplex
784 * to the values in phydev. Assumes that the values are valid. 784 * to the values in phydev. Assumes that the values are valid.
785 * Please see phy_sanitize_settings(). 785 * Please see phy_sanitize_settings().
786 */ 786 */
787 int genphy_setup_forced(struct phy_device *phydev) 787 int genphy_setup_forced(struct phy_device *phydev)
788 { 788 {
789 int ctl = 0; 789 int ctl = 0;
790 790
791 phydev->pause = 0; 791 phydev->pause = 0;
792 phydev->asym_pause = 0; 792 phydev->asym_pause = 0;
793 793
794 if (SPEED_1000 == phydev->speed) 794 if (SPEED_1000 == phydev->speed)
795 ctl |= BMCR_SPEED1000; 795 ctl |= BMCR_SPEED1000;
796 else if (SPEED_100 == phydev->speed) 796 else if (SPEED_100 == phydev->speed)
797 ctl |= BMCR_SPEED100; 797 ctl |= BMCR_SPEED100;
798 798
799 if (DUPLEX_FULL == phydev->duplex) 799 if (DUPLEX_FULL == phydev->duplex)
800 ctl |= BMCR_FULLDPLX; 800 ctl |= BMCR_FULLDPLX;
801 801
802 return phy_write(phydev, MII_BMCR, ctl); 802 return phy_write(phydev, MII_BMCR, ctl);
803 } 803 }
804 EXPORT_SYMBOL(genphy_setup_forced); 804 EXPORT_SYMBOL(genphy_setup_forced);
805 805
806 /** 806 /**
807 * genphy_restart_aneg - Enable and Restart Autonegotiation 807 * genphy_restart_aneg - Enable and Restart Autonegotiation
808 * @phydev: target phy_device struct 808 * @phydev: target phy_device struct
809 */ 809 */
810 int genphy_restart_aneg(struct phy_device *phydev) 810 int genphy_restart_aneg(struct phy_device *phydev)
811 { 811 {
812 int ctl = phy_read(phydev, MII_BMCR); 812 int ctl = phy_read(phydev, MII_BMCR);
813 813
814 if (ctl < 0) 814 if (ctl < 0)
815 return ctl; 815 return ctl;
816 816
817 ctl |= BMCR_ANENABLE | BMCR_ANRESTART; 817 ctl |= BMCR_ANENABLE | BMCR_ANRESTART;
818 818
819 /* Don't isolate the PHY if we're negotiating */ 819 /* Don't isolate the PHY if we're negotiating */
820 ctl &= ~BMCR_ISOLATE; 820 ctl &= ~BMCR_ISOLATE;
821 821
822 return phy_write(phydev, MII_BMCR, ctl); 822 return phy_write(phydev, MII_BMCR, ctl);
823 } 823 }
824 EXPORT_SYMBOL(genphy_restart_aneg); 824 EXPORT_SYMBOL(genphy_restart_aneg);
825 825
826 /** 826 /**
827 * genphy_config_aneg - restart auto-negotiation or write BMCR 827 * genphy_config_aneg - restart auto-negotiation or write BMCR
828 * @phydev: target phy_device struct 828 * @phydev: target phy_device struct
829 * 829 *
830 * Description: If auto-negotiation is enabled, we configure the 830 * Description: If auto-negotiation is enabled, we configure the
831 * advertising, and then restart auto-negotiation. If it is not 831 * advertising, and then restart auto-negotiation. If it is not
832 * enabled, then we write the BMCR. 832 * enabled, then we write the BMCR.
833 */ 833 */
834 int genphy_config_aneg(struct phy_device *phydev) 834 int genphy_config_aneg(struct phy_device *phydev)
835 { 835 {
836 int result; 836 int result;
837 837
838 if (AUTONEG_ENABLE != phydev->autoneg) 838 if (AUTONEG_ENABLE != phydev->autoneg)
839 return genphy_setup_forced(phydev); 839 return genphy_setup_forced(phydev);
840 840
841 result = genphy_config_advert(phydev); 841 result = genphy_config_advert(phydev);
842 if (result < 0) /* error */ 842 if (result < 0) /* error */
843 return result; 843 return result;
844 if (result == 0) { 844 if (result == 0) {
845 /* Advertisement hasn't changed, but maybe aneg was never on to 845 /* Advertisement hasn't changed, but maybe aneg was never on to
846 * begin with? Or maybe phy was isolated? 846 * begin with? Or maybe phy was isolated?
847 */ 847 */
848 int ctl = phy_read(phydev, MII_BMCR); 848 int ctl = phy_read(phydev, MII_BMCR);
849 849
850 if (ctl < 0) 850 if (ctl < 0)
851 return ctl; 851 return ctl;
852 852
853 if (!(ctl & BMCR_ANENABLE) || (ctl & BMCR_ISOLATE)) 853 if (!(ctl & BMCR_ANENABLE) || (ctl & BMCR_ISOLATE))
854 result = 1; /* do restart aneg */ 854 result = 1; /* do restart aneg */
855 } 855 }
856 856
857 /* Only restart aneg if we are advertising something different 857 /* Only restart aneg if we are advertising something different
858 * than we were before. 858 * than we were before.
859 */ 859 */
860 if (result > 0) 860 if (result > 0)
861 result = genphy_restart_aneg(phydev); 861 result = genphy_restart_aneg(phydev);
862 862
863 return result; 863 return result;
864 } 864 }
865 EXPORT_SYMBOL(genphy_config_aneg); 865 EXPORT_SYMBOL(genphy_config_aneg);
866 866
867 static int gen10g_config_aneg(struct phy_device *phydev) 867 static int gen10g_config_aneg(struct phy_device *phydev)
868 { 868 {
869 return 0; 869 return 0;
870 } 870 }
871 871
872 /** 872 /**
873 * genphy_update_link - update link status in @phydev 873 * genphy_update_link - update link status in @phydev
874 * @phydev: target phy_device struct 874 * @phydev: target phy_device struct
875 * 875 *
876 * Description: Update the value in phydev->link to reflect the 876 * Description: Update the value in phydev->link to reflect the
877 * current link value. In order to do this, we need to read 877 * current link value. In order to do this, we need to read
878 * the status register twice, keeping the second value. 878 * the status register twice, keeping the second value.
879 */ 879 */
880 int genphy_update_link(struct phy_device *phydev) 880 int genphy_update_link(struct phy_device *phydev)
881 { 881 {
882 int status; 882 int status;
883 883
884 /* Do a fake read */ 884 /* Do a fake read */
885 status = phy_read(phydev, MII_BMSR); 885 status = phy_read(phydev, MII_BMSR);
886 if (status < 0) 886 if (status < 0)
887 return status; 887 return status;
888 888
889 /* Read link and autonegotiation status */ 889 /* Read link and autonegotiation status */
890 status = phy_read(phydev, MII_BMSR); 890 status = phy_read(phydev, MII_BMSR);
891 if (status < 0) 891 if (status < 0)
892 return status; 892 return status;
893 893
894 if ((status & BMSR_LSTATUS) == 0) 894 if ((status & BMSR_LSTATUS) == 0)
895 phydev->link = 0; 895 phydev->link = 0;
896 else 896 else
897 phydev->link = 1; 897 phydev->link = 1;
898 898
899 return 0; 899 return 0;
900 } 900 }
901 EXPORT_SYMBOL(genphy_update_link); 901 EXPORT_SYMBOL(genphy_update_link);
902 902
903 /** 903 /**
904 * genphy_read_status - check the link status and update current link state 904 * genphy_read_status - check the link status and update current link state
905 * @phydev: target phy_device struct 905 * @phydev: target phy_device struct
906 * 906 *
907 * Description: Check the link, then figure out the current state 907 * Description: Check the link, then figure out the current state
908 * by comparing what we advertise with what the link partner 908 * by comparing what we advertise with what the link partner
909 * advertises. Start by checking the gigabit possibilities, 909 * advertises. Start by checking the gigabit possibilities,
910 * then move on to 10/100. 910 * then move on to 10/100.
911 */ 911 */
912 int genphy_read_status(struct phy_device *phydev) 912 int genphy_read_status(struct phy_device *phydev)
913 { 913 {
914 int adv; 914 int adv;
915 int err; 915 int err;
916 int lpa; 916 int lpa;
917 int lpagb = 0; 917 int lpagb = 0;
918 int common_adv; 918 int common_adv;
919 int common_adv_gb = 0; 919 int common_adv_gb = 0;
920 920
921 /* Update the link, but return if there was an error */ 921 /* Update the link, but return if there was an error */
922 err = genphy_update_link(phydev); 922 err = genphy_update_link(phydev);
923 if (err) 923 if (err)
924 return err; 924 return err;
925 925
926 phydev->lp_advertising = 0; 926 phydev->lp_advertising = 0;
927 927
928 if (AUTONEG_ENABLE == phydev->autoneg) { 928 if (AUTONEG_ENABLE == phydev->autoneg) {
929 if (phydev->supported & (SUPPORTED_1000baseT_Half 929 if (phydev->supported & (SUPPORTED_1000baseT_Half
930 | SUPPORTED_1000baseT_Full)) { 930 | SUPPORTED_1000baseT_Full)) {
931 lpagb = phy_read(phydev, MII_STAT1000); 931 lpagb = phy_read(phydev, MII_STAT1000);
932 if (lpagb < 0) 932 if (lpagb < 0)
933 return lpagb; 933 return lpagb;
934 934
935 adv = phy_read(phydev, MII_CTRL1000); 935 adv = phy_read(phydev, MII_CTRL1000);
936 if (adv < 0) 936 if (adv < 0)
937 return adv; 937 return adv;
938 938
939 phydev->lp_advertising = 939 phydev->lp_advertising =
940 mii_stat1000_to_ethtool_lpa_t(lpagb); 940 mii_stat1000_to_ethtool_lpa_t(lpagb);
941 common_adv_gb = lpagb & adv << 2; 941 common_adv_gb = lpagb & adv << 2;
942 } 942 }
943 943
944 lpa = phy_read(phydev, MII_LPA); 944 lpa = phy_read(phydev, MII_LPA);
945 if (lpa < 0) 945 if (lpa < 0)
946 return lpa; 946 return lpa;
947 947
948 phydev->lp_advertising |= mii_lpa_to_ethtool_lpa_t(lpa); 948 phydev->lp_advertising |= mii_lpa_to_ethtool_lpa_t(lpa);
949 949
950 adv = phy_read(phydev, MII_ADVERTISE); 950 adv = phy_read(phydev, MII_ADVERTISE);
951 if (adv < 0) 951 if (adv < 0)
952 return adv; 952 return adv;
953 953
954 common_adv = lpa & adv; 954 common_adv = lpa & adv;
955 955
956 phydev->speed = SPEED_10; 956 phydev->speed = SPEED_10;
957 phydev->duplex = DUPLEX_HALF; 957 phydev->duplex = DUPLEX_HALF;
958 phydev->pause = 0; 958 phydev->pause = 0;
959 phydev->asym_pause = 0; 959 phydev->asym_pause = 0;
960 960
961 if (common_adv_gb & (LPA_1000FULL | LPA_1000HALF)) { 961 if (common_adv_gb & (LPA_1000FULL | LPA_1000HALF)) {
962 phydev->speed = SPEED_1000; 962 phydev->speed = SPEED_1000;
963 963
964 if (common_adv_gb & LPA_1000FULL) 964 if (common_adv_gb & LPA_1000FULL)
965 phydev->duplex = DUPLEX_FULL; 965 phydev->duplex = DUPLEX_FULL;
966 } else if (common_adv & (LPA_100FULL | LPA_100HALF)) { 966 } else if (common_adv & (LPA_100FULL | LPA_100HALF)) {
967 phydev->speed = SPEED_100; 967 phydev->speed = SPEED_100;
968 968
969 if (common_adv & LPA_100FULL) 969 if (common_adv & LPA_100FULL)
970 phydev->duplex = DUPLEX_FULL; 970 phydev->duplex = DUPLEX_FULL;
971 } else 971 } else
972 if (common_adv & LPA_10FULL) 972 if (common_adv & LPA_10FULL)
973 phydev->duplex = DUPLEX_FULL; 973 phydev->duplex = DUPLEX_FULL;
974 974
975 if (phydev->duplex == DUPLEX_FULL) { 975 if (phydev->duplex == DUPLEX_FULL) {
976 phydev->pause = lpa & LPA_PAUSE_CAP ? 1 : 0; 976 phydev->pause = lpa & LPA_PAUSE_CAP ? 1 : 0;
977 phydev->asym_pause = lpa & LPA_PAUSE_ASYM ? 1 : 0; 977 phydev->asym_pause = lpa & LPA_PAUSE_ASYM ? 1 : 0;
978 } 978 }
979 } else { 979 } else {
980 int bmcr = phy_read(phydev, MII_BMCR); 980 int bmcr = phy_read(phydev, MII_BMCR);
981 981
982 if (bmcr < 0) 982 if (bmcr < 0)
983 return bmcr; 983 return bmcr;
984 984
985 if (bmcr & BMCR_FULLDPLX) 985 if (bmcr & BMCR_FULLDPLX)
986 phydev->duplex = DUPLEX_FULL; 986 phydev->duplex = DUPLEX_FULL;
987 else 987 else
988 phydev->duplex = DUPLEX_HALF; 988 phydev->duplex = DUPLEX_HALF;
989 989
990 if (bmcr & BMCR_SPEED1000) 990 if (bmcr & BMCR_SPEED1000)
991 phydev->speed = SPEED_1000; 991 phydev->speed = SPEED_1000;
992 else if (bmcr & BMCR_SPEED100) 992 else if (bmcr & BMCR_SPEED100)
993 phydev->speed = SPEED_100; 993 phydev->speed = SPEED_100;
994 else 994 else
995 phydev->speed = SPEED_10; 995 phydev->speed = SPEED_10;
996 996
997 phydev->pause = 0; 997 phydev->pause = 0;
998 phydev->asym_pause = 0; 998 phydev->asym_pause = 0;
999 } 999 }
1000 1000
1001 return 0; 1001 return 0;
1002 } 1002 }
1003 EXPORT_SYMBOL(genphy_read_status); 1003 EXPORT_SYMBOL(genphy_read_status);
1004 1004
1005 static int gen10g_read_status(struct phy_device *phydev) 1005 static int gen10g_read_status(struct phy_device *phydev)
1006 { 1006 {
1007 int devad, reg; 1007 int devad, reg;
1008 u32 mmd_mask = phydev->c45_ids.devices_in_package; 1008 u32 mmd_mask = phydev->c45_ids.devices_in_package;
1009 1009
1010 phydev->link = 1; 1010 phydev->link = 1;
1011 1011
1012 /* For now just lie and say it's 10G all the time */ 1012 /* For now just lie and say it's 10G all the time */
1013 phydev->speed = SPEED_10000; 1013 phydev->speed = SPEED_10000;
1014 phydev->duplex = DUPLEX_FULL; 1014 phydev->duplex = DUPLEX_FULL;
1015 1015
1016 for (devad = 0; mmd_mask; devad++, mmd_mask = mmd_mask >> 1) { 1016 for (devad = 0; mmd_mask; devad++, mmd_mask = mmd_mask >> 1) {
1017 if (!(mmd_mask & 1)) 1017 if (!(mmd_mask & 1))
1018 continue; 1018 continue;
1019 1019
1020 /* Read twice because link state is latched and a 1020 /* Read twice because link state is latched and a
1021 * read moves the current state into the register 1021 * read moves the current state into the register
1022 */ 1022 */
1023 phy_read_mmd(phydev, devad, MDIO_STAT1); 1023 phy_read_mmd(phydev, devad, MDIO_STAT1);
1024 reg = phy_read_mmd(phydev, devad, MDIO_STAT1); 1024 reg = phy_read_mmd(phydev, devad, MDIO_STAT1);
1025 if (reg < 0 || !(reg & MDIO_STAT1_LSTATUS)) 1025 if (reg < 0 || !(reg & MDIO_STAT1_LSTATUS))
1026 phydev->link = 0; 1026 phydev->link = 0;
1027 } 1027 }
1028 1028
1029 return 0; 1029 return 0;
1030 } 1030 }
1031 1031
1032 static int genphy_config_init(struct phy_device *phydev) 1032 static int genphy_config_init(struct phy_device *phydev)
1033 { 1033 {
1034 int val; 1034 int val;
1035 u32 features; 1035 u32 features;
1036 1036
1037 /* For now, I'll claim that the generic driver supports 1037 /* For now, I'll claim that the generic driver supports
1038 * all possible port types 1038 * all possible port types
1039 */ 1039 */
1040 features = (SUPPORTED_TP | SUPPORTED_MII 1040 features = (SUPPORTED_TP | SUPPORTED_MII
1041 | SUPPORTED_AUI | SUPPORTED_FIBRE | 1041 | SUPPORTED_AUI | SUPPORTED_FIBRE |
1042 SUPPORTED_BNC); 1042 SUPPORTED_BNC);
1043 1043
1044 /* Do we support autonegotiation? */ 1044 /* Do we support autonegotiation? */
1045 val = phy_read(phydev, MII_BMSR); 1045 val = phy_read(phydev, MII_BMSR);
1046 if (val < 0) 1046 if (val < 0)
1047 return val; 1047 return val;
1048 1048
1049 if (val & BMSR_ANEGCAPABLE) 1049 if (val & BMSR_ANEGCAPABLE)
1050 features |= SUPPORTED_Autoneg; 1050 features |= SUPPORTED_Autoneg;
1051 1051
1052 if (val & BMSR_100FULL) 1052 if (val & BMSR_100FULL)
1053 features |= SUPPORTED_100baseT_Full; 1053 features |= SUPPORTED_100baseT_Full;
1054 if (val & BMSR_100HALF) 1054 if (val & BMSR_100HALF)
1055 features |= SUPPORTED_100baseT_Half; 1055 features |= SUPPORTED_100baseT_Half;
1056 if (val & BMSR_10FULL) 1056 if (val & BMSR_10FULL)
1057 features |= SUPPORTED_10baseT_Full; 1057 features |= SUPPORTED_10baseT_Full;
1058 if (val & BMSR_10HALF) 1058 if (val & BMSR_10HALF)
1059 features |= SUPPORTED_10baseT_Half; 1059 features |= SUPPORTED_10baseT_Half;
1060 1060
1061 if (val & BMSR_ESTATEN) { 1061 if (val & BMSR_ESTATEN) {
1062 val = phy_read(phydev, MII_ESTATUS); 1062 val = phy_read(phydev, MII_ESTATUS);
1063 if (val < 0) 1063 if (val < 0)
1064 return val; 1064 return val;
1065 1065
1066 if (val & ESTATUS_1000_TFULL) 1066 if (val & ESTATUS_1000_TFULL)
1067 features |= SUPPORTED_1000baseT_Full; 1067 features |= SUPPORTED_1000baseT_Full;
1068 if (val & ESTATUS_1000_THALF) 1068 if (val & ESTATUS_1000_THALF)
1069 features |= SUPPORTED_1000baseT_Half; 1069 features |= SUPPORTED_1000baseT_Half;
1070 } 1070 }
1071 1071
1072 phydev->supported = features; 1072 phydev->supported = features;
1073 phydev->advertising = features; 1073 phydev->advertising = features;
1074 1074
1075 return 0; 1075 return 0;
1076 } 1076 }
1077 1077
1078 static int gen10g_config_init(struct phy_device *phydev) 1078 static int gen10g_config_init(struct phy_device *phydev)
1079 { 1079 {
1080 /* Temporarily just say we support everything */ 1080 /* Temporarily just say we support everything */
1081 phydev->supported = SUPPORTED_10000baseT_Full; 1081 phydev->supported = SUPPORTED_10000baseT_Full;
1082 phydev->advertising = SUPPORTED_10000baseT_Full; 1082 phydev->advertising = SUPPORTED_10000baseT_Full;
1083 1083
1084 return 0; 1084 return 0;
1085 } 1085 }
1086 1086
1087 int genphy_suspend(struct phy_device *phydev) 1087 int genphy_suspend(struct phy_device *phydev)
1088 { 1088 {
1089 int value; 1089 int value;
1090 1090
1091 mutex_lock(&phydev->lock); 1091 mutex_lock(&phydev->lock);
1092 1092
1093 value = phy_read(phydev, MII_BMCR); 1093 value = phy_read(phydev, MII_BMCR);
1094 phy_write(phydev, MII_BMCR, value | BMCR_PDOWN); 1094 phy_write(phydev, MII_BMCR, value | BMCR_PDOWN);
1095 1095
1096 mutex_unlock(&phydev->lock); 1096 mutex_unlock(&phydev->lock);
1097 1097
1098 return 0; 1098 return 0;
1099 } 1099 }
1100 EXPORT_SYMBOL(genphy_suspend); 1100 EXPORT_SYMBOL(genphy_suspend);
1101 1101
1102 static int gen10g_suspend(struct phy_device *phydev) 1102 static int gen10g_suspend(struct phy_device *phydev)
1103 { 1103 {
1104 return 0; 1104 return 0;
1105 } 1105 }
1106 1106
1107 int genphy_resume(struct phy_device *phydev) 1107 int genphy_resume(struct phy_device *phydev)
1108 { 1108 {
1109 int value; 1109 int value;
1110 1110
1111 mutex_lock(&phydev->lock); 1111 mutex_lock(&phydev->lock);
1112 1112
1113 value = phy_read(phydev, MII_BMCR); 1113 value = phy_read(phydev, MII_BMCR);
1114 phy_write(phydev, MII_BMCR, value & ~BMCR_PDOWN); 1114 phy_write(phydev, MII_BMCR, value & ~BMCR_PDOWN);
1115 1115
1116 mutex_unlock(&phydev->lock); 1116 mutex_unlock(&phydev->lock);
1117 1117
1118 return 0; 1118 return 0;
1119 } 1119 }
1120 EXPORT_SYMBOL(genphy_resume); 1120 EXPORT_SYMBOL(genphy_resume);
1121 1121
1122 static int gen10g_resume(struct phy_device *phydev) 1122 static int gen10g_resume(struct phy_device *phydev)
1123 { 1123 {
1124 return 0; 1124 return 0;
1125 } 1125 }
1126 1126
1127 /** 1127 /**
1128 * phy_probe - probe and init a PHY device 1128 * phy_probe - probe and init a PHY device
1129 * @dev: device to probe and init 1129 * @dev: device to probe and init
1130 * 1130 *
1131 * Description: Take care of setting up the phy_device structure, 1131 * Description: Take care of setting up the phy_device structure,
1132 * set the state to READY (the driver's init function should 1132 * set the state to READY (the driver's init function should
1133 * set it to STARTING if needed). 1133 * set it to STARTING if needed).
1134 */ 1134 */
1135 static int phy_probe(struct device *dev) 1135 static int phy_probe(struct device *dev)
1136 { 1136 {
1137 struct phy_device *phydev = to_phy_device(dev); 1137 struct phy_device *phydev = to_phy_device(dev);
1138 struct device_driver *drv = phydev->dev.driver; 1138 struct device_driver *drv = phydev->dev.driver;
1139 struct phy_driver *phydrv = to_phy_driver(drv); 1139 struct phy_driver *phydrv = to_phy_driver(drv);
1140 int err = 0; 1140 int err = 0;
1141 1141
1142 phydev->drv = phydrv; 1142 phydev->drv = phydrv;
1143 1143
1144 /* Disable the interrupt if the PHY doesn't support it 1144 /* Disable the interrupt if the PHY doesn't support it
1145 * but the interrupt is still a valid one 1145 * but the interrupt is still a valid one
1146 */ 1146 */
1147 if (!(phydrv->flags & PHY_HAS_INTERRUPT) && 1147 if (!(phydrv->flags & PHY_HAS_INTERRUPT) &&
1148 phy_interrupt_is_valid(phydev)) 1148 phy_interrupt_is_valid(phydev))
1149 phydev->irq = PHY_POLL; 1149 phydev->irq = PHY_POLL;
1150 1150
1151 if (phydrv->flags & PHY_IS_INTERNAL) 1151 if (phydrv->flags & PHY_IS_INTERNAL)
1152 phydev->is_internal = true; 1152 phydev->is_internal = true;
1153 1153
1154 mutex_lock(&phydev->lock); 1154 mutex_lock(&phydev->lock);
1155 1155
1156 /* Start out supporting everything. Eventually, 1156 /* Start out supporting everything. Eventually,
1157 * a controller will attach, and may modify one 1157 * a controller will attach, and may modify one
1158 * or both of these values 1158 * or both of these values
1159 */ 1159 */
1160 phydev->supported = phydrv->features; 1160 phydev->supported = phydrv->features;
1161 phydev->advertising = phydrv->features; 1161 phydev->advertising = phydrv->features;
1162 1162
1163 /* Set the state to READY by default */ 1163 /* Set the state to READY by default */
1164 phydev->state = PHY_READY; 1164 phydev->state = PHY_READY;
1165 1165
1166 if (phydev->drv->probe) 1166 if (phydev->drv->probe)
1167 err = phydev->drv->probe(phydev); 1167 err = phydev->drv->probe(phydev);
1168 1168
1169 mutex_unlock(&phydev->lock); 1169 mutex_unlock(&phydev->lock);
1170 1170
1171 return err; 1171 return err;
1172 } 1172 }
1173 1173
1174 static int phy_remove(struct device *dev) 1174 static int phy_remove(struct device *dev)
1175 { 1175 {
1176 struct phy_device *phydev = to_phy_device(dev); 1176 struct phy_device *phydev = to_phy_device(dev);
1177 1177
1178 mutex_lock(&phydev->lock); 1178 mutex_lock(&phydev->lock);
1179 phydev->state = PHY_DOWN; 1179 phydev->state = PHY_DOWN;
1180 mutex_unlock(&phydev->lock); 1180 mutex_unlock(&phydev->lock);
1181 1181
1182 if (phydev->drv->remove) 1182 if (phydev->drv->remove)
1183 phydev->drv->remove(phydev); 1183 phydev->drv->remove(phydev);
1184 phydev->drv = NULL; 1184 phydev->drv = NULL;
1185 1185
1186 return 0; 1186 return 0;
1187 } 1187 }
1188 1188
1189 /** 1189 /**
1190 * phy_driver_register - register a phy_driver with the PHY layer 1190 * phy_driver_register - register a phy_driver with the PHY layer
1191 * @new_driver: new phy_driver to register 1191 * @new_driver: new phy_driver to register
1192 */ 1192 */
1193 int phy_driver_register(struct phy_driver *new_driver) 1193 int phy_driver_register(struct phy_driver *new_driver)
1194 { 1194 {
1195 int retval; 1195 int retval;
1196 1196
1197 new_driver->driver.name = new_driver->name; 1197 new_driver->driver.name = new_driver->name;
1198 new_driver->driver.bus = &mdio_bus_type; 1198 new_driver->driver.bus = &mdio_bus_type;
1199 new_driver->driver.probe = phy_probe; 1199 new_driver->driver.probe = phy_probe;
1200 new_driver->driver.remove = phy_remove; 1200 new_driver->driver.remove = phy_remove;
1201 1201
1202 retval = driver_register(&new_driver->driver); 1202 retval = driver_register(&new_driver->driver);
1203 if (retval) { 1203 if (retval) {
1204 pr_err("%s: Error %d in registering driver\n", 1204 pr_err("%s: Error %d in registering driver\n",
1205 new_driver->name, retval); 1205 new_driver->name, retval);
1206 1206
1207 return retval; 1207 return retval;
1208 } 1208 }
1209 1209
1210 pr_debug("%s: Registered new driver\n", new_driver->name); 1210 pr_debug("%s: Registered new driver\n", new_driver->name);
1211 1211
1212 return 0; 1212 return 0;
1213 } 1213 }
1214 EXPORT_SYMBOL(phy_driver_register); 1214 EXPORT_SYMBOL(phy_driver_register);
1215 1215
1216 int phy_drivers_register(struct phy_driver *new_driver, int n) 1216 int phy_drivers_register(struct phy_driver *new_driver, int n)
1217 { 1217 {
1218 int i, ret = 0; 1218 int i, ret = 0;
1219 1219
1220 for (i = 0; i < n; i++) { 1220 for (i = 0; i < n; i++) {
1221 ret = phy_driver_register(new_driver + i); 1221 ret = phy_driver_register(new_driver + i);
1222 if (ret) { 1222 if (ret) {
1223 while (i-- > 0) 1223 while (i-- > 0)
1224 phy_driver_unregister(new_driver + i); 1224 phy_driver_unregister(new_driver + i);
1225 break; 1225 break;
1226 } 1226 }
1227 } 1227 }
1228 return ret; 1228 return ret;
1229 } 1229 }
1230 EXPORT_SYMBOL(phy_drivers_register); 1230 EXPORT_SYMBOL(phy_drivers_register);
1231 1231
1232 void phy_driver_unregister(struct phy_driver *drv) 1232 void phy_driver_unregister(struct phy_driver *drv)
1233 { 1233 {
1234 driver_unregister(&drv->driver); 1234 driver_unregister(&drv->driver);
1235 } 1235 }
1236 EXPORT_SYMBOL(phy_driver_unregister); 1236 EXPORT_SYMBOL(phy_driver_unregister);
1237 1237
1238 void phy_drivers_unregister(struct phy_driver *drv, int n) 1238 void phy_drivers_unregister(struct phy_driver *drv, int n)
1239 { 1239 {
1240 int i; 1240 int i;
1241 1241
1242 for (i = 0; i < n; i++) 1242 for (i = 0; i < n; i++)
1243 phy_driver_unregister(drv + i); 1243 phy_driver_unregister(drv + i);
1244 } 1244 }
1245 EXPORT_SYMBOL(phy_drivers_unregister); 1245 EXPORT_SYMBOL(phy_drivers_unregister);
1246 1246
1247 static struct phy_driver genphy_driver[] = { 1247 static struct phy_driver genphy_driver[] = {
1248 { 1248 {
1249 .phy_id = 0xffffffff, 1249 .phy_id = 0xffffffff,
1250 .phy_id_mask = 0xffffffff, 1250 .phy_id_mask = 0xffffffff,
1251 .name = "Generic PHY", 1251 .name = "Generic PHY",
1252 .config_init = genphy_config_init, 1252 .config_init = genphy_config_init,
1253 .features = 0, 1253 .features = 0,
1254 .config_aneg = genphy_config_aneg, 1254 .config_aneg = genphy_config_aneg,
1255 .read_status = genphy_read_status, 1255 .read_status = genphy_read_status,
1256 .suspend = genphy_suspend, 1256 .suspend = genphy_suspend,
1257 .resume = genphy_resume, 1257 .resume = genphy_resume,
1258 .driver = { .owner = THIS_MODULE, }, 1258 .driver = { .owner = THIS_MODULE, },
1259 }, { 1259 }, {
1260 .phy_id = 0xffffffff, 1260 .phy_id = 0xffffffff,
1261 .phy_id_mask = 0xffffffff, 1261 .phy_id_mask = 0xffffffff,
1262 .name = "Generic 10G PHY", 1262 .name = "Generic 10G PHY",
1263 .config_init = gen10g_config_init, 1263 .config_init = gen10g_config_init,
1264 .features = 0, 1264 .features = 0,
1265 .config_aneg = gen10g_config_aneg, 1265 .config_aneg = gen10g_config_aneg,
1266 .read_status = gen10g_read_status, 1266 .read_status = gen10g_read_status,
1267 .suspend = gen10g_suspend, 1267 .suspend = gen10g_suspend,
1268 .resume = gen10g_resume, 1268 .resume = gen10g_resume,
1269 .driver = {.owner = THIS_MODULE, }, 1269 .driver = {.owner = THIS_MODULE, },
1270 } }; 1270 } };
1271 1271
1272 static int __init phy_init(void) 1272 static int __init phy_init(void)
1273 { 1273 {
1274 int rc; 1274 int rc;
1275 1275
1276 rc = mdio_bus_init(); 1276 rc = mdio_bus_init();
1277 if (rc) 1277 if (rc)
1278 return rc; 1278 return rc;
1279 1279
1280 rc = phy_drivers_register(genphy_driver, 1280 rc = phy_drivers_register(genphy_driver,
1281 ARRAY_SIZE(genphy_driver)); 1281 ARRAY_SIZE(genphy_driver));
1282 if (rc) 1282 if (rc)
1283 mdio_bus_exit(); 1283 mdio_bus_exit();
1284 1284
1285 return rc; 1285 return rc;
1286 } 1286 }
1287 1287
1288 static void __exit phy_exit(void) 1288 static void __exit phy_exit(void)
1289 { 1289 {
1290 phy_drivers_unregister(genphy_driver, 1290 phy_drivers_unregister(genphy_driver,
1291 ARRAY_SIZE(genphy_driver)); 1291 ARRAY_SIZE(genphy_driver));
1292 mdio_bus_exit(); 1292 mdio_bus_exit();
1293 } 1293 }
1294 1294
1295 subsys_initcall(phy_init); 1295 subsys_initcall(phy_init);
1296 module_exit(phy_exit); 1296 module_exit(phy_exit);
1297 1297