1 // SPDX-License-Identifier: GPL-2.0+
3 * DaVinci Ethernet Medium Access Controller
5 * DaVinci EMAC is based upon CPPI 3.0 TI DMA engine
7 * Copyright (C) 2009 Texas Instruments.
9 * ---------------------------------------------------------------------------
11 * 0-5 A number of folks worked on this driver in bits and pieces but the major
12 * contribution came from Suraj Iyer and Anant Gole
13 * 6.0 Anant Gole - rewrote the driver as per Linux conventions
14 * 6.1 Chaithrika U S - added support for Gigabit and RMII features,
18 #include <linux/module.h>
19 #include <linux/kernel.h>
20 #include <linux/sched.h>
21 #include <linux/string.h>
22 #include <linux/timer.h>
23 #include <linux/errno.h>
25 #include <linux/ioport.h>
26 #include <linux/slab.h>
28 #include <linux/interrupt.h>
29 #include <linux/init.h>
30 #include <linux/netdevice.h>
31 #include <linux/etherdevice.h>
32 #include <linux/skbuff.h>
33 #include <linux/ethtool.h>
34 #include <linux/highmem.h>
35 #include <linux/proc_fs.h>
36 #include <linux/ctype.h>
37 #include <linux/spinlock.h>
38 #include <linux/dma-mapping.h>
39 #include <linux/clk.h>
40 #include <linux/platform_device.h>
41 #include <linux/regmap.h>
42 #include <linux/semaphore.h>
43 #include <linux/phy.h>
44 #include <linux/bitops.h>
46 #include <linux/uaccess.h>
47 #include <linux/pm_runtime.h>
48 #include <linux/davinci_emac.h>
50 #include <linux/of_address.h>
51 #include <linux/of_device.h>
52 #include <linux/of_mdio.h>
53 #include <linux/of_irq.h>
54 #include <linux/of_net.h>
55 #include <linux/mfd/syscon.h>
61 #include "davinci_cpdma.h"
63 static int debug_level;
64 module_param(debug_level, int, 0);
65 MODULE_PARM_DESC(debug_level, "DaVinci EMAC debug level (NETIF_MSG bits)");
67 /* Netif debug messages possible */
68 #define DAVINCI_EMAC_DEBUG (NETIF_MSG_DRV | \
76 NETIF_MSG_TX_QUEUED | \
79 NETIF_MSG_RX_STATUS | \
85 #define EMAC_MAJOR_VERSION 6
86 #define EMAC_MINOR_VERSION 1
87 #define EMAC_MODULE_VERSION "6.1"
88 MODULE_VERSION(EMAC_MODULE_VERSION);
89 static const char emac_version_string[] = "TI DaVinci EMAC Linux v6.1";
91 /* Configuration items */
92 #define EMAC_DEF_PASS_CRC (0) /* Do not pass CRC up to frames */
93 #define EMAC_DEF_QOS_EN (0) /* EMAC proprietary QoS disabled */
94 #define EMAC_DEF_NO_BUFF_CHAIN (0) /* No buffer chain */
95 #define EMAC_DEF_MACCTRL_FRAME_EN (0) /* Discard Maccontrol frames */
96 #define EMAC_DEF_SHORT_FRAME_EN (0) /* Discard short frames */
97 #define EMAC_DEF_ERROR_FRAME_EN (0) /* Discard error frames */
98 #define EMAC_DEF_PROM_EN (0) /* Promiscuous disabled */
99 #define EMAC_DEF_PROM_CH (0) /* Promiscuous channel is 0 */
100 #define EMAC_DEF_BCAST_EN (1) /* Broadcast enabled */
101 #define EMAC_DEF_BCAST_CH (0) /* Broadcast channel is 0 */
102 #define EMAC_DEF_MCAST_EN (1) /* Multicast enabled */
103 #define EMAC_DEF_MCAST_CH (0) /* Multicast channel is 0 */
105 #define EMAC_DEF_TXPRIO_FIXED (1) /* TX Priority is fixed */
106 #define EMAC_DEF_TXPACING_EN (0) /* TX pacing NOT supported*/
108 #define EMAC_DEF_BUFFER_OFFSET (0) /* Buffer offset to DMA (future) */
109 #define EMAC_DEF_MIN_ETHPKTSIZE (60) /* Minimum ethernet pkt size */
110 #define EMAC_DEF_MAX_FRAME_SIZE (1500 + 14 + 4 + 4)
111 #define EMAC_DEF_TX_CH (0) /* Default 0th channel */
112 #define EMAC_DEF_RX_CH (0) /* Default 0th channel */
113 #define EMAC_DEF_RX_NUM_DESC (128)
114 #define EMAC_DEF_MAX_TX_CH (1) /* Max TX channels configured */
115 #define EMAC_DEF_MAX_RX_CH (1) /* Max RX channels configured */
116 #define EMAC_POLL_WEIGHT (64) /* Default NAPI poll weight */
118 /* Buffer descriptor parameters */
119 #define EMAC_DEF_TX_MAX_SERVICE (32) /* TX max service BD's */
120 #define EMAC_DEF_RX_MAX_SERVICE (64) /* should = netdev->weight */
122 /* EMAC register related defines */
123 #define EMAC_ALL_MULTI_REG_VALUE (0xFFFFFFFF)
124 #define EMAC_NUM_MULTICAST_BITS (64)
125 #define EMAC_TX_CONTROL_TX_ENABLE_VAL (0x1)
126 #define EMAC_RX_CONTROL_RX_ENABLE_VAL (0x1)
127 #define EMAC_MAC_HOST_ERR_INTMASK_VAL (0x2)
128 #define EMAC_RX_UNICAST_CLEAR_ALL (0xFF)
129 #define EMAC_INT_MASK_CLEAR (0xFF)
131 /* RX MBP register bit positions */
132 #define EMAC_RXMBP_PASSCRC_MASK BIT(30)
133 #define EMAC_RXMBP_QOSEN_MASK BIT(29)
134 #define EMAC_RXMBP_NOCHAIN_MASK BIT(28)
135 #define EMAC_RXMBP_CMFEN_MASK BIT(24)
136 #define EMAC_RXMBP_CSFEN_MASK BIT(23)
137 #define EMAC_RXMBP_CEFEN_MASK BIT(22)
138 #define EMAC_RXMBP_CAFEN_MASK BIT(21)
139 #define EMAC_RXMBP_PROMCH_SHIFT (16)
140 #define EMAC_RXMBP_PROMCH_MASK (0x7 << 16)
141 #define EMAC_RXMBP_BROADEN_MASK BIT(13)
142 #define EMAC_RXMBP_BROADCH_SHIFT (8)
143 #define EMAC_RXMBP_BROADCH_MASK (0x7 << 8)
144 #define EMAC_RXMBP_MULTIEN_MASK BIT(5)
145 #define EMAC_RXMBP_MULTICH_SHIFT (0)
146 #define EMAC_RXMBP_MULTICH_MASK (0x7)
147 #define EMAC_RXMBP_CHMASK (0x7)
149 /* EMAC register definitions/bit maps used */
150 # define EMAC_MBP_RXPROMISC (0x00200000)
151 # define EMAC_MBP_PROMISCCH(ch) (((ch) & 0x7) << 16)
152 # define EMAC_MBP_RXBCAST (0x00002000)
153 # define EMAC_MBP_BCASTCHAN(ch) (((ch) & 0x7) << 8)
154 # define EMAC_MBP_RXMCAST (0x00000020)
155 # define EMAC_MBP_MCASTCHAN(ch) ((ch) & 0x7)
157 /* EMAC mac_control register */
158 #define EMAC_MACCONTROL_TXPTYPE BIT(9)
159 #define EMAC_MACCONTROL_TXPACEEN BIT(6)
160 #define EMAC_MACCONTROL_GMIIEN BIT(5)
161 #define EMAC_MACCONTROL_GIGABITEN BIT(7)
162 #define EMAC_MACCONTROL_FULLDUPLEXEN BIT(0)
163 #define EMAC_MACCONTROL_RMIISPEED_MASK BIT(15)
165 /* GIGABIT MODE related bits */
166 #define EMAC_DM646X_MACCONTORL_GIG BIT(7)
167 #define EMAC_DM646X_MACCONTORL_GIGFORCE BIT(17)
169 /* EMAC mac_status register */
170 #define EMAC_MACSTATUS_TXERRCODE_MASK (0xF00000)
171 #define EMAC_MACSTATUS_TXERRCODE_SHIFT (20)
172 #define EMAC_MACSTATUS_TXERRCH_MASK (0x70000)
173 #define EMAC_MACSTATUS_TXERRCH_SHIFT (16)
174 #define EMAC_MACSTATUS_RXERRCODE_MASK (0xF000)
175 #define EMAC_MACSTATUS_RXERRCODE_SHIFT (12)
176 #define EMAC_MACSTATUS_RXERRCH_MASK (0x700)
177 #define EMAC_MACSTATUS_RXERRCH_SHIFT (8)
179 /* EMAC RX register masks */
180 #define EMAC_RX_MAX_LEN_MASK (0xFFFF)
181 #define EMAC_RX_BUFFER_OFFSET_MASK (0xFFFF)
183 /* MAC_IN_VECTOR (0x180) register bit fields */
184 #define EMAC_DM644X_MAC_IN_VECTOR_HOST_INT BIT(17)
185 #define EMAC_DM644X_MAC_IN_VECTOR_STATPEND_INT BIT(16)
186 #define EMAC_DM644X_MAC_IN_VECTOR_RX_INT_VEC BIT(8)
187 #define EMAC_DM644X_MAC_IN_VECTOR_TX_INT_VEC BIT(0)
189 /** NOTE:: For DM646x the IN_VECTOR has changed */
190 #define EMAC_DM646X_MAC_IN_VECTOR_RX_INT_VEC BIT(EMAC_DEF_RX_CH)
191 #define EMAC_DM646X_MAC_IN_VECTOR_TX_INT_VEC BIT(16 + EMAC_DEF_TX_CH)
192 #define EMAC_DM646X_MAC_IN_VECTOR_HOST_INT BIT(26)
193 #define EMAC_DM646X_MAC_IN_VECTOR_STATPEND_INT BIT(27)
195 /* CPPI bit positions */
196 #define EMAC_CPPI_SOP_BIT BIT(31)
197 #define EMAC_CPPI_EOP_BIT BIT(30)
198 #define EMAC_CPPI_OWNERSHIP_BIT BIT(29)
199 #define EMAC_CPPI_EOQ_BIT BIT(28)
200 #define EMAC_CPPI_TEARDOWN_COMPLETE_BIT BIT(27)
201 #define EMAC_CPPI_PASS_CRC_BIT BIT(26)
202 #define EMAC_RX_BD_BUF_SIZE (0xFFFF)
203 #define EMAC_BD_LENGTH_FOR_CACHE (16) /* only CPPI bytes */
204 #define EMAC_RX_BD_PKT_LENGTH_MASK (0xFFFF)
206 /* Max hardware defines */
207 #define EMAC_MAX_TXRX_CHANNELS (8) /* Max hardware channels */
208 #define EMAC_DEF_MAX_MULTICAST_ADDRESSES (64) /* Max mcast addr's */
210 /* EMAC Peripheral Device Register Memory Layout structure */
211 #define EMAC_MACINVECTOR 0x90
213 #define EMAC_DM646X_MACEOIVECTOR 0x94
215 #define EMAC_MACINTSTATRAW 0xB0
216 #define EMAC_MACINTSTATMASKED 0xB4
217 #define EMAC_MACINTMASKSET 0xB8
218 #define EMAC_MACINTMASKCLEAR 0xBC
220 #define EMAC_RXMBPENABLE 0x100
221 #define EMAC_RXUNICASTSET 0x104
222 #define EMAC_RXUNICASTCLEAR 0x108
223 #define EMAC_RXMAXLEN 0x10C
224 #define EMAC_RXBUFFEROFFSET 0x110
225 #define EMAC_RXFILTERLOWTHRESH 0x114
227 #define EMAC_MACCONTROL 0x160
228 #define EMAC_MACSTATUS 0x164
229 #define EMAC_EMCONTROL 0x168
230 #define EMAC_FIFOCONTROL 0x16C
231 #define EMAC_MACCONFIG 0x170
232 #define EMAC_SOFTRESET 0x174
233 #define EMAC_MACSRCADDRLO 0x1D0
234 #define EMAC_MACSRCADDRHI 0x1D4
235 #define EMAC_MACHASH1 0x1D8
236 #define EMAC_MACHASH2 0x1DC
237 #define EMAC_MACADDRLO 0x500
238 #define EMAC_MACADDRHI 0x504
239 #define EMAC_MACINDEX 0x508
241 /* EMAC statistics registers */
242 #define EMAC_RXGOODFRAMES 0x200
243 #define EMAC_RXBCASTFRAMES 0x204
244 #define EMAC_RXMCASTFRAMES 0x208
245 #define EMAC_RXPAUSEFRAMES 0x20C
246 #define EMAC_RXCRCERRORS 0x210
247 #define EMAC_RXALIGNCODEERRORS 0x214
248 #define EMAC_RXOVERSIZED 0x218
249 #define EMAC_RXJABBER 0x21C
250 #define EMAC_RXUNDERSIZED 0x220
251 #define EMAC_RXFRAGMENTS 0x224
252 #define EMAC_RXFILTERED 0x228
253 #define EMAC_RXQOSFILTERED 0x22C
254 #define EMAC_RXOCTETS 0x230
255 #define EMAC_TXGOODFRAMES 0x234
256 #define EMAC_TXBCASTFRAMES 0x238
257 #define EMAC_TXMCASTFRAMES 0x23C
258 #define EMAC_TXPAUSEFRAMES 0x240
259 #define EMAC_TXDEFERRED 0x244
260 #define EMAC_TXCOLLISION 0x248
261 #define EMAC_TXSINGLECOLL 0x24C
262 #define EMAC_TXMULTICOLL 0x250
263 #define EMAC_TXEXCESSIVECOLL 0x254
264 #define EMAC_TXLATECOLL 0x258
265 #define EMAC_TXUNDERRUN 0x25C
266 #define EMAC_TXCARRIERSENSE 0x260
267 #define EMAC_TXOCTETS 0x264
268 #define EMAC_NETOCTETS 0x280
269 #define EMAC_RXSOFOVERRUNS 0x284
270 #define EMAC_RXMOFOVERRUNS 0x288
271 #define EMAC_RXDMAOVERRUNS 0x28C
273 /* EMAC DM644x control registers */
274 #define EMAC_CTRL_EWCTL (0x4)
275 #define EMAC_CTRL_EWINTTCNT (0x8)
277 /* EMAC DM644x control module masks */
278 #define EMAC_DM644X_EWINTCNT_MASK 0x1FFFF
279 #define EMAC_DM644X_INTMIN_INTVL 0x1
280 #define EMAC_DM644X_INTMAX_INTVL (EMAC_DM644X_EWINTCNT_MASK)
282 /* EMAC DM646X control module registers */
283 #define EMAC_DM646X_CMINTCTRL 0x0C
284 #define EMAC_DM646X_CMRXINTEN 0x14
285 #define EMAC_DM646X_CMTXINTEN 0x18
286 #define EMAC_DM646X_CMRXINTMAX 0x70
287 #define EMAC_DM646X_CMTXINTMAX 0x74
289 /* EMAC DM646X control module masks */
290 #define EMAC_DM646X_INTPACEEN (0x3 << 16)
291 #define EMAC_DM646X_INTPRESCALE_MASK (0x7FF << 0)
292 #define EMAC_DM646X_CMINTMAX_CNT 63
293 #define EMAC_DM646X_CMINTMIN_CNT 2
294 #define EMAC_DM646X_CMINTMAX_INTVL (1000 / EMAC_DM646X_CMINTMIN_CNT)
295 #define EMAC_DM646X_CMINTMIN_INTVL ((1000 / EMAC_DM646X_CMINTMAX_CNT) + 1)
298 /* EMAC EOI codes for C0 */
299 #define EMAC_DM646X_MAC_EOI_C0_RXEN (0x01)
300 #define EMAC_DM646X_MAC_EOI_C0_TXEN (0x02)
302 /* EMAC Stats Clear Mask */
303 #define EMAC_STATS_CLR_MASK (0xFFFFFFFF)
305 /* emac_priv: EMAC private data structure
307 * EMAC adapter private data structure
311 struct net_device *ndev;
312 struct platform_device *pdev;
313 struct napi_struct napi;
315 void __iomem *remap_addr;
317 void __iomem *emac_base;
318 void __iomem *ctrl_base;
319 struct cpdma_ctlr *dma;
320 struct cpdma_chan *txchan;
321 struct cpdma_chan *rxchan;
322 u32 link; /* 1=link on, 0=link off */
323 u32 speed; /* 0=Auto Neg, 1=No PHY, 10,100, 1000 - mbps */
324 u32 duplex; /* Link duplex: 0=Half, 1=Full */
333 u32 multicast_hash_cnt[EMAC_NUM_MULTICAST_BITS];
336 struct device_node *phy_node;
338 /*platform specific members*/
339 void (*int_enable) (void);
340 void (*int_disable) (void);
343 /* EMAC TX Host Error description strings */
344 static char *emac_txhost_errcodes[16] = {
345 "No error", "SOP error", "Ownership bit not set in SOP buffer",
346 "Zero Next Buffer Descriptor Pointer Without EOP",
347 "Zero Buffer Pointer", "Zero Buffer Length", "Packet Length Error",
348 "Reserved", "Reserved", "Reserved", "Reserved", "Reserved",
349 "Reserved", "Reserved", "Reserved", "Reserved"
352 /* EMAC RX Host Error description strings */
353 static char *emac_rxhost_errcodes[16] = {
354 "No error", "Reserved", "Ownership bit not set in input buffer",
355 "Reserved", "Zero Buffer Pointer", "Reserved", "Reserved",
356 "Reserved", "Reserved", "Reserved", "Reserved", "Reserved",
357 "Reserved", "Reserved", "Reserved", "Reserved"
361 #define emac_read(reg) ioread32(priv->emac_base + (reg))
362 #define emac_write(reg, val) iowrite32(val, priv->emac_base + (reg))
364 #define emac_ctrl_read(reg) ioread32((priv->ctrl_base + (reg)))
365 #define emac_ctrl_write(reg, val) iowrite32(val, (priv->ctrl_base + (reg)))
368 * emac_get_drvinfo - Get EMAC driver information
369 * @ndev: The DaVinci EMAC network adapter
370 * @info: ethtool info structure containing name and version
372 * Returns EMAC driver information (name and version)
375 static void emac_get_drvinfo(struct net_device *ndev,
376 struct ethtool_drvinfo *info)
378 strlcpy(info->driver, emac_version_string, sizeof(info->driver));
379 strlcpy(info->version, EMAC_MODULE_VERSION, sizeof(info->version));
383 * emac_get_coalesce - Get interrupt coalesce settings for this device
384 * @ndev : The DaVinci EMAC network adapter
385 * @coal : ethtool coalesce settings structure
387 * Fetch the current interrupt coalesce settings
390 static int emac_get_coalesce(struct net_device *ndev,
391 struct ethtool_coalesce *coal)
393 struct emac_priv *priv = netdev_priv(ndev);
395 coal->rx_coalesce_usecs = priv->coal_intvl;
401 * emac_set_coalesce - Set interrupt coalesce settings for this device
402 * @ndev : The DaVinci EMAC network adapter
403 * @coal : ethtool coalesce settings structure
405 * Set interrupt coalesce parameters
408 static int emac_set_coalesce(struct net_device *ndev,
409 struct ethtool_coalesce *coal)
411 struct emac_priv *priv = netdev_priv(ndev);
412 u32 int_ctrl, num_interrupts = 0;
413 u32 prescale = 0, addnl_dvdr = 1, coal_intvl = 0;
415 if (!coal->rx_coalesce_usecs) {
416 priv->coal_intvl = 0;
418 switch (priv->version) {
420 emac_ctrl_write(EMAC_DM646X_CMINTCTRL, 0);
423 emac_ctrl_write(EMAC_CTRL_EWINTTCNT, 0);
430 coal_intvl = coal->rx_coalesce_usecs;
432 switch (priv->version) {
434 int_ctrl = emac_ctrl_read(EMAC_DM646X_CMINTCTRL);
435 prescale = priv->bus_freq_mhz * 4;
437 if (coal_intvl < EMAC_DM646X_CMINTMIN_INTVL)
438 coal_intvl = EMAC_DM646X_CMINTMIN_INTVL;
440 if (coal_intvl > EMAC_DM646X_CMINTMAX_INTVL) {
442 * Interrupt pacer works with 4us Pulse, we can
443 * throttle further by dilating the 4us pulse.
445 addnl_dvdr = EMAC_DM646X_INTPRESCALE_MASK / prescale;
447 if (addnl_dvdr > 1) {
448 prescale *= addnl_dvdr;
449 if (coal_intvl > (EMAC_DM646X_CMINTMAX_INTVL
451 coal_intvl = (EMAC_DM646X_CMINTMAX_INTVL
455 coal_intvl = EMAC_DM646X_CMINTMAX_INTVL;
459 num_interrupts = (1000 * addnl_dvdr) / coal_intvl;
461 int_ctrl |= EMAC_DM646X_INTPACEEN;
462 int_ctrl &= (~EMAC_DM646X_INTPRESCALE_MASK);
463 int_ctrl |= (prescale & EMAC_DM646X_INTPRESCALE_MASK);
464 emac_ctrl_write(EMAC_DM646X_CMINTCTRL, int_ctrl);
466 emac_ctrl_write(EMAC_DM646X_CMRXINTMAX, num_interrupts);
467 emac_ctrl_write(EMAC_DM646X_CMTXINTMAX, num_interrupts);
471 int_ctrl = emac_ctrl_read(EMAC_CTRL_EWINTTCNT);
472 int_ctrl &= (~EMAC_DM644X_EWINTCNT_MASK);
473 prescale = coal_intvl * priv->bus_freq_mhz;
474 if (prescale > EMAC_DM644X_EWINTCNT_MASK) {
475 prescale = EMAC_DM644X_EWINTCNT_MASK;
476 coal_intvl = prescale / priv->bus_freq_mhz;
478 emac_ctrl_write(EMAC_CTRL_EWINTTCNT, (int_ctrl | prescale));
483 printk(KERN_INFO"Set coalesce to %d usecs.\n", coal_intvl);
484 priv->coal_intvl = coal_intvl;
491 /* ethtool_ops: DaVinci EMAC Ethtool structure
493 * Ethtool support for EMAC adapter
495 static const struct ethtool_ops ethtool_ops = {
496 .supported_coalesce_params = ETHTOOL_COALESCE_RX_USECS,
497 .get_drvinfo = emac_get_drvinfo,
498 .get_link = ethtool_op_get_link,
499 .get_coalesce = emac_get_coalesce,
500 .set_coalesce = emac_set_coalesce,
501 .get_ts_info = ethtool_op_get_ts_info,
502 .get_link_ksettings = phy_ethtool_get_link_ksettings,
503 .set_link_ksettings = phy_ethtool_set_link_ksettings,
507 * emac_update_phystatus - Update Phy status
508 * @priv: The DaVinci EMAC private adapter structure
510 * Updates phy status and takes action for network queue if required
511 * based upon link status
514 static void emac_update_phystatus(struct emac_priv *priv)
519 struct net_device *ndev = priv->ndev;
521 mac_control = emac_read(EMAC_MACCONTROL);
522 cur_duplex = (mac_control & EMAC_MACCONTROL_FULLDUPLEXEN) ?
523 DUPLEX_FULL : DUPLEX_HALF;
525 new_duplex = ndev->phydev->duplex;
527 new_duplex = DUPLEX_FULL;
529 /* We get called only if link has changed (speed/duplex/status) */
530 if ((priv->link) && (new_duplex != cur_duplex)) {
531 priv->duplex = new_duplex;
532 if (DUPLEX_FULL == priv->duplex)
533 mac_control |= (EMAC_MACCONTROL_FULLDUPLEXEN);
535 mac_control &= ~(EMAC_MACCONTROL_FULLDUPLEXEN);
538 if (priv->speed == SPEED_1000 && (priv->version == EMAC_VERSION_2)) {
539 mac_control = emac_read(EMAC_MACCONTROL);
540 mac_control |= (EMAC_DM646X_MACCONTORL_GIG |
541 EMAC_DM646X_MACCONTORL_GIGFORCE);
543 /* Clear the GIG bit and GIGFORCE bit */
544 mac_control &= ~(EMAC_DM646X_MACCONTORL_GIGFORCE |
545 EMAC_DM646X_MACCONTORL_GIG);
547 if (priv->rmii_en && (priv->speed == SPEED_100))
548 mac_control |= EMAC_MACCONTROL_RMIISPEED_MASK;
550 mac_control &= ~EMAC_MACCONTROL_RMIISPEED_MASK;
553 /* Update mac_control if changed */
554 emac_write(EMAC_MACCONTROL, mac_control);
558 if (!netif_carrier_ok(ndev))
559 netif_carrier_on(ndev);
560 /* reactivate the transmit queue if it is stopped */
561 if (netif_running(ndev) && netif_queue_stopped(ndev))
562 netif_wake_queue(ndev);
565 if (netif_carrier_ok(ndev))
566 netif_carrier_off(ndev);
567 if (!netif_queue_stopped(ndev))
568 netif_stop_queue(ndev);
573 * hash_get - Calculate hash value from mac address
574 * @addr: mac address to delete from hash table
576 * Calculates hash value from mac address
579 static u32 hash_get(u8 *addr)
586 for (cnt = 0; cnt < 2; cnt++) {
588 hash ^= (tmpval >> 2) ^ (tmpval << 4);
590 hash ^= (tmpval >> 4) ^ (tmpval << 2);
592 hash ^= (tmpval >> 6) ^ (tmpval);
599 * emac_hash_add - Hash function to add mac addr from hash table
600 * @priv: The DaVinci EMAC private adapter structure
601 * @mac_addr: mac address to delete from hash table
603 * Adds mac address to the internal hash table
606 static int emac_hash_add(struct emac_priv *priv, u8 *mac_addr)
608 struct device *emac_dev = &priv->ndev->dev;
611 u32 hash_value = hash_get(mac_addr);
613 if (hash_value >= EMAC_NUM_MULTICAST_BITS) {
614 if (netif_msg_drv(priv)) {
615 dev_err(emac_dev, "DaVinci EMAC: emac_hash_add(): Invalid "\
616 "Hash %08x, should not be greater than %08x",
617 hash_value, (EMAC_NUM_MULTICAST_BITS - 1));
622 /* set the hash bit only if not previously set */
623 if (priv->multicast_hash_cnt[hash_value] == 0) {
624 rc = 1; /* hash value changed */
625 if (hash_value < 32) {
626 hash_bit = BIT(hash_value);
627 priv->mac_hash1 |= hash_bit;
629 hash_bit = BIT((hash_value - 32));
630 priv->mac_hash2 |= hash_bit;
634 /* incr counter for num of mcast addr's mapped to "this" hash bit */
635 ++priv->multicast_hash_cnt[hash_value];
641 * emac_hash_del - Hash function to delete mac addr from hash table
642 * @priv: The DaVinci EMAC private adapter structure
643 * @mac_addr: mac address to delete from hash table
645 * Removes mac address from the internal hash table
648 static int emac_hash_del(struct emac_priv *priv, u8 *mac_addr)
653 hash_value = hash_get(mac_addr);
654 if (priv->multicast_hash_cnt[hash_value] > 0) {
655 /* dec cntr for num of mcast addr's mapped to this hash bit */
656 --priv->multicast_hash_cnt[hash_value];
659 /* if counter still > 0, at least one multicast address refers
660 * to this hash bit. so return 0 */
661 if (priv->multicast_hash_cnt[hash_value] > 0)
664 if (hash_value < 32) {
665 hash_bit = BIT(hash_value);
666 priv->mac_hash1 &= ~hash_bit;
668 hash_bit = BIT((hash_value - 32));
669 priv->mac_hash2 &= ~hash_bit;
672 /* return 1 to indicate change in mac_hash registers reqd */
676 /* EMAC multicast operation */
677 #define EMAC_MULTICAST_ADD 0
678 #define EMAC_MULTICAST_DEL 1
679 #define EMAC_ALL_MULTI_SET 2
680 #define EMAC_ALL_MULTI_CLR 3
683 * emac_add_mcast - Set multicast address in the EMAC adapter (Internal)
684 * @priv: The DaVinci EMAC private adapter structure
685 * @action: multicast operation to perform
686 * @mac_addr: mac address to set
688 * Set multicast addresses in EMAC adapter - internal function
691 static void emac_add_mcast(struct emac_priv *priv, u32 action, u8 *mac_addr)
693 struct device *emac_dev = &priv->ndev->dev;
697 case EMAC_MULTICAST_ADD:
698 update = emac_hash_add(priv, mac_addr);
700 case EMAC_MULTICAST_DEL:
701 update = emac_hash_del(priv, mac_addr);
703 case EMAC_ALL_MULTI_SET:
705 priv->mac_hash1 = EMAC_ALL_MULTI_REG_VALUE;
706 priv->mac_hash2 = EMAC_ALL_MULTI_REG_VALUE;
708 case EMAC_ALL_MULTI_CLR:
712 memset(&(priv->multicast_hash_cnt[0]), 0,
713 sizeof(priv->multicast_hash_cnt[0]) *
714 EMAC_NUM_MULTICAST_BITS);
717 if (netif_msg_drv(priv))
718 dev_err(emac_dev, "DaVinci EMAC: add_mcast"\
719 ": bad operation %d", action);
723 /* write to the hardware only if the register status chances */
725 emac_write(EMAC_MACHASH1, priv->mac_hash1);
726 emac_write(EMAC_MACHASH2, priv->mac_hash2);
731 * emac_dev_mcast_set - Set multicast address in the EMAC adapter
732 * @ndev: The DaVinci EMAC network adapter
734 * Set multicast addresses in EMAC adapter
737 static void emac_dev_mcast_set(struct net_device *ndev)
740 struct emac_priv *priv = netdev_priv(ndev);
742 mbp_enable = emac_read(EMAC_RXMBPENABLE);
743 if (ndev->flags & IFF_PROMISC) {
744 mbp_enable &= (~EMAC_MBP_PROMISCCH(EMAC_DEF_PROM_CH));
745 mbp_enable |= (EMAC_MBP_RXPROMISC);
747 mbp_enable = (mbp_enable & ~EMAC_MBP_RXPROMISC);
748 if ((ndev->flags & IFF_ALLMULTI) ||
749 netdev_mc_count(ndev) > EMAC_DEF_MAX_MULTICAST_ADDRESSES) {
750 mbp_enable = (mbp_enable | EMAC_MBP_RXMCAST);
751 emac_add_mcast(priv, EMAC_ALL_MULTI_SET, NULL);
752 } else if (!netdev_mc_empty(ndev)) {
753 struct netdev_hw_addr *ha;
755 mbp_enable = (mbp_enable | EMAC_MBP_RXMCAST);
756 emac_add_mcast(priv, EMAC_ALL_MULTI_CLR, NULL);
757 /* program multicast address list into EMAC hardware */
758 netdev_for_each_mc_addr(ha, ndev) {
759 emac_add_mcast(priv, EMAC_MULTICAST_ADD,
763 mbp_enable = (mbp_enable & ~EMAC_MBP_RXMCAST);
764 emac_add_mcast(priv, EMAC_ALL_MULTI_CLR, NULL);
767 /* Set mbp config register */
768 emac_write(EMAC_RXMBPENABLE, mbp_enable);
771 /*************************************************************************
772 * EMAC Hardware manipulation
773 *************************************************************************/
776 * emac_int_disable - Disable EMAC module interrupt (from adapter)
777 * @priv: The DaVinci EMAC private adapter structure
779 * Disable EMAC interrupt on the adapter
782 static void emac_int_disable(struct emac_priv *priv)
784 if (priv->version == EMAC_VERSION_2) {
787 local_irq_save(flags);
789 /* Program C0_Int_En to zero to turn off
790 * interrupts to the CPU */
791 emac_ctrl_write(EMAC_DM646X_CMRXINTEN, 0x0);
792 emac_ctrl_write(EMAC_DM646X_CMTXINTEN, 0x0);
793 /* NOTE: Rx Threshold and Misc interrupts are not disabled */
794 if (priv->int_disable)
797 /* NOTE: Rx Threshold and Misc interrupts are not enabled */
799 /* ack rxen only then a new pulse will be generated */
800 emac_write(EMAC_DM646X_MACEOIVECTOR,
801 EMAC_DM646X_MAC_EOI_C0_RXEN);
803 /* ack txen- only then a new pulse will be generated */
804 emac_write(EMAC_DM646X_MACEOIVECTOR,
805 EMAC_DM646X_MAC_EOI_C0_TXEN);
807 local_irq_restore(flags);
810 /* Set DM644x control registers for interrupt control */
811 emac_ctrl_write(EMAC_CTRL_EWCTL, 0x0);
816 * emac_int_enable - Enable EMAC module interrupt (from adapter)
817 * @priv: The DaVinci EMAC private adapter structure
819 * Enable EMAC interrupt on the adapter
822 static void emac_int_enable(struct emac_priv *priv)
824 if (priv->version == EMAC_VERSION_2) {
825 if (priv->int_enable)
828 emac_ctrl_write(EMAC_DM646X_CMRXINTEN, 0xff);
829 emac_ctrl_write(EMAC_DM646X_CMTXINTEN, 0xff);
831 /* In addition to turning on interrupt Enable, we need
832 * ack by writing appropriate values to the EOI
835 /* NOTE: Rx Threshold and Misc interrupts are not enabled */
837 /* Set DM644x control registers for interrupt control */
838 emac_ctrl_write(EMAC_CTRL_EWCTL, 0x1);
843 * emac_irq - EMAC interrupt handler
844 * @irq: interrupt number
845 * @dev_id: EMAC network adapter data structure ptr
847 * EMAC Interrupt handler - we only schedule NAPI and not process any packets
848 * here. EVen the interrupt status is checked (TX/RX/Err) in NAPI poll function
850 * Returns interrupt handled condition
852 static irqreturn_t emac_irq(int irq, void *dev_id)
854 struct net_device *ndev = (struct net_device *)dev_id;
855 struct emac_priv *priv = netdev_priv(ndev);
858 if (likely(netif_running(priv->ndev))) {
859 emac_int_disable(priv);
860 napi_schedule(&priv->napi);
862 /* we are closing down, so dont process anything */
867 static struct sk_buff *emac_rx_alloc(struct emac_priv *priv)
869 struct sk_buff *skb = netdev_alloc_skb(priv->ndev, priv->rx_buf_size);
872 skb_reserve(skb, NET_IP_ALIGN);
876 static void emac_rx_handler(void *token, int len, int status)
878 struct sk_buff *skb = token;
879 struct net_device *ndev = skb->dev;
880 struct emac_priv *priv = netdev_priv(ndev);
881 struct device *emac_dev = &ndev->dev;
884 /* free and bail if we are shutting down */
885 if (unlikely(!netif_running(ndev))) {
886 dev_kfree_skb_any(skb);
890 /* recycle on receive error */
892 ndev->stats.rx_errors++;
896 /* feed received packet up the stack */
898 skb->protocol = eth_type_trans(skb, ndev);
899 netif_receive_skb(skb);
900 ndev->stats.rx_bytes += len;
901 ndev->stats.rx_packets++;
903 /* alloc a new packet for receive */
904 skb = emac_rx_alloc(priv);
906 if (netif_msg_rx_err(priv) && net_ratelimit())
907 dev_err(emac_dev, "failed rx buffer alloc\n");
912 ret = cpdma_chan_submit(priv->rxchan, skb, skb->data,
913 skb_tailroom(skb), 0);
915 WARN_ON(ret == -ENOMEM);
916 if (unlikely(ret < 0))
917 dev_kfree_skb_any(skb);
920 static void emac_tx_handler(void *token, int len, int status)
922 struct sk_buff *skb = token;
923 struct net_device *ndev = skb->dev;
925 /* Check whether the queue is stopped due to stalled tx dma, if the
926 * queue is stopped then start the queue as we have free desc for tx
928 if (unlikely(netif_queue_stopped(ndev)))
929 netif_wake_queue(ndev);
930 ndev->stats.tx_packets++;
931 ndev->stats.tx_bytes += len;
932 dev_kfree_skb_any(skb);
936 * emac_dev_xmit - EMAC Transmit function
938 * @ndev: The DaVinci EMAC network adapter
940 * Called by the system to transmit a packet - we queue the packet in
941 * EMAC hardware transmit queue
943 * Returns success(NETDEV_TX_OK) or error code (typically out of desc's)
945 static int emac_dev_xmit(struct sk_buff *skb, struct net_device *ndev)
947 struct device *emac_dev = &ndev->dev;
949 struct emac_priv *priv = netdev_priv(ndev);
951 /* If no link, return */
952 if (unlikely(!priv->link)) {
953 if (netif_msg_tx_err(priv) && net_ratelimit())
954 dev_err(emac_dev, "DaVinci EMAC: No link to transmit");
958 ret_code = skb_padto(skb, EMAC_DEF_MIN_ETHPKTSIZE);
959 if (unlikely(ret_code < 0)) {
960 if (netif_msg_tx_err(priv) && net_ratelimit())
961 dev_err(emac_dev, "DaVinci EMAC: packet pad failed");
965 skb_tx_timestamp(skb);
967 ret_code = cpdma_chan_submit(priv->txchan, skb, skb->data, skb->len,
969 if (unlikely(ret_code != 0)) {
970 if (netif_msg_tx_err(priv) && net_ratelimit())
971 dev_err(emac_dev, "DaVinci EMAC: desc submit failed");
975 /* If there is no more tx desc left free then we need to
976 * tell the kernel to stop sending us tx frames.
978 if (unlikely(!cpdma_check_free_tx_desc(priv->txchan)))
979 netif_stop_queue(ndev);
984 ndev->stats.tx_dropped++;
985 netif_stop_queue(ndev);
986 return NETDEV_TX_BUSY;
990 * emac_dev_tx_timeout - EMAC Transmit timeout function
991 * @ndev: The DaVinci EMAC network adapter
992 * @txqueue: the index of the hung transmit queue
994 * Called when system detects that a skb timeout period has expired
995 * potentially due to a fault in the adapter in not being able to send
996 * it out on the wire. We teardown the TX channel assuming a hardware
997 * error and re-initialize the TX channel for hardware operation
1000 static void emac_dev_tx_timeout(struct net_device *ndev, unsigned int txqueue)
1002 struct emac_priv *priv = netdev_priv(ndev);
1003 struct device *emac_dev = &ndev->dev;
1005 if (netif_msg_tx_err(priv))
1006 dev_err(emac_dev, "DaVinci EMAC: xmit timeout, restarting TX");
1008 ndev->stats.tx_errors++;
1009 emac_int_disable(priv);
1010 cpdma_chan_stop(priv->txchan);
1011 cpdma_chan_start(priv->txchan);
1012 emac_int_enable(priv);
1016 * emac_set_type0addr - Set EMAC Type0 mac address
1017 * @priv: The DaVinci EMAC private adapter structure
1018 * @ch: RX channel number
1019 * @mac_addr: MAC address to set in device
1021 * Called internally to set Type0 mac address of the adapter (Device)
1023 * Returns success (0) or appropriate error code (none as of now)
1025 static void emac_set_type0addr(struct emac_priv *priv, u32 ch, char *mac_addr)
1028 val = ((mac_addr[5] << 8) | (mac_addr[4]));
1029 emac_write(EMAC_MACSRCADDRLO, val);
1031 val = ((mac_addr[3] << 24) | (mac_addr[2] << 16) | \
1032 (mac_addr[1] << 8) | (mac_addr[0]));
1033 emac_write(EMAC_MACSRCADDRHI, val);
1034 val = emac_read(EMAC_RXUNICASTSET);
1036 emac_write(EMAC_RXUNICASTSET, val);
1037 val = emac_read(EMAC_RXUNICASTCLEAR);
1039 emac_write(EMAC_RXUNICASTCLEAR, val);
1043 * emac_set_type1addr - Set EMAC Type1 mac address
1044 * @priv: The DaVinci EMAC private adapter structure
1045 * @ch: RX channel number
1046 * @mac_addr: MAC address to set in device
1048 * Called internally to set Type1 mac address of the adapter (Device)
1050 * Returns success (0) or appropriate error code (none as of now)
1052 static void emac_set_type1addr(struct emac_priv *priv, u32 ch, char *mac_addr)
1055 emac_write(EMAC_MACINDEX, ch);
1056 val = ((mac_addr[5] << 8) | mac_addr[4]);
1057 emac_write(EMAC_MACADDRLO, val);
1058 val = ((mac_addr[3] << 24) | (mac_addr[2] << 16) | \
1059 (mac_addr[1] << 8) | (mac_addr[0]));
1060 emac_write(EMAC_MACADDRHI, val);
1061 emac_set_type0addr(priv, ch, mac_addr);
1065 * emac_set_type2addr - Set EMAC Type2 mac address
1066 * @priv: The DaVinci EMAC private adapter structure
1067 * @ch: RX channel number
1068 * @mac_addr: MAC address to set in device
1069 * @index: index into RX address entries
1070 * @match: match parameter for RX address matching logic
1072 * Called internally to set Type2 mac address of the adapter (Device)
1074 * Returns success (0) or appropriate error code (none as of now)
1076 static void emac_set_type2addr(struct emac_priv *priv, u32 ch,
1077 char *mac_addr, int index, int match)
1080 emac_write(EMAC_MACINDEX, index);
1081 val = ((mac_addr[3] << 24) | (mac_addr[2] << 16) | \
1082 (mac_addr[1] << 8) | (mac_addr[0]));
1083 emac_write(EMAC_MACADDRHI, val);
1084 val = ((mac_addr[5] << 8) | mac_addr[4] | ((ch & 0x7) << 16) | \
1085 (match << 19) | BIT(20));
1086 emac_write(EMAC_MACADDRLO, val);
1087 emac_set_type0addr(priv, ch, mac_addr);
1091 * emac_setmac - Set mac address in the adapter (internal function)
1092 * @priv: The DaVinci EMAC private adapter structure
1093 * @ch: RX channel number
1094 * @mac_addr: MAC address to set in device
1096 * Called internally to set the mac address of the adapter (Device)
1098 * Returns success (0) or appropriate error code (none as of now)
1100 static void emac_setmac(struct emac_priv *priv, u32 ch, char *mac_addr)
1102 struct device *emac_dev = &priv->ndev->dev;
1104 if (priv->rx_addr_type == 0) {
1105 emac_set_type0addr(priv, ch, mac_addr);
1106 } else if (priv->rx_addr_type == 1) {
1108 for (cnt = 0; cnt < EMAC_MAX_TXRX_CHANNELS; cnt++)
1109 emac_set_type1addr(priv, ch, mac_addr);
1110 } else if (priv->rx_addr_type == 2) {
1111 emac_set_type2addr(priv, ch, mac_addr, ch, 1);
1112 emac_set_type0addr(priv, ch, mac_addr);
1114 if (netif_msg_drv(priv))
1115 dev_err(emac_dev, "DaVinci EMAC: Wrong addressing\n");
1120 * emac_dev_setmac_addr - Set mac address in the adapter
1121 * @ndev: The DaVinci EMAC network adapter
1122 * @addr: MAC address to set in device
1124 * Called by the system to set the mac address of the adapter (Device)
1126 * Returns success (0) or appropriate error code (none as of now)
1128 static int emac_dev_setmac_addr(struct net_device *ndev, void *addr)
1130 struct emac_priv *priv = netdev_priv(ndev);
1131 struct device *emac_dev = &priv->ndev->dev;
1132 struct sockaddr *sa = addr;
1134 if (!is_valid_ether_addr(sa->sa_data))
1135 return -EADDRNOTAVAIL;
1137 /* Store mac addr in priv and rx channel and set it in EMAC hw */
1138 memcpy(priv->mac_addr, sa->sa_data, ndev->addr_len);
1139 memcpy(ndev->dev_addr, sa->sa_data, ndev->addr_len);
1141 /* MAC address is configured only after the interface is enabled. */
1142 if (netif_running(ndev)) {
1143 emac_setmac(priv, EMAC_DEF_RX_CH, priv->mac_addr);
1146 if (netif_msg_drv(priv))
1147 dev_notice(emac_dev, "DaVinci EMAC: emac_dev_setmac_addr %pM\n",
1154 * emac_hw_enable - Enable EMAC hardware for packet transmission/reception
1155 * @priv: The DaVinci EMAC private adapter structure
1157 * Enables EMAC hardware for packet processing - enables PHY, enables RX
1158 * for packet reception and enables device interrupts and then NAPI
1160 * Returns success (0) or appropriate error code (none right now)
1162 static int emac_hw_enable(struct emac_priv *priv)
1164 u32 val, mbp_enable, mac_control;
1167 emac_write(EMAC_SOFTRESET, 1);
1168 while (emac_read(EMAC_SOFTRESET))
1171 /* Disable interrupt & Set pacing for more interrupts initially */
1172 emac_int_disable(priv);
1174 /* Full duplex enable bit set when auto negotiation happens */
1176 (((EMAC_DEF_TXPRIO_FIXED) ? (EMAC_MACCONTROL_TXPTYPE) : 0x0) |
1177 ((priv->speed == 1000) ? EMAC_MACCONTROL_GIGABITEN : 0x0) |
1178 ((EMAC_DEF_TXPACING_EN) ? (EMAC_MACCONTROL_TXPACEEN) : 0x0) |
1179 ((priv->duplex == DUPLEX_FULL) ? 0x1 : 0));
1180 emac_write(EMAC_MACCONTROL, mac_control);
1183 (((EMAC_DEF_PASS_CRC) ? (EMAC_RXMBP_PASSCRC_MASK) : 0x0) |
1184 ((EMAC_DEF_QOS_EN) ? (EMAC_RXMBP_QOSEN_MASK) : 0x0) |
1185 ((EMAC_DEF_NO_BUFF_CHAIN) ? (EMAC_RXMBP_NOCHAIN_MASK) : 0x0) |
1186 ((EMAC_DEF_MACCTRL_FRAME_EN) ? (EMAC_RXMBP_CMFEN_MASK) : 0x0) |
1187 ((EMAC_DEF_SHORT_FRAME_EN) ? (EMAC_RXMBP_CSFEN_MASK) : 0x0) |
1188 ((EMAC_DEF_ERROR_FRAME_EN) ? (EMAC_RXMBP_CEFEN_MASK) : 0x0) |
1189 ((EMAC_DEF_PROM_EN) ? (EMAC_RXMBP_CAFEN_MASK) : 0x0) |
1190 ((EMAC_DEF_PROM_CH & EMAC_RXMBP_CHMASK) << \
1191 EMAC_RXMBP_PROMCH_SHIFT) |
1192 ((EMAC_DEF_BCAST_EN) ? (EMAC_RXMBP_BROADEN_MASK) : 0x0) |
1193 ((EMAC_DEF_BCAST_CH & EMAC_RXMBP_CHMASK) << \
1194 EMAC_RXMBP_BROADCH_SHIFT) |
1195 ((EMAC_DEF_MCAST_EN) ? (EMAC_RXMBP_MULTIEN_MASK) : 0x0) |
1196 ((EMAC_DEF_MCAST_CH & EMAC_RXMBP_CHMASK) << \
1197 EMAC_RXMBP_MULTICH_SHIFT));
1198 emac_write(EMAC_RXMBPENABLE, mbp_enable);
1199 emac_write(EMAC_RXMAXLEN, (EMAC_DEF_MAX_FRAME_SIZE &
1200 EMAC_RX_MAX_LEN_MASK));
1201 emac_write(EMAC_RXBUFFEROFFSET, (EMAC_DEF_BUFFER_OFFSET &
1202 EMAC_RX_BUFFER_OFFSET_MASK));
1203 emac_write(EMAC_RXFILTERLOWTHRESH, 0);
1204 emac_write(EMAC_RXUNICASTCLEAR, EMAC_RX_UNICAST_CLEAR_ALL);
1205 priv->rx_addr_type = (emac_read(EMAC_MACCONFIG) >> 8) & 0xFF;
1207 emac_write(EMAC_MACINTMASKSET, EMAC_MAC_HOST_ERR_INTMASK_VAL);
1209 emac_setmac(priv, EMAC_DEF_RX_CH, priv->mac_addr);
1212 val = emac_read(EMAC_MACCONTROL);
1213 val |= (EMAC_MACCONTROL_GMIIEN);
1214 emac_write(EMAC_MACCONTROL, val);
1216 /* Enable NAPI and interrupts */
1217 napi_enable(&priv->napi);
1218 emac_int_enable(priv);
1224 * emac_poll - EMAC NAPI Poll function
1225 * @napi: pointer to the napi_struct containing The DaVinci EMAC network adapter
1226 * @budget: Number of receive packets to process (as told by NAPI layer)
1228 * NAPI Poll function implemented to process packets as per budget. We check
1229 * the type of interrupt on the device and accordingly call the TX or RX
1230 * packet processing functions. We follow the budget for RX processing and
1231 * also put a cap on number of TX pkts processed through config param. The
1232 * NAPI schedule function is called if more packets pending.
1234 * Returns number of packets received (in most cases; else TX pkts - rarely)
1236 static int emac_poll(struct napi_struct *napi, int budget)
1239 struct emac_priv *priv = container_of(napi, struct emac_priv, napi);
1240 struct net_device *ndev = priv->ndev;
1241 struct device *emac_dev = &ndev->dev;
1243 u32 num_rx_pkts = 0;
1245 /* Check interrupt vectors and call packet processing */
1246 status = emac_read(EMAC_MACINVECTOR);
1248 mask = EMAC_DM644X_MAC_IN_VECTOR_TX_INT_VEC;
1250 if (priv->version == EMAC_VERSION_2)
1251 mask = EMAC_DM646X_MAC_IN_VECTOR_TX_INT_VEC;
1253 if (status & mask) {
1254 cpdma_chan_process(priv->txchan, EMAC_DEF_TX_MAX_SERVICE);
1255 } /* TX processing */
1257 mask = EMAC_DM644X_MAC_IN_VECTOR_RX_INT_VEC;
1259 if (priv->version == EMAC_VERSION_2)
1260 mask = EMAC_DM646X_MAC_IN_VECTOR_RX_INT_VEC;
1262 if (status & mask) {
1263 num_rx_pkts = cpdma_chan_process(priv->rxchan, budget);
1264 } /* RX processing */
1266 mask = EMAC_DM644X_MAC_IN_VECTOR_HOST_INT;
1267 if (priv->version == EMAC_VERSION_2)
1268 mask = EMAC_DM646X_MAC_IN_VECTOR_HOST_INT;
1270 if (unlikely(status & mask)) {
1272 dev_err(emac_dev, "DaVinci EMAC: Fatal Hardware Error\n");
1273 netif_stop_queue(ndev);
1274 napi_disable(&priv->napi);
1276 status = emac_read(EMAC_MACSTATUS);
1277 cause = ((status & EMAC_MACSTATUS_TXERRCODE_MASK) >>
1278 EMAC_MACSTATUS_TXERRCODE_SHIFT);
1280 ch = ((status & EMAC_MACSTATUS_TXERRCH_MASK) >>
1281 EMAC_MACSTATUS_TXERRCH_SHIFT);
1282 if (net_ratelimit()) {
1283 dev_err(emac_dev, "TX Host error %s on ch=%d\n",
1284 &emac_txhost_errcodes[cause][0], ch);
1287 cause = ((status & EMAC_MACSTATUS_RXERRCODE_MASK) >>
1288 EMAC_MACSTATUS_RXERRCODE_SHIFT);
1290 ch = ((status & EMAC_MACSTATUS_RXERRCH_MASK) >>
1291 EMAC_MACSTATUS_RXERRCH_SHIFT);
1292 if (netif_msg_hw(priv) && net_ratelimit())
1293 dev_err(emac_dev, "RX Host error %s on ch=%d\n",
1294 &emac_rxhost_errcodes[cause][0], ch);
1296 } else if (num_rx_pkts < budget) {
1297 napi_complete_done(napi, num_rx_pkts);
1298 emac_int_enable(priv);
1304 #ifdef CONFIG_NET_POLL_CONTROLLER
1306 * emac_poll_controller - EMAC Poll controller function
1307 * @ndev: The DaVinci EMAC network adapter
1309 * Polled functionality used by netconsole and others in non interrupt mode
1312 static void emac_poll_controller(struct net_device *ndev)
1314 struct emac_priv *priv = netdev_priv(ndev);
1316 emac_int_disable(priv);
1317 emac_irq(ndev->irq, ndev);
1318 emac_int_enable(priv);
1322 static void emac_adjust_link(struct net_device *ndev)
1324 struct emac_priv *priv = netdev_priv(ndev);
1325 struct phy_device *phydev = ndev->phydev;
1326 unsigned long flags;
1329 spin_lock_irqsave(&priv->lock, flags);
1332 /* check the mode of operation - full/half duplex */
1333 if (phydev->duplex != priv->duplex) {
1335 priv->duplex = phydev->duplex;
1337 if (phydev->speed != priv->speed) {
1339 priv->speed = phydev->speed;
1346 } else if (priv->link) {
1353 emac_update_phystatus(priv);
1354 phy_print_status(ndev->phydev);
1357 spin_unlock_irqrestore(&priv->lock, flags);
1360 /*************************************************************************
1361 * Linux Driver Model
1362 *************************************************************************/
1365 * emac_devioctl - EMAC adapter ioctl
1366 * @ndev: The DaVinci EMAC network adapter
1367 * @ifrq: request parameter
1368 * @cmd: command parameter
1370 * EMAC driver ioctl function
1372 * Returns success(0) or appropriate error code
1374 static int emac_devioctl(struct net_device *ndev, struct ifreq *ifrq, int cmd)
1376 if (!(netif_running(ndev)))
1379 /* TODO: Add phy read and write and private statistics get feature */
1382 return phy_mii_ioctl(ndev->phydev, ifrq, cmd);
1387 static int match_first_device(struct device *dev, const void *data)
1389 if (dev->parent && dev->parent->of_node)
1390 return of_device_is_compatible(dev->parent->of_node,
1393 return !strncmp(dev_name(dev), "davinci_mdio", 12);
1397 * emac_dev_open - EMAC device open
1398 * @ndev: The DaVinci EMAC network adapter
1400 * Called when system wants to start the interface. We init TX/RX channels
1401 * and enable the hardware for packet reception/transmission and start the
1404 * Returns 0 for a successful open, or appropriate error code
1406 static int emac_dev_open(struct net_device *ndev)
1408 struct device *emac_dev = &ndev->dev;
1410 struct resource *res;
1412 int res_num = 0, irq_num = 0;
1414 struct emac_priv *priv = netdev_priv(ndev);
1415 struct phy_device *phydev = NULL;
1416 struct device *phy = NULL;
1418 ret = pm_runtime_get_sync(&priv->pdev->dev);
1420 pm_runtime_put_noidle(&priv->pdev->dev);
1421 dev_err(&priv->pdev->dev, "%s: failed to get_sync(%d)\n",
1426 netif_carrier_off(ndev);
1427 for (cnt = 0; cnt < ETH_ALEN; cnt++)
1428 ndev->dev_addr[cnt] = priv->mac_addr[cnt];
1430 /* Configuration items */
1431 priv->rx_buf_size = EMAC_DEF_MAX_FRAME_SIZE + NET_IP_ALIGN;
1433 priv->mac_hash1 = 0;
1434 priv->mac_hash2 = 0;
1435 emac_write(EMAC_MACHASH1, 0);
1436 emac_write(EMAC_MACHASH2, 0);
1438 for (i = 0; i < EMAC_DEF_RX_NUM_DESC; i++) {
1439 struct sk_buff *skb = emac_rx_alloc(priv);
1444 ret = cpdma_chan_idle_submit(priv->rxchan, skb, skb->data,
1445 skb_tailroom(skb), 0);
1446 if (WARN_ON(ret < 0))
1451 while ((res = platform_get_resource(priv->pdev, IORESOURCE_IRQ,
1453 for (irq_num = res->start; irq_num <= res->end; irq_num++) {
1454 if (request_irq(irq_num, emac_irq, 0, ndev->name,
1457 "DaVinci EMAC: request_irq() failed\n");
1465 /* prepare counters for rollback in case of an error */
1469 /* Start/Enable EMAC hardware */
1470 emac_hw_enable(priv);
1472 /* Enable Interrupt pacing if configured */
1473 if (priv->coal_intvl != 0) {
1474 struct ethtool_coalesce coal;
1476 coal.rx_coalesce_usecs = (priv->coal_intvl << 4);
1477 emac_set_coalesce(ndev, &coal);
1480 cpdma_ctlr_start(priv->dma);
1482 if (priv->phy_node) {
1483 phydev = of_phy_connect(ndev, priv->phy_node,
1484 &emac_adjust_link, 0, 0);
1486 dev_err(emac_dev, "could not connect to phy %pOF\n",
1493 /* use the first phy on the bus if pdata did not give us a phy id */
1494 if (!phydev && !priv->phy_id) {
1495 /* NOTE: we can't use bus_find_device_by_name() here because
1496 * the device name is not guaranteed to be 'davinci_mdio'. On
1497 * some systems it can be 'davinci_mdio.0' so we need to use
1498 * strncmp() against the first part of the string to correctly
1501 phy = bus_find_device(&mdio_bus_type, NULL, NULL,
1502 match_first_device);
1504 priv->phy_id = dev_name(phy);
1505 if (!priv->phy_id || !*priv->phy_id)
1510 if (!phydev && priv->phy_id && *priv->phy_id) {
1511 phydev = phy_connect(ndev, priv->phy_id,
1513 PHY_INTERFACE_MODE_MII);
1514 put_device(phy); /* reference taken by bus_find_device */
1515 if (IS_ERR(phydev)) {
1516 dev_err(emac_dev, "could not connect to phy %s\n",
1518 ret = PTR_ERR(phydev);
1526 phy_attached_info(phydev);
1530 /* No PHY , fix the link, speed and duplex settings */
1531 dev_notice(emac_dev, "no phy, defaulting to 100/full\n");
1533 priv->speed = SPEED_100;
1534 priv->duplex = DUPLEX_FULL;
1535 emac_update_phystatus(priv);
1538 if (netif_msg_drv(priv))
1539 dev_notice(emac_dev, "DaVinci EMAC: Opened %s\n", ndev->name);
1547 emac_int_disable(priv);
1548 napi_disable(&priv->napi);
1551 for (q = res_num; q >= 0; q--) {
1552 res = platform_get_resource(priv->pdev, IORESOURCE_IRQ, q);
1553 /* at the first iteration, irq_num is already set to the
1559 for (m = irq_num; m >= res->start; m--)
1562 cpdma_ctlr_stop(priv->dma);
1563 pm_runtime_put(&priv->pdev->dev);
1568 * emac_dev_stop - EMAC device stop
1569 * @ndev: The DaVinci EMAC network adapter
1571 * Called when system wants to stop or down the interface. We stop the network
1572 * queue, disable interrupts and cleanup TX/RX channels.
1574 * We return the statistics in net_device_stats structure pulled from emac
1576 static int emac_dev_stop(struct net_device *ndev)
1578 struct resource *res;
1581 struct emac_priv *priv = netdev_priv(ndev);
1582 struct device *emac_dev = &ndev->dev;
1584 /* inform the upper layers. */
1585 netif_stop_queue(ndev);
1586 napi_disable(&priv->napi);
1588 netif_carrier_off(ndev);
1589 emac_int_disable(priv);
1590 cpdma_ctlr_stop(priv->dma);
1591 emac_write(EMAC_SOFTRESET, 1);
1594 phy_disconnect(ndev->phydev);
1597 while ((res = platform_get_resource(priv->pdev, IORESOURCE_IRQ, i))) {
1598 for (irq_num = res->start; irq_num <= res->end; irq_num++)
1599 free_irq(irq_num, priv->ndev);
1603 if (netif_msg_drv(priv))
1604 dev_notice(emac_dev, "DaVinci EMAC: %s stopped\n", ndev->name);
1606 pm_runtime_put(&priv->pdev->dev);
1611 * emac_dev_getnetstats - EMAC get statistics function
1612 * @ndev: The DaVinci EMAC network adapter
1614 * Called when system wants to get statistics from the device.
1616 * We return the statistics in net_device_stats structure pulled from emac
1618 static struct net_device_stats *emac_dev_getnetstats(struct net_device *ndev)
1620 struct emac_priv *priv = netdev_priv(ndev);
1622 u32 stats_clear_mask;
1625 err = pm_runtime_get_sync(&priv->pdev->dev);
1627 pm_runtime_put_noidle(&priv->pdev->dev);
1628 dev_err(&priv->pdev->dev, "%s: failed to get_sync(%d)\n",
1630 return &ndev->stats;
1633 /* update emac hardware stats and reset the registers*/
1635 mac_control = emac_read(EMAC_MACCONTROL);
1637 if (mac_control & EMAC_MACCONTROL_GMIIEN)
1638 stats_clear_mask = EMAC_STATS_CLR_MASK;
1640 stats_clear_mask = 0;
1642 ndev->stats.multicast += emac_read(EMAC_RXMCASTFRAMES);
1643 emac_write(EMAC_RXMCASTFRAMES, stats_clear_mask);
1645 ndev->stats.collisions += (emac_read(EMAC_TXCOLLISION) +
1646 emac_read(EMAC_TXSINGLECOLL) +
1647 emac_read(EMAC_TXMULTICOLL));
1648 emac_write(EMAC_TXCOLLISION, stats_clear_mask);
1649 emac_write(EMAC_TXSINGLECOLL, stats_clear_mask);
1650 emac_write(EMAC_TXMULTICOLL, stats_clear_mask);
1652 ndev->stats.rx_length_errors += (emac_read(EMAC_RXOVERSIZED) +
1653 emac_read(EMAC_RXJABBER) +
1654 emac_read(EMAC_RXUNDERSIZED));
1655 emac_write(EMAC_RXOVERSIZED, stats_clear_mask);
1656 emac_write(EMAC_RXJABBER, stats_clear_mask);
1657 emac_write(EMAC_RXUNDERSIZED, stats_clear_mask);
1659 ndev->stats.rx_over_errors += (emac_read(EMAC_RXSOFOVERRUNS) +
1660 emac_read(EMAC_RXMOFOVERRUNS));
1661 emac_write(EMAC_RXSOFOVERRUNS, stats_clear_mask);
1662 emac_write(EMAC_RXMOFOVERRUNS, stats_clear_mask);
1664 ndev->stats.rx_fifo_errors += emac_read(EMAC_RXDMAOVERRUNS);
1665 emac_write(EMAC_RXDMAOVERRUNS, stats_clear_mask);
1667 ndev->stats.tx_carrier_errors +=
1668 emac_read(EMAC_TXCARRIERSENSE);
1669 emac_write(EMAC_TXCARRIERSENSE, stats_clear_mask);
1671 ndev->stats.tx_fifo_errors += emac_read(EMAC_TXUNDERRUN);
1672 emac_write(EMAC_TXUNDERRUN, stats_clear_mask);
1674 pm_runtime_put(&priv->pdev->dev);
1676 return &ndev->stats;
1679 static const struct net_device_ops emac_netdev_ops = {
1680 .ndo_open = emac_dev_open,
1681 .ndo_stop = emac_dev_stop,
1682 .ndo_start_xmit = emac_dev_xmit,
1683 .ndo_set_rx_mode = emac_dev_mcast_set,
1684 .ndo_set_mac_address = emac_dev_setmac_addr,
1685 .ndo_do_ioctl = emac_devioctl,
1686 .ndo_tx_timeout = emac_dev_tx_timeout,
1687 .ndo_get_stats = emac_dev_getnetstats,
1688 #ifdef CONFIG_NET_POLL_CONTROLLER
1689 .ndo_poll_controller = emac_poll_controller,
1693 static const struct of_device_id davinci_emac_of_match[];
1695 static struct emac_platform_data *
1696 davinci_emac_of_get_pdata(struct platform_device *pdev, struct emac_priv *priv)
1698 struct device_node *np;
1699 const struct of_device_id *match;
1700 const struct emac_platform_data *auxdata;
1701 struct emac_platform_data *pdata = NULL;
1704 if (!IS_ENABLED(CONFIG_OF) || !pdev->dev.of_node)
1705 return dev_get_platdata(&pdev->dev);
1707 pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
1711 np = pdev->dev.of_node;
1712 pdata->version = EMAC_VERSION_2;
1714 if (!is_valid_ether_addr(pdata->mac_addr)) {
1715 mac_addr = of_get_mac_address(np);
1716 if (!IS_ERR(mac_addr))
1717 ether_addr_copy(pdata->mac_addr, mac_addr);
1720 of_property_read_u32(np, "ti,davinci-ctrl-reg-offset",
1721 &pdata->ctrl_reg_offset);
1723 of_property_read_u32(np, "ti,davinci-ctrl-mod-reg-offset",
1724 &pdata->ctrl_mod_reg_offset);
1726 of_property_read_u32(np, "ti,davinci-ctrl-ram-offset",
1727 &pdata->ctrl_ram_offset);
1729 of_property_read_u32(np, "ti,davinci-ctrl-ram-size",
1730 &pdata->ctrl_ram_size);
1732 of_property_read_u8(np, "ti,davinci-rmii-en", &pdata->rmii_en);
1734 pdata->no_bd_ram = of_property_read_bool(np, "ti,davinci-no-bd-ram");
1736 priv->phy_node = of_parse_phandle(np, "phy-handle", 0);
1737 if (!priv->phy_node) {
1738 if (!of_phy_is_fixed_link(np))
1739 pdata->phy_id = NULL;
1740 else if (of_phy_register_fixed_link(np) >= 0)
1741 priv->phy_node = of_node_get(np);
1744 auxdata = pdev->dev.platform_data;
1746 pdata->interrupt_enable = auxdata->interrupt_enable;
1747 pdata->interrupt_disable = auxdata->interrupt_disable;
1750 match = of_match_device(davinci_emac_of_match, &pdev->dev);
1751 if (match && match->data) {
1752 auxdata = match->data;
1753 pdata->version = auxdata->version;
1754 pdata->hw_ram_addr = auxdata->hw_ram_addr;
1760 static int davinci_emac_try_get_mac(struct platform_device *pdev,
1761 int instance, u8 *mac_addr)
1763 if (!pdev->dev.of_node)
1766 return ti_cm_get_macid(&pdev->dev, instance, mac_addr);
1770 * davinci_emac_probe - EMAC device probe
1771 * @pdev: The DaVinci EMAC device that we are removing
1773 * Called when probing for emac devicesr. We get details of instances and
1774 * resource information from platform init and register a network device
1775 * and allocate resources necessary for driver to perform
1777 static int davinci_emac_probe(struct platform_device *pdev)
1779 struct device_node *np = pdev->dev.of_node;
1781 struct resource *res, *res_ctrl;
1782 struct net_device *ndev;
1783 struct emac_priv *priv;
1784 unsigned long hw_ram_addr;
1785 struct emac_platform_data *pdata;
1786 struct cpdma_params dma_params;
1787 struct clk *emac_clk;
1788 unsigned long emac_bus_frequency;
1791 /* obtain emac clock from kernel */
1792 emac_clk = devm_clk_get(&pdev->dev, NULL);
1793 if (IS_ERR(emac_clk)) {
1794 dev_err(&pdev->dev, "failed to get EMAC clock\n");
1797 emac_bus_frequency = clk_get_rate(emac_clk);
1798 devm_clk_put(&pdev->dev, emac_clk);
1800 /* TODO: Probe PHY here if possible */
1802 ndev = alloc_etherdev(sizeof(struct emac_priv));
1806 platform_set_drvdata(pdev, ndev);
1807 priv = netdev_priv(ndev);
1810 priv->msg_enable = netif_msg_init(debug_level, DAVINCI_EMAC_DEBUG);
1812 spin_lock_init(&priv->lock);
1814 pdata = davinci_emac_of_get_pdata(pdev, priv);
1816 dev_err(&pdev->dev, "no platform data\n");
1818 goto err_free_netdev;
1821 /* MAC addr and PHY mask , RMII enable info from platform_data */
1822 memcpy(priv->mac_addr, pdata->mac_addr, ETH_ALEN);
1823 priv->phy_id = pdata->phy_id;
1824 priv->rmii_en = pdata->rmii_en;
1825 priv->version = pdata->version;
1826 priv->int_enable = pdata->interrupt_enable;
1827 priv->int_disable = pdata->interrupt_disable;
1829 priv->coal_intvl = 0;
1830 priv->bus_freq_mhz = (u32)(emac_bus_frequency / 1000000);
1832 /* Get EMAC platform data */
1833 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1834 priv->emac_base_phys = res->start + pdata->ctrl_reg_offset;
1835 priv->remap_addr = devm_ioremap_resource(&pdev->dev, res);
1836 if (IS_ERR(priv->remap_addr)) {
1837 rc = PTR_ERR(priv->remap_addr);
1841 res_ctrl = platform_get_resource(pdev, IORESOURCE_MEM, 1);
1844 devm_ioremap_resource(&pdev->dev, res_ctrl);
1845 if (IS_ERR(priv->ctrl_base)) {
1846 rc = PTR_ERR(priv->ctrl_base);
1850 priv->ctrl_base = priv->remap_addr + pdata->ctrl_mod_reg_offset;
1853 priv->emac_base = priv->remap_addr + pdata->ctrl_reg_offset;
1854 ndev->base_addr = (unsigned long)priv->remap_addr;
1856 hw_ram_addr = pdata->hw_ram_addr;
1858 hw_ram_addr = (u32 __force)res->start + pdata->ctrl_ram_offset;
1860 memset(&dma_params, 0, sizeof(dma_params));
1861 dma_params.dev = &pdev->dev;
1862 dma_params.dmaregs = priv->emac_base;
1863 dma_params.rxthresh = priv->emac_base + 0x120;
1864 dma_params.rxfree = priv->emac_base + 0x140;
1865 dma_params.txhdp = priv->emac_base + 0x600;
1866 dma_params.rxhdp = priv->emac_base + 0x620;
1867 dma_params.txcp = priv->emac_base + 0x640;
1868 dma_params.rxcp = priv->emac_base + 0x660;
1869 dma_params.num_chan = EMAC_MAX_TXRX_CHANNELS;
1870 dma_params.min_packet_size = EMAC_DEF_MIN_ETHPKTSIZE;
1871 dma_params.desc_hw_addr = hw_ram_addr;
1872 dma_params.desc_mem_size = pdata->ctrl_ram_size;
1873 dma_params.desc_align = 16;
1875 dma_params.desc_mem_phys = pdata->no_bd_ram ? 0 :
1876 (u32 __force)res->start + pdata->ctrl_ram_offset;
1878 priv->dma = cpdma_ctlr_create(&dma_params);
1880 dev_err(&pdev->dev, "error initializing DMA\n");
1885 priv->txchan = cpdma_chan_create(priv->dma, EMAC_DEF_TX_CH,
1886 emac_tx_handler, 0);
1887 if (IS_ERR(priv->txchan)) {
1888 dev_err(&pdev->dev, "error initializing tx dma channel\n");
1889 rc = PTR_ERR(priv->txchan);
1893 priv->rxchan = cpdma_chan_create(priv->dma, EMAC_DEF_RX_CH,
1894 emac_rx_handler, 1);
1895 if (IS_ERR(priv->rxchan)) {
1896 dev_err(&pdev->dev, "error initializing rx dma channel\n");
1897 rc = PTR_ERR(priv->rxchan);
1898 goto err_free_txchan;
1901 res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
1903 dev_err(&pdev->dev, "error getting irq res\n");
1905 goto err_free_rxchan;
1907 ndev->irq = res->start;
1909 rc = davinci_emac_try_get_mac(pdev, res_ctrl ? 0 : 1, priv->mac_addr);
1911 ether_addr_copy(ndev->dev_addr, priv->mac_addr);
1913 if (!is_valid_ether_addr(priv->mac_addr)) {
1914 /* Use random MAC if still none obtained. */
1915 eth_hw_addr_random(ndev);
1916 memcpy(priv->mac_addr, ndev->dev_addr, ndev->addr_len);
1917 dev_warn(&pdev->dev, "using random MAC addr: %pM\n",
1921 ndev->netdev_ops = &emac_netdev_ops;
1922 ndev->ethtool_ops = ðtool_ops;
1923 netif_napi_add(ndev, &priv->napi, emac_poll, EMAC_POLL_WEIGHT);
1925 pm_runtime_enable(&pdev->dev);
1926 rc = pm_runtime_get_sync(&pdev->dev);
1928 pm_runtime_put_noidle(&pdev->dev);
1929 dev_err(&pdev->dev, "%s: failed to get_sync(%d)\n",
1934 /* register the network device */
1935 SET_NETDEV_DEV(ndev, &pdev->dev);
1936 rc = register_netdev(ndev);
1938 dev_err(&pdev->dev, "error in register_netdev\n");
1940 pm_runtime_put(&pdev->dev);
1945 if (netif_msg_probe(priv)) {
1946 dev_notice(&pdev->dev, "DaVinci EMAC Probe found device "
1947 "(regs: %pa, irq: %d)\n",
1948 &priv->emac_base_phys, ndev->irq);
1950 pm_runtime_put(&pdev->dev);
1955 netif_napi_del(&priv->napi);
1957 cpdma_chan_destroy(priv->rxchan);
1959 cpdma_chan_destroy(priv->txchan);
1961 cpdma_ctlr_destroy(priv->dma);
1963 if (of_phy_is_fixed_link(np))
1964 of_phy_deregister_fixed_link(np);
1965 of_node_put(priv->phy_node);
1972 * davinci_emac_remove - EMAC device remove
1973 * @pdev: The DaVinci EMAC device that we are removing
1975 * Called when removing the device driver. We disable clock usage and release
1976 * the resources taken up by the driver and unregister network device
1978 static int davinci_emac_remove(struct platform_device *pdev)
1980 struct net_device *ndev = platform_get_drvdata(pdev);
1981 struct emac_priv *priv = netdev_priv(ndev);
1982 struct device_node *np = pdev->dev.of_node;
1984 dev_notice(&ndev->dev, "DaVinci EMAC: davinci_emac_remove()\n");
1987 cpdma_chan_destroy(priv->txchan);
1989 cpdma_chan_destroy(priv->rxchan);
1990 cpdma_ctlr_destroy(priv->dma);
1992 unregister_netdev(ndev);
1993 of_node_put(priv->phy_node);
1994 pm_runtime_disable(&pdev->dev);
1995 if (of_phy_is_fixed_link(np))
1996 of_phy_deregister_fixed_link(np);
2002 static int davinci_emac_suspend(struct device *dev)
2004 struct net_device *ndev = dev_get_drvdata(dev);
2006 if (netif_running(ndev))
2007 emac_dev_stop(ndev);
2012 static int davinci_emac_resume(struct device *dev)
2014 struct net_device *ndev = dev_get_drvdata(dev);
2016 if (netif_running(ndev))
2017 emac_dev_open(ndev);
2022 static const struct dev_pm_ops davinci_emac_pm_ops = {
2023 .suspend = davinci_emac_suspend,
2024 .resume = davinci_emac_resume,
2027 static const struct emac_platform_data am3517_emac_data = {
2028 .version = EMAC_VERSION_2,
2029 .hw_ram_addr = 0x01e20000,
2032 static const struct emac_platform_data dm816_emac_data = {
2033 .version = EMAC_VERSION_2,
2036 static const struct of_device_id davinci_emac_of_match[] = {
2037 {.compatible = "ti,davinci-dm6467-emac", },
2038 {.compatible = "ti,am3517-emac", .data = &am3517_emac_data, },
2039 {.compatible = "ti,dm816-emac", .data = &dm816_emac_data, },
2042 MODULE_DEVICE_TABLE(of, davinci_emac_of_match);
2044 /* davinci_emac_driver: EMAC platform driver structure */
2045 static struct platform_driver davinci_emac_driver = {
2047 .name = "davinci_emac",
2048 .pm = &davinci_emac_pm_ops,
2049 .of_match_table = davinci_emac_of_match,
2051 .probe = davinci_emac_probe,
2052 .remove = davinci_emac_remove,
2056 * davinci_emac_init - EMAC driver module init
2058 * Called when initializing the driver. We register the driver with
2061 static int __init davinci_emac_init(void)
2063 return platform_driver_register(&davinci_emac_driver);
2065 late_initcall(davinci_emac_init);
2068 * davinci_emac_exit - EMAC driver module exit
2070 * Called when exiting the driver completely. We unregister the driver with
2071 * the platform and exit
2073 static void __exit davinci_emac_exit(void)
2075 platform_driver_unregister(&davinci_emac_driver);
2077 module_exit(davinci_emac_exit);
2079 MODULE_LICENSE("GPL");
2080 MODULE_AUTHOR("DaVinci EMAC Maintainer: Anant Gole <anantgole@ti.com>");
2081 MODULE_AUTHOR("DaVinci EMAC Maintainer: Chaithrika U S <chaithrika@ti.com>");
2082 MODULE_DESCRIPTION("DaVinci EMAC Ethernet driver");