Module: Origen::Pins

Included in:
Port
Defined in:
lib/origen/pins.rb,
lib/origen/pins/pin.rb,
lib/origen/pins/port.rb,
lib/origen/pins/pin_bank.rb,
lib/origen/pins/pin_clock.rb,
lib/origen/pins/power_pin.rb,
lib/origen/pins/ground_pin.rb,
lib/origen/pins/pin_common.rb,
lib/origen/pins/function_proxy.rb,
lib/origen/pins/pin_collection.rb

Overview

****** These notes refer to the pin model for the upcoming Origen V3 ******

Pin muxing and grouping on modern SoCs can be incredibly complex, Origen provides the following pin model architecture which should hopefully be sufficient to accurately model even the most complex of cases…

At the lowest layer are the pin objects, one per physical pin on a DUT. Each pin can store 1-bit of data with directional/state information for pattern generation, and additional metadata about the function of that pin in different modes of operation.

pin1                        pin2                        pin3                        pin4

Package

Packages are the first layer of filtering that can be applied to pins, each pin has a package hash which contains information about which packages it is available in and any additional metadata associated with the pin when in that package - for example what package pin location it is.

pin1                        pin2                        pin3                        pin4
  packages:                   packages:                   packages:                   packages:
    p1:                         p1:                         p1:
      location: "A5"              location: "B2"              location: "B3"
    p2:                                                     p2:
      location: "A5"                                          location: "B2"

Based on the above metadata these pins will work as follows within an SoC model:

$dut.package                     # => :none
$dut.pins.size                   # => 4

$dut.with_package :p1 do
  $dut.pins.size                 # => 3     (No pin4)
  $dut.pin(:pin1).location       # => "A5"
  $dut.has_pin?(:pin2)           # => true
  $dut.pin(:pin2).location       # => "B2"
  $dut.pin(:pin3).location       # => "B3"
end

$dut.with_package :p2 do
  $dut.pins.size                 # => 2     (No pin2 or pin4)
  $dut.pin(:pin1).location       # => "A5"
  $dut.has_pin?(:pin2)           # => false
  $dut.pin(:pin2).location       # => ERROR! The soc does not have pin 2 in the current configuration!
  $dut.pin(:pin3).location       # => "B2"
end

Aside from a physical package the packages attribute can also be used to model pseudo-packages like the subset of pins that are available in a probe or burn-in setup for example.

Pins availability can also be scoped by SoC mode and configuration…

Mode

The SoC mode attribute is inteded to be used to model top-level operating modes, such as functional test, RAMBIST, NVMBIST, etc. As such it is a top-level attribute similar to package attribute e.g. the SoC can be in RAMBIST mode within package P1, or it could be in User mode within package P2.

Configuration

The configuration scope should be used to model pin muxing that can occur independently of the SoC mode, for example in a functional test mode many different pin configurations may exist based on the IP modules that are enabled or disabled at runtime. Unlike the mode the configuration attribute can also be set at pin level as well. Any configuration attribute set on a pin will override the configuration attribute that is currently live on the SoC. This allows individual pins, or perhaps more commonly individual pin groups, to be set to a particular configuration independently of the other pins or the SoC.

The mode and configuration attributes at pin level are similar to those for the package, each pin also has a current_configuration attribute which will override the current_configuration attribute of the SoC when present. Each mode and configuration entry will be hash for storing meta data as required.

pin1                        pin2                        pin3                        pin4
  modes:                      modes:                      modes:                      modes:
    user:                       user:                       user:
    nvmbist:                    nvmbist:
  configurations:             configurations:             configurations:             configurations:
    default:                    default:                    default:                    default:
    alt0:                       alt1:                       alt0:
                                                            alt1:

Pin availability will be scoped accordingly when the mode and configuration of the SoC model is changed.

Although not shown in this example all of these filters are AND’d together, so a pin is only available if it is available in the current package, mode and configuration.

$dut.mode                        # => :none
$dut.configuration               # => :none

$dut.pins.size                   # => 4
$dut.mode = :user
$dut.pins.size                   # => 3   (No pin4)

$dut.configuration = :alt0
$dut.pins.size                   # => 2   (No pin2 or pin4)
# Set the configuration of pin2 directly, the all_pins method will bypass the current scope
# when looking up a pin
$dut.all_pins(:pin2).configuration = :alt1
$dut.pins.size                   # => 3   (pin2 is now available to)

While not shown here an additional value of :all can be set when specifying the mode/configuration attributes of a given pin and which means that it will be available in all modes and/or configurations.

Functions

Each pin can have multiple functions associated with it which is intended to reflect the current signal that is mux’d onto it. Functions are scoped by mode and configuration (not package) and only one function can exist per mode/configuration combo.

Again the reserved mode/configuration name :all can be used here to reflect a function that will be common to all modes/configurations unless a more specific function has been declared. The top-level key of the functions hash is the mode, then the configuration and then the meta data associated with that selection:

pin1                        pin2                        pin3                        pin4
  functions:                  functions:                  functions:                  functions:
    user:                       user:                       user:
      all:                        default:                    default:
        name: "TDI"                  name: "PORTA0"              name: "PORTA1"
        direction: :input            direction: :io              direction: :io
                                  alt1:                       alt0:
                                     name: "SPI0"                name: "IIC0"
                                     direction: :io              direction: :output
                                                              alt1:
                                                                 name: "SPI1"
                                                                 direction: :io
    nvmbist:                    nvmbist:
      all:                        all:
        name: "NVM_FAIL"            name: "NVM_DONE"
        direction: :output          direction: :output

The function attributes returned will automatically scope to the current SoC state:

$dut.mode = :user
$dut.pin(:pin1).name             # => "TDI"
$dut.pin(:pin1).direction        # => :input

$dut.mode = :nvmbist
$dut.pin(:pin1).name             # => "NVM_FAIL"
$dut.pin(:pin1).direction        # => :output

Aliases

Aliases are alternative names/handles to give to pins when using them to create patterns and other IP in Origen. Aliases can be made universal in which case they will work regardless of scope, or they can be scoped to the current package, mode and configuration.

The Origen pin API will automatically create scoped aliases for functions and package locations as they are declared, so for example:

$dut.mode = :user
$dut.pin(:pin1).name             # => "TDI"
$dut.pin(:tdi).name              # => "TDI"
$dut.has_pin?(:nvm_fail)         # => false
$dut.pin(:nvm_fail).name         # => ERROR! No pin called NVM_FAIL in the current scope!

$dut.mode = :nvmbist
$dut.pin(:pin1).name             # => "NVM_FAIL"
$dut.has_pin?(:nvm_fail)         # => true
$dut.pin(:nvm_fail).name         # => "NVM_FAIL"

*Pin Groups*

Pin groups will be similar to aliases in that they can be made universal or scoped to a specific package/mode/ configuration.

While aliases are simply pointers to pin objects pin groups will themselves be an Origen object which will be like a Ruby array with additional metadata attached (such as a name) and a dedicated API for working with the pins. Generally a pin and pingroup will respond to the same API so that calling code does not need to worry very much about dealing with a single pin vs. a collection.

Defined Under Namespace

Modules: PinCommon Classes: FunctionProxy, GroundPin, Pin, PinBank, PinClock, PinCollection, Port, PowerPin

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.clear_pin_aliases ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

API v2, deprecated



184
185
186
 
# File 'lib/origen/pins.rb', line 184

def self.clear_pin_aliases
  @@pin_aliases = {}
end

.pin_aliases ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Aliases are stored in a global array that is cleared out everytime the target is loaded, while a bit hacky this is an easy way to allow sub modules to defined con

API v2, deprecated



194
195
196
 
# File 'lib/origen/pins.rb', line 194

def self.pin_aliases
  @@pin_aliases ||= {}
end

Instance Method Details

#add_ground_pin(id = nil, options = {}, &block) ⇒ Object Also known as: add_ground_pins 



270
271
272
273
274
275
276
 
# File 'lib/origen/pins.rb', line 270

def add_ground_pin(id = nil, options = {}, &block)
  id, options = nil, id if id.is_a?(Hash)
  options = {
    ground_pin: true
  }.merge(options)
  add_pin(id, options, &block)
end

#add_ground_pin_group(id, *pins, &block) ⇒ Object 



455
456
457
458
459
460
461
462
463
464
465
 
# File 'lib/origen/pins.rb', line 455

def add_ground_pin_group(id, *pins, &block)
  if pins.last.is_a?(Hash)
    options = pins.pop
  else
    options = {}
  end
  options = {
    ground_pin: true
  }.merge(options)
  add_pin_group(id, *pins, options, &block)
end

#add_pin(id = nil, options = {}, &_block) ⇒ Object Also known as: add_pins

Use this method to add any pins that are considered owned by the given object. Pins declared via this method will be accessible within the object via pin(:pinname) or if you prefer self.pin(:pinname). Externally you would refer to it via $top.pin(:pinname) or $soc.pin(:pinname) or even $top.sub_module.pin(:pinname) depending on where you called this method. Pins are output in the pattern in the order that they are declared. A minimum declaration is this:

add_pin  :d_out        # A single pin that will be set to :dont_care by default

To set the initial state at the same time:

add_pin  :d_in,   :reset => :drive_hi
add_pin  :invoke, :reset => :drive_lo

You can override the name that appears in the pattern by providing a string as the last argument

add_pin  :done,   :reset => :expect_hi, :name => "bist_done"
add_pin  :fail,                         :name => "bist_fail"



213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
 
# File 'lib/origen/pins.rb', line 213

def add_pin(id = nil, options = {}, &_block)
  id, options = nil, id if id.is_a?(Hash)
  power_pin = options.delete(:power_pin)
  ground_pin = options.delete(:ground_pin)
  if options[:size] && options[:size] > 1
    group = PinCollection.new(self, options.merge(placeholder: true))
    group.id = id if id
    options = {
      name: ''
    }.merge(options)

    options.delete(:size).times do |i|
      options[:name] = "#{id}#{i}".to_sym

      if power_pin
        group[i] = PowerPin.new(i, self, options)
      elsif ground_pin
        group[i] = GroundPin.new(i, self, options)
      else
        group[i] = Pin.new(i, self, options)
      end
      group[i].invalidate_group_cache
    end
    yield group if block_given?
    group.each do |pin|
      pin.id = "#{group.id}#{pin.id}".to_sym
      pin.finalize
    end
    if group.size == 1
      Origen.pin_bank.add_pin(group.first, self, options)
    else
      Origen.pin_bank.add_pin_group(group, self, options)
    end
  else
    if power_pin
      pin = PowerPin.new(id || :temp, self, options)
    elsif ground_pin
      pin = GroundPin.new(id || :temp, self, options)
    else
      pin = Pin.new(id || :temp, self, options)
    end
    yield pin if block_given?
    pin.finalize
    Origen.pin_bank.add_pin(pin, self, options)
  end
end

#add_pin_alias(new_name, original_name, options = {}) ⇒ Object Also known as: pin_alias, alias_pin, add_port_alias 



321
322
323
324
325
326
327
328
329
330
331
 
# File 'lib/origen/pins.rb', line 321

def add_pin_alias(new_name, original_name, options = {})
  if pin_groups.include?(original_name) # this is a pin group
    if options[:pin] # alias single pin from a pin group
      pin(original_name)[options[:pin]].add_alias(new_name, options)
    else # alias subset of pins from a pin group
      add_pin_group_alias(new_name, original_name, options)
    end
  else # this is a pin
    pin(original_name).add_alias(new_name, options)
  end
end

#add_pin_group(id, *pins, &_block) ⇒ Object 



394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
 
# File 'lib/origen/pins.rb', line 394

def add_pin_group(id, *pins, &_block)
  if pins.last.is_a?(Hash)
    options = pins.pop
  else
    options = {}
  end
  # check if this is a pin group alias

  found = false
  group = nil
  unless options[:pins_only] == true
    pins.each do |i|
      if pin_groups.include?(i)
        group = add_pin_group_alias(id, i, options)
        found = true
      end
    end
  end
  unless found # not a pin group alias
    group = Origen.pin_bank.find_or_create_pin_group(id, self, options)
    if block_given?
      yield group
    else
      # SMcG:
      #
      # Not 100% sure that this is right, but the idea here is that when manually defining a pin
      # group the user will naturally think in endian order. e.g. when defining a big endian group
      # they would do:
      #
      #   add_pin_group :pa, :pa7, :pa5, :pa1, :pa0
      #
      # But if it was little endian they would probably do:
      #
      #   add_pin_group :pa, :pa0, :pa1, :pa5, :pa7, :endian => :little
      #
      # However I never work on little endian ports so I don't know for sure!
      #
      # In both cases though we always want pins(:pa)[0] to return :pa0.
      if options[:endian] == :little
        pins.each { |pin| group.add_pin(pin, options) }
      else
        pins.reverse_each { |pin| group.add_pin(pin, options) }
      end
    end
  end
  group
  # Origen.pin_bank.add_pin_group(group, self, {:pins_exist => true}.merge(options))
end

#add_pin_group_alias(new_name, original_name, options = {}) ⇒ Object 



336
337
338
339
340
341
342
343
344
345
346
 
# File 'lib/origen/pins.rb', line 336

def add_pin_group_alias(new_name, original_name, options = {})
  group = Origen.pin_bank.find_or_create_pin_group(new_name, self, options)
  if options[:pins] # alias to range of pins from a pin group
    options[:pins].each do |mypin|
      pin(new_name).add_pin(pin(original_name)[mypin])
    end
  else
    pin(original_name).each_with_index { |_pin, i| pin(new_name).add_pin(pin(original_name)[i]) }
  end
  group
end

#add_pin_object(pin) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

API v2, deprecated



691
692
693
694
 
# File 'lib/origen/pins.rb', line 691

def add_pin_object(pin)
  @pins ||= {}
  @pins[@pins.size] = pin
end

#add_port(id, options = {}) ⇒ Object

API v2, deprecated



317
318
319
 
# File 'lib/origen/pins.rb', line 317

def add_port(id, options = {})
  add_pins(id, options)
end

#add_power_pin(id = nil, options = {}, &block) ⇒ Object Also known as: add_power_pins 



261
262
263
264
265
266
267
 
# File 'lib/origen/pins.rb', line 261

def add_power_pin(id = nil, options = {}, &block)
  id, options = nil, id if id.is_a?(Hash)
  options = {
    power_pin: true
  }.merge(options)
  add_pin(id, options, &block)
end

#add_power_pin_group(id, *pins, &block) ⇒ Object 



443
444
445
446
447
448
449
450
451
452
453
 
# File 'lib/origen/pins.rb', line 443

def add_power_pin_group(id, *pins, &block)
  if pins.last.is_a?(Hash)
    options = pins.pop
  else
    options = {}
  end
  options = {
    power_pin: true
  }.merge(options)
  add_pin_group(id, *pins, options, &block)
end

#all_ground_pins(id = nil, _options = {}, &_block) ⇒ Object

Equivalent to the all_pins method but considers ground pins rather than regular pins



490
491
492
493
494
495
496
 
# File 'lib/origen/pins.rb', line 490

def all_ground_pins(id = nil, _options = {}, &_block)
  if id
    pin = Origen.pin_bank.find(id, ignore_context: true, ground_pin: true)
  else
    Origen.pin_bank.all_ground_pins
  end
end

#all_pins(id = nil, _options = {}, &_block) ⇒ Object

Similar to the pins method except that this method will bypass the package/mode/configuration scope.

Therefore with no id supplied it will return all known pins and with an id it will return the given pin object regardless of where or not it is enabled by the current context



472
473
474
475
476
477
478
 
# File 'lib/origen/pins.rb', line 472

def all_pins(id = nil, _options = {}, &_block)
  if id
    pin = Origen.pin_bank.find(id, ignore_context: true)
  else
    Origen.pin_bank.all_pins
  end
end

#all_power_pins(id = nil, _options = {}, &_block) ⇒ Object

Equivalent to the all_pins method but considers power pins rather than regular pins



481
482
483
484
485
486
487
 
# File 'lib/origen/pins.rb', line 481

def all_power_pins(id = nil, _options = {}, &_block)
  if id
    pin = Origen.pin_bank.find(id, ignore_context: true, power_pin: true)
  else
    Origen.pin_bank.all_power_pins
  end
end

#clean_pin_arg(pin) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Returns an array of ids, regardless if the input is a single number, an array, a range, or an array contaning a range

API v2, deprecated



667
668
669
670
 
# File 'lib/origen/pins.rb', line 667

def clean_pin_arg(pin)
  pin = [pin].flatten
  pin.map { |obj| range_to_array(obj) }.flatten.sort
end

#delete_all_pins ⇒ Object 



616
617
618
 
# File 'lib/origen/pins.rb', line 616

def delete_all_pins
  Origen.pin_bank.send :empty!
end

#delete_pin(id, options = {}) ⇒ Object

Delete any pin or pin group. If arg is a pin then delete the pin and any instances of it in any pin groups



622
623
624
625
626
627
628
629
630
631
632
 
# File 'lib/origen/pins.rb', line 622

def delete_pin(id, options = {})
  id = id.to_sym
  # Check if this is a Pin or a PinGroup
  if pin_groups.key? id
    Origen.pin_bank.delete_pingroup(Origen.pin_bank.find_pin_group(id, options))
  elsif pins(id).class.to_s.match(/Pin/)
    Origen.pin_bank.delete_pin(Origen.pin_bank.find(id, options))
  else
    fail "Error: the object #{id} you tried to delete is not a pin or pingroup"
  end
end

#ground_pin_groups(id = nil, options = {}, &_block) ⇒ Object Also known as: ground_pin_group

Equivalent to the pin_groups method but considers ground pins rather than regular pins



542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
 
# File 'lib/origen/pins.rb', line 542

def ground_pin_groups(id = nil, options = {}, &_block)
  id, options = nil, id if id.is_a?(Hash)
  if id
    pin = Origen.pin_bank.find(id, options.merge(ground_pin: true))
    unless pin
      puts <<-END
You have tried to reference ground_pin_group :#{id} within #{self.class} but it does not exist, this could be
because the pin group has not been defined yet or it is an alias that is not available in the current context.

If you meant to define the ground_pin_group then use the add_ground_pin_group method instead.

      END
      fail 'Power pin group not found'
    end
    pin
  else
    Origen.pin_bank.ground_pin_groups(options)
  end
end

#ground_pins(id = nil, options = {}, &block) ⇒ Object

Equivalent to the pins method but considers ground pins rather than regular pins



608
609
610
611
612
613
614
 
# File 'lib/origen/pins.rb', line 608

def ground_pins(id = nil, options = {}, &block)
  id, options = nil, id if id.is_a?(Hash)
  options = {
    ground_pin: true
  }.merge(options)
  pins(id, options, &block)
end

#has_ground_pin?(id) ⇒ Boolean Also known as: has_ground_pins?

Equivalent to the has_pin? method but considers ground pins rather than regular pins

Returns:

  • (Boolean) 


389
390
391
 
# File 'lib/origen/pins.rb', line 389

def has_ground_pin?(id)
  !!Origen.pin_bank.find(id, ground_pin: true)
end

#has_pin?(id) ⇒ Boolean Also known as: has_pins?

Returns true if the module has access to a pin with the given name within the current context

Returns:

  • (Boolean) 


377
378
379
 
# File 'lib/origen/pins.rb', line 377

def has_pin?(id)
  !!Origen.pin_bank.find(id)
end

#has_power_pin?(id) ⇒ Boolean Also known as: has_power_pins?

Equivalent to the has_pin? method but considers power pins rather than regular pins

Returns:

  • (Boolean) 


383
384
385
 
# File 'lib/origen/pins.rb', line 383

def has_power_pin?(id)
  !!Origen.pin_bank.find(id, power_pin: true)
end

#pin_aliases ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

API v2, deprecated



351
352
353
354
355
356
357
358
359
 
# File 'lib/origen/pins.rb', line 351

def pin_aliases
  # Clear this out every time the target changes
  if !(defined? @@pin_aliases_target) ||
     (@@pin_aliases_target != Origen.target.signature)
    Origen::Pins.clear_pin_aliases
    @@pin_aliases_target = Origen.target.signature
  end
  Origen::Pins.pin_aliases
end

#pin_groups(id = nil, options = {}, &_block) ⇒ Object Also known as: pin_group 



498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
 
# File 'lib/origen/pins.rb', line 498

def pin_groups(id = nil, options = {}, &_block)
  id, options = nil, id if id.is_a?(Hash)
  if id
    pin = Origen.pin_bank.find(id, options)
    unless pin
      puts <<-END
You have tried to reference pin_group :#{id} within #{self.class} but it does not exist, this could be
because the pin has not been defined yet or it is an alias that is not available in the current context.

If you meant to define the pin_group then use the add_pin_group method instead.

      END
      fail 'Pin not found'
    end
    pin
  else
    Origen.pin_bank.pin_groups(options)
  end
end

#pin_order ⇒ Object

API v2, deprecated



362
363
364
365
 
# File 'lib/origen/pins.rb', line 362

def pin_order
  @pin_order ||= 10_000_000
  @pin_order += 1
end

#pin_order_block(order) ⇒ Object

API v2, deprecated



368
369
370
371
372
373
 
# File 'lib/origen/pins.rb', line 368

def pin_order_block(order)
  pin_order_orig = @pin_order
  @pin_order = order * 1000
  yield
  @pin_order = pin_order_orig
end

#pin_pattern_exclude(*pin_ids) ⇒ Object

Specifiy the pins will not appear in the output pattern



300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
 
# File 'lib/origen/pins.rb', line 300

def pin_pattern_exclude(*pin_ids)
  if pin_ids.last.is_a?(Hash)
    options = pin_ids.pop
  else
    options = {}
  end
  pin_ids.each do |id|
    if pin_aliases[id]
      Origen.app.pin_names[pin_aliases[id].first] = id
      id = pin_aliases[id].first
    end
    Origen.app.pin_pattern_exclude << id
  end
  Origen.app.pin_pattern_exclude << options unless options.empty?
end

#pin_pattern_order(*pin_ids) ⇒ Object

Specifiy the order that pins will appear in the output pattern, unspecified pins will appear in an arbitrary order at the end

API v2, deprecated



283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
 
# File 'lib/origen/pins.rb', line 283

def pin_pattern_order(*pin_ids)
  if pin_ids.last.is_a?(Hash)
    options = pin_ids.pop
  else
    options = {}
  end
  pin_ids.each do |id|
    if pin_aliases[id]
      Origen.app.pin_names[pin_aliases[id].first] = id
      id = pin_aliases[id].first
    end
    Origen.app.pin_pattern_order << id
  end
  Origen.app.pin_pattern_order << options unless options.empty?
end

#pins(id = nil, options = {}, &_block) ⇒ Object Also known as: pin, port, ports

Permits access via object.pin(x), returns a hash of all pins if no id is specified.

Examples

$top.pin(:done)
$soc.pin(:port_a1)
pin(:fail)          # Access directly from within the module



569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
 
# File 'lib/origen/pins.rb', line 569

def pins(id = nil, options = {}, &_block)
  id, options = nil, id if id.is_a?(Hash)
  if id
    pin = Origen.pin_bank.find(id, options)
    unless pin
      puts <<-END
You have tried to reference pin :#{id} within #{self.class} but it does not exist, this could be
because the pin has not been defined yet or it is an alias that is not available in the current context.

If you meant to define the pin then use the add_pin method instead.

      END
      fail 'Pin not found'
    end
    pin
  else
    if options[:power_pin]
      Origen.pin_bank.power_pins
    elsif options[:ground_pin]
      Origen.pin_bank.ground_pins
    else
      Origen.pin_bank.pins
    end
  end
end

#power_pin_groups(id = nil, options = {}, &_block) ⇒ Object Also known as: power_pin_group

Equivalent to the pin_groups method but considers power pins rather than regular pins



520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
 
# File 'lib/origen/pins.rb', line 520

def power_pin_groups(id = nil, options = {}, &_block)
  id, options = nil, id if id.is_a?(Hash)
  if id
    pin = Origen.pin_bank.find(id, options.merge(power_pin: true))
    unless pin
      puts <<-END
You have tried to reference power_pin_group :#{id} within #{self.class} but it does not exist, this could be
because the pin group has not been defined yet or it is an alias that is not available in the current context.

If you meant to define the power_pin_group then use the add_power_pin_group method instead.

      END
      fail 'Power pin group not found'
    end
    pin
  else
    Origen.pin_bank.power_pin_groups(options)
  end
end

#power_pins(id = nil, options = {}, &block) ⇒ Object

Equivalent to the pins method but considers power pins rather than regular pins



599
600
601
602
603
604
605
 
# File 'lib/origen/pins.rb', line 599

def power_pins(id = nil, options = {}, &block)
  id, options = nil, id if id.is_a?(Hash)
  options = {
    power_pin: true
  }.merge(options)
  pins(id, options, &block)
end

#range_to_array(range) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

API v2, deprecated



675
676
677
678
679
680
681
682
683
684
685
686
687
 
# File 'lib/origen/pins.rb', line 675

def range_to_array(range)
  if range.is_a?(Range)
    a = range.first
    b = range.last
    if a > b
      (b..a).to_a
    else
      (a..b).to_a
    end
  else
    range
  end
end

#resolve_pin(obj, options) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

If the pin is a port it will select the target pin from it based on the options

API v2, deprecated



639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
 
# File 'lib/origen/pins.rb', line 639

def resolve_pin(obj, options)
  if obj.is_a?(Port)
    pins = options[:pin] || options[:pins]
    if pins
      pins = clean_pin_arg(pins)
      if pins.size == 1
        obj[pins.first]
      else
        port = Port.new("subset_of_#{obj.id}", obj.owner, add_pins: false, size: pins.size)
        pins.each do |pin|
          port.add_pin_object(obj[pin])
        end
        port
      end
    else
      obj
    end
  else
    obj
  end
end