int print_trigger(struct cli_state *state,
bladerf_module module, bladerf_trigger_signal signal)
{
int status;
struct bladerf_trigger t;
bool master, armed, fired, fire_req;
const char *sig_str, *role_str, *module_str;
status = bladerf_trigger_init(state->dev, module, signal, &t);
if (status != 0) {
goto out;
}
status = bladerf_trigger_state(state->dev, &t,
&armed, &fired, &fire_req, NULL, NULL);
if (status != 0) {
goto out;
}
printf("\n");
master = (t.role == BLADERF_TRIGGER_ROLE_MASTER);
role_str = triggerrole2str(t.role);
sig_str = trigger2str(signal);
module_str = module2str(module);
printf(" %s %s trigger\n", sig_str, module_str);
printf(" State: %s\n", armed ? "Armed" : "Disarmed");
printf(" Role: %s\n", role_str);
if (master) {
printf(" Fire Requested: %s\n", fire_req ? "Yes" : "No");
}
printf(" Fired: %s\n", fired ? "Yes" : "No");
printf("\n");
out:
if (status != 0) {
state->last_lib_error = status;
return CLI_RET_LIBBLADERF;
}
return status;
}
static inline int config_trigger(struct cli_state *state,
bladerf_module module,
bladerf_trigger_signal signal,
const char *cmd, const char *argv0)
{
int status;
struct bladerf_trigger trigger;
bool armed, fired, fire_req, master;
const char *module_str, *sig_str;
/* Dissect current value to print certain warnings */
status = bladerf_trigger_init(state->dev, module, signal, &trigger);
if (status != 0) {
goto out;
}
status = bladerf_trigger_state(state->dev, &trigger,
&armed, &fired, &fire_req, NULL, NULL);
if (status != 0) {
goto out;
}
master = (trigger.role == BLADERF_TRIGGER_ROLE_MASTER);
module_str = module2str(module);
sig_str = trigger2str(signal);
if (!strcasecmp(cmd, "off") || !strcasecmp(cmd, "disable") || !strcasecmp(cmd, "disabled")) {
/* Disarm trigger and restore it to a slave role */
trigger.role = BLADERF_TRIGGER_ROLE_DISABLED;
status = bladerf_trigger_arm(state->dev, &trigger, false, 0, 0);
if (status != 0) {
goto out;
}
printf("\n %s %s trigger disabled\n\n", sig_str, module_str);
} else if (!strcasecmp(cmd, "slave")) {
if (fired) {
printf("\n WARNING: Trigger signal is already asserted; trigger will fire immediately.\n");
}
if (master && fire_req) {
printf("\n WARNING: Fire request on this master was active. Changing from master to slave will stop other triggered slaves.\n");
}
trigger.role = BLADERF_TRIGGER_ROLE_SLAVE;
status = bladerf_trigger_arm(state->dev, &trigger, true, 0, 0);
if (status != 0) {
goto out;
}
printf("\n %s %s trigger armed as a slave.\n\n",
sig_str, module_str);
} else if (!strcasecmp(cmd, "master")) {
if (armed && !master) {
printf("\n WARNING: Changing from slave to master. Ensure there is only one master in the trigger chain!\n");
}
trigger.role = BLADERF_TRIGGER_ROLE_MASTER;
status = bladerf_trigger_arm(state->dev, &trigger, true, 0, 0);
if (status != 0) {
goto out;
}
printf("\n %s %s trigger armed as master.\n\n",
sig_str, module_str);
} else if (!strcasecmp(cmd, "fire")) {
if (!(armed && master)) {
cli_err(state, argv0,
"%s %s trigger not configured as master, can't fire\n",
sig_str, module_str);
return CLI_RET_INVPARAM;
}
if (fired) {
printf("\n WARNING: Trigger already fired. Ignoring fire request.\n\n");
return 0;
}
status = bladerf_trigger_fire(state->dev, &trigger);
if (status != 0) {
goto out;
}
printf("\n %s %s trigger fire request submitted successfully.\n\n",
sig_str, module_str);
} else {
cli_err(state, cmd, "Invalid trigger command.\n");
return CLI_RET_INVPARAM;
}
out:
if (status != 0) {
state->last_lib_error = status;
status = CLI_RET_LIBBLADERF;
}
return status;
}
static void update_triggers(trigger_item_t *trigger_tgt,
unsigned int count_tgt,
trigger_item_t *trigger_new,
unsigned int count_new, bool *check_interval_chgd)
{
unsigned int i;
*check_interval_chgd = false;
if (count_new != count_tgt) {
/* skip trigger checking & update */
no_trig_updt_msg("Trigger count");
return;
}
/* check trigger types */
for (i = 0; i < count_new; i++) {
if (trigger_new[i].trigger_type != trigger_tgt[i].trigger_type
|| trigger_new[i].target_type != trigger_tgt[i].target_type) {
no_trig_updt_msg("Trigger type");
return;
} else if ((trigger_new[i].trigger_type != TRIG_ALWAYS) &&
(trigger_new[i].hw_type != trigger_tgt[i].hw_type)) {
no_trig_updt_msg("High threshold type");
return;
} else if ((trigger_new[i].trigger_type != TRIG_ALWAYS) &&
(trigger_new[i].lw_type != trigger_tgt[i].lw_type)) {
no_trig_updt_msg("Low threshold type");
return;
}
}
/* triggers have the same type: update simple parameters:
* max_action_count, max_action_volume, check_interval, alert_high,
* alert_low, post_trigger_wait */
for (i = 0; i < count_new; i++) {
char tname[256];
snprintf(tname, sizeof(tname), "#%u (%s): ", i,
trigger2str(&trigger_tgt[i]));
if (trigger_new[i].check_interval != trigger_tgt[i].check_interval) {
DisplayLog(LVL_EVENT, TAG,
"check_interval updated for trigger %s: %lu->%lu", tname,
trigger_tgt[i].check_interval,
trigger_new[i].check_interval);
trigger_tgt[i].check_interval = trigger_new[i].check_interval;
*check_interval_chgd = true;
}
if (trigger_new[i].max_action_nbr != trigger_tgt[i].max_action_nbr) {
DisplayLog(LVL_EVENT, TAG,
"max_action_count updated for trigger %s: %u entries ->%u entries",
tname, trigger_tgt[i].max_action_nbr,
trigger_new[i].max_action_nbr);
trigger_tgt[i].max_action_nbr = trigger_new[i].max_action_nbr;
}
if (trigger_new[i].max_action_vol != trigger_tgt[i].max_action_vol) {
DisplayLog(LVL_EVENT, TAG,
"max_action_volume updated for trigger %s: %llu bytes->%llu bytes",
tname, trigger_tgt[i].max_action_vol,
trigger_new[i].max_action_vol);
trigger_tgt[i].max_action_vol = trigger_new[i].max_action_vol;
}
if (trigger_new[i].post_trigger_wait !=
trigger_tgt[i].post_trigger_wait) {
DisplayLog(LVL_EVENT, TAG,
"post_trigger_wait updated for trigger %s: %lu->%lu",
tname, trigger_tgt[i].post_trigger_wait,
trigger_new[i].post_trigger_wait);
trigger_tgt[i].post_trigger_wait = trigger_new[i].post_trigger_wait;
}
if (trigger_new[i].alert_hw != trigger_tgt[i].alert_hw) {
DisplayLog(LVL_EVENT, TAG,
"alert_high updated for trigger %s: %s->%s", tname,
bool2str(trigger_tgt[i].alert_hw),
bool2str(trigger_new[i].alert_hw));
trigger_tgt[i].alert_hw = trigger_new[i].alert_hw;
}
if (trigger_new[i].alert_lw != trigger_tgt[i].alert_lw) {
DisplayLog(LVL_EVENT, TAG,
"alert_low updated for trigger %s: %s->%s", tname,
bool2str(trigger_tgt[i].alert_lw),
bool2str(trigger_new[i].alert_lw));
trigger_tgt[i].alert_lw = trigger_new[i].alert_lw;
}
if (trigger_new[i].trigger_type == TRIG_ALWAYS)
/* no threshold for 'periodic' triggers */
continue;
switch (trigger_new[i].hw_type) {
case PCT_THRESHOLD:
if (trigger_new[i].hw_percent != trigger_tgt[i].hw_percent) {
DisplayLog(LVL_EVENT, TAG,
"High threshold updated for trigger %s: "
"%.2f%%->%.2f%%", tname, trigger_tgt[i].hw_percent,
trigger_new[i].hw_percent);
trigger_tgt[i].hw_percent = trigger_new[i].hw_percent;
}
break;
case VOL_THRESHOLD:
if (trigger_new[i].hw_volume != trigger_tgt[i].hw_volume) {
DisplayLog(LVL_EVENT, TAG,
"High threshold updated for trigger %s: %llu bytes->%llu bytes",
tname, trigger_tgt[i].hw_volume,
trigger_new[i].hw_volume);
trigger_tgt[i].hw_volume = trigger_new[i].hw_volume;
}
break;
case COUNT_THRESHOLD:
if (trigger_new[i].hw_count != trigger_tgt[i].hw_count) {
DisplayLog(LVL_EVENT, TAG,
"High threshold updated for trigger %s: %llu entries ->%llu entries",
tname, trigger_tgt[i].hw_count,
trigger_new[i].hw_count);
trigger_tgt[i].hw_count = trigger_new[i].hw_count;
}
break;
}
switch (trigger_new[i].lw_type) {
case PCT_THRESHOLD:
if (trigger_new[i].lw_percent != trigger_tgt[i].lw_percent) {
DisplayLog(LVL_EVENT, TAG,
"Low threshold updated for trigger %s: %.2f%%->%.2f%%",
tname, trigger_tgt[i].lw_percent,
trigger_new[i].lw_percent);
trigger_tgt[i].lw_percent = trigger_new[i].lw_percent;
}
break;
case VOL_THRESHOLD:
if (trigger_new[i].lw_volume != trigger_tgt[i].lw_volume) {
DisplayLog(LVL_EVENT, TAG,
"Low threshold updated for trigger %s: %llu bytes->%llu bytes",
tname, trigger_tgt[i].lw_volume,
trigger_new[i].lw_volume);
trigger_tgt[i].lw_volume = trigger_new[i].lw_volume;
}
break;
case COUNT_THRESHOLD:
if (trigger_new[i].lw_count != trigger_tgt[i].lw_count) {
DisplayLog(LVL_EVENT, TAG,
"Low threshold updated for trigger %s: %llu entries->%llu entries",
tname, trigger_tgt[i].lw_count,
trigger_new[i].lw_count);
trigger_tgt[i].lw_count = trigger_new[i].lw_count;
}
break;
}
}
/* update global interval check (GCD of all check intervals) if one of
* them changed */
// TODO move to caller
// if (check_interval_chgd)
// ResMon_UpdateCheckInterval();
/* triggers have been updated */
return;
}
