drivers/misc/altera-stapl/altera-jtag.c

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
altera_jinit
altera_set_drstop
altera_set_irstop
altera_set_dr_pre
altera_set_ir_pre
altera_set_dr_post
altera_set_ir_post
altera_jreset_idle
altera_goto_jstate
altera_wait_cycles
altera_wait_msecs
altera_concatenate_data
alt_jtag_drscan
alt_jtag_irscan
altera_extract_target_data
altera_irscan
altera_swap_ir
altera_drscan
altera_swap_dr
altera_free_buffers
   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * altera-jtag.c
   4  *
   5  * altera FPGA driver
   6  *
   7  * Copyright (C) Altera Corporation 1998-2001
   8  * Copyright (C) 2010 NetUP Inc.
   9  * Copyright (C) 2010 Igor M. Liplianin <liplianin@netup.ru>
  10  */
  11 
  12 #include <linux/delay.h>
  13 #include <linux/firmware.h>
  14 #include <linux/slab.h>
  15 #include <misc/altera.h>
  16 #include "altera-exprt.h"
  17 #include "altera-jtag.h"
  18 
  19 #define alt_jtag_io(a, b, c)\
  20                 astate->config->jtag_io(astate->config->dev, a, b, c);
  21 
  22 #define alt_malloc(a)   kzalloc(a, GFP_KERNEL);
  23 
  24 /*
  25  * This structure shows, for each JTAG state, which state is reached after
  26  * a single TCK clock cycle with TMS high or TMS low, respectively.  This
  27  * describes all possible state transitions in the JTAG state machine.
  28  */
  29 struct altera_jtag_machine {
  30         enum altera_jtag_state tms_high;
  31         enum altera_jtag_state tms_low;
  32 };
  33 
  34 static const struct altera_jtag_machine altera_transitions[] = {
  35         /* RESET     */ { RESET,        IDLE },
  36         /* IDLE      */ { DRSELECT,     IDLE },
  37         /* DRSELECT  */ { IRSELECT,     DRCAPTURE },
  38         /* DRCAPTURE */ { DREXIT1,      DRSHIFT },
  39         /* DRSHIFT   */ { DREXIT1,      DRSHIFT },
  40         /* DREXIT1   */ { DRUPDATE,     DRPAUSE },
  41         /* DRPAUSE   */ { DREXIT2,      DRPAUSE },
  42         /* DREXIT2   */ { DRUPDATE,     DRSHIFT },
  43         /* DRUPDATE  */ { DRSELECT,     IDLE },
  44         /* IRSELECT  */ { RESET,        IRCAPTURE },
  45         /* IRCAPTURE */ { IREXIT1,      IRSHIFT },
  46         /* IRSHIFT   */ { IREXIT1,      IRSHIFT },
  47         /* IREXIT1   */ { IRUPDATE,     IRPAUSE },
  48         /* IRPAUSE   */ { IREXIT2,      IRPAUSE },
  49         /* IREXIT2   */ { IRUPDATE,     IRSHIFT },
  50         /* IRUPDATE  */ { DRSELECT,     IDLE }
  51 };
  52 
  53 /*
  54  * This table contains the TMS value to be used to take the NEXT STEP on
  55  * the path to the desired state.  The array index is the current state,
  56  * and the bit position is the desired endstate.  To find out which state
  57  * is used as the intermediate state, look up the TMS value in the
  58  * altera_transitions[] table.
  59  */
  60 static const u16 altera_jtag_path_map[16] = {
  61         /* RST  RTI     SDRS    CDR     SDR     E1DR    PDR     E2DR */
  62         0x0001, 0xFFFD, 0xFE01, 0xFFE7, 0xFFEF, 0xFF0F, 0xFFBF, 0xFFFF,
  63         /* UDR  SIRS    CIR     SIR     E1IR    PIR     E2IR    UIR */
  64         0xFEFD, 0x0001, 0xF3FF, 0xF7FF, 0x87FF, 0xDFFF, 0xFFFF, 0x7FFD
  65 };
  66 
  67 /* Flag bits for alt_jtag_io() function */
  68 #define TMS_HIGH   1
  69 #define TMS_LOW    0
  70 #define TDI_HIGH   1
  71 #define TDI_LOW    0
  72 #define READ_TDO   1
  73 #define IGNORE_TDO 0
  74 
  75 int altera_jinit(struct altera_state *astate)
  76 {
  77         struct altera_jtag *js = &astate->js;
  78 
  79         /* initial JTAG state is unknown */
  80         js->jtag_state = ILLEGAL_JTAG_STATE;
  81 
  82         /* initialize to default state */
  83         js->drstop_state = IDLE;
  84         js->irstop_state = IDLE;
  85         js->dr_pre  = 0;
  86         js->dr_post = 0;
  87         js->ir_pre  = 0;
  88         js->ir_post = 0;
  89         js->dr_length    = 0;
  90         js->ir_length    = 0;
  91 
  92         js->dr_pre_data  = NULL;
  93         js->dr_post_data = NULL;
  94         js->ir_pre_data  = NULL;
  95         js->ir_post_data = NULL;
  96         js->dr_buffer    = NULL;
  97         js->ir_buffer    = NULL;
  98 
  99         return 0;
 100 }
 101 
 102 int altera_set_drstop(struct altera_jtag *js, enum altera_jtag_state state)
 103 {
 104         js->drstop_state = state;
 105 
 106         return 0;
 107 }
 108 
 109 int altera_set_irstop(struct altera_jtag *js, enum altera_jtag_state state)
 110 {
 111         js->irstop_state = state;
 112 
 113         return 0;
 114 }
 115 
 116 int altera_set_dr_pre(struct altera_jtag *js,
 117                                 u32 count, u32 start_index,
 118                                 u8 *preamble_data)
 119 {
 120         int status = 0;
 121         u32 i;
 122         u32 j;
 123 
 124         if (count > js->dr_pre) {
 125                 kfree(js->dr_pre_data);
 126                 js->dr_pre_data = (u8 *)alt_malloc((count + 7) >> 3);
 127                 if (js->dr_pre_data == NULL)
 128                         status = -ENOMEM;
 129                 else
 130                         js->dr_pre = count;
 131         } else
 132                 js->dr_pre = count;
 133 
 134         if (status == 0) {
 135                 for (i = 0; i < count; ++i) {
 136                         j = i + start_index;
 137 
 138                         if (preamble_data == NULL)
 139                                 js->dr_pre_data[i >> 3] |= (1 << (i & 7));
 140                         else {
 141                                 if (preamble_data[j >> 3] & (1 << (j & 7)))
 142                                         js->dr_pre_data[i >> 3] |=
 143                                                         (1 << (i & 7));
 144                                 else
 145                                         js->dr_pre_data[i >> 3] &=
 146                                                         ~(u32)(1 << (i & 7));
 147 
 148                         }
 149                 }
 150         }
 151 
 152         return status;
 153 }
 154 
 155 int altera_set_ir_pre(struct altera_jtag *js, u32 count, u32 start_index,
 156                                                         u8 *preamble_data)
 157 {
 158         int status = 0;
 159         u32 i;
 160         u32 j;
 161 
 162         if (count > js->ir_pre) {
 163                 kfree(js->ir_pre_data);
 164                 js->ir_pre_data = (u8 *)alt_malloc((count + 7) >> 3);
 165                 if (js->ir_pre_data == NULL)
 166                         status = -ENOMEM;
 167                 else
 168                         js->ir_pre = count;
 169 
 170         } else
 171                 js->ir_pre = count;
 172 
 173         if (status == 0) {
 174                 for (i = 0; i < count; ++i) {
 175                         j = i + start_index;
 176                         if (preamble_data == NULL)
 177                                 js->ir_pre_data[i >> 3] |= (1 << (i & 7));
 178                         else {
 179                                 if (preamble_data[j >> 3] & (1 << (j & 7)))
 180                                         js->ir_pre_data[i >> 3] |=
 181                                                         (1 << (i & 7));
 182                                 else
 183                                         js->ir_pre_data[i >> 3] &=
 184                                                         ~(u32)(1 << (i & 7));
 185 
 186                         }
 187                 }
 188         }
 189 
 190         return status;
 191 }
 192 
 193 int altera_set_dr_post(struct altera_jtag *js, u32 count, u32 start_index,
 194                                                 u8 *postamble_data)
 195 {
 196         int status = 0;
 197         u32 i;
 198         u32 j;
 199 
 200         if (count > js->dr_post) {
 201                 kfree(js->dr_post_data);
 202                 js->dr_post_data = (u8 *)alt_malloc((count + 7) >> 3);
 203 
 204                 if (js->dr_post_data == NULL)
 205                         status = -ENOMEM;
 206                 else
 207                         js->dr_post = count;
 208 
 209         } else
 210                 js->dr_post = count;
 211 
 212         if (status == 0) {
 213                 for (i = 0; i < count; ++i) {
 214                         j = i + start_index;
 215 
 216                         if (postamble_data == NULL)
 217                                 js->dr_post_data[i >> 3] |= (1 << (i & 7));
 218                         else {
 219                                 if (postamble_data[j >> 3] & (1 << (j & 7)))
 220                                         js->dr_post_data[i >> 3] |=
 221                                                                 (1 << (i & 7));
 222                                 else
 223                                         js->dr_post_data[i >> 3] &=
 224                                             ~(u32)(1 << (i & 7));
 225 
 226                         }
 227                 }
 228         }
 229 
 230         return status;
 231 }
 232 
 233 int altera_set_ir_post(struct altera_jtag *js, u32 count, u32 start_index,
 234                                                 u8 *postamble_data)
 235 {
 236         int status = 0;
 237         u32 i;
 238         u32 j;
 239 
 240         if (count > js->ir_post) {
 241                 kfree(js->ir_post_data);
 242                 js->ir_post_data = (u8 *)alt_malloc((count + 7) >> 3);
 243                 if (js->ir_post_data == NULL)
 244                         status = -ENOMEM;
 245                 else
 246                         js->ir_post = count;
 247 
 248         } else
 249                 js->ir_post = count;
 250 
 251         if (status != 0)
 252                 return status;
 253 
 254         for (i = 0; i < count; ++i) {
 255                 j = i + start_index;
 256 
 257                 if (postamble_data == NULL)
 258                         js->ir_post_data[i >> 3] |= (1 << (i & 7));
 259                 else {
 260                         if (postamble_data[j >> 3] & (1 << (j & 7)))
 261                                 js->ir_post_data[i >> 3] |= (1 << (i & 7));
 262                         else
 263                                 js->ir_post_data[i >> 3] &=
 264                                     ~(u32)(1 << (i & 7));
 265 
 266                 }
 267         }
 268 
 269         return status;
 270 }
 271 
 272 static void altera_jreset_idle(struct altera_state *astate)
 273 {
 274         struct altera_jtag *js = &astate->js;
 275         int i;
 276         /* Go to Test Logic Reset (no matter what the starting state may be) */
 277         for (i = 0; i < 5; ++i)
 278                 alt_jtag_io(TMS_HIGH, TDI_LOW, IGNORE_TDO);
 279 
 280         /* Now step to Run Test / Idle */
 281         alt_jtag_io(TMS_LOW, TDI_LOW, IGNORE_TDO);
 282         js->jtag_state = IDLE;
 283 }
 284 
 285 int altera_goto_jstate(struct altera_state *astate,
 286                                         enum altera_jtag_state state)
 287 {
 288         struct altera_jtag *js = &astate->js;
 289         int tms;
 290         int count = 0;
 291         int status = 0;
 292 
 293         if (js->jtag_state == ILLEGAL_JTAG_STATE)
 294                 /* initialize JTAG chain to known state */
 295                 altera_jreset_idle(astate);
 296 
 297         if (js->jtag_state == state) {
 298                 /*
 299                  * We are already in the desired state.
 300                  * If it is a stable state, loop here.
 301                  * Otherwise do nothing (no clock cycles).
 302                  */
 303                 if ((state == IDLE) || (state == DRSHIFT) ||
 304                         (state == DRPAUSE) || (state == IRSHIFT) ||
 305                                 (state == IRPAUSE)) {
 306                         alt_jtag_io(TMS_LOW, TDI_LOW, IGNORE_TDO);
 307                 } else if (state == RESET)
 308                         alt_jtag_io(TMS_HIGH, TDI_LOW, IGNORE_TDO);
 309 
 310         } else {
 311                 while ((js->jtag_state != state) && (count < 9)) {
 312                         /* Get TMS value to take a step toward desired state */
 313                         tms = (altera_jtag_path_map[js->jtag_state] &
 314                                                         (1 << state))
 315                                                         ? TMS_HIGH : TMS_LOW;
 316 
 317                         /* Take a step */
 318                         alt_jtag_io(tms, TDI_LOW, IGNORE_TDO);
 319 
 320                         if (tms)
 321                                 js->jtag_state =
 322                                         altera_transitions[js->jtag_state].tms_high;
 323                         else
 324                                 js->jtag_state =
 325                                         altera_transitions[js->jtag_state].tms_low;
 326 
 327                         ++count;
 328                 }
 329         }
 330 
 331         if (js->jtag_state != state)
 332                 status = -EREMOTEIO;
 333 
 334         return status;
 335 }
 336 
 337 int altera_wait_cycles(struct altera_state *astate,
 338                                         s32 cycles,
 339                                         enum altera_jtag_state wait_state)
 340 {
 341         struct altera_jtag *js = &astate->js;
 342         int tms;
 343         s32 count;
 344         int status = 0;
 345 
 346         if (js->jtag_state != wait_state)
 347                 status = altera_goto_jstate(astate, wait_state);
 348 
 349         if (status == 0) {
 350                 /*
 351                  * Set TMS high to loop in RESET state
 352                  * Set TMS low to loop in any other stable state
 353                  */
 354                 tms = (wait_state == RESET) ? TMS_HIGH : TMS_LOW;
 355 
 356                 for (count = 0L; count < cycles; count++)
 357                         alt_jtag_io(tms, TDI_LOW, IGNORE_TDO);
 358 
 359         }
 360 
 361         return status;
 362 }
 363 
 364 int altera_wait_msecs(struct altera_state *astate,
 365                         s32 microseconds, enum altera_jtag_state wait_state)
 366 /*
 367  * Causes JTAG hardware to sit in the specified stable
 368  * state for the specified duration of real time.  If
 369  * no JTAG operations have been performed yet, then only
 370  * a delay is performed.  This permits the WAIT USECS
 371  * statement to be used in VECTOR programs without causing
 372  * any JTAG operations.
 373  * Returns 0 for success, else appropriate error code.
 374  */
 375 {
 376         struct altera_jtag *js = &astate->js;
 377         int status = 0;
 378 
 379         if ((js->jtag_state != ILLEGAL_JTAG_STATE) &&
 380             (js->jtag_state != wait_state))
 381                 status = altera_goto_jstate(astate, wait_state);
 382 
 383         if (status == 0)
 384                 /* Wait for specified time interval */
 385                 udelay(microseconds);
 386 
 387         return status;
 388 }
 389 
 390 static void altera_concatenate_data(u8 *buffer,
 391                                 u8 *preamble_data,
 392                                 u32 preamble_count,
 393                                 u8 *target_data,
 394                                 u32 start_index,
 395                                 u32 target_count,
 396                                 u8 *postamble_data,
 397                                 u32 postamble_count)
 398 /*
 399  * Copies preamble data, target data, and postamble data
 400  * into one buffer for IR or DR scans.
 401  */
 402 {
 403         u32 i, j, k;
 404 
 405         for (i = 0L; i < preamble_count; ++i) {
 406                 if (preamble_data[i >> 3L] & (1L << (i & 7L)))
 407                         buffer[i >> 3L] |= (1L << (i & 7L));
 408                 else
 409                         buffer[i >> 3L] &= ~(u32)(1L << (i & 7L));
 410 
 411         }
 412 
 413         j = start_index;
 414         k = preamble_count + target_count;
 415         for (; i < k; ++i, ++j) {
 416                 if (target_data[j >> 3L] & (1L << (j & 7L)))
 417                         buffer[i >> 3L] |= (1L << (i & 7L));
 418                 else
 419                         buffer[i >> 3L] &= ~(u32)(1L << (i & 7L));
 420 
 421         }
 422 
 423         j = 0L;
 424         k = preamble_count + target_count + postamble_count;
 425         for (; i < k; ++i, ++j) {
 426                 if (postamble_data[j >> 3L] & (1L << (j & 7L)))
 427                         buffer[i >> 3L] |= (1L << (i & 7L));
 428                 else
 429                         buffer[i >> 3L] &= ~(u32)(1L << (i & 7L));
 430 
 431         }
 432 }
 433 
 434 static int alt_jtag_drscan(struct altera_state *astate,
 435                         int start_state,
 436                         int count,
 437                         u8 *tdi,
 438                         u8 *tdo)
 439 {
 440         int i = 0;
 441         int tdo_bit = 0;
 442         int status = 1;
 443 
 444         /* First go to DRSHIFT state */
 445         switch (start_state) {
 446         case 0:                                         /* IDLE */
 447                 alt_jtag_io(1, 0, 0);   /* DRSELECT */
 448                 alt_jtag_io(0, 0, 0);   /* DRCAPTURE */
 449                 alt_jtag_io(0, 0, 0);   /* DRSHIFT */
 450                 break;
 451 
 452         case 1:                                         /* DRPAUSE */
 453                 alt_jtag_io(1, 0, 0);   /* DREXIT2 */
 454                 alt_jtag_io(1, 0, 0);   /* DRUPDATE */
 455                 alt_jtag_io(1, 0, 0);   /* DRSELECT */
 456                 alt_jtag_io(0, 0, 0);   /* DRCAPTURE */
 457                 alt_jtag_io(0, 0, 0);   /* DRSHIFT */
 458                 break;
 459 
 460         case 2:                                         /* IRPAUSE */
 461                 alt_jtag_io(1, 0, 0);   /* IREXIT2 */
 462                 alt_jtag_io(1, 0, 0);   /* IRUPDATE */
 463                 alt_jtag_io(1, 0, 0);   /* DRSELECT */
 464                 alt_jtag_io(0, 0, 0);   /* DRCAPTURE */
 465                 alt_jtag_io(0, 0, 0);   /* DRSHIFT */
 466                 break;
 467 
 468         default:
 469                 status = 0;
 470         }
 471 
 472         if (status) {
 473                 /* loop in the SHIFT-DR state */
 474                 for (i = 0; i < count; i++) {
 475                         tdo_bit = alt_jtag_io(
 476                                         (i == count - 1),
 477                                         tdi[i >> 3] & (1 << (i & 7)),
 478                                         (tdo != NULL));
 479 
 480                         if (tdo != NULL) {
 481                                 if (tdo_bit)
 482                                         tdo[i >> 3] |= (1 << (i & 7));
 483                                 else
 484                                         tdo[i >> 3] &= ~(u32)(1 << (i & 7));
 485 
 486                         }
 487                 }
 488 
 489                 alt_jtag_io(0, 0, 0);   /* DRPAUSE */
 490         }
 491 
 492         return status;
 493 }
 494 
 495 static int alt_jtag_irscan(struct altera_state *astate,
 496                     int start_state,
 497                     int count,
 498                     u8 *tdi,
 499                     u8 *tdo)
 500 {
 501         int i = 0;
 502         int tdo_bit = 0;
 503         int status = 1;
 504 
 505         /* First go to IRSHIFT state */
 506         switch (start_state) {
 507         case 0:                                         /* IDLE */
 508                 alt_jtag_io(1, 0, 0);   /* DRSELECT */
 509                 alt_jtag_io(1, 0, 0);   /* IRSELECT */
 510                 alt_jtag_io(0, 0, 0);   /* IRCAPTURE */
 511                 alt_jtag_io(0, 0, 0);   /* IRSHIFT */
 512                 break;
 513 
 514         case 1:                                         /* DRPAUSE */
 515                 alt_jtag_io(1, 0, 0);   /* DREXIT2 */
 516                 alt_jtag_io(1, 0, 0);   /* DRUPDATE */
 517                 alt_jtag_io(1, 0, 0);   /* DRSELECT */
 518                 alt_jtag_io(1, 0, 0);   /* IRSELECT */
 519                 alt_jtag_io(0, 0, 0);   /* IRCAPTURE */
 520                 alt_jtag_io(0, 0, 0);   /* IRSHIFT */
 521                 break;
 522 
 523         case 2:                                         /* IRPAUSE */
 524                 alt_jtag_io(1, 0, 0);   /* IREXIT2 */
 525                 alt_jtag_io(1, 0, 0);   /* IRUPDATE */
 526                 alt_jtag_io(1, 0, 0);   /* DRSELECT */
 527                 alt_jtag_io(1, 0, 0);   /* IRSELECT */
 528                 alt_jtag_io(0, 0, 0);   /* IRCAPTURE */
 529                 alt_jtag_io(0, 0, 0);   /* IRSHIFT */
 530                 break;
 531 
 532         default:
 533                 status = 0;
 534         }
 535 
 536         if (status) {
 537                 /* loop in the SHIFT-IR state */
 538                 for (i = 0; i < count; i++) {
 539                         tdo_bit = alt_jtag_io(
 540                                       (i == count - 1),
 541                                       tdi[i >> 3] & (1 << (i & 7)),
 542                                       (tdo != NULL));
 543                         if (tdo != NULL) {
 544                                 if (tdo_bit)
 545                                         tdo[i >> 3] |= (1 << (i & 7));
 546                                 else
 547                                         tdo[i >> 3] &= ~(u32)(1 << (i & 7));
 548 
 549                         }
 550                 }
 551 
 552                 alt_jtag_io(0, 0, 0);   /* IRPAUSE */
 553         }
 554 
 555         return status;
 556 }
 557 
 558 static void altera_extract_target_data(u8 *buffer,
 559                                 u8 *target_data,
 560                                 u32 start_index,
 561                                 u32 preamble_count,
 562                                 u32 target_count)
 563 /*
 564  * Copies target data from scan buffer, filtering out
 565  * preamble and postamble data.
 566  */
 567 {
 568         u32 i;
 569         u32 j;
 570         u32 k;
 571 
 572         j = preamble_count;
 573         k = start_index + target_count;
 574         for (i = start_index; i < k; ++i, ++j) {
 575                 if (buffer[j >> 3] & (1 << (j & 7)))
 576                         target_data[i >> 3] |= (1 << (i & 7));
 577                 else
 578                         target_data[i >> 3] &= ~(u32)(1 << (i & 7));
 579 
 580         }
 581 }
 582 
 583 int altera_irscan(struct altera_state *astate,
 584                                 u32 count,
 585                                 u8 *tdi_data,
 586                                 u32 start_index)
 587 /* Shifts data into instruction register */
 588 {
 589         struct altera_jtag *js = &astate->js;
 590         int start_code = 0;
 591         u32 alloc_chars = 0;
 592         u32 shift_count = js->ir_pre + count + js->ir_post;
 593         int status = 0;
 594         enum altera_jtag_state start_state = ILLEGAL_JTAG_STATE;
 595 
 596         switch (js->jtag_state) {
 597         case ILLEGAL_JTAG_STATE:
 598         case RESET:
 599         case IDLE:
 600                 start_code = 0;
 601                 start_state = IDLE;
 602                 break;
 603 
 604         case DRSELECT:
 605         case DRCAPTURE:
 606         case DRSHIFT:
 607         case DREXIT1:
 608         case DRPAUSE:
 609         case DREXIT2:
 610         case DRUPDATE:
 611                 start_code = 1;
 612                 start_state = DRPAUSE;
 613                 break;
 614 
 615         case IRSELECT:
 616         case IRCAPTURE:
 617         case IRSHIFT:
 618         case IREXIT1:
 619         case IRPAUSE:
 620         case IREXIT2:
 621         case IRUPDATE:
 622                 start_code = 2;
 623                 start_state = IRPAUSE;
 624                 break;
 625 
 626         default:
 627                 status = -EREMOTEIO;
 628                 break;
 629         }
 630 
 631         if (status == 0)
 632                 if (js->jtag_state != start_state)
 633                         status = altera_goto_jstate(astate, start_state);
 634 
 635         if (status == 0) {
 636                 if (shift_count > js->ir_length) {
 637                         alloc_chars = (shift_count + 7) >> 3;
 638                         kfree(js->ir_buffer);
 639                         js->ir_buffer = (u8 *)alt_malloc(alloc_chars);
 640                         if (js->ir_buffer == NULL)
 641                                 status = -ENOMEM;
 642                         else
 643                                 js->ir_length = alloc_chars * 8;
 644 
 645                 }
 646         }
 647 
 648         if (status == 0) {
 649                 /*
 650                  * Copy preamble data, IR data,
 651                  * and postamble data into a buffer
 652                  */
 653                 altera_concatenate_data(js->ir_buffer,
 654                                         js->ir_pre_data,
 655                                         js->ir_pre,
 656                                         tdi_data,
 657                                         start_index,
 658                                         count,
 659                                         js->ir_post_data,
 660                                         js->ir_post);
 661                 /* Do the IRSCAN */
 662                 alt_jtag_irscan(astate,
 663                                 start_code,
 664                                 shift_count,
 665                                 js->ir_buffer,
 666                                 NULL);
 667 
 668                 /* alt_jtag_irscan() always ends in IRPAUSE state */
 669                 js->jtag_state = IRPAUSE;
 670         }
 671 
 672         if (status == 0)
 673                 if (js->irstop_state != IRPAUSE)
 674                         status = altera_goto_jstate(astate, js->irstop_state);
 675 
 676 
 677         return status;
 678 }
 679 
 680 int altera_swap_ir(struct altera_state *astate,
 681                             u32 count,
 682                             u8 *in_data,
 683                             u32 in_index,
 684                             u8 *out_data,
 685                             u32 out_index)
 686 /* Shifts data into instruction register, capturing output data */
 687 {
 688         struct altera_jtag *js = &astate->js;
 689         int start_code = 0;
 690         u32 alloc_chars = 0;
 691         u32 shift_count = js->ir_pre + count + js->ir_post;
 692         int status = 0;
 693         enum altera_jtag_state start_state = ILLEGAL_JTAG_STATE;
 694 
 695         switch (js->jtag_state) {
 696         case ILLEGAL_JTAG_STATE:
 697         case RESET:
 698         case IDLE:
 699                 start_code = 0;
 700                 start_state = IDLE;
 701                 break;
 702 
 703         case DRSELECT:
 704         case DRCAPTURE:
 705         case DRSHIFT:
 706         case DREXIT1:
 707         case DRPAUSE:
 708         case DREXIT2:
 709         case DRUPDATE:
 710                 start_code = 1;
 711                 start_state = DRPAUSE;
 712                 break;
 713 
 714         case IRSELECT:
 715         case IRCAPTURE:
 716         case IRSHIFT:
 717         case IREXIT1:
 718         case IRPAUSE:
 719         case IREXIT2:
 720         case IRUPDATE:
 721                 start_code = 2;
 722                 start_state = IRPAUSE;
 723                 break;
 724 
 725         default:
 726                 status = -EREMOTEIO;
 727                 break;
 728         }
 729 
 730         if (status == 0)
 731                 if (js->jtag_state != start_state)
 732                         status = altera_goto_jstate(astate, start_state);
 733 
 734         if (status == 0) {
 735                 if (shift_count > js->ir_length) {
 736                         alloc_chars = (shift_count + 7) >> 3;
 737                         kfree(js->ir_buffer);
 738                         js->ir_buffer = (u8 *)alt_malloc(alloc_chars);
 739                         if (js->ir_buffer == NULL)
 740                                 status = -ENOMEM;
 741                         else
 742                                 js->ir_length = alloc_chars * 8;
 743 
 744                 }
 745         }
 746 
 747         if (status == 0) {
 748                 /*
 749                  * Copy preamble data, IR data,
 750                  * and postamble data into a buffer
 751                  */
 752                 altera_concatenate_data(js->ir_buffer,
 753                                         js->ir_pre_data,
 754                                         js->ir_pre,
 755                                         in_data,
 756                                         in_index,
 757                                         count,
 758                                         js->ir_post_data,
 759                                         js->ir_post);
 760 
 761                 /* Do the IRSCAN */
 762                 alt_jtag_irscan(astate,
 763                                 start_code,
 764                                 shift_count,
 765                                 js->ir_buffer,
 766                                 js->ir_buffer);
 767 
 768                 /* alt_jtag_irscan() always ends in IRPAUSE state */
 769                 js->jtag_state = IRPAUSE;
 770         }
 771 
 772         if (status == 0)
 773                 if (js->irstop_state != IRPAUSE)
 774                         status = altera_goto_jstate(astate, js->irstop_state);
 775 
 776 
 777         if (status == 0)
 778                 /* Now extract the returned data from the buffer */
 779                 altera_extract_target_data(js->ir_buffer,
 780                                         out_data, out_index,
 781                                         js->ir_pre, count);
 782 
 783         return status;
 784 }
 785 
 786 int altera_drscan(struct altera_state *astate,
 787                                 u32 count,
 788                                 u8 *tdi_data,
 789                                 u32 start_index)
 790 /* Shifts data into data register (ignoring output data) */
 791 {
 792         struct altera_jtag *js = &astate->js;
 793         int start_code = 0;
 794         u32 alloc_chars = 0;
 795         u32 shift_count = js->dr_pre + count + js->dr_post;
 796         int status = 0;
 797         enum altera_jtag_state start_state = ILLEGAL_JTAG_STATE;
 798 
 799         switch (js->jtag_state) {
 800         case ILLEGAL_JTAG_STATE:
 801         case RESET:
 802         case IDLE:
 803                 start_code = 0;
 804                 start_state = IDLE;
 805                 break;
 806 
 807         case DRSELECT:
 808         case DRCAPTURE:
 809         case DRSHIFT:
 810         case DREXIT1:
 811         case DRPAUSE:
 812         case DREXIT2:
 813         case DRUPDATE:
 814                 start_code = 1;
 815                 start_state = DRPAUSE;
 816                 break;
 817 
 818         case IRSELECT:
 819         case IRCAPTURE:
 820         case IRSHIFT:
 821         case IREXIT1:
 822         case IRPAUSE:
 823         case IREXIT2:
 824         case IRUPDATE:
 825                 start_code = 2;
 826                 start_state = IRPAUSE;
 827                 break;
 828 
 829         default:
 830                 status = -EREMOTEIO;
 831                 break;
 832         }
 833 
 834         if (status == 0)
 835                 if (js->jtag_state != start_state)
 836                         status = altera_goto_jstate(astate, start_state);
 837 
 838         if (status == 0) {
 839                 if (shift_count > js->dr_length) {
 840                         alloc_chars = (shift_count + 7) >> 3;
 841                         kfree(js->dr_buffer);
 842                         js->dr_buffer = (u8 *)alt_malloc(alloc_chars);
 843                         if (js->dr_buffer == NULL)
 844                                 status = -ENOMEM;
 845                         else
 846                                 js->dr_length = alloc_chars * 8;
 847 
 848                 }
 849         }
 850 
 851         if (status == 0) {
 852                 /*
 853                  * Copy preamble data, DR data,
 854                  * and postamble data into a buffer
 855                  */
 856                 altera_concatenate_data(js->dr_buffer,
 857                                         js->dr_pre_data,
 858                                         js->dr_pre,
 859                                         tdi_data,
 860                                         start_index,
 861                                         count,
 862                                         js->dr_post_data,
 863                                         js->dr_post);
 864                 /* Do the DRSCAN */
 865                 alt_jtag_drscan(astate, start_code, shift_count,
 866                                 js->dr_buffer, NULL);
 867                 /* alt_jtag_drscan() always ends in DRPAUSE state */
 868                 js->jtag_state = DRPAUSE;
 869         }
 870 
 871         if (status == 0)
 872                 if (js->drstop_state != DRPAUSE)
 873                         status = altera_goto_jstate(astate, js->drstop_state);
 874 
 875         return status;
 876 }
 877 
 878 int altera_swap_dr(struct altera_state *astate, u32 count,
 879                                 u8 *in_data, u32 in_index,
 880                                 u8 *out_data, u32 out_index)
 881 /* Shifts data into data register, capturing output data */
 882 {
 883         struct altera_jtag *js = &astate->js;
 884         int start_code = 0;
 885         u32 alloc_chars = 0;
 886         u32 shift_count = js->dr_pre + count + js->dr_post;
 887         int status = 0;
 888         enum altera_jtag_state start_state = ILLEGAL_JTAG_STATE;
 889 
 890         switch (js->jtag_state) {
 891         case ILLEGAL_JTAG_STATE:
 892         case RESET:
 893         case IDLE:
 894                 start_code = 0;
 895                 start_state = IDLE;
 896                 break;
 897 
 898         case DRSELECT:
 899         case DRCAPTURE:
 900         case DRSHIFT:
 901         case DREXIT1:
 902         case DRPAUSE:
 903         case DREXIT2:
 904         case DRUPDATE:
 905                 start_code = 1;
 906                 start_state = DRPAUSE;
 907                 break;
 908 
 909         case IRSELECT:
 910         case IRCAPTURE:
 911         case IRSHIFT:
 912         case IREXIT1:
 913         case IRPAUSE:
 914         case IREXIT2:
 915         case IRUPDATE:
 916                 start_code = 2;
 917                 start_state = IRPAUSE;
 918                 break;
 919 
 920         default:
 921                 status = -EREMOTEIO;
 922                 break;
 923         }
 924 
 925         if (status == 0)
 926                 if (js->jtag_state != start_state)
 927                         status = altera_goto_jstate(astate, start_state);
 928 
 929         if (status == 0) {
 930                 if (shift_count > js->dr_length) {
 931                         alloc_chars = (shift_count + 7) >> 3;
 932                         kfree(js->dr_buffer);
 933                         js->dr_buffer = (u8 *)alt_malloc(alloc_chars);
 934 
 935                         if (js->dr_buffer == NULL)
 936                                 status = -ENOMEM;
 937                         else
 938                                 js->dr_length = alloc_chars * 8;
 939 
 940                 }
 941         }
 942 
 943         if (status == 0) {
 944                 /*
 945                  * Copy preamble data, DR data,
 946                  * and postamble data into a buffer
 947                  */
 948                 altera_concatenate_data(js->dr_buffer,
 949                                 js->dr_pre_data,
 950                                 js->dr_pre,
 951                                 in_data,
 952                                 in_index,
 953                                 count,
 954                                 js->dr_post_data,
 955                                 js->dr_post);
 956 
 957                 /* Do the DRSCAN */
 958                 alt_jtag_drscan(astate,
 959                                 start_code,
 960                                 shift_count,
 961                                 js->dr_buffer,
 962                                 js->dr_buffer);
 963 
 964                 /* alt_jtag_drscan() always ends in DRPAUSE state */
 965                 js->jtag_state = DRPAUSE;
 966         }
 967 
 968         if (status == 0)
 969                 if (js->drstop_state != DRPAUSE)
 970                         status = altera_goto_jstate(astate, js->drstop_state);
 971 
 972         if (status == 0)
 973                 /* Now extract the returned data from the buffer */
 974                 altera_extract_target_data(js->dr_buffer,
 975                                         out_data,
 976                                         out_index,
 977                                         js->dr_pre,
 978                                         count);
 979 
 980         return status;
 981 }
 982 
 983 void altera_free_buffers(struct altera_state *astate)
 984 {
 985         struct altera_jtag *js = &astate->js;
 986         /* If the JTAG interface was used, reset it to TLR */
 987         if (js->jtag_state != ILLEGAL_JTAG_STATE)
 988                 altera_jreset_idle(astate);
 989 
 990         kfree(js->dr_pre_data);
 991         js->dr_pre_data = NULL;
 992 
 993         kfree(js->dr_post_data);
 994         js->dr_post_data = NULL;
 995 
 996         kfree(js->dr_buffer);
 997         js->dr_buffer = NULL;
 998 
 999         kfree(js->ir_pre_data);
1000         js->ir_pre_data = NULL;
1001 
1002         kfree(js->ir_post_data);
1003         js->ir_post_data = NULL;
1004 
1005         kfree(js->ir_buffer);
1006         js->ir_buffer = NULL;
1007 }
/* [<][>][^][v][top][bottom][index][help] */
root/drivers/misc/altera-stapl/altera-jtag.c

DEFINITIONS
