Subversion Repositories freemyipod

Rev

Rev 28 | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 28 Rev 29
Line 30... Line 30...
30 
#include "console.h"
 30 
#include "console.h"
31 
#include "util.h"
 31 
#include "util.h"
32 
#include "i2c.h"
 32 
#include "i2c.h"
33 
#include "strlen.h"
 33 
#include "strlen.h"
34 
#include "contextswitch.h"
 34 
#include "contextswitch.h"
- 
 
 35 
#include "pmu.h"
- 
 
 36 
#include "shutdown.h"
35 
 
 37 
 
36 
 
 38 
 
37 
static uint8_t ctrlresp[2] CACHEALIGN_ATTR;
 39 
static uint8_t ctrlresp[2] CACHEALIGN_ATTR;
38 
static uint32_t dbgrecvbuf[0x80] CACHEALIGN_ATTR;
 40 
static uint32_t dbgrecvbuf[0x80] CACHEALIGN_ATTR;
39 
static uint32_t dbgsendbuf[0x80] CACHEALIGN_ATTR;
 41 
static uint32_t dbgsendbuf[0x80] CACHEALIGN_ATTR;
Line 43... Line 45...
43 
enum dbgaction_t
 45 
enum dbgaction_t
44 
{
 46 
{
45 
    DBGACTION_IDLE = 0,
 47 
    DBGACTION_IDLE = 0,
46 
    DBGACTION_I2CSEND,
 48 
    DBGACTION_I2CSEND,
47 
    DBGACTION_I2CRECV,
 49 
    DBGACTION_I2CRECV,
- 
 
 50 
    DBGACTION_RESET,
48 
    DBGACTION_POWEROFF
 51 
    DBGACTION_POWEROFF,
- 
 
 52 
    DBGACTION_CWRITE,
- 
 
 53 
    DBGACTION_CREAD,
- 
 
 54 
    DBGACTION_CFLUSH
49 
};
 55 
};
50 
 
 56 
 
51 
static uint32_t dbgstack[0x100] STACK_ATTR;
 57 
static uint32_t dbgstack[0x100] STACK_ATTR;
52 
struct wakeup dbgwakeup IBSS_ATTR;
 58 
struct wakeup dbgwakeup IBSS_ATTR;
53 
extern struct scheduler_thread* scheduler_threads;
 59 
extern struct scheduler_thread* scheduler_threads;
54 
static enum dbgaction_t dbgaction IBSS_ATTR;
 60 
static enum dbgaction_t dbgaction IBSS_ATTR;
55 
static int dbgi2cbus IBSS_ATTR;
 61 
static int dbgi2cbus;
56 
static int dbgi2cslave IBSS_ATTR;
 62 
static int dbgi2cslave;
57 
static int dbgi2caddr IBSS_ATTR;
 63 
static int dbgactionaddr;
- 
 
 64 
static int dbgactionlength;
58 
static int dbgi2clen IBSS_ATTR;
 65 
static int dbgactionconsoles;
- 
 
 66 
static int dbgactiontype;
59 
static char dbgconsendbuf[4096];
 67 
static char dbgconsendbuf[4096];
60 
static char dbgconrecvbuf[1024];
 68 
static char dbgconrecvbuf[1024];
61 
static int dbgconsendreadidx IBSS_ATTR;
 69 
static int dbgconsendreadidx IBSS_ATTR;
62 
static int dbgconsendwriteidx IBSS_ATTR;
 70 
static int dbgconsendwriteidx IBSS_ATTR;
63 
static int dbgconrecvreadidx IBSS_ATTR;
 71 
static int dbgconrecvreadidx IBSS_ATTR;
Line 279... Line 287...
279 
        usb_drv_recv(0, NULL, 0);
 287 
        usb_drv_recv(0, NULL, 0);
280 
        usb_drv_send_nonblocking(0, addr, size > req->wLength ? req->wLength : size);
 288 
        usb_drv_send_nonblocking(0, addr, size > req->wLength ? req->wLength : size);
281 
    }
 289 
    }
282 
}
 290 
}
283 
 
 291 
 
284 
bool set_dbgaction(enum dbgaction_t action)
 292 
bool set_dbgaction(enum dbgaction_t action, int addsize)
285 
{
 293 
{
286 
    if (dbgaction != DBGACTION_IDLE)
 294 
    if (dbgaction != DBGACTION_IDLE)
287 
    {
 295 
    {
288 
        dbgsendbuf[0] = 3;
 296 
        dbgsendbuf[0] = 3;
289 
        usb_drv_send_nonblocking(dbgendpoints[1], dbgsendbuf, 16);
 297 
        usb_drv_send_nonblocking(dbgendpoints[1], dbgsendbuf, 16 + addsize);
290 
        return true;
 298 
        return true;
291 
    }
 299 
    }
292 
    dbgaction = action;
 300 
    dbgaction = action;
293 
    wakeup_signal(&dbgwakeup);
 301 
    wakeup_signal(&dbgwakeup);
294 
    return false;
 302 
    return false;
Line 323... Line 331...
323 
            default:
 331 
            default:
324 
                dbgsendbuf[0] = 2;
 332 
                dbgsendbuf[0] = 2;
325 
            }
 333 
            }
326 
            break;
 334 
            break;
327 
        case 2:  // RESET
 335 
        case 2:  // RESET
- 
 
 336 
            if (dbgrecvbuf[1])
- 
 
 337 
            {
- 
 
 338 
                if (set_dbgaction(DBGACTION_RESET, 0)) break;
- 
 
 339 
                dbgsendbuf[0] = 1;
- 
 
 340 
                size = 16;
- 
 
 341 
            }
328 
            reset();
 342 
            else reset();
329 
            break;
 343 
            break;
330 
        case 3:  // POWER OFF
 344 
        case 3:  // POWER OFF
331 
            set_dbgaction(DBGACTION_POWEROFF);
 345 
            if (set_dbgaction(DBGACTION_POWEROFF, 0)) break;
- 
 
 346 
            dbgactiontype = dbgrecvbuf[1];
- 
 
 347 
            dbgsendbuf[0] = 1;
- 
 
 348 
            size = 16;
332 
            break;
 349 
            break;
333 
        case 4:  // READ MEMORY
 350 
        case 4:  // READ MEMORY
334 
            dbgsendbuf[0] = 1;
 351 
            dbgsendbuf[0] = 1;
335 
            memcpy(&dbgsendbuf[4], (const void*)dbgrecvbuf[1], dbgrecvbuf[2]);
 352 
            memcpy(&dbgsendbuf[4], (const void*)dbgrecvbuf[1], dbgrecvbuf[2]);
336 
            size = dbgrecvbuf[2] + 16;
 353 
            size = dbgrecvbuf[2] + 16;
Line 349... Line 366...
349 
            dbgsendbuf[0] = 1;
 366 
            dbgsendbuf[0] = 1;
350 
            size = 16;
 367 
            size = 16;
351 
            usb_drv_recv(dbgendpoints[2], (void*)dbgrecvbuf[1], dbgrecvbuf[2]);
 368 
            usb_drv_recv(dbgendpoints[2], (void*)dbgrecvbuf[1], dbgrecvbuf[2]);
352 
            break;
 369 
            break;
353 
        case 8:  // READ I2C
 370 
        case 8:  // READ I2C
354 
            if (set_dbgaction(DBGACTION_I2CRECV)) break;
 371 
            if (set_dbgaction(DBGACTION_I2CRECV, dbgrecvbuf[1] >> 24)) break;
355 
            dbgi2cbus = dbgrecvbuf[1] & 0xff;
 372 
            dbgi2cbus = dbgrecvbuf[1] & 0xff;
356 
            dbgi2cslave = (dbgrecvbuf[1] >> 8) & 0xff;
 373 
            dbgi2cslave = (dbgrecvbuf[1] >> 8) & 0xff;
357 
            dbgi2caddr = (dbgrecvbuf[1] >> 16) & 0xff;
 374 
            dbgactionaddr = (dbgrecvbuf[1] >> 16) & 0xff;
358 
            dbgi2clen = dbgrecvbuf[1] >> 24;
 375 
            dbgactionlength = dbgrecvbuf[1] >> 24;
359 
            break;
 376 
            break;
360 
        case 9:  // WRITE I2C
 377 
        case 9:  // WRITE I2C
361 
            if (set_dbgaction(DBGACTION_I2CSEND)) break;
 378 
            if (set_dbgaction(DBGACTION_I2CSEND, 0)) break;
362 
            dbgi2cbus = dbgrecvbuf[1] & 0xff;
 379 
            dbgi2cbus = dbgrecvbuf[1] & 0xff;
363 
            dbgi2cslave = (dbgrecvbuf[1] >> 8) & 0xff;
 380 
            dbgi2cslave = (dbgrecvbuf[1] >> 8) & 0xff;
364 
            dbgi2caddr = (dbgrecvbuf[1] >> 16) & 0xff;
 381 
            dbgactionaddr = (dbgrecvbuf[1] >> 16) & 0xff;
365 
            dbgi2clen = dbgrecvbuf[1] >> 24;
 382 
            dbgactionlength = dbgrecvbuf[1] >> 24;
366 
            memcpy(dbgasyncsendbuf, &dbgsendbuf[4], dbgi2clen);
 383 
            memcpy(dbgasyncsendbuf, &dbgsendbuf[4], dbgactionlength);
367 
            break;
 384 
            break;
368 
        case 10:  // READ CONSOLE
 385 
        case 10:  // READ CONSOLE
369 
            dbgconsoleattached = true;
 386 
            dbgconsoleattached = true;
370 
            int bytes = dbgconsendwriteidx - dbgconsendreadidx;
 387 
            int bytes = dbgconsendwriteidx - dbgconsendreadidx;
371 
            if (bytes >= sizeof(dbgconsendbuf)) bytes -= sizeof(dbgconsendbuf);
 388 
            if (bytes >= sizeof(dbgconsendbuf)) bytes -= sizeof(dbgconsendbuf);
Line 417... Line 434...
417 
            dbgsendbuf[1] = bytes;
 434 
            dbgsendbuf[1] = bytes;
418 
            dbgsendbuf[2] = sizeof(dbgconrecvbuf);
 435 
            dbgsendbuf[2] = sizeof(dbgconrecvbuf);
419 
            dbgsendbuf[3] = dbgconrecvreadidx - dbgconrecvwriteidx - 1;
 436 
            dbgsendbuf[3] = dbgconrecvreadidx - dbgconrecvwriteidx - 1;
420 
            size = 16;
 437 
            size = 16;
421 
            break;
 438 
            break;
- 
 
 439 
        case 12:  // CWRITE
- 
 
 440 
            if (set_dbgaction(DBGACTION_CWRITE, 0)) break;
- 
 
 441 
            dbgactionconsoles = dbgrecvbuf[1];
- 
 
 442 
            dbgactionlength = dbgrecvbuf[2];
- 
 
 443 
            memcpy(dbgasyncsendbuf, &dbgrecvbuf[4], dbgactionlength);
- 
 
 444 
            break;
- 
 
 445 
        case 13:  // CREAD
- 
 
 446 
            if (set_dbgaction(DBGACTION_CREAD, dbgrecvbuf[2])) break;
- 
 
 447 
            dbgactionconsoles = dbgrecvbuf[1];
- 
 
 448 
            dbgactionlength = dbgrecvbuf[2];
- 
 
 449 
            break;
- 
 
 450 
        case 14:  // CFLUSH
- 
 
 451 
            if (set_dbgaction(DBGACTION_CFLUSH, 0)) break;
- 
 
 452 
            dbgactionconsoles = dbgrecvbuf[1];
- 
 
 453 
            break;
422 
        default:
 454 
        default:
423 
            dbgsendbuf[0] = 2;
 455 
            dbgsendbuf[0] = 2;
424 
            size = 16;
 456 
            size = 16;
425 
        }
 457 
        }
426 
        usb_setup_dbg_listener();
 458 
        usb_setup_dbg_listener();
Line 459... Line 491...
459 
        if (dbgaction != DBGACTION_IDLE)
 491 
        if (dbgaction != DBGACTION_IDLE)
460 
        {
 492 
        {
461 
            switch (dbgaction)
 493 
            switch (dbgaction)
462 
            {
 494 
            {
463 
            case DBGACTION_I2CSEND:
 495 
            case DBGACTION_I2CSEND:
464 
                i2c_send(dbgi2cbus, dbgi2cslave, dbgi2caddr, (uint8_t*)dbgasyncsendbuf, dbgi2clen);
 496 
                i2c_send(dbgi2cbus, dbgi2cslave, dbgactionaddr,
- 
 
 497 
                         (uint8_t*)dbgasyncsendbuf, dbgactionlength);
465 
                dbgasyncsendbuf[0] = 1;
 498 
                dbgasyncsendbuf[0] = 1;
466 
                usb_drv_send_nonblocking(dbgendpoints[1], dbgasyncsendbuf, 16);
 499 
                usb_drv_send_nonblocking(dbgendpoints[1], dbgasyncsendbuf, 16);
467 
                break;
 500 
                break;
468 
            case DBGACTION_I2CRECV:
 501 
            case DBGACTION_I2CRECV:
469 
                i2c_recv(dbgi2cbus, dbgi2cslave, dbgi2caddr,
 502 
                i2c_recv(dbgi2cbus, dbgi2cslave, dbgactionaddr,
470 
                         (uint8_t*)(&dbgasyncsendbuf[4]), dbgi2clen);
 503 
                         (uint8_t*)(&dbgasyncsendbuf[4]), dbgactionlength);
471 
                dbgasyncsendbuf[0] = 1;
 504 
                dbgasyncsendbuf[0] = 1;
472 
                usb_drv_send_nonblocking(dbgendpoints[1], dbgasyncsendbuf, 16 + dbgi2clen);
 505 
                usb_drv_send_nonblocking(dbgendpoints[1], dbgasyncsendbuf, 16 + dbgactionlength);
473 
                break;
 506 
                break;
474 
            case DBGACTION_POWEROFF:
 507 
            case DBGACTION_POWEROFF:
- 
 
 508 
                if (dbgactiontype) shutdown();
- 
 
 509 
                poweroff();
- 
 
 510 
                break;
- 
 
 511 
            case DBGACTION_RESET:
- 
 
 512 
                shutdown();
- 
 
 513 
                reset();
- 
 
 514 
                break;
- 
 
 515 
            case DBGACTION_CWRITE:
- 
 
 516 
                cwrite(dbgactionconsoles, (const char*)dbgasyncsendbuf, dbgactionlength);
- 
 
 517 
                dbgasyncsendbuf[0] = 1;
- 
 
 518 
                usb_drv_send_nonblocking(dbgendpoints[1], dbgasyncsendbuf, 16);
- 
 
 519 
                break;
- 
 
 520 
            case DBGACTION_CREAD:
- 
 
 521 
                cread(dbgactionconsoles, (char*)&dbgasyncsendbuf[4], dbgactionlength, 0);
- 
 
 522 
                dbgasyncsendbuf[0] = 1;
- 
 
 523 
                usb_drv_send_nonblocking(dbgendpoints[1], dbgasyncsendbuf, 16);
- 
 
 524 
                break;
- 
 
 525 
            case DBGACTION_CFLUSH:
- 
 
 526 
                cflush(dbgactionconsoles);
- 
 
 527 
                dbgasyncsendbuf[0] = 1;
- 
 
 528 
                usb_drv_send_nonblocking(dbgendpoints[1], dbgasyncsendbuf, 16);
475 
                break;
 529 
                break;
476 
            }
 530 
            }
477 
            dbgaction = DBGACTION_IDLE;
 531 
            dbgaction = DBGACTION_IDLE;
478 
        }
 532 
        }
479 
    }
 533 
    }