hw/arm/raspi: fix CPRMAN base address
[qemu.git] / hw / net / rocker / rocker_fp.c
1 /*
2 * QEMU rocker switch emulation - front-panel ports
3 *
4 * Copyright (c) 2014 Scott Feldman <sfeldma@gmail.com>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 */
16
17 #include "qemu/osdep.h"
18 #include "qapi/qapi-types-rocker.h"
19 #include "rocker.h"
20 #include "rocker_hw.h"
21 #include "rocker_fp.h"
22 #include "rocker_world.h"
23
24 enum duplex {
25 DUPLEX_HALF = 0,
26 DUPLEX_FULL
27 };
28
29 struct fp_port {
30 Rocker *r;
31 World *world;
32 unsigned int index;
33 char *name;
34 uint32_t pport;
35 bool enabled;
36 uint32_t speed;
37 uint8_t duplex;
38 uint8_t autoneg;
39 uint8_t learning;
40 NICState *nic;
41 NICConf conf;
42 };
43
44 char *fp_port_get_name(FpPort *port)
45 {
46 return port->name;
47 }
48
49 bool fp_port_get_link_up(FpPort *port)
50 {
51 return !qemu_get_queue(port->nic)->link_down;
52 }
53
54 void fp_port_get_info(FpPort *port, RockerPortList *info)
55 {
56 info->value->name = g_strdup(port->name);
57 info->value->enabled = port->enabled;
58 info->value->link_up = fp_port_get_link_up(port);
59 info->value->speed = port->speed;
60 info->value->duplex = port->duplex;
61 info->value->autoneg = port->autoneg;
62 }
63
64 void fp_port_get_macaddr(FpPort *port, MACAddr *macaddr)
65 {
66 memcpy(macaddr->a, port->conf.macaddr.a, sizeof(macaddr->a));
67 }
68
69 void fp_port_set_macaddr(FpPort *port, MACAddr *macaddr)
70 {
71 /* XXX TODO implement and test setting mac addr
72 * XXX memcpy(port->conf.macaddr.a, macaddr.a, sizeof(port->conf.macaddr.a));
73 */
74 }
75
76 uint8_t fp_port_get_learning(FpPort *port)
77 {
78 return port->learning;
79 }
80
81 void fp_port_set_learning(FpPort *port, uint8_t learning)
82 {
83 port->learning = learning;
84 }
85
86 int fp_port_get_settings(FpPort *port, uint32_t *speed,
87 uint8_t *duplex, uint8_t *autoneg)
88 {
89 *speed = port->speed;
90 *duplex = port->duplex;
91 *autoneg = port->autoneg;
92
93 return ROCKER_OK;
94 }
95
96 int fp_port_set_settings(FpPort *port, uint32_t speed,
97 uint8_t duplex, uint8_t autoneg)
98 {
99 /* XXX validate inputs */
100
101 port->speed = speed;
102 port->duplex = duplex;
103 port->autoneg = autoneg;
104
105 return ROCKER_OK;
106 }
107
108 bool fp_port_from_pport(uint32_t pport, uint32_t *port)
109 {
110 if (pport < 1 || pport > ROCKER_FP_PORTS_MAX) {
111 return false;
112 }
113 *port = pport - 1;
114 return true;
115 }
116
117 int fp_port_eg(FpPort *port, const struct iovec *iov, int iovcnt)
118 {
119 NetClientState *nc = qemu_get_queue(port->nic);
120
121 if (port->enabled) {
122 qemu_sendv_packet(nc, iov, iovcnt);
123 }
124
125 return ROCKER_OK;
126 }
127
128 static ssize_t fp_port_receive_iov(NetClientState *nc, const struct iovec *iov,
129 int iovcnt)
130 {
131 FpPort *port = qemu_get_nic_opaque(nc);
132
133 /* If the port is disabled, we want to drop this pkt
134 * now rather than queing it for later. We don't want
135 * any stale pkts getting into the device when the port
136 * transitions to enabled.
137 */
138
139 if (!port->enabled) {
140 return -1;
141 }
142
143 return world_ingress(port->world, port->pport, iov, iovcnt);
144 }
145
146 static ssize_t fp_port_receive(NetClientState *nc, const uint8_t *buf,
147 size_t size)
148 {
149 const struct iovec iov = {
150 .iov_base = (uint8_t *)buf,
151 .iov_len = size
152 };
153
154 return fp_port_receive_iov(nc, &iov, 1);
155 }
156
157 static void fp_port_cleanup(NetClientState *nc)
158 {
159 }
160
161 static void fp_port_set_link_status(NetClientState *nc)
162 {
163 FpPort *port = qemu_get_nic_opaque(nc);
164
165 rocker_event_link_changed(port->r, port->pport, !nc->link_down);
166 }
167
168 static NetClientInfo fp_port_info = {
169 .type = NET_CLIENT_DRIVER_NIC,
170 .size = sizeof(NICState),
171 .receive = fp_port_receive,
172 .receive_iov = fp_port_receive_iov,
173 .cleanup = fp_port_cleanup,
174 .link_status_changed = fp_port_set_link_status,
175 };
176
177 World *fp_port_get_world(FpPort *port)
178 {
179 return port->world;
180 }
181
182 void fp_port_set_world(FpPort *port, World *world)
183 {
184 DPRINTF("port %d setting world \"%s\"\n", port->index, world_name(world));
185 port->world = world;
186 }
187
188 bool fp_port_check_world(FpPort *port, World *world)
189 {
190 return port->world == world;
191 }
192
193 bool fp_port_enabled(FpPort *port)
194 {
195 return port->enabled;
196 }
197
198 static void fp_port_set_link(FpPort *port, bool up)
199 {
200 NetClientState *nc = qemu_get_queue(port->nic);
201
202 if (up == nc->link_down) {
203 nc->link_down = !up;
204 nc->info->link_status_changed(nc);
205 }
206 }
207
208 void fp_port_enable(FpPort *port)
209 {
210 fp_port_set_link(port, true);
211 port->enabled = true;
212 DPRINTF("port %d enabled\n", port->index);
213 }
214
215 void fp_port_disable(FpPort *port)
216 {
217 port->enabled = false;
218 fp_port_set_link(port, false);
219 DPRINTF("port %d disabled\n", port->index);
220 }
221
222 FpPort *fp_port_alloc(Rocker *r, char *sw_name,
223 MACAddr *start_mac, unsigned int index,
224 NICPeers *peers)
225 {
226 FpPort *port = g_new0(FpPort, 1);
227
228 port->r = r;
229 port->index = index;
230 port->pport = index + 1;
231
232 /* front-panel switch port names are 1-based */
233
234 port->name = g_strdup_printf("%sp%d", sw_name, port->pport);
235
236 memcpy(port->conf.macaddr.a, start_mac, sizeof(port->conf.macaddr.a));
237 port->conf.macaddr.a[5] += index;
238 port->conf.bootindex = -1;
239 port->conf.peers = *peers;
240
241 port->nic = qemu_new_nic(&fp_port_info, &port->conf,
242 sw_name, NULL, port);
243 qemu_format_nic_info_str(qemu_get_queue(port->nic),
244 port->conf.macaddr.a);
245
246 fp_port_reset(port);
247
248 return port;
249 }
250
251 void fp_port_free(FpPort *port)
252 {
253 qemu_del_nic(port->nic);
254 g_free(port->name);
255 g_free(port);
256 }
257
258 void fp_port_reset(FpPort *port)
259 {
260 fp_port_disable(port);
261 port->speed = 10000; /* 10Gbps */
262 port->duplex = DUPLEX_FULL;
263 port->autoneg = 0;
264 }