int Csp1ConfigDevice(void) { void * n1_ssl_config_device(void); void * (*func)(void); func = symbol_get(n1_ssl_config_device); if (!func) { printk(KERN_CRIT "n1_ssl_config_device: symbol_get failed\n"); return -1; } n1_list = (struct N1_Dev *)(*func)(); if (n1_list == NULL) { printk(KERN_CRIT "No Cavium devices detected in the system\n"); symbol_put(n1_ssl_config_device); return -1; } module_count++; if (module_count == 1) { if (p_alloc_context == NULL) { p_alloc_context = symbol_get(n1_ssl_alloc_context); } if (p_dealloc_context == NULL) { p_dealloc_context = symbol_get(n1_ssl_dealloc_context); } if (p_KernAes == NULL) { p_KernAes = symbol_get(n1_KernAes); } } symbol_put(n1_ssl_config_device); return 0; }
static void mali_counter_initialize(void) { /* If a Mali driver is present and exporting the appropriate symbol * then we can request the HW counters (of which there are only 2) * be configured to count the desired events */ void (*set_hw_event)(unsigned int, unsigned int); void (*set_fb_event)(unsigned int, unsigned int); set_hw_event = symbol_get(_mali_profiling_set_event); if (set_hw_event) { int i; pr_debug("gator: mali online _mali_profiling_set_event symbol @ %p\n",set_hw_event); for (i = FIRST_HW_COUNTER; i <= LAST_HW_COUNTER; i++) { if (counter_enabled[i]) { set_hw_event(i, counter_event[i]); } else { set_hw_event(i, 0xFFFFFFFF); } } symbol_put(_mali_profiling_set_event); } else { printk("gator: mali online _mali_profiling_set_event symbol not found\n"); } set_fb_event = symbol_get(_mali_osk_fb_control_set); if (set_fb_event) { pr_debug("gator: mali online _mali_osk_fb_control_set symbol @ %p\n", set_fb_event); set_fb_event(0,(counter_enabled[COUNTER_FILMSTRIP]?1:0)); symbol_put(_mali_osk_fb_control_set); } else { printk("gator: mali online _mali_osk_fb_control_set symbol not found\n"); } _mali_profiling_get_counters_function_pointer = symbol_get(_mali_profiling_get_counters); if (_mali_profiling_get_counters_function_pointer){ pr_debug("gator: mali online _mali_profiling_get_counters symbol @ %p\n", _mali_profiling_get_counters_function_pointer); counter_prev[COUNTER_L2_C0] = 0; counter_prev[COUNTER_L2_C1] = 0; } else{ pr_debug("gator WARNING: mali _mali_profiling_get_counters symbol not defined"); } }
int hda_i915_exit(void) { if (get_power) { symbol_put(i915_request_power_well); get_power = NULL; } if (put_power) { symbol_put(i915_release_power_well); put_power = NULL; } return 0; }
void kfd_close_peer_direct(void) { if (pfn_ib_unregister_peer_memory_client) { if (ib_reg_handle) pfn_ib_unregister_peer_memory_client(ib_reg_handle); symbol_put(ib_unregister_peer_memory_client); } if (pfn_ib_register_peer_memory_client) symbol_put(ib_register_peer_memory_client); }
static int corgibl_send_intensity(struct backlight_device *bd) { void (*corgi_kick_batt)(void); int intensity = bd->props.brightness; if (bd->props.power != FB_BLANK_UNBLANK) intensity = 0; if (bd->props.fb_blank != FB_BLANK_UNBLANK) intensity = 0; if (corgibl_flags & CORGIBL_SUSPENDED) intensity = 0; if (corgibl_flags & CORGIBL_BATTLOW) intensity &= bl_machinfo->limit_mask; bl_machinfo->set_bl_intensity(intensity); corgibl_intensity = intensity; corgi_kick_batt = symbol_get(sharpsl_battery_kick); if (corgi_kick_batt) { corgi_kick_batt(); symbol_put(sharpsl_battery_kick); } return 0; }
void amdgpu_amdkfd_fini(void) { if (kgd2kfd) { kgd2kfd->exit(); symbol_put(kgd2kfd_init); } }
int amdgpu_amdkfd_init(void) { int ret; #if defined(CONFIG_HSA_AMD_MODULE) int (*kgd2kfd_init_p)(unsigned, const struct kgd2kfd_calls**); kgd2kfd_init_p = symbol_request(kgd2kfd_init); if (kgd2kfd_init_p == NULL) return -ENOENT; ret = kgd2kfd_init_p(KFD_INTERFACE_VERSION, &kgd2kfd); if (ret) { symbol_put(kgd2kfd_init); kgd2kfd = NULL; } #elif defined(CONFIG_HSA_AMD) ret = kgd2kfd_init(KFD_INTERFACE_VERSION, &kgd2kfd); if (ret) kgd2kfd = NULL; #else ret = -ENOENT; #endif return ret; }
int dcl_sym_assign(char *sym,char *oper) { int symlvl; char work[1024]; char *ch = dcl_line; NEXT_LINE(); if (cmd[C].subr) return(0); if (!dcl[D].cc[dcl[D].ccl]) return(0); if (sym == NULL || oper == NULL) return(DCL_ERROR); *work = 0; if (strcmp(oper,"==")==0 || strcmp(oper,":==")==0) symlvl = 0; else symlvl = D; while (*ch && *ch != '=') ch++; while (*ch && *ch != ' ') ch++; if (*ch) { (void) EXP_compute(ch,work); if (*work) (void) symbol_put(sym,work,symlvl); else symbol_del_lvl(sym, symlvl); } return(0); }
static void alc_fixup_dell_wmi(struct hda_codec *codec, const struct hda_fixup *fix, int action) { struct alc_spec *spec = codec->spec; bool removefunc = false; if (action == HDA_FIXUP_ACT_PROBE) { if (!dell_led_set_func) dell_led_set_func = symbol_request(dell_app_wmi_led_set); if (!dell_led_set_func) { codec_warn(codec, "Failed to find dell wmi symbol dell_app_wmi_led_set\n"); return; } removefunc = true; if (dell_led_set_func(DELL_LED_MICMUTE, false) >= 0) { dell_led_value = 0; if (spec->gen.num_adc_nids > 1) codec_dbg(codec, "Skipping micmute LED control due to several ADCs"); else { dell_old_cap_hook = spec->gen.cap_sync_hook; spec->gen.cap_sync_hook = update_dell_wmi_micmute_led; removefunc = false; } } } if (dell_led_set_func && (action == HDA_FIXUP_ACT_FREE || removefunc)) { symbol_put(dell_app_wmi_led_set); dell_led_set_func = NULL; dell_old_cap_hook = NULL; } }
int hda_i915_init(bool is_broadwell) { int err = 0; if (is_broadwell) get_power = symbol_request(i915_bdw_request_power_well); else get_power = symbol_request(i915_request_power_well); if (!get_power) { snd_printk(KERN_WARNING "hda-i915: get_power symbol get fail\n"); return -ENODEV; } if (is_broadwell) put_power = symbol_request(i915_bdw_release_power_well); else put_power = symbol_request(i915_release_power_well); if (!put_power) { symbol_put(i915_request_power_well); get_power = NULL; return -ENODEV; } snd_printd("HDA driver get symbol successfully from i915 module\n"); return err; }
int hda_i915_init(void) { int err = 0; get_power = symbol_request(i915_request_power_well); if (!get_power) { pr_warn("hda-i915: get_power symbol get fail\n"); return -ENODEV; } put_power = symbol_request(i915_release_power_well); if (!put_power) { symbol_put(i915_request_power_well); get_power = NULL; return -ENODEV; } get_cdclk = symbol_request(i915_get_cdclk_freq); if (!get_cdclk) /* may have abnormal BCLK and audio playback rate */ pr_warn("hda-i915: get_cdclk symbol get fail\n"); pr_debug("HDA driver get symbol successfully from i915 module\n"); return err; }
/** * @brief Unregister LLF */ void llf_exit(void) { if(enableLLF >= 1){ if( unregister_llf_cb_function ){ printk("unregister_llf_cb_function( )...\n"); unregister_llf_cb_function( ); } if( register_llf_cb_function ) { printk("symbol_put( register_llf_cb )...\n"); symbol_put( register_llf_cb ); } if( unregister_llf_cb_function ) { printk("symbol_put( unregister_llf_cb )...\n"); symbol_put( unregister_llf_cb ); } } }
static irqreturn_t db1100_mmc_cd(int irq, void *ptr) { void (*mmc_cd)(struct mmc_host *, unsigned long); /* link against CONFIG_MMC=m */ mmc_cd = symbol_get(mmc_detect_change); mmc_cd(ptr, msecs_to_jiffies(500)); symbol_put(mmc_detect_change); return IRQ_HANDLED; }
static void corgi_bl_kick_battery(void) { void (*kick_batt)(void); kick_batt = symbol_get(sharpsl_battery_kick); if (kick_batt) { kick_batt(); symbol_put(sharpsl_battery_kick); } }
void savagefb_delete_i2c_busses(struct fb_info *info) { struct savagefb_par *par = (struct savagefb_par *)info->par; int (*del_bus)(struct i2c_adapter *) = symbol_get(i2c_bit_del_bus); if (del_bus && par->chan.par) { del_bus(&par->chan.adapter); symbol_put(i2c_bit_del_bus); } par->chan.par = NULL; }
static void mali_counter_deinitialize(void) { void (*set_hw_event)(unsigned int, unsigned int); void (*set_fb_event)(unsigned int, unsigned int); set_hw_event = symbol_get(_mali_profiling_set_event); if (set_hw_event) { int i; pr_debug("gator: mali offline _mali_profiling_set_event symbol @ %p\n",set_hw_event); for (i = FIRST_HW_COUNTER; i <= LAST_HW_COUNTER; i++) { set_hw_event(i, 0xFFFFFFFF); } symbol_put(_mali_profiling_set_event); } else { printk("gator: mali offline _mali_profiling_set_event symbol not found\n"); } set_fb_event = symbol_get(_mali_osk_fb_control_set); if (set_fb_event) { pr_debug("gator: mali offline _mali_osk_fb_control_set symbol @ %p\n", set_fb_event); set_fb_event(0,0); symbol_put(_mali_osk_fb_control_set); } else { printk("gator: mali offline _mali_osk_fb_control_set symbol not found\n"); } if (_mali_profiling_get_counters_function_pointer){ symbol_put(_mali_profiling_get_counters); } }
void Csp1UnconfigDevice(void) { void * n1_ssl_unconfig_device(void *,u64); void * (*func)(void *, u64); Csp1FreeContext(); func = symbol_get(n1_ssl_unconfig_device); if (!func) { printk(KERN_CRIT "Csp1UnConfigDevice: symbol_get failed\n"); return; } (*func)(n1_list->data, 0); symbol_put(n1_ssl_unconfig_device); module_count--; if(module_count == 0) { n1_list = NULL; if (p_alloc_context) { symbol_put(n1_ssl_alloc_context); p_alloc_context = NULL; } if (p_dealloc_context) { symbol_put(n1_ssl_dealloc_context); p_dealloc_context = NULL; } if (p_KernAes) { symbol_put(n1_KernAes); p_KernAes = NULL; } } }
static int start(void) { unsigned int cnt; mali_profiling_control_type *mali_control; previous_shader_bitmask = 0; previous_tiler_bitmask = 0; previous_l2_bitmask = 0; /* Clean all data for the next capture */ for (cnt = 0; cnt < NUMBER_OF_TIMELINE_EVENTS; cnt++) { timeline_event_starttime[cnt].tv_sec = timeline_event_starttime[cnt].tv_nsec = 0; timeline_data[cnt] = 0; } for (cnt = 0; cnt < NUMBER_OF_SOFTWARE_COUNTERS; cnt++) sw_counter_data[cnt] = 0; for (cnt = 0; cnt < NUMBER_OF_ACCUMULATORS; cnt++) accumulators_data[cnt] = 0; /* Register tracepoints */ if (register_tracepoints() == 0) return -1; /* Generic control interface for Mali DDK. */ mali_control = symbol_get(_mali_profiling_control); if (mali_control) { /* The event attribute in the XML file keeps the actual frame rate. */ unsigned int enabled = counters[FILMSTRIP].enabled ? 1 : 0; unsigned int rate = filmstrip_event & 0xff; unsigned int resize_factor = (filmstrip_event >> 8) & 0xff; pr_debug("gator: mali online _mali_profiling_control symbol @ %p\n", mali_control); #define FBDUMP_CONTROL_ENABLE (1) #define FBDUMP_CONTROL_RATE (2) #define FBDUMP_CONTROL_RESIZE_FACTOR (4) mali_control(FBDUMP_CONTROL_ENABLE, enabled); mali_control(FBDUMP_CONTROL_RATE, rate); mali_control(FBDUMP_CONTROL_RESIZE_FACTOR, resize_factor); pr_debug("gator: sent mali_control enabled=%d, rate=%d, resize_factor=%d\n", enabled, rate, resize_factor); symbol_put(_mali_profiling_control); } else {
static irqreturn_t db1300_mmc_cd(int irq, void *ptr) { void(*mmc_cd)(struct mmc_host *, unsigned long); if (irq == DB1300_SD1_INSERT_INT) { disable_irq_nosync(DB1300_SD1_INSERT_INT); enable_irq(DB1300_SD1_EJECT_INT); } else { disable_irq_nosync(DB1300_SD1_EJECT_INT); enable_irq(DB1300_SD1_INSERT_INT); } mmc_cd = symbol_get(mmc_detect_change); mmc_cd(ptr, msecs_to_jiffies(500)); symbol_put(mmc_detect_change); return IRQ_HANDLED; }
static int create_files(struct super_block *sb, struct dentry *root) { int event; /* * Create the filesystem for all events */ int counter_index = 0; const char *mali_name = gator_mali_get_mali_name(); mali_profiling_control_type *mali_control; for (event = FIRST_TIMELINE_EVENT; event < FIRST_TIMELINE_EVENT + NUMBER_OF_TIMELINE_EVENTS; event++) { if (gator_mali_create_file_system(mali_name, timeline_event_names[counter_index], sb, root, &counters[event], NULL) != 0) { return -1; } counter_index++; } counter_index = 0; for (event = FIRST_SOFTWARE_COUNTER; event < FIRST_SOFTWARE_COUNTER + NUMBER_OF_SOFTWARE_COUNTERS; event++) { if (gator_mali_create_file_system(mali_name, software_counter_names[counter_index], sb, root, &counters[event], NULL) != 0) { return -1; } counter_index++; } counter_index = 0; for (event = FIRST_ACCUMULATOR; event < FIRST_ACCUMULATOR + NUMBER_OF_ACCUMULATORS; event++) { if (gator_mali_create_file_system(mali_name, accumulators_names[counter_index], sb, root, &counters[event], NULL) != 0) { return -1; } counter_index++; } mali_control = symbol_get(_mali_profiling_control); if (mali_control) { if (gator_mali_create_file_system(mali_name, "Filmstrip_cnt0", sb, root, &counters[FILMSTRIP], &filmstrip_event) != 0) { return -1; } symbol_put(_mali_profiling_control); } return 0; }
/* SD carddetects: they're supposed to be edge-triggered, but ack * doesn't seem to work (CPLD Rev 2). Instead, the screaming one * is disabled and its counterpart enabled. The 500ms timeout is * because the carddetect isn't debounced in hardware. */ static irqreturn_t db1200_mmc_cd(int irq, void *ptr) { void(*mmc_cd)(struct mmc_host *, unsigned long); if (irq == DB1200_SD0_INSERT_INT) { disable_irq_nosync(DB1200_SD0_INSERT_INT); enable_irq(DB1200_SD0_EJECT_INT); } else { disable_irq_nosync(DB1200_SD0_EJECT_INT); enable_irq(DB1200_SD0_INSERT_INT); } /* link against CONFIG_MMC=m */ mmc_cd = symbol_get(mmc_detect_change); if (mmc_cd) { mmc_cd(ptr, msecs_to_jiffies(500)); symbol_put(mmc_detect_change); } return IRQ_HANDLED; }
static int savage_setup_i2c_bus(struct savagefb_i2c_chan *chan, const char *name) { int (*add_bus)(struct i2c_adapter *) = symbol_get(i2c_bit_add_bus); int rc = 0; if (add_bus && chan->par) { strcpy(chan->adapter.name, name); chan->adapter.owner = THIS_MODULE; chan->adapter.id = I2C_HW_B_SAVAGE; chan->adapter.algo_data = &chan->algo; chan->adapter.dev.parent = &chan->par->pcidev->dev; chan->algo.udelay = 40; chan->algo.mdelay = 5; chan->algo.timeout = 20; chan->algo.data = chan; i2c_set_adapdata(&chan->adapter, chan); /* Raise SCL and SDA */ chan->algo.setsda(chan, 1); chan->algo.setscl(chan, 1); udelay(20); rc = add_bus(&chan->adapter); if (rc == 0) dev_dbg(&chan->par->pcidev->dev, "I2C bus %s registered.\n", name); else dev_warn(&chan->par->pcidev->dev, "Failed to register I2C bus %s.\n", name); symbol_put(i2c_bit_add_bus); } else chan->par = NULL; return rc; }
static irqreturn_t db1300_mmc_cd(int irq, void *ptr) { void(*mmc_cd)(struct mmc_host *, unsigned long); /* disable the one currently screaming. No other way to shut it up */ if (irq == DB1300_SD1_INSERT_INT) { disable_irq_nosync(DB1300_SD1_INSERT_INT); enable_irq(DB1300_SD1_EJECT_INT); } else { disable_irq_nosync(DB1300_SD1_EJECT_INT); enable_irq(DB1300_SD1_INSERT_INT); } /* link against CONFIG_MMC=m. We can only be called once MMC core has * initialized the controller, so symbol_get() should always succeed. */ mmc_cd = symbol_get(mmc_detect_change); mmc_cd(ptr, msecs_to_jiffies(500)); symbol_put(mmc_detect_change); return IRQ_HANDLED; }
static int libcfs_ioctl_int(struct cfs_psdev_file *pfile,unsigned long cmd, void *arg, struct libcfs_ioctl_data *data) { int err = -EINVAL; ENTRY; switch (cmd) { case IOC_LIBCFS_CLEAR_DEBUG: libcfs_debug_clear_buffer(); RETURN(0); /* * case IOC_LIBCFS_PANIC: * Handled in arch/cfs_module.c */ case IOC_LIBCFS_MARK_DEBUG: if (data->ioc_inlbuf1 == NULL || data->ioc_inlbuf1[data->ioc_inllen1 - 1] != '\0') RETURN(-EINVAL); libcfs_debug_mark_buffer(data->ioc_inlbuf1); RETURN(0); #if LWT_SUPPORT case IOC_LIBCFS_LWT_CONTROL: err = lwt_control ((data->ioc_flags & 1) != 0, (data->ioc_flags & 2) != 0); break; case IOC_LIBCFS_LWT_SNAPSHOT: { cfs_cycles_t now; int ncpu; int total_size; err = lwt_snapshot (&now, &ncpu, &total_size, data->ioc_pbuf1, data->ioc_plen1); data->ioc_u64[0] = now; data->ioc_u32[0] = ncpu; data->ioc_u32[1] = total_size; /* Hedge against broken user/kernel typedefs (e.g. cycles_t) */ data->ioc_u32[2] = sizeof(lwt_event_t); data->ioc_u32[3] = offsetof(lwt_event_t, lwte_where); if (err == 0 && libcfs_ioctl_popdata(arg, data, sizeof (*data))) err = -EFAULT; break; } case IOC_LIBCFS_LWT_LOOKUP_STRING: err = lwt_lookup_string (&data->ioc_count, data->ioc_pbuf1, data->ioc_pbuf2, data->ioc_plen2); if (err == 0 && libcfs_ioctl_popdata(arg, data, sizeof (*data))) err = -EFAULT; break; #endif case IOC_LIBCFS_MEMHOG: if (pfile->private_data == NULL) { err = -EINVAL; } else { kportal_memhog_free(pfile->private_data); /* XXX The ioc_flags is not GFP flags now, need to be fixed */ err = kportal_memhog_alloc(pfile->private_data, data->ioc_count, data->ioc_flags); if (err != 0) kportal_memhog_free(pfile->private_data); } break; case IOC_LIBCFS_PING_TEST: { extern void (kping_client)(struct libcfs_ioctl_data *); void (*ping)(struct libcfs_ioctl_data *); CDEBUG(D_IOCTL, "doing %d pings to nid %s (%s)\n", data->ioc_count, libcfs_nid2str(data->ioc_nid), libcfs_nid2str(data->ioc_nid)); ping = symbol_get(kping_client); if (!ping) { CERROR("symbol_get failed\n"); } else { ping(data); symbol_put(kping_client); } RETURN(0); } default: { struct libcfs_ioctl_handler *hand; err = -EINVAL; down_read(&ioctl_list_sem); cfs_list_for_each_entry_typed(hand, &ioctl_list, struct libcfs_ioctl_handler, item) { err = hand->handle_ioctl(cmd, data); if (err != -EINVAL) { if (err == 0) err = libcfs_ioctl_popdata(arg, data, sizeof (*data)); break; } } up_read(&ioctl_list_sem); break; } } RETURN(err); }
int dcl_string_assign(char *sym,char *oper) { int symlvl; char work[1024]; char *ch = dcl_line; char *w1; int quoting = 0; int sp = 0; NEXT_LINE(); if (cmd[C].subr) return(0); if (!dcl[D].cc[dcl[D].ccl]) return(0); if (sym == NULL || oper == NULL) return(DCL_ERROR); *work = 0; w1 = work; if (strncmp(oper,"==",2)==0 || strncmp(oper,":==",2)==0) symlvl = 0; else symlvl = D; while (*ch && *ch != '=') ch++; while (*ch && *ch == '=') ch++; //while (*ch && *ch != ' ' && *ch != '\t') ch++; while (*ch && (*ch == ' ' || *ch == '\t')) ch++; sp = (int)strlen(ch) - 1; while (sp && (ch[sp] == ' ' || ch[sp] == '\t')) ch[sp--] = 0; while (*ch) { switch (*ch){ case '"' : if (quoting) { if (*(ch+1)== '"') *w1++ = *ch; quoting = 0; } else { quoting = 1; } sp = 0; break; case '\t': if (quoting) { *w1++ = *ch; sp = 0; break; } else *ch = ' '; /*lint -fallthrough */ case ' ' : if (quoting) { *w1++ = *ch; sp = 0; break; } else { sp++; if (sp == 1) *w1++ = *ch; break; } default : sp = 0; if (quoting) *w1++ = *ch; else *w1++ = (char) toupper(*ch); break; } *w1 = 0; ch++; } (void) symbol_put(sym,work,symlvl); return(0); }
void au_loopback_fin(void) { if (backing_file_func) symbol_put(loop_backing_file); kfree(au_warn_loopback_array); }
/* * out_sz (out) size of data put into it by process_kex_msg * (in) space available in out_buf */ int process_kex_msg(struct priv_crypt_ctx *cctx, size_t *out_sz, u8 *out_buf, size_t in_sz, u8 *in_buf) { int rc = -1, i; u8 msg_type; u8 key_buf[MAX_KEY_LEN]; struct dhm_kex *kex; const struct dhm_kex_ops *kex_ops; #ifdef KEX_DEBUG const size_t debug_msg_sz = 256; #endif if (in_sz < sizeof(u8)) { printk(KERN_ERR "kex_msg too short\n"); rc = -1; goto out; } msg_type = in_buf[0]; DPRINTF("%s: msg type %u\n", __func__, (unsigned int)msg_type); switch (msg_type) { case PRIV_CRYPT_KEX_PARAMS: kex_ops = symbol_request(cm_dhm_kex_ops); if (kex_ops == NULL) { printk(KERN_ERR "cannot load kex operations\n"); goto put; } if ((rc = kex_ops->init(&kex)) < 0) goto put; *out_sz -= 1; if ((rc = kex_ops->respond(kex, out_sz, out_buf+1, in_sz-1, in_buf+1)) < 0) goto destroy; *out_sz += 1; if ((rc = kex_ops->get_key(kex, cctx->key_size, key_buf)) < 0) goto destroy; if ((rc = priv_set_key(cctx, cctx->key_size, key_buf)) < 0) goto destroy; destroy: kex_ops->destroy(kex); out_buf[0] = PRIV_CRYPT_KEX_RESPONSE; put: symbol_put(cm_dhm_kex_ops); if (rc < 0) goto out; break; #ifdef KEX_DEBUG case PRIV_CRYPT_KEX_DEBUG: DPRINTF("message:\n"); DPRINT_HEX(in_sz - sizeof(u8), in_buf + sizeof(u8)); /* debug response message */ out_buf[0] = PRIV_CRYPT_KEX_DEBUG; for (i = sizeof(u8); i < sizeof(u8) + debug_msg_sz; i++) { out_buf[i] = (u8)(i - 1); } *out_sz = sizeof(u8) + debug_msg_sz; break; #endif default: printk(KERN_ERR "%s: unknown msg type %u\n", __func__, msg_type); goto out; break; } rc = 0; out: memset(key_buf, 0, sizeof(key_buf)); return rc; }
static void __init DoC_Probe(unsigned long physadr) { void __iomem *docptr; struct DiskOnChip *this; struct mtd_info *mtd; int ChipID; char namebuf[15]; char *name = namebuf; char *im_funcname = NULL; char *im_modname = NULL; void (*initroutine)(struct mtd_info *) = NULL; docptr = ioremap(physadr, DOC_IOREMAP_LEN); if (!docptr) return; if ((ChipID = doccheck(docptr, physadr))) { if (ChipID == DOC_ChipID_Doc2kTSOP) { /* Remove this at your own peril. The hardware driver works but nothing prevents you from erasing bad blocks */ printk(KERN_NOTICE "Refusing to drive DiskOnChip 2000 TSOP until Bad Block Table is correctly supported by INFTL\n"); iounmap(docptr); return; } docfound = 1; mtd = kmalloc(sizeof(struct DiskOnChip) + sizeof(struct mtd_info), GFP_KERNEL); if (!mtd) { printk(KERN_WARNING "Cannot allocate memory for data structures. Dropping.\n"); iounmap(docptr); return; } this = (struct DiskOnChip *)(&mtd[1]); memset((char *)mtd,0, sizeof(struct mtd_info)); memset((char *)this, 0, sizeof(struct DiskOnChip)); mtd->priv = this; this->virtadr = docptr; this->physadr = physadr; this->ChipID = ChipID; sprintf(namebuf, "with ChipID %2.2X", ChipID); switch(ChipID) { case DOC_ChipID_Doc2kTSOP: name="2000 TSOP"; im_funcname = "DoC2k_init"; im_modname = "doc2000"; break; case DOC_ChipID_Doc2k: name="2000"; im_funcname = "DoC2k_init"; im_modname = "doc2000"; break; case DOC_ChipID_DocMil: name="Millennium"; #ifdef DOC_SINGLE_DRIVER im_funcname = "DoC2k_init"; im_modname = "doc2000"; #else im_funcname = "DoCMil_init"; im_modname = "doc2001"; #endif /* DOC_SINGLE_DRIVER */ break; case DOC_ChipID_DocMilPlus16: case DOC_ChipID_DocMilPlus32: name="MillenniumPlus"; im_funcname = "DoCMilPlus_init"; im_modname = "doc2001plus"; break; } if (im_funcname) { if (!request_module("%s", im_modname)) goto fail; initroutine = __symbol_get(im_funcname); } if (initroutine) { (*initroutine)(mtd); symbol_put(im_funcname); return; } fail: printk(KERN_NOTICE "Cannot find driver for DiskOnChip %s at 0x%lX\n", name, physadr); kfree(mtd); } iounmap(docptr); }