type stringclasses 5
values | content stringlengths 9 163k |
|---|---|
functions | u32 __get_unaligned_le32(unsigned char *p)
{
return (u32)p[0] | ((u32)p[1] << 8) | ((u32)p[2] << 16) | ((u32)p[3] << 24);
} |
functions | u64 __get_unaligned_le64(unsigned char *p)
{
return (u64)p[0] | ((u64)p[1] << 8) | ((u64)p[2] << 16) | ((u64)p[3] << 24) |
((u64)p[4] << 32) | ((u64)p[5] << 40) | ((u64)p[6] << 48) | ((u64)p[7] << 56);
} |
functions | int ubi_initialize(void)
{
struct mtd_info *master;
struct mtd_device *dev;
struct mtd_partition mtd_part;
struct part_info *part;
char buffer[20];
u8 pnum;
int err;
if (ubi_devices[0]) {
ubi = ubi_devices[0];
return 0;
// ubi_exit();
// del_mtd_partitions(&nand_info[0]);
} |
functions | int init_fat(void)
{
block_dev_desc_t *dev_desc;
int part = 1;
struct mmc *mmc;
mmc = find_mmc_device(0);
if (!mmc)
return -1;
if (mmc_init(mmc))
return -1;
dev_desc = get_dev("mmc", 0);
if (dev_desc==NULL) {
printf("\nERROR: Invalid mmc device. Please check your SD/MMC card.\n");
return -1;
} |
functions | int fw_load(char *filename, unsigned char *buf, unsigned long size, unsigned long offset)
{
if (init_fat() < 0)
return -1;
printf("Reading file %s (0x%lx bytes from 0x%lx) offset\n", filename, size, offset);
return file_fat_read(filename, buf, size, offset);
} |
functions | int check_global_property(char *name, char *val, unsigned long len)
{
long t;
char date[32];
if (!strcmp(name, "device")) {
if (strcmp(val, CONFIG_BOARD_NAME))
return -1;
} |
functions | int check_block_property(char *block_name, char *name, char *val,
unsigned long len, struct block_properties *block_prop)
{
if (!strcmp(name, "raw") && !strcmp(val, "yes"))
block_prop->raw = 1;
if (!strcmp(name, "crc32"))
block_prop->crc32 = __get_unaligned_le32((unsigned char *)val);
return 0;
} |
functions | long process_all_properties(unsigned char *start, char *block_name,
int dry_run, int *image_valid, struct block_properties *block_prop)
{
u32 property_name_len;
u32 property_val_len;
char *property_name, *property_val;
unsigned char *buf = start;
int res;
property_name_len = __get_unaligned_le32(buf);
buf += ... |
functions | int flash_chunk(u64 offset, unsigned char *buf, size_t count)
{
nand_info_t *nand;
#ifdef CONFIG_SYS_NAND_SELECT_DEVICE
board_nand_select_device(nand_info[0].priv, 0);
#endif
nand = &nand_info[0];
count = roundup(count, nand->writesize);
printf("Flashing chunk to offset 0x%08x, count 0x%x...\n", (u32)offset, co... |
functions | int erase_flash(u64 offset, u64 size)
{
nand_erase_options_t opts;
nand_info_t *nand;
#ifdef CONFIG_SYS_NAND_SELECT_DEVICE
board_nand_select_device(nand_info[0].priv, 0);
#endif
nand = &nand_info[0];
memset(&opts, 0, sizeof(opts));
opts.offset = offset;
opts.length = size;
opts.jffs2 = 0;
opts.quiet = 0;
o... |
functions | int process_block_raw(char *filename, struct block_properties *block_prop, int dry_run)
{
unsigned char *buf = (unsigned char *)CONFIG_UPDATE_TMPBUF;
u64 bytes_read = 0, bytes_remain = block_prop->size;
struct update_layout_entry *layout;
u64 flash_address;
u32 block_crc32;
layout = get_block_flash_layout(block_... |
functions | int process_block_ubivol(char *filename, struct block_properties *block_prop, int dry_run)
{
unsigned char *buf = (unsigned char *)CONFIG_UPDATE_TMPBUF;
u64 bytes_read = 0, bytes_remain = block_prop->size;
int i = 0, err = 0;
int rsvd_bytes = 0;
int found = 0;
struct ubi_volume *vol;
u32 block_crc32;
log("Flas... |
functions | void ubi_cleanup(void)
{
ubi_exit();
del_mtd_partitions(&nand_info[0]);
} |
functions | int process_update(char *filename, int dry_run)
{
struct fw_update_head fw_head;
unsigned char *header;
unsigned char *p;
u32 block_name_len;
u64 block_offset, block_size;
char *block_name;
int image_valid = 1;
int ret = 0;
if (fw_load(filename, (unsigned char *)&fw_head, sizeof(fw_head), 0) < 0)
{
log("Fa... |
functions | int do_updatesim(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
return process_update(CONFIG_UPDATE_FILENAME, 1);
} |
functions | int do_update(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
return process_update(CONFIG_UPDATE_FILENAME, 0);
} |
functions | int find_key(unsigned char code)
{
int i;
for (i = 0; i < ARRAY_SIZE(keymap); i++) {
if (keymap[i][0] == code) {
return keymap[i][1];
} |
functions | int key_to_number(int key)
{
if ((key >= KEY_1) && (key <= KEY_0))
return (key - KEY_1 + 1) % 10;
else
return -1;
} |
functions | int check_for_menu_key(void)
{
uchar code;
int key;
unsigned int t;
log(" Press any key to enter update mode\n");
/* Switch LPC to normal mode */
code = 0x02;
i2c_write(CONFIG_LPC_I2C_ADDR, 0, 0, &code, 1);
t = 0;
while (t < KEYPRESS_TIMEOUT) {
__gpio_clear_pin(GPIO_LED_EN);
udelay(BLINK_PERIOD / 2);
... |
functions | void file_check(char *filename, struct file_stat *stat)
{
struct file_entry *f, *cur;
char *c;
if (stat->is_directory)
return;
c = strstr(filename, CONFIG_UPDATE_FILEEXT);
if (c && *(c + sizeof(CONFIG_UPDATE_FILEEXT) - 1) == '\0') {
f = malloc(sizeof(*f));
if (!f) {
printf("Failed to allo... |
functions | int ask_user(char *buf, unsigned int len)
{
uchar code;
int i, n;
int key, num;
struct file_entry *cur;
metronome_disable_sync();
lcd_clear();
eputs("Select firmware update file:\n\n");
n = 0;
list_for_each_entry(cur, &found_files, link) {
n++;
log("%d. %s\n", n, cur->filename);
if (n > 9)
break;
} |
functions | int do_checkupdate(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
int choice;
int res;
int dry_run = 0;
char filename[255];
struct file_entry *cur, *tmp;
if (!strcmp(argv[0], "check_and_updatesim")) {
dry_run = 1;
printf("Dry run mode\n");
} |
includes | #include <linux/init.h> |
includes | #include <linux/module.h> |
includes | #include <linux/moduleparam.h> |
includes | #include <linux/skbuff.h> |
includes | #include <linux/timer.h> |
includes | #include <linux/completion.h> |
includes | #include <linux/connector.h> |
includes | #include <linux/random.h> |
includes | #include <linux/platform_device.h> |
includes | #include <linux/limits.h> |
includes | #include <linux/fb.h> |
includes | #include <linux/io.h> |
includes | #include <linux/mutex.h> |
includes | #include <linux/slab.h> |
includes | #include <video/edid.h> |
includes | #include <video/uvesafb.h> |
includes | #include <video/vga.h> |
includes | #include <linux/pci.h> |
includes | #include <asm/mtrr.h> |
defines | #define param_check_scroll(name, p) __param_check(name, p, void) |
functions | void uvesafb_cn_callback(struct cn_msg *msg, struct netlink_skb_parms *nsp)
{
struct uvesafb_task *utask;
struct uvesafb_ktask *task;
if (!cap_raised(current_cap(), CAP_SYS_ADMIN))
return;
if (msg->seq >= UVESAFB_TASKS_MAX)
return;
mutex_lock(&uvfb_lock);
task = uvfb_tasks[msg->seq];
if (!task || msg->ac... |
functions | int uvesafb_helper_start(void)
{
char *envp[] = {
"HOME=/",
"PATH=/sbin:/bin",
NULL,
} |
functions | int uvesafb_exec(struct uvesafb_ktask *task)
{
static int seq;
struct cn_msg *m;
int err;
int len = sizeof(task->t) + task->t.buf_len;
/*
* Check whether the message isn't longer than the maximum
* allowed by connector.
*/
if (sizeof(*m) + len > CONNECTOR_MAX_MSG_SIZE) {
printk(KERN_WARNING "uvesafb: mes... |
functions | void uvesafb_free(struct uvesafb_ktask *task)
{
if (task) {
if (task->done)
kfree(task->done);
kfree(task);
} |
functions | void uvesafb_reset(struct uvesafb_ktask *task)
{
struct completion *cpl = task->done;
memset(task, 0, sizeof(*task));
task->done = cpl;
} |
functions | void uvesafb_setup_var(struct fb_var_screeninfo *var,
struct fb_info *info, struct vbe_mode_ib *mode)
{
struct uvesafb_par *par = info->par;
var->vmode = FB_VMODE_NONINTERLACED;
var->sync = FB_SYNC_VERT_HIGH_ACT;
var->xres = mode->x_res;
var->yres = mode->y_res;
var->xres_virtual = mode->x_res;
var->yres_vir... |
functions | int uvesafb_vbe_find_mode(struct uvesafb_par *par,
int xres, int yres, int depth, unsigned char flags)
{
int i, match = -1, h = 0, d = 0x7fffffff;
for (i = 0; i < par->vbe_modes_cnt; i++) {
h = abs(par->vbe_modes[i].x_res - xres) +
abs(par->vbe_modes[i].y_res - yres) +
abs(depth - par->vbe_modes[i].d... |
functions | void uvesafb_vbe_state_restore(struct uvesafb_par *par, u8 *state_buf)
{
struct uvesafb_ktask *task;
int err;
if (!state_buf)
return;
task = uvesafb_prep();
if (!task)
return;
task->t.regs.eax = 0x4f04;
task->t.regs.ecx = 0x000f;
task->t.regs.edx = 0x0002;
task->t.buf_len = par->vbe_state_size;
task->t... |
functions | __devinit uvesafb_vbe_getinfo(struct uvesafb_ktask *task,
struct uvesafb_par *par)
{
int err;
task->t.regs.eax = 0x4f00;
task->t.flags = TF_VBEIB;
task->t.buf_len = sizeof(struct vbe_ib);
task->buf = &par->vbe_ib;
strncpy(par->vbe_ib.vbe_signature, "VBE2", 4);
err = uvesafb_exec(task);
if (err || (task->t.r... |
functions | __devinit uvesafb_vbe_getmodes(struct uvesafb_ktask *task,
struct uvesafb_par *par)
{
int off = 0, err;
u16 *mode;
par->vbe_modes_cnt = 0;
/* Count available modes. */
mode = (u16 *) (((u8 *)&par->vbe_ib) + par->vbe_ib.mode_list_ptr);
while (*mode != 0xffff) {
par->vbe_modes_cnt++;
mode++;
} |
functions | __devinit uvesafb_vbe_getpmi(struct uvesafb_ktask *task,
struct uvesafb_par *par)
{
int i, err;
uvesafb_reset(task);
task->t.regs.eax = 0x4f0a;
task->t.regs.ebx = 0x0;
err = uvesafb_exec(task);
if ((task->t.regs.eax & 0xffff) != 0x4f || task->t.regs.es < 0xc000) {
par->pmi_setpal = par->ypan = 0;
} |
functions | __devinit uvesafb_is_valid_mode(struct fb_videomode *mode,
struct fb_info *info)
{
if (info->monspecs.gtf) {
fb_videomode_to_var(&info->var, mode);
if (fb_validate_mode(&info->var, info))
return 0;
} |
functions | __devinit uvesafb_vbe_getedid(struct uvesafb_ktask *task,
struct fb_info *info)
{
struct uvesafb_par *par = info->par;
int err = 0;
if (noedid || par->vbe_ib.vbe_version < 0x0300)
return -EINVAL;
task->t.regs.eax = 0x4f15;
task->t.regs.ebx = 0;
task->t.regs.ecx = 0;
task->t.buf_len = 0;
task->t.flags = 0;... |
functions | __devinit uvesafb_vbe_getmonspecs(struct uvesafb_ktask *task,
struct fb_info *info)
{
struct uvesafb_par *par = info->par;
int i;
memset(&info->monspecs, 0, sizeof(info->monspecs));
/*
* If we don't get all necessary data from the EDID block,
* mark it as incompatible with the GTF and set nocrtc so
* that... |
functions | __devinit uvesafb_vbe_getstatesize(struct uvesafb_ktask *task,
struct uvesafb_par *par)
{
int err;
uvesafb_reset(task);
/*
* Get the VBE state buffer size. We want all available
* hardware state data (CL = 0x0f).
*/
task->t.regs.eax = 0x4f04;
task->t.regs.ecx = 0x000f;
task->t.regs.edx = 0x0000;
task->... |
functions | __devinit uvesafb_vbe_init(struct fb_info *info)
{
struct uvesafb_ktask *task = NULL;
struct uvesafb_par *par = info->par;
int err;
task = uvesafb_prep();
if (!task)
return -ENOMEM;
err = uvesafb_vbe_getinfo(task, par);
if (err)
goto out;
err = uvesafb_vbe_getmodes(task, par);
if (err)
goto out;
par... |
functions | __devinit uvesafb_vbe_init_mode(struct fb_info *info)
{
struct list_head *pos;
struct fb_modelist *modelist;
struct fb_videomode *mode;
struct uvesafb_par *par = info->par;
int i, modeid;
/* Has the user requested a specific VESA mode? */
if (vbemode) {
for (i = 0; i < par->vbe_modes_cnt; i++) {
if (par->v... |
functions | int uvesafb_setpalette(struct uvesafb_pal_entry *entries, int count,
int start, struct fb_info *info)
{
struct uvesafb_ktask *task;
#ifdef CONFIG_X86
struct uvesafb_par *par = info->par;
int i = par->mode_idx;
#endif
int err = 0;
/*
* We support palette modifications for 8 bpp modes only, so
* there can nev... |
functions | else if (par->pmi_setpal) {
__asm__ __volatile__(
"call *(%%esi)"
: /* no return value */
: "a" (0x4f09), /* EAX */
"b" (0), /* EBX */
"c" (count), /* ECX */
"d" (start), /* EDX */
"D" (entries), /* EDI */
"S" (&par->pmi_pal)); /* ESI */
} |
functions | int uvesafb_setcolreg(unsigned regno, unsigned red, unsigned green,
unsigned blue, unsigned transp,
struct fb_info *info)
{
struct uvesafb_pal_entry entry;
int shift = 16 - dac_width;
int err = 0;
if (regno >= info->cmap.len)
return -EINVAL;
if (info->var.bits_per_pixel == 8) {
entry.red = red >> shi... |
functions | else if (regno < 16) {
switch (info->var.bits_per_pixel) {
case 16:
if (info->var.red.offset == 10) {
/* 1:5:5:5 */
((u32 *) (info->pseudo_palette))[regno] =
((red & 0xf800) >> 1) |
((green & 0xf800) >> 6) |
((blue & 0xf800) >> 11);
} |
functions | int uvesafb_setcmap(struct fb_cmap *cmap, struct fb_info *info)
{
struct uvesafb_pal_entry *entries;
int shift = 16 - dac_width;
int i, err = 0;
if (info->var.bits_per_pixel == 8) {
if (cmap->start + cmap->len > info->cmap.start +
info->cmap.len || cmap->start < info->cmap.start)
return -EINVAL;
entr... |
functions | int uvesafb_pan_display(struct fb_var_screeninfo *var,
struct fb_info *info)
{
#ifdef CONFIG_X86_32
int offset;
struct uvesafb_par *par = info->par;
offset = (var->yoffset * info->fix.line_length + var->xoffset) / 4;
/*
* It turns out it's not the best idea to do panning via vm86,
* so we only allow it if w... |
functions | int uvesafb_blank(int blank, struct fb_info *info)
{
struct uvesafb_ktask *task;
int err = 1;
#ifdef CONFIG_X86
struct uvesafb_par *par = info->par;
if (par->vbe_ib.capabilities & VBE_CAP_VGACOMPAT) {
int loop = 10000;
u8 seq = 0, crtc17 = 0;
if (blank == FB_BLANK_POWERDOWN) {
seq = 0x20;
crtc17 = 0x0... |
functions | int uvesafb_open(struct fb_info *info, int user)
{
struct uvesafb_par *par = info->par;
int cnt = atomic_read(&par->ref_count);
if (!cnt && par->vbe_state_size)
par->vbe_state_orig = uvesafb_vbe_state_save(par);
atomic_inc(&par->ref_count);
return 0;
} |
functions | int uvesafb_release(struct fb_info *info, int user)
{
struct uvesafb_ktask *task = NULL;
struct uvesafb_par *par = info->par;
int cnt = atomic_read(&par->ref_count);
if (!cnt)
return -EINVAL;
if (cnt != 1)
goto out;
task = uvesafb_prep();
if (!task)
goto out;
/* First, try to set the standard 80x25 te... |
functions | int uvesafb_set_par(struct fb_info *info)
{
struct uvesafb_par *par = info->par;
struct uvesafb_ktask *task = NULL;
struct vbe_crtc_ib *crtc = NULL;
struct vbe_mode_ib *mode = NULL;
int i, err = 0, depth = info->var.bits_per_pixel;
if (depth > 8 && depth != 32)
depth = info->var.red.length + info->var.green.le... |
functions | void uvesafb_check_limits(struct fb_var_screeninfo *var,
struct fb_info *info)
{
const struct fb_videomode *mode;
struct uvesafb_par *par = info->par;
/*
* If pixclock is set to 0, then we're using default BIOS timings
* and thus don't have to perform any checks here.
*/
if (!var->pixclock)
return;
if ... |
functions | int uvesafb_check_var(struct fb_var_screeninfo *var,
struct fb_info *info)
{
struct uvesafb_par *par = info->par;
struct vbe_mode_ib *mode = NULL;
int match = -1;
int depth = var->red.length + var->green.length + var->blue.length;
/*
* Various apps will use bits_per_pixel to set the color depth,
* which is ... |
functions | __devinit uvesafb_init_info(struct fb_info *info,
struct vbe_mode_ib *mode)
{
unsigned int size_vmode;
unsigned int size_remap;
unsigned int size_total;
struct uvesafb_par *par = info->par;
int i, h;
info->pseudo_palette = ((u8 *)info->par + sizeof(struct uvesafb_par));
info->fix = uvesafb_fix;
info->fix.ypa... |
functions | __devinit uvesafb_init_mtrr(struct fb_info *info)
{
#ifdef CONFIG_MTRR
if (mtrr && !(info->fix.smem_start & (PAGE_SIZE - 1))) {
int temp_size = info->fix.smem_len;
unsigned int type = 0;
switch (mtrr) {
case 1:
type = MTRR_TYPE_UNCACHABLE;
break;
case 2:
type = MTRR_TYPE_WRBACK;
break;
case 3:... |
functions | __devinit uvesafb_ioremap(struct fb_info *info)
{
#ifdef CONFIG_X86
switch (mtrr) {
case 1: /* uncachable */
info->screen_base = ioremap_nocache(info->fix.smem_start, info->fix.smem_len);
break;
case 2: /* write-back */
info->screen_base = ioremap_cache(info->fix.smem_start, info->fix.smem_len);
break;
case... |
functions | ssize_t uvesafb_show_vbe_ver(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct fb_info *info = platform_get_drvdata(to_platform_device(dev));
struct uvesafb_par *par = info->par;
return snprintf(buf, PAGE_SIZE, "%.4x\n", par->vbe_ib.vbe_version);
} |
functions | ssize_t uvesafb_show_vbe_modes(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct fb_info *info = platform_get_drvdata(to_platform_device(dev));
struct uvesafb_par *par = info->par;
int ret = 0, i;
for (i = 0; i < par->vbe_modes_cnt && ret < PAGE_SIZE; i++) {
ret += snprintf(buf + ret, PAGE... |
functions | ssize_t uvesafb_show_vendor(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct fb_info *info = platform_get_drvdata(to_platform_device(dev));
struct uvesafb_par *par = info->par;
if (par->vbe_ib.oem_vendor_name_ptr)
return snprintf(buf, PAGE_SIZE, "%s\n", (char *)
(&par->vbe_ib) + par->vb... |
functions | ssize_t uvesafb_show_product_name(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct fb_info *info = platform_get_drvdata(to_platform_device(dev));
struct uvesafb_par *par = info->par;
if (par->vbe_ib.oem_product_name_ptr)
return snprintf(buf, PAGE_SIZE, "%s\n", (char *)
(&par->vbe_ib) + ... |
functions | ssize_t uvesafb_show_product_rev(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct fb_info *info = platform_get_drvdata(to_platform_device(dev));
struct uvesafb_par *par = info->par;
if (par->vbe_ib.oem_product_rev_ptr)
return snprintf(buf, PAGE_SIZE, "%s\n", (char *)
(&par->vbe_ib) + pa... |
functions | ssize_t uvesafb_show_oem_string(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct fb_info *info = platform_get_drvdata(to_platform_device(dev));
struct uvesafb_par *par = info->par;
if (par->vbe_ib.oem_string_ptr)
return snprintf(buf, PAGE_SIZE, "%s\n",
(char *)(&par->vbe_ib) + par->vbe_... |
functions | ssize_t uvesafb_show_nocrtc(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct fb_info *info = platform_get_drvdata(to_platform_device(dev));
struct uvesafb_par *par = info->par;
return snprintf(buf, PAGE_SIZE, "%d\n", par->nocrtc);
} |
functions | ssize_t uvesafb_store_nocrtc(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
struct fb_info *info = platform_get_drvdata(to_platform_device(dev));
struct uvesafb_par *par = info->par;
if (count > 0) {
if (buf[0] == '0')
par->nocrtc = 0;
else
par->nocrtc = 1;
} |
functions | __devinit uvesafb_probe(struct platform_device *dev)
{
struct fb_info *info;
struct vbe_mode_ib *mode = NULL;
struct uvesafb_par *par;
int err = 0, i;
info = framebuffer_alloc(sizeof(*par) + sizeof(u32) * 256, &dev->dev);
if (!info)
return -ENOMEM;
par = info->par;
err = uvesafb_vbe_init(info);
if (err) {... |
functions | int uvesafb_remove(struct platform_device *dev)
{
struct fb_info *info = platform_get_drvdata(dev);
if (info) {
struct uvesafb_par *par = info->par;
sysfs_remove_group(&dev->dev.kobj, &uvesafb_dev_attgrp);
unregister_framebuffer(info);
release_region(0x3c0, 32);
iounmap(info->screen_base);
release_mem_r... |
functions | __devinit uvesafb_setup(char *options)
{
char *this_opt;
if (!options || !*options)
return 0;
while ((this_opt = strsep(&options, ",")) != NULL) {
if (!*this_opt) continue;
if (!strcmp(this_opt, "redraw"))
ypan = 0;
else if (!strcmp(this_opt, "ypan"))
ypan = 1;
else if (!strcmp(this_opt, "ywrap"))... |
functions | ssize_t show_v86d(struct device_driver *dev, char *buf)
{
return snprintf(buf, PAGE_SIZE, "%s\n", v86d_path);
} |
functions | ssize_t store_v86d(struct device_driver *dev, const char *buf,
size_t count)
{
strncpy(v86d_path, buf, PATH_MAX);
return count;
} |
functions | __devinit uvesafb_init(void)
{
int err;
#ifndef MODULE
char *option = NULL;
if (fb_get_options("uvesafb", &option))
return -ENODEV;
uvesafb_setup(option);
#endif
err = cn_add_callback(&uvesafb_cn_id, "uvesafb", uvesafb_cn_callback);
if (err)
return err;
err = platform_driver_register(&uvesafb_driver);
i... |
functions | __devexit uvesafb_exit(void)
{
struct uvesafb_ktask *task;
if (v86d_started) {
task = uvesafb_prep();
if (task) {
task->t.flags = TF_EXIT;
uvesafb_exec(task);
uvesafb_free(task);
} |
functions | int param_set_scroll(const char *val, const struct kernel_param *kp)
{
ypan = 0;
if (!strcmp(val, "redraw"))
ypan = 0;
else if (!strcmp(val, "ypan"))
ypan = 1;
else if (!strcmp(val, "ywrap"))
ypan = 2;
else
return -EINVAL;
return 0;
} |
includes |
#include <common.h> |
includes | #include <pci.h> |
includes | #include <mpc83xx.h> |
includes | #include <asm/io.h> |
defines |
#define PCIE_MAX_BUSES 2 |
defines |
#define cfg_read(val, addr, type, op) \ |
defines | #define cfg_write(val, addr, type, op) \ |
defines |
#define cfg_read_err(val) do { *val = -1; } while (0) |
defines | #define cfg_write_err(val) do { } while (0) |
defines |
#define PCIE_OP(rw, size, type, op) \ |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.