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);
}
