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