// SPDX-License-Identifier: GPL-2.0-or-later /* * imon.c: input and display driver for SoundGraph iMON IR/VFD/LCD * * Copyright(C) 2010 Jarod Wilson <[email protected]> * Portions based on the original lirc_imon driver, * Copyright(C) 2004 Venky Raju([email protected]) * * Huge thanks to R. Geoff Newbury for invaluable debugging on the * 0xffdc iMON devices, and for sending me one to hack on, without * which the support for them wouldn't be nearly as good. Thanks * also to the numerous 0xffdc device owners that tested auto-config * support for me and provided debug dumps from their devices. */ #define pr_fmt(fmt) … #include <linux/errno.h> #include <linux/init.h> #include <linux/kernel.h> #include <linux/ktime.h> #include <linux/module.h> #include <linux/slab.h> #include <linux/uaccess.h> #include <linux/ratelimit.h> #include <linux/input.h> #include <linux/usb.h> #include <linux/usb/input.h> #include <media/rc-core.h> #include <linux/timer.h> #define MOD_AUTHOR … #define MOD_DESC … #define MOD_NAME … #define MOD_VERSION … #define DISPLAY_MINOR_BASE … #define DEVICE_NAME … #define BUF_CHUNK_SIZE … #define BUF_SIZE … #define BIT_DURATION … #define IMON_CLOCK_ENABLE_PACKETS … /*** P R O T O T Y P E S ***/ /* USB Callback prototypes */ static int imon_probe(struct usb_interface *interface, const struct usb_device_id *id); static void imon_disconnect(struct usb_interface *interface); static void usb_rx_callback_intf0(struct urb *urb); static void usb_rx_callback_intf1(struct urb *urb); static void usb_tx_callback(struct urb *urb); /* suspend/resume support */ static int imon_resume(struct usb_interface *intf); static int imon_suspend(struct usb_interface *intf, pm_message_t message); /* Display file_operations function prototypes */ static int display_open(struct inode *inode, struct file *file); static int display_close(struct inode *inode, struct file *file); /* VFD write operation */ static ssize_t vfd_write(struct file *file, const char __user *buf, size_t n_bytes, loff_t *pos); /* LCD file_operations override function prototypes */ static ssize_t lcd_write(struct file *file, const char __user *buf, size_t n_bytes, loff_t *pos); /*** G L O B A L S ***/ struct imon_panel_key_table { … }; struct imon_usb_dev_descr { … }; struct imon_context { … }; #define TOUCH_TIMEOUT … /* vfd character device file operations */ static const struct file_operations vfd_fops = …; /* lcd character device file operations */ static const struct file_operations lcd_fops = …; enum { … }; enum { … }; static struct usb_class_driver imon_vfd_class = …; static struct usb_class_driver imon_lcd_class = …; /* imon receiver front panel/knob key table */ static const struct imon_usb_dev_descr imon_default_table = …; static const struct imon_usb_dev_descr imon_OEM_VFD = …; /* imon receiver front panel/knob key table for DH102*/ static const struct imon_usb_dev_descr imon_DH102 = …; /* imon ultrabay front panel key table */ static const struct imon_usb_dev_descr ultrabay_table = …; /* * USB Device ID for iMON USB Control Boards * * The Windows drivers contain 6 different inf files, more or less one for * each new device until the 0x0034-0x0046 devices, which all use the same * driver. Some of the devices in the 34-46 range haven't been definitively * identified yet. Early devices have either a TriGem Computer, Inc. or a * Samsung vendor ID (0x0aa8 and 0x04e8 respectively), while all later * devices use the SoundGraph vendor ID (0x15c2). This driver only supports * the ffdc and later devices, which do onboard decoding. */ static const struct usb_device_id imon_usb_id_table[] = …; /* USB Device data */ static struct usb_driver imon_driver = …; /* Module bookkeeping bits */ MODULE_AUTHOR(…); MODULE_DESCRIPTION(…); MODULE_VERSION(…); MODULE_LICENSE(…) …; MODULE_DEVICE_TABLE(usb, imon_usb_id_table); static bool debug; module_param(debug, bool, S_IRUGO | S_IWUSR); MODULE_PARM_DESC(…) …; /* lcd, vfd, vga or none? should be auto-detected, but can be overridden... */ static int display_type; module_param(display_type, int, S_IRUGO); MODULE_PARM_DESC(…) …; static int pad_stabilize = …; module_param(pad_stabilize, int, S_IRUGO | S_IWUSR); MODULE_PARM_DESC(…) …; /* * In certain use cases, mouse mode isn't really helpful, and could actually * cause confusion, so allow disabling it when the IR device is open. */ static bool nomouse; module_param(nomouse, bool, S_IRUGO | S_IWUSR); MODULE_PARM_DESC(…) …; /* threshold at which a pad push registers as an arrow key in kbd mode */ static int pad_thresh; module_param(pad_thresh, int, S_IRUGO | S_IWUSR); MODULE_PARM_DESC(…) …; static void free_imon_context(struct imon_context *ictx) { … } /* * Called when the Display device (e.g. /dev/lcd0) * is opened by the application. */ static int display_open(struct inode *inode, struct file *file) { … } /* * Called when the display device (e.g. /dev/lcd0) * is closed by the application. */ static int display_close(struct inode *inode, struct file *file) { … } /* * Sends a packet to the device -- this function must be called with * ictx->lock held, or its unlock/lock sequence while waiting for tx * to complete can/will lead to a deadlock. */ static int send_packet(struct imon_context *ictx) { … } /* * Sends an associate packet to the iMON 2.4G. * * This might not be such a good idea, since it has an id collision with * some versions of the "IR & VFD" combo. The only way to determine if it * is an RF version is to look at the product description string. (Which * we currently do not fetch). */ static int send_associate_24g(struct imon_context *ictx) { … } /* * Sends packets to setup and show clock on iMON display * * Arguments: year - last 2 digits of year, month - 1..12, * day - 1..31, dow - day of the week (0-Sun...6-Sat), * hour - 0..23, minute - 0..59, second - 0..59 */ static int send_set_imon_clock(struct imon_context *ictx, unsigned int year, unsigned int month, unsigned int day, unsigned int dow, unsigned int hour, unsigned int minute, unsigned int second) { … } /* * These are the sysfs functions to handle the association on the iMON 2.4G LT. */ static ssize_t associate_remote_show(struct device *d, struct device_attribute *attr, char *buf) { … } static ssize_t associate_remote_store(struct device *d, struct device_attribute *attr, const char *buf, size_t count) { … } /* * sysfs functions to control internal imon clock */ static ssize_t imon_clock_show(struct device *d, struct device_attribute *attr, char *buf) { … } static ssize_t imon_clock_store(struct device *d, struct device_attribute *attr, const char *buf, size_t count) { … } static DEVICE_ATTR_RW(imon_clock); static DEVICE_ATTR_RW(associate_remote); static struct attribute *imon_display_sysfs_entries[] = …; static const struct attribute_group imon_display_attr_group = …; static struct attribute *imon_rf_sysfs_entries[] = …; static const struct attribute_group imon_rf_attr_group = …; /* * Writes data to the VFD. The iMON VFD is 2x16 characters * and requires data in 5 consecutive USB interrupt packets, * each packet but the last carrying 7 bytes. * * I don't know if the VFD board supports features such as * scrolling, clearing rows, blanking, etc. so at * the caller must provide a full screen of data. If fewer * than 32 bytes are provided spaces will be appended to * generate a full screen. */ static ssize_t vfd_write(struct file *file, const char __user *buf, size_t n_bytes, loff_t *pos) { … } /* * Writes data to the LCD. The iMON OEM LCD screen expects 8-byte * packets. We accept data as 16 hexadecimal digits, followed by a * newline (to make it easy to drive the device from a command-line * -- even though the actual binary data is a bit complicated). * * The device itself is not a "traditional" text-mode display. It's * actually a 16x96 pixel bitmap display. That means if you want to * display text, you've got to have your own "font" and translate the * text into bitmaps for display. This is really flexible (you can * display whatever diacritics you need, and so on), but it's also * a lot more complicated than most LCDs... */ static ssize_t lcd_write(struct file *file, const char __user *buf, size_t n_bytes, loff_t *pos) { … } /* * Callback function for USB core API: transmit data */ static void usb_tx_callback(struct urb *urb) { … } /* * report touchscreen input */ static void imon_touch_display_timeout(struct timer_list *t) { … } /* * iMON IR receivers support two different signal sets -- those used by * the iMON remotes, and those used by the Windows MCE remotes (which is * really just RC-6), but only one or the other at a time, as the signals * are decoded onboard the receiver. * * This function gets called two different ways, one way is from * rc_register_device, for initial protocol selection/setup, and the other is * via a userspace-initiated protocol change request, either by direct sysfs * prodding or by something like ir-keytable. In the rc_register_device case, * the imon context lock is already held, but when initiated from userspace, * it is not, so we must acquire it prior to calling send_packet, which * requires that the lock is held. */ static int imon_ir_change_protocol(struct rc_dev *rc, u64 *rc_proto) { … } /* * The directional pad behaves a bit differently, depending on whether this is * one of the older ffdc devices or a newer device. Newer devices appear to * have a higher resolution matrix for more precise mouse movement, but it * makes things overly sensitive in keyboard mode, so we do some interesting * contortions to make it less touchy. Older devices run through the same * routine with shorter timeout and a smaller threshold. */ static int stabilize(int a, int b, u16 timeout, u16 threshold) { … } static u32 imon_remote_key_lookup(struct imon_context *ictx, u32 scancode) { … } static u32 imon_mce_key_lookup(struct imon_context *ictx, u32 scancode) { … } static u32 imon_panel_key_lookup(struct imon_context *ictx, u64 code) { … } static bool imon_mouse_event(struct imon_context *ictx, unsigned char *buf, int len) { … } static void imon_touch_event(struct imon_context *ictx, unsigned char *buf) { … } static void imon_pad_to_keys(struct imon_context *ictx, unsigned char *buf) { … } /* * figure out if these is a press or a release. We don't actually * care about repeats, as those will be auto-generated within the IR * subsystem for repeating scancodes. */ static int imon_parse_press_type(struct imon_context *ictx, unsigned char *buf, u8 ktype) { … } /* * Process the incoming packet */ static void imon_incoming_packet(struct imon_context *ictx, struct urb *urb, int intf) { … } /* * Callback function for USB core API: receive data */ static void usb_rx_callback_intf0(struct urb *urb) { … } static void usb_rx_callback_intf1(struct urb *urb) { … } /* * The 0x15c2:0xffdc device ID was used for umpteen different imon * devices, and all of them constantly spew interrupts, even when there * is no actual data to report. However, byte 6 of this buffer looks like * its unique across device variants, so we're trying to key off that to * figure out which display type (if any) and what IR protocol the device * actually supports. These devices have their IR protocol hard-coded into * their firmware, they can't be changed on the fly like the newer hardware. */ static void imon_get_ffdc_type(struct imon_context *ictx) { … } static void imon_set_display_type(struct imon_context *ictx) { … } static struct rc_dev *imon_init_rdev(struct imon_context *ictx) { … } static struct input_dev *imon_init_idev(struct imon_context *ictx) { … } static struct input_dev *imon_init_touch(struct imon_context *ictx) { … } static bool imon_find_endpoints(struct imon_context *ictx, struct usb_host_interface *iface_desc) { … } static struct imon_context *imon_init_intf0(struct usb_interface *intf, const struct usb_device_id *id) { … } static struct imon_context *imon_init_intf1(struct usb_interface *intf, struct imon_context *ictx) { … } static void imon_init_display(struct imon_context *ictx, struct usb_interface *intf) { … } /* * Callback function for USB core API: Probe */ static int imon_probe(struct usb_interface *interface, const struct usb_device_id *id) { … } /* * Callback function for USB core API: disconnect */ static void imon_disconnect(struct usb_interface *interface) { … } static int imon_suspend(struct usb_interface *intf, pm_message_t message) { … } static int imon_resume(struct usb_interface *intf) { … } module_usb_driver(…) …;
Codebase Browser
linux