1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * DaVinci Ethernet Medium Access Controller
4 *
5 * DaVinci EMAC is based upon CPPI 3.0 TI DMA engine
6 *
7 * Copyright (C) 2009 Texas Instruments.
8 *
9 * ---------------------------------------------------------------------------
10 * History:
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,
15 * PHY layer usage
16 */
17
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>
24#include <linux/in.h>
25#include <linux/ioport.h>
26#include <linux/slab.h>
27#include <linux/mm.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>
45#include <linux/io.h>
46#include <linux/uaccess.h>
47#include <linux/pm_runtime.h>
48#include <linux/davinci_emac.h>
49#include <linux/of.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>
56
57#include <asm/irq.h>
58#include <asm/page.h>
59
60#include "cpsw.h"
61#include "davinci_cpdma.h"
62
63static int debug_level;
64module_param(debug_level, int, 0);
65MODULE_PARM_DESC(debug_level, "DaVinci EMAC debug level (NETIF_MSG bits)");
66
67/* Netif debug messages possible */
68#define DAVINCI_EMAC_DEBUG (NETIF_MSG_DRV | \
69 NETIF_MSG_PROBE | \
70 NETIF_MSG_LINK | \
71 NETIF_MSG_TIMER | \
72 NETIF_MSG_IFDOWN | \
73 NETIF_MSG_IFUP | \
74 NETIF_MSG_RX_ERR | \
75 NETIF_MSG_TX_ERR | \
76 NETIF_MSG_TX_QUEUED | \
77 NETIF_MSG_INTR | \
78 NETIF_MSG_TX_DONE | \
79 NETIF_MSG_RX_STATUS | \
80 NETIF_MSG_PKTDATA | \
81 NETIF_MSG_HW | \
82 NETIF_MSG_WOL)
83
84/* version info */
85#define EMAC_MAJOR_VERSION 6
86#define EMAC_MINOR_VERSION 1
87#define EMAC_MODULE_VERSION "6.1"
88MODULE_VERSION(EMAC_MODULE_VERSION);
89static const char emac_version_string[] = "TI DaVinci EMAC Linux v6.1";
90
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 */
104
105#define EMAC_DEF_TXPRIO_FIXED (1) /* TX Priority is fixed */
106#define EMAC_DEF_TXPACING_EN (0) /* TX pacing NOT supported*/
107
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
117/* Buffer descriptor parameters */
118#define EMAC_DEF_TX_MAX_SERVICE (32) /* TX max service BD's */
119#define EMAC_DEF_RX_MAX_SERVICE (64) /* should = netdev->weight */
120
121/* EMAC register related defines */
122#define EMAC_ALL_MULTI_REG_VALUE (0xFFFFFFFF)
123#define EMAC_NUM_MULTICAST_BITS (64)
124#define EMAC_TX_CONTROL_TX_ENABLE_VAL (0x1)
125#define EMAC_RX_CONTROL_RX_ENABLE_VAL (0x1)
126#define EMAC_MAC_HOST_ERR_INTMASK_VAL (0x2)
127#define EMAC_RX_UNICAST_CLEAR_ALL (0xFF)
128#define EMAC_INT_MASK_CLEAR (0xFF)
129
130/* RX MBP register bit positions */
131#define EMAC_RXMBP_PASSCRC_MASK BIT(30)
132#define EMAC_RXMBP_QOSEN_MASK BIT(29)
133#define EMAC_RXMBP_NOCHAIN_MASK BIT(28)
134#define EMAC_RXMBP_CMFEN_MASK BIT(24)
135#define EMAC_RXMBP_CSFEN_MASK BIT(23)
136#define EMAC_RXMBP_CEFEN_MASK BIT(22)
137#define EMAC_RXMBP_CAFEN_MASK BIT(21)
138#define EMAC_RXMBP_PROMCH_SHIFT (16)
139#define EMAC_RXMBP_PROMCH_MASK (0x7 << 16)
140#define EMAC_RXMBP_BROADEN_MASK BIT(13)
141#define EMAC_RXMBP_BROADCH_SHIFT (8)
142#define EMAC_RXMBP_BROADCH_MASK (0x7 << 8)
143#define EMAC_RXMBP_MULTIEN_MASK BIT(5)
144#define EMAC_RXMBP_MULTICH_SHIFT (0)
145#define EMAC_RXMBP_MULTICH_MASK (0x7)
146#define EMAC_RXMBP_CHMASK (0x7)
147
148/* EMAC register definitions/bit maps used */
149# define EMAC_MBP_RXPROMISC (0x00200000)
150# define EMAC_MBP_PROMISCCH(ch) (((ch) & 0x7) << 16)
151# define EMAC_MBP_RXBCAST (0x00002000)
152# define EMAC_MBP_BCASTCHAN(ch) (((ch) & 0x7) << 8)
153# define EMAC_MBP_RXMCAST (0x00000020)
154# define EMAC_MBP_MCASTCHAN(ch) ((ch) & 0x7)
155
156/* EMAC mac_control register */
157#define EMAC_MACCONTROL_TXPTYPE BIT(9)
158#define EMAC_MACCONTROL_TXPACEEN BIT(6)
159#define EMAC_MACCONTROL_GMIIEN BIT(5)
160#define EMAC_MACCONTROL_GIGABITEN BIT(7)
161#define EMAC_MACCONTROL_FULLDUPLEXEN BIT(0)
162#define EMAC_MACCONTROL_RMIISPEED_MASK BIT(15)
163
164/* GIGABIT MODE related bits */
165#define EMAC_DM646X_MACCONTORL_GIG BIT(7)
166#define EMAC_DM646X_MACCONTORL_GIGFORCE BIT(17)
167
168/* EMAC mac_status register */
169#define EMAC_MACSTATUS_TXERRCODE_MASK (0xF00000)
170#define EMAC_MACSTATUS_TXERRCODE_SHIFT (20)
171#define EMAC_MACSTATUS_TXERRCH_MASK (0x70000)
172#define EMAC_MACSTATUS_TXERRCH_SHIFT (16)
173#define EMAC_MACSTATUS_RXERRCODE_MASK (0xF000)
174#define EMAC_MACSTATUS_RXERRCODE_SHIFT (12)
175#define EMAC_MACSTATUS_RXERRCH_MASK (0x700)
176#define EMAC_MACSTATUS_RXERRCH_SHIFT (8)
177
178/* EMAC RX register masks */
179#define EMAC_RX_MAX_LEN_MASK (0xFFFF)
180#define EMAC_RX_BUFFER_OFFSET_MASK (0xFFFF)
181
182/* MAC_IN_VECTOR (0x180) register bit fields */
183#define EMAC_DM644X_MAC_IN_VECTOR_HOST_INT BIT(17)
184#define EMAC_DM644X_MAC_IN_VECTOR_STATPEND_INT BIT(16)
185#define EMAC_DM644X_MAC_IN_VECTOR_RX_INT_VEC BIT(8)
186#define EMAC_DM644X_MAC_IN_VECTOR_TX_INT_VEC BIT(0)
187
188/** NOTE:: For DM646x the IN_VECTOR has changed */
189#define EMAC_DM646X_MAC_IN_VECTOR_RX_INT_VEC BIT(EMAC_DEF_RX_CH)
190#define EMAC_DM646X_MAC_IN_VECTOR_TX_INT_VEC BIT(16 + EMAC_DEF_TX_CH)
191#define EMAC_DM646X_MAC_IN_VECTOR_HOST_INT BIT(26)
192#define EMAC_DM646X_MAC_IN_VECTOR_STATPEND_INT BIT(27)
193
194/* CPPI bit positions */
195#define EMAC_CPPI_SOP_BIT BIT(31)
196#define EMAC_CPPI_EOP_BIT BIT(30)
197#define EMAC_CPPI_OWNERSHIP_BIT BIT(29)
198#define EMAC_CPPI_EOQ_BIT BIT(28)
199#define EMAC_CPPI_TEARDOWN_COMPLETE_BIT BIT(27)
200#define EMAC_CPPI_PASS_CRC_BIT BIT(26)
201#define EMAC_RX_BD_BUF_SIZE (0xFFFF)
202#define EMAC_BD_LENGTH_FOR_CACHE (16) /* only CPPI bytes */
203#define EMAC_RX_BD_PKT_LENGTH_MASK (0xFFFF)
204
205/* Max hardware defines */
206#define EMAC_MAX_TXRX_CHANNELS (8) /* Max hardware channels */
207#define EMAC_DEF_MAX_MULTICAST_ADDRESSES (64) /* Max mcast addr's */
208
209/* EMAC Peripheral Device Register Memory Layout structure */
210#define EMAC_MACINVECTOR 0x90
211
212#define EMAC_DM646X_MACEOIVECTOR 0x94
213
214#define EMAC_MACINTSTATRAW 0xB0
215#define EMAC_MACINTSTATMASKED 0xB4
216#define EMAC_MACINTMASKSET 0xB8
217#define EMAC_MACINTMASKCLEAR 0xBC
218
219#define EMAC_RXMBPENABLE 0x100
220#define EMAC_RXUNICASTSET 0x104
221#define EMAC_RXUNICASTCLEAR 0x108
222#define EMAC_RXMAXLEN 0x10C
223#define EMAC_RXBUFFEROFFSET 0x110
224#define EMAC_RXFILTERLOWTHRESH 0x114
225
226#define EMAC_MACCONTROL 0x160
227#define EMAC_MACSTATUS 0x164
228#define EMAC_EMCONTROL 0x168
229#define EMAC_FIFOCONTROL 0x16C
230#define EMAC_MACCONFIG 0x170
231#define EMAC_SOFTRESET 0x174
232#define EMAC_MACSRCADDRLO 0x1D0
233#define EMAC_MACSRCADDRHI 0x1D4
234#define EMAC_MACHASH1 0x1D8
235#define EMAC_MACHASH2 0x1DC
236#define EMAC_MACADDRLO 0x500
237#define EMAC_MACADDRHI 0x504
238#define EMAC_MACINDEX 0x508
239
240/* EMAC statistics registers */
241#define EMAC_RXGOODFRAMES 0x200
242#define EMAC_RXBCASTFRAMES 0x204
243#define EMAC_RXMCASTFRAMES 0x208
244#define EMAC_RXPAUSEFRAMES 0x20C
245#define EMAC_RXCRCERRORS 0x210
246#define EMAC_RXALIGNCODEERRORS 0x214
247#define EMAC_RXOVERSIZED 0x218
248#define EMAC_RXJABBER 0x21C
249#define EMAC_RXUNDERSIZED 0x220
250#define EMAC_RXFRAGMENTS 0x224
251#define EMAC_RXFILTERED 0x228
252#define EMAC_RXQOSFILTERED 0x22C
253#define EMAC_RXOCTETS 0x230
254#define EMAC_TXGOODFRAMES 0x234
255#define EMAC_TXBCASTFRAMES 0x238
256#define EMAC_TXMCASTFRAMES 0x23C
257#define EMAC_TXPAUSEFRAMES 0x240
258#define EMAC_TXDEFERRED 0x244
259#define EMAC_TXCOLLISION 0x248
260#define EMAC_TXSINGLECOLL 0x24C
261#define EMAC_TXMULTICOLL 0x250
262#define EMAC_TXEXCESSIVECOLL 0x254
263#define EMAC_TXLATECOLL 0x258
264#define EMAC_TXUNDERRUN 0x25C
265#define EMAC_TXCARRIERSENSE 0x260
266#define EMAC_TXOCTETS 0x264
267#define EMAC_NETOCTETS 0x280
268#define EMAC_RXSOFOVERRUNS 0x284
269#define EMAC_RXMOFOVERRUNS 0x288
270#define EMAC_RXDMAOVERRUNS 0x28C
271
272/* EMAC DM644x control registers */
273#define EMAC_CTRL_EWCTL (0x4)
274#define EMAC_CTRL_EWINTTCNT (0x8)
275
276/* EMAC DM644x control module masks */
277#define EMAC_DM644X_EWINTCNT_MASK 0x1FFFF
278#define EMAC_DM644X_INTMIN_INTVL 0x1
279#define EMAC_DM644X_INTMAX_INTVL (EMAC_DM644X_EWINTCNT_MASK)
280
281/* EMAC DM646X control module registers */
282#define EMAC_DM646X_CMINTCTRL 0x0C
283#define EMAC_DM646X_CMRXINTEN 0x14
284#define EMAC_DM646X_CMTXINTEN 0x18
285#define EMAC_DM646X_CMRXINTMAX 0x70
286#define EMAC_DM646X_CMTXINTMAX 0x74
287
288/* EMAC DM646X control module masks */
289#define EMAC_DM646X_INTPACEEN (0x3 << 16)
290#define EMAC_DM646X_INTPRESCALE_MASK (0x7FF << 0)
291#define EMAC_DM646X_CMINTMAX_CNT 63
292#define EMAC_DM646X_CMINTMIN_CNT 2
293#define EMAC_DM646X_CMINTMAX_INTVL (1000 / EMAC_DM646X_CMINTMIN_CNT)
294#define EMAC_DM646X_CMINTMIN_INTVL ((1000 / EMAC_DM646X_CMINTMAX_CNT) + 1)
295
296
297/* EMAC EOI codes for C0 */
298#define EMAC_DM646X_MAC_EOI_C0_RXEN (0x01)
299#define EMAC_DM646X_MAC_EOI_C0_TXEN (0x02)
300
301/* EMAC Stats Clear Mask */
302#define EMAC_STATS_CLR_MASK (0xFFFFFFFF)
303
304/* emac_priv: EMAC private data structure
305 *
306 * EMAC adapter private data structure
307 */
308struct emac_priv {
309 u32 msg_enable;
310 struct net_device *ndev;
311 struct platform_device *pdev;
312 struct napi_struct napi;
313 char mac_addr[6];
314 void __iomem *remap_addr;
315 u32 emac_base_phys;
316 void __iomem *emac_base;
317 void __iomem *ctrl_base;
318 struct cpdma_ctlr *dma;
319 struct cpdma_chan *txchan;
320 struct cpdma_chan *rxchan;
321 u32 link; /* 1=link on, 0=link off */
322 u32 speed; /* 0=Auto Neg, 1=No PHY, 10,100, 1000 - mbps */
323 u32 duplex; /* Link duplex: 0=Half, 1=Full */
324 u32 rx_buf_size;
325 u32 isr_count;
326 u32 coal_intvl;
327 u32 bus_freq_mhz;
328 u8 rmii_en;
329 u8 version;
330 u32 mac_hash1;
331 u32 mac_hash2;
332 u32 multicast_hash_cnt[EMAC_NUM_MULTICAST_BITS];
333 u32 rx_addr_type;
334 const char *phy_id;
335 struct device_node *phy_node;
336 spinlock_t lock;
337 /*platform specific members*/
338 void (*int_enable) (void);
339 void (*int_disable) (void);
340};
341
342/* EMAC TX Host Error description strings */
343static char *emac_txhost_errcodes[16] = {
344 "No error", "SOP error", "Ownership bit not set in SOP buffer",
345 "Zero Next Buffer Descriptor Pointer Without EOP",
346 "Zero Buffer Pointer", "Zero Buffer Length", "Packet Length Error",
347 "Reserved", "Reserved", "Reserved", "Reserved", "Reserved",
348 "Reserved", "Reserved", "Reserved", "Reserved"
349};
350
351/* EMAC RX Host Error description strings */
352static char *emac_rxhost_errcodes[16] = {
353 "No error", "Reserved", "Ownership bit not set in input buffer",
354 "Reserved", "Zero Buffer Pointer", "Reserved", "Reserved",
355 "Reserved", "Reserved", "Reserved", "Reserved", "Reserved",
356 "Reserved", "Reserved", "Reserved", "Reserved"
357};
358
359/* Helper macros */
360#define emac_read(reg) ioread32(priv->emac_base + (reg))
361#define emac_write(reg, val) iowrite32(val, priv->emac_base + (reg))
362
363#define emac_ctrl_read(reg) ioread32((priv->ctrl_base + (reg)))
364#define emac_ctrl_write(reg, val) iowrite32(val, (priv->ctrl_base + (reg)))
365
366/**
367 * emac_get_drvinfo - Get EMAC driver information
368 * @ndev: The DaVinci EMAC network adapter
369 * @info: ethtool info structure containing name and version
370 *
371 * Returns EMAC driver information (name and version)
372 *
373 */
374static void emac_get_drvinfo(struct net_device *ndev,
375 struct ethtool_drvinfo *info)
376{
377 strlcpy(info->driver, emac_version_string, sizeof(info->driver));
378 strlcpy(info->version, EMAC_MODULE_VERSION, sizeof(info->version));
379}
380
381/**
382 * emac_get_coalesce - Get interrupt coalesce settings for this device
383 * @ndev : The DaVinci EMAC network adapter
384 * @coal : ethtool coalesce settings structure
385 * @kernel_coal: ethtool CQE mode setting structure
386 * @extack: extack for reporting error messages
387 *
388 * Fetch the current interrupt coalesce settings
389 *
390 */
391static int emac_get_coalesce(struct net_device *ndev,
392 struct ethtool_coalesce *coal,
393 struct kernel_ethtool_coalesce *kernel_coal,
394 struct netlink_ext_ack *extack)
395{
396 struct emac_priv *priv = netdev_priv(ndev);
397
398 coal->rx_coalesce_usecs = priv->coal_intvl;
399 return 0;
400
401}
402
403/**
404 * emac_set_coalesce - Set interrupt coalesce settings for this device
405 * @ndev : The DaVinci EMAC network adapter
406 * @coal : ethtool coalesce settings structure
407 * @kernel_coal: ethtool CQE mode setting structure
408 * @extack: extack for reporting error messages
409 *
410 * Set interrupt coalesce parameters
411 *
412 */
413static int emac_set_coalesce(struct net_device *ndev,
414 struct ethtool_coalesce *coal,
415 struct kernel_ethtool_coalesce *kernel_coal,
416 struct netlink_ext_ack *extack)
417{
418 struct emac_priv *priv = netdev_priv(ndev);
419 u32 int_ctrl, num_interrupts = 0;
420 u32 prescale = 0, addnl_dvdr = 1, coal_intvl = 0;
421
422 if (!coal->rx_coalesce_usecs) {
423 priv->coal_intvl = 0;
424
425 switch (priv->version) {
426 case EMAC_VERSION_2:
427 emac_ctrl_write(EMAC_DM646X_CMINTCTRL, 0);
428 break;
429 default:
430 emac_ctrl_write(EMAC_CTRL_EWINTTCNT, 0);
431 break;
432 }
433
434 return 0;
435 }
436
437 coal_intvl = coal->rx_coalesce_usecs;
438
439 switch (priv->version) {
440 case EMAC_VERSION_2:
441 int_ctrl = emac_ctrl_read(EMAC_DM646X_CMINTCTRL);
442 prescale = priv->bus_freq_mhz * 4;
443
444 if (coal_intvl < EMAC_DM646X_CMINTMIN_INTVL)
445 coal_intvl = EMAC_DM646X_CMINTMIN_INTVL;
446
447 if (coal_intvl > EMAC_DM646X_CMINTMAX_INTVL) {
448 /*
449 * Interrupt pacer works with 4us Pulse, we can
450 * throttle further by dilating the 4us pulse.
451 */
452 addnl_dvdr = EMAC_DM646X_INTPRESCALE_MASK / prescale;
453
454 if (addnl_dvdr > 1) {
455 prescale *= addnl_dvdr;
456 if (coal_intvl > (EMAC_DM646X_CMINTMAX_INTVL
457 * addnl_dvdr))
458 coal_intvl = (EMAC_DM646X_CMINTMAX_INTVL
459 * addnl_dvdr);
460 } else {
461 addnl_dvdr = 1;
462 coal_intvl = EMAC_DM646X_CMINTMAX_INTVL;
463 }
464 }
465
466 num_interrupts = (1000 * addnl_dvdr) / coal_intvl;
467
468 int_ctrl |= EMAC_DM646X_INTPACEEN;
469 int_ctrl &= (~EMAC_DM646X_INTPRESCALE_MASK);
470 int_ctrl |= (prescale & EMAC_DM646X_INTPRESCALE_MASK);
471 emac_ctrl_write(EMAC_DM646X_CMINTCTRL, int_ctrl);
472
473 emac_ctrl_write(EMAC_DM646X_CMRXINTMAX, num_interrupts);
474 emac_ctrl_write(EMAC_DM646X_CMTXINTMAX, num_interrupts);
475
476 break;
477 default:
478 int_ctrl = emac_ctrl_read(EMAC_CTRL_EWINTTCNT);
479 int_ctrl &= (~EMAC_DM644X_EWINTCNT_MASK);
480 prescale = coal_intvl * priv->bus_freq_mhz;
481 if (prescale > EMAC_DM644X_EWINTCNT_MASK) {
482 prescale = EMAC_DM644X_EWINTCNT_MASK;
483 coal_intvl = prescale / priv->bus_freq_mhz;
484 }
485 emac_ctrl_write(EMAC_CTRL_EWINTTCNT, (int_ctrl | prescale));
486
487 break;
488 }
489
490 printk(KERN_INFO"Set coalesce to %d usecs.\n", coal_intvl);
491 priv->coal_intvl = coal_intvl;
492
493 return 0;
494
495}
496
497
498/* ethtool_ops: DaVinci EMAC Ethtool structure
499 *
500 * Ethtool support for EMAC adapter
501 */
502static const struct ethtool_ops ethtool_ops = {
503 .supported_coalesce_params = ETHTOOL_COALESCE_RX_USECS,
504 .get_drvinfo = emac_get_drvinfo,
505 .get_link = ethtool_op_get_link,
506 .get_coalesce = emac_get_coalesce,
507 .set_coalesce = emac_set_coalesce,
508 .get_ts_info = ethtool_op_get_ts_info,
509 .get_link_ksettings = phy_ethtool_get_link_ksettings,
510 .set_link_ksettings = phy_ethtool_set_link_ksettings,
511};
512
513/**
514 * emac_update_phystatus - Update Phy status
515 * @priv: The DaVinci EMAC private adapter structure
516 *
517 * Updates phy status and takes action for network queue if required
518 * based upon link status
519 *
520 */
521static void emac_update_phystatus(struct emac_priv *priv)
522{
523 u32 mac_control;
524 u32 new_duplex;
525 u32 cur_duplex;
526 struct net_device *ndev = priv->ndev;
527
528 mac_control = emac_read(EMAC_MACCONTROL);
529 cur_duplex = (mac_control & EMAC_MACCONTROL_FULLDUPLEXEN) ?
530 DUPLEX_FULL : DUPLEX_HALF;
531 if (ndev->phydev)
532 new_duplex = ndev->phydev->duplex;
533 else
534 new_duplex = DUPLEX_FULL;
535
536 /* We get called only if link has changed (speed/duplex/status) */
537 if ((priv->link) && (new_duplex != cur_duplex)) {
538 priv->duplex = new_duplex;
539 if (DUPLEX_FULL == priv->duplex)
540 mac_control |= (EMAC_MACCONTROL_FULLDUPLEXEN);
541 else
542 mac_control &= ~(EMAC_MACCONTROL_FULLDUPLEXEN);
543 }
544
545 if (priv->speed == SPEED_1000 && (priv->version == EMAC_VERSION_2)) {
546 mac_control = emac_read(EMAC_MACCONTROL);
547 mac_control |= (EMAC_DM646X_MACCONTORL_GIG |
548 EMAC_DM646X_MACCONTORL_GIGFORCE);
549 } else {
550 /* Clear the GIG bit and GIGFORCE bit */
551 mac_control &= ~(EMAC_DM646X_MACCONTORL_GIGFORCE |
552 EMAC_DM646X_MACCONTORL_GIG);
553
554 if (priv->rmii_en && (priv->speed == SPEED_100))
555 mac_control |= EMAC_MACCONTROL_RMIISPEED_MASK;
556 else
557 mac_control &= ~EMAC_MACCONTROL_RMIISPEED_MASK;
558 }
559
560 /* Update mac_control if changed */
561 emac_write(EMAC_MACCONTROL, mac_control);
562
563 if (priv->link) {
564 /* link ON */
565 if (!netif_carrier_ok(ndev))
566 netif_carrier_on(ndev);
567 /* reactivate the transmit queue if it is stopped */
568 if (netif_running(ndev) && netif_queue_stopped(ndev))
569 netif_wake_queue(ndev);
570 } else {
571 /* link OFF */
572 if (netif_carrier_ok(ndev))
573 netif_carrier_off(ndev);
574 if (!netif_queue_stopped(ndev))
575 netif_stop_queue(ndev);
576 }
577}
578
579/**
580 * hash_get - Calculate hash value from mac address
581 * @addr: mac address to delete from hash table
582 *
583 * Calculates hash value from mac address
584 *
585 */
586static u32 hash_get(u8 *addr)
587{
588 u32 hash;
589 u8 tmpval;
590 int cnt;
591 hash = 0;
592
593 for (cnt = 0; cnt < 2; cnt++) {
594 tmpval = *addr++;
595 hash ^= (tmpval >> 2) ^ (tmpval << 4);
596 tmpval = *addr++;
597 hash ^= (tmpval >> 4) ^ (tmpval << 2);
598 tmpval = *addr++;
599 hash ^= (tmpval >> 6) ^ (tmpval);
600 }
601
602 return hash & 0x3F;
603}
604
605/**
606 * emac_hash_add - Hash function to add mac addr from hash table
607 * @priv: The DaVinci EMAC private adapter structure
608 * @mac_addr: mac address to delete from hash table
609 *
610 * Adds mac address to the internal hash table
611 *
612 */
613static int emac_hash_add(struct emac_priv *priv, u8 *mac_addr)
614{
615 struct device *emac_dev = &priv->ndev->dev;
616 u32 rc = 0;
617 u32 hash_bit;
618 u32 hash_value = hash_get(mac_addr);
619
620 if (hash_value >= EMAC_NUM_MULTICAST_BITS) {
621 if (netif_msg_drv(priv)) {
622 dev_err(emac_dev, "DaVinci EMAC: emac_hash_add(): Invalid "\
623 "Hash %08x, should not be greater than %08x",
624 hash_value, (EMAC_NUM_MULTICAST_BITS - 1));
625 }
626 return -1;
627 }
628
629 /* set the hash bit only if not previously set */
630 if (priv->multicast_hash_cnt[hash_value] == 0) {
631 rc = 1; /* hash value changed */
632 if (hash_value < 32) {
633 hash_bit = BIT(hash_value);
634 priv->mac_hash1 |= hash_bit;
635 } else {
636 hash_bit = BIT((hash_value - 32));
637 priv->mac_hash2 |= hash_bit;
638 }
639 }
640
641 /* incr counter for num of mcast addr's mapped to "this" hash bit */
642 ++priv->multicast_hash_cnt[hash_value];
643
644 return rc;
645}
646
647/**
648 * emac_hash_del - Hash function to delete mac addr from hash table
649 * @priv: The DaVinci EMAC private adapter structure
650 * @mac_addr: mac address to delete from hash table
651 *
652 * Removes mac address from the internal hash table
653 *
654 */
655static int emac_hash_del(struct emac_priv *priv, u8 *mac_addr)
656{
657 u32 hash_value;
658 u32 hash_bit;
659
660 hash_value = hash_get(mac_addr);
661 if (priv->multicast_hash_cnt[hash_value] > 0) {
662 /* dec cntr for num of mcast addr's mapped to this hash bit */
663 --priv->multicast_hash_cnt[hash_value];
664 }
665
666 /* if counter still > 0, at least one multicast address refers
667 * to this hash bit. so return 0 */
668 if (priv->multicast_hash_cnt[hash_value] > 0)
669 return 0;
670
671 if (hash_value < 32) {
672 hash_bit = BIT(hash_value);
673 priv->mac_hash1 &= ~hash_bit;
674 } else {
675 hash_bit = BIT((hash_value - 32));
676 priv->mac_hash2 &= ~hash_bit;
677 }
678
679 /* return 1 to indicate change in mac_hash registers reqd */
680 return 1;
681}
682
683/* EMAC multicast operation */
684#define EMAC_MULTICAST_ADD 0
685#define EMAC_MULTICAST_DEL 1
686#define EMAC_ALL_MULTI_SET 2
687#define EMAC_ALL_MULTI_CLR 3
688
689/**
690 * emac_add_mcast - Set multicast address in the EMAC adapter (Internal)
691 * @priv: The DaVinci EMAC private adapter structure
692 * @action: multicast operation to perform
693 * @mac_addr: mac address to set
694 *
695 * Set multicast addresses in EMAC adapter - internal function
696 *
697 */
698static void emac_add_mcast(struct emac_priv *priv, u32 action, u8 *mac_addr)
699{
700 struct device *emac_dev = &priv->ndev->dev;
701 int update = -1;
702
703 switch (action) {
704 case EMAC_MULTICAST_ADD:
705 update = emac_hash_add(priv, mac_addr);
706 break;
707 case EMAC_MULTICAST_DEL:
708 update = emac_hash_del(priv, mac_addr);
709 break;
710 case EMAC_ALL_MULTI_SET:
711 update = 1;
712 priv->mac_hash1 = EMAC_ALL_MULTI_REG_VALUE;
713 priv->mac_hash2 = EMAC_ALL_MULTI_REG_VALUE;
714 break;
715 case EMAC_ALL_MULTI_CLR:
716 update = 1;
717 priv->mac_hash1 = 0;
718 priv->mac_hash2 = 0;
719 memset(&(priv->multicast_hash_cnt[0]), 0,
720 sizeof(priv->multicast_hash_cnt[0]) *
721 EMAC_NUM_MULTICAST_BITS);
722 break;
723 default:
724 if (netif_msg_drv(priv))
725 dev_err(emac_dev, "DaVinci EMAC: add_mcast"\
726 ": bad operation %d", action);
727 break;
728 }
729
730 /* write to the hardware only if the register status chances */
731 if (update > 0) {
732 emac_write(EMAC_MACHASH1, priv->mac_hash1);
733 emac_write(EMAC_MACHASH2, priv->mac_hash2);
734 }
735}
736
737/**
738 * emac_dev_mcast_set - Set multicast address in the EMAC adapter
739 * @ndev: The DaVinci EMAC network adapter
740 *
741 * Set multicast addresses in EMAC adapter
742 *
743 */
744static void emac_dev_mcast_set(struct net_device *ndev)
745{
746 u32 mbp_enable;
747 struct emac_priv *priv = netdev_priv(ndev);
748
749 mbp_enable = emac_read(EMAC_RXMBPENABLE);
750 if (ndev->flags & IFF_PROMISC) {
751 mbp_enable &= (~EMAC_MBP_PROMISCCH(EMAC_DEF_PROM_CH));
752 mbp_enable |= (EMAC_MBP_RXPROMISC);
753 } else {
754 mbp_enable = (mbp_enable & ~EMAC_MBP_RXPROMISC);
755 if ((ndev->flags & IFF_ALLMULTI) ||
756 netdev_mc_count(ndev) > EMAC_DEF_MAX_MULTICAST_ADDRESSES) {
757 mbp_enable = (mbp_enable | EMAC_MBP_RXMCAST);
758 emac_add_mcast(priv, EMAC_ALL_MULTI_SET, NULL);
759 } else if (!netdev_mc_empty(ndev)) {
760 struct netdev_hw_addr *ha;
761
762 mbp_enable = (mbp_enable | EMAC_MBP_RXMCAST);
763 emac_add_mcast(priv, EMAC_ALL_MULTI_CLR, NULL);
764 /* program multicast address list into EMAC hardware */
765 netdev_for_each_mc_addr(ha, ndev) {
766 emac_add_mcast(priv, EMAC_MULTICAST_ADD,
767 (u8 *) ha->addr);
768 }
769 } else {
770 mbp_enable = (mbp_enable & ~EMAC_MBP_RXMCAST);
771 emac_add_mcast(priv, EMAC_ALL_MULTI_CLR, NULL);
772 }
773 }
774 /* Set mbp config register */
775 emac_write(EMAC_RXMBPENABLE, mbp_enable);
776}
777
778/*************************************************************************
779 * EMAC Hardware manipulation
780 *************************************************************************/
781
782/**
783 * emac_int_disable - Disable EMAC module interrupt (from adapter)
784 * @priv: The DaVinci EMAC private adapter structure
785 *
786 * Disable EMAC interrupt on the adapter
787 *
788 */
789static void emac_int_disable(struct emac_priv *priv)
790{
791 if (priv->version == EMAC_VERSION_2) {
792 unsigned long flags;
793
794 local_irq_save(flags);
795
796 /* Program C0_Int_En to zero to turn off
797 * interrupts to the CPU */
798 emac_ctrl_write(EMAC_DM646X_CMRXINTEN, 0x0);
799 emac_ctrl_write(EMAC_DM646X_CMTXINTEN, 0x0);
800 /* NOTE: Rx Threshold and Misc interrupts are not disabled */
801 if (priv->int_disable)
802 priv->int_disable();
803
804 /* NOTE: Rx Threshold and Misc interrupts are not enabled */
805
806 /* ack rxen only then a new pulse will be generated */
807 emac_write(EMAC_DM646X_MACEOIVECTOR,
808 EMAC_DM646X_MAC_EOI_C0_RXEN);
809
810 /* ack txen- only then a new pulse will be generated */
811 emac_write(EMAC_DM646X_MACEOIVECTOR,
812 EMAC_DM646X_MAC_EOI_C0_TXEN);
813
814 local_irq_restore(flags);
815
816 } else {
817 /* Set DM644x control registers for interrupt control */
818 emac_ctrl_write(EMAC_CTRL_EWCTL, 0x0);
819 }
820}
821
822/**
823 * emac_int_enable - Enable EMAC module interrupt (from adapter)
824 * @priv: The DaVinci EMAC private adapter structure
825 *
826 * Enable EMAC interrupt on the adapter
827 *
828 */
829static void emac_int_enable(struct emac_priv *priv)
830{
831 if (priv->version == EMAC_VERSION_2) {
832 if (priv->int_enable)
833 priv->int_enable();
834
835 emac_ctrl_write(EMAC_DM646X_CMRXINTEN, 0xff);
836 emac_ctrl_write(EMAC_DM646X_CMTXINTEN, 0xff);
837
838 /* In addition to turning on interrupt Enable, we need
839 * ack by writing appropriate values to the EOI
840 * register */
841
842 /* NOTE: Rx Threshold and Misc interrupts are not enabled */
843 } else {
844 /* Set DM644x control registers for interrupt control */
845 emac_ctrl_write(EMAC_CTRL_EWCTL, 0x1);
846 }
847}
848
849/**
850 * emac_irq - EMAC interrupt handler
851 * @irq: interrupt number
852 * @dev_id: EMAC network adapter data structure ptr
853 *
854 * EMAC Interrupt handler - we only schedule NAPI and not process any packets
855 * here. EVen the interrupt status is checked (TX/RX/Err) in NAPI poll function
856 *
857 * Returns interrupt handled condition
858 */
859static irqreturn_t emac_irq(int irq, void *dev_id)
860{
861 struct net_device *ndev = (struct net_device *)dev_id;
862 struct emac_priv *priv = netdev_priv(ndev);
863
864 ++priv->isr_count;
865 if (likely(netif_running(priv->ndev))) {
866 emac_int_disable(priv);
867 napi_schedule(&priv->napi);
868 } else {
869 /* we are closing down, so dont process anything */
870 }
871 return IRQ_HANDLED;
872}
873
874static struct sk_buff *emac_rx_alloc(struct emac_priv *priv)
875{
876 struct sk_buff *skb = netdev_alloc_skb(priv->ndev, priv->rx_buf_size);
877 if (WARN_ON(!skb))
878 return NULL;
879 skb_reserve(skb, NET_IP_ALIGN);
880 return skb;
881}
882
883static void emac_rx_handler(void *token, int len, int status)
884{
885 struct sk_buff *skb = token;
886 struct net_device *ndev = skb->dev;
887 struct emac_priv *priv = netdev_priv(ndev);
888 struct device *emac_dev = &ndev->dev;
889 int ret;
890
891 /* free and bail if we are shutting down */
892 if (unlikely(!netif_running(ndev))) {
893 dev_kfree_skb_any(skb);
894 return;
895 }
896
897 /* recycle on receive error */
898 if (status < 0) {
899 ndev->stats.rx_errors++;
900 goto recycle;
901 }
902
903 /* feed received packet up the stack */
904 skb_put(skb, len);
905 skb->protocol = eth_type_trans(skb, ndev);
906 netif_receive_skb(skb);
907 ndev->stats.rx_bytes += len;
908 ndev->stats.rx_packets++;
909
910 /* alloc a new packet for receive */
911 skb = emac_rx_alloc(priv);
912 if (!skb) {
913 if (netif_msg_rx_err(priv) && net_ratelimit())
914 dev_err(emac_dev, "failed rx buffer alloc\n");
915 return;
916 }
917
918recycle:
919 ret = cpdma_chan_submit(priv->rxchan, skb, skb->data,
920 skb_tailroom(skb), 0);
921
922 WARN_ON(ret == -ENOMEM);
923 if (unlikely(ret < 0))
924 dev_kfree_skb_any(skb);
925}
926
927static void emac_tx_handler(void *token, int len, int status)
928{
929 struct sk_buff *skb = token;
930 struct net_device *ndev = skb->dev;
931
932 /* Check whether the queue is stopped due to stalled tx dma, if the
933 * queue is stopped then start the queue as we have free desc for tx
934 */
935 if (unlikely(netif_queue_stopped(ndev)))
936 netif_wake_queue(ndev);
937 ndev->stats.tx_packets++;
938 ndev->stats.tx_bytes += len;
939 dev_kfree_skb_any(skb);
940}
941
942/**
943 * emac_dev_xmit - EMAC Transmit function
944 * @skb: SKB pointer
945 * @ndev: The DaVinci EMAC network adapter
946 *
947 * Called by the system to transmit a packet - we queue the packet in
948 * EMAC hardware transmit queue
949 *
950 * Returns success(NETDEV_TX_OK) or error code (typically out of desc's)
951 */
952static int emac_dev_xmit(struct sk_buff *skb, struct net_device *ndev)
953{
954 struct device *emac_dev = &ndev->dev;
955 int ret_code;
956 struct emac_priv *priv = netdev_priv(ndev);
957
958 /* If no link, return */
959 if (unlikely(!priv->link)) {
960 if (netif_msg_tx_err(priv) && net_ratelimit())
961 dev_err(emac_dev, "DaVinci EMAC: No link to transmit");
962 goto fail_tx;
963 }
964
965 ret_code = skb_put_padto(skb, EMAC_DEF_MIN_ETHPKTSIZE);
966 if (unlikely(ret_code < 0)) {
967 if (netif_msg_tx_err(priv) && net_ratelimit())
968 dev_err(emac_dev, "DaVinci EMAC: packet pad failed");
969 goto fail_tx;
970 }
971
972 skb_tx_timestamp(skb);
973
974 ret_code = cpdma_chan_submit(priv->txchan, skb, skb->data, skb->len,
975 0);
976 if (unlikely(ret_code != 0)) {
977 if (netif_msg_tx_err(priv) && net_ratelimit())
978 dev_err(emac_dev, "DaVinci EMAC: desc submit failed");
979 goto fail_tx;
980 }
981
982 /* If there is no more tx desc left free then we need to
983 * tell the kernel to stop sending us tx frames.
984 */
985 if (unlikely(!cpdma_check_free_tx_desc(priv->txchan)))
986 netif_stop_queue(ndev);
987
988 return NETDEV_TX_OK;
989
990fail_tx:
991 ndev->stats.tx_dropped++;
992 netif_stop_queue(ndev);
993 return NETDEV_TX_BUSY;
994}
995
996/**
997 * emac_dev_tx_timeout - EMAC Transmit timeout function
998 * @ndev: The DaVinci EMAC network adapter
999 * @txqueue: the index of the hung transmit queue
1000 *
1001 * Called when system detects that a skb timeout period has expired
1002 * potentially due to a fault in the adapter in not being able to send
1003 * it out on the wire. We teardown the TX channel assuming a hardware
1004 * error and re-initialize the TX channel for hardware operation
1005 *
1006 */
1007static void emac_dev_tx_timeout(struct net_device *ndev, unsigned int txqueue)
1008{
1009 struct emac_priv *priv = netdev_priv(ndev);
1010 struct device *emac_dev = &ndev->dev;
1011
1012 if (netif_msg_tx_err(priv))
1013 dev_err(emac_dev, "DaVinci EMAC: xmit timeout, restarting TX");
1014
1015 ndev->stats.tx_errors++;
1016 emac_int_disable(priv);
1017 cpdma_chan_stop(priv->txchan);
1018 cpdma_chan_start(priv->txchan);
1019 emac_int_enable(priv);
1020}
1021
1022/**
1023 * emac_set_type0addr - Set EMAC Type0 mac address
1024 * @priv: The DaVinci EMAC private adapter structure
1025 * @ch: RX channel number
1026 * @mac_addr: MAC address to set in device
1027 *
1028 * Called internally to set Type0 mac address of the adapter (Device)
1029 *
1030 * Returns success (0) or appropriate error code (none as of now)
1031 */
1032static void emac_set_type0addr(struct emac_priv *priv, u32 ch, char *mac_addr)
1033{
1034 u32 val;
1035 val = ((mac_addr[5] << 8) | (mac_addr[4]));
1036 emac_write(EMAC_MACSRCADDRLO, val);
1037
1038 val = ((mac_addr[3] << 24) | (mac_addr[2] << 16) | \
1039 (mac_addr[1] << 8) | (mac_addr[0]));
1040 emac_write(EMAC_MACSRCADDRHI, val);
1041 val = emac_read(EMAC_RXUNICASTSET);
1042 val |= BIT(ch);
1043 emac_write(EMAC_RXUNICASTSET, val);
1044 val = emac_read(EMAC_RXUNICASTCLEAR);
1045 val &= ~BIT(ch);
1046 emac_write(EMAC_RXUNICASTCLEAR, val);
1047}
1048
1049/**
1050 * emac_set_type1addr - Set EMAC Type1 mac address
1051 * @priv: The DaVinci EMAC private adapter structure
1052 * @ch: RX channel number
1053 * @mac_addr: MAC address to set in device
1054 *
1055 * Called internally to set Type1 mac address of the adapter (Device)
1056 *
1057 * Returns success (0) or appropriate error code (none as of now)
1058 */
1059static void emac_set_type1addr(struct emac_priv *priv, u32 ch, char *mac_addr)
1060{
1061 u32 val;
1062 emac_write(EMAC_MACINDEX, ch);
1063 val = ((mac_addr[5] << 8) | mac_addr[4]);
1064 emac_write(EMAC_MACADDRLO, val);
1065 val = ((mac_addr[3] << 24) | (mac_addr[2] << 16) | \
1066 (mac_addr[1] << 8) | (mac_addr[0]));
1067 emac_write(EMAC_MACADDRHI, val);
1068 emac_set_type0addr(priv, ch, mac_addr);
1069}
1070
1071/**
1072 * emac_set_type2addr - Set EMAC Type2 mac address
1073 * @priv: The DaVinci EMAC private adapter structure
1074 * @ch: RX channel number
1075 * @mac_addr: MAC address to set in device
1076 * @index: index into RX address entries
1077 * @match: match parameter for RX address matching logic
1078 *
1079 * Called internally to set Type2 mac address of the adapter (Device)
1080 *
1081 * Returns success (0) or appropriate error code (none as of now)
1082 */
1083static void emac_set_type2addr(struct emac_priv *priv, u32 ch,
1084 char *mac_addr, int index, int match)
1085{
1086 u32 val;
1087 emac_write(EMAC_MACINDEX, index);
1088 val = ((mac_addr[3] << 24) | (mac_addr[2] << 16) | \
1089 (mac_addr[1] << 8) | (mac_addr[0]));
1090 emac_write(EMAC_MACADDRHI, val);
1091 val = ((mac_addr[5] << 8) | mac_addr[4] | ((ch & 0x7) << 16) | \
1092 (match << 19) | BIT(20));
1093 emac_write(EMAC_MACADDRLO, val);
1094 emac_set_type0addr(priv, ch, mac_addr);
1095}
1096
1097/**
1098 * emac_setmac - Set mac address in the adapter (internal function)
1099 * @priv: The DaVinci EMAC private adapter structure
1100 * @ch: RX channel number
1101 * @mac_addr: MAC address to set in device
1102 *
1103 * Called internally to set the mac address of the adapter (Device)
1104 *
1105 * Returns success (0) or appropriate error code (none as of now)
1106 */
1107static void emac_setmac(struct emac_priv *priv, u32 ch, char *mac_addr)
1108{
1109 struct device *emac_dev = &priv->ndev->dev;
1110
1111 if (priv->rx_addr_type == 0) {
1112 emac_set_type0addr(priv, ch, mac_addr);
1113 } else if (priv->rx_addr_type == 1) {
1114 u32 cnt;
1115 for (cnt = 0; cnt < EMAC_MAX_TXRX_CHANNELS; cnt++)
1116 emac_set_type1addr(priv, ch, mac_addr);
1117 } else if (priv->rx_addr_type == 2) {
1118 emac_set_type2addr(priv, ch, mac_addr, ch, 1);
1119 emac_set_type0addr(priv, ch, mac_addr);
1120 } else {
1121 if (netif_msg_drv(priv))
1122 dev_err(emac_dev, "DaVinci EMAC: Wrong addressing\n");
1123 }
1124}
1125
1126/**
1127 * emac_dev_setmac_addr - Set mac address in the adapter
1128 * @ndev: The DaVinci EMAC network adapter
1129 * @addr: MAC address to set in device
1130 *
1131 * Called by the system to set the mac address of the adapter (Device)
1132 *
1133 * Returns success (0) or appropriate error code (none as of now)
1134 */
1135static int emac_dev_setmac_addr(struct net_device *ndev, void *addr)
1136{
1137 struct emac_priv *priv = netdev_priv(ndev);
1138 struct device *emac_dev = &priv->ndev->dev;
1139 struct sockaddr *sa = addr;
1140
1141 if (!is_valid_ether_addr(sa->sa_data))
1142 return -EADDRNOTAVAIL;
1143
1144 /* Store mac addr in priv and rx channel and set it in EMAC hw */
1145 memcpy(priv->mac_addr, sa->sa_data, ndev->addr_len);
1146 eth_hw_addr_set(ndev, sa->sa_data);
1147
1148 /* MAC address is configured only after the interface is enabled. */
1149 if (netif_running(ndev)) {
1150 emac_setmac(priv, EMAC_DEF_RX_CH, priv->mac_addr);
1151 }
1152
1153 if (netif_msg_drv(priv))
1154 dev_notice(emac_dev, "DaVinci EMAC: emac_dev_setmac_addr %pM\n",
1155 priv->mac_addr);
1156
1157 return 0;
1158}
1159
1160/**
1161 * emac_hw_enable - Enable EMAC hardware for packet transmission/reception
1162 * @priv: The DaVinci EMAC private adapter structure
1163 *
1164 * Enables EMAC hardware for packet processing - enables PHY, enables RX
1165 * for packet reception and enables device interrupts and then NAPI
1166 *
1167 * Returns success (0) or appropriate error code (none right now)
1168 */
1169static int emac_hw_enable(struct emac_priv *priv)
1170{
1171 u32 val, mbp_enable, mac_control;
1172
1173 /* Soft reset */
1174 emac_write(EMAC_SOFTRESET, 1);
1175 while (emac_read(EMAC_SOFTRESET))
1176 cpu_relax();
1177
1178 /* Disable interrupt & Set pacing for more interrupts initially */
1179 emac_int_disable(priv);
1180
1181 /* Full duplex enable bit set when auto negotiation happens */
1182 mac_control =
1183 (((EMAC_DEF_TXPRIO_FIXED) ? (EMAC_MACCONTROL_TXPTYPE) : 0x0) |
1184 ((priv->speed == 1000) ? EMAC_MACCONTROL_GIGABITEN : 0x0) |
1185 ((EMAC_DEF_TXPACING_EN) ? (EMAC_MACCONTROL_TXPACEEN) : 0x0) |
1186 ((priv->duplex == DUPLEX_FULL) ? 0x1 : 0));
1187 emac_write(EMAC_MACCONTROL, mac_control);
1188
1189 mbp_enable =
1190 (((EMAC_DEF_PASS_CRC) ? (EMAC_RXMBP_PASSCRC_MASK) : 0x0) |
1191 ((EMAC_DEF_QOS_EN) ? (EMAC_RXMBP_QOSEN_MASK) : 0x0) |
1192 ((EMAC_DEF_NO_BUFF_CHAIN) ? (EMAC_RXMBP_NOCHAIN_MASK) : 0x0) |
1193 ((EMAC_DEF_MACCTRL_FRAME_EN) ? (EMAC_RXMBP_CMFEN_MASK) : 0x0) |
1194 ((EMAC_DEF_SHORT_FRAME_EN) ? (EMAC_RXMBP_CSFEN_MASK) : 0x0) |
1195 ((EMAC_DEF_ERROR_FRAME_EN) ? (EMAC_RXMBP_CEFEN_MASK) : 0x0) |
1196 ((EMAC_DEF_PROM_EN) ? (EMAC_RXMBP_CAFEN_MASK) : 0x0) |
1197 ((EMAC_DEF_PROM_CH & EMAC_RXMBP_CHMASK) << \
1198 EMAC_RXMBP_PROMCH_SHIFT) |
1199 ((EMAC_DEF_BCAST_EN) ? (EMAC_RXMBP_BROADEN_MASK) : 0x0) |
1200 ((EMAC_DEF_BCAST_CH & EMAC_RXMBP_CHMASK) << \
1201 EMAC_RXMBP_BROADCH_SHIFT) |
1202 ((EMAC_DEF_MCAST_EN) ? (EMAC_RXMBP_MULTIEN_MASK) : 0x0) |
1203 ((EMAC_DEF_MCAST_CH & EMAC_RXMBP_CHMASK) << \
1204 EMAC_RXMBP_MULTICH_SHIFT));
1205 emac_write(EMAC_RXMBPENABLE, mbp_enable);
1206 emac_write(EMAC_RXMAXLEN, (EMAC_DEF_MAX_FRAME_SIZE &
1207 EMAC_RX_MAX_LEN_MASK));
1208 emac_write(EMAC_RXBUFFEROFFSET, (EMAC_DEF_BUFFER_OFFSET &
1209 EMAC_RX_BUFFER_OFFSET_MASK));
1210 emac_write(EMAC_RXFILTERLOWTHRESH, 0);
1211 emac_write(EMAC_RXUNICASTCLEAR, EMAC_RX_UNICAST_CLEAR_ALL);
1212 priv->rx_addr_type = (emac_read(EMAC_MACCONFIG) >> 8) & 0xFF;
1213
1214 emac_write(EMAC_MACINTMASKSET, EMAC_MAC_HOST_ERR_INTMASK_VAL);
1215
1216 emac_setmac(priv, EMAC_DEF_RX_CH, priv->mac_addr);
1217
1218 /* Enable MII */
1219 val = emac_read(EMAC_MACCONTROL);
1220 val |= (EMAC_MACCONTROL_GMIIEN);
1221 emac_write(EMAC_MACCONTROL, val);
1222
1223 /* Enable NAPI and interrupts */
1224 napi_enable(&priv->napi);
1225 emac_int_enable(priv);
1226 return 0;
1227
1228}
1229
1230/**
1231 * emac_poll - EMAC NAPI Poll function
1232 * @napi: pointer to the napi_struct containing The DaVinci EMAC network adapter
1233 * @budget: Number of receive packets to process (as told by NAPI layer)
1234 *
1235 * NAPI Poll function implemented to process packets as per budget. We check
1236 * the type of interrupt on the device and accordingly call the TX or RX
1237 * packet processing functions. We follow the budget for RX processing and
1238 * also put a cap on number of TX pkts processed through config param. The
1239 * NAPI schedule function is called if more packets pending.
1240 *
1241 * Returns number of packets received (in most cases; else TX pkts - rarely)
1242 */
1243static int emac_poll(struct napi_struct *napi, int budget)
1244{
1245 unsigned int mask;
1246 struct emac_priv *priv = container_of(napi, struct emac_priv, napi);
1247 struct net_device *ndev = priv->ndev;
1248 struct device *emac_dev = &ndev->dev;
1249 u32 status = 0;
1250 u32 num_rx_pkts = 0;
1251
1252 /* Check interrupt vectors and call packet processing */
1253 status = emac_read(EMAC_MACINVECTOR);
1254
1255 mask = EMAC_DM644X_MAC_IN_VECTOR_TX_INT_VEC;
1256
1257 if (priv->version == EMAC_VERSION_2)
1258 mask = EMAC_DM646X_MAC_IN_VECTOR_TX_INT_VEC;
1259
1260 if (status & mask) {
1261 cpdma_chan_process(priv->txchan, EMAC_DEF_TX_MAX_SERVICE);
1262 } /* TX processing */
1263
1264 mask = EMAC_DM644X_MAC_IN_VECTOR_RX_INT_VEC;
1265
1266 if (priv->version == EMAC_VERSION_2)
1267 mask = EMAC_DM646X_MAC_IN_VECTOR_RX_INT_VEC;
1268
1269 if (status & mask) {
1270 num_rx_pkts = cpdma_chan_process(priv->rxchan, budget);
1271 } /* RX processing */
1272
1273 mask = EMAC_DM644X_MAC_IN_VECTOR_HOST_INT;
1274 if (priv->version == EMAC_VERSION_2)
1275 mask = EMAC_DM646X_MAC_IN_VECTOR_HOST_INT;
1276
1277 if (unlikely(status & mask)) {
1278 u32 ch, cause;
1279 dev_err(emac_dev, "DaVinci EMAC: Fatal Hardware Error\n");
1280 netif_stop_queue(ndev);
1281 napi_disable(&priv->napi);
1282
1283 status = emac_read(EMAC_MACSTATUS);
1284 cause = ((status & EMAC_MACSTATUS_TXERRCODE_MASK) >>
1285 EMAC_MACSTATUS_TXERRCODE_SHIFT);
1286 if (cause) {
1287 ch = ((status & EMAC_MACSTATUS_TXERRCH_MASK) >>
1288 EMAC_MACSTATUS_TXERRCH_SHIFT);
1289 if (net_ratelimit()) {
1290 dev_err(emac_dev, "TX Host error %s on ch=%d\n",
1291 &emac_txhost_errcodes[cause][0], ch);
1292 }
1293 }
1294 cause = ((status & EMAC_MACSTATUS_RXERRCODE_MASK) >>
1295 EMAC_MACSTATUS_RXERRCODE_SHIFT);
1296 if (cause) {
1297 ch = ((status & EMAC_MACSTATUS_RXERRCH_MASK) >>
1298 EMAC_MACSTATUS_RXERRCH_SHIFT);
1299 if (netif_msg_hw(priv) && net_ratelimit())
1300 dev_err(emac_dev, "RX Host error %s on ch=%d\n",
1301 &emac_rxhost_errcodes[cause][0], ch);
1302 }
1303 } else if (num_rx_pkts < budget) {
1304 napi_complete_done(napi, num_rx_pkts);
1305 emac_int_enable(priv);
1306 }
1307
1308 return num_rx_pkts;
1309}
1310
1311#ifdef CONFIG_NET_POLL_CONTROLLER
1312/**
1313 * emac_poll_controller - EMAC Poll controller function
1314 * @ndev: The DaVinci EMAC network adapter
1315 *
1316 * Polled functionality used by netconsole and others in non interrupt mode
1317 *
1318 */
1319static void emac_poll_controller(struct net_device *ndev)
1320{
1321 struct emac_priv *priv = netdev_priv(ndev);
1322
1323 emac_int_disable(priv);
1324 emac_irq(ndev->irq, ndev);
1325 emac_int_enable(priv);
1326}
1327#endif
1328
1329static void emac_adjust_link(struct net_device *ndev)
1330{
1331 struct emac_priv *priv = netdev_priv(ndev);
1332 struct phy_device *phydev = ndev->phydev;
1333 unsigned long flags;
1334 int new_state = 0;
1335
1336 spin_lock_irqsave(&priv->lock, flags);
1337
1338 if (phydev->link) {
1339 /* check the mode of operation - full/half duplex */
1340 if (phydev->duplex != priv->duplex) {
1341 new_state = 1;
1342 priv->duplex = phydev->duplex;
1343 }
1344 if (phydev->speed != priv->speed) {
1345 new_state = 1;
1346 priv->speed = phydev->speed;
1347 }
1348 if (!priv->link) {
1349 new_state = 1;
1350 priv->link = 1;
1351 }
1352
1353 } else if (priv->link) {
1354 new_state = 1;
1355 priv->link = 0;
1356 priv->speed = 0;
1357 priv->duplex = ~0;
1358 }
1359 if (new_state) {
1360 emac_update_phystatus(priv);
1361 phy_print_status(ndev->phydev);
1362 }
1363
1364 spin_unlock_irqrestore(&priv->lock, flags);
1365}
1366
1367/*************************************************************************
1368 * Linux Driver Model
1369 *************************************************************************/
1370
1371/**
1372 * emac_devioctl - EMAC adapter ioctl
1373 * @ndev: The DaVinci EMAC network adapter
1374 * @ifrq: request parameter
1375 * @cmd: command parameter
1376 *
1377 * EMAC driver ioctl function
1378 *
1379 * Returns success(0) or appropriate error code
1380 */
1381static int emac_devioctl(struct net_device *ndev, struct ifreq *ifrq, int cmd)
1382{
1383 if (!(netif_running(ndev)))
1384 return -EINVAL;
1385
1386 /* TODO: Add phy read and write and private statistics get feature */
1387
1388 if (ndev->phydev)
1389 return phy_mii_ioctl(ndev->phydev, ifrq, cmd);
1390 else
1391 return -EOPNOTSUPP;
1392}
1393
1394static int match_first_device(struct device *dev, const void *data)
1395{
1396 if (dev->parent && dev->parent->of_node)
1397 return of_device_is_compatible(dev->parent->of_node,
1398 "ti,davinci_mdio");
1399
1400 return !strncmp(dev_name(dev), "davinci_mdio", 12);
1401}
1402
1403/**
1404 * emac_dev_open - EMAC device open
1405 * @ndev: The DaVinci EMAC network adapter
1406 *
1407 * Called when system wants to start the interface. We init TX/RX channels
1408 * and enable the hardware for packet reception/transmission and start the
1409 * network queue.
1410 *
1411 * Returns 0 for a successful open, or appropriate error code
1412 */
1413static int emac_dev_open(struct net_device *ndev)
1414{
1415 struct device *emac_dev = &ndev->dev;
1416 struct resource *res;
1417 int q, m, ret;
1418 int res_num = 0, irq_num = 0;
1419 int i = 0;
1420 struct emac_priv *priv = netdev_priv(ndev);
1421 struct phy_device *phydev = NULL;
1422 struct device *phy = NULL;
1423
1424 ret = pm_runtime_resume_and_get(&priv->pdev->dev);
1425 if (ret < 0) {
1426 dev_err(&priv->pdev->dev, "%s: failed to get_sync(%d)\n",
1427 __func__, ret);
1428 return ret;
1429 }
1430
1431 netif_carrier_off(ndev);
1432 eth_hw_addr_set(ndev, priv->mac_addr);
1433
1434 /* Configuration items */
1435 priv->rx_buf_size = EMAC_DEF_MAX_FRAME_SIZE + NET_IP_ALIGN;
1436
1437 priv->mac_hash1 = 0;
1438 priv->mac_hash2 = 0;
1439 emac_write(EMAC_MACHASH1, 0);
1440 emac_write(EMAC_MACHASH2, 0);
1441
1442 for (i = 0; i < EMAC_DEF_RX_NUM_DESC; i++) {
1443 struct sk_buff *skb = emac_rx_alloc(priv);
1444
1445 if (!skb)
1446 break;
1447
1448 ret = cpdma_chan_idle_submit(priv->rxchan, skb, skb->data,
1449 skb_tailroom(skb), 0);
1450 if (WARN_ON(ret < 0))
1451 break;
1452 }
1453
1454 /* Request IRQ */
1455 if (dev_of_node(&priv->pdev->dev)) {
1456 while ((ret = platform_get_irq_optional(priv->pdev, res_num)) != -ENXIO) {
1457 if (ret < 0)
1458 goto rollback;
1459
1460 ret = request_irq(ret, emac_irq, 0, ndev->name, ndev);
1461 if (ret) {
1462 dev_err(emac_dev, "DaVinci EMAC: request_irq() failed\n");
1463 goto rollback;
1464 }
1465 res_num++;
1466 }
1467 } else {
1468 while ((res = platform_get_resource(priv->pdev, IORESOURCE_IRQ, res_num))) {
1469 for (irq_num = res->start; irq_num <= res->end; irq_num++) {
1470 ret = request_irq(irq_num, emac_irq, 0, ndev->name, ndev);
1471 if (ret) {
1472 dev_err(emac_dev, "DaVinci EMAC: request_irq() failed\n");
1473 goto rollback;
1474 }
1475 }
1476 res_num++;
1477 }
1478 /* prepare counters for rollback in case of an error */
1479 res_num--;
1480 irq_num--;
1481 }
1482
1483 /* Start/Enable EMAC hardware */
1484 emac_hw_enable(priv);
1485
1486 /* Enable Interrupt pacing if configured */
1487 if (priv->coal_intvl != 0) {
1488 struct ethtool_coalesce coal;
1489
1490 coal.rx_coalesce_usecs = (priv->coal_intvl << 4);
1491 emac_set_coalesce(ndev, &coal, NULL, NULL);
1492 }
1493
1494 cpdma_ctlr_start(priv->dma);
1495
1496 if (priv->phy_node) {
1497 phydev = of_phy_connect(ndev, priv->phy_node,
1498 &emac_adjust_link, 0, 0);
1499 if (!phydev) {
1500 dev_err(emac_dev, "could not connect to phy %pOF\n",
1501 priv->phy_node);
1502 ret = -ENODEV;
1503 goto err;
1504 }
1505 }
1506
1507 /* use the first phy on the bus if pdata did not give us a phy id */
1508 if (!phydev && !priv->phy_id) {
1509 /* NOTE: we can't use bus_find_device_by_name() here because
1510 * the device name is not guaranteed to be 'davinci_mdio'. On
1511 * some systems it can be 'davinci_mdio.0' so we need to use
1512 * strncmp() against the first part of the string to correctly
1513 * match it.
1514 */
1515 phy = bus_find_device(&mdio_bus_type, NULL, NULL,
1516 match_first_device);
1517 if (phy) {
1518 priv->phy_id = dev_name(phy);
1519 if (!priv->phy_id || !*priv->phy_id)
1520 put_device(phy);
1521 }
1522 }
1523
1524 if (!phydev && priv->phy_id && *priv->phy_id) {
1525 phydev = phy_connect(ndev, priv->phy_id,
1526 &emac_adjust_link,
1527 PHY_INTERFACE_MODE_MII);
1528 put_device(phy); /* reference taken by bus_find_device */
1529 if (IS_ERR(phydev)) {
1530 dev_err(emac_dev, "could not connect to phy %s\n",
1531 priv->phy_id);
1532 ret = PTR_ERR(phydev);
1533 goto err;
1534 }
1535
1536 priv->link = 0;
1537 priv->speed = 0;
1538 priv->duplex = ~0;
1539
1540 phy_attached_info(phydev);
1541 }
1542
1543 if (!phydev) {
1544 /* No PHY , fix the link, speed and duplex settings */
1545 dev_notice(emac_dev, "no phy, defaulting to 100/full\n");
1546 priv->link = 1;
1547 priv->speed = SPEED_100;
1548 priv->duplex = DUPLEX_FULL;
1549 emac_update_phystatus(priv);
1550 }
1551
1552 if (netif_msg_drv(priv))
1553 dev_notice(emac_dev, "DaVinci EMAC: Opened %s\n", ndev->name);
1554
1555 if (phydev)
1556 phy_start(phydev);
1557
1558 return 0;
1559
1560err:
1561 emac_int_disable(priv);
1562 napi_disable(&priv->napi);
1563
1564rollback:
1565 if (dev_of_node(&priv->pdev->dev)) {
1566 for (q = res_num - 1; q >= 0; q--) {
1567 irq_num = platform_get_irq(priv->pdev, q);
1568 if (irq_num > 0)
1569 free_irq(irq_num, ndev);
1570 }
1571 } else {
1572 for (q = res_num; q >= 0; q--) {
1573 res = platform_get_resource(priv->pdev, IORESOURCE_IRQ, q);
1574 /* at the first iteration, irq_num is already set to the
1575 * right value
1576 */
1577 if (q != res_num)
1578 irq_num = res->end;
1579
1580 for (m = irq_num; m >= res->start; m--)
1581 free_irq(m, ndev);
1582 }
1583 }
1584 cpdma_ctlr_stop(priv->dma);
1585 pm_runtime_put(&priv->pdev->dev);
1586 return ret;
1587}
1588
1589/**
1590 * emac_dev_stop - EMAC device stop
1591 * @ndev: The DaVinci EMAC network adapter
1592 *
1593 * Called when system wants to stop or down the interface. We stop the network
1594 * queue, disable interrupts and cleanup TX/RX channels.
1595 *
1596 * We return the statistics in net_device_stats structure pulled from emac
1597 */
1598static int emac_dev_stop(struct net_device *ndev)
1599{
1600 struct resource *res;
1601 int i = 0;
1602 int irq_num;
1603 struct emac_priv *priv = netdev_priv(ndev);
1604 struct device *emac_dev = &ndev->dev;
1605 int ret = 0;
1606
1607 /* inform the upper layers. */
1608 netif_stop_queue(ndev);
1609 napi_disable(&priv->napi);
1610
1611 netif_carrier_off(ndev);
1612 emac_int_disable(priv);
1613 cpdma_ctlr_stop(priv->dma);
1614 emac_write(EMAC_SOFTRESET, 1);
1615
1616 if (ndev->phydev)
1617 phy_disconnect(ndev->phydev);
1618
1619 /* Free IRQ */
1620 if (dev_of_node(&priv->pdev->dev)) {
1621 do {
1622 ret = platform_get_irq_optional(priv->pdev, i);
1623 if (ret < 0 && ret != -ENXIO)
1624 break;
1625 if (ret > 0) {
1626 free_irq(ret, priv->ndev);
1627 } else {
1628 ret = 0;
1629 break;
1630 }
1631 } while (++i);
1632 } else {
1633 while ((res = platform_get_resource(priv->pdev, IORESOURCE_IRQ, i))) {
1634 for (irq_num = res->start; irq_num <= res->end; irq_num++)
1635 free_irq(irq_num, priv->ndev);
1636 i++;
1637 }
1638 }
1639
1640 if (netif_msg_drv(priv))
1641 dev_notice(emac_dev, "DaVinci EMAC: %s stopped\n", ndev->name);
1642
1643 pm_runtime_put(&priv->pdev->dev);
1644 return ret;
1645}
1646
1647/**
1648 * emac_dev_getnetstats - EMAC get statistics function
1649 * @ndev: The DaVinci EMAC network adapter
1650 *
1651 * Called when system wants to get statistics from the device.
1652 *
1653 * We return the statistics in net_device_stats structure pulled from emac
1654 */
1655static struct net_device_stats *emac_dev_getnetstats(struct net_device *ndev)
1656{
1657 struct emac_priv *priv = netdev_priv(ndev);
1658 u32 mac_control;
1659 u32 stats_clear_mask;
1660 int err;
1661
1662 err = pm_runtime_resume_and_get(&priv->pdev->dev);
1663 if (err < 0) {
1664 dev_err(&priv->pdev->dev, "%s: failed to get_sync(%d)\n",
1665 __func__, err);
1666 return &ndev->stats;
1667 }
1668
1669 /* update emac hardware stats and reset the registers*/
1670
1671 mac_control = emac_read(EMAC_MACCONTROL);
1672
1673 if (mac_control & EMAC_MACCONTROL_GMIIEN)
1674 stats_clear_mask = EMAC_STATS_CLR_MASK;
1675 else
1676 stats_clear_mask = 0;
1677
1678 ndev->stats.multicast += emac_read(EMAC_RXMCASTFRAMES);
1679 emac_write(EMAC_RXMCASTFRAMES, stats_clear_mask);
1680
1681 ndev->stats.collisions += (emac_read(EMAC_TXCOLLISION) +
1682 emac_read(EMAC_TXSINGLECOLL) +
1683 emac_read(EMAC_TXMULTICOLL));
1684 emac_write(EMAC_TXCOLLISION, stats_clear_mask);
1685 emac_write(EMAC_TXSINGLECOLL, stats_clear_mask);
1686 emac_write(EMAC_TXMULTICOLL, stats_clear_mask);
1687
1688 ndev->stats.rx_length_errors += (emac_read(EMAC_RXOVERSIZED) +
1689 emac_read(EMAC_RXJABBER) +
1690 emac_read(EMAC_RXUNDERSIZED));
1691 emac_write(EMAC_RXOVERSIZED, stats_clear_mask);
1692 emac_write(EMAC_RXJABBER, stats_clear_mask);
1693 emac_write(EMAC_RXUNDERSIZED, stats_clear_mask);
1694
1695 ndev->stats.rx_over_errors += (emac_read(EMAC_RXSOFOVERRUNS) +
1696 emac_read(EMAC_RXMOFOVERRUNS));
1697 emac_write(EMAC_RXSOFOVERRUNS, stats_clear_mask);
1698 emac_write(EMAC_RXMOFOVERRUNS, stats_clear_mask);
1699
1700 ndev->stats.rx_fifo_errors += emac_read(EMAC_RXDMAOVERRUNS);
1701 emac_write(EMAC_RXDMAOVERRUNS, stats_clear_mask);
1702
1703 ndev->stats.tx_carrier_errors +=
1704 emac_read(EMAC_TXCARRIERSENSE);
1705 emac_write(EMAC_TXCARRIERSENSE, stats_clear_mask);
1706
1707 ndev->stats.tx_fifo_errors += emac_read(EMAC_TXUNDERRUN);
1708 emac_write(EMAC_TXUNDERRUN, stats_clear_mask);
1709
1710 pm_runtime_put(&priv->pdev->dev);
1711
1712 return &ndev->stats;
1713}
1714
1715static const struct net_device_ops emac_netdev_ops = {
1716 .ndo_open = emac_dev_open,
1717 .ndo_stop = emac_dev_stop,
1718 .ndo_start_xmit = emac_dev_xmit,
1719 .ndo_set_rx_mode = emac_dev_mcast_set,
1720 .ndo_set_mac_address = emac_dev_setmac_addr,
1721 .ndo_eth_ioctl = emac_devioctl,
1722 .ndo_tx_timeout = emac_dev_tx_timeout,
1723 .ndo_get_stats = emac_dev_getnetstats,
1724#ifdef CONFIG_NET_POLL_CONTROLLER
1725 .ndo_poll_controller = emac_poll_controller,
1726#endif
1727};
1728
1729static const struct of_device_id davinci_emac_of_match[];
1730
1731static struct emac_platform_data *
1732davinci_emac_of_get_pdata(struct platform_device *pdev, struct emac_priv *priv)
1733{
1734 struct device_node *np;
1735 const struct of_device_id *match;
1736 const struct emac_platform_data *auxdata;
1737 struct emac_platform_data *pdata = NULL;
1738
1739 if (!IS_ENABLED(CONFIG_OF) || !pdev->dev.of_node)
1740 return dev_get_platdata(&pdev->dev);
1741
1742 pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
1743 if (!pdata)
1744 return NULL;
1745
1746 np = pdev->dev.of_node;
1747 pdata->version = EMAC_VERSION_2;
1748
1749 if (!is_valid_ether_addr(pdata->mac_addr))
1750 of_get_mac_address(np, pdata->mac_addr);
1751
1752 of_property_read_u32(np, "ti,davinci-ctrl-reg-offset",
1753 &pdata->ctrl_reg_offset);
1754
1755 of_property_read_u32(np, "ti,davinci-ctrl-mod-reg-offset",
1756 &pdata->ctrl_mod_reg_offset);
1757
1758 of_property_read_u32(np, "ti,davinci-ctrl-ram-offset",
1759 &pdata->ctrl_ram_offset);
1760
1761 of_property_read_u32(np, "ti,davinci-ctrl-ram-size",
1762 &pdata->ctrl_ram_size);
1763
1764 of_property_read_u8(np, "ti,davinci-rmii-en", &pdata->rmii_en);
1765
1766 pdata->no_bd_ram = of_property_read_bool(np, "ti,davinci-no-bd-ram");
1767
1768 priv->phy_node = of_parse_phandle(np, "phy-handle", 0);
1769 if (!priv->phy_node) {
1770 if (!of_phy_is_fixed_link(np))
1771 pdata->phy_id = NULL;
1772 else if (of_phy_register_fixed_link(np) >= 0)
1773 priv->phy_node = of_node_get(np);
1774 }
1775
1776 auxdata = pdev->dev.platform_data;
1777 if (auxdata) {
1778 pdata->interrupt_enable = auxdata->interrupt_enable;
1779 pdata->interrupt_disable = auxdata->interrupt_disable;
1780 }
1781
1782 match = of_match_device(davinci_emac_of_match, &pdev->dev);
1783 if (match && match->data) {
1784 auxdata = match->data;
1785 pdata->version = auxdata->version;
1786 pdata->hw_ram_addr = auxdata->hw_ram_addr;
1787 }
1788
1789 return pdata;
1790}
1791
1792static int davinci_emac_try_get_mac(struct platform_device *pdev,
1793 int instance, u8 *mac_addr)
1794{
1795 if (!pdev->dev.of_node)
1796 return -EINVAL;
1797
1798 return ti_cm_get_macid(&pdev->dev, instance, mac_addr);
1799}
1800
1801/**
1802 * davinci_emac_probe - EMAC device probe
1803 * @pdev: The DaVinci EMAC device that we are removing
1804 *
1805 * Called when probing for emac devicesr. We get details of instances and
1806 * resource information from platform init and register a network device
1807 * and allocate resources necessary for driver to perform
1808 */
1809static int davinci_emac_probe(struct platform_device *pdev)
1810{
1811 struct device_node *np = pdev->dev.of_node;
1812 int rc = 0;
1813 struct resource *res, *res_ctrl;
1814 struct net_device *ndev;
1815 struct emac_priv *priv;
1816 unsigned long hw_ram_addr;
1817 struct emac_platform_data *pdata;
1818 struct cpdma_params dma_params;
1819 struct clk *emac_clk;
1820 unsigned long emac_bus_frequency;
1821
1822
1823 /* obtain emac clock from kernel */
1824 emac_clk = devm_clk_get(&pdev->dev, NULL);
1825 if (IS_ERR(emac_clk)) {
1826 dev_err(&pdev->dev, "failed to get EMAC clock\n");
1827 return -EBUSY;
1828 }
1829 emac_bus_frequency = clk_get_rate(emac_clk);
1830 devm_clk_put(&pdev->dev, emac_clk);
1831
1832 /* TODO: Probe PHY here if possible */
1833
1834 ndev = alloc_etherdev(sizeof(struct emac_priv));
1835 if (!ndev)
1836 return -ENOMEM;
1837
1838 platform_set_drvdata(pdev, ndev);
1839 priv = netdev_priv(ndev);
1840 priv->pdev = pdev;
1841 priv->ndev = ndev;
1842 priv->msg_enable = netif_msg_init(debug_level, DAVINCI_EMAC_DEBUG);
1843
1844 spin_lock_init(&priv->lock);
1845
1846 pdata = davinci_emac_of_get_pdata(pdev, priv);
1847 if (!pdata) {
1848 dev_err(&pdev->dev, "no platform data\n");
1849 rc = -ENODEV;
1850 goto err_free_netdev;
1851 }
1852
1853 /* MAC addr and PHY mask , RMII enable info from platform_data */
1854 memcpy(priv->mac_addr, pdata->mac_addr, ETH_ALEN);
1855 priv->phy_id = pdata->phy_id;
1856 priv->rmii_en = pdata->rmii_en;
1857 priv->version = pdata->version;
1858 priv->int_enable = pdata->interrupt_enable;
1859 priv->int_disable = pdata->interrupt_disable;
1860
1861 priv->coal_intvl = 0;
1862 priv->bus_freq_mhz = (u32)(emac_bus_frequency / 1000000);
1863
1864 /* Get EMAC platform data */
1865 priv->remap_addr = devm_platform_get_and_ioremap_resource(pdev, 0, &res);
1866 if (IS_ERR(priv->remap_addr)) {
1867 rc = PTR_ERR(priv->remap_addr);
1868 goto no_pdata;
1869 }
1870 priv->emac_base_phys = res->start + pdata->ctrl_reg_offset;
1871
1872 res_ctrl = platform_get_resource(pdev, IORESOURCE_MEM, 1);
1873 if (res_ctrl) {
1874 priv->ctrl_base =
1875 devm_ioremap_resource(&pdev->dev, res_ctrl);
1876 if (IS_ERR(priv->ctrl_base)) {
1877 rc = PTR_ERR(priv->ctrl_base);
1878 goto no_pdata;
1879 }
1880 } else {
1881 priv->ctrl_base = priv->remap_addr + pdata->ctrl_mod_reg_offset;
1882 }
1883
1884 priv->emac_base = priv->remap_addr + pdata->ctrl_reg_offset;
1885 ndev->base_addr = (unsigned long)priv->remap_addr;
1886
1887 hw_ram_addr = pdata->hw_ram_addr;
1888 if (!hw_ram_addr)
1889 hw_ram_addr = (u32 __force)res->start + pdata->ctrl_ram_offset;
1890
1891 memset(&dma_params, 0, sizeof(dma_params));
1892 dma_params.dev = &pdev->dev;
1893 dma_params.dmaregs = priv->emac_base;
1894 dma_params.rxthresh = priv->emac_base + 0x120;
1895 dma_params.rxfree = priv->emac_base + 0x140;
1896 dma_params.txhdp = priv->emac_base + 0x600;
1897 dma_params.rxhdp = priv->emac_base + 0x620;
1898 dma_params.txcp = priv->emac_base + 0x640;
1899 dma_params.rxcp = priv->emac_base + 0x660;
1900 dma_params.num_chan = EMAC_MAX_TXRX_CHANNELS;
1901 dma_params.min_packet_size = EMAC_DEF_MIN_ETHPKTSIZE;
1902 dma_params.desc_hw_addr = hw_ram_addr;
1903 dma_params.desc_mem_size = pdata->ctrl_ram_size;
1904 dma_params.desc_align = 16;
1905
1906 dma_params.desc_mem_phys = pdata->no_bd_ram ? 0 :
1907 (u32 __force)res->start + pdata->ctrl_ram_offset;
1908
1909 priv->dma = cpdma_ctlr_create(&dma_params);
1910 if (!priv->dma) {
1911 dev_err(&pdev->dev, "error initializing DMA\n");
1912 rc = -ENOMEM;
1913 goto no_pdata;
1914 }
1915
1916 priv->txchan = cpdma_chan_create(priv->dma, EMAC_DEF_TX_CH,
1917 emac_tx_handler, 0);
1918 if (IS_ERR(priv->txchan)) {
1919 dev_err(&pdev->dev, "error initializing tx dma channel\n");
1920 rc = PTR_ERR(priv->txchan);
1921 goto err_free_dma;
1922 }
1923
1924 priv->rxchan = cpdma_chan_create(priv->dma, EMAC_DEF_RX_CH,
1925 emac_rx_handler, 1);
1926 if (IS_ERR(priv->rxchan)) {
1927 dev_err(&pdev->dev, "error initializing rx dma channel\n");
1928 rc = PTR_ERR(priv->rxchan);
1929 goto err_free_txchan;
1930 }
1931
1932 rc = platform_get_irq(pdev, 0);
1933 if (rc < 0)
1934 goto err_free_rxchan;
1935 ndev->irq = rc;
1936
1937 rc = davinci_emac_try_get_mac(pdev, res_ctrl ? 0 : 1, priv->mac_addr);
1938 if (!rc)
1939 eth_hw_addr_set(ndev, priv->mac_addr);
1940
1941 if (!is_valid_ether_addr(priv->mac_addr)) {
1942 /* Use random MAC if still none obtained. */
1943 eth_hw_addr_random(ndev);
1944 memcpy(priv->mac_addr, ndev->dev_addr, ndev->addr_len);
1945 dev_warn(&pdev->dev, "using random MAC addr: %pM\n",
1946 priv->mac_addr);
1947 }
1948
1949 ndev->netdev_ops = &emac_netdev_ops;
1950 ndev->ethtool_ops = &ethtool_ops;
1951 netif_napi_add(ndev, &priv->napi, emac_poll, NAPI_POLL_WEIGHT);
1952
1953 pm_runtime_enable(&pdev->dev);
1954 rc = pm_runtime_resume_and_get(&pdev->dev);
1955 if (rc < 0) {
1956 dev_err(&pdev->dev, "%s: failed to get_sync(%d)\n",
1957 __func__, rc);
1958 goto err_napi_del;
1959 }
1960
1961 /* register the network device */
1962 SET_NETDEV_DEV(ndev, &pdev->dev);
1963 rc = register_netdev(ndev);
1964 if (rc) {
1965 dev_err(&pdev->dev, "error in register_netdev\n");
1966 rc = -ENODEV;
1967 pm_runtime_put(&pdev->dev);
1968 goto err_napi_del;
1969 }
1970
1971
1972 if (netif_msg_probe(priv)) {
1973 dev_notice(&pdev->dev, "DaVinci EMAC Probe found device "
1974 "(regs: %pa, irq: %d)\n",
1975 &priv->emac_base_phys, ndev->irq);
1976 }
1977 pm_runtime_put(&pdev->dev);
1978
1979 return 0;
1980
1981err_napi_del:
1982 netif_napi_del(&priv->napi);
1983err_free_rxchan:
1984 cpdma_chan_destroy(priv->rxchan);
1985err_free_txchan:
1986 cpdma_chan_destroy(priv->txchan);
1987err_free_dma:
1988 cpdma_ctlr_destroy(priv->dma);
1989no_pdata:
1990 if (of_phy_is_fixed_link(np))
1991 of_phy_deregister_fixed_link(np);
1992 of_node_put(priv->phy_node);
1993err_free_netdev:
1994 free_netdev(ndev);
1995 return rc;
1996}
1997
1998/**
1999 * davinci_emac_remove - EMAC device remove
2000 * @pdev: The DaVinci EMAC device that we are removing
2001 *
2002 * Called when removing the device driver. We disable clock usage and release
2003 * the resources taken up by the driver and unregister network device
2004 */
2005static int davinci_emac_remove(struct platform_device *pdev)
2006{
2007 struct net_device *ndev = platform_get_drvdata(pdev);
2008 struct emac_priv *priv = netdev_priv(ndev);
2009 struct device_node *np = pdev->dev.of_node;
2010
2011 dev_notice(&ndev->dev, "DaVinci EMAC: davinci_emac_remove()\n");
2012
2013 if (priv->txchan)
2014 cpdma_chan_destroy(priv->txchan);
2015 if (priv->rxchan)
2016 cpdma_chan_destroy(priv->rxchan);
2017 cpdma_ctlr_destroy(priv->dma);
2018
2019 unregister_netdev(ndev);
2020 of_node_put(priv->phy_node);
2021 pm_runtime_disable(&pdev->dev);
2022 if (of_phy_is_fixed_link(np))
2023 of_phy_deregister_fixed_link(np);
2024 free_netdev(ndev);
2025
2026 return 0;
2027}
2028
2029static int davinci_emac_suspend(struct device *dev)
2030{
2031 struct net_device *ndev = dev_get_drvdata(dev);
2032
2033 if (netif_running(ndev))
2034 emac_dev_stop(ndev);
2035
2036 return 0;
2037}
2038
2039static int davinci_emac_resume(struct device *dev)
2040{
2041 struct net_device *ndev = dev_get_drvdata(dev);
2042
2043 if (netif_running(ndev))
2044 emac_dev_open(ndev);
2045
2046 return 0;
2047}
2048
2049static const struct dev_pm_ops davinci_emac_pm_ops = {
2050 .suspend = davinci_emac_suspend,
2051 .resume = davinci_emac_resume,
2052};
2053
2054static const struct emac_platform_data am3517_emac_data = {
2055 .version = EMAC_VERSION_2,
2056 .hw_ram_addr = 0x01e20000,
2057};
2058
2059static const struct emac_platform_data dm816_emac_data = {
2060 .version = EMAC_VERSION_2,
2061};
2062
2063static const struct of_device_id davinci_emac_of_match[] = {
2064 {.compatible = "ti,davinci-dm6467-emac", },
2065 {.compatible = "ti,am3517-emac", .data = &am3517_emac_data, },
2066 {.compatible = "ti,dm816-emac", .data = &dm816_emac_data, },
2067 {},
2068};
2069MODULE_DEVICE_TABLE(of, davinci_emac_of_match);
2070
2071/* davinci_emac_driver: EMAC platform driver structure */
2072static struct platform_driver davinci_emac_driver = {
2073 .driver = {
2074 .name = "davinci_emac",
2075 .pm = &davinci_emac_pm_ops,
2076 .of_match_table = davinci_emac_of_match,
2077 },
2078 .probe = davinci_emac_probe,
2079 .remove = davinci_emac_remove,
2080};
2081
2082/**
2083 * davinci_emac_init - EMAC driver module init
2084 *
2085 * Called when initializing the driver. We register the driver with
2086 * the platform.
2087 */
2088static int __init davinci_emac_init(void)
2089{
2090 return platform_driver_register(&davinci_emac_driver);
2091}
2092late_initcall(davinci_emac_init);
2093
2094/**
2095 * davinci_emac_exit - EMAC driver module exit
2096 *
2097 * Called when exiting the driver completely. We unregister the driver with
2098 * the platform and exit
2099 */
2100static void __exit davinci_emac_exit(void)
2101{
2102 platform_driver_unregister(&davinci_emac_driver);
2103}
2104module_exit(davinci_emac_exit);
2105
2106MODULE_LICENSE("GPL");
2107MODULE_AUTHOR("DaVinci EMAC Maintainer: Anant Gole <anantgole@ti.com>");
2108MODULE_AUTHOR("DaVinci EMAC Maintainer: Chaithrika U S <chaithrika@ti.com>");
2109MODULE_DESCRIPTION("DaVinci EMAC Ethernet driver");
2110

source code of linux/drivers/net/ethernet/ti/davinci_emac.c