Esempio n. 1
0
static void g19_led_set(struct led_classdev *led_cdev,
                        enum led_brightness value,
                        int led_num)
{
	struct device *dev;
	struct hid_device *hdev;
	struct g19_data *g19data;
	u8 mask;

	/* Get the device associated with the led */
	dev = led_cdev->dev->parent;

	/* Get the hid associated with the device */
	hdev = container_of(dev, struct hid_device, dev);

	/* Get the underlying data value */
	g19data = hid_get_g19data(hdev);

	mask = 0x80>>led_num;
	if (value)
		g19data->led |= mask;
	else
		g19data->led &= ~mask;

	g19_led_send(hdev);
}
Esempio n. 2
0
static void g19_led_bl_brightness_set(struct led_classdev *led_cdev,
				      enum led_brightness value)
{
	struct device *dev;
	struct hid_device *hdev;
	struct g19_data *data;

	/* Get the device associated with the led */
	dev = led_cdev->dev->parent;

	/* Get the hid associated with the device */
	hdev = container_of(dev, struct hid_device, dev);

	/* Get the underlying data value */
	data = hid_get_g19data(hdev);

	if (led_cdev == data->led_cdev[G19_LED_BL_R])
		data->rgb[0] = value;
	else if (led_cdev == data->led_cdev[G19_LED_BL_G])
		data->rgb[1] = value;
	else if (led_cdev == data->led_cdev[G19_LED_BL_B])
		data->rgb[2] = value;

	g19_rgb_send(hdev);
}
Esempio n. 3
0
static enum led_brightness g19_led_bl_brightness_get(struct led_classdev *led_cdev)
{
	struct device *dev;
	struct hid_device *hdev;
	struct g19_data *data;

	/* Get the device associated with the led */
	dev = led_cdev->dev->parent;

	/* Get the hid associated with the device */
	hdev = container_of(dev, struct hid_device, dev);

	/* Get the underlying data value */
	data = hid_get_g19data(hdev);

	if (led_cdev == data->led_cdev[G19_LED_BL_R])
		return data->rgb[0];
	else if (led_cdev == data->led_cdev[G19_LED_BL_G])
		return data->rgb[1];
	else if (led_cdev == data->led_cdev[G19_LED_BL_B])
		return data->rgb[2];
	else
		dev_info(dev, G19_NAME " error retrieving LED brightness\n");
		
	return LED_OFF;
}
Esempio n. 4
0
static int g19_ep1_read(struct hid_device *hdev)
{
	struct usb_interface *intf;
	struct usb_device *usb_dev;
	struct g19_data *data = hid_get_g19data(hdev);

	struct usb_host_endpoint *ep;
	unsigned int pipe;
	int retval = 0;

	/* Get the usb device to send the image on */
	intf = to_usb_interface(hdev->dev.parent);
	usb_dev = interface_to_usbdev(intf);

	pipe = usb_rcvintpipe(usb_dev, 0x01);
	ep = (usb_pipein(pipe) ? usb_dev->ep_in : usb_dev->ep_out)[usb_pipeendpoint(pipe)];

	if (unlikely(!ep))
		return -EINVAL;

	usb_fill_int_urb(data->ep1_urb, usb_dev, pipe, data->ep1keys, 2,
			 g19_ep1_urb_completion, NULL, 10);
	data->ep1_urb->context = hdev;
	data->ep1_urb->actual_length = 0;

	retval = usb_submit_urb(data->ep1_urb, GFP_KERNEL);

	return retval;
}
Esempio n. 5
0
static void g19_led_screen_bl_send(struct hid_device *hdev)
{
	struct usb_interface *intf;
	struct usb_device *usb_dev;
	struct g19_data *g19data = hid_get_g19data(hdev);
	unsigned int pipe;
	int i = 0;

	unsigned char cp[9];

	cp[0] = g19data->screen_bl;
	cp[1] = 0xe2;
	cp[2] = 0x12;
	cp[3] = 0x00;
	cp[4] = 0x8c;
	cp[5] = 0x11;
	cp[6] = 0x00;
	cp[7] = 0x10;
	cp[8] = 0x00;

	intf = to_usb_interface(hdev->dev.parent);
	usb_dev = interface_to_usbdev(intf);
	pipe = usb_sndctrlpipe(usb_dev, 0x00);
	i = usb_control_msg(usb_dev, pipe, 0x0a,
			    USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
			    0, 0, cp, sizeof(cp),
			    1 * HZ);
	if (i < 0) {
		dev_warn(&hdev->dev,
			 G19_NAME " error setting LCD backlight level %d\n",
			 i);
	}
}
Esempio n. 6
0
static void g19_feature_report_4_send(struct hid_device *hdev, int which)
{
	struct g19_data *g19data = hid_get_g19data(hdev);

	if (which == G19_REPORT_4_INIT) {
		g19data->feature_report_4->field[0]->value[0] = 0x02;
		g19data->feature_report_4->field[0]->value[1] = 0x00;
		g19data->feature_report_4->field[0]->value[2] = 0x00;
		g19data->feature_report_4->field[0]->value[3] = 0x00;
	} else if (which == G19_REPORT_4_FINALIZE) {
		g19data->feature_report_4->field[0]->value[0] = 0x02;
		g19data->feature_report_4->field[0]->value[1] = 0x80;
		g19data->feature_report_4->field[0]->value[2] = 0x00;
		g19data->feature_report_4->field[0]->value[3] = 0xFF;
	} else {
		return;
	}

#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,10,0)

	hid_hw_request(hdev, g19data->feature_report_4, HID_REQ_SET_REPORT);

#else

	usbhid_submit_report(hdev, g19data->feature_report_4, USB_DIR_OUT);

#endif
}
Esempio n. 7
0
static enum led_brightness g19_led_brightness_get(struct led_classdev *led_cdev)
{
	struct device *dev;
	struct hid_device *hdev;
	struct g19_data *data;
	int value = 0;

	/* Get the device associated with the led */
	dev = led_cdev->dev->parent;

	/* Get the hid associated with the device */
	hdev = container_of(dev, struct hid_device, dev);

	/* Get the underlying data value */
	data = hid_get_g19data(hdev);

	if (led_cdev == data->led_cdev[G19_LED_M1])
		value = data->led & 0x80;
	else if (led_cdev == data->led_cdev[G19_LED_M2])
		value = data->led & 0x40;
	else if (led_cdev == data->led_cdev[G19_LED_M3])
		value = data->led & 0x20;
	else if (led_cdev == data->led_cdev[G19_LED_MR])
		value = data->led & 0x10;
	else
		dev_info(dev, G19_NAME " error retrieving LED brightness\n");

	if (value)
		return LED_FULL;
	return LED_OFF;
}
Esempio n. 8
0
static void g19_led_mbtns_send(struct hid_device *hdev)
{
	struct g19_data *g19data = hid_get_g19data(hdev);

	g19data->led_report->field[0]->value[0] = g19data->led_mbtns & 0xFF;

	hid_hw_request(hdev, g19data->led_report, HID_REQ_SET_REPORT);
}
Esempio n. 9
0
static void g19_post_reset_start(struct hid_device *hdev)
{
        unsigned long irq_flags;
	struct g19_data *data = hid_get_g19data(hdev);

	spin_lock_irqsave(&data->lock, irq_flags);
	data->need_reset = 1;
	spin_unlock_irqrestore(&data->lock, irq_flags);
}
Esempio n. 10
0
static void g19_led_bl_send(struct hid_device *hdev)
{
	struct g19_data *g19data = hid_get_g19data(hdev);

	struct hid_field *field0 = g19data->backlight_report->field[0];

	field0->value[0] = g19data->backlight_rgb[0];
	field0->value[1] = g19data->backlight_rgb[1];
	field0->value[2] = g19data->backlight_rgb[2];

	hid_hw_request(hdev, g19data->backlight_report, HID_REQ_SET_REPORT);
}
Esempio n. 11
0
static ssize_t g19_set_keymap_switching(struct hid_device *hdev, unsigned k)
{
	struct g19_data *data = hid_get_g19data(hdev);

	data->keymap_switching = k;

	if (data->keymap_switching) {
		data->led = 1 << data->curkeymap;
		g19_led_send(hdev);
	}

	return 0;
}
Esempio n. 12
0
static void g19_led_send(struct hid_device *hdev)
{
	struct g19_data *g19data = hid_get_g19data(hdev);

	g19data->led_report->field[0]->value[0] = g19data->led&0xFF;

#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,10,0)

	hid_hw_request(hdev, g19data->led_report, HID_REQ_SET_REPORT);

#else

	usbhid_submit_report(hdev, g19data->led_report, USB_DIR_OUT);

#endif
}
Esempio n. 13
0
/* Unlock the urb so we can reuse it */
static void g19_ep1_urb_completion(struct urb *urb)
{
        /* don't process unlinked or failed urbs */
        if (likely(urb->status == 0)) {
	        struct hid_device *hdev = urb->context;
                struct g19_data *data = hid_get_g19data(hdev);
                struct input_dev *idev = data->input_dev;
                int i;

                for (i = 0; i < 8; i++)
		        g19_handle_key_event(data, idev, 24+i, data->ep1keys[0]&(1<<i));

                input_sync(idev);
                
                usb_submit_urb(urb, GFP_ATOMIC);
        }
}
Esempio n. 14
0
static ssize_t g19_set_keymap_index(struct hid_device *hdev, unsigned k)
{
	int scancode;
	int offset_old;
	int offset_new;
	int keycode_old;
	int keycode_new;
	struct g19_data *data = hid_get_g19data(hdev);
	struct input_dev *idev = data->input_dev;

	if (k > 2)
		return -EINVAL;

	/*
	 * Release all the pressed keys unless the new keymap has the same key
	 * in the same scancode position.
	 *
	 * Also, clear the scancode state unless the new keymap has the same
	 * key in the same scancode position.
	 *
	 * This allows a keycode mapped to the same scancode in two different
	 * keymaps to remain pressed without a key up code when the keymap is
	 * switched.
	 */
	offset_old = G19_KEYS * data->curkeymap;
	offset_new = G19_KEYS * k;
	for (scancode = 0; scancode < G19_KEYS; scancode++) {
		keycode_old = data->keycode[offset_old+scancode];
		keycode_new = data->keycode[offset_new+scancode];
		if (keycode_old != keycode_new) {
			if (keycode_old != KEY_RESERVED)
				input_report_key(idev, keycode_old, 0);
			data->scancode_state[scancode] = 0;
		}
	}

	data->curkeymap = k;

	if (data->keymap_switching) {
		data->led = 1 << k;
		g19_led_send(hdev);
	}

	return 0;
}
Esempio n. 15
0
static void g19_feature_report_4_send(struct hid_device *hdev, int which)
{
	struct g19_data *data = hid_get_g19data(hdev);

	if (which == G19_REPORT_4_INIT) {
		data->feature_report_4->field[0]->value[0] = 0x02;
		data->feature_report_4->field[0]->value[1] = 0x00;
		data->feature_report_4->field[0]->value[2] = 0x00;
		data->feature_report_4->field[0]->value[3] = 0x00;
	} else if (which == G19_REPORT_4_FINALIZE) {
		data->feature_report_4->field[0]->value[0] = 0x02;
		data->feature_report_4->field[0]->value[1] = 0x80;
		data->feature_report_4->field[0]->value[2] = 0x00;
		data->feature_report_4->field[0]->value[3] = 0xFF;
	} else {
		return;
	}

	usbhid_submit_report(hdev, data->feature_report_4, USB_DIR_OUT);
}
Esempio n. 16
0
static void g19_feature_report_4_send(struct hid_device *hdev, int which)
{
	struct g19_data *g19data = hid_get_g19data(hdev);

	if (which == G19_REPORT_4_INIT) {
		g19data->feature_report_4->field[0]->value[0] = 0x02;
		g19data->feature_report_4->field[0]->value[1] = 0x00;
		g19data->feature_report_4->field[0]->value[2] = 0x00;
		g19data->feature_report_4->field[0]->value[3] = 0x00;
	} else if (which == G19_REPORT_4_FINALIZE) {
		g19data->feature_report_4->field[0]->value[0] = 0x02;
		g19data->feature_report_4->field[0]->value[1] = 0x80;
		g19data->feature_report_4->field[0]->value[2] = 0x00;
		g19data->feature_report_4->field[0]->value[3] = 0xFF;
	} else {
		return;
	}

	hid_hw_request(hdev, g19data->feature_report_4, HID_REQ_SET_REPORT);
}
Esempio n. 17
0
static void g19_screen_bl_set(struct led_classdev *led_cdev,
				      enum led_brightness value)
{

	struct device *dev;
	struct hid_device *hdev;
	struct g19_data *data;

	/* Get the device associated with the led */
	dev = led_cdev->dev->parent;
	// TEMPORARY

	/* Get the hid associated with the device */
	hdev = container_of(dev, struct hid_device, dev);

	/* Get the underlying data value */
	data = hid_get_g19data(hdev);


//    data = [val, 0xe2, 0x12, 0x00, 0x8c, 0x11, 0x00, 0x10, 0x00]
//    rtype = usb.TYPE_VENDOR | usb.RECIP_INTERFACE
//    self.__usbDeviceMutex.acquire()
//    try:
//        self.__usbDevice.handleIf1.controlMsg(rtype, 0x0a, data, 0x0, 0x0, self.__write_timeout)
//    finally:
//        self.__usbDeviceMutex.release()

	if (led_cdev == data->led_cdev[G19_LED_BL_SCREEN]) {
		if (value > 100)
			value = 100;
		// TEMPORARY
		data->screen_bl = value;
		g19_screen_bl_send(hdev);
	} else
		dev_info(dev, G19_NAME " error retrieving LED brightness\n");
}
Esempio n. 18
0
static ssize_t g19_keymap_store(struct device *dev,
				struct device_attribute *attr,
				const char *buf, size_t count)
{
	struct hid_device *hdev;
	int scanned;
	int consumed;
	int scancd;
	int keycd;
	int error;
	int set = 0;
	int gkey;
	int index;
	int good;
	struct g19_data *data;

	/* Get the hid associated with the device */
	hdev = container_of(dev, struct hid_device, dev);

	/* If we have an invalid pointer we'll return ENODATA */
	if (hdev == NULL || &(hdev->dev) != dev)
		return -ENODATA;

	/* Now, let's get the data structure */
	data = hid_get_g19data(hdev);

	do {
		good = 0;

		/* Look for scancode keycode pair in hex */
		scanned = sscanf(buf, "%x %x%n", &scancd, &keycd, &consumed);
		if (scanned == 2) {
			buf += consumed;
			error = g19_input_setkeycode(data->input_dev, scancd, keycd);
			if (error)
				goto err_input_setkeycode;
			set++;
			good = 1;
		} else {
			/*
			 * Look for Gkey keycode pair and assign to current
			 * keymap
			 */
			scanned = sscanf(buf, "G%d %x%n", &gkey, &keycd, &consumed);
			if (scanned == 2 && gkey > 0 && gkey <= G19_KEYS) {
				buf += consumed;
				scancd = data->curkeymap * G19_KEYS + gkey - 1;
				error = g19_input_setkeycode(data->input_dev, scancd, keycd);
				if (error)
					goto err_input_setkeycode;
				set++;
				good = 1;
			} else {
				/*
				 * Look for Gkey-index keycode pair and assign
				 * to indexed keymap
				 */
				scanned = sscanf(buf, "G%d-%d %x%n", &gkey, &index, &keycd, &consumed);
				if (scanned == 3 &&
				    gkey > 0 && gkey <= G19_KEYS &&
				    index >= 0 && index <= 2) {
					buf += consumed;
					scancd = index * G19_KEYS + gkey - 1;
					error = g19_input_setkeycode(data->input_dev, scancd, keycd);
					if (error)
						goto err_input_setkeycode;
					set++;
					good = 1;
				}
			}
		}

	} while (good);

	if (set == 0) {
		dev_warn(dev, G19_NAME " unrecognized keycode input: %s", buf);
		return -1;
	}

	return count;

err_input_setkeycode:
	dev_warn(dev, G19_NAME " error setting scancode %d to keycode %d\n",
		 scancd, keycd);
	return error;
}
Esempio n. 19
0
static int g19_input_get_keycode(struct input_dev * dev,
                                 unsigned int scancode,
                                 unsigned int * keycode)
{
	int retval;
	
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37)
	
	struct input_keymap_entry ke = {
		.flags    = 0,
		.len      = sizeof(scancode),
		.index    = scancode,
		.scancode = { scancode },
	};
	
	retval   = input_get_keycode(dev, &ke);
	*keycode = ke.keycode;
	
#else
	
	retval   = input_get_keycode(dev, scancode, keycode);
	
#endif
	
	return retval;
}

static void g19_led_send(struct hid_device *hdev)
{
	struct g19_data *data = hid_get_g19data(hdev);

	data->led_report->field[0]->value[0] = data->led&0xFF;

	usbhid_submit_report(hdev, data->led_report, USB_DIR_OUT);
}

static void g19_screen_bl_send(struct hid_device *hdev)
{
	struct usb_interface *intf;
	struct usb_device *usb_dev;
	struct g19_data *data = hid_get_g19data(hdev);
	unsigned int pipe;
	int i = 0;

	unsigned char cp[9];
	cp[0] = data->screen_bl;
	cp[1] = 0xe2;
	cp[2] = 0x12;
	cp[3] = 0x00;
	cp[4] = 0x8c;
	cp[5] = 0x11;
	cp[6] = 0x00;
	cp[7] = 0x10;
	cp[8] = 0x00;

	intf = to_usb_interface(hdev->dev.parent);
	usb_dev = interface_to_usbdev(intf);
	pipe = usb_sndctrlpipe(usb_dev, 0x00);
	i = usb_control_msg(usb_dev, pipe, 0x0a,
			USB_TYPE_VENDOR | USB_RECIP_INTERFACE, 0, 0, cp, sizeof(cp),
			1 * HZ);
	if (i < 0) {
		dev_warn(&hdev->dev, G19_NAME " error setting LCD backlight level %d\n",
				i);
	}
}

static void g19_rgb_send(struct hid_device *hdev)
{
	struct g19_data *data = hid_get_g19data(hdev);

	data->backlight_report->field[0]->value[0] = data->rgb[0];
	data->backlight_report->field[0]->value[1] = data->rgb[1];
	data->backlight_report->field[0]->value[2] = data->rgb[2];

	usbhid_submit_report(hdev, data->backlight_report, USB_DIR_OUT);
}

static void g19_led_set(struct led_classdev *led_cdev,
			 enum led_brightness value,
			 int led_num)
{
	struct device *dev;
	struct hid_device *hdev;
	struct g19_data *data;
	u8 mask;

	/* Get the device associated with the led */
	dev = led_cdev->dev->parent;

	/* Get the hid associated with the device */
	hdev = container_of(dev, struct hid_device, dev);

	/* Get the underlying data value */
	data = hid_get_g19data(hdev);

	mask = 0x80>>led_num;
	if (value)
		data->led |= mask;
	else
		data->led &= ~mask;

	g19_led_send(hdev);
}

static void g19_led_m1_brightness_set(struct led_classdev *led_cdev,
				      enum led_brightness value)
{
	g19_led_set(led_cdev, value, G19_LED_M1);
}