phy.c 31 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258
  1. /* Framework for configuring and reading PHY devices
  2. * Based on code in sungem_phy.c and gianfar_phy.c
  3. *
  4. * Author: Andy Fleming
  5. *
  6. * Copyright (c) 2004 Freescale Semiconductor, Inc.
  7. * Copyright (c) 2006, 2007 Maciej W. Rozycki
  8. *
  9. * This program is free software; you can redistribute it and/or modify it
  10. * under the terms of the GNU General Public License as published by the
  11. * Free Software Foundation; either version 2 of the License, or (at your
  12. * option) any later version.
  13. *
  14. */
  15. #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  16. #include <linux/kernel.h>
  17. #include <linux/string.h>
  18. #include <linux/errno.h>
  19. #include <linux/unistd.h>
  20. #include <linux/interrupt.h>
  21. #include <linux/delay.h>
  22. #include <linux/netdevice.h>
  23. #include <linux/etherdevice.h>
  24. #include <linux/skbuff.h>
  25. #include <linux/mm.h>
  26. #include <linux/module.h>
  27. #include <linux/mii.h>
  28. #include <linux/ethtool.h>
  29. #include <linux/phy.h>
  30. #include <linux/timer.h>
  31. #include <linux/workqueue.h>
  32. #include <linux/mdio.h>
  33. #include <linux/io.h>
  34. #include <linux/uaccess.h>
  35. #include <linux/atomic.h>
  36. #include <asm/irq.h>
  37. static const char *phy_speed_to_str(int speed)
  38. {
  39. switch (speed) {
  40. case SPEED_10:
  41. return "10Mbps";
  42. case SPEED_100:
  43. return "100Mbps";
  44. case SPEED_1000:
  45. return "1Gbps";
  46. case SPEED_2500:
  47. return "2.5Gbps";
  48. case SPEED_10000:
  49. return "10Gbps";
  50. case SPEED_UNKNOWN:
  51. return "Unknown";
  52. default:
  53. return "Unsupported (update phy.c)";
  54. }
  55. }
  56. #define PHY_STATE_STR(_state) \
  57. case PHY_##_state: \
  58. return __stringify(_state); \
  59. static const char *phy_state_to_str(enum phy_state st)
  60. {
  61. switch (st) {
  62. PHY_STATE_STR(DOWN)
  63. PHY_STATE_STR(STARTING)
  64. PHY_STATE_STR(READY)
  65. PHY_STATE_STR(PENDING)
  66. PHY_STATE_STR(UP)
  67. PHY_STATE_STR(AN)
  68. PHY_STATE_STR(RUNNING)
  69. PHY_STATE_STR(NOLINK)
  70. PHY_STATE_STR(FORCING)
  71. PHY_STATE_STR(CHANGELINK)
  72. PHY_STATE_STR(HALTED)
  73. PHY_STATE_STR(RESUMING)
  74. }
  75. return NULL;
  76. }
  77. /**
  78. * phy_print_status - Convenience function to print out the current phy status
  79. * @phydev: the phy_device struct
  80. */
  81. void phy_print_status(struct phy_device *phydev)
  82. {
  83. if (phydev->link) {
  84. netdev_info(phydev->attached_dev,
  85. "Link is Up - %s/%s - flow control %s\n",
  86. phy_speed_to_str(phydev->speed),
  87. DUPLEX_FULL == phydev->duplex ? "Full" : "Half",
  88. phydev->pause ? "rx/tx" : "off");
  89. } else {
  90. netdev_info(phydev->attached_dev, "Link is Down\n");
  91. }
  92. }
  93. EXPORT_SYMBOL(phy_print_status);
  94. /**
  95. * phy_clear_interrupt - Ack the phy device's interrupt
  96. * @phydev: the phy_device struct
  97. *
  98. * If the @phydev driver has an ack_interrupt function, call it to
  99. * ack and clear the phy device's interrupt.
  100. *
  101. * Returns 0 on success or < 0 on error.
  102. */
  103. static int phy_clear_interrupt(struct phy_device *phydev)
  104. {
  105. if (phydev->drv->ack_interrupt)
  106. return phydev->drv->ack_interrupt(phydev);
  107. return 0;
  108. }
  109. /**
  110. * phy_config_interrupt - configure the PHY device for the requested interrupts
  111. * @phydev: the phy_device struct
  112. * @interrupts: interrupt flags to configure for this @phydev
  113. *
  114. * Returns 0 on success or < 0 on error.
  115. */
  116. static int phy_config_interrupt(struct phy_device *phydev, u32 interrupts)
  117. {
  118. phydev->interrupts = interrupts;
  119. if (phydev->drv->config_intr)
  120. return phydev->drv->config_intr(phydev);
  121. return 0;
  122. }
  123. /**
  124. * phy_aneg_done - return auto-negotiation status
  125. * @phydev: target phy_device struct
  126. *
  127. * Description: Return the auto-negotiation status from this @phydev
  128. * Returns > 0 on success or < 0 on error. 0 means that auto-negotiation
  129. * is still pending.
  130. */
  131. static inline int phy_aneg_done(struct phy_device *phydev)
  132. {
  133. if (phydev->drv->aneg_done)
  134. return phydev->drv->aneg_done(phydev);
  135. return genphy_aneg_done(phydev);
  136. }
  137. /* A structure for mapping a particular speed and duplex
  138. * combination to a particular SUPPORTED and ADVERTISED value
  139. */
  140. struct phy_setting {
  141. int speed;
  142. int duplex;
  143. u32 setting;
  144. };
  145. /* A mapping of all SUPPORTED settings to speed/duplex */
  146. static const struct phy_setting settings[] = {
  147. {
  148. .speed = SPEED_10000,
  149. .duplex = DUPLEX_FULL,
  150. .setting = SUPPORTED_10000baseKR_Full,
  151. },
  152. {
  153. .speed = SPEED_10000,
  154. .duplex = DUPLEX_FULL,
  155. .setting = SUPPORTED_10000baseKX4_Full,
  156. },
  157. {
  158. .speed = SPEED_10000,
  159. .duplex = DUPLEX_FULL,
  160. .setting = SUPPORTED_10000baseT_Full,
  161. },
  162. {
  163. .speed = SPEED_2500,
  164. .duplex = DUPLEX_FULL,
  165. .setting = SUPPORTED_2500baseX_Full,
  166. },
  167. {
  168. .speed = SPEED_1000,
  169. .duplex = DUPLEX_FULL,
  170. .setting = SUPPORTED_1000baseKX_Full,
  171. },
  172. {
  173. .speed = SPEED_1000,
  174. .duplex = DUPLEX_FULL,
  175. .setting = SUPPORTED_1000baseT_Full,
  176. },
  177. {
  178. .speed = SPEED_1000,
  179. .duplex = DUPLEX_HALF,
  180. .setting = SUPPORTED_1000baseT_Half,
  181. },
  182. {
  183. .speed = SPEED_100,
  184. .duplex = DUPLEX_FULL,
  185. .setting = SUPPORTED_100baseT_Full,
  186. },
  187. {
  188. .speed = SPEED_100,
  189. .duplex = DUPLEX_HALF,
  190. .setting = SUPPORTED_100baseT_Half,
  191. },
  192. {
  193. .speed = SPEED_10,
  194. .duplex = DUPLEX_FULL,
  195. .setting = SUPPORTED_10baseT_Full,
  196. },
  197. {
  198. .speed = SPEED_10,
  199. .duplex = DUPLEX_HALF,
  200. .setting = SUPPORTED_10baseT_Half,
  201. },
  202. };
  203. #define MAX_NUM_SETTINGS ARRAY_SIZE(settings)
  204. /**
  205. * phy_find_setting - find a PHY settings array entry that matches speed & duplex
  206. * @speed: speed to match
  207. * @duplex: duplex to match
  208. *
  209. * Description: Searches the settings array for the setting which
  210. * matches the desired speed and duplex, and returns the index
  211. * of that setting. Returns the index of the last setting if
  212. * none of the others match.
  213. */
  214. static inline unsigned int phy_find_setting(int speed, int duplex)
  215. {
  216. unsigned int idx = 0;
  217. while (idx < ARRAY_SIZE(settings) &&
  218. (settings[idx].speed != speed || settings[idx].duplex != duplex))
  219. idx++;
  220. return idx < MAX_NUM_SETTINGS ? idx : MAX_NUM_SETTINGS - 1;
  221. }
  222. /**
  223. * phy_find_valid - find a PHY setting that matches the requested features mask
  224. * @idx: The first index in settings[] to search
  225. * @features: A mask of the valid settings
  226. *
  227. * Description: Returns the index of the first valid setting less
  228. * than or equal to the one pointed to by idx, as determined by
  229. * the mask in features. Returns the index of the last setting
  230. * if nothing else matches.
  231. */
  232. static inline unsigned int phy_find_valid(unsigned int idx, u32 features)
  233. {
  234. while (idx < MAX_NUM_SETTINGS && !(settings[idx].setting & features))
  235. idx++;
  236. return idx < MAX_NUM_SETTINGS ? idx : MAX_NUM_SETTINGS - 1;
  237. }
  238. /**
  239. * phy_check_valid - check if there is a valid PHY setting which matches
  240. * speed, duplex, and feature mask
  241. * @speed: speed to match
  242. * @duplex: duplex to match
  243. * @features: A mask of the valid settings
  244. *
  245. * Description: Returns true if there is a valid setting, false otherwise.
  246. */
  247. static inline bool phy_check_valid(int speed, int duplex, u32 features)
  248. {
  249. unsigned int idx;
  250. idx = phy_find_valid(phy_find_setting(speed, duplex), features);
  251. return settings[idx].speed == speed && settings[idx].duplex == duplex &&
  252. (settings[idx].setting & features);
  253. }
  254. /**
  255. * phy_sanitize_settings - make sure the PHY is set to supported speed and duplex
  256. * @phydev: the target phy_device struct
  257. *
  258. * Description: Make sure the PHY is set to supported speeds and
  259. * duplexes. Drop down by one in this order: 1000/FULL,
  260. * 1000/HALF, 100/FULL, 100/HALF, 10/FULL, 10/HALF.
  261. */
  262. static void phy_sanitize_settings(struct phy_device *phydev)
  263. {
  264. u32 features = phydev->supported;
  265. unsigned int idx;
  266. /* Sanitize settings based on PHY capabilities */
  267. if ((features & SUPPORTED_Autoneg) == 0)
  268. phydev->autoneg = AUTONEG_DISABLE;
  269. idx = phy_find_valid(phy_find_setting(phydev->speed, phydev->duplex),
  270. features);
  271. phydev->speed = settings[idx].speed;
  272. phydev->duplex = settings[idx].duplex;
  273. }
  274. /**
  275. * phy_ethtool_sset - generic ethtool sset function, handles all the details
  276. * @phydev: target phy_device struct
  277. * @cmd: ethtool_cmd
  278. *
  279. * A few notes about parameter checking:
  280. * - We don't set port or transceiver, so we don't care what they
  281. * were set to.
  282. * - phy_start_aneg() will make sure forced settings are sane, and
  283. * choose the next best ones from the ones selected, so we don't
  284. * care if ethtool tries to give us bad values.
  285. */
  286. int phy_ethtool_sset(struct phy_device *phydev, struct ethtool_cmd *cmd)
  287. {
  288. u32 speed = ethtool_cmd_speed(cmd);
  289. if (cmd->phy_address != phydev->mdio.addr)
  290. return -EINVAL;
  291. /* We make sure that we don't pass unsupported values in to the PHY */
  292. cmd->advertising &= phydev->supported;
  293. /* Verify the settings we care about. */
  294. if (cmd->autoneg != AUTONEG_ENABLE && cmd->autoneg != AUTONEG_DISABLE)
  295. return -EINVAL;
  296. if (cmd->autoneg == AUTONEG_ENABLE && cmd->advertising == 0)
  297. return -EINVAL;
  298. if (cmd->autoneg == AUTONEG_DISABLE &&
  299. ((speed != SPEED_1000 &&
  300. speed != SPEED_100 &&
  301. speed != SPEED_10) ||
  302. (cmd->duplex != DUPLEX_HALF &&
  303. cmd->duplex != DUPLEX_FULL)))
  304. return -EINVAL;
  305. phydev->autoneg = cmd->autoneg;
  306. phydev->speed = speed;
  307. phydev->advertising = cmd->advertising;
  308. if (AUTONEG_ENABLE == cmd->autoneg)
  309. phydev->advertising |= ADVERTISED_Autoneg;
  310. else
  311. phydev->advertising &= ~ADVERTISED_Autoneg;
  312. phydev->duplex = cmd->duplex;
  313. phydev->mdix = cmd->eth_tp_mdix_ctrl;
  314. /* Restart the PHY */
  315. phy_start_aneg(phydev);
  316. return 0;
  317. }
  318. EXPORT_SYMBOL(phy_ethtool_sset);
  319. int phy_ethtool_gset(struct phy_device *phydev, struct ethtool_cmd *cmd)
  320. {
  321. cmd->supported = phydev->supported;
  322. cmd->advertising = phydev->advertising;
  323. cmd->lp_advertising = phydev->lp_advertising;
  324. ethtool_cmd_speed_set(cmd, phydev->speed);
  325. cmd->duplex = phydev->duplex;
  326. if (phydev->interface == PHY_INTERFACE_MODE_MOCA)
  327. cmd->port = PORT_BNC;
  328. else
  329. cmd->port = PORT_MII;
  330. cmd->phy_address = phydev->mdio.addr;
  331. cmd->transceiver = phy_is_internal(phydev) ?
  332. XCVR_INTERNAL : XCVR_EXTERNAL;
  333. cmd->autoneg = phydev->autoneg;
  334. cmd->eth_tp_mdix_ctrl = phydev->mdix;
  335. return 0;
  336. }
  337. EXPORT_SYMBOL(phy_ethtool_gset);
  338. /**
  339. * phy_mii_ioctl - generic PHY MII ioctl interface
  340. * @phydev: the phy_device struct
  341. * @ifr: &struct ifreq for socket ioctl's
  342. * @cmd: ioctl cmd to execute
  343. *
  344. * Note that this function is currently incompatible with the
  345. * PHYCONTROL layer. It changes registers without regard to
  346. * current state. Use at own risk.
  347. */
  348. int phy_mii_ioctl(struct phy_device *phydev, struct ifreq *ifr, int cmd)
  349. {
  350. struct mii_ioctl_data *mii_data = if_mii(ifr);
  351. u16 val = mii_data->val_in;
  352. bool change_autoneg = false;
  353. switch (cmd) {
  354. case SIOCGMIIPHY:
  355. mii_data->phy_id = phydev->mdio.addr;
  356. /* fall through */
  357. case SIOCGMIIREG:
  358. mii_data->val_out = mdiobus_read(phydev->mdio.bus,
  359. mii_data->phy_id,
  360. mii_data->reg_num);
  361. return 0;
  362. case SIOCSMIIREG:
  363. if (mii_data->phy_id == phydev->mdio.addr) {
  364. switch (mii_data->reg_num) {
  365. case MII_BMCR:
  366. if ((val & (BMCR_RESET | BMCR_ANENABLE)) == 0) {
  367. if (phydev->autoneg == AUTONEG_ENABLE)
  368. change_autoneg = true;
  369. phydev->autoneg = AUTONEG_DISABLE;
  370. if (val & BMCR_FULLDPLX)
  371. phydev->duplex = DUPLEX_FULL;
  372. else
  373. phydev->duplex = DUPLEX_HALF;
  374. if (val & BMCR_SPEED1000)
  375. phydev->speed = SPEED_1000;
  376. else if (val & BMCR_SPEED100)
  377. phydev->speed = SPEED_100;
  378. else phydev->speed = SPEED_10;
  379. }
  380. else {
  381. if (phydev->autoneg == AUTONEG_DISABLE)
  382. change_autoneg = true;
  383. phydev->autoneg = AUTONEG_ENABLE;
  384. }
  385. break;
  386. case MII_ADVERTISE:
  387. phydev->advertising = mii_adv_to_ethtool_adv_t(val);
  388. change_autoneg = true;
  389. break;
  390. default:
  391. /* do nothing */
  392. break;
  393. }
  394. }
  395. mdiobus_write(phydev->mdio.bus, mii_data->phy_id,
  396. mii_data->reg_num, val);
  397. if (mii_data->phy_id == phydev->mdio.addr &&
  398. mii_data->reg_num == MII_BMCR &&
  399. val & BMCR_RESET)
  400. return phy_init_hw(phydev);
  401. if (change_autoneg)
  402. return phy_start_aneg(phydev);
  403. return 0;
  404. case SIOCSHWTSTAMP:
  405. if (phydev->drv->hwtstamp)
  406. return phydev->drv->hwtstamp(phydev, ifr);
  407. /* fall through */
  408. default:
  409. return -EOPNOTSUPP;
  410. }
  411. }
  412. EXPORT_SYMBOL(phy_mii_ioctl);
  413. /**
  414. * phy_start_aneg - start auto-negotiation for this PHY device
  415. * @phydev: the phy_device struct
  416. *
  417. * Description: Sanitizes the settings (if we're not autonegotiating
  418. * them), and then calls the driver's config_aneg function.
  419. * If the PHYCONTROL Layer is operating, we change the state to
  420. * reflect the beginning of Auto-negotiation or forcing.
  421. */
  422. int phy_start_aneg(struct phy_device *phydev)
  423. {
  424. int err;
  425. mutex_lock(&phydev->lock);
  426. if (AUTONEG_DISABLE == phydev->autoneg)
  427. phy_sanitize_settings(phydev);
  428. /* Invalidate LP advertising flags */
  429. phydev->lp_advertising = 0;
  430. err = phydev->drv->config_aneg(phydev);
  431. if (err < 0)
  432. goto out_unlock;
  433. if (phydev->state != PHY_HALTED) {
  434. if (AUTONEG_ENABLE == phydev->autoneg) {
  435. phydev->state = PHY_AN;
  436. phydev->link_timeout = PHY_AN_TIMEOUT;
  437. } else {
  438. phydev->state = PHY_FORCING;
  439. phydev->link_timeout = PHY_FORCE_TIMEOUT;
  440. }
  441. }
  442. out_unlock:
  443. mutex_unlock(&phydev->lock);
  444. return err;
  445. }
  446. EXPORT_SYMBOL(phy_start_aneg);
  447. /**
  448. * phy_start_machine - start PHY state machine tracking
  449. * @phydev: the phy_device struct
  450. *
  451. * Description: The PHY infrastructure can run a state machine
  452. * which tracks whether the PHY is starting up, negotiating,
  453. * etc. This function starts the timer which tracks the state
  454. * of the PHY. If you want to maintain your own state machine,
  455. * do not call this function.
  456. */
  457. void phy_start_machine(struct phy_device *phydev)
  458. {
  459. queue_delayed_work(system_power_efficient_wq, &phydev->state_queue, HZ);
  460. }
  461. /**
  462. * phy_stop_machine - stop the PHY state machine tracking
  463. * @phydev: target phy_device struct
  464. *
  465. * Description: Stops the state machine timer, sets the state to UP
  466. * (unless it wasn't up yet). This function must be called BEFORE
  467. * phy_detach.
  468. */
  469. void phy_stop_machine(struct phy_device *phydev)
  470. {
  471. cancel_delayed_work_sync(&phydev->state_queue);
  472. mutex_lock(&phydev->lock);
  473. if (phydev->state > PHY_UP)
  474. phydev->state = PHY_UP;
  475. mutex_unlock(&phydev->lock);
  476. }
  477. /**
  478. * phy_error - enter HALTED state for this PHY device
  479. * @phydev: target phy_device struct
  480. *
  481. * Moves the PHY to the HALTED state in response to a read
  482. * or write error, and tells the controller the link is down.
  483. * Must not be called from interrupt context, or while the
  484. * phydev->lock is held.
  485. */
  486. static void phy_error(struct phy_device *phydev)
  487. {
  488. mutex_lock(&phydev->lock);
  489. phydev->state = PHY_HALTED;
  490. mutex_unlock(&phydev->lock);
  491. }
  492. /**
  493. * phy_interrupt - PHY interrupt handler
  494. * @irq: interrupt line
  495. * @phy_dat: phy_device pointer
  496. *
  497. * Description: When a PHY interrupt occurs, the handler disables
  498. * interrupts, and schedules a work task to clear the interrupt.
  499. */
  500. static irqreturn_t phy_interrupt(int irq, void *phy_dat)
  501. {
  502. struct phy_device *phydev = phy_dat;
  503. if (PHY_HALTED == phydev->state)
  504. return IRQ_NONE; /* It can't be ours. */
  505. /* The MDIO bus is not allowed to be written in interrupt
  506. * context, so we need to disable the irq here. A work
  507. * queue will write the PHY to disable and clear the
  508. * interrupt, and then reenable the irq line.
  509. */
  510. disable_irq_nosync(irq);
  511. atomic_inc(&phydev->irq_disable);
  512. queue_work(system_power_efficient_wq, &phydev->phy_queue);
  513. return IRQ_HANDLED;
  514. }
  515. /**
  516. * phy_enable_interrupts - Enable the interrupts from the PHY side
  517. * @phydev: target phy_device struct
  518. */
  519. static int phy_enable_interrupts(struct phy_device *phydev)
  520. {
  521. int err = phy_clear_interrupt(phydev);
  522. if (err < 0)
  523. return err;
  524. return phy_config_interrupt(phydev, PHY_INTERRUPT_ENABLED);
  525. }
  526. /**
  527. * phy_disable_interrupts - Disable the PHY interrupts from the PHY side
  528. * @phydev: target phy_device struct
  529. */
  530. static int phy_disable_interrupts(struct phy_device *phydev)
  531. {
  532. int err;
  533. /* Disable PHY interrupts */
  534. err = phy_config_interrupt(phydev, PHY_INTERRUPT_DISABLED);
  535. if (err)
  536. goto phy_err;
  537. /* Clear the interrupt */
  538. err = phy_clear_interrupt(phydev);
  539. if (err)
  540. goto phy_err;
  541. return 0;
  542. phy_err:
  543. phy_error(phydev);
  544. return err;
  545. }
  546. /**
  547. * phy_start_interrupts - request and enable interrupts for a PHY device
  548. * @phydev: target phy_device struct
  549. *
  550. * Description: Request the interrupt for the given PHY.
  551. * If this fails, then we set irq to PHY_POLL.
  552. * Otherwise, we enable the interrupts in the PHY.
  553. * This should only be called with a valid IRQ number.
  554. * Returns 0 on success or < 0 on error.
  555. */
  556. int phy_start_interrupts(struct phy_device *phydev)
  557. {
  558. atomic_set(&phydev->irq_disable, 0);
  559. if (request_irq(phydev->irq, phy_interrupt, 0, "phy_interrupt",
  560. phydev) < 0) {
  561. pr_warn("%s: Can't get IRQ %d (PHY)\n",
  562. phydev->mdio.bus->name, phydev->irq);
  563. phydev->irq = PHY_POLL;
  564. return 0;
  565. }
  566. return phy_enable_interrupts(phydev);
  567. }
  568. EXPORT_SYMBOL(phy_start_interrupts);
  569. /**
  570. * phy_stop_interrupts - disable interrupts from a PHY device
  571. * @phydev: target phy_device struct
  572. */
  573. int phy_stop_interrupts(struct phy_device *phydev)
  574. {
  575. int err = phy_disable_interrupts(phydev);
  576. if (err)
  577. phy_error(phydev);
  578. free_irq(phydev->irq, phydev);
  579. /* Cannot call flush_scheduled_work() here as desired because
  580. * of rtnl_lock(), but we do not really care about what would
  581. * be done, except from enable_irq(), so cancel any work
  582. * possibly pending and take care of the matter below.
  583. */
  584. cancel_work_sync(&phydev->phy_queue);
  585. /* If work indeed has been cancelled, disable_irq() will have
  586. * been left unbalanced from phy_interrupt() and enable_irq()
  587. * has to be called so that other devices on the line work.
  588. */
  589. while (atomic_dec_return(&phydev->irq_disable) >= 0)
  590. enable_irq(phydev->irq);
  591. return err;
  592. }
  593. EXPORT_SYMBOL(phy_stop_interrupts);
  594. /**
  595. * phy_change - Scheduled by the phy_interrupt/timer to handle PHY changes
  596. * @work: work_struct that describes the work to be done
  597. */
  598. void phy_change(struct work_struct *work)
  599. {
  600. struct phy_device *phydev =
  601. container_of(work, struct phy_device, phy_queue);
  602. if (phydev->drv->did_interrupt &&
  603. !phydev->drv->did_interrupt(phydev))
  604. goto ignore;
  605. if (phy_disable_interrupts(phydev))
  606. goto phy_err;
  607. mutex_lock(&phydev->lock);
  608. if ((PHY_RUNNING == phydev->state) || (PHY_NOLINK == phydev->state))
  609. phydev->state = PHY_CHANGELINK;
  610. mutex_unlock(&phydev->lock);
  611. atomic_dec(&phydev->irq_disable);
  612. enable_irq(phydev->irq);
  613. /* Reenable interrupts */
  614. if (PHY_HALTED != phydev->state &&
  615. phy_config_interrupt(phydev, PHY_INTERRUPT_ENABLED))
  616. goto irq_enable_err;
  617. /* reschedule state queue work to run as soon as possible */
  618. cancel_delayed_work_sync(&phydev->state_queue);
  619. queue_delayed_work(system_power_efficient_wq, &phydev->state_queue, 0);
  620. return;
  621. ignore:
  622. atomic_dec(&phydev->irq_disable);
  623. enable_irq(phydev->irq);
  624. return;
  625. irq_enable_err:
  626. disable_irq(phydev->irq);
  627. atomic_inc(&phydev->irq_disable);
  628. phy_err:
  629. phy_error(phydev);
  630. }
  631. /**
  632. * phy_stop - Bring down the PHY link, and stop checking the status
  633. * @phydev: target phy_device struct
  634. */
  635. void phy_stop(struct phy_device *phydev)
  636. {
  637. mutex_lock(&phydev->lock);
  638. if (PHY_HALTED == phydev->state)
  639. goto out_unlock;
  640. if (phy_interrupt_is_valid(phydev)) {
  641. /* Disable PHY Interrupts */
  642. phy_config_interrupt(phydev, PHY_INTERRUPT_DISABLED);
  643. /* Clear any pending interrupts */
  644. phy_clear_interrupt(phydev);
  645. }
  646. phydev->state = PHY_HALTED;
  647. out_unlock:
  648. mutex_unlock(&phydev->lock);
  649. /* Cannot call flush_scheduled_work() here as desired because
  650. * of rtnl_lock(), but PHY_HALTED shall guarantee phy_change()
  651. * will not reenable interrupts.
  652. */
  653. }
  654. EXPORT_SYMBOL(phy_stop);
  655. /**
  656. * phy_start - start or restart a PHY device
  657. * @phydev: target phy_device struct
  658. *
  659. * Description: Indicates the attached device's readiness to
  660. * handle PHY-related work. Used during startup to start the
  661. * PHY, and after a call to phy_stop() to resume operation.
  662. * Also used to indicate the MDIO bus has cleared an error
  663. * condition.
  664. */
  665. void phy_start(struct phy_device *phydev)
  666. {
  667. bool do_resume = false;
  668. int err = 0;
  669. mutex_lock(&phydev->lock);
  670. switch (phydev->state) {
  671. case PHY_STARTING:
  672. phydev->state = PHY_PENDING;
  673. break;
  674. case PHY_READY:
  675. phydev->state = PHY_UP;
  676. break;
  677. case PHY_HALTED:
  678. /* make sure interrupts are re-enabled for the PHY */
  679. err = phy_enable_interrupts(phydev);
  680. if (err < 0)
  681. break;
  682. phydev->state = PHY_RESUMING;
  683. do_resume = true;
  684. break;
  685. default:
  686. break;
  687. }
  688. mutex_unlock(&phydev->lock);
  689. /* if phy was suspended, bring the physical link up again */
  690. if (do_resume)
  691. phy_resume(phydev);
  692. }
  693. EXPORT_SYMBOL(phy_start);
  694. /**
  695. * phy_state_machine - Handle the state machine
  696. * @work: work_struct that describes the work to be done
  697. */
  698. void phy_state_machine(struct work_struct *work)
  699. {
  700. struct delayed_work *dwork = to_delayed_work(work);
  701. struct phy_device *phydev =
  702. container_of(dwork, struct phy_device, state_queue);
  703. bool needs_aneg = false, do_suspend = false;
  704. enum phy_state old_state;
  705. int err = 0;
  706. int old_link;
  707. mutex_lock(&phydev->lock);
  708. old_state = phydev->state;
  709. if (phydev->drv->link_change_notify)
  710. phydev->drv->link_change_notify(phydev);
  711. switch (phydev->state) {
  712. case PHY_DOWN:
  713. case PHY_STARTING:
  714. case PHY_READY:
  715. case PHY_PENDING:
  716. break;
  717. case PHY_UP:
  718. needs_aneg = true;
  719. phydev->link_timeout = PHY_AN_TIMEOUT;
  720. break;
  721. case PHY_AN:
  722. err = phy_read_status(phydev);
  723. if (err < 0)
  724. break;
  725. /* If the link is down, give up on negotiation for now */
  726. if (!phydev->link) {
  727. phydev->state = PHY_NOLINK;
  728. netif_carrier_off(phydev->attached_dev);
  729. phydev->adjust_link(phydev->attached_dev);
  730. break;
  731. }
  732. /* Check if negotiation is done. Break if there's an error */
  733. err = phy_aneg_done(phydev);
  734. if (err < 0)
  735. break;
  736. /* If AN is done, we're running */
  737. if (err > 0) {
  738. phydev->state = PHY_RUNNING;
  739. netif_carrier_on(phydev->attached_dev);
  740. phydev->adjust_link(phydev->attached_dev);
  741. } else if (0 == phydev->link_timeout--)
  742. needs_aneg = true;
  743. break;
  744. case PHY_NOLINK:
  745. if (phy_interrupt_is_valid(phydev))
  746. break;
  747. err = phy_read_status(phydev);
  748. if (err)
  749. break;
  750. if (phydev->link) {
  751. if (AUTONEG_ENABLE == phydev->autoneg) {
  752. err = phy_aneg_done(phydev);
  753. if (err < 0)
  754. break;
  755. if (!err) {
  756. phydev->state = PHY_AN;
  757. phydev->link_timeout = PHY_AN_TIMEOUT;
  758. break;
  759. }
  760. }
  761. phydev->state = PHY_RUNNING;
  762. netif_carrier_on(phydev->attached_dev);
  763. phydev->adjust_link(phydev->attached_dev);
  764. }
  765. break;
  766. case PHY_FORCING:
  767. err = genphy_update_link(phydev);
  768. if (err)
  769. break;
  770. if (phydev->link) {
  771. phydev->state = PHY_RUNNING;
  772. netif_carrier_on(phydev->attached_dev);
  773. } else {
  774. if (0 == phydev->link_timeout--)
  775. needs_aneg = true;
  776. }
  777. phydev->adjust_link(phydev->attached_dev);
  778. break;
  779. case PHY_RUNNING:
  780. /* Only register a CHANGE if we are polling or ignoring
  781. * interrupts and link changed since latest checking.
  782. */
  783. if (!phy_interrupt_is_valid(phydev)) {
  784. old_link = phydev->link;
  785. err = phy_read_status(phydev);
  786. if (err)
  787. break;
  788. if (old_link != phydev->link)
  789. phydev->state = PHY_CHANGELINK;
  790. }
  791. break;
  792. case PHY_CHANGELINK:
  793. err = phy_read_status(phydev);
  794. if (err)
  795. break;
  796. if (phydev->link) {
  797. phydev->state = PHY_RUNNING;
  798. netif_carrier_on(phydev->attached_dev);
  799. } else {
  800. phydev->state = PHY_NOLINK;
  801. netif_carrier_off(phydev->attached_dev);
  802. }
  803. phydev->adjust_link(phydev->attached_dev);
  804. if (phy_interrupt_is_valid(phydev))
  805. err = phy_config_interrupt(phydev,
  806. PHY_INTERRUPT_ENABLED);
  807. break;
  808. case PHY_HALTED:
  809. if (phydev->link) {
  810. phydev->link = 0;
  811. netif_carrier_off(phydev->attached_dev);
  812. phydev->adjust_link(phydev->attached_dev);
  813. do_suspend = true;
  814. }
  815. break;
  816. case PHY_RESUMING:
  817. if (AUTONEG_ENABLE == phydev->autoneg) {
  818. err = phy_aneg_done(phydev);
  819. if (err < 0)
  820. break;
  821. /* err > 0 if AN is done.
  822. * Otherwise, it's 0, and we're still waiting for AN
  823. */
  824. if (err > 0) {
  825. err = phy_read_status(phydev);
  826. if (err)
  827. break;
  828. if (phydev->link) {
  829. phydev->state = PHY_RUNNING;
  830. netif_carrier_on(phydev->attached_dev);
  831. } else {
  832. phydev->state = PHY_NOLINK;
  833. }
  834. phydev->adjust_link(phydev->attached_dev);
  835. } else {
  836. phydev->state = PHY_AN;
  837. phydev->link_timeout = PHY_AN_TIMEOUT;
  838. }
  839. } else {
  840. err = phy_read_status(phydev);
  841. if (err)
  842. break;
  843. if (phydev->link) {
  844. phydev->state = PHY_RUNNING;
  845. netif_carrier_on(phydev->attached_dev);
  846. } else {
  847. phydev->state = PHY_NOLINK;
  848. }
  849. phydev->adjust_link(phydev->attached_dev);
  850. }
  851. break;
  852. }
  853. mutex_unlock(&phydev->lock);
  854. if (needs_aneg)
  855. err = phy_start_aneg(phydev);
  856. else if (do_suspend)
  857. phy_suspend(phydev);
  858. if (err < 0)
  859. phy_error(phydev);
  860. phydev_dbg(phydev, "PHY state change %s -> %s\n",
  861. phy_state_to_str(old_state),
  862. phy_state_to_str(phydev->state));
  863. queue_delayed_work(system_power_efficient_wq, &phydev->state_queue,
  864. PHY_STATE_TIME * HZ);
  865. }
  866. void phy_mac_interrupt(struct phy_device *phydev, int new_link)
  867. {
  868. cancel_work_sync(&phydev->phy_queue);
  869. phydev->link = new_link;
  870. schedule_work(&phydev->phy_queue);
  871. }
  872. EXPORT_SYMBOL(phy_mac_interrupt);
  873. static inline void mmd_phy_indirect(struct mii_bus *bus, int prtad, int devad,
  874. int addr)
  875. {
  876. /* Write the desired MMD Devad */
  877. bus->write(bus, addr, MII_MMD_CTRL, devad);
  878. /* Write the desired MMD register address */
  879. bus->write(bus, addr, MII_MMD_DATA, prtad);
  880. /* Select the Function : DATA with no post increment */
  881. bus->write(bus, addr, MII_MMD_CTRL, (devad | MII_MMD_CTRL_NOINCR));
  882. }
  883. /**
  884. * phy_read_mmd_indirect - reads data from the MMD registers
  885. * @phydev: The PHY device bus
  886. * @prtad: MMD Address
  887. * @devad: MMD DEVAD
  888. *
  889. * Description: it reads data from the MMD registers (clause 22 to access to
  890. * clause 45) of the specified phy address.
  891. * To read these register we have:
  892. * 1) Write reg 13 // DEVAD
  893. * 2) Write reg 14 // MMD Address
  894. * 3) Write reg 13 // MMD Data Command for MMD DEVAD
  895. * 3) Read reg 14 // Read MMD data
  896. */
  897. int phy_read_mmd_indirect(struct phy_device *phydev, int prtad, int devad)
  898. {
  899. struct phy_driver *phydrv = phydev->drv;
  900. int addr = phydev->mdio.addr;
  901. int value = -1;
  902. if (!phydrv->read_mmd_indirect) {
  903. struct mii_bus *bus = phydev->mdio.bus;
  904. mutex_lock(&bus->mdio_lock);
  905. mmd_phy_indirect(bus, prtad, devad, addr);
  906. /* Read the content of the MMD's selected register */
  907. value = bus->read(bus, addr, MII_MMD_DATA);
  908. mutex_unlock(&bus->mdio_lock);
  909. } else {
  910. value = phydrv->read_mmd_indirect(phydev, prtad, devad, addr);
  911. }
  912. return value;
  913. }
  914. EXPORT_SYMBOL(phy_read_mmd_indirect);
  915. /**
  916. * phy_write_mmd_indirect - writes data to the MMD registers
  917. * @phydev: The PHY device
  918. * @prtad: MMD Address
  919. * @devad: MMD DEVAD
  920. * @data: data to write in the MMD register
  921. *
  922. * Description: Write data from the MMD registers of the specified
  923. * phy address.
  924. * To write these register we have:
  925. * 1) Write reg 13 // DEVAD
  926. * 2) Write reg 14 // MMD Address
  927. * 3) Write reg 13 // MMD Data Command for MMD DEVAD
  928. * 3) Write reg 14 // Write MMD data
  929. */
  930. void phy_write_mmd_indirect(struct phy_device *phydev, int prtad,
  931. int devad, u32 data)
  932. {
  933. struct phy_driver *phydrv = phydev->drv;
  934. int addr = phydev->mdio.addr;
  935. if (!phydrv->write_mmd_indirect) {
  936. struct mii_bus *bus = phydev->mdio.bus;
  937. mutex_lock(&bus->mdio_lock);
  938. mmd_phy_indirect(bus, prtad, devad, addr);
  939. /* Write the data into MMD's selected register */
  940. bus->write(bus, addr, MII_MMD_DATA, data);
  941. mutex_unlock(&bus->mdio_lock);
  942. } else {
  943. phydrv->write_mmd_indirect(phydev, prtad, devad, addr, data);
  944. }
  945. }
  946. EXPORT_SYMBOL(phy_write_mmd_indirect);
  947. /**
  948. * phy_init_eee - init and check the EEE feature
  949. * @phydev: target phy_device struct
  950. * @clk_stop_enable: PHY may stop the clock during LPI
  951. *
  952. * Description: it checks if the Energy-Efficient Ethernet (EEE)
  953. * is supported by looking at the MMD registers 3.20 and 7.60/61
  954. * and it programs the MMD register 3.0 setting the "Clock stop enable"
  955. * bit if required.
  956. */
  957. int phy_init_eee(struct phy_device *phydev, bool clk_stop_enable)
  958. {
  959. /* According to 802.3az,the EEE is supported only in full duplex-mode.
  960. * Also EEE feature is active when core is operating with MII, GMII
  961. * or RGMII (all kinds). Internal PHYs are also allowed to proceed and
  962. * should return an error if they do not support EEE.
  963. */
  964. if ((phydev->duplex == DUPLEX_FULL) &&
  965. ((phydev->interface == PHY_INTERFACE_MODE_MII) ||
  966. (phydev->interface == PHY_INTERFACE_MODE_GMII) ||
  967. phy_interface_is_rgmii(phydev) ||
  968. phy_is_internal(phydev))) {
  969. int eee_lp, eee_cap, eee_adv;
  970. u32 lp, cap, adv;
  971. int status;
  972. /* Read phy status to properly get the right settings */
  973. status = phy_read_status(phydev);
  974. if (status)
  975. return status;
  976. /* First check if the EEE ability is supported */
  977. eee_cap = phy_read_mmd_indirect(phydev, MDIO_PCS_EEE_ABLE,
  978. MDIO_MMD_PCS);
  979. if (eee_cap <= 0)
  980. goto eee_exit_err;
  981. cap = mmd_eee_cap_to_ethtool_sup_t(eee_cap);
  982. if (!cap)
  983. goto eee_exit_err;
  984. /* Check which link settings negotiated and verify it in
  985. * the EEE advertising registers.
  986. */
  987. eee_lp = phy_read_mmd_indirect(phydev, MDIO_AN_EEE_LPABLE,
  988. MDIO_MMD_AN);
  989. if (eee_lp <= 0)
  990. goto eee_exit_err;
  991. eee_adv = phy_read_mmd_indirect(phydev, MDIO_AN_EEE_ADV,
  992. MDIO_MMD_AN);
  993. if (eee_adv <= 0)
  994. goto eee_exit_err;
  995. adv = mmd_eee_adv_to_ethtool_adv_t(eee_adv);
  996. lp = mmd_eee_adv_to_ethtool_adv_t(eee_lp);
  997. if (!phy_check_valid(phydev->speed, phydev->duplex, lp & adv))
  998. goto eee_exit_err;
  999. if (clk_stop_enable) {
  1000. /* Configure the PHY to stop receiving xMII
  1001. * clock while it is signaling LPI.
  1002. */
  1003. int val = phy_read_mmd_indirect(phydev, MDIO_CTRL1,
  1004. MDIO_MMD_PCS);
  1005. if (val < 0)
  1006. return val;
  1007. val |= MDIO_PCS_CTRL1_CLKSTOP_EN;
  1008. phy_write_mmd_indirect(phydev, MDIO_CTRL1,
  1009. MDIO_MMD_PCS, val);
  1010. }
  1011. return 0; /* EEE supported */
  1012. }
  1013. eee_exit_err:
  1014. return -EPROTONOSUPPORT;
  1015. }
  1016. EXPORT_SYMBOL(phy_init_eee);
  1017. /**
  1018. * phy_get_eee_err - report the EEE wake error count
  1019. * @phydev: target phy_device struct
  1020. *
  1021. * Description: it is to report the number of time where the PHY
  1022. * failed to complete its normal wake sequence.
  1023. */
  1024. int phy_get_eee_err(struct phy_device *phydev)
  1025. {
  1026. return phy_read_mmd_indirect(phydev, MDIO_PCS_EEE_WK_ERR, MDIO_MMD_PCS);
  1027. }
  1028. EXPORT_SYMBOL(phy_get_eee_err);
  1029. /**
  1030. * phy_ethtool_get_eee - get EEE supported and status
  1031. * @phydev: target phy_device struct
  1032. * @data: ethtool_eee data
  1033. *
  1034. * Description: it reportes the Supported/Advertisement/LP Advertisement
  1035. * capabilities.
  1036. */
  1037. int phy_ethtool_get_eee(struct phy_device *phydev, struct ethtool_eee *data)
  1038. {
  1039. int val;
  1040. /* Get Supported EEE */
  1041. val = phy_read_mmd_indirect(phydev, MDIO_PCS_EEE_ABLE, MDIO_MMD_PCS);
  1042. if (val < 0)
  1043. return val;
  1044. data->supported = mmd_eee_cap_to_ethtool_sup_t(val);
  1045. /* Get advertisement EEE */
  1046. val = phy_read_mmd_indirect(phydev, MDIO_AN_EEE_ADV, MDIO_MMD_AN);
  1047. if (val < 0)
  1048. return val;
  1049. data->advertised = mmd_eee_adv_to_ethtool_adv_t(val);
  1050. /* Get LP advertisement EEE */
  1051. val = phy_read_mmd_indirect(phydev, MDIO_AN_EEE_LPABLE, MDIO_MMD_AN);
  1052. if (val < 0)
  1053. return val;
  1054. data->lp_advertised = mmd_eee_adv_to_ethtool_adv_t(val);
  1055. return 0;
  1056. }
  1057. EXPORT_SYMBOL(phy_ethtool_get_eee);
  1058. /**
  1059. * phy_ethtool_set_eee - set EEE supported and status
  1060. * @phydev: target phy_device struct
  1061. * @data: ethtool_eee data
  1062. *
  1063. * Description: it is to program the Advertisement EEE register.
  1064. */
  1065. int phy_ethtool_set_eee(struct phy_device *phydev, struct ethtool_eee *data)
  1066. {
  1067. int val = ethtool_adv_to_mmd_eee_adv_t(data->advertised);
  1068. phy_write_mmd_indirect(phydev, MDIO_AN_EEE_ADV, MDIO_MMD_AN, val);
  1069. return 0;
  1070. }
  1071. EXPORT_SYMBOL(phy_ethtool_set_eee);
  1072. int phy_ethtool_set_wol(struct phy_device *phydev, struct ethtool_wolinfo *wol)
  1073. {
  1074. if (phydev->drv->set_wol)
  1075. return phydev->drv->set_wol(phydev, wol);
  1076. return -EOPNOTSUPP;
  1077. }
  1078. EXPORT_SYMBOL(phy_ethtool_set_wol);
  1079. void phy_ethtool_get_wol(struct phy_device *phydev, struct ethtool_wolinfo *wol)
  1080. {
  1081. if (phydev->drv->get_wol)
  1082. phydev->drv->get_wol(phydev, wol);
  1083. }
  1084. EXPORT_SYMBOL(phy_ethtool_get_wol);