Pull misc into release branch
[linux-2.6] / drivers / usb / misc / berry_charge.c
1 /*
2  * USB BlackBerry charging module
3  *
4  * Copyright (C) 2007 Greg Kroah-Hartman <gregkh@suse.de>
5  *
6  *      This program is free software; you can redistribute it and/or
7  *      modify it under the terms of the GNU General Public License as
8  *      published by the Free Software Foundation, version 2.
9  *
10  * Information on how to switch configs was taken by the bcharge.cc file
11  * created by the barry.sf.net project.
12  *
13  * bcharge.cc has the following copyright:
14  *      Copyright (C) 2006, Net Direct Inc. (http://www.netdirect.ca/)
15  * and is released under the GPLv2.
16  *
17  *
18  */
19
20 #include <linux/kernel.h>
21 #include <linux/errno.h>
22 #include <linux/init.h>
23 #include <linux/slab.h>
24 #include <linux/module.h>
25 #include <linux/usb.h>
26
27 #define RIM_VENDOR              0x0fca
28 #define BLACKBERRY              0x0001
29 #define BLACKBERRY_PEARL_DUAL   0x0004
30 #define BLACKBERRY_PEARL        0x0006
31
32 static int debug;
33 static int pearl_dual_mode = 1;
34
35 #ifdef dbg
36 #undef dbg
37 #endif
38 #define dbg(dev, format, arg...)                                \
39         if (debug)                                              \
40                 dev_printk(KERN_DEBUG , dev , format , ## arg)
41
42 static struct usb_device_id id_table [] = {
43         { USB_DEVICE(RIM_VENDOR, BLACKBERRY) },
44         { USB_DEVICE(RIM_VENDOR, BLACKBERRY_PEARL) },
45         { USB_DEVICE(RIM_VENDOR, BLACKBERRY_PEARL_DUAL) },
46         { },                                    /* Terminating entry */
47 };
48 MODULE_DEVICE_TABLE(usb, id_table);
49
50 static int magic_charge(struct usb_device *udev)
51 {
52         char *dummy_buffer = kzalloc(2, GFP_KERNEL);
53         int retval;
54
55         if (!dummy_buffer)
56                 return -ENOMEM;
57
58         /* send two magic commands and then set the configuration.  The device
59          * will then reset itself with the new power usage and should start
60          * charging. */
61
62         /* Note, with testing, it only seems that the first message is really
63          * needed (at least for the 8700c), but to be safe, we emulate what
64          * other operating systems seem to be sending to their device.  We
65          * really need to get some specs for this device to be sure about what
66          * is going on here.
67          */
68         dbg(&udev->dev, "Sending first magic command\n");
69         retval = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
70                                  0xa5, 0xc0, 0, 1, dummy_buffer, 2, 100);
71         if (retval != 2) {
72                 dev_err(&udev->dev, "First magic command failed: %d.\n",
73                         retval);
74                 return retval;
75         }
76
77         dbg(&udev->dev, "Sending second magic command\n");
78         retval = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
79                                  0xa2, 0x40, 0, 1, dummy_buffer, 0, 100);
80         if (retval != 0) {
81                 dev_err(&udev->dev, "Second magic command failed: %d.\n",
82                         retval);
83                 return retval;
84         }
85
86         dbg(&udev->dev, "Calling set_configuration\n");
87         retval = usb_driver_set_configuration(udev, 1);
88         if (retval)
89                 dev_err(&udev->dev, "Set Configuration failed :%d.\n", retval);
90
91         return retval;
92 }
93
94 static int magic_dual_mode(struct usb_device *udev)
95 {
96         char *dummy_buffer = kzalloc(2, GFP_KERNEL);
97         int retval;
98
99         if (!dummy_buffer)
100                 return -ENOMEM;
101
102         /* send magic command so that the Blackberry Pearl device exposes
103          * two interfaces: both the USB mass-storage one and one which can
104          * be used for database access. */
105         dbg(&udev->dev, "Sending magic pearl command\n");
106         retval = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
107                                  0xa9, 0xc0, 1, 1, dummy_buffer, 2, 100);
108         dbg(&udev->dev, "Magic pearl command returned %d\n", retval);
109
110         dbg(&udev->dev, "Calling set_configuration\n");
111         retval = usb_driver_set_configuration(udev, 1);
112         if (retval)
113                 dev_err(&udev->dev, "Set Configuration failed :%d.\n", retval);
114
115         return retval;
116 }
117
118 static int berry_probe(struct usb_interface *intf,
119                        const struct usb_device_id *id)
120 {
121         struct usb_device *udev = interface_to_usbdev(intf);
122
123         dbg(&udev->dev, "Power is set to %dmA\n",
124             udev->actconfig->desc.bMaxPower * 2);
125
126         /* check the power usage so we don't try to enable something that is
127          * already enabled */
128         if ((udev->actconfig->desc.bMaxPower * 2) == 500) {
129                 dbg(&udev->dev, "device is already charging, power is "
130                     "set to %dmA\n", udev->actconfig->desc.bMaxPower * 2);
131                 return -ENODEV;
132         }
133
134         /* turn the power on */
135         magic_charge(udev);
136
137         if ((le16_to_cpu(udev->descriptor.idProduct) == BLACKBERRY_PEARL) &&
138             (pearl_dual_mode))
139                 magic_dual_mode(udev);
140
141         /* we don't really want to bind to the device, userspace programs can
142          * handle the syncing just fine, so get outta here. */
143         return -ENODEV;
144 }
145
146 static void berry_disconnect(struct usb_interface *intf)
147 {
148 }
149
150 static struct usb_driver berry_driver = {
151         .name =         "berry_charge",
152         .probe =        berry_probe,
153         .disconnect =   berry_disconnect,
154         .id_table =     id_table,
155 };
156
157 static int __init berry_init(void)
158 {
159         return usb_register(&berry_driver);
160 }
161
162 static void __exit berry_exit(void)
163 {
164         usb_deregister(&berry_driver);
165 }
166
167 module_init(berry_init);
168 module_exit(berry_exit);
169
170 MODULE_LICENSE("GPL");
171 MODULE_AUTHOR("Greg Kroah-Hartman <gregkh@suse.de>");
172 module_param(debug, bool, S_IRUGO | S_IWUSR);
173 MODULE_PARM_DESC(debug, "Debug enabled or not");
174 module_param(pearl_dual_mode, bool, S_IRUGO | S_IWUSR);
175 MODULE_PARM_DESC(pearl_dual_mode, "Change Blackberry Pearl to run in dual mode");