Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit 5772f63613ce0a6777e82a7e8fb553e49da27719

Authored by Stefan Achatz 2011-01-30 20:38:23 +0800

Committed by Jiri Kosina 2011-02-03 23:37:27 +0800

Exists in master and in 7 other branches

HID: roccat: Introduce module hid-roccat-common

Module hid-roccat-common contains functions used by roccat device driver
modules to reduce code duplication.
At the moment it contains just two wrapper methods for usb_control_msg
that ensure that the buffer used for transfer is dma capable which wasn't
the case before.
The kconfig option is not visible to the user but will be selected by the
device specific drivers.

Signed-off-by: Stefan Achatz <erazor_de@users.sourceforge.net>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>

Showing 8 changed files with 254 additions and 426 deletions Inline Diff

drivers/hid/Kconfig
drivers/hid/Makefile
drivers/hid/hid-roccat-arvo.c
drivers/hid/hid-roccat-common.c
drivers/hid/hid-roccat-common.h
drivers/hid/hid-roccat-kone.c
drivers/hid/hid-roccat-koneplus.c
drivers/hid/hid-roccat-pyra.c

drivers/hid/Kconfig

Diff comments View file @ 5772f63

 #
 # HID driver configuration
 #
 menuconfig HID_SUPPORT
 	bool "HID Devices"
 	depends on INPUT
 	default y
 	---help---
 	  Say Y here to get to see options for various computer-human interface
 	  device drivers. This option alone does not add any kernel code.
 	  If you say N, all options in this submenu will be skipped and disabled.
 if HID_SUPPORT
 config HID
 	tristate "Generic HID support"
 	depends on INPUT
 	default y
 	---help---
 	  A human interface device (HID) is a type of computer device that
 	  interacts directly with and takes input from humans. The term "HID"
 	  most commonly used to refer to the USB-HID specification, but other
 	  devices (such as, but not strictly limited to, Bluetooth) are
 	  designed using HID specification (this involves certain keyboards,
 	  mice, tablets, etc). This option compiles into kernel the generic
 	  HID layer code (parser, usages, etc.), which can then be used by
 	  transport-specific HID implementation (like USB or Bluetooth).
 	  For docs and specs, see http://www.usb.org/developers/hidpage/
 	  If unsure, say Y.
 config HIDRAW
 	bool "/dev/hidraw raw HID device support"
 	depends on HID
 	---help---
 	Say Y here if you want to support HID devices (from the USB
 	specification standpoint) that aren't strictly user interface
 	devices, like monitor controls and Uninterruptable Power Supplies.
 	This module supports these devices separately using a separate
 	event interface on /dev/hidraw.
 	There is also a /dev/hiddev configuration option in the USB HID
 	configuration menu. In comparison to hiddev, this device does not process
 	the hid events at all (no parsing, no lookups). This lets applications
 	to work on raw hid events when they want to, and avoid using transport-specific
 	userspace libhid/libusb libraries.
 	If unsure, say Y.
 source "drivers/hid/usbhid/Kconfig"
 menu "Special HID drivers"
 	depends on HID
 config HID_3M_PCT
 	tristate "3M PCT touchscreen"
 	depends on USB_HID
 	---help---
 	Support for 3M PCT touch screens.
 config HID_A4TECH
 	tristate "A4 tech mice" if EMBEDDED
 	depends on USB_HID
 	default !EMBEDDED
 	---help---
 	Support for A4 tech X5 and WOP-35 / Trust 450L mice.
 config HID_ACRUX_FF
 	tristate "ACRUX force feedback"
 	depends on USB_HID
 	select INPUT_FF_MEMLESS
 	---help---
 	Say Y here if you want to enable force feedback support for ACRUX
 	game controllers.
 config HID_APPLE
 	tristate "Apple {i,Power,Mac}Books" if EMBEDDED
 	depends on (USB_HID || BT_HIDP)
 	default !EMBEDDED
 	---help---
 	Support for some Apple devices which less or more break
 	HID specification.
 	Say Y here if you want support for keyboards of	Apple iBooks, PowerBooks,
 	MacBooks, MacBook Pros and Apple Aluminum.
 config HID_BELKIN
 	tristate "Belkin Flip KVM and Wireless keyboard" if EMBEDDED
 	depends on USB_HID
 	default !EMBEDDED
 	---help---
 	Support for Belkin Flip KVM and Wireless keyboard.
 config HID_CANDO
 	tristate "Cando dual touch panel"
 	depends on USB_HID
 	---help---
 	Support for Cando dual touch panel.
 config HID_CHERRY
 	tristate "Cherry Cymotion keyboard" if EMBEDDED
 	depends on USB_HID
 	default !EMBEDDED
 	---help---
 	Support for Cherry Cymotion keyboard.
 config HID_CHICONY
 	tristate "Chicony Tactical pad" if EMBEDDED
 	depends on USB_HID
 	default !EMBEDDED
 	---help---
 	Support for Chicony Tactical pad.
 config HID_PRODIKEYS
 	tristate "Prodikeys PC-MIDI Keyboard support"
 	depends on USB_HID && SND
 	select SND_RAWMIDI
 	---help---
 	Support for Prodikeys PC-MIDI Keyboard device support.
 	Say Y here to enable support for this device.
 	- Prodikeys PC-MIDI keyboard.
 	  The Prodikeys PC-MIDI acts as a USB Audio device, with one MIDI
 	  input and one MIDI output. These MIDI jacks appear as
 	  a sound "card" in the ALSA sound system.
 	  Note: if you say N here, this device will still function as a basic
 	  multimedia keyboard, but will lack support for the musical keyboard
 	  and some additional multimedia keys.
 config HID_CYPRESS
 	tristate "Cypress mouse and barcode readers" if EMBEDDED
 	depends on USB_HID
 	default !EMBEDDED
 	---help---
 	Support for cypress mouse and barcode readers.
 config HID_DRAGONRISE
 	tristate "DragonRise Inc. game controller"
 	depends on USB_HID
 	---help---
 	Say Y here if you have DragonRise Inc.game controllers.
 config DRAGONRISE_FF
 	bool "DragonRise Inc. force feedback"
 	depends on HID_DRAGONRISE
 	select INPUT_FF_MEMLESS
 	---help---
 	Say Y here if you want to enable force feedback support for DragonRise Inc.
 	game controllers.
 config HID_EMS_FF
 	tristate "EMS Production Inc. force feedback support"
 	depends on USB_HID
 	select INPUT_FF_MEMLESS
 	---help---
 	Say Y here if you want to enable force feedback support for devices by
 	EMS Production Ltd.
 	Currently the following devices are known to be supported:
 	 - Trio Linker Plus II
 config HID_EGALAX
 	tristate "eGalax multi-touch panel"
 	depends on USB_HID
 	---help---
 	Support for the eGalax dual-touch panels, including the
 	Joojoo and Wetab tablets.
 config HID_ELECOM
 	tristate "ELECOM BM084 bluetooth mouse"
 	depends on BT_HIDP
 	---help---
 	Support for the ELECOM BM084 (bluetooth mouse).
 config HID_EZKEY
 	tristate "Ezkey BTC 8193 keyboard" if EMBEDDED
 	depends on USB_HID
 	default !EMBEDDED
 	---help---
 	Support for Ezkey BTC 8193 keyboard.
 config HID_KYE
 	tristate "Kye/Genius Ergo Mouse" if EMBEDDED
 	depends on USB_HID
 	default !EMBEDDED
 	---help---
 	Support for Kye/Genius Ergo Mouse.
 config HID_UCLOGIC
 	tristate "UC-Logic"
 	depends on USB_HID
 	---help---
 	Support for UC-Logic tablets.
 config HID_WALTOP
 	tristate "Waltop"
 	depends on USB_HID
 	---help---
 	Support for Waltop tablets.
 config HID_GYRATION
 	tristate "Gyration remote control"
 	depends on USB_HID
 	---help---
 	Support for Gyration remote control.
 config HID_TWINHAN
 	tristate "Twinhan IR remote control"
 	depends on USB_HID
 	---help---
 	Support for Twinhan IR remote control.
 config HID_KENSINGTON
 	tristate "Kensington Slimblade Trackball" if EMBEDDED
 	depends on USB_HID
 	default !EMBEDDED
 	---help---
 	Support for Kensington Slimblade Trackball.
 config HID_LOGITECH
 	tristate "Logitech devices" if EMBEDDED
 	depends on USB_HID
 	default !EMBEDDED
 	---help---
 	Support for Logitech devices that are not fully compliant with HID standard.
 config LOGITECH_FF
 	bool "Logitech force feedback support"
 	depends on HID_LOGITECH
 	select INPUT_FF_MEMLESS
 	help
 	  Say Y here if you have one of these devices:
 	  - Logitech WingMan Cordless RumblePad
 	  - Logitech WingMan Cordless RumblePad 2
 	  - Logitech WingMan Force 3D
 	  - Logitech Formula Force EX
 	  - Logitech WingMan Formula Force GP
 	  - Logitech MOMO Force wheel
 	  and if you want to enable force feedback for them.
 	  Note: if you say N here, this device will still be supported, but without
 	  force feedback.
 config LOGIRUMBLEPAD2_FF
 	bool "Logitech RumblePad/Rumblepad 2 force feedback support"
 	depends on HID_LOGITECH
 	select INPUT_FF_MEMLESS
 	help
 	  Say Y here if you want to enable force feedback support for Logitech
 	  RumblePad and Rumblepad 2 devices.
 config LOGIG940_FF
 	bool "Logitech Flight System G940 force feedback support"
 	depends on HID_LOGITECH
 	select INPUT_FF_MEMLESS
 	help
 	  Say Y here if you want to enable force feedback support for Logitech
 	  Flight System G940 devices.
 config LOGIWII_FF
 	bool "Logitech Speed Force Wireless force feedback support"
 	depends on HID_LOGITECH
 	select INPUT_FF_MEMLESS
 	help
 	  Say Y here if you want to enable force feedback support for Logitech
 	  Speed Force Wireless (Wii) devices.
 config HID_MAGICMOUSE
 	tristate "Apple MagicMouse multi-touch support"
 	depends on BT_HIDP
 	---help---
 	Support for the Apple Magic Mouse multi-touch.
 	Say Y here if you want support for the multi-touch features of the
 	Apple Wireless "Magic" Mouse.
 config HID_MICROSOFT
 	tristate "Microsoft non-fully HID-compliant devices" if EMBEDDED
 	depends on USB_HID
 	default !EMBEDDED
 	---help---
 	Support for Microsoft devices that are not fully compliant with HID standard.
 config HID_MOSART
 	tristate "MosArt dual-touch panels"
 	depends on USB_HID
 	---help---
 	Support for MosArt dual-touch panels.
 config HID_MONTEREY
 	tristate "Monterey Genius KB29E keyboard" if EMBEDDED
 	depends on USB_HID
 	default !EMBEDDED
 	---help---
 	Support for Monterey Genius KB29E.
 config HID_MULTITOUCH
 	tristate "HID Multitouch panels"
 	depends on USB_HID
 	---help---
 	  Generic support for HID multitouch panels.
 	  Say Y here if you have one of the following devices:
 	  - Cypress TrueTouch panels
 	  - Hanvon dual touch panels
 	  - Pixcir dual touch panels
 	  - 'Sensing Win7-TwoFinger' panel by GeneralTouch
 	  If unsure, say N.
 	  To compile this driver as a module, choose M here: the
 	  module will be called hid-multitouch.
 config HID_NTRIG
 	tristate "N-Trig touch screen"
 	depends on USB_HID
 	---help---
 	Support for N-Trig touch screen.
 config HID_ORTEK
 	tristate "Ortek WKB-2000 wireless keyboard and mouse trackpad"
 	depends on USB_HID
 	---help---
 	Support for Ortek WKB-2000 wireless keyboard + mouse trackpad.
 config HID_PANTHERLORD
 	tristate "Pantherlord/GreenAsia game controller"
 	depends on USB_HID
 	---help---
 	  Say Y here if you have a PantherLord/GreenAsia based game controller
 	  or adapter.
 config PANTHERLORD_FF
 	bool "Pantherlord force feedback support"
 	depends on HID_PANTHERLORD
 	select INPUT_FF_MEMLESS
 	---help---
 	  Say Y here if you have a PantherLord/GreenAsia based game controller
 	  or adapter and want to enable force feedback support for it.
 config HID_PETALYNX
 	tristate "Petalynx Maxter remote control"
 	depends on USB_HID
 	---help---
 	Support for Petalynx Maxter remote control.
 config HID_PICOLCD
 	tristate "PicoLCD (graphic version)"
 	depends on USB_HID
 	---help---
 	  This provides support for Minibox PicoLCD devices, currently
 	  only the graphical ones are supported.
 	  This includes support for the following device features:
 	  - Keypad
 	  - Switching between Firmware and Flash mode
 	  - EEProm / Flash access     (via debugfs)
 	  Features selectively enabled:
 	  - Framebuffer for monochrome 256x64 display
 	  - Backlight control
 	  - Contrast control
 	  - General purpose outputs
 	  Features that are not (yet) supported:
 	  - IR
 config HID_PICOLCD_FB
 	bool "Framebuffer support" if EMBEDDED
 	default !EMBEDDED
 	depends on HID_PICOLCD
 	depends on HID_PICOLCD=FB || FB=y
 	select FB_DEFERRED_IO
 	select FB_SYS_FILLRECT
 	select FB_SYS_COPYAREA
 	select FB_SYS_IMAGEBLIT
 	select FB_SYS_FOPS
 	---help---
 	  Provide access to PicoLCD's 256x64 monochrome display via a
 	  frambuffer device.
 config HID_PICOLCD_BACKLIGHT
 	bool "Backlight control" if EMBEDDED
 	default !EMBEDDED
 	depends on HID_PICOLCD
 	depends on HID_PICOLCD=BACKLIGHT_CLASS_DEVICE || BACKLIGHT_CLASS_DEVICE=y
 	---help---
 	  Provide access to PicoLCD's backlight control via backlight
 	  class.
 config HID_PICOLCD_LCD
 	bool "Contrast control" if EMBEDDED
 	default !EMBEDDED
 	depends on HID_PICOLCD
 	depends on HID_PICOLCD=LCD_CLASS_DEVICE || LCD_CLASS_DEVICE=y
 	---help---
 	  Provide access to PicoLCD's LCD contrast via lcd class.
 config HID_PICOLCD_LEDS
 	bool "GPO via leds class" if EMBEDDED
 	default !EMBEDDED
 	depends on HID_PICOLCD
 	depends on HID_PICOLCD=LEDS_CLASS || LEDS_CLASS=y
 	---help---
 	  Provide access to PicoLCD's GPO pins via leds class.
 config HID_QUANTA
 	tristate "Quanta Optical Touch panels"
 	depends on USB_HID
 	---help---
 	Support for Quanta Optical Touch dual-touch panels.
 config HID_ROCCAT
 	tristate "Roccat special event support"
 	depends on USB_HID
 	---help---
 	Support for Roccat special events.
 	Say Y here if you have a Roccat mouse or keyboard and want OSD or
 	macro execution support.
+config HID_ROCCAT_COMMON
+	tristate
 config HID_ROCCAT_ARVO
 	tristate "Roccat Arvo keyboard support"
 	depends on USB_HID
 	select HID_ROCCAT
+	select HID_ROCCAT_COMMON
 	---help---
 	Support for Roccat Arvo keyboard.
 config HID_ROCCAT_KONE
 	tristate "Roccat Kone Mouse support"
 	depends on USB_HID
 	select HID_ROCCAT
+	select HID_ROCCAT_COMMON
 	---help---
 	Support for Roccat Kone mouse.
 config HID_ROCCAT_KONEPLUS
 	tristate "Roccat Kone[+] mouse support"
 	depends on USB_HID
 	select HID_ROCCAT
+	select HID_ROCCAT_COMMON
 	---help---
 	Support for Roccat Kone[+] mouse.
 config HID_ROCCAT_PYRA
 	tristate "Roccat Pyra mouse support"
 	depends on USB_HID
 	select HID_ROCCAT
+	select HID_ROCCAT_COMMON
 	---help---
 	Support for Roccat Pyra mouse.
 config HID_SAMSUNG
 	tristate "Samsung InfraRed remote control or keyboards"
 	depends on USB_HID
 	---help---
 	Support for Samsung InfraRed remote control or keyboards.
 config HID_SONY
 	tristate "Sony PS3 controller"
 	depends on USB_HID
 	---help---
 	Support for Sony PS3 controller.
 config HID_STANTUM
 	tristate "Stantum multitouch panel"
 	depends on USB_HID
 	---help---
 	Support for Stantum multitouch panel.
 config HID_SUNPLUS
 	tristate "Sunplus wireless desktop"
 	depends on USB_HID
 	---help---
 	Support for Sunplus wireless desktop.
 config HID_GREENASIA
 	tristate "GreenAsia (Product ID 0x12) game controller support"
 	depends on USB_HID
 	---help---
 	  Say Y here if you have a GreenAsia (Product ID 0x12) based game
 	  controller or adapter.
 config GREENASIA_FF
 	bool "GreenAsia (Product ID 0x12) force feedback support"
 	depends on HID_GREENASIA
 	select INPUT_FF_MEMLESS
 	---help---
 	Say Y here if you have a GreenAsia (Product ID 0x12) based game controller
 	(like MANTA Warrior MM816 and SpeedLink Strike2 SL-6635) or adapter
 	and want to enable force feedback support for it.
 config HID_SMARTJOYPLUS
 	tristate "SmartJoy PLUS PS2/USB adapter support"
 	depends on USB_HID
 	---help---
 	Support for SmartJoy PLUS PS2/USB adapter.
 config SMARTJOYPLUS_FF
 	bool "SmartJoy PLUS PS2/USB adapter force feedback support"
 	depends on HID_SMARTJOYPLUS
 	select INPUT_FF_MEMLESS
 	---help---
 	Say Y here if you have a SmartJoy PLUS PS2/USB adapter and want to
 	enable force feedback support for it.
 config HID_TOPSEED
 	tristate "TopSeed Cyberlink, BTC Emprex, Conceptronic remote control support"
 	depends on USB_HID
 	---help---
 	Say Y if you have a TopSeed Cyberlink or BTC Emprex or Conceptronic
 	CLLRCMCE remote control.
 config HID_THRUSTMASTER
 	tristate "ThrustMaster devices support"
 	depends on USB_HID
 	---help---
 	  Say Y here if you have a THRUSTMASTER FireStore Dual Power 2 or
 	  a THRUSTMASTER Ferrari GT Rumble Wheel.
 config THRUSTMASTER_FF
 	bool "ThrustMaster devices force feedback support"
 	depends on HID_THRUSTMASTER
 	select INPUT_FF_MEMLESS
 	---help---
 	  Say Y here if you have a THRUSTMASTER FireStore Dual Power 2 or 3,
 	  a THRUSTMASTER Dual Trigger 3-in-1 or a THRUSTMASTER Ferrari GT
 	  Rumble Force or Force Feedback Wheel.
 config HID_WACOM
 	tristate "Wacom Bluetooth devices support"
 	depends on BT_HIDP
 	---help---
 	Support for Wacom Graphire Bluetooth tablet.
 config HID_WACOM_POWER_SUPPLY
 	bool "Wacom Bluetooth devices power supply status support"
 	depends on HID_WACOM
 	select POWER_SUPPLY
 	---help---
 	  Say Y here if you want to enable power supply status monitoring for
 	  Wacom Bluetooth devices.
 config HID_ZEROPLUS
 	tristate "Zeroplus based game controller support"
 	depends on USB_HID
 	---help---
 	  Say Y here if you have a Zeroplus based game controller.
 config ZEROPLUS_FF
 	bool "Zeroplus based game controller force feedback support"
 	depends on HID_ZEROPLUS
 	select INPUT_FF_MEMLESS
 	---help---
 	  Say Y here if you have a Zeroplus based game controller and want
 	  to have force feedback support for it.
 config HID_ZYDACRON
 	tristate "Zydacron remote control support"
 	depends on USB_HID
 	---help---
 	Support for Zydacron remote control.
 endmenu
 endif # HID_SUPPORT

drivers/hid/Makefile

Diff comments View file @ 5772f63

 #
 # Makefile for the HID driver
 #
 hid-y			:= hid-core.o hid-input.o
 ifdef CONFIG_DEBUG_FS
 	hid-objs		+= hid-debug.o
 endif
 obj-$(CONFIG_HID)		+= hid.o
 hid-$(CONFIG_HIDRAW)		+= hidraw.o
 hid-logitech-y		:= hid-lg.o
 ifdef CONFIG_LOGITECH_FF
 	hid-logitech-y	+= hid-lgff.o
 endif
 ifdef CONFIG_LOGIRUMBLEPAD2_FF
 	hid-logitech-y	+= hid-lg2ff.o
 endif
 ifdef CONFIG_LOGIG940_FF
 	hid-logitech-y	+= hid-lg3ff.o
 endif
 ifdef CONFIG_LOGIWII_FF
 	hid-logitech-y	+= hid-lg4ff.o
 endif
 obj-$(CONFIG_HID_3M_PCT)	+= hid-3m-pct.o
 obj-$(CONFIG_HID_A4TECH)	+= hid-a4tech.o
 obj-$(CONFIG_HID_ACRUX_FF)	+= hid-axff.o
 obj-$(CONFIG_HID_APPLE)		+= hid-apple.o
 obj-$(CONFIG_HID_BELKIN)	+= hid-belkin.o
 obj-$(CONFIG_HID_CANDO)		+= hid-cando.o
 obj-$(CONFIG_HID_CHERRY)	+= hid-cherry.o
 obj-$(CONFIG_HID_CHICONY)	+= hid-chicony.o
 obj-$(CONFIG_HID_CYPRESS)	+= hid-cypress.o
 obj-$(CONFIG_HID_DRAGONRISE)	+= hid-drff.o
 obj-$(CONFIG_HID_EMS_FF)	+= hid-emsff.o
 obj-$(CONFIG_HID_EGALAX)	+= hid-egalax.o
 obj-$(CONFIG_HID_ELECOM)	+= hid-elecom.o
 obj-$(CONFIG_HID_EZKEY)		+= hid-ezkey.o
 obj-$(CONFIG_HID_GYRATION)	+= hid-gyration.o
 obj-$(CONFIG_HID_KENSINGTON)	+= hid-kensington.o
 obj-$(CONFIG_HID_KYE)		+= hid-kye.o
 obj-$(CONFIG_HID_LOGITECH)	+= hid-logitech.o
 obj-$(CONFIG_HID_MAGICMOUSE)    += hid-magicmouse.o
 obj-$(CONFIG_HID_MICROSOFT)	+= hid-microsoft.o
 obj-$(CONFIG_HID_MONTEREY)	+= hid-monterey.o
 obj-$(CONFIG_HID_MOSART)	+= hid-mosart.o
 obj-$(CONFIG_HID_MULTITOUCH)	+= hid-multitouch.o
 obj-$(CONFIG_HID_NTRIG)		+= hid-ntrig.o
 obj-$(CONFIG_HID_ORTEK)		+= hid-ortek.o
 obj-$(CONFIG_HID_PRODIKEYS)	+= hid-prodikeys.o
 obj-$(CONFIG_HID_QUANTA)	+= hid-quanta.o
 obj-$(CONFIG_HID_PANTHERLORD)	+= hid-pl.o
 obj-$(CONFIG_HID_PETALYNX)	+= hid-petalynx.o
 obj-$(CONFIG_HID_PICOLCD)	+= hid-picolcd.o
 obj-$(CONFIG_HID_ROCCAT)	+= hid-roccat.o
+obj-$(CONFIG_HID_ROCCAT_COMMON)	+= hid-roccat-common.o
 obj-$(CONFIG_HID_ROCCAT_ARVO)	+= hid-roccat-arvo.o
 obj-$(CONFIG_HID_ROCCAT_KONE)	+= hid-roccat-kone.o
 obj-$(CONFIG_HID_ROCCAT_KONEPLUS)	+= hid-roccat-koneplus.o
 obj-$(CONFIG_HID_ROCCAT_PYRA)	+= hid-roccat-pyra.o
 obj-$(CONFIG_HID_SAMSUNG)	+= hid-samsung.o
 obj-$(CONFIG_HID_SMARTJOYPLUS)	+= hid-sjoy.o
 obj-$(CONFIG_HID_SONY)		+= hid-sony.o
 obj-$(CONFIG_HID_STANTUM)	+= hid-stantum.o
 obj-$(CONFIG_HID_SUNPLUS)	+= hid-sunplus.o
 obj-$(CONFIG_HID_GREENASIA)	+= hid-gaff.o
 obj-$(CONFIG_HID_THRUSTMASTER)	+= hid-tmff.o
 obj-$(CONFIG_HID_TOPSEED)	+= hid-topseed.o
 obj-$(CONFIG_HID_TWINHAN)	+= hid-twinhan.o
 obj-$(CONFIG_HID_UCLOGIC)	+= hid-uclogic.o
 obj-$(CONFIG_HID_ZEROPLUS)	+= hid-zpff.o
 obj-$(CONFIG_HID_ZYDACRON)	+= hid-zydacron.o
 obj-$(CONFIG_HID_WACOM)		+= hid-wacom.o
 obj-$(CONFIG_HID_WALTOP)	+= hid-waltop.o
 obj-$(CONFIG_USB_HID)		+= usbhid/
 obj-$(CONFIG_USB_MOUSE)		+= usbhid/
 obj-$(CONFIG_USB_KBD)		+= usbhid/

drivers/hid/hid-roccat-arvo.c

Diff comments View file @ 5772f63

 /*
  * Roccat Arvo driver for Linux
  *
  * Copyright (c) 2011 Stefan Achatz <erazor_de@users.sourceforge.net>
  */
 /*
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by the Free
  * Software Foundation; either version 2 of the License, or (at your option)
  * any later version.
  */
 /*
  * Roccat Arvo is a gamer keyboard with 5 macro keys that can be configured in
  * 5 profiles.
  */
 #include <linux/device.h>
 #include <linux/input.h>
 #include <linux/hid.h>
-#include <linux/usb.h>
 #include <linux/module.h>
 #include <linux/slab.h>
 #include "hid-ids.h"
 #include "hid-roccat.h"
+#include "hid-roccat-common.h"
 #include "hid-roccat-arvo.h"
 static struct class *arvo_class;
-static int arvo_receive(struct usb_device *usb_dev, uint usb_command,
-		void *buf, uint size)
-{
-	int len;
-	len = usb_control_msg(usb_dev, usb_rcvctrlpipe(usb_dev, 0),
-			USB_REQ_CLEAR_FEATURE,
-			USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN,
-			usb_command, 0, buf, size, USB_CTRL_SET_TIMEOUT);
-	return (len != size) ? -EIO : 0;
-}
-static int arvo_send(struct usb_device *usb_dev, uint usb_command,
-		void const *buf, uint size)
-{
-	int len;
-	len = usb_control_msg(usb_dev, usb_sndctrlpipe(usb_dev, 0),
-			USB_REQ_SET_CONFIGURATION,
-			USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_OUT,
-			usb_command, 0, (void *)buf, size, USB_CTRL_SET_TIMEOUT);
-	return (len != size) ? -EIO : 0;
-}
 static ssize_t arvo_sysfs_show_mode_key(struct device *dev,
 		struct device_attribute *attr, char *buf)
 {
 	struct arvo_device *arvo =
 			hid_get_drvdata(dev_get_drvdata(dev->parent->parent));
 	struct usb_device *usb_dev =
 			interface_to_usbdev(to_usb_interface(dev->parent->parent));
-	struct arvo_mode_key *temp_buf;
+	struct arvo_mode_key temp_buf;
 	int retval;
-	temp_buf = kmalloc(sizeof(struct arvo_mode_key), GFP_KERNEL);
-	if (!temp_buf)
-		return -ENOMEM;
 	mutex_lock(&arvo->arvo_lock);
-	retval = arvo_receive(usb_dev, ARVO_USB_COMMAND_MODE_KEY,
+	retval = roccat_common_receive(usb_dev, ARVO_USB_COMMAND_MODE_KEY,
-			temp_buf, sizeof(struct arvo_mode_key));
+			&temp_buf, sizeof(struct arvo_mode_key));
 	mutex_unlock(&arvo->arvo_lock);
 	if (retval)
-		goto out;
+		return retval;
-	retval = snprintf(buf, PAGE_SIZE, "%d\n", temp_buf->state);
+	return snprintf(buf, PAGE_SIZE, "%d\n", temp_buf.state);
-out:
-	kfree(temp_buf);
-	return retval;
 }
 static ssize_t arvo_sysfs_set_mode_key(struct device *dev,
 		struct device_attribute *attr, char const *buf, size_t size)
 {
 	struct arvo_device *arvo =
 			hid_get_drvdata(dev_get_drvdata(dev->parent->parent));
 	struct usb_device *usb_dev =
 			interface_to_usbdev(to_usb_interface(dev->parent->parent));
-	struct arvo_mode_key *temp_buf;
+	struct arvo_mode_key temp_buf;
 	unsigned long state;
 	int retval;
-	temp_buf = kmalloc(sizeof(struct arvo_mode_key), GFP_KERNEL);
-	if (!temp_buf)
-		return -ENOMEM;
 	retval = strict_strtoul(buf, 10, &state);
 	if (retval)
-		goto out;
+		return retval;
-	temp_buf->command = ARVO_COMMAND_MODE_KEY;
+	temp_buf.command = ARVO_COMMAND_MODE_KEY;
-	temp_buf->state = state;
+	temp_buf.state = state;
 	mutex_lock(&arvo->arvo_lock);
-	retval = arvo_send(usb_dev, ARVO_USB_COMMAND_MODE_KEY,
+	retval = roccat_common_send(usb_dev, ARVO_USB_COMMAND_MODE_KEY,
-			temp_buf, sizeof(struct arvo_mode_key));
+			&temp_buf, sizeof(struct arvo_mode_key));
 	mutex_unlock(&arvo->arvo_lock);
 	if (retval)
-		goto out;
+		return retval;
-	retval = size;
+	return size;
-out:
-	kfree(temp_buf);
-	return retval;
 }
 static ssize_t arvo_sysfs_show_key_mask(struct device *dev,
 		struct device_attribute *attr, char *buf)
 {
 	struct arvo_device *arvo =
 			hid_get_drvdata(dev_get_drvdata(dev->parent->parent));
 	struct usb_device *usb_dev =
 			interface_to_usbdev(to_usb_interface(dev->parent->parent));
-	struct arvo_key_mask *temp_buf;
+	struct arvo_key_mask temp_buf;
 	int retval;
-	temp_buf = kmalloc(sizeof(struct arvo_key_mask), GFP_KERNEL);
-	if (!temp_buf)
-		return -ENOMEM;
 	mutex_lock(&arvo->arvo_lock);
-	retval = arvo_receive(usb_dev, ARVO_USB_COMMAND_KEY_MASK,
+	retval = roccat_common_receive(usb_dev, ARVO_USB_COMMAND_KEY_MASK,
-			temp_buf, sizeof(struct arvo_key_mask));
+			&temp_buf, sizeof(struct arvo_key_mask));
 	mutex_unlock(&arvo->arvo_lock);
 	if (retval)
-		goto out;
+		return retval;
-	retval = snprintf(buf, PAGE_SIZE, "%d\n", temp_buf->key_mask);
+	return snprintf(buf, PAGE_SIZE, "%d\n", temp_buf.key_mask);
-out:
-	kfree(temp_buf);
-	return retval;
 }
 static ssize_t arvo_sysfs_set_key_mask(struct device *dev,
 		struct device_attribute *attr, char const *buf, size_t size)
 {
 	struct arvo_device *arvo =
 			hid_get_drvdata(dev_get_drvdata(dev->parent->parent));
 	struct usb_device *usb_dev =
 			interface_to_usbdev(to_usb_interface(dev->parent->parent));
-	struct arvo_key_mask *temp_buf;
+	struct arvo_key_mask temp_buf;
 	unsigned long key_mask;
 	int retval;
-	temp_buf = kmalloc(sizeof(struct arvo_key_mask), GFP_KERNEL);
-	if (!temp_buf)
-		return -ENOMEM;
 	retval = strict_strtoul(buf, 10, &key_mask);
 	if (retval)
-		goto out;
+		return retval;
-	temp_buf->command = ARVO_COMMAND_KEY_MASK;
+	temp_buf.command = ARVO_COMMAND_KEY_MASK;
-	temp_buf->key_mask = key_mask;
+	temp_buf.key_mask = key_mask;
 	mutex_lock(&arvo->arvo_lock);
-	retval = arvo_send(usb_dev, ARVO_USB_COMMAND_KEY_MASK,
+	retval = roccat_common_send(usb_dev, ARVO_USB_COMMAND_KEY_MASK,
-			temp_buf, sizeof(struct arvo_key_mask));
+			&temp_buf, sizeof(struct arvo_key_mask));
 	mutex_unlock(&arvo->arvo_lock);
 	if (retval)
-		goto out;
+		return retval;
-	retval = size;
+	return size;
-out:
-	kfree(temp_buf);
-	return retval;
 }
 /* retval is 1-5 on success, < 0 on error */
 static int arvo_get_actual_profile(struct usb_device *usb_dev)
 {
-	struct arvo_actual_profile *temp_buf;
+	struct arvo_actual_profile temp_buf;
 	int retval;
-	temp_buf = kmalloc(sizeof(struct arvo_actual_profile), GFP_KERNEL);
+	retval = roccat_common_receive(usb_dev, ARVO_USB_COMMAND_ACTUAL_PROFILE,
-	if (!temp_buf)
+			&temp_buf, sizeof(struct arvo_actual_profile));
-		return -ENOMEM;
-	retval = arvo_receive(usb_dev, ARVO_USB_COMMAND_ACTUAL_PROFILE,
+	if (retval)
-			temp_buf, sizeof(struct arvo_actual_profile));
+		return retval;
-	if (!retval)
+	return temp_buf.actual_profile;
-		retval = temp_buf->actual_profile;
-	kfree(temp_buf);
-	return retval;
 }
 static ssize_t arvo_sysfs_show_actual_profile(struct device *dev,
 		struct device_attribute *attr, char *buf)
 {
 	struct arvo_device *arvo =
 			hid_get_drvdata(dev_get_drvdata(dev->parent->parent));
 	return snprintf(buf, PAGE_SIZE, "%d\n", arvo->actual_profile);
 }
 static ssize_t arvo_sysfs_set_actual_profile(struct device *dev,
 		struct device_attribute *attr, char const *buf, size_t size)
 {
 	struct arvo_device *arvo =
 			hid_get_drvdata(dev_get_drvdata(dev->parent->parent));
 	struct usb_device *usb_dev =
 			interface_to_usbdev(to_usb_interface(dev->parent->parent));
-	struct arvo_actual_profile *temp_buf;
+	struct arvo_actual_profile temp_buf;
 	unsigned long profile;
 	int retval;
-	temp_buf = kmalloc(sizeof(struct arvo_actual_profile), GFP_KERNEL);
-	if (!temp_buf)
-		return -ENOMEM;
 	retval = strict_strtoul(buf, 10, &profile);
 	if (retval)
-		goto out;
+		return retval;
-	temp_buf->command = ARVO_COMMAND_ACTUAL_PROFILE;
+	temp_buf.command = ARVO_COMMAND_ACTUAL_PROFILE;
-	temp_buf->actual_profile = profile;
+	temp_buf.actual_profile = profile;
 	mutex_lock(&arvo->arvo_lock);
-	retval = arvo_send(usb_dev, ARVO_USB_COMMAND_ACTUAL_PROFILE,
+	retval = roccat_common_send(usb_dev, ARVO_USB_COMMAND_ACTUAL_PROFILE,
-			temp_buf, sizeof(struct arvo_actual_profile));
+			&temp_buf, sizeof(struct arvo_actual_profile));
 	if (!retval) {
 		arvo->actual_profile = profile;
 		retval = size;
 	}
 	mutex_unlock(&arvo->arvo_lock);
-out:
-	kfree(temp_buf);
 	return retval;
 }
 static ssize_t arvo_sysfs_write(struct file *fp,
 		struct kobject *kobj, void const *buf,
 		loff_t off, size_t count, size_t real_size, uint command)
 {
 	struct device *dev =
 			container_of(kobj, struct device, kobj)->parent->parent;
 	struct arvo_device *arvo = hid_get_drvdata(dev_get_drvdata(dev));
 	struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));
 	int retval;
 	if (off != 0 || count != real_size)
 		return -EINVAL;
 	mutex_lock(&arvo->arvo_lock);
-	retval = arvo_send(usb_dev, command, buf, real_size);
+	retval = roccat_common_send(usb_dev, command, buf, real_size);
 	mutex_unlock(&arvo->arvo_lock);
 	return (retval ? retval : real_size);
 }
 static ssize_t arvo_sysfs_read(struct file *fp,
 		struct kobject *kobj, void *buf, loff_t off,
 		size_t count, size_t real_size, uint command)
 {
 	struct device *dev =
 			container_of(kobj, struct device, kobj)->parent->parent;
 	struct arvo_device *arvo = hid_get_drvdata(dev_get_drvdata(dev));
 	struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));
 	int retval;
 	if (off >= real_size)
 		return 0;
 	if (off != 0 || count != real_size)
 		return -EINVAL;
 	mutex_lock(&arvo->arvo_lock);
-	retval = arvo_receive(usb_dev, command, buf, real_size);
+	retval = roccat_common_receive(usb_dev, command, buf, real_size);
 	mutex_unlock(&arvo->arvo_lock);
 	return (retval ? retval : real_size);
 }
 static ssize_t arvo_sysfs_write_button(struct file *fp,
 		struct kobject *kobj, struct bin_attribute *attr, char *buf,
 		loff_t off, size_t count)
 {
 	return arvo_sysfs_write(fp, kobj, buf, off, count,
 			sizeof(struct arvo_button), ARVO_USB_COMMAND_BUTTON);
 }
 static ssize_t arvo_sysfs_read_info(struct file *fp,
 		struct kobject *kobj, struct bin_attribute *attr, char *buf,
 		loff_t off, size_t count)
 {
 	return arvo_sysfs_read(fp, kobj, buf, off, count,
 			sizeof(struct arvo_info), ARVO_USB_COMMAND_INFO);
 }
 static struct device_attribute arvo_attributes[] = {
 	__ATTR(mode_key, 0660,
 			arvo_sysfs_show_mode_key, arvo_sysfs_set_mode_key),
 	__ATTR(key_mask, 0660,
 			arvo_sysfs_show_key_mask, arvo_sysfs_set_key_mask),
 	__ATTR(actual_profile, 0660,
 			arvo_sysfs_show_actual_profile,
 			arvo_sysfs_set_actual_profile),
 	__ATTR_NULL
 };
 static struct bin_attribute arvo_bin_attributes[] = {
 	{
 		.attr = { .name = "button", .mode = 0220 },
 		.size = sizeof(struct arvo_button),
 		.write = arvo_sysfs_write_button
 	},
 	{
 		.attr = { .name = "info", .mode = 0440 },
 		.size = sizeof(struct arvo_info),
 		.read = arvo_sysfs_read_info
 	},
 	__ATTR_NULL
 };
 static int arvo_init_arvo_device_struct(struct usb_device *usb_dev,
 		struct arvo_device *arvo)
 {
 	int retval;
 	mutex_init(&arvo->arvo_lock);
 	retval = arvo_get_actual_profile(usb_dev);
 	if (retval < 0)
 		return retval;
 	arvo->actual_profile = retval;
 	return 0;
 }
 static int arvo_init_specials(struct hid_device *hdev)
 {
 	struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
 	struct usb_device *usb_dev = interface_to_usbdev(intf);
 	struct arvo_device *arvo;
 	int retval;
 	if (intf->cur_altsetting->desc.bInterfaceProtocol
 			== USB_INTERFACE_PROTOCOL_KEYBOARD) {
 		hid_set_drvdata(hdev, NULL);
 		return 0;
 	}
 	arvo = kzalloc(sizeof(*arvo), GFP_KERNEL);
 	if (!arvo) {
 		hid_err(hdev, "can't alloc device descriptor\n");
 		return -ENOMEM;
 	}
 	hid_set_drvdata(hdev, arvo);
 	retval = arvo_init_arvo_device_struct(usb_dev, arvo);
 	if (retval) {
 		hid_err(hdev, "couldn't init struct arvo_device\n");
 		goto exit_free;
 	}
 	retval = roccat_connect(arvo_class, hdev);
 	if (retval < 0) {
 		hid_err(hdev, "couldn't init char dev\n");
 	} else {
 		arvo->chrdev_minor = retval;
 		arvo->roccat_claimed = 1;
 	}
 	return 0;
 exit_free:
 	kfree(arvo);
 	return retval;
 }
 static void arvo_remove_specials(struct hid_device *hdev)
 {
 	struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
 	struct arvo_device *arvo;
 	if (intf->cur_altsetting->desc.bInterfaceProtocol
 			== USB_INTERFACE_PROTOCOL_KEYBOARD)
 		return;
 	arvo = hid_get_drvdata(hdev);
 	if (arvo->roccat_claimed)
 		roccat_disconnect(arvo->chrdev_minor);
 	kfree(arvo);
 }
 static int arvo_probe(struct hid_device *hdev,
 		const struct hid_device_id *id)
 {
 	int retval;
 	retval = hid_parse(hdev);
 	if (retval) {
 		hid_err(hdev, "parse failed\n");
 		goto exit;
 	}
 	retval = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
 	if (retval) {
 		hid_err(hdev, "hw start failed\n");
 		goto exit;
 	}
 	retval = arvo_init_specials(hdev);
 	if (retval) {
 		hid_err(hdev, "couldn't install keyboard\n");
 		goto exit_stop;
 	}
 	return 0;
 exit_stop:
 	hid_hw_stop(hdev);
 exit:
 	return retval;
 }
 static void arvo_remove(struct hid_device *hdev)
 {
 	arvo_remove_specials(hdev);
 	hid_hw_stop(hdev);
 }
 static void arvo_report_to_chrdev(struct arvo_device const *arvo,
 		u8 const *data)
 {
 	struct arvo_special_report const *special_report;
 	struct arvo_roccat_report roccat_report;
 	special_report = (struct arvo_special_report const *)data;
 	roccat_report.profile = arvo->actual_profile;
 	roccat_report.button = special_report->event &
 			ARVO_SPECIAL_REPORT_EVENT_MASK_BUTTON;
 	if ((special_report->event & ARVO_SPECIAL_REPORT_EVENT_MASK_ACTION) ==
 			ARVO_SPECIAL_REPORT_EVENT_ACTION_PRESS)
 		roccat_report.action = ARVO_ROCCAT_REPORT_ACTION_PRESS;
 	else
 		roccat_report.action = ARVO_ROCCAT_REPORT_ACTION_RELEASE;
 	roccat_report_event(arvo->chrdev_minor, (uint8_t const *)&roccat_report,
 			sizeof(struct arvo_roccat_report));
 }
 static int arvo_raw_event(struct hid_device *hdev,
 		struct hid_report *report, u8 *data, int size)
 {
 	struct arvo_device *arvo = hid_get_drvdata(hdev);
 	if (size != 3)
 		return 0;
 	if (arvo->roccat_claimed)
 		arvo_report_to_chrdev(arvo, data);
 	return 0;
 }
 static const struct hid_device_id arvo_devices[] = {
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_ARVO) },
 	{ }
 };
 MODULE_DEVICE_TABLE(hid, arvo_devices);
 static struct hid_driver arvo_driver = {
 	.name = "arvo",
 	.id_table = arvo_devices,
 	.probe = arvo_probe,
 	.remove = arvo_remove,
 	.raw_event = arvo_raw_event
 };
 static int __init arvo_init(void)
 {
 	int retval;
 	arvo_class = class_create(THIS_MODULE, "arvo");
 	if (IS_ERR(arvo_class))
 		return PTR_ERR(arvo_class);
 	arvo_class->dev_attrs = arvo_attributes;
 	arvo_class->dev_bin_attrs = arvo_bin_attributes;
 	retval = hid_register_driver(&arvo_driver);
 	if (retval)
 		class_destroy(arvo_class);
 	return retval;
 }
 static void __exit arvo_exit(void)
 {
 	class_destroy(arvo_class);
 	hid_unregister_driver(&arvo_driver);
 }
 module_init(arvo_init);
 module_exit(arvo_exit);
 MODULE_AUTHOR("Stefan Achatz");
 MODULE_DESCRIPTION("USB Roccat Arvo driver");
 MODULE_LICENSE("GPL v2");

drivers/hid/hid-roccat-common.c

Diff comments View file @ 5772f63

File was created	1	/*
	2	* Roccat common functions for device specific drivers
	3	*
	4	* Copyright (c) 2011 Stefan Achatz <erazor_de@users.sourceforge.net>
	5	*/
	6
	7	/*
	8	* This program is free software; you can redistribute it and/or modify it
	9	* under the terms of the GNU General Public License as published by the Free
	10	* Software Foundation; either version 2 of the License, or (at your option)
	11	* any later version.
	12	*/
	13
	14	#include <linux/slab.h>
	15	#include "hid-roccat-common.h"
	16
	17	int roccat_common_receive(struct usb_device *usb_dev, uint usb_command,
	18	void *data, uint size)
	19	{
	20	char *buf;
	21	int len;
	22
	23	buf = kmalloc(size, GFP_KERNEL);
	24	if (buf == NULL)
	25	return -ENOMEM;
	26
	27	len = usb_control_msg(usb_dev, usb_rcvctrlpipe(usb_dev, 0),
	28	USB_REQ_CLEAR_FEATURE,
	29	USB_TYPE_CLASS \| USB_RECIP_INTERFACE \| USB_DIR_IN,
	30	usb_command, 0, buf, size, USB_CTRL_SET_TIMEOUT);
	31
	32	memcpy(data, buf, size);
	33	kfree(buf);
	34	return ((len < 0) ? len : ((len != size) ? -EIO : 0));
	35	}
	36	EXPORT_SYMBOL_GPL(roccat_common_receive);
	37
	38	int roccat_common_send(struct usb_device *usb_dev, uint usb_command,
	39	void const *data, uint size)
	40	{
	41	char *buf;
	42	int len;
	43
	44	buf = kmalloc(size, GFP_KERNEL);
	45	if (buf == NULL)
	46	return -ENOMEM;
	47
	48	memcpy(buf, data, size);
	49
	50	len = usb_control_msg(usb_dev, usb_sndctrlpipe(usb_dev, 0),
	51	USB_REQ_SET_CONFIGURATION,
	52	USB_TYPE_CLASS \| USB_RECIP_INTERFACE \| USB_DIR_OUT,
	53	usb_command, 0, buf, size, USB_CTRL_SET_TIMEOUT);
	54
	55	kfree(buf);
	56	return ((len < 0) ? len : ((len != size) ? -EIO : 0));
	57	}
	58	EXPORT_SYMBOL_GPL(roccat_common_send);
	59
	60	MODULE_AUTHOR("Stefan Achatz");
	61	MODULE_DESCRIPTION("USB Roccat common driver");
	62	MODULE_LICENSE("GPL v2");
	63

drivers/hid/hid-roccat-common.h

Diff comments View file @ 5772f63

File was created	1	#ifndef __HID_ROCCAT_COMMON_H
	2	#define __HID_ROCCAT_COMMON_H
	3
	4	/*
	5	* Copyright (c) 2011 Stefan Achatz <erazor_de@users.sourceforge.net>
	6	*/
	7
	8	/*
	9	* This program is free software; you can redistribute it and/or modify it
	10	* under the terms of the GNU General Public License as published by the Free
	11	* Software Foundation; either version 2 of the License, or (at your option)
	12	* any later version.
	13	*/
	14
	15	#include <linux/usb.h>
	16	#include <linux/types.h>
	17
	18	int roccat_common_receive(struct usb_device *usb_dev, uint usb_command,
	19	void *data, uint size);
	20	int roccat_common_send(struct usb_device *usb_dev, uint usb_command,
	21	void const *data, uint size);
	22
	23	#endif
	24

drivers/hid/hid-roccat-kone.c

Diff comments View file @ 5772f63

1	/*	1	/*
2	* Roccat Kone driver for Linux	2	* Roccat Kone driver for Linux
3	*	3	*
4	* Copyright (c) 2010 Stefan Achatz <erazor_de@users.sourceforge.net>	4	* Copyright (c) 2010 Stefan Achatz <erazor_de@users.sourceforge.net>
5	*/	5	*/
6		6
7	/*	7	/*
8	* This program is free software; you can redistribute it and/or modify it	8	* This program is free software; you can redistribute it and/or modify it
9	* under the terms of the GNU General Public License as published by the Free	9	* under the terms of the GNU General Public License as published by the Free
10	* Software Foundation; either version 2 of the License, or (at your option)	10	* Software Foundation; either version 2 of the License, or (at your option)
11	* any later version.	11	* any later version.
12	*/	12	*/
13		13
14	/*	14	/*
15	* Roccat Kone is a gamer mouse which consists of a mouse part and a keyboard	15	* Roccat Kone is a gamer mouse which consists of a mouse part and a keyboard
16	* part. The keyboard part enables the mouse to execute stored macros with mixed	16	* part. The keyboard part enables the mouse to execute stored macros with mixed
17	* key- and button-events.	17	* key- and button-events.
18	*	18	*
19	* TODO implement on-the-fly polling-rate change	19	* TODO implement on-the-fly polling-rate change
20	* The windows driver has the ability to change the polling rate of the	20	* The windows driver has the ability to change the polling rate of the
21	* device on the press of a mousebutton.	21	* device on the press of a mousebutton.
22	* Is it possible to remove and reinstall the urb in raw-event- or any	22	* Is it possible to remove and reinstall the urb in raw-event- or any
23	* other handler, or to defer this action to be executed somewhere else?	23	* other handler, or to defer this action to be executed somewhere else?
24	*	24	*
25	* TODO is it possible to overwrite group for sysfs attributes via udev?	25	* TODO is it possible to overwrite group for sysfs attributes via udev?
26	*/	26	*/
27		27
28	#include <linux/device.h>	28	#include <linux/device.h>
29	#include <linux/input.h>	29	#include <linux/input.h>
30	#include <linux/hid.h>	30	#include <linux/hid.h>
31	#include <linux/usb.h>
32	#include <linux/module.h>	31	#include <linux/module.h>
33	#include <linux/slab.h>	32	#include <linux/slab.h>
34	#include "hid-ids.h"	33	#include "hid-ids.h"
35	#include "hid-roccat.h"	34	#include "hid-roccat.h"
		35	#include "hid-roccat-common.h"
36	#include "hid-roccat-kone.h"	36	#include "hid-roccat-kone.h"
37		37
38	static uint profile_numbers[5] = {0, 1, 2, 3, 4};	38	static uint profile_numbers[5] = {0, 1, 2, 3, 4};
39		39
40	/* kone_class is used for creating sysfs attributes via roccat char device */	40	/* kone_class is used for creating sysfs attributes via roccat char device */
41	static struct class *kone_class;	41	static struct class *kone_class;
42		42
43	static void kone_set_settings_checksum(struct kone_settings *settings)	43	static void kone_set_settings_checksum(struct kone_settings *settings)
44	{	44	{
45	uint16_t checksum = 0;	45	uint16_t checksum = 0;
46	unsigned char address = (unsigned char )settings;	46	unsigned char address = (unsigned char )settings;
47	int i;	47	int i;
48		48
49	for (i = 0; i < sizeof(struct kone_settings) - 2; ++i, ++address)	49	for (i = 0; i < sizeof(struct kone_settings) - 2; ++i, ++address)
50	checksum += *address;	50	checksum += *address;
51	settings->checksum = cpu_to_le16(checksum);	51	settings->checksum = cpu_to_le16(checksum);
52	}	52	}
53		53
54	/*	54	/*
55	* Checks success after writing data to mouse	55	* Checks success after writing data to mouse
56	* On success returns 0	56	* On success returns 0
57	* On failure returns errno	57	* On failure returns errno
58	*/	58	*/
59	static int kone_check_write(struct usb_device *usb_dev)	59	static int kone_check_write(struct usb_device *usb_dev)
60	{	60	{
61	int len;	61	int retval;
62	unsigned char *data;	62	uint8_t data;
63		63
64	data = kmalloc(1, GFP_KERNEL);
65	if (!data)
66	return -ENOMEM;
67
68	do {	64	do {
69	/*	65	/*
70	* Mouse needs 50 msecs until it says ok, but there are	66	* Mouse needs 50 msecs until it says ok, but there are
71	* 30 more msecs needed for next write to work.	67	* 30 more msecs needed for next write to work.
72	*/	68	*/
73	msleep(80);	69	msleep(80);
74		70
75	len = usb_control_msg(usb_dev, usb_rcvctrlpipe(usb_dev, 0),	71	retval = roccat_common_receive(usb_dev,
76	USB_REQ_CLEAR_FEATURE,	72	kone_command_confirm_write, &data, 1);
77	USB_TYPE_CLASS \| USB_RECIP_INTERFACE \|	73	if (retval)
78	USB_DIR_IN,	74	return retval;
79	kone_command_confirm_write, 0, data, 1,
80	USB_CTRL_SET_TIMEOUT);
81		75
82	if (len != 1) {
83	kfree(data);
84	return -EIO;
85	}
86
87	/*	76	/*
88	* value of 3 seems to mean something like	77	* value of 3 seems to mean something like
89	* "not finished yet, but it looks good"	78	* "not finished yet, but it looks good"
90	* So check again after a moment.	79	* So check again after a moment.
91	*/	80	*/
92	} while (*data == 3);	81	} while (data == 3);
93		82
94	if (data == 1) { / everything alright */	83	if (data == 1) /* everything alright */
95	kfree(data);
96	return 0;	84	return 0;
97	} else { /* unknown answer */	85
98	hid_err(usb_dev, "got retval %d when checking write\n", *data);	86	/* unknown answer */
99	kfree(data);	87	hid_err(usb_dev, "got retval %d when checking write\n", data);
100	return -EIO;	88	return -EIO;
101	}
102	}	89	}
103		90
104	/*	91	/*
105	* Reads settings from mouse and stores it in @buf	92	* Reads settings from mouse and stores it in @buf
106	* @buf has to be alloced with GFP_KERNEL
107	* On success returns 0	93	* On success returns 0
108	* On failure returns errno	94	* On failure returns errno
109	*/	95	*/
110	static int kone_get_settings(struct usb_device *usb_dev,	96	static int kone_get_settings(struct usb_device *usb_dev,
111	struct kone_settings *buf)	97	struct kone_settings *buf)
112	{	98	{
113	int len;	99	return roccat_common_receive(usb_dev, kone_command_settings, buf,
114		100	sizeof(struct kone_settings));
115	len = usb_control_msg(usb_dev, usb_rcvctrlpipe(usb_dev, 0),
116	USB_REQ_CLEAR_FEATURE,
117	USB_TYPE_CLASS \| USB_RECIP_INTERFACE \| USB_DIR_IN,
118	kone_command_settings, 0, buf,
119	sizeof(struct kone_settings), USB_CTRL_SET_TIMEOUT);
120
121	if (len != sizeof(struct kone_settings))
122	return -EIO;
123
124	return 0;
125	}	101	}
126		102
127	/*	103	/*
128	* Writes settings from @buf to mouse	104	* Writes settings from @buf to mouse
129	* On success returns 0	105	* On success returns 0
130	* On failure returns errno	106	* On failure returns errno
131	*/	107	*/
132	static int kone_set_settings(struct usb_device *usb_dev,	108	static int kone_set_settings(struct usb_device *usb_dev,
133	struct kone_settings const *settings)	109	struct kone_settings const *settings)
134	{	110	{
135	int len;	111	int retval;
136		112	retval = roccat_common_send(usb_dev, kone_command_settings,
137	len = usb_control_msg(usb_dev, usb_sndctrlpipe(usb_dev, 0),	113	settings, sizeof(struct kone_settings));
138	USB_REQ_SET_CONFIGURATION,	114	if (retval)
139	USB_TYPE_CLASS \| USB_RECIP_INTERFACE \| USB_DIR_OUT,	115	return retval;
140	kone_command_settings, 0, (char *)settings,	116	return kone_check_write(usb_dev);
141	sizeof(struct kone_settings),
142	USB_CTRL_SET_TIMEOUT);
143
144	if (len != sizeof(struct kone_settings))
145	return -EIO;
146
147	if (kone_check_write(usb_dev))
148	return -EIO;
149
150	return 0;
151	}	117	}
152		118
153	/*	119	/*
154	* Reads profile data from mouse and stores it in @buf	120	* Reads profile data from mouse and stores it in @buf
155	* @number: profile number to read	121	* @number: profile number to read
156	* On success returns 0	122	* On success returns 0
157	* On failure returns errno	123	* On failure returns errno
158	*/	124	*/
159	static int kone_get_profile(struct usb_device *usb_dev,	125	static int kone_get_profile(struct usb_device *usb_dev,
160	struct kone_profile *buf, int number)	126	struct kone_profile *buf, int number)
161	{	127	{
162	int len;	128	int len;
163		129
164	if (number < 1 \|\| number > 5)	130	if (number < 1 \|\| number > 5)
165	return -EINVAL;	131	return -EINVAL;
166		132
167	len = usb_control_msg(usb_dev, usb_rcvctrlpipe(usb_dev, 0),	133	len = usb_control_msg(usb_dev, usb_rcvctrlpipe(usb_dev, 0),
168	USB_REQ_CLEAR_FEATURE,	134	USB_REQ_CLEAR_FEATURE,
169	USB_TYPE_CLASS \| USB_RECIP_INTERFACE \| USB_DIR_IN,	135	USB_TYPE_CLASS \| USB_RECIP_INTERFACE \| USB_DIR_IN,
170	kone_command_profile, number, buf,	136	kone_command_profile, number, buf,
171	sizeof(struct kone_profile), USB_CTRL_SET_TIMEOUT);	137	sizeof(struct kone_profile), USB_CTRL_SET_TIMEOUT);
172		138
173	if (len != sizeof(struct kone_profile))	139	if (len != sizeof(struct kone_profile))
174	return -EIO;	140	return -EIO;
175		141
176	return 0;	142	return 0;
177	}	143	}
178		144
179	/*	145	/*
180	* Writes profile data to mouse.	146	* Writes profile data to mouse.
181	* @number: profile number to write	147	* @number: profile number to write
182	* On success returns 0	148	* On success returns 0
183	* On failure returns errno	149	* On failure returns errno
184	*/	150	*/
185	static int kone_set_profile(struct usb_device *usb_dev,	151	static int kone_set_profile(struct usb_device *usb_dev,
186	struct kone_profile const *profile, int number)	152	struct kone_profile const *profile, int number)
187	{	153	{
188	int len;	154	int len;
189		155
190	if (number < 1 \|\| number > 5)	156	if (number < 1 \|\| number > 5)
191	return -EINVAL;	157	return -EINVAL;
192		158
193	len = usb_control_msg(usb_dev, usb_sndctrlpipe(usb_dev, 0),	159	len = usb_control_msg(usb_dev, usb_sndctrlpipe(usb_dev, 0),
194	USB_REQ_SET_CONFIGURATION,	160	USB_REQ_SET_CONFIGURATION,
195	USB_TYPE_CLASS \| USB_RECIP_INTERFACE \| USB_DIR_OUT,	161	USB_TYPE_CLASS \| USB_RECIP_INTERFACE \| USB_DIR_OUT,
196	kone_command_profile, number, (char *)profile,	162	kone_command_profile, number, (void *)profile,
197	sizeof(struct kone_profile),	163	sizeof(struct kone_profile),
198	USB_CTRL_SET_TIMEOUT);	164	USB_CTRL_SET_TIMEOUT);
199		165
200	if (len != sizeof(struct kone_profile))	166	if (len != sizeof(struct kone_profile))
201	return len;	167	return len;
202		168
203	if (kone_check_write(usb_dev))	169	if (kone_check_write(usb_dev))
204	return -EIO;	170	return -EIO;
205		171
206	return 0;	172	return 0;
207	}	173	}
208		174
209	/*	175	/*
210	* Reads value of "fast-clip-weight" and stores it in @result	176	* Reads value of "fast-clip-weight" and stores it in @result
211	* On success returns 0	177	* On success returns 0
212	* On failure returns errno	178	* On failure returns errno
213	*/	179	*/
214	static int kone_get_weight(struct usb_device usb_dev, int result)	180	static int kone_get_weight(struct usb_device usb_dev, int result)
215	{	181	{
216	int len;	182	int retval;
217	uint8_t *data;	183	uint8_t data;
218		184
219	data = kmalloc(1, GFP_KERNEL);	185	retval = roccat_common_receive(usb_dev, kone_command_weight, &data, 1);
220	if (!data)
221	return -ENOMEM;
222		186
223	len = usb_control_msg(usb_dev, usb_rcvctrlpipe(usb_dev, 0),	187	if (retval)
224	USB_REQ_CLEAR_FEATURE,	188	return retval;
225	USB_TYPE_CLASS \| USB_RECIP_INTERFACE \| USB_DIR_IN,
226	kone_command_weight, 0, data, 1, USB_CTRL_SET_TIMEOUT);
227		189
228	if (len != 1) {	190	*result = (int)data;
229	kfree(data);
230	return -EIO;
231	}
232	result = (int)data;
233	kfree(data);
234	return 0;	191	return 0;
235	}	192	}
236		193
237	/*	194	/*
238	* Reads firmware_version of mouse and stores it in @result	195	* Reads firmware_version of mouse and stores it in @result
239	* On success returns 0	196	* On success returns 0
240	* On failure returns errno	197	* On failure returns errno
241	*/	198	*/
242	static int kone_get_firmware_version(struct usb_device usb_dev, int result)	199	static int kone_get_firmware_version(struct usb_device usb_dev, int result)
243	{	200	{
244	int len;	201	int retval;
245	unsigned char *data;	202	uint16_t data;
246		203
247	data = kmalloc(2, GFP_KERNEL);	204	retval = roccat_common_receive(usb_dev, kone_command_firmware_version,
248	if (!data)	205	&data, 2);
249	return -ENOMEM;	206	if (retval)
		207	return retval;
250		208
251	len = usb_control_msg(usb_dev, usb_rcvctrlpipe(usb_dev, 0),	209	*result = le16_to_cpu(data);
252	USB_REQ_CLEAR_FEATURE,
253	USB_TYPE_CLASS \| USB_RECIP_INTERFACE \| USB_DIR_IN,
254	kone_command_firmware_version, 0, data, 2,
255	USB_CTRL_SET_TIMEOUT);
256
257	if (len != 2) {
258	kfree(data);
259	return -EIO;
260	}
261	result = le16_to_cpu(data);
262	kfree(data);
263	return 0;	210	return 0;
264	}	211	}
265		212
266	static ssize_t kone_sysfs_read_settings(struct file fp, struct kobject kobj,	213	static ssize_t kone_sysfs_read_settings(struct file fp, struct kobject kobj,
267	struct bin_attribute attr, char buf,	214	struct bin_attribute attr, char buf,
268	loff_t off, size_t count) {	215	loff_t off, size_t count) {
269	struct device *dev =	216	struct device *dev =
270	container_of(kobj, struct device, kobj)->parent->parent;	217	container_of(kobj, struct device, kobj)->parent->parent;
271	struct kone_device *kone = hid_get_drvdata(dev_get_drvdata(dev));	218	struct kone_device *kone = hid_get_drvdata(dev_get_drvdata(dev));
272		219
273	if (off >= sizeof(struct kone_settings))	220	if (off >= sizeof(struct kone_settings))
274	return 0;	221	return 0;
275		222
276	if (off + count > sizeof(struct kone_settings))	223	if (off + count > sizeof(struct kone_settings))
277	count = sizeof(struct kone_settings) - off;	224	count = sizeof(struct kone_settings) - off;
278		225
279	mutex_lock(&kone->kone_lock);	226	mutex_lock(&kone->kone_lock);
280	memcpy(buf, ((char const *)&kone->settings) + off, count);	227	memcpy(buf, ((char const *)&kone->settings) + off, count);
281	mutex_unlock(&kone->kone_lock);	228	mutex_unlock(&kone->kone_lock);
282		229
283	return count;	230	return count;
284	}	231	}
285		232
286	/*	233	/*
287	* Writing settings automatically activates startup_profile.	234	* Writing settings automatically activates startup_profile.
288	* This function keeps values in kone_device up to date and assumes that in	235	* This function keeps values in kone_device up to date and assumes that in
289	* case of error the old data is still valid	236	* case of error the old data is still valid
290	*/	237	*/
291	static ssize_t kone_sysfs_write_settings(struct file fp, struct kobject kobj,	238	static ssize_t kone_sysfs_write_settings(struct file fp, struct kobject kobj,
292	struct bin_attribute attr, char buf,	239	struct bin_attribute attr, char buf,
293	loff_t off, size_t count) {	240	loff_t off, size_t count) {
294	struct device *dev =	241	struct device *dev =
295	container_of(kobj, struct device, kobj)->parent->parent;	242	container_of(kobj, struct device, kobj)->parent->parent;
296	struct kone_device *kone = hid_get_drvdata(dev_get_drvdata(dev));	243	struct kone_device *kone = hid_get_drvdata(dev_get_drvdata(dev));
297	struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));	244	struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));
298	int retval = 0, difference;	245	int retval = 0, difference;
299		246
300	/* I need to get my data in one piece */	247	/* I need to get my data in one piece */
301	if (off != 0 \|\| count != sizeof(struct kone_settings))	248	if (off != 0 \|\| count != sizeof(struct kone_settings))
302	return -EINVAL;	249	return -EINVAL;
303		250
304	mutex_lock(&kone->kone_lock);	251	mutex_lock(&kone->kone_lock);
305	difference = memcmp(buf, &kone->settings, sizeof(struct kone_settings));	252	difference = memcmp(buf, &kone->settings, sizeof(struct kone_settings));
306	if (difference) {	253	if (difference) {
307	retval = kone_set_settings(usb_dev,	254	retval = kone_set_settings(usb_dev,
308	(struct kone_settings const *)buf);	255	(struct kone_settings const *)buf);
309	if (!retval)	256	if (!retval)
310	memcpy(&kone->settings, buf,	257	memcpy(&kone->settings, buf,
311	sizeof(struct kone_settings));	258	sizeof(struct kone_settings));
312	}	259	}
313	mutex_unlock(&kone->kone_lock);	260	mutex_unlock(&kone->kone_lock);
314		261
315	if (retval)	262	if (retval)
316	return retval;	263	return retval;
317		264
318	/*	265	/*
319	* If we get here, treat settings as okay and update actual values	266	* If we get here, treat settings as okay and update actual values
320	* according to startup_profile	267	* according to startup_profile
321	*/	268	*/
322	kone->actual_profile = kone->settings.startup_profile;	269	kone->actual_profile = kone->settings.startup_profile;
323	kone->actual_dpi = kone->profiles[kone->actual_profile - 1].startup_dpi;	270	kone->actual_dpi = kone->profiles[kone->actual_profile - 1].startup_dpi;
324		271
325	return sizeof(struct kone_settings);	272	return sizeof(struct kone_settings);
326	}	273	}
327		274
328	static ssize_t kone_sysfs_read_profilex(struct file *fp,	275	static ssize_t kone_sysfs_read_profilex(struct file *fp,
329	struct kobject kobj, struct bin_attribute attr,	276	struct kobject kobj, struct bin_attribute attr,
330	char *buf, loff_t off, size_t count) {	277	char *buf, loff_t off, size_t count) {
331	struct device *dev =	278	struct device *dev =
332	container_of(kobj, struct device, kobj)->parent->parent;	279	container_of(kobj, struct device, kobj)->parent->parent;
333	struct kone_device *kone = hid_get_drvdata(dev_get_drvdata(dev));	280	struct kone_device *kone = hid_get_drvdata(dev_get_drvdata(dev));
334		281
335	if (off >= sizeof(struct kone_profile))	282	if (off >= sizeof(struct kone_profile))
336	return 0;	283	return 0;
337		284
338	if (off + count > sizeof(struct kone_profile))	285	if (off + count > sizeof(struct kone_profile))
339	count = sizeof(struct kone_profile) - off;	286	count = sizeof(struct kone_profile) - off;
340		287
341	mutex_lock(&kone->kone_lock);	288	mutex_lock(&kone->kone_lock);
342	memcpy(buf, ((char const )&kone->profiles[(uint *)(attr->private)]) + off, count);	289	memcpy(buf, ((char const )&kone->profiles[(uint *)(attr->private)]) + off, count);
343	mutex_unlock(&kone->kone_lock);	290	mutex_unlock(&kone->kone_lock);
344		291
345	return count;	292	return count;
346	}	293	}
347		294
348	/* Writes data only if different to stored data */	295	/* Writes data only if different to stored data */
349	static ssize_t kone_sysfs_write_profilex(struct file *fp,	296	static ssize_t kone_sysfs_write_profilex(struct file *fp,
350	struct kobject kobj, struct bin_attribute attr,	297	struct kobject kobj, struct bin_attribute attr,
351	char *buf, loff_t off, size_t count) {	298	char *buf, loff_t off, size_t count) {
352	struct device *dev =	299	struct device *dev =
353	container_of(kobj, struct device, kobj)->parent->parent;	300	container_of(kobj, struct device, kobj)->parent->parent;
354	struct kone_device *kone = hid_get_drvdata(dev_get_drvdata(dev));	301	struct kone_device *kone = hid_get_drvdata(dev_get_drvdata(dev));
355	struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));	302	struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));
356	struct kone_profile *profile;	303	struct kone_profile *profile;
357	int retval = 0, difference;	304	int retval = 0, difference;
358		305
359	/* I need to get my data in one piece */	306	/* I need to get my data in one piece */
360	if (off != 0 \|\| count != sizeof(struct kone_profile))	307	if (off != 0 \|\| count != sizeof(struct kone_profile))
361	return -EINVAL;	308	return -EINVAL;
362		309
363	profile = &kone->profiles[(uint )(attr->private)];	310	profile = &kone->profiles[(uint )(attr->private)];
364		311
365	mutex_lock(&kone->kone_lock);	312	mutex_lock(&kone->kone_lock);
366	difference = memcmp(buf, profile, sizeof(struct kone_profile));	313	difference = memcmp(buf, profile, sizeof(struct kone_profile));
367	if (difference) {	314	if (difference) {
368	retval = kone_set_profile(usb_dev,	315	retval = kone_set_profile(usb_dev,
369	(struct kone_profile const *)buf,	316	(struct kone_profile const *)buf,
370	(uint )(attr->private) + 1);	317	(uint )(attr->private) + 1);
371	if (!retval)	318	if (!retval)
372	memcpy(profile, buf, sizeof(struct kone_profile));	319	memcpy(profile, buf, sizeof(struct kone_profile));
373	}	320	}
374	mutex_unlock(&kone->kone_lock);	321	mutex_unlock(&kone->kone_lock);
375		322
376	if (retval)	323	if (retval)
377	return retval;	324	return retval;
378		325
379	return sizeof(struct kone_profile);	326	return sizeof(struct kone_profile);
380	}	327	}
381		328
382	static ssize_t kone_sysfs_show_actual_profile(struct device *dev,	329	static ssize_t kone_sysfs_show_actual_profile(struct device *dev,
383	struct device_attribute attr, char buf)	330	struct device_attribute attr, char buf)
384	{	331	{
385	struct kone_device *kone =	332	struct kone_device *kone =
386	hid_get_drvdata(dev_get_drvdata(dev->parent->parent));	333	hid_get_drvdata(dev_get_drvdata(dev->parent->parent));
387	return snprintf(buf, PAGE_SIZE, "%d\n", kone->actual_profile);	334	return snprintf(buf, PAGE_SIZE, "%d\n", kone->actual_profile);
388	}	335	}
389		336
390	static ssize_t kone_sysfs_show_actual_dpi(struct device *dev,	337	static ssize_t kone_sysfs_show_actual_dpi(struct device *dev,
391	struct device_attribute attr, char buf)	338	struct device_attribute attr, char buf)
392	{	339	{
393	struct kone_device *kone =	340	struct kone_device *kone =
394	hid_get_drvdata(dev_get_drvdata(dev->parent->parent));	341	hid_get_drvdata(dev_get_drvdata(dev->parent->parent));
395	return snprintf(buf, PAGE_SIZE, "%d\n", kone->actual_dpi);	342	return snprintf(buf, PAGE_SIZE, "%d\n", kone->actual_dpi);
396	}	343	}
397		344
398	/* weight is read each time, since we don't get informed when it's changed */	345	/* weight is read each time, since we don't get informed when it's changed */
399	static ssize_t kone_sysfs_show_weight(struct device *dev,	346	static ssize_t kone_sysfs_show_weight(struct device *dev,
400	struct device_attribute attr, char buf)	347	struct device_attribute attr, char buf)
401	{	348	{
402	struct kone_device *kone;	349	struct kone_device *kone;
403	struct usb_device *usb_dev;	350	struct usb_device *usb_dev;
404	int weight = 0;	351	int weight = 0;
405	int retval;	352	int retval;
406		353
407	dev = dev->parent->parent;	354	dev = dev->parent->parent;
408	kone = hid_get_drvdata(dev_get_drvdata(dev));	355	kone = hid_get_drvdata(dev_get_drvdata(dev));
409	usb_dev = interface_to_usbdev(to_usb_interface(dev));	356	usb_dev = interface_to_usbdev(to_usb_interface(dev));
410		357
411	mutex_lock(&kone->kone_lock);	358	mutex_lock(&kone->kone_lock);
412	retval = kone_get_weight(usb_dev, &weight);	359	retval = kone_get_weight(usb_dev, &weight);
413	mutex_unlock(&kone->kone_lock);	360	mutex_unlock(&kone->kone_lock);
414		361
415	if (retval)	362	if (retval)
416	return retval;	363	return retval;
417	return snprintf(buf, PAGE_SIZE, "%d\n", weight);	364	return snprintf(buf, PAGE_SIZE, "%d\n", weight);
418	}	365	}
419		366
420	static ssize_t kone_sysfs_show_firmware_version(struct device *dev,	367	static ssize_t kone_sysfs_show_firmware_version(struct device *dev,
421	struct device_attribute attr, char buf)	368	struct device_attribute attr, char buf)
422	{	369	{
423	struct kone_device *kone =	370	struct kone_device *kone =
424	hid_get_drvdata(dev_get_drvdata(dev->parent->parent));	371	hid_get_drvdata(dev_get_drvdata(dev->parent->parent));
425	return snprintf(buf, PAGE_SIZE, "%d\n", kone->firmware_version);	372	return snprintf(buf, PAGE_SIZE, "%d\n", kone->firmware_version);
426	}	373	}
427		374
428	static ssize_t kone_sysfs_show_tcu(struct device *dev,	375	static ssize_t kone_sysfs_show_tcu(struct device *dev,
429	struct device_attribute attr, char buf)	376	struct device_attribute attr, char buf)
430	{	377	{
431	struct kone_device *kone =	378	struct kone_device *kone =
432	hid_get_drvdata(dev_get_drvdata(dev->parent->parent));	379	hid_get_drvdata(dev_get_drvdata(dev->parent->parent));
433	return snprintf(buf, PAGE_SIZE, "%d\n", kone->settings.tcu);	380	return snprintf(buf, PAGE_SIZE, "%d\n", kone->settings.tcu);
434	}	381	}
435		382
436	static int kone_tcu_command(struct usb_device *usb_dev, int number)	383	static int kone_tcu_command(struct usb_device *usb_dev, int number)
437	{	384	{
438	int len;	385	unsigned char value;
439	char *value;	386	value = number;
440		387	return roccat_common_send(usb_dev, kone_command_calibrate, &value, 1);
441	value = kmalloc(1, GFP_KERNEL);
442	if (!value)
443	return -ENOMEM;
444
445	*value = number;
446
447	len = usb_control_msg(usb_dev, usb_sndctrlpipe(usb_dev, 0),
448	USB_REQ_SET_CONFIGURATION,
449	USB_TYPE_CLASS \| USB_RECIP_INTERFACE \| USB_DIR_OUT,
450	kone_command_calibrate, 0, value, 1,
451	USB_CTRL_SET_TIMEOUT);
452
453	kfree(value);
454	return ((len != 1) ? -EIO : 0);
455	}	388	}
456		389
457	/*	390	/*
458	* Calibrating the tcu is the only action that changes settings data inside the	391	* Calibrating the tcu is the only action that changes settings data inside the
459	* mouse, so this data needs to be reread	392	* mouse, so this data needs to be reread
460	*/	393	*/
461	static ssize_t kone_sysfs_set_tcu(struct device *dev,	394	static ssize_t kone_sysfs_set_tcu(struct device *dev,
462	struct device_attribute attr, char const buf, size_t size)	395	struct device_attribute attr, char const buf, size_t size)
463	{	396	{
464	struct kone_device *kone;	397	struct kone_device *kone;
465	struct usb_device *usb_dev;	398	struct usb_device *usb_dev;
466	int retval;	399	int retval;
467	unsigned long state;	400	unsigned long state;
468		401
469	dev = dev->parent->parent;	402	dev = dev->parent->parent;
470	kone = hid_get_drvdata(dev_get_drvdata(dev));	403	kone = hid_get_drvdata(dev_get_drvdata(dev));
471	usb_dev = interface_to_usbdev(to_usb_interface(dev));	404	usb_dev = interface_to_usbdev(to_usb_interface(dev));
472		405
473	retval = strict_strtoul(buf, 10, &state);	406	retval = strict_strtoul(buf, 10, &state);
474	if (retval)	407	if (retval)
475	return retval;	408	return retval;
476		409
477	if (state != 0 && state != 1)	410	if (state != 0 && state != 1)
478	return -EINVAL;	411	return -EINVAL;
479		412
480	mutex_lock(&kone->kone_lock);	413	mutex_lock(&kone->kone_lock);
481		414
482	if (state == 1) { /* state activate */	415	if (state == 1) { /* state activate */
483	retval = kone_tcu_command(usb_dev, 1);	416	retval = kone_tcu_command(usb_dev, 1);
484	if (retval)	417	if (retval)
485	goto exit_unlock;	418	goto exit_unlock;
486	retval = kone_tcu_command(usb_dev, 2);	419	retval = kone_tcu_command(usb_dev, 2);
487	if (retval)	420	if (retval)
488	goto exit_unlock;	421	goto exit_unlock;
489	ssleep(5); /* tcu needs this time for calibration */	422	ssleep(5); /* tcu needs this time for calibration */
490	retval = kone_tcu_command(usb_dev, 3);	423	retval = kone_tcu_command(usb_dev, 3);
491	if (retval)	424	if (retval)
492	goto exit_unlock;	425	goto exit_unlock;
493	retval = kone_tcu_command(usb_dev, 0);	426	retval = kone_tcu_command(usb_dev, 0);
494	if (retval)	427	if (retval)
495	goto exit_unlock;	428	goto exit_unlock;
496	retval = kone_tcu_command(usb_dev, 4);	429	retval = kone_tcu_command(usb_dev, 4);
497	if (retval)	430	if (retval)
498	goto exit_unlock;	431	goto exit_unlock;
499	/*	432	/*
500	* Kone needs this time to settle things.	433	* Kone needs this time to settle things.
501	* Reading settings too early will result in invalid data.	434	* Reading settings too early will result in invalid data.
502	* Roccat's driver waits 1 sec, maybe this time could be	435	* Roccat's driver waits 1 sec, maybe this time could be
503	* shortened.	436	* shortened.
504	*/	437	*/
505	ssleep(1);	438	ssleep(1);
506	}	439	}
507		440
508	/* calibration changes values in settings, so reread */	441	/* calibration changes values in settings, so reread */
509	retval = kone_get_settings(usb_dev, &kone->settings);	442	retval = kone_get_settings(usb_dev, &kone->settings);
510	if (retval)	443	if (retval)
511	goto exit_no_settings;	444	goto exit_no_settings;
512		445
513	/* only write settings back if activation state is different */	446	/* only write settings back if activation state is different */
514	if (kone->settings.tcu != state) {	447	if (kone->settings.tcu != state) {
515	kone->settings.tcu = state;	448	kone->settings.tcu = state;
516	kone_set_settings_checksum(&kone->settings);	449	kone_set_settings_checksum(&kone->settings);
517		450
518	retval = kone_set_settings(usb_dev, &kone->settings);	451	retval = kone_set_settings(usb_dev, &kone->settings);
519	if (retval) {	452	if (retval) {
520	hid_err(usb_dev, "couldn't set tcu state\n");	453	hid_err(usb_dev, "couldn't set tcu state\n");
521	/*	454	/*
522	* try to reread valid settings into buffer overwriting	455	* try to reread valid settings into buffer overwriting
523	* first error code	456	* first error code
524	*/	457	*/
525	retval = kone_get_settings(usb_dev, &kone->settings);	458	retval = kone_get_settings(usb_dev, &kone->settings);
526	if (retval)	459	if (retval)
527	goto exit_no_settings;	460	goto exit_no_settings;
528	goto exit_unlock;	461	goto exit_unlock;
529	}	462	}
530	}	463	}
531		464
532	retval = size;	465	retval = size;
533	exit_no_settings:	466	exit_no_settings:
534	hid_err(usb_dev, "couldn't read settings\n");	467	hid_err(usb_dev, "couldn't read settings\n");
535	exit_unlock:	468	exit_unlock:
536	mutex_unlock(&kone->kone_lock);	469	mutex_unlock(&kone->kone_lock);
537	return retval;	470	return retval;
538	}	471	}
539		472
540	static ssize_t kone_sysfs_show_startup_profile(struct device *dev,	473	static ssize_t kone_sysfs_show_startup_profile(struct device *dev,
541	struct device_attribute attr, char buf)	474	struct device_attribute attr, char buf)
542	{	475	{
543	struct kone_device *kone =	476	struct kone_device *kone =
544	hid_get_drvdata(dev_get_drvdata(dev->parent->parent));	477	hid_get_drvdata(dev_get_drvdata(dev->parent->parent));
545	return snprintf(buf, PAGE_SIZE, "%d\n", kone->settings.startup_profile);	478	return snprintf(buf, PAGE_SIZE, "%d\n", kone->settings.startup_profile);
546	}	479	}
547		480
548	static ssize_t kone_sysfs_set_startup_profile(struct device *dev,	481	static ssize_t kone_sysfs_set_startup_profile(struct device *dev,
549	struct device_attribute attr, char const buf, size_t size)	482	struct device_attribute attr, char const buf, size_t size)
550	{	483	{
551	struct kone_device *kone;	484	struct kone_device *kone;
552	struct usb_device *usb_dev;	485	struct usb_device *usb_dev;
553	int retval;	486	int retval;
554	unsigned long new_startup_profile;	487	unsigned long new_startup_profile;
555		488
556	dev = dev->parent->parent;	489	dev = dev->parent->parent;
557	kone = hid_get_drvdata(dev_get_drvdata(dev));	490	kone = hid_get_drvdata(dev_get_drvdata(dev));
558	usb_dev = interface_to_usbdev(to_usb_interface(dev));	491	usb_dev = interface_to_usbdev(to_usb_interface(dev));
559		492
560	retval = strict_strtoul(buf, 10, &new_startup_profile);	493	retval = strict_strtoul(buf, 10, &new_startup_profile);
561	if (retval)	494	if (retval)
562	return retval;	495	return retval;
563		496
564	if (new_startup_profile < 1 \|\| new_startup_profile > 5)	497	if (new_startup_profile < 1 \|\| new_startup_profile > 5)
565	return -EINVAL;	498	return -EINVAL;
566		499
567	mutex_lock(&kone->kone_lock);	500	mutex_lock(&kone->kone_lock);
568		501
569	kone->settings.startup_profile = new_startup_profile;	502	kone->settings.startup_profile = new_startup_profile;
570	kone_set_settings_checksum(&kone->settings);	503	kone_set_settings_checksum(&kone->settings);
571		504
572	retval = kone_set_settings(usb_dev, &kone->settings);	505	retval = kone_set_settings(usb_dev, &kone->settings);
573		506
574	mutex_unlock(&kone->kone_lock);	507	mutex_unlock(&kone->kone_lock);
575		508
576	if (retval)	509	if (retval)
577	return retval;	510	return retval;
578		511
579	/* changing the startup profile immediately activates this profile */	512	/* changing the startup profile immediately activates this profile */
580	kone->actual_profile = new_startup_profile;	513	kone->actual_profile = new_startup_profile;
581	kone->actual_dpi = kone->profiles[kone->actual_profile - 1].startup_dpi;	514	kone->actual_dpi = kone->profiles[kone->actual_profile - 1].startup_dpi;
582		515
583	return size;	516	return size;
584	}	517	}
585		518
586	static struct device_attribute kone_attributes[] = {	519	static struct device_attribute kone_attributes[] = {
587	/*	520	/*
588	* Read actual dpi settings.	521	* Read actual dpi settings.
589	* Returns raw value for further processing. Refer to enum	522	* Returns raw value for further processing. Refer to enum
590	* kone_polling_rates to get real value.	523	* kone_polling_rates to get real value.
591	*/	524	*/
592	__ATTR(actual_dpi, 0440, kone_sysfs_show_actual_dpi, NULL),	525	__ATTR(actual_dpi, 0440, kone_sysfs_show_actual_dpi, NULL),
593	__ATTR(actual_profile, 0440, kone_sysfs_show_actual_profile, NULL),	526	__ATTR(actual_profile, 0440, kone_sysfs_show_actual_profile, NULL),
594		527
595	/*	528	/*
596	* The mouse can be equipped with one of four supplied weights from 5	529	* The mouse can be equipped with one of four supplied weights from 5
597	* to 20 grams which are recognized and its value can be read out.	530	* to 20 grams which are recognized and its value can be read out.
598	* This returns the raw value reported by the mouse for easy evaluation	531	* This returns the raw value reported by the mouse for easy evaluation
599	* by software. Refer to enum kone_weights to get corresponding real	532	* by software. Refer to enum kone_weights to get corresponding real
600	* weight.	533	* weight.
601	*/	534	*/
602	__ATTR(weight, 0440, kone_sysfs_show_weight, NULL),	535	__ATTR(weight, 0440, kone_sysfs_show_weight, NULL),
603		536
604	/*	537	/*
605	* Prints firmware version stored in mouse as integer.	538	* Prints firmware version stored in mouse as integer.
606	* The raw value reported by the mouse is returned for easy evaluation,	539	* The raw value reported by the mouse is returned for easy evaluation,
607	* to get the real version number the decimal point has to be shifted 2	540	* to get the real version number the decimal point has to be shifted 2
608	* positions to the left. E.g. a value of 138 means 1.38.	541	* positions to the left. E.g. a value of 138 means 1.38.
609	*/	542	*/
610	__ATTR(firmware_version, 0440,	543	__ATTR(firmware_version, 0440,
611	kone_sysfs_show_firmware_version, NULL),	544	kone_sysfs_show_firmware_version, NULL),
612		545
613	/*	546	/*
614	* Prints state of Tracking Control Unit as number where 0 = off and	547	* Prints state of Tracking Control Unit as number where 0 = off and
615	* 1 = on. Writing 0 deactivates tcu and writing 1 calibrates and	548	* 1 = on. Writing 0 deactivates tcu and writing 1 calibrates and
616	* activates the tcu	549	* activates the tcu
617	*/	550	*/
618	__ATTR(tcu, 0660, kone_sysfs_show_tcu, kone_sysfs_set_tcu),	551	__ATTR(tcu, 0660, kone_sysfs_show_tcu, kone_sysfs_set_tcu),
619		552
620	/* Prints and takes the number of the profile the mouse starts with */	553	/* Prints and takes the number of the profile the mouse starts with */
621	__ATTR(startup_profile, 0660,	554	__ATTR(startup_profile, 0660,
622	kone_sysfs_show_startup_profile,	555	kone_sysfs_show_startup_profile,
623	kone_sysfs_set_startup_profile),	556	kone_sysfs_set_startup_profile),
624	__ATTR_NULL	557	__ATTR_NULL
625	};	558	};
626		559
627	static struct bin_attribute kone_bin_attributes[] = {	560	static struct bin_attribute kone_bin_attributes[] = {
628	{	561	{
629	.attr = { .name = "settings", .mode = 0660 },	562	.attr = { .name = "settings", .mode = 0660 },
630	.size = sizeof(struct kone_settings),	563	.size = sizeof(struct kone_settings),
631	.read = kone_sysfs_read_settings,	564	.read = kone_sysfs_read_settings,
632	.write = kone_sysfs_write_settings	565	.write = kone_sysfs_write_settings
633	},	566	},
634	{	567	{
635	.attr = { .name = "profile1", .mode = 0660 },	568	.attr = { .name = "profile1", .mode = 0660 },
636	.size = sizeof(struct kone_profile),	569	.size = sizeof(struct kone_profile),
637	.read = kone_sysfs_read_profilex,	570	.read = kone_sysfs_read_profilex,
638	.write = kone_sysfs_write_profilex,	571	.write = kone_sysfs_write_profilex,
639	.private = &profile_numbers[0]	572	.private = &profile_numbers[0]
640	},	573	},
641	{	574	{
642	.attr = { .name = "profile2", .mode = 0660 },	575	.attr = { .name = "profile2", .mode = 0660 },
643	.size = sizeof(struct kone_profile),	576	.size = sizeof(struct kone_profile),
644	.read = kone_sysfs_read_profilex,	577	.read = kone_sysfs_read_profilex,
645	.write = kone_sysfs_write_profilex,	578	.write = kone_sysfs_write_profilex,
646	.private = &profile_numbers[1]	579	.private = &profile_numbers[1]
647	},	580	},
648	{	581	{
649	.attr = { .name = "profile3", .mode = 0660 },	582	.attr = { .name = "profile3", .mode = 0660 },
650	.size = sizeof(struct kone_profile),	583	.size = sizeof(struct kone_profile),
651	.read = kone_sysfs_read_profilex,	584	.read = kone_sysfs_read_profilex,
652	.write = kone_sysfs_write_profilex,	585	.write = kone_sysfs_write_profilex,
653	.private = &profile_numbers[2]	586	.private = &profile_numbers[2]
654	},	587	},
655	{	588	{
656	.attr = { .name = "profile4", .mode = 0660 },	589	.attr = { .name = "profile4", .mode = 0660 },
657	.size = sizeof(struct kone_profile),	590	.size = sizeof(struct kone_profile),
658	.read = kone_sysfs_read_profilex,	591	.read = kone_sysfs_read_profilex,
659	.write = kone_sysfs_write_profilex,	592	.write = kone_sysfs_write_profilex,
660	.private = &profile_numbers[3]	593	.private = &profile_numbers[3]
661	},	594	},
662	{	595	{
663	.attr = { .name = "profile5", .mode = 0660 },	596	.attr = { .name = "profile5", .mode = 0660 },
664	.size = sizeof(struct kone_profile),	597	.size = sizeof(struct kone_profile),
665	.read = kone_sysfs_read_profilex,	598	.read = kone_sysfs_read_profilex,
666	.write = kone_sysfs_write_profilex,	599	.write = kone_sysfs_write_profilex,
667	.private = &profile_numbers[4]	600	.private = &profile_numbers[4]
668	},	601	},
669	__ATTR_NULL	602	__ATTR_NULL
670	};	603	};
671		604
672	static int kone_init_kone_device_struct(struct usb_device *usb_dev,	605	static int kone_init_kone_device_struct(struct usb_device *usb_dev,
673	struct kone_device *kone)	606	struct kone_device *kone)
674	{	607	{
675	uint i;	608	uint i;
676	int retval;	609	int retval;
677		610
678	mutex_init(&kone->kone_lock);	611	mutex_init(&kone->kone_lock);
679		612
680	for (i = 0; i < 5; ++i) {	613	for (i = 0; i < 5; ++i) {
681	retval = kone_get_profile(usb_dev, &kone->profiles[i], i + 1);	614	retval = kone_get_profile(usb_dev, &kone->profiles[i], i + 1);
682	if (retval)	615	if (retval)
683	return retval;	616	return retval;
684	}	617	}
685		618
686	retval = kone_get_settings(usb_dev, &kone->settings);	619	retval = kone_get_settings(usb_dev, &kone->settings);
687	if (retval)	620	if (retval)
688	return retval;	621	return retval;
689		622
690	retval = kone_get_firmware_version(usb_dev, &kone->firmware_version);	623	retval = kone_get_firmware_version(usb_dev, &kone->firmware_version);
691	if (retval)	624	if (retval)
692	return retval;	625	return retval;
693		626
694	kone->actual_profile = kone->settings.startup_profile;	627	kone->actual_profile = kone->settings.startup_profile;
695	kone->actual_dpi = kone->profiles[kone->actual_profile].startup_dpi;	628	kone->actual_dpi = kone->profiles[kone->actual_profile].startup_dpi;
696		629
697	return 0;	630	return 0;
698	}	631	}
699		632
700	/*	633	/*
701	* Since IGNORE_MOUSE quirk moved to hid-apple, there is no way to bind only to	634	* Since IGNORE_MOUSE quirk moved to hid-apple, there is no way to bind only to
702	* mousepart if usb_hid is compiled into the kernel and kone is compiled as	635	* mousepart if usb_hid is compiled into the kernel and kone is compiled as
703	* module.	636	* module.
704	* Secial behaviour is bound only to mousepart since only mouseevents contain	637	* Secial behaviour is bound only to mousepart since only mouseevents contain
705	* additional notifications.	638	* additional notifications.
706	*/	639	*/
707	static int kone_init_specials(struct hid_device *hdev)	640	static int kone_init_specials(struct hid_device *hdev)
708	{	641	{
709	struct usb_interface *intf = to_usb_interface(hdev->dev.parent);	642	struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
710	struct usb_device *usb_dev = interface_to_usbdev(intf);	643	struct usb_device *usb_dev = interface_to_usbdev(intf);
711	struct kone_device *kone;	644	struct kone_device *kone;
712	int retval;	645	int retval;
713		646
714	if (intf->cur_altsetting->desc.bInterfaceProtocol	647	if (intf->cur_altsetting->desc.bInterfaceProtocol
715	== USB_INTERFACE_PROTOCOL_MOUSE) {	648	== USB_INTERFACE_PROTOCOL_MOUSE) {
716		649
717	kone = kzalloc(sizeof(*kone), GFP_KERNEL);	650	kone = kzalloc(sizeof(*kone), GFP_KERNEL);
718	if (!kone) {	651	if (!kone) {
719	hid_err(hdev, "can't alloc device descriptor\n");	652	hid_err(hdev, "can't alloc device descriptor\n");
720	return -ENOMEM;	653	return -ENOMEM;
721	}	654	}
722	hid_set_drvdata(hdev, kone);	655	hid_set_drvdata(hdev, kone);
723		656
724	retval = kone_init_kone_device_struct(usb_dev, kone);	657	retval = kone_init_kone_device_struct(usb_dev, kone);
725	if (retval) {	658	if (retval) {
726	hid_err(hdev, "couldn't init struct kone_device\n");	659	hid_err(hdev, "couldn't init struct kone_device\n");
727	goto exit_free;	660	goto exit_free;
728	}	661	}
729		662
730	retval = roccat_connect(kone_class, hdev);	663	retval = roccat_connect(kone_class, hdev);
731	if (retval < 0) {	664	if (retval < 0) {
732	hid_err(hdev, "couldn't init char dev\n");	665	hid_err(hdev, "couldn't init char dev\n");
733	/* be tolerant about not getting chrdev */	666	/* be tolerant about not getting chrdev */
734	} else {	667	} else {
735	kone->roccat_claimed = 1;	668	kone->roccat_claimed = 1;
736	kone->chrdev_minor = retval;	669	kone->chrdev_minor = retval;
737	}	670	}
738	} else {	671	} else {
739	hid_set_drvdata(hdev, NULL);	672	hid_set_drvdata(hdev, NULL);
740	}	673	}
741		674
742	return 0;	675	return 0;
743	exit_free:	676	exit_free:
744	kfree(kone);	677	kfree(kone);
745	return retval;	678	return retval;
746	}	679	}
747		680
748	static void kone_remove_specials(struct hid_device *hdev)	681	static void kone_remove_specials(struct hid_device *hdev)
749	{	682	{
750	struct usb_interface *intf = to_usb_interface(hdev->dev.parent);	683	struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
751	struct kone_device *kone;	684	struct kone_device *kone;
752		685
753	if (intf->cur_altsetting->desc.bInterfaceProtocol	686	if (intf->cur_altsetting->desc.bInterfaceProtocol
754	== USB_INTERFACE_PROTOCOL_MOUSE) {	687	== USB_INTERFACE_PROTOCOL_MOUSE) {
755	kone = hid_get_drvdata(hdev);	688	kone = hid_get_drvdata(hdev);
756	if (kone->roccat_claimed)	689	if (kone->roccat_claimed)
757	roccat_disconnect(kone->chrdev_minor);	690	roccat_disconnect(kone->chrdev_minor);
758	kfree(hid_get_drvdata(hdev));	691	kfree(hid_get_drvdata(hdev));
759	}	692	}
760	}	693	}
761		694
762	static int kone_probe(struct hid_device hdev, const struct hid_device_id id)	695	static int kone_probe(struct hid_device hdev, const struct hid_device_id id)
763	{	696	{
764	int retval;	697	int retval;
765		698
766	retval = hid_parse(hdev);	699	retval = hid_parse(hdev);
767	if (retval) {	700	if (retval) {
768	hid_err(hdev, "parse failed\n");	701	hid_err(hdev, "parse failed\n");
769	goto exit;	702	goto exit;
770	}	703	}
771		704
772	retval = hid_hw_start(hdev, HID_CONNECT_DEFAULT);	705	retval = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
773	if (retval) {	706	if (retval) {
774	hid_err(hdev, "hw start failed\n");	707	hid_err(hdev, "hw start failed\n");
775	goto exit;	708	goto exit;
776	}	709	}
777		710
778	retval = kone_init_specials(hdev);	711	retval = kone_init_specials(hdev);
779	if (retval) {	712	if (retval) {
780	hid_err(hdev, "couldn't install mouse\n");	713	hid_err(hdev, "couldn't install mouse\n");
781	goto exit_stop;	714	goto exit_stop;
782	}	715	}
783		716
784	return 0;	717	return 0;
785		718
786	exit_stop:	719	exit_stop:
787	hid_hw_stop(hdev);	720	hid_hw_stop(hdev);
788	exit:	721	exit:
789	return retval;	722	return retval;
790	}	723	}
791		724
792	static void kone_remove(struct hid_device *hdev)	725	static void kone_remove(struct hid_device *hdev)
793	{	726	{
794	kone_remove_specials(hdev);	727	kone_remove_specials(hdev);
795	hid_hw_stop(hdev);	728	hid_hw_stop(hdev);
796	}	729	}
797		730
798	/* handle special events and keep actual profile and dpi values up to date */	731	/* handle special events and keep actual profile and dpi values up to date */
799	static void kone_keep_values_up_to_date(struct kone_device *kone,	732	static void kone_keep_values_up_to_date(struct kone_device *kone,
800	struct kone_mouse_event const *event)	733	struct kone_mouse_event const *event)
801	{	734	{
802	switch (event->event) {	735	switch (event->event) {
803	case kone_mouse_event_switch_profile:	736	case kone_mouse_event_switch_profile:
804	case kone_mouse_event_osd_profile:	737	case kone_mouse_event_osd_profile:
805	kone->actual_profile = event->value;	738	kone->actual_profile = event->value;
806	kone->actual_dpi = kone->profiles[kone->actual_profile - 1].	739	kone->actual_dpi = kone->profiles[kone->actual_profile - 1].
807	startup_dpi;	740	startup_dpi;
808	break;	741	break;
809	case kone_mouse_event_switch_dpi:	742	case kone_mouse_event_switch_dpi:
810	case kone_mouse_event_osd_dpi:	743	case kone_mouse_event_osd_dpi:
811	kone->actual_dpi = event->value;	744	kone->actual_dpi = event->value;
812	break;	745	break;
813	}	746	}
814	}	747	}
815		748
816	static void kone_report_to_chrdev(struct kone_device const *kone,	749	static void kone_report_to_chrdev(struct kone_device const *kone,
817	struct kone_mouse_event const *event)	750	struct kone_mouse_event const *event)
818	{	751	{
819	struct kone_roccat_report roccat_report;	752	struct kone_roccat_report roccat_report;
820		753
821	switch (event->event) {	754	switch (event->event) {
822	case kone_mouse_event_switch_profile:	755	case kone_mouse_event_switch_profile:
823	case kone_mouse_event_switch_dpi:	756	case kone_mouse_event_switch_dpi:
824	case kone_mouse_event_osd_profile:	757	case kone_mouse_event_osd_profile:
825	case kone_mouse_event_osd_dpi:	758	case kone_mouse_event_osd_dpi:
826	roccat_report.event = event->event;	759	roccat_report.event = event->event;
827	roccat_report.value = event->value;	760	roccat_report.value = event->value;
828	roccat_report.key = 0;	761	roccat_report.key = 0;
829	roccat_report_event(kone->chrdev_minor,	762	roccat_report_event(kone->chrdev_minor,
830	(uint8_t *)&roccat_report,	763	(uint8_t *)&roccat_report,
831	sizeof(struct kone_roccat_report));	764	sizeof(struct kone_roccat_report));
832	break;	765	break;
833	case kone_mouse_event_call_overlong_macro:	766	case kone_mouse_event_call_overlong_macro:
834	if (event->value == kone_keystroke_action_press) {	767	if (event->value == kone_keystroke_action_press) {
835	roccat_report.event = kone_mouse_event_call_overlong_macro;	768	roccat_report.event = kone_mouse_event_call_overlong_macro;
836	roccat_report.value = kone->actual_profile;	769	roccat_report.value = kone->actual_profile;
837	roccat_report.key = event->macro_key;	770	roccat_report.key = event->macro_key;
838	roccat_report_event(kone->chrdev_minor,	771	roccat_report_event(kone->chrdev_minor,
839	(uint8_t *)&roccat_report,	772	(uint8_t *)&roccat_report,
840	sizeof(struct kone_roccat_report));	773	sizeof(struct kone_roccat_report));
841	}	774	}
842	break;	775	break;
843	}	776	}
844		777
845	}	778	}
846		779
847	/*	780	/*
848	* Is called for keyboard- and mousepart.	781	* Is called for keyboard- and mousepart.
849	* Only mousepart gets informations about special events in its extended event	782	* Only mousepart gets informations about special events in its extended event
850	* structure.	783	* structure.
851	*/	784	*/
852	static int kone_raw_event(struct hid_device hdev, struct hid_report report,	785	static int kone_raw_event(struct hid_device hdev, struct hid_report report,
853	u8 *data, int size)	786	u8 *data, int size)
854	{	787	{
855	struct kone_device *kone = hid_get_drvdata(hdev);	788	struct kone_device *kone = hid_get_drvdata(hdev);
856	struct kone_mouse_event event = (struct kone_mouse_event )data;	789	struct kone_mouse_event event = (struct kone_mouse_event )data;
857		790
858	/* keyboard events are always processed by default handler */	791	/* keyboard events are always processed by default handler */
859	if (size != sizeof(struct kone_mouse_event))	792	if (size != sizeof(struct kone_mouse_event))
860	return 0;	793	return 0;
861		794
862	/*	795	/*
863	* Firmware 1.38 introduced new behaviour for tilt and special buttons.	796	* Firmware 1.38 introduced new behaviour for tilt and special buttons.
864	* Pressed button is reported in each movement event.	797	* Pressed button is reported in each movement event.
865	* Workaround sends only one event per press.	798	* Workaround sends only one event per press.
866	*/	799	*/
867	if (memcmp(&kone->last_mouse_event.tilt, &event->tilt, 5))	800	if (memcmp(&kone->last_mouse_event.tilt, &event->tilt, 5))
868	memcpy(&kone->last_mouse_event, event,	801	memcpy(&kone->last_mouse_event, event,
869	sizeof(struct kone_mouse_event));	802	sizeof(struct kone_mouse_event));
870	else	803	else
871	memset(&event->tilt, 0, 5);	804	memset(&event->tilt, 0, 5);
872		805
873	kone_keep_values_up_to_date(kone, event);	806	kone_keep_values_up_to_date(kone, event);
874		807
875	if (kone->roccat_claimed)	808	if (kone->roccat_claimed)
876	kone_report_to_chrdev(kone, event);	809	kone_report_to_chrdev(kone, event);
877		810
878	return 0; /* always do further processing */	811	return 0; /* always do further processing */
879	}	812	}
880		813
881	static const struct hid_device_id kone_devices[] = {	814	static const struct hid_device_id kone_devices[] = {
882	{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_KONE) },	815	{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_KONE) },
883	{ }	816	{ }
884	};	817	};
885		818
886	MODULE_DEVICE_TABLE(hid, kone_devices);	819	MODULE_DEVICE_TABLE(hid, kone_devices);
887		820
888	static struct hid_driver kone_driver = {	821	static struct hid_driver kone_driver = {
889	.name = "kone",	822	.name = "kone",
890	.id_table = kone_devices,	823	.id_table = kone_devices,
891	.probe = kone_probe,	824	.probe = kone_probe,
892	.remove = kone_remove,	825	.remove = kone_remove,
893	.raw_event = kone_raw_event	826	.raw_event = kone_raw_event
894	};	827	};
895		828
896	static int __init kone_init(void)	829	static int __init kone_init(void)
897	{	830	{
898	int retval;	831	int retval;
899		832
900	/* class name has to be same as driver name */	833	/* class name has to be same as driver name */
901	kone_class = class_create(THIS_MODULE, "kone");	834	kone_class = class_create(THIS_MODULE, "kone");
902	if (IS_ERR(kone_class))	835	if (IS_ERR(kone_class))
903	return PTR_ERR(kone_class);	836	return PTR_ERR(kone_class);
904	kone_class->dev_attrs = kone_attributes;	837	kone_class->dev_attrs = kone_attributes;
905	kone_class->dev_bin_attrs = kone_bin_attributes;	838	kone_class->dev_bin_attrs = kone_bin_attributes;
906		839
907	retval = hid_register_driver(&kone_driver);	840	retval = hid_register_driver(&kone_driver);
908	if (retval)	841	if (retval)
909	class_destroy(kone_class);	842	class_destroy(kone_class);
910	return retval;	843	return retval;
911	}	844	}
912		845
913	static void __exit kone_exit(void)	846	static void __exit kone_exit(void)
914	{	847	{
915	class_destroy(kone_class);	848	class_destroy(kone_class);
916	hid_unregister_driver(&kone_driver);	849	hid_unregister_driver(&kone_driver);
917	}	850	}
918		851
919	module_init(kone_init);	852	module_init(kone_init);
920	module_exit(kone_exit);	853	module_exit(kone_exit);
921		854
922	MODULE_AUTHOR("Stefan Achatz");	855	MODULE_AUTHOR("Stefan Achatz");
923	MODULE_DESCRIPTION("USB Roccat Kone driver");	856	MODULE_DESCRIPTION("USB Roccat Kone driver");

drivers/hid/hid-roccat-koneplus.c

Diff comments View file @ 5772f63

 /*
  * Roccat Kone[+] driver for Linux
  *
  * Copyright (c) 2010 Stefan Achatz <erazor_de@users.sourceforge.net>
  */
 /*
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by the Free
  * Software Foundation; either version 2 of the License, or (at your option)
  * any later version.
  */
 /*
  * Roccat Kone[+] is an updated/improved version of the Kone with more memory
  * and functionality and without the non-standard behaviours the Kone had.
  */
 #include <linux/device.h>
 #include <linux/input.h>
 #include <linux/hid.h>
-#include <linux/usb.h>
 #include <linux/module.h>
 #include <linux/slab.h>
 #include "hid-ids.h"
 #include "hid-roccat.h"
+#include "hid-roccat-common.h"
 #include "hid-roccat-koneplus.h"
 static uint profile_numbers[5] = {0, 1, 2, 3, 4};
 static struct class *koneplus_class;
 static void koneplus_profile_activated(struct koneplus_device *koneplus,
 		uint new_profile)
 {
 	koneplus->actual_profile = new_profile;
 }
 static int koneplus_send_control(struct usb_device *usb_dev, uint value,
 		enum koneplus_control_requests request)
 {
-	int len;
+	struct koneplus_control control;
-	struct koneplus_control *control;
 	if ((request == KONEPLUS_CONTROL_REQUEST_PROFILE_SETTINGS ||
 			request == KONEPLUS_CONTROL_REQUEST_PROFILE_BUTTONS) &&
 			value > 4)
 		return -EINVAL;
-	control = kmalloc(sizeof(struct koneplus_control), GFP_KERNEL);
+	control.command = KONEPLUS_COMMAND_CONTROL;
-	if (!control)
+	control.value = value;
-		return -ENOMEM;
+	control.request = request;
-	control->command = KONEPLUS_COMMAND_CONTROL;
+	return roccat_common_send(usb_dev, KONEPLUS_USB_COMMAND_CONTROL,
-	control->value = value;
+			&control, sizeof(struct koneplus_control));
-	control->request = request;
-	len = usb_control_msg(usb_dev, usb_sndctrlpipe(usb_dev, 0),
-			USB_REQ_SET_CONFIGURATION,
-			USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_OUT,
-			KONEPLUS_USB_COMMAND_CONTROL, 0, control,
-			sizeof(struct koneplus_control),
-			USB_CTRL_SET_TIMEOUT);
-	kfree(control);
-	if (len != sizeof(struct koneplus_control))
-		return len;
-	return 0;
 }
-static int koneplus_receive(struct usb_device *usb_dev, uint usb_command,
-		void *buf, uint size) {
-	int len;
-	len = usb_control_msg(usb_dev, usb_rcvctrlpipe(usb_dev, 0),
-			USB_REQ_CLEAR_FEATURE,
-			USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN,
-			usb_command, 0, buf, size, USB_CTRL_SET_TIMEOUT);
-	return (len != size) ? -EIO : 0;
-}
 static int koneplus_receive_control_status(struct usb_device *usb_dev)
 {
 	int retval;
-	struct koneplus_control *control;
+	struct koneplus_control control;
-	control = kmalloc(sizeof(struct koneplus_control), GFP_KERNEL);
-	if (!control)
-		return -ENOMEM;
 	do {
-		retval = koneplus_receive(usb_dev, KONEPLUS_USB_COMMAND_CONTROL,
+		retval = roccat_common_receive(usb_dev, KONEPLUS_USB_COMMAND_CONTROL,
-				control, sizeof(struct koneplus_control));
+				&control, sizeof(struct koneplus_control));
 		/* check if we get a completely wrong answer */
 		if (retval)
-			goto out;
+			return retval;
-		if (control->value == KONEPLUS_CONTROL_REQUEST_STATUS_OK) {
+		if (control.value == KONEPLUS_CONTROL_REQUEST_STATUS_OK)
-			retval = 0;
+			return 0;
-			goto out;
-		}
 		/* indicates that hardware needs some more time to complete action */
-		if (control->value == KONEPLUS_CONTROL_REQUEST_STATUS_WAIT) {
+		if (control.value == KONEPLUS_CONTROL_REQUEST_STATUS_WAIT) {
 			msleep(500); /* windows driver uses 1000 */
 			continue;
 		}
 		/* seems to be critical - replug necessary */
-		if (control->value == KONEPLUS_CONTROL_REQUEST_STATUS_OVERLOAD) {
+		if (control.value == KONEPLUS_CONTROL_REQUEST_STATUS_OVERLOAD)
-			retval = -EINVAL;
+			return -EINVAL;
-			goto out;
-		}
 		hid_err(usb_dev, "koneplus_receive_control_status: "
-				"unknown response value 0x%x\n", control->value);
+				"unknown response value 0x%x\n", control.value);
-		retval = -EINVAL;
+		return -EINVAL;
-		goto out;
 	} while (1);
-out:
-	kfree(control);
-	return retval;
 }
 static int koneplus_send(struct usb_device *usb_dev, uint command,
-		void *buf, uint size) {
+		void const *buf, uint size)
-	int len;
+{
+	int retval;
-	len = usb_control_msg(usb_dev, usb_sndctrlpipe(usb_dev, 0),
+	retval = roccat_common_send(usb_dev, command, buf, size);
-			USB_REQ_SET_CONFIGURATION,
+	if (retval)
-			USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_OUT,
+		return retval;
-			command, 0, buf, size, USB_CTRL_SET_TIMEOUT);
-	if (len != size)
+	return koneplus_receive_control_status(usb_dev);
-		return -EIO;
-	if (koneplus_receive_control_status(usb_dev))
-		return -EIO;
-	return 0;
 }
 static int koneplus_select_profile(struct usb_device *usb_dev, uint number,
 		enum koneplus_control_requests request)
 {
 	int retval;
 	retval = koneplus_send_control(usb_dev, number, request);
 	if (retval)
 		return retval;
 	/* allow time to settle things - windows driver uses 500 */
 	msleep(100);
 	retval = koneplus_receive_control_status(usb_dev);
 	if (retval)
 		return retval;
 	return 0;
 }
 static int koneplus_get_info(struct usb_device *usb_dev,
 		struct koneplus_info *buf)
 {
-	return koneplus_receive(usb_dev, KONEPLUS_USB_COMMAND_INFO,
+	return roccat_common_receive(usb_dev, KONEPLUS_USB_COMMAND_INFO,
 			buf, sizeof(struct koneplus_info));
 }
 static int koneplus_get_profile_settings(struct usb_device *usb_dev,
 		struct koneplus_profile_settings *buf, uint number)
 {
 	int retval;
 	retval = koneplus_select_profile(usb_dev, number,
 			KONEPLUS_CONTROL_REQUEST_PROFILE_SETTINGS);
 	if (retval)
 		return retval;
-	return koneplus_receive(usb_dev, KONEPLUS_USB_COMMAND_PROFILE_SETTINGS,
+	return roccat_common_receive(usb_dev, KONEPLUS_USB_COMMAND_PROFILE_SETTINGS,
 			buf, sizeof(struct koneplus_profile_settings));
 }
 static int koneplus_set_profile_settings(struct usb_device *usb_dev,
 		struct koneplus_profile_settings const *settings)
 {
 	return koneplus_send(usb_dev, KONEPLUS_USB_COMMAND_PROFILE_SETTINGS,
-			(void *)settings, sizeof(struct koneplus_profile_settings));
+			settings, sizeof(struct koneplus_profile_settings));
 }
 static int koneplus_get_profile_buttons(struct usb_device *usb_dev,
 		struct koneplus_profile_buttons *buf, int number)
 {
 	int retval;
 	retval = koneplus_select_profile(usb_dev, number,
 			KONEPLUS_CONTROL_REQUEST_PROFILE_BUTTONS);
 	if (retval)
 		return retval;
-	return koneplus_receive(usb_dev, KONEPLUS_USB_COMMAND_PROFILE_BUTTONS,
+	return roccat_common_receive(usb_dev, KONEPLUS_USB_COMMAND_PROFILE_BUTTONS,
 			buf, sizeof(struct koneplus_profile_buttons));
 }
 static int koneplus_set_profile_buttons(struct usb_device *usb_dev,
 		struct koneplus_profile_buttons const *buttons)
 {
 	return koneplus_send(usb_dev, KONEPLUS_USB_COMMAND_PROFILE_BUTTONS,
-			(void *)buttons, sizeof(struct koneplus_profile_buttons));
+			buttons, sizeof(struct koneplus_profile_buttons));
 }
 /* retval is 0-4 on success, < 0 on error */
 static int koneplus_get_startup_profile(struct usb_device *usb_dev)
 {
-	struct koneplus_startup_profile *buf;
+	struct koneplus_startup_profile buf;
 	int retval;
-	buf = kmalloc(sizeof(struct koneplus_startup_profile), GFP_KERNEL);
+	retval = roccat_common_receive(usb_dev, KONEPLUS_USB_COMMAND_STARTUP_PROFILE,
-	if (buf == NULL)
+			&buf, sizeof(struct koneplus_startup_profile));
-		return -ENOMEM;
-	retval = koneplus_receive(usb_dev, KONEPLUS_USB_COMMAND_STARTUP_PROFILE,
+	return retval ? retval : buf.startup_profile;
-			buf, sizeof(struct koneplus_startup_profile));
-	if (retval)
-		goto out;
-	retval = buf->startup_profile;
-out:
-	kfree(buf);
-	return retval;
 }
 static int koneplus_set_startup_profile(struct usb_device *usb_dev,
 		int startup_profile)
 {
 	struct koneplus_startup_profile buf;
 	buf.command = KONEPLUS_COMMAND_STARTUP_PROFILE;
 	buf.size = sizeof(struct koneplus_startup_profile);
 	buf.startup_profile = startup_profile;
 	return koneplus_send(usb_dev, KONEPLUS_USB_COMMAND_STARTUP_PROFILE,
-			(char *)&buf, sizeof(struct koneplus_profile_buttons));
+			&buf, sizeof(struct koneplus_profile_buttons));
 }
 static ssize_t koneplus_sysfs_read(struct file *fp, struct kobject *kobj,
 		char *buf, loff_t off, size_t count,
 		size_t real_size, uint command)
 {
 	struct device *dev =
 			container_of(kobj, struct device, kobj)->parent->parent;
 	struct koneplus_device *koneplus = hid_get_drvdata(dev_get_drvdata(dev));
 	struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));
 	int retval;
 	if (off >= real_size)
 		return 0;
 	if (off != 0 || count != real_size)
 		return -EINVAL;
 	mutex_lock(&koneplus->koneplus_lock);
-	retval = koneplus_receive(usb_dev, command, buf, real_size);
+	retval = roccat_common_receive(usb_dev, command, buf, real_size);
 	mutex_unlock(&koneplus->koneplus_lock);
 	if (retval)
 		return retval;
 	return real_size;
 }
 static ssize_t koneplus_sysfs_write(struct file *fp, struct kobject *kobj,
 		void const *buf, loff_t off, size_t count,
 		size_t real_size, uint command)
 {
 	struct device *dev =
 			container_of(kobj, struct device, kobj)->parent->parent;
 	struct koneplus_device *koneplus = hid_get_drvdata(dev_get_drvdata(dev));
 	struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));
 	int retval;
 	if (off != 0 || count != real_size)
 		return -EINVAL;
 	mutex_lock(&koneplus->koneplus_lock);
-	retval = koneplus_send(usb_dev, command, (void *)buf, real_size);
+	retval = koneplus_send(usb_dev, command, buf, real_size);
 	mutex_unlock(&koneplus->koneplus_lock);
 	if (retval)
 		return retval;
 	return real_size;
 }
 static ssize_t koneplus_sysfs_write_macro(struct file *fp,
 		struct kobject *kobj, struct bin_attribute *attr, char *buf,
 		loff_t off, size_t count)
 {
 	return koneplus_sysfs_write(fp, kobj, buf, off, count,
 			sizeof(struct koneplus_macro), KONEPLUS_USB_COMMAND_MACRO);
 }
 static ssize_t koneplus_sysfs_read_sensor(struct file *fp,
 		struct kobject *kobj, struct bin_attribute *attr, char *buf,
 		loff_t off, size_t count)
 {
 	return koneplus_sysfs_read(fp, kobj, buf, off, count,
 			sizeof(struct koneplus_sensor), KONEPLUS_USB_COMMAND_SENSOR);
 }
 static ssize_t koneplus_sysfs_write_sensor(struct file *fp,
 		struct kobject *kobj, struct bin_attribute *attr, char *buf,
 		loff_t off, size_t count)
 {
 	return koneplus_sysfs_write(fp, kobj, buf, off, count,
 			sizeof(struct koneplus_sensor), KONEPLUS_USB_COMMAND_SENSOR);
 }
 static ssize_t koneplus_sysfs_write_tcu(struct file *fp,
 		struct kobject *kobj, struct bin_attribute *attr, char *buf,
 		loff_t off, size_t count)
 {
 	return koneplus_sysfs_write(fp, kobj, buf, off, count,
 			sizeof(struct koneplus_tcu), KONEPLUS_USB_COMMAND_TCU);
 }
 static ssize_t koneplus_sysfs_read_tcu_image(struct file *fp,
 		struct kobject *kobj, struct bin_attribute *attr, char *buf,
 		loff_t off, size_t count)
 {
 	return koneplus_sysfs_read(fp, kobj, buf, off, count,
 			sizeof(struct koneplus_tcu_image), KONEPLUS_USB_COMMAND_TCU);
 }
 static ssize_t koneplus_sysfs_read_profilex_settings(struct file *fp,
 		struct kobject *kobj, struct bin_attribute *attr, char *buf,
 		loff_t off, size_t count)
 {
 	struct device *dev =
 			container_of(kobj, struct device, kobj)->parent->parent;
 	struct koneplus_device *koneplus = hid_get_drvdata(dev_get_drvdata(dev));
 	if (off >= sizeof(struct koneplus_profile_settings))
 		return 0;
 	if (off + count > sizeof(struct koneplus_profile_settings))
 		count = sizeof(struct koneplus_profile_settings) - off;
 	mutex_lock(&koneplus->koneplus_lock);
-	memcpy(buf, ((void const *)&koneplus->profile_settings[*(uint *)(attr->private)]) + off,
+	memcpy(buf, ((char const *)&koneplus->profile_settings[*(uint *)(attr->private)]) + off,
 			count);
 	mutex_unlock(&koneplus->koneplus_lock);
 	return count;
 }
 static ssize_t koneplus_sysfs_write_profile_settings(struct file *fp,
 		struct kobject *kobj, struct bin_attribute *attr, char *buf,
 		loff_t off, size_t count)
 {
 	struct device *dev =
 			container_of(kobj, struct device, kobj)->parent->parent;
 	struct koneplus_device *koneplus = hid_get_drvdata(dev_get_drvdata(dev));
 	struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));
 	int retval = 0;
 	int difference;
 	int profile_number;
 	struct koneplus_profile_settings *profile_settings;
 	if (off != 0 || count != sizeof(struct koneplus_profile_settings))
 		return -EINVAL;
 	profile_number = ((struct koneplus_profile_settings const *)buf)->number;
 	profile_settings = &koneplus->profile_settings[profile_number];
 	mutex_lock(&koneplus->koneplus_lock);
 	difference = memcmp(buf, profile_settings,
 			sizeof(struct koneplus_profile_settings));
 	if (difference) {
 		retval = koneplus_set_profile_settings(usb_dev,
 				(struct koneplus_profile_settings const *)buf);
 		if (!retval)
 			memcpy(profile_settings, buf,
 					sizeof(struct koneplus_profile_settings));
 	}
 	mutex_unlock(&koneplus->koneplus_lock);
 	if (retval)
 		return retval;
 	return sizeof(struct koneplus_profile_settings);
 }
 static ssize_t koneplus_sysfs_read_profilex_buttons(struct file *fp,
 		struct kobject *kobj, struct bin_attribute *attr, char *buf,
 		loff_t off, size_t count)
 {
 	struct device *dev =
 			container_of(kobj, struct device, kobj)->parent->parent;
 	struct koneplus_device *koneplus = hid_get_drvdata(dev_get_drvdata(dev));
 	if (off >= sizeof(struct koneplus_profile_buttons))
 		return 0;
 	if (off + count > sizeof(struct koneplus_profile_buttons))
 		count = sizeof(struct koneplus_profile_buttons) - off;
 	mutex_lock(&koneplus->koneplus_lock);
-	memcpy(buf, ((void const *)&koneplus->profile_buttons[*(uint *)(attr->private)]) + off,
+	memcpy(buf, ((char const *)&koneplus->profile_buttons[*(uint *)(attr->private)]) + off,
 			count);
 	mutex_unlock(&koneplus->koneplus_lock);
 	return count;
 }
 static ssize_t koneplus_sysfs_write_profile_buttons(struct file *fp,
 		struct kobject *kobj, struct bin_attribute *attr, char *buf,
 		loff_t off, size_t count)
 {
 	struct device *dev =
 			container_of(kobj, struct device, kobj)->parent->parent;
 	struct koneplus_device *koneplus = hid_get_drvdata(dev_get_drvdata(dev));
 	struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));
 	int retval = 0;
 	int difference;
 	uint profile_number;
 	struct koneplus_profile_buttons *profile_buttons;
 	if (off != 0 || count != sizeof(struct koneplus_profile_buttons))
 		return -EINVAL;
 	profile_number = ((struct koneplus_profile_buttons const *)buf)->number;
 	profile_buttons = &koneplus->profile_buttons[profile_number];
 	mutex_lock(&koneplus->koneplus_lock);
 	difference = memcmp(buf, profile_buttons,
 			sizeof(struct koneplus_profile_buttons));
 	if (difference) {
 		retval = koneplus_set_profile_buttons(usb_dev,
 				(struct koneplus_profile_buttons const *)buf);
 		if (!retval)
 			memcpy(profile_buttons, buf,
 					sizeof(struct koneplus_profile_buttons));
 	}
 	mutex_unlock(&koneplus->koneplus_lock);
 	if (retval)
 		return retval;
 	return sizeof(struct koneplus_profile_buttons);
 }
 static ssize_t koneplus_sysfs_show_startup_profile(struct device *dev,
 		struct device_attribute *attr, char *buf)
 {
 	struct koneplus_device *koneplus =
 			hid_get_drvdata(dev_get_drvdata(dev->parent->parent));
 	return snprintf(buf, PAGE_SIZE, "%d\n", koneplus->startup_profile);
 }
 static ssize_t koneplus_sysfs_set_startup_profile(struct device *dev,
 		struct device_attribute *attr, char const *buf, size_t size)
 {
 	struct koneplus_device *koneplus;
 	struct usb_device *usb_dev;
 	unsigned long profile;
 	int retval;
 	dev = dev->parent->parent;
 	koneplus = hid_get_drvdata(dev_get_drvdata(dev));
 	usb_dev = interface_to_usbdev(to_usb_interface(dev));
 	retval = strict_strtoul(buf, 10, &profile);
 	if (retval)
 		return retval;
 	mutex_lock(&koneplus->koneplus_lock);
 	retval = koneplus_set_startup_profile(usb_dev, profile);
 	mutex_unlock(&koneplus->koneplus_lock);
 	if (retval)
 		return retval;
 	return size;
 }
 static ssize_t koneplus_sysfs_show_actual_profile(struct device *dev,
 		struct device_attribute *attr, char *buf)
 {
 	struct koneplus_device *koneplus =
 			hid_get_drvdata(dev_get_drvdata(dev->parent->parent));
 	return snprintf(buf, PAGE_SIZE, "%d\n", koneplus->actual_profile);
 }
 static ssize_t koneplus_sysfs_show_firmware_version(struct device *dev,
 		struct device_attribute *attr, char *buf)
 {
 	struct koneplus_device *koneplus =
 			hid_get_drvdata(dev_get_drvdata(dev->parent->parent));
 	return snprintf(buf, PAGE_SIZE, "%d\n", koneplus->info.firmware_version);
 }
 static struct device_attribute koneplus_attributes[] = {
 	__ATTR(startup_profile, 0660,
 			koneplus_sysfs_show_startup_profile,
 			koneplus_sysfs_set_startup_profile),
 	__ATTR(actual_profile, 0440,
 			koneplus_sysfs_show_actual_profile, NULL),
 	__ATTR(firmware_version, 0440,
 			koneplus_sysfs_show_firmware_version, NULL),
 	__ATTR_NULL
 };
 static struct bin_attribute koneplus_bin_attributes[] = {
 	{
 		.attr = { .name = "sensor", .mode = 0220 },
 		.size = sizeof(struct koneplus_sensor),
 		.read = koneplus_sysfs_read_sensor,
 		.write = koneplus_sysfs_write_sensor
 	},
 	{
 		.attr = { .name = "tcu", .mode = 0220 },
 		.size = sizeof(struct koneplus_tcu),
 		.write = koneplus_sysfs_write_tcu
 	},
 	{
 		.attr = { .name = "tcu_image", .mode = 0440 },
 		.size = sizeof(struct koneplus_tcu_image),
 		.read = koneplus_sysfs_read_tcu_image
 	},
 	{
 		.attr = { .name = "profile_settings", .mode = 0220 },
 		.size = sizeof(struct koneplus_profile_settings),
 		.write = koneplus_sysfs_write_profile_settings
 	},
 	{
 		.attr = { .name = "profile1_settings", .mode = 0440 },
 		.size = sizeof(struct koneplus_profile_settings),
 		.read = koneplus_sysfs_read_profilex_settings,
 		.private = &profile_numbers[0]
 	},
 	{
 		.attr = { .name = "profile2_settings", .mode = 0440 },
 		.size = sizeof(struct koneplus_profile_settings),
 		.read = koneplus_sysfs_read_profilex_settings,
 		.private = &profile_numbers[1]
 	},
 	{
 		.attr = { .name = "profile3_settings", .mode = 0440 },
 		.size = sizeof(struct koneplus_profile_settings),
 		.read = koneplus_sysfs_read_profilex_settings,
 		.private = &profile_numbers[2]
 	},
 	{
 		.attr = { .name = "profile4_settings", .mode = 0440 },
 		.size = sizeof(struct koneplus_profile_settings),
 		.read = koneplus_sysfs_read_profilex_settings,
 		.private = &profile_numbers[3]
 	},
 	{
 		.attr = { .name = "profile5_settings", .mode = 0440 },
 		.size = sizeof(struct koneplus_profile_settings),
 		.read = koneplus_sysfs_read_profilex_settings,
 		.private = &profile_numbers[4]
 	},
 	{
 		.attr = { .name = "profile_buttons", .mode = 0220 },
 		.size = sizeof(struct koneplus_profile_buttons),
 		.write = koneplus_sysfs_write_profile_buttons
 	},
 	{
 		.attr = { .name = "profile1_buttons", .mode = 0440 },
 		.size = sizeof(struct koneplus_profile_buttons),
 		.read = koneplus_sysfs_read_profilex_buttons,
 		.private = &profile_numbers[0]
 	},
 	{
 		.attr = { .name = "profile2_buttons", .mode = 0440 },
 		.size = sizeof(struct koneplus_profile_buttons),
 		.read = koneplus_sysfs_read_profilex_buttons,
 		.private = &profile_numbers[1]
 	},
 	{
 		.attr = { .name = "profile3_buttons", .mode = 0440 },
 		.size = sizeof(struct koneplus_profile_buttons),
 		.read = koneplus_sysfs_read_profilex_buttons,
 		.private = &profile_numbers[2]
 	},
 	{
 		.attr = { .name = "profile4_buttons", .mode = 0440 },
 		.size = sizeof(struct koneplus_profile_buttons),
 		.read = koneplus_sysfs_read_profilex_buttons,
 		.private = &profile_numbers[3]
 	},
 	{
 		.attr = { .name = "profile5_buttons", .mode = 0440 },
 		.size = sizeof(struct koneplus_profile_buttons),
 		.read = koneplus_sysfs_read_profilex_buttons,
 		.private = &profile_numbers[4]
 	},
 	{
 		.attr = { .name = "macro", .mode = 0220 },
 		.size = sizeof(struct koneplus_macro),
 		.write = koneplus_sysfs_write_macro
 	},
 	__ATTR_NULL
 };
 static int koneplus_init_koneplus_device_struct(struct usb_device *usb_dev,
 		struct koneplus_device *koneplus)
 {
 	int retval, i;
 	static uint wait = 70; /* device will freeze with just 60 */
 	mutex_init(&koneplus->koneplus_lock);
 	koneplus->startup_profile = koneplus_get_startup_profile(usb_dev);
 	if (koneplus->startup_profile < 0)
 		return koneplus->startup_profile;
 	msleep(wait);
 	retval = koneplus_get_info(usb_dev, &koneplus->info);
 	if (retval)
 		return retval;
 	for (i = 0; i < 5; ++i) {
 		msleep(wait);
 		retval = koneplus_get_profile_settings(usb_dev,
 				&koneplus->profile_settings[i], i);
 		if (retval)
 			return retval;
 		msleep(wait);
 		retval = koneplus_get_profile_buttons(usb_dev,
 				&koneplus->profile_buttons[i], i);
 		if (retval)
 			return retval;
 	}
 	koneplus_profile_activated(koneplus, koneplus->startup_profile);
 	return 0;
 }
 static int koneplus_init_specials(struct hid_device *hdev)
 {
 	struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
 	struct usb_device *usb_dev = interface_to_usbdev(intf);
 	struct koneplus_device *koneplus;
 	int retval;
 	if (intf->cur_altsetting->desc.bInterfaceProtocol
 			== USB_INTERFACE_PROTOCOL_MOUSE) {
 		koneplus = kzalloc(sizeof(*koneplus), GFP_KERNEL);
 		if (!koneplus) {
 			hid_err(hdev, "can't alloc device descriptor\n");
 			return -ENOMEM;
 		}
 		hid_set_drvdata(hdev, koneplus);
 		retval = koneplus_init_koneplus_device_struct(usb_dev, koneplus);
 		if (retval) {
 			hid_err(hdev, "couldn't init struct koneplus_device\n");
 			goto exit_free;
 		}
 		retval = roccat_connect(koneplus_class, hdev);
 		if (retval < 0) {
 			hid_err(hdev, "couldn't init char dev\n");
 		} else {
 			koneplus->chrdev_minor = retval;
 			koneplus->roccat_claimed = 1;
 		}
 	} else {
 		hid_set_drvdata(hdev, NULL);
 	}
 	return 0;
 exit_free:
 	kfree(koneplus);
 	return retval;
 }
 static void koneplus_remove_specials(struct hid_device *hdev)
 {
 	struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
 	struct koneplus_device *koneplus;
 	if (intf->cur_altsetting->desc.bInterfaceProtocol
 			== USB_INTERFACE_PROTOCOL_MOUSE) {
 		koneplus = hid_get_drvdata(hdev);
 		if (koneplus->roccat_claimed)
 			roccat_disconnect(koneplus->chrdev_minor);
 		kfree(koneplus);
 	}
 }
 static int koneplus_probe(struct hid_device *hdev,
 		const struct hid_device_id *id)
 {
 	int retval;
 	retval = hid_parse(hdev);
 	if (retval) {
 		hid_err(hdev, "parse failed\n");
 		goto exit;
 	}
 	retval = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
 	if (retval) {
 		hid_err(hdev, "hw start failed\n");
 		goto exit;
 	}
 	retval = koneplus_init_specials(hdev);
 	if (retval) {
 		hid_err(hdev, "couldn't install mouse\n");
 		goto exit_stop;
 	}
 	return 0;
 exit_stop:
 	hid_hw_stop(hdev);
 exit:
 	return retval;
 }
 static void koneplus_remove(struct hid_device *hdev)
 {
 	koneplus_remove_specials(hdev);
 	hid_hw_stop(hdev);
 }
 static void koneplus_keep_values_up_to_date(struct koneplus_device *koneplus,
 		u8 const *data)
 {
 	struct koneplus_mouse_report_button const *button_report;
 	switch (data[0]) {
 	case KONEPLUS_MOUSE_REPORT_NUMBER_BUTTON:
 		button_report = (struct koneplus_mouse_report_button const *)data;
 		switch (button_report->type) {
 		case KONEPLUS_MOUSE_REPORT_BUTTON_TYPE_PROFILE:
 			koneplus_profile_activated(koneplus, button_report->data1 - 1);
 			break;
 		}
 		break;
 	}
 }
 static void koneplus_report_to_chrdev(struct koneplus_device const *koneplus,
 		u8 const *data)
 {
 	struct koneplus_roccat_report roccat_report;
 	struct koneplus_mouse_report_button const *button_report;
 	if (data[0] != KONEPLUS_MOUSE_REPORT_NUMBER_BUTTON)
 		return;
 	button_report = (struct koneplus_mouse_report_button const *)data;
 	if ((button_report->type == KONEPLUS_MOUSE_REPORT_BUTTON_TYPE_QUICKLAUNCH ||
 			button_report->type == KONEPLUS_MOUSE_REPORT_BUTTON_TYPE_TIMER) &&
 			button_report->data2 != KONEPLUS_MOUSE_REPORT_BUTTON_ACTION_PRESS)
 		return;
 	roccat_report.type = button_report->type;
 	roccat_report.data1 = button_report->data1;
 	roccat_report.data2 = button_report->data2;
 	roccat_report.profile = koneplus->actual_profile + 1;
 	roccat_report_event(koneplus->chrdev_minor,
 			(uint8_t const *)&roccat_report,
 			sizeof(struct koneplus_roccat_report));
 }
 static int koneplus_raw_event(struct hid_device *hdev,
 		struct hid_report *report, u8 *data, int size)
 {
 	struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
 	struct koneplus_device *koneplus = hid_get_drvdata(hdev);
 	if (intf->cur_altsetting->desc.bInterfaceProtocol
 			!= USB_INTERFACE_PROTOCOL_MOUSE)
 		return 0;
 	koneplus_keep_values_up_to_date(koneplus, data);
 	if (koneplus->roccat_claimed)
 		koneplus_report_to_chrdev(koneplus, data);
 	return 0;
 }
 static const struct hid_device_id koneplus_devices[] = {
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_KONEPLUS) },
 	{ }
 };
 MODULE_DEVICE_TABLE(hid, koneplus_devices);
 static struct hid_driver koneplus_driver = {
 		.name = "koneplus",
 		.id_table = koneplus_devices,
 		.probe = koneplus_probe,
 		.remove = koneplus_remove,
 		.raw_event = koneplus_raw_event
 };
 static int __init koneplus_init(void)
 {
 	int retval;
 	/* class name has to be same as driver name */
 	koneplus_class = class_create(THIS_MODULE, "koneplus");
 	if (IS_ERR(koneplus_class))
 		return PTR_ERR(koneplus_class);
 	koneplus_class->dev_attrs = koneplus_attributes;
 	koneplus_class->dev_bin_attrs = koneplus_bin_attributes;
 	retval = hid_register_driver(&koneplus_driver);
 	if (retval)
 		class_destroy(koneplus_class);
 	return retval;
 }
 static void __exit koneplus_exit(void)
 {
 	class_destroy(koneplus_class);
 	hid_unregister_driver(&koneplus_driver);
 }
 module_init(koneplus_init);
 module_exit(koneplus_exit);
 MODULE_AUTHOR("Stefan Achatz");
 MODULE_DESCRIPTION("USB Roccat Kone[+] driver");

drivers/hid/hid-roccat-pyra.c

Diff comments View file @ 5772f63

1	/*	1	/*
2	* Roccat Pyra driver for Linux	2	* Roccat Pyra driver for Linux
3	*	3	*
4	* Copyright (c) 2010 Stefan Achatz <erazor_de@users.sourceforge.net>	4	* Copyright (c) 2010 Stefan Achatz <erazor_de@users.sourceforge.net>
5	*/	5	*/
6		6
7	/*	7	/*
8	* This program is free software; you can redistribute it and/or modify it	8	* This program is free software; you can redistribute it and/or modify it
9	* under the terms of the GNU General Public License as published by the Free	9	* under the terms of the GNU General Public License as published by the Free
10	* Software Foundation; either version 2 of the License, or (at your option)	10	* Software Foundation; either version 2 of the License, or (at your option)
11	* any later version.	11	* any later version.
12	*/	12	*/
13		13
14	/*	14	/*
15	* Roccat Pyra is a mobile gamer mouse which comes in wired and wireless	15	* Roccat Pyra is a mobile gamer mouse which comes in wired and wireless
16	* variant. Wireless variant is not tested.	16	* variant. Wireless variant is not tested.
17	* Userland tools can be found at http://sourceforge.net/projects/roccat	17	* Userland tools can be found at http://sourceforge.net/projects/roccat
18	*/	18	*/
19		19
20	#include <linux/device.h>	20	#include <linux/device.h>
21	#include <linux/input.h>	21	#include <linux/input.h>
22	#include <linux/hid.h>	22	#include <linux/hid.h>
23	#include <linux/usb.h>
24	#include <linux/module.h>	23	#include <linux/module.h>
25	#include <linux/slab.h>	24	#include <linux/slab.h>
26	#include "hid-ids.h"	25	#include "hid-ids.h"
27	#include "hid-roccat.h"	26	#include "hid-roccat.h"
		27	#include "hid-roccat-common.h"
28	#include "hid-roccat-pyra.h"	28	#include "hid-roccat-pyra.h"
29		29
30	static uint profile_numbers[5] = {0, 1, 2, 3, 4};	30	static uint profile_numbers[5] = {0, 1, 2, 3, 4};
31		31
32	/* pyra_class is used for creating sysfs attributes via roccat char device */	32	/* pyra_class is used for creating sysfs attributes via roccat char device */
33	static struct class *pyra_class;	33	static struct class *pyra_class;
34		34
35	static void profile_activated(struct pyra_device *pyra,	35	static void profile_activated(struct pyra_device *pyra,
36	unsigned int new_profile)	36	unsigned int new_profile)
37	{	37	{
38	pyra->actual_profile = new_profile;	38	pyra->actual_profile = new_profile;
39	pyra->actual_cpi = pyra->profile_settings[pyra->actual_profile].y_cpi;	39	pyra->actual_cpi = pyra->profile_settings[pyra->actual_profile].y_cpi;
40	}	40	}
41		41
42	static int pyra_send_control(struct usb_device *usb_dev, int value,	42	static int pyra_send_control(struct usb_device *usb_dev, int value,
43	enum pyra_control_requests request)	43	enum pyra_control_requests request)
44	{	44	{
45	int len;
46	struct pyra_control control;	45	struct pyra_control control;
47		46
48	if ((request == PYRA_CONTROL_REQUEST_PROFILE_SETTINGS \|\|	47	if ((request == PYRA_CONTROL_REQUEST_PROFILE_SETTINGS \|\|
49	request == PYRA_CONTROL_REQUEST_PROFILE_BUTTONS) &&	48	request == PYRA_CONTROL_REQUEST_PROFILE_BUTTONS) &&
50	(value < 0 \|\| value > 4))	49	(value < 0 \|\| value > 4))
51	return -EINVAL;	50	return -EINVAL;
52		51
53	control.command = PYRA_COMMAND_CONTROL;	52	control.command = PYRA_COMMAND_CONTROL;
54	control.value = value;	53	control.value = value;
55	control.request = request;	54	control.request = request;
56		55
57	len = usb_control_msg(usb_dev, usb_sndctrlpipe(usb_dev, 0),	56	return roccat_common_send(usb_dev, PYRA_USB_COMMAND_CONTROL,
58	USB_REQ_SET_CONFIGURATION,	57	&control, sizeof(struct pyra_control));
59	USB_TYPE_CLASS \| USB_RECIP_INTERFACE \| USB_DIR_OUT,
60	PYRA_USB_COMMAND_CONTROL, 0, (char *)&control,
61	sizeof(struct pyra_control),
62	USB_CTRL_SET_TIMEOUT);
63
64	if (len != sizeof(struct pyra_control))
65	return len;
66
67	return 0;
68	}	58	}
69		59
70	static int pyra_receive_control_status(struct usb_device *usb_dev)	60	static int pyra_receive_control_status(struct usb_device *usb_dev)
71	{	61	{
72	int len;	62	int retval;
73	struct pyra_control control;	63	struct pyra_control control;
74		64
75	do {	65	do {
76	msleep(10);	66	msleep(10);
		67	retval = roccat_common_receive(usb_dev, PYRA_USB_COMMAND_CONTROL,
		68	&control, sizeof(struct pyra_control));
77		69
78	len = usb_control_msg(usb_dev, usb_rcvctrlpipe(usb_dev, 0),
79	USB_REQ_CLEAR_FEATURE,
80	USB_TYPE_CLASS \| USB_RECIP_INTERFACE \|
81	USB_DIR_IN,
82	PYRA_USB_COMMAND_CONTROL, 0, (char *)&control,
83	sizeof(struct pyra_control),
84	USB_CTRL_SET_TIMEOUT);
85
86	/* requested too early, try again */	70	/* requested too early, try again */
87	} while (len == -EPROTO);	71	} while (retval == -EPROTO);
88		72
89	if (len == sizeof(struct pyra_control) &&	73	if (!retval && control.command == PYRA_COMMAND_CONTROL &&
90	control.command == PYRA_COMMAND_CONTROL &&
91	control.request == PYRA_CONTROL_REQUEST_STATUS &&	74	control.request == PYRA_CONTROL_REQUEST_STATUS &&
92	control.value == 1)	75	control.value == 1)
93	return 0;	76	return 0;
94	else {	77	else {
95	hid_err(usb_dev, "receive control status: unknown response 0x%x 0x%x\n",	78	hid_err(usb_dev, "receive control status: unknown response 0x%x 0x%x\n",
96	control.request, control.value);	79	control.request, control.value);
97	return -EINVAL;	80	return retval ? retval : -EINVAL;
98	}	81	}
99	}	82	}
100		83
101	static int pyra_get_profile_settings(struct usb_device *usb_dev,	84	static int pyra_get_profile_settings(struct usb_device *usb_dev,
102	struct pyra_profile_settings *buf, int number)	85	struct pyra_profile_settings *buf, int number)
103	{	86	{
104	int retval;	87	int retval;
105
106	retval = pyra_send_control(usb_dev, number,	88	retval = pyra_send_control(usb_dev, number,
107	PYRA_CONTROL_REQUEST_PROFILE_SETTINGS);	89	PYRA_CONTROL_REQUEST_PROFILE_SETTINGS);
108
109	if (retval)	90	if (retval)
110	return retval;	91	return retval;
111		92	return roccat_common_receive(usb_dev, PYRA_USB_COMMAND_PROFILE_SETTINGS,
112	retval = usb_control_msg(usb_dev, usb_rcvctrlpipe(usb_dev, 0),	93	buf, sizeof(struct pyra_profile_settings));
113	USB_REQ_CLEAR_FEATURE,
114	USB_TYPE_CLASS \| USB_RECIP_INTERFACE \| USB_DIR_IN,
115	PYRA_USB_COMMAND_PROFILE_SETTINGS, 0, (char *)buf,
116	sizeof(struct pyra_profile_settings),
117	USB_CTRL_SET_TIMEOUT);
118
119	if (retval != sizeof(struct pyra_profile_settings))
120	return retval;
121
122	return 0;
123	}	94	}
124		95
125	static int pyra_get_profile_buttons(struct usb_device *usb_dev,	96	static int pyra_get_profile_buttons(struct usb_device *usb_dev,
126	struct pyra_profile_buttons *buf, int number)	97	struct pyra_profile_buttons *buf, int number)
127	{	98	{
128	int retval;	99	int retval;
129
130	retval = pyra_send_control(usb_dev, number,	100	retval = pyra_send_control(usb_dev, number,
131	PYRA_CONTROL_REQUEST_PROFILE_BUTTONS);	101	PYRA_CONTROL_REQUEST_PROFILE_BUTTONS);
132
133	if (retval)	102	if (retval)
134	return retval;	103	return retval;
135		104	return roccat_common_receive(usb_dev, PYRA_USB_COMMAND_PROFILE_BUTTONS,
136	retval = usb_control_msg(usb_dev, usb_rcvctrlpipe(usb_dev, 0),	105	buf, sizeof(struct pyra_profile_buttons));
137	USB_REQ_CLEAR_FEATURE,
138	USB_TYPE_CLASS \| USB_RECIP_INTERFACE \| USB_DIR_IN,
139	PYRA_USB_COMMAND_PROFILE_BUTTONS, 0, (char *)buf,
140	sizeof(struct pyra_profile_buttons),
141	USB_CTRL_SET_TIMEOUT);
142
143	if (retval != sizeof(struct pyra_profile_buttons))
144	return retval;
145
146	return 0;
147	}	106	}
148		107
149	static int pyra_get_settings(struct usb_device *usb_dev,	108	static int pyra_get_settings(struct usb_device *usb_dev,
150	struct pyra_settings *buf)	109	struct pyra_settings *buf)
151	{	110	{
152	int len;	111	return roccat_common_receive(usb_dev, PYRA_USB_COMMAND_SETTINGS,
153	len = usb_control_msg(usb_dev, usb_rcvctrlpipe(usb_dev, 0),	112	buf, sizeof(struct pyra_settings));
154	USB_REQ_CLEAR_FEATURE,
155	USB_TYPE_CLASS \| USB_RECIP_INTERFACE \| USB_DIR_IN,
156	PYRA_USB_COMMAND_SETTINGS, 0, buf,
157	sizeof(struct pyra_settings), USB_CTRL_SET_TIMEOUT);
158	if (len != sizeof(struct pyra_settings))
159	return -EIO;
160	return 0;
161	}	113	}
162		114
163	static int pyra_get_info(struct usb_device usb_dev, struct pyra_info buf)	115	static int pyra_get_info(struct usb_device usb_dev, struct pyra_info buf)
164	{	116	{
165	int len;	117	return roccat_common_receive(usb_dev, PYRA_USB_COMMAND_INFO,
166	len = usb_control_msg(usb_dev, usb_rcvctrlpipe(usb_dev, 0),	118	buf, sizeof(struct pyra_info));
167	USB_REQ_CLEAR_FEATURE,
168	USB_TYPE_CLASS \| USB_RECIP_INTERFACE \| USB_DIR_IN,
169	PYRA_USB_COMMAND_INFO, 0, buf,
170	sizeof(struct pyra_info), USB_CTRL_SET_TIMEOUT);
171	if (len != sizeof(struct pyra_info))
172	return -EIO;
173	return 0;
174	}	119	}
175		120
		121	static int pyra_send(struct usb_device *usb_dev, uint command,
		122	void const *buf, uint size)
		123	{
		124	int retval;
		125	retval = roccat_common_send(usb_dev, command, buf, size);
		126	if (retval)
		127	return retval;
		128	return pyra_receive_control_status(usb_dev);
		129	}
		130
176	static int pyra_set_profile_settings(struct usb_device *usb_dev,	131	static int pyra_set_profile_settings(struct usb_device *usb_dev,
177	struct pyra_profile_settings const *settings)	132	struct pyra_profile_settings const *settings)
178	{	133	{
179	int len;	134	return pyra_send(usb_dev, PYRA_USB_COMMAND_PROFILE_SETTINGS, settings,
180	len = usb_control_msg(usb_dev, usb_sndctrlpipe(usb_dev, 0),	135	sizeof(struct pyra_profile_settings));
181	USB_REQ_SET_CONFIGURATION,
182	USB_TYPE_CLASS \| USB_RECIP_INTERFACE \| USB_DIR_OUT,
183	PYRA_USB_COMMAND_PROFILE_SETTINGS, 0, (char *)settings,
184	sizeof(struct pyra_profile_settings),
185	USB_CTRL_SET_TIMEOUT);
186	if (len != sizeof(struct pyra_profile_settings))
187	return -EIO;
188	if (pyra_receive_control_status(usb_dev))
189	return -EIO;
190	return 0;
191	}	136	}
192		137
193	static int pyra_set_profile_buttons(struct usb_device *usb_dev,	138	static int pyra_set_profile_buttons(struct usb_device *usb_dev,
194	struct pyra_profile_buttons const *buttons)	139	struct pyra_profile_buttons const *buttons)
195	{	140	{
196	int len;	141	return pyra_send(usb_dev, PYRA_USB_COMMAND_PROFILE_BUTTONS, buttons,
197	len = usb_control_msg(usb_dev, usb_sndctrlpipe(usb_dev, 0),	142	sizeof(struct pyra_profile_buttons));
198	USB_REQ_SET_CONFIGURATION,
199	USB_TYPE_CLASS \| USB_RECIP_INTERFACE \| USB_DIR_OUT,
200	PYRA_USB_COMMAND_PROFILE_BUTTONS, 0, (char *)buttons,
201	sizeof(struct pyra_profile_buttons),
202	USB_CTRL_SET_TIMEOUT);
203	if (len != sizeof(struct pyra_profile_buttons))
204	return -EIO;
205	if (pyra_receive_control_status(usb_dev))
206	return -EIO;
207	return 0;
208	}	143	}
209		144
210	static int pyra_set_settings(struct usb_device *usb_dev,	145	static int pyra_set_settings(struct usb_device *usb_dev,
211	struct pyra_settings const *settings)	146	struct pyra_settings const *settings)
212	{	147	{
213	int len;	148	int retval;
214	len = usb_control_msg(usb_dev, usb_sndctrlpipe(usb_dev, 0),	149	retval = roccat_common_send(usb_dev, PYRA_USB_COMMAND_SETTINGS, settings,
215	USB_REQ_SET_CONFIGURATION,	150	sizeof(struct pyra_settings));
216	USB_TYPE_CLASS \| USB_RECIP_INTERFACE \| USB_DIR_OUT,	151	if (retval)
217	PYRA_USB_COMMAND_SETTINGS, 0, (char *)settings,	152	return retval;
218	sizeof(struct pyra_settings), USB_CTRL_SET_TIMEOUT);	153	return pyra_receive_control_status(usb_dev);
219	if (len != sizeof(struct pyra_settings))
220	return -EIO;
221	if (pyra_receive_control_status(usb_dev))
222	return -EIO;
223	return 0;
224	}	154	}
225		155
226	static ssize_t pyra_sysfs_read_profilex_settings(struct file *fp,	156	static ssize_t pyra_sysfs_read_profilex_settings(struct file *fp,
227	struct kobject kobj, struct bin_attribute attr, char *buf,	157	struct kobject kobj, struct bin_attribute attr, char *buf,
228	loff_t off, size_t count)	158	loff_t off, size_t count)
229	{	159	{
230	struct device *dev =	160	struct device *dev =
231	container_of(kobj, struct device, kobj)->parent->parent;	161	container_of(kobj, struct device, kobj)->parent->parent;
232	struct pyra_device *pyra = hid_get_drvdata(dev_get_drvdata(dev));	162	struct pyra_device *pyra = hid_get_drvdata(dev_get_drvdata(dev));
233		163
234	if (off >= sizeof(struct pyra_profile_settings))	164	if (off >= sizeof(struct pyra_profile_settings))
235	return 0;	165	return 0;
236		166
237	if (off + count > sizeof(struct pyra_profile_settings))	167	if (off + count > sizeof(struct pyra_profile_settings))
238	count = sizeof(struct pyra_profile_settings) - off;	168	count = sizeof(struct pyra_profile_settings) - off;
239		169
240	mutex_lock(&pyra->pyra_lock);	170	mutex_lock(&pyra->pyra_lock);
241	memcpy(buf, ((char const )&pyra->profile_settings[(uint *)(attr->private)]) + off,	171	memcpy(buf, ((char const )&pyra->profile_settings[(uint *)(attr->private)]) + off,
242	count);	172	count);
243	mutex_unlock(&pyra->pyra_lock);	173	mutex_unlock(&pyra->pyra_lock);
244		174
245	return count;	175	return count;
246	}	176	}
247		177
248	static ssize_t pyra_sysfs_read_profilex_buttons(struct file *fp,	178	static ssize_t pyra_sysfs_read_profilex_buttons(struct file *fp,
249	struct kobject kobj, struct bin_attribute attr, char *buf,	179	struct kobject kobj, struct bin_attribute attr, char *buf,
250	loff_t off, size_t count)	180	loff_t off, size_t count)
251	{	181	{
252	struct device *dev =	182	struct device *dev =
253	container_of(kobj, struct device, kobj)->parent->parent;	183	container_of(kobj, struct device, kobj)->parent->parent;
254	struct pyra_device *pyra = hid_get_drvdata(dev_get_drvdata(dev));	184	struct pyra_device *pyra = hid_get_drvdata(dev_get_drvdata(dev));
255		185
256	if (off >= sizeof(struct pyra_profile_buttons))	186	if (off >= sizeof(struct pyra_profile_buttons))
257	return 0;	187	return 0;
258		188
259	if (off + count > sizeof(struct pyra_profile_buttons))	189	if (off + count > sizeof(struct pyra_profile_buttons))
260	count = sizeof(struct pyra_profile_buttons) - off;	190	count = sizeof(struct pyra_profile_buttons) - off;
261		191
262	mutex_lock(&pyra->pyra_lock);	192	mutex_lock(&pyra->pyra_lock);
263	memcpy(buf, ((char const )&pyra->profile_buttons[(uint *)(attr->private)]) + off,	193	memcpy(buf, ((char const )&pyra->profile_buttons[(uint *)(attr->private)]) + off,
264	count);	194	count);
265	mutex_unlock(&pyra->pyra_lock);	195	mutex_unlock(&pyra->pyra_lock);
266		196
267	return count;	197	return count;
268	}	198	}
269		199
270	static ssize_t pyra_sysfs_write_profile_settings(struct file *fp,	200	static ssize_t pyra_sysfs_write_profile_settings(struct file *fp,
271	struct kobject kobj, struct bin_attribute attr, char *buf,	201	struct kobject kobj, struct bin_attribute attr, char *buf,
272	loff_t off, size_t count)	202	loff_t off, size_t count)
273	{	203	{
274	struct device *dev =	204	struct device *dev =
275	container_of(kobj, struct device, kobj)->parent->parent;	205	container_of(kobj, struct device, kobj)->parent->parent;
276	struct pyra_device *pyra = hid_get_drvdata(dev_get_drvdata(dev));	206	struct pyra_device *pyra = hid_get_drvdata(dev_get_drvdata(dev));
277	struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));	207	struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));
278	int retval = 0;	208	int retval = 0;
279	int difference;	209	int difference;
280	int profile_number;	210	int profile_number;
281	struct pyra_profile_settings *profile_settings;	211	struct pyra_profile_settings *profile_settings;
282		212
283	if (off != 0 \|\| count != sizeof(struct pyra_profile_settings))	213	if (off != 0 \|\| count != sizeof(struct pyra_profile_settings))
284	return -EINVAL;	214	return -EINVAL;
285		215
286	profile_number = ((struct pyra_profile_settings const *)buf)->number;	216	profile_number = ((struct pyra_profile_settings const *)buf)->number;
287	profile_settings = &pyra->profile_settings[profile_number];	217	profile_settings = &pyra->profile_settings[profile_number];
288		218
289	mutex_lock(&pyra->pyra_lock);	219	mutex_lock(&pyra->pyra_lock);
290	difference = memcmp(buf, profile_settings,	220	difference = memcmp(buf, profile_settings,
291	sizeof(struct pyra_profile_settings));	221	sizeof(struct pyra_profile_settings));
292	if (difference) {	222	if (difference) {
293	retval = pyra_set_profile_settings(usb_dev,	223	retval = pyra_set_profile_settings(usb_dev,
294	(struct pyra_profile_settings const *)buf);	224	(struct pyra_profile_settings const *)buf);
295	if (!retval)	225	if (!retval)
296	memcpy(profile_settings, buf,	226	memcpy(profile_settings, buf,
297	sizeof(struct pyra_profile_settings));	227	sizeof(struct pyra_profile_settings));
298	}	228	}
299	mutex_unlock(&pyra->pyra_lock);	229	mutex_unlock(&pyra->pyra_lock);
300		230
301	if (retval)	231	if (retval)
302	return retval;	232	return retval;
303		233
304	return sizeof(struct pyra_profile_settings);	234	return sizeof(struct pyra_profile_settings);
305	}	235	}
306		236
307	static ssize_t pyra_sysfs_write_profile_buttons(struct file *fp,	237	static ssize_t pyra_sysfs_write_profile_buttons(struct file *fp,
308	struct kobject kobj, struct bin_attribute attr, char *buf,	238	struct kobject kobj, struct bin_attribute attr, char *buf,
309	loff_t off, size_t count)	239	loff_t off, size_t count)
310	{	240	{
311	struct device *dev =	241	struct device *dev =
312	container_of(kobj, struct device, kobj)->parent->parent;	242	container_of(kobj, struct device, kobj)->parent->parent;
313	struct pyra_device *pyra = hid_get_drvdata(dev_get_drvdata(dev));	243	struct pyra_device *pyra = hid_get_drvdata(dev_get_drvdata(dev));
314	struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));	244	struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));
315	int retval = 0;	245	int retval = 0;
316	int difference;	246	int difference;
317	int profile_number;	247	int profile_number;
318	struct pyra_profile_buttons *profile_buttons;	248	struct pyra_profile_buttons *profile_buttons;
319		249
320	if (off != 0 \|\| count != sizeof(struct pyra_profile_buttons))	250	if (off != 0 \|\| count != sizeof(struct pyra_profile_buttons))
321	return -EINVAL;	251	return -EINVAL;
322		252
323	profile_number = ((struct pyra_profile_buttons const *)buf)->number;	253	profile_number = ((struct pyra_profile_buttons const *)buf)->number;
324	profile_buttons = &pyra->profile_buttons[profile_number];	254	profile_buttons = &pyra->profile_buttons[profile_number];
325		255
326	mutex_lock(&pyra->pyra_lock);	256	mutex_lock(&pyra->pyra_lock);
327	difference = memcmp(buf, profile_buttons,	257	difference = memcmp(buf, profile_buttons,
328	sizeof(struct pyra_profile_buttons));	258	sizeof(struct pyra_profile_buttons));
329	if (difference) {	259	if (difference) {
330	retval = pyra_set_profile_buttons(usb_dev,	260	retval = pyra_set_profile_buttons(usb_dev,
331	(struct pyra_profile_buttons const *)buf);	261	(struct pyra_profile_buttons const *)buf);
332	if (!retval)	262	if (!retval)
333	memcpy(profile_buttons, buf,	263	memcpy(profile_buttons, buf,
334	sizeof(struct pyra_profile_buttons));	264	sizeof(struct pyra_profile_buttons));
335	}	265	}
336	mutex_unlock(&pyra->pyra_lock);	266	mutex_unlock(&pyra->pyra_lock);
337		267
338	if (retval)	268	if (retval)
339	return retval;	269	return retval;
340		270
341	return sizeof(struct pyra_profile_buttons);	271	return sizeof(struct pyra_profile_buttons);
342	}	272	}
343		273
344	static ssize_t pyra_sysfs_read_settings(struct file *fp,	274	static ssize_t pyra_sysfs_read_settings(struct file *fp,
345	struct kobject kobj, struct bin_attribute attr, char *buf,	275	struct kobject kobj, struct bin_attribute attr, char *buf,
346	loff_t off, size_t count)	276	loff_t off, size_t count)
347	{	277	{
348	struct device *dev =	278	struct device *dev =
349	container_of(kobj, struct device, kobj)->parent->parent;	279	container_of(kobj, struct device, kobj)->parent->parent;
350	struct pyra_device *pyra = hid_get_drvdata(dev_get_drvdata(dev));	280	struct pyra_device *pyra = hid_get_drvdata(dev_get_drvdata(dev));
351		281
352	if (off >= sizeof(struct pyra_settings))	282	if (off >= sizeof(struct pyra_settings))
353	return 0;	283	return 0;
354		284
355	if (off + count > sizeof(struct pyra_settings))	285	if (off + count > sizeof(struct pyra_settings))
356	count = sizeof(struct pyra_settings) - off;	286	count = sizeof(struct pyra_settings) - off;
357		287
358	mutex_lock(&pyra->pyra_lock);	288	mutex_lock(&pyra->pyra_lock);
359	memcpy(buf, ((char const *)&pyra->settings) + off, count);	289	memcpy(buf, ((char const *)&pyra->settings) + off, count);
360	mutex_unlock(&pyra->pyra_lock);	290	mutex_unlock(&pyra->pyra_lock);
361		291
362	return count;	292	return count;
363	}	293	}
364		294
365	static ssize_t pyra_sysfs_write_settings(struct file *fp,	295	static ssize_t pyra_sysfs_write_settings(struct file *fp,
366	struct kobject kobj, struct bin_attribute attr, char *buf,	296	struct kobject kobj, struct bin_attribute attr, char *buf,
367	loff_t off, size_t count)	297	loff_t off, size_t count)
368	{	298	{
369	struct device *dev =	299	struct device *dev =
370	container_of(kobj, struct device, kobj)->parent->parent;	300	container_of(kobj, struct device, kobj)->parent->parent;
371	struct pyra_device *pyra = hid_get_drvdata(dev_get_drvdata(dev));	301	struct pyra_device *pyra = hid_get_drvdata(dev_get_drvdata(dev));
372	struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));	302	struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));
373	int retval = 0;	303	int retval = 0;
374	int difference;	304	int difference;
375		305
376	if (off != 0 \|\| count != sizeof(struct pyra_settings))	306	if (off != 0 \|\| count != sizeof(struct pyra_settings))
377	return -EINVAL;	307	return -EINVAL;
378		308
379	mutex_lock(&pyra->pyra_lock);	309	mutex_lock(&pyra->pyra_lock);
380	difference = memcmp(buf, &pyra->settings, sizeof(struct pyra_settings));	310	difference = memcmp(buf, &pyra->settings, sizeof(struct pyra_settings));
381	if (difference) {	311	if (difference) {
382	retval = pyra_set_settings(usb_dev,	312	retval = pyra_set_settings(usb_dev,
383	(struct pyra_settings const *)buf);	313	(struct pyra_settings const *)buf);
384	if (!retval)	314	if (!retval)
385	memcpy(&pyra->settings, buf,	315	memcpy(&pyra->settings, buf,
386	sizeof(struct pyra_settings));	316	sizeof(struct pyra_settings));
387	}	317	}
388	mutex_unlock(&pyra->pyra_lock);	318	mutex_unlock(&pyra->pyra_lock);
389		319
390	if (retval)	320	if (retval)
391	return retval;	321	return retval;
392		322
393	profile_activated(pyra, pyra->settings.startup_profile);	323	profile_activated(pyra, pyra->settings.startup_profile);
394		324
395	return sizeof(struct pyra_settings);	325	return sizeof(struct pyra_settings);
396	}	326	}
397		327
398		328
399	static ssize_t pyra_sysfs_show_actual_cpi(struct device *dev,	329	static ssize_t pyra_sysfs_show_actual_cpi(struct device *dev,
400	struct device_attribute attr, char buf)	330	struct device_attribute attr, char buf)
401	{	331	{
402	struct pyra_device *pyra =	332	struct pyra_device *pyra =
403	hid_get_drvdata(dev_get_drvdata(dev->parent->parent));	333	hid_get_drvdata(dev_get_drvdata(dev->parent->parent));
404	return snprintf(buf, PAGE_SIZE, "%d\n", pyra->actual_cpi);	334	return snprintf(buf, PAGE_SIZE, "%d\n", pyra->actual_cpi);
405	}	335	}
406		336
407	static ssize_t pyra_sysfs_show_actual_profile(struct device *dev,	337	static ssize_t pyra_sysfs_show_actual_profile(struct device *dev,
408	struct device_attribute attr, char buf)	338	struct device_attribute attr, char buf)
409	{	339	{
410	struct pyra_device *pyra =	340	struct pyra_device *pyra =
411	hid_get_drvdata(dev_get_drvdata(dev->parent->parent));	341	hid_get_drvdata(dev_get_drvdata(dev->parent->parent));
412	return snprintf(buf, PAGE_SIZE, "%d\n", pyra->actual_profile);	342	return snprintf(buf, PAGE_SIZE, "%d\n", pyra->actual_profile);
413	}	343	}
414		344
415	static ssize_t pyra_sysfs_show_firmware_version(struct device *dev,	345	static ssize_t pyra_sysfs_show_firmware_version(struct device *dev,
416	struct device_attribute attr, char buf)	346	struct device_attribute attr, char buf)
417	{	347	{
418	struct pyra_device *pyra =	348	struct pyra_device *pyra =
419	hid_get_drvdata(dev_get_drvdata(dev->parent->parent));	349	hid_get_drvdata(dev_get_drvdata(dev->parent->parent));
420	return snprintf(buf, PAGE_SIZE, "%d\n", pyra->firmware_version);	350	return snprintf(buf, PAGE_SIZE, "%d\n", pyra->firmware_version);
421	}	351	}
422		352
423	static ssize_t pyra_sysfs_show_startup_profile(struct device *dev,	353	static ssize_t pyra_sysfs_show_startup_profile(struct device *dev,
424	struct device_attribute attr, char buf)	354	struct device_attribute attr, char buf)
425	{	355	{
426	struct pyra_device *pyra =	356	struct pyra_device *pyra =
427	hid_get_drvdata(dev_get_drvdata(dev->parent->parent));	357	hid_get_drvdata(dev_get_drvdata(dev->parent->parent));
428	return snprintf(buf, PAGE_SIZE, "%d\n", pyra->settings.startup_profile);	358	return snprintf(buf, PAGE_SIZE, "%d\n", pyra->settings.startup_profile);
429	}	359	}
430		360
431	static struct device_attribute pyra_attributes[] = {	361	static struct device_attribute pyra_attributes[] = {
432	__ATTR(actual_cpi, 0440, pyra_sysfs_show_actual_cpi, NULL),	362	__ATTR(actual_cpi, 0440, pyra_sysfs_show_actual_cpi, NULL),
433	__ATTR(actual_profile, 0440, pyra_sysfs_show_actual_profile, NULL),	363	__ATTR(actual_profile, 0440, pyra_sysfs_show_actual_profile, NULL),
434	__ATTR(firmware_version, 0440,	364	__ATTR(firmware_version, 0440,
435	pyra_sysfs_show_firmware_version, NULL),	365	pyra_sysfs_show_firmware_version, NULL),
436	__ATTR(startup_profile, 0440,	366	__ATTR(startup_profile, 0440,
437	pyra_sysfs_show_startup_profile, NULL),	367	pyra_sysfs_show_startup_profile, NULL),
438	__ATTR_NULL	368	__ATTR_NULL
439	};	369	};
440		370
441	static struct bin_attribute pyra_bin_attributes[] = {	371	static struct bin_attribute pyra_bin_attributes[] = {
442	{	372	{
443	.attr = { .name = "profile_settings", .mode = 0220 },	373	.attr = { .name = "profile_settings", .mode = 0220 },
444	.size = sizeof(struct pyra_profile_settings),	374	.size = sizeof(struct pyra_profile_settings),
445	.write = pyra_sysfs_write_profile_settings	375	.write = pyra_sysfs_write_profile_settings
446	},	376	},
447	{	377	{
448	.attr = { .name = "profile1_settings", .mode = 0440 },	378	.attr = { .name = "profile1_settings", .mode = 0440 },
449	.size = sizeof(struct pyra_profile_settings),	379	.size = sizeof(struct pyra_profile_settings),
450	.read = pyra_sysfs_read_profilex_settings,	380	.read = pyra_sysfs_read_profilex_settings,
451	.private = &profile_numbers[0]	381	.private = &profile_numbers[0]
452	},	382	},
453	{	383	{
454	.attr = { .name = "profile2_settings", .mode = 0440 },	384	.attr = { .name = "profile2_settings", .mode = 0440 },
455	.size = sizeof(struct pyra_profile_settings),	385	.size = sizeof(struct pyra_profile_settings),
456	.read = pyra_sysfs_read_profilex_settings,	386	.read = pyra_sysfs_read_profilex_settings,
457	.private = &profile_numbers[1]	387	.private = &profile_numbers[1]
458	},	388	},
459	{	389	{
460	.attr = { .name = "profile3_settings", .mode = 0440 },	390	.attr = { .name = "profile3_settings", .mode = 0440 },
461	.size = sizeof(struct pyra_profile_settings),	391	.size = sizeof(struct pyra_profile_settings),
462	.read = pyra_sysfs_read_profilex_settings,	392	.read = pyra_sysfs_read_profilex_settings,
463	.private = &profile_numbers[2]	393	.private = &profile_numbers[2]
464	},	394	},
465	{	395	{
466	.attr = { .name = "profile4_settings", .mode = 0440 },	396	.attr = { .name = "profile4_settings", .mode = 0440 },
467	.size = sizeof(struct pyra_profile_settings),	397	.size = sizeof(struct pyra_profile_settings),
468	.read = pyra_sysfs_read_profilex_settings,	398	.read = pyra_sysfs_read_profilex_settings,
469	.private = &profile_numbers[3]	399	.private = &profile_numbers[3]
470	},	400	},
471	{	401	{
472	.attr = { .name = "profile5_settings", .mode = 0440 },	402	.attr = { .name = "profile5_settings", .mode = 0440 },
473	.size = sizeof(struct pyra_profile_settings),	403	.size = sizeof(struct pyra_profile_settings),
474	.read = pyra_sysfs_read_profilex_settings,	404	.read = pyra_sysfs_read_profilex_settings,
475	.private = &profile_numbers[4]	405	.private = &profile_numbers[4]
476	},	406	},
477	{	407	{
478	.attr = { .name = "profile_buttons", .mode = 0220 },	408	.attr = { .name = "profile_buttons", .mode = 0220 },
479	.size = sizeof(struct pyra_profile_buttons),	409	.size = sizeof(struct pyra_profile_buttons),
480	.write = pyra_sysfs_write_profile_buttons	410	.write = pyra_sysfs_write_profile_buttons
481	},	411	},
482	{	412	{
483	.attr = { .name = "profile1_buttons", .mode = 0440 },	413	.attr = { .name = "profile1_buttons", .mode = 0440 },
484	.size = sizeof(struct pyra_profile_buttons),	414	.size = sizeof(struct pyra_profile_buttons),
485	.read = pyra_sysfs_read_profilex_buttons,	415	.read = pyra_sysfs_read_profilex_buttons,
486	.private = &profile_numbers[0]	416	.private = &profile_numbers[0]
487	},	417	},
488	{	418	{
489	.attr = { .name = "profile2_buttons", .mode = 0440 },	419	.attr = { .name = "profile2_buttons", .mode = 0440 },
490	.size = sizeof(struct pyra_profile_buttons),	420	.size = sizeof(struct pyra_profile_buttons),
491	.read = pyra_sysfs_read_profilex_buttons,	421	.read = pyra_sysfs_read_profilex_buttons,
492	.private = &profile_numbers[1]	422	.private = &profile_numbers[1]
493	},	423	},
494	{	424	{
495	.attr = { .name = "profile3_buttons", .mode = 0440 },	425	.attr = { .name = "profile3_buttons", .mode = 0440 },
496	.size = sizeof(struct pyra_profile_buttons),	426	.size = sizeof(struct pyra_profile_buttons),
497	.read = pyra_sysfs_read_profilex_buttons,	427	.read = pyra_sysfs_read_profilex_buttons,
498	.private = &profile_numbers[2]	428	.private = &profile_numbers[2]
499	},	429	},
500	{	430	{
501	.attr = { .name = "profile4_buttons", .mode = 0440 },	431	.attr = { .name = "profile4_buttons", .mode = 0440 },
502	.size = sizeof(struct pyra_profile_buttons),	432	.size = sizeof(struct pyra_profile_buttons),
503	.read = pyra_sysfs_read_profilex_buttons,	433	.read = pyra_sysfs_read_profilex_buttons,
504	.private = &profile_numbers[3]	434	.private = &profile_numbers[3]
505	},	435	},
506	{	436	{
507	.attr = { .name = "profile5_buttons", .mode = 0440 },	437	.attr = { .name = "profile5_buttons", .mode = 0440 },
508	.size = sizeof(struct pyra_profile_buttons),	438	.size = sizeof(struct pyra_profile_buttons),
509	.read = pyra_sysfs_read_profilex_buttons,	439	.read = pyra_sysfs_read_profilex_buttons,
510	.private = &profile_numbers[4]	440	.private = &profile_numbers[4]
511	},	441	},
512	{	442	{
513	.attr = { .name = "settings", .mode = 0660 },	443	.attr = { .name = "settings", .mode = 0660 },
514	.size = sizeof(struct pyra_settings),	444	.size = sizeof(struct pyra_settings),
515	.read = pyra_sysfs_read_settings,	445	.read = pyra_sysfs_read_settings,
516	.write = pyra_sysfs_write_settings	446	.write = pyra_sysfs_write_settings
517	},	447	},
518	__ATTR_NULL	448	__ATTR_NULL
519	};	449	};
520		450
521	static int pyra_init_pyra_device_struct(struct usb_device *usb_dev,	451	static int pyra_init_pyra_device_struct(struct usb_device *usb_dev,
522	struct pyra_device *pyra)	452	struct pyra_device *pyra)
523	{	453	{
524	struct pyra_info *info;	454	struct pyra_info info;
525	int retval, i;	455	int retval, i;
526		456
527	mutex_init(&pyra->pyra_lock);	457	mutex_init(&pyra->pyra_lock);
528		458
529	info = kmalloc(sizeof(struct pyra_info), GFP_KERNEL);	459	retval = pyra_get_info(usb_dev, &info);
530	if (!info)	460	if (retval)
531	return -ENOMEM;
532	retval = pyra_get_info(usb_dev, info);
533	if (retval) {
534	kfree(info);
535	return retval;	461	return retval;
536	}	462
537	pyra->firmware_version = info->firmware_version;	463	pyra->firmware_version = info.firmware_version;
538	kfree(info);
539		464
540	retval = pyra_get_settings(usb_dev, &pyra->settings);	465	retval = pyra_get_settings(usb_dev, &pyra->settings);
541	if (retval)	466	if (retval)
542	return retval;	467	return retval;
543		468
544	for (i = 0; i < 5; ++i) {	469	for (i = 0; i < 5; ++i) {
545	retval = pyra_get_profile_settings(usb_dev,	470	retval = pyra_get_profile_settings(usb_dev,
546	&pyra->profile_settings[i], i);	471	&pyra->profile_settings[i], i);
547	if (retval)	472	if (retval)
548	return retval;	473	return retval;
549		474
550	retval = pyra_get_profile_buttons(usb_dev,	475	retval = pyra_get_profile_buttons(usb_dev,
551	&pyra->profile_buttons[i], i);	476	&pyra->profile_buttons[i], i);
552	if (retval)	477	if (retval)
553	return retval;	478	return retval;
554	}	479	}
555		480
556	profile_activated(pyra, pyra->settings.startup_profile);	481	profile_activated(pyra, pyra->settings.startup_profile);
557		482
558	return 0;	483	return 0;
559	}	484	}
560		485
561	static int pyra_init_specials(struct hid_device *hdev)	486	static int pyra_init_specials(struct hid_device *hdev)
562	{	487	{
563	struct usb_interface *intf = to_usb_interface(hdev->dev.parent);	488	struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
564	struct usb_device *usb_dev = interface_to_usbdev(intf);	489	struct usb_device *usb_dev = interface_to_usbdev(intf);
565	struct pyra_device *pyra;	490	struct pyra_device *pyra;
566	int retval;	491	int retval;
567		492
568	if (intf->cur_altsetting->desc.bInterfaceProtocol	493	if (intf->cur_altsetting->desc.bInterfaceProtocol
569	== USB_INTERFACE_PROTOCOL_MOUSE) {	494	== USB_INTERFACE_PROTOCOL_MOUSE) {
570		495
571	pyra = kzalloc(sizeof(*pyra), GFP_KERNEL);	496	pyra = kzalloc(sizeof(*pyra), GFP_KERNEL);
572	if (!pyra) {	497	if (!pyra) {
573	hid_err(hdev, "can't alloc device descriptor\n");	498	hid_err(hdev, "can't alloc device descriptor\n");
574	return -ENOMEM;	499	return -ENOMEM;
575	}	500	}
576	hid_set_drvdata(hdev, pyra);	501	hid_set_drvdata(hdev, pyra);
577		502
578	retval = pyra_init_pyra_device_struct(usb_dev, pyra);	503	retval = pyra_init_pyra_device_struct(usb_dev, pyra);
579	if (retval) {	504	if (retval) {
580	hid_err(hdev, "couldn't init struct pyra_device\n");	505	hid_err(hdev, "couldn't init struct pyra_device\n");
581	goto exit_free;	506	goto exit_free;
582	}	507	}
583		508
584	retval = roccat_connect(pyra_class, hdev);	509	retval = roccat_connect(pyra_class, hdev);
585	if (retval < 0) {	510	if (retval < 0) {
586	hid_err(hdev, "couldn't init char dev\n");	511	hid_err(hdev, "couldn't init char dev\n");
587	} else {	512	} else {
588	pyra->chrdev_minor = retval;	513	pyra->chrdev_minor = retval;
589	pyra->roccat_claimed = 1;	514	pyra->roccat_claimed = 1;
590	}	515	}
591	} else {	516	} else {
592	hid_set_drvdata(hdev, NULL);	517	hid_set_drvdata(hdev, NULL);
593	}	518	}
594		519
595	return 0;	520	return 0;
596	exit_free:	521	exit_free:
597	kfree(pyra);	522	kfree(pyra);
598	return retval;	523	return retval;
599	}	524	}
600		525
601	static void pyra_remove_specials(struct hid_device *hdev)	526	static void pyra_remove_specials(struct hid_device *hdev)
602	{	527	{
603	struct usb_interface *intf = to_usb_interface(hdev->dev.parent);	528	struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
604	struct pyra_device *pyra;	529	struct pyra_device *pyra;
605		530
606	if (intf->cur_altsetting->desc.bInterfaceProtocol	531	if (intf->cur_altsetting->desc.bInterfaceProtocol
607	== USB_INTERFACE_PROTOCOL_MOUSE) {	532	== USB_INTERFACE_PROTOCOL_MOUSE) {
608	pyra = hid_get_drvdata(hdev);	533	pyra = hid_get_drvdata(hdev);
609	if (pyra->roccat_claimed)	534	if (pyra->roccat_claimed)
610	roccat_disconnect(pyra->chrdev_minor);	535	roccat_disconnect(pyra->chrdev_minor);
611	kfree(hid_get_drvdata(hdev));	536	kfree(hid_get_drvdata(hdev));
612	}	537	}
613	}	538	}
614		539
615	static int pyra_probe(struct hid_device hdev, const struct hid_device_id id)	540	static int pyra_probe(struct hid_device hdev, const struct hid_device_id id)
616	{	541	{
617	int retval;	542	int retval;
618		543
619	retval = hid_parse(hdev);	544	retval = hid_parse(hdev);
620	if (retval) {	545	if (retval) {
621	hid_err(hdev, "parse failed\n");	546	hid_err(hdev, "parse failed\n");
622	goto exit;	547	goto exit;
623	}	548	}
624		549
625	retval = hid_hw_start(hdev, HID_CONNECT_DEFAULT);	550	retval = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
626	if (retval) {	551	if (retval) {
627	hid_err(hdev, "hw start failed\n");	552	hid_err(hdev, "hw start failed\n");
628	goto exit;	553	goto exit;
629	}	554	}
630		555
631	retval = pyra_init_specials(hdev);	556	retval = pyra_init_specials(hdev);
632	if (retval) {	557	if (retval) {
633	hid_err(hdev, "couldn't install mouse\n");	558	hid_err(hdev, "couldn't install mouse\n");
634	goto exit_stop;	559	goto exit_stop;
635	}	560	}
636	return 0;	561	return 0;
637		562
638	exit_stop:	563	exit_stop:
639	hid_hw_stop(hdev);	564	hid_hw_stop(hdev);
640	exit:	565	exit:
641	return retval;	566	return retval;
642	}	567	}
643		568
644	static void pyra_remove(struct hid_device *hdev)	569	static void pyra_remove(struct hid_device *hdev)
645	{	570	{
646	pyra_remove_specials(hdev);	571	pyra_remove_specials(hdev);
647	hid_hw_stop(hdev);	572	hid_hw_stop(hdev);
648	}	573	}
649		574
650	static void pyra_keep_values_up_to_date(struct pyra_device *pyra,	575	static void pyra_keep_values_up_to_date(struct pyra_device *pyra,
651	u8 const *data)	576	u8 const *data)
652	{	577	{
653	struct pyra_mouse_event_button const *button_event;	578	struct pyra_mouse_event_button const *button_event;
654		579
655	switch (data[0]) {	580	switch (data[0]) {
656	case PYRA_MOUSE_REPORT_NUMBER_BUTTON:	581	case PYRA_MOUSE_REPORT_NUMBER_BUTTON:
657	button_event = (struct pyra_mouse_event_button const *)data;	582	button_event = (struct pyra_mouse_event_button const *)data;
658	switch (button_event->type) {	583	switch (button_event->type) {
659	case PYRA_MOUSE_EVENT_BUTTON_TYPE_PROFILE_2:	584	case PYRA_MOUSE_EVENT_BUTTON_TYPE_PROFILE_2:
660	profile_activated(pyra, button_event->data1 - 1);	585	profile_activated(pyra, button_event->data1 - 1);
661	break;	586	break;
662	case PYRA_MOUSE_EVENT_BUTTON_TYPE_CPI:	587	case PYRA_MOUSE_EVENT_BUTTON_TYPE_CPI:
663	pyra->actual_cpi = button_event->data1;	588	pyra->actual_cpi = button_event->data1;
664	break;	589	break;
665	}	590	}
666	break;	591	break;
667	}	592	}
668	}	593	}
669		594
670	static void pyra_report_to_chrdev(struct pyra_device const *pyra,	595	static void pyra_report_to_chrdev(struct pyra_device const *pyra,
671	u8 const *data)	596	u8 const *data)
672	{	597	{
673	struct pyra_roccat_report roccat_report;	598	struct pyra_roccat_report roccat_report;
674	struct pyra_mouse_event_button const *button_event;	599	struct pyra_mouse_event_button const *button_event;
675		600
676	if (data[0] != PYRA_MOUSE_REPORT_NUMBER_BUTTON)	601	if (data[0] != PYRA_MOUSE_REPORT_NUMBER_BUTTON)
677	return;	602	return;
678		603
679	button_event = (struct pyra_mouse_event_button const *)data;	604	button_event = (struct pyra_mouse_event_button const *)data;
680		605
681	switch (button_event->type) {	606	switch (button_event->type) {
682	case PYRA_MOUSE_EVENT_BUTTON_TYPE_PROFILE_2:	607	case PYRA_MOUSE_EVENT_BUTTON_TYPE_PROFILE_2:
683	case PYRA_MOUSE_EVENT_BUTTON_TYPE_CPI:	608	case PYRA_MOUSE_EVENT_BUTTON_TYPE_CPI:
684	roccat_report.type = button_event->type;	609	roccat_report.type = button_event->type;
685	roccat_report.value = button_event->data1;	610	roccat_report.value = button_event->data1;
686	roccat_report.key = 0;	611	roccat_report.key = 0;
687	roccat_report_event(pyra->chrdev_minor,	612	roccat_report_event(pyra->chrdev_minor,
688	(uint8_t const *)&roccat_report,	613	(uint8_t const *)&roccat_report,
689	sizeof(struct pyra_roccat_report));	614	sizeof(struct pyra_roccat_report));
690	break;	615	break;
691	case PYRA_MOUSE_EVENT_BUTTON_TYPE_MACRO:	616	case PYRA_MOUSE_EVENT_BUTTON_TYPE_MACRO:
692	case PYRA_MOUSE_EVENT_BUTTON_TYPE_SHORTCUT:	617	case PYRA_MOUSE_EVENT_BUTTON_TYPE_SHORTCUT:
693	case PYRA_MOUSE_EVENT_BUTTON_TYPE_QUICKLAUNCH:	618	case PYRA_MOUSE_EVENT_BUTTON_TYPE_QUICKLAUNCH:
694	if (button_event->data2 == PYRA_MOUSE_EVENT_BUTTON_PRESS) {	619	if (button_event->data2 == PYRA_MOUSE_EVENT_BUTTON_PRESS) {
695	roccat_report.type = button_event->type;	620	roccat_report.type = button_event->type;
696	roccat_report.key = button_event->data1;	621	roccat_report.key = button_event->data1;
697	/*	622	/*
698	* pyra reports profile numbers with range 1-5.	623	* pyra reports profile numbers with range 1-5.
699	* Keeping this behaviour.	624	* Keeping this behaviour.
700	*/	625	*/
701	roccat_report.value = pyra->actual_profile + 1;	626	roccat_report.value = pyra->actual_profile + 1;
702	roccat_report_event(pyra->chrdev_minor,	627	roccat_report_event(pyra->chrdev_minor,
703	(uint8_t const *)&roccat_report,	628	(uint8_t const *)&roccat_report,
704	sizeof(struct pyra_roccat_report));	629	sizeof(struct pyra_roccat_report));
705	}	630	}
706	break;	631	break;
707	}	632	}
708	}	633	}
709		634
710	static int pyra_raw_event(struct hid_device hdev, struct hid_report report,	635	static int pyra_raw_event(struct hid_device hdev, struct hid_report report,
711	u8 *data, int size)	636	u8 *data, int size)
712	{	637	{
713	struct usb_interface *intf = to_usb_interface(hdev->dev.parent);	638	struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
714	struct pyra_device *pyra = hid_get_drvdata(hdev);	639	struct pyra_device *pyra = hid_get_drvdata(hdev);
715		640
716	if (intf->cur_altsetting->desc.bInterfaceProtocol	641	if (intf->cur_altsetting->desc.bInterfaceProtocol
717	!= USB_INTERFACE_PROTOCOL_MOUSE)	642	!= USB_INTERFACE_PROTOCOL_MOUSE)
718	return 0;	643	return 0;
719		644
720	pyra_keep_values_up_to_date(pyra, data);	645	pyra_keep_values_up_to_date(pyra, data);
721		646
722	if (pyra->roccat_claimed)	647	if (pyra->roccat_claimed)
723	pyra_report_to_chrdev(pyra, data);	648	pyra_report_to_chrdev(pyra, data);
724		649
725	return 0;	650	return 0;
726	}	651	}
727		652
728	static const struct hid_device_id pyra_devices[] = {	653	static const struct hid_device_id pyra_devices[] = {
729	{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT,	654	{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT,
730	USB_DEVICE_ID_ROCCAT_PYRA_WIRED) },	655	USB_DEVICE_ID_ROCCAT_PYRA_WIRED) },
731	/* TODO add USB_DEVICE_ID_ROCCAT_PYRA_WIRELESS after testing */	656	/* TODO add USB_DEVICE_ID_ROCCAT_PYRA_WIRELESS after testing */
732	{ }	657	{ }
733	};	658	};
734		659
735	MODULE_DEVICE_TABLE(hid, pyra_devices);	660	MODULE_DEVICE_TABLE(hid, pyra_devices);
736		661
737	static struct hid_driver pyra_driver = {	662	static struct hid_driver pyra_driver = {
738	.name = "pyra",	663	.name = "pyra",
739	.id_table = pyra_devices,	664	.id_table = pyra_devices,
740	.probe = pyra_probe,	665	.probe = pyra_probe,
741	.remove = pyra_remove,	666	.remove = pyra_remove,
742	.raw_event = pyra_raw_event	667	.raw_event = pyra_raw_event
743	};	668	};
744		669
745	static int __init pyra_init(void)	670	static int __init pyra_init(void)
746	{	671	{
747	int retval;	672	int retval;
748		673
749	/* class name has to be same as driver name */	674	/* class name has to be same as driver name */
750	pyra_class = class_create(THIS_MODULE, "pyra");	675	pyra_class = class_create(THIS_MODULE, "pyra");
751	if (IS_ERR(pyra_class))	676	if (IS_ERR(pyra_class))
752	return PTR_ERR(pyra_class);	677	return PTR_ERR(pyra_class);
753	pyra_class->dev_attrs = pyra_attributes;	678	pyra_class->dev_attrs = pyra_attributes;
754	pyra_class->dev_bin_attrs = pyra_bin_attributes;	679	pyra_class->dev_bin_attrs = pyra_bin_attributes;
755		680
756	retval = hid_register_driver(&pyra_driver);	681	retval = hid_register_driver(&pyra_driver);
757	if (retval)	682	if (retval)
758	class_destroy(pyra_class);	683	class_destroy(pyra_class);
759	return retval;	684	return retval;
760	}	685	}
761		686