qemu/roms/openbios/drivers/cuda.c

   1 #include "config.h"
   2 #include "libopenbios/bindings.h"
   3 #include "drivers/drivers.h"
   4 #include "libc/byteorder.h"
   5 #include "libc/vsprintf.h"
   6
   7 #include "macio.h"
   8 #include "cuda.h"
   9
  10 //#define DEBUG_CUDA
  11 #ifdef DEBUG_CUDA
  12 #define CUDA_DPRINTF(fmt, args...) \
  13         do { printk("CUDA - %s: " fmt, __func__ , ##args); } while (0)
  14 #else
  15 #define CUDA_DPRINTF(fmt, args...) do { } while (0)
  16 #endif
  17
  18 #define IO_CUDA_OFFSET  0x00016000
  19 #define IO_CUDA_SIZE    0x00002000
  20
  21 /* VIA registers - spaced 0x200 bytes apart */
  22 #define RS              0x200           /* skip between registers */
  23 #define B               0               /* B-side data */
  24 #define A               RS              /* A-side data */
  25 #define DIRB            (2*RS)          /* B-side direction (1=output) */
  26 #define DIRA            (3*RS)          /* A-side direction (1=output) */
  27 #define T1CL            (4*RS)          /* Timer 1 ctr/latch (low 8 bits) */
  28 #define T1CH            (5*RS)          /* Timer 1 counter (high 8 bits) */
  29 #define T1LL            (6*RS)          /* Timer 1 latch (low 8 bits) */
  30 #define T1LH            (7*RS)          /* Timer 1 latch (high 8 bits) */
  31 #define T2CL            (8*RS)          /* Timer 2 ctr/latch (low 8 bits) */
  32 #define T2CH            (9*RS)          /* Timer 2 counter (high 8 bits) */
  33 #define SR              (10*RS)         /* Shift register */
  34 #define ACR             (11*RS)         /* Auxiliary control register */
  35 #define PCR             (12*RS)         /* Peripheral control register */
  36 #define IFR             (13*RS)         /* Interrupt flag register */
  37 #define IER             (14*RS)         /* Interrupt enable register */
  38 #define ANH             (15*RS)         /* A-side data, no handshake */
  39
  40 /* Bits in B data register: all active low */
  41 #define TREQ            0x08            /* Transfer request (input) */
  42 #define TACK            0x10            /* Transfer acknowledge (output) */
  43 #define TIP             0x20            /* Transfer in progress (output) */
  44
  45 /* Bits in ACR */
  46 #define SR_CTRL         0x1c            /* Shift register control bits */
  47 #define SR_EXT          0x0c            /* Shift on external clock */
  48 #define SR_OUT          0x10            /* Shift out if 1 */
  49
  50 /* Bits in IFR and IER */
  51 #define IER_SET         0x80            /* set bits in IER */
  52 #define IER_CLR         0               /* clear bits in IER */
  53 #define SR_INT          0x04            /* Shift register full/empty */
  54
  55 #define CUDA_BUF_SIZE 16
  56
  57 #define ADB_PACKET      0
  58 #define CUDA_PACKET     1
  59
  60 /* CUDA commands (2nd byte) */
  61 #define CUDA_GET_TIME                   0x03
  62 #define CUDA_SET_TIME                   0x09
  63 #define CUDA_POWERDOWN                  0x0a
  64 #define CUDA_RESET_SYSTEM               0x11
  65
  66 static uint8_t cuda_readb (cuda_t *dev, int reg)
  67 {
  68             return *(volatile uint8_t *)(dev->base + reg);
  69 }
  70
  71 static void cuda_writeb (cuda_t *dev, int reg, uint8_t val)
  72 {
  73             *(volatile uint8_t *)(dev->base + reg) = val;
  74 }
  75
  76 static void cuda_wait_irq (cuda_t *dev)
  77 {
  78     int val;
  79
  80 //    CUDA_DPRINTF("\n");
  81     for(;;) {
  82         val = cuda_readb(dev, IFR);
  83         cuda_writeb(dev, IFR, val & 0x7f);
  84         if (val & SR_INT)
  85             break;
  86     }
  87 }
  88
  89
  90
  91 static int cuda_request (cuda_t *dev, uint8_t pkt_type, const uint8_t *buf,
  92                          int buf_len, uint8_t *obuf)
  93 {
  94     int i, obuf_len, val;
  95
  96     cuda_writeb(dev, ACR, cuda_readb(dev, ACR) | SR_OUT);
  97     cuda_writeb(dev, SR, pkt_type);
  98     cuda_writeb(dev, B, cuda_readb(dev, B) & ~TIP);
  99     if (buf) {
 100         //CUDA_DPRINTF("Send buf len: %d\n", buf_len);
 101         /* send 'buf' */
 102         for(i = 0; i < buf_len; i++) {
 103             cuda_wait_irq(dev);
 104             cuda_writeb(dev, SR, buf[i]);
 105             cuda_writeb(dev, B, cuda_readb(dev, B) ^ TACK);
 106         }
 107     }
 108     cuda_wait_irq(dev);
 109     cuda_writeb(dev, ACR, cuda_readb(dev, ACR) & ~SR_OUT);
 110     cuda_readb(dev, SR);
 111     cuda_writeb(dev, B, cuda_readb(dev, B) | TIP | TACK);
 112
 113     obuf_len = 0;
 114     if (obuf) {
 115         cuda_wait_irq(dev);
 116         cuda_readb(dev, SR);
 117         cuda_writeb(dev, B, cuda_readb(dev, B) & ~TIP);
 118         for(;;) {
 119             cuda_wait_irq(dev);
 120             val = cuda_readb(dev, SR);
 121             if (obuf_len < CUDA_BUF_SIZE)
 122                 obuf[obuf_len++] = val;
 123             if (cuda_readb(dev, B) & TREQ)
 124                 break;
 125             cuda_writeb(dev, B, cuda_readb(dev, B) ^ TACK);
 126         }
 127         cuda_writeb(dev, B, cuda_readb(dev, B) | TIP | TACK);
 128
 129         cuda_wait_irq(dev);
 130         cuda_readb(dev, SR);
 131     }
 132 //    CUDA_DPRINTF("Got len: %d\n", obuf_len);
 133
 134     return obuf_len;
 135 }
 136
 137
 138
 139 static int cuda_adb_req (void *host, const uint8_t *snd_buf, int len,
 140                          uint8_t *rcv_buf)
 141 {
 142     uint8_t buffer[CUDA_BUF_SIZE], *pos;
 143
 144  //   CUDA_DPRINTF("len: %d %02x\n", len, snd_buf[0]);
 145     len = cuda_request(host, ADB_PACKET, snd_buf, len, buffer);
 146     if (len > 1 && buffer[0] == ADB_PACKET) {
 147         /* We handle 2 types of ADB packet here:
 148                Normal: <type> <status> <data> ...
 149                Error : <type> <status> <cmd> (<data> ...)
 150            Ideally we should use buffer[1] (status) to determine whether this
 151            is a normal or error packet but this requires a corresponding fix
 152            in QEMU <= 2.4. Hence we temporarily handle it this way to ease
 153            the transition. */
 154         if (len > 2 && buffer[2] == snd_buf[0]) {
 155             /* Error */
 156             pos = buffer + 3;
 157             len -= 3;
 158         } else {
 159             /* Normal */
 160             pos = buffer + 2;
 161             len -= 2;
 162         }
 163     } else {
 164         pos = buffer + 1;
 165         len = -1;
 166     }
 167     memcpy(rcv_buf, pos, len);
 168
 169     return len;
 170 }
 171
 172
 173 DECLARE_UNNAMED_NODE(ob_cuda, INSTALL_OPEN, sizeof(int));
 174
 175 static cuda_t *main_cuda;
 176
 177 static void
 178 ppc32_reset_all(void)
 179 {
 180         uint8_t cmdbuf[2], obuf[64];
 181
 182         cmdbuf[0] = CUDA_RESET_SYSTEM;
 183         cuda_request(main_cuda, CUDA_PACKET, cmdbuf, sizeof(cmdbuf), obuf);
 184 }
 185
 186 static void
 187 ppc32_poweroff(void)
 188 {
 189         uint8_t cmdbuf[2], obuf[64];
 190
 191         cmdbuf[0] = CUDA_POWERDOWN;
 192         cuda_request(main_cuda, CUDA_PACKET, cmdbuf, sizeof(cmdbuf), obuf);
 193 }
 194
 195 static void
 196 ob_cuda_initialize (int *idx)
 197 {
 198         phandle_t ph=get_cur_dev();
 199         int props[2];
 200
 201         push_str("via-cuda");
 202         fword("device-type");
 203
 204         set_int_property(ph, "#address-cells", 1);
 205         set_int_property(ph, "#size-cells", 0);
 206
 207         set_property(ph, "compatible", "cuda", 5);
 208
 209         props[0] = __cpu_to_be32(IO_CUDA_OFFSET);
 210         props[1] = __cpu_to_be32(IO_CUDA_SIZE);
 211
 212         set_property(ph, "reg", (char *)&props, sizeof(props));
 213
 214         /* on newworld machines the cuda is on interrupt 0x19 */
 215
 216         props[0] = 0x19;
 217         props[1] = 0;
 218         NEWWORLD(set_property(ph, "interrupts", (char *)props, sizeof(props)));
 219         NEWWORLD(set_int_property(ph, "#interrupt-cells", 2));
 220
 221         /* we emulate an oldworld hardware, so we must use
 222          * non-standard oldworld property (needed by linux 2.6.18)
 223          */
 224
 225         OLDWORLD(set_int_property(ph, "AAPL,interrupts", 0x12));
 226
 227         bind_func("ppc32-reset-all", ppc32_reset_all);
 228         push_str("' ppc32-reset-all to reset-all");
 229         fword("eval");
 230 }
 231
 232 static void
 233 ob_cuda_open(int *idx)
 234 {
 235         RET(-1);
 236 }
 237
 238 static void
 239 ob_cuda_close(int *idx)
 240 {
 241 }
 242
 243 NODE_METHODS(ob_cuda) = {
 244         { NULL,                 ob_cuda_initialize      },
 245         { "open",               ob_cuda_open            },
 246         { "close",              ob_cuda_close           },
 247 };
 248
 249 DECLARE_UNNAMED_NODE(rtc, INSTALL_OPEN, sizeof(int));
 250
 251 static void
 252 rtc_open(int *idx)
 253 {
 254         RET(-1);
 255 }
 256
 257 /*
 258  * get-time ( -- second minute hour day month year )
 259  *
 260  */
 261
 262 static const int days_month[12] =
 263         { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
 264 static const int days_month_leap[12] =
 265         { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
 266
 267 static inline int is_leap(int year)
 268 {
 269         return ((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0);
 270 }
 271
 272 static  void
 273 rtc_get_time(int *idx)
 274 {
 275         uint8_t cmdbuf[2], obuf[64];
 276         ucell second, minute, hour, day, month, year;
 277         uint32_t now;
 278         int current;
 279         const int *days;
 280
 281         cmdbuf[0] = CUDA_GET_TIME;
 282         cuda_request(main_cuda, CUDA_PACKET, cmdbuf, sizeof(cmdbuf), obuf);
 283
 284         /* seconds since 01/01/1904 */
 285
 286         now = (obuf[3] << 24) + (obuf[4] << 16) + (obuf[5] << 8) + obuf[6];
 287
 288         second =  now % 60;
 289         now /= 60;
 290
 291         minute = now % 60;
 292         now /= 60;
 293
 294         hour = now % 24;
 295         now /= 24;
 296
 297         year = now * 100 / 36525;
 298         now -= year * 36525 / 100;
 299         year += 1904;
 300
 301         days = is_leap(year) ?  days_month_leap : days_month;
 302
 303         current = 0;
 304         month = 0;
 305         while (month < 12) {
 306                 if (now <= current + days[month]) {
 307                         break;
 308                 }
 309                 current += days[month];
 310                 month++;
 311         }
 312         month++;
 313
 314         day = now - current;
 315
 316         PUSH(second);
 317         PUSH(minute);
 318         PUSH(hour);
 319         PUSH(day);
 320         PUSH(month);
 321         PUSH(year);
 322 }
 323
 324 /*
 325  * set-time ( second minute hour day month year -- )
 326  *
 327  */
 328
 329 static  void
 330 rtc_set_time(int *idx)
 331 {
 332         uint8_t cmdbuf[5], obuf[3];
 333         ucell second, minute, hour, day, month, year;
 334         const int *days;
 335         uint32_t now;
 336         unsigned int nb_days;
 337         int i;
 338
 339         year = POP();
 340         month = POP();
 341         day = POP();
 342         hour = POP();
 343         minute = POP();
 344         second = POP();
 345
 346         days = is_leap(year) ?  days_month_leap : days_month;
 347         nb_days = (year - 1904) * 36525 / 100 + day;
 348         for (i = 0; i < month - 1; i++)
 349                 nb_days += days[i];
 350
 351         now = (((nb_days * 24) + hour) * 60 + minute) * 60 + second;
 352
 353         cmdbuf[0] = CUDA_SET_TIME;
 354         cmdbuf[1] = now >> 24;
 355         cmdbuf[2] = now >> 16;
 356         cmdbuf[3] = now >> 8;
 357         cmdbuf[4] = now;
 358
 359         cuda_request(main_cuda, CUDA_PACKET, cmdbuf, sizeof(cmdbuf), obuf);
 360 }
 361
 362 NODE_METHODS(rtc) = {
 363         { "open",               rtc_open                },
 364         { "get-time",           rtc_get_time            },
 365         { "set-time",           rtc_set_time            },
 366 };
 367
 368 static void
 369 rtc_init(char *path)
 370 {
 371         phandle_t ph, aliases;
 372         char buf[64];
 373
 374         snprintf(buf, sizeof(buf), "%s/rtc", path);
 375         REGISTER_NAMED_NODE(rtc, buf);
 376
 377         ph = find_dev(buf);
 378         set_property(ph, "device_type", "rtc", 4);
 379         set_property(ph, "compatible", "rtc", 4);
 380
 381         aliases = find_dev("/aliases");
 382         set_property(aliases, "rtc", buf, strlen(buf) + 1);
 383
 384 }
 385
 386 static void
 387 powermgt_init(char *path)
 388 {
 389         phandle_t ph;
 390         char buf[64];
 391
 392         snprintf(buf, sizeof(buf), "%s/power-mgt", path);
 393         REGISTER_NAMED_NODE(rtc, buf);
 394
 395         ph = find_dev(buf);
 396         set_property(ph, "device_type", "power-mgt", 10);
 397         set_property(ph, "mgt-kind", "min-consumption-pwm-led", strlen("min-consumption-pwm-led") + 1);
 398         set_property(ph, "compatible", "cuda", strlen("cuda") + 1);
 399 }
 400
 401 cuda_t *cuda_init (const char *path, phys_addr_t base)
 402 {
 403         cuda_t *cuda;
 404         char buf[64];
 405         phandle_t aliases;
 406
 407         base += IO_CUDA_OFFSET;
 408         CUDA_DPRINTF(" base=" FMT_plx "\n", base);
 409         cuda = malloc(sizeof(cuda_t));
 410         if (cuda == NULL)
 411             return NULL;
 412
 413         snprintf(buf, sizeof(buf), "%s/via-cuda", path);
 414         REGISTER_NAMED_NODE(ob_cuda, buf);
 415
 416         aliases = find_dev("/aliases");
 417         set_property(aliases, "via-cuda", buf, strlen(buf) + 1);
 418
 419         cuda->base = base;
 420         cuda_writeb(cuda, B, cuda_readb(cuda, B) | TREQ | TIP);
 421 #ifdef CONFIG_DRIVER_ADB
 422         cuda->adb_bus = adb_bus_new(cuda, &cuda_adb_req);
 423         if (cuda->adb_bus == NULL) {
 424             free(cuda);
 425             return NULL;
 426         }
 427         adb_bus_init(buf, cuda->adb_bus);
 428 #endif
 429
 430         rtc_init(buf);
 431         powermgt_init(buf);
 432
 433         main_cuda = cuda;
 434
 435         device_end();
 436         bind_func("poweroff", ppc32_poweroff);
 437
 438         return cuda;
 439 }