Commit | Line | Data |
---|---|---|
a8ebf98f IPG |
1 | /* |
2 | * Intel Wireless WiMAX Connection 2400m over USB | |
3 | * Notification handling | |
4 | * | |
5 | * | |
6 | * Copyright (C) 2007-2008 Intel Corporation. All rights reserved. | |
7 | * | |
8 | * Redistribution and use in source and binary forms, with or without | |
9 | * modification, are permitted provided that the following conditions | |
10 | * are met: | |
11 | * | |
12 | * * Redistributions of source code must retain the above copyright | |
13 | * notice, this list of conditions and the following disclaimer. | |
14 | * * Redistributions in binary form must reproduce the above copyright | |
15 | * notice, this list of conditions and the following disclaimer in | |
16 | * the documentation and/or other materials provided with the | |
17 | * distribution. | |
18 | * * Neither the name of Intel Corporation nor the names of its | |
19 | * contributors may be used to endorse or promote products derived | |
20 | * from this software without specific prior written permission. | |
21 | * | |
22 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |
23 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |
24 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | |
25 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | |
26 | * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
27 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | |
28 | * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | |
29 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | |
30 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
31 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
32 | * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
33 | * | |
34 | * | |
35 | * Intel Corporation <linux-wimax@intel.com> | |
36 | * Yanir Lubetkin <yanirx.lubetkin@intel.com> | |
37 | * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com> | |
38 | * - Initial implementation | |
39 | * | |
40 | * | |
41 | * The notification endpoint is active when the device is not in boot | |
42 | * mode; in here we just read and get notifications; based on those, | |
43 | * we act to either reinitialize the device after a reboot or to | |
44 | * submit a RX request. | |
45 | * | |
46 | * ROADMAP | |
47 | * | |
48 | * i2400mu_usb_notification_setup() | |
49 | * | |
50 | * i2400mu_usb_notification_release() | |
51 | * | |
52 | * i2400mu_usb_notification_cb() Called when a URB is ready | |
53 | * i2400mu_notif_grok() | |
aba3792a | 54 | * i2400m_is_boot_barker() |
a8ebf98f IPG |
55 | * i2400m_dev_reset_handle() |
56 | * i2400mu_rx_kick() | |
57 | */ | |
58 | #include <linux/usb.h> | |
5a0e3ad6 | 59 | #include <linux/slab.h> |
a8ebf98f IPG |
60 | #include "i2400m-usb.h" |
61 | ||
62 | ||
63 | #define D_SUBMODULE notif | |
64 | #include "usb-debug-levels.h" | |
65 | ||
66 | ||
67 | static const | |
68 | __le32 i2400m_ZERO_BARKER[4] = { 0, 0, 0, 0 }; | |
69 | ||
70 | ||
71 | /* | |
72 | * Process a received notification | |
73 | * | |
74 | * In normal operation mode, we can only receive two types of payloads | |
75 | * on the notification endpoint: | |
76 | * | |
77 | * - a reboot barker, we do a bootstrap (the device has reseted). | |
78 | * | |
79 | * - a block of zeroes: there is pending data in the IN endpoint | |
80 | */ | |
81 | static | |
82 | int i2400mu_notification_grok(struct i2400mu *i2400mu, const void *buf, | |
83 | size_t buf_len) | |
84 | { | |
85 | int ret; | |
86 | struct device *dev = &i2400mu->usb_iface->dev; | |
87 | struct i2400m *i2400m = &i2400mu->i2400m; | |
88 | ||
89 | d_fnstart(4, dev, "(i2400m %p buf %p buf_len %zu)\n", | |
90 | i2400mu, buf, buf_len); | |
91 | ret = -EIO; | |
aba3792a | 92 | if (buf_len < sizeof(i2400m_ZERO_BARKER)) |
a8ebf98f IPG |
93 | /* Not a bug, just ignore */ |
94 | goto error_bad_size; | |
aba3792a IPG |
95 | ret = 0; |
96 | if (!memcmp(i2400m_ZERO_BARKER, buf, sizeof(i2400m_ZERO_BARKER))) { | |
a8ebf98f | 97 | i2400mu_rx_kick(i2400mu); |
aba3792a | 98 | goto out; |
a8ebf98f | 99 | } |
aba3792a IPG |
100 | ret = i2400m_is_boot_barker(i2400m, buf, buf_len); |
101 | if (unlikely(ret >= 0)) | |
3ef6129e | 102 | ret = i2400m_dev_reset_handle(i2400m, "device rebooted"); |
aba3792a IPG |
103 | else /* Unknown or unexpected data in the notif message */ |
104 | i2400m_unknown_barker(i2400m, buf, buf_len); | |
a8ebf98f | 105 | error_bad_size: |
aba3792a | 106 | out: |
a8ebf98f IPG |
107 | d_fnend(4, dev, "(i2400m %p buf %p buf_len %zu) = %d\n", |
108 | i2400mu, buf, buf_len, ret); | |
109 | return ret; | |
110 | } | |
111 | ||
112 | ||
113 | /* | |
114 | * URB callback for the notification endpoint | |
115 | * | |
116 | * @urb: the urb received from the notification endpoint | |
117 | * | |
118 | * This function will just process the USB side of the transaction, | |
119 | * checking everything is fine, pass the processing to | |
120 | * i2400m_notification_grok() and resubmit the URB. | |
121 | */ | |
122 | static | |
123 | void i2400mu_notification_cb(struct urb *urb) | |
124 | { | |
125 | int ret; | |
126 | struct i2400mu *i2400mu = urb->context; | |
127 | struct device *dev = &i2400mu->usb_iface->dev; | |
128 | ||
129 | d_fnstart(4, dev, "(urb %p status %d actual_length %d)\n", | |
130 | urb, urb->status, urb->actual_length); | |
131 | ret = urb->status; | |
132 | switch (ret) { | |
133 | case 0: | |
134 | ret = i2400mu_notification_grok(i2400mu, urb->transfer_buffer, | |
135 | urb->actual_length); | |
136 | if (ret == -EIO && edc_inc(&i2400mu->urb_edc, EDC_MAX_ERRORS, | |
137 | EDC_ERROR_TIMEFRAME)) | |
138 | goto error_exceeded; | |
139 | if (ret == -ENOMEM) /* uff...power cycle? shutdown? */ | |
140 | goto error_exceeded; | |
141 | break; | |
142 | case -EINVAL: /* while removing driver */ | |
143 | case -ENODEV: /* dev disconnect ... */ | |
144 | case -ENOENT: /* ditto */ | |
145 | case -ESHUTDOWN: /* URB killed */ | |
146 | case -ECONNRESET: /* disconnection */ | |
147 | goto out; /* Notify around */ | |
148 | default: /* Some error? */ | |
149 | if (edc_inc(&i2400mu->urb_edc, | |
150 | EDC_MAX_ERRORS, EDC_ERROR_TIMEFRAME)) | |
151 | goto error_exceeded; | |
152 | dev_err(dev, "notification: URB error %d, retrying\n", | |
153 | urb->status); | |
154 | } | |
155 | usb_mark_last_busy(i2400mu->usb_dev); | |
156 | ret = usb_submit_urb(i2400mu->notif_urb, GFP_ATOMIC); | |
157 | switch (ret) { | |
158 | case 0: | |
159 | case -EINVAL: /* while removing driver */ | |
160 | case -ENODEV: /* dev disconnect ... */ | |
161 | case -ENOENT: /* ditto */ | |
162 | case -ESHUTDOWN: /* URB killed */ | |
163 | case -ECONNRESET: /* disconnection */ | |
164 | break; /* just ignore */ | |
165 | default: /* Some error? */ | |
166 | dev_err(dev, "notification: cannot submit URB: %d\n", ret); | |
167 | goto error_submit; | |
168 | } | |
169 | d_fnend(4, dev, "(urb %p status %d actual_length %d) = void\n", | |
170 | urb, urb->status, urb->actual_length); | |
171 | return; | |
172 | ||
173 | error_exceeded: | |
174 | dev_err(dev, "maximum errors in notification URB exceeded; " | |
175 | "resetting device\n"); | |
176 | error_submit: | |
177 | usb_queue_reset_device(i2400mu->usb_iface); | |
178 | out: | |
179 | d_fnend(4, dev, "(urb %p status %d actual_length %d) = void\n", | |
180 | urb, urb->status, urb->actual_length); | |
a8ebf98f IPG |
181 | } |
182 | ||
183 | ||
184 | /* | |
185 | * setup the notification endpoint | |
186 | * | |
187 | * @i2400m: device descriptor | |
188 | * | |
189 | * This procedure prepares the notification urb and handler for receiving | |
190 | * unsolicited barkers from the device. | |
191 | */ | |
192 | int i2400mu_notification_setup(struct i2400mu *i2400mu) | |
193 | { | |
194 | struct device *dev = &i2400mu->usb_iface->dev; | |
195 | int usb_pipe, ret = 0; | |
196 | struct usb_endpoint_descriptor *epd; | |
197 | char *buf; | |
198 | ||
199 | d_fnstart(4, dev, "(i2400m %p)\n", i2400mu); | |
200 | buf = kmalloc(I2400MU_MAX_NOTIFICATION_LEN, GFP_KERNEL | GFP_DMA); | |
201 | if (buf == NULL) { | |
a8ebf98f IPG |
202 | ret = -ENOMEM; |
203 | goto error_buf_alloc; | |
204 | } | |
205 | ||
206 | i2400mu->notif_urb = usb_alloc_urb(0, GFP_KERNEL); | |
207 | if (!i2400mu->notif_urb) { | |
208 | ret = -ENOMEM; | |
209 | dev_err(dev, "notification: cannot allocate URB\n"); | |
210 | goto error_alloc_urb; | |
211 | } | |
2093586d DB |
212 | epd = usb_get_epd(i2400mu->usb_iface, |
213 | i2400mu->endpoint_cfg.notification); | |
a8ebf98f IPG |
214 | usb_pipe = usb_rcvintpipe(i2400mu->usb_dev, epd->bEndpointAddress); |
215 | usb_fill_int_urb(i2400mu->notif_urb, i2400mu->usb_dev, usb_pipe, | |
216 | buf, I2400MU_MAX_NOTIFICATION_LEN, | |
217 | i2400mu_notification_cb, i2400mu, epd->bInterval); | |
218 | ret = usb_submit_urb(i2400mu->notif_urb, GFP_KERNEL); | |
219 | if (ret != 0) { | |
220 | dev_err(dev, "notification: cannot submit URB: %d\n", ret); | |
221 | goto error_submit; | |
222 | } | |
223 | d_fnend(4, dev, "(i2400m %p) = %d\n", i2400mu, ret); | |
224 | return ret; | |
225 | ||
226 | error_submit: | |
227 | usb_free_urb(i2400mu->notif_urb); | |
228 | error_alloc_urb: | |
229 | kfree(buf); | |
230 | error_buf_alloc: | |
231 | d_fnend(4, dev, "(i2400m %p) = %d\n", i2400mu, ret); | |
232 | return ret; | |
233 | } | |
234 | ||
235 | ||
236 | /* | |
237 | * Tear down of the notification mechanism | |
238 | * | |
239 | * @i2400m: device descriptor | |
240 | * | |
241 | * Kill the interrupt endpoint urb, free any allocated resources. | |
242 | * | |
243 | * We need to check if we have done it before as for example, | |
244 | * _suspend() call this; if after a suspend() we get a _disconnect() | |
245 | * (as the case is when hibernating), nothing bad happens. | |
246 | */ | |
247 | void i2400mu_notification_release(struct i2400mu *i2400mu) | |
248 | { | |
249 | struct device *dev = &i2400mu->usb_iface->dev; | |
250 | ||
251 | d_fnstart(4, dev, "(i2400mu %p)\n", i2400mu); | |
252 | if (i2400mu->notif_urb != NULL) { | |
253 | usb_kill_urb(i2400mu->notif_urb); | |
254 | kfree(i2400mu->notif_urb->transfer_buffer); | |
255 | usb_free_urb(i2400mu->notif_urb); | |
256 | i2400mu->notif_urb = NULL; | |
257 | } | |
258 | d_fnend(4, dev, "(i2400mu %p)\n", i2400mu); | |
259 | } |