vcs.maemo.org Git - wpasupplicant/blob - src/drivers/driver_roboswitch.c

   1 /*
   2  * WPA Supplicant - roboswitch driver interface
   3  * Copyright (c) 2008 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/mii.h>
  20
  21 #include "common.h"
  22 #include "driver.h"
  23
  24 #define ROBO_PHY_ADDR           0x1E    /* RoboSwitch PHY address */
  25
  26 /* MII access registers */
  27 #define ROBO_MII_PAGE           0x10    /* MII page register */
  28 #define ROBO_MII_ADDR           0x11    /* MII address register */
  29 #define ROBO_MII_DATA_OFFSET    0x18    /* Start of MII data registers */
  30
  31 #define ROBO_MII_PAGE_ENABLE    0x01    /* MII page op code */
  32 #define ROBO_MII_ADDR_WRITE     0x01    /* MII address write op code */
  33 #define ROBO_MII_ADDR_READ      0x02    /* MII address read op code */
  34 #define ROBO_MII_DATA_MAX          4    /* Consecutive MII data registers */
  35 #define ROBO_MII_RETRY_MAX        10    /* Read attempts before giving up */
  36
  37 /* Page numbers */
  38 #define ROBO_ARLCTRL_PAGE       0x04    /* ARL control page */
  39 #define ROBO_VLAN_PAGE          0x34    /* VLAN page */
  40
  41 /* ARL control page registers */
  42 #define ROBO_ARLCTRL_CONF       0x00    /* ARL configuration register */
  43 #define ROBO_ARLCTRL_ADDR_1     0x10    /* Multiport address 1 */
  44 #define ROBO_ARLCTRL_VEC_1      0x16    /* Multiport vector 1 */
  45 #define ROBO_ARLCTRL_ADDR_2     0x20    /* Multiport address 2 */
  46 #define ROBO_ARLCTRL_VEC_2      0x26    /* Multiport vector 2 */
  47
  48 /* VLAN page registers */
  49 #define ROBO_VLAN_ACCESS        0x06    /* VLAN table Access register */
  50 #define ROBO_VLAN_READ          0x0C    /* VLAN read register */
  51
  52
  53 static const u8 pae_group_addr[ETH_ALEN] =
  54 { 0x01, 0x80, 0xc2, 0x00, 0x00, 0x03 };
  55
  56
  57 struct wpa_driver_roboswitch_data {
  58         void *ctx;
  59         char ifname[IFNAMSIZ + 1];
  60         struct ifreq ifr;
  61         int fd;
  62         u16 ports;
  63 };
  64
  65
  66 /* Copied from the kernel-only part of mii.h. */
  67 static inline struct mii_ioctl_data *if_mii(struct ifreq *rq)
  68 {
  69         return (struct mii_ioctl_data *) &rq->ifr_ifru;
  70 }
  71
  72
  73 static u16 wpa_driver_roboswitch_mdio_read(
  74         struct wpa_driver_roboswitch_data *drv, u8 reg)
  75 {
  76         struct mii_ioctl_data *mii = if_mii(&drv->ifr);
  77
  78         mii->phy_id = ROBO_PHY_ADDR;
  79         mii->reg_num = reg;
  80
  81         if (ioctl(drv->fd, SIOCGMIIREG, &drv->ifr) < 0) {
  82                 perror("ioctl[SIOCGMIIREG]");
  83                 return 0x00;
  84         }
  85         return mii->val_out;
  86 }
  87
  88
  89 static void wpa_driver_roboswitch_mdio_write(
  90         struct wpa_driver_roboswitch_data *drv, u8 reg, u16 val)
  91 {
  92         struct mii_ioctl_data *mii = if_mii(&drv->ifr);
  93
  94         mii->phy_id = ROBO_PHY_ADDR;
  95         mii->reg_num = reg;
  96         mii->val_in = val;
  97
  98         if (ioctl(drv->fd, SIOCSMIIREG, &drv->ifr) < 0) {
  99                 perror("ioctl[SIOCSMIIREG");
 100         }
 101 }
 102
 103
 104 static int wpa_driver_roboswitch_reg(struct wpa_driver_roboswitch_data *drv,
 105                                      u8 page, u8 reg, u8 op)
 106 {
 107         int i;
 108
 109         /* set page number */
 110         wpa_driver_roboswitch_mdio_write(drv, ROBO_MII_PAGE,
 111                                          (page << 8) | ROBO_MII_PAGE_ENABLE);
 112         /* set register address */
 113         wpa_driver_roboswitch_mdio_write(drv, ROBO_MII_ADDR, (reg << 8) | op);
 114
 115         /* check if operation completed */
 116         for (i = 0; i < ROBO_MII_RETRY_MAX; ++i) {
 117                 if ((wpa_driver_roboswitch_mdio_read(drv, ROBO_MII_ADDR) & 3)
 118                     == 0)
 119                         return 0;
 120         }
 121         /* timeout */
 122         return -1;
 123 }
 124
 125
 126 static int wpa_driver_roboswitch_read(struct wpa_driver_roboswitch_data *drv,
 127                                       u8 page, u8 reg, u16 *val, int len)
 128 {
 129         int i;
 130
 131         if (len > ROBO_MII_DATA_MAX ||
 132             wpa_driver_roboswitch_reg(drv, page, reg, ROBO_MII_ADDR_READ) < 0)
 133                 return -1;
 134
 135         for (i = 0; i < len; ++i) {
 136                 val[i] = wpa_driver_roboswitch_mdio_read(
 137                         drv, ROBO_MII_DATA_OFFSET + i);
 138         }
 139
 140         return 0;
 141 }
 142
 143
 144 static int wpa_driver_roboswitch_write(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) return -1;
 150         for (i = 0; i < len; ++i) {
 151                 wpa_driver_roboswitch_mdio_write(drv, ROBO_MII_DATA_OFFSET + i,
 152                                                  val[i]);
 153         }
 154         return wpa_driver_roboswitch_reg(drv, page, reg, ROBO_MII_ADDR_WRITE);
 155 }
 156
 157
 158 static int wpa_driver_roboswitch_get_ssid(void *priv, u8 *ssid)
 159 {
 160         ssid[0] = 0;
 161         return 0;
 162 }
 163
 164
 165 static int wpa_driver_roboswitch_get_bssid(void *priv, u8 *bssid)
 166 {
 167         /* Report PAE group address as the "BSSID" for wired connection. */
 168         os_memcpy(bssid, pae_group_addr, ETH_ALEN);
 169         return 0;
 170 }
 171
 172
 173 static const char * wpa_driver_roboswitch_get_ifname(void *priv)
 174 {
 175         struct wpa_driver_roboswitch_data *drv = priv;
 176         return drv->ifname;
 177 }
 178
 179
 180 static int wpa_driver_roboswitch_join(struct wpa_driver_roboswitch_data *drv,
 181                                       const u8 *addr)
 182 {
 183         int i;
 184         u16 _read, zero = 0;
 185         /* For reasons of simplicity we assume ETH_ALEN is even. */
 186         u16 addr_word[ETH_ALEN / 2];
 187         /* RoboSwitch uses 16-bit Big Endian addresses.                 */
 188         /* The ordering of the words is reversed in the MII registers.  */
 189         for (i = 0; i < ETH_ALEN; i += 2)
 190                 addr_word[(ETH_ALEN - i) / 2 - 1] = WPA_GET_BE16(addr + i);
 191
 192         /* check if multiport addresses are not yet enabled */
 193         if (wpa_driver_roboswitch_read(drv, ROBO_ARLCTRL_PAGE,
 194                                        ROBO_ARLCTRL_CONF, &_read, 1) < 0)
 195                 return -1;
 196
 197         if (!(_read & (1 << 4))) {
 198                 _read |= 1 << 4;
 199                 wpa_driver_roboswitch_write(drv, ROBO_ARLCTRL_PAGE,
 200                                             ROBO_ARLCTRL_ADDR_1, addr_word, 3);
 201                 wpa_driver_roboswitch_write(drv, ROBO_ARLCTRL_PAGE,
 202                                             ROBO_ARLCTRL_VEC_1, &drv->ports,
 203                                             1);
 204                 wpa_driver_roboswitch_write(drv, ROBO_ARLCTRL_PAGE,
 205                                             ROBO_ARLCTRL_VEC_2, &zero, 1);
 206                 wpa_driver_roboswitch_write(drv, ROBO_ARLCTRL_PAGE,
 207                                             ROBO_ARLCTRL_CONF, &_read, 1);
 208                 return 0;
 209         }
 210
 211         /* check if multiport address 1 is free */
 212         wpa_driver_roboswitch_read(drv, ROBO_ARLCTRL_PAGE, ROBO_ARLCTRL_VEC_1,
 213                                    &_read, 1);
 214         if (_read == 0) {
 215                 wpa_driver_roboswitch_write(drv, ROBO_ARLCTRL_PAGE,
 216                                             ROBO_ARLCTRL_ADDR_1, addr_word, 3);
 217                 wpa_driver_roboswitch_write(drv, ROBO_ARLCTRL_PAGE,
 218                                             ROBO_ARLCTRL_VEC_1, &drv->ports,
 219                                             1);
 220                 return 0;
 221         }
 222         /* check if multiport address 2 is free */
 223         wpa_driver_roboswitch_read(drv, ROBO_ARLCTRL_PAGE, ROBO_ARLCTRL_VEC_2,
 224                                    &_read, 1);
 225         if (_read == 0) {
 226                 wpa_driver_roboswitch_write(drv, ROBO_ARLCTRL_PAGE,
 227                                             ROBO_ARLCTRL_ADDR_2, addr_word, 3);
 228                 wpa_driver_roboswitch_write(drv, ROBO_ARLCTRL_PAGE,
 229                                             ROBO_ARLCTRL_VEC_2, &drv->ports,
 230                                             1);
 231                 return 0;
 232         }
 233
 234         /* out of free multiport addresses */
 235         return -1;
 236 }
 237
 238
 239 static int wpa_driver_roboswitch_leave(struct wpa_driver_roboswitch_data *drv,
 240                                        const u8 *addr)
 241 {
 242         int i;
 243         u8 mport[4] = { ROBO_ARLCTRL_VEC_1, ROBO_ARLCTRL_ADDR_1,
 244                         ROBO_ARLCTRL_VEC_2, ROBO_ARLCTRL_ADDR_2 };
 245         u16 _read[3], zero = 0;
 246         /* same as at join */
 247         u16 addr_word[ETH_ALEN / 2];
 248
 249         for (i = 0; i < ETH_ALEN; i += 2)
 250                 addr_word[(ETH_ALEN - i) / 2 - 1] = WPA_GET_BE16(addr + i);
 251
 252         /* find our address/vector pair */
 253         for (i = 0; i < 4; i += 2) {
 254                 wpa_driver_roboswitch_read(drv, ROBO_ARLCTRL_PAGE, mport[i],
 255                                            _read, 1);
 256                 if (_read[0] == drv->ports) {
 257                         wpa_driver_roboswitch_read(drv, ROBO_ARLCTRL_PAGE,
 258                                                    mport[i + 1], _read, 3);
 259                         if (os_memcmp(_read, addr_word, 6) == 0)
 260                                 break;
 261                 }
 262         }
 263         /* check if we found our address/vector pair and deactivate it */
 264         if (i == 4)
 265                 return -1;
 266         wpa_driver_roboswitch_write(drv, ROBO_ARLCTRL_PAGE, mport[i], &zero,
 267                                     1);
 268
 269         /* leave the multiport registers in a sane state */
 270         wpa_driver_roboswitch_read(drv, ROBO_ARLCTRL_PAGE, ROBO_ARLCTRL_VEC_1,
 271                                    _read, 1);
 272         if (_read[0] == 0) {
 273                 wpa_driver_roboswitch_read(drv, ROBO_ARLCTRL_PAGE,
 274                                            ROBO_ARLCTRL_VEC_2, _read, 1);
 275                 if (_read[0] == 0) {
 276                         wpa_driver_roboswitch_read(drv, ROBO_ARLCTRL_PAGE,
 277                                                    ROBO_ARLCTRL_CONF, _read,
 278                                                    1);
 279                         _read[0] &= ~(1 << 4);
 280                         wpa_driver_roboswitch_write(drv, ROBO_ARLCTRL_PAGE,
 281                                                     ROBO_ARLCTRL_CONF, _read,
 282                                                     1);
 283                 } else {
 284                         wpa_driver_roboswitch_read(drv, ROBO_ARLCTRL_PAGE,
 285                                                    ROBO_ARLCTRL_ADDR_2, _read,
 286                                                    3);
 287                         wpa_driver_roboswitch_write(drv, ROBO_ARLCTRL_PAGE,
 288                                                     ROBO_ARLCTRL_ADDR_1, _read,
 289                                                     3);
 290                         wpa_driver_roboswitch_read(drv, ROBO_ARLCTRL_PAGE,
 291                                                    ROBO_ARLCTRL_VEC_2, _read,
 292                                                    1);
 293                         wpa_driver_roboswitch_write(drv, ROBO_ARLCTRL_PAGE,
 294                                                     ROBO_ARLCTRL_VEC_1, _read,
 295                                                     1);
 296                         wpa_driver_roboswitch_write(drv, ROBO_ARLCTRL_PAGE,
 297                                                     ROBO_ARLCTRL_VEC_2, &zero,
 298                                                     1);
 299                 }
 300         }
 301         return 0;
 302 }
 303
 304
 305 static void * wpa_driver_roboswitch_init(void *ctx, const char *ifname)
 306 {
 307         struct wpa_driver_roboswitch_data *drv;
 308         int len = -1, sep = -1;
 309         u16 vlan = 0, vlan_read[2];
 310
 311         drv = os_zalloc(sizeof(*drv));
 312         if (drv == NULL) return NULL;
 313         drv->ctx = ctx;
 314
 315         while (ifname[++len]) {
 316                 if (ifname[len] == '.')
 317                         sep = len;
 318         }
 319         if (sep < 0 || sep >= len - 1) {
 320                 wpa_printf(MSG_INFO, "%s: No <interface>.<vlan> pair in "
 321                            "interface name %s", __func__, ifname);
 322                 os_free(drv);
 323                 return NULL;
 324         }
 325         if (sep > IFNAMSIZ) {
 326                 wpa_printf(MSG_INFO, "%s: Interface name %s is too long",
 327                            __func__, ifname);
 328                 os_free(drv);
 329                 return NULL;
 330         }
 331         os_memcpy(drv->ifname, ifname, sep);
 332         drv->ifname[sep] = '\0';
 333         while (++sep < len) {
 334                 if (ifname[sep] < '0' || ifname[sep] > '9') {
 335                         wpa_printf(MSG_INFO, "%s: Invalid vlan specification "
 336                                    "in interface name %s", __func__, ifname);
 337                         os_free(drv);
 338                         return NULL;
 339                 }
 340                 vlan *= 10;
 341                 vlan += ifname[sep] - '0';
 342                 if (vlan > 255) {
 343                         wpa_printf(MSG_INFO, "%s: VLAN out of range in "
 344                                    "interface name %s", __func__, ifname);
 345                         os_free(drv);
 346                         return NULL;
 347                 }
 348         }
 349
 350         drv->fd = socket(PF_INET, SOCK_DGRAM, 0);
 351         if (drv->fd < 0) {
 352                 wpa_printf(MSG_INFO, "%s: Unable to create socket", __func__);
 353                 os_free(drv);
 354                 return NULL;
 355         }
 356
 357         os_memset(&drv->ifr, 0, sizeof(drv->ifr));
 358         os_strlcpy(drv->ifr.ifr_name, drv->ifname, IFNAMSIZ);
 359         if (ioctl(drv->fd, SIOCGMIIPHY, &drv->ifr) < 0) {
 360                 perror("ioctl[SIOCGMIIPHY]");
 361                 os_free(drv);
 362                 return NULL;
 363         }
 364         if (if_mii(&drv->ifr)->phy_id != ROBO_PHY_ADDR) {
 365                 wpa_printf(MSG_INFO, "%s: Invalid phy address (not a "
 366                            "RoboSwitch?)", __func__);
 367                 os_free(drv);
 368                 return NULL;
 369         }
 370
 371         vlan |= 1 << 13;
 372         /* The BCM5365 uses a different register and is not accounted for. */
 373         wpa_driver_roboswitch_write(drv, ROBO_VLAN_PAGE, ROBO_VLAN_ACCESS,
 374                                     &vlan, 1);
 375         wpa_driver_roboswitch_read(drv, ROBO_VLAN_PAGE, ROBO_VLAN_READ,
 376                                    vlan_read, 2);
 377         if (!(vlan_read[1] & (1 << 4))) {
 378                 wpa_printf(MSG_INFO, "%s: Could not get port information for "
 379                                      "VLAN %d", __func__, vlan & ~(1 << 13));
 380                 os_free(drv);
 381                 return NULL;
 382         }
 383         drv->ports = vlan_read[0] & 0x001F;
 384         /* add the MII port */
 385         drv->ports |= 1 << 8;
 386         if (wpa_driver_roboswitch_join(drv, pae_group_addr) < 0) {
 387                 wpa_printf(MSG_INFO, "%s: Unable to join PAE group", __func__);
 388                 os_free(drv);
 389                 return NULL;
 390         } else {
 391                 wpa_printf(MSG_DEBUG, "%s: Added PAE group address to "
 392                            "RoboSwitch ARL", __func__);
 393         }
 394
 395         return drv;
 396 }
 397
 398
 399 static void wpa_driver_roboswitch_deinit(void *priv)
 400 {
 401         struct wpa_driver_roboswitch_data *drv = priv;
 402
 403         if (wpa_driver_roboswitch_leave(drv, pae_group_addr) < 0) {
 404                 wpa_printf(MSG_DEBUG, "%s: Unable to leave PAE group",
 405                            __func__);
 406         }
 407
 408         close(drv->fd);
 409         os_free(drv);
 410 }
 411
 412
 413 const struct wpa_driver_ops wpa_driver_roboswitch_ops = {
 414         .name = "roboswitch",
 415         .desc = "wpa_supplicant roboswitch driver",
 416         .get_ssid = wpa_driver_roboswitch_get_ssid,
 417         .get_bssid = wpa_driver_roboswitch_get_bssid,
 418         .init = wpa_driver_roboswitch_init,
 419         .deinit = wpa_driver_roboswitch_deinit,
 420         .get_ifname = wpa_driver_roboswitch_get_ifname,
 421 };