diff options
Diffstat (limited to 'drivers/usb')
-rw-r--r-- | drivers/usb/input/Kconfig | 20 | ||||
-rw-r--r-- | drivers/usb/input/Makefile | 1 | ||||
-rw-r--r-- | drivers/usb/input/appletouch.c | 469 |
3 files changed, 490 insertions, 0 deletions
diff --git a/drivers/usb/input/Kconfig b/drivers/usb/input/Kconfig index 482c4be521f5..1e53934907c0 100644 --- a/drivers/usb/input/Kconfig +++ b/drivers/usb/input/Kconfig | |||
@@ -286,3 +286,23 @@ config USB_KEYSPAN_REMOTE | |||
286 | 286 | ||
287 | To compile this driver as a module, choose M here: the module will | 287 | To compile this driver as a module, choose M here: the module will |
288 | be called keyspan_remote. | 288 | be called keyspan_remote. |
289 | |||
290 | config USB_APPLETOUCH | ||
291 | tristate "Apple USB Touchpad support" | ||
292 | depends on USB && INPUT | ||
293 | ---help--- | ||
294 | Say Y here if you want to use an Apple USB Touchpad. | ||
295 | |||
296 | These are the touchpads that can be found on post-February 2005 | ||
297 | Apple Powerbooks (prior models have a Synaptics touchpad connected | ||
298 | to the ADB bus). | ||
299 | |||
300 | This driver provides a basic mouse driver but can be interfaced | ||
301 | with the synaptics X11 driver to provide acceleration and | ||
302 | scrolling in X11. | ||
303 | |||
304 | For further information, see | ||
305 | <file:Documentation/input/appletouch.txt>. | ||
306 | |||
307 | To compile this driver as a module, choose M here: the | ||
308 | module will be called appletouch. | ||
diff --git a/drivers/usb/input/Makefile b/drivers/usb/input/Makefile index 43b2f999edfe..5e03b93f29f6 100644 --- a/drivers/usb/input/Makefile +++ b/drivers/usb/input/Makefile | |||
@@ -41,3 +41,4 @@ obj-$(CONFIG_USB_WACOM) += wacom.o | |||
41 | obj-$(CONFIG_USB_ACECAD) += acecad.o | 41 | obj-$(CONFIG_USB_ACECAD) += acecad.o |
42 | obj-$(CONFIG_USB_YEALINK) += yealink.o | 42 | obj-$(CONFIG_USB_YEALINK) += yealink.o |
43 | obj-$(CONFIG_USB_XPAD) += xpad.o | 43 | obj-$(CONFIG_USB_XPAD) += xpad.o |
44 | obj-$(CONFIG_USB_APPLETOUCH) += appletouch.o | ||
diff --git a/drivers/usb/input/appletouch.c b/drivers/usb/input/appletouch.c new file mode 100644 index 000000000000..e03c1c567a14 --- /dev/null +++ b/drivers/usb/input/appletouch.c | |||
@@ -0,0 +1,469 @@ | |||
1 | /* | ||
2 | * Apple USB Touchpad (for post-February 2005 PowerBooks) driver | ||
3 | * | ||
4 | * Copyright (C) 2001-2004 Greg Kroah-Hartman (greg@kroah.com) | ||
5 | * Copyright (C) 2005 Johannes Berg (johannes@sipsolutions.net) | ||
6 | * Copyright (C) 2005 Stelian Pop (stelian@popies.net) | ||
7 | * Copyright (C) 2005 Frank Arnold (frank@scirocco-5v-turbo.de) | ||
8 | * Copyright (C) 2005 Peter Osterlund (petero2@telia.com) | ||
9 | * | ||
10 | * Thanks to Alex Harper <basilisk@foobox.net> for his inputs. | ||
11 | * | ||
12 | * This program is free software; you can redistribute it and/or modify | ||
13 | * it under the terms of the GNU General Public License as published by | ||
14 | * the Free Software Foundation; either version 2 of the License, or | ||
15 | * (at your option) any later version. | ||
16 | * | ||
17 | * This program is distributed in the hope that it will be useful, | ||
18 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
19 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
20 | * GNU General Public License for more details. | ||
21 | * | ||
22 | * You should have received a copy of the GNU General Public License | ||
23 | * along with this program; if not, write to the Free Software | ||
24 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | ||
25 | * | ||
26 | */ | ||
27 | |||
28 | #include <linux/config.h> | ||
29 | #include <linux/kernel.h> | ||
30 | #include <linux/errno.h> | ||
31 | #include <linux/init.h> | ||
32 | #include <linux/slab.h> | ||
33 | #include <linux/module.h> | ||
34 | #include <linux/usb.h> | ||
35 | #include <linux/input.h> | ||
36 | #include <linux/usb_input.h> | ||
37 | |||
38 | /* Apple has powerbooks which have the keyboard with different Product IDs */ | ||
39 | #define APPLE_VENDOR_ID 0x05AC | ||
40 | |||
41 | #define ATP_DEVICE(prod) \ | ||
42 | .match_flags = USB_DEVICE_ID_MATCH_DEVICE | \ | ||
43 | USB_DEVICE_ID_MATCH_INT_CLASS | \ | ||
44 | USB_DEVICE_ID_MATCH_INT_PROTOCOL, \ | ||
45 | .idVendor = APPLE_VENDOR_ID, \ | ||
46 | .idProduct = (prod), \ | ||
47 | .bInterfaceClass = 0x03, \ | ||
48 | .bInterfaceProtocol = 0x02 | ||
49 | |||
50 | /* table of devices that work with this driver */ | ||
51 | static struct usb_device_id atp_table [] = { | ||
52 | { ATP_DEVICE(0x020E) }, | ||
53 | { ATP_DEVICE(0x020F) }, | ||
54 | { ATP_DEVICE(0x030A) }, | ||
55 | { ATP_DEVICE(0x030B) }, | ||
56 | { } /* Terminating entry */ | ||
57 | }; | ||
58 | MODULE_DEVICE_TABLE (usb, atp_table); | ||
59 | |||
60 | /* size of a USB urb transfer */ | ||
61 | #define ATP_DATASIZE 81 | ||
62 | |||
63 | /* | ||
64 | * number of sensors. Note that only 16 instead of 26 X (horizontal) | ||
65 | * sensors exist on 12" and 15" PowerBooks. All models have 16 Y | ||
66 | * (vertical) sensors. | ||
67 | */ | ||
68 | #define ATP_XSENSORS 26 | ||
69 | #define ATP_YSENSORS 16 | ||
70 | |||
71 | /* amount of fuzz this touchpad generates */ | ||
72 | #define ATP_FUZZ 16 | ||
73 | |||
74 | /* maximum pressure this driver will report */ | ||
75 | #define ATP_PRESSURE 300 | ||
76 | /* | ||
77 | * multiplication factor for the X and Y coordinates. | ||
78 | * We try to keep the touchpad aspect ratio while still doing only simple | ||
79 | * arithmetics. | ||
80 | * The factors below give coordinates like: | ||
81 | * 0 <= x < 960 on 12" and 15" Powerbooks | ||
82 | * 0 <= x < 1600 on 17" Powerbooks | ||
83 | * 0 <= y < 646 | ||
84 | */ | ||
85 | #define ATP_XFACT 64 | ||
86 | #define ATP_YFACT 43 | ||
87 | |||
88 | /* | ||
89 | * Threshold for the touchpad sensors. Any change less than ATP_THRESHOLD is | ||
90 | * ignored. | ||
91 | */ | ||
92 | #define ATP_THRESHOLD 5 | ||
93 | |||
94 | /* Structure to hold all of our device specific stuff */ | ||
95 | struct atp { | ||
96 | struct usb_device * udev; /* usb device */ | ||
97 | struct urb * urb; /* usb request block */ | ||
98 | signed char * data; /* transferred data */ | ||
99 | int open; /* non-zero if opened */ | ||
100 | struct input_dev input; /* input dev */ | ||
101 | int valid; /* are the sensors valid ? */ | ||
102 | int x_old; /* last reported x/y, */ | ||
103 | int y_old; /* used for smoothing */ | ||
104 | /* current value of the sensors */ | ||
105 | signed char xy_cur[ATP_XSENSORS + ATP_YSENSORS]; | ||
106 | /* last value of the sensors */ | ||
107 | signed char xy_old[ATP_XSENSORS + ATP_YSENSORS]; | ||
108 | /* accumulated sensors */ | ||
109 | int xy_acc[ATP_XSENSORS + ATP_YSENSORS]; | ||
110 | }; | ||
111 | |||
112 | #define dbg_dump(msg, tab) \ | ||
113 | if (debug > 1) { \ | ||
114 | int i; \ | ||
115 | printk("appletouch: %s %lld", msg, (long long)jiffies); \ | ||
116 | for (i = 0; i < ATP_XSENSORS + ATP_YSENSORS; i++) \ | ||
117 | printk(" %02x", tab[i]); \ | ||
118 | printk("\n"); \ | ||
119 | } | ||
120 | |||
121 | #define dprintk(format, a...) \ | ||
122 | do { \ | ||
123 | if (debug) printk(format, ##a); \ | ||
124 | } while (0) | ||
125 | |||
126 | MODULE_AUTHOR("Johannes Berg, Stelian Pop, Frank Arnold"); | ||
127 | MODULE_DESCRIPTION("Apple PowerBooks USB touchpad driver"); | ||
128 | MODULE_LICENSE("GPL"); | ||
129 | |||
130 | static int debug = 1; | ||
131 | module_param(debug, int, 0644); | ||
132 | MODULE_PARM_DESC(debug, "Activate debugging output"); | ||
133 | |||
134 | static int atp_calculate_abs(int *xy_sensors, int nb_sensors, int fact, | ||
135 | int *z, int *fingers) | ||
136 | { | ||
137 | int i; | ||
138 | /* values to calculate mean */ | ||
139 | int pcum = 0, psum = 0; | ||
140 | |||
141 | *fingers = 0; | ||
142 | |||
143 | for (i = 0; i < nb_sensors; i++) { | ||
144 | if (xy_sensors[i] < ATP_THRESHOLD) | ||
145 | continue; | ||
146 | if ((i - 1 < 0) || (xy_sensors[i - 1] < ATP_THRESHOLD)) | ||
147 | (*fingers)++; | ||
148 | pcum += xy_sensors[i] * i; | ||
149 | psum += xy_sensors[i]; | ||
150 | } | ||
151 | |||
152 | if (psum > 0) { | ||
153 | *z = psum; | ||
154 | return pcum * fact / psum; | ||
155 | } | ||
156 | |||
157 | return 0; | ||
158 | } | ||
159 | |||
160 | static inline void atp_report_fingers(struct input_dev *input, int fingers) | ||
161 | { | ||
162 | input_report_key(input, BTN_TOOL_FINGER, fingers == 1); | ||
163 | input_report_key(input, BTN_TOOL_DOUBLETAP, fingers == 2); | ||
164 | input_report_key(input, BTN_TOOL_TRIPLETAP, fingers > 2); | ||
165 | } | ||
166 | |||
167 | static void atp_complete(struct urb* urb, struct pt_regs* regs) | ||
168 | { | ||
169 | int x, y, x_z, y_z, x_f, y_f; | ||
170 | int retval, i; | ||
171 | struct atp *dev = urb->context; | ||
172 | |||
173 | switch (urb->status) { | ||
174 | case 0: | ||
175 | /* success */ | ||
176 | break; | ||
177 | case -ECONNRESET: | ||
178 | case -ENOENT: | ||
179 | case -ESHUTDOWN: | ||
180 | /* This urb is terminated, clean up */ | ||
181 | dbg("%s - urb shutting down with status: %d", | ||
182 | __FUNCTION__, urb->status); | ||
183 | return; | ||
184 | default: | ||
185 | dbg("%s - nonzero urb status received: %d", | ||
186 | __FUNCTION__, urb->status); | ||
187 | goto exit; | ||
188 | } | ||
189 | |||
190 | /* drop incomplete datasets */ | ||
191 | if (dev->urb->actual_length != ATP_DATASIZE) { | ||
192 | dprintk("appletouch: incomplete data package.\n"); | ||
193 | goto exit; | ||
194 | } | ||
195 | |||
196 | /* reorder the sensors values */ | ||
197 | for (i = 0; i < 8; i++) { | ||
198 | /* X values */ | ||
199 | dev->xy_cur[i ] = dev->data[5 * i + 2]; | ||
200 | dev->xy_cur[i + 8] = dev->data[5 * i + 4]; | ||
201 | dev->xy_cur[i + 16] = dev->data[5 * i + 42]; | ||
202 | if (i < 2) | ||
203 | dev->xy_cur[i + 24] = dev->data[5 * i + 44]; | ||
204 | |||
205 | /* Y values */ | ||
206 | dev->xy_cur[i + 26] = dev->data[5 * i + 1]; | ||
207 | dev->xy_cur[i + 34] = dev->data[5 * i + 3]; | ||
208 | } | ||
209 | |||
210 | dbg_dump("sample", dev->xy_cur); | ||
211 | |||
212 | if (!dev->valid) { | ||
213 | /* first sample */ | ||
214 | dev->valid = 1; | ||
215 | dev->x_old = dev->y_old = -1; | ||
216 | memcpy(dev->xy_old, dev->xy_cur, sizeof(dev->xy_old)); | ||
217 | |||
218 | /* 17" Powerbooks have 10 extra X sensors */ | ||
219 | for (i = 16; i < ATP_XSENSORS; i++) | ||
220 | if (dev->xy_cur[i]) { | ||
221 | printk("appletouch: 17\" model detected.\n"); | ||
222 | input_set_abs_params(&dev->input, ABS_X, 0, | ||
223 | (ATP_XSENSORS - 1) * | ||
224 | ATP_XFACT - 1, | ||
225 | ATP_FUZZ, 0); | ||
226 | break; | ||
227 | } | ||
228 | |||
229 | goto exit; | ||
230 | } | ||
231 | |||
232 | for (i = 0; i < ATP_XSENSORS + ATP_YSENSORS; i++) { | ||
233 | /* accumulate the change */ | ||
234 | signed char change = dev->xy_old[i] - dev->xy_cur[i]; | ||
235 | dev->xy_acc[i] -= change; | ||
236 | |||
237 | /* prevent down drifting */ | ||
238 | if (dev->xy_acc[i] < 0) | ||
239 | dev->xy_acc[i] = 0; | ||
240 | } | ||
241 | |||
242 | memcpy(dev->xy_old, dev->xy_cur, sizeof(dev->xy_old)); | ||
243 | |||
244 | dbg_dump("accumulator", dev->xy_acc); | ||
245 | |||
246 | x = atp_calculate_abs(dev->xy_acc, ATP_XSENSORS, | ||
247 | ATP_XFACT, &x_z, &x_f); | ||
248 | y = atp_calculate_abs(dev->xy_acc + ATP_XSENSORS, ATP_YSENSORS, | ||
249 | ATP_YFACT, &y_z, &y_f); | ||
250 | |||
251 | if (x && y) { | ||
252 | if (dev->x_old != -1) { | ||
253 | x = (dev->x_old * 3 + x) >> 2; | ||
254 | y = (dev->y_old * 3 + y) >> 2; | ||
255 | dev->x_old = x; | ||
256 | dev->y_old = y; | ||
257 | |||
258 | if (debug > 1) | ||
259 | printk("appletouch: X: %3d Y: %3d " | ||
260 | "Xz: %3d Yz: %3d\n", | ||
261 | x, y, x_z, y_z); | ||
262 | |||
263 | input_report_key(&dev->input, BTN_TOUCH, 1); | ||
264 | input_report_abs(&dev->input, ABS_X, x); | ||
265 | input_report_abs(&dev->input, ABS_Y, y); | ||
266 | input_report_abs(&dev->input, ABS_PRESSURE, | ||
267 | min(ATP_PRESSURE, x_z + y_z)); | ||
268 | atp_report_fingers(&dev->input, max(x_f, y_f)); | ||
269 | } | ||
270 | dev->x_old = x; | ||
271 | dev->y_old = y; | ||
272 | } | ||
273 | else if (!x && !y) { | ||
274 | |||
275 | dev->x_old = dev->y_old = -1; | ||
276 | input_report_key(&dev->input, BTN_TOUCH, 0); | ||
277 | input_report_abs(&dev->input, ABS_PRESSURE, 0); | ||
278 | atp_report_fingers(&dev->input, 0); | ||
279 | |||
280 | /* reset the accumulator on release */ | ||
281 | memset(dev->xy_acc, 0, sizeof(dev->xy_acc)); | ||
282 | } | ||
283 | |||
284 | input_report_key(&dev->input, BTN_LEFT, !!dev->data[80]); | ||
285 | |||
286 | input_sync(&dev->input); | ||
287 | |||
288 | exit: | ||
289 | retval = usb_submit_urb(dev->urb, GFP_ATOMIC); | ||
290 | if (retval) { | ||
291 | err("%s - usb_submit_urb failed with result %d", | ||
292 | __FUNCTION__, retval); | ||
293 | } | ||
294 | } | ||
295 | |||
296 | static int atp_open(struct input_dev *input) | ||
297 | { | ||
298 | struct atp *dev = input->private; | ||
299 | |||
300 | if (usb_submit_urb(dev->urb, GFP_ATOMIC)) | ||
301 | return -EIO; | ||
302 | |||
303 | dev->open = 1; | ||
304 | return 0; | ||
305 | } | ||
306 | |||
307 | static void atp_close(struct input_dev *input) | ||
308 | { | ||
309 | struct atp *dev = input->private; | ||
310 | |||
311 | usb_kill_urb(dev->urb); | ||
312 | dev->open = 0; | ||
313 | } | ||
314 | |||
315 | static int atp_probe(struct usb_interface *iface, const struct usb_device_id *id) | ||
316 | { | ||
317 | struct atp *dev = NULL; | ||
318 | struct usb_host_interface *iface_desc; | ||
319 | struct usb_endpoint_descriptor *endpoint; | ||
320 | int int_in_endpointAddr = 0; | ||
321 | int i, retval = -ENOMEM; | ||
322 | |||
323 | /* allocate memory for our device state and initialize it */ | ||
324 | dev = kmalloc(sizeof(struct atp), GFP_KERNEL); | ||
325 | if (dev == NULL) { | ||
326 | err("Out of memory"); | ||
327 | goto err_kmalloc; | ||
328 | } | ||
329 | memset(dev, 0, sizeof(struct atp)); | ||
330 | |||
331 | dev->udev = interface_to_usbdev(iface); | ||
332 | |||
333 | /* set up the endpoint information */ | ||
334 | /* use only the first interrupt-in endpoint */ | ||
335 | iface_desc = iface->cur_altsetting; | ||
336 | for (i = 0; i < iface_desc->desc.bNumEndpoints; i++) { | ||
337 | endpoint = &iface_desc->endpoint[i].desc; | ||
338 | if (!int_in_endpointAddr && | ||
339 | (endpoint->bEndpointAddress & USB_DIR_IN) && | ||
340 | ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) | ||
341 | == USB_ENDPOINT_XFER_INT)) { | ||
342 | /* we found an interrupt in endpoint */ | ||
343 | int_in_endpointAddr = endpoint->bEndpointAddress; | ||
344 | break; | ||
345 | } | ||
346 | } | ||
347 | if (!int_in_endpointAddr) { | ||
348 | retval = -EIO; | ||
349 | err("Could not find int-in endpoint"); | ||
350 | goto err_endpoint; | ||
351 | } | ||
352 | |||
353 | /* save our data pointer in this interface device */ | ||
354 | usb_set_intfdata(iface, dev); | ||
355 | |||
356 | dev->urb = usb_alloc_urb(0, GFP_KERNEL); | ||
357 | if (!dev->urb) { | ||
358 | retval = -ENOMEM; | ||
359 | goto err_usballoc; | ||
360 | } | ||
361 | dev->data = usb_buffer_alloc(dev->udev, ATP_DATASIZE, GFP_KERNEL, | ||
362 | &dev->urb->transfer_dma); | ||
363 | if (!dev->data) { | ||
364 | retval = -ENOMEM; | ||
365 | goto err_usbbufalloc; | ||
366 | } | ||
367 | usb_fill_int_urb(dev->urb, dev->udev, | ||
368 | usb_rcvintpipe(dev->udev, int_in_endpointAddr), | ||
369 | dev->data, ATP_DATASIZE, atp_complete, dev, 1); | ||
370 | |||
371 | init_input_dev(&dev->input); | ||
372 | dev->input.name = "appletouch"; | ||
373 | dev->input.dev = &iface->dev; | ||
374 | dev->input.private = dev; | ||
375 | dev->input.open = atp_open; | ||
376 | dev->input.close = atp_close; | ||
377 | |||
378 | usb_to_input_id(dev->udev, &dev->input.id); | ||
379 | |||
380 | set_bit(EV_ABS, dev->input.evbit); | ||
381 | |||
382 | /* | ||
383 | * 12" and 15" Powerbooks only have 16 x sensors, | ||
384 | * 17" models are detected later. | ||
385 | */ | ||
386 | input_set_abs_params(&dev->input, ABS_X, 0, | ||
387 | (16 - 1) * ATP_XFACT - 1, ATP_FUZZ, 0); | ||
388 | input_set_abs_params(&dev->input, ABS_Y, 0, | ||
389 | (ATP_YSENSORS - 1) * ATP_YFACT - 1, ATP_FUZZ, 0); | ||
390 | input_set_abs_params(&dev->input, ABS_PRESSURE, 0, ATP_PRESSURE, 0, 0); | ||
391 | |||
392 | set_bit(EV_KEY, dev->input.evbit); | ||
393 | set_bit(BTN_TOUCH, dev->input.keybit); | ||
394 | set_bit(BTN_TOOL_FINGER, dev->input.keybit); | ||
395 | set_bit(BTN_TOOL_DOUBLETAP, dev->input.keybit); | ||
396 | set_bit(BTN_TOOL_TRIPLETAP, dev->input.keybit); | ||
397 | set_bit(BTN_LEFT, dev->input.keybit); | ||
398 | |||
399 | input_register_device(&dev->input); | ||
400 | |||
401 | printk(KERN_INFO "input: appletouch connected\n"); | ||
402 | |||
403 | return 0; | ||
404 | |||
405 | err_usbbufalloc: | ||
406 | usb_free_urb(dev->urb); | ||
407 | err_usballoc: | ||
408 | usb_set_intfdata(iface, NULL); | ||
409 | err_endpoint: | ||
410 | kfree(dev); | ||
411 | err_kmalloc: | ||
412 | return retval; | ||
413 | } | ||
414 | |||
415 | static void atp_disconnect(struct usb_interface *iface) | ||
416 | { | ||
417 | struct atp *dev = usb_get_intfdata(iface); | ||
418 | |||
419 | usb_set_intfdata(iface, NULL); | ||
420 | if (dev) { | ||
421 | usb_kill_urb(dev->urb); | ||
422 | input_unregister_device(&dev->input); | ||
423 | usb_free_urb(dev->urb); | ||
424 | usb_buffer_free(dev->udev, ATP_DATASIZE, | ||
425 | dev->data, dev->urb->transfer_dma); | ||
426 | kfree(dev); | ||
427 | } | ||
428 | printk(KERN_INFO "input: appletouch disconnected\n"); | ||
429 | } | ||
430 | |||
431 | static int atp_suspend(struct usb_interface *iface, pm_message_t message) | ||
432 | { | ||
433 | struct atp *dev = usb_get_intfdata(iface); | ||
434 | usb_kill_urb(dev->urb); | ||
435 | dev->valid = 0; | ||
436 | return 0; | ||
437 | } | ||
438 | |||
439 | static int atp_resume(struct usb_interface *iface) | ||
440 | { | ||
441 | struct atp *dev = usb_get_intfdata(iface); | ||
442 | if (dev->open && usb_submit_urb(dev->urb, GFP_ATOMIC)) | ||
443 | return -EIO; | ||
444 | |||
445 | return 0; | ||
446 | } | ||
447 | |||
448 | static struct usb_driver atp_driver = { | ||
449 | .owner = THIS_MODULE, | ||
450 | .name = "appletouch", | ||
451 | .probe = atp_probe, | ||
452 | .disconnect = atp_disconnect, | ||
453 | .suspend = atp_suspend, | ||
454 | .resume = atp_resume, | ||
455 | .id_table = atp_table, | ||
456 | }; | ||
457 | |||
458 | static int __init atp_init(void) | ||
459 | { | ||
460 | return usb_register(&atp_driver); | ||
461 | } | ||
462 | |||
463 | static void __exit atp_exit(void) | ||
464 | { | ||
465 | usb_deregister(&atp_driver); | ||
466 | } | ||
467 | |||
468 | module_init(atp_init); | ||
469 | module_exit(atp_exit); | ||