← Back to branch summary

~ubuntu-branches/ubuntu/precise/avrdude/precise

« back to all changes in this revision

Viewing changes to stk500v2.c

  • Committer: Bazaar Package Importer
  • Author(s): Michael Biebl
  • Date: 2009-07-14 15:09:17 UTC
  • mfrom: (1.1.7 upstream)
  • Revision ID: james.westby@ubuntu.com-20090714150917-vthf96lweuevgtds
Tags: 5.8-1
* New upstream release.
* Bump Standards-Version to 3.8.2. No further changes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
stk500v2.c
20
20
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
21
21
 */
22
22
 
23
 
/* $Id: stk500v2.c,v 1.47 2009/02/26 19:43:55 joerg_wunsch Exp $ */
 
23
/* $Id: stk500v2.c 836 2009-07-10 22:39:37Z joerg_wunsch $ */
24
24
/* Based on Id: stk500.c,v 1.46 2004/12/22 01:52:45 bdean Exp */
25
25
 
26
26
/*
117
117
    }
118
118
        pgmtype;
119
119
 
120
 
    AVRPART *lastpart;
 
120
  AVRPART *lastpart;
 
121
 
 
122
  /*
 
123
   * Chained pdata for the JTAG ICE mkII backend.  This is used when
 
124
   * calling the backend functions for ISP/HVSP/PP programming
 
125
   * functionality of the JTAG ICE mkII and AVR Dragon.
 
126
   */
 
127
  void *chained_pdata;
121
128
};
122
129
 
123
130
#define PDATA(pgm) ((struct pdata *)(pgm->cookie))
278
285
  PDATA(pgm)->command_sequence = 1;
279
286
}
280
287
 
 
288
static void stk500v2_jtagmkII_setup(PROGRAMMER * pgm)
 
289
{
 
290
  void *mycookie, *theircookie;
 
291
 
 
292
  if ((pgm->cookie = malloc(sizeof(struct pdata))) == 0) {
 
293
    fprintf(stderr,
 
294
            "%s: stk500v2_setup(): Out of memory allocating private data\n",
 
295
            progname);
 
296
    exit(1);
 
297
  }
 
298
  memset(pgm->cookie, 0, sizeof(struct pdata));
 
299
  PDATA(pgm)->command_sequence = 1;
 
300
 
 
301
  /*
 
302
   * Now, have the JTAG ICE mkII backend allocate its own private
 
303
   * data.  Store our own cookie in a safe place for the time being.
 
304
   */
 
305
  mycookie = pgm->cookie;
 
306
  jtagmkII_setup(pgm);
 
307
  theircookie = pgm->cookie;
 
308
  pgm->cookie = mycookie;
 
309
  PDATA(pgm)->chained_pdata = theircookie;
 
310
}
 
311
 
281
312
static void stk500v2_teardown(PROGRAMMER * pgm)
282
313
{
283
314
  free(pgm->cookie);
284
315
}
285
316
 
 
317
static void stk500v2_jtagmkII_teardown(PROGRAMMER * pgm)
 
318
{
 
319
  void *mycookie;
 
320
 
 
321
  mycookie = pgm->cookie;
 
322
  pgm->cookie = PDATA(pgm)->chained_pdata;
 
323
  jtagmkII_teardown(pgm);
 
324
 
 
325
  free(mycookie);
 
326
}
 
327
 
286
328
 
287
329
static unsigned short
288
330
b2_to_u16(unsigned char *b)
326
368
  unsigned char *cmdbuf;
327
369
  int rv;
328
370
  unsigned short sz;
 
371
  void *mycookie;
329
372
 
330
373
  sz = get_jtagisp_return_size(data[0]);
331
374
  if (sz == 0) {
353
396
            progname);
354
397
    exit(1);
355
398
  }
 
399
  mycookie = pgm->cookie;
 
400
  pgm->cookie = PDATA(pgm)->chained_pdata;
356
401
  cmdbuf[0] = CMND_ISP_PACKET;
357
402
  cmdbuf[1] = sz & 0xff;
358
403
  cmdbuf[2] = (sz >> 8) & 0xff;
359
404
  memcpy(cmdbuf + 3, data, len);
360
405
  rv = jtagmkII_send(pgm, cmdbuf, len + 3);
361
406
  free(cmdbuf);
 
407
  pgm->cookie = mycookie;
362
408
 
363
409
  return rv;
364
410
}
423
469
{
424
470
  int rv;
425
471
  unsigned char *jtagmsg;
 
472
  void *mycookie;
426
473
 
 
474
  mycookie = pgm->cookie;
 
475
  pgm->cookie = PDATA(pgm)->chained_pdata;
427
476
  rv = jtagmkII_recv(pgm, &jtagmsg);
 
477
  pgm->cookie = mycookie;
428
478
  if (rv <= 0) {
429
479
    fprintf(stderr, "%s: stk500v2_jtagmkII_recv(): error in jtagmkII_recv()\n",
430
480
            progname);
524
574
        if (curlen < maxsize) {
525
575
          msg[curlen] = c;
526
576
        } else {
527
 
          fprintf(stderr, "%s: stk500v2_recv(): buffer too small, received %d byte into %zd byte buffer\n",
 
577
          fprintf(stderr, "%s: stk500v2_recv(): buffer too small, received %d byte into %u byte buffer\n",
528
578
                  progname,curlen,maxsize);
529
579
          return -2;
530
580
        }
2571
2621
  int prescale;
2572
2622
  double f;
2573
2623
  const char *unit;
 
2624
  void *mycookie;
2574
2625
 
2575
2626
  if (PDATA(pgm)->pgmtype == PGMTYPE_JTAGICE_MKII) {
 
2627
    mycookie = pgm->cookie;
 
2628
    pgm->cookie = PDATA(pgm)->chained_pdata;
2576
2629
    jtagmkII_getparm(pgm, PAR_OCD_VTARGET, vtarget_jtag);
 
2630
    pgm->cookie = mycookie;
2577
2631
    fprintf(stderr, "%sVtarget         : %.1f V\n", p,
2578
2632
            b2_to_u16(vtarget_jtag) / 1000.0);
2579
2633
  } else {
2681
2735
static int stk500v2_jtagmkII_open(PROGRAMMER * pgm, char * port)
2682
2736
{
2683
2737
  long baud;
 
2738
  void *mycookie;
2684
2739
 
2685
2740
  if (verbose >= 2)
2686
2741
    fprintf(stderr, "%s: stk500v2_jtagmkII_open()\n", progname);
2717
2772
   */
2718
2773
  stk500v2_drain(pgm, 0);
2719
2774
 
 
2775
  mycookie = pgm->cookie;
 
2776
  pgm->cookie = PDATA(pgm)->chained_pdata;
2720
2777
  if (jtagmkII_getsync(pgm, EMULATOR_MODE_SPI) != 0) {
2721
2778
    fprintf(stderr, "%s: failed to sync with the JTAG ICE mkII in ISP mode\n",
2722
2779
            progname);
2723
2780
    pgm->close(pgm);            /* sign off correctly */
 
2781
    pgm->cookie = mycookie;
2724
2782
    exit(1);
2725
2783
  }
 
2784
  pgm->cookie = mycookie;
2726
2785
 
2727
2786
  PDATA(pgm)->pgmtype = PGMTYPE_JTAGICE_MKII;
2728
2787
 
2748
2807
static int stk500v2_dragon_isp_open(PROGRAMMER * pgm, char * port)
2749
2808
{
2750
2809
  long baud;
 
2810
  void *mycookie;
2751
2811
 
2752
2812
  if (verbose >= 2)
2753
2813
    fprintf(stderr, "%s: stk500v2_dragon_isp_open()\n", progname);
2784
2844
   */
2785
2845
  stk500v2_drain(pgm, 0);
2786
2846
 
 
2847
  mycookie = pgm->cookie;
 
2848
  pgm->cookie = PDATA(pgm)->chained_pdata;
2787
2849
  if (jtagmkII_getsync(pgm, EMULATOR_MODE_SPI) != 0) {
2788
2850
    fprintf(stderr, "%s: failed to sync with the JTAG ICE mkII in ISP mode\n",
2789
2851
            progname);
2790
2852
    pgm->close(pgm);            /* sign off correctly */
 
2853
    pgm->cookie = mycookie;
2791
2854
    exit(1);
2792
2855
  }
 
2856
  pgm->cookie = mycookie;
2793
2857
 
2794
2858
  PDATA(pgm)->pgmtype = PGMTYPE_JTAGICE_MKII;
2795
2859
 
2815
2879
static int stk500v2_dragon_hv_open(PROGRAMMER * pgm, char * port)
2816
2880
{
2817
2881
  long baud;
 
2882
  void *mycookie;
2818
2883
 
2819
2884
  if (verbose >= 2)
2820
2885
    fprintf(stderr, "%s: stk500v2_dragon_hv_open()\n", progname);
2851
2916
   */
2852
2917
  stk500v2_drain(pgm, 0);
2853
2918
 
 
2919
  mycookie = pgm->cookie;
 
2920
  pgm->cookie = PDATA(pgm)->chained_pdata;
2854
2921
  if (jtagmkII_getsync(pgm, EMULATOR_MODE_HV) != 0) {
2855
2922
    fprintf(stderr, "%s: failed to sync with the JTAG ICE mkII in HV mode\n",
2856
2923
            progname);
2857
2924
    pgm->close(pgm);            /* sign off correctly */
 
2925
    pgm->cookie = mycookie;
2858
2926
    exit(1);
2859
2927
  }
 
2928
  pgm->cookie = mycookie;
2860
2929
 
2861
2930
  PDATA(pgm)->pgmtype = PGMTYPE_JTAGICE_MKII;
2862
2931
 
3016
3085
    } else if (strcmp(mem->desc, "lockbits") == 0) {
3017
3086
        b[1] = XPRG_MEM_TYPE_LOCKBITS;
3018
3087
        addr += 0x008f0000;
 
3088
    } else if (strncmp(mem->desc, "fuse", strlen("fuse")) == 0) {
 
3089
        b[1] = XPRG_MEM_TYPE_FUSE;
 
3090
        addr += 0x008f0000;
3019
3091
    } else if (strcmp(mem->desc, "usersig") == 0) {
3020
3092
        b[1] = XPRG_MEM_TYPE_USERSIG;
3021
3093
        addr += 0x008e0000;
3483
3555
  pgm->print_parms    = stk500v2_print_parms;
3484
3556
  pgm->set_sck_period = stk500v2_set_sck_period_mk2;
3485
3557
  pgm->perform_osccal = stk500v2_perform_osccal;
3486
 
  pgm->setup          = jtagmkII_setup;
3487
 
  pgm->teardown       = jtagmkII_teardown;
 
3558
  pgm->setup          = stk500v2_jtagmkII_setup;
 
3559
  pgm->teardown       = stk500v2_jtagmkII_teardown;
3488
3560
  pgm->page_size      = 256;
3489
3561
}
3490
3562
 
3547
3619
  pgm->set_varef      = stk500v2_set_varef;
3548
3620
  pgm->set_fosc       = stk500v2_set_fosc;
3549
3621
  pgm->set_sck_period = stk500v2_set_sck_period_mk2;
3550
 
  pgm->setup          = jtagmkII_setup;
3551
 
  pgm->teardown       = jtagmkII_teardown;
 
3622
  pgm->setup          = stk500v2_jtagmkII_setup;
 
3623
  pgm->teardown       = stk500v2_jtagmkII_teardown;
3552
3624
  pgm->page_size      = 256;
3553
3625
}
3554
3626
 
3580
3652
  pgm->set_varef      = stk500v2_set_varef;
3581
3653
  pgm->set_fosc       = stk500v2_set_fosc;
3582
3654
  pgm->set_sck_period = stk500v2_set_sck_period_mk2;
3583
 
  pgm->setup          = jtagmkII_setup;
3584
 
  pgm->teardown       = jtagmkII_teardown;
 
3655
  pgm->setup          = stk500v2_jtagmkII_setup;
 
3656
  pgm->teardown       = stk500v2_jtagmkII_teardown;
3585
3657
  pgm->page_size      = 256;
3586
3658
}
3587
3659