Merge branch 'vendor/LDNS'
[dragonfly.git] / contrib / hostapd / src / drivers / driver_roboswitch.c
1 /*
2  * WPA Supplicant - roboswitch driver interface
3  * Copyright (c) 2008-2009 Jouke Witteveen
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License version 2 as
7  * published by the Free Software Foundation.
8  *
9  * Alternatively, this software may be distributed under the terms of BSD
10  * license.
11  *
12  * See README and COPYING for more details.
13  */
14
15 #include "includes.h"
16 #include <sys/ioctl.h>
17 #include <linux/if.h>
18 #include <linux/sockios.h>
19 #include <linux/if_ether.h>
20 #include <linux/mii.h>
21
22 #include "common.h"
23 #include "driver.h"
24 #include "l2_packet/l2_packet.h"
25
26 #ifndef ETH_P_EAPOL
27 #define ETH_P_EAPOL             0x888e
28 #endif
29
30 #define ROBO_PHY_ADDR           0x1e    /* RoboSwitch PHY address */
31
32 /* MII access registers */
33 #define ROBO_MII_PAGE           0x10    /* MII page register */
34 #define ROBO_MII_ADDR           0x11    /* MII address register */
35 #define ROBO_MII_DATA_OFFSET    0x18    /* Start of MII data registers */
36
37 #define ROBO_MII_PAGE_ENABLE    0x01    /* MII page op code */
38 #define ROBO_MII_ADDR_WRITE     0x01    /* MII address write op code */
39 #define ROBO_MII_ADDR_READ      0x02    /* MII address read op code */
40 #define ROBO_MII_DATA_MAX          4    /* Consecutive MII data registers */
41 #define ROBO_MII_RETRY_MAX        10    /* Read attempts before giving up */
42
43 /* Page numbers */
44 #define ROBO_ARLCTRL_PAGE       0x04    /* ARL control page */
45 #define ROBO_VLAN_PAGE          0x34    /* VLAN page */
46
47 /* ARL control page registers */
48 #define ROBO_ARLCTRL_CONF       0x00    /* ARL configuration register */
49 #define ROBO_ARLCTRL_ADDR_1     0x10    /* Multiport address 1 */
50 #define ROBO_ARLCTRL_VEC_1      0x16    /* Multiport vector 1 */
51 #define ROBO_ARLCTRL_ADDR_2     0x20    /* Multiport address 2 */
52 #define ROBO_ARLCTRL_VEC_2      0x26    /* Multiport vector 2 */
53
54 /* VLAN page registers */
55 #define ROBO_VLAN_ACCESS        0x08    /* VLAN table access register */
56 #define ROBO_VLAN_ACCESS_5350   0x06    /* VLAN table access register (5350) */
57 #define ROBO_VLAN_READ          0x0c    /* VLAN read register */
58 #define ROBO_VLAN_MAX           0xff    /* Maximum number of VLANs */
59
60
61 static const u8 pae_group_addr[ETH_ALEN] =
62 { 0x01, 0x80, 0xc2, 0x00, 0x00, 0x03 };
63
64
65 struct wpa_driver_roboswitch_data {
66         void *ctx;
67         struct l2_packet_data *l2;
68         char ifname[IFNAMSIZ + 1];
69         u8 own_addr[ETH_ALEN];
70         struct ifreq ifr;
71         int fd, is_5350;
72         u16 ports;
73 };
74
75
76 /* Copied from the kernel-only part of mii.h. */
77 static inline struct mii_ioctl_data *if_mii(struct ifreq *rq)
78 {
79         return (struct mii_ioctl_data *) &rq->ifr_ifru;
80 }
81
82
83 /*
84  * RoboSwitch uses 16-bit Big Endian addresses.
85  * The ordering of the words is reversed in the MII registers.
86  */
87 static void wpa_driver_roboswitch_addr_be16(const u8 addr[ETH_ALEN], u16 *be)
88 {
89         int i;
90         for (i = 0; i < ETH_ALEN; i += 2)
91                 be[(ETH_ALEN - i) / 2 - 1] = WPA_GET_BE16(addr + i);
92 }
93
94
95 static u16 wpa_driver_roboswitch_mdio_read(
96         struct wpa_driver_roboswitch_data *drv, u8 reg)
97 {
98         struct mii_ioctl_data *mii = if_mii(&drv->ifr);
99
100         mii->phy_id = ROBO_PHY_ADDR;
101         mii->reg_num = reg;
102
103         if (ioctl(drv->fd, SIOCGMIIREG, &drv->ifr) < 0) {
104                 perror("ioctl[SIOCGMIIREG]");
105                 return 0x00;
106         }
107         return mii->val_out;
108 }
109
110
111 static void wpa_driver_roboswitch_mdio_write(
112         struct wpa_driver_roboswitch_data *drv, u8 reg, u16 val)
113 {
114         struct mii_ioctl_data *mii = if_mii(&drv->ifr);
115
116         mii->phy_id = ROBO_PHY_ADDR;
117         mii->reg_num = reg;
118         mii->val_in = val;
119
120         if (ioctl(drv->fd, SIOCSMIIREG, &drv->ifr) < 0) {
121                 perror("ioctl[SIOCSMIIREG");
122         }
123 }
124
125
126 static int wpa_driver_roboswitch_reg(struct wpa_driver_roboswitch_data *drv,
127                                      u8 page, u8 reg, u8 op)
128 {
129         int i;
130
131         /* set page number */
132         wpa_driver_roboswitch_mdio_write(drv, ROBO_MII_PAGE,
133                                          (page << 8) | ROBO_MII_PAGE_ENABLE);
134         /* set register address */
135         wpa_driver_roboswitch_mdio_write(drv, ROBO_MII_ADDR, (reg << 8) | op);
136
137         /* check if operation completed */
138         for (i = 0; i < ROBO_MII_RETRY_MAX; ++i) {
139                 if ((wpa_driver_roboswitch_mdio_read(drv, ROBO_MII_ADDR) & 3)
140                     == 0)
141                         return 0;
142         }
143         /* timeout */
144         return -1;
145 }
146
147
148 static int wpa_driver_roboswitch_read(struct wpa_driver_roboswitch_data *drv,
149                                       u8 page, u8 reg, u16 *val, int len)
150 {
151         int i;
152
153         if (len > ROBO_MII_DATA_MAX ||
154             wpa_driver_roboswitch_reg(drv, page, reg, ROBO_MII_ADDR_READ) < 0)
155                 return -1;
156
157         for (i = 0; i < len; ++i) {
158                 val[i] = wpa_driver_roboswitch_mdio_read(
159                         drv, ROBO_MII_DATA_OFFSET + i);
160         }
161
162         return 0;
163 }
164
165
166 static int wpa_driver_roboswitch_write(struct wpa_driver_roboswitch_data *drv,
167                                        u8 page, u8 reg, u16 *val, int len)
168 {
169         int i;
170
171         if (len > ROBO_MII_DATA_MAX) return -1;
172         for (i = 0; i < len; ++i) {
173                 wpa_driver_roboswitch_mdio_write(drv, ROBO_MII_DATA_OFFSET + i,
174                                                  val[i]);
175         }
176         return wpa_driver_roboswitch_reg(drv, page, reg, ROBO_MII_ADDR_WRITE);
177 }
178
179
180 static void wpa_driver_roboswitch_receive(void *priv, const u8 *src_addr,
181                                           const u8 *buf, size_t len)
182 {
183         struct wpa_driver_roboswitch_data *drv = priv;
184
185         if (len > 14 && WPA_GET_BE16(buf + 12) == ETH_P_EAPOL &&
186             os_memcmp(buf, drv->own_addr, ETH_ALEN) == 0) {
187                 wpa_supplicant_rx_eapol(drv->ctx, src_addr, buf + 14,
188                                         len - 14);
189         }
190 }
191
192
193 static int wpa_driver_roboswitch_get_ssid(void *priv, u8 *ssid)
194 {
195         ssid[0] = 0;
196         return 0;
197 }
198
199
200 static int wpa_driver_roboswitch_get_bssid(void *priv, u8 *bssid)
201 {
202         /* Report PAE group address as the "BSSID" for wired connection. */
203         os_memcpy(bssid, pae_group_addr, ETH_ALEN);
204         return 0;
205 }
206
207
208 static int wpa_driver_roboswitch_set_param(void *priv, const char *param)
209 {
210         struct wpa_driver_roboswitch_data *drv = priv;
211         char *sep;
212
213         if (param == NULL || os_strstr(param, "multicast_only=1") == NULL) {
214                 sep = drv->ifname + os_strlen(drv->ifname);
215                 *sep = '.';
216                 drv->l2 = l2_packet_init(drv->ifname, NULL, ETH_P_ALL,
217                                          wpa_driver_roboswitch_receive, drv,
218                                          1);
219                 if (drv->l2 == NULL) {
220                         wpa_printf(MSG_INFO, "%s: Unable to listen on %s",
221                                    __func__, drv->ifname);
222                         return -1;
223                 }
224                 *sep = '\0';
225                 l2_packet_get_own_addr(drv->l2, drv->own_addr);
226         } else {
227                 wpa_printf(MSG_DEBUG, "%s: Ignoring unicast frames", __func__);
228                 drv->l2 = NULL;
229         }
230         return 0;
231 }
232
233
234 static const char * wpa_driver_roboswitch_get_ifname(void *priv)
235 {
236         struct wpa_driver_roboswitch_data *drv = priv;
237         return drv->ifname;
238 }
239
240
241 static int wpa_driver_roboswitch_join(struct wpa_driver_roboswitch_data *drv,
242                                       u16 ports, const u8 *addr)
243 {
244         u16 read1[3], read2[3], addr_be16[3];
245
246         wpa_driver_roboswitch_addr_be16(addr, addr_be16);
247
248         if (wpa_driver_roboswitch_read(drv, ROBO_ARLCTRL_PAGE,
249                                        ROBO_ARLCTRL_CONF, read1, 1) < 0)
250                 return -1;
251         if (!(read1[0] & (1 << 4))) {
252                 /* multiport addresses are not yet enabled */
253                 read1[0] |= 1 << 4;
254                 wpa_driver_roboswitch_write(drv, ROBO_ARLCTRL_PAGE,
255                                             ROBO_ARLCTRL_ADDR_1, addr_be16, 3);
256                 wpa_driver_roboswitch_write(drv, ROBO_ARLCTRL_PAGE,
257                                             ROBO_ARLCTRL_VEC_1, &ports, 1);
258                 wpa_driver_roboswitch_write(drv, ROBO_ARLCTRL_PAGE,
259                                             ROBO_ARLCTRL_ADDR_2, addr_be16, 3);
260                 wpa_driver_roboswitch_write(drv, ROBO_ARLCTRL_PAGE,
261                                             ROBO_ARLCTRL_VEC_2, &ports, 1);
262                 wpa_driver_roboswitch_write(drv, ROBO_ARLCTRL_PAGE,
263                                             ROBO_ARLCTRL_CONF, read1, 1);
264         } else {
265                 /* if both multiport addresses are the same we can add */
266                 wpa_driver_roboswitch_read(drv, ROBO_ARLCTRL_PAGE,
267                                            ROBO_ARLCTRL_ADDR_1, read1, 3);
268                 wpa_driver_roboswitch_read(drv, ROBO_ARLCTRL_PAGE,
269                                            ROBO_ARLCTRL_ADDR_2, read2, 3);
270                 if (os_memcmp(read1, read2, 6) != 0)
271                         return -1;
272                 wpa_driver_roboswitch_read(drv, ROBO_ARLCTRL_PAGE,
273                                            ROBO_ARLCTRL_VEC_1, read1, 1);
274                 wpa_driver_roboswitch_read(drv, ROBO_ARLCTRL_PAGE,
275                                            ROBO_ARLCTRL_VEC_2, read2, 1);
276                 if (read1[0] != read2[0])
277                         return -1;
278                 wpa_driver_roboswitch_write(drv, ROBO_ARLCTRL_PAGE,
279                                             ROBO_ARLCTRL_ADDR_1, addr_be16, 3);
280                 wpa_driver_roboswitch_write(drv, ROBO_ARLCTRL_PAGE,
281                                             ROBO_ARLCTRL_VEC_1, &ports, 1);
282         }
283         return 0;
284 }
285
286
287 static int wpa_driver_roboswitch_leave(struct wpa_driver_roboswitch_data *drv,
288                                        u16 ports, const u8 *addr)
289 {
290         u16 _read, addr_be16[3], addr_read[3], ports_read;
291
292         wpa_driver_roboswitch_addr_be16(addr, addr_be16);
293
294         wpa_driver_roboswitch_read(drv, ROBO_ARLCTRL_PAGE, ROBO_ARLCTRL_CONF,
295                                    &_read, 1);
296         /* If ARL control is disabled, there is nothing to leave. */
297         if (!(_read & (1 << 4))) return -1;
298
299         wpa_driver_roboswitch_read(drv, ROBO_ARLCTRL_PAGE,
300                                    ROBO_ARLCTRL_ADDR_1, addr_read, 3);
301         wpa_driver_roboswitch_read(drv, ROBO_ARLCTRL_PAGE, ROBO_ARLCTRL_VEC_1,
302                                    &ports_read, 1);
303         /* check if we occupy multiport address 1 */
304         if (os_memcmp(addr_read, addr_be16, 6) == 0 && ports_read == ports) {
305                 wpa_driver_roboswitch_read(drv, ROBO_ARLCTRL_PAGE,
306                                            ROBO_ARLCTRL_ADDR_2, addr_read, 3);
307                 wpa_driver_roboswitch_read(drv, ROBO_ARLCTRL_PAGE,
308                                            ROBO_ARLCTRL_VEC_2, &ports_read, 1);
309                 /* and multiport address 2 */
310                 if (os_memcmp(addr_read, addr_be16, 6) == 0 &&
311                     ports_read == ports) {
312                         _read &= ~(1 << 4);
313                         wpa_driver_roboswitch_write(drv, ROBO_ARLCTRL_PAGE,
314                                                     ROBO_ARLCTRL_CONF, &_read,
315                                                     1);
316                 } else {
317                         wpa_driver_roboswitch_read(drv, ROBO_ARLCTRL_PAGE,
318                                                    ROBO_ARLCTRL_ADDR_1,
319                                                    addr_read, 3);
320                         wpa_driver_roboswitch_read(drv, ROBO_ARLCTRL_PAGE,
321                                                    ROBO_ARLCTRL_VEC_1,
322                                                    &ports_read, 1);
323                         wpa_driver_roboswitch_write(drv, ROBO_ARLCTRL_PAGE,
324                                                     ROBO_ARLCTRL_ADDR_2,
325                                                     addr_read, 3);
326                         wpa_driver_roboswitch_write(drv, ROBO_ARLCTRL_PAGE,
327                                                     ROBO_ARLCTRL_VEC_2,
328                                                     &ports_read, 1);
329                 }
330         } else {
331                 wpa_driver_roboswitch_read(drv, ROBO_ARLCTRL_PAGE,
332                                            ROBO_ARLCTRL_ADDR_2, addr_read, 3);
333                 wpa_driver_roboswitch_read(drv, ROBO_ARLCTRL_PAGE,
334                                            ROBO_ARLCTRL_VEC_2, &ports_read, 1);
335                 /* or multiport address 2 */
336                 if (os_memcmp(addr_read, addr_be16, 6) == 0 &&
337                     ports_read == ports) {
338                         wpa_driver_roboswitch_write(drv, ROBO_ARLCTRL_PAGE,
339                                                     ROBO_ARLCTRL_ADDR_1,
340                                                     addr_read, 3);
341                         wpa_driver_roboswitch_write(drv, ROBO_ARLCTRL_PAGE,
342                                                     ROBO_ARLCTRL_VEC_1,
343                                                     &ports_read, 1);
344                 } else return -1;
345         }
346         return 0;
347 }
348
349
350 static void * wpa_driver_roboswitch_init(void *ctx, const char *ifname)
351 {
352         struct wpa_driver_roboswitch_data *drv;
353         char *sep;
354         u16 vlan = 0, _read[2];
355
356         drv = os_zalloc(sizeof(*drv));
357         if (drv == NULL) return NULL;
358         drv->ctx = ctx;
359         drv->own_addr[0] = '\0';
360
361         /* copy ifname and take a pointer to the second to last character */
362         sep = drv->ifname +
363               os_strlcpy(drv->ifname, ifname, sizeof(drv->ifname)) - 2;
364         /* find the '.' seperating <interface> and <vlan> */
365         while (sep > drv->ifname && *sep != '.') sep--;
366         if (sep <= drv->ifname) {
367                 wpa_printf(MSG_INFO, "%s: No <interface>.<vlan> pair in "
368                            "interface name %s", __func__, drv->ifname);
369                 os_free(drv);
370                 return NULL;
371         }
372         *sep = '\0';
373         while (*++sep) {
374                 if (*sep < '0' || *sep > '9') {
375                         wpa_printf(MSG_INFO, "%s: Invalid vlan specification "
376                                    "in interface name %s", __func__, ifname);
377                         os_free(drv);
378                         return NULL;
379                 }
380                 vlan *= 10;
381                 vlan += *sep - '0';
382                 if (vlan > ROBO_VLAN_MAX) {
383                         wpa_printf(MSG_INFO, "%s: VLAN out of range in "
384                                    "interface name %s", __func__, ifname);
385                         os_free(drv);
386                         return NULL;
387                 }
388         }
389
390         drv->fd = socket(PF_INET, SOCK_DGRAM, 0);
391         if (drv->fd < 0) {
392                 wpa_printf(MSG_INFO, "%s: Unable to create socket", __func__);
393                 os_free(drv);
394                 return NULL;
395         }
396
397         os_memset(&drv->ifr, 0, sizeof(drv->ifr));
398         os_strlcpy(drv->ifr.ifr_name, drv->ifname, IFNAMSIZ);
399         if (ioctl(drv->fd, SIOCGMIIPHY, &drv->ifr) < 0) {
400                 perror("ioctl[SIOCGMIIPHY]");
401                 os_free(drv);
402                 return NULL;
403         }
404         if (if_mii(&drv->ifr)->phy_id != ROBO_PHY_ADDR) {
405                 wpa_printf(MSG_INFO, "%s: Invalid phy address (not a "
406                            "RoboSwitch?)", __func__);
407                 os_free(drv);
408                 return NULL;
409         }
410
411         /* set and read back to see if the register can be used */
412         _read[0] = ROBO_VLAN_MAX;
413         wpa_driver_roboswitch_write(drv, ROBO_VLAN_PAGE, ROBO_VLAN_ACCESS_5350,
414                                     _read, 1);
415         wpa_driver_roboswitch_read(drv, ROBO_VLAN_PAGE, ROBO_VLAN_ACCESS_5350,
416                                    _read + 1, 1);
417         drv->is_5350 = _read[0] == _read[1];
418
419         /* set the read bit */
420         vlan |= 1 << 13;
421         wpa_driver_roboswitch_write(drv, ROBO_VLAN_PAGE,
422                                     drv->is_5350 ? ROBO_VLAN_ACCESS_5350
423                                                  : ROBO_VLAN_ACCESS,
424                                     &vlan, 1);
425         wpa_driver_roboswitch_read(drv, ROBO_VLAN_PAGE, ROBO_VLAN_READ, _read,
426                                    drv->is_5350 ? 2 : 1);
427         if (!(drv->is_5350 ? _read[1] & (1 << 4) : _read[0] & (1 << 14))) {
428                 wpa_printf(MSG_INFO, "%s: Could not get port information for "
429                                      "VLAN %d", __func__, vlan & ~(1 << 13));
430                 os_free(drv);
431                 return NULL;
432         }
433         drv->ports = _read[0] & 0x001F;
434         /* add the MII port */
435         drv->ports |= 1 << 8;
436         if (wpa_driver_roboswitch_join(drv, drv->ports, pae_group_addr) < 0) {
437                 wpa_printf(MSG_INFO, "%s: Unable to join PAE group", __func__);
438                 os_free(drv);
439                 return NULL;
440         } else {
441                 wpa_printf(MSG_DEBUG, "%s: Added PAE group address to "
442                            "RoboSwitch ARL", __func__);
443         }
444
445         return drv;
446 }
447
448
449 static void wpa_driver_roboswitch_deinit(void *priv)
450 {
451         struct wpa_driver_roboswitch_data *drv = priv;
452
453         if (drv->l2) {
454                 l2_packet_deinit(drv->l2);
455                 drv->l2 = NULL;
456         }
457         if (wpa_driver_roboswitch_leave(drv, drv->ports, pae_group_addr) < 0) {
458                 wpa_printf(MSG_DEBUG, "%s: Unable to leave PAE group",
459                            __func__);
460         }
461
462         close(drv->fd);
463         os_free(drv);
464 }
465
466
467 const struct wpa_driver_ops wpa_driver_roboswitch_ops = {
468         .name = "roboswitch",
469         .desc = "wpa_supplicant roboswitch driver",
470         .get_ssid = wpa_driver_roboswitch_get_ssid,
471         .get_bssid = wpa_driver_roboswitch_get_bssid,
472         .init = wpa_driver_roboswitch_init,
473         .deinit = wpa_driver_roboswitch_deinit,
474         .set_param = wpa_driver_roboswitch_set_param,
475         .get_ifname = wpa_driver_roboswitch_get_ifname,
476 };