type stringclasses 5
values | content stringlengths 9 163k |
|---|---|
functions | int
intel_trans_dp_port_sel (struct drm_crtc *crtc)
{
struct drm_device *dev = crtc->dev;
struct drm_mode_config *mode_config = &dev->mode_config;
struct drm_encoder *encoder;
list_for_each_entry(encoder, &mode_config->encoder_list, head) {
struct intel_dp *intel_dp;
if (encoder->crtc != crtc)
continue;
... |
functions | bool intel_dpd_is_edp(struct drm_device *dev)
{
struct drm_i915_private *dev_priv = dev->dev_private;
struct child_device_config *p_child;
int i;
if (!dev_priv->child_dev_num)
return false;
for (i = 0; i < dev_priv->child_dev_num; i++) {
p_child = dev_priv->child_dev + i;
if (p_child->dvo_port == PORT_IDP... |
functions | void
intel_dp_init(struct drm_device *dev, int output_reg)
{
struct drm_i915_private *dev_priv = dev->dev_private;
struct drm_connector *connector;
struct intel_dp *intel_dp;
struct intel_encoder *intel_encoder;
struct intel_connector *intel_connector;
const char *name = NULL;
int type;
intel_dp = kzalloc(size... |
includes |
#include <fcntl.h> |
includes | #include <signal.h> |
includes | #include <sys/types.h> |
functions | int p_mpi_hook_slurmstepd_task(const mpi_plugin_task_info_t*job,
char ***env)
{
debug("Using mpi/none");
return SLURM_SUCCESS;
} |
functions | int p_mpi_hook_client_single_task_per_node()
{
return false;
} |
functions | int p_mpi_hook_client_fini(mpi_plugin_client_state_t *state)
{
return SLURM_SUCCESS;
} |
includes | #include <nettle/sha1.h> |
functions | void SHATransform(word32 * digest, word32 * block)
{
// This has different endianess than the PuTTY code, but this is fine for use in the RNG
_nettle_sha1_compress(digest, (uint8_t *)block);
} |
functions | void SHA_Init(SHA_State *s)
{
sha1_init(s);
} |
functions | void SHA_Bytes(SHA_State *s, const void *p, int len) {
sha1_update(s, len, p);
} |
functions | void SHA_Final(SHA_State *s, unsigned char *digest) {
sha1_digest(s, SHA1_DIGEST_SIZE, digest);
} |
functions | void SHA_Simple(const void *p, int len, unsigned char *output) {
SHA_State s;
SHA_Init(&s);
SHA_Bytes(&s, p, len);
SHA_Final(&s, output);
smemclr(&s, sizeof(s));
} |
functions | void sha1_free(void *handle)
{
SHA_State *s = handle;
smemclr(s, sizeof(*s));
sfree(s);
} |
functions | void sha1_bytes(void *handle, const void *p, int len)
{
SHA_State *s = handle;
SHA_Bytes(s, p, len);
} |
functions | void sha1_final(void *handle, unsigned char *output)
{
SHA_State *s = handle;
SHA_Final(s, output);
sha1_free(s);
} |
functions | void sha1_free_context(void *handle)
{
smemclr(handle, 3 * sizeof(SHA_State));
sfree(handle);
} |
functions | void sha1_key_internal(void *handle, unsigned char *key, int len)
{
SHA_State *keys = (SHA_State *)handle;
unsigned char foo[64];
int i;
memset(foo, 0x36, 64);
for (i = 0; i < len && i < 64; i++)
foo[i] ^= key[i];
SHA_Init(&keys[0]);
SHA_Bytes(&keys[0], foo, 64);
memset(foo, 0x5C, 64)... |
functions | void sha1_key(void *handle, unsigned char *key)
{
sha1_key_internal(handle, key, 20);
} |
functions | void sha1_key_buggy(void *handle, unsigned char *key)
{
sha1_key_internal(handle, key, 16);
} |
functions | void hmacsha1_start(void *handle)
{
SHA_State *keys = (SHA_State *)handle;
keys[2] = keys[0]; /* structure copy */
} |
functions | void hmacsha1_bytes(void *handle, unsigned char const *blk, int len)
{
SHA_State *keys = (SHA_State *)handle;
SHA_Bytes(&keys[2], (void *)blk, len);
} |
functions | void hmacsha1_genresult(void *handle, unsigned char *hmac)
{
SHA_State *keys = (SHA_State *)handle;
SHA_State s;
unsigned char intermediate[20];
s = keys[2]; /* structure copy */
SHA_Final(&s, intermediate);
s = keys[1]; /* structure copy */
SHA_Bytes(&s, intermediate, 20);
... |
functions | void sha1_do_hmac(void *handle, unsigned char *blk, int len,
unsigned long seq, unsigned char *hmac)
{
unsigned char seqbuf[4];
PUT_32BIT_MSB_FIRST(seqbuf, seq);
hmacsha1_start(handle);
hmacsha1_bytes(handle, seqbuf, 4);
hmacsha1_bytes(handle, blk, len);
hmacsha1_genresult(handle, hmac);
} |
functions | void sha1_generate(void *handle, unsigned char *blk, int len,
unsigned long seq)
{
sha1_do_hmac(handle, blk, len, seq, blk + len);
} |
functions | int hmacsha1_verresult(void *handle, unsigned char const *hmac)
{
unsigned char correct[20];
hmacsha1_genresult(handle, correct);
return smemeq(correct, hmac, 20);
} |
functions | int sha1_verify(void *handle, unsigned char *blk, int len,
unsigned long seq)
{
unsigned char correct[20];
sha1_do_hmac(handle, blk, len, seq, correct);
return smemeq(correct, blk + len, 20);
} |
functions | void hmacsha1_96_genresult(void *handle, unsigned char *hmac)
{
unsigned char full[20];
hmacsha1_genresult(handle, full);
memcpy(hmac, full, 12);
} |
functions | void sha1_96_generate(void *handle, unsigned char *blk, int len,
unsigned long seq)
{
unsigned char full[20];
sha1_do_hmac(handle, blk, len, seq, full);
memcpy(blk + len, full, 12);
} |
functions | int hmacsha1_96_verresult(void *handle, unsigned char const *hmac)
{
unsigned char correct[20];
hmacsha1_genresult(handle, correct);
return smemeq(correct, hmac, 12);
} |
functions | int sha1_96_verify(void *handle, unsigned char *blk, int len,
unsigned long seq)
{
unsigned char correct[20];
sha1_do_hmac(handle, blk, len, seq, correct);
return smemeq(correct, blk + len, 12);
} |
functions | void hmac_sha1_simple(void *key, int keylen, void *data, int datalen,
unsigned char *output) {
SHA_State states[2];
unsigned char intermediate[20];
sha1_key_internal(states, key, keylen);
SHA_Bytes(&states[0], data, datalen);
SHA_Final(&states[0], intermediate);
SHA_Bytes(&states[1], i... |
functions | void do_compute_dfns(struct basic_block *bb, struct basic_block **df_array, int *dfn, struct basic_block *entry_bb)
{
unsigned int i;
for (i = 0; i < bb->nr_successors; i++) {
struct basic_block *succ = bb->successors[i];
if (succ->dfn || succ == entry_bb)
continue;
(*dfn)++;
succ->dfn = *dfn;
df_a... |
functions | int compute_dfns(struct compilation_unit *cu)
{
int dfn = 0;
cu->bb_df_array = zalloc(sizeof(struct basic_block *) * nr_bblocks(cu));
if (!cu->bb_df_array)
return -ENOMEM;
cu->bb_df_array[0] = cu->entry_bb;
do_compute_dfns(cu->entry_bb, cu->bb_df_array, &dfn, cu->entry_bb);
return 0;
} |
functions | int compute_dom(struct compilation_unit *cu)
{
struct basic_block *start;
bool changed;
start = cu->entry_bb;
cu->doms = zalloc(sizeof(struct basic_block *) * nr_bblocks(cu));
if (!cu->doms)
return -ENOMEM;
cu->doms[start->dfn] = start;
changed = true;
while (changed) {
struct basic_block *b;
unsigned... |
functions | int compute_dom_frontier(struct compilation_unit *cu)
{
struct basic_block *b, *start;
start = cu->entry_bb;
for_each_basic_block(b, &cu->bb_list) {
b->dom_frontier = alloc_bitset(nr_bblocks(cu));
if (!b->dom_frontier)
return -ENOMEM;
} |
includes |
#include <linux/kernel.h> |
includes | #include <linux/slab.h> |
includes | #include <linux/module.h> |
includes | #include <linux/fs.h> |
includes | #include <linux/platform_device.h> |
includes | #include <linux/debugfs.h> |
includes | #include <linux/cdev.h> |
includes | #include <linux/uaccess.h> |
includes | #include <linux/sched.h> |
includes | #include <linux/list.h> |
includes | #include <linux/mutex.h> |
includes | #include <linux/io.h> |
includes | #include <linux/msm_ion.h> |
includes | #include <linux/types.h> |
includes | #include <linux/clk.h> |
includes | #include <linux/qseecom.h> |
includes | #include <linux/elf.h> |
includes | #include <linux/firmware.h> |
includes | #include <linux/freezer.h> |
includes | #include <linux/scatterlist.h> |
includes | #include <soc/qcom/subsystem_restart.h> |
includes | #include <soc/qcom/scm.h> |
includes | #include <soc/qcom/socinfo.h> |
includes | #include <mach/board.h> |
includes | #include <mach/msm_bus.h> |
includes | #include <mach/msm_bus_board.h> |
includes | #include <mach/qseecomi.h> |
includes | #include <asm/cacheflush.h> |
defines |
#define pr_fmt(fmt) "QSEECOM: %s: " fmt, __func__ |
defines |
#define QSEECOM_DEV "qseecom" |
defines | #define QSEOS_VERSION_14 0x14 |
defines | #define QSEEE_VERSION_00 0x400000 |
defines | #define QSEE_VERSION_01 0x401000 |
defines | #define QSEE_VERSION_02 0x402000 |
defines | #define QSEE_VERSION_03 0x403000 |
defines | #define QSEE_VERSION_04 0x404000 |
defines | #define QSEE_VERSION_05 0x405000 |
defines |
#define QSEOS_CHECK_VERSION_CMD 0x00001803 |
defines |
#define QSEE_CE_CLK_100MHZ 100000000 |
defines |
#define QSEECOM_MAX_SG_ENTRY 512 |
defines | #define QSEECOM_INVALID_KEY_ID 0xff |
defines | #define SCM_SAVE_PARTITION_HASH_ID 0x01 |
defines | #define SCM_IS_ACTIVATED_ID 0x02 |
defines |
#define RPMB_SERVICE 0x2000 |
defines |
#define QSEECOM_SEND_CMD_CRYPTO_TIMEOUT 2000 |
defines | #define QSEECOM_LOAD_APP_CRYPTO_TIMEOUT 2000 |
structs | struct qseecom_registered_listener_list {
struct list_head list;
struct qseecom_register_listener_req svc;
uint32_t user_virt_sb_base;
u8 *sb_virt;
s32 sb_phys;
size_t sb_length;
struct ion_handle *ihandle; /* Retrieve phy addr */
wait_queue_head_t rcv_req_wq;
int ... |
structs | struct qseecom_registered_app_list {
struct list_head list;
u32 app_id;
u32 ref_cnt;
char app_name[MAX_APP_NAME_SIZE];
}; |
structs | struct qseecom_registered_kclient_list {
struct list_head list;
struct qseecom_handle *handle;
}; |
structs | struct ce_hw_usage_info {
uint32_t qsee_ce_hw_instance;
uint32_t hlos_ce_hw_instance;
uint32_t disk_encrypt_pipe;
uint32_t file_encrypt_pipe;
}; |
structs | struct qseecom_clk {
enum qseecom_ce_hw_instance instance;
struct clk *ce_core_clk;
struct clk *ce_clk;
struct clk *ce_core_src_clk;
struct clk *ce_bus_clk;
uint32_t clk_access_cnt;
}; |
structs | struct qseecom_control {
struct ion_client *ion_clnt; /* Ion client */
struct list_head registered_listener_list_head;
spinlock_t registered_listener_list_lock;
struct list_head registered_app_list_head;
spinlock_t registered_app_list_lock;
struct list_head registered_kclient_list_head;
spin... |
structs | struct qseecom_client_handle {
u32 app_id;
u8 *sb_virt;
s32 sb_phys;
uint32_t user_virt_sb_base;
size_t sb_length;
struct ion_handle *ihandle; /* Retrieve phy addr */
char app_name[MAX_APP_NAME_SIZE];
}; |
structs | struct qseecom_listener_handle {
u32 id;
}; |
structs | struct qseecom_dev_handle {
enum qseecom_client_handle_type type;
union {
struct qseecom_client_handle client;
struct qseecom_listener_handle listener;
}; |
structs | struct qseecom_sg_entry {
uint32_t phys_addr;
uint32_t len;
}; |
structs | struct qseecom_key_id_usage_desc {
uint8_t desc[QSEECOM_KEY_ID_SIZE];
}; |
functions | int __qseecom_is_svc_unique(struct qseecom_dev_handle *data,
struct qseecom_register_listener_req *svc)
{
struct qseecom_registered_listener_list *ptr;
int unique = 1;
unsigned long flags;
spin_lock_irqsave(&qseecom.registered_listener_list_lock, flags);
list_for_each_entry(ptr, &qseecom.registered_listener_lis... |
functions | int __qseecom_set_sb_memory(struct qseecom_registered_listener_list *svc,
struct qseecom_dev_handle *handle,
struct qseecom_register_listener_req *listener)
{
int ret = 0;
struct qseecom_register_listener_ireq req;
struct qseecom_command_scm_resp resp;
ion_phys_addr_t pa;
/* Get the handle of the shared f... |
functions | int qseecom_register_listener(struct qseecom_dev_handle *data,
void __user *argp)
{
int ret = 0;
unsigned long flags;
struct qseecom_register_listener_req rcvd_lstnr;
struct qseecom_registered_listener_list *new_entry;
ret = copy_from_user(&rcvd_lstnr, argp, sizeof(rcvd_lstnr));
if (ret) {
pr_err("copy_fr... |
functions | int qseecom_unregister_listener(struct qseecom_dev_handle *data)
{
int ret = 0;
unsigned long flags;
uint32_t unmap_mem = 0;
struct qseecom_register_listener_ireq req;
struct qseecom_registered_listener_list *ptr_svc = NULL;
struct qseecom_command_scm_resp resp;
struct ion_handle *ihandle = NULL; /* Retrieve ph... |
functions | int __qseecom_set_msm_bus_request(uint32_t mode)
{
int ret = 0;
struct qseecom_clk *qclk;
qclk = &qseecom.qsee;
if (qclk->ce_core_src_clk != NULL) {
if (mode == INACTIVE) {
__qseecom_disable_clk(CLK_QSEE);
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.