?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
netdev: octeon_mgmt: Try not to drop TX packets when stopping the queue.
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / net / octeon / octeon_mgmt.c
blob1fdc7b303a6b9a2490e794c52c23ee13d9551cfb
1 /*
2 * This file is subject to the terms and conditions of the GNU General Public
3 * License. See the file "COPYING" in the main directory of this archive
4 * for more details.
5 *
6 * Copyright (C) 2009 Cavium Networks
7 */
8
9 #include <linux/capability.h>
10 #include <linux/dma-mapping.h>
11 #include <linux/init.h>
12 #include <linux/platform_device.h>
13 #include <linux/netdevice.h>
14 #include <linux/etherdevice.h>
15 #include <linux/if_vlan.h>
16 #include <linux/slab.h>
17 #include <linux/phy.h>
18 #include <linux/spinlock.h>
19
20 #include <asm/octeon/octeon.h>
21 #include <asm/octeon/cvmx-mixx-defs.h>
22 #include <asm/octeon/cvmx-agl-defs.h>
23
24 #define DRV_NAME "octeon_mgmt"
25 #define DRV_VERSION "2.0"
26 #define DRV_DESCRIPTION \
27 "Cavium Networks Octeon MII (management) port Network Driver"
28
29 #define OCTEON_MGMT_NAPI_WEIGHT 16
30
31 /*
32 * Ring sizes that are powers of two allow for more efficient modulo
33 * opertions.
34 */
35 #define OCTEON_MGMT_RX_RING_SIZE 512
36 #define OCTEON_MGMT_TX_RING_SIZE 128
37
38 /* Allow 8 bytes for vlan and FCS. */
39 #define OCTEON_MGMT_RX_HEADROOM (ETH_HLEN + ETH_FCS_LEN + VLAN_HLEN)
40
41 union mgmt_port_ring_entry {
42 u64 d64;
43 struct {
44 u64 reserved_62_63:2;
45 /* Length of the buffer/packet in bytes */
46 u64 len:14;
47 /* For TX, signals that the packet should be timestamped */
48 u64 tstamp:1;
49 /* The RX error code */
50 u64 code:7;
51 #define RING_ENTRY_CODE_DONE 0xf
52 #define RING_ENTRY_CODE_MORE 0x10
53 /* Physical address of the buffer */
54 u64 addr:40;
55 } s;
56 };
57
58 struct octeon_mgmt {
59 struct net_device *netdev;
60 int port;
61 int irq;
62 u64 *tx_ring;
63 dma_addr_t tx_ring_handle;
64 unsigned int tx_next;
65 unsigned int tx_next_clean;
66 unsigned int tx_current_fill;
67 /* The tx_list lock also protects the ring related variables */
68 struct sk_buff_head tx_list;
69
70 /* RX variables only touched in napi_poll. No locking necessary. */
71 u64 *rx_ring;
72 dma_addr_t rx_ring_handle;
73 unsigned int rx_next;
74 unsigned int rx_next_fill;
75 unsigned int rx_current_fill;
76 struct sk_buff_head rx_list;
77
78 spinlock_t lock;
79 unsigned int last_duplex;
80 unsigned int last_link;
81 struct device *dev;
82 struct napi_struct napi;
83 struct tasklet_struct tx_clean_tasklet;
84 struct phy_device *phydev;
85 };
86
87 static void octeon_mgmt_set_rx_irq(struct octeon_mgmt *p, int enable)
88 {
89 int port = p->port;
90 union cvmx_mixx_intena mix_intena;
91 unsigned long flags;
92
93 spin_lock_irqsave(&p->lock, flags);
94 mix_intena.u64 = cvmx_read_csr(CVMX_MIXX_INTENA(port));
95 mix_intena.s.ithena = enable ? 1 : 0;
96 cvmx_write_csr(CVMX_MIXX_INTENA(port), mix_intena.u64);
97 spin_unlock_irqrestore(&p->lock, flags);
98 }
99
100 static void octeon_mgmt_set_tx_irq(struct octeon_mgmt *p, int enable)
101 {
102 int port = p->port;
103 union cvmx_mixx_intena mix_intena;
104 unsigned long flags;
105
106 spin_lock_irqsave(&p->lock, flags);
107 mix_intena.u64 = cvmx_read_csr(CVMX_MIXX_INTENA(port));
108 mix_intena.s.othena = enable ? 1 : 0;
109 cvmx_write_csr(CVMX_MIXX_INTENA(port), mix_intena.u64);
110 spin_unlock_irqrestore(&p->lock, flags);
111 }
112
113 static inline void octeon_mgmt_enable_rx_irq(struct octeon_mgmt *p)
114 {
115 octeon_mgmt_set_rx_irq(p, 1);
116 }
117
118 static inline void octeon_mgmt_disable_rx_irq(struct octeon_mgmt *p)
119 {
120 octeon_mgmt_set_rx_irq(p, 0);
121 }
122
123 static inline void octeon_mgmt_enable_tx_irq(struct octeon_mgmt *p)
124 {
125 octeon_mgmt_set_tx_irq(p, 1);
126 }
127
128 static inline void octeon_mgmt_disable_tx_irq(struct octeon_mgmt *p)
129 {
130 octeon_mgmt_set_tx_irq(p, 0);
131 }
132
133 static unsigned int ring_max_fill(unsigned int ring_size)
134 {
135 return ring_size - 8;
136 }
137
138 static unsigned int ring_size_to_bytes(unsigned int ring_size)
139 {
140 return ring_size * sizeof(union mgmt_port_ring_entry);
141 }
142
143 static void octeon_mgmt_rx_fill_ring(struct net_device *netdev)
144 {
145 struct octeon_mgmt *p = netdev_priv(netdev);
146 int port = p->port;
147
148 while (p->rx_current_fill < ring_max_fill(OCTEON_MGMT_RX_RING_SIZE)) {
149 unsigned int size;
150 union mgmt_port_ring_entry re;
151 struct sk_buff *skb;
152
153 /* CN56XX pass 1 needs 8 bytes of padding. */
154 size = netdev->mtu + OCTEON_MGMT_RX_HEADROOM + 8 + NET_IP_ALIGN;
155
156 skb = netdev_alloc_skb(netdev, size);
157 if (!skb)
158 break;
159 skb_reserve(skb, NET_IP_ALIGN);
160 __skb_queue_tail(&p->rx_list, skb);
161
162 re.d64 = 0;
163 re.s.len = size;
164 re.s.addr = dma_map_single(p->dev, skb->data,
165 size,
166 DMA_FROM_DEVICE);
167
168 /* Put it in the ring. */
169 p->rx_ring[p->rx_next_fill] = re.d64;
170 dma_sync_single_for_device(p->dev, p->rx_ring_handle,
171 ring_size_to_bytes(OCTEON_MGMT_RX_RING_SIZE),
172 DMA_BIDIRECTIONAL);
173 p->rx_next_fill =
174 (p->rx_next_fill + 1) % OCTEON_MGMT_RX_RING_SIZE;
175 p->rx_current_fill++;
176 /* Ring the bell. */
177 cvmx_write_csr(CVMX_MIXX_IRING2(port), 1);
178 }
179 }
180
181 static void octeon_mgmt_clean_tx_buffers(struct octeon_mgmt *p)
182 {
183 int port = p->port;
184 union cvmx_mixx_orcnt mix_orcnt;
185 union mgmt_port_ring_entry re;
186 struct sk_buff *skb;
187 int cleaned = 0;
188 unsigned long flags;
189
190 mix_orcnt.u64 = cvmx_read_csr(CVMX_MIXX_ORCNT(port));
191 while (mix_orcnt.s.orcnt) {
192 spin_lock_irqsave(&p->tx_list.lock, flags);
193
194 mix_orcnt.u64 = cvmx_read_csr(CVMX_MIXX_ORCNT(port));
195
196 if (mix_orcnt.s.orcnt == 0) {
197 spin_unlock_irqrestore(&p->tx_list.lock, flags);
198 break;
199 }
200
201 dma_sync_single_for_cpu(p->dev, p->tx_ring_handle,
202 ring_size_to_bytes(OCTEON_MGMT_TX_RING_SIZE),
203 DMA_BIDIRECTIONAL);
204
205 re.d64 = p->tx_ring[p->tx_next_clean];
206 p->tx_next_clean =
207 (p->tx_next_clean + 1) % OCTEON_MGMT_TX_RING_SIZE;
208 skb = __skb_dequeue(&p->tx_list);
209
210 mix_orcnt.u64 = 0;
211 mix_orcnt.s.orcnt = 1;
212
213 /* Acknowledge to hardware that we have the buffer. */
214 cvmx_write_csr(CVMX_MIXX_ORCNT(port), mix_orcnt.u64);
215 p->tx_current_fill--;
216
217 spin_unlock_irqrestore(&p->tx_list.lock, flags);
218
219 dma_unmap_single(p->dev, re.s.addr, re.s.len,
220 DMA_TO_DEVICE);
221 dev_kfree_skb_any(skb);
222 cleaned++;
223
224 mix_orcnt.u64 = cvmx_read_csr(CVMX_MIXX_ORCNT(port));
225 }
226
227 if (cleaned && netif_queue_stopped(p->netdev))
228 netif_wake_queue(p->netdev);
229 }
230
231 static void octeon_mgmt_clean_tx_tasklet(unsigned long arg)
232 {
233 struct octeon_mgmt *p = (struct octeon_mgmt *)arg;
234 octeon_mgmt_clean_tx_buffers(p);
235 octeon_mgmt_enable_tx_irq(p);
236 }
237
238 static void octeon_mgmt_update_rx_stats(struct net_device *netdev)
239 {
240 struct octeon_mgmt *p = netdev_priv(netdev);
241 int port = p->port;
242 unsigned long flags;
243 u64 drop, bad;
244
245 /* These reads also clear the count registers. */
246 drop = cvmx_read_csr(CVMX_AGL_GMX_RXX_STATS_PKTS_DRP(port));
247 bad = cvmx_read_csr(CVMX_AGL_GMX_RXX_STATS_PKTS_BAD(port));
248
249 if (drop || bad) {
250 /* Do an atomic update. */
251 spin_lock_irqsave(&p->lock, flags);
252 netdev->stats.rx_errors += bad;
253 netdev->stats.rx_dropped += drop;
254 spin_unlock_irqrestore(&p->lock, flags);
255 }
256 }
257
258 static void octeon_mgmt_update_tx_stats(struct net_device *netdev)
259 {
260 struct octeon_mgmt *p = netdev_priv(netdev);
261 int port = p->port;
262 unsigned long flags;
263
264 union cvmx_agl_gmx_txx_stat0 s0;
265 union cvmx_agl_gmx_txx_stat1 s1;
266
267 /* These reads also clear the count registers. */
268 s0.u64 = cvmx_read_csr(CVMX_AGL_GMX_TXX_STAT0(port));
269 s1.u64 = cvmx_read_csr(CVMX_AGL_GMX_TXX_STAT1(port));
270
271 if (s0.s.xsdef || s0.s.xscol || s1.s.scol || s1.s.mcol) {
272 /* Do an atomic update. */
273 spin_lock_irqsave(&p->lock, flags);
274 netdev->stats.tx_errors += s0.s.xsdef + s0.s.xscol;
275 netdev->stats.collisions += s1.s.scol + s1.s.mcol;
276 spin_unlock_irqrestore(&p->lock, flags);
277 }
278 }
279
280 /*
281 * Dequeue a receive skb and its corresponding ring entry. The ring
282 * entry is returned, *pskb is updated to point to the skb.
283 */
284 static u64 octeon_mgmt_dequeue_rx_buffer(struct octeon_mgmt *p,
285 struct sk_buff **pskb)
286 {
287 union mgmt_port_ring_entry re;
288
289 dma_sync_single_for_cpu(p->dev, p->rx_ring_handle,
290 ring_size_to_bytes(OCTEON_MGMT_RX_RING_SIZE),
291 DMA_BIDIRECTIONAL);
292
293 re.d64 = p->rx_ring[p->rx_next];
294 p->rx_next = (p->rx_next + 1) % OCTEON_MGMT_RX_RING_SIZE;
295 p->rx_current_fill--;
296 *pskb = __skb_dequeue(&p->rx_list);
297
298 dma_unmap_single(p->dev, re.s.addr,
299 ETH_FRAME_LEN + OCTEON_MGMT_RX_HEADROOM,
300 DMA_FROM_DEVICE);
301
302 return re.d64;
303 }
304
305
306 static int octeon_mgmt_receive_one(struct octeon_mgmt *p)
307 {
308 int port = p->port;
309 struct net_device *netdev = p->netdev;
310 union cvmx_mixx_ircnt mix_ircnt;
311 union mgmt_port_ring_entry re;
312 struct sk_buff *skb;
313 struct sk_buff *skb2;
314 struct sk_buff *skb_new;
315 union mgmt_port_ring_entry re2;
316 int rc = 1;
317
318
319 re.d64 = octeon_mgmt_dequeue_rx_buffer(p, &skb);
320 if (likely(re.s.code == RING_ENTRY_CODE_DONE)) {
321 /* A good packet, send it up. */
322 skb_put(skb, re.s.len);
323 good:
324 skb->protocol = eth_type_trans(skb, netdev);
325 netdev->stats.rx_packets++;
326 netdev->stats.rx_bytes += skb->len;
327 netif_receive_skb(skb);
328 rc = 0;
329 } else if (re.s.code == RING_ENTRY_CODE_MORE) {
330 /*
331 * Packet split across skbs. This can happen if we
332 * increase the MTU. Buffers that are already in the
333 * rx ring can then end up being too small. As the rx
334 * ring is refilled, buffers sized for the new MTU
335 * will be used and we should go back to the normal
336 * non-split case.
337 */
338 skb_put(skb, re.s.len);
339 do {
340 re2.d64 = octeon_mgmt_dequeue_rx_buffer(p, &skb2);
341 if (re2.s.code != RING_ENTRY_CODE_MORE
342 && re2.s.code != RING_ENTRY_CODE_DONE)
343 goto split_error;
344 skb_put(skb2, re2.s.len);
345 skb_new = skb_copy_expand(skb, 0, skb2->len,
346 GFP_ATOMIC);
347 if (!skb_new)
348 goto split_error;
349 if (skb_copy_bits(skb2, 0, skb_tail_pointer(skb_new),
350 skb2->len))
351 goto split_error;
352 skb_put(skb_new, skb2->len);
353 dev_kfree_skb_any(skb);
354 dev_kfree_skb_any(skb2);
355 skb = skb_new;
356 } while (re2.s.code == RING_ENTRY_CODE_MORE);
357 goto good;
358 } else {
359 /* Some other error, discard it. */
360 dev_kfree_skb_any(skb);
361 /*
362 * Error statistics are accumulated in
363 * octeon_mgmt_update_rx_stats.
364 */
365 }
366 goto done;
367 split_error:
368 /* Discard the whole mess. */
369 dev_kfree_skb_any(skb);
370 dev_kfree_skb_any(skb2);
371 while (re2.s.code == RING_ENTRY_CODE_MORE) {
372 re2.d64 = octeon_mgmt_dequeue_rx_buffer(p, &skb2);
373 dev_kfree_skb_any(skb2);
374 }
375 netdev->stats.rx_errors++;
376
377 done:
378 /* Tell the hardware we processed a packet. */
379 mix_ircnt.u64 = 0;
380 mix_ircnt.s.ircnt = 1;
381 cvmx_write_csr(CVMX_MIXX_IRCNT(port), mix_ircnt.u64);
382 return rc;
383
384 }
385
386 static int octeon_mgmt_receive_packets(struct octeon_mgmt *p, int budget)
387 {
388 int port = p->port;
389 unsigned int work_done = 0;
390 union cvmx_mixx_ircnt mix_ircnt;
391 int rc;
392
393
394 mix_ircnt.u64 = cvmx_read_csr(CVMX_MIXX_IRCNT(port));
395 while (work_done < budget && mix_ircnt.s.ircnt) {
396
397 rc = octeon_mgmt_receive_one(p);
398 if (!rc)
399 work_done++;
400
401 /* Check for more packets. */
402 mix_ircnt.u64 = cvmx_read_csr(CVMX_MIXX_IRCNT(port));
403 }
404
405 octeon_mgmt_rx_fill_ring(p->netdev);
406
407 return work_done;
408 }
409
410 static int octeon_mgmt_napi_poll(struct napi_struct *napi, int budget)
411 {
412 struct octeon_mgmt *p = container_of(napi, struct octeon_mgmt, napi);
413 struct net_device *netdev = p->netdev;
414 unsigned int work_done = 0;
415
416 work_done = octeon_mgmt_receive_packets(p, budget);
417
418 if (work_done < budget) {
419 /* We stopped because no more packets were available. */
420 napi_complete(napi);
421 octeon_mgmt_enable_rx_irq(p);
422 }
423 octeon_mgmt_update_rx_stats(netdev);
424
425 return work_done;
426 }
427
428 /* Reset the hardware to clean state. */
429 static void octeon_mgmt_reset_hw(struct octeon_mgmt *p)
430 {
431 union cvmx_mixx_ctl mix_ctl;
432 union cvmx_mixx_bist mix_bist;
433 union cvmx_agl_gmx_bist agl_gmx_bist;
434
435 mix_ctl.u64 = 0;
436 cvmx_write_csr(CVMX_MIXX_CTL(p->port), mix_ctl.u64);
437 do {
438 mix_ctl.u64 = cvmx_read_csr(CVMX_MIXX_CTL(p->port));
439 } while (mix_ctl.s.busy);
440 mix_ctl.s.reset = 1;
441 cvmx_write_csr(CVMX_MIXX_CTL(p->port), mix_ctl.u64);
442 cvmx_read_csr(CVMX_MIXX_CTL(p->port));
443 cvmx_wait(64);
444
445 mix_bist.u64 = cvmx_read_csr(CVMX_MIXX_BIST(p->port));
446 if (mix_bist.u64)
447 dev_warn(p->dev, "MIX failed BIST (0x%016llx)\n",
448 (unsigned long long)mix_bist.u64);
449
450 agl_gmx_bist.u64 = cvmx_read_csr(CVMX_AGL_GMX_BIST);
451 if (agl_gmx_bist.u64)
452 dev_warn(p->dev, "AGL failed BIST (0x%016llx)\n",
453 (unsigned long long)agl_gmx_bist.u64);
454 }
455
456 struct octeon_mgmt_cam_state {
457 u64 cam[6];
458 u64 cam_mask;
459 int cam_index;
460 };
461
462 static void octeon_mgmt_cam_state_add(struct octeon_mgmt_cam_state *cs,
463 unsigned char *addr)
464 {
465 int i;
466
467 for (i = 0; i < 6; i++)
468 cs->cam[i] |= (u64)addr[i] << (8 * (cs->cam_index));
469 cs->cam_mask |= (1ULL << cs->cam_index);
470 cs->cam_index++;
471 }
472
473 static void octeon_mgmt_set_rx_filtering(struct net_device *netdev)
474 {
475 struct octeon_mgmt *p = netdev_priv(netdev);
476 int port = p->port;
477 union cvmx_agl_gmx_rxx_adr_ctl adr_ctl;
478 union cvmx_agl_gmx_prtx_cfg agl_gmx_prtx;
479 unsigned long flags;
480 unsigned int prev_packet_enable;
481 unsigned int cam_mode = 1; /* 1 - Accept on CAM match */
482 unsigned int multicast_mode = 1; /* 1 - Reject all multicast. */
483 struct octeon_mgmt_cam_state cam_state;
484 struct netdev_hw_addr *ha;
485 int available_cam_entries;
486
487 memset(&cam_state, 0, sizeof(cam_state));
488
489 if ((netdev->flags & IFF_PROMISC) || netdev->uc.count > 7) {
490 cam_mode = 0;
491 available_cam_entries = 8;
492 } else {
493 /*
494 * One CAM entry for the primary address, leaves seven
495 * for the secondary addresses.
496 */
497 available_cam_entries = 7 - netdev->uc.count;
498 }
499
500 if (netdev->flags & IFF_MULTICAST) {
501 if (cam_mode == 0 || (netdev->flags & IFF_ALLMULTI) ||
502 netdev_mc_count(netdev) > available_cam_entries)
503 multicast_mode = 2; /* 2 - Accept all multicast. */
504 else
505 multicast_mode = 0; /* 0 - Use CAM. */
506 }
507
508 if (cam_mode == 1) {
509 /* Add primary address. */
510 octeon_mgmt_cam_state_add(&cam_state, netdev->dev_addr);
511 netdev_for_each_uc_addr(ha, netdev)
512 octeon_mgmt_cam_state_add(&cam_state, ha->addr);
513 }
514 if (multicast_mode == 0) {
515 netdev_for_each_mc_addr(ha, netdev)
516 octeon_mgmt_cam_state_add(&cam_state, ha->addr);
517 }
518
519
520 spin_lock_irqsave(&p->lock, flags);
521
522 /* Disable packet I/O. */
523 agl_gmx_prtx.u64 = cvmx_read_csr(CVMX_AGL_GMX_PRTX_CFG(port));
524 prev_packet_enable = agl_gmx_prtx.s.en;
525 agl_gmx_prtx.s.en = 0;
526 cvmx_write_csr(CVMX_AGL_GMX_PRTX_CFG(port), agl_gmx_prtx.u64);
527
528
529 adr_ctl.u64 = 0;
530 adr_ctl.s.cam_mode = cam_mode;
531 adr_ctl.s.mcst = multicast_mode;
532 adr_ctl.s.bcst = 1; /* Allow broadcast */
533
534 cvmx_write_csr(CVMX_AGL_GMX_RXX_ADR_CTL(port), adr_ctl.u64);
535
536 cvmx_write_csr(CVMX_AGL_GMX_RXX_ADR_CAM0(port), cam_state.cam[0]);
537 cvmx_write_csr(CVMX_AGL_GMX_RXX_ADR_CAM1(port), cam_state.cam[1]);
538 cvmx_write_csr(CVMX_AGL_GMX_RXX_ADR_CAM2(port), cam_state.cam[2]);
539 cvmx_write_csr(CVMX_AGL_GMX_RXX_ADR_CAM3(port), cam_state.cam[3]);
540 cvmx_write_csr(CVMX_AGL_GMX_RXX_ADR_CAM4(port), cam_state.cam[4]);
541 cvmx_write_csr(CVMX_AGL_GMX_RXX_ADR_CAM5(port), cam_state.cam[5]);
542 cvmx_write_csr(CVMX_AGL_GMX_RXX_ADR_CAM_EN(port), cam_state.cam_mask);
543
544 /* Restore packet I/O. */
545 agl_gmx_prtx.s.en = prev_packet_enable;
546 cvmx_write_csr(CVMX_AGL_GMX_PRTX_CFG(port), agl_gmx_prtx.u64);
547
548 spin_unlock_irqrestore(&p->lock, flags);
549 }
550
551 static int octeon_mgmt_set_mac_address(struct net_device *netdev, void *addr)
552 {
553 struct sockaddr *sa = addr;
554
555 if (!is_valid_ether_addr(sa->sa_data))
556 return -EADDRNOTAVAIL;
557
558 memcpy(netdev->dev_addr, sa->sa_data, ETH_ALEN);
559
560 octeon_mgmt_set_rx_filtering(netdev);
561
562 return 0;
563 }
564
565 static int octeon_mgmt_change_mtu(struct net_device *netdev, int new_mtu)
566 {
567 struct octeon_mgmt *p = netdev_priv(netdev);
568 int port = p->port;
569 int size_without_fcs = new_mtu + OCTEON_MGMT_RX_HEADROOM;
570
571 /*
572 * Limit the MTU to make sure the ethernet packets are between
573 * 64 bytes and 16383 bytes.
574 */
575 if (size_without_fcs < 64 || size_without_fcs > 16383) {
576 dev_warn(p->dev, "MTU must be between %d and %d.\n",
577 64 - OCTEON_MGMT_RX_HEADROOM,
578 16383 - OCTEON_MGMT_RX_HEADROOM);
579 return -EINVAL;
580 }
581
582 netdev->mtu = new_mtu;
583
584 cvmx_write_csr(CVMX_AGL_GMX_RXX_FRM_MAX(port), size_without_fcs);
585 cvmx_write_csr(CVMX_AGL_GMX_RXX_JABBER(port),
586 (size_without_fcs + 7) & 0xfff8);
587
588 return 0;
589 }
590
591 static irqreturn_t octeon_mgmt_interrupt(int cpl, void *dev_id)
592 {
593 struct net_device *netdev = dev_id;
594 struct octeon_mgmt *p = netdev_priv(netdev);
595 int port = p->port;
596 union cvmx_mixx_isr mixx_isr;
597
598 mixx_isr.u64 = cvmx_read_csr(CVMX_MIXX_ISR(port));
599
600 /* Clear any pending interrupts */
601 cvmx_write_csr(CVMX_MIXX_ISR(port), mixx_isr.u64);
602 cvmx_read_csr(CVMX_MIXX_ISR(port));
603
604 if (mixx_isr.s.irthresh) {
605 octeon_mgmt_disable_rx_irq(p);
606 napi_schedule(&p->napi);
607 }
608 if (mixx_isr.s.orthresh) {
609 octeon_mgmt_disable_tx_irq(p);
610 tasklet_schedule(&p->tx_clean_tasklet);
611 }
612
613 return IRQ_HANDLED;
614 }
615
616 static int octeon_mgmt_ioctl(struct net_device *netdev,
617 struct ifreq *rq, int cmd)
618 {
619 struct octeon_mgmt *p = netdev_priv(netdev);
620
621 if (!netif_running(netdev))
622 return -EINVAL;
623
624 if (!p->phydev)
625 return -EINVAL;
626
627 return phy_mii_ioctl(p->phydev, if_mii(rq), cmd);
628 }
629
630 static void octeon_mgmt_adjust_link(struct net_device *netdev)
631 {
632 struct octeon_mgmt *p = netdev_priv(netdev);
633 int port = p->port;
634 union cvmx_agl_gmx_prtx_cfg prtx_cfg;
635 unsigned long flags;
636 int link_changed = 0;
637
638 spin_lock_irqsave(&p->lock, flags);
639 if (p->phydev->link) {
640 if (!p->last_link)
641 link_changed = 1;
642 if (p->last_duplex != p->phydev->duplex) {
643 p->last_duplex = p->phydev->duplex;
644 prtx_cfg.u64 =
645 cvmx_read_csr(CVMX_AGL_GMX_PRTX_CFG(port));
646 prtx_cfg.s.duplex = p->phydev->duplex;
647 cvmx_write_csr(CVMX_AGL_GMX_PRTX_CFG(port),
648 prtx_cfg.u64);
649 }
650 } else {
651 if (p->last_link)
652 link_changed = -1;
653 }
654 p->last_link = p->phydev->link;
655 spin_unlock_irqrestore(&p->lock, flags);
656
657 if (link_changed != 0) {
658 if (link_changed > 0) {
659 netif_carrier_on(netdev);
660 pr_info("%s: Link is up - %d/%s\n", netdev->name,
661 p->phydev->speed,
662 DUPLEX_FULL == p->phydev->duplex ?
663 "Full" : "Half");
664 } else {
665 netif_carrier_off(netdev);
666 pr_info("%s: Link is down\n", netdev->name);
667 }
668 }
669 }
670
671 static int octeon_mgmt_init_phy(struct net_device *netdev)
672 {
673 struct octeon_mgmt *p = netdev_priv(netdev);
674 char phy_id[20];
675
676 if (octeon_is_simulation()) {
677 /* No PHYs in the simulator. */
678 netif_carrier_on(netdev);
679 return 0;
680 }
681
682 snprintf(phy_id, sizeof(phy_id), PHY_ID_FMT, "0", p->port);
683
684 p->phydev = phy_connect(netdev, phy_id, octeon_mgmt_adjust_link, 0,
685 PHY_INTERFACE_MODE_MII);
686
687 if (IS_ERR(p->phydev)) {
688 p->phydev = NULL;
689 return -1;
690 }
691
692 phy_start_aneg(p->phydev);
693
694 return 0;
695 }
696
697 static int octeon_mgmt_open(struct net_device *netdev)
698 {
699 struct octeon_mgmt *p = netdev_priv(netdev);
700 int port = p->port;
701 union cvmx_mixx_ctl mix_ctl;
702 union cvmx_agl_gmx_inf_mode agl_gmx_inf_mode;
703 union cvmx_mixx_oring1 oring1;
704 union cvmx_mixx_iring1 iring1;
705 union cvmx_agl_gmx_prtx_cfg prtx_cfg;
706 union cvmx_agl_gmx_rxx_frm_ctl rxx_frm_ctl;
707 union cvmx_mixx_irhwm mix_irhwm;
708 union cvmx_mixx_orhwm mix_orhwm;
709 union cvmx_mixx_intena mix_intena;
710 struct sockaddr sa;
711
712 /* Allocate ring buffers. */
713 p->tx_ring = kzalloc(ring_size_to_bytes(OCTEON_MGMT_TX_RING_SIZE),
714 GFP_KERNEL);
715 if (!p->tx_ring)
716 return -ENOMEM;
717 p->tx_ring_handle =
718 dma_map_single(p->dev, p->tx_ring,
719 ring_size_to_bytes(OCTEON_MGMT_TX_RING_SIZE),
720 DMA_BIDIRECTIONAL);
721 p->tx_next = 0;
722 p->tx_next_clean = 0;
723 p->tx_current_fill = 0;
724
725
726 p->rx_ring = kzalloc(ring_size_to_bytes(OCTEON_MGMT_RX_RING_SIZE),
727 GFP_KERNEL);
728 if (!p->rx_ring)
729 goto err_nomem;
730 p->rx_ring_handle =
731 dma_map_single(p->dev, p->rx_ring,
732 ring_size_to_bytes(OCTEON_MGMT_RX_RING_SIZE),
733 DMA_BIDIRECTIONAL);
734
735 p->rx_next = 0;
736 p->rx_next_fill = 0;
737 p->rx_current_fill = 0;
738
739 octeon_mgmt_reset_hw(p);
740
741 mix_ctl.u64 = cvmx_read_csr(CVMX_MIXX_CTL(port));
742
743 /* Bring it out of reset if needed. */
744 if (mix_ctl.s.reset) {
745 mix_ctl.s.reset = 0;
746 cvmx_write_csr(CVMX_MIXX_CTL(port), mix_ctl.u64);
747 do {
748 mix_ctl.u64 = cvmx_read_csr(CVMX_MIXX_CTL(port));
749 } while (mix_ctl.s.reset);
750 }
751
752 agl_gmx_inf_mode.u64 = 0;
753 agl_gmx_inf_mode.s.en = 1;
754 cvmx_write_csr(CVMX_AGL_GMX_INF_MODE, agl_gmx_inf_mode.u64);
755
756 oring1.u64 = 0;
757 oring1.s.obase = p->tx_ring_handle >> 3;
758 oring1.s.osize = OCTEON_MGMT_TX_RING_SIZE;
759 cvmx_write_csr(CVMX_MIXX_ORING1(port), oring1.u64);
760
761 iring1.u64 = 0;
762 iring1.s.ibase = p->rx_ring_handle >> 3;
763 iring1.s.isize = OCTEON_MGMT_RX_RING_SIZE;
764 cvmx_write_csr(CVMX_MIXX_IRING1(port), iring1.u64);
765
766 /* Disable packet I/O. */
767 prtx_cfg.u64 = cvmx_read_csr(CVMX_AGL_GMX_PRTX_CFG(port));
768 prtx_cfg.s.en = 0;
769 cvmx_write_csr(CVMX_AGL_GMX_PRTX_CFG(port), prtx_cfg.u64);
770
771 memcpy(sa.sa_data, netdev->dev_addr, ETH_ALEN);
772 octeon_mgmt_set_mac_address(netdev, &sa);
773
774 octeon_mgmt_change_mtu(netdev, netdev->mtu);
775
776 /*
777 * Enable the port HW. Packets are not allowed until
778 * cvmx_mgmt_port_enable() is called.
779 */
780 mix_ctl.u64 = 0;
781 mix_ctl.s.crc_strip = 1; /* Strip the ending CRC */
782 mix_ctl.s.en = 1; /* Enable the port */
783 mix_ctl.s.nbtarb = 0; /* Arbitration mode */
784 /* MII CB-request FIFO programmable high watermark */
785 mix_ctl.s.mrq_hwm = 1;
786 cvmx_write_csr(CVMX_MIXX_CTL(port), mix_ctl.u64);
787
788 if (OCTEON_IS_MODEL(OCTEON_CN56XX_PASS1_X)
789 || OCTEON_IS_MODEL(OCTEON_CN52XX_PASS1_X)) {
790 /*
791 * Force compensation values, as they are not
792 * determined properly by HW
793 */
794 union cvmx_agl_gmx_drv_ctl drv_ctl;
795
796 drv_ctl.u64 = cvmx_read_csr(CVMX_AGL_GMX_DRV_CTL);
797 if (port) {
798 drv_ctl.s.byp_en1 = 1;
799 drv_ctl.s.nctl1 = 6;
800 drv_ctl.s.pctl1 = 6;
801 } else {
802 drv_ctl.s.byp_en = 1;
803 drv_ctl.s.nctl = 6;
804 drv_ctl.s.pctl = 6;
805 }
806 cvmx_write_csr(CVMX_AGL_GMX_DRV_CTL, drv_ctl.u64);
807 }
808
809 octeon_mgmt_rx_fill_ring(netdev);
810
811 /* Clear statistics. */
812 /* Clear on read. */
813 cvmx_write_csr(CVMX_AGL_GMX_RXX_STATS_CTL(port), 1);
814 cvmx_write_csr(CVMX_AGL_GMX_RXX_STATS_PKTS_DRP(port), 0);
815 cvmx_write_csr(CVMX_AGL_GMX_RXX_STATS_PKTS_BAD(port), 0);
816
817 cvmx_write_csr(CVMX_AGL_GMX_TXX_STATS_CTL(port), 1);
818 cvmx_write_csr(CVMX_AGL_GMX_TXX_STAT0(port), 0);
819 cvmx_write_csr(CVMX_AGL_GMX_TXX_STAT1(port), 0);
820
821 /* Clear any pending interrupts */
822 cvmx_write_csr(CVMX_MIXX_ISR(port), cvmx_read_csr(CVMX_MIXX_ISR(port)));
823
824 if (request_irq(p->irq, octeon_mgmt_interrupt, 0, netdev->name,
825 netdev)) {
826 dev_err(p->dev, "request_irq(%d) failed.\n", p->irq);
827 goto err_noirq;
828 }
829
830 /* Interrupt every single RX packet */
831 mix_irhwm.u64 = 0;
832 mix_irhwm.s.irhwm = 0;
833 cvmx_write_csr(CVMX_MIXX_IRHWM(port), mix_irhwm.u64);
834
835 /* Interrupt when we have 1 or more packets to clean. */
836 mix_orhwm.u64 = 0;
837 mix_orhwm.s.orhwm = 1;
838 cvmx_write_csr(CVMX_MIXX_ORHWM(port), mix_orhwm.u64);
839
840 /* Enable receive and transmit interrupts */
841 mix_intena.u64 = 0;
842 mix_intena.s.ithena = 1;
843 mix_intena.s.othena = 1;
844 cvmx_write_csr(CVMX_MIXX_INTENA(port), mix_intena.u64);
845
846
847 /* Enable packet I/O. */
848
849 rxx_frm_ctl.u64 = 0;
850 rxx_frm_ctl.s.pre_align = 1;
851 /*
852 * When set, disables the length check for non-min sized pkts
853 * with padding in the client data.
854 */
855 rxx_frm_ctl.s.pad_len = 1;
856 /* When set, disables the length check for VLAN pkts */
857 rxx_frm_ctl.s.vlan_len = 1;
858 /* When set, PREAMBLE checking is less strict */
859 rxx_frm_ctl.s.pre_free = 1;
860 /* Control Pause Frames can match station SMAC */
861 rxx_frm_ctl.s.ctl_smac = 0;
862 /* Control Pause Frames can match globally assign Multicast address */
863 rxx_frm_ctl.s.ctl_mcst = 1;
864 /* Forward pause information to TX block */
865 rxx_frm_ctl.s.ctl_bck = 1;
866 /* Drop Control Pause Frames */
867 rxx_frm_ctl.s.ctl_drp = 1;
868 /* Strip off the preamble */
869 rxx_frm_ctl.s.pre_strp = 1;
870 /*
871 * This port is configured to send PREAMBLE+SFD to begin every
872 * frame. GMX checks that the PREAMBLE is sent correctly.
873 */
874 rxx_frm_ctl.s.pre_chk = 1;
875 cvmx_write_csr(CVMX_AGL_GMX_RXX_FRM_CTL(port), rxx_frm_ctl.u64);
876
877 /* Enable the AGL block */
878 agl_gmx_inf_mode.u64 = 0;
879 agl_gmx_inf_mode.s.en = 1;
880 cvmx_write_csr(CVMX_AGL_GMX_INF_MODE, agl_gmx_inf_mode.u64);
881
882 /* Configure the port duplex and enables */
883 prtx_cfg.u64 = cvmx_read_csr(CVMX_AGL_GMX_PRTX_CFG(port));
884 prtx_cfg.s.tx_en = 1;
885 prtx_cfg.s.rx_en = 1;
886 prtx_cfg.s.en = 1;
887 p->last_duplex = 1;
888 prtx_cfg.s.duplex = p->last_duplex;
889 cvmx_write_csr(CVMX_AGL_GMX_PRTX_CFG(port), prtx_cfg.u64);
890
891 p->last_link = 0;
892 netif_carrier_off(netdev);
893
894 if (octeon_mgmt_init_phy(netdev)) {
895 dev_err(p->dev, "Cannot initialize PHY.\n");
896 goto err_noirq;
897 }
898
899 netif_wake_queue(netdev);
900 napi_enable(&p->napi);
901
902 return 0;
903 err_noirq:
904 octeon_mgmt_reset_hw(p);
905 dma_unmap_single(p->dev, p->rx_ring_handle,
906 ring_size_to_bytes(OCTEON_MGMT_RX_RING_SIZE),
907 DMA_BIDIRECTIONAL);
908 kfree(p->rx_ring);
909 err_nomem:
910 dma_unmap_single(p->dev, p->tx_ring_handle,
911 ring_size_to_bytes(OCTEON_MGMT_TX_RING_SIZE),
912 DMA_BIDIRECTIONAL);
913 kfree(p->tx_ring);
914 return -ENOMEM;
915 }
916
917 static int octeon_mgmt_stop(struct net_device *netdev)
918 {
919 struct octeon_mgmt *p = netdev_priv(netdev);
920
921 napi_disable(&p->napi);
922 netif_stop_queue(netdev);
923
924 if (p->phydev)
925 phy_disconnect(p->phydev);
926
927 netif_carrier_off(netdev);
928
929 octeon_mgmt_reset_hw(p);
930
931
932 free_irq(p->irq, netdev);
933
934 /* dma_unmap is a nop on Octeon, so just free everything. */
935 skb_queue_purge(&p->tx_list);
936 skb_queue_purge(&p->rx_list);
937
938 dma_unmap_single(p->dev, p->rx_ring_handle,
939 ring_size_to_bytes(OCTEON_MGMT_RX_RING_SIZE),
940 DMA_BIDIRECTIONAL);
941 kfree(p->rx_ring);
942
943 dma_unmap_single(p->dev, p->tx_ring_handle,
944 ring_size_to_bytes(OCTEON_MGMT_TX_RING_SIZE),
945 DMA_BIDIRECTIONAL);
946 kfree(p->tx_ring);
947
948
949 return 0;
950 }
951
952 static int octeon_mgmt_xmit(struct sk_buff *skb, struct net_device *netdev)
953 {
954 struct octeon_mgmt *p = netdev_priv(netdev);
955 int port = p->port;
956 union mgmt_port_ring_entry re;
957 unsigned long flags;
958 int rv = NETDEV_TX_BUSY;
959
960 re.d64 = 0;
961 re.s.len = skb->len;
962 re.s.addr = dma_map_single(p->dev, skb->data,
963 skb->len,
964 DMA_TO_DEVICE);
965
966 spin_lock_irqsave(&p->tx_list.lock, flags);
967
968 if (unlikely(p->tx_current_fill >= ring_max_fill(OCTEON_MGMT_TX_RING_SIZE) - 1)) {
969 spin_unlock_irqrestore(&p->tx_list.lock, flags);
970 netif_stop_queue(netdev);
971 spin_lock_irqsave(&p->tx_list.lock, flags);
972 }
973
974 if (unlikely(p->tx_current_fill >=
975 ring_max_fill(OCTEON_MGMT_TX_RING_SIZE))) {
976 spin_unlock_irqrestore(&p->tx_list.lock, flags);
977 dma_unmap_single(p->dev, re.s.addr, re.s.len,
978 DMA_TO_DEVICE);
979 goto out;
980 }
981
982 __skb_queue_tail(&p->tx_list, skb);
983
984 /* Put it in the ring. */
985 p->tx_ring[p->tx_next] = re.d64;
986 p->tx_next = (p->tx_next + 1) % OCTEON_MGMT_TX_RING_SIZE;
987 p->tx_current_fill++;
988
989 spin_unlock_irqrestore(&p->tx_list.lock, flags);
990
991 dma_sync_single_for_device(p->dev, p->tx_ring_handle,
992 ring_size_to_bytes(OCTEON_MGMT_TX_RING_SIZE),
993 DMA_BIDIRECTIONAL);
994
995 netdev->stats.tx_packets++;
996 netdev->stats.tx_bytes += skb->len;
997
998 /* Ring the bell. */
999 cvmx_write_csr(CVMX_MIXX_ORING2(port), 1);
1000
1001 netdev->trans_start = jiffies;
1002 rv = NETDEV_TX_OK;
1003 out:
1004 octeon_mgmt_update_tx_stats(netdev);
1005 return rv;
1006 }
1007
1008 #ifdef CONFIG_NET_POLL_CONTROLLER
1009 static void octeon_mgmt_poll_controller(struct net_device *netdev)
1010 {
1011 struct octeon_mgmt *p = netdev_priv(netdev);
1012
1013 octeon_mgmt_receive_packets(p, 16);
1014 octeon_mgmt_update_rx_stats(netdev);
1015 return;
1016 }
1017 #endif
1018
1019 static void octeon_mgmt_get_drvinfo(struct net_device *netdev,
1020 struct ethtool_drvinfo *info)
1021 {
1022 strncpy(info->driver, DRV_NAME, sizeof(info->driver));
1023 strncpy(info->version, DRV_VERSION, sizeof(info->version));
1024 strncpy(info->fw_version, "N/A", sizeof(info->fw_version));
1025 strncpy(info->bus_info, "N/A", sizeof(info->bus_info));
1026 info->n_stats = 0;
1027 info->testinfo_len = 0;
1028 info->regdump_len = 0;
1029 info->eedump_len = 0;
1030 }
1031
1032 static int octeon_mgmt_get_settings(struct net_device *netdev,
1033 struct ethtool_cmd *cmd)
1034 {
1035 struct octeon_mgmt *p = netdev_priv(netdev);
1036
1037 if (p->phydev)
1038 return phy_ethtool_gset(p->phydev, cmd);
1039
1040 return -EINVAL;
1041 }
1042
1043 static int octeon_mgmt_set_settings(struct net_device *netdev,
1044 struct ethtool_cmd *cmd)
1045 {
1046 struct octeon_mgmt *p = netdev_priv(netdev);
1047
1048 if (!capable(CAP_NET_ADMIN))
1049 return -EPERM;
1050
1051 if (p->phydev)
1052 return phy_ethtool_sset(p->phydev, cmd);
1053
1054 return -EINVAL;
1055 }
1056
1057 static const struct ethtool_ops octeon_mgmt_ethtool_ops = {
1058 .get_drvinfo = octeon_mgmt_get_drvinfo,
1059 .get_link = ethtool_op_get_link,
1060 .get_settings = octeon_mgmt_get_settings,
1061 .set_settings = octeon_mgmt_set_settings
1062 };
1063
1064 static const struct net_device_ops octeon_mgmt_ops = {
1065 .ndo_open = octeon_mgmt_open,
1066 .ndo_stop = octeon_mgmt_stop,
1067 .ndo_start_xmit = octeon_mgmt_xmit,
1068 .ndo_set_rx_mode = octeon_mgmt_set_rx_filtering,
1069 .ndo_set_multicast_list = octeon_mgmt_set_rx_filtering,
1070 .ndo_set_mac_address = octeon_mgmt_set_mac_address,
1071 .ndo_do_ioctl = octeon_mgmt_ioctl,
1072 .ndo_change_mtu = octeon_mgmt_change_mtu,
1073 #ifdef CONFIG_NET_POLL_CONTROLLER
1074 .ndo_poll_controller = octeon_mgmt_poll_controller,
1075 #endif
1076 };
1077
1078 static int __init octeon_mgmt_probe(struct platform_device *pdev)
1079 {
1080 struct resource *res_irq;
1081 struct net_device *netdev;
1082 struct octeon_mgmt *p;
1083 int i;
1084
1085 netdev = alloc_etherdev(sizeof(struct octeon_mgmt));
1086 if (netdev == NULL)
1087 return -ENOMEM;
1088
1089 dev_set_drvdata(&pdev->dev, netdev);
1090 p = netdev_priv(netdev);
1091 netif_napi_add(netdev, &p->napi, octeon_mgmt_napi_poll,
1092 OCTEON_MGMT_NAPI_WEIGHT);
1093
1094 p->netdev = netdev;
1095 p->dev = &pdev->dev;
1096
1097 p->port = pdev->id;
1098 snprintf(netdev->name, IFNAMSIZ, "mgmt%d", p->port);
1099
1100 res_irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
1101 if (!res_irq)
1102 goto err;
1103
1104 p->irq = res_irq->start;
1105 spin_lock_init(&p->lock);
1106
1107 skb_queue_head_init(&p->tx_list);
1108 skb_queue_head_init(&p->rx_list);
1109 tasklet_init(&p->tx_clean_tasklet,
1110 octeon_mgmt_clean_tx_tasklet, (unsigned long)p);
1111
1112 netdev->netdev_ops = &octeon_mgmt_ops;
1113 netdev->ethtool_ops = &octeon_mgmt_ethtool_ops;
1114
1115
1116 /* The mgmt ports get the first N MACs. */
1117 for (i = 0; i < 6; i++)
1118 netdev->dev_addr[i] = octeon_bootinfo->mac_addr_base[i];
1119 netdev->dev_addr[5] += p->port;
1120
1121 if (p->port >= octeon_bootinfo->mac_addr_count)
1122 dev_err(&pdev->dev,
1123 "Error %s: Using MAC outside of the assigned range: %pM\n",
1124 netdev->name, netdev->dev_addr);
1125
1126 if (register_netdev(netdev))
1127 goto err;
1128
1129 dev_info(&pdev->dev, "Version " DRV_VERSION "\n");
1130 return 0;
1131 err:
1132 free_netdev(netdev);
1133 return -ENOENT;
1134 }
1135
1136 static int __exit octeon_mgmt_remove(struct platform_device *pdev)
1137 {
1138 struct net_device *netdev = dev_get_drvdata(&pdev->dev);
1139
1140 unregister_netdev(netdev);
1141 free_netdev(netdev);
1142 return 0;
1143 }
1144
1145 static struct platform_driver octeon_mgmt_driver = {
1146 .driver = {
1147 .name = "octeon_mgmt",
1148 .owner = THIS_MODULE,
1149 },
1150 .probe = octeon_mgmt_probe,
1151 .remove = __exit_p(octeon_mgmt_remove),
1152 };
1153
1154 extern void octeon_mdiobus_force_mod_depencency(void);
1155
1156 static int __init octeon_mgmt_mod_init(void)
1157 {
1158 /* Force our mdiobus driver module to be loaded first. */
1159 octeon_mdiobus_force_mod_depencency();
1160 return platform_driver_register(&octeon_mgmt_driver);
1161 }
1162
1163 static void __exit octeon_mgmt_mod_exit(void)
1164 {
1165 platform_driver_unregister(&octeon_mgmt_driver);
1166 }
1167
1168 module_init(octeon_mgmt_mod_init);
1169 module_exit(octeon_mgmt_mod_exit);
1170
1171 MODULE_DESCRIPTION(DRV_DESCRIPTION);
1172 MODULE_AUTHOR("David Daney");
1173 MODULE_LICENSE("GPL");
1174 MODULE_VERSION(DRV_VERSION);
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree