firmware/drivers/isp1583.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2006 by Tomasz Malesinski
  11  * Copyright (C) 2008 by Maurus Cuelenaere
  12  *
  13  * This program is free software; you can redistribute it and/or
  14  * modify it under the terms of the GNU General Public License
  15  * as published by the Free Software Foundation; either version 2
  16  * of the License, or (at your option) any later version.
  17  *
  18  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  19  * KIND, either express or implied.
  20  *
  21  ****************************************************************************/
  22
  23 #include "config.h"
  24 #include "usb_ch9.h"
  25 #include "usb_drv.h"
  26 #include "usb_core.h"
  27 #include "isp1583.h"
  28 #include "thread.h"
  29 #include "logf.h"
  30 #include <stdio.h>
  31
  32 #define DIR_RX                      0
  33 #define DIR_TX                      1
  34
  35 struct usb_endpoint
  36 {
  37     unsigned char *out_buf;
  38     short out_len;
  39     short out_ptr;
  40     void (*out_done)(int, unsigned char *, int);
  41     unsigned char out_in_progress;
  42
  43     unsigned char *in_buf;
  44     short in_min_len;
  45     short in_max_len;
  46     short in_ptr;
  47     void (*in_done)(int, unsigned char *, int);
  48     unsigned char in_ack;
  49
  50     unsigned char halt[2];
  51     unsigned char enabled[2];
  52     short max_pkt_size[2];
  53     short type;
  54     char allocation;
  55 };
  56
  57 static unsigned char setup_pkt_buf[8];
  58 static struct usb_endpoint endpoints[USB_NUM_ENDPOINTS];
  59
  60 static bool high_speed_mode = false;
  61
  62 static inline void or_int_value(volatile unsigned short *a, volatile unsigned short *b, unsigned long r, unsigned long value)
  63 {
  64     set_int_value(*a, *b, (r | value));
  65 }
  66 static inline void bc_int_value(volatile unsigned short *a, volatile unsigned short *b, unsigned long r, unsigned long value)
  67 {
  68     set_int_value(*a, *b, (r & ~value));
  69 }
  70
  71 static inline void nop_f(void)
  72 {
  73     yield();
  74 }
  75
  76 #define NOP     asm volatile("nop\n");
  77
  78 static inline int ep_index(int n, bool dir)
  79 {
  80     return (n << 1) | dir;
  81 }
  82
  83 static inline bool epidx_dir(int idx)
  84 {
  85     return idx & 1;
  86 }
  87
  88 static inline int epidx_n(int idx)
  89 {
  90     return idx >> 1;
  91 }
  92
  93 static inline void usb_select_endpoint(int idx)
  94 {
  95     /* Select the endpoint */
  96     ISP1583_DFLOW_EPINDEX = idx;
  97     /* The delay time from the Write Endpoint Index register to the Read Data Port register must be at least 190 ns.
  98     * The delay time from the Write Endpoint Index register to the Write Data Port register must be at least 100 ns.
  99     */
 100     NOP;
 101 }
 102
 103 static inline void usb_select_setup_endpoint(void)
 104 {
 105     /* Select the endpoint */
 106     ISP1583_DFLOW_EPINDEX = DFLOW_EPINDEX_EP0SETUP;
 107     /* The delay time from the Write Endpoint Index register to the Read Data Port register must be at least 190 ns.
 108     * The delay time from the Write Endpoint Index register to the Write Data Port register must be at least 100 ns.
 109     */
 110     NOP;
 111 }
 112
 113 static void usb_setup_endpoint(int idx, int max_pkt_size, int type)
 114 {
 115     if(epidx_n(idx)!=0)
 116     {
 117         usb_select_endpoint(idx);
 118         ISP1583_DFLOW_MAXPKSZ = max_pkt_size & 0x7FF;
 119         ISP1583_DFLOW_EPTYPE = (DFLOW_EPTYPE_NOEMPKT | DFLOW_EPTYPE_DBLBUF | (type & 0x3));
 120
 121         /* clear buffer ... */
 122         ISP1583_DFLOW_CTRLFUN |= DFLOW_CTRLFUN_CLBUF;
 123         /* ... twice because of double buffering */
 124         usb_select_endpoint(idx);
 125         ISP1583_DFLOW_CTRLFUN |= DFLOW_CTRLFUN_CLBUF;
 126     }
 127
 128     struct usb_endpoint *ep;
 129     ep = &(endpoints[epidx_n(idx)]);
 130     ep->halt[epidx_dir(idx)] = 0;
 131     ep->enabled[epidx_dir(idx)] = 0;
 132     ep->out_in_progress = 0;
 133     ep->in_min_len = -1;
 134     ep->in_ack = 0;
 135     ep->type = type;
 136     ep->max_pkt_size[epidx_dir(idx)] = max_pkt_size;
 137 }
 138
 139 static void usb_enable_endpoint(int idx)
 140 {
 141     if(epidx_n(idx)!=0)
 142     {
 143         usb_select_endpoint(idx);
 144         /* Enable interrupt */
 145         or_int_value(&ISP1583_INIT_INTEN_A, &ISP1583_INIT_INTEN_B, ISP1583_INIT_INTEN_READ, 1 << (10 + idx));
 146         /* Enable endpoint */
 147         ISP1583_DFLOW_EPTYPE |= DFLOW_EPTYPE_ENABLE;
 148     }
 149
 150     endpoints[epidx_n(idx)].enabled[epidx_dir(idx)] = 1;
 151 }
 152 /*
 153 static void usb_disable_endpoint(int idx, bool set_struct)
 154 {
 155     usb_select_endpoint(idx);
 156     ISP1583_DFLOW_EPTYPE &= ~DFLOW_EPTYPE_ENABLE;
 157     bc_int_value(&ISP1583_INIT_INTEN_A, &ISP1583_INIT_INTEN_B, ISP1583_INIT_INTEN_READ, 1 << (10 + idx));
 158
 159     if(set_struct)
 160         endpoints[epidx_n(idx)].enabled[epidx_dir(idx)] = 0;
 161 }
 162 */
 163 static int usb_get_packet(unsigned char *buf, int max_len)
 164 {
 165     int len, i;
 166     len = ISP1583_DFLOW_BUFLEN;
 167
 168     if (max_len < 0 || max_len > len)
 169         max_len = len;
 170
 171     i = 0;
 172     while (i < len)
 173     {
 174         unsigned short d = ISP1583_DFLOW_DATA;
 175         if (i < max_len)
 176             buf[i] = d & 0xff;
 177         i++;
 178         if (i < max_len)
 179             buf[i] = (d >> 8) & 0xff;
 180         i++;
 181     }
 182     return max_len;
 183 }
 184
 185 static int usb_receive(int n)
 186 {
 187     logf("usb_receive(%d)", n);
 188     int len;
 189
 190     if (endpoints[n].halt[DIR_RX]
 191         || !endpoints[n].enabled[DIR_RX]
 192         || endpoints[n].in_min_len < 0
 193         || !endpoints[n].in_ack)
 194         return -1;
 195
 196     endpoints[n].in_ack = 0;
 197
 198     usb_select_endpoint(ep_index(n, DIR_RX));
 199
 200     len = usb_get_packet(endpoints[n].in_buf + endpoints[n].in_ptr,
 201                          endpoints[n].in_max_len - endpoints[n].in_ptr);
 202     endpoints[n].in_ptr += len;
 203     if (endpoints[n].in_ptr >= endpoints[n].in_min_len) {
 204         endpoints[n].in_min_len = -1;
 205         if (endpoints[n].in_done)
 206             (*(endpoints[n].in_done))(n, endpoints[n].in_buf,
 207                                       endpoints[n].in_ptr);
 208     }
 209     logf("receive_end");
 210     return 0;
 211 }
 212
 213 static bool usb_out_buffer_full(int ep)
 214 {
 215     usb_select_endpoint(ep_index(ep, DIR_TX));
 216     if (ISP1583_DFLOW_EPTYPE & 4)   /* Check if type=bulk and double buffering is set */
 217         return (ISP1583_DFLOW_BUFSTAT & 3) == 3; /* Return true if both buffers are filled */
 218     else
 219         return (ISP1583_DFLOW_BUFSTAT & 3) != 0; /* Return true if one of the buffers are filled */
 220 }
 221
 222 static int usb_send(int n)
 223 {
 224     logf("usb_send(%d)", n);
 225     int max_pkt_size, len;
 226     int i;
 227     unsigned char *p;
 228
 229     if (endpoints[n].halt[DIR_TX]
 230         || !endpoints[n].enabled[DIR_TX]
 231         || !endpoints[n].out_in_progress)
 232         {
 233         logf("NOT SEND TO EP!");
 234         return -1;
 235         }
 236
 237     if (endpoints[n].out_ptr < 0)
 238     {
 239         endpoints[n].out_in_progress = 0;
 240         if (endpoints[n].out_done)
 241             (*(endpoints[n].out_done))(n, endpoints[n].out_buf,
 242                                        endpoints[n].out_len);
 243         logf("ALREADY SENT TO EP!");
 244         return -1;
 245     }
 246
 247     if (usb_out_buffer_full(n))
 248     {
 249     logf("BUFFER FULL!");
 250         return -1;
 251         }
 252
 253     usb_select_endpoint(ep_index(n, DIR_TX));
 254     max_pkt_size = endpoints[n].max_pkt_size[DIR_TX];
 255     len = endpoints[n].out_len - endpoints[n].out_ptr;
 256     if (len > max_pkt_size)
 257         len = max_pkt_size;
 258
 259     if(len < max_pkt_size)
 260         ISP1583_DFLOW_BUFLEN = len;
 261
 262     p = endpoints[n].out_buf + endpoints[n].out_ptr;
 263     i = 0;
 264     while (len - i >= 2) {
 265         ISP1583_DFLOW_DATA = p[i] | (p[i + 1] << 8);
 266         i += 2;
 267     }
 268     if (i < len)
 269         ISP1583_DFLOW_DATA = p[i];
 270
 271     endpoints[n].out_ptr += len;
 272
 273 /*
 274     if (endpoints[n].out_ptr == endpoints[n].out_len
 275         && len < max_pkt_size)
 276 */
 277     if (endpoints[n].out_ptr == endpoints[n].out_len)
 278         endpoints[n].out_ptr = -1;
 279
 280     logf("send_end");
 281     return 0;
 282 }
 283
 284 static void usb_stall_endpoint(int idx)
 285 {
 286     usb_select_endpoint(idx);
 287     ISP1583_DFLOW_CTRLFUN |= DFLOW_CTRLFUN_STALL;
 288     endpoints[epidx_n(idx)].halt[epidx_dir(idx)] = 1;
 289 }
 290
 291 static void usb_unstall_endpoint(int idx)
 292 {
 293     usb_select_endpoint(idx);
 294     ISP1583_DFLOW_CTRLFUN &= ~DFLOW_CTRLFUN_STALL;
 295     ISP1583_DFLOW_EPTYPE &= ~DFLOW_EPTYPE_ENABLE;
 296     ISP1583_DFLOW_EPTYPE |= DFLOW_EPTYPE_ENABLE;
 297     ISP1583_DFLOW_CTRLFUN |= DFLOW_CTRLFUN_CLBUF;
 298     if (epidx_dir(idx) == DIR_TX)
 299         endpoints[epidx_n(idx)].out_in_progress = 0;
 300     else
 301     {
 302         endpoints[epidx_n(idx)].in_min_len = -1;
 303         endpoints[epidx_n(idx)].in_ack = 0;
 304     }
 305     endpoints[epidx_n(idx)].halt[epidx_dir(idx)] = 0;
 306 }
 307
 308 static void usb_status_ack(int ep, int dir)
 309 {
 310     logf("usb_status_ack(%d)", dir);
 311     usb_select_endpoint(ep_index(ep, dir));
 312     ISP1583_DFLOW_CTRLFUN |= DFLOW_CTRLFUN_STATUS;
 313 }
 314
 315 static void usb_data_stage_enable(int ep, int dir)
 316 {
 317     logf("usb_data_stage_enable(%d)", dir);
 318     usb_select_endpoint(ep_index(ep, dir));
 319     ISP1583_DFLOW_CTRLFUN |= DFLOW_CTRLFUN_DSEN;
 320 }
 321
 322 static void usb_handle_setup_rx(void)
 323 {
 324     int len;
 325     usb_select_setup_endpoint();
 326     len = usb_get_packet(setup_pkt_buf, 8);
 327
 328     if (len == 8)
 329         usb_core_control_request((struct usb_ctrlrequest*)setup_pkt_buf);
 330     else
 331     {
 332         usb_drv_stall(0, true, false);
 333         usb_drv_stall(0, true, true);
 334         logf("usb_handle_setup_rx() failed");
 335         return;
 336     }
 337
 338     logf("usb_handle_setup_rx(): %02x %02x %02x %02x %02x %02x %02x %02x", setup_pkt_buf[0], setup_pkt_buf[1], setup_pkt_buf[2], setup_pkt_buf[3], setup_pkt_buf[4], setup_pkt_buf[5], setup_pkt_buf[6], setup_pkt_buf[7]);
 339 }
 340
 341 static void usb_handle_data_int(int ep, int dir)
 342 {
 343     int len;
 344     if (dir == DIR_TX)
 345         len = usb_send(ep);
 346     else
 347     {
 348         len = usb_receive(ep);
 349         endpoints[ep].in_ack = 1;
 350     }
 351     logf("usb_handle_data_int(%d, %d) finished", ep, dir);
 352 }
 353
 354 bool usb_drv_powered(void)
 355 {
 356 #if 0
 357     return (ISP1583_INIT_OTG & INIT_OTG_BSESS_VALID) ? true : false;
 358 #else
 359     return (ISP1583_INIT_MODE & INIT_MODE_VBUSSTAT) ? true : false;
 360 #endif
 361 }
 362
 363 static void setup_endpoints(void)
 364 {
 365     usb_setup_endpoint(ep_index(0, DIR_RX), 64, 0);
 366     usb_setup_endpoint(ep_index(0, DIR_TX), 64, 0);
 367
 368     int i;
 369     for(i = 1; i < USB_NUM_ENDPOINTS-1; i++)
 370     {
 371         usb_setup_endpoint(ep_index(i, DIR_RX), (high_speed_mode ? 512 : 64), 2); /* 2 = TYPE_BULK */
 372         usb_setup_endpoint(ep_index(i, DIR_TX), (high_speed_mode ? 512 : 64), 2);
 373     }
 374
 375     usb_enable_endpoint(ep_index(0, DIR_RX));
 376     usb_enable_endpoint(ep_index(0, DIR_TX));
 377
 378     for (i = 1; i < USB_NUM_ENDPOINTS-1; i++)
 379     {
 380         usb_enable_endpoint(ep_index(i, DIR_RX));
 381         usb_enable_endpoint(ep_index(i, DIR_TX));
 382     }
 383
 384     ZVM_SPECIFIC;
 385 }
 386
 387 void usb_helper(void)
 388 {
 389     if(ISP1583_GEN_INT_READ & ISP1583_INIT_INTEN_READ)
 390     {
 391     #ifdef DEBUG
 392         logf("Helper detected interrupt... [%d]", current_tick);
 393     #endif
 394         usb_drv_int();
 395     }
 396     return;
 397 }
 398
 399 void usb_drv_init(void)
 400 {
 401     /* Disable interrupt at CPU level */
 402     DIS_INT_CPU_TARGET;
 403
 404     /* Unlock the device's registers */
 405     ISP1583_GEN_UNLCKDEV = ISP1583_UNLOCK_CODE;
 406
 407     /* Soft reset the device */
 408     ISP1583_INIT_MODE = INIT_MODE_SFRESET;
 409     sleep(10);
 410     /* Enable CLKAON & GLINTENA */
 411     ISP1583_INIT_MODE = STANDARD_INIT_MODE;
 412
 413     /* Disable all OTG functions */
 414     ISP1583_INIT_OTG = 0;
 415
 416 #if 0
 417     #ifdef USE_HIGH_SPEED
 418     /* Force device to high speed */
 419     ISP1583_GEN_TSTMOD = GEN_TSTMOD_FORCEHS;
 420     high_speed_mode = true;
 421     #endif
 422 #endif
 423
 424     #ifdef DEBUG
 425     logf("BUS_CONF/DA0:%d MODE0/DA1: %d MODE1: %d", (bool)(ISP1583_INIT_MODE & INIT_MODE_TEST0), (bool)(ISP1583_INIT_MODE & INIT_MODE_TEST1), (bool)(ISP1583_INIT_MODE & INIT_MODE_TEST2));
 426     logf("Chip ID: 0x%x", ISP1583_GEN_CHIPID);
 427     //logf("INV0: 0x% IRQEDGE: 0x%x IRQPORT: 0x%x", IO_GIO_INV0, IO_GIO_IRQEDGE, IO_GIO_IRQPORT);
 428     #endif
 429
 430     /*Set interrupt generation to target-specific mode +
 431     * Set the control pipe to ACK only interrupt +
 432     * Set the IN pipe to ACK only interrupt +
 433     * Set OUT pipe to ACK and NYET interrupt
 434     */
 435
 436     ISP1583_INIT_INTCONF = 0x54 | INT_CONF_TARGET;
 437     /* Clear all interrupts */
 438     set_int_value(ISP1583_GEN_INT_A, ISP1583_GEN_INT_B, 0xFFFFFFFF);
 439     /* Enable USB interrupts */
 440     set_int_value(ISP1583_INIT_INTEN_A, ISP1583_INIT_INTEN_B, STANDARD_INTEN);
 441
 442     ZVM_SPECIFIC;
 443
 444     /* Enable interrupt at CPU level */
 445     EN_INT_CPU_TARGET;
 446
 447     setup_endpoints();
 448
 449     /* Clear device address and disable it */
 450     ISP1583_INIT_ADDRESS = 0;
 451
 452     /* Turn SoftConnect on */
 453     ISP1583_INIT_MODE |= INIT_MODE_SOFTCT;
 454
 455     ZVM_SPECIFIC;
 456
 457     tick_add_task(usb_helper);
 458
 459     logf("usb_init_device() finished");
 460 }
 461
 462 int usb_drv_port_speed(void)
 463 {
 464     return (int)high_speed_mode;
 465 }
 466
 467 void usb_drv_exit(void)
 468 {
 469     logf("usb_drv_exit()");
 470
 471     /* Disable device */
 472     ISP1583_INIT_MODE &= ~INIT_MODE_SOFTCT;
 473     ISP1583_INIT_ADDRESS = 0;
 474
 475     /* Disable interrupts */
 476     set_int_value(ISP1583_INIT_INTEN_A, ISP1583_INIT_INTEN_B, 0);
 477     /* and the CPU's one... */
 478     DIS_INT_CPU_TARGET;
 479
 480
 481     /* Send usb controller to suspend mode */
 482     ISP1583_INIT_MODE = INIT_MODE_GOSUSP;
 483     ISP1583_INIT_MODE = 0;
 484
 485     tick_remove_task(usb_helper);
 486
 487     ZVM_SPECIFIC;
 488 }
 489
 490 void usb_drv_stall(int endpoint, bool stall, bool in)
 491 {
 492     logf("%sstall EP%d %s", (stall ? "" : "un"), endpoint, (in ? "RX" : "TX" ));
 493     if (stall)
 494         usb_stall_endpoint(ep_index(endpoint, (int)in));
 495     else
 496         usb_unstall_endpoint(ep_index(endpoint, (int)in));
 497 }
 498
 499 bool usb_drv_stalled(int endpoint, bool in)
 500 {
 501     return (endpoints[endpoint].halt[(int)in] == 1);
 502 }
 503
 504 static void out_callback(int ep, unsigned char *buf, int len)
 505 {
 506     (void)buf;
 507     logf("out_callback(%d, 0x%x, %d)", ep, &buf, len);
 508     usb_status_ack(ep, DIR_RX);
 509     usb_core_transfer_complete(ep, true, 0, len); /* 0=>status succeeded, haven't worked out status failed yet... */
 510 }
 511
 512 static void in_callback(int ep, unsigned char *buf, int len)
 513 {
 514     (void)buf;
 515     logf("in_callback(%d, 0x%x, %d)", ep, &buf, len);
 516     usb_status_ack(ep, DIR_TX);
 517     usb_core_transfer_complete(ep, false, 0, len);
 518 }
 519
 520 int usb_drv_recv(int ep, void* ptr, int length)
 521 {
 522     logf("usb_drv_recv(%d, 0x%x, %d)", ep, &ptr, length);
 523     if(ep == 0 && length == 0 && ptr == NULL)
 524     {
 525         usb_status_ack(ep, DIR_TX);
 526         return 0;
 527     }
 528     endpoints[ep].in_done = in_callback;
 529     endpoints[ep].in_buf = ptr;
 530     endpoints[ep].in_max_len = length;
 531     endpoints[ep].in_min_len = length;
 532     endpoints[ep].in_ptr = 0;
 533     if(ep == 0)
 534     {
 535         usb_data_stage_enable(ep, DIR_RX);
 536         return usb_receive(ep);
 537     }
 538     else
 539         return usb_receive(ep);
 540 }
 541
 542 int usb_drv_send_nonblocking(int ep, void* ptr, int length)
 543 {
 544     /* First implement DMA... */
 545     return usb_drv_send(ep, ptr, length);
 546 }
 547
 548 static void usb_drv_wait(int ep, bool send)
 549 {
 550     logf("usb_drv_wait(%d, %d)", ep, send);
 551     if(send)
 552     {
 553         while (endpoints[ep].out_in_progress)
 554             nop_f();
 555     }
 556     else
 557     {
 558         while (endpoints[ep].in_ack)
 559             nop_f();
 560     }
 561 }
 562
 563 int usb_drv_send(int ep, void* ptr, int length)
 564 {
 565     logf("usb_drv_send_nb(%d, 0x%x, %d)", ep, &ptr, length);
 566     if(ep == 0 && length == 0 && ptr == NULL)
 567     {
 568         usb_status_ack(ep, DIR_RX);
 569         return 0;
 570     }
 571     if(endpoints[ep].out_in_progress == 1)
 572         return -1;
 573     endpoints[ep].out_done = out_callback;
 574     endpoints[ep].out_buf = ptr;
 575     endpoints[ep].out_len = length;
 576     endpoints[ep].out_ptr = 0;
 577     endpoints[ep].out_in_progress = 1;
 578     if(ep == 0)
 579     {
 580         int rc = usb_send(ep);
 581         usb_data_stage_enable(ep, DIR_TX);
 582         usb_drv_wait(ep, DIR_TX);
 583         return rc;
 584     }
 585     else
 586         return usb_send(ep);
 587 }
 588
 589 void usb_drv_reset_endpoint(int ep, bool send)
 590 {
 591     logf("reset endpoint(%d, %d)", ep, send);
 592     usb_setup_endpoint(ep_index(ep, (int)send), endpoints[ep].max_pkt_size[(int)send], endpoints[ep].type);
 593     usb_enable_endpoint(ep_index(ep, (int)send));
 594 }
 595
 596 void usb_drv_cancel_all_transfers(void)
 597 {
 598     logf("usb_drv_cancel_all_tranfers()");
 599     int i;
 600
 601     for(i=0;i<USB_NUM_ENDPOINTS-1;i++)
 602         endpoints[i].halt[0] = endpoints[i].halt[1] = 1;
 603 }
 604
 605 int usb_drv_request_endpoint(int dir)
 606 {
 607     int i, bit;
 608
 609     bit=(dir & USB_DIR_IN)? 2:1;
 610
 611     for (i=1; i < USB_NUM_ENDPOINTS; i++) {
 612         if((endpoints[i].allocation & bit)!=0)
 613             continue;
 614         endpoints[i].allocation |= bit;
 615         return i | dir;
 616     }
 617
 618     return -1;
 619 }
 620
 621 void usb_drv_release_endpoint(int ep)
 622 {
 623     int mask = (ep & USB_DIR_IN)? ~2:~1;
 624     endpoints[ep & 0x7f].allocation &= mask;
 625 }
 626
 627
 628
 629 static void bus_reset(void)
 630 {
 631     /* Enable CLKAON & GLINTENA */
 632     ISP1583_INIT_MODE = STANDARD_INIT_MODE;
 633     /* Enable USB interrupts */
 634     ISP1583_INIT_INTCONF = 0x54 | INT_CONF_TARGET;
 635     set_int_value(ISP1583_INIT_INTEN_A, ISP1583_INIT_INTEN_B, STANDARD_INTEN);
 636
 637     /* Disable all OTG functions */
 638     ISP1583_INIT_OTG = 0;
 639
 640     /* Clear device address and enable it */
 641     ISP1583_INIT_ADDRESS = INIT_ADDRESS_DEVEN;
 642
 643     ZVM_SPECIFIC;
 644
 645     /* Reset endpoints to default */
 646     setup_endpoints();
 647
 648     logf("bus reset->done");
 649 }
 650
 651 /* Method for handling interrupts, must be called from usb-<target>.c */
 652 void IRAM_ATTR usb_drv_int(void)
 653 {
 654     unsigned long ints;
 655     ints = ISP1583_GEN_INT_READ & ISP1583_INIT_INTEN_READ;
 656
 657     if(!ints)
 658         return;
 659
 660     /* Unlock the device's registers */
 661     ISP1583_GEN_UNLCKDEV = ISP1583_UNLOCK_CODE;
 662
 663     #if 0
 664     logf(" handling int [0x%x & 0x%x = 0x%x]", ISP1583_GEN_INT_READ, ISP1583_INIT_INTEN_READ, ints);
 665     #endif
 666
 667     if(ints & INT_IEBRST) /* Bus reset */
 668     {
 669         logf("BRESET");
 670         high_speed_mode = false;
 671         bus_reset();
 672         usb_core_bus_reset();
 673         /* Mask bus reset interrupt */
 674         set_int_value(ISP1583_GEN_INT_A, ISP1583_GEN_INT_B, INT_IEBRST);
 675         return;
 676     }
 677     if(ints & INT_IEP0SETUP) /* EP0SETUP interrupt */
 678     {
 679         logf("EP0SETUP");
 680         usb_handle_setup_rx();
 681     }
 682     if(ints & INT_IEHS_STA) /* change from full-speed to high-speed mode -> endpoints need to get reconfigured!! */
 683     {
 684         logf("HS_STA");
 685         high_speed_mode = true;
 686         setup_endpoints();
 687     }
 688     if(ints & INT_EP_MASK) /* Endpoints interrupt */
 689     {
 690         unsigned long ep_event;
 691         unsigned short i = 10;
 692         ep_event = ints & INT_EP_MASK;
 693         while(ep_event)
 694         {
 695             if(i>25)
 696                 break;
 697
 698             if(ep_event & (1 << i))
 699             {
 700                 logf("EP%d %s interrupt", (i - 10) / 2, i % 2 ? "RX" : "TX");
 701                 usb_handle_data_int((i - 10) / 2, i % 2);
 702                 ep_event &= ~(1 << i);
 703             }
 704             i++;
 705         }
 706     }
 707     if(ints & INT_IERESM && !(ints & INT_IESUSP)) /* Resume status: status change from suspend to resume (active) */
 708     {
 709         logf("RESM");
 710     }
 711     if(ints & INT_IESUSP && !(ints & INT_IERESM)) /* Suspend status: status change from active to suspend */
 712     {
 713         logf("SUSP");
 714     }
 715     if(ints & INT_IEDMA) /* change in the DMA Interrupt Reason register */
 716     {
 717         logf("DMA");
 718     }
 719     if(ints & INT_IEVBUS) /* transition from LOW to HIGH on VBUS */
 720     {
 721         logf("VBUS");
 722     }
 723     /* Mask all (enabled) interrupts */
 724     set_int_value(ISP1583_GEN_INT_A, ISP1583_GEN_INT_B, ints);
 725
 726     ZVM_SPECIFIC;
 727 }
 728
 729 void usb_drv_set_address(int address)
 730 {
 731     logf("usb_drv_set_address(0x%x)", address);
 732     ISP1583_INIT_ADDRESS = (address & 0x7F) | INIT_ADDRESS_DEVEN;
 733
 734     ZVM_SPECIFIC;
 735
 736     usb_status_ack(0, DIR_TX);
 737 }
 738
 739 int dbg_usb_num_items(void)
 740 {
 741     return 2+USB_NUM_ENDPOINTS*2;
 742 }
 743
 744 char* dbg_usb_item(int selected_item, void *data, char *buffer, size_t buffer_len)
 745 {
 746     if(selected_item < 2)
 747     {
 748         switch(selected_item)
 749         {
 750             case 0:
 751                 snprintf(buffer, buffer_len, "USB connected: %s", (usb_drv_connected() ? "Yes" : "No"));
 752                 return buffer;
 753             case 1:
 754                 snprintf(buffer, buffer_len, "HS mode: %s", (high_speed_mode ? "Yes" : "No"));
 755                 return buffer;
 756         }
 757     }
 758     else
 759     {
 760         int n = ep_index((selected_item - 2) / 2, (selected_item - 2) % 2);
 761         if(endpoints[n].enabled == false)
 762             snprintf(buffer, buffer_len, "EP%d[%s]: DISABLED", epidx_n(n), (epidx_dir(n) ? "TX" : "RX"));
 763         else
 764         {
 765             if(epidx_dir(n))
 766             {
 767                 if(endpoints[n].out_in_progress)
 768                     snprintf(buffer, buffer_len, "EP%d[TX]: TRANSFERRING DATA -> %d bytes/%d bytes", epidx_n(n), (endpoints[n].out_len - endpoints[n].out_ptr), endpoints[n].out_len);
 769                 else
 770                     snprintf(buffer, buffer_len, "EP%d[TX]: STANDBY", epidx_n(n));
 771             }
 772             else
 773             {
 774                 if(endpoints[n].in_buf && !endpoints[n].in_ack)
 775                     snprintf(buffer, buffer_len, "EP%d[RX]: RECEIVING DATA -> %d bytes/%d bytes", epidx_n(n), endpoints[n].in_ptr, endpoints[n].in_max_len);
 776                 else
 777                     snprintf(buffer, buffer_len, "EP%d[RX]: STANDBY", epidx_n(n));
 778             }
 779         }
 780         return buffer;
 781     }
 782     return NULL;
 783     (void)data;
 784 }
 785
 786 void usb_drv_set_test_mode(int mode)
 787 {
 788     logf("usb_drv_set_test_mode(%d)", mode);
 789     switch(mode){
 790         case 0:
 791             ISP1583_GEN_TSTMOD = 0;
 792             /* Power cycle... */
 793             break;
 794         case 1:
 795             ISP1583_GEN_TSTMOD = GEN_TSTMOD_JSTATE;
 796             break;
 797         case 2:
 798             ISP1583_GEN_TSTMOD = GEN_TSTMOD_KSTATE;
 799             break;
 800         case 3:
 801             ISP1583_GEN_TSTMOD = GEN_TSTMOD_SE0_NAK;
 802             break;
 803         case 4:
 804             //REG_PORTSC1 |= PORTSCX_PTC_PACKET;
 805             break;
 806         case 5:
 807             //REG_PORTSC1 |= PORTSCX_PTC_FORCE_EN;
 808             break;
 809     }
 810 }