![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dev_nm_16esw.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Dynamips Cisco Emulator] / cf|
Return to dev_nm_16esw.c CVS log | Up to [Dynamips Cisco Emulator] / cf |
1.1 root 1: /*
2: * Cisco C3600 simulation platform.
3: * Copyright (c) 2006 Christophe Fillot ([email protected])
4: *
5: * NM-16ESW ethernet switch module (experimental!)
6: *
7: * It's an attempt of proof of concept, so not optimized at all at this time.
8: * Only L2 switching will be managed (no L3 at all).
9: *
10: * To do next: QoS features (CoS/DSCP handling).
11: */
12:
13: #include <stdio.h>
14: #include <stdlib.h>
15: #include <string.h>
16: #include <stdarg.h>
17: #include <unistd.h>
18: #include <time.h>
19: #include <errno.h>
20: #include <assert.h>
21:
22: #include "utils.h"
23: #include "timer.h"
24: #include "net.h"
25: #include "net_io.h"
26: #include "ptask.h"
27: #include "dev_nm_16esw.h"
28:
29: /* Debugging flags */
30: #define DEBUG_ACCESS 0
31: #define DEBUG_UNKNOWN 0
32: #define DEBUG_MII 0
33: #define DEBUG_MEM 0
34: #define DEBUG_REG 1
35: #define DEBUG_TRANSMIT 0
36: #define DEBUG_RECEIVE 0
37: #define DEBUG_FORWARD 0
38: #define DEBUG_MIRROR 0
39: #define DEBUG_ARL 0
40:
41: /* Invalid VLAN value */
42: #define VLAN_INVALID 0xFFF
43:
44: /* Maximum packet size */
45: #define BCM5600_MAX_PKT_SIZE 2048
46:
47: /* PCI vendor/product codes */
48: #define BCM5605_PCI_VENDOR_ID 0x14e4
49: #define BCM5605_PCI_PRODUCT_ID 0x5605
50:
51: /* "S-channel" commands */
52: #define BCM5600_SCHAN_CMD_LINKSCAN 0x13
53: #define BCM5600_SCHAN_CMD_EXEC 0x80
54: #define BCM5600_SCHAN_CMD_READ_MII 0x90
55: #define BCM5600_SCHAN_CMD_WRITE_MII 0x91
56:
57: /* Opcodes */
58: #define BCM5600_OP_BP_WARN_STATUS 0x01
59: #define BCM5600_OP_BP_DISCARD_STATUS 0x02
60: #define BCM5600_OP_COS_QSTAT_NOTIFY 0x03
61: #define BCM5600_OP_HOL_STAT_NOTIFY 0x04
62: #define BCM5600_OP_GBP_FULL_NOTIFY 0x05
63: #define BCM5600_OP_GBP_AVAIL_NOTIFY 0x06
64: #define BCM5600_OP_READ_MEM_CMD 0x07
65: #define BCM5600_OP_READ_MEM_ACK 0x08
66: #define BCM5600_OP_WRITE_MEM_CMD 0x09
67: #define BCM5600_OP_WRITE_MEM_ACK 0x0A
68: #define BCM5600_OP_READ_REG_CMD 0x0B
69: #define BCM5600_OP_READ_REG_ACK 0x0C
70: #define BCM5600_OP_WRITE_REG_CMD 0x0D
71: #define BCM5600_OP_WRITE_REG_ACK 0x0E
72: #define BCM5600_OP_ARL_INSERT_CMD 0x0F
73: #define BCM5600_OP_ARL_INSERT_DONE 0x10
74: #define BCM5600_OP_ARL_DELETE_CMD 0x11
75: #define BCM5600_OP_ARL_DELETE_DONE 0x12
76: #define BCM5600_OP_LINKSTAT_NOTIFY 0x13
77: #define BCM5600_OP_MEM_FAIL_NOTIFY 0x14
78: #define BCM5600_OP_INIT_CFAP 0x15
79: #define BCM5600_OP_INIT_SFAP 0x16
80: #define BCM5600_OP_ENTER_DEBUG_MODE 0x17
81: #define BCM5600_OP_EXIT_DEBUG_MODE 0x18
82: #define BCM5600_OP_ARL_LOOKUP_CMD 0x19
83:
84: /* Command details */
85: #define BCM5600_CMD_OP_MASK 0xFC000000
86: #define BCM5600_CMD_OP_SHIFT 26
87: #define BCM5600_CMD_DST_MASK 0x03F00000
88: #define BCM5600_CMD_DST_SHIFT 20
89: #define BCM5600_CMD_SRC_MASK 0x000FC000
90: #define BCM5600_CMD_SRC_SHIFT 14
91: #define BCM5600_CMD_LEN_MASK 0x00003F80
92: #define BCM5600_CMD_LEN_SHIFT 7
93: #define BCM5600_CMD_EBIT_MASK 0x00000040
94: #define BCM5600_CMD_EBIT_SHIFT 6
95: #define BCM5600_CMD_ECODE_MASK 0x00000030
96: #define BCM5600_CMD_ECODE_SHIFT 4
97: #define BCM5600_CMD_COS_MASK 0x0000000E
98: #define BCM5600_CMD_COS_SHIFT 1
99: #define BCM5600_CMD_CPU_MASK 0x00000001
100: #define BCM5600_CMD_CPU_SHIFT 0
101:
102: /* Memory zones */
103: #define BCM5600_ADDR_ARLCNT0 0x01000000
104: #define BCM5600_ADDR_ARLCNT1 0x01100000
105: #define BCM5600_ADDR_ARLCNT2 0x01200000
106: #define BCM5600_ADDR_ARL0 0x02000000
107: #define BCM5600_ADDR_ARL1 0x02100000
108: #define BCM5600_ADDR_ARL2 0x02200000
109: #define BCM5600_ADDR_PTABLE0 0x03000000
110: #define BCM5600_ADDR_PTABLE1 0x03100000
111: #define BCM5600_ADDR_PTABLE2 0x03200000
112: #define BCM5600_ADDR_VTABLE0 0x05000000
113: #define BCM5600_ADDR_VTABLE1 0x05100000
114: #define BCM5600_ADDR_VTABLE2 0x05200000
115: #define BCM5600_ADDR_TTR0 0x06000000
116: #define BCM5600_ADDR_TBMAP0 0x06010000
117: #define BCM5600_ADDR_TTR1 0x06100000
118: #define BCM5600_ADDR_TBMAP1 0x06110000
119: #define BCM5600_ADDR_TTR2 0x06200000
120: #define BCM5600_ADDR_TBMAP2 0x06210000
121: #define BCM5600_ADDR_IMASK0 0x07000000
122: #define BCM5600_ADDR_IRULE0 0x07020000
123: #define BCM5600_ADDR_IMASK1 0x07100000
124: #define BCM5600_ADDR_IRULE1 0x07120000
125: #define BCM5600_ADDR_IMASK2 0x07200000
126: #define BCM5600_ADDR_IRULE2 0x07220000
127: #define BCM5600_ADDR_GIMASK 0x07300000
128: #define BCM5600_ADDR_GIRULE 0x07320000
129: #define BCM5600_ADDR_MARL0 0x08000000
130: #define BCM5600_ADDR_MARL1 0x08100000
131: #define BCM5600_ADDR_MARL2 0x08200000
132: #define BCM5600_ADDR_L3 0x09000000
133: #define BCM5600_ADDR_DEFIP 0x09010000
134: #define BCM5600_ADDR_L3INTF 0x09020000
135: #define BCM5600_ADDR_IPMC 0x09030000
136: #define BCM5600_ADDR_CBPHDR 0x0A600000
137: #define BCM5600_ADDR_CAB0 0x0A610000
138: #define BCM5600_ADDR_CAB1 0x0A620000
139: #define BCM5600_ADDR_CAB2 0x0A630000
140: #define BCM5600_ADDR_CAB3 0x0A640000
141: #define BCM5600_ADDR_CCP 0x0A650000
142: #define BCM5600_ADDR_PPP 0x0A660000
143: #define BCM5600_ADDR_CFAP 0x0A670000
144: #define BCM5600_ADDR_SFAP 0x0A680000
145: #define BCM5600_ADDR_CBPDATA0 0x0A6A0000
146: #define BCM5600_ADDR_CBPDATA1 0x0A6B0000
147: #define BCM5600_ADDR_CBPDATA2 0x0A6C0000
148: #define BCM5600_ADDR_CBPDATA3 0x0A6D0000
149: #define BCM5600_ADDR_PID 0x0A900000
150: #define BCM5600_ADDR_XQ_BASE 0x0B600000
151: #define BCM5600_ADDR_GBP 0x12000000
152:
153: /* Number of "Data Words" */
154: #define BCM5600_DW_MAX 32
155:
156: /* === VTABLE definitions === */
157: /* Word 0 */
158: #define BCM5600_VTABLE_VLAN_TAG_MASK 0x00000FFF
159:
160: /* Word 1: Port bitmap */
161: #define BCM5600_VTABLE_PORT_BMAP_MASK 0x1FFFFFFF
162:
163: /* Word 2: Untagged port bitmap */
164: #define BCM5600_VTABLE_UT_PORT_BMAP_MASK 0x1FFFFFFF
165:
166: /* Word 3: Module bitmap */
167: #define BCM5600_VTABLE_MOD_BMAP_MASK 0xFFFFFFFF
168:
169: /* === PTABLE definitions === */
170: /* Word 0 */
171: #define BCM5600_PTABLE_VLAN_TAG_MASK 0x00000FFF
172: #define BCM5600_PTABLE_SP_ST_MASK 0x00003000
173: #define BCM5600_PTABLE_SP_ST_SHIFT 12
174: #define BCM5600_PTABLE_PRT_DIS_MASK 0x000FC000
175: #define BCM5600_PTABLE_PRT_DIS_SHIFT 14
176: #define BCM5600_PTABLE_JUMBO_FLAG 0x00100000
177: #define BCM5600_PTABLE_RTAG_MASK 0x00E00000
178: #define BCM5600_PTABLE_RTAG_SHIFT 21
179: #define BCM5600_PTABLE_TGID_MASK 0x07000000
180: #define BCM5600_PTABLE_TGID_SHIFT 24
181: #define BCM5600_PTABLE_TRUNK_FLAG 0x08000000
182: #define BCM5600_PTABLE_CPU_FLAG 0x10000000
183: #define BCM5600_PTABLE_PTYPE_MASK 0x60000000
184: #define BCM5600_PTABLE_PTYPE_SHIFT 29
185: #define BCM5600_PTABLE_BPDU_FLAG 0x80000000
186:
187: /* Word 1 */
188: #define BCM5600_PTABLE_PORT_BMAP_MASK 0x1FFFFFFF
189: #define BCM5600_PTABLE_MI_FLAG 0x20000000
190: #define BCM5600_PTABLE_CML_MASK 0xC0000000
191: #define BCM5600_PTABLE_CML_SHIFT 30
192:
193: /* Word 2 */
194: #define BCM5600_PTABLE_UT_PORT_BMAP_MASK 0x1FFFFFFF
195:
196: /* Word 4 */
197: #define BCM5600_PTABLE_DSCP_MASK 0x0000003F
198: #define BCM5600_PTABLE_DSCP_SHIFT 0
199: #define BCM5600_PTABLE_DSE_MODE_MASK 0x000000C0
200: #define BCM5600_PTABLE_DSE_MODE_SHIFT 6
201: #define BCM5600_PTABLE_RPE_FLAG 0x00000100
202: #define BCM5600_PTABLE_PRI_MASK 0x00000E00
203: #define BCM5600_PTABLE_PRI_SHIFT 9
204: #define BCM5600_PTABLE_L3_DIS_FLAG 0x00001000
205:
206:
207: /* === ARL (Addess Resolution Logic) definitions === */
208: /* Word 0: MAC address LSB */
209:
210: /* Word 1 */
211: #define BCM5600_ARL_MAC_MSB_MASK 0x0000FFFF
212: #define BCM5600_ARL_VLAN_TAG_MASK 0x0FFF0000
213: #define BCM5600_ARL_VLAN_TAG_SHIFT 16
214: #define BCM5600_ARL_COS_DST_MASK 0x70000000
215: #define BCM5600_ARL_COS_DST_SHIFT 28
216: #define BCM5600_ARL_CPU_FLAG 0x80000000
217:
218: /* Word 2 */
219: #define BCM5600_ARL_L3_FLAG 0x00000001
220: #define BCM5600_ARL_SD_DIS_MASK 0x00000006
221: #define BCM5600_ARL_SD_DIS_SHIFT 1
222: #define BCM5600_ARL_ST_FLAG 0x00000008
223: #define BCM5600_ARL_HIT_FLAG 0x00000010
224: #define BCM5600_ARL_COS_SRC_MASK 0x000000E0
225: #define BCM5600_ARL_COS_SRC_SHIFT 5
226: #define BCM5600_ARL_TRUNK_FLAG 0x00000100
227: #define BCM5600_ARL_TGID_MASK 0x00000E00
228: #define BCM5600_ARL_TGID_SHIFT 9
229: #define BCM5600_ARL_RTAG_MASK 0x00007000
230: #define BCM5600_ARL_RTAG_SHIFT 12
231: #define BCM5600_ARL_PORT_MASK 0x001F8000
232: #define BCM5600_ARL_PORT_SHIFT 15
233: #define BCM5600_ARL_SCP_FLAG 0x00200000
234: #define BCM5600_ARL_MOD_ID_MASK 0x07C00000
235: #define BCM5600_ARL_MOD_ID_SHIFT 22
236:
237: /* === Multicast ARL definitions === */
238: /* Word 0: MAC address LSB */
239:
240: /* Word 1 */
241: #define BCM5600_MARL_MAC_MSB_MASK 0x0000FFFF
242: #define BCM5600_MARL_VLAN_TAG_MASK 0x0FFF0000
243: #define BCM5600_MARL_VLAN_TAG_SHIFT 16
244: #define BCM5600_MARL_COS_DST_MASK 0x70000000
245: #define BCM5600_MARL_COS_DST_SHIFT 28
246:
247: /* Word 2 */
248: #define BCM5600_MARL_PORT_BMAP_MASK 0x1FFFFFFF
249:
250: /* Word 3 */
251: #define BCM5600_MARL_UT_PORT_BMAP_MASK 0x1FFFFFFF
252:
253: /* Word 4 */
254: #define BCM5600_MARL_MOD_BMAP_MASK 0xFFFFFFFF
255:
256: /* === Trunk bitmap === */
257: #define BCM5600_TBMAP_MASK 0x0FFFFFFF
258:
259: /* === Trunk table === */
260: /* Word 0 */
261: #define BCM5600_TTR_TP0_MASK 0x0000003F
262: #define BCM5600_TTR_TP0_SHIFT 0
263: #define BCM5600_TTR_TP1_MASK 0x00000FC0
264: #define BCM5600_TTR_TP1_SHIFT 6
265: #define BCM5600_TTR_TP2_MASK 0x0003F000
266: #define BCM5600_TTR_TP2_SHIFT 12
267: #define BCM5600_TTR_TP3_MASK 0x00FC0000
268: #define BCM5600_TTR_TP3_SHIFT 18
269: #define BCM5600_TTR_TP4_MASK 0x3F000000
270: #define BCM5600_TTR_TP4_SHIFT 24
271:
272: /* Word 1 */
273: #define BCM5600_TTR_TP5_MASK 0x0000003F
274: #define BCM5600_TTR_TP5_SHIFT 0
275: #define BCM5600_TTR_TP6_MASK 0x00000FC0
276: #define BCM5600_TTR_TP6_SHIFT 6
277: #define BCM5600_TTR_TP7_MASK 0x0003F000
278: #define BCM5600_TTR_TP7_SHIFT 12
279:
280: #define BCM5600_TTR_TG_SIZE_MASK 0x003C0000
281: #define BCM5600_TTR_TG_SIZE_SHIFT 18
282:
283: /* Trunks (port aggregation) */
284: #define BCM5600_MAX_TRUNKS 6
285: #define BCM5600_MAX_PORTS_PER_TRUNK 8
286:
287: /* ======================================================================= */
288:
289: /* Transmit descriptor size */
290: #define BCM5600_TXD_SIZE 32
291: #define BCM5600_TXD_RING_CONT 0x80000000 /* ring is continuing */
292: #define BCM5600_TXD_UNKNOWN 0x04000000 /* valid packet (?) */
293: #define BCM5600_TXD_NEOP 0x00040000 /* end of packet if not set */
294:
295: /* Receive descriptor size */
296: #define BCM5600_RXD_SIZE 32
297: #define BCM5600_RXD_RING_CONT 0x80000000 /* ring is continuing */
298: #define BCM5600_RXD_UNKNOWN 0x00040000 /* unknown */
299:
300: /* Interrupt sources */
301: #define BCM5600_INTR_STAT_ITER_DONE 0x00100000 /* Unknown */
302: #define BCM5600_INTR_RX_UNDERRUN 0x00000400 /* RX ring underrun */
303: #define BCM5600_INTR_RX_AVAIL 0x00000200 /* packet available */
304: #define BCM5600_INTR_TX_UNDERRUN 0x00000100 /* TX ring underrun */
305: #define BCM5600_INTR_LINKSTAT_MOD 0x00000010 /* Link status modified */
306:
307: /* ======================================================================= */
308:
309: /* Port Mirroring */
310: #define BCM5600_MIRROR_ENABLE 0x40
311: #define BCM5600_MIRROR_PORT_MASK 0x3F
312:
313: /* ======================================================================= */
314:
315: #define BCM5600_REG_HASH_SIZE 8192
316:
317: /* BCM5600 register */
318: struct bcm5600_reg {
319: m_uint32_t addr;
320: m_uint32_t value;
321: struct bcm5600_reg *next;
322: };
323:
324: /* BCM5600 table */
325: struct bcm5600_table {
326: char *name;
327: long offset;
328: m_uint32_t addr;
329: u_int min_index,max_index;
330: u_int nr_words;
331: };
332:
333: /* BCM5600 in-transit packet */
334: struct bcm5600_pkt {
335: /* Received packet data */
336: u_char *pkt;
337: ssize_t pkt_len;
338:
339: /* Rewritten packet (802.1Q tag pushed or poped) */
340: u_char *rewr_pkt;
341: int rewrite_done;
342:
343: /* Original VLAN (-1 for untagged packet) and Real VLAN */
344: int orig_vlan,real_vlan;
345:
346: /* VLAN entry */
347: m_uint32_t *vlan_entry;
348:
349: /* Ingress Port and Egress Port bitmap */
350: u_int ingress_port,egress_bitmap,egress_ut_bitmap;
351: u_int egress_filter_bitmap;
352:
353: /* RX descriptor */
354: m_uint32_t rdes[4];
355:
356: /* Packet sent to CPU */
357: u_int sent_to_cpu;
358: };
359:
360: /* BCM5600 physical port */
361: struct bcm5600_port {
362: netio_desc_t *nio;
363: u_int id;
364: char name[32];
365: };
366:
367: /* NM-16ESW private data */
368: struct nm_16esw_data {
369: char *name;
370: u_int nr_port;
371:
372: vm_instance_t *vm;
373: struct vdevice *dev;
374: struct pci_device *pci_dev;
375:
376: pthread_mutex_t lock;
377:
378: /* Ager task */
379: timer_id ager_tid;
380:
381: /* S-channel command and command result */
382: m_uint32_t schan_cmd,schan_cmd_res;
383:
384: /* Data Words */
385: m_uint32_t dw[BCM5600_DW_MAX];
386:
387: /* Interrupt mask */
388: m_uint32_t intr_mask;
389:
390: /* MII registers */
391: m_uint16_t mii_regs[64][32];
392: m_uint32_t mii_input,mii_output;
393: u_int mii_intr;
394:
395: /* RX/TX rings addresses */
396: m_uint32_t rx_ring_addr,tx_ring_addr;
397: m_uint32_t tx_current,tx_end_scan;
398: m_uint32_t rx_current,rx_end_scan;
399:
400: /* TX ring scanner task id */
401: ptask_id_t tx_tid;
402:
403: /* TX buffer */
404: u_char tx_buffer[BCM5600_MAX_PKT_SIZE];
405: u_int tx_bufsize;
406:
407: /* Port Mirroring */
408: u_int mirror_dst_port;
409: u_int mirror_egress_ports;
410:
411: /* Registers hash table */
412: struct bcm5600_reg *reg_hash_table[BCM5600_REG_HASH_SIZE];
413:
414: /* Most used tables... */
415: struct bcm5600_table *t_ptable,*t_vtable;
416: struct bcm5600_table *t_arl,*t_marl;
417: struct bcm5600_table *t_tbmap,*t_ttr;
418:
419: /* Ports (only 16 are "real" and usable) */
420: struct bcm5600_port ports[32];
421:
422: /* CPU port */
423: u_int cpu_port;
424:
425: /* Current egress port of all trunks */
426: u_int trunk_last_egress_port[BCM5600_MAX_TRUNKS];
427:
428: /* ARL count table */
429: m_uint32_t *arl_cnt;
430:
431: /* ARL (Address Resolution Logic) Table */
432: m_uint32_t *arl_table;
433:
434: /* Multicast ARL Table */
435: m_uint32_t *marl_table;
436:
437: /* VTABLE (VLAN Table) */
438: m_uint32_t *vtable;
439:
440: /* Trunks */
441: m_uint32_t *ttr,*tbmap;
442:
443: /* PTABLE (Port Table) */
444: m_uint32_t *ptable;
445: };
446:
447: /* NM-16ESW Port physical port mapping table (Cisco => BCM) */
448: static int nm16esw_port_mapping[] = {
449: 2, 0, 6, 4, 10, 8, 14, 12, 3, 1, 7, 5, 11, 9, 15, 13,
450: };
451:
452: /* Log a BCM message */
453: #define BCM_LOG(d,msg...) vm_log((d)->vm,(d)->name,msg)
454:
455: /* Lock/Unlock primitives */
456: #define BCM_LOCK(d) pthread_mutex_lock(&(d)->lock)
457: #define BCM_UNLOCK(d) pthread_mutex_unlock(&(d)->lock)
458:
459: /* Trunk group info */
460: struct bcm5600_tg_info {
461: u_int index,mask,shift;
462: };
463:
464: static struct bcm5600_tg_info tg_info[8] = {
465: { 0, BCM5600_TTR_TP0_MASK, BCM5600_TTR_TP0_SHIFT },
466: { 0, BCM5600_TTR_TP1_MASK, BCM5600_TTR_TP1_SHIFT },
467: { 0, BCM5600_TTR_TP2_MASK, BCM5600_TTR_TP2_SHIFT },
468: { 0, BCM5600_TTR_TP3_MASK, BCM5600_TTR_TP3_SHIFT },
469: { 0, BCM5600_TTR_TP4_MASK, BCM5600_TTR_TP4_SHIFT },
470: { 1, BCM5600_TTR_TP5_MASK, BCM5600_TTR_TP5_SHIFT },
471: { 1, BCM5600_TTR_TP6_MASK, BCM5600_TTR_TP6_SHIFT },
472: { 1, BCM5600_TTR_TP7_MASK, BCM5600_TTR_TP7_SHIFT },
473: };
474:
475: /* Return port status (up or down), based on the MII register */
476: static int bcm5600_mii_port_status(struct nm_16esw_data *d,u_int port)
477: {
478: u_int mii_ctrl;
479:
480: mii_ctrl = d->mii_regs[port][0x00];
481:
482: /* Isolate bit */
483: return(!(mii_ctrl & 0x400));
484: }
485:
486: /* Build port status bitmap */
487: static m_uint32_t bcm5600_mii_port_status_bmp(struct nm_16esw_data *d)
488: {
489: m_uint32_t bmp;
490: int i;
491:
492: for(i=0,bmp=0;i<d->nr_port;i++)
493: if (bcm5600_mii_port_status(d,i))
494: bmp |= 1 << i;
495:
496: return(bmp);
497: }
498:
499: /* Read a MII register */
500: static void bcm5600_mii_read(struct nm_16esw_data *d)
501: {
502: m_uint8_t port,reg;
503:
504: port = (d->mii_input >> 16) & 0xFF;
505: reg = (d->mii_input >> 24) & 0xFF;
506:
507: if ((port < 32) && (reg < 32)) {
508: d->mii_output = d->mii_regs[port][reg];
509:
510: switch(reg) {
511: case 0x00:
512: d->mii_output &= ~0x8200;
513: break;
514: case 0x01:
515: if (d->ports[port].nio && bcm5600_mii_port_status(d,port))
516: d->mii_output = 0x782C;
517: else
518: d->mii_output = 0;
519: break;
520: case 0x02:
521: d->mii_output = 0x40;
522: break;
523: case 0x03:
524: d->mii_output = 0x61d4;
525: break;
526: case 0x04:
527: d->mii_output = 0x1E1;
528: break;
529: case 0x05:
530: d->mii_output = 0x41E1;
531: break;
532: default:
533: d->mii_output = 0;
534: }
535: }
536: }
537:
538: /* Write a MII register */
539: static void bcm5600_mii_write(struct nm_16esw_data *d)
540: {
541: m_uint8_t port,reg;
542: m_uint16_t isolation;
543:
544: port = (d->mii_input >> 16) & 0xFF;
545: reg = (d->mii_input >> 24) & 0xFF;
546:
547: if ((port < 32) && (reg < 32))
548: {
549: #if DEBUG_MII
550: BCM_LOG(d,"MII: port 0x%4.4x, reg 0x%2.2x: writing 0x%4.4x\n",
551: port,reg,d->mii_input & 0xFFFF);
552: #endif
553:
554: /* Check if PHY isolation status is changing */
555: if (reg == 0) {
556: isolation = (d->mii_input ^ d->mii_regs[port][reg]) & 0x400;
557:
558: if (isolation) {
559: #if DEBUG_MII
560: BCM_LOG(d,"MII: port 0x%4.4x: generating IRQ\n",port);
561: #endif
562: d->mii_intr = TRUE;
563: pci_dev_trigger_irq(d->vm,d->pci_dev);
564: }
565: }
566:
567: d->mii_regs[port][reg] = d->mii_input & 0xFFFF;
568: }
569: }
570:
571: /* Hash function for register */
572: static u_int bcm5600_reg_get_hash(m_uint32_t addr)
573: {
574: return((addr ^ (addr >> 16)) & (BCM5600_REG_HASH_SIZE - 1));
575: }
576:
577: /* Find a register entry */
578: static struct bcm5600_reg *bcm5600_reg_find(struct nm_16esw_data *d,
579: m_uint32_t addr)
580: {
581: struct bcm5600_reg *reg;
582: u_int h_index;
583:
584: h_index = bcm5600_reg_get_hash(addr);
585: for(reg=d->reg_hash_table[h_index];reg;reg=reg->next)
586: if (reg->addr == addr)
587: return reg;
588:
589: return NULL;
590: }
591:
592: /* Read a register */
593: static m_uint32_t bcm5600_reg_read(struct nm_16esw_data *d,m_uint32_t addr)
594: {
595: struct bcm5600_reg *reg;
596:
597: if (!(reg = bcm5600_reg_find(d,addr)))
598: return(0);
599:
600: return(reg->value);
601: }
602:
603: /* Write a register */
604: static int bcm5600_reg_write(struct nm_16esw_data *d,m_uint32_t addr,
605: m_uint32_t value)
606: {
607: struct bcm5600_reg *reg;
608: u_int h_index;
609:
610: if ((reg = bcm5600_reg_find(d,addr))) {
611: reg->value = value;
612: return(0);
613: }
614:
615: /* create a new register */
616: if (!(reg = malloc(sizeof(*reg))))
617: return(-1);
618:
619: reg->addr = addr;
620: reg->value = value;
621:
622: /* insert new register in hash table */
623: h_index = bcm5600_reg_get_hash(addr);
624: reg->next = d->reg_hash_table[h_index];
625: d->reg_hash_table[h_index] = reg;
626:
627: return(0);
628: }
629:
630: /* Register special handling */
631: static void bcm5600_reg_write_special(struct nm_16esw_data *d,
632: m_uint32_t addr,m_uint32_t value)
633: {
634: switch(addr) {
635: case 0x80006:
636: d->mirror_dst_port = value;
637: break;
638:
639: case 0x8000d:
640: d->mirror_egress_ports = value;
641: break;
642:
643: case 0x80009:
644: /* age timer */
645: break;
646: }
647: }
648:
649: /* Free memory used to store register info */
650: static void bcm5600_reg_free(struct nm_16esw_data *d)
651: {
652: struct bcm5600_reg *reg,*next;
653: int i;
654:
655: for(i=0;i<BCM5600_REG_HASH_SIZE;i++)
656: for(reg=d->reg_hash_table[i];reg;reg=next) {
657: next = reg->next;
658: free(reg);
659: }
660: }
661:
662: /* Dump all known registers */
663: static void bcm5600_reg_dump(struct nm_16esw_data *d,int show_null)
664: {
665: struct bcm5600_reg *reg;
666: int i;
667:
668: printf("%s: dumping registers:\n",d->name);
669:
670: for(i=0;i<BCM5600_REG_HASH_SIZE;i++)
671: for(reg=d->reg_hash_table[i];reg;reg=reg->next) {
672: if (reg->value || show_null)
673: printf(" 0x%8.8x: 0x%8.8x\n",reg->addr,reg->value);
674: }
675: }
676:
677: /* Fill a string buffer with all ports of the specified bitmap */
678: static char *bcm5600_port_bitmap_str(struct nm_16esw_data *d,
679: char *buffer,m_uint32_t bitmap)
680: {
681: char *ptr = buffer;
682: int i;
683:
684: *ptr = 0;
685:
686: for(i=0;i<d->nr_port;i++)
687: if (bitmap & (1 << i)) {
688: ptr += sprintf(ptr,"%s ",d->ports[i].name);
689: }
690:
691: return buffer;
692: }
693:
694: /* BCM5600 tables */
695: #define BCM_OFFSET(x) (OFFSET(struct nm_16esw_data,x))
696:
697: static struct bcm5600_table bcm5600_tables[] = {
698: /* ARL tables */
699: { "arlcnt0", BCM_OFFSET(arl_cnt), BCM5600_ADDR_ARLCNT0, 0, 0, 1 },
700: { "arlcnt1", BCM_OFFSET(arl_cnt), BCM5600_ADDR_ARLCNT1, 0, 0, 1 },
701: { "arlcnt2", BCM_OFFSET(arl_cnt), BCM5600_ADDR_ARLCNT2, 0, 0, 1 },
702:
703: /* ARL tables */
704: { "arl0", BCM_OFFSET(arl_table), BCM5600_ADDR_ARL0, 0, 8191, 3 },
705: { "arl1", BCM_OFFSET(arl_table), BCM5600_ADDR_ARL1, 0, 8191, 3 },
706: { "arl2", BCM_OFFSET(arl_table), BCM5600_ADDR_ARL2, 0, 8191, 3 },
707:
708: /* Multicast ARL tables */
709: { "marl0", BCM_OFFSET(marl_table), BCM5600_ADDR_MARL0, 1, 255, 5 },
710: { "marl1", BCM_OFFSET(marl_table), BCM5600_ADDR_MARL1, 1, 255, 5 },
711: { "marl2", BCM_OFFSET(marl_table), BCM5600_ADDR_MARL2, 1, 255, 5 },
712:
713: /* PTABLE - Physical Ports */
714: { "ptable0", BCM_OFFSET(ptable), BCM5600_ADDR_PTABLE0, 0, 31, 6 },
715: { "ptable1", BCM_OFFSET(ptable), BCM5600_ADDR_PTABLE1, 0, 31, 6 },
716: { "ptable2", BCM_OFFSET(ptable), BCM5600_ADDR_PTABLE2, 0, 31, 6 },
717:
718: /* VTABLE - VLANs */
719: { "vtable0", BCM_OFFSET(vtable), BCM5600_ADDR_VTABLE0, 1, 255, 4 },
720: { "vtable1", BCM_OFFSET(vtable), BCM5600_ADDR_VTABLE1, 1, 255, 4 },
721: { "vtable2", BCM_OFFSET(vtable), BCM5600_ADDR_VTABLE2, 1, 255, 4 },
722:
723: /* TTR */
724: { "ttr0", BCM_OFFSET(ttr), BCM5600_ADDR_TTR0, 0, 5, 3 },
725: { "ttr1", BCM_OFFSET(ttr), BCM5600_ADDR_TTR1, 0, 5, 3 },
726: { "ttr2", BCM_OFFSET(ttr), BCM5600_ADDR_TTR2, 0, 5, 3 },
727:
728: /* TBMAP */
729: { "tbmap0", BCM_OFFSET(tbmap), BCM5600_ADDR_TBMAP0, 0, 5, 1 },
730: { "tbmap1", BCM_OFFSET(tbmap), BCM5600_ADDR_TBMAP1, 0, 5, 1 },
731: { "tbmap2", BCM_OFFSET(tbmap), BCM5600_ADDR_TBMAP2, 0, 5, 1 },
732:
733: { NULL, -1, 0, 0, 0 },
734: };
735:
736: /* Get table size (in number of words) */
737: static inline u_int bcm5600_table_get_size(struct bcm5600_table *table)
738: {
739: return(table->nr_words * (table->max_index + 1));
740: }
741:
742: /* Create automatically tables */
743: static int bcm5600_table_create(struct nm_16esw_data *d)
744: {
745: struct bcm5600_table *table;
746: m_uint32_t *array;
747: size_t nr_words;
748: int i;
749:
750: for(i=0;bcm5600_tables[i].name;i++)
751: {
752: table = &bcm5600_tables[i];
753: nr_words = bcm5600_table_get_size(table);
754:
755: if (!(array = calloc(nr_words,sizeof(m_uint32_t)))) {
756: fprintf(stderr,"BCM5600: unable to create table '%s'\n",table->name);
757: return(-1);
758: }
759:
760: *(PTR_ADJUST(m_uint32_t **,d,table->offset)) = array;
761: }
762:
763: return(0);
764: }
765:
766: /* Free tables */
767: static void bcm5600_table_free(struct nm_16esw_data *d)
768: {
769: struct bcm5600_table *table;
770: m_uint32_t **array;
771: int i;
772:
773: for(i=0;bcm5600_tables[i].name;i++) {
774: table = &bcm5600_tables[i];
775: array = (PTR_ADJUST(m_uint32_t **,d,table->offset));
776: free(*array);
777:
778: /* avoid freeing the same table multiple times */
779: *array = NULL;
780: }
781: }
782:
783: /* Find a table given its address */
784: static struct bcm5600_table *bcm5600_table_find(struct nm_16esw_data *d,
785: m_uint32_t addr)
786: {
787: int i;
788:
789: for(i=0;bcm5600_tables[i].name;i++)
790: if (bcm5600_tables[i].addr == addr)
791: return(&bcm5600_tables[i]);
792:
793: #if DEBUG_UNKNOWN
794: BCM_LOG(d,"unknown table at address 0x%8.8x\n",addr);
795: #endif
796: return NULL;
797: }
798:
799: /* Get a table entry */
800: static inline m_uint32_t *bcm5600_table_get_entry(struct nm_16esw_data *d,
801: struct bcm5600_table *table,
802: m_uint32_t index)
803: {
804: m_uint32_t *array;
805:
806: if ((index < table->min_index) || (index > table->max_index))
807: return NULL;
808:
809: array = *(PTR_ADJUST(m_uint32_t **,d,table->offset));
810: return(&array[index*table->nr_words]);
811: }
812:
813: /* Read a table entry */
814: static int bcm5600_table_read_entry(struct nm_16esw_data *d)
815: {
816: struct bcm5600_table *table;
817: m_uint32_t addr,index,*entry;
818: int i;
819:
820: addr = d->dw[1] & 0xFFFF0000;
821: index = d->dw[1] & 0x0000FFFF;
822:
823: if (!(table = bcm5600_table_find(d,addr))) {
824: #if DEBUG_UNKNOWN
825: BCM_LOG(d,"unknown mem address at address 0x%8.8x\n",d->dw[1]);
826: #endif
827: return(-1);
828: }
829:
830: if (!(entry = bcm5600_table_get_entry(d,table,index)))
831: return(-1);
832:
833: #if DEBUG_MEM
834: BCM_LOG(d,"READ_MEM: addr=0x%8.8x (table %s)\n",d->dw[1],table->name);
835: #endif
836:
837: for(i=0;i<table->nr_words;i++)
838: d->dw[i+1] = entry[i];
839:
840: return(0);
841: }
842:
843: /* Write a table entry */
844: static int bcm5600_table_write_entry(struct nm_16esw_data *d)
845: {
846: struct bcm5600_table *table;
847: m_uint32_t addr,index,*entry;
848: int i;
849:
850: addr = d->dw[1] & 0xFFFF0000;
851: index = d->dw[1] & 0x0000FFFF;
852:
853: if (!(table = bcm5600_table_find(d,addr)))
854: return(-1);
855:
856: if (!(entry = bcm5600_table_get_entry(d,table,index)))
857: return(-1);
858:
859: for(i=0;i<table->nr_words;i++)
860: entry[i] = d->dw[i+2];
861:
862: #if DEBUG_MEM
863: {
864: char buffer[512],*ptr = buffer;
865:
866: for(i=0;i<table->nr_words;i++)
867: ptr += sprintf(ptr,"data[%d]=0x%8.8x ",i,entry[i]);
868:
869: BCM_LOG(d,"WRITE_MEM: addr=0x%8.8x (table %s) %s\n",
870: d->dw[1],table->name,buffer);
871: }
872: #endif
873: return(0);
874: }
875:
876: /* Dump a table (for debugging) */
877: static int bcm5600_table_dump(struct nm_16esw_data *d,m_uint32_t addr)
878: {
879: struct bcm5600_table *table;
880: m_uint32_t *entry;
881: int i,j;
882:
883: if (!(table = bcm5600_table_find(d,addr)))
884: return(-1);
885:
886: printf("%s: dumping table \"%s\":\n",d->name,table->name);
887:
888: for(i=table->min_index;i<=table->max_index;i++) {
889: if (!(entry = bcm5600_table_get_entry(d,table,i)))
890: break;
891:
892: printf(" %4d:",i);
893:
894: for(j=0;j<table->nr_words;j++)
895: printf("0x%8.8x ",entry[j]);
896:
897: printf("\n");
898: }
899:
900: printf("\n");
901: return(0);
902: }
903:
904: /* Dump the VLAN table */
905: static int bcm5600_dump_vtable(struct nm_16esw_data *d)
906: {
907: struct bcm5600_table *table;
908: struct bcm5600_port *port;
909: m_uint32_t *entry,tbmp,ubmp;
910: u_int vlan;
911: int i,j;
912:
913: if (!(table = bcm5600_table_find(d,BCM5600_ADDR_VTABLE0)))
914: return(-1);
915:
916: printf("%s: dumping VLAN table:\n",d->name);
917:
918: for(i=table->min_index;i<=table->max_index;i++) {
919: if (!(entry = bcm5600_table_get_entry(d,table,i)))
920: break;
921:
922: /* Extract the VLAN info */
923: vlan = entry[0] & BCM5600_VTABLE_VLAN_TAG_MASK;
924:
925: if (vlan == VLAN_INVALID)
926: continue;
927:
928: printf(" VLAN %4u: ",vlan);
929:
930: for(j=0;j<d->nr_port;j++) {
931: tbmp = entry[1] & (1 << j);
932: ubmp = entry[2] & (1 << j);
933:
934: if (tbmp || ubmp) {
935: port = &d->ports[j];
936:
937: printf("%s (",port->name);
938:
939: if (tbmp)
940: printf("T%s",ubmp ? "/" : ") ");
941:
942: if (ubmp)
943: printf("UT) ");
944: }
945: }
946:
947: printf("\n");
948: }
949:
950: printf("\n");
951: return(0);
952: }
953:
954: /* Dump the "trunk" ports */
955: static int bcm5600_dump_trunks(struct nm_16esw_data *d)
956: {
957: struct bcm5600_table *table;
958: struct bcm5600_port *port;
959: m_uint32_t *entry;
960: int i,j;
961:
962: if (!(table = bcm5600_table_find(d,BCM5600_ADDR_TBMAP0)))
963: return(-1);
964:
965: printf("%s: trunk ports:\n",d->name);
966:
967: for(i=table->min_index;i<=table->max_index;i++) {
968: if (!(entry = bcm5600_table_get_entry(d,table,i)))
969: break;
970:
971: if (!entry[0])
972: continue;
973:
974: printf(" Trunk %d: ",i);
975:
976: for(j=0;j<d->nr_port;j++) {
977: if (entry[0] & (1 << j)) {
978: port = &d->ports[j];
979: printf("%s ",port->name);
980: }
981: }
982:
983: printf("\n");
984: }
985:
986: printf("\n");
987: return(0);
988: }
989:
990: /* Dump the physical port info */
991: static int bcm5600_dump_ports(struct nm_16esw_data *d)
992: {
993: struct bcm5600_table *table;
994: struct bcm5600_port *port;
995: m_uint32_t *entry;
996: u_int vlan,tgid;
997: int i;
998:
999: if (!(table = bcm5600_table_find(d,BCM5600_ADDR_PTABLE0)))
1000: return(-1);
1001:
1002: printf("%s: physical ports:\n",d->name);
1003:
1004: for(i=0;i<d->nr_port;i++) {
1005: if (!(entry = bcm5600_table_get_entry(d,table,i)))
1006: break;
1007:
1008: port = &d->ports[i];
1009: vlan = entry[0] & BCM5600_PTABLE_VLAN_TAG_MASK;
1010:
1011: printf(" %-10s: VLAN %u",port->name,vlan);
1012:
1013: if (entry[0] & BCM5600_PTABLE_TRUNK_FLAG) {
1014: tgid = entry[0] & BCM5600_PTABLE_TGID_MASK;
1015: tgid >>= BCM5600_PTABLE_TGID_SHIFT;
1016:
1017: printf(", Trunk Group %u ",tgid);
1018: }
1019:
1020: printf("\n");
1021: }
1022:
1023: printf("\n");
1024: return(0);
1025: }
1026:
1027: /* Dump the physical port bitmaps */
1028: static int bcm5600_dump_port_bitmaps(struct nm_16esw_data *d)
1029: {
1030: struct bcm5600_table *table;
1031: struct bcm5600_port *port;
1032: m_uint32_t *entry,tbmp,ubmp;
1033: int i,j;
1034:
1035: if (!(table = bcm5600_table_find(d,BCM5600_ADDR_PTABLE0)))
1036: return(-1);
1037:
1038: printf("%s: dumping bitmaps of the port table:\n",d->name);
1039:
1040: for(i=0;i<d->nr_port;i++) {
1041: if (!(entry = bcm5600_table_get_entry(d,table,i)))
1042: break;
1043:
1044: port = &d->ports[i];
1045:
1046: printf(" %-10s: ",port->name);
1047:
1048: for(j=0;j<d->nr_port;j++) {
1049: tbmp = entry[1] & (1 << j);
1050: ubmp = entry[2] & (1 << j);
1051:
1052: if (tbmp || ubmp) {
1053: printf("%s (",d->ports[j].name);
1054:
1055: if (tbmp)
1056: printf("T%s",ubmp ? "/" : ") ");
1057:
1058: if (ubmp)
1059: printf("UT) ");
1060: }
1061: }
1062:
1063: printf("\n");
1064: }
1065:
1066: printf("\n");
1067: return(0);
1068: }
1069:
1070: /* Dump main tables */
1071: static void bcm5600_dump_main_tables(struct nm_16esw_data *d)
1072: {
1073: bcm5600_dump_ports(d);
1074: bcm5600_dump_port_bitmaps(d);
1075: bcm5600_dump_vtable(d);
1076: bcm5600_dump_trunks(d);
1077: }
1078:
1079: /* Find a free ARL entry */
1080: static int bcm5600_find_free_arl_entry(struct nm_16esw_data *d)
1081: {
1082: struct bcm5600_table *table = d->t_arl;
1083:
1084: if (d->arl_cnt[0] == table->max_index)
1085: return(-1);
1086:
1087: return(d->arl_cnt[0] - 1);
1088: }
1089:
1090: /* ARL Lookup. TODO: this must be optimized in the future. */
1091: static inline int bcm5600_gen_arl_lookup(struct nm_16esw_data *d,
1092: struct bcm5600_table *table,
1093: u_int index_start,u_int index_end,
1094: n_eth_addr_t *mac_addr,
1095: u_int vlan)
1096: {
1097: m_uint32_t *entry,tmp[2],mask;
1098: int i;
1099:
1100: tmp[0] = mac_addr->eth_addr_byte[2] << 24;
1101: tmp[0] |= mac_addr->eth_addr_byte[3] << 16;
1102: tmp[0] |= mac_addr->eth_addr_byte[4] << 8;
1103: tmp[0] |= mac_addr->eth_addr_byte[5];
1104:
1105: tmp[1] = (mac_addr->eth_addr_byte[0] << 8) | mac_addr->eth_addr_byte[1];
1106: tmp[1] |= vlan << BCM5600_ARL_VLAN_TAG_SHIFT;
1107:
1108: mask = BCM5600_ARL_VLAN_TAG_MASK | BCM5600_ARL_MAC_MSB_MASK;
1109:
1110: for(i=index_start;i<index_end;i++) {
1111: entry = bcm5600_table_get_entry(d,table,i);
1112:
1113: if ((entry[0] == tmp[0]) && ((entry[1] & mask) == tmp[1]))
1114: return(i);
1115: }
1116:
1117: return(-1);
1118: }
1119:
1120: /* ARL Lookup */
1121: static inline int bcm5600_arl_lookup(struct nm_16esw_data *d,
1122: n_eth_addr_t *mac_addr,
1123: u_int vlan)
1124: {
1125: struct bcm5600_table *table = d->t_arl;
1126: return(bcm5600_gen_arl_lookup(d,table,1,d->arl_cnt[0]-1,mac_addr,vlan));
1127: }
1128:
1129: /* MARL Lookup */
1130: static inline int bcm5600_marl_lookup(struct nm_16esw_data *d,
1131: n_eth_addr_t *mac_addr,
1132: u_int vlan)
1133: {
1134: struct bcm5600_table *table = d->t_marl;
1135: return(bcm5600_gen_arl_lookup(d,table,table->min_index,table->max_index+1,
1136: mac_addr,vlan));
1137: }
1138:
1139: /* Invalidate an ARL entry */
1140: static void bcm5600_invalidate_arl_entry(m_uint32_t *entry)
1141: {
1142: entry[0] = entry[1] = entry[2] = 0;
1143: }
1144:
1145: /* Insert an entry into the ARL table */
1146: static int bcm5600_insert_arl_entry(struct nm_16esw_data *d)
1147: {
1148: struct bcm5600_table *table = d->t_arl;
1149: m_uint32_t *entry,mask;
1150: int i,index;
1151:
1152: mask = BCM5600_ARL_VLAN_TAG_MASK | BCM5600_ARL_MAC_MSB_MASK;
1153:
1154: for(i=0;i<d->arl_cnt[0]-1;i++) {
1155: entry = bcm5600_table_get_entry(d,table,i);
1156:
1157: /* If entry already exists, just modify it */
1158: if ((entry[0] == d->dw[1]) && ((entry[1] & mask) == (d->dw[2] & mask))) {
1159: entry[0] = d->dw[1];
1160: entry[1] = d->dw[2];
1161: entry[2] = d->dw[3];
1162: d->dw[1] = i;
1163: return(0);
1164: }
1165: }
1166:
1167: index = d->arl_cnt[0] - 1;
1168:
1169: entry = bcm5600_table_get_entry(d,table,index);
1170: entry[0] = d->dw[1];
1171: entry[1] = d->dw[2];
1172: entry[2] = d->dw[3];
1173: d->dw[1] = index;
1174:
1175: d->arl_cnt[0]++;
1176: return(0);
1177: }
1178:
1179: /* Delete an entry from the ARL table */
1180: static int bcm5600_delete_arl_entry(struct nm_16esw_data *d)
1181: {
1182: struct bcm5600_table *table;
1183: m_uint32_t *entry,*last_entry,mac_msb;
1184: u_int cvlan,vlan;
1185: int i;
1186:
1187: if (!(table = bcm5600_table_find(d,BCM5600_ADDR_ARL0)))
1188: return(-1);
1189:
1190: vlan = d->dw[2] & BCM5600_ARL_VLAN_TAG_MASK;
1191: vlan >>= BCM5600_ARL_VLAN_TAG_SHIFT;
1192:
1193: mac_msb = d->dw[2] & BCM5600_ARL_MAC_MSB_MASK;
1194:
1195: for(i=table->min_index;i<=table->max_index;i++) {
1196: entry = bcm5600_table_get_entry(d,table,i);
1197:
1198: /* compare VLANs and MAC addresses */
1199: cvlan = (entry[1] & BCM5600_ARL_VLAN_TAG_MASK);
1200: cvlan >>= BCM5600_ARL_VLAN_TAG_SHIFT;
1201:
1202: if ((cvlan == vlan) && (entry[0] == d->dw[1]) &&
1203: ((entry[1] & BCM5600_ARL_MAC_MSB_MASK) == mac_msb))
1204: {
1205: d->dw[1] = i;
1206:
1207: last_entry = bcm5600_table_get_entry(d,d->t_arl,d->arl_cnt[0]-2);
1208:
1209: entry[0] = last_entry[0];
1210: entry[1] = last_entry[1];
1211: entry[2] = last_entry[2];
1212:
1213: d->arl_cnt[0]--;
1214: return(i);
1215: }
1216: }
1217:
1218: return(0);
1219: }
1220:
1221: /* Reset the ARL tables */
1222: static int bcm5600_reset_arl(struct nm_16esw_data *d)
1223: {
1224: struct bcm5600_table *table;
1225: m_uint32_t *entry;
1226: int i;
1227:
1228: if (!(table = bcm5600_table_find(d,BCM5600_ADDR_ARL0)))
1229: return(-1);
1230:
1231: for(i=table->min_index;i<=table->max_index;i++) {
1232: entry = bcm5600_table_get_entry(d,table,i);
1233: bcm5600_invalidate_arl_entry(entry);
1234: }
1235:
1236: return(0);
1237: }
1238:
1239: /* MAC Address Ager */
1240: static int bcm5600_arl_ager(struct nm_16esw_data *d)
1241: {
1242: m_uint32_t *entry,*last_entry;
1243: int i;
1244:
1245: BCM_LOCK(d);
1246:
1247: for(i=1;i<d->arl_cnt[0]-1;i++) {
1248: entry = bcm5600_table_get_entry(d,d->t_arl,i);
1249: assert(entry);
1250:
1251: if (entry[2] & BCM5600_ARL_ST_FLAG)
1252: continue;
1253:
1254: /* The entry has expired, purge it */
1255: if (!(entry[2] & BCM5600_ARL_HIT_FLAG)) {
1256: last_entry = bcm5600_table_get_entry(d,d->t_arl,d->arl_cnt[0]-2);
1257:
1258: entry[0] = last_entry[0];
1259: entry[1] = last_entry[1];
1260: entry[2] = last_entry[2];
1261:
1262: d->arl_cnt[0]--;
1263: i--;
1264: } else {
1265: entry[2] &= ~BCM5600_ARL_HIT_FLAG;
1266: }
1267: }
1268:
1269: BCM_UNLOCK(d);
1270: return(TRUE);
1271: }
1272:
1273: /* Get the VTABLE entry matching the specified VLAN */
1274: static m_uint32_t *bcm5600_vtable_get_entry_by_vlan(struct nm_16esw_data *d,
1275: u_int vlan)
1276: {
1277: struct bcm5600_table *table = d->t_vtable;
1278: m_uint32_t *entry;
1279: int i;
1280:
1281: for(i=table->min_index;i<=table->max_index;i++) {
1282: if (!(entry = bcm5600_table_get_entry(d,table,i)))
1283: break;
1284:
1285: if ((entry[0] & BCM5600_VTABLE_VLAN_TAG_MASK) == vlan)
1286: return entry;
1287: }
1288:
1289: return NULL;
1290: }
1291:
1292: /* Read memory command */
1293: static void bcm5600_handle_read_mem_cmd(struct nm_16esw_data *d)
1294: {
1295: int i;
1296:
1297: if (bcm5600_table_read_entry(d) != 0) {
1298: for(i=1;i<BCM5600_DW_MAX;i++)
1299: d->dw[i] = 0;
1300: }
1301:
1302: d->dw[0] = BCM5600_OP_READ_MEM_ACK << BCM5600_CMD_OP_SHIFT;
1303: }
1304:
1305: /* Write memory command */
1306: static void bcm5600_handle_write_mem_cmd(struct nm_16esw_data *d)
1307: {
1308: bcm5600_table_write_entry(d);
1309: d->dw[0] = BCM5600_OP_WRITE_MEM_ACK << BCM5600_CMD_OP_SHIFT;
1310: }
1311:
1312: /* Handle a "general" command */
1313: static void bcm5600_handle_gen_cmd(struct nm_16esw_data *d)
1314: {
1315: m_uint32_t op,src,dst,len;
1316:
1317: /* Extract the opcode */
1318: op = (d->dw[0] & BCM5600_CMD_OP_MASK) >> BCM5600_CMD_OP_SHIFT;
1319: src = (d->dw[0] & BCM5600_CMD_SRC_MASK) >> BCM5600_CMD_SRC_SHIFT;
1320: dst = (d->dw[0] & BCM5600_CMD_DST_MASK) >> BCM5600_CMD_DST_SHIFT;
1321: len = (d->dw[0] & BCM5600_CMD_LEN_MASK) >> BCM5600_CMD_LEN_SHIFT;
1322:
1323: #if DEBUG_ACCESS
1324: BCM_LOG(d,"gen_cmd: opcode 0x%2.2x [src=0x%2.2x,dst=0x%2.2x,len=0x%2.2x] "
1325: "(dw[0]=0x%8.8x, dw[1]=0x%8.8x, dw[2]=0x%8.8x, dw[3]=0x%8.8x)\n",
1326: op,src,dst,len,d->dw[0],d->dw[1],d->dw[2],d->dw[3]);
1327: #endif
1328:
1329: switch(op) {
1330: case BCM5600_OP_READ_MEM_CMD:
1331: bcm5600_handle_read_mem_cmd(d);
1332: break;
1333:
1334: case BCM5600_OP_WRITE_MEM_CMD:
1335: bcm5600_handle_write_mem_cmd(d);
1336: break;
1337:
1338: case BCM5600_OP_READ_REG_CMD:
1339: d->dw[0] = BCM5600_OP_READ_REG_ACK << BCM5600_CMD_OP_SHIFT;
1340: #if DEBUG_REG
1341: BCM_LOG(d,"READ_REG: reg_addr=0x%8.8x\n",d->dw[1]);
1342: #endif
1343: d->dw[1] = bcm5600_reg_read(d,d->dw[1]);
1344: break;
1345:
1346: case BCM5600_OP_WRITE_REG_CMD:
1347: d->dw[0] = BCM5600_OP_WRITE_REG_ACK << BCM5600_CMD_OP_SHIFT;
1348: #if DEBUG_REG
1349: BCM_LOG(d,"WRITE_REG: reg_addr=0x%8.8x val=0x%8.8x\n",
1350: d->dw[1],d->dw[2]);
1351: #endif
1352: bcm5600_reg_write(d,d->dw[1],d->dw[2]);
1353: bcm5600_reg_write_special(d,d->dw[1],d->dw[2]);
1354: break;
1355:
1356: case BCM5600_OP_ARL_INSERT_CMD:
1357: d->dw[0] = BCM5600_OP_ARL_INSERT_DONE << BCM5600_CMD_OP_SHIFT;
1358:
1359: #if DEBUG_ARL
1360: BCM_LOG(d,"ARL_INSERT_CMD "
1361: "(dw[1]=0x%8.8x,dw[2]=0x%8.8x,dw[3]=0x%8.8x)\n",
1362: d->dw[1],d->dw[2],d->dw[3]);
1363: #endif
1364: bcm5600_insert_arl_entry(d);
1365: break;
1366:
1367: case BCM5600_OP_ARL_DELETE_CMD:
1368: d->dw[0] = BCM5600_OP_ARL_DELETE_DONE << BCM5600_CMD_OP_SHIFT;
1369:
1370: #if DEBUG_ARL
1371: BCM_LOG(d,"ARL_DELETE_CMD (dw[1]=0x%8.8x,dw[2]=0x%8.8x)\n",
1372: d->dw[1],d->dw[2]);
1373: #endif
1374: bcm5600_delete_arl_entry(d);
1375: break;
1376:
1377: case BCM5600_OP_ARL_LOOKUP_CMD:
1378: d->dw[0] = BCM5600_OP_READ_MEM_ACK << BCM5600_CMD_OP_SHIFT;
1379: break;
1380:
1381: default:
1382: BCM_LOG(d,"unknown opcode 0x%8.8x (cmd=0x%8.8x)\n",op,d->dw[0]);
1383: }
1384: }
1385:
1386: /* Handle a s-channel command */
1387: static void bcm5600_handle_schan_cmd(struct nm_16esw_data *d,m_uint32_t cmd)
1388: {
1389: d->schan_cmd = cmd;
1390:
1391: #if DEBUG_ACCESS
1392: BCM_LOG(d,"s-chan command 0x%8.8x\n",cmd);
1393: #endif
1394:
1395: switch(cmd) {
1396: case BCM5600_SCHAN_CMD_EXEC:
1397: bcm5600_handle_gen_cmd(d);
1398: d->schan_cmd_res = 0xFFFFFFFF;
1399: break;
1400:
1401: case BCM5600_SCHAN_CMD_READ_MII:
1402: bcm5600_mii_read(d);
1403: d->schan_cmd_res = 0xFFFFFFFF;
1404: break;
1405:
1406: case BCM5600_SCHAN_CMD_WRITE_MII:
1407: bcm5600_mii_write(d);
1408: d->schan_cmd_res = 0xFFFFFFFF;
1409: break;
1410:
1411: case BCM5600_SCHAN_CMD_LINKSCAN:
1412: d->schan_cmd_res = 0x0;
1413: break;
1414:
1415: default:
1416: #if DEBUG_UNKNOWN
1417: BCM_LOG(d,"unknown s-chan command 0x%8.8x\n",cmd);
1418: #endif
1419: d->schan_cmd_res = 0xFFFFFFFF;
1420: }
1421: }
1422:
1423: /*
1424: * dev_bcm5605_access()
1425: */
1426: void *dev_bcm5605_access(cpu_mips_t *cpu,struct vdevice *dev,m_uint32_t offset,
1427: u_int op_size,u_int op_type,m_uint64_t *data)
1428: {
1429: struct nm_16esw_data *d = dev->priv_data;
1430: u_int reg;
1431:
1432: if (op_type == MTS_READ)
1433: *data = 0;
1434:
1435: #if DEBUG_ACCESS
1436: if (op_type == MTS_READ) {
1437: BCM_LOG(d,"read access to offset=0x%x, pc=0x%llx\n",offset,cpu->pc);
1438: } else {
1439: BCM_LOG(d,"write access to offset=0x%x, pc=0x%llx, val=0x%llx\n",
1440: offset,cpu->pc,*data);
1441: }
1442: #endif
1443:
1444: BCM_LOCK(d);
1445:
1446: switch(offset) {
1447: case 0x50:
1448: if (op_type == MTS_WRITE) {
1449: bcm5600_handle_schan_cmd(d,*data);
1450: } else {
1451: *data = d->schan_cmd_res;
1452: }
1453: break;
1454:
1455: case 0x140:
1456: if (op_type == MTS_READ)
1457: *data = bcm5600_mii_port_status_bmp(d);
1458: break;
1459:
1460: /* MII input register */
1461: case 0x158:
1462: if (op_type == MTS_WRITE)
1463: d->mii_input = *data;
1464: break;
1465:
1466: /* MII output register */
1467: case 0x15c:
1468: if (op_type == MTS_READ)
1469: *data = d->mii_output;
1470: break;
1471:
1472: /* Unknown (related to RX/TX rings ?) */
1473: case 0x104:
1474: break;
1475:
1476: /* TX ring address */
1477: case 0x110:
1478: if (op_type == MTS_READ)
1479: *data = d->tx_ring_addr;
1480: else {
1481: d->tx_ring_addr = d->tx_current = *data;
1482: d->tx_end_scan = 0;
1483: #if DEBUG_TRANSMIT
1484: BCM_LOG(d,"tx_ring_addr = 0x%8.8x\n",d->tx_ring_addr);
1485: #endif
1486: }
1487: break;
1488:
1489: /* RX ring address */
1490: case 0x114:
1491: if (op_type == MTS_READ)
1492: *data = d->rx_ring_addr;
1493: else {
1494: d->rx_ring_addr = d->rx_current = *data;
1495: d->rx_end_scan = 0;
1496: #if DEBUG_RECEIVE
1497: BCM_LOG(d,"rx_ring_addr = 0x%8.8x\n",d->rx_ring_addr);
1498: #endif
1499: }
1500: break;
1501:
1502: /* Interrupt status */
1503: case 0x144:
1504: if (op_type == MTS_READ) {
1505: *data = 0;
1506:
1507: /* RX/TX underrun (end of rings reached) */
1508: if (d->tx_end_scan)
1509: *data |= BCM5600_INTR_TX_UNDERRUN;
1510:
1511: if (d->rx_end_scan)
1512: *data |= BCM5600_INTR_RX_UNDERRUN;
1513:
1514: /* RX packet available */
1515: *data |= BCM5600_INTR_RX_AVAIL;
1516:
1517: /* Link status changed */
1518: if (d->mii_intr) {
1519: *data |= BCM5600_INTR_LINKSTAT_MOD;
1520: d->mii_intr = FALSE;
1521: }
1522: }
1523: break;
1524:
1525: /* Interrupt mask */
1526: case 0x148:
1527: if (op_type == MTS_READ)
1528: *data = d->intr_mask;
1529: else
1530: d->intr_mask = *data;
1531: break;
1532:
1533: /* Data Words */
1534: case 0x800 ... 0x850:
1535: reg = (offset - 0x800) >> 2;
1536:
1537: if (op_type == MTS_READ)
1538: *data = d->dw[reg];
1539: else
1540: d->dw[reg] = *data;
1541: break;
1542:
1543: #if DEBUG_UNKNOWN
1544: /* Unknown offset */
1545: default:
1546: if (op_type == MTS_READ) {
1547: BCM_LOG(d,"read from unknown addr 0x%x, pc=0x%llx (size=%u)\n",
1548: offset,cpu->pc,op_size);
1549: } else {
1550: BCM_LOG(d,"write to unknown addr 0x%x, value=0x%llx, "
1551: "pc=0x%llx (size=%u)\n",offset,*data,cpu->pc,op_size);
1552: }
1553: #endif
1554: }
1555:
1556: BCM_UNLOCK(d);
1557: return NULL;
1558: }
1559:
1560: /* Show mirroring status */
1561: static int bcm5600_mirror_show_status(struct nm_16esw_data *d)
1562: {
1563: m_uint32_t *port,dst_port;
1564: int i;
1565:
1566: printf("Mirroring status: ");
1567:
1568: if (!(d->mirror_dst_port & BCM5600_MIRROR_ENABLE)) {
1569: printf("disabled.\n\n");
1570: return(FALSE);
1571: }
1572:
1573: printf("enabled. Dest port: ");
1574:
1575: dst_port = d->mirror_dst_port & BCM5600_MIRROR_PORT_MASK;
1576:
1577: if (dst_port < 32)
1578: printf("%s\n",d->ports[dst_port].name);
1579: else
1580: printf("none set.\n");
1581:
1582: /* Ingress info */
1583: printf(" Ingress Ports: ");
1584:
1585: for(i=0;i<d->nr_port;i++) {
1586: port = bcm5600_table_get_entry(d,d->t_ptable,i);
1587: if (port[1] & BCM5600_PTABLE_MI_FLAG)
1588: printf("%s ",d->ports[i].name);
1589: }
1590:
1591: printf("\n");
1592:
1593: /* Egress info */
1594: printf(" Egress Ports: ");
1595:
1596: for(i=0;i<d->nr_port;i++)
1597: if (d->mirror_egress_ports & (1 << i))
1598: printf("%s ",d->ports[i].name);
1599:
1600: printf("\n\n");
1601: return(TRUE);
1602: }
1603:
1604: /* Mirror a packet */
1605: static int bcm5600_mirror_pkt(struct nm_16esw_data *d,struct bcm5600_pkt *p,
1606: int reason)
1607: {
1608: u_int mport;
1609:
1610: if (!(d->mirror_dst_port & BCM5600_MIRROR_ENABLE))
1611: return(FALSE);
1612:
1613: #if DEBUG_MIRROR
1614: if (reason == 0) {
1615: BCM_LOG(d,"mirroring packet on ingress port %s\n",
1616: d->ports[p->ingress_port]);
1617: } else {
1618: BCM_LOG(d,"mirroring packet on egress port (input port %s)\n",
1619: d->ports[p->ingress_port]);
1620: }
1621: mem_dump(d->vm->log_fd,pkt,pkt_len);
1622: #endif
1623:
1624: mport = d->mirror_dst_port & BCM5600_MIRROR_PORT_MASK;
1625: if (mport < 32)
1626: netio_send(d->ports[mport].nio,p->pkt,p->pkt_len);
1627: return(TRUE);
1628: }
1629:
1630: /* Put a packet into the RX ring (tag it if necessary) */
1631: static int bcm5600_send_pkt_to_cpu(struct nm_16esw_data *d,
1632: struct bcm5600_pkt *p)
1633: {
1634: m_uint32_t pkt_addr,pkt_len,dot1q_data;
1635:
1636: /* If the packet was already sent to CPU, don't send it again */
1637: if (p->sent_to_cpu)
1638: return(FALSE);
1639:
1640: pkt_addr = p->rdes[0];
1641: pkt_len = p->pkt_len;
1642:
1643: if (p->orig_vlan != -1) {
1644: /* 802.1Q packet: copy it directly */
1645: physmem_copy_to_vm(d->vm,p->pkt,pkt_addr,pkt_len);
1646: } else {
1647: /* untagged packet: copy the dst and src addresses first */
1648: physmem_copy_to_vm(d->vm,p->pkt,pkt_addr,N_ETH_HLEN - 2);
1649:
1650: /* add the 802.1Q protocol field (0x8100) + VLAN info */
1651: dot1q_data = (N_ETH_PROTO_DOT1Q << 16) | p->real_vlan;
1652: physmem_copy_u32_to_vm(d->vm,pkt_addr+N_ETH_HLEN-2,dot1q_data);
1653:
1654: /* copy the payload */
1655: physmem_copy_to_vm(d->vm,p->pkt+N_ETH_HLEN-2,
1656: pkt_addr+sizeof(n_eth_dot1q_hdr_t),
1657: pkt_len - (N_ETH_HLEN - 2));
1658: pkt_len += 4;
1659: }
1660:
1661: physmem_copy_u32_to_vm(d->vm,d->rx_current+0x14,0x40000000 + (pkt_len+4));
1662: physmem_copy_u32_to_vm(d->vm,d->rx_current+0x18,0x100 + p->ingress_port);
1663: p->sent_to_cpu = TRUE;
1664:
1665: #if DEBUG_RECEIVE
1666: BCM_LOG(d,"sending packet to CPU (orig_vlan=%d).\n",p->orig_vlan);
1667: #endif
1668: return(TRUE);
1669: }
1670:
1671: /* Source MAC address learning */
1672: static int bcm5600_src_mac_learning(struct nm_16esw_data *d,
1673: struct bcm5600_pkt *p)
1674: {
1675: n_eth_hdr_t *eth_hdr = (n_eth_hdr_t *)p->pkt;
1676: n_eth_addr_t *src_mac = ð_hdr->saddr;
1677: m_uint32_t *arl_entry,*src_port,*trunk;
1678: u_int trunk_id,old_ingress_port;
1679: int src_mac_index;
1680:
1681: trunk = NULL;
1682: trunk_id = 0;
1683:
1684: /* Skip multicast sources */
1685: if (eth_addr_is_mcast(src_mac))
1686: return(FALSE);
1687:
1688: src_port = bcm5600_table_get_entry(d,d->t_ptable,p->ingress_port);
1689: assert(src_port != NULL);
1690:
1691: /*
1692: * The packet comes from a trunk port. Prevent sending the packet
1693: * to the other ports of the trunk.
1694: */
1695: if (src_port[0] & BCM5600_PTABLE_TRUNK_FLAG) {
1696: trunk_id = src_port[0] & BCM5600_PTABLE_TGID_MASK;
1697: trunk_id >>= BCM5600_PTABLE_TGID_SHIFT;
1698:
1699: trunk = bcm5600_table_get_entry(d,d->t_tbmap,trunk_id);
1700: assert(trunk != NULL);
1701:
1702: p->egress_filter_bitmap |= trunk[0] & BCM5600_TBMAP_MASK;
1703: }
1704:
1705: /* Source MAC address learning */
1706: src_mac_index = bcm5600_arl_lookup(d,src_mac,p->real_vlan);
1707:
1708: if (src_mac_index != -1) {
1709: arl_entry = bcm5600_table_get_entry(d,d->t_arl,src_mac_index);
1710: assert(arl_entry != NULL);
1711:
1712: old_ingress_port = arl_entry[2] & BCM5600_ARL_PORT_MASK;
1713: old_ingress_port >>= BCM5600_ARL_PORT_SHIFT;
1714:
1715: if (old_ingress_port != p->ingress_port)
1716: {
1717: /*
1718: * Determine if we have a station movement.
1719: * If we have a trunk, check if the old ingress port is member
1720: * of this trunk, in this case this is not a movement.
1721: */
1722: if (trunk != NULL) {
1723: if (trunk[0] & (1 << old_ingress_port))
1724: arl_entry[2] |= BCM5600_ARL_HIT_FLAG;
1725: else
1726: arl_entry[2] &= ~BCM5600_ARL_HIT_FLAG;
1727: } else {
1728: arl_entry[2] &= ~(BCM5600_ARL_TRUNK_FLAG|BCM5600_ARL_HIT_FLAG);
1729: arl_entry[2] &= ~BCM5600_ARL_TGID_MASK;
1730: }
1731:
1732: /* Change the ingress port */
1733: arl_entry[2] &= ~BCM5600_ARL_PORT_MASK;
1734: arl_entry[2] |= p->ingress_port << BCM5600_ARL_PORT_SHIFT;
1735: return(TRUE);
1736: }
1737:
1738: arl_entry[2] |= BCM5600_ARL_HIT_FLAG;
1739: return(TRUE);
1740: }
1741:
1742: #if DEBUG_FORWARD
1743: BCM_LOG(d,"source MAC address unknown, learning it.\n");
1744: #endif
1745:
1746: /* Add the new learned MAC address */
1747: src_mac_index = bcm5600_find_free_arl_entry(d);
1748:
1749: if (src_mac_index == -1) {
1750: BCM_LOG(d,"no free entries in ARL table!\n");
1751: return(FALSE);
1752: }
1753:
1754: arl_entry = bcm5600_table_get_entry(d,d->t_arl,src_mac_index);
1755: assert(arl_entry != NULL);
1756:
1757: /* Fill the new ARL entry */
1758: arl_entry[0] = src_mac->eth_addr_byte[2] << 24;
1759: arl_entry[0] |= src_mac->eth_addr_byte[3] << 16;
1760: arl_entry[0] |= src_mac->eth_addr_byte[4] << 8;
1761: arl_entry[0] |= src_mac->eth_addr_byte[5];
1762:
1763: arl_entry[1] = src_mac->eth_addr_byte[0] << 8;
1764: arl_entry[1] |= src_mac->eth_addr_byte[1];
1765: arl_entry[1] |= p->real_vlan << BCM5600_ARL_VLAN_TAG_SHIFT;
1766:
1767: arl_entry[2] = BCM5600_ARL_HIT_FLAG;
1768: arl_entry[2] |= p->ingress_port << BCM5600_ARL_PORT_SHIFT;
1769:
1770: if (trunk != NULL) {
1771: arl_entry[2] |= BCM5600_ARL_TRUNK_FLAG;
1772: arl_entry[2] |= (trunk_id << BCM5600_ARL_TGID_SHIFT);
1773: }
1774:
1775: d->arl_cnt[0]++;
1776: return(TRUE);
1777: }
1778:
1779: /* Select an egress port the specified trunk */
1780: static int bcm5600_trunk_egress_port(struct nm_16esw_data *d,
1781: struct bcm5600_pkt *p,
1782: u_int trunk_id)
1783: {
1784: n_eth_hdr_t *eth_hdr = (n_eth_hdr_t *)p->pkt;
1785: struct bcm5600_tg_info *tgi;
1786: m_uint32_t *ttr_entry;
1787: u_int i,nr_links;
1788: u_int hash,port_id;
1789:
1790: ttr_entry = bcm5600_table_get_entry(d,d->t_ttr,trunk_id);
1791: assert(ttr_entry != NULL);
1792:
1793: nr_links = ttr_entry[1] & BCM5600_TTR_TG_SIZE_MASK;
1794: nr_links >>= BCM5600_TTR_TG_SIZE_SHIFT;
1795:
1796: #if 0
1797: /* Hash on source and destination MAC addresses */
1798: for(i=0,hash=0;i<N_ETH_ALEN;i++) {
1799: hash ^= eth_hdr->saddr.eth_addr_byte[i];
1800: hash ^= eth_hdr->daddr.eth_addr_byte[i];
1801: }
1802:
1803: hash ^= (hash >> 4);
1804: port_id = hash % nr_links;
1805:
1806: /* Maximum of 8 ports per trunk */
1807: assert(hash < BCM5600_MAX_PORTS_PER_TRUNK);
1808: #else
1809: port_id = d->trunk_last_egress_port[trunk_id] + 1;
1810: port_id %= nr_links;
1811: #endif
1812:
1813: /* Save the latest port used for this trunk */
1814: d->trunk_last_egress_port[trunk_id] = port_id;
1815:
1816: /* Select the egress port */
1817: tgi = &tg_info[port_id];
1818: return((ttr_entry[tgi->index] & tgi->mask) >> tgi->shift);
1819: }
1820:
1821: /* Destination address lookup (take the forwarding decision) */
1822: static int bcm5600_dst_mac_lookup(struct nm_16esw_data *d,
1823: struct bcm5600_pkt *p)
1824: {
1825: n_eth_hdr_t *eth_hdr = (n_eth_hdr_t *)p->pkt;
1826: n_eth_addr_t *dst_mac = ð_hdr->daddr;
1827: struct bcm5600_table *arl_table;
1828: m_uint32_t *arl_entry;
1829: u_int egress_port;
1830: u_int trunk_id;
1831: int dst_mac_index;
1832: int is_mcast;
1833:
1834: /* Select the appropriate ARL table and do the lookup on dst MAC + VLAN */
1835: if (eth_addr_is_mcast(dst_mac)) {
1836: is_mcast = TRUE;
1837: arl_table = d->t_marl;
1838: dst_mac_index = bcm5600_marl_lookup(d,dst_mac,p->real_vlan);
1839: } else {
1840: is_mcast = FALSE;
1841: arl_table = d->t_arl;
1842: dst_mac_index = bcm5600_arl_lookup(d,dst_mac,p->real_vlan);
1843: }
1844:
1845: /*
1846: * Destination Lookup Failure (DLF).
1847: *
1848: * Use the VLAN bitmap to compute the Egress port bitmap.
1849: * Remove the ingress port from it.
1850: */
1851: if (dst_mac_index == -1) {
1852: #if DEBUG_FORWARD
1853: BCM_LOG(d,"Destination MAC address unknown, flooding.\n");
1854: #endif
1855: p->egress_bitmap = p->vlan_entry[1] & BCM5600_VTABLE_PORT_BMAP_MASK;
1856:
1857: /* Add the CPU to the egress ports */
1858: p->egress_bitmap |= 1 << d->cpu_port;
1859:
1860: p->egress_ut_bitmap = p->vlan_entry[2];
1861: p->egress_ut_bitmap &= BCM5600_VTABLE_UT_PORT_BMAP_MASK;
1862: return(TRUE);
1863: }
1864:
1865: /* The MAC address was found in the ARL/MARL table */
1866: arl_entry = bcm5600_table_get_entry(d,arl_table,dst_mac_index);
1867: assert(arl_entry != NULL);
1868:
1869: /* If the CPU bit is set, send a copy of the packet to the CPU */
1870: if (arl_entry[1] & BCM5600_ARL_CPU_FLAG)
1871: bcm5600_send_pkt_to_cpu(d,p);
1872:
1873: if (!is_mcast) {
1874: /* Unicast: send the packet to the port or trunk found in ARL table */
1875: if (arl_entry[2] & BCM5600_ARL_TRUNK_FLAG) {
1876: trunk_id = arl_entry[2] & BCM5600_ARL_TGID_MASK;
1877: trunk_id >>= BCM5600_ARL_TGID_SHIFT;
1878:
1879: /* Select an output port for this trunk */
1880: egress_port = bcm5600_trunk_egress_port(d,p,trunk_id);
1881:
1882: #if DEBUG_FORWARD
1883: BCM_LOG(d,"Sending packet to trunk port %u, egress port %u\n",
1884: trunk_id,egress_port);
1885: #endif
1886: } else {
1887: egress_port = arl_entry[2] & BCM5600_ARL_PORT_MASK;
1888: egress_port >>= BCM5600_ARL_PORT_SHIFT;
1889: }
1890:
1891: p->egress_bitmap = 1 << egress_port;
1892: p->egress_ut_bitmap = p->vlan_entry[2] &
1893: BCM5600_VTABLE_UT_PORT_BMAP_MASK;
1894: } else {
1895: /* Multicast: send the packet to the egress ports found in MARL table */
1896: p->egress_bitmap = arl_entry[2] & BCM5600_MARL_PORT_BMAP_MASK;
1897: p->egress_ut_bitmap = arl_entry[3] & BCM5600_MARL_UT_PORT_BMAP_MASK;
1898: }
1899:
1900: #if DEBUG_FORWARD
1901: {
1902: char buffer[1024];
1903:
1904: BCM_LOG(d,"bitmap: 0x%8.8x, filter: 0x%8.8x\n",
1905: p->egress_bitmap,p->egress_filter_bitmap);
1906:
1907: bcm5600_port_bitmap_str(d,buffer,p->egress_bitmap);
1908:
1909: /* without egress port filtering */
1910: if (*buffer)
1911: BCM_LOG(d,"forwarding to egress port list w/o filter: %s\n",buffer);
1912: else
1913: BCM_LOG(d,"w/o filter: empty egress port list.\n");
1914:
1915: /* with egress port filtering */
1916: bcm5600_port_bitmap_str(d,buffer,
1917: p->egress_bitmap & ~p->egress_filter_bitmap);
1918:
1919: if (*buffer)
1920: BCM_LOG(d,"forwarding to egress port list w/ filter: %s\n",buffer);
1921: }
1922: #endif
1923:
1924: return(p->egress_bitmap != 0);
1925: }
1926:
1927: /* Prototype for a packet sending function */
1928: typedef void (*bcm5600_send_pkt_t)(struct nm_16esw_data *d,
1929: struct bcm5600_pkt *p,
1930: netio_desc_t *nio);
1931:
1932: /* Directly forward a packet (not rewritten) */
1933: static void bcm5600_send_pkt_direct(struct nm_16esw_data *d,
1934: struct bcm5600_pkt *p,
1935: netio_desc_t *nio)
1936: {
1937: netio_send(nio,p->pkt,p->pkt_len);
1938: }
1939:
1940: /* Send a packet with a 802.1Q tag */
1941: static void bcm5600_send_pkt_push_dot1q(struct nm_16esw_data *d,
1942: struct bcm5600_pkt *p,
1943: netio_desc_t *nio)
1944: {
1945: n_eth_dot1q_hdr_t *hdr;
1946:
1947: if (!p->rewrite_done) {
1948: memcpy(p->rewr_pkt,p->pkt,(N_ETH_HLEN - 2));
1949:
1950: hdr = (n_eth_dot1q_hdr_t *)p->rewr_pkt;
1951: hdr->type = htons(N_ETH_PROTO_DOT1Q);
1952: hdr->vlan_id = htons(p->real_vlan);
1953:
1954: memcpy(p->rewr_pkt + sizeof(n_eth_dot1q_hdr_t),
1955: p->pkt + (N_ETH_HLEN - 2),
1956: p->pkt_len - (N_ETH_HLEN - 2));
1957:
1958: p->rewrite_done = TRUE;
1959: }
1960:
1961: netio_send(nio,p->rewr_pkt,p->pkt_len+4);
1962: }
1963:
1964: /* Send a packet deleting its 802.1Q tag */
1965: static void bcm5600_send_pkt_pop_dot1q(struct nm_16esw_data *d,
1966: struct bcm5600_pkt *p,
1967: netio_desc_t *nio)
1968: {
1969: if (!p->rewrite_done) {
1970: memcpy(p->rewr_pkt,p->pkt,(N_ETH_HLEN - 2));
1971:
1972: memcpy(p->rewr_pkt + (N_ETH_HLEN - 2),
1973: p->pkt + sizeof(n_eth_dot1q_hdr_t),
1974: p->pkt_len - sizeof(n_eth_dot1q_hdr_t));
1975:
1976: p->rewrite_done = TRUE;
1977: }
1978:
1979: netio_send(nio,p->rewr_pkt,p->pkt_len-4);
1980: }
1981:
1982: /* Forward a packet on physical ports (egress bitmap must be defined) */
1983: static int bcm5600_forward_pkt(struct nm_16esw_data *d,struct bcm5600_pkt *p)
1984: {
1985: u_char rewr_pkt[BCM5600_MAX_PKT_SIZE];
1986: bcm5600_send_pkt_t send_pkt;
1987: u_int egress_untagged,trunk_id;
1988: m_uint32_t *dst_port,*trunk;
1989: int i;
1990:
1991: p->egress_bitmap &= ~p->egress_filter_bitmap;
1992:
1993: if (!p->egress_bitmap)
1994: return(FALSE);
1995:
1996: /* Process egress mirroring (if enabled) */
1997: if (p->egress_bitmap & d->mirror_egress_ports)
1998: bcm5600_mirror_pkt(d,p,1);
1999:
2000: /* No rewrite done at this time */
2001: p->rewr_pkt = rewr_pkt;
2002: p->rewrite_done = FALSE;
2003:
2004: /* Forward to CPU port ? */
2005: if (p->egress_bitmap & (1 << d->cpu_port))
2006: bcm5600_send_pkt_to_cpu(d,p);
2007:
2008: for(i=0;i<d->nr_port;i++) {
2009: if (!(p->egress_bitmap & (1 << i)))
2010: continue;
2011:
2012: /*
2013: * If this port is a member of a trunk, remove all other ports to avoid
2014: * duplicate frames (typically, when a dest MAC address is unknown
2015: * or for a broadcast/multicast).
2016: */
2017: dst_port = bcm5600_table_get_entry(d,d->t_ptable,i);
2018: assert(dst_port != NULL);
2019:
2020: if (dst_port[0] & BCM5600_PTABLE_TRUNK_FLAG) {
2021: trunk_id = dst_port[0] & BCM5600_PTABLE_TGID_MASK;
2022: trunk_id >>= BCM5600_PTABLE_TGID_SHIFT;
2023:
2024: trunk = bcm5600_table_get_entry(d,d->t_tbmap,trunk_id);
2025: assert(trunk != NULL);
2026:
2027: p->egress_bitmap &= ~trunk[0];
2028: }
2029:
2030: /* select the appropriate output vector */
2031: if (p->orig_vlan == 0)
2032: send_pkt = bcm5600_send_pkt_direct;
2033: else {
2034: egress_untagged = p->egress_ut_bitmap & (1 << i);
2035:
2036: if (p->orig_vlan == -1) {
2037: /* Untagged packet */
2038: if (egress_untagged)
2039: send_pkt = bcm5600_send_pkt_direct;
2040: else
2041: send_pkt = bcm5600_send_pkt_push_dot1q;
2042: } else {
2043: /* Tagged packet */
2044: if (egress_untagged)
2045: send_pkt = bcm5600_send_pkt_pop_dot1q;
2046: else
2047: send_pkt = bcm5600_send_pkt_direct;
2048: }
2049: }
2050:
2051: #if DEBUG_FORWARD > 1
2052: BCM_LOG(d,"forwarding on port %s (vector=%p)\n",
2053: d->ports[i].name,send_pkt);
2054: #endif
2055: send_pkt(d,p,d->ports[i].nio);
2056: }
2057:
2058: return(TRUE);
2059: }
2060:
2061: /* Handle a received packet */
2062: static int bcm5600_handle_rx_pkt(struct nm_16esw_data *d,struct bcm5600_pkt *p)
2063: {
2064: m_uint32_t *port_entry;
2065: n_eth_dot1q_hdr_t *eth_hdr;
2066: u_int discard;
2067:
2068: /* No egress port at this time */
2069: p->egress_bitmap = 0;
2070:
2071: /* Never send back frames to the source port */
2072: p->egress_filter_bitmap = 1 << p->ingress_port;
2073:
2074: if (!(port_entry = bcm5600_table_get_entry(d,d->t_ptable,p->ingress_port)))
2075: return(FALSE);
2076:
2077: /* Analyze the Ethernet header */
2078: eth_hdr = (n_eth_dot1q_hdr_t *)p->pkt;
2079:
2080: /* Check for the reserved addresses (BPDU for spanning-tree) */
2081: if (!memcmp(ð_hdr->daddr,"\x01\x80\xc2\x00\x00",5) ||
2082: !memcmp(ð_hdr->daddr,"\x01\x00\x0c\xcc\xcc\xcd",6))
2083: {
2084: #if DEBUG_RECEIVE
2085: BCM_LOG(d,"Received a BPDU packet:\n");
2086: mem_dump(d->vm->log_fd,p->pkt,p->pkt_len);
2087: #endif
2088: p->orig_vlan = 0;
2089: p->egress_bitmap |= 1 << d->cpu_port;
2090: return(bcm5600_forward_pkt(d,p));
2091: }
2092:
2093: /* Discard packet ? */
2094: discard = port_entry[0] & BCM5600_PTABLE_PRT_DIS_MASK;
2095: discard >>= BCM5600_PTABLE_PRT_DIS_SHIFT;
2096:
2097: if (discard) {
2098: if (discard != 0x20) {
2099: printf("\n\n\n"
2100: "-----------------------------------------------------------"
2101: "---------------------------------\n"
2102: "Unspported feature: please post your current configuration "
2103: "on http://www.ipflow.utc.fr/blog/\n"
2104: "-----------------------------------------------------------"
2105: "---------------------------------\n");
2106: }
2107:
2108: /* Drop the packet */
2109: return(FALSE);
2110: }
2111:
2112: /* Mirroring on Ingress ? */
2113: if (port_entry[1] & BCM5600_PTABLE_MI_FLAG)
2114: bcm5600_mirror_pkt(d,p,0);
2115:
2116: /* Determine VLAN */
2117: if (ntohs(eth_hdr->type) != N_ETH_PROTO_DOT1Q) {
2118: p->orig_vlan = -1;
2119: p->real_vlan = port_entry[0] & BCM5600_PTABLE_VLAN_TAG_MASK;
2120:
2121: if (!(p->vlan_entry = bcm5600_vtable_get_entry_by_vlan(d,p->real_vlan)))
2122: return(FALSE);
2123:
2124: /* TODO: 802.1p/CoS remarking */
2125: if (port_entry[4] & BCM5600_PTABLE_RPE_FLAG) {
2126: }
2127: } else {
2128: p->orig_vlan = p->real_vlan = ntohs(eth_hdr->vlan_id) & 0xFFF;
2129:
2130: /* Check that this VLAN exists */
2131: if (!(p->vlan_entry = bcm5600_vtable_get_entry_by_vlan(d,p->real_vlan)))
2132: return(FALSE);
2133:
2134: /* Check that this port is a member of this VLAN */
2135: if (!(p->vlan_entry[1] & (1 << p->ingress_port)))
2136: return(FALSE);
2137: }
2138:
2139: #if DEBUG_RECEIVE
2140: BCM_LOG(d,"%s: received a packet on VLAN %u\n",
2141: d->ports[p->ingress_port].name,p->real_vlan);
2142: #endif
2143:
2144: /* Source MAC address learning */
2145: if (!bcm5600_src_mac_learning(d,p))
2146: return(FALSE);
2147:
2148: /* Take forwarding decision based on destination MAC address */
2149: if (!bcm5600_dst_mac_lookup(d,p))
2150: return(FALSE);
2151:
2152: /* Send the packet to the egress ports */
2153: return(bcm5600_forward_pkt(d,p));
2154: }
2155:
2156: /* Handle a packet to transmit */
2157: static int bcm5600_handle_tx_pkt(struct nm_16esw_data *d,
2158: struct bcm5600_pkt *p,
2159: u_int egress_bitmap)
2160: {
2161: n_eth_dot1q_hdr_t *eth_hdr;
2162:
2163: /* Never send back frames to the source port */
2164: p->egress_filter_bitmap = 1 << p->ingress_port;
2165:
2166: /* We take the complete forwarding decision if bit 23 is set */
2167: if (egress_bitmap & (1 << 23)) {
2168: /* No egress port at this time */
2169: p->egress_bitmap = 0;
2170:
2171: /* The packet must be tagged so that we can determine the VLAN */
2172: eth_hdr = (n_eth_dot1q_hdr_t *)p->pkt;
2173:
2174: if (ntohs(eth_hdr->type) != N_ETH_PROTO_DOT1Q) {
2175: BCM_LOG(d,"bcm5600_handle_tx_pkt: untagged packet ?\n");
2176: return(FALSE);
2177: }
2178:
2179: /* Find the appropriate, check it exists (just in case) */
2180: p->orig_vlan = p->real_vlan = ntohs(eth_hdr->vlan_id) & 0xFFF;
2181:
2182: if (!(p->vlan_entry = bcm5600_vtable_get_entry_by_vlan(d,p->real_vlan)))
2183: return(FALSE);
2184:
2185: #if DEBUG_TRANSMIT
2186: BCM_LOG(d,"Transmitting a packet from TX ring to VLAN %u\n",
2187: p->real_vlan);
2188: #endif
2189:
2190: /* Take forwarding decision based on destination MAC address */
2191: if (!bcm5600_dst_mac_lookup(d,p))
2192: return(FALSE);
2193: } else {
2194: #if DEBUG_TRANSMIT
2195: BCM_LOG(d,"Transmitting natively a packet from TX ring.\n");
2196: #endif
2197: /* The egress ports are specified, send the packet natively */
2198: p->orig_vlan = 0;
2199: p->egress_bitmap = egress_bitmap;
2200: }
2201:
2202: /* Send the packet to the egress ports */
2203: return(bcm5600_forward_pkt(d,p));
2204: }
2205:
2206: /* Handle the TX ring */
2207: static int dev_bcm5600_handle_txring(struct nm_16esw_data *d)
2208: {
2209: struct bcm5600_pkt pkt_data;
2210: m_uint32_t tdes[4],txd_len;
2211:
2212: BCM_LOCK(d);
2213:
2214: if (!d->tx_current || d->tx_end_scan) {
2215: BCM_UNLOCK(d);
2216: return(FALSE);
2217: }
2218:
2219: /* Read the current TX descriptor */
2220: physmem_copy_from_vm(d->vm,tdes,d->tx_current,4*sizeof(m_uint32_t));
2221: tdes[0] = vmtoh32(tdes[0]);
2222: tdes[1] = vmtoh32(tdes[1]);
2223: tdes[2] = vmtoh32(tdes[2]);
2224: tdes[3] = vmtoh32(tdes[3]);
2225:
2226: #if DEBUG_TRANSMIT
2227: BCM_LOG(d,"=== TRANSMIT PATH ===\n");
2228:
2229: BCM_LOG(d,"tx_current=0x%8.8x, "
2230: "tdes[0]=0x%8.8x, tdes[1]=0x%8.8x, tdes[2]=0x%8.8x\n",
2231: d->tx_current,tdes[0],tdes[1],tdes[2]);
2232: #endif
2233:
2234: /* Get the buffer size */
2235: txd_len = tdes[1] & 0x7FF;
2236:
2237: /* Check buffer size */
2238: if ((d->tx_bufsize + txd_len) >= sizeof(d->tx_buffer))
2239: goto done;
2240:
2241: /* Copy the packet from memory */
2242: physmem_copy_from_vm(d->vm,d->tx_buffer+d->tx_bufsize,tdes[0],txd_len);
2243: d->tx_bufsize += txd_len;
2244:
2245: /* Packet not complete: handle it later */
2246: if (tdes[1] & BCM5600_TXD_NEOP)
2247: goto done;
2248:
2249: #if DEBUG_TRANSMIT
2250: mem_dump(d->vm->log_fd,d->tx_buffer,d->tx_bufsize);
2251: #endif
2252:
2253: /* Transmit the packet */
2254: pkt_data.ingress_port = d->cpu_port;
2255: pkt_data.pkt = d->tx_buffer;
2256: pkt_data.pkt_len = d->tx_bufsize - 4;
2257: pkt_data.sent_to_cpu = TRUE;
2258: bcm5600_handle_tx_pkt(d,&pkt_data,tdes[2]);
2259:
2260: /* Reset the TX buffer (packet fully transmitted) */
2261: d->tx_bufsize = 0;
2262:
2263: done:
2264: /* We have reached end of ring: trigger the TX underrun interrupt */
2265: if (!(tdes[1] & BCM5600_TXD_RING_CONT)) {
2266: d->tx_end_scan = 1;
2267: pci_dev_trigger_irq(d->vm,d->pci_dev);
2268: BCM_UNLOCK(d);
2269: return(TRUE);
2270: }
2271:
2272: /* Go to the next descriptor */
2273: d->tx_current += BCM5600_TXD_SIZE;
2274: BCM_UNLOCK(d);
2275: return(TRUE);
2276: }
2277:
2278: /* Handle the RX ring */
2279: static int dev_bcm5600_handle_rxring(netio_desc_t *nio,
2280: u_char *pkt,ssize_t pkt_len,
2281: struct nm_16esw_data *d,
2282: struct bcm5600_port *port)
2283: {
2284: struct bcm5600_pkt pkt_data;
2285: m_uint32_t rxd_len;
2286:
2287: #if DEBUG_RECEIVE
2288: BCM_LOG(d,"=== RECEIVE PATH ===\n");
2289:
2290: BCM_LOG(d,"%s: received a packet of %ld bytes.\n",
2291: port->name,(u_long)pkt_len);
2292: mem_dump(d->vm->log_fd,pkt,pkt_len);
2293: #endif
2294:
2295: BCM_LOCK(d);
2296:
2297: if (!d->rx_current || d->rx_end_scan) {
2298: BCM_UNLOCK(d);
2299: return(FALSE);
2300: }
2301:
2302: /* Read the current TX descriptor */
2303: physmem_copy_from_vm(d->vm,pkt_data.rdes,d->rx_current,
2304: (4 * sizeof(m_uint32_t)));
2305:
2306: pkt_data.rdes[0] = vmtoh32(pkt_data.rdes[0]);
2307: pkt_data.rdes[1] = vmtoh32(pkt_data.rdes[1]);
2308: pkt_data.rdes[2] = vmtoh32(pkt_data.rdes[2]);
2309: pkt_data.rdes[3] = vmtoh32(pkt_data.rdes[3]);
2310:
2311: #if DEBUG_RECEIVE
2312: BCM_LOG(d,"rx_current=0x%8.8x, "
2313: "rdes[0]=0x%8.8x, rdes[1]=0x%8.8x, rdes[2]=0x%8.8x\n",
2314: d->rx_current,pkt_data.rdes[0],pkt_data.rdes[1],pkt_data.rdes[2]);
2315: #endif
2316:
2317: /* Get the buffer size */
2318: rxd_len = pkt_data.rdes[1] & 0x7FF;
2319:
2320: if (pkt_len > rxd_len) {
2321: BCM_UNLOCK(d);
2322: return(FALSE);
2323: }
2324:
2325: /* Fill the packet info */
2326: pkt_data.ingress_port = port->id;
2327: pkt_data.pkt = pkt;
2328: pkt_data.pkt_len = pkt_len;
2329: pkt_data.sent_to_cpu = FALSE;
2330:
2331: /* Handle the packet */
2332: bcm5600_handle_rx_pkt(d,&pkt_data);
2333:
2334: /* Signal only an interrupt when a packet has been sent to the CPU */
2335: if (pkt_data.sent_to_cpu) {
2336: /* We have reached end of ring: trigger the RX underrun interrupt */
2337: if (!(pkt_data.rdes[1] & BCM5600_RXD_RING_CONT)) {
2338: d->rx_end_scan = 1;
2339: pci_dev_trigger_irq(d->vm,d->pci_dev);
2340: BCM_UNLOCK(d);
2341: return(TRUE);
2342: }
2343:
2344: /* A packet was received */
2345: pci_dev_trigger_irq(d->vm,d->pci_dev);
2346:
2347: /* Go to the next descriptor */
2348: d->rx_current += BCM5600_RXD_SIZE;
2349: }
2350:
2351: BCM_UNLOCK(d);
2352: return(TRUE);
2353: }
2354:
2355: /* pci_bcm5605_read() */
2356: static m_uint32_t pci_bcm5605_read(cpu_mips_t *cpu,struct pci_device *dev,
2357: int reg)
2358: {
2359: struct nm_16esw_data *d = dev->priv_data;
2360:
2361: switch(reg) {
2362: case PCI_REG_BAR0:
2363: return(d->dev->phys_addr);
2364: default:
2365: return(0);
2366: }
2367: }
2368:
2369: /* pci_bcm5605_write() */
2370: static void pci_bcm5605_write(cpu_mips_t *cpu,struct pci_device *dev,
2371: int reg,m_uint32_t value)
2372: {
2373: struct nm_16esw_data *d = dev->priv_data;
2374:
2375: switch(reg) {
2376: case PCI_REG_BAR0:
2377: vm_map_device(cpu->vm,d->dev,(m_uint64_t)value);
2378: BCM_LOG(d,"BCM5600 registers are mapped at 0x%x\n",value);
2379: break;
2380: }
2381: }
2382:
2383: /* Rewrite the base MAC address */
2384: int dev_nm_16esw_burn_mac_addr(vm_instance_t *vm,u_int nm_bay,
2385: struct cisco_eeprom *eeprom)
2386: {
2387: m_uint8_t eeprom_ver;
2388: size_t offset;
2389: n_eth_addr_t addr;
2390: m_uint16_t pid;
2391:
2392: pid = (m_uint16_t)getpid();
2393:
2394: /* Generate automatically the MAC address */
2395: addr.eth_addr_byte[0] = vm_get_mac_addr_msb(vm);
2396: addr.eth_addr_byte[1] = vm->instance_id & 0xFF;
2397: addr.eth_addr_byte[2] = pid >> 8;
2398: addr.eth_addr_byte[3] = pid & 0xFF;
2399: addr.eth_addr_byte[4] = 0xF0 + nm_bay;
2400: addr.eth_addr_byte[5] = 0x00;
2401:
2402: /* Read EEPROM format version */
2403: cisco_eeprom_get_byte(eeprom,0,&eeprom_ver);
2404:
2405: if (eeprom_ver != 4)
2406: return(-1);
2407:
2408: if (cisco_eeprom_v4_find_field(eeprom,0xCF,&offset) == -1)
2409: return(-1);
2410:
2411: cisco_eeprom_set_region(eeprom,offset,addr.eth_addr_byte,6);
2412: return(0);
2413: }
2414:
2415: /* Initialize a NM-16ESW module */
2416: struct nm_16esw_data *
2417: dev_nm_16esw_init(vm_instance_t *vm,char *name,u_int nm_bay,
2418: struct pci_bus *pci_bus,int pci_device,int irq)
2419: {
2420: struct nm_16esw_data *data;
2421: struct bcm5600_port *port;
2422: struct vdevice *dev;
2423: int i,port_id;
2424:
2425: /* Allocate the private data structure */
2426: if (!(data = malloc(sizeof(*data)))) {
2427: fprintf(stderr,"%s: out of memory\n",name);
2428: return NULL;
2429: }
2430:
2431: memset(data,0,sizeof(*data));
2432: pthread_mutex_init(&data->lock,NULL);
2433: data->name = name;
2434: data->nr_port = 16;
2435: data->vm = vm;
2436:
2437: /* Create the BCM5600 tables */
2438: if (bcm5600_table_create(data) == -1)
2439: return NULL;
2440:
2441: /* Clear the various tables */
2442: bcm5600_reset_arl(data);
2443: data->arl_cnt[0] = 1;
2444: data->t_ptable = bcm5600_table_find(data,BCM5600_ADDR_PTABLE0);
2445: data->t_vtable = bcm5600_table_find(data,BCM5600_ADDR_VTABLE0);
2446: data->t_arl = bcm5600_table_find(data,BCM5600_ADDR_ARL0);
2447: data->t_marl = bcm5600_table_find(data,BCM5600_ADDR_MARL0);
2448: data->t_tbmap = bcm5600_table_find(data,BCM5600_ADDR_TBMAP0);
2449: data->t_ttr = bcm5600_table_find(data,BCM5600_ADDR_TTR0);
2450:
2451: /* Initialize ports */
2452: data->cpu_port = 27;
2453:
2454: for(i=0;i<data->nr_port;i++) {
2455: port_id = nm16esw_port_mapping[i];
2456:
2457: port = &data->ports[port_id];
2458: port->id = port_id;
2459: snprintf(port->name,sizeof(port->name),"Fa%u/%d",nm_bay,i);
2460: }
2461:
2462: /* Create the BCM5605 PCI device */
2463: data->pci_dev = pci_dev_add(pci_bus,name,
2464: BCM5605_PCI_VENDOR_ID,BCM5605_PCI_PRODUCT_ID,
2465: pci_device,0,irq,data,
2466: NULL,pci_bcm5605_read,pci_bcm5605_write);
2467:
2468: if (!data->pci_dev) {
2469: fprintf(stderr,"%s: unable to create PCI device.\n",name);
2470: return NULL;
2471: }
2472:
2473: /* Create the BCM5605 device itself */
2474: if (!(dev = dev_create(name))) {
2475: fprintf(stderr,"%s: unable to create device.\n",name);
2476: return NULL;
2477: }
2478:
2479: dev->phys_addr = 0;
2480: dev->phys_len = 0x200000;
2481: dev->handler = dev_bcm5605_access;
2482:
2483: /* Store device info */
2484: dev->priv_data = data;
2485: data->dev = dev;
2486:
2487: /* Create the TX ring scanner */
2488: data->tx_tid = ptask_add((ptask_callback)dev_bcm5600_handle_txring,
2489: data,NULL);
2490:
2491: /* Start the MAC address ager */
2492: data->ager_tid = timer_create_entry(15000,FALSE,10,
2493: (timer_proc)bcm5600_arl_ager,data);
2494: return data;
2495: }
2496:
2497: /* Remove a NM-16ESW from the specified slot */
2498: int dev_nm_16esw_remove(struct nm_16esw_data *data)
2499: {
2500: /* Stop the Ager */
2501: timer_remove(data->ager_tid);
2502:
2503: /* Stop the TX ring task */
2504: ptask_remove(data->tx_tid);
2505:
2506: /* Remove device + PCI stuff */
2507: pci_dev_remove(data->pci_dev);
2508: vm_unbind_device(data->vm,data->dev);
2509: cpu_group_rebuild_mts(data->vm->cpu_group);
2510: free(data->dev);
2511:
2512: /* Free all tables and registers */
2513: bcm5600_table_free(data);
2514: bcm5600_reg_free(data);
2515: free(data);
2516: return(0);
2517: }
2518:
2519: /* Bind a Network IO descriptor */
2520: int dev_nm_16esw_set_nio(struct nm_16esw_data *d,u_int port_id,
2521: netio_desc_t *nio)
2522: {
2523: struct bcm5600_port *port;
2524:
2525: if (!d || (port_id >= d->nr_port))
2526: return(-1);
2527:
2528: /* define the new NIO */
2529: port = &d->ports[nm16esw_port_mapping[port_id]];
2530: port->nio = nio;
2531: netio_rxl_add(nio,(netio_rx_handler_t)dev_bcm5600_handle_rxring,d,port);
2532: return(0);
2533: }
2534:
2535: /* Unbind a Network IO descriptor */
2536: int dev_nm_16esw_unset_nio(struct nm_16esw_data *d,u_int port_id)
2537: {
2538: struct bcm5600_port *port;
2539:
2540: if (!d || (port_id >= d->nr_port))
2541: return(-1);
2542:
2543: port = &d->ports[nm16esw_port_mapping[port_id]];
2544:
2545: if (port->nio) {
2546: netio_rxl_remove(port->nio);
2547: port->nio = NULL;
2548: }
2549:
2550: return(0);
2551: }
2552:
2553: /* Show debugging information */
2554: int dev_nm_16esw_show_info(struct nm_16esw_data *d)
2555: {
2556: BCM_LOCK(d);
2557: printf("ARL count = %u\n\n",d->arl_cnt[0]);
2558: bcm5600_dump_main_tables(d);
2559: bcm5600_mirror_show_status(d);
2560: bcm5600_reg_dump(d,FALSE);
2561: BCM_UNLOCK(d);
2562: return(0);
2563: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.