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 f7d[]        = { 255, 255,   255,  255,   12,   13,  255,   14       };
 201         static int wrt160nv3[]  = { 255,   1,     4,    2,  255,  255,  255,  255       };
 202         static int wrt320n[]    = { 255,   2,     3,    4,  255,  255,  255,  255       };
 203         static int wrt610nv2[]  = { 255,   5,     3,    0,  255,  255,  255,   -7       };
 204         static int e4200[]      = { 255,   5,    -3,  255,  255,  255,  255,  255       };
 205         static int rtn66u[]     = { 255, -12,   255,  255,  255,  255,  255,   15       };
 206 #endif
 207
 208         char s[16];
 209         int n;
 210         int b = 255, c = 255;
 211         int ret = 255;
 212
 213         if ((which < 0) || (which >= LED_COUNT)) return ret;
 214
 215         switch (nvram_match("led_override", "1") ? MODEL_UNKNOWN : get_model()) {
 216         case MODEL_WRT54G:
 217                 if (check_hw_type() == HW_BCM4702) {
 218                         // G v1.x
 219                         if ((which != LED_DIAG) && (which != LED_DMZ)) return ret;
 220                         b = (which == LED_DMZ) ? 1 : 4;
 221                         if (mode != LED_PROBE) {
 222                                 if (f_read_string("/proc/sys/diag", s, sizeof(s)) > 0) {
 223                                         n = atoi(s);
 224                                         sprintf(s, "%u", mode ? (n | b) : (n & ~b));
 225                                         f_write_string("/proc/sys/diag", s, 0, 0);
 226                                 }
 227                         }
 228                         return b;
 229                 }
 230                 switch (which) {
 231                 case LED_AMBER:
 232                 case LED_WHITE:
 233                         if (!supports(SUP_WHAM_LED)) return ret;
 234                         break;
 235                 }
 236                 b = wrt54g[which];
 237                 break;
 238         case MODEL_WTR54GS:
 239                 b = wtr54gs[which];
 240                 break;
 241         case MODEL_WRTSL54GS:
 242                 b = wrtsl[which];
 243                 break;
 244         case MODEL_WHRG54S:
 245         case MODEL_WHRHPG54:
 246         case MODEL_WHRG125:
 247                 b = whrg54[which];
 248                 break;
 249         case MODEL_WZRG54:
 250         case MODEL_WZRHPG54:
 251         case MODEL_WZRRSG54:
 252         case MODEL_WZRRSG54HP:
 253         case MODEL_WVRG54NF:
 254         case MODEL_WHR2A54G54:
 255         case MODEL_WHR3AG54:
 256         case MODEL_WZRG108:
 257                 b = wzrg54[which];
 258                 break;
 259 /*
 260         case MODEL_WHR2A54G54:
 261                 if (which != LED_DIAG) return ret;
 262                 b = 7;
 263                 break;
 264 */
 265         case MODEL_WBRG54:
 266                 if (which != LED_DIAG) return ret;
 267                 b = 7;
 268                 break;
 269         case MODEL_WBR2G54:
 270                 b = wbr2g54[which];
 271                 break;
 272         case MODEL_WR850GV1:
 273                 b = wr850g1[which];
 274                 break;
 275         case MODEL_WR850GV2:
 276         case MODEL_WR100:
 277                 b = wr850g2[which];
 278                 break;
 279         case MODEL_WL500GP:
 280                 if (which != LED_DIAG) return ret;
 281                 b = -1; // power light
 282                 break;
 283         case MODEL_WL500W:
 284                 if (which != LED_DIAG) return ret;
 285                 b = -5; // power light
 286                 break;
 287         case MODEL_DIR320:
 288                 b = dir320[which];
 289                 break;
 290         case MODEL_H618B:
 291                 b = h618b[which];
 292                 break;
 293         case MODEL_WL1600GL:
 294                 b = wl1600gl[which];
 295                 break;
 296         case MODEL_WL500GPv2:
 297         case MODEL_WL500GD:
 298         case MODEL_WL520GU:
 299                 if (which != LED_DIAG) return ret;
 300                 b = -99;        // Invert power light as diag indicator
 301                 break;
 302 #ifdef CONFIG_BCMWL5
 303         case MODEL_RTN12:
 304                 if (which != LED_DIAG) return ret;
 305                 b = -2; // power light
 306                 break;
 307         case MODEL_RTN10:
 308         case MODEL_RTN16:
 309                 if (which != LED_DIAG) return ret;
 310                 b = -1; // power light
 311                 break;
 312         case MODEL_RTN66U:
 313                 b = rtn66u[which];
 314                 break;
 315         case MODEL_WNR3500L:
 316                 if (which == LED_DIAG) {
 317                         // power led gpio: 0x03 - green, 0x07 - amber
 318                         b = (mode) ? 7 : 3;
 319                         c = (mode) ? 3 : 7;
 320                 } else
 321                         b = wnr3500[which];
 322                 break;
 323         case MODEL_WNR2000v2:
 324                 if (which == LED_DIAG) {
 325                         // power led gpio: 0x01 - green, 0x02 - amber
 326                         b = (mode) ? 2 : 1;
 327                         c = (mode) ? 1 : 2;
 328                 } else
 329                         b = wnr2000v2[which];
 330                 break;
 331         case MODEL_F7D3301:
 332         case MODEL_F7D3302:
 333         case MODEL_F7D4301:
 334         case MODEL_F7D4302:
 335         case MODEL_F5D8235v3:
 336                 if (which == LED_DIAG) {
 337                         // power led gpio: 10 - green, 11 - red
 338                         b = (mode) ? 11 : -10;
 339                         c = (mode) ? -10 : 11;
 340                 } else
 341                         b = f7d[which];
 342                 break;
 343         case MODEL_WRT160Nv3:
 344                 b = wrt160nv3[which];
 345                 break;
 346         case MODEL_WRT320N:
 347                 b = wrt320n[which];
 348                 break;
 349         case MODEL_WRT610Nv2:
 350                 b = wrt610nv2[which];
 351                 break;
 352         case MODEL_E4200:
 353                 b = e4200[which];
 354                 break;
 355 #endif
 356 /*
 357         case MODEL_RT390W:
 358                 break;
 359 */
 360         case MODEL_MN700:
 361                 if (which != LED_DIAG) return ret;
 362                 b = 6;
 363                 break;
 364         case MODEL_WLA2G54L:
 365                 if (which != LED_DIAG) return ret;
 366                 b = 1;
 367                 break;
 368         case MODEL_WRT300N:
 369                 if (which != LED_DIAG) return ret;
 370                 b = 1;
 371                 break;
 372         case MODEL_WRT310Nv1:
 373                 b = wrt310nv1[which];
 374                 break;
 375         case MODEL_WRT160Nv1:
 376                 b = wrt160nv1[which];
 377                 break;
 378         default:
 379                 sprintf(s, "led_%s", led_names[which]);
 380                 if (nvget_gpio(s, &b, &n)) {
 381                         if ((mode != LED_PROBE) && (n)) mode = !mode;
 382                         ret = (n) ? b : ((b) ? -b : -99);
 383                         goto SET;
 384                 }
 385                 return ret;
 386         }
 387
 388         ret = b;
 389         if (b < 0) {
 390                 if (b == -99) b = 0; // -0 substitute
 391                         else b = -b;
 392         }
 393         else if (mode != LED_PROBE) {
 394                 mode = !mode;
 395         }
 396
 397 SET:
 398         if (b < 16) {
 399                 if (mode != LED_PROBE) {
 400                         gpio_write(1 << b, mode);
 401
 402                         if (c < 0) {
 403                                 if (c == -99) c = 0;
 404                                 else c = -c;
 405                         }
 406                         else mode = !mode;
 407                         if (c < 16) gpio_write(1 << c, mode);
 408                 }
 409         }
 410
 411         return ret;
 412 }