1 /* -----------------------------------------------------------------------------
2 * Copyright (c) 2011 Ozmo Inc
3 * Released under the GNU General Public License Version 2 (GPLv2).
5 * This file implements the protocol specific parts of the USB service for a PD.
6 * -----------------------------------------------------------------------------
8 #include <linux/module.h>
9 #include <linux/timer.h>
10 #include <linux/sched.h>
11 #include <linux/netdevice.h>
12 #include <linux/errno.h>
13 #include <linux/input.h>
14 #include <asm/unaligned.h>
16 #include "ozprotocol.h"
24 #define MAX_ISOC_FIXED_DATA (253-sizeof(struct oz_isoc_fixed))
29 static int oz_usb_submit_elt(struct oz_elt_buf *eb, struct oz_elt_info *ei,
30 struct oz_usb_ctx *usb_ctx, u8 strid, u8 isoc)
33 struct oz_elt *elt = (struct oz_elt *)ei->data;
34 struct oz_app_hdr *app_hdr = (struct oz_app_hdr *)(elt+1);
36 elt->type = OZ_ELT_APP_DATA;
37 ei->app_id = OZ_APPID_USB;
38 ei->length = elt->length + sizeof(struct oz_elt);
39 app_hdr->app_id = OZ_APPID_USB;
40 spin_lock_bh(&eb->lock);
42 app_hdr->elt_seq_num = usb_ctx->tx_seq_num++;
43 if (usb_ctx->tx_seq_num == 0)
44 usb_ctx->tx_seq_num = 1;
46 ret = oz_queue_elt_info(eb, isoc, strid, ei);
48 oz_elt_info_free(eb, ei);
49 spin_unlock_bh(&eb->lock);
56 int oz_usb_get_desc_req(void *hpd, u8 req_id, u8 req_type, u8 desc_type,
57 u8 index, __le16 windex, int offset, int len)
59 struct oz_usb_ctx *usb_ctx = hpd;
60 struct oz_pd *pd = usb_ctx->pd;
62 struct oz_get_desc_req *body;
63 struct oz_elt_buf *eb = &pd->elt_buff;
64 struct oz_elt_info *ei = oz_elt_info_alloc(&pd->elt_buff);
66 oz_dbg(ON, " req_type = 0x%x\n", req_type);
67 oz_dbg(ON, " desc_type = 0x%x\n", desc_type);
68 oz_dbg(ON, " index = 0x%x\n", index);
69 oz_dbg(ON, " windex = 0x%x\n", windex);
70 oz_dbg(ON, " offset = 0x%x\n", offset);
71 oz_dbg(ON, " len = 0x%x\n", len);
76 elt = (struct oz_elt *)ei->data;
77 elt->length = sizeof(struct oz_get_desc_req);
78 body = (struct oz_get_desc_req *)(elt+1);
79 body->type = OZ_GET_DESC_REQ;
80 body->req_id = req_id;
81 put_unaligned(cpu_to_le16(offset), &body->offset);
82 put_unaligned(cpu_to_le16(len), &body->size);
83 body->req_type = req_type;
84 body->desc_type = desc_type;
85 body->w_index = windex;
87 return oz_usb_submit_elt(eb, ei, usb_ctx, 0, 0);
93 static int oz_usb_set_config_req(void *hpd, u8 req_id, u8 index)
95 struct oz_usb_ctx *usb_ctx = hpd;
96 struct oz_pd *pd = usb_ctx->pd;
98 struct oz_elt_buf *eb = &pd->elt_buff;
99 struct oz_elt_info *ei = oz_elt_info_alloc(&pd->elt_buff);
100 struct oz_set_config_req *body;
104 elt = (struct oz_elt *)ei->data;
105 elt->length = sizeof(struct oz_set_config_req);
106 body = (struct oz_set_config_req *)(elt+1);
107 body->type = OZ_SET_CONFIG_REQ;
108 body->req_id = req_id;
110 return oz_usb_submit_elt(eb, ei, usb_ctx, 0, 0);
116 static int oz_usb_set_interface_req(void *hpd, u8 req_id, u8 index, u8 alt)
118 struct oz_usb_ctx *usb_ctx = hpd;
119 struct oz_pd *pd = usb_ctx->pd;
121 struct oz_elt_buf *eb = &pd->elt_buff;
122 struct oz_elt_info *ei = oz_elt_info_alloc(&pd->elt_buff);
123 struct oz_set_interface_req *body;
127 elt = (struct oz_elt *)ei->data;
128 elt->length = sizeof(struct oz_set_interface_req);
129 body = (struct oz_set_interface_req *)(elt+1);
130 body->type = OZ_SET_INTERFACE_REQ;
131 body->req_id = req_id;
133 body->alternative = alt;
134 return oz_usb_submit_elt(eb, ei, usb_ctx, 0, 0);
140 static int oz_usb_set_clear_feature_req(void *hpd, u8 req_id, u8 type,
141 u8 recipient, u8 index, __le16 feature)
143 struct oz_usb_ctx *usb_ctx = hpd;
144 struct oz_pd *pd = usb_ctx->pd;
146 struct oz_elt_buf *eb = &pd->elt_buff;
147 struct oz_elt_info *ei = oz_elt_info_alloc(&pd->elt_buff);
148 struct oz_feature_req *body;
152 elt = (struct oz_elt *)ei->data;
153 elt->length = sizeof(struct oz_feature_req);
154 body = (struct oz_feature_req *)(elt+1);
156 body->req_id = req_id;
157 body->recipient = recipient;
159 put_unaligned(feature, &body->feature);
160 return oz_usb_submit_elt(eb, ei, usb_ctx, 0, 0);
166 static int oz_usb_vendor_class_req(void *hpd, u8 req_id, u8 req_type,
167 u8 request, __le16 value, __le16 index, const u8 *data, int data_len)
169 struct oz_usb_ctx *usb_ctx = hpd;
170 struct oz_pd *pd = usb_ctx->pd;
172 struct oz_elt_buf *eb = &pd->elt_buff;
173 struct oz_elt_info *ei = oz_elt_info_alloc(&pd->elt_buff);
174 struct oz_vendor_class_req *body;
178 elt = (struct oz_elt *)ei->data;
179 elt->length = sizeof(struct oz_vendor_class_req) - 1 + data_len;
180 body = (struct oz_vendor_class_req *)(elt+1);
181 body->type = OZ_VENDOR_CLASS_REQ;
182 body->req_id = req_id;
183 body->req_type = req_type;
184 body->request = request;
185 put_unaligned(value, &body->value);
186 put_unaligned(index, &body->index);
188 memcpy(body->data, data, data_len);
189 return oz_usb_submit_elt(eb, ei, usb_ctx, 0, 0);
195 int oz_usb_control_req(void *hpd, u8 req_id, struct usb_ctrlrequest *setup,
196 const u8 *data, int data_len)
198 unsigned wvalue = le16_to_cpu(setup->wValue);
199 unsigned windex = le16_to_cpu(setup->wIndex);
200 unsigned wlength = le16_to_cpu(setup->wLength);
203 if ((setup->bRequestType & USB_TYPE_MASK) == USB_TYPE_STANDARD) {
204 switch (setup->bRequest) {
205 case USB_REQ_GET_DESCRIPTOR:
206 rc = oz_usb_get_desc_req(hpd, req_id,
207 setup->bRequestType, (u8)(wvalue>>8),
208 (u8)wvalue, setup->wIndex, 0, wlength);
210 case USB_REQ_SET_CONFIGURATION:
211 rc = oz_usb_set_config_req(hpd, req_id, (u8)wvalue);
213 case USB_REQ_SET_INTERFACE: {
214 u8 if_num = (u8)windex;
217 rc = oz_usb_set_interface_req(hpd, req_id,
221 case USB_REQ_SET_FEATURE:
222 rc = oz_usb_set_clear_feature_req(hpd, req_id,
224 setup->bRequestType & 0xf, (u8)windex,
227 case USB_REQ_CLEAR_FEATURE:
228 rc = oz_usb_set_clear_feature_req(hpd, req_id,
229 OZ_CLEAR_FEATURE_REQ,
230 setup->bRequestType & 0xf,
231 (u8)windex, setup->wValue);
235 rc = oz_usb_vendor_class_req(hpd, req_id, setup->bRequestType,
236 setup->bRequest, setup->wValue, setup->wIndex,
245 int oz_usb_send_isoc(void *hpd, u8 ep_num, struct urb *urb)
247 struct oz_usb_ctx *usb_ctx = hpd;
248 struct oz_pd *pd = usb_ctx->pd;
249 struct oz_elt_buf *eb;
253 struct usb_iso_packet_descriptor *desc;
255 if (pd->mode & OZ_F_ISOC_NO_ELTS) {
256 for (i = 0; i < urb->number_of_packets; i++) {
259 desc = &urb->iso_frame_desc[i];
260 data = ((u8 *)urb->transfer_buffer)+desc->offset;
261 oz_send_isoc_unit(pd, ep_num, data, desc->length);
266 hdr_size = sizeof(struct oz_isoc_fixed) - 1;
269 while (i < urb->number_of_packets) {
270 struct oz_elt_info *ei = oz_elt_info_alloc(eb);
272 struct oz_isoc_fixed *body;
279 rem = MAX_ISOC_FIXED_DATA;
280 elt = (struct oz_elt *)ei->data;
281 body = (struct oz_isoc_fixed *)(elt + 1);
282 body->type = OZ_USB_ENDPOINT_DATA;
283 body->endpoint = ep_num;
284 body->format = OZ_DATA_F_ISOC_FIXED;
285 unit_size = urb->iso_frame_desc[i].length;
286 body->unit_size = (u8)unit_size;
287 data = ((u8 *)(elt+1)) + hdr_size;
289 while (i < urb->number_of_packets) {
290 desc = &urb->iso_frame_desc[i];
291 if ((unit_size == desc->length) &&
292 (desc->length <= rem)) {
293 memcpy(data, ((u8 *)urb->transfer_buffer) +
294 desc->offset, unit_size);
299 desc->actual_length = desc->length;
305 elt->length = hdr_size + MAX_ISOC_FIXED_DATA - rem;
306 /* Store the number of units in body->frame_number for the
307 * moment. This field will be correctly determined before
308 * the element is sent. */
309 body->frame_number = (u8)unit_count;
310 oz_usb_submit_elt(eb, ei, usb_ctx, ep_num,
311 pd->mode & OZ_F_ISOC_ANYTIME);
317 * Context: softirq-serialized
319 static void oz_usb_handle_ep_data(struct oz_usb_ctx *usb_ctx,
320 struct oz_usb_hdr *usb_hdr, int len)
322 struct oz_data *data_hdr = (struct oz_data *)usb_hdr;
324 switch (data_hdr->format) {
325 case OZ_DATA_F_MULTIPLE_FIXED: {
326 struct oz_multiple_fixed *body =
327 (struct oz_multiple_fixed *)data_hdr;
328 u8 *data = body->data;
329 int n = (len - sizeof(struct oz_multiple_fixed)+1)
332 oz_hcd_data_ind(usb_ctx->hport, body->endpoint,
333 data, body->unit_size);
334 data += body->unit_size;
338 case OZ_DATA_F_ISOC_FIXED: {
339 struct oz_isoc_fixed *body =
340 (struct oz_isoc_fixed *)data_hdr;
341 int data_len = len-sizeof(struct oz_isoc_fixed)+1;
342 int unit_size = body->unit_size;
343 u8 *data = body->data;
349 count = data_len/unit_size;
350 for (i = 0; i < count; i++) {
351 oz_hcd_data_ind(usb_ctx->hport,
352 body->endpoint, data, unit_size);
362 * This is called when the PD has received a USB element. The type of element
363 * is determined and is then passed to an appropriate handler function.
364 * Context: softirq-serialized
366 void oz_usb_rx(struct oz_pd *pd, struct oz_elt *elt)
368 struct oz_usb_hdr *usb_hdr = (struct oz_usb_hdr *)(elt + 1);
369 struct oz_usb_ctx *usb_ctx;
371 spin_lock_bh(&pd->app_lock[OZ_APPID_USB]);
372 usb_ctx = (struct oz_usb_ctx *)pd->app_ctx[OZ_APPID_USB];
375 spin_unlock_bh(&pd->app_lock[OZ_APPID_USB]);
377 return; /* Context has gone so nothing to do. */
378 if (usb_ctx->stopped)
380 /* If sequence number is non-zero then check it is not a duplicate.
381 * Zero sequence numbers are always accepted.
383 if (usb_hdr->elt_seq_num != 0) {
384 if (((usb_ctx->rx_seq_num - usb_hdr->elt_seq_num) & 0x80) == 0)
385 /* Reject duplicate element. */
388 usb_ctx->rx_seq_num = usb_hdr->elt_seq_num;
389 switch (usb_hdr->type) {
390 case OZ_GET_DESC_RSP: {
391 struct oz_get_desc_rsp *body =
392 (struct oz_get_desc_rsp *)usb_hdr;
393 int data_len = elt->length -
394 sizeof(struct oz_get_desc_rsp) + 1;
395 u16 offs = le16_to_cpu(get_unaligned(&body->offset));
397 le16_to_cpu(get_unaligned(&body->total_size));
398 oz_dbg(ON, "USB_REQ_GET_DESCRIPTOR - cnf\n");
399 oz_hcd_get_desc_cnf(usb_ctx->hport, body->req_id,
400 body->rcode, body->data,
401 data_len, offs, total_size);
404 case OZ_SET_CONFIG_RSP: {
405 struct oz_set_config_rsp *body =
406 (struct oz_set_config_rsp *)usb_hdr;
407 oz_hcd_control_cnf(usb_ctx->hport, body->req_id,
408 body->rcode, NULL, 0);
411 case OZ_SET_INTERFACE_RSP: {
412 struct oz_set_interface_rsp *body =
413 (struct oz_set_interface_rsp *)usb_hdr;
414 oz_hcd_control_cnf(usb_ctx->hport,
415 body->req_id, body->rcode, NULL, 0);
418 case OZ_VENDOR_CLASS_RSP: {
419 struct oz_vendor_class_rsp *body =
420 (struct oz_vendor_class_rsp *)usb_hdr;
421 oz_hcd_control_cnf(usb_ctx->hport, body->req_id,
422 body->rcode, body->data, elt->length-
423 sizeof(struct oz_vendor_class_rsp)+1);
426 case OZ_USB_ENDPOINT_DATA:
427 oz_usb_handle_ep_data(usb_ctx, usb_hdr, elt->length);
435 * Context: softirq, process
437 void oz_usb_farewell(struct oz_pd *pd, u8 ep_num, u8 *data, u8 len)
439 struct oz_usb_ctx *usb_ctx;
441 spin_lock_bh(&pd->app_lock[OZ_APPID_USB]);
442 usb_ctx = (struct oz_usb_ctx *)pd->app_ctx[OZ_APPID_USB];
445 spin_unlock_bh(&pd->app_lock[OZ_APPID_USB]);
447 return; /* Context has gone so nothing to do. */
448 if (!usb_ctx->stopped) {
449 oz_dbg(ON, "Farewell indicated ep = 0x%x\n", ep_num);
450 oz_hcd_data_ind(usb_ctx->hport, ep_num, data, len);