OpenWrt – Blame information for rev 3
?pathlinks?
Rev | Author | Line No. | Line |
---|---|---|---|
1 | office | 1 | /* |
2 | * Cavium CNS3xxx Gigabit driver for Linux |
||
3 | * |
||
4 | * Copyright 2011 Gateworks Corporation |
||
5 | * Chris Lang <clang@gateworks.com> |
||
6 | * |
||
7 | * This program is free software; you can redistribute it and/or modify it |
||
8 | * under the terms of version 2 of the GNU General Public License |
||
9 | * as published by the Free Software Foundation. |
||
10 | * |
||
11 | */ |
||
12 | |||
13 | #include <linux/delay.h> |
||
14 | #include <linux/module.h> |
||
15 | #include <linux/dma-mapping.h> |
||
16 | #include <linux/dmapool.h> |
||
17 | #include <linux/etherdevice.h> |
||
18 | #include <linux/interrupt.h> |
||
19 | #include <linux/io.h> |
||
20 | #include <linux/kernel.h> |
||
21 | #include <linux/phy.h> |
||
22 | #include <linux/platform_device.h> |
||
23 | #include <linux/platform_data/cns3xxx.h> |
||
24 | #include <linux/skbuff.h> |
||
25 | |||
26 | #define DRV_NAME "cns3xxx_eth" |
||
27 | |||
28 | #define RX_DESCS 256 |
||
29 | #define TX_DESCS 128 |
||
30 | #define TX_DESC_RESERVE 20 |
||
31 | |||
32 | #define RX_POOL_ALLOC_SIZE (sizeof(struct rx_desc) * RX_DESCS) |
||
33 | #define TX_POOL_ALLOC_SIZE (sizeof(struct tx_desc) * TX_DESCS) |
||
34 | #define REGS_SIZE 336 |
||
35 | |||
36 | #define RX_BUFFER_ALIGN 64 |
||
37 | #define RX_BUFFER_ALIGN_MASK (~(RX_BUFFER_ALIGN - 1)) |
||
38 | |||
39 | #define SKB_HEAD_ALIGN (((PAGE_SIZE - NET_SKB_PAD) % RX_BUFFER_ALIGN) + NET_SKB_PAD + NET_IP_ALIGN) |
||
40 | #define RX_SEGMENT_ALLOC_SIZE 2048 |
||
41 | #define RX_SEGMENT_BUFSIZE (SKB_WITH_OVERHEAD(RX_SEGMENT_ALLOC_SIZE)) |
||
42 | #define RX_SEGMENT_MRU (((RX_SEGMENT_BUFSIZE - SKB_HEAD_ALIGN) & RX_BUFFER_ALIGN_MASK) - NET_IP_ALIGN) |
||
43 | #define MAX_MTU 9500 |
||
44 | |||
45 | #define NAPI_WEIGHT 64 |
||
46 | |||
47 | /* MDIO Defines */ |
||
48 | #define MDIO_CMD_COMPLETE 0x00008000 |
||
49 | #define MDIO_WRITE_COMMAND 0x00002000 |
||
50 | #define MDIO_READ_COMMAND 0x00004000 |
||
51 | #define MDIO_REG_OFFSET 8 |
||
52 | #define MDIO_VALUE_OFFSET 16 |
||
53 | |||
54 | /* Descritor Defines */ |
||
55 | #define END_OF_RING 0x40000000 |
||
56 | #define FIRST_SEGMENT 0x20000000 |
||
57 | #define LAST_SEGMENT 0x10000000 |
||
58 | #define FORCE_ROUTE 0x04000000 |
||
59 | #define UDP_CHECKSUM 0x00020000 |
||
60 | #define TCP_CHECKSUM 0x00010000 |
||
61 | |||
62 | /* Port Config Defines */ |
||
63 | #define PORT_BP_ENABLE 0x00020000 |
||
64 | #define PORT_DISABLE 0x00040000 |
||
65 | #define PORT_LEARN_DIS 0x00080000 |
||
66 | #define PORT_BLOCK_STATE 0x00100000 |
||
67 | #define PORT_BLOCK_MODE 0x00200000 |
||
68 | |||
69 | #define PROMISC_OFFSET 29 |
||
70 | |||
71 | /* Global Config Defines */ |
||
72 | #define UNKNOWN_VLAN_TO_CPU 0x02000000 |
||
73 | #define ACCEPT_CRC_PACKET 0x00200000 |
||
74 | #define CRC_STRIPPING 0x00100000 |
||
75 | |||
76 | /* VLAN Config Defines */ |
||
77 | #define NIC_MODE 0x00008000 |
||
78 | #define VLAN_UNAWARE 0x00000001 |
||
79 | |||
80 | /* DMA AUTO Poll Defines */ |
||
81 | #define TS_POLL_EN 0x00000020 |
||
82 | #define TS_SUSPEND 0x00000010 |
||
83 | #define FS_POLL_EN 0x00000002 |
||
84 | #define FS_SUSPEND 0x00000001 |
||
85 | |||
86 | /* DMA Ring Control Defines */ |
||
87 | #define QUEUE_THRESHOLD 0x000000f0 |
||
88 | #define CLR_FS_STATE 0x80000000 |
||
89 | |||
90 | /* Interrupt Status Defines */ |
||
91 | #define MAC0_STATUS_CHANGE 0x00004000 |
||
92 | #define MAC1_STATUS_CHANGE 0x00008000 |
||
93 | #define MAC2_STATUS_CHANGE 0x00010000 |
||
94 | #define MAC0_RX_ERROR 0x00100000 |
||
95 | #define MAC1_RX_ERROR 0x00200000 |
||
96 | #define MAC2_RX_ERROR 0x00400000 |
||
97 | |||
98 | struct tx_desc |
||
99 | { |
||
100 | u32 sdp; /* segment data pointer */ |
||
101 | |||
102 | union { |
||
103 | struct { |
||
104 | u32 sdl:16; /* segment data length */ |
||
105 | u32 tco:1; |
||
106 | u32 uco:1; |
||
107 | u32 ico:1; |
||
108 | u32 rsv_1:3; /* reserve */ |
||
109 | u32 pri:3; |
||
110 | u32 fp:1; /* force priority */ |
||
111 | u32 fr:1; |
||
112 | u32 interrupt:1; |
||
113 | u32 lsd:1; |
||
114 | u32 fsd:1; |
||
115 | u32 eor:1; |
||
116 | u32 cown:1; |
||
117 | }; |
||
118 | u32 config0; |
||
119 | }; |
||
120 | |||
121 | union { |
||
122 | struct { |
||
123 | u32 ctv:1; |
||
124 | u32 stv:1; |
||
125 | u32 sid:4; |
||
126 | u32 inss:1; |
||
127 | u32 dels:1; |
||
128 | u32 rsv_2:9; |
||
129 | u32 pmap:5; |
||
130 | u32 mark:3; |
||
131 | u32 ewan:1; |
||
132 | u32 fewan:1; |
||
133 | u32 rsv_3:5; |
||
134 | }; |
||
135 | u32 config1; |
||
136 | }; |
||
137 | |||
138 | union { |
||
139 | struct { |
||
140 | u32 c_vid:12; |
||
141 | u32 c_cfs:1; |
||
142 | u32 c_pri:3; |
||
143 | u32 s_vid:12; |
||
144 | u32 s_dei:1; |
||
145 | u32 s_pri:3; |
||
146 | }; |
||
147 | u32 config2; |
||
148 | }; |
||
149 | |||
150 | u8 alignment[16]; /* for 32 byte */ |
||
151 | }; |
||
152 | |||
153 | struct rx_desc |
||
154 | { |
||
155 | u32 sdp; /* segment data pointer */ |
||
156 | |||
157 | union { |
||
158 | struct { |
||
159 | u32 sdl:16; /* segment data length */ |
||
160 | u32 l4f:1; |
||
161 | u32 ipf:1; |
||
162 | u32 prot:4; |
||
163 | u32 hr:6; |
||
164 | u32 lsd:1; |
||
165 | u32 fsd:1; |
||
166 | u32 eor:1; |
||
167 | u32 cown:1; |
||
168 | }; |
||
169 | u32 config0; |
||
170 | }; |
||
171 | |||
172 | union { |
||
173 | struct { |
||
174 | u32 ctv:1; |
||
175 | u32 stv:1; |
||
176 | u32 unv:1; |
||
177 | u32 iwan:1; |
||
178 | u32 exdv:1; |
||
179 | u32 e_wan:1; |
||
180 | u32 rsv_1:2; |
||
181 | u32 sp:3; |
||
182 | u32 crc_err:1; |
||
183 | u32 un_eth:1; |
||
184 | u32 tc:2; |
||
185 | u32 rsv_2:1; |
||
186 | u32 ip_offset:5; |
||
187 | u32 rsv_3:11; |
||
188 | }; |
||
189 | u32 config1; |
||
190 | }; |
||
191 | |||
192 | union { |
||
193 | struct { |
||
194 | u32 c_vid:12; |
||
195 | u32 c_cfs:1; |
||
196 | u32 c_pri:3; |
||
197 | u32 s_vid:12; |
||
198 | u32 s_dei:1; |
||
199 | u32 s_pri:3; |
||
200 | }; |
||
201 | u32 config2; |
||
202 | }; |
||
203 | |||
204 | u8 alignment[16]; /* for 32 byte alignment */ |
||
205 | }; |
||
206 | |||
207 | |||
208 | struct switch_regs { |
||
209 | u32 phy_control; |
||
210 | u32 phy_auto_addr; |
||
211 | u32 mac_glob_cfg; |
||
212 | u32 mac_cfg[4]; |
||
213 | u32 mac_pri_ctrl[5], __res; |
||
214 | u32 etype[2]; |
||
215 | u32 udp_range[4]; |
||
216 | u32 prio_etype_udp; |
||
217 | u32 prio_ipdscp[8]; |
||
218 | u32 tc_ctrl; |
||
219 | u32 rate_ctrl; |
||
220 | u32 fc_glob_thrs; |
||
221 | u32 fc_port_thrs; |
||
222 | u32 mc_fc_glob_thrs; |
||
223 | u32 dc_glob_thrs; |
||
224 | u32 arl_vlan_cmd; |
||
225 | u32 arl_ctrl[3]; |
||
226 | u32 vlan_cfg; |
||
227 | u32 pvid[2]; |
||
228 | u32 vlan_ctrl[3]; |
||
229 | u32 session_id[8]; |
||
230 | u32 intr_stat; |
||
231 | u32 intr_mask; |
||
232 | u32 sram_test; |
||
233 | u32 mem_queue; |
||
234 | u32 farl_ctrl; |
||
235 | u32 fc_input_thrs, __res1[2]; |
||
236 | u32 clk_skew_ctrl; |
||
237 | u32 mac_glob_cfg_ext, __res2[2]; |
||
238 | u32 dma_ring_ctrl; |
||
239 | u32 dma_auto_poll_cfg; |
||
240 | u32 delay_intr_cfg, __res3; |
||
241 | u32 ts_dma_ctrl0; |
||
242 | u32 ts_desc_ptr0; |
||
243 | u32 ts_desc_base_addr0, __res4; |
||
244 | u32 fs_dma_ctrl0; |
||
245 | u32 fs_desc_ptr0; |
||
246 | u32 fs_desc_base_addr0, __res5; |
||
247 | u32 ts_dma_ctrl1; |
||
248 | u32 ts_desc_ptr1; |
||
249 | u32 ts_desc_base_addr1, __res6; |
||
250 | u32 fs_dma_ctrl1; |
||
251 | u32 fs_desc_ptr1; |
||
252 | u32 fs_desc_base_addr1; |
||
253 | u32 __res7[109]; |
||
254 | u32 mac_counter0[13]; |
||
255 | }; |
||
256 | |||
257 | struct _tx_ring { |
||
258 | struct tx_desc *desc; |
||
259 | dma_addr_t phys_addr; |
||
260 | struct tx_desc *cur_addr; |
||
261 | struct sk_buff *buff_tab[TX_DESCS]; |
||
262 | unsigned int phys_tab[TX_DESCS]; |
||
263 | u32 free_index; |
||
264 | u32 count_index; |
||
265 | u32 cur_index; |
||
266 | int num_used; |
||
267 | int num_count; |
||
268 | bool stopped; |
||
269 | }; |
||
270 | |||
271 | struct _rx_ring { |
||
272 | struct rx_desc *desc; |
||
273 | dma_addr_t phys_addr; |
||
274 | struct rx_desc *cur_addr; |
||
275 | void *buff_tab[RX_DESCS]; |
||
276 | unsigned int phys_tab[RX_DESCS]; |
||
277 | u32 cur_index; |
||
278 | u32 alloc_index; |
||
279 | int alloc_count; |
||
280 | }; |
||
281 | |||
282 | struct sw { |
||
283 | struct switch_regs __iomem *regs; |
||
284 | struct napi_struct napi; |
||
285 | struct cns3xxx_plat_info *plat; |
||
286 | struct _tx_ring tx_ring; |
||
287 | struct _rx_ring rx_ring; |
||
288 | struct sk_buff *frag_first; |
||
289 | struct sk_buff *frag_last; |
||
290 | struct device *dev; |
||
291 | int rx_irq; |
||
292 | int stat_irq; |
||
293 | }; |
||
294 | |||
295 | struct port { |
||
296 | struct net_device *netdev; |
||
297 | struct phy_device *phydev; |
||
298 | struct sw *sw; |
||
299 | int id; /* logical port ID */ |
||
300 | int speed, duplex; |
||
301 | }; |
||
302 | |||
303 | static spinlock_t mdio_lock; |
||
304 | static DEFINE_SPINLOCK(tx_lock); |
||
305 | static struct switch_regs __iomem *mdio_regs; /* mdio command and status only */ |
||
306 | struct mii_bus *mdio_bus; |
||
307 | static int ports_open; |
||
308 | static struct port *switch_port_tab[4]; |
||
309 | struct net_device *napi_dev; |
||
310 | |||
311 | static int cns3xxx_mdio_cmd(struct mii_bus *bus, int phy_id, int location, |
||
312 | int write, u16 cmd) |
||
313 | { |
||
314 | int cycles = 0; |
||
315 | u32 temp = 0; |
||
316 | |||
317 | temp = __raw_readl(&mdio_regs->phy_control); |
||
318 | temp |= MDIO_CMD_COMPLETE; |
||
319 | __raw_writel(temp, &mdio_regs->phy_control); |
||
320 | udelay(10); |
||
321 | |||
322 | if (write) { |
||
323 | temp = (cmd << MDIO_VALUE_OFFSET); |
||
324 | temp |= MDIO_WRITE_COMMAND; |
||
325 | } else { |
||
326 | temp = MDIO_READ_COMMAND; |
||
327 | } |
||
328 | temp |= ((location & 0x1f) << MDIO_REG_OFFSET); |
||
329 | temp |= (phy_id & 0x1f); |
||
330 | |||
331 | __raw_writel(temp, &mdio_regs->phy_control); |
||
332 | |||
333 | while (((__raw_readl(&mdio_regs->phy_control) & MDIO_CMD_COMPLETE) == 0) |
||
334 | && cycles < 5000) { |
||
335 | udelay(1); |
||
336 | cycles++; |
||
337 | } |
||
338 | |||
339 | if (cycles == 5000) { |
||
3 | office | 340 | printk(KERN_ERR "%s #%i: MII transaction failed\n", bus->name, |
341 | phy_id); |
||
1 | office | 342 | return -1; |
343 | } |
||
344 | |||
345 | temp = __raw_readl(&mdio_regs->phy_control); |
||
346 | temp |= MDIO_CMD_COMPLETE; |
||
347 | __raw_writel(temp, &mdio_regs->phy_control); |
||
348 | |||
349 | if (write) |
||
350 | return 0; |
||
351 | |||
352 | return ((temp >> MDIO_VALUE_OFFSET) & 0xFFFF); |
||
353 | } |
||
354 | |||
355 | static int cns3xxx_mdio_read(struct mii_bus *bus, int phy_id, int location) |
||
356 | { |
||
357 | unsigned long flags; |
||
358 | int ret; |
||
359 | |||
360 | spin_lock_irqsave(&mdio_lock, flags); |
||
361 | ret = cns3xxx_mdio_cmd(bus, phy_id, location, 0, 0); |
||
362 | spin_unlock_irqrestore(&mdio_lock, flags); |
||
363 | return ret; |
||
364 | } |
||
365 | |||
3 | office | 366 | static int cns3xxx_mdio_write(struct mii_bus *bus, int phy_id, int location, |
367 | u16 val) |
||
1 | office | 368 | { |
369 | unsigned long flags; |
||
370 | int ret; |
||
371 | |||
372 | spin_lock_irqsave(&mdio_lock, flags); |
||
373 | ret = cns3xxx_mdio_cmd(bus, phy_id, location, 1, val); |
||
374 | spin_unlock_irqrestore(&mdio_lock, flags); |
||
375 | return ret; |
||
376 | } |
||
377 | |||
378 | static int cns3xxx_mdio_register(void __iomem *base) |
||
379 | { |
||
380 | int err; |
||
381 | |||
382 | if (!(mdio_bus = mdiobus_alloc())) |
||
383 | return -ENOMEM; |
||
384 | |||
385 | mdio_regs = base; |
||
386 | |||
387 | spin_lock_init(&mdio_lock); |
||
388 | mdio_bus->name = "CNS3xxx MII Bus"; |
||
389 | mdio_bus->read = &cns3xxx_mdio_read; |
||
390 | mdio_bus->write = &cns3xxx_mdio_write; |
||
391 | strcpy(mdio_bus->id, "0"); |
||
392 | |||
393 | if ((err = mdiobus_register(mdio_bus))) |
||
394 | mdiobus_free(mdio_bus); |
||
395 | return err; |
||
396 | } |
||
397 | |||
398 | static void cns3xxx_mdio_remove(void) |
||
399 | { |
||
400 | mdiobus_unregister(mdio_bus); |
||
401 | mdiobus_free(mdio_bus); |
||
402 | } |
||
403 | |||
404 | static void enable_tx_dma(struct sw *sw) |
||
405 | { |
||
406 | __raw_writel(0x1, &sw->regs->ts_dma_ctrl0); |
||
407 | } |
||
408 | |||
409 | static void enable_rx_dma(struct sw *sw) |
||
410 | { |
||
411 | __raw_writel(0x1, &sw->regs->fs_dma_ctrl0); |
||
412 | } |
||
413 | |||
414 | static void cns3xxx_adjust_link(struct net_device *dev) |
||
415 | { |
||
416 | struct port *port = netdev_priv(dev); |
||
417 | struct phy_device *phydev = port->phydev; |
||
418 | |||
419 | if (!phydev->link) { |
||
420 | if (port->speed) { |
||
421 | port->speed = 0; |
||
422 | printk(KERN_INFO "%s: link down\n", dev->name); |
||
423 | } |
||
424 | return; |
||
425 | } |
||
426 | |||
427 | if (port->speed == phydev->speed && port->duplex == phydev->duplex) |
||
428 | return; |
||
429 | |||
430 | port->speed = phydev->speed; |
||
431 | port->duplex = phydev->duplex; |
||
432 | |||
433 | printk(KERN_INFO "%s: link up, speed %u Mb/s, %s duplex\n", |
||
434 | dev->name, port->speed, port->duplex ? "full" : "half"); |
||
435 | } |
||
436 | |||
437 | static void eth_schedule_poll(struct sw *sw) |
||
438 | { |
||
439 | if (unlikely(!napi_schedule_prep(&sw->napi))) |
||
440 | return; |
||
441 | |||
442 | disable_irq_nosync(sw->rx_irq); |
||
443 | __napi_schedule(&sw->napi); |
||
444 | } |
||
445 | |||
446 | irqreturn_t eth_rx_irq(int irq, void *pdev) |
||
447 | { |
||
448 | struct net_device *dev = pdev; |
||
449 | struct sw *sw = netdev_priv(dev); |
||
450 | eth_schedule_poll(sw); |
||
451 | return (IRQ_HANDLED); |
||
452 | } |
||
453 | |||
454 | irqreturn_t eth_stat_irq(int irq, void *pdev) |
||
455 | { |
||
456 | struct net_device *dev = pdev; |
||
457 | struct sw *sw = netdev_priv(dev); |
||
458 | u32 cfg; |
||
459 | u32 stat = __raw_readl(&sw->regs->intr_stat); |
||
460 | __raw_writel(0xffffffff, &sw->regs->intr_stat); |
||
461 | |||
462 | if (stat & MAC2_RX_ERROR) |
||
463 | switch_port_tab[3]->netdev->stats.rx_dropped++; |
||
464 | if (stat & MAC1_RX_ERROR) |
||
465 | switch_port_tab[1]->netdev->stats.rx_dropped++; |
||
466 | if (stat & MAC0_RX_ERROR) |
||
467 | switch_port_tab[0]->netdev->stats.rx_dropped++; |
||
468 | |||
469 | if (stat & MAC0_STATUS_CHANGE) { |
||
470 | cfg = __raw_readl(&sw->regs->mac_cfg[0]); |
||
471 | switch_port_tab[0]->phydev->link = (cfg & 0x1); |
||
472 | switch_port_tab[0]->phydev->duplex = ((cfg >> 4) & 0x1); |
||
473 | if (((cfg >> 2) & 0x3) == 2) |
||
474 | switch_port_tab[0]->phydev->speed = 1000; |
||
475 | else if (((cfg >> 2) & 0x3) == 1) |
||
476 | switch_port_tab[0]->phydev->speed = 100; |
||
477 | else |
||
478 | switch_port_tab[0]->phydev->speed = 10; |
||
479 | cns3xxx_adjust_link(switch_port_tab[0]->netdev); |
||
480 | } |
||
481 | |||
482 | if (stat & MAC1_STATUS_CHANGE) { |
||
483 | cfg = __raw_readl(&sw->regs->mac_cfg[1]); |
||
484 | switch_port_tab[1]->phydev->link = (cfg & 0x1); |
||
485 | switch_port_tab[1]->phydev->duplex = ((cfg >> 4) & 0x1); |
||
486 | if (((cfg >> 2) & 0x3) == 2) |
||
487 | switch_port_tab[1]->phydev->speed = 1000; |
||
488 | else if (((cfg >> 2) & 0x3) == 1) |
||
489 | switch_port_tab[1]->phydev->speed = 100; |
||
490 | else |
||
491 | switch_port_tab[1]->phydev->speed = 10; |
||
492 | cns3xxx_adjust_link(switch_port_tab[1]->netdev); |
||
493 | } |
||
494 | |||
495 | if (stat & MAC2_STATUS_CHANGE) { |
||
496 | cfg = __raw_readl(&sw->regs->mac_cfg[3]); |
||
497 | switch_port_tab[3]->phydev->link = (cfg & 0x1); |
||
498 | switch_port_tab[3]->phydev->duplex = ((cfg >> 4) & 0x1); |
||
499 | if (((cfg >> 2) & 0x3) == 2) |
||
500 | switch_port_tab[3]->phydev->speed = 1000; |
||
501 | else if (((cfg >> 2) & 0x3) == 1) |
||
502 | switch_port_tab[3]->phydev->speed = 100; |
||
503 | else |
||
504 | switch_port_tab[3]->phydev->speed = 10; |
||
505 | cns3xxx_adjust_link(switch_port_tab[3]->netdev); |
||
506 | } |
||
507 | |||
508 | return (IRQ_HANDLED); |
||
509 | } |
||
510 | |||
511 | |||
512 | static void cns3xxx_alloc_rx_buf(struct sw *sw, int received) |
||
513 | { |
||
514 | struct _rx_ring *rx_ring = &sw->rx_ring; |
||
515 | unsigned int i = rx_ring->alloc_index; |
||
516 | struct rx_desc *desc = &(rx_ring)->desc[i]; |
||
517 | void *buf; |
||
518 | unsigned int phys; |
||
519 | |||
520 | for (received += rx_ring->alloc_count; received > 0; received--) { |
||
521 | buf = napi_alloc_frag(RX_SEGMENT_ALLOC_SIZE); |
||
522 | if (!buf) |
||
523 | break; |
||
524 | |||
525 | phys = dma_map_single(sw->dev, buf + SKB_HEAD_ALIGN, |
||
526 | RX_SEGMENT_MRU, DMA_FROM_DEVICE); |
||
527 | if (dma_mapping_error(sw->dev, phys)) { |
||
528 | skb_free_frag(buf); |
||
529 | break; |
||
530 | } |
||
531 | |||
532 | desc->sdl = RX_SEGMENT_MRU; |
||
533 | desc->sdp = phys; |
||
534 | |||
535 | wmb(); |
||
536 | |||
537 | /* put the new buffer on RX-free queue */ |
||
538 | rx_ring->buff_tab[i] = buf; |
||
539 | rx_ring->phys_tab[i] = phys; |
||
540 | if (i == RX_DESCS - 1) { |
||
541 | i = 0; |
||
3 | office | 542 | desc->config0 = END_OF_RING | FIRST_SEGMENT | |
543 | LAST_SEGMENT | RX_SEGMENT_MRU; |
||
1 | office | 544 | desc = &(rx_ring)->desc[i]; |
545 | } else { |
||
3 | office | 546 | desc->config0 = FIRST_SEGMENT | LAST_SEGMENT | |
547 | RX_SEGMENT_MRU; |
||
1 | office | 548 | i++; |
549 | desc++; |
||
550 | } |
||
551 | } |
||
552 | |||
553 | rx_ring->alloc_count = received; |
||
554 | rx_ring->alloc_index = i; |
||
555 | } |
||
556 | |||
557 | static void eth_check_num_used(struct _tx_ring *tx_ring) |
||
558 | { |
||
559 | bool stop = false; |
||
560 | int i; |
||
561 | |||
562 | if (tx_ring->num_used >= TX_DESCS - TX_DESC_RESERVE) |
||
563 | stop = true; |
||
564 | |||
565 | if (tx_ring->stopped == stop) |
||
566 | return; |
||
567 | |||
568 | tx_ring->stopped = stop; |
||
569 | for (i = 0; i < 4; i++) { |
||
570 | struct port *port = switch_port_tab[i]; |
||
571 | struct net_device *dev; |
||
572 | |||
573 | if (!port) |
||
574 | continue; |
||
575 | |||
576 | dev = port->netdev; |
||
577 | if (stop) |
||
578 | netif_stop_queue(dev); |
||
579 | else |
||
580 | netif_wake_queue(dev); |
||
581 | } |
||
582 | } |
||
583 | |||
584 | static void eth_complete_tx(struct sw *sw) |
||
585 | { |
||
586 | struct _tx_ring *tx_ring = &sw->tx_ring; |
||
587 | struct tx_desc *desc; |
||
588 | int i; |
||
589 | int index; |
||
590 | int num_used = tx_ring->num_used; |
||
591 | struct sk_buff *skb; |
||
592 | |||
593 | index = tx_ring->free_index; |
||
594 | desc = &(tx_ring)->desc[index]; |
||
595 | for (i = 0; i < num_used; i++) { |
||
3 | office | 596 | if (desc->cown) { |
597 | skb = tx_ring->buff_tab[index]; |
||
598 | tx_ring->buff_tab[index] = 0; |
||
599 | if (skb) |
||
600 | dev_kfree_skb_any(skb); |
||
601 | dma_unmap_single(sw->dev, tx_ring->phys_tab[index], |
||
602 | desc->sdl, DMA_TO_DEVICE); |
||
603 | if (++index == TX_DESCS) { |
||
604 | index = 0; |
||
605 | desc = &(tx_ring)->desc[index]; |
||
606 | } else { |
||
607 | desc++; |
||
608 | } |
||
609 | } else { |
||
1 | office | 610 | break; |
611 | } |
||
612 | } |
||
613 | tx_ring->free_index = index; |
||
614 | tx_ring->num_used -= i; |
||
615 | eth_check_num_used(tx_ring); |
||
616 | } |
||
617 | |||
618 | static int eth_poll(struct napi_struct *napi, int budget) |
||
619 | { |
||
620 | struct sw *sw = container_of(napi, struct sw, napi); |
||
621 | struct _rx_ring *rx_ring = &sw->rx_ring; |
||
622 | int received = 0; |
||
623 | unsigned int length; |
||
624 | unsigned int i = rx_ring->cur_index; |
||
625 | struct rx_desc *desc = &(rx_ring)->desc[i]; |
||
626 | unsigned int alloc_count = rx_ring->alloc_count; |
||
627 | |||
628 | while (desc->cown && alloc_count + received < RX_DESCS - 1) { |
||
629 | struct sk_buff *skb; |
||
630 | int reserve = SKB_HEAD_ALIGN; |
||
631 | |||
632 | if (received >= budget) |
||
633 | break; |
||
634 | |||
635 | /* process received frame */ |
||
3 | office | 636 | dma_unmap_single(sw->dev, rx_ring->phys_tab[i], |
637 | RX_SEGMENT_MRU, DMA_FROM_DEVICE); |
||
1 | office | 638 | |
639 | skb = build_skb(rx_ring->buff_tab[i], RX_SEGMENT_ALLOC_SIZE); |
||
640 | if (!skb) |
||
641 | break; |
||
642 | |||
643 | skb->dev = switch_port_tab[desc->sp]->netdev; |
||
644 | |||
645 | length = desc->sdl; |
||
646 | if (desc->fsd && !desc->lsd) |
||
647 | length = RX_SEGMENT_MRU; |
||
648 | |||
649 | if (!desc->fsd) { |
||
650 | reserve -= NET_IP_ALIGN; |
||
651 | if (!desc->lsd) |
||
652 | length += NET_IP_ALIGN; |
||
653 | } |
||
654 | |||
655 | skb_reserve(skb, reserve); |
||
656 | skb_put(skb, length); |
||
657 | |||
658 | if (!sw->frag_first) |
||
659 | sw->frag_first = skb; |
||
660 | else { |
||
661 | if (sw->frag_first == sw->frag_last) |
||
662 | skb_shinfo(sw->frag_first)->frag_list = skb; |
||
663 | else |
||
664 | sw->frag_last->next = skb; |
||
665 | sw->frag_first->len += skb->len; |
||
666 | sw->frag_first->data_len += skb->len; |
||
667 | sw->frag_first->truesize += skb->truesize; |
||
668 | } |
||
669 | sw->frag_last = skb; |
||
670 | |||
671 | if (desc->lsd) { |
||
672 | struct net_device *dev; |
||
673 | |||
674 | skb = sw->frag_first; |
||
675 | dev = skb->dev; |
||
676 | skb->protocol = eth_type_trans(skb, dev); |
||
677 | |||
678 | dev->stats.rx_packets++; |
||
679 | dev->stats.rx_bytes += skb->len; |
||
680 | |||
681 | /* RX Hardware checksum offload */ |
||
682 | skb->ip_summed = CHECKSUM_NONE; |
||
683 | switch (desc->prot) { |
||
684 | case 1: |
||
685 | case 2: |
||
686 | case 5: |
||
687 | case 6: |
||
688 | case 13: |
||
689 | case 14: |
||
690 | if (!desc->l4f) { |
||
691 | skb->ip_summed = CHECKSUM_UNNECESSARY; |
||
692 | napi_gro_receive(napi, skb); |
||
693 | break; |
||
694 | } |
||
695 | /* fall through */ |
||
696 | default: |
||
697 | netif_receive_skb(skb); |
||
698 | break; |
||
699 | } |
||
700 | |||
701 | sw->frag_first = NULL; |
||
702 | sw->frag_last = NULL; |
||
703 | } |
||
704 | |||
705 | received++; |
||
3 | office | 706 | if (++i == RX_DESCS) { |
1 | office | 707 | i = 0; |
708 | desc = &(rx_ring)->desc[i]; |
||
709 | } else { |
||
710 | desc++; |
||
711 | } |
||
712 | } |
||
713 | |||
714 | rx_ring->cur_index = i; |
||
715 | |||
716 | cns3xxx_alloc_rx_buf(sw, received); |
||
717 | wmb(); |
||
718 | enable_rx_dma(sw); |
||
719 | |||
720 | if (received < budget && napi_complete_done(napi, received)) { |
||
721 | enable_irq(sw->rx_irq); |
||
722 | } |
||
723 | |||
724 | spin_lock_bh(&tx_lock); |
||
725 | eth_complete_tx(sw); |
||
726 | spin_unlock_bh(&tx_lock); |
||
727 | |||
728 | return received; |
||
729 | } |
||
730 | |||
731 | static void eth_set_desc(struct sw *sw, struct _tx_ring *tx_ring, int index, |
||
732 | int index_last, void *data, int len, u32 config0, |
||
733 | u32 pmap) |
||
734 | { |
||
735 | struct tx_desc *tx_desc = &(tx_ring)->desc[index]; |
||
736 | unsigned int phys; |
||
737 | |||
738 | phys = dma_map_single(sw->dev, data, len, DMA_TO_DEVICE); |
||
739 | tx_desc->sdp = phys; |
||
740 | tx_desc->pmap = pmap; |
||
741 | tx_ring->phys_tab[index] = phys; |
||
742 | |||
743 | config0 |= len; |
||
744 | if (index == TX_DESCS - 1) |
||
745 | config0 |= END_OF_RING; |
||
746 | if (index == index_last) |
||
747 | config0 |= LAST_SEGMENT; |
||
748 | |||
749 | wmb(); |
||
750 | tx_desc->config0 = config0; |
||
751 | } |
||
752 | |||
753 | static int eth_xmit(struct sk_buff *skb, struct net_device *dev) |
||
754 | { |
||
755 | struct port *port = netdev_priv(dev); |
||
756 | struct sw *sw = port->sw; |
||
757 | struct _tx_ring *tx_ring = &sw->tx_ring; |
||
758 | struct sk_buff *skb1; |
||
759 | char pmap = (1 << port->id); |
||
760 | int nr_frags = skb_shinfo(skb)->nr_frags; |
||
761 | int nr_desc = nr_frags; |
||
762 | int index0, index, index_last; |
||
763 | int len0; |
||
3 | office | 764 | unsigned int i; |
1 | office | 765 | u32 config0; |
766 | |||
767 | if (pmap == 8) |
||
768 | pmap = (1 << 4); |
||
769 | |||
770 | skb_walk_frags(skb, skb1) |
||
771 | nr_desc++; |
||
772 | |||
773 | eth_schedule_poll(sw); |
||
774 | spin_lock_bh(&tx_lock); |
||
775 | if ((tx_ring->num_used + nr_desc + 1) >= TX_DESCS) { |
||
776 | spin_unlock_bh(&tx_lock); |
||
777 | return NETDEV_TX_BUSY; |
||
778 | } |
||
779 | |||
780 | index = index0 = tx_ring->cur_index; |
||
781 | index_last = (index0 + nr_desc) % TX_DESCS; |
||
782 | tx_ring->cur_index = (index_last + 1) % TX_DESCS; |
||
783 | |||
784 | spin_unlock_bh(&tx_lock); |
||
785 | |||
786 | config0 = FORCE_ROUTE; |
||
787 | if (skb->ip_summed == CHECKSUM_PARTIAL) |
||
788 | config0 |= UDP_CHECKSUM | TCP_CHECKSUM; |
||
789 | |||
790 | len0 = skb->len; |
||
791 | |||
792 | /* fragments */ |
||
793 | for (i = 0; i < nr_frags; i++) { |
||
794 | struct skb_frag_struct *frag; |
||
795 | void *addr; |
||
796 | |||
797 | index = (index + 1) % TX_DESCS; |
||
798 | |||
799 | frag = &skb_shinfo(skb)->frags[i]; |
||
800 | addr = page_address(skb_frag_page(frag)) + frag->page_offset; |
||
801 | |||
802 | eth_set_desc(sw, tx_ring, index, index_last, addr, frag->size, |
||
803 | config0, pmap); |
||
804 | } |
||
805 | |||
806 | if (nr_frags) |
||
807 | len0 = skb->len - skb->data_len; |
||
808 | |||
809 | skb_walk_frags(skb, skb1) { |
||
810 | index = (index + 1) % TX_DESCS; |
||
811 | len0 -= skb1->len; |
||
812 | |||
813 | eth_set_desc(sw, tx_ring, index, index_last, skb1->data, |
||
814 | skb1->len, config0, pmap); |
||
815 | } |
||
816 | |||
817 | tx_ring->buff_tab[index0] = skb; |
||
818 | eth_set_desc(sw, tx_ring, index0, index_last, skb->data, len0, |
||
819 | config0 | FIRST_SEGMENT, pmap); |
||
820 | |||
821 | wmb(); |
||
822 | |||
823 | spin_lock(&tx_lock); |
||
824 | tx_ring->num_used += nr_desc + 1; |
||
825 | spin_unlock(&tx_lock); |
||
826 | |||
827 | dev->stats.tx_packets++; |
||
828 | dev->stats.tx_bytes += skb->len; |
||
829 | |||
830 | enable_tx_dma(sw); |
||
831 | |||
832 | return NETDEV_TX_OK; |
||
833 | } |
||
834 | |||
835 | static int eth_ioctl(struct net_device *dev, struct ifreq *req, int cmd) |
||
836 | { |
||
837 | struct port *port = netdev_priv(dev); |
||
838 | |||
839 | if (!netif_running(dev)) |
||
840 | return -EINVAL; |
||
841 | return phy_mii_ioctl(port->phydev, req, cmd); |
||
842 | } |
||
843 | |||
844 | /* ethtool support */ |
||
845 | |||
846 | static void cns3xxx_get_drvinfo(struct net_device *dev, |
||
847 | struct ethtool_drvinfo *info) |
||
848 | { |
||
849 | strcpy(info->driver, DRV_NAME); |
||
850 | strcpy(info->bus_info, "internal"); |
||
851 | } |
||
852 | |||
853 | static int cns3xxx_nway_reset(struct net_device *dev) |
||
854 | { |
||
855 | struct port *port = netdev_priv(dev); |
||
856 | return phy_start_aneg(port->phydev); |
||
857 | } |
||
858 | |||
859 | static struct ethtool_ops cns3xxx_ethtool_ops = { |
||
860 | .get_drvinfo = cns3xxx_get_drvinfo, |
||
861 | .get_link_ksettings = phy_ethtool_get_link_ksettings, |
||
862 | .set_link_ksettings = phy_ethtool_set_link_ksettings, |
||
863 | .nway_reset = cns3xxx_nway_reset, |
||
864 | .get_link = ethtool_op_get_link, |
||
865 | }; |
||
866 | |||
867 | |||
868 | static int init_rings(struct sw *sw) |
||
869 | { |
||
870 | int i; |
||
871 | struct _rx_ring *rx_ring = &sw->rx_ring; |
||
872 | struct _tx_ring *tx_ring = &sw->tx_ring; |
||
873 | |||
874 | __raw_writel(0, &sw->regs->fs_dma_ctrl0); |
||
875 | __raw_writel(TS_SUSPEND | FS_SUSPEND, &sw->regs->dma_auto_poll_cfg); |
||
876 | __raw_writel(QUEUE_THRESHOLD, &sw->regs->dma_ring_ctrl); |
||
877 | __raw_writel(CLR_FS_STATE | QUEUE_THRESHOLD, &sw->regs->dma_ring_ctrl); |
||
3 | office | 878 | |
1 | office | 879 | __raw_writel(QUEUE_THRESHOLD, &sw->regs->dma_ring_ctrl); |
880 | |||
881 | rx_ring->desc = dmam_alloc_coherent(sw->dev, RX_POOL_ALLOC_SIZE, |
||
882 | &rx_ring->phys_addr, GFP_KERNEL); |
||
883 | if (!rx_ring->desc) |
||
884 | return -ENOMEM; |
||
885 | |||
886 | /* Setup RX buffers */ |
||
887 | memset(rx_ring->desc, 0, RX_POOL_ALLOC_SIZE); |
||
888 | for (i = 0; i < RX_DESCS; i++) { |
||
889 | struct rx_desc *desc = &(rx_ring)->desc[i]; |
||
890 | void *buf; |
||
891 | |||
892 | buf = netdev_alloc_frag(RX_SEGMENT_ALLOC_SIZE); |
||
893 | if (!buf) |
||
894 | return -ENOMEM; |
||
895 | |||
896 | desc->sdl = RX_SEGMENT_MRU; |
||
897 | if (i == (RX_DESCS - 1)) |
||
898 | desc->eor = 1; |
||
899 | desc->fsd = 1; |
||
900 | desc->lsd = 1; |
||
901 | |||
902 | desc->sdp = dma_map_single(sw->dev, buf + SKB_HEAD_ALIGN, |
||
903 | RX_SEGMENT_MRU, DMA_FROM_DEVICE); |
||
904 | if (dma_mapping_error(sw->dev, desc->sdp)) |
||
905 | return -EIO; |
||
906 | |||
907 | rx_ring->buff_tab[i] = buf; |
||
908 | rx_ring->phys_tab[i] = desc->sdp; |
||
909 | desc->cown = 0; |
||
910 | } |
||
911 | __raw_writel(rx_ring->phys_addr, &sw->regs->fs_desc_ptr0); |
||
912 | __raw_writel(rx_ring->phys_addr, &sw->regs->fs_desc_base_addr0); |
||
913 | |||
914 | tx_ring->desc = dmam_alloc_coherent(sw->dev, TX_POOL_ALLOC_SIZE, |
||
915 | &tx_ring->phys_addr, GFP_KERNEL); |
||
916 | if (!tx_ring->desc) |
||
917 | return -ENOMEM; |
||
918 | |||
919 | /* Setup TX buffers */ |
||
920 | memset(tx_ring->desc, 0, TX_POOL_ALLOC_SIZE); |
||
921 | for (i = 0; i < TX_DESCS; i++) { |
||
922 | struct tx_desc *desc = &(tx_ring)->desc[i]; |
||
923 | tx_ring->buff_tab[i] = 0; |
||
924 | |||
925 | if (i == (TX_DESCS - 1)) |
||
926 | desc->eor = 1; |
||
927 | desc->cown = 1; |
||
928 | } |
||
929 | __raw_writel(tx_ring->phys_addr, &sw->regs->ts_desc_ptr0); |
||
930 | __raw_writel(tx_ring->phys_addr, &sw->regs->ts_desc_base_addr0); |
||
931 | |||
932 | return 0; |
||
933 | } |
||
934 | |||
935 | static void destroy_rings(struct sw *sw) |
||
936 | { |
||
937 | int i; |
||
938 | |||
939 | for (i = 0; i < RX_DESCS; i++) { |
||
940 | struct _rx_ring *rx_ring = &sw->rx_ring; |
||
941 | struct rx_desc *desc = &(rx_ring)->desc[i]; |
||
942 | void *buf = sw->rx_ring.buff_tab[i]; |
||
943 | |||
944 | if (!buf) |
||
945 | continue; |
||
946 | |||
3 | office | 947 | dma_unmap_single(sw->dev, desc->sdp, RX_SEGMENT_MRU, |
948 | DMA_FROM_DEVICE); |
||
1 | office | 949 | skb_free_frag(buf); |
950 | } |
||
951 | |||
952 | for (i = 0; i < TX_DESCS; i++) { |
||
953 | struct _tx_ring *tx_ring = &sw->tx_ring; |
||
954 | struct tx_desc *desc = &(tx_ring)->desc[i]; |
||
955 | struct sk_buff *skb = sw->tx_ring.buff_tab[i]; |
||
956 | |||
957 | if (!skb) |
||
958 | continue; |
||
959 | |||
960 | dma_unmap_single(sw->dev, desc->sdp, skb->len, DMA_TO_DEVICE); |
||
961 | dev_kfree_skb(skb); |
||
962 | } |
||
963 | } |
||
964 | |||
965 | static int eth_open(struct net_device *dev) |
||
966 | { |
||
967 | struct port *port = netdev_priv(dev); |
||
968 | struct sw *sw = port->sw; |
||
969 | u32 temp; |
||
970 | |||
971 | port->speed = 0; /* force "link up" message */ |
||
972 | phy_start(port->phydev); |
||
973 | |||
974 | netif_start_queue(dev); |
||
975 | |||
976 | if (!ports_open) { |
||
977 | request_irq(sw->rx_irq, eth_rx_irq, IRQF_SHARED, "gig_switch", napi_dev); |
||
978 | request_irq(sw->stat_irq, eth_stat_irq, IRQF_SHARED, "gig_stat", napi_dev); |
||
979 | napi_enable(&sw->napi); |
||
980 | netif_start_queue(napi_dev); |
||
981 | |||
982 | __raw_writel(~(MAC0_STATUS_CHANGE | MAC1_STATUS_CHANGE | MAC2_STATUS_CHANGE | |
||
983 | MAC0_RX_ERROR | MAC1_RX_ERROR | MAC2_RX_ERROR), &sw->regs->intr_mask); |
||
984 | |||
985 | temp = __raw_readl(&sw->regs->mac_cfg[2]); |
||
986 | temp &= ~(PORT_DISABLE); |
||
987 | __raw_writel(temp, &sw->regs->mac_cfg[2]); |
||
988 | |||
989 | temp = __raw_readl(&sw->regs->dma_auto_poll_cfg); |
||
990 | temp &= ~(TS_SUSPEND | FS_SUSPEND); |
||
991 | __raw_writel(temp, &sw->regs->dma_auto_poll_cfg); |
||
992 | |||
993 | enable_rx_dma(sw); |
||
994 | } |
||
995 | temp = __raw_readl(&sw->regs->mac_cfg[port->id]); |
||
996 | temp &= ~(PORT_DISABLE); |
||
997 | __raw_writel(temp, &sw->regs->mac_cfg[port->id]); |
||
998 | |||
999 | ports_open++; |
||
1000 | netif_carrier_on(dev); |
||
1001 | |||
1002 | return 0; |
||
1003 | } |
||
1004 | |||
1005 | static int eth_close(struct net_device *dev) |
||
1006 | { |
||
1007 | struct port *port = netdev_priv(dev); |
||
1008 | struct sw *sw = port->sw; |
||
1009 | u32 temp; |
||
1010 | |||
1011 | ports_open--; |
||
1012 | |||
1013 | temp = __raw_readl(&sw->regs->mac_cfg[port->id]); |
||
1014 | temp |= (PORT_DISABLE); |
||
1015 | __raw_writel(temp, &sw->regs->mac_cfg[port->id]); |
||
1016 | |||
1017 | netif_stop_queue(dev); |
||
1018 | |||
1019 | phy_stop(port->phydev); |
||
1020 | |||
1021 | if (!ports_open) { |
||
1022 | disable_irq(sw->rx_irq); |
||
1023 | free_irq(sw->rx_irq, napi_dev); |
||
1024 | disable_irq(sw->stat_irq); |
||
1025 | free_irq(sw->stat_irq, napi_dev); |
||
1026 | napi_disable(&sw->napi); |
||
1027 | netif_stop_queue(napi_dev); |
||
1028 | temp = __raw_readl(&sw->regs->mac_cfg[2]); |
||
1029 | temp |= (PORT_DISABLE); |
||
1030 | __raw_writel(temp, &sw->regs->mac_cfg[2]); |
||
1031 | |||
1032 | __raw_writel(TS_SUSPEND | FS_SUSPEND, |
||
1033 | &sw->regs->dma_auto_poll_cfg); |
||
1034 | } |
||
1035 | |||
1036 | netif_carrier_off(dev); |
||
1037 | return 0; |
||
1038 | } |
||
1039 | |||
1040 | static void eth_rx_mode(struct net_device *dev) |
||
1041 | { |
||
1042 | struct port *port = netdev_priv(dev); |
||
1043 | struct sw *sw = port->sw; |
||
1044 | u32 temp; |
||
1045 | |||
1046 | temp = __raw_readl(&sw->regs->mac_glob_cfg); |
||
1047 | |||
1048 | if (dev->flags & IFF_PROMISC) { |
||
1049 | if (port->id == 3) |
||
1050 | temp |= ((1 << 2) << PROMISC_OFFSET); |
||
1051 | else |
||
1052 | temp |= ((1 << port->id) << PROMISC_OFFSET); |
||
1053 | } else { |
||
1054 | if (port->id == 3) |
||
1055 | temp &= ~((1 << 2) << PROMISC_OFFSET); |
||
1056 | else |
||
1057 | temp &= ~((1 << port->id) << PROMISC_OFFSET); |
||
1058 | } |
||
1059 | __raw_writel(temp, &sw->regs->mac_glob_cfg); |
||
1060 | } |
||
1061 | |||
1062 | static int eth_set_mac(struct net_device *netdev, void *p) |
||
1063 | { |
||
1064 | struct port *port = netdev_priv(netdev); |
||
1065 | struct sw *sw = port->sw; |
||
1066 | struct sockaddr *addr = p; |
||
1067 | u32 cycles = 0; |
||
1068 | |||
1069 | if (!is_valid_ether_addr(addr->sa_data)) |
||
1070 | return -EADDRNOTAVAIL; |
||
1071 | |||
1072 | /* Invalidate old ARL Entry */ |
||
1073 | if (port->id == 3) |
||
1074 | __raw_writel((port->id << 16) | (0x4 << 9), &sw->regs->arl_ctrl[0]); |
||
1075 | else |
||
1076 | __raw_writel(((port->id + 1) << 16) | (0x4 << 9), &sw->regs->arl_ctrl[0]); |
||
1077 | __raw_writel( ((netdev->dev_addr[0] << 24) | (netdev->dev_addr[1] << 16) | |
||
1078 | (netdev->dev_addr[2] << 8) | (netdev->dev_addr[3])), |
||
1079 | &sw->regs->arl_ctrl[1]); |
||
1080 | |||
1081 | __raw_writel( ((netdev->dev_addr[4] << 24) | (netdev->dev_addr[5] << 16) | |
||
1082 | (1 << 1)), |
||
1083 | &sw->regs->arl_ctrl[2]); |
||
1084 | __raw_writel((1 << 19), &sw->regs->arl_vlan_cmd); |
||
1085 | |||
1086 | while (((__raw_readl(&sw->regs->arl_vlan_cmd) & (1 << 21)) == 0) |
||
1087 | && cycles < 5000) { |
||
1088 | udelay(1); |
||
1089 | cycles++; |
||
1090 | } |
||
1091 | |||
1092 | cycles = 0; |
||
1093 | memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len); |
||
1094 | |||
1095 | if (port->id == 3) |
||
1096 | __raw_writel((port->id << 16) | (0x4 << 9), &sw->regs->arl_ctrl[0]); |
||
1097 | else |
||
1098 | __raw_writel(((port->id + 1) << 16) | (0x4 << 9), &sw->regs->arl_ctrl[0]); |
||
1099 | __raw_writel( ((addr->sa_data[0] << 24) | (addr->sa_data[1] << 16) | |
||
1100 | (addr->sa_data[2] << 8) | (addr->sa_data[3])), |
||
1101 | &sw->regs->arl_ctrl[1]); |
||
1102 | |||
1103 | __raw_writel( ((addr->sa_data[4] << 24) | (addr->sa_data[5] << 16) | |
||
1104 | (7 << 4) | (1 << 1)), &sw->regs->arl_ctrl[2]); |
||
1105 | __raw_writel((1 << 19), &sw->regs->arl_vlan_cmd); |
||
1106 | |||
1107 | while (((__raw_readl(&sw->regs->arl_vlan_cmd) & (1 << 21)) == 0) |
||
1108 | && cycles < 5000) { |
||
1109 | udelay(1); |
||
1110 | cycles++; |
||
1111 | } |
||
1112 | return 0; |
||
1113 | } |
||
1114 | |||
3 | office | 1115 | static int cns3xxx_change_mtu(struct net_device *dev, int new_mtu) |
1116 | { |
||
1117 | if (new_mtu > MAX_MTU) |
||
1118 | return -EINVAL; |
||
1119 | |||
1120 | dev->mtu = new_mtu; |
||
1121 | return 0; |
||
1122 | } |
||
1123 | |||
1 | office | 1124 | static const struct net_device_ops cns3xxx_netdev_ops = { |
1125 | .ndo_open = eth_open, |
||
1126 | .ndo_stop = eth_close, |
||
1127 | .ndo_start_xmit = eth_xmit, |
||
1128 | .ndo_set_rx_mode = eth_rx_mode, |
||
1129 | .ndo_do_ioctl = eth_ioctl, |
||
3 | office | 1130 | .ndo_change_mtu = cns3xxx_change_mtu, |
1 | office | 1131 | .ndo_set_mac_address = eth_set_mac, |
1132 | .ndo_validate_addr = eth_validate_addr, |
||
1133 | }; |
||
1134 | |||
1135 | static int eth_init_one(struct platform_device *pdev) |
||
1136 | { |
||
1137 | int i; |
||
1138 | struct port *port; |
||
1139 | struct sw *sw; |
||
1140 | struct net_device *dev; |
||
1141 | struct cns3xxx_plat_info *plat = pdev->dev.platform_data; |
||
1142 | char phy_id[MII_BUS_ID_SIZE + 3]; |
||
1143 | int err; |
||
1144 | u32 temp; |
||
1145 | struct resource *res; |
||
1146 | void __iomem *regs; |
||
1147 | |||
1148 | res = platform_get_resource(pdev, IORESOURCE_MEM, 0); |
||
1149 | regs = devm_ioremap_resource(&pdev->dev, res); |
||
1150 | if (IS_ERR(regs)) |
||
1151 | return PTR_ERR(regs); |
||
1152 | |||
1153 | err = cns3xxx_mdio_register(regs); |
||
1154 | if (err) |
||
1155 | return err; |
||
1156 | |||
1157 | if (!(napi_dev = alloc_etherdev(sizeof(struct sw)))) { |
||
1158 | err = -ENOMEM; |
||
1159 | goto err_remove_mdio; |
||
1160 | } |
||
1161 | |||
1162 | strcpy(napi_dev->name, "cns3xxx_eth"); |
||
1163 | napi_dev->features = NETIF_F_IP_CSUM | NETIF_F_SG | NETIF_F_FRAGLIST; |
||
1164 | |||
1165 | SET_NETDEV_DEV(napi_dev, &pdev->dev); |
||
1166 | sw = netdev_priv(napi_dev); |
||
1167 | memset(sw, 0, sizeof(struct sw)); |
||
1168 | sw->regs = regs; |
||
1169 | sw->dev = &pdev->dev; |
||
1170 | |||
1171 | sw->rx_irq = platform_get_irq_byname(pdev, "eth_rx"); |
||
1172 | sw->stat_irq = platform_get_irq_byname(pdev, "eth_stat"); |
||
1173 | |||
1174 | temp = __raw_readl(&sw->regs->phy_auto_addr); |
||
1175 | temp |= (3 << 30); /* maximum frame length: 9600 bytes */ |
||
1176 | __raw_writel(temp, &sw->regs->phy_auto_addr); |
||
1177 | |||
1178 | for (i = 0; i < 4; i++) { |
||
1179 | temp = __raw_readl(&sw->regs->mac_cfg[i]); |
||
1180 | temp |= (PORT_DISABLE); |
||
1181 | __raw_writel(temp, &sw->regs->mac_cfg[i]); |
||
1182 | } |
||
1183 | |||
1184 | temp = PORT_DISABLE; |
||
1185 | __raw_writel(temp, &sw->regs->mac_cfg[2]); |
||
1186 | |||
1187 | temp = __raw_readl(&sw->regs->vlan_cfg); |
||
1188 | temp |= NIC_MODE | VLAN_UNAWARE; |
||
1189 | __raw_writel(temp, &sw->regs->vlan_cfg); |
||
1190 | |||
1191 | __raw_writel(UNKNOWN_VLAN_TO_CPU | |
||
1192 | CRC_STRIPPING, &sw->regs->mac_glob_cfg); |
||
1193 | |||
1194 | if ((err = init_rings(sw)) != 0) { |
||
1195 | err = -ENOMEM; |
||
1196 | goto err_free; |
||
1197 | } |
||
1198 | platform_set_drvdata(pdev, napi_dev); |
||
1199 | |||
1200 | netif_napi_add(napi_dev, &sw->napi, eth_poll, NAPI_WEIGHT); |
||
1201 | |||
1202 | for (i = 0; i < 3; i++) { |
||
1203 | if (!(plat->ports & (1 << i))) { |
||
1204 | continue; |
||
1205 | } |
||
1206 | |||
1207 | if (!(dev = alloc_etherdev(sizeof(struct port)))) { |
||
1208 | goto free_ports; |
||
1209 | } |
||
1210 | |||
1211 | port = netdev_priv(dev); |
||
1212 | port->netdev = dev; |
||
1213 | if (i == 2) |
||
1214 | port->id = 3; |
||
1215 | else |
||
1216 | port->id = i; |
||
1217 | port->sw = sw; |
||
1218 | |||
1219 | temp = __raw_readl(&sw->regs->mac_cfg[port->id]); |
||
1220 | temp |= (PORT_DISABLE | PORT_BLOCK_STATE | PORT_LEARN_DIS); |
||
1221 | __raw_writel(temp, &sw->regs->mac_cfg[port->id]); |
||
1222 | |||
1223 | SET_NETDEV_DEV(dev, &pdev->dev); |
||
1224 | dev->netdev_ops = &cns3xxx_netdev_ops; |
||
1225 | dev->ethtool_ops = &cns3xxx_ethtool_ops; |
||
1226 | dev->tx_queue_len = 1000; |
||
1227 | dev->features = NETIF_F_IP_CSUM | NETIF_F_SG | NETIF_F_FRAGLIST; |
||
1228 | |||
1229 | switch_port_tab[port->id] = port; |
||
1230 | memcpy(dev->dev_addr, &plat->hwaddr[i], ETH_ALEN); |
||
1231 | |||
1232 | snprintf(phy_id, MII_BUS_ID_SIZE + 3, PHY_ID_FMT, "0", plat->phy[i]); |
||
1233 | port->phydev = phy_connect(dev, phy_id, &cns3xxx_adjust_link, |
||
1234 | PHY_INTERFACE_MODE_RGMII); |
||
1235 | if ((err = IS_ERR(port->phydev))) { |
||
1236 | switch_port_tab[port->id] = 0; |
||
1237 | free_netdev(dev); |
||
1238 | goto free_ports; |
||
1239 | } |
||
1240 | |||
1241 | port->phydev->irq = PHY_IGNORE_INTERRUPT; |
||
1242 | |||
1243 | if ((err = register_netdev(dev))) { |
||
1244 | phy_disconnect(port->phydev); |
||
1245 | switch_port_tab[port->id] = 0; |
||
1246 | free_netdev(dev); |
||
1247 | goto free_ports; |
||
1248 | } |
||
1249 | |||
1250 | printk(KERN_INFO "%s: RGMII PHY %i on cns3xxx Switch\n", dev->name, plat->phy[i]); |
||
1251 | netif_carrier_off(dev); |
||
1252 | dev = 0; |
||
1253 | } |
||
1254 | |||
1255 | return 0; |
||
1256 | |||
1257 | free_ports: |
||
1258 | err = -ENOMEM; |
||
1259 | for (--i; i >= 0; i--) { |
||
1260 | if (switch_port_tab[i]) { |
||
1261 | port = switch_port_tab[i]; |
||
1262 | dev = port->netdev; |
||
1263 | unregister_netdev(dev); |
||
1264 | phy_disconnect(port->phydev); |
||
1265 | switch_port_tab[i] = 0; |
||
1266 | free_netdev(dev); |
||
1267 | } |
||
1268 | } |
||
1269 | err_free: |
||
1270 | free_netdev(napi_dev); |
||
1271 | err_remove_mdio: |
||
1272 | cns3xxx_mdio_remove(); |
||
1273 | return err; |
||
1274 | } |
||
1275 | |||
1276 | static int eth_remove_one(struct platform_device *pdev) |
||
1277 | { |
||
1278 | struct net_device *dev = platform_get_drvdata(pdev); |
||
1279 | struct sw *sw = netdev_priv(dev); |
||
1280 | int i; |
||
1281 | |||
1282 | destroy_rings(sw); |
||
1283 | for (i = 3; i >= 0; i--) { |
||
1284 | if (switch_port_tab[i]) { |
||
1285 | struct port *port = switch_port_tab[i]; |
||
1286 | struct net_device *dev = port->netdev; |
||
1287 | unregister_netdev(dev); |
||
1288 | phy_disconnect(port->phydev); |
||
1289 | switch_port_tab[i] = 0; |
||
1290 | free_netdev(dev); |
||
1291 | } |
||
1292 | } |
||
1293 | |||
1294 | free_netdev(napi_dev); |
||
1295 | cns3xxx_mdio_remove(); |
||
1296 | |||
1297 | return 0; |
||
1298 | } |
||
1299 | |||
1300 | static struct platform_driver cns3xxx_eth_driver = { |
||
1301 | .driver.name = DRV_NAME, |
||
1302 | .probe = eth_init_one, |
||
1303 | .remove = eth_remove_one, |
||
1304 | }; |
||
1305 | |||
1306 | static int __init eth_init_module(void) |
||
1307 | { |
||
1308 | return platform_driver_register(&cns3xxx_eth_driver); |
||
1309 | } |
||
1310 | |||
1311 | static void __exit eth_cleanup_module(void) |
||
1312 | { |
||
1313 | platform_driver_unregister(&cns3xxx_eth_driver); |
||
1314 | } |
||
1315 | |||
1316 | module_init(eth_init_module); |
||
1317 | module_exit(eth_cleanup_module); |
||
1318 | |||
1319 | MODULE_AUTHOR("Chris Lang"); |
||
1320 | MODULE_DESCRIPTION("Cavium CNS3xxx Ethernet driver"); |
||
1321 | MODULE_LICENSE("GPL v2"); |
||
1322 | MODULE_ALIAS("platform:cns3xxx_eth"); |