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