static int
hfsc_get_sc1(int *argcp, char ***argvp,
struct tc_service_curve *sc, const char *dev)
{
char **argv = *argvp;
int argc = *argcp;
unsigned int m1 = 0, d = 0, m2 = 0;
if (matches(*argv, "m1") == 0) {
NEXT_ARG();
if (strchr(*argv, '%')) {
if (get_percent_rate(&m1, *argv, dev)) {
explain1("m1");
return -1;
}
} else if (get_rate(&m1, *argv) < 0) {
explain1("m1");
return -1;
}
NEXT_ARG();
}
if (matches(*argv, "d") == 0) {
NEXT_ARG();
if (get_time(&d, *argv) < 0) {
explain1("d");
return -1;
}
NEXT_ARG();
}
if (matches(*argv, "m2") == 0) {
NEXT_ARG();
if (strchr(*argv, '%')) {
if (get_percent_rate(&m2, *argv, dev)) {
explain1("m2");
return -1;
}
} else if (get_rate(&m2, *argv) < 0) {
explain1("m2");
return -1;
}
} else
return -1;
sc->m1 = m1;
sc->d = tc_core_time2ktime(d);
sc->m2 = m2;
*argvp = argv;
*argcp = argc;
return 0;
}
static void show_evdev_attribs(int fd)
{
unsigned int delay, period;
printf("\t");
get_rate(fd, &delay, &period);
}
dsk_err_t linux_xseek(DSK_DRIVER *self, const DSK_GEOMETRY *geom,
dsk_pcyl_t cylinder, dsk_phead_t head)
{
struct floppy_raw_cmd raw_cmd;
LINUX_DSK_DRIVER *lxself;
if (!self || !geom) return DSK_ERR_BADPTR;
if (self->dr_class != &dc_linux) return DSK_ERR_BADPTR;
lxself = (LINUX_DSK_DRIVER *)self;
if (lxself->lx_fd < 0) return DSK_ERR_NOTRDY;
init_raw_cmd(&raw_cmd);
raw_cmd.flags = FD_RAW_INTR;
raw_cmd.flags |= FD_RAW_NEED_SEEK;
raw_cmd.track = cylinder;
if (lxself->lx_doublestep) raw_cmd.track *= 2;
raw_cmd.rate = get_rate(geom);
raw_cmd.cmd[raw_cmd.cmd_count++] = FD_SEEK;
raw_cmd.cmd[raw_cmd.cmd_count++] = encode_head(self, head);
raw_cmd.cmd[raw_cmd.cmd_count++] = cylinder;
if (ioctl(lxself->lx_fd, FDRAWCMD, &raw_cmd) < 0) return DSK_ERR_SYSERR;
memcpy(lxself->lx_status, raw_cmd.reply, 4);
if (raw_cmd.reply[0] & 0x40) return xlt_error(raw_cmd.reply);
lxself->lx_cylinder = cylinder;
return DSK_ERR_OK;
}
int main(int argc, char *argv[])
{
float freq = 1000, amp = 0.5f, phase = 0.0f;
float period;
long len;
long n;
int i;
get_rate();
len = RATE;
/* read options */
for (i = 1; i < argc; i++)
{
if (!strcmp(argv[i], "-freq") && i+1 < argc)
freq = atof(argv[++i]); /* frequency of the wave */
else if (!strcmp(argv[i], "-amp") && i+1 < argc)
amp = atof(argv[++i]); /* amplitude from 0 to 1 */
else if (!strcmp(argv[i], "-len") && i+1 < argc)
len = atof(argv[++i]) / 1000.0f * RATE; /* length in ms */
else if (!strcmp(argv[i], "-phase") && i+1 < argc)
phase = atof(argv[++i]); /* phase in degrees */
else if (!strcmp(argv[i], "-help"))
{
fprintf(stderr, "options: -freq arg, -amp arg, -len "
"arg, -phase arg\n");
exit(0);
}
}
/* check options */
freq = CLAMP(0.01f, freq, RATE / 22.0f * 10.f);
amp = CLAMP(0.0f, amp, 1.0f);
phase = CLAMP(0.0f, phase, 359.99f);
/* convert options */
period = RATE / freq;
phase *= period;
SET_BINARY_MODE
for (n = 0; n < len; n++)
{
float f;
f = square((n + phase) * 360.0f / period) * amp;
/* left channel */
if (fwrite(&f, sizeof f, 1, stdout) < 1)
break;
/* right channel */
if (fwrite(&f, sizeof f, 1, stdout) < 1)
break;
}
return 0;
}
static int
hfsc_get_sc1(int *argcp, char ***argvp, struct tc_service_curve *sc)
{
char **argv = *argvp;
int argc = *argcp;
unsigned int m1 = 0, d = 0, m2 = 0;
if (matches(*argv, "m1") == 0) {
NEXT_ARG();
if (get_rate(&m1, *argv) < 0) {
explain1("m1");
return -1;
}
NEXT_ARG();
}
if (matches(*argv, "d") == 0) {
NEXT_ARG();
if (get_usecs(&d, *argv) < 0) {
explain1("d");
return -1;
}
NEXT_ARG();
}
if (matches(*argv, "m2") == 0) {
NEXT_ARG();
if (get_rate(&m2, *argv) < 0) {
explain1("m2");
return -1;
}
} else
return -1;
sc->m1 = m1;
sc->d = d;
sc->m2 = m2;
*argvp = argv;
*argcp = argc;
return 0;
}
ReturnCode_t SimulationExecutionContext::start() throw (CORBA::SystemException)
{
ReturnCode_t ret = OpenHRPExecutionContext::start();
if (ret == RTC_OK){
OpenRTM::ExtTrigExecutionContextService_var extTrigExecContext =
OpenRTM::ExtTrigExecutionContextService::_narrow(this->getObjRef());
m_cg->subscribe(extTrigExecContext, 1.0/get_rate());
}
return ret;
}
dsk_err_t linux_format(DSK_DRIVER *self, DSK_GEOMETRY *geom,
dsk_pcyl_t cylinder, dsk_phead_t head,
const DSK_FORMAT *format, unsigned char filler)
{
struct floppy_raw_cmd raw_cmd;
LINUX_DSK_DRIVER *lxself;
int n;
dsk_err_t err;
unsigned char *buf;
unsigned char mask = 0xFF;
if (!self || !geom || !format) return DSK_ERR_BADPTR;
if (self->dr_class != &dc_linux) return DSK_ERR_BADPTR;
lxself = (LINUX_DSK_DRIVER *)self;
if (lxself->lx_fd < 0) return DSK_ERR_NOTRDY;
err = check_geom(lxself, geom);
if (err) return err;
if (geom->dg_fm) mask &= ~0x40;
if (geom->dg_nomulti) mask &= ~0x80;
buf = dsk_malloc(geom->dg_sectors * 4);
if (!buf) return DSK_ERR_NOMEM;
for (n = 0; n < geom->dg_sectors; n++)
{
buf[n*4] = format[n].fmt_cylinder;
buf[n*4+1] = format[n].fmt_head;
buf[n*4+2] = format[n].fmt_sector;
buf[n*4+3] = dsk_get_psh(format[n].fmt_secsize);
}
init_raw_cmd(&raw_cmd);
raw_cmd.flags = FD_RAW_WRITE | FD_RAW_INTR;
if (cylinder != lxself->lx_cylinder) raw_cmd.flags |= FD_RAW_NEED_SEEK;
raw_cmd.track = cylinder;
if (lxself->lx_doublestep) raw_cmd.track *= 2;
raw_cmd.rate = get_rate(geom);
raw_cmd.length= 4 * geom->dg_sectors;
raw_cmd.data = buf;
raw_cmd.cmd[raw_cmd.cmd_count++] = FD_FORMAT & mask;
raw_cmd.cmd[raw_cmd.cmd_count++] = encode_head(self, head);
raw_cmd.cmd[raw_cmd.cmd_count++] = dsk_get_psh(geom->dg_secsize);
raw_cmd.cmd[raw_cmd.cmd_count++] = geom->dg_sectors;
raw_cmd.cmd[raw_cmd.cmd_count++] = geom->dg_fmtgap;
raw_cmd.cmd[raw_cmd.cmd_count++] = filler;
if (ioctl(lxself->lx_fd, FDRAWCMD, &raw_cmd) < 0) return DSK_ERR_SYSERR;
memcpy(lxself->lx_status, raw_cmd.reply, 4);
if (raw_cmd.reply[0] & 0x40) return xlt_error(raw_cmd.reply);
lxself->lx_cylinder = cylinder;
return DSK_ERR_OK;
}
dsk_err_t linux_xread(DSK_DRIVER *self, const DSK_GEOMETRY *geom, void *buf,
dsk_pcyl_t cylinder, dsk_phead_t head,
dsk_pcyl_t cyl_expected, dsk_phead_t head_expected,
dsk_psect_t sector, size_t sector_size, int *deleted)
{
struct floppy_raw_cmd raw_cmd;
LINUX_DSK_DRIVER *lxself;
dsk_err_t err;
unsigned char mask = 0xFF;
if (!self || !geom || !buf) return DSK_ERR_BADPTR;
if (self->dr_class != &dc_linux) return DSK_ERR_BADPTR;
lxself = (LINUX_DSK_DRIVER *)self;
if (lxself->lx_fd < 0) return DSK_ERR_NOTRDY;
err = check_geom(lxself, geom);
if (err) return err;
if (geom->dg_noskip) mask &= ~0x20; /* Don't skip deleted data */
if (geom->dg_fm) mask &= ~0x40; /* FM recording mode */
if (geom->dg_nomulti) mask &= ~0x80; /* Disable multitrack */
init_raw_cmd(&raw_cmd);
raw_cmd.flags = FD_RAW_READ | FD_RAW_INTR;
if (cylinder != lxself->lx_cylinder) raw_cmd.flags |= FD_RAW_NEED_SEEK;
raw_cmd.track = cylinder;
if (lxself->lx_doublestep) raw_cmd.track *= 2;
raw_cmd.rate = get_rate(geom);
raw_cmd.length= sector_size;
raw_cmd.data = buf;
if (deleted && (*deleted))
raw_cmd.cmd[raw_cmd.cmd_count++] = 0xEC & mask;
else raw_cmd.cmd[raw_cmd.cmd_count++] = FD_READ & mask;
raw_cmd.cmd[raw_cmd.cmd_count++] = encode_head(self, head);
raw_cmd.cmd[raw_cmd.cmd_count++] = cyl_expected;
raw_cmd.cmd[raw_cmd.cmd_count++] = head_expected;
raw_cmd.cmd[raw_cmd.cmd_count++] = sector;
raw_cmd.cmd[raw_cmd.cmd_count++] = dsk_get_psh(sector_size);
raw_cmd.cmd[raw_cmd.cmd_count++] = sector;
raw_cmd.cmd[raw_cmd.cmd_count++] = geom->dg_rwgap;
raw_cmd.cmd[raw_cmd.cmd_count++] = (sector_size < 255) ? sector_size : 0xFF;
if (ioctl(lxself->lx_fd, FDRAWCMD, &raw_cmd) < 0) return DSK_ERR_SYSERR;
memcpy(lxself->lx_status, raw_cmd.reply, 4);
if (raw_cmd.reply[0] & 0x40) return xlt_error(raw_cmd.reply);
if (deleted) deleted[0] = (raw_cmd.reply[2] & 0x40) ? 1 : 0;
lxself->lx_cylinder = cylinder;
return DSK_ERR_OK;
}
static dsk_err_t check_geom(NTWDM_DSK_DRIVER *self, const DSK_GEOMETRY *dg)
{
UCHAR rate;
if (dg->dg_cylinders == self->nt_geom.dg_cylinders &&
dg->dg_sectors == self->nt_geom.dg_sectors &&
dg->dg_heads == self->nt_geom.dg_heads &&
dg->dg_datarate == self->nt_geom.dg_datarate) return DSK_ERR_OK;
rate = get_rate(dg);
if (!DeviceIoControl(self->nt_hdisk, IOCTL_FD_SET_DATA_RATE, &rate, sizeof(rate),
NULL, 0, &dwRet, NULL)) return xlt_error(GetLastError());
memcpy(&self->nt_geom, dg, sizeof(*dg));
return DSK_ERR_OK;
}
/* Read a track (FDC765 READ TRACK command) */
dsk_err_t linux_xtread(DSK_DRIVER *self, const DSK_GEOMETRY *geom, void *buf,
dsk_pcyl_t cylinder, dsk_phead_t head,
dsk_pcyl_t cyl_expected, dsk_phead_t head_expected)
{
struct floppy_raw_cmd raw_cmd;
LINUX_DSK_DRIVER *lxself;
dsk_err_t err;
unsigned char mask = 0xFF;
if (!self || !geom || !buf) return DSK_ERR_BADPTR;
if (self->dr_class != &dc_linux) return DSK_ERR_BADPTR;
lxself = (LINUX_DSK_DRIVER *)self;
if (lxself->lx_fd < 0) return DSK_ERR_NOTRDY;
err = check_geom(lxself, geom);
if (err) return err;
if (geom->dg_fm) mask &= ~0x40;
if (geom->dg_nomulti) mask &= ~0x80;
init_raw_cmd(&raw_cmd);
raw_cmd.flags = FD_RAW_READ | FD_RAW_INTR;
if (cylinder != lxself->lx_cylinder) raw_cmd.flags |= FD_RAW_NEED_SEEK;
raw_cmd.track = cylinder;
if (lxself->lx_doublestep) raw_cmd.track *= 2;
raw_cmd.rate = get_rate(geom);
raw_cmd.length= geom->dg_secsize * geom->dg_sectors;
raw_cmd.data = buf;
/* fdreg.h doesn't define the Read Track command, but here it is */
raw_cmd.cmd[raw_cmd.cmd_count++] = 0x62 & mask;
raw_cmd.cmd[raw_cmd.cmd_count++] = encode_head(self, head);
raw_cmd.cmd[raw_cmd.cmd_count++] = cyl_expected;
raw_cmd.cmd[raw_cmd.cmd_count++] = head_expected;
raw_cmd.cmd[raw_cmd.cmd_count++] = geom->dg_secbase;
raw_cmd.cmd[raw_cmd.cmd_count++] = dsk_get_psh(geom->dg_secsize);
raw_cmd.cmd[raw_cmd.cmd_count++] = geom->dg_secbase + geom->dg_sectors;
raw_cmd.cmd[raw_cmd.cmd_count++] = geom->dg_rwgap;
raw_cmd.cmd[raw_cmd.cmd_count++] = 0xFF;
if (ioctl(lxself->lx_fd, FDRAWCMD, &raw_cmd) < 0) return DSK_ERR_SYSERR;
memcpy(lxself->lx_status, raw_cmd.reply, 4);
if (raw_cmd.reply[0] & 0x40) return xlt_error(raw_cmd.reply);
lxself->lx_cylinder = cylinder;
return DSK_ERR_OK;
}
int main(int argc, char *argv[])
{
float leftlen = 50.0f, rightlen = 60.0f;
float feedback = 37.5f;
float wetout = 100.0f;
int leftlen_smp, rightlen_smp;
int i;
get_rate();
for (i = 1; i < argc; i++)
{
if (!strcmp(argv[i], "-leftlen") && i+1 < argc)
leftlen = atof(argv[++i]);
else if (!strcmp(argv[i], "-rightlen") && i+1 < argc)
rightlen = atof(argv[++i]);
else if (!strcmp(argv[i], "-feedback") && i+1 < argc)
feedback = atof(argv[++i]);
else if (!strcmp(argv[i], "-wetout") && i+1 < argc)
wetout = atof(argv[++i]);
else if (!strcmp(argv[i], "-help"))
{
fprintf(stderr, "options: -leftlen ms, -rightlen ms, "
"-feedback percent, -wetout percent\n");
exit(0);
}
}
leftlen = CLAMP(0.0f, leftlen, 30000.0f);
leftlen_smp = (int)(leftlen * RATE / 1000.0f);
if (leftlen_smp == 0)
leftlen_smp = 1;
rightlen = CLAMP(0.0f, rightlen, 30000.0f);
rightlen_smp = (int)(rightlen * RATE / 1000.0f);
if (rightlen_smp == 0)
rightlen_smp = 1;
SET_BINARY_MODE
xdelay(leftlen_smp, rightlen_smp, feedback, wetout);
return 0;
}
dsk_err_t linux_secid(DSK_DRIVER *self, const DSK_GEOMETRY *geom,
dsk_pcyl_t cylinder, dsk_phead_t head,
DSK_FORMAT *result)
{
struct floppy_raw_cmd raw_cmd;
LINUX_DSK_DRIVER *lxself;
unsigned char mask = 0xFF;
dsk_err_t err;
if (!self || !geom || !result) return DSK_ERR_BADPTR;
if (self->dr_class != &dc_linux) return DSK_ERR_BADPTR;
lxself = (LINUX_DSK_DRIVER *)self;
if (lxself->lx_fd < 0) return DSK_ERR_NOTRDY;
if (geom->dg_fm) mask &= ~0x40;
if (geom->dg_nomulti) mask &= ~0x80;
/* [v0.8.3] It was necessary to add this check correctly to detect 100k
* FM-recorded discs in a 5.25" drive */
err = check_geom(lxself, geom);
if (err) return err;
init_raw_cmd(&raw_cmd);
raw_cmd.flags = FD_RAW_INTR;
if (cylinder != lxself->lx_cylinder) raw_cmd.flags |= FD_RAW_NEED_SEEK;
raw_cmd.track = cylinder;
if (lxself->lx_doublestep) raw_cmd.track *= 2;
raw_cmd.rate = get_rate(geom);
raw_cmd.cmd[raw_cmd.cmd_count++] = FD_READID & mask;
raw_cmd.cmd[raw_cmd.cmd_count++] = encode_head(self, head);
if (ioctl(lxself->lx_fd, FDRAWCMD, &raw_cmd) < 0) return DSK_ERR_SYSERR;
memcpy(lxself->lx_status, raw_cmd.reply, 4);
if (raw_cmd.reply[0] & 0x40) return xlt_error(raw_cmd.reply);
result->fmt_cylinder = raw_cmd.reply[3];
result->fmt_head = raw_cmd.reply[4];
result->fmt_sector = raw_cmd.reply[5];
result->fmt_secsize = 128 << raw_cmd.reply[6];
lxself->lx_cylinder = cylinder;
return DSK_ERR_OK;
}
unsigned long dfs_get_rate(struct vclk *vclk)
{
struct pwrcal_vclk_dfs *dfs;
unsigned long ret = 0;
#ifdef CONFIG_SOC_EXYNOS8890
unsigned long flag = 0;
if (vclk == &vclk_dvfs_int.vclk)
spin_lock_irqsave(&dfs_int_spinlock, flag);
#endif
dfs = to_dfs(vclk);
ret = (unsigned long)get_rate(dfs->table);
#ifdef CONFIG_SOC_EXYNOS8890
if (vclk == &vclk_dvfs_int.vclk)
spin_unlock_irqrestore(&dfs_int_spinlock, flag);
#endif
return ret;
}
int main(int argc, char *argv[])
{
float grainlen = 200.0;
int numbins = 10;
int grainsamps;
int i;
get_rate();
for (i = 1; i < argc; i++)
{
if (!strcmp(argv[i], "-numbins") && i+1 < argc)
numbins = atoi(argv[++i]);
else if (!strcmp(argv[i], "-grainlen") && i+1 < argc)
grainlen = atof(argv[++i]);
else if (!strcmp(argv[i], "-help"))
{
fprintf(stderr, "options: -numbins n, -grainlen ms\n");
exit(0);
}
}
grainsamps = (int)(grainlen * RATE / 1000.0f);
if (grainsamps < 30)
{
fprintf(stderr, "sampbins: grains too short\n");
exit(EXIT_FAILURE);
}
if (numbins < 1)
{
fprintf(stderr, "sampbins: must have at least 1 bin\n");
exit(EXIT_FAILURE);
}
SET_BINARY_MODE
sampbins(numbins, grainsamps);
return 0;
}
dsk_err_t linux_status(DSK_DRIVER *self, const DSK_GEOMETRY *geom,
dsk_phead_t head, unsigned char *result)
{
struct floppy_raw_cmd raw_cmd;
LINUX_DSK_DRIVER *lxself;
if (!self || !geom || !result) return DSK_ERR_BADPTR;
if (self->dr_class != &dc_linux) return DSK_ERR_BADPTR;
lxself = (LINUX_DSK_DRIVER *)self;
if (lxself->lx_fd < 0) return DSK_ERR_NOTRDY;
init_raw_cmd(&raw_cmd);
raw_cmd.flags = FD_RAW_INTR;
raw_cmd.rate = get_rate(geom);
raw_cmd.cmd[raw_cmd.cmd_count++] = FD_GETSTATUS;
raw_cmd.cmd[raw_cmd.cmd_count++] = encode_head(self, head);
if (ioctl(lxself->lx_fd, FDRAWCMD, &raw_cmd) < 0) return DSK_ERR_SYSERR;
*result = raw_cmd.reply[0];
return DSK_ERR_OK;
}
static dsk_err_t check_geom(LINUX_DSK_DRIVER *self, const DSK_GEOMETRY *dg)
{
struct floppy_struct str;
if (dg->dg_cylinders == self->lx_geom.dg_cylinders &&
dg->dg_sectors == self->lx_geom.dg_sectors &&
dg->dg_heads == self->lx_geom.dg_heads) return DSK_ERR_OK;
str.sect = dg->dg_sectors;
str.head = dg->dg_heads;
str.track = dg->dg_cylinders;
str.stretch = 0; /* LibDsk does its own double-stepping */
str.gap = dg->dg_rwgap;
str.rate = get_rate(dg);
str.spec1 = 0xDF; /* XXX Is it always this? */
str.fmt_gap = dg->dg_fmtgap;
if (ioctl(self->lx_fd, FDSETPRM, &str)) return DSK_ERR_SYSERR;
/* 1.1.10: Make the next command do a seek, in case the FDSETPRM
* has moved the head. */
self->lx_cylinder = ~0;
memcpy(&self->lx_geom, dg, sizeof(*dg));
return DSK_ERR_OK;
}
static int
hfsc_get_sc2(int *argcp, char ***argvp, struct tc_service_curve *sc, const char *dev)
{
char **argv = *argvp;
int argc = *argcp;
unsigned int umax = 0, dmax = 0, rate = 0;
if (matches(*argv, "umax") == 0) {
NEXT_ARG();
if (get_size(&umax, *argv) < 0) {
explain1("umax");
return -1;
}
NEXT_ARG();
}
if (matches(*argv, "dmax") == 0) {
NEXT_ARG();
if (get_time(&dmax, *argv) < 0) {
explain1("dmax");
return -1;
}
NEXT_ARG();
}
if (matches(*argv, "rate") == 0) {
NEXT_ARG();
if (strchr(*argv, '%')) {
if (get_percent_rate(&rate, *argv, dev)) {
explain1("rate");
return -1;
}
} else if (get_rate(&rate, *argv) < 0) {
explain1("rate");
return -1;
}
} else
return -1;
if (umax != 0 && dmax == 0) {
fprintf(stderr, "HFSC: umax given but dmax is zero.\n");
return -1;
}
if (dmax != 0 && ceil(1.0 * umax * TIME_UNITS_PER_SEC / dmax) > rate) {
/*
* concave curve, slope of first segment is umax/dmax,
* intersection is at dmax
*/
sc->m1 = ceil(1.0 * umax * TIME_UNITS_PER_SEC / dmax); /* in bps */
sc->d = tc_core_time2ktime(dmax);
sc->m2 = rate;
} else {
/*
* convex curve, slope of first segment is 0, intersection
* is at dmax - umax / rate
*/
sc->m1 = 0;
sc->d = tc_core_time2ktime(ceil(dmax - umax * TIME_UNITS_PER_SEC / rate));
sc->m2 = rate;
}
*argvp = argv;
*argcp = argc;
return 0;
}
double _get_tick_rate() { return get_rate(); }
virtual double get_output_samp_rate(size_t /* port */) { return get_rate(); }
int main(int argc, char *argv[])
{
int dev_from_class = 0, write_cnt;
int fd;
static struct sysfs_names *names;
struct rc_device rc_dev;
argp_parse(&argp, argc, argv, 0, 0, 0);
/* Just list all devices */
if (!clear && !readtable && !keys.next && !ch_proto && !cfg.next && !test && !delay && !period) {
if (devicename) {
fd = open(devicename, O_RDONLY);
if (fd < 0) {
perror("Can't open device");
return -1;
}
device_info(fd, "");
close(fd);
return 0;
}
if (show_sysfs_attribs(&rc_dev))
return -1;
return 0;
}
if (cfg.next && (clear || keys.next || ch_proto || devicename)) {
fprintf (stderr, "Auto-mode can be used only with --read, --debug and --sysdev options\n");
return -1;
}
if (!devicename) {
names = find_device(devclass);
if (!names)
return -1;
rc_dev.sysfs_name = names->name;
if (get_attribs(&rc_dev, names->name)) {
free_names(names);
return -1;
}
names->name = NULL;
free_names(names);
devicename = rc_dev.input_name;
dev_from_class++;
}
if (cfg.next) {
struct cfgfile *cur;
char *fname, *name;
int rc;
for (cur = &cfg; cur->next; cur = cur->next) {
if ((!rc_dev.drv_name || strcasecmp(cur->driver, rc_dev.drv_name)) && strcasecmp(cur->driver, "*"))
continue;
if ((!rc_dev.keytable_name || strcasecmp(cur->table, rc_dev.keytable_name)) && strcasecmp(cur->table, "*"))
continue;
break;
}
if (!cur->next) {
if (debug)
fprintf(stderr, "Table for %s, %s not found. Keep as-is\n",
rc_dev.drv_name, rc_dev.keytable_name);
return 0;
}
if (debug)
fprintf(stderr, "Table for %s, %s is on %s file.\n",
rc_dev.drv_name, rc_dev.keytable_name,
cur->fname);
if (cur->fname[0] == '/' || ((cur->fname[0] == '.') && strchr(cur->fname, '/'))) {
fname = cur->fname;
rc = parse_keyfile(fname, &name);
if (rc < 0) {
fprintf(stderr, "Can't load %s table\n", fname);
return -1;
}
} else {
fname = malloc(strlen(cur->fname) + strlen(IR_KEYTABLE_USER_DIR) + 2);
strcpy(fname, IR_KEYTABLE_USER_DIR);
strcat(fname, "/");
strcat(fname, cur->fname);
rc = parse_keyfile(fname, &name);
if (rc != 0) {
fname = malloc(strlen(cur->fname) + strlen(IR_KEYTABLE_SYSTEM_DIR) + 2);
strcpy(fname, IR_KEYTABLE_SYSTEM_DIR);
strcat(fname, "/");
strcat(fname, cur->fname);
rc = parse_keyfile(fname, &name);
}
if (rc != 0) {
fprintf(stderr, "Can't load %s table from %s or %s\n", cur->fname, IR_KEYTABLE_USER_DIR, IR_KEYTABLE_SYSTEM_DIR);
return -1;
}
}
if (!keys.next) {
fprintf(stderr, "Empty table %s\n", fname);
return -1;
}
clear = 1;
}
if (debug)
fprintf(stderr, "Opening %s\n", devicename);
fd = open(devicename, O_RDONLY);
if (fd < 0) {
perror(devicename);
return -1;
}
if (dev_from_class)
free(devicename);
if (get_input_protocol_version(fd))
return -1;
/*
* First step: clear, if --clear is specified
*/
if (clear) {
clear_table(fd);
fprintf(stderr, "Old keytable cleared\n");
}
/*
* Second step: stores key tables from file or from commandline
*/
write_cnt = add_keys(fd);
if (write_cnt)
fprintf(stderr, "Wrote %d keycode(s) to driver\n", write_cnt);
/*
* Third step: change protocol
*/
if (ch_proto) {
rc_dev.current = ch_proto;
if (set_proto(&rc_dev))
fprintf(stderr, "Couldn't change the IR protocols\n");
else {
fprintf(stderr, "Protocols changed to ");
show_proto(rc_dev.current);
fprintf(stderr, "\n");
}
}
/*
* Fourth step: display current keytable
*/
if (readtable)
display_table(&rc_dev, fd);
/*
* Fiveth step: change repeat rate/delay
*/
if (delay || period) {
unsigned int new_delay, new_period;
get_rate(fd, &new_delay, &new_period);
if (delay)
new_delay = delay;
if (period)
new_period = period;
set_rate(fd, new_delay, new_period);
}
if (test)
test_event(fd);
return 0;
}
static int fq_parse_opt(struct qdisc_util *qu, int argc, char **argv,
struct nlmsghdr *n)
{
unsigned int plimit = ~0U;
unsigned int flow_plimit = ~0U;
unsigned int quantum = ~0U;
unsigned int initial_quantum = ~0U;
unsigned int buckets = 0;
unsigned int maxrate = ~0U;
unsigned int defrate = ~0U;
int pacing = -1;
struct rtattr *tail;
while (argc > 0) {
if (strcmp(*argv, "limit") == 0) {
NEXT_ARG();
if (get_unsigned(&plimit, *argv, 0)) {
fprintf(stderr, "Illegal \"limit\"\n");
return -1;
}
} else if (strcmp(*argv, "flow_limit") == 0) {
NEXT_ARG();
if (get_unsigned(&flow_plimit, *argv, 0)) {
fprintf(stderr, "Illegal \"flow_limit\"\n");
return -1;
}
} else if (strcmp(*argv, "buckets") == 0) {
NEXT_ARG();
if (get_unsigned(&buckets, *argv, 0)) {
fprintf(stderr, "Illegal \"buckets\"\n");
return -1;
}
} else if (strcmp(*argv, "maxrate") == 0) {
NEXT_ARG();
if (get_rate(&maxrate, *argv)) {
fprintf(stderr, "Illegal \"maxrate\"\n");
return -1;
}
} else if (strcmp(*argv, "defrate") == 0) {
NEXT_ARG();
if (get_rate(&defrate, *argv)) {
fprintf(stderr, "Illegal \"defrate\"\n");
return -1;
}
} else if (strcmp(*argv, "quantum") == 0) {
NEXT_ARG();
if (get_unsigned(&quantum, *argv, 0)) {
fprintf(stderr, "Illegal \"quantum\"\n");
return -1;
}
} else if (strcmp(*argv, "initial_quantum") == 0) {
NEXT_ARG();
if (get_unsigned(&initial_quantum, *argv, 0)) {
fprintf(stderr, "Illegal \"initial_quantum\"\n");
return -1;
}
} else if (strcmp(*argv, "pacing") == 0) {
pacing = 1;
} else if (strcmp(*argv, "nopacing") == 0) {
pacing = 0;
} else if (strcmp(*argv, "help") == 0) {
explain();
return -1;
} else {
fprintf(stderr, "What is \"%s\"?\n", *argv);
explain();
return -1;
}
argc--; argv++;
}
tail = NLMSG_TAIL(n);
addattr_l(n, 1024, TCA_OPTIONS, NULL, 0);
if (buckets) {
unsigned int log = ilog2(buckets);
addattr_l(n, 1024, TCA_FQ_BUCKETS_LOG,
&log, sizeof(log));
}
if (plimit != ~0U)
addattr_l(n, 1024, TCA_FQ_PLIMIT,
&plimit, sizeof(plimit));
if (flow_plimit != ~0U)
addattr_l(n, 1024, TCA_FQ_FLOW_PLIMIT,
&flow_plimit, sizeof(flow_plimit));
if (quantum != ~0U)
addattr_l(n, 1024, TCA_FQ_QUANTUM, &quantum, sizeof(quantum));
if (initial_quantum != ~0U)
addattr_l(n, 1024, TCA_FQ_INITIAL_QUANTUM,
&initial_quantum, sizeof(initial_quantum));
if (pacing != -1)
addattr_l(n, 1024, TCA_FQ_RATE_ENABLE,
&pacing, sizeof(pacing));
if (maxrate != ~0U)
addattr_l(n, 1024, TCA_FQ_FLOW_MAX_RATE,
&maxrate, sizeof(maxrate));
if (defrate != ~0U)
addattr_l(n, 1024, TCA_FQ_FLOW_DEFAULT_RATE,
&defrate, sizeof(defrate));
tail->rta_len = (void *) NLMSG_TAIL(n) - (void *) tail;
return 0;
}
/*
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
*/
static int gred_parse_opt(struct qdisc_util *qu, int argc, char **argv, struct nlmsghdr *n)
{
int ok = 0;
struct tc_gred_qopt opt = { 0 };
unsigned int burst = 0;
unsigned int avpkt = 0;
double probability = 0.02;
unsigned int rate = 0;
int parm;
__u8 sbuf[256];
struct rtattr *tail;
__u32 max_P;
opt.DP = MAX_DPs;
while (argc > 0) {
if (strcmp(*argv, "limit") == 0) {
NEXT_ARG();
if (get_size(&opt.limit, *argv)) {
fprintf(stderr, "Illegal \"limit\"\n");
return -1;
}
ok++;
} else if (strcmp(*argv, "setup") == 0) {
if (ok) {
fprintf(stderr, "Illegal \"setup\"\n");
return -1;
}
return init_gred(qu, argc-1, argv+1, n);
} else if (strcmp(*argv, "min") == 0) {
NEXT_ARG();
if (get_size(&opt.qth_min, *argv)) {
fprintf(stderr, "Illegal \"min\"\n");
return -1;
}
ok++;
} else if (strcmp(*argv, "max") == 0) {
NEXT_ARG();
if (get_size(&opt.qth_max, *argv)) {
fprintf(stderr, "Illegal \"max\"\n");
return -1;
}
ok++;
} else if (strcmp(*argv, "vq") == 0 ||
strcmp(*argv, "DP") == 0) {
NEXT_ARG();
if (get_unsigned(&opt.DP, *argv, 10)) {
fprintf(stderr, "Illegal \"vq\"\n");
return -1;
} else if (opt.DP >= MAX_DPs) {
fprintf(stderr, "GRED: only %u VQs are currently supported\n",
MAX_DPs);
return -1;
} /* need a better error check */
ok++;
} else if (strcmp(*argv, "burst") == 0) {
NEXT_ARG();
if (get_unsigned(&burst, *argv, 0)) {
fprintf(stderr, "Illegal \"burst\"\n");
return -1;
}
ok++;
} else if (strcmp(*argv, "avpkt") == 0) {
NEXT_ARG();
if (get_size(&avpkt, *argv)) {
fprintf(stderr, "Illegal \"avpkt\"\n");
return -1;
}
ok++;
} else if (strcmp(*argv, "probability") == 0) {
NEXT_ARG();
if (sscanf(*argv, "%lg", &probability) != 1) {
fprintf(stderr, "Illegal \"probability\"\n");
return -1;
}
ok++;
} else if (strcmp(*argv, "prio") == 0) {
NEXT_ARG();
opt.prio = strtol(*argv, (char **)NULL, 10);
/* some error check here */
ok++;
} else if (strcmp(*argv, "bandwidth") == 0) {
NEXT_ARG();
if (get_rate(&rate, *argv)) {
fprintf(stderr, "Illegal \"bandwidth\"\n");
return -1;
}
ok++;
} else if (strcmp(*argv, "help") == 0) {
explain();
return -1;
} else {
fprintf(stderr, "What is \"%s\"?\n", *argv);
explain();
return -1;
}
argc--; argv++;
}
if (!ok) {
explain();
return -1;
}
if (opt.DP == MAX_DPs || !opt.limit || !opt.qth_min || !opt.qth_max ||
!avpkt) {
fprintf(stderr, "Required parameter (vq, limit, min, max, avpkt) is missing\n");
return -1;
}
if (!burst) {
burst = (2 * opt.qth_min + opt.qth_max) / (3 * avpkt);
fprintf(stderr, "GRED: set burst to %u\n", burst);
}
if (!rate) {
get_rate(&rate, "10Mbit");
fprintf(stderr, "GRED: set bandwidth to 10Mbit\n");
}
if ((parm = tc_red_eval_ewma(opt.qth_min, burst, avpkt)) < 0) {
fprintf(stderr, "GRED: failed to calculate EWMA constant.\n");
return -1;
}
if (parm >= 10)
fprintf(stderr, "GRED: WARNING. Burst %u seems to be too large.\n",
burst);
opt.Wlog = parm;
if ((parm = tc_red_eval_P(opt.qth_min, opt.qth_max, probability)) < 0) {
fprintf(stderr, "GRED: failed to calculate probability.\n");
return -1;
}
opt.Plog = parm;
if ((parm = tc_red_eval_idle_damping(opt.Wlog, avpkt, rate, sbuf)) < 0)
{
fprintf(stderr, "GRED: failed to calculate idle damping table.\n");
return -1;
}
opt.Scell_log = parm;
tail = NLMSG_TAIL(n);
addattr_l(n, 1024, TCA_OPTIONS, NULL, 0);
addattr_l(n, 1024, TCA_GRED_PARMS, &opt, sizeof(opt));
addattr_l(n, 1024, TCA_GRED_STAB, sbuf, 256);
max_P = probability * pow(2, 32);
addattr32(n, 1024, TCA_GRED_MAX_P, max_P);
tail->rta_len = (void *) NLMSG_TAIL(n) - (void *) tail;
return 0;
}
/*
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
*/
static int gred_parse_opt(struct qdisc_util *qu, int argc, char **argv, struct nlmsghdr *n)
{
int ok=0;
struct tc_gred_qopt opt;
unsigned burst = 0;
unsigned avpkt = 0;
double probability = 0.02;
unsigned rate = 0;
int wlog;
__u8 sbuf[256];
struct rtattr *tail;
memset(&opt, 0, sizeof(opt));
while (argc > 0) {
if (strcmp(*argv, "limit") == 0) {
NEXT_ARG();
if (get_size(&opt.limit, *argv)) {
fprintf(stderr, "Illegal \"limit\"\n");
return -1;
}
ok++;
} else if (strcmp(*argv, "setup") == 0) {
if (ok) {
fprintf(stderr, "Illegal \"setup\"\n");
return -1;
}
return init_gred(qu,argc-1, argv+1,n);
} else if (strcmp(*argv, "min") == 0) {
NEXT_ARG();
if (get_size(&opt.qth_min, *argv)) {
fprintf(stderr, "Illegal \"min\"\n");
return -1;
}
ok++;
} else if (strcmp(*argv, "max") == 0) {
NEXT_ARG();
if (get_size(&opt.qth_max, *argv)) {
fprintf(stderr, "Illegal \"max\"\n");
return -1;
}
ok++;
} else if (strcmp(*argv, "DP") == 0) {
NEXT_ARG();
opt.DP=strtol(*argv, (char **)NULL, 10);
DPRINTF ("\n ******* DP =%u\n",opt.DP);
if (opt.DP >MAX_DPs) { /* need a better error check */
fprintf(stderr, "DP =%u \n",opt.DP);
fprintf(stderr, "Illegal \"DP\"\n");
fprintf(stderr, "GRED: only %d DPs are currently supported\n",MAX_DPs);
return -1;
}
ok++;
} else if (strcmp(*argv, "burst") == 0) {
NEXT_ARG();
if (get_unsigned(&burst, *argv, 0)) {
fprintf(stderr, "Illegal \"burst\"\n");
return -1;
}
ok++;
} else if (strcmp(*argv, "avpkt") == 0) {
NEXT_ARG();
if (get_size(&avpkt, *argv)) {
fprintf(stderr, "Illegal \"avpkt\"\n");
return -1;
}
ok++;
} else if (strcmp(*argv, "probability") == 0) {
NEXT_ARG();
if (sscanf(*argv, "%lg", &probability) != 1) {
fprintf(stderr, "Illegal \"probability\"\n");
return -1;
}
ok++;
} else if (strcmp(*argv, "prio") == 0) {
NEXT_ARG();
opt.prio=strtol(*argv, (char **)NULL, 10);
/* some error check here */
ok++;
} else if (strcmp(*argv, "bandwidth") == 0) {
NEXT_ARG();
if (get_rate(&rate, *argv)) {
fprintf(stderr, "Illegal \"bandwidth\"\n");
return -1;
}
ok++;
} else if (strcmp(*argv, "help") == 0) {
explain();
return -1;
} else {
fprintf(stderr, "What is \"%s\"?\n", *argv);
explain();
return -1;
}
argc--; argv++;
}
if (!ok)
return 0;
if (rate == 0)
get_rate(&rate, "10Mbit");
if (!opt.qth_min || !opt.qth_max || !burst || !opt.limit || !avpkt ||
(opt.DP<0)) {
fprintf(stderr, "Required parameter (min, max, burst, limit, "
"avpket, DP) is missing\n");
return -1;
}
if ((wlog = tc_red_eval_ewma(opt.qth_min, burst, avpkt)) < 0) {
fprintf(stderr, "GRED: failed to calculate EWMA constant.\n");
return -1;
}
if (wlog >= 10)
fprintf(stderr, "GRED: WARNING. Burst %d seems to be to "
"large.\n", burst);
opt.Wlog = wlog;
if ((wlog = tc_red_eval_P(opt.qth_min, opt.qth_max, probability)) < 0) {
fprintf(stderr, "GRED: failed to calculate probability.\n");
return -1;
}
opt.Plog = wlog;
if ((wlog = tc_red_eval_idle_damping(opt.Wlog, avpkt, rate, sbuf)) < 0)
{
fprintf(stderr, "GRED: failed to calculate idle damping "
"table.\n");
return -1;
}
opt.Scell_log = wlog;
tail = NLMSG_TAIL(n);
addattr_l(n, 1024, TCA_OPTIONS, NULL, 0);
addattr_l(n, 1024, TCA_GRED_PARMS, &opt, sizeof(opt));
addattr_l(n, 1024, TCA_GRED_STAB, sbuf, 256);
tail->rta_len = (void *) NLMSG_TAIL(n) - (void *) tail;
return 0;
}
int main(int argc, char *argv[])
{
float f0; /* set below */
float q = 1.0f;
float bw = 1.0f;
float slope = 1.0f;
float dBgain = 1.0f;
int type = FILT_HP;
int usewhich = USE_Q;
int i;
biquadcoeffs_t co;
get_rate();
f0 = RATE / 4.0f;
for (i = 1; i < argc; i++)
{
if ((strcmp(argv[i], "-cutoff") == 0
|| strcmp(argv[i], "-center") == 0
|| strcmp(argv[i], "-corner") == 0
|| strcmp(argv[i], "-midpoint") == 0)
&& i+1 < argc)
{
f0 = atof(argv[++i]);
}
else if ((strcmp(argv[i], "-dbgain") == 0
|| strcmp(argv[i], "-dBgain") == 0)
&& i+1 < argc)
{
dBgain = atof(argv[++i]);
dBgain = CLAMP(-100.0f, q, 100.0f);
}
else if (strcmp(argv[i], "-q") == 0 && i+1 < argc)
{
q = atof(argv[++i]);
q = CLAMP(0.01f, q, 100.0f);
usewhich = USE_Q;
}
else if (strcmp(argv[i], "-bw") == 0 && i+1 < argc)
{
bw = atof(argv[++i]);
bw = CLAMP(0.01f, bw, 100.0f);
usewhich = USE_BW;
}
else if (strcmp(argv[i], "-slope") == 0 && i+1 < argc)
{
slope = atof(argv[++i]);
slope = CLAMP(0.01f, slope, 100.0f);
usewhich = USE_SLOPE;
}
else if (strcmp(argv[i], "-type") == 0 && i+1 < argc)
{
i++;
if (strcmp(argv[i], "hp") == 0
|| strcmp(argv[i], "highpass") == 0
|| strcmp(argv[i], "hpf") == 0)
{
type = FILT_HP;
}
else if (strcmp(argv[i], "lp") == 0
|| strcmp(argv[i], "lowpass") == 0
|| strcmp(argv[i], "lpf") == 0)
{
type = FILT_LP;
}
else if (strcmp(argv[i], "bp_skirt_gain") == 0)
type = FILT_BP_SKIRT_GAIN;
else if (strcmp(argv[i], "bp") == 0
|| strcmp(argv[i], "bandpass") == 0
|| strcmp(argv[i], "bpf") == 0)
{
type = FILT_BP_CONSTANT_PEAK;
}
else if (strcmp(argv[i], "notch") == 0)
type = FILT_NOTCH;
else if (strcmp(argv[i], "ap") == 0
|| strcmp(argv[i], "allpass") == 0
|| strcmp(argv[i], "apf") == 0)
{
type = FILT_AP;
}
else if (strcmp(argv[i], "peakingeq") == 0)
type = FILT_PEAKINGEQ;
else if (strcmp(argv[i], "lowshelf") == 0)
type = FILT_LOWSHELF;
else if (strcmp(argv[i], "highshelf") == 0)
type = FILT_HIGHSHELF;
else
{
fprintf(stderr, "unknown filter type: %s\n",
argv[i]);
exit(EXIT_FAILURE);
}
}
else if (strcmp(argv[i], "-help") == 0)
{
fprintf(stderr,
"options: -type [hp|highpass|hpf|lp|lowpass|"
"lpf|bp_skirt_gain|bp|bandpass|bpf|\nnotch|ap|"
"allpass|apf|peakingeq|lowshelf|highshelf],\n"
"-slope arg, -dBgain arg, -q arg, -bw arg,\n"
"-[cutoff|center|corner|midpoint] arg\n");
exit(0);
}
}
computecoeffs(&co, type, usewhich, RATE, f0, dBgain, q, bw, slope);
SET_BINARY_MODE
filter(&co);
return 0;
}
static int fq_parse_opt(struct qdisc_util *qu, int argc, char **argv,
struct nlmsghdr *n, const char *dev)
{
unsigned int plimit;
unsigned int flow_plimit;
unsigned int quantum;
unsigned int initial_quantum;
unsigned int buckets = 0;
unsigned int maxrate;
unsigned int low_rate_threshold;
unsigned int defrate;
unsigned int refill_delay;
unsigned int orphan_mask;
unsigned int ce_threshold;
bool set_plimit = false;
bool set_flow_plimit = false;
bool set_quantum = false;
bool set_initial_quantum = false;
bool set_maxrate = false;
bool set_defrate = false;
bool set_refill_delay = false;
bool set_orphan_mask = false;
bool set_low_rate_threshold = false;
bool set_ce_threshold = false;
int pacing = -1;
struct rtattr *tail;
while (argc > 0) {
if (strcmp(*argv, "limit") == 0) {
NEXT_ARG();
if (get_unsigned(&plimit, *argv, 0)) {
fprintf(stderr, "Illegal \"limit\"\n");
return -1;
}
set_plimit = true;
} else if (strcmp(*argv, "flow_limit") == 0) {
NEXT_ARG();
if (get_unsigned(&flow_plimit, *argv, 0)) {
fprintf(stderr, "Illegal \"flow_limit\"\n");
return -1;
}
set_flow_plimit = true;
} else if (strcmp(*argv, "buckets") == 0) {
NEXT_ARG();
if (get_unsigned(&buckets, *argv, 0)) {
fprintf(stderr, "Illegal \"buckets\"\n");
return -1;
}
} else if (strcmp(*argv, "maxrate") == 0) {
NEXT_ARG();
if (strchr(*argv, '%')) {
if (get_percent_rate(&maxrate, *argv, dev)) {
fprintf(stderr, "Illegal \"maxrate\"\n");
return -1;
}
} else if (get_rate(&maxrate, *argv)) {
fprintf(stderr, "Illegal \"maxrate\"\n");
return -1;
}
set_maxrate = true;
} else if (strcmp(*argv, "low_rate_threshold") == 0) {
NEXT_ARG();
if (get_rate(&low_rate_threshold, *argv)) {
fprintf(stderr, "Illegal \"low_rate_threshold\"\n");
return -1;
}
set_low_rate_threshold = true;
} else if (strcmp(*argv, "ce_threshold") == 0) {
NEXT_ARG();
if (get_time(&ce_threshold, *argv)) {
fprintf(stderr, "Illegal \"ce_threshold\"\n");
return -1;
}
set_ce_threshold = true;
} else if (strcmp(*argv, "defrate") == 0) {
NEXT_ARG();
if (strchr(*argv, '%')) {
if (get_percent_rate(&defrate, *argv, dev)) {
fprintf(stderr, "Illegal \"defrate\"\n");
return -1;
}
} else if (get_rate(&defrate, *argv)) {
fprintf(stderr, "Illegal \"defrate\"\n");
return -1;
}
set_defrate = true;
} else if (strcmp(*argv, "quantum") == 0) {
NEXT_ARG();
if (get_unsigned(&quantum, *argv, 0)) {
fprintf(stderr, "Illegal \"quantum\"\n");
return -1;
}
set_quantum = true;
} else if (strcmp(*argv, "initial_quantum") == 0) {
NEXT_ARG();
if (get_unsigned(&initial_quantum, *argv, 0)) {
fprintf(stderr, "Illegal \"initial_quantum\"\n");
return -1;
}
set_initial_quantum = true;
} else if (strcmp(*argv, "orphan_mask") == 0) {
NEXT_ARG();
if (get_unsigned(&orphan_mask, *argv, 0)) {
fprintf(stderr, "Illegal \"initial_quantum\"\n");
return -1;
}
set_orphan_mask = true;
} else if (strcmp(*argv, "refill_delay") == 0) {
NEXT_ARG();
if (get_time(&refill_delay, *argv)) {
fprintf(stderr, "Illegal \"refill_delay\"\n");
return -1;
}
set_refill_delay = true;
} else if (strcmp(*argv, "pacing") == 0) {
pacing = 1;
} else if (strcmp(*argv, "nopacing") == 0) {
pacing = 0;
} else if (strcmp(*argv, "help") == 0) {
explain();
return -1;
} else {
fprintf(stderr, "What is \"%s\"?\n", *argv);
explain();
return -1;
}
argc--; argv++;
}
tail = addattr_nest(n, 1024, TCA_OPTIONS);
if (buckets) {
unsigned int log = ilog2(buckets);
addattr_l(n, 1024, TCA_FQ_BUCKETS_LOG,
&log, sizeof(log));
}
if (set_plimit)
addattr_l(n, 1024, TCA_FQ_PLIMIT,
&plimit, sizeof(plimit));
if (set_flow_plimit)
addattr_l(n, 1024, TCA_FQ_FLOW_PLIMIT,
&flow_plimit, sizeof(flow_plimit));
if (set_quantum)
addattr_l(n, 1024, TCA_FQ_QUANTUM, &quantum, sizeof(quantum));
if (set_initial_quantum)
addattr_l(n, 1024, TCA_FQ_INITIAL_QUANTUM,
&initial_quantum, sizeof(initial_quantum));
if (pacing != -1)
addattr_l(n, 1024, TCA_FQ_RATE_ENABLE,
&pacing, sizeof(pacing));
if (set_maxrate)
addattr_l(n, 1024, TCA_FQ_FLOW_MAX_RATE,
&maxrate, sizeof(maxrate));
if (set_low_rate_threshold)
addattr_l(n, 1024, TCA_FQ_LOW_RATE_THRESHOLD,
&low_rate_threshold, sizeof(low_rate_threshold));
if (set_defrate)
addattr_l(n, 1024, TCA_FQ_FLOW_DEFAULT_RATE,
&defrate, sizeof(defrate));
if (set_refill_delay)
addattr_l(n, 1024, TCA_FQ_FLOW_REFILL_DELAY,
&refill_delay, sizeof(refill_delay));
if (set_orphan_mask)
addattr_l(n, 1024, TCA_FQ_ORPHAN_MASK,
&orphan_mask, sizeof(refill_delay));
if (set_ce_threshold)
addattr_l(n, 1024, TCA_FQ_CE_THRESHOLD,
&ce_threshold, sizeof(ce_threshold));
addattr_nest_end(n, tail);
return 0;
}
// ------------------------------------------------------------------------------------------------
// Option parser
static error_t parse_opt (int key, char *arg, struct argp_state *state)
// ------------------------------------------------------------------------------------------------
{
arguments_t *arguments = state->input;
char *end; // Used to indicate if ASCII to int was successful
uint8_t i8;
uint32_t i32;
switch (key){
// Verbosity
case 'v':
arguments->verbose_level = strtol(arg, &end, 10);
if (*end)
argp_usage(state);
else
verbose_level = arguments->verbose_level;
break;
// Print long help and exit
case 'H':
arguments->print_long_help = 1;
break;
// Activate FEC
case 'F':
arguments->fec = 1;
break;
// Activate whitening
case 'W':
arguments->whitening = 1;
break;
// Reception test
case 'r':
arguments->test_rx = 1;
break;
// Modulation scheme
case 'M':
i8 = strtol(arg, &end, 10);
if (*end)
argp_usage(state);
else
arguments->modulation = get_modulation_scheme(i8);
break;
// TNC mode
case 't':
i8 = strtol(arg, &end, 10);
if (*end)
argp_usage(state);
else
arguments->tnc_mode = get_tnc_mode(i8);
break;
// Radio data rate
case 'R':
i8 = strtol(arg, &end, 10);
if (*end)
argp_usage(state);
else
arguments->rate = get_rate(i8);
break;
// Output power
case 'd':
i8 = strtol(arg, &end, 10);
if (*end)
argp_usage(state);
else
arguments->power_index = get_power(i8);
break;
// Radio link frequency
case 'f':
arguments->freq_hz = strtol(arg, &end, 10);
if (*end)
argp_usage(state);
break;
// Radio link intermediate frequency
case 'I':
arguments->if_freq_hz = strtol(arg, &end, 10);
if (*end)
argp_usage(state);
break;
// Packet length
case 'p':
arguments->packet_length = strtol(arg, &end, 10) % 254;
if (*end)
argp_usage(state);
break;
// Large packet length
case 'P':
arguments->large_packet_length = strtol(arg, &end, 10) % (1<<16);
if (*end)
argp_usage(state);
break;
// Packet delay
case 'l':
arguments->block_delay = strtol(arg, &end, 10);
if (*end)
argp_usage(state);
break;
// Variable length packet
case 'V':
if (ALLOW_VAR_BLOCKS)
{
arguments->variable_length = 1;
}
else
{
fprintf(stderr, "Variable length blocks are not allowed (yet?)\n");
}
break;
// Real time scheduling
case 'T':
if (ALLOW_REAL_TIME)
{
arguments->real_time = 1;
}
else
{
fprintf(stderr, "Real time scheduling is not allowed\n");
}
break;
// Repetition factor
case 'n':
arguments->repetition = strtol(arg, &end, 10);
if (*end)
argp_usage(state);
break;
// USB device
case 'U':
arguments->usbacm_device = strdup(arg);
break;
// Serial device
case 'D':
arguments->serial_device = strdup(arg);
break;
// Serial speed
case 'B':
i32 = strtol(arg, &end, 10);
if (*end)
argp_usage(state);
else
arguments->serial_speed = get_serial_speed(i32, &(arguments->serial_speed_n));
break;
// Transmission test phrase
case 'y':
arguments->test_phrase = strdup(arg);
break;
// Print radio status and exit
case 's':
arguments->print_radio_status = 1;
break;
// Modulation index
case 'm':
arguments->modulation_index = atof(arg);
break;
// Frequency offset in ppb from nominal
case 'o':
arguments->freq_offset_ppm = atof(arg);
break;
// Rate skew multiplier
case 'w':
arguments->rate_skew = atof(arg);
break;
// TNC serial link window
case 300:
arguments->tnc_serial_window = strtol(arg, &end, 10);
if (*end)
argp_usage(state);
break;
// TNC radio link window
case 301:
arguments->tnc_radio_window = strtol(arg, &end, 10);
if (*end)
argp_usage(state);
break;
// TNC keyup delay
case 302:
arguments->tnc_keyup_delay = strtol(arg, &end, 10);
if (*end)
argp_usage(state);
break;
// TNC keydown delay
case 303:
arguments->tnc_keydown_delay = strtol(arg, &end, 10);
if (*end)
argp_usage(state);
break;
// TNC switchover delay
case 304:
arguments->tnc_switchover_delay = strtol(arg, &end, 10);
if (*end)
argp_usage(state);
break;
// Bkulk filename
case 310:
arguments->bulk_filename = strdup(arg);
break;
default:
return ARGP_ERR_UNKNOWN;
}
return 0;
}
int get_raw_rate(void) {
return get_rate(1);
}
static int red_parse_opt(struct qdisc_util *qu, int argc, char **argv, struct nlmsghdr *n)
{
struct tc_red_qopt opt;
unsigned burst = 0;
unsigned avpkt = 0;
double probability = 0.02;
__u64 rate = 0;
int wlog;
__u8 sbuf[256];
__u32 max_P;
struct rtattr *tail;
memset(&opt, 0, sizeof(opt));
while (argc > 0) {
if (strcmp(*argv, "limit") == 0) {
NEXT_ARG();
if (get_size(&opt.limit, *argv)) {
fprintf(stderr, "Illegal \"limit\"\n");
return -1;
}
} else if (strcmp(*argv, "min") == 0) {
NEXT_ARG();
if (get_size(&opt.qth_min, *argv)) {
fprintf(stderr, "Illegal \"min\"\n");
return -1;
}
} else if (strcmp(*argv, "max") == 0) {
NEXT_ARG();
if (get_size(&opt.qth_max, *argv)) {
fprintf(stderr, "Illegal \"max\"\n");
return -1;
}
} else if (strcmp(*argv, "burst") == 0) {
NEXT_ARG();
if (get_unsigned(&burst, *argv, 0)) {
fprintf(stderr, "Illegal \"burst\"\n");
return -1;
}
} else if (strcmp(*argv, "avpkt") == 0) {
NEXT_ARG();
if (get_size(&avpkt, *argv)) {
fprintf(stderr, "Illegal \"avpkt\"\n");
return -1;
}
} else if (strcmp(*argv, "probability") == 0) {
NEXT_ARG();
if (sscanf(*argv, "%lg", &probability) != 1) {
fprintf(stderr, "Illegal \"probability\"\n");
return -1;
}
} else if (strcmp(*argv, "bandwidth") == 0) {
NEXT_ARG();
if (get_rate(&rate, *argv)) {
fprintf(stderr, "Illegal \"bandwidth\"\n");
return -1;
}
} else if (strcmp(*argv, "ecn") == 0) {
opt.flags |= TC_RED_ECN;
} else if (strcmp(*argv, "harddrop") == 0) {
opt.flags |= TC_RED_HARDDROP;
} else if (strcmp(*argv, "adaptative") == 0) {
opt.flags |= TC_RED_ADAPTATIVE;
} else if (strcmp(*argv, "adaptive") == 0) {
opt.flags |= TC_RED_ADAPTATIVE;
} else if (strcmp(*argv, "help") == 0) {
explain();
return -1;
} else {
fprintf(stderr, "What is \"%s\"?\n", *argv);
explain();
return -1;
}
argc--; argv++;
}
if (rate == 0)
get_rate(&rate, "10Mbit");
if (!opt.limit || !avpkt) {
fprintf(stderr, "RED: Required parameter (limit, avpkt) is missing\n");
return -1;
}
/* Compute default min/max thresholds based on
* Sally Floyd's recommendations:
* http://www.icir.org/floyd/REDparameters.txt
*/
if (!opt.qth_max)
opt.qth_max = opt.qth_min ? opt.qth_min * 3 : opt.limit / 4;
if (!opt.qth_min)
opt.qth_min = opt.qth_max / 3;
if (!burst)
burst = (2 * opt.qth_min + opt.qth_max) / (3 * avpkt);
if ((wlog = tc_red_eval_ewma(opt.qth_min, burst, avpkt)) < 0) {
fprintf(stderr, "RED: failed to calculate EWMA constant.\n");
return -1;
}
if (wlog >= 10)
fprintf(stderr, "RED: WARNING. Burst %d seems to be too large.\n", burst);
opt.Wlog = wlog;
if ((wlog = tc_red_eval_P(opt.qth_min, opt.qth_max, probability)) < 0) {
fprintf(stderr, "RED: failed to calculate probability.\n");
return -1;
}
opt.Plog = wlog;
if ((wlog = tc_red_eval_idle_damping(opt.Wlog, avpkt, rate, sbuf)) < 0) {
fprintf(stderr, "RED: failed to calculate idle damping table.\n");
return -1;
}
opt.Scell_log = wlog;
tail = NLMSG_TAIL(n);
addattr_l(n, 1024, TCA_OPTIONS, NULL, 0);
addattr_l(n, 1024, TCA_RED_PARMS, &opt, sizeof(opt));
addattr_l(n, 1024, TCA_RED_STAB, sbuf, 256);
max_P = probability * pow(2, 32);
addattr_l(n, 1024, TCA_RED_MAX_P, &max_P, sizeof(max_P));
tail->rta_len = (void *) NLMSG_TAIL(n) - (void *) tail;
return 0;
}
int get_cmp_rate(void) {
return get_rate(0);
}
static int tbf_parse_opt(struct qdisc_util *qu, int argc, char **argv, struct nlmsghdr *n)
{
int ok=0;
struct tc_tbf_qopt opt;
__u32 rtab[256];
__u32 ptab[256];
unsigned buffer=0, mtu=0, mpu=0, latency=0;
int Rcell_log=-1, Pcell_log = -1;
struct rtattr *tail;
memset(&opt, 0, sizeof(opt));
while (argc > 0) {
if (matches(*argv, "limit") == 0) {
NEXT_ARG();
if (opt.limit || latency) {
fprintf(stderr, "Double \"limit/latency\" spec\n");
return -1;
}
if (get_size(&opt.limit, *argv)) {
explain1("limit");
return -1;
}
ok++;
} else if (matches(*argv, "latency") == 0) {
NEXT_ARG();
if (opt.limit || latency) {
fprintf(stderr, "Double \"limit/latency\" spec\n");
return -1;
}
if (get_usecs(&latency, *argv)) {
explain1("latency");
return -1;
}
ok++;
} else if (matches(*argv, "burst") == 0 ||
strcmp(*argv, "buffer") == 0 ||
strcmp(*argv, "maxburst") == 0) {
NEXT_ARG();
if (buffer) {
fprintf(stderr, "Double \"buffer/burst\" spec\n");
return -1;
}
if (get_size_and_cell(&buffer, &Rcell_log, *argv) < 0) {
explain1("buffer");
return -1;
}
ok++;
} else if (strcmp(*argv, "mtu") == 0 ||
strcmp(*argv, "minburst") == 0) {
NEXT_ARG();
if (mtu) {
fprintf(stderr, "Double \"mtu/minburst\" spec\n");
return -1;
}
if (get_size_and_cell(&mtu, &Pcell_log, *argv) < 0) {
explain1("mtu");
return -1;
}
ok++;
} else if (strcmp(*argv, "mpu") == 0) {
NEXT_ARG();
if (mpu) {
fprintf(stderr, "Double \"mpu\" spec\n");
return -1;
}
if (get_size(&mpu, *argv)) {
explain1("mpu");
return -1;
}
ok++;
} else if (strcmp(*argv, "rate") == 0) {
NEXT_ARG();
if (opt.rate.rate) {
fprintf(stderr, "Double \"rate\" spec\n");
return -1;
}
if (get_rate(&opt.rate.rate, *argv)) {
explain1("rate");
return -1;
}
ok++;
} else if (matches(*argv, "peakrate") == 0) {
NEXT_ARG();
if (opt.peakrate.rate) {
fprintf(stderr, "Double \"peakrate\" spec\n");
return -1;
}
if (get_rate(&opt.peakrate.rate, *argv)) {
explain1("peakrate");
return -1;
}
ok++;
} else if (strcmp(*argv, "help") == 0) {
explain();
return -1;
} else {
fprintf(stderr, "What is \"%s\"?\n", *argv);
explain();
return -1;
}
argc--; argv++;
}
if (!ok)
return 0;
if (opt.rate.rate == 0 || !buffer) {
fprintf(stderr, "Both \"rate\" and \"burst\" are required.\n");
return -1;
}
if (opt.peakrate.rate) {
if (!mtu) {
fprintf(stderr, "\"mtu\" is required, if \"peakrate\" is requested.\n");
return -1;
}
}
if (opt.limit == 0 && latency == 0) {
fprintf(stderr, "Either \"limit\" or \"latency\" are required.\n");
return -1;
}
if (opt.limit == 0) {
double lim = opt.rate.rate*(double)latency/1000000 + buffer;
if (opt.peakrate.rate) {
double lim2 = opt.peakrate.rate*(double)latency/1000000 + mtu;
if (lim2 < lim)
lim = lim2;
}
opt.limit = lim;
}
if ((Rcell_log = tc_calc_rtable(opt.rate.rate, rtab, Rcell_log, mtu, mpu)) < 0) {
fprintf(stderr, "TBF: failed to calculate rate table.\n");
return -1;
}
opt.buffer = tc_calc_xmittime(opt.rate.rate, buffer);
opt.rate.cell_log = Rcell_log;
opt.rate.mpu = mpu;
if (opt.peakrate.rate) {
if ((Pcell_log = tc_calc_rtable(opt.peakrate.rate, ptab, Pcell_log, mtu, mpu)) < 0) {
fprintf(stderr, "TBF: failed to calculate peak rate table.\n");
return -1;
}
opt.mtu = tc_calc_xmittime(opt.peakrate.rate, mtu);
opt.peakrate.cell_log = Pcell_log;
opt.peakrate.mpu = mpu;
}
tail = (struct rtattr*)(((void*)n)+NLMSG_ALIGN(n->nlmsg_len));
addattr_l(n, 1024, TCA_OPTIONS, NULL, 0);
addattr_l(n, 2024, TCA_TBF_PARMS, &opt, sizeof(opt));
addattr_l(n, 3024, TCA_TBF_RTAB, rtab, 1024);
if (opt.peakrate.rate)
addattr_l(n, 4096, TCA_TBF_PTAB, ptab, 1024);
tail->rta_len = (((void*)n)+NLMSG_ALIGN(n->nlmsg_len)) - (void*)tail;
return 0;
}
