Linux Audio

Check our new training course

Loading...
v3.1
  1/*
  2 * Support for the Maxtor OneTouch USB hard drive's button
  3 *
  4 * Current development and maintenance by:
  5 *	Copyright (c) 2005 Nick Sillik <n.sillik@temple.edu>
  6 *
  7 * Initial work by:
  8 *	Copyright (c) 2003 Erik Thyren <erth7411@student.uu.se>
  9 *
 10 * Based on usbmouse.c (Vojtech Pavlik) and xpad.c (Marko Friedemann)
 11 *
 12 */
 13
 14/*
 15 * This program is free software; you can redistribute it and/or modify
 16 * it under the terms of the GNU General Public License as published by
 17 * the Free Software Foundation; either version 2 of the License, or
 18 * (at your option) any later version.
 19 *
 20 * This program is distributed in the hope that it will be useful,
 21 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 23 * GNU General Public License for more details.
 24 *
 25 * You should have received a copy of the GNU General Public License
 26 * along with this program; if not, write to the Free Software
 27 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 28 *
 29 */
 30
 31#include <linux/kernel.h>
 32#include <linux/input.h>
 33#include <linux/init.h>
 34#include <linux/slab.h>
 35#include <linux/module.h>
 36#include <linux/usb/input.h>
 37#include "usb.h"
 38#include "debug.h"
 39
 40MODULE_DESCRIPTION("Maxtor USB OneTouch hard drive button driver");
 41MODULE_AUTHOR("Nick Sillik <n.sillik@temple.edu>");
 42MODULE_LICENSE("GPL");
 43
 44#define ONETOUCH_PKT_LEN        0x02
 45#define ONETOUCH_BUTTON         KEY_PROG1
 46
 47static int onetouch_connect_input(struct us_data *ss);
 48static void onetouch_release_input(void *onetouch_);
 49
 50struct usb_onetouch {
 51	char name[128];
 52	char phys[64];
 53	struct input_dev *dev;	/* input device interface */
 54	struct usb_device *udev;	/* usb device */
 55
 56	struct urb *irq;	/* urb for interrupt in report */
 57	unsigned char *data;	/* input data */
 58	dma_addr_t data_dma;
 59	unsigned int is_open:1;
 60};
 61
 62
 63/*
 64 * The table of devices
 65 */
 66#define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
 67		    vendorName, productName, useProtocol, useTransport, \
 68		    initFunction, flags) \
 69{ USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
 70  .driver_info = (flags)|(USB_US_TYPE_STOR<<24) }
 71
 72struct usb_device_id onetouch_usb_ids[] = {
 73#	include "unusual_onetouch.h"
 74	{ }		/* Terminating entry */
 75};
 76MODULE_DEVICE_TABLE(usb, onetouch_usb_ids);
 77
 78#undef UNUSUAL_DEV
 79
 80/*
 81 * The flags table
 82 */
 83#define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \
 84		    vendor_name, product_name, use_protocol, use_transport, \
 85		    init_function, Flags) \
 86{ \
 87	.vendorName = vendor_name,	\
 88	.productName = product_name,	\
 89	.useProtocol = use_protocol,	\
 90	.useTransport = use_transport,	\
 91	.initFunction = init_function,	\
 92}
 93
 94static struct us_unusual_dev onetouch_unusual_dev_list[] = {
 95#	include "unusual_onetouch.h"
 96	{ }		/* Terminating entry */
 97};
 98
 99#undef UNUSUAL_DEV
100
101
102static void usb_onetouch_irq(struct urb *urb)
103{
104	struct usb_onetouch *onetouch = urb->context;
105	signed char *data = onetouch->data;
106	struct input_dev *dev = onetouch->dev;
107	int status = urb->status;
108	int retval;
109
110	switch (status) {
111	case 0:			/* success */
112		break;
113	case -ECONNRESET:	/* unlink */
114	case -ENOENT:
115	case -ESHUTDOWN:
116		return;
117	/* -EPIPE:  should clear the halt */
118	default:		/* error */
119		goto resubmit;
120	}
121
122	input_report_key(dev, ONETOUCH_BUTTON, data[0] & 0x02);
123	input_sync(dev);
124
125resubmit:
126	retval = usb_submit_urb (urb, GFP_ATOMIC);
127	if (retval)
128		dev_err(&dev->dev, "can't resubmit intr, %s-%s/input0, "
129			"retval %d\n", onetouch->udev->bus->bus_name,
130			onetouch->udev->devpath, retval);
131}
132
133static int usb_onetouch_open(struct input_dev *dev)
134{
135	struct usb_onetouch *onetouch = input_get_drvdata(dev);
136
137	onetouch->is_open = 1;
138	onetouch->irq->dev = onetouch->udev;
139	if (usb_submit_urb(onetouch->irq, GFP_KERNEL)) {
140		dev_err(&dev->dev, "usb_submit_urb failed\n");
141		return -EIO;
142	}
143
144	return 0;
145}
146
147static void usb_onetouch_close(struct input_dev *dev)
148{
149	struct usb_onetouch *onetouch = input_get_drvdata(dev);
150
151	usb_kill_urb(onetouch->irq);
152	onetouch->is_open = 0;
153}
154
155#ifdef CONFIG_PM
156static void usb_onetouch_pm_hook(struct us_data *us, int action)
157{
158	struct usb_onetouch *onetouch = (struct usb_onetouch *) us->extra;
159
160	if (onetouch->is_open) {
161		switch (action) {
162		case US_SUSPEND:
163			usb_kill_urb(onetouch->irq);
164			break;
165		case US_RESUME:
166			if (usb_submit_urb(onetouch->irq, GFP_NOIO) != 0)
167				dev_err(&onetouch->irq->dev->dev,
168					"usb_submit_urb failed\n");
169			break;
170		default:
171			break;
172		}
173	}
174}
175#endif /* CONFIG_PM */
176
177static int onetouch_connect_input(struct us_data *ss)
178{
179	struct usb_device *udev = ss->pusb_dev;
180	struct usb_host_interface *interface;
181	struct usb_endpoint_descriptor *endpoint;
182	struct usb_onetouch *onetouch;
183	struct input_dev *input_dev;
184	int pipe, maxp;
185	int error = -ENOMEM;
186
187	interface = ss->pusb_intf->cur_altsetting;
188
189	if (interface->desc.bNumEndpoints != 3)
190		return -ENODEV;
191
192	endpoint = &interface->endpoint[2].desc;
193	if (!usb_endpoint_is_int_in(endpoint))
194		return -ENODEV;
195
196	pipe = usb_rcvintpipe(udev, endpoint->bEndpointAddress);
197	maxp = usb_maxpacket(udev, pipe, usb_pipeout(pipe));
 
198
199	onetouch = kzalloc(sizeof(struct usb_onetouch), GFP_KERNEL);
200	input_dev = input_allocate_device();
201	if (!onetouch || !input_dev)
202		goto fail1;
203
204	onetouch->data = usb_alloc_coherent(udev, ONETOUCH_PKT_LEN,
205					    GFP_KERNEL, &onetouch->data_dma);
206	if (!onetouch->data)
207		goto fail1;
208
209	onetouch->irq = usb_alloc_urb(0, GFP_KERNEL);
210	if (!onetouch->irq)
211		goto fail2;
212
213	onetouch->udev = udev;
214	onetouch->dev = input_dev;
215
216	if (udev->manufacturer)
217		strlcpy(onetouch->name, udev->manufacturer,
218			sizeof(onetouch->name));
219	if (udev->product) {
220		if (udev->manufacturer)
221			strlcat(onetouch->name, " ", sizeof(onetouch->name));
222		strlcat(onetouch->name, udev->product, sizeof(onetouch->name));
223	}
224
225	if (!strlen(onetouch->name))
226		snprintf(onetouch->name, sizeof(onetouch->name),
227			 "Maxtor Onetouch %04x:%04x",
228			 le16_to_cpu(udev->descriptor.idVendor),
229			 le16_to_cpu(udev->descriptor.idProduct));
230
231	usb_make_path(udev, onetouch->phys, sizeof(onetouch->phys));
232	strlcat(onetouch->phys, "/input0", sizeof(onetouch->phys));
233
234	input_dev->name = onetouch->name;
235	input_dev->phys = onetouch->phys;
236	usb_to_input_id(udev, &input_dev->id);
237	input_dev->dev.parent = &udev->dev;
238
239	set_bit(EV_KEY, input_dev->evbit);
240	set_bit(ONETOUCH_BUTTON, input_dev->keybit);
241	clear_bit(0, input_dev->keybit);
242
243	input_set_drvdata(input_dev, onetouch);
244
245	input_dev->open = usb_onetouch_open;
246	input_dev->close = usb_onetouch_close;
247
248	usb_fill_int_urb(onetouch->irq, udev, pipe, onetouch->data,
249			 (maxp > 8 ? 8 : maxp),
250			 usb_onetouch_irq, onetouch, endpoint->bInterval);
251	onetouch->irq->transfer_dma = onetouch->data_dma;
252	onetouch->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
253
254	ss->extra_destructor = onetouch_release_input;
255	ss->extra = onetouch;
256#ifdef CONFIG_PM
257	ss->suspend_resume_hook = usb_onetouch_pm_hook;
258#endif
259
260	error = input_register_device(onetouch->dev);
261	if (error)
262		goto fail3;
263
264	return 0;
265
266 fail3:	usb_free_urb(onetouch->irq);
267 fail2:	usb_free_coherent(udev, ONETOUCH_PKT_LEN,
268			  onetouch->data, onetouch->data_dma);
269 fail1:	kfree(onetouch);
270	input_free_device(input_dev);
271	return error;
272}
273
274static void onetouch_release_input(void *onetouch_)
275{
276	struct usb_onetouch *onetouch = (struct usb_onetouch *) onetouch_;
277
278	if (onetouch) {
279		usb_kill_urb(onetouch->irq);
280		input_unregister_device(onetouch->dev);
281		usb_free_urb(onetouch->irq);
282		usb_free_coherent(onetouch->udev, ONETOUCH_PKT_LEN,
283				  onetouch->data, onetouch->data_dma);
284	}
285}
286
287static int onetouch_probe(struct usb_interface *intf,
288			 const struct usb_device_id *id)
289{
290	struct us_data *us;
291	int result;
292
293	result = usb_stor_probe1(&us, intf, id,
294			(id - onetouch_usb_ids) + onetouch_unusual_dev_list);
295	if (result)
296		return result;
297
298	/* Use default transport and protocol */
299
300	result = usb_stor_probe2(us);
301	return result;
302}
303
304static struct usb_driver onetouch_driver = {
305	.name =		"ums-onetouch",
306	.probe =	onetouch_probe,
307	.disconnect =	usb_stor_disconnect,
308	.suspend =	usb_stor_suspend,
309	.resume =	usb_stor_resume,
310	.reset_resume =	usb_stor_reset_resume,
311	.pre_reset =	usb_stor_pre_reset,
312	.post_reset =	usb_stor_post_reset,
313	.id_table =	onetouch_usb_ids,
314	.soft_unbind =	1,
 
315};
316
317static int __init onetouch_init(void)
318{
319	return usb_register(&onetouch_driver);
320}
321
322static void __exit onetouch_exit(void)
323{
324	usb_deregister(&onetouch_driver);
325}
326
327module_init(onetouch_init);
328module_exit(onetouch_exit);
v3.15
  1/*
  2 * Support for the Maxtor OneTouch USB hard drive's button
  3 *
  4 * Current development and maintenance by:
  5 *	Copyright (c) 2005 Nick Sillik <n.sillik@temple.edu>
  6 *
  7 * Initial work by:
  8 *	Copyright (c) 2003 Erik Thyren <erth7411@student.uu.se>
  9 *
 10 * Based on usbmouse.c (Vojtech Pavlik) and xpad.c (Marko Friedemann)
 11 *
 12 */
 13
 14/*
 15 * This program is free software; you can redistribute it and/or modify
 16 * it under the terms of the GNU General Public License as published by
 17 * the Free Software Foundation; either version 2 of the License, or
 18 * (at your option) any later version.
 19 *
 20 * This program is distributed in the hope that it will be useful,
 21 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 23 * GNU General Public License for more details.
 24 *
 25 * You should have received a copy of the GNU General Public License
 26 * along with this program; if not, write to the Free Software
 27 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 28 *
 29 */
 30
 31#include <linux/kernel.h>
 32#include <linux/input.h>
 
 33#include <linux/slab.h>
 34#include <linux/module.h>
 35#include <linux/usb/input.h>
 36#include "usb.h"
 37#include "debug.h"
 38
 39MODULE_DESCRIPTION("Maxtor USB OneTouch hard drive button driver");
 40MODULE_AUTHOR("Nick Sillik <n.sillik@temple.edu>");
 41MODULE_LICENSE("GPL");
 42
 43#define ONETOUCH_PKT_LEN        0x02
 44#define ONETOUCH_BUTTON         KEY_PROG1
 45
 46static int onetouch_connect_input(struct us_data *ss);
 47static void onetouch_release_input(void *onetouch_);
 48
 49struct usb_onetouch {
 50	char name[128];
 51	char phys[64];
 52	struct input_dev *dev;	/* input device interface */
 53	struct usb_device *udev;	/* usb device */
 54
 55	struct urb *irq;	/* urb for interrupt in report */
 56	unsigned char *data;	/* input data */
 57	dma_addr_t data_dma;
 58	unsigned int is_open:1;
 59};
 60
 61
 62/*
 63 * The table of devices
 64 */
 65#define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
 66		    vendorName, productName, useProtocol, useTransport, \
 67		    initFunction, flags) \
 68{ USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
 69  .driver_info = (flags) }
 70
 71static struct usb_device_id onetouch_usb_ids[] = {
 72#	include "unusual_onetouch.h"
 73	{ }		/* Terminating entry */
 74};
 75MODULE_DEVICE_TABLE(usb, onetouch_usb_ids);
 76
 77#undef UNUSUAL_DEV
 78
 79/*
 80 * The flags table
 81 */
 82#define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \
 83		    vendor_name, product_name, use_protocol, use_transport, \
 84		    init_function, Flags) \
 85{ \
 86	.vendorName = vendor_name,	\
 87	.productName = product_name,	\
 88	.useProtocol = use_protocol,	\
 89	.useTransport = use_transport,	\
 90	.initFunction = init_function,	\
 91}
 92
 93static struct us_unusual_dev onetouch_unusual_dev_list[] = {
 94#	include "unusual_onetouch.h"
 95	{ }		/* Terminating entry */
 96};
 97
 98#undef UNUSUAL_DEV
 99
100
101static void usb_onetouch_irq(struct urb *urb)
102{
103	struct usb_onetouch *onetouch = urb->context;
104	signed char *data = onetouch->data;
105	struct input_dev *dev = onetouch->dev;
106	int status = urb->status;
107	int retval;
108
109	switch (status) {
110	case 0:			/* success */
111		break;
112	case -ECONNRESET:	/* unlink */
113	case -ENOENT:
114	case -ESHUTDOWN:
115		return;
116	/* -EPIPE:  should clear the halt */
117	default:		/* error */
118		goto resubmit;
119	}
120
121	input_report_key(dev, ONETOUCH_BUTTON, data[0] & 0x02);
122	input_sync(dev);
123
124resubmit:
125	retval = usb_submit_urb (urb, GFP_ATOMIC);
126	if (retval)
127		dev_err(&dev->dev, "can't resubmit intr, %s-%s/input0, "
128			"retval %d\n", onetouch->udev->bus->bus_name,
129			onetouch->udev->devpath, retval);
130}
131
132static int usb_onetouch_open(struct input_dev *dev)
133{
134	struct usb_onetouch *onetouch = input_get_drvdata(dev);
135
136	onetouch->is_open = 1;
137	onetouch->irq->dev = onetouch->udev;
138	if (usb_submit_urb(onetouch->irq, GFP_KERNEL)) {
139		dev_err(&dev->dev, "usb_submit_urb failed\n");
140		return -EIO;
141	}
142
143	return 0;
144}
145
146static void usb_onetouch_close(struct input_dev *dev)
147{
148	struct usb_onetouch *onetouch = input_get_drvdata(dev);
149
150	usb_kill_urb(onetouch->irq);
151	onetouch->is_open = 0;
152}
153
154#ifdef CONFIG_PM
155static void usb_onetouch_pm_hook(struct us_data *us, int action)
156{
157	struct usb_onetouch *onetouch = (struct usb_onetouch *) us->extra;
158
159	if (onetouch->is_open) {
160		switch (action) {
161		case US_SUSPEND:
162			usb_kill_urb(onetouch->irq);
163			break;
164		case US_RESUME:
165			if (usb_submit_urb(onetouch->irq, GFP_NOIO) != 0)
166				dev_err(&onetouch->irq->dev->dev,
167					"usb_submit_urb failed\n");
168			break;
169		default:
170			break;
171		}
172	}
173}
174#endif /* CONFIG_PM */
175
176static int onetouch_connect_input(struct us_data *ss)
177{
178	struct usb_device *udev = ss->pusb_dev;
179	struct usb_host_interface *interface;
180	struct usb_endpoint_descriptor *endpoint;
181	struct usb_onetouch *onetouch;
182	struct input_dev *input_dev;
183	int pipe, maxp;
184	int error = -ENOMEM;
185
186	interface = ss->pusb_intf->cur_altsetting;
187
188	if (interface->desc.bNumEndpoints != 3)
189		return -ENODEV;
190
191	endpoint = &interface->endpoint[2].desc;
192	if (!usb_endpoint_is_int_in(endpoint))
193		return -ENODEV;
194
195	pipe = usb_rcvintpipe(udev, endpoint->bEndpointAddress);
196	maxp = usb_maxpacket(udev, pipe, usb_pipeout(pipe));
197	maxp = min(maxp, ONETOUCH_PKT_LEN);
198
199	onetouch = kzalloc(sizeof(struct usb_onetouch), GFP_KERNEL);
200	input_dev = input_allocate_device();
201	if (!onetouch || !input_dev)
202		goto fail1;
203
204	onetouch->data = usb_alloc_coherent(udev, ONETOUCH_PKT_LEN,
205					    GFP_KERNEL, &onetouch->data_dma);
206	if (!onetouch->data)
207		goto fail1;
208
209	onetouch->irq = usb_alloc_urb(0, GFP_KERNEL);
210	if (!onetouch->irq)
211		goto fail2;
212
213	onetouch->udev = udev;
214	onetouch->dev = input_dev;
215
216	if (udev->manufacturer)
217		strlcpy(onetouch->name, udev->manufacturer,
218			sizeof(onetouch->name));
219	if (udev->product) {
220		if (udev->manufacturer)
221			strlcat(onetouch->name, " ", sizeof(onetouch->name));
222		strlcat(onetouch->name, udev->product, sizeof(onetouch->name));
223	}
224
225	if (!strlen(onetouch->name))
226		snprintf(onetouch->name, sizeof(onetouch->name),
227			 "Maxtor Onetouch %04x:%04x",
228			 le16_to_cpu(udev->descriptor.idVendor),
229			 le16_to_cpu(udev->descriptor.idProduct));
230
231	usb_make_path(udev, onetouch->phys, sizeof(onetouch->phys));
232	strlcat(onetouch->phys, "/input0", sizeof(onetouch->phys));
233
234	input_dev->name = onetouch->name;
235	input_dev->phys = onetouch->phys;
236	usb_to_input_id(udev, &input_dev->id);
237	input_dev->dev.parent = &udev->dev;
238
239	set_bit(EV_KEY, input_dev->evbit);
240	set_bit(ONETOUCH_BUTTON, input_dev->keybit);
241	clear_bit(0, input_dev->keybit);
242
243	input_set_drvdata(input_dev, onetouch);
244
245	input_dev->open = usb_onetouch_open;
246	input_dev->close = usb_onetouch_close;
247
248	usb_fill_int_urb(onetouch->irq, udev, pipe, onetouch->data, maxp,
 
249			 usb_onetouch_irq, onetouch, endpoint->bInterval);
250	onetouch->irq->transfer_dma = onetouch->data_dma;
251	onetouch->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
252
253	ss->extra_destructor = onetouch_release_input;
254	ss->extra = onetouch;
255#ifdef CONFIG_PM
256	ss->suspend_resume_hook = usb_onetouch_pm_hook;
257#endif
258
259	error = input_register_device(onetouch->dev);
260	if (error)
261		goto fail3;
262
263	return 0;
264
265 fail3:	usb_free_urb(onetouch->irq);
266 fail2:	usb_free_coherent(udev, ONETOUCH_PKT_LEN,
267			  onetouch->data, onetouch->data_dma);
268 fail1:	kfree(onetouch);
269	input_free_device(input_dev);
270	return error;
271}
272
273static void onetouch_release_input(void *onetouch_)
274{
275	struct usb_onetouch *onetouch = (struct usb_onetouch *) onetouch_;
276
277	if (onetouch) {
278		usb_kill_urb(onetouch->irq);
279		input_unregister_device(onetouch->dev);
280		usb_free_urb(onetouch->irq);
281		usb_free_coherent(onetouch->udev, ONETOUCH_PKT_LEN,
282				  onetouch->data, onetouch->data_dma);
283	}
284}
285
286static int onetouch_probe(struct usb_interface *intf,
287			 const struct usb_device_id *id)
288{
289	struct us_data *us;
290	int result;
291
292	result = usb_stor_probe1(&us, intf, id,
293			(id - onetouch_usb_ids) + onetouch_unusual_dev_list);
294	if (result)
295		return result;
296
297	/* Use default transport and protocol */
298
299	result = usb_stor_probe2(us);
300	return result;
301}
302
303static struct usb_driver onetouch_driver = {
304	.name =		"ums-onetouch",
305	.probe =	onetouch_probe,
306	.disconnect =	usb_stor_disconnect,
307	.suspend =	usb_stor_suspend,
308	.resume =	usb_stor_resume,
309	.reset_resume =	usb_stor_reset_resume,
310	.pre_reset =	usb_stor_pre_reset,
311	.post_reset =	usb_stor_post_reset,
312	.id_table =	onetouch_usb_ids,
313	.soft_unbind =	1,
314	.no_dynamic_id = 1,
315};
316
317module_usb_driver(onetouch_driver);