/src/qemu/hw/net/rocker/rocker.c
Line | Count | Source |
1 | | /* |
2 | | * QEMU rocker switch emulation - PCI device |
3 | | * |
4 | | * Copyright (c) 2014 Scott Feldman <sfeldma@gmail.com> |
5 | | * Copyright (c) 2014 Jiri Pirko <jiri@resnulli.us> |
6 | | * |
7 | | * This program is free software; you can redistribute it and/or modify |
8 | | * it under the terms of the GNU General Public License as published by |
9 | | * the Free Software Foundation; either version 2 of the License, or |
10 | | * (at your option) any later version. |
11 | | * |
12 | | * This program is distributed in the hope that it will be useful, |
13 | | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
14 | | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
15 | | * GNU General Public License for more details. |
16 | | */ |
17 | | |
18 | | #include "qemu/osdep.h" |
19 | | #include "hw/pci/pci_device.h" |
20 | | #include "hw/core/qdev-properties.h" |
21 | | #include "hw/core/qdev-properties-system.h" |
22 | | #include "migration/vmstate.h" |
23 | | #include "hw/pci/msix.h" |
24 | | #include "net/net.h" |
25 | | #include "net/eth.h" |
26 | | #include "qapi/error.h" |
27 | | #include "qapi/qapi-commands-rocker.h" |
28 | | #include "qemu/iov.h" |
29 | | #include "qemu/module.h" |
30 | | #include "qemu/bitops.h" |
31 | | #include "qemu/log.h" |
32 | | |
33 | | #include "rocker.h" |
34 | | #include "rocker_hw.h" |
35 | | #include "rocker_fp.h" |
36 | | #include "rocker_desc.h" |
37 | | #include "rocker_tlv.h" |
38 | | #include "rocker_world.h" |
39 | | #include "rocker_of_dpa.h" |
40 | | |
41 | | struct rocker { |
42 | | /* private */ |
43 | | PCIDevice parent_obj; |
44 | | /* public */ |
45 | | |
46 | | MemoryRegion mmio; |
47 | | MemoryRegion msix_bar; |
48 | | |
49 | | /* switch configuration */ |
50 | | char *name; /* switch name */ |
51 | | char *world_name; /* world name */ |
52 | | uint32_t fp_ports; /* front-panel port count */ |
53 | | NICPeers *fp_ports_peers; |
54 | | MACAddr fp_start_macaddr; /* front-panel port 0 mac addr */ |
55 | | uint64_t switch_id; /* switch id */ |
56 | | |
57 | | /* front-panel ports */ |
58 | | FpPort *fp_port[ROCKER_FP_PORTS_MAX]; |
59 | | |
60 | | /* register backings */ |
61 | | uint32_t test_reg; |
62 | | uint64_t test_reg64; |
63 | | dma_addr_t test_dma_addr; |
64 | | uint32_t test_dma_size; |
65 | | uint64_t lower32; /* lower 32-bit val in 2-part 64-bit access */ |
66 | | |
67 | | /* desc rings */ |
68 | | DescRing **rings; |
69 | | |
70 | | /* switch worlds */ |
71 | | World *worlds[ROCKER_WORLD_TYPE_MAX]; |
72 | | World *world_dflt; |
73 | | |
74 | | QLIST_ENTRY(rocker) next; |
75 | | }; |
76 | | |
77 | | static QLIST_HEAD(, rocker) rockers; |
78 | | |
79 | | Rocker *rocker_find(const char *name) |
80 | 0 | { |
81 | 0 | Rocker *r; |
82 | |
|
83 | 0 | QLIST_FOREACH(r, &rockers, next) |
84 | 0 | if (strcmp(r->name, name) == 0) { |
85 | 0 | return r; |
86 | 0 | } |
87 | | |
88 | 0 | return NULL; |
89 | 0 | } |
90 | | |
91 | | World *rocker_get_world(Rocker *r, enum rocker_world_type type) |
92 | 0 | { |
93 | 0 | if (type < ROCKER_WORLD_TYPE_MAX) { |
94 | 0 | return r->worlds[type]; |
95 | 0 | } |
96 | 0 | return NULL; |
97 | 0 | } |
98 | | |
99 | | RockerSwitch *qmp_query_rocker(const char *name, Error **errp) |
100 | 0 | { |
101 | 0 | RockerSwitch *rocker; |
102 | 0 | Rocker *r; |
103 | |
|
104 | 0 | r = rocker_find(name); |
105 | 0 | if (!r) { |
106 | 0 | error_setg(errp, "rocker %s not found", name); |
107 | 0 | return NULL; |
108 | 0 | } |
109 | | |
110 | 0 | rocker = g_new0(RockerSwitch, 1); |
111 | 0 | rocker->name = g_strdup(r->name); |
112 | 0 | rocker->id = r->switch_id; |
113 | 0 | rocker->ports = r->fp_ports; |
114 | |
|
115 | 0 | return rocker; |
116 | 0 | } |
117 | | |
118 | | RockerPortList *qmp_query_rocker_ports(const char *name, Error **errp) |
119 | 0 | { |
120 | 0 | RockerPortList *list = NULL; |
121 | 0 | Rocker *r; |
122 | 0 | int i; |
123 | |
|
124 | 0 | r = rocker_find(name); |
125 | 0 | if (!r) { |
126 | 0 | error_setg(errp, "rocker %s not found", name); |
127 | 0 | return NULL; |
128 | 0 | } |
129 | | |
130 | 0 | for (i = r->fp_ports - 1; i >= 0; i--) { |
131 | 0 | QAPI_LIST_PREPEND(list, fp_port_get_info(r->fp_port[i])); |
132 | 0 | } |
133 | |
|
134 | 0 | return list; |
135 | 0 | } |
136 | | |
137 | | static uint32_t rocker_get_pport_by_tx_ring(Rocker *r, |
138 | | DescRing *ring) |
139 | 0 | { |
140 | 0 | return (desc_ring_index(ring) - 2) / 2 + 1; |
141 | 0 | } |
142 | | |
143 | | static int tx_consume(Rocker *r, DescInfo *info) |
144 | 0 | { |
145 | 0 | PCIDevice *dev = PCI_DEVICE(r); |
146 | 0 | char *buf = desc_get_buf(info, true); |
147 | 0 | RockerTlv *tlv_frag; |
148 | 0 | RockerTlv *tlvs[ROCKER_TLV_TX_MAX + 1]; |
149 | 0 | struct iovec iov[ROCKER_TX_FRAGS_MAX] = { { 0, }, }; |
150 | 0 | uint32_t pport; |
151 | 0 | uint32_t port; |
152 | 0 | uint16_t tx_offload = ROCKER_TX_OFFLOAD_NONE; |
153 | 0 | uint16_t tx_l3_csum_off = 0; |
154 | 0 | uint16_t tx_tso_mss = 0; |
155 | 0 | uint16_t tx_tso_hdr_len = 0; |
156 | 0 | int iovcnt = 0; |
157 | 0 | int err = ROCKER_OK; |
158 | 0 | int rem; |
159 | 0 | int i; |
160 | |
|
161 | 0 | if (!buf) { |
162 | 0 | return -ROCKER_ENXIO; |
163 | 0 | } |
164 | | |
165 | 0 | rocker_tlv_parse(tlvs, ROCKER_TLV_TX_MAX, buf, desc_tlv_size(info)); |
166 | |
|
167 | 0 | if (!tlvs[ROCKER_TLV_TX_FRAGS]) { |
168 | 0 | return -ROCKER_EINVAL; |
169 | 0 | } |
170 | | |
171 | 0 | pport = rocker_get_pport_by_tx_ring(r, desc_get_ring(info)); |
172 | 0 | if (!fp_port_from_pport(pport, &port)) { |
173 | 0 | return -ROCKER_EINVAL; |
174 | 0 | } |
175 | | |
176 | 0 | if (tlvs[ROCKER_TLV_TX_OFFLOAD]) { |
177 | 0 | tx_offload = rocker_tlv_get_u8(tlvs[ROCKER_TLV_TX_OFFLOAD]); |
178 | 0 | } |
179 | |
|
180 | 0 | switch (tx_offload) { |
181 | 0 | case ROCKER_TX_OFFLOAD_L3_CSUM: |
182 | 0 | if (!tlvs[ROCKER_TLV_TX_L3_CSUM_OFF]) { |
183 | 0 | return -ROCKER_EINVAL; |
184 | 0 | } |
185 | 0 | break; |
186 | 0 | case ROCKER_TX_OFFLOAD_TSO: |
187 | 0 | if (!tlvs[ROCKER_TLV_TX_TSO_MSS] || |
188 | 0 | !tlvs[ROCKER_TLV_TX_TSO_HDR_LEN]) { |
189 | 0 | return -ROCKER_EINVAL; |
190 | 0 | } |
191 | 0 | break; |
192 | 0 | } |
193 | | |
194 | 0 | if (tlvs[ROCKER_TLV_TX_L3_CSUM_OFF]) { |
195 | 0 | tx_l3_csum_off = rocker_tlv_get_le16(tlvs[ROCKER_TLV_TX_L3_CSUM_OFF]); |
196 | 0 | qemu_log_mask(LOG_UNIMP, "rocker %s: L3 not implemented" |
197 | 0 | " (cksum off: %u)\n", |
198 | 0 | __func__, tx_l3_csum_off); |
199 | 0 | } |
200 | |
|
201 | 0 | if (tlvs[ROCKER_TLV_TX_TSO_MSS]) { |
202 | 0 | tx_tso_mss = rocker_tlv_get_le16(tlvs[ROCKER_TLV_TX_TSO_MSS]); |
203 | 0 | qemu_log_mask(LOG_UNIMP, "rocker %s: TSO not implemented (MSS: %u)\n", |
204 | 0 | __func__, tx_tso_mss); |
205 | 0 | } |
206 | |
|
207 | 0 | if (tlvs[ROCKER_TLV_TX_TSO_HDR_LEN]) { |
208 | 0 | tx_tso_hdr_len = rocker_tlv_get_le16(tlvs[ROCKER_TLV_TX_TSO_HDR_LEN]); |
209 | 0 | qemu_log_mask(LOG_UNIMP, "rocker %s: TSO not implemented" |
210 | 0 | " (hdr length: %u)\n", |
211 | 0 | __func__, tx_tso_hdr_len); |
212 | 0 | } |
213 | |
|
214 | 0 | rocker_tlv_for_each_nested(tlv_frag, tlvs[ROCKER_TLV_TX_FRAGS], rem) { |
215 | 0 | hwaddr frag_addr; |
216 | 0 | uint16_t frag_len; |
217 | |
|
218 | 0 | if (rocker_tlv_type(tlv_frag) != ROCKER_TLV_TX_FRAG) { |
219 | 0 | err = -ROCKER_EINVAL; |
220 | 0 | goto err_bad_attr; |
221 | 0 | } |
222 | | |
223 | 0 | rocker_tlv_parse_nested(tlvs, ROCKER_TLV_TX_FRAG_ATTR_MAX, tlv_frag); |
224 | |
|
225 | 0 | if (!tlvs[ROCKER_TLV_TX_FRAG_ATTR_ADDR] || |
226 | 0 | !tlvs[ROCKER_TLV_TX_FRAG_ATTR_LEN]) { |
227 | 0 | err = -ROCKER_EINVAL; |
228 | 0 | goto err_bad_attr; |
229 | 0 | } |
230 | | |
231 | 0 | frag_addr = rocker_tlv_get_le64(tlvs[ROCKER_TLV_TX_FRAG_ATTR_ADDR]); |
232 | 0 | frag_len = rocker_tlv_get_le16(tlvs[ROCKER_TLV_TX_FRAG_ATTR_LEN]); |
233 | |
|
234 | 0 | if (iovcnt >= ROCKER_TX_FRAGS_MAX) { |
235 | 0 | goto err_too_many_frags; |
236 | 0 | } |
237 | 0 | iov[iovcnt].iov_len = frag_len; |
238 | 0 | iov[iovcnt].iov_base = g_malloc(frag_len); |
239 | |
|
240 | 0 | pci_dma_read(dev, frag_addr, iov[iovcnt].iov_base, |
241 | 0 | iov[iovcnt].iov_len); |
242 | |
|
243 | 0 | iovcnt++; |
244 | 0 | } |
245 | | |
246 | 0 | err = fp_port_eg(r->fp_port[port], iov, iovcnt); |
247 | |
|
248 | 0 | err_too_many_frags: |
249 | 0 | err_bad_attr: |
250 | 0 | for (i = 0; i < ROCKER_TX_FRAGS_MAX; i++) { |
251 | 0 | g_free(iov[i].iov_base); |
252 | 0 | } |
253 | |
|
254 | 0 | return err; |
255 | 0 | } |
256 | | |
257 | | static int cmd_get_port_settings(Rocker *r, |
258 | | DescInfo *info, char *buf, |
259 | | RockerTlv *cmd_info_tlv) |
260 | 0 | { |
261 | 0 | RockerTlv *tlvs[ROCKER_TLV_CMD_PORT_SETTINGS_MAX + 1]; |
262 | 0 | RockerTlv *nest; |
263 | 0 | FpPort *fp_port; |
264 | 0 | uint32_t pport; |
265 | 0 | uint32_t port; |
266 | 0 | uint32_t speed; |
267 | 0 | uint8_t duplex; |
268 | 0 | uint8_t autoneg; |
269 | 0 | uint8_t learning; |
270 | 0 | char *phys_name; |
271 | 0 | MACAddr macaddr; |
272 | 0 | enum rocker_world_type mode; |
273 | 0 | size_t tlv_size; |
274 | 0 | int pos; |
275 | 0 | int err; |
276 | |
|
277 | 0 | rocker_tlv_parse_nested(tlvs, ROCKER_TLV_CMD_PORT_SETTINGS_MAX, |
278 | 0 | cmd_info_tlv); |
279 | |
|
280 | 0 | if (!tlvs[ROCKER_TLV_CMD_PORT_SETTINGS_PPORT]) { |
281 | 0 | return -ROCKER_EINVAL; |
282 | 0 | } |
283 | | |
284 | 0 | pport = rocker_tlv_get_le32(tlvs[ROCKER_TLV_CMD_PORT_SETTINGS_PPORT]); |
285 | 0 | if (!fp_port_from_pport(pport, &port)) { |
286 | 0 | return -ROCKER_EINVAL; |
287 | 0 | } |
288 | 0 | fp_port = r->fp_port[port]; |
289 | |
|
290 | 0 | err = fp_port_get_settings(fp_port, &speed, &duplex, &autoneg); |
291 | 0 | if (err) { |
292 | 0 | return err; |
293 | 0 | } |
294 | | |
295 | 0 | fp_port_get_macaddr(fp_port, &macaddr); |
296 | 0 | mode = world_type(fp_port_get_world(fp_port)); |
297 | 0 | learning = fp_port_get_learning(fp_port); |
298 | 0 | phys_name = fp_port_get_name(fp_port); |
299 | |
|
300 | 0 | tlv_size = rocker_tlv_total_size(0) + /* nest */ |
301 | 0 | rocker_tlv_total_size(sizeof(uint32_t)) + /* pport */ |
302 | 0 | rocker_tlv_total_size(sizeof(uint32_t)) + /* speed */ |
303 | 0 | rocker_tlv_total_size(sizeof(uint8_t)) + /* duplex */ |
304 | 0 | rocker_tlv_total_size(sizeof(uint8_t)) + /* autoneg */ |
305 | 0 | rocker_tlv_total_size(sizeof(macaddr.a)) + /* macaddr */ |
306 | 0 | rocker_tlv_total_size(sizeof(uint8_t)) + /* mode */ |
307 | 0 | rocker_tlv_total_size(sizeof(uint8_t)) + /* learning */ |
308 | 0 | rocker_tlv_total_size(strlen(phys_name)); |
309 | |
|
310 | 0 | if (tlv_size > desc_buf_size(info)) { |
311 | 0 | return -ROCKER_EMSGSIZE; |
312 | 0 | } |
313 | | |
314 | 0 | pos = 0; |
315 | 0 | nest = rocker_tlv_nest_start(buf, &pos, ROCKER_TLV_CMD_INFO); |
316 | 0 | rocker_tlv_put_le32(buf, &pos, ROCKER_TLV_CMD_PORT_SETTINGS_PPORT, pport); |
317 | 0 | rocker_tlv_put_le32(buf, &pos, ROCKER_TLV_CMD_PORT_SETTINGS_SPEED, speed); |
318 | 0 | rocker_tlv_put_u8(buf, &pos, ROCKER_TLV_CMD_PORT_SETTINGS_DUPLEX, duplex); |
319 | 0 | rocker_tlv_put_u8(buf, &pos, ROCKER_TLV_CMD_PORT_SETTINGS_AUTONEG, autoneg); |
320 | 0 | rocker_tlv_put(buf, &pos, ROCKER_TLV_CMD_PORT_SETTINGS_MACADDR, |
321 | 0 | sizeof(macaddr.a), macaddr.a); |
322 | 0 | rocker_tlv_put_u8(buf, &pos, ROCKER_TLV_CMD_PORT_SETTINGS_MODE, mode); |
323 | 0 | rocker_tlv_put_u8(buf, &pos, ROCKER_TLV_CMD_PORT_SETTINGS_LEARNING, |
324 | 0 | learning); |
325 | 0 | rocker_tlv_put(buf, &pos, ROCKER_TLV_CMD_PORT_SETTINGS_PHYS_NAME, |
326 | 0 | strlen(phys_name), phys_name); |
327 | 0 | rocker_tlv_nest_end(buf, &pos, nest); |
328 | |
|
329 | 0 | return desc_set_buf(info, tlv_size); |
330 | 0 | } |
331 | | |
332 | | static int cmd_set_port_settings(Rocker *r, |
333 | | RockerTlv *cmd_info_tlv) |
334 | 0 | { |
335 | 0 | RockerTlv *tlvs[ROCKER_TLV_CMD_PORT_SETTINGS_MAX + 1]; |
336 | 0 | FpPort *fp_port; |
337 | 0 | uint32_t pport; |
338 | 0 | uint32_t port; |
339 | 0 | uint32_t speed; |
340 | 0 | uint8_t duplex; |
341 | 0 | uint8_t autoneg; |
342 | 0 | uint8_t learning; |
343 | 0 | MACAddr macaddr; |
344 | 0 | enum rocker_world_type mode; |
345 | 0 | int err; |
346 | |
|
347 | 0 | rocker_tlv_parse_nested(tlvs, ROCKER_TLV_CMD_PORT_SETTINGS_MAX, |
348 | 0 | cmd_info_tlv); |
349 | |
|
350 | 0 | if (!tlvs[ROCKER_TLV_CMD_PORT_SETTINGS_PPORT]) { |
351 | 0 | return -ROCKER_EINVAL; |
352 | 0 | } |
353 | | |
354 | 0 | pport = rocker_tlv_get_le32(tlvs[ROCKER_TLV_CMD_PORT_SETTINGS_PPORT]); |
355 | 0 | if (!fp_port_from_pport(pport, &port)) { |
356 | 0 | return -ROCKER_EINVAL; |
357 | 0 | } |
358 | 0 | fp_port = r->fp_port[port]; |
359 | |
|
360 | 0 | if (tlvs[ROCKER_TLV_CMD_PORT_SETTINGS_SPEED] && |
361 | 0 | tlvs[ROCKER_TLV_CMD_PORT_SETTINGS_DUPLEX] && |
362 | 0 | tlvs[ROCKER_TLV_CMD_PORT_SETTINGS_AUTONEG]) { |
363 | |
|
364 | 0 | speed = rocker_tlv_get_le32(tlvs[ROCKER_TLV_CMD_PORT_SETTINGS_SPEED]); |
365 | 0 | duplex = rocker_tlv_get_u8(tlvs[ROCKER_TLV_CMD_PORT_SETTINGS_DUPLEX]); |
366 | 0 | autoneg = rocker_tlv_get_u8(tlvs[ROCKER_TLV_CMD_PORT_SETTINGS_AUTONEG]); |
367 | |
|
368 | 0 | err = fp_port_set_settings(fp_port, speed, duplex, autoneg); |
369 | 0 | if (err) { |
370 | 0 | return err; |
371 | 0 | } |
372 | 0 | } |
373 | | |
374 | 0 | if (tlvs[ROCKER_TLV_CMD_PORT_SETTINGS_MACADDR]) { |
375 | 0 | if (rocker_tlv_len(tlvs[ROCKER_TLV_CMD_PORT_SETTINGS_MACADDR]) != |
376 | 0 | sizeof(macaddr.a)) { |
377 | 0 | return -ROCKER_EINVAL; |
378 | 0 | } |
379 | 0 | memcpy(macaddr.a, |
380 | 0 | rocker_tlv_data(tlvs[ROCKER_TLV_CMD_PORT_SETTINGS_MACADDR]), |
381 | 0 | sizeof(macaddr.a)); |
382 | 0 | fp_port_set_macaddr(fp_port, &macaddr); |
383 | 0 | } |
384 | | |
385 | 0 | if (tlvs[ROCKER_TLV_CMD_PORT_SETTINGS_MODE]) { |
386 | 0 | mode = rocker_tlv_get_u8(tlvs[ROCKER_TLV_CMD_PORT_SETTINGS_MODE]); |
387 | 0 | if (mode >= ROCKER_WORLD_TYPE_MAX) { |
388 | 0 | return -ROCKER_EINVAL; |
389 | 0 | } |
390 | | /* We don't support world change. */ |
391 | 0 | if (!fp_port_check_world(fp_port, r->worlds[mode])) { |
392 | 0 | return -ROCKER_EINVAL; |
393 | 0 | } |
394 | 0 | } |
395 | | |
396 | 0 | if (tlvs[ROCKER_TLV_CMD_PORT_SETTINGS_LEARNING]) { |
397 | 0 | learning = |
398 | 0 | rocker_tlv_get_u8(tlvs[ROCKER_TLV_CMD_PORT_SETTINGS_LEARNING]); |
399 | 0 | fp_port_set_learning(fp_port, learning); |
400 | 0 | } |
401 | |
|
402 | 0 | return ROCKER_OK; |
403 | 0 | } |
404 | | |
405 | | static int cmd_consume(Rocker *r, DescInfo *info) |
406 | 0 | { |
407 | 0 | char *buf = desc_get_buf(info, false); |
408 | 0 | RockerTlv *tlvs[ROCKER_TLV_CMD_MAX + 1]; |
409 | 0 | RockerTlv *info_tlv; |
410 | 0 | World *world; |
411 | 0 | uint16_t cmd; |
412 | 0 | int err; |
413 | |
|
414 | 0 | if (!buf) { |
415 | 0 | return -ROCKER_ENXIO; |
416 | 0 | } |
417 | | |
418 | 0 | rocker_tlv_parse(tlvs, ROCKER_TLV_CMD_MAX, buf, desc_tlv_size(info)); |
419 | |
|
420 | 0 | if (!tlvs[ROCKER_TLV_CMD_TYPE] || !tlvs[ROCKER_TLV_CMD_INFO]) { |
421 | 0 | return -ROCKER_EINVAL; |
422 | 0 | } |
423 | | |
424 | 0 | cmd = rocker_tlv_get_le16(tlvs[ROCKER_TLV_CMD_TYPE]); |
425 | 0 | info_tlv = tlvs[ROCKER_TLV_CMD_INFO]; |
426 | | |
427 | | /* This might be reworked to something like this: |
428 | | * Every world will have an array of command handlers from |
429 | | * ROCKER_TLV_CMD_TYPE_UNSPEC to ROCKER_TLV_CMD_TYPE_MAX. There is |
430 | | * up to each world to implement whatever command it want. |
431 | | * It can reference "generic" commands as cmd_set_port_settings or |
432 | | * cmd_get_port_settings |
433 | | */ |
434 | |
|
435 | 0 | switch (cmd) { |
436 | 0 | case ROCKER_TLV_CMD_TYPE_OF_DPA_FLOW_ADD: |
437 | 0 | case ROCKER_TLV_CMD_TYPE_OF_DPA_FLOW_MOD: |
438 | 0 | case ROCKER_TLV_CMD_TYPE_OF_DPA_FLOW_DEL: |
439 | 0 | case ROCKER_TLV_CMD_TYPE_OF_DPA_FLOW_GET_STATS: |
440 | 0 | case ROCKER_TLV_CMD_TYPE_OF_DPA_GROUP_ADD: |
441 | 0 | case ROCKER_TLV_CMD_TYPE_OF_DPA_GROUP_MOD: |
442 | 0 | case ROCKER_TLV_CMD_TYPE_OF_DPA_GROUP_DEL: |
443 | 0 | case ROCKER_TLV_CMD_TYPE_OF_DPA_GROUP_GET_STATS: |
444 | 0 | world = r->worlds[ROCKER_WORLD_TYPE_OF_DPA]; |
445 | 0 | err = world_do_cmd(world, info, buf, cmd, info_tlv); |
446 | 0 | break; |
447 | 0 | case ROCKER_TLV_CMD_TYPE_GET_PORT_SETTINGS: |
448 | 0 | err = cmd_get_port_settings(r, info, buf, info_tlv); |
449 | 0 | break; |
450 | 0 | case ROCKER_TLV_CMD_TYPE_SET_PORT_SETTINGS: |
451 | 0 | err = cmd_set_port_settings(r, info_tlv); |
452 | 0 | break; |
453 | 0 | default: |
454 | 0 | err = -ROCKER_EINVAL; |
455 | 0 | break; |
456 | 0 | } |
457 | | |
458 | 0 | return err; |
459 | 0 | } |
460 | | |
461 | | static void rocker_msix_irq(Rocker *r, unsigned vector) |
462 | 0 | { |
463 | 0 | PCIDevice *dev = PCI_DEVICE(r); |
464 | |
|
465 | 0 | DPRINTF("MSI-X notify request for vector %d\n", vector); |
466 | 0 | if (vector >= ROCKER_MSIX_VEC_COUNT(r->fp_ports)) { |
467 | 0 | DPRINTF("incorrect vector %d\n", vector); |
468 | 0 | return; |
469 | 0 | } |
470 | 0 | msix_notify(dev, vector); |
471 | 0 | } |
472 | | |
473 | | int rocker_event_link_changed(Rocker *r, uint32_t pport, bool link_up) |
474 | 0 | { |
475 | 0 | DescRing *ring = r->rings[ROCKER_RING_EVENT]; |
476 | 0 | DescInfo *info = desc_ring_fetch_desc(ring); |
477 | 0 | RockerTlv *nest; |
478 | 0 | char *buf; |
479 | 0 | size_t tlv_size; |
480 | 0 | int pos; |
481 | 0 | int err; |
482 | |
|
483 | 0 | if (!info) { |
484 | 0 | return -ROCKER_ENOBUFS; |
485 | 0 | } |
486 | | |
487 | 0 | tlv_size = rocker_tlv_total_size(sizeof(uint16_t)) + /* event type */ |
488 | 0 | rocker_tlv_total_size(0) + /* nest */ |
489 | 0 | rocker_tlv_total_size(sizeof(uint32_t)) + /* pport */ |
490 | 0 | rocker_tlv_total_size(sizeof(uint8_t)); /* link up */ |
491 | |
|
492 | 0 | if (tlv_size > desc_buf_size(info)) { |
493 | 0 | err = -ROCKER_EMSGSIZE; |
494 | 0 | goto err_too_big; |
495 | 0 | } |
496 | | |
497 | 0 | buf = desc_get_buf(info, false); |
498 | 0 | if (!buf) { |
499 | 0 | err = -ROCKER_ENOMEM; |
500 | 0 | goto err_no_mem; |
501 | 0 | } |
502 | | |
503 | 0 | pos = 0; |
504 | 0 | rocker_tlv_put_le32(buf, &pos, ROCKER_TLV_EVENT_TYPE, |
505 | 0 | ROCKER_TLV_EVENT_TYPE_LINK_CHANGED); |
506 | 0 | nest = rocker_tlv_nest_start(buf, &pos, ROCKER_TLV_EVENT_INFO); |
507 | 0 | rocker_tlv_put_le32(buf, &pos, ROCKER_TLV_EVENT_LINK_CHANGED_PPORT, pport); |
508 | 0 | rocker_tlv_put_u8(buf, &pos, ROCKER_TLV_EVENT_LINK_CHANGED_LINKUP, |
509 | 0 | link_up ? 1 : 0); |
510 | 0 | rocker_tlv_nest_end(buf, &pos, nest); |
511 | |
|
512 | 0 | err = desc_set_buf(info, tlv_size); |
513 | |
|
514 | 0 | err_too_big: |
515 | 0 | err_no_mem: |
516 | 0 | if (desc_ring_post_desc(ring, err)) { |
517 | 0 | rocker_msix_irq(r, ROCKER_MSIX_VEC_EVENT); |
518 | 0 | } |
519 | |
|
520 | 0 | return err; |
521 | 0 | } |
522 | | |
523 | | int rocker_event_mac_vlan_seen(Rocker *r, uint32_t pport, uint8_t *addr, |
524 | | uint16_t vlan_id) |
525 | 0 | { |
526 | 0 | DescRing *ring = r->rings[ROCKER_RING_EVENT]; |
527 | 0 | DescInfo *info; |
528 | 0 | FpPort *fp_port; |
529 | 0 | uint32_t port; |
530 | 0 | RockerTlv *nest; |
531 | 0 | char *buf; |
532 | 0 | size_t tlv_size; |
533 | 0 | int pos; |
534 | 0 | int err; |
535 | |
|
536 | 0 | if (!fp_port_from_pport(pport, &port)) { |
537 | 0 | return -ROCKER_EINVAL; |
538 | 0 | } |
539 | 0 | fp_port = r->fp_port[port]; |
540 | 0 | if (!fp_port_get_learning(fp_port)) { |
541 | 0 | return ROCKER_OK; |
542 | 0 | } |
543 | | |
544 | 0 | info = desc_ring_fetch_desc(ring); |
545 | 0 | if (!info) { |
546 | 0 | return -ROCKER_ENOBUFS; |
547 | 0 | } |
548 | | |
549 | 0 | tlv_size = rocker_tlv_total_size(sizeof(uint16_t)) + /* event type */ |
550 | 0 | rocker_tlv_total_size(0) + /* nest */ |
551 | 0 | rocker_tlv_total_size(sizeof(uint32_t)) + /* pport */ |
552 | 0 | rocker_tlv_total_size(ETH_ALEN) + /* mac addr */ |
553 | 0 | rocker_tlv_total_size(sizeof(uint16_t)); /* vlan_id */ |
554 | |
|
555 | 0 | if (tlv_size > desc_buf_size(info)) { |
556 | 0 | err = -ROCKER_EMSGSIZE; |
557 | 0 | goto err_too_big; |
558 | 0 | } |
559 | | |
560 | 0 | buf = desc_get_buf(info, false); |
561 | 0 | if (!buf) { |
562 | 0 | err = -ROCKER_ENOMEM; |
563 | 0 | goto err_no_mem; |
564 | 0 | } |
565 | | |
566 | 0 | pos = 0; |
567 | 0 | rocker_tlv_put_le32(buf, &pos, ROCKER_TLV_EVENT_TYPE, |
568 | 0 | ROCKER_TLV_EVENT_TYPE_MAC_VLAN_SEEN); |
569 | 0 | nest = rocker_tlv_nest_start(buf, &pos, ROCKER_TLV_EVENT_INFO); |
570 | 0 | rocker_tlv_put_le32(buf, &pos, ROCKER_TLV_EVENT_MAC_VLAN_PPORT, pport); |
571 | 0 | rocker_tlv_put(buf, &pos, ROCKER_TLV_EVENT_MAC_VLAN_MAC, ETH_ALEN, addr); |
572 | 0 | rocker_tlv_put_u16(buf, &pos, ROCKER_TLV_EVENT_MAC_VLAN_VLAN_ID, vlan_id); |
573 | 0 | rocker_tlv_nest_end(buf, &pos, nest); |
574 | |
|
575 | 0 | err = desc_set_buf(info, tlv_size); |
576 | |
|
577 | 0 | err_too_big: |
578 | 0 | err_no_mem: |
579 | 0 | if (desc_ring_post_desc(ring, err)) { |
580 | 0 | rocker_msix_irq(r, ROCKER_MSIX_VEC_EVENT); |
581 | 0 | } |
582 | |
|
583 | 0 | return err; |
584 | 0 | } |
585 | | |
586 | | static DescRing *rocker_get_rx_ring_by_pport(Rocker *r, |
587 | | uint32_t pport) |
588 | 0 | { |
589 | 0 | return r->rings[(pport - 1) * 2 + 3]; |
590 | 0 | } |
591 | | |
592 | | int rx_produce(World *world, uint32_t pport, |
593 | | const struct iovec *iov, int iovcnt, uint8_t copy_to_cpu) |
594 | 0 | { |
595 | 0 | Rocker *r = world_rocker(world); |
596 | 0 | PCIDevice *dev = (PCIDevice *)r; |
597 | 0 | DescRing *ring = rocker_get_rx_ring_by_pport(r, pport); |
598 | 0 | DescInfo *info = desc_ring_fetch_desc(ring); |
599 | 0 | char *data; |
600 | 0 | size_t data_size = iov_size(iov, iovcnt); |
601 | 0 | char *buf; |
602 | 0 | uint16_t rx_flags = 0; |
603 | 0 | uint16_t rx_csum = 0; |
604 | 0 | size_t tlv_size; |
605 | 0 | RockerTlv *tlvs[ROCKER_TLV_RX_MAX + 1]; |
606 | 0 | hwaddr frag_addr; |
607 | 0 | uint16_t frag_max_len; |
608 | 0 | int pos; |
609 | 0 | int err; |
610 | |
|
611 | 0 | if (!info) { |
612 | 0 | return -ROCKER_ENOBUFS; |
613 | 0 | } |
614 | | |
615 | 0 | buf = desc_get_buf(info, false); |
616 | 0 | if (!buf) { |
617 | 0 | err = -ROCKER_ENXIO; |
618 | 0 | goto out; |
619 | 0 | } |
620 | 0 | rocker_tlv_parse(tlvs, ROCKER_TLV_RX_MAX, buf, desc_tlv_size(info)); |
621 | |
|
622 | 0 | if (!tlvs[ROCKER_TLV_RX_FRAG_ADDR] || |
623 | 0 | !tlvs[ROCKER_TLV_RX_FRAG_MAX_LEN]) { |
624 | 0 | err = -ROCKER_EINVAL; |
625 | 0 | goto out; |
626 | 0 | } |
627 | | |
628 | 0 | frag_addr = rocker_tlv_get_le64(tlvs[ROCKER_TLV_RX_FRAG_ADDR]); |
629 | 0 | frag_max_len = rocker_tlv_get_le16(tlvs[ROCKER_TLV_RX_FRAG_MAX_LEN]); |
630 | |
|
631 | 0 | if (data_size > frag_max_len) { |
632 | 0 | err = -ROCKER_EMSGSIZE; |
633 | 0 | goto out; |
634 | 0 | } |
635 | | |
636 | 0 | if (copy_to_cpu) { |
637 | 0 | rx_flags |= ROCKER_RX_FLAGS_FWD_OFFLOAD; |
638 | 0 | } |
639 | | |
640 | | /* XXX calc rx flags/csum */ |
641 | |
|
642 | 0 | tlv_size = rocker_tlv_total_size(sizeof(uint16_t)) + /* flags */ |
643 | 0 | rocker_tlv_total_size(sizeof(uint16_t)) + /* scum */ |
644 | 0 | rocker_tlv_total_size(sizeof(uint64_t)) + /* frag addr */ |
645 | 0 | rocker_tlv_total_size(sizeof(uint16_t)) + /* frag max len */ |
646 | 0 | rocker_tlv_total_size(sizeof(uint16_t)); /* frag len */ |
647 | |
|
648 | 0 | if (tlv_size > desc_buf_size(info)) { |
649 | 0 | err = -ROCKER_EMSGSIZE; |
650 | 0 | goto out; |
651 | 0 | } |
652 | | |
653 | | /* TODO: |
654 | | * iov dma write can be optimized in similar way e1000 does it in |
655 | | * e1000_receive_iov. But maybe if would make sense to introduce |
656 | | * generic helper iov_dma_write. |
657 | | */ |
658 | | |
659 | 0 | data = g_malloc(data_size); |
660 | |
|
661 | 0 | iov_to_buf(iov, iovcnt, 0, data, data_size); |
662 | 0 | pci_dma_write(dev, frag_addr, data, data_size); |
663 | 0 | g_free(data); |
664 | |
|
665 | 0 | pos = 0; |
666 | 0 | rocker_tlv_put_le16(buf, &pos, ROCKER_TLV_RX_FLAGS, rx_flags); |
667 | 0 | rocker_tlv_put_le16(buf, &pos, ROCKER_TLV_RX_CSUM, rx_csum); |
668 | 0 | rocker_tlv_put_le64(buf, &pos, ROCKER_TLV_RX_FRAG_ADDR, frag_addr); |
669 | 0 | rocker_tlv_put_le16(buf, &pos, ROCKER_TLV_RX_FRAG_MAX_LEN, frag_max_len); |
670 | 0 | rocker_tlv_put_le16(buf, &pos, ROCKER_TLV_RX_FRAG_LEN, data_size); |
671 | |
|
672 | 0 | err = desc_set_buf(info, tlv_size); |
673 | |
|
674 | 0 | out: |
675 | 0 | if (desc_ring_post_desc(ring, err)) { |
676 | 0 | rocker_msix_irq(r, ROCKER_MSIX_VEC_RX(pport - 1)); |
677 | 0 | } |
678 | |
|
679 | 0 | return err; |
680 | 0 | } |
681 | | |
682 | | int rocker_port_eg(Rocker *r, uint32_t pport, |
683 | | const struct iovec *iov, int iovcnt) |
684 | 0 | { |
685 | 0 | FpPort *fp_port; |
686 | 0 | uint32_t port; |
687 | |
|
688 | 0 | if (!fp_port_from_pport(pport, &port)) { |
689 | 0 | return -ROCKER_EINVAL; |
690 | 0 | } |
691 | | |
692 | 0 | fp_port = r->fp_port[port]; |
693 | |
|
694 | 0 | return fp_port_eg(fp_port, iov, iovcnt); |
695 | 0 | } |
696 | | |
697 | | static void rocker_test_dma_ctrl(Rocker *r, uint32_t val) |
698 | 0 | { |
699 | 0 | PCIDevice *dev = PCI_DEVICE(r); |
700 | 0 | char *buf; |
701 | 0 | int i; |
702 | |
|
703 | 0 | buf = g_malloc(r->test_dma_size); |
704 | |
|
705 | 0 | switch (val) { |
706 | 0 | case ROCKER_TEST_DMA_CTRL_CLEAR: |
707 | 0 | memset(buf, 0, r->test_dma_size); |
708 | 0 | break; |
709 | 0 | case ROCKER_TEST_DMA_CTRL_FILL: |
710 | 0 | memset(buf, 0x96, r->test_dma_size); |
711 | 0 | break; |
712 | 0 | case ROCKER_TEST_DMA_CTRL_INVERT: |
713 | 0 | pci_dma_read(dev, r->test_dma_addr, buf, r->test_dma_size); |
714 | 0 | for (i = 0; i < r->test_dma_size; i++) { |
715 | 0 | buf[i] = ~buf[i]; |
716 | 0 | } |
717 | 0 | break; |
718 | 0 | default: |
719 | 0 | DPRINTF("not test dma control val=0x%08x\n", val); |
720 | 0 | goto err_out; |
721 | 0 | } |
722 | 0 | pci_dma_write(dev, r->test_dma_addr, buf, r->test_dma_size); |
723 | |
|
724 | 0 | rocker_msix_irq(r, ROCKER_MSIX_VEC_TEST); |
725 | |
|
726 | 0 | err_out: |
727 | 0 | g_free(buf); |
728 | 0 | } |
729 | | |
730 | | static void rocker_reset(DeviceState *dev); |
731 | | |
732 | | static void rocker_control(Rocker *r, uint32_t val) |
733 | 0 | { |
734 | 0 | if (val & ROCKER_CONTROL_RESET) { |
735 | 0 | rocker_reset(DEVICE(r)); |
736 | 0 | } |
737 | 0 | } |
738 | | |
739 | | static int rocker_pci_ring_count(Rocker *r) |
740 | 0 | { |
741 | | /* There are: |
742 | | * - command ring |
743 | | * - event ring |
744 | | * - tx and rx ring per each port |
745 | | */ |
746 | 0 | return 2 + (2 * r->fp_ports); |
747 | 0 | } |
748 | | |
749 | | static bool rocker_addr_is_desc_reg(Rocker *r, hwaddr addr) |
750 | 0 | { |
751 | 0 | hwaddr start = ROCKER_DMA_DESC_BASE; |
752 | 0 | hwaddr end = start + (ROCKER_DMA_DESC_SIZE * rocker_pci_ring_count(r)); |
753 | |
|
754 | 0 | return addr >= start && addr < end; |
755 | 0 | } |
756 | | |
757 | | static void rocker_port_phys_enable_write(Rocker *r, uint64_t new) |
758 | 0 | { |
759 | 0 | int i; |
760 | 0 | bool old_enabled; |
761 | 0 | bool new_enabled; |
762 | 0 | FpPort *fp_port; |
763 | |
|
764 | 0 | for (i = 0; i < r->fp_ports; i++) { |
765 | 0 | fp_port = r->fp_port[i]; |
766 | 0 | old_enabled = fp_port_enabled(fp_port); |
767 | 0 | new_enabled = (new >> (i + 1)) & 0x1; |
768 | 0 | if (new_enabled == old_enabled) { |
769 | 0 | continue; |
770 | 0 | } |
771 | 0 | if (new_enabled) { |
772 | 0 | fp_port_enable(r->fp_port[i]); |
773 | 0 | } else { |
774 | 0 | fp_port_disable(r->fp_port[i]); |
775 | 0 | } |
776 | 0 | } |
777 | 0 | } |
778 | | |
779 | | static void rocker_io_writel(void *opaque, hwaddr addr, uint32_t val) |
780 | 0 | { |
781 | 0 | Rocker *r = opaque; |
782 | |
|
783 | 0 | if (rocker_addr_is_desc_reg(r, addr)) { |
784 | 0 | unsigned index = ROCKER_RING_INDEX(addr); |
785 | 0 | unsigned offset = addr & ROCKER_DMA_DESC_MASK; |
786 | |
|
787 | 0 | switch (offset) { |
788 | 0 | case ROCKER_DMA_DESC_ADDR_OFFSET: |
789 | 0 | r->lower32 = (uint64_t)val; |
790 | 0 | break; |
791 | 0 | case ROCKER_DMA_DESC_ADDR_OFFSET + 4: |
792 | 0 | desc_ring_set_base_addr(r->rings[index], |
793 | 0 | ((uint64_t)val) << 32 | r->lower32); |
794 | 0 | r->lower32 = 0; |
795 | 0 | break; |
796 | 0 | case ROCKER_DMA_DESC_SIZE_OFFSET: |
797 | 0 | desc_ring_set_size(r->rings[index], val); |
798 | 0 | break; |
799 | 0 | case ROCKER_DMA_DESC_HEAD_OFFSET: |
800 | 0 | if (desc_ring_set_head(r->rings[index], val)) { |
801 | 0 | rocker_msix_irq(r, desc_ring_get_msix_vector(r->rings[index])); |
802 | 0 | } |
803 | 0 | break; |
804 | 0 | case ROCKER_DMA_DESC_CTRL_OFFSET: |
805 | 0 | desc_ring_set_ctrl(r->rings[index], val); |
806 | 0 | break; |
807 | 0 | case ROCKER_DMA_DESC_CREDITS_OFFSET: |
808 | 0 | if (desc_ring_ret_credits(r->rings[index], val)) { |
809 | 0 | rocker_msix_irq(r, desc_ring_get_msix_vector(r->rings[index])); |
810 | 0 | } |
811 | 0 | break; |
812 | 0 | default: |
813 | 0 | DPRINTF("not implemented dma reg write(l) addr=0x" HWADDR_FMT_plx |
814 | 0 | " val=0x%08x (ring %d, addr=0x%02x)\n", |
815 | 0 | addr, val, index, offset); |
816 | 0 | break; |
817 | 0 | } |
818 | 0 | return; |
819 | 0 | } |
820 | | |
821 | 0 | switch (addr) { |
822 | 0 | case ROCKER_TEST_REG: |
823 | 0 | r->test_reg = val; |
824 | 0 | break; |
825 | 0 | case ROCKER_TEST_REG64: |
826 | 0 | case ROCKER_TEST_DMA_ADDR: |
827 | 0 | case ROCKER_PORT_PHYS_ENABLE: |
828 | 0 | r->lower32 = (uint64_t)val; |
829 | 0 | break; |
830 | 0 | case ROCKER_TEST_REG64 + 4: |
831 | 0 | r->test_reg64 = ((uint64_t)val) << 32 | r->lower32; |
832 | 0 | r->lower32 = 0; |
833 | 0 | break; |
834 | 0 | case ROCKER_TEST_IRQ: |
835 | 0 | rocker_msix_irq(r, val); |
836 | 0 | break; |
837 | 0 | case ROCKER_TEST_DMA_SIZE: |
838 | 0 | r->test_dma_size = val & 0xFFFF; |
839 | 0 | break; |
840 | 0 | case ROCKER_TEST_DMA_ADDR + 4: |
841 | 0 | r->test_dma_addr = ((uint64_t)val) << 32 | r->lower32; |
842 | 0 | r->lower32 = 0; |
843 | 0 | break; |
844 | 0 | case ROCKER_TEST_DMA_CTRL: |
845 | 0 | rocker_test_dma_ctrl(r, val); |
846 | 0 | break; |
847 | 0 | case ROCKER_CONTROL: |
848 | 0 | rocker_control(r, val); |
849 | 0 | break; |
850 | 0 | case ROCKER_PORT_PHYS_ENABLE + 4: |
851 | 0 | rocker_port_phys_enable_write(r, ((uint64_t)val) << 32 | r->lower32); |
852 | 0 | r->lower32 = 0; |
853 | 0 | break; |
854 | 0 | default: |
855 | 0 | DPRINTF("not implemented write(l) addr=0x" HWADDR_FMT_plx |
856 | 0 | " val=0x%08x\n", addr, val); |
857 | 0 | break; |
858 | 0 | } |
859 | 0 | } |
860 | | |
861 | | static void rocker_io_writeq(void *opaque, hwaddr addr, uint64_t val) |
862 | 0 | { |
863 | 0 | Rocker *r = opaque; |
864 | |
|
865 | 0 | if (rocker_addr_is_desc_reg(r, addr)) { |
866 | 0 | unsigned index = ROCKER_RING_INDEX(addr); |
867 | 0 | unsigned offset = addr & ROCKER_DMA_DESC_MASK; |
868 | |
|
869 | 0 | switch (offset) { |
870 | 0 | case ROCKER_DMA_DESC_ADDR_OFFSET: |
871 | 0 | desc_ring_set_base_addr(r->rings[index], val); |
872 | 0 | break; |
873 | 0 | default: |
874 | 0 | DPRINTF("not implemented dma reg write(q) addr=0x" HWADDR_FMT_plx |
875 | 0 | " val=0x" HWADDR_FMT_plx " (ring %d, offset=0x%02x)\n", |
876 | 0 | addr, val, index, offset); |
877 | 0 | break; |
878 | 0 | } |
879 | 0 | return; |
880 | 0 | } |
881 | | |
882 | 0 | switch (addr) { |
883 | 0 | case ROCKER_TEST_REG64: |
884 | 0 | r->test_reg64 = val; |
885 | 0 | break; |
886 | 0 | case ROCKER_TEST_DMA_ADDR: |
887 | 0 | r->test_dma_addr = val; |
888 | 0 | break; |
889 | 0 | case ROCKER_PORT_PHYS_ENABLE: |
890 | 0 | rocker_port_phys_enable_write(r, val); |
891 | 0 | break; |
892 | 0 | default: |
893 | 0 | DPRINTF("not implemented write(q) addr=0x" HWADDR_FMT_plx |
894 | 0 | " val=0x" HWADDR_FMT_plx "\n", addr, val); |
895 | 0 | break; |
896 | 0 | } |
897 | 0 | } |
898 | | |
899 | | #ifdef DEBUG_ROCKER |
900 | | #define regname(reg) case (reg): return #reg |
901 | | static const char *rocker_reg_name(void *opaque, hwaddr addr) |
902 | | { |
903 | | Rocker *r = opaque; |
904 | | |
905 | | if (rocker_addr_is_desc_reg(r, addr)) { |
906 | | unsigned index = ROCKER_RING_INDEX(addr); |
907 | | unsigned offset = addr & ROCKER_DMA_DESC_MASK; |
908 | | static char buf[100]; |
909 | | char ring_name[10]; |
910 | | |
911 | | switch (index) { |
912 | | case 0: |
913 | | sprintf(ring_name, "cmd"); |
914 | | break; |
915 | | case 1: |
916 | | sprintf(ring_name, "event"); |
917 | | break; |
918 | | default: |
919 | | sprintf(ring_name, "%s-%d", index % 2 ? "rx" : "tx", |
920 | | (index - 2) / 2); |
921 | | } |
922 | | |
923 | | switch (offset) { |
924 | | case ROCKER_DMA_DESC_ADDR_OFFSET: |
925 | | sprintf(buf, "Ring[%s] ADDR", ring_name); |
926 | | return buf; |
927 | | case ROCKER_DMA_DESC_ADDR_OFFSET+4: |
928 | | sprintf(buf, "Ring[%s] ADDR+4", ring_name); |
929 | | return buf; |
930 | | case ROCKER_DMA_DESC_SIZE_OFFSET: |
931 | | sprintf(buf, "Ring[%s] SIZE", ring_name); |
932 | | return buf; |
933 | | case ROCKER_DMA_DESC_HEAD_OFFSET: |
934 | | sprintf(buf, "Ring[%s] HEAD", ring_name); |
935 | | return buf; |
936 | | case ROCKER_DMA_DESC_TAIL_OFFSET: |
937 | | sprintf(buf, "Ring[%s] TAIL", ring_name); |
938 | | return buf; |
939 | | case ROCKER_DMA_DESC_CTRL_OFFSET: |
940 | | sprintf(buf, "Ring[%s] CTRL", ring_name); |
941 | | return buf; |
942 | | case ROCKER_DMA_DESC_CREDITS_OFFSET: |
943 | | sprintf(buf, "Ring[%s] CREDITS", ring_name); |
944 | | return buf; |
945 | | default: |
946 | | sprintf(buf, "Ring[%s] ???", ring_name); |
947 | | return buf; |
948 | | } |
949 | | } else { |
950 | | switch (addr) { |
951 | | regname(ROCKER_BOGUS_REG0); |
952 | | regname(ROCKER_BOGUS_REG1); |
953 | | regname(ROCKER_BOGUS_REG2); |
954 | | regname(ROCKER_BOGUS_REG3); |
955 | | regname(ROCKER_TEST_REG); |
956 | | regname(ROCKER_TEST_REG64); |
957 | | regname(ROCKER_TEST_REG64+4); |
958 | | regname(ROCKER_TEST_IRQ); |
959 | | regname(ROCKER_TEST_DMA_ADDR); |
960 | | regname(ROCKER_TEST_DMA_ADDR+4); |
961 | | regname(ROCKER_TEST_DMA_SIZE); |
962 | | regname(ROCKER_TEST_DMA_CTRL); |
963 | | regname(ROCKER_CONTROL); |
964 | | regname(ROCKER_PORT_PHYS_COUNT); |
965 | | regname(ROCKER_PORT_PHYS_LINK_STATUS); |
966 | | regname(ROCKER_PORT_PHYS_LINK_STATUS+4); |
967 | | regname(ROCKER_PORT_PHYS_ENABLE); |
968 | | regname(ROCKER_PORT_PHYS_ENABLE+4); |
969 | | regname(ROCKER_SWITCH_ID); |
970 | | regname(ROCKER_SWITCH_ID+4); |
971 | | } |
972 | | } |
973 | | return "???"; |
974 | | } |
975 | | #else |
976 | | static const char *rocker_reg_name(void *opaque, hwaddr addr) |
977 | 0 | { |
978 | 0 | return NULL; |
979 | 0 | } |
980 | | #endif |
981 | | |
982 | | static void rocker_mmio_write(void *opaque, hwaddr addr, uint64_t val, |
983 | | unsigned size) |
984 | 0 | { |
985 | 0 | DPRINTF("Write %s addr " HWADDR_FMT_plx |
986 | 0 | ", size %u, val " HWADDR_FMT_plx "\n", |
987 | 0 | rocker_reg_name(opaque, addr), addr, size, val); |
988 | |
|
989 | 0 | switch (size) { |
990 | 0 | case 4: |
991 | 0 | rocker_io_writel(opaque, addr, val); |
992 | 0 | break; |
993 | 0 | case 8: |
994 | 0 | rocker_io_writeq(opaque, addr, val); |
995 | 0 | break; |
996 | 0 | } |
997 | 0 | } |
998 | | |
999 | | static uint64_t rocker_port_phys_link_status(Rocker *r) |
1000 | 0 | { |
1001 | 0 | int i; |
1002 | 0 | uint64_t status = 0; |
1003 | |
|
1004 | 0 | for (i = 0; i < r->fp_ports; i++) { |
1005 | 0 | FpPort *port = r->fp_port[i]; |
1006 | |
|
1007 | 0 | if (fp_port_get_link_up(port)) { |
1008 | 0 | status |= 1ULL << (i + 1); |
1009 | 0 | } |
1010 | 0 | } |
1011 | 0 | return status; |
1012 | 0 | } |
1013 | | |
1014 | | static uint64_t rocker_port_phys_enable_read(Rocker *r) |
1015 | 0 | { |
1016 | 0 | int i; |
1017 | 0 | uint64_t ret = 0; |
1018 | |
|
1019 | 0 | for (i = 0; i < r->fp_ports; i++) { |
1020 | 0 | FpPort *port = r->fp_port[i]; |
1021 | |
|
1022 | 0 | if (fp_port_enabled(port)) { |
1023 | 0 | ret |= 1ULL << (i + 1); |
1024 | 0 | } |
1025 | 0 | } |
1026 | 0 | return ret; |
1027 | 0 | } |
1028 | | |
1029 | | static uint32_t rocker_io_readl(void *opaque, hwaddr addr) |
1030 | 0 | { |
1031 | 0 | Rocker *r = opaque; |
1032 | 0 | uint32_t ret; |
1033 | |
|
1034 | 0 | if (rocker_addr_is_desc_reg(r, addr)) { |
1035 | 0 | unsigned index = ROCKER_RING_INDEX(addr); |
1036 | 0 | unsigned offset = addr & ROCKER_DMA_DESC_MASK; |
1037 | |
|
1038 | 0 | switch (offset) { |
1039 | 0 | case ROCKER_DMA_DESC_ADDR_OFFSET: |
1040 | 0 | ret = (uint32_t)desc_ring_get_base_addr(r->rings[index]); |
1041 | 0 | break; |
1042 | 0 | case ROCKER_DMA_DESC_ADDR_OFFSET + 4: |
1043 | 0 | ret = (uint32_t)(desc_ring_get_base_addr(r->rings[index]) >> 32); |
1044 | 0 | break; |
1045 | 0 | case ROCKER_DMA_DESC_SIZE_OFFSET: |
1046 | 0 | ret = desc_ring_get_size(r->rings[index]); |
1047 | 0 | break; |
1048 | 0 | case ROCKER_DMA_DESC_HEAD_OFFSET: |
1049 | 0 | ret = desc_ring_get_head(r->rings[index]); |
1050 | 0 | break; |
1051 | 0 | case ROCKER_DMA_DESC_TAIL_OFFSET: |
1052 | 0 | ret = desc_ring_get_tail(r->rings[index]); |
1053 | 0 | break; |
1054 | 0 | case ROCKER_DMA_DESC_CREDITS_OFFSET: |
1055 | 0 | ret = desc_ring_get_credits(r->rings[index]); |
1056 | 0 | break; |
1057 | 0 | default: |
1058 | 0 | DPRINTF("not implemented dma reg read(l) addr=0x" HWADDR_FMT_plx |
1059 | 0 | " (ring %d, addr=0x%02x)\n", addr, index, offset); |
1060 | 0 | ret = 0; |
1061 | 0 | break; |
1062 | 0 | } |
1063 | 0 | return ret; |
1064 | 0 | } |
1065 | | |
1066 | 0 | switch (addr) { |
1067 | 0 | case ROCKER_BOGUS_REG0: |
1068 | 0 | case ROCKER_BOGUS_REG1: |
1069 | 0 | case ROCKER_BOGUS_REG2: |
1070 | 0 | case ROCKER_BOGUS_REG3: |
1071 | 0 | ret = 0xDEADBABE; |
1072 | 0 | break; |
1073 | 0 | case ROCKER_TEST_REG: |
1074 | 0 | ret = r->test_reg * 2; |
1075 | 0 | break; |
1076 | 0 | case ROCKER_TEST_REG64: |
1077 | 0 | ret = (uint32_t)(r->test_reg64 * 2); |
1078 | 0 | break; |
1079 | 0 | case ROCKER_TEST_REG64 + 4: |
1080 | 0 | ret = (uint32_t)((r->test_reg64 * 2) >> 32); |
1081 | 0 | break; |
1082 | 0 | case ROCKER_TEST_DMA_SIZE: |
1083 | 0 | ret = r->test_dma_size; |
1084 | 0 | break; |
1085 | 0 | case ROCKER_TEST_DMA_ADDR: |
1086 | 0 | ret = (uint32_t)r->test_dma_addr; |
1087 | 0 | break; |
1088 | 0 | case ROCKER_TEST_DMA_ADDR + 4: |
1089 | 0 | ret = (uint32_t)(r->test_dma_addr >> 32); |
1090 | 0 | break; |
1091 | 0 | case ROCKER_PORT_PHYS_COUNT: |
1092 | 0 | ret = r->fp_ports; |
1093 | 0 | break; |
1094 | 0 | case ROCKER_PORT_PHYS_LINK_STATUS: |
1095 | 0 | ret = (uint32_t)rocker_port_phys_link_status(r); |
1096 | 0 | break; |
1097 | 0 | case ROCKER_PORT_PHYS_LINK_STATUS + 4: |
1098 | 0 | ret = (uint32_t)(rocker_port_phys_link_status(r) >> 32); |
1099 | 0 | break; |
1100 | 0 | case ROCKER_PORT_PHYS_ENABLE: |
1101 | 0 | ret = (uint32_t)rocker_port_phys_enable_read(r); |
1102 | 0 | break; |
1103 | 0 | case ROCKER_PORT_PHYS_ENABLE + 4: |
1104 | 0 | ret = (uint32_t)(rocker_port_phys_enable_read(r) >> 32); |
1105 | 0 | break; |
1106 | 0 | case ROCKER_SWITCH_ID: |
1107 | 0 | ret = (uint32_t)r->switch_id; |
1108 | 0 | break; |
1109 | 0 | case ROCKER_SWITCH_ID + 4: |
1110 | 0 | ret = (uint32_t)(r->switch_id >> 32); |
1111 | 0 | break; |
1112 | 0 | default: |
1113 | 0 | DPRINTF("not implemented read(l) addr=0x" HWADDR_FMT_plx "\n", addr); |
1114 | 0 | ret = 0; |
1115 | 0 | break; |
1116 | 0 | } |
1117 | 0 | return ret; |
1118 | 0 | } |
1119 | | |
1120 | | static uint64_t rocker_io_readq(void *opaque, hwaddr addr) |
1121 | 0 | { |
1122 | 0 | Rocker *r = opaque; |
1123 | 0 | uint64_t ret; |
1124 | |
|
1125 | 0 | if (rocker_addr_is_desc_reg(r, addr)) { |
1126 | 0 | unsigned index = ROCKER_RING_INDEX(addr); |
1127 | 0 | unsigned offset = addr & ROCKER_DMA_DESC_MASK; |
1128 | |
|
1129 | 0 | switch (addr & ROCKER_DMA_DESC_MASK) { |
1130 | 0 | case ROCKER_DMA_DESC_ADDR_OFFSET: |
1131 | 0 | ret = desc_ring_get_base_addr(r->rings[index]); |
1132 | 0 | break; |
1133 | 0 | default: |
1134 | 0 | DPRINTF("not implemented dma reg read(q) addr=0x" HWADDR_FMT_plx |
1135 | 0 | " (ring %d, addr=0x%02x)\n", addr, index, offset); |
1136 | 0 | ret = 0; |
1137 | 0 | break; |
1138 | 0 | } |
1139 | 0 | return ret; |
1140 | 0 | } |
1141 | | |
1142 | 0 | switch (addr) { |
1143 | 0 | case ROCKER_BOGUS_REG0: |
1144 | 0 | case ROCKER_BOGUS_REG2: |
1145 | 0 | ret = 0xDEADBABEDEADBABEULL; |
1146 | 0 | break; |
1147 | 0 | case ROCKER_TEST_REG64: |
1148 | 0 | ret = r->test_reg64 * 2; |
1149 | 0 | break; |
1150 | 0 | case ROCKER_TEST_DMA_ADDR: |
1151 | 0 | ret = r->test_dma_addr; |
1152 | 0 | break; |
1153 | 0 | case ROCKER_PORT_PHYS_LINK_STATUS: |
1154 | 0 | ret = rocker_port_phys_link_status(r); |
1155 | 0 | break; |
1156 | 0 | case ROCKER_PORT_PHYS_ENABLE: |
1157 | 0 | ret = rocker_port_phys_enable_read(r); |
1158 | 0 | break; |
1159 | 0 | case ROCKER_SWITCH_ID: |
1160 | 0 | ret = r->switch_id; |
1161 | 0 | break; |
1162 | 0 | default: |
1163 | 0 | DPRINTF("not implemented read(q) addr=0x" HWADDR_FMT_plx "\n", addr); |
1164 | 0 | ret = 0; |
1165 | 0 | break; |
1166 | 0 | } |
1167 | 0 | return ret; |
1168 | 0 | } |
1169 | | |
1170 | | static uint64_t rocker_mmio_read(void *opaque, hwaddr addr, unsigned size) |
1171 | 0 | { |
1172 | 0 | DPRINTF("Read %s addr " HWADDR_FMT_plx ", size %u\n", |
1173 | 0 | rocker_reg_name(opaque, addr), addr, size); |
1174 | |
|
1175 | 0 | switch (size) { |
1176 | 0 | case 4: |
1177 | 0 | return rocker_io_readl(opaque, addr); |
1178 | 0 | case 8: |
1179 | 0 | return rocker_io_readq(opaque, addr); |
1180 | 0 | } |
1181 | | |
1182 | 0 | return -1; |
1183 | 0 | } |
1184 | | |
1185 | | static const MemoryRegionOps rocker_mmio_ops = { |
1186 | | .read = rocker_mmio_read, |
1187 | | .write = rocker_mmio_write, |
1188 | | .endianness = DEVICE_LITTLE_ENDIAN, |
1189 | | .valid = { |
1190 | | .min_access_size = 4, |
1191 | | .max_access_size = 8, |
1192 | | }, |
1193 | | .impl = { |
1194 | | .min_access_size = 4, |
1195 | | .max_access_size = 8, |
1196 | | }, |
1197 | | }; |
1198 | | |
1199 | | static void rocker_msix_vectors_unuse(Rocker *r, |
1200 | | unsigned int num_vectors) |
1201 | 0 | { |
1202 | 0 | PCIDevice *dev = PCI_DEVICE(r); |
1203 | 0 | int i; |
1204 | |
|
1205 | 0 | for (i = 0; i < num_vectors; i++) { |
1206 | 0 | msix_vector_unuse(dev, i); |
1207 | 0 | } |
1208 | 0 | } |
1209 | | |
1210 | | static void rocker_msix_vectors_use(Rocker *r, unsigned int num_vectors) |
1211 | 0 | { |
1212 | 0 | PCIDevice *dev = PCI_DEVICE(r); |
1213 | 0 | int i; |
1214 | |
|
1215 | 0 | for (i = 0; i < num_vectors; i++) { |
1216 | 0 | msix_vector_use(dev, i); |
1217 | 0 | } |
1218 | 0 | } |
1219 | | |
1220 | | static int rocker_msix_init(Rocker *r, Error **errp) |
1221 | 0 | { |
1222 | 0 | PCIDevice *dev = PCI_DEVICE(r); |
1223 | 0 | int err; |
1224 | |
|
1225 | 0 | err = msix_init(dev, ROCKER_MSIX_VEC_COUNT(r->fp_ports), |
1226 | 0 | &r->msix_bar, |
1227 | 0 | ROCKER_PCI_MSIX_BAR_IDX, ROCKER_PCI_MSIX_TABLE_OFFSET, |
1228 | 0 | &r->msix_bar, |
1229 | 0 | ROCKER_PCI_MSIX_BAR_IDX, ROCKER_PCI_MSIX_PBA_OFFSET, |
1230 | 0 | 0, errp); |
1231 | 0 | if (err < 0) { |
1232 | 0 | return err; |
1233 | 0 | } |
1234 | | |
1235 | 0 | rocker_msix_vectors_use(r, ROCKER_MSIX_VEC_COUNT(r->fp_ports)); |
1236 | |
|
1237 | 0 | return 0; |
1238 | 0 | } |
1239 | | |
1240 | | static void rocker_msix_uninit(Rocker *r) |
1241 | 0 | { |
1242 | 0 | PCIDevice *dev = PCI_DEVICE(r); |
1243 | |
|
1244 | 0 | msix_uninit(dev, &r->msix_bar, &r->msix_bar); |
1245 | 0 | rocker_msix_vectors_unuse(r, ROCKER_MSIX_VEC_COUNT(r->fp_ports)); |
1246 | 0 | } |
1247 | | |
1248 | | static World *rocker_world_type_by_name(Rocker *r, const char *name) |
1249 | 0 | { |
1250 | 0 | int i; |
1251 | |
|
1252 | 0 | for (i = 0; i < ROCKER_WORLD_TYPE_MAX; i++) { |
1253 | 0 | if (strcmp(name, world_name(r->worlds[i])) == 0) { |
1254 | 0 | return r->worlds[i]; |
1255 | 0 | } |
1256 | 0 | } |
1257 | 0 | return NULL; |
1258 | 0 | } |
1259 | | |
1260 | | static void pci_rocker_realize(PCIDevice *dev, Error **errp) |
1261 | 0 | { |
1262 | 0 | Rocker *r = ROCKER(dev); |
1263 | 0 | const MACAddr zero = { .a = { 0, 0, 0, 0, 0, 0 } }; |
1264 | 0 | const MACAddr dflt = { .a = { 0x52, 0x54, 0x00, 0x12, 0x35, 0x01 } }; |
1265 | 0 | static int sw_index; |
1266 | 0 | int i, err = 0; |
1267 | | |
1268 | | /* allocate worlds */ |
1269 | |
|
1270 | 0 | r->worlds[ROCKER_WORLD_TYPE_OF_DPA] = of_dpa_world_alloc(r); |
1271 | |
|
1272 | 0 | if (!r->world_name) { |
1273 | 0 | r->world_name = g_strdup(world_name(r->worlds[ROCKER_WORLD_TYPE_OF_DPA])); |
1274 | 0 | } |
1275 | |
|
1276 | 0 | r->world_dflt = rocker_world_type_by_name(r, r->world_name); |
1277 | 0 | if (!r->world_dflt) { |
1278 | 0 | error_setg(errp, |
1279 | 0 | "invalid argument requested world %s does not exist", |
1280 | 0 | r->world_name); |
1281 | 0 | goto err_world_type_by_name; |
1282 | 0 | } |
1283 | | |
1284 | | /* set up memory-mapped region at BAR0 */ |
1285 | | |
1286 | 0 | memory_region_init_io(&r->mmio, OBJECT(r), &rocker_mmio_ops, r, |
1287 | 0 | "rocker-mmio", ROCKER_PCI_BAR0_SIZE); |
1288 | 0 | pci_register_bar(dev, ROCKER_PCI_BAR0_IDX, |
1289 | 0 | PCI_BASE_ADDRESS_SPACE_MEMORY, &r->mmio); |
1290 | | |
1291 | | /* set up memory-mapped region for MSI-X */ |
1292 | |
|
1293 | 0 | memory_region_init(&r->msix_bar, OBJECT(r), "rocker-msix-bar", |
1294 | 0 | ROCKER_PCI_MSIX_BAR_SIZE); |
1295 | 0 | pci_register_bar(dev, ROCKER_PCI_MSIX_BAR_IDX, |
1296 | 0 | PCI_BASE_ADDRESS_SPACE_MEMORY, &r->msix_bar); |
1297 | | |
1298 | | /* MSI-X init */ |
1299 | |
|
1300 | 0 | err = rocker_msix_init(r, errp); |
1301 | 0 | if (err) { |
1302 | 0 | goto err_msix_init; |
1303 | 0 | } |
1304 | | |
1305 | | /* validate switch properties */ |
1306 | | |
1307 | 0 | if (!r->name) { |
1308 | 0 | r->name = g_strdup(TYPE_ROCKER); |
1309 | 0 | } |
1310 | |
|
1311 | 0 | if (rocker_find(r->name)) { |
1312 | 0 | error_setg(errp, "%s already exists", r->name); |
1313 | 0 | goto err_duplicate; |
1314 | 0 | } |
1315 | | |
1316 | | /* Rocker name is passed in port name requests to OS with the intention |
1317 | | * that the name is used in interface names. Limit the length of the |
1318 | | * rocker name to avoid naming problems in the OS. Also, adding the |
1319 | | * port number as p# and unganged breakout b#, where # is at most 2 |
1320 | | * digits, so leave room for it too (-1 for string terminator, -3 for |
1321 | | * p# and -3 for b#) |
1322 | | */ |
1323 | 0 | #define ROCKER_IFNAMSIZ 16 |
1324 | 0 | #define MAX_ROCKER_NAME_LEN (ROCKER_IFNAMSIZ - 1 - 3 - 3) |
1325 | 0 | if (strlen(r->name) > MAX_ROCKER_NAME_LEN) { |
1326 | 0 | error_setg(errp, |
1327 | 0 | "name too long; please shorten to at most %d chars", |
1328 | 0 | MAX_ROCKER_NAME_LEN); |
1329 | 0 | goto err_name_too_long; |
1330 | 0 | } |
1331 | | |
1332 | 0 | if (memcmp(&r->fp_start_macaddr, &zero, sizeof(zero)) == 0) { |
1333 | 0 | memcpy(&r->fp_start_macaddr, &dflt, sizeof(dflt)); |
1334 | 0 | r->fp_start_macaddr.a[4] += (sw_index++); |
1335 | 0 | } |
1336 | |
|
1337 | 0 | if (!r->switch_id) { |
1338 | 0 | memcpy(&r->switch_id, &r->fp_start_macaddr, |
1339 | 0 | sizeof(r->fp_start_macaddr)); |
1340 | 0 | } |
1341 | |
|
1342 | 0 | if (r->fp_ports > ROCKER_FP_PORTS_MAX) { |
1343 | 0 | r->fp_ports = ROCKER_FP_PORTS_MAX; |
1344 | 0 | } |
1345 | |
|
1346 | 0 | r->rings = g_new(DescRing *, rocker_pci_ring_count(r)); |
1347 | | |
1348 | | /* Rings are ordered like this: |
1349 | | * - command ring |
1350 | | * - event ring |
1351 | | * - port0 tx ring |
1352 | | * - port0 rx ring |
1353 | | * - port1 tx ring |
1354 | | * - port1 rx ring |
1355 | | * ..... |
1356 | | */ |
1357 | |
|
1358 | 0 | for (i = 0; i < rocker_pci_ring_count(r); i++) { |
1359 | 0 | DescRing *ring = desc_ring_alloc(r, i); |
1360 | |
|
1361 | 0 | if (i == ROCKER_RING_CMD) { |
1362 | 0 | desc_ring_set_consume(ring, cmd_consume, ROCKER_MSIX_VEC_CMD); |
1363 | 0 | } else if (i == ROCKER_RING_EVENT) { |
1364 | 0 | desc_ring_set_consume(ring, NULL, ROCKER_MSIX_VEC_EVENT); |
1365 | 0 | } else if (i % 2 == 0) { |
1366 | 0 | desc_ring_set_consume(ring, tx_consume, |
1367 | 0 | ROCKER_MSIX_VEC_TX((i - 2) / 2)); |
1368 | 0 | } else if (i % 2 == 1) { |
1369 | 0 | desc_ring_set_consume(ring, NULL, ROCKER_MSIX_VEC_RX((i - 3) / 2)); |
1370 | 0 | } |
1371 | |
|
1372 | 0 | r->rings[i] = ring; |
1373 | 0 | } |
1374 | |
|
1375 | 0 | for (i = 0; i < r->fp_ports; i++) { |
1376 | 0 | FpPort *port = |
1377 | 0 | fp_port_alloc(r, r->name, &r->fp_start_macaddr, |
1378 | 0 | i, &r->fp_ports_peers[i]); |
1379 | |
|
1380 | 0 | r->fp_port[i] = port; |
1381 | 0 | fp_port_set_world(port, r->world_dflt); |
1382 | 0 | } |
1383 | |
|
1384 | 0 | QLIST_INSERT_HEAD(&rockers, r, next); |
1385 | |
|
1386 | 0 | return; |
1387 | | |
1388 | 0 | err_name_too_long: |
1389 | 0 | err_duplicate: |
1390 | 0 | rocker_msix_uninit(r); |
1391 | 0 | err_msix_init: |
1392 | 0 | object_unparent(OBJECT(&r->msix_bar)); |
1393 | 0 | object_unparent(OBJECT(&r->mmio)); |
1394 | 0 | err_world_type_by_name: |
1395 | 0 | for (i = 0; i < ROCKER_WORLD_TYPE_MAX; i++) { |
1396 | 0 | if (r->worlds[i]) { |
1397 | 0 | world_free(r->worlds[i]); |
1398 | 0 | } |
1399 | 0 | } |
1400 | 0 | } |
1401 | | |
1402 | | static void pci_rocker_uninit(PCIDevice *dev) |
1403 | 0 | { |
1404 | 0 | Rocker *r = ROCKER(dev); |
1405 | 0 | int i; |
1406 | |
|
1407 | 0 | QLIST_REMOVE(r, next); |
1408 | |
|
1409 | 0 | for (i = 0; i < r->fp_ports; i++) { |
1410 | 0 | FpPort *port = r->fp_port[i]; |
1411 | |
|
1412 | 0 | fp_port_free(port); |
1413 | 0 | r->fp_port[i] = NULL; |
1414 | 0 | } |
1415 | |
|
1416 | 0 | for (i = 0; i < rocker_pci_ring_count(r); i++) { |
1417 | 0 | if (r->rings[i]) { |
1418 | 0 | desc_ring_free(r->rings[i]); |
1419 | 0 | } |
1420 | 0 | } |
1421 | 0 | g_free(r->rings); |
1422 | |
|
1423 | 0 | rocker_msix_uninit(r); |
1424 | 0 | object_unparent(OBJECT(&r->msix_bar)); |
1425 | 0 | object_unparent(OBJECT(&r->mmio)); |
1426 | |
|
1427 | 0 | for (i = 0; i < ROCKER_WORLD_TYPE_MAX; i++) { |
1428 | 0 | if (r->worlds[i]) { |
1429 | 0 | world_free(r->worlds[i]); |
1430 | 0 | } |
1431 | 0 | } |
1432 | 0 | } |
1433 | | |
1434 | | static void rocker_reset(DeviceState *dev) |
1435 | 0 | { |
1436 | 0 | Rocker *r = ROCKER(dev); |
1437 | 0 | int i; |
1438 | |
|
1439 | 0 | for (i = 0; i < ROCKER_WORLD_TYPE_MAX; i++) { |
1440 | 0 | if (r->worlds[i]) { |
1441 | 0 | world_reset(r->worlds[i]); |
1442 | 0 | } |
1443 | 0 | } |
1444 | 0 | for (i = 0; i < r->fp_ports; i++) { |
1445 | 0 | fp_port_reset(r->fp_port[i]); |
1446 | 0 | fp_port_set_world(r->fp_port[i], r->world_dflt); |
1447 | 0 | } |
1448 | |
|
1449 | 0 | r->test_reg = 0; |
1450 | 0 | r->test_reg64 = 0; |
1451 | 0 | r->test_dma_addr = 0; |
1452 | 0 | r->test_dma_size = 0; |
1453 | |
|
1454 | 0 | for (i = 0; i < rocker_pci_ring_count(r); i++) { |
1455 | 0 | desc_ring_reset(r->rings[i]); |
1456 | 0 | } |
1457 | |
|
1458 | 0 | DPRINTF("Reset done\n"); |
1459 | 0 | } |
1460 | | |
1461 | | static const Property rocker_properties[] = { |
1462 | | DEFINE_PROP_STRING("name", Rocker, name), |
1463 | | DEFINE_PROP_STRING("world", Rocker, world_name), |
1464 | | DEFINE_PROP_MACADDR("fp_start_macaddr", Rocker, |
1465 | | fp_start_macaddr), |
1466 | | DEFINE_PROP_UINT64("switch_id", Rocker, |
1467 | | switch_id, 0), |
1468 | | DEFINE_PROP_ARRAY("ports", Rocker, fp_ports, |
1469 | | fp_ports_peers, qdev_prop_netdev, NICPeers), |
1470 | | }; |
1471 | | |
1472 | | static const VMStateDescription rocker_vmsd = { |
1473 | | .name = TYPE_ROCKER, |
1474 | | .unmigratable = 1, |
1475 | | }; |
1476 | | |
1477 | | static void rocker_class_init(ObjectClass *klass, const void *data) |
1478 | 63 | { |
1479 | 63 | DeviceClass *dc = DEVICE_CLASS(klass); |
1480 | 63 | PCIDeviceClass *k = PCI_DEVICE_CLASS(klass); |
1481 | | |
1482 | 63 | k->realize = pci_rocker_realize; |
1483 | 63 | k->exit = pci_rocker_uninit; |
1484 | 63 | k->vendor_id = PCI_VENDOR_ID_REDHAT; |
1485 | 63 | k->device_id = PCI_DEVICE_ID_REDHAT_ROCKER; |
1486 | 63 | k->revision = ROCKER_PCI_REVISION; |
1487 | 63 | k->class_id = PCI_CLASS_NETWORK_OTHER; |
1488 | 63 | set_bit(DEVICE_CATEGORY_NETWORK, dc->categories); |
1489 | 63 | dc->desc = "Rocker Switch"; |
1490 | 63 | device_class_set_legacy_reset(dc, rocker_reset); |
1491 | 63 | device_class_set_props(dc, rocker_properties); |
1492 | 63 | dc->vmsd = &rocker_vmsd; |
1493 | 63 | } |
1494 | | |
1495 | | static const TypeInfo rocker_info = { |
1496 | | .name = TYPE_ROCKER, |
1497 | | .parent = TYPE_PCI_DEVICE, |
1498 | | .instance_size = sizeof(Rocker), |
1499 | | .class_init = rocker_class_init, |
1500 | | .interfaces = (const InterfaceInfo[]) { |
1501 | | { INTERFACE_CONVENTIONAL_PCI_DEVICE }, |
1502 | | { }, |
1503 | | }, |
1504 | | }; |
1505 | | |
1506 | | static void rocker_register_types(void) |
1507 | 63 | { |
1508 | 63 | type_register_static(&rocker_info); |
1509 | 63 | } |
1510 | | |
1511 | | type_init(rocker_register_types) |