release/src/router/shared/led.c

   1 /*
   2
   3         Tomato Firmware
   4         Copyright (C) 2006-2009 Jonathan Zarate
   5
   6 */
   7 #include <stdio.h>
   8 #include <stdlib.h>
   9 #include <string.h>
  10 #include <unistd.h>
  11 #include <sys/types.h>
  12 #include <sys/stat.h>
  13 #include <fcntl.h>
  14 #include <bcmnvram.h>
  15
  16 #include "utils.h"
  17 #include "shutils.h"
  18 #include "shared.h"
  19
  20
  21 const char *led_names[] = { "wlan", "diag", "white", "amber", "dmz", "aoss", "bridge", "usb" };
  22
  23 #ifdef LINUX26
  24 #define GPIO_IOCTL
  25 #endif
  26
  27 // --- move begin ---
  28 #ifdef GPIO_IOCTL
  29
  30 #include <sys/ioctl.h>
  31 #include <linux_gpio.h>
  32
  33 static int _gpio_ioctl(int f, int gpioreg, unsigned int mask, unsigned int val)
  34 {
  35         struct gpio_ioctl gpio;
  36
  37         gpio.val = val;
  38         gpio.mask = mask;
  39
  40         if (ioctl(f, gpioreg, &gpio) < 0) {
  41                 _dprintf("Invalid gpioreg %d\n", gpioreg);
  42                 return -1;
  43         }
  44         return (gpio.val);
  45 }
  46
  47 static int _gpio_open()
  48 {
  49         int f = open("/dev/gpio", O_RDWR);
  50         if (f < 0)
  51                 _dprintf ("Failed to open /dev/gpio\n");
  52         return f;
  53 }
  54
  55 int gpio_open(uint32_t mask)
  56 {
  57         uint32_t bit;
  58         int i;
  59         int f = _gpio_open();
  60
  61         if ((f >= 0) && mask) {
  62                 for (i = 0; i <= 15; i++) {
  63                         bit = 1 << i;
  64                         if ((mask & bit) == bit) {
  65                                 _gpio_ioctl(f, GPIO_IOC_RESERVE, bit, bit);
  66                                 _gpio_ioctl(f, GPIO_IOC_OUTEN, bit, 0);
  67                         }
  68                 }
  69                 close(f);
  70                 f = _gpio_open();
  71         }
  72
  73         return f;
  74 }
  75
  76 void gpio_write(uint32_t bit, int en)
  77 {
  78         int f;
  79
  80         if ((f = gpio_open(0)) < 0) return;
  81
  82         _gpio_ioctl(f, GPIO_IOC_RESERVE, bit, bit);
  83         _gpio_ioctl(f, GPIO_IOC_OUTEN, bit, bit);
  84         _gpio_ioctl(f, GPIO_IOC_OUT, bit, en ? bit : 0);
  85         close(f);
  86 }
  87
  88 uint32_t _gpio_read(int f)
  89 {
  90         uint32_t r;
  91 //      r = _gpio_ioctl(f, GPIO_IOC_IN, 0xFFFF, 0);
  92         r = _gpio_ioctl(f, GPIO_IOC_IN, 0x07FF, 0);
  93         if (r < 0) r = ~0;
  94         return r;
  95 }
  96
  97 uint32_t gpio_read(void)
  98 {
  99         int f;
 100         uint32_t r;
 101
 102         if ((f = gpio_open(0)) < 0) return ~0;
 103         r = _gpio_read(f);
 104         close(f);
 105         return r;
 106 }
 107
 108 #else
 109
 110 int gpio_open(uint32_t mask)
 111 {
 112         int f = open(DEV_GPIO(in), O_RDONLY|O_SYNC);
 113         if (f < 0)
 114                 _dprintf ("Failed to open %s\n", DEV_GPIO(in));
 115         return f;
 116 }
 117
 118 void gpio_write(uint32_t bit, int en)
 119 {
 120         int f;
 121         uint32_t r;
 122
 123         if ((f = open(DEV_GPIO(control), O_RDWR)) < 0) return;
 124         read(f, &r, sizeof(r));
 125         r &= ~bit;
 126         write(f, &r, sizeof(r));
 127         close(f);
 128
 129         if ((f = open(DEV_GPIO(outen), O_RDWR)) < 0) return;
 130         read(f, &r, sizeof(r));
 131         r |= bit;
 132         write(f, &r, sizeof(r));
 133         close(f);
 134
 135         if ((f = open(DEV_GPIO(out), O_RDWR)) < 0) return;
 136         read(f, &r, sizeof(r));
 137         if (en) r |= bit;
 138                 else r &= ~bit;
 139         write(f, &r, sizeof(r));
 140         close(f);
 141 }
 142
 143 uint32_t _gpio_read(int f)
 144 {
 145         uint32_t v;
 146         return (read(f, &v, sizeof(v)) == sizeof(v)) ? v : ~0;
 147 }
 148
 149 uint32_t gpio_read(void)
 150 {
 151         int f;
 152         uint32_t r;
 153
 154         if ((f = open(DEV_GPIO(in), O_RDONLY)) < 0) return ~0;
 155         r = _gpio_read(f);
 156         close(f);
 157         return r;
 158 }
 159
 160 #endif
 161
 162 int nvget_gpio(const char *name, int *gpio, int *inv)
 163 {
 164         char *p;
 165         uint32_t n;
 166
 167         if (((p = nvram_get(name)) != NULL) && (*p)) {
 168                 n = strtoul(p, NULL, 0);
 169                 if ((n & 0xFFFFFF70) == 0) {
 170                         *gpio = (n & 15);
 171                         *inv = ((n & 0x80) != 0);
 172                         return 1;
 173                 }
 174         }
 175         return 0;
 176 }
 177 // --- move end ---
 178
 179
 180 int do_led(int which, int mode)
 181 {
 182 //                                  WLAN  DIAG  WHITE AMBER DMZ   AOSS  BRIDG MYST/USB
 183 //                                  ----- ----- ----- ----- ----- ----- ----- -----
 184         static int wrt54g[]     = { 255,  1,    2,    3,    7,    255,  255,  255       };
 185         static int wrtsl[]      = { 255,  1,    5,    7,    0,    255,  255,  255       };
 186         static int whrg54[]     = { 2,    7,    255,  255,  255,  6,    1,    3         };
 187         static int wbr2g54[]    = { 255,  -1,   255,  255,  255,  -6,   255,  255       };
 188         static int wzrg54[]     = { 2,    7,    255,  255,  255,  6,    255,  255       };
 189         static int wr850g1[]    = { 7,    3,    255,  255,  255,  255,  255,  255       };
 190         static int wr850g2[]    = { 0,    1,    255,  255,  255,  255,  255,  255       };
 191         static int wtr54gs[]    = { 1,    -1,   255,  255,  255,  255,  255,  255       };
 192         static int dir320[]     = { -99,   1,     4,    3,  255,  255,  255,   -5       };
 193         static int h618b[]      = { 255,  -1,   255,  255,  255,   -5,   -3,   -4       };
 194         static int wl1600gl[]   = { 1,    -5,     0,  255,  255,  2,    255,  255       };
 195         static int wrt310nv1[]  = { 255,   1,     9,    3,  255,  255,  255,  255       };
 196         static int wrt160nv1[]  = { 255,   1,     5,    3,  255,  255,  255,  255       };
 197 #ifdef CONFIG_BCMWL5
 198         static int wnr3500[]    = { 255, 255,     2,  255,  255,   -1,  255,  255       };
 199         static int wnr2000v2[]  = { 255, 255,   255,  255,  255,   -7,  255,  255       };
 200         static int wrt160nv3[]  = { 255,   1,     4,    2,  255,  255,  255,  255       };
 201         static int wrt320n[]    = { 255,   2,     3,    4,  255,  255,  255,  255       };
 202         static int wrt610nv2[]  = { 255,   5,     3,    0,  255,  255,  255,   -7       };
 203 #endif
 204
 205         char s[16];
 206         int n;
 207         int b = 255, c = 255;
 208         int ret = 255;
 209
 210         if ((which < 0) || (which >= LED_COUNT)) return ret;
 211
 212         switch (nvram_match("led_override", "1") ? MODEL_UNKNOWN : get_model()) {
 213         case MODEL_WRT54G:
 214                 if (check_hw_type() == HW_BCM4702) {
 215                         // G v1.x
 216                         if ((which != LED_DIAG) && (which != LED_DMZ)) return ret;
 217                         b = (which == LED_DMZ) ? 1 : 4;
 218                         if (mode != LED_PROBE) {
 219                                 if (f_read_string("/proc/sys/diag", s, sizeof(s)) > 0) {
 220                                         n = atoi(s);
 221                                         sprintf(s, "%u", mode ? (n | b) : (n & ~b));
 222                                         f_write_string("/proc/sys/diag", s, 0, 0);
 223                                 }
 224                         }
 225                         return b;
 226                 }
 227                 switch (which) {
 228                 case LED_AMBER:
 229                 case LED_WHITE:
 230                         if (!supports(SUP_WHAM_LED)) return ret;
 231                         break;
 232                 }
 233                 b = wrt54g[which];
 234                 break;
 235         case MODEL_WTR54GS:
 236                 b = wtr54gs[which];
 237                 break;
 238         case MODEL_WRTSL54GS:
 239                 b = wrtsl[which];
 240                 break;
 241         case MODEL_WHRG54S:
 242         case MODEL_WHRHPG54:
 243         case MODEL_WHRG125:
 244                 b = whrg54[which];
 245                 break;
 246         case MODEL_WZRG54:
 247         case MODEL_WZRHPG54:
 248         case MODEL_WZRRSG54:
 249         case MODEL_WZRRSG54HP:
 250         case MODEL_WVRG54NF:
 251         case MODEL_WHR2A54G54:
 252         case MODEL_WHR3AG54:
 253         case MODEL_WZRG108:
 254                 b = wzrg54[which];
 255                 break;
 256 /*
 257         case MODEL_WHR2A54G54:
 258                 if (which != LED_DIAG) return ret;
 259                 b = 7;
 260                 break;
 261 */
 262         case MODEL_WBRG54:
 263                 if (which != LED_DIAG) return ret;
 264                 b = 7;
 265                 break;
 266         case MODEL_WBR2G54:
 267                 b = wbr2g54[which];
 268                 break;
 269         case MODEL_WR850GV1:
 270                 b = wr850g1[which];
 271                 break;
 272         case MODEL_WR850GV2:
 273         case MODEL_WR100:
 274                 b = wr850g2[which];
 275                 break;
 276         case MODEL_WL500GP:
 277                 if (which != LED_DIAG) return ret;
 278                 b = -1; // power light
 279                 break;
 280         case MODEL_WL500W:
 281                 if (which != LED_DIAG) return ret;
 282                 b = -5; // power light
 283                 break;
 284         case MODEL_DIR320:
 285                 b = dir320[which];
 286                 break;
 287         case MODEL_H618B:
 288                 b = h618b[which];
 289                 break;
 290         case MODEL_WL1600GL:
 291                 b = wl1600gl[which];
 292                 break;
 293         case MODEL_WL500GPv2:
 294         case MODEL_WL500GD:
 295         case MODEL_WL520GU:
 296                 if (which != LED_DIAG) return ret;
 297                 b = -99;        // Invert power light as diag indicator
 298                 break;
 299 #ifdef CONFIG_BCMWL5
 300         case MODEL_RTN12:
 301                 if (which != LED_DIAG) return ret;
 302                 b = -2; // power light
 303                 break;
 304         case MODEL_RTN10:
 305         case MODEL_RTN16:
 306                 if (which != LED_DIAG) return ret;
 307                 b = -1; // power light
 308                 break;
 309         case MODEL_WNR3500L:
 310                 if (which == LED_DIAG) {
 311                         // power led gpio: 0x03 - green, 0x07 - amber
 312                         b = (mode) ? 7 : 3;
 313                         c = (mode) ? 3 : 7;
 314                 } else
 315                         b = wnr3500[which];
 316                 break;
 317         case MODEL_WNR2000v2:
 318                 if (which == LED_DIAG) {
 319                         // power led gpio: 0x01 - green, 0x02 - amber
 320                         b = (mode) ? 2 : 1;
 321                         c = (mode) ? 1 : 2;
 322                 } else
 323                         b = wnr2000v2[which];
 324                 break;
 325         case MODEL_WRT160Nv3:
 326                 b = wrt160nv3[which];
 327                 break;
 328         case MODEL_WRT320N:
 329                 b = wrt320n[which];
 330                 break;
 331         case MODEL_WRT610Nv2:
 332                 b = wrt610nv2[which];
 333                 break;
 334 #endif
 335 /*
 336         case MODEL_RT390W:
 337                 break;
 338 */
 339         case MODEL_MN700:
 340                 if (which != LED_DIAG) return ret;
 341                 b = 6;
 342                 break;
 343         case MODEL_WLA2G54L:
 344                 if (which != LED_DIAG) return ret;
 345                 b = 1;
 346                 break;
 347         case MODEL_WRT300N:
 348                 if (which != LED_DIAG) return ret;
 349                 b = 1;
 350                 break;
 351         case MODEL_WRT310Nv1:
 352                 b = wrt310nv1[which];
 353                 break;
 354         case MODEL_WRT160Nv1:
 355                 b = wrt160nv1[which];
 356                 break;
 357         default:
 358                 sprintf(s, "led_%s", led_names[which]);
 359                 if (nvget_gpio(s, &b, &n)) {
 360                         if ((mode != LED_PROBE) && (n)) mode = !mode;
 361                         ret = (n) ? b : ((b) ? -b : -99);
 362                         goto SET;
 363                 }
 364                 return ret;
 365         }
 366
 367         ret = b;
 368         if (b < 0) {
 369                 if (b == -99) b = 0; // -0 substitute
 370                         else b = -b;
 371         }
 372         else if (mode != LED_PROBE) {
 373                 mode = !mode;
 374         }
 375
 376 SET:
 377         if (b < 16) {
 378                 if (mode != LED_PROBE) {
 379                         gpio_write(1 << b, mode);
 380
 381                         if (c < 0) {
 382                                 if (c == -99) c = 0;
 383                                 else c = -c;
 384                         }
 385                         else mode = !mode;
 386                         if (c < 16) gpio_write(1 << c, mode);
 387                 }
 388         }
 389
 390         return ret;
 391 }