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