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 61static const u8 pae_group_addr[ETH_ALEN] = 62{ 0x01, 0x80, 0xc2, 0x00, 0x00, 0x03 }; 63 64 65struct 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. */ 77static 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 */ 87static 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 95static 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 111static 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 126static 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 148static 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 166static 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 180static 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 193static int wpa_driver_roboswitch_get_ssid(void *priv, u8 *ssid) 194{ 195 ssid[0] = 0; 196 return 0; 197} 198 199 200static 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 208static 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 234static 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 241static 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 287static 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 350static 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 449static 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 467const 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}; 477