예제 #1
0
static int lenovo_sl_procfs_init(void)
{
	struct proc_dir_entry *proc_ec;

	proc_dir = proc_mkdir(LENSL_PROC_DIRNAME, acpi_root_dir);
	if (!proc_dir) {
		vdbg_printk(LENSL_ERR,
		   "Failed to create proc dir acpi/%s/\n", LENSL_PROC_DIRNAME);
		return -ENOENT;
	}
#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,29)
	proc_dir->owner = THIS_MODULE;
#endif

#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25)
	proc_ec = create_proc_entry(LENSL_PROC_EC, 0600, proc_dir);
#else
	proc_ec = proc_create(LENSL_PROC_EC, 0600, proc_dir, &proc_fops);
#endif
	if (!proc_ec) {
		vdbg_printk(LENSL_ERR,
			"Failed to create proc entry acpi/%s/%s\n",
			LENSL_PROC_DIRNAME, LENSL_PROC_EC);
		return -ENOENT;
	}
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25)
	proc_ec->proc_fops = &proc_fops;
#endif
	vdbg_printk(LENSL_DEBUG, "Initialized procfs debugging interface\n");

	return 0;
}
예제 #2
0
static int lensl_radio_new_rfkill(struct lensl_radio *radio,
			struct rfkill **rfk, bool sw_blocked,
			bool hw_blocked)
{
	int res;		
		
	*rfk = rfkill_alloc(radio->rfkname, &lensl_pdev->dev, radio->rfktype,
			&rfkops, radio);
	if (!*rfk) {
		vdbg_printk(LENSL_ERR,
			"Failed to allocate memory for rfkill class\n");
		return -ENOMEM;
	}

	rfkill_set_hw_state(*rfk, hw_blocked);
	rfkill_set_sw_state(*rfk, sw_blocked);

	res = rfkill_register(*rfk);
	if (res < 0) {
		vdbg_printk(LENSL_ERR,
			"Failed to register %s rfkill switch: %d\n",
			radio->rfkname, res);
		rfkill_destroy(*rfk);
		*rfk = NULL;
		return res;
	}

	return 0;
}
예제 #3
0
static int hkey_inputdev_init(void)
{
	int result;
	struct key_entry *key;

	hkey_inputdev = input_allocate_device();
	if (!hkey_inputdev) {
		vdbg_printk(LENSL_ERR,
			"Failed to allocate hotkey input device\n");
		return -ENODEV;
	}
	hkey_inputdev->name = "Lenovo ThinkPad SL Series extra buttons";
	hkey_inputdev->phys = LENSL_HKEY_FILE "/input0";
	hkey_inputdev->uniq = LENSL_HKEY_FILE;
	hkey_inputdev->id.bustype = BUS_HOST;
	hkey_inputdev->id.vendor = PCI_VENDOR_ID_LENOVO;
	hkey_inputdev->getkeycode = hkey_inputdev_getkeycode;
	hkey_inputdev->setkeycode = hkey_inputdev_setkeycode;
	set_bit(EV_KEY, hkey_inputdev->evbit);

	for (key = ec_keymap; key->type != KE_END; key++)
		set_bit(key->keycode, hkey_inputdev->keybit);

	result = input_register_device(hkey_inputdev);
	if (result) {
		vdbg_printk(LENSL_ERR,
			"Failed to register hotkey input device\n");
		input_free_device(hkey_inputdev);
		hkey_inputdev = NULL;
		return -ENODEV;
	}
	vdbg_printk(LENSL_DEBUG, "Initialized hotkey subdriver\n");
	return 0;
}
예제 #4
0
static int hwmon_init(void)
{
	int res;

	pwm1_value = -1;
#if LINUX_VERSION_CODE >= KERNEL_VERSION(4,9,0)
	lensl_hwmon_device = hwmon_device_register_with_info(&lensl_pdev->dev, "lenovo_sl_laptop", NULL, NULL, NULL);
#else
	lensl_hwmon_device = hwmon_device_register(&lensl_pdev->dev);
#endif
	if (!lensl_hwmon_device) {
		vdbg_printk(LENSL_ERR, "Failed to register hwmon device\n");
		return -ENODEV;
	}

	res = sysfs_create_group(&lensl_hwmon_device->kobj,
				 &hwmon_attr_group);
	if (res < 0) {
		vdbg_printk(LENSL_ERR, "Failed to create hwmon sysfs group\n");
		hwmon_device_unregister(lensl_hwmon_device);
		lensl_hwmon_device = NULL;
		return -ENODEV;
	}
	vdbg_printk(LENSL_DEBUG, "Initialized hwmon subdriver\n");
	return 0;
}
예제 #5
0
static int __init lenovo_sl_laptop_init(void)
{
	int ret;
	acpi_status status;

	hkey_handle = ec0_handle = NULL;

	if (acpi_disabled)
		return -ENODEV;

	lensl_wq = create_singlethread_workqueue(LENSL_WORKQUEUE_NAME);
	if (!lensl_wq) {
		vdbg_printk(LENSL_ERR, "Failed to create a workqueue\n");
		return -ENOMEM;
	}

	status = acpi_get_handle(NULL, LENSL_HKEY, &hkey_handle);
	if (ACPI_FAILURE(status)) {
		vdbg_printk(LENSL_ERR,
			"Failed to get ACPI handle for %s\n", LENSL_HKEY);
		return -ENODEV;
	}
	status = acpi_get_handle(NULL, LENSL_EC0, &ec0_handle);
	if (ACPI_FAILURE(status)) {
		vdbg_printk(LENSL_ERR,
			"Failed to get ACPI handle for %s\n", LENSL_EC0);
		return -ENODEV;
	}

	lensl_pdev = platform_device_register_simple(LENSL_DRVR_NAME, -1,
							NULL, 0);
	if (IS_ERR(lensl_pdev)) {
		ret = PTR_ERR(lensl_pdev);
		lensl_pdev = NULL;
		vdbg_printk(LENSL_ERR, "Failed to register platform device\n");
		return ret;
	}

	ret = hkey_inputdev_init();
	if (ret)
		return -ENODEV;

	radio_init(LENSL_BLUETOOTH);
	radio_init(LENSL_WWAN);
	radio_init(LENSL_UWB);

	led_init();
	mutex_init(&hkey_poll_mutex);
	hwmon_init();

	if (debug_ec)
		lenovo_sl_procfs_init();

	vdbg_printk(LENSL_INFO, "Loaded Lenovo ThinkPad SL Series driver\n");
	return 0;
}
예제 #6
0
static int get_bcl(struct lensl_vector *levels)
{
	int i, status;
	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
	union acpi_object *o, *obj;

	if (!levels)
		return -EINVAL;
	if (levels->count) {
		levels->count = 0;
		kfree(levels->values);
	}

	/* _BCL returns an array sorted from high to low; the first two values
	   are *not* special (non-standard behavior) */
	status = acpi_evaluate_object(lcdd_handle, "_BCL", NULL, &buffer);
	if (!ACPI_SUCCESS(status))
		return status;
	obj = (union acpi_object *)buffer.pointer;
	if (!obj || (obj->type != ACPI_TYPE_PACKAGE)) {
		vdbg_printk(LENSL_ERR, "Invalid _BCL data\n");
		status = -EFAULT;
		goto out;
	}

	levels->count = obj->package.count;
	if (!levels->count)
		goto out;
	levels->values = kmalloc(levels->count * sizeof(int), GFP_KERNEL);
	if (!levels->values) {
		vdbg_printk(LENSL_ERR,
			"Failed to allocate memory for brightness levels\n");
		status = -ENOMEM;
		goto out;
	}

	for (i = 0; i < obj->package.count; i++) {
		o = (union acpi_object *)&obj->package.elements[i];
		if (o->type != ACPI_TYPE_INTEGER) {
			vdbg_printk(LENSL_ERR, "Invalid brightness data\n");
			goto err;
		}
		levels->values[i] = (int) o->integer.value;
	}
	goto out;

err:
	levels->count = 0;
	kfree(levels->values);

out:
	kfree(buffer.pointer);

	return status;
}
예제 #7
0
static int led_init(void)
{
	int res;

	memset(&led_tv, 0, sizeof(led_tv));
	led_tv.cdev.brightness_get = led_tv_brightness_get_sysfs;
	led_tv.cdev.brightness_set = led_tv_brightness_set_sysfs;
	led_tv.cdev.blink_set = led_tv_blink_set_sysfs;
	led_tv.cdev.name = LENSL_LED_TV_NAME;
	INIT_WORK(&led_tv.work, led_tv_worker);
	set_tvls(LENSL_LED_TV_OFF);
	res = led_classdev_register(&lensl_pdev->dev, &led_tv.cdev);
	if (res) {
		vdbg_printk(LENSL_WARNING, "Failed to register LED device\n");
		return res;
	}
	led_tv.supported = 1;
	vdbg_printk(LENSL_DEBUG, "Initialized LED subdriver\n");
	return 0;
}
예제 #8
0
static int backlight_init(void)
{
	int status = 0;

	lcdd_handle = NULL;
	backlight = NULL;
	backlight_levels.count = 0;
	backlight_levels.values = NULL;

	status = acpi_get_handle(NULL, LENSL_LCDD, &lcdd_handle);
	if (ACPI_FAILURE(status)) {
		vdbg_printk(LENSL_ERR,
			"Failed to get ACPI handle for %s\n", LENSL_LCDD);
		return -EIO;
	}

	status = get_bcl(&backlight_levels);
	if (status || !backlight_levels.count)
		goto err;

#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,34)
	backlight = backlight_device_register(LENSL_BACKLIGHT_NAME,
			NULL, NULL, &lensl_backlight_ops, NULL);
#else
	backlight = backlight_device_register(LENSL_BACKLIGHT_NAME,
			NULL, NULL, &lensl_backlight_ops);
#endif
	backlight->props.max_brightness = backlight_levels.count - 1;
	backlight->props.brightness = lensl_bd_get_brightness(backlight);
	vdbg_printk(LENSL_INFO, "Started backlight brightness control\n");
	goto out;
err:
	if (backlight_levels.count) {
		kfree(backlight_levels.values);
		backlight_levels.count = 0;
	}
	vdbg_printk(LENSL_ERR,
		"Failed to start backlight brightness control\n");
out:
	return status;
}
예제 #9
0
static void hkey_poll_start(void)
{
	hkey_ec_prev_offset = 0;
	mutex_lock(&hkey_poll_mutex);
	hkey_poll_task = kthread_run(hkey_poll_kthread,
		NULL, LENSL_HKEY_POLL_KTHREAD_NAME);
	if (IS_ERR(hkey_poll_task)) {
		hkey_poll_task = NULL;
		vdbg_printk(LENSL_ERR,
			"Could not create kernel thread for hotkey polling\n");
	}
	mutex_unlock(&hkey_poll_mutex);
}
예제 #10
0
static int hwmon_init(void)
{
	int res;

	pwm1_value = -1;
	lensl_hwmon_device = hwmon_device_register(&lensl_pdev->dev);
	if (!lensl_hwmon_device) {
		vdbg_printk(LENSL_ERR, "Failed to register hwmon device\n");
		return -ENODEV;
	}

	res = sysfs_create_group(&lensl_hwmon_device->kobj,
				 &hwmon_attr_group);
	if (res < 0) {
		vdbg_printk(LENSL_ERR, "Failed to create hwmon sysfs group\n");
		hwmon_device_unregister(lensl_hwmon_device);
		lensl_hwmon_device = NULL;
		return -ENODEV;
	}
	vdbg_printk(LENSL_DEBUG, "Initialized hwmon subdriver\n");
	return 0;
}
예제 #11
0
static int lensl_acpi_int_func(acpi_handle handle, char *pathname, int *ret,
				int n_arg, ...)
{
	acpi_status status;
	struct acpi_object_list params;
	union acpi_object in_obj[LENSL_MAX_ACPI_ARGS], out_obj;
	struct acpi_buffer result, *resultp;
	int i;
	va_list ap;

	if (!handle)
		return -EINVAL;
	if (n_arg < 0 || n_arg > LENSL_MAX_ACPI_ARGS)
		return -EINVAL;
	va_start(ap, n_arg);
	for (i = 0; i < n_arg; i++) {
		in_obj[i].integer.value = va_arg(ap, int);
		in_obj[i].type = ACPI_TYPE_INTEGER;
	}
	va_end(ap);
	params.count = n_arg;
	params.pointer = in_obj;

	if (ret) {
		result.length = sizeof(out_obj);
		result.pointer = &out_obj;
		resultp = &result;
	} else
		resultp = NULL;

	status = acpi_evaluate_object(handle, pathname, &params, resultp);
	if (ACPI_FAILURE(status))
		return -EIO;
	if (ret)
		*ret = out_obj.integer.value;

	vdbg_printk(LENSL_DEBUG, "ACPI : %s(", pathname);
	if (dbg_level >= LENSL_DEBUG) {
		for (i = 0; i < n_arg; i++) {
			if (i)
				printk(", ");
			printk("%d", (int)in_obj[i].integer.value);
		}
		printk(")");
		if (ret)
			printk(" == %d", *ret);
		printk("\n");
	}
	return 0;
}
예제 #12
0
static void __exit lenovo_sl_laptop_exit(void)
{
	lenovo_sl_procfs_exit();
	hwmon_exit();
	hkey_poll_stop();
	led_exit();
	backlight_exit();
	bluetooth_exit();
	hkey_inputdev_exit();
	if (lensl_pdev)
		platform_device_unregister(lensl_pdev);
	destroy_workqueue(lensl_wq);
	vdbg_printk(LENSL_INFO, "Unloaded Lenovo ThinkPad SL Series driver\n");
}
예제 #13
0
static int lensl_radio_new_rfkill(struct lensl_radio *radio,
			struct rfkill **rfk, bool sw_blocked,
			bool hw_blocked)
{
	int res;

	*rfk = rfkill_allocate(&lensl_pdev->dev, radio->rfktype);
	if (!*rfk) {
		vdbg_printk(LENSL_ERR,
			"Failed to allocate memory for rfkill class\n");
		return -ENOMEM;
	}

	(*rfk)->name = radio->rfkname;
	(*rfk)->get_state = lensl_radio_rfkill_get_state;
	(*rfk)->toggle_radio = lensl_radio_rfkill_toggle_radio;
	(*rfk)->data = radio;

	if (hw_blocked)
		(*rfk)->state = RFKILL_STATE_HARD_BLOCKED;
	else if (sw_blocked)
		(*rfk)->state = RFKILL_STATE_SOFT_BLOCKED;
	else
		(*rfk)->state = RFKILL_STATE_UNBLOCKED;

	res = rfkill_register(*rfk);
	if (res < 0) {
		vdbg_printk(LENSL_ERR,
			"Failed to register %s rfkill switch: %d\n",
			radio->rfkname, res);
		rfkill_free(*rfk);
		*rfk = NULL;
		return res;
	}

	return 0;
}
예제 #14
0
static int bluetooth_init(void)
{
	int value, res;
	bluetooth_present = 0;
	if (!hkey_handle)
		return -ENODEV;
	if (get_gbdc(&value))
		return -EIO;
	if (!(value & TP_ACPI_BLUETOOTH_HWPRESENT))
		return -ENODEV;
	bluetooth_present = 1;

	res = sysfs_create_group(&lensl_pdev->dev.kobj,
				&bluetooth_attr_group);
	if (res) {
		vdbg_printk(LENSL_ERR,
			"Failed to register bluetooth sysfs group\n");
		return res;
	}

	bluetooth_pretend_blocked = !bluetooth_auto_enable;
	res = lensl_new_rfkill(LENSL_RFK_BLUETOOTH_SW_ID,
				&bluetooth_rfkill,
				RFKILL_TYPE_BLUETOOTH,
				"lensl_bluetooth_sw",
				bluetooth_rfk_set,
				bluetooth_rfk_get);
	bluetooth_pretend_blocked = 0;
	if (res) {
		bluetooth_exit();
		return res;
	}
	vdbg_printk(LENSL_DEBUG, "Initialized bluetooth subdriver\n");

	return 0;
}
예제 #15
0
static int lensl_new_rfkill(const unsigned int id,
			struct rfkill **rfk,
			const enum rfkill_type rfktype,
			const char *name,
			int (*toggle_radio)(void *, enum rfkill_state),
			int (*get_state)(void *, enum rfkill_state *))
{
	int res;
	enum rfkill_state initial_state;

	*rfk = rfkill_allocate(&lensl_pdev->dev, rfktype);
	if (!*rfk) {
		vdbg_printk(LENSL_ERR,
			"Failed to allocate memory for rfkill class\n");
		return -ENOMEM;
	}

	(*rfk)->name = name;
	(*rfk)->get_state = get_state;
	(*rfk)->toggle_radio = toggle_radio;

	if (!get_state(NULL, &initial_state))
		(*rfk)->state = initial_state;

	res = rfkill_register(*rfk);
	if (res < 0) {
		vdbg_printk(LENSL_ERR,
			"Failed to register %s rfkill switch: %d\n",
			name, res);
		rfkill_free(*rfk);
		*rfk = NULL;
		return res;
	}

	return 0;
}
예제 #16
0
static int lenovo_sl_procfs_init(void)
{
	struct proc_dir_entry *proc_ec;

	proc_dir = proc_mkdir(LENSL_PROC_DIRNAME, acpi_root_dir);
	if (!proc_dir) {
		vdbg_printk(LENSL_ERR,
		   "Failed to create proc dir acpi/%s/\n", LENSL_PROC_DIRNAME);
		return -ENOENT;
	}
	proc_dir->owner = THIS_MODULE;
	proc_ec = create_proc_entry(LENSL_PROC_EC, 0600, proc_dir);
	if (!proc_ec) {
		vdbg_printk(LENSL_ERR,
			"Failed to create proc entry acpi/%s/%s\n",
			LENSL_PROC_DIRNAME, LENSL_PROC_EC);
		return -ENOENT;
	}
	proc_ec->read_proc = lensl_ec_read_procmem;
	proc_ec->write_proc = lensl_ec_write_procmem;
	vdbg_printk(LENSL_DEBUG, "Initialized procfs debugging interface\n");

	return 0;
}
예제 #17
0
static int radio_init(lensl_radio_type type)
{
	int value, res, hw_blocked = 0, sw_blocked;

	if (!hkey_handle)
		return -ENODEV;
	lensl_radios[type].present = 1; /* need for lensl_radio_get */
	res = lensl_radio_get(&lensl_radios[type], &hw_blocked, &value);
	lensl_radios[type].present = 0;
	if (res && !hw_blocked)
		return -EIO;
	if (!(value & LENSL_RADIO_HWPRESENT))
		return -ENODEV;
	lensl_radios[type].present = 1;

	if (*lensl_radios[type].auto_enable) {
		sw_blocked = 0;
		value |= LENSL_RADIO_RADIOSSW;
		lensl_radios[type].set_acpi(value);
	} else {
		sw_blocked = 1;
		value &= ~LENSL_RADIO_RADIOSSW;
		lensl_radios[type].set_acpi(value);
	}

	res = lensl_radio_new_rfkill(&lensl_radios[type], &lensl_radios[type].rfk,
					sw_blocked, hw_blocked);

	if (res) {
		radio_exit(type);
		return res;
	}
	vdbg_printk(LENSL_DEBUG, "Initialized %s subdriver\n",
		lensl_radios[type].name);

	return 0;
}
예제 #18
0
static int hkey_poll_kthread(void *data)
{
	unsigned long t = 0;
	int offset, level;
	unsigned int keycode;
	u8 scancode;

	mutex_lock(&hkey_poll_mutex);

	offset = hkey_ec_get_offset();
	if (offset < 0) {
		vdbg_printk(LENSL_WARNING,
			"Failed to read hotkey register offset from EC\n");
		hkey_ec_prev_offset = 0;
	} else
		hkey_ec_prev_offset = offset;

	while (!kthread_should_stop() && hkey_poll_hz) {
		if (t == 0)
			t = 1000/hkey_poll_hz;
		t = msleep_interruptible(t);
		if (unlikely(kthread_should_stop()))
			break;
		try_to_freeze();
		if (t > 0)
			continue;
		offset = hkey_ec_get_offset();
		if (offset < 0) {
			vdbg_printk(LENSL_WARNING,
			   "Failed to read hotkey register offset from EC\n");
			continue;
		}
		if (offset == hkey_ec_prev_offset)
			continue;

		if (ec_read(0x0A + offset, &scancode)) {
			vdbg_printk(LENSL_WARNING,
				"Failed to read hotkey code from EC\n");
			continue;
		}
		keycode = ec_scancode_to_keycode(scancode);
		vdbg_printk(LENSL_DEBUG,
		   "Got hotkey keycode %d (scancode %d)\n", keycode, scancode);

		/* Special handling for brightness keys. We do it here and not
		   via an ACPI notifier in order to prevent possible conflicts
		   with video.c */
		if (keycode == KEY_BRIGHTNESSDOWN) {
			if (control_backlight && backlight) {
				level = lensl_bd_get_brightness(backlight);
				if (0 <= --level)
					lensl_bd_set_brightness_int(level);
			} else
				keycode = KEY_RESERVED;
		} else if (keycode == KEY_BRIGHTNESSUP) {
			if (control_backlight && backlight) {
				level = lensl_bd_get_brightness(backlight);
				if (backlight_levels.count > ++level)
					lensl_bd_set_brightness_int(level);
			} else
				keycode = KEY_RESERVED;
		}

		if (keycode != KEY_RESERVED) {
			input_report_key(hkey_inputdev, keycode, 1);
			input_sync(hkey_inputdev);
			input_report_key(hkey_inputdev, keycode, 0);
			input_sync(hkey_inputdev);
		}
		hkey_ec_prev_offset = offset;
	}

	mutex_unlock(&hkey_poll_mutex);
	return 0;
}
예제 #19
0
static int __init lenovo_sl_laptop_init(void)
{
	int ret;
	acpi_status status;

#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,28)
	if (!acpi_video_backlight_support())
		control_backlight = 1;
#endif

	hkey_handle = ec0_handle = NULL;

	if (acpi_disabled)
		return -ENODEV;

	lensl_wq = create_singlethread_workqueue(LENSL_WORKQUEUE_NAME);
	if (!lensl_wq) {
		vdbg_printk(LENSL_ERR, "Failed to create a workqueue\n");
		return -ENOMEM;
	}

	status = acpi_get_handle(NULL, LENSL_HKEY, &hkey_handle);
	if (ACPI_FAILURE(status)) {
		vdbg_printk(LENSL_ERR,
			"Failed to get ACPI handle for %s\n", LENSL_HKEY);
		return -ENODEV;
	}
	status = acpi_get_handle(NULL, LENSL_EC0, &ec0_handle);
	if (ACPI_FAILURE(status)) {
		vdbg_printk(LENSL_ERR,
			"Failed to get ACPI handle for %s\n", LENSL_EC0);
		return -ENODEV;
	}

	lensl_pdev = platform_device_register_simple(LENSL_DRVR_NAME, -1,
							NULL, 0);
	if (IS_ERR(lensl_pdev)) {
		ret = PTR_ERR(lensl_pdev);
		lensl_pdev = NULL;
		vdbg_printk(LENSL_ERR, "Failed to register platform device\n");
		return ret;
	}

	ret = hkey_inputdev_init();
	if (ret)
		return -ENODEV;

	bluetooth_init();
	if (control_backlight)
		backlight_init();

	led_init();
	mutex_init(&hkey_poll_mutex);
	hkey_poll_start();
	hwmon_init();

	if (debug_ec)
		lenovo_sl_procfs_init();

	vdbg_printk(LENSL_INFO, "Loaded Lenovo ThinkPad SL Series driver\n");
	return 0;
}