static int
trace_selftest_function_regs(void)
{
int save_ftrace_enabled = ftrace_enabled;
char *func_name;
int len;
int ret;
int supported = 0;
#ifdef CONFIG_DYNAMIC_FTRACE_WITH_REGS
supported = 1;
#endif
/* The previous test PASSED */
pr_cont("PASSED\n");
pr_info("Testing ftrace regs%s: ",
!supported ? "(no arch support)" : "");
/* enable tracing, and record the filter function */
ftrace_enabled = 1;
/* Handle PPC64 '.' name */
func_name = "*" __stringify(DYN_FTRACE_TEST_NAME);
len = strlen(func_name);
ret = ftrace_set_filter(&test_regs_probe, func_name, len, 1);
/*
* If DYNAMIC_FTRACE is not set, then we just trace all functions.
* This test really doesn't care.
*/
if (ret && ret != -ENODEV) {
pr_cont("*Could not set filter* ");
goto out;
}
ret = register_ftrace_function(&test_regs_probe);
/*
* Now if the arch does not support passing regs, then this should
* have failed.
*/
if (!supported) {
if (!ret) {
pr_cont("*registered save-regs without arch support* ");
goto out;
}
test_regs_probe.flags |= FTRACE_OPS_FL_SAVE_REGS_IF_SUPPORTED;
ret = register_ftrace_function(&test_regs_probe);
}
if (ret) {
pr_cont("*could not register callback* ");
goto out;
}
DYN_FTRACE_TEST_NAME();
unregister_ftrace_function(&test_regs_probe);
ret = -1;
switch (trace_selftest_regs_stat) {
case TRACE_SELFTEST_REGS_START:
pr_cont("*callback never called* ");
goto out;
case TRACE_SELFTEST_REGS_FOUND:
if (supported)
break;
pr_cont("*callback received regs without arch support* ");
goto out;
case TRACE_SELFTEST_REGS_NOT_FOUND:
if (!supported)
break;
pr_cont("*callback received NULL regs* ");
goto out;
}
ret = 0;
out:
ftrace_enabled = save_ftrace_enabled;
return ret;
}
#ifdef CONFIG_STREAMS_SOCKSYS_MODULE
MODULE_AUTHOR(SOCKSYS_CONTACT);
MODULE_DESCRIPTION(SOCKSYS_DESCRIP);
MODULE_SUPPORTED_DEVICE(SOCKSYS_DEVICE);
MODULE_LICENSE(SOCKSYS_LICENSE);
#endif /* CONFIG_STREAMS_SOCKSYS_MODULE */
#define SOCKSYS_DRV_ID CONFIG_STREAMS_SOCKSYS_MODID
#define SOCKSYS_DRV_NAME CONFIG_STREAMS_SOCKSYS_NAME
#define SOCKSYS_CMAJORS CONFIG_STREAMS_SOCKSYS_NMAJORS
#define SOCKSYS_CMAJOR_0 CONFIG_STREAMS_SOCKSYS_MAJOR
#define SOCKSYS_UNITS CONFIG_STREAMS_SOCKSYS_NMINORS
#ifdef LINUX
#ifdef MODULE_ALIAS
MODULE_ALIAS("streams-modid-" __stringify(CONFIG_STREAMS_SOCKSYS_MODID));
MODULE_ALIAS("streams-driver-socksys");
MODULE_ALIAS("streams-major-" __stringify(CONFIG_STREAMS_SOCKSYS_MAJOR));
MODULE_ALIAS("/dev/streams/socksys");
MODULE_ALIAS("/dev/streams/socksys/*");
MODULE_ALIAS("/dev/streams/clone/socksys");
MODULE_ALIAS("char-major-" __stringify(CONFIG_STREAMS_CLONE_MAJOR) "-" __stringify(SOCKSYS_CMAJOR_0));
MODULE_ALIAS("/dev/socksys");
//MODULE_ALIAS("devname:socksys");
#endif /* MODULE_ALIAS */
#ifdef MODULE_VERSION
MODULE_VERSION(PACKAGE_ENVR);
#endif
#endif /* LINUX */
/*
const char * buf,
size_t n)
{
unsigned short value;
if (sscanf(buf, "%hu", &value) != 1 ||
(value != 0 && value != 1)) {
printk(KERN_ERR "idle_sleep_store: Invalid value\n");
return -EINVAL;
}
enable_dyn_sleep = value;
return n;
}
static struct subsys_attribute sleep_while_idle_attr = {
.attr = {
.name = __stringify(sleep_while_idle),
.mode = 0644,
},
.show = omap_pm_sleep_while_idle_show,
.store = omap_pm_sleep_while_idle_store,
};
extern struct kset power_subsys;
static void (*omap_sram_idle)(void) = NULL;
static void (*omap_sram_suspend)(unsigned long r0, unsigned long r1) = NULL;
/*
* Let's power down on idle, but only if we are really
* idle, because once we start down the path of
* going idle we continue to do idle even if we get
* a clock tick interrupt . .
option snd-seq-dummy ports=4
The modle option "duplex=1" enables duplex operation to the port.
In duplex mode, a pair of ports are created instead of single port,
and events are tunneled between pair-ports. For example, input to
port A is sent to output port of another port B and vice versa.
In duplex mode, each port has DUPLEX capability.
*/
MODULE_AUTHOR("Takashi Iwai <*****@*****.**>");
MODULE_DESCRIPTION("ALSA sequencer MIDI-through client");
MODULE_LICENSE("GPL");
MODULE_ALIAS("snd-seq-client-" __stringify(SNDRV_SEQ_CLIENT_DUMMY));
static int ports = 1;
static int duplex;
module_param(ports, int, 0444);
MODULE_PARM_DESC(ports, "number of ports to be created");
module_param(duplex, bool, 0444);
MODULE_PARM_DESC(duplex, "create DUPLEX ports");
struct snd_seq_dummy_port {
int client;
int port;
int duplex;
int connect;
};
.decomp_free = z_decomp_free,
.decomp_init = z_decomp_init,
.decomp_reset = z_decomp_reset,
.decompress = z_decompress,
.incomp = z_incomp,
.decomp_stat = z_comp_stats,
.owner = THIS_MODULE
};
static int __init deflate_init(void)
{
int answer = ppp_register_compressor(&ppp_deflate);
if (answer == 0)
printk(KERN_INFO
"PPP Deflate Compression module registered\n");
ppp_register_compressor(&ppp_deflate_draft);
return answer;
}
static void __exit deflate_cleanup(void)
{
ppp_unregister_compressor(&ppp_deflate);
ppp_unregister_compressor(&ppp_deflate_draft);
}
module_init(deflate_init);
module_exit(deflate_cleanup);
MODULE_LICENSE("Dual BSD/GPL");
MODULE_ALIAS("ppp-compress-" __stringify(CI_DEFLATE));
MODULE_ALIAS("ppp-compress-" __stringify(CI_DEFLATE_DRAFT));
return err;
}
rtctimer = timer; /* remember this */
return 0;
}
static void __exit rtctimer_exit(void)
{
if (rtctimer) {
snd_timer_global_free(rtctimer);
rtctimer = NULL;
}
}
/*
* exported stuff
*/
module_init(rtctimer_init)
module_exit(rtctimer_exit)
module_param(rtctimer_freq, int, 0444);
MODULE_PARM_DESC(rtctimer_freq, "timer frequency in Hz");
MODULE_LICENSE("GPL");
MODULE_ALIAS("snd-timer-" __stringify(SNDRV_TIMER_GLOBAL_RTC));
#endif /* CONFIG_RTC || CONFIG_RTC_MODULE */
// Support setting gpio pins at mcu start
//
// Copyright (C) 2019 Kevin O'Connor <*****@*****.**>
//
// This file may be distributed under the terms of the GNU GPLv3 license.
#include "autoconf.h" // CONFIG_INITIAL_PINS
#include "board/gpio.h" // gpio_out_setup
#include "board/pgm.h" // READP
#include "ctr.h" // DECL_CTR
#include "initial_pins.h" // initial_pins
#include "sched.h" // DECL_INIT
DECL_CTR("DECL_INITIAL_PINS " __stringify(CONFIG_INITIAL_PINS));
void
initial_pins_setup(void)
{
int i;
for (i=0; i<initial_pins_size; i++) {
const struct initial_pin_s *ip = &initial_pins[i];
gpio_out_setup(READP(ip->pin), READP(ip->flags) & IP_OUT_HIGH);
}
}
DECL_INIT(initial_pins_setup);
* dump_style=1: force USB dump when panic;
* Or it will be SD dump default.
*/
if (strncmp(buf, "USB", 3) == 0) {
emmd_page->dump_style = 0x1;
goto OUT;
}
pr_warn("Not valid value!!!\n");
OUT:
return len;
}
static struct kobj_attribute panic_attr = {
.attr = {
.name = __stringify(panic),
.mode = 0644,
},
.store = panic_store,
};
static struct attribute *g[] = {
&panic_attr.attr,
NULL,
};
static struct attribute_group attr_group = {
.attrs = g,
};
#endif /* CONFIG_PM */
/* Test dynamic code modification and ftrace filters */
int trace_selftest_startup_dynamic_tracing(struct tracer *trace,
struct trace_array *tr,
int (*func)(void))
{
int save_ftrace_enabled = ftrace_enabled;
int save_tracer_enabled = tracer_enabled;
unsigned long count;
char *func_name;
int ret;
/* The ftrace test PASSED */
printk(KERN_CONT "PASSED\n");
pr_info("Testing dynamic ftrace: ");
/* enable tracing, and record the filter function */
ftrace_enabled = 1;
tracer_enabled = 1;
/* passed in by parameter to fool gcc from optimizing */
func();
/*
* Some archs *cough*PowerPC*cough* add characters to the
* start of the function names. We simply put a '*' to
* accommodate them.
*/
func_name = "*" __stringify(DYN_FTRACE_TEST_NAME);
/* filter only on our function */
ftrace_set_filter(func_name, strlen(func_name), 1);
/* enable tracing */
ret = tracer_init(trace, tr);
if (ret) {
warn_failed_init_tracer(trace, ret);
goto out;
}
/* Sleep for a 1/10 of a second */
msleep(100);
/* we should have nothing in the buffer */
ret = trace_test_buffer(tr, &count);
if (ret)
goto out;
if (count) {
ret = -1;
printk(KERN_CONT ".. filter did not filter .. ");
goto out;
}
/* call our function again */
func();
/* sleep again */
msleep(100);
/* stop the tracing. */
tracing_stop();
ftrace_enabled = 0;
/* check the trace buffer */
ret = trace_test_buffer(tr, &count);
trace->reset(tr);
tracing_start();
/* we should only have one item */
if (!ret && count != 1) {
printk(KERN_CONT ".. filter failed count=%ld ..", count);
ret = -1;
goto out;
}
out:
ftrace_enabled = save_ftrace_enabled;
tracer_enabled = save_tracer_enabled;
/* Enable tracing on all functions again */
ftrace_set_filter(NULL, 0, 1);
return ret;
}
#endif
#ifndef CONFIG_STREAMS_LDTERM_MODID
#error CONFIG_STREAMS_LDTERM_MODID must be defined.
#endif
modID_t modid = CONFIG_STREAMS_LDTERM_MODID;
#ifndef module_param
MODULE_PARM(modid, "h");
#else /* module_param */
module_param(modid, ushort, 0444);
#endif /* module_param */
MODULE_PARM_DESC(modid, "Module Id for LDTERM (0 for allocation).");
#ifdef MODULE_ALIAS
MODULE_ALIAS("streams-modid-" __stringify(CONFIG_STREAMS_LDTERM_MODID));
MODULE_ALIAS("streams-module-ldterm");
#endif /* MODULE_ALIAS */
static struct module_info ldterm_minfo = {
.mi_idnum = CONFIG_STREAMS_LDTERM_MODID,
.mi_idname = CONFIG_STREAMS_PCKT_NAME,
.mi_minpsz = STRMINPSZ,
.mi_maxpsz = STRMAXPSZ,
.mi_hiwat = STRHIGH,
.mi_lowat = STRLOW,
};
static struct module_stat ldterm_rstat __attribute__ ((__aligned__(SMP_CACHE_BYTES)));
static struct module_stat ldterm_wstat __attribute__ ((__aligned__(SMP_CACHE_BYTES)));
static ssize_t incrediblec_virtual_keys_show(struct kobject *kobj,
struct kobj_attribute *attr, char *buf)
{
if (engineerid > 1 && system_rev > 1) {
/* center: x: home: 45, menu: 152, back: 318, search 422, y: 830 */
return sprintf(buf,
__stringify(EV_KEY) ":" __stringify(KEY_HOME) ":47:830:74:50"
":" __stringify(EV_KEY) ":" __stringify(KEY_MENU) ":155:830:80:50"
":" __stringify(EV_KEY) ":" __stringify(KEY_BACK) ":337:830:90:50"
":" __stringify(EV_KEY) ":" __stringify(KEY_SEARCH) ":434:830:60:50"
"\n");
} else {
/* center: x: home: 50, menu: 184, back: 315, search 435, y: 830*/
return sprintf(buf,
__stringify(EV_KEY) ":" __stringify(KEY_HOME) ":50:830:98:50"
":" __stringify(EV_KEY) ":" __stringify(KEY_MENU) ":184:830:120:50"
":" __stringify(EV_KEY) ":" __stringify(KEY_BACK) ":315:830:100:50"
":" __stringify(EV_KEY) ":" __stringify(KEY_SEARCH) ":435:830:88:50"
"\n");
}
}
#include <sys/types.h>
#include <limits.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "zdtmtst.h"
const char *test_doc = "Multi-process fifo loop";
#define BUF_SIZE 256
#define PROCS_DEF 4
unsigned int num_procs = PROCS_DEF;
TEST_OPTION(num_procs, uint, "# processes to create "
"(default " __stringify(PROCS_DEF) ")", 0);
char *filename;
TEST_OPTION(filename, string, "file name", 1);
static int pids[PROCS_DEF];
volatile sig_atomic_t num_exited = 0;
void inc_num_exited(int signo)
{
num_exited++;
}
int main(int argc, char **argv)
{
int ret = 0;
int readfd, writefd;
#include <sys/types.h>
#include <sys/wait.h>
#include <signal.h>
#include <string.h>
#include <pty.h>
#include "zdtmtst.h"
const char *test_doc = "Check that job control migrates correctly";
const char *test_author = "Roman Kagan <*****@*****.**>";
#define JOBS_DEF 8
#define JOBS_MAX 64
unsigned int num_jobs = JOBS_DEF;
TEST_OPTION(num_jobs, uint, "# \"jobs\" in a \"shell\" "
"(default " __stringify(JOBS_DEF)
", max " __stringify(JOBS_MAX) ")", 0);
#define PROCS_DEF 4
unsigned int num_procs = PROCS_DEF;
TEST_OPTION(num_procs, uint, "# processes in a \"job\" "
"(default " __stringify(PROCS_DEF) ")", 0);
static const char wr_string[] = "All you need is love!\n";
static const char rd_string[] = "We all live in a yellow submarine\n";
static const char susp_char = '\032'; /* ^Z */
static volatile sig_atomic_t signo = 0;
static void record_sig(int sig)
{
.print_tuple = ipv6_print_tuple,
.print_conntrack = ipv6_print_conntrack,
.prepare = ipv6_prepare,
#if defined(CONFIG_NF_CT_NETLINK) || defined(CONFIG_NF_CT_NETLINK_MODULE)
.tuple_to_nfattr = ipv6_tuple_to_nfattr,
.nfattr_to_tuple = ipv6_nfattr_to_tuple,
#endif
#ifdef CONFIG_SYSCTL
.ctl_table_path = nf_net_netfilter_sysctl_path,
.ctl_table = nf_ct_ipv6_sysctl_table,
#endif
.get_features = ipv6_get_features,
.me = THIS_MODULE,
};
MODULE_ALIAS("nf_conntrack-" __stringify(AF_INET6));
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Yasuyuki KOZAKAI @USAGI <*****@*****.**>");
static int __init nf_conntrack_l3proto_ipv6_init(void)
{
int ret = 0;
need_conntrack();
ret = nf_ct_frag6_init();
if (ret < 0) {
printk("nf_conntrack_ipv6: can't initialize frag6.\n");
return ret;
}
ret = nf_conntrack_l4proto_register(&nf_conntrack_l4proto_tcp6);
static int uio_pdrv_genirq_probe(struct platform_device *pdev)
{
struct uio_info *uioinfo = pdev->dev.platform_data;
struct uio_pdrv_genirq_platdata *priv;
struct uio_mem *uiomem;
int ret = -EINVAL;
int i;
if (!uioinfo || !uioinfo->name || !uioinfo->version) {
dev_err(&pdev->dev, "missing platform_data\n");
goto bad0;
}
if (uioinfo->handler || uioinfo->irqcontrol ||
uioinfo->irq_flags & IRQF_SHARED) {
dev_err(&pdev->dev, "interrupt configuration error\n");
goto bad0;
}
priv = kzalloc(sizeof(*priv), GFP_KERNEL);
if (!priv) {
ret = -ENOMEM;
dev_err(&pdev->dev, "unable to kmalloc\n");
goto bad0;
}
priv->uioinfo = uioinfo;
spin_lock_init(&priv->lock);
priv->flags = 0; /* interrupt is enabled to begin with */
priv->pdev = pdev;
uiomem = &uioinfo->mem[0];
for (i = 0; i < pdev->num_resources; ++i) {
struct resource *r = &pdev->resource[i];
if (r->flags != IORESOURCE_MEM)
continue;
if (uiomem >= &uioinfo->mem[MAX_UIO_MAPS]) {
dev_warn(&pdev->dev, "device has more than "
__stringify(MAX_UIO_MAPS)
" I/O memory resources.\n");
break;
}
uiomem->memtype = UIO_MEM_PHYS;
uiomem->addr = r->start;
uiomem->size = r->end - r->start + 1;
++uiomem;
}
while (uiomem < &uioinfo->mem[MAX_UIO_MAPS]) {
uiomem->size = 0;
++uiomem;
}
/* This driver requires no hardware specific kernel code to handle
* interrupts. Instead, the interrupt handler simply disables the
* interrupt in the interrupt controller. User space is responsible
* for performing hardware specific acknowledge and re-enabling of
* the interrupt in the interrupt controller.
*
* Interrupt sharing is not supported.
*/
uioinfo->irq_flags |= IRQF_DISABLED;
uioinfo->handler = uio_pdrv_genirq_handler;
uioinfo->irqcontrol = uio_pdrv_genirq_irqcontrol;
uioinfo->open = uio_pdrv_genirq_open;
uioinfo->release = uio_pdrv_genirq_release;
uioinfo->priv = priv;
/* Enable Runtime PM for this device:
* The device starts in suspended state to allow the hardware to be
* turned off by default. The Runtime PM bus code should power on the
* hardware and enable clocks at open().
*/
pm_runtime_enable(&pdev->dev);
ret = uio_register_device(&pdev->dev, priv->uioinfo);
if (ret) {
dev_err(&pdev->dev, "unable to register uio device\n");
goto bad1;
}
platform_set_drvdata(pdev, priv);
return 0;
bad1:
kfree(priv);
pm_runtime_disable(&pdev->dev);
bad0:
return ret;
}
unsigned long arg)
{
struct lib_ring_buffer *buf = filp->private_data;
return lib_ring_buffer_compat_ioctl(filp, cmd, arg, buf);
}
#endif
const struct file_operations lib_ring_buffer_file_operations = {
.owner = THIS_MODULE,
.open = vfs_lib_ring_buffer_open,
.release = vfs_lib_ring_buffer_release,
.poll = vfs_lib_ring_buffer_poll,
.splice_read = vfs_lib_ring_buffer_splice_read,
.mmap = vfs_lib_ring_buffer_mmap,
.unlocked_ioctl = vfs_lib_ring_buffer_ioctl,
.llseek = vfs_lib_ring_buffer_no_llseek,
#ifdef CONFIG_COMPAT
.compat_ioctl = vfs_lib_ring_buffer_compat_ioctl,
#endif
};
EXPORT_SYMBOL_GPL(lib_ring_buffer_file_operations);
MODULE_LICENSE("GPL and additional rights");
MODULE_AUTHOR("Mathieu Desnoyers");
MODULE_DESCRIPTION("Ring Buffer Library VFS");
MODULE_VERSION(__stringify(LTTNG_MODULES_MAJOR_VERSION) "."
__stringify(LTTNG_MODULES_MINOR_VERSION) "."
__stringify(LTTNG_MODULES_PATCHLEVEL_VERSION)
LTTNG_MODULES_EXTRAVERSION);
static ssize_t mot_virtual_keys_show(struct kobject *kobj,
struct kobj_attribute *attr, char *buf)
{
/* keys are specified by setting the x,y of the center, the width,
* and the height, as such keycode:center_x:center_y:width:height */
if ( machine_is_olympus() )
{
if (HWREV_TYPE_IS_PORTABLE(system_rev) ||
HWREV_TYPE_IS_FINAL(system_rev) )
{
/* Olympus, P1C+ product */
if (HWREV_REV(system_rev) >= HWREV_REV_1C )
{
return sprintf(buf, __stringify(EV_KEY) ":" __stringify(KEY_MENU) ":%d:%d:%d:%d:"
__stringify(EV_KEY) ":" __stringify(KEY_HOME) ":%d:%d:%d:%d:"
__stringify(EV_KEY) ":" __stringify(KEY_BACK) ":%d:%d:%d:%d:"
__stringify(EV_KEY) ":" __stringify(KEY_SEARCH) ":%d:%d:%d:%d\n",
vkey_size_olympus_p_1_43[0][0],vkey_size_olympus_p_1_43[0][1],vkey_size_olympus_p_1_43[0][2],vkey_size_olympus_p_1_43[0][3],
vkey_size_olympus_p_1_43[1][0],vkey_size_olympus_p_1_43[1][1],vkey_size_olympus_p_1_43[1][2],vkey_size_olympus_p_1_43[1][3],
vkey_size_olympus_p_1_43[2][0],vkey_size_olympus_p_1_43[2][1],vkey_size_olympus_p_1_43[2][2],vkey_size_olympus_p_1_43[2][3],
vkey_size_olympus_p_1_43[3][0],vkey_size_olympus_p_1_43[3][1], vkey_size_olympus_p_1_43[3][2], vkey_size_olympus_p_1_43[3][3]);
}
else
{
return sprintf(buf, __stringify(EV_KEY) ":" __stringify(KEY_MENU) ":%d:%d:%d:%d:"
__stringify(EV_KEY) ":" __stringify(KEY_HOME) ":%d:%d:%d:%d:"
__stringify(EV_KEY) ":" __stringify(KEY_BACK) ":%d:%d:%d:%d:"
__stringify(EV_KEY) ":" __stringify(KEY_SEARCH) ":%d:%d:%d:%d\n",
vkey_size_olympus_p_1_42[0][0],vkey_size_olympus_p_1_42[0][1],vkey_size_olympus_p_1_42[0][2],vkey_size_olympus_p_1_42[0][3],
vkey_size_olympus_p_1_42[1][0],vkey_size_olympus_p_1_42[1][1],vkey_size_olympus_p_1_42[1][2],vkey_size_olympus_p_1_42[1][3],
vkey_size_olympus_p_1_42[2][0],vkey_size_olympus_p_1_42[2][1],vkey_size_olympus_p_1_42[2][2],vkey_size_olympus_p_1_42[2][3],
vkey_size_olympus_p_1_42[3][0],vkey_size_olympus_p_1_42[3][1], vkey_size_olympus_p_1_42[3][2], vkey_size_olympus_p_1_42[3][3]);
}
}
else
return 0;
}
else if ( machine_is_etna())
{
if (HWREV_TYPE_IS_PORTABLE(system_rev) ||
HWREV_TYPE_IS_FINAL(system_rev) )
{
/* Etna product */
if (HWREV_REV(system_rev) >= HWREV_REV_1B )
{
return sprintf(buf, __stringify(EV_KEY) ":" __stringify(KEY_MENU) ":%d:%d:%d:%d:"
__stringify(EV_KEY) ":" __stringify(KEY_HOME) ":%d:%d:%d:%d:"
__stringify(EV_KEY) ":" __stringify(KEY_BACK) ":%d:%d:%d:%d:"
__stringify(EV_KEY) ":" __stringify(KEY_SEARCH) ":%d:%d:%d:%d\n",
vkey_size_etna_p_1_42[0][0],vkey_size_etna_p_1_42[0][1],vkey_size_etna_p_1_42[0][2],vkey_size_etna_p_1_42[0][3],
vkey_size_etna_p_1_42[1][0],vkey_size_etna_p_1_42[1][1],vkey_size_etna_p_1_42[1][2],vkey_size_etna_p_1_42[1][3],
vkey_size_etna_p_1_42[2][0],vkey_size_etna_p_1_42[2][1],vkey_size_etna_p_1_42[2][2],vkey_size_etna_p_1_42[2][3],
vkey_size_etna_p_1_42[3][0],vkey_size_etna_p_1_42[3][1], vkey_size_etna_p_1_42[3][2], vkey_size_etna_p_1_42[3][3]);
}
else
{
return sprintf(buf, __stringify(EV_KEY) ":" __stringify(KEY_MENU) ":%d:%d:%d:%d:"
__stringify(EV_KEY) ":" __stringify(KEY_HOME) ":%d:%d:%d:%d:"
__stringify(EV_KEY) ":" __stringify(KEY_BACK) ":%d:%d:%d:%d:"
__stringify(EV_KEY) ":" __stringify(KEY_SEARCH) ":%d:%d:%d:%d\n",
vkey_size_etna_p_1_41[0][0],vkey_size_etna_p_1_41[0][1],vkey_size_etna_p_1_41[0][2],vkey_size_etna_p_1_41[0][3],
vkey_size_etna_p_1_41[1][0],vkey_size_etna_p_1_41[1][1],vkey_size_etna_p_1_41[1][2],vkey_size_etna_p_1_41[1][3],
vkey_size_etna_p_1_41[2][0],vkey_size_etna_p_1_41[2][1],vkey_size_etna_p_1_41[2][2],vkey_size_etna_p_1_41[2][3],
vkey_size_etna_p_1_41[3][0],vkey_size_etna_p_1_41[3][1], vkey_size_etna_p_1_41[3][2], vkey_size_etna_p_1_41[3][3]);
}
} else if (HWREV_TYPE_IS_BRASSBOARD(system_rev) &&
HWREV_REV(system_rev) >= HWREV_REV_3) {
/* Etna product */
return sprintf(buf,
__stringify(EV_KEY) ":" __stringify(KEY_MENU) ":%d:%d:%d:%d:"
__stringify(EV_KEY) ":" __stringify(KEY_HOME) ":%d:%d:%d:%d:"
__stringify(EV_KEY) ":" __stringify(KEY_BACK) ":%d:%d:%d:%d:"
__stringify(EV_KEY) ":" __stringify(KEY_SEARCH) ":%d:%d:%d:%d\n",
vkey_size_etna_p_1_42[0][0],
vkey_size_etna_p_1_42[0][1],
vkey_size_etna_p_1_42[0][2],
vkey_size_etna_p_1_42[0][3],
vkey_size_etna_p_1_42[1][0],
vkey_size_etna_p_1_42[1][1],
vkey_size_etna_p_1_42[1][2],
vkey_size_etna_p_1_42[1][3],
vkey_size_etna_p_1_42[2][0],
vkey_size_etna_p_1_42[2][1],
vkey_size_etna_p_1_42[2][2],
vkey_size_etna_p_1_42[2][3],
vkey_size_etna_p_1_42[3][0],
vkey_size_etna_p_1_42[3][1],
vkey_size_etna_p_1_42[3][2],
vkey_size_etna_p_1_42[3][3]);
}
else
return 0;
}
else if ( machine_is_sunfire())
{
return sprintf(buf,
__stringify(EV_KEY) ":" __stringify(KEY_MENU) ":%d:%d:%d:%d:"
__stringify(EV_KEY) ":" __stringify(KEY_HOME) ":%d:%d:%d:%d:"
__stringify(EV_KEY) ":" __stringify(KEY_BACK) ":%d:%d:%d:%d:"
__stringify(EV_KEY) ":" __stringify(KEY_SEARCH) ":%d:%d:%d:%d\n",
vkey_size_etna_p_1_42[0][0],
vkey_size_etna_p_1_42[0][1],
vkey_size_etna_p_1_42[0][2],
vkey_size_etna_p_1_42[0][3],
vkey_size_etna_p_1_42[1][0],
vkey_size_etna_p_1_42[1][1],
vkey_size_etna_p_1_42[1][2],
vkey_size_etna_p_1_42[1][3],
vkey_size_etna_p_1_42[2][0],
vkey_size_etna_p_1_42[2][1],
vkey_size_etna_p_1_42[2][2],
vkey_size_etna_p_1_42[2][3],
vkey_size_etna_p_1_42[3][0],
vkey_size_etna_p_1_42[3][1],
vkey_size_etna_p_1_42[3][2],
vkey_size_etna_p_1_42[3][3]);
}
else
return 0;
};
}
static void at91_tc_release(struct ipipe_timer *timer)
{
/* Disable all interrupts. */
at91_tc_write(AT91_TC_IDR, ~0ul);
}
static struct ipipe_timer at91_itimer = {
.irq = KERNEL_TIMER_IRQ_NUM,
.request = at91_tc_request,
.set = at91_tc_set,
.ack = at91_tc_ack,
.release = at91_tc_release,
.name = "at91_tc" __stringify(CONFIG_IPIPE_AT91_TC),
.rating = 250,
};
static struct __ipipe_tscinfo tsc_info = {
.type = IPIPE_TSC_TYPE_FREERUNNING,
.counter_vaddr = (AT91_VA_BASE_TCB0 +
0x40 * CONFIG_IPIPE_AT91_TC + AT91_TC_CV),
.u = {
{
.counter_paddr = (AT91_BASE_TCB0 +
0x40 * CONFIG_IPIPE_AT91_TC +
AT91_TC_CV),
.mask = AT91_TC_REG_MASK,
},
},
return CMD_RET_USAGE;
}
fastboot_init((void *)buf_addr, buf_size);
if (!strcmp(argv[1], "udp"))
return do_fastboot_udp(argc, argv, buf_addr, buf_size);
if (!strcmp(argv[1], "usb")) {
argv++;
argc--;
}
return do_fastboot_usb(argc, argv, buf_addr, buf_size);
}
#ifdef CONFIG_SYS_LONGHELP
static char fastboot_help_text[] =
"[-l addr] [-s size] usb <controller> | udp\n"
"\taddr - address of buffer used during data transfers ("
__stringify(CONFIG_FASTBOOT_BUF_ADDR) ")\n"
"\tsize - size of buffer used during data transfers ("
__stringify(CONFIG_FASTBOOT_BUF_SIZE) ")"
;
#endif
U_BOOT_CMD(
fastboot, CONFIG_SYS_MAXARGS, 1, do_fastboot,
"run as a fastboot usb or udp device", fastboot_help_text
);
}; /* Command line parameters */ static int pvscsi_ring_pages = PVSCSI_DEFAULT_NUM_PAGES_PER_RING; static int pvscsi_msg_ring_pages = PVSCSI_DEFAULT_NUM_PAGES_MSG_RING; static int pvscsi_cmd_per_lun = PVSCSI_DEFAULT_QUEUE_DEPTH; static bool pvscsi_disable_msi; static bool pvscsi_disable_msix; static bool pvscsi_use_msg = true; #define PVSCSI_RW (S_IRUSR | S_IWUSR) module_param_named(ring_pages, pvscsi_ring_pages, int, PVSCSI_RW); MODULE_PARM_DESC(ring_pages, "Number of pages per req/cmp ring - (default=" __stringify(PVSCSI_DEFAULT_NUM_PAGES_PER_RING) ")"); module_param_named(msg_ring_pages, pvscsi_msg_ring_pages, int, PVSCSI_RW); MODULE_PARM_DESC(msg_ring_pages, "Number of pages for the msg ring - (default=" __stringify(PVSCSI_DEFAULT_NUM_PAGES_MSG_RING) ")"); module_param_named(cmd_per_lun, pvscsi_cmd_per_lun, int, PVSCSI_RW); MODULE_PARM_DESC(cmd_per_lun, "Maximum commands per lun - (default=" __stringify(PVSCSI_MAX_REQ_QUEUE_DEPTH) ")"); module_param_named(disable_msi, pvscsi_disable_msi, bool, PVSCSI_RW); MODULE_PARM_DESC(disable_msi, "Disable MSI use in driver - (default=0)"); module_param_named(disable_msix, pvscsi_disable_msix, bool, PVSCSI_RW); MODULE_PARM_DESC(disable_msix, "Disable MSI-X use in driver - (default=0)");
PAGE_SIZE / MAX_PACKET_SIZE)
static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;
static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;
static unsigned int queue_length = 21;
module_param_array(index, int, NULL, 0444);
MODULE_PARM_DESC(index, "card index");
module_param_array(id, charp, NULL, 0444);
MODULE_PARM_DESC(id, "ID string");
module_param_array(enable, bool, NULL, 0444);
MODULE_PARM_DESC(enable, "enable card");
module_param(queue_length, uint, 0644);
MODULE_PARM_DESC(queue_length, "USB queue length in microframes, "
__stringify(MIN_QUEUE_LENGTH)"-"__stringify(MAX_QUEUE_LENGTH));
enum {
INTF_PLAYBACK,
INTF_CAPTURE,
INTF_MIDI,
INTF_COUNT
};
/* bits in struct ua101::states */
enum {
USB_CAPTURE_RUNNING,
USB_PLAYBACK_RUNNING,
ALSA_CAPTURE_OPEN,
ALSA_PLAYBACK_OPEN,
ret = 0;
}
mutex_unlock(&vibrator_lock);
return ret;
}
CARDHU_MISC_ATTR(cardhu_chipid);
CARDHU_MISC_ATTR(cardhu_backup_chipid);
CARDHU_MISC_ATTR(cardhu_pcbid);
CARDHU_MISC_ATTR(cardhu_projectid);
CARDHU_MISC_ATTR(cardhu_projectname);
static struct kobj_attribute cardhu_vibctl_attr = {
.attr = {
.name = __stringify(cardhu_vibctl),
.mode = 0220,
},
.store = cardhu_vibctl_store,
};
static struct attribute *attr_list[] = {
&cardhu_chipid_attr.attr,
&cardhu_backup_chipid_attr.attr,
&cardhu_pcbid_attr.attr,
&cardhu_projectid_attr.attr,
&cardhu_projectname_attr.attr,
&cardhu_vibctl_attr.attr,
NULL,
};
#include <linux/dma-mapping.h>
#include <linux/delay.h>
#include <linux/skbuff.h>
#include <linux/netdevice.h>
#include <linux/wireless.h>
#include <net/mac80211.h>
#include <linux/etherdevice.h>
#include <asm/unaligned.h>
#include "iwl-dev.h"
#include "iwl-core.h"
#include "iwl-io.h"
#ifdef CONFIG_IWLWIFI_DEBUG
static const char *led_type_str[] = {
__stringify(IWL_LED_TRG_TX),
__stringify(IWL_LED_TRG_RX),
__stringify(IWL_LED_TRG_ASSOC),
__stringify(IWL_LED_TRG_RADIO),
NULL
};
#endif /* CONFIG_IWLWIFI_DEBUG */
static const struct {
u16 tpt;
u8 on_time;
u8 off_time;
} blink_tbl[] =
{
{300, 25, 25},
"\t\t\t 32/0x0020: file\n" "\t\t\t 64/0x0040: i2c\n" "\t\t\t128/0x0080: irq\n" "\t\t\t256/0x0100: high volume\n"); MODULE_PARM_DESC(cx18_pci_latency, "Change the PCI latency to 64 if lower: 0 = No, 1 = Yes,\n" "\t\t\tDefault: Yes"); MODULE_PARM_DESC(retry_mmio, "(Deprecated) MMIO writes are now always checked and retried\n" "\t\t\tEffectively: 1 [Yes]"); MODULE_PARM_DESC(mmio_ndelay, "(Deprecated) MMIO accesses are now never purposely delayed\n" "\t\t\tEffectively: 0 ns"); MODULE_PARM_DESC(enc_ts_buffers, "Encoder TS buffer memory (MB). (enc_ts_bufs can override)\n" "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_TS_BUFFERS)); MODULE_PARM_DESC(enc_ts_bufsize, "Size of an encoder TS buffer (kB)\n" "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_TS_BUFSIZE)); MODULE_PARM_DESC(enc_ts_bufs, "Number of encoder TS buffers\n" "\t\t\tDefault is computed from other enc_ts_* parameters"); MODULE_PARM_DESC(enc_mpg_buffers, "Encoder MPG buffer memory (MB). (enc_mpg_bufs can override)\n" "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_MPG_BUFFERS)); MODULE_PARM_DESC(enc_mpg_bufsize, "Size of an encoder MPG buffer (kB)\n" "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_MPG_BUFSIZE)); MODULE_PARM_DESC(enc_mpg_bufs, "Number of encoder MPG buffers\n" "\t\t\tDefault is computed from other enc_mpg_* parameters");
#include "cpia2.h"
#include "cpia2dev.h"
static int video_nr = -1;
module_param(video_nr, int, 0);
MODULE_PARM_DESC(video_nr,"video device to register (0=/dev/video0, etc)");
static int buffer_size = 68*1024;
module_param(buffer_size, int, 0);
MODULE_PARM_DESC(buffer_size, "Size for each frame buffer in bytes (default 68k)");
static int num_buffers = 3;
module_param(num_buffers, int, 0);
MODULE_PARM_DESC(num_buffers, "Number of frame buffers (1-"
__stringify(VIDEO_MAX_FRAME) ", default 3)");
static int alternate = DEFAULT_ALT;
module_param(alternate, int, 0);
MODULE_PARM_DESC(alternate, "USB Alternate (" __stringify(USBIF_ISO_1) "-"
__stringify(USBIF_ISO_6) ", default "
__stringify(DEFAULT_ALT) ")");
static int flicker_freq = 60;
module_param(flicker_freq, int, 0);
MODULE_PARM_DESC(flicker_freq, "Flicker frequency (" __stringify(50) "or"
__stringify(60) ", default "
__stringify(60) ")");
static int flicker_mode = NEVER_FLICKER;
module_param(flicker_mode, int, 0);
int main(int argc, char* argv[])
{
int ret = EXIT_SUCCESS;
int childstatus;
unsigned int i;
outputstd("Trinity v" __stringify(VERSION) " Dave Jones <*****@*****.**>\n");
progname = argv[0];
initpid = getpid();
page_size = getpagesize();
num_online_cpus = sysconf(_SC_NPROCESSORS_ONLN);
select_syscall_tables();
if (create_shm())
exit(EXIT_FAILURE);
parse_args(argc, argv);
outputstd("Done parsing arguments.\n");
if (kernel_taint_mask != (int)0xFFFFFFFF) {
outputstd("Custom kernel taint mask has been specified: 0x%08x (%d).\n", kernel_taint_mask, kernel_taint_mask);
}
if (user_specified_children != 0)
max_children = user_specified_children;
else
max_children = sysconf(_SC_NPROCESSORS_ONLN);
if (max_children > MAX_NR_CHILDREN) {
outputerr("Increase MAX_NR_CHILDREN!\n");
exit(EXIT_FAILURE);
}
setup_shm_postargs();
if (logging == TRUE)
open_logfiles();
if (munge_tables() == FALSE) {
ret = EXIT_FAILURE;
goto out;
}
if (show_syscall_list == TRUE) {
dump_syscall_tables();
goto out;
}
init_syscalls();
if (show_ioctl_list == TRUE) {
dump_ioctls();
goto out;
}
if (getuid() == 0) {
if (dangerous == TRUE) {
outputstd("DANGER: RUNNING AS ROOT.\n");
outputstd("Unless you are running in a virtual machine, this could cause serious problems such as overwriting CMOS\n");
outputstd("or similar which could potentially make this machine unbootable without a firmware reset.\n\n");
outputstd("ctrl-c now unless you really know what you are doing.\n");
for (i = 10; i > 0; i--) {
outputstd("Continuing in %d seconds.\r", i);
(void)fflush(stdout);
sleep(1);
}
} else {
outputstd("Don't run as root (or pass --dangerous if you know what you are doing).\n");
exit(EXIT_FAILURE);
}
}
if (do_specific_proto == TRUE)
find_specific_proto(specific_proto_optarg);
init_buffers();
parse_devices();
pids_init();
setup_main_signals();
kernel_taint_initial = check_tainted();
if (kernel_taint_initial != 0) {
output(0, "Kernel was tainted on startup. Will ignore flags that are already set.\n");
}
change_tmp_dir();
/* check if we ctrl'c or something went wrong during init. */
if (shm->exit_reason != STILL_RUNNING)
goto cleanup_fds;
init_watchdog();
do_main_loop();
/* Shutting down. */
waitpid(watchdog_pid, &childstatus, 0);
output(0, "\nRan %ld syscalls. Successes: %ld Failures: %ld\n",
shm->total_syscalls_done - 1, shm->successes, shm->failures);
ret = EXIT_SUCCESS;
cleanup_fds:
close_sockets();
destroy_global_mappings();
if (logging == TRUE)
close_logfiles();
out:
exit(ret);
}
#include <linux/module.h>
#include <linux/init.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <asm/uaccess.h>
#include "mt_ppm_internal.h"
static void ppm_thermal_update_limit_cb(enum ppm_power_state new_state);
static void ppm_thermal_status_change_cb(bool enable);
static void ppm_thermal_mode_change_cb(enum ppm_mode mode);
/* other members will init by ppm_main */
static struct ppm_policy_data thermal_policy = {
.name = __stringify(PPM_POLICY_THERMAL),
.lock = __MUTEX_INITIALIZER(thermal_policy.lock),
.policy = PPM_POLICY_THERMAL,
.priority = PPM_POLICY_PRIO_POWER_BUDGET_BASE,
.get_power_state_cb = NULL, /* decide in ppm main via min power budget */
.update_limit_cb = ppm_thermal_update_limit_cb,
.status_change_cb = ppm_thermal_status_change_cb,
.mode_change_cb = ppm_thermal_mode_change_cb,
};
void mt_ppm_cpu_thermal_protect(unsigned int limited_power)
{
FUNC_ENTER(FUNC_LV_POLICY);
ppm_info("Get budget from thermal => limited_power = %d\n", limited_power);
int trace_selftest_startup_dynamic_tracing(struct tracer *trace,
struct trace_array *tr,
int (*func)(void))
{
int save_ftrace_enabled = ftrace_enabled;
int save_tracer_enabled = tracer_enabled;
unsigned long count;
char *func_name;
int ret;
printk(KERN_CONT "PASSED\n");
pr_info("Testing dynamic ftrace: ");
ftrace_enabled = 1;
tracer_enabled = 1;
func();
func_name = "*" __stringify(DYN_FTRACE_TEST_NAME);
ftrace_set_filter(func_name, strlen(func_name), 1);
ret = tracer_init(trace, tr);
if (ret) {
warn_failed_init_tracer(trace, ret);
goto out;
}
msleep(100);
ret = trace_test_buffer(tr, &count);
if (ret)
goto out;
if (count) {
ret = -1;
printk(KERN_CONT ".. filter did not filter .. ");
goto out;
}
func();
msleep(100);
tracing_stop();
ftrace_enabled = 0;
ret = trace_test_buffer(tr, &count);
trace->reset(tr);
tracing_start();
if (!ret && count != 1) {
printk(KERN_CONT ".. filter failed count=%ld ..", count);
ret = -1;
goto out;
}
out:
ftrace_enabled = save_ftrace_enabled;
tracer_enabled = save_tracer_enabled;
ftrace_set_filter(NULL, 0, 1);
return ret;
}
* specified in the module load parameter.
* Useful if a blacklist entry interfered with a non-broken device.
*/
#define SBP2_WORKAROUND_128K_MAX_TRANS 0x1
#define SBP2_WORKAROUND_INQUIRY_36 0x2
#define SBP2_WORKAROUND_MODE_SENSE_8 0x4
#define SBP2_WORKAROUND_FIX_CAPACITY 0x8
#define SBP2_WORKAROUND_DELAY_INQUIRY 0x10
#define SBP2_INQUIRY_DELAY 12
#define SBP2_WORKAROUND_POWER_CONDITION 0x20
#define SBP2_WORKAROUND_OVERRIDE 0x100
static int sbp2_param_workarounds;
module_param_named(workarounds, sbp2_param_workarounds, int, 0644);
MODULE_PARM_DESC(workarounds, "Work around device bugs (default = 0"
", 128kB max transfer = " __stringify(SBP2_WORKAROUND_128K_MAX_TRANS)
", 36 byte inquiry = " __stringify(SBP2_WORKAROUND_INQUIRY_36)
", skip mode page 8 = " __stringify(SBP2_WORKAROUND_MODE_SENSE_8)
", fix capacity = " __stringify(SBP2_WORKAROUND_FIX_CAPACITY)
", delay inquiry = " __stringify(SBP2_WORKAROUND_DELAY_INQUIRY)
", set power condition in start stop unit = "
__stringify(SBP2_WORKAROUND_POWER_CONDITION)
", override internal blacklist = " __stringify(SBP2_WORKAROUND_OVERRIDE)
", or a combination)");
/*
* We create one struct sbp2_logical_unit per SBP-2 Logical Unit Number Entry
* and one struct scsi_device per sbp2_logical_unit.
*/
struct sbp2_logical_unit {
struct sbp2_target *tgt;
static int
trace_selftest_function_recursion(void)
{
int save_ftrace_enabled = ftrace_enabled;
char *func_name;
int len;
int ret;
/* The previous test PASSED */
pr_cont("PASSED\n");
pr_info("Testing ftrace recursion: ");
/* enable tracing, and record the filter function */
ftrace_enabled = 1;
/* Handle PPC64 '.' name */
func_name = "*" __stringify(DYN_FTRACE_TEST_NAME);
len = strlen(func_name);
ret = ftrace_set_filter(&test_rec_probe, func_name, len, 1);
if (ret) {
pr_cont("*Could not set filter* ");
goto out;
}
ret = register_ftrace_function(&test_rec_probe);
if (ret) {
pr_cont("*could not register callback* ");
goto out;
}
DYN_FTRACE_TEST_NAME();
unregister_ftrace_function(&test_rec_probe);
ret = -1;
if (trace_selftest_recursion_cnt != 1) {
pr_cont("*callback not called once (%d)* ",
trace_selftest_recursion_cnt);
goto out;
}
trace_selftest_recursion_cnt = 1;
pr_cont("PASSED\n");
pr_info("Testing ftrace recursion safe: ");
ret = ftrace_set_filter(&test_recsafe_probe, func_name, len, 1);
if (ret) {
pr_cont("*Could not set filter* ");
goto out;
}
ret = register_ftrace_function(&test_recsafe_probe);
if (ret) {
pr_cont("*could not register callback* ");
goto out;
}
DYN_FTRACE_TEST_NAME();
unregister_ftrace_function(&test_recsafe_probe);
ret = -1;
if (trace_selftest_recursion_cnt != 2) {
pr_cont("*callback not called expected 2 times (%d)* ",
trace_selftest_recursion_cnt);
goto out;
}
ret = 0;
out:
ftrace_enabled = save_ftrace_enabled;
return ret;
}
