Felipe Balbi | 3086775 | 2008-08-18 17:39:30 -0700 | [diff] [blame] | 1 | /* |
| 2 | * f_obex.c -- USB CDC OBEX function driver |
| 3 | * |
| 4 | * Copyright (C) 2008 Nokia Corporation |
| 5 | * Contact: Felipe Balbi <felipe.balbi@nokia.com> |
| 6 | * |
| 7 | * Based on f_acm.c by Al Borchers and David Brownell. |
| 8 | * |
| 9 | * This program is free software; you can redistribute it and/or modify |
| 10 | * it under the terms of the GNU General Public License as published by |
| 11 | * the Free Software Foundation; either version 2 of the License, or |
| 12 | * (at your option) any later version. |
Felipe Balbi | 3086775 | 2008-08-18 17:39:30 -0700 | [diff] [blame] | 13 | */ |
| 14 | |
| 15 | /* #define VERBOSE_DEBUG */ |
| 16 | |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 17 | #include <linux/slab.h> |
Felipe Balbi | 3086775 | 2008-08-18 17:39:30 -0700 | [diff] [blame] | 18 | #include <linux/kernel.h> |
Felipe Balbi | 3086775 | 2008-08-18 17:39:30 -0700 | [diff] [blame] | 19 | #include <linux/device.h> |
Paul Gortmaker | 6eb0de8 | 2011-07-03 16:09:31 -0400 | [diff] [blame] | 20 | #include <linux/module.h> |
Felipe Balbi | 3086775 | 2008-08-18 17:39:30 -0700 | [diff] [blame] | 21 | |
| 22 | #include "u_serial.h" |
| 23 | #include "gadget_chips.h" |
| 24 | |
| 25 | |
| 26 | /* |
| 27 | * This CDC OBEX function support just packages a TTY-ish byte stream. |
| 28 | * A user mode server will put it into "raw" mode and handle all the |
| 29 | * relevant protocol details ... this is just a kernel passthrough. |
David Brownell | 2121427 | 2008-08-18 17:45:25 -0700 | [diff] [blame] | 30 | * When possible, we prevent gadget enumeration until that server is |
| 31 | * ready to handle the commands. |
Felipe Balbi | 3086775 | 2008-08-18 17:39:30 -0700 | [diff] [blame] | 32 | */ |
| 33 | |
Felipe Balbi | 3086775 | 2008-08-18 17:39:30 -0700 | [diff] [blame] | 34 | struct f_obex { |
| 35 | struct gserial port; |
| 36 | u8 ctrl_id; |
| 37 | u8 data_id; |
Felipe Balbi | 3985f3a | 2014-09-29 15:18:20 -0500 | [diff] [blame] | 38 | u8 cur_alt; |
Felipe Balbi | 3086775 | 2008-08-18 17:39:30 -0700 | [diff] [blame] | 39 | u8 port_num; |
David Brownell | 2121427 | 2008-08-18 17:45:25 -0700 | [diff] [blame] | 40 | u8 can_activate; |
Felipe Balbi | 3086775 | 2008-08-18 17:39:30 -0700 | [diff] [blame] | 41 | }; |
| 42 | |
| 43 | static inline struct f_obex *func_to_obex(struct usb_function *f) |
| 44 | { |
| 45 | return container_of(f, struct f_obex, port.func); |
| 46 | } |
| 47 | |
David Brownell | 2121427 | 2008-08-18 17:45:25 -0700 | [diff] [blame] | 48 | static inline struct f_obex *port_to_obex(struct gserial *p) |
| 49 | { |
| 50 | return container_of(p, struct f_obex, port); |
| 51 | } |
| 52 | |
Felipe Balbi | 3086775 | 2008-08-18 17:39:30 -0700 | [diff] [blame] | 53 | /*-------------------------------------------------------------------------*/ |
| 54 | |
| 55 | #define OBEX_CTRL_IDX 0 |
| 56 | #define OBEX_DATA_IDX 1 |
| 57 | |
| 58 | static struct usb_string obex_string_defs[] = { |
| 59 | [OBEX_CTRL_IDX].s = "CDC Object Exchange (OBEX)", |
| 60 | [OBEX_DATA_IDX].s = "CDC OBEX Data", |
| 61 | { }, /* end of list */ |
| 62 | }; |
| 63 | |
| 64 | static struct usb_gadget_strings obex_string_table = { |
| 65 | .language = 0x0409, /* en-US */ |
| 66 | .strings = obex_string_defs, |
| 67 | }; |
| 68 | |
| 69 | static struct usb_gadget_strings *obex_strings[] = { |
| 70 | &obex_string_table, |
| 71 | NULL, |
| 72 | }; |
| 73 | |
| 74 | /*-------------------------------------------------------------------------*/ |
| 75 | |
Andrzej Pietrasiewicz | 1d8fc25 | 2013-03-21 15:33:42 +0100 | [diff] [blame] | 76 | static struct usb_interface_descriptor obex_control_intf = { |
Felipe Balbi | 3086775 | 2008-08-18 17:39:30 -0700 | [diff] [blame] | 77 | .bLength = sizeof(obex_control_intf), |
| 78 | .bDescriptorType = USB_DT_INTERFACE, |
| 79 | .bInterfaceNumber = 0, |
| 80 | |
| 81 | .bAlternateSetting = 0, |
| 82 | .bNumEndpoints = 0, |
| 83 | .bInterfaceClass = USB_CLASS_COMM, |
| 84 | .bInterfaceSubClass = USB_CDC_SUBCLASS_OBEX, |
| 85 | }; |
| 86 | |
Andrzej Pietrasiewicz | 1d8fc25 | 2013-03-21 15:33:42 +0100 | [diff] [blame] | 87 | static struct usb_interface_descriptor obex_data_nop_intf = { |
Felipe Balbi | 3086775 | 2008-08-18 17:39:30 -0700 | [diff] [blame] | 88 | .bLength = sizeof(obex_data_nop_intf), |
| 89 | .bDescriptorType = USB_DT_INTERFACE, |
| 90 | .bInterfaceNumber = 1, |
| 91 | |
| 92 | .bAlternateSetting = 0, |
| 93 | .bNumEndpoints = 0, |
| 94 | .bInterfaceClass = USB_CLASS_CDC_DATA, |
| 95 | }; |
| 96 | |
Andrzej Pietrasiewicz | 1d8fc25 | 2013-03-21 15:33:42 +0100 | [diff] [blame] | 97 | static struct usb_interface_descriptor obex_data_intf = { |
Felipe Balbi | 3086775 | 2008-08-18 17:39:30 -0700 | [diff] [blame] | 98 | .bLength = sizeof(obex_data_intf), |
| 99 | .bDescriptorType = USB_DT_INTERFACE, |
| 100 | .bInterfaceNumber = 2, |
| 101 | |
| 102 | .bAlternateSetting = 1, |
| 103 | .bNumEndpoints = 2, |
| 104 | .bInterfaceClass = USB_CLASS_CDC_DATA, |
| 105 | }; |
| 106 | |
Andrzej Pietrasiewicz | 1d8fc25 | 2013-03-21 15:33:42 +0100 | [diff] [blame] | 107 | static struct usb_cdc_header_desc obex_cdc_header_desc = { |
Felipe Balbi | 3086775 | 2008-08-18 17:39:30 -0700 | [diff] [blame] | 108 | .bLength = sizeof(obex_cdc_header_desc), |
| 109 | .bDescriptorType = USB_DT_CS_INTERFACE, |
| 110 | .bDescriptorSubType = USB_CDC_HEADER_TYPE, |
Harvey Harrison | 551509d | 2009-02-11 14:11:36 -0800 | [diff] [blame] | 111 | .bcdCDC = cpu_to_le16(0x0120), |
Felipe Balbi | 3086775 | 2008-08-18 17:39:30 -0700 | [diff] [blame] | 112 | }; |
| 113 | |
Andrzej Pietrasiewicz | 1d8fc25 | 2013-03-21 15:33:42 +0100 | [diff] [blame] | 114 | static struct usb_cdc_union_desc obex_cdc_union_desc = { |
Felipe Balbi | 3086775 | 2008-08-18 17:39:30 -0700 | [diff] [blame] | 115 | .bLength = sizeof(obex_cdc_union_desc), |
| 116 | .bDescriptorType = USB_DT_CS_INTERFACE, |
| 117 | .bDescriptorSubType = USB_CDC_UNION_TYPE, |
| 118 | .bMasterInterface0 = 1, |
| 119 | .bSlaveInterface0 = 2, |
| 120 | }; |
| 121 | |
Andrzej Pietrasiewicz | 1d8fc25 | 2013-03-21 15:33:42 +0100 | [diff] [blame] | 122 | static struct usb_cdc_obex_desc obex_desc = { |
Felipe Balbi | 3086775 | 2008-08-18 17:39:30 -0700 | [diff] [blame] | 123 | .bLength = sizeof(obex_desc), |
| 124 | .bDescriptorType = USB_DT_CS_INTERFACE, |
| 125 | .bDescriptorSubType = USB_CDC_OBEX_TYPE, |
Harvey Harrison | 551509d | 2009-02-11 14:11:36 -0800 | [diff] [blame] | 126 | .bcdVersion = cpu_to_le16(0x0100), |
Felipe Balbi | 3086775 | 2008-08-18 17:39:30 -0700 | [diff] [blame] | 127 | }; |
| 128 | |
| 129 | /* High-Speed Support */ |
| 130 | |
Andrzej Pietrasiewicz | 1d8fc25 | 2013-03-21 15:33:42 +0100 | [diff] [blame] | 131 | static struct usb_endpoint_descriptor obex_hs_ep_out_desc = { |
Felipe Balbi | 3086775 | 2008-08-18 17:39:30 -0700 | [diff] [blame] | 132 | .bLength = USB_DT_ENDPOINT_SIZE, |
| 133 | .bDescriptorType = USB_DT_ENDPOINT, |
| 134 | |
| 135 | .bEndpointAddress = USB_DIR_OUT, |
| 136 | .bmAttributes = USB_ENDPOINT_XFER_BULK, |
Harvey Harrison | 551509d | 2009-02-11 14:11:36 -0800 | [diff] [blame] | 137 | .wMaxPacketSize = cpu_to_le16(512), |
Felipe Balbi | 3086775 | 2008-08-18 17:39:30 -0700 | [diff] [blame] | 138 | }; |
| 139 | |
Andrzej Pietrasiewicz | 1d8fc25 | 2013-03-21 15:33:42 +0100 | [diff] [blame] | 140 | static struct usb_endpoint_descriptor obex_hs_ep_in_desc = { |
Felipe Balbi | 3086775 | 2008-08-18 17:39:30 -0700 | [diff] [blame] | 141 | .bLength = USB_DT_ENDPOINT_SIZE, |
| 142 | .bDescriptorType = USB_DT_ENDPOINT, |
| 143 | |
| 144 | .bEndpointAddress = USB_DIR_IN, |
| 145 | .bmAttributes = USB_ENDPOINT_XFER_BULK, |
Harvey Harrison | 551509d | 2009-02-11 14:11:36 -0800 | [diff] [blame] | 146 | .wMaxPacketSize = cpu_to_le16(512), |
Felipe Balbi | 3086775 | 2008-08-18 17:39:30 -0700 | [diff] [blame] | 147 | }; |
| 148 | |
Andrzej Pietrasiewicz | 1d8fc25 | 2013-03-21 15:33:42 +0100 | [diff] [blame] | 149 | static struct usb_descriptor_header *hs_function[] = { |
Felipe Balbi | 3086775 | 2008-08-18 17:39:30 -0700 | [diff] [blame] | 150 | (struct usb_descriptor_header *) &obex_control_intf, |
| 151 | (struct usb_descriptor_header *) &obex_cdc_header_desc, |
| 152 | (struct usb_descriptor_header *) &obex_desc, |
| 153 | (struct usb_descriptor_header *) &obex_cdc_union_desc, |
| 154 | |
| 155 | (struct usb_descriptor_header *) &obex_data_nop_intf, |
| 156 | (struct usb_descriptor_header *) &obex_data_intf, |
| 157 | (struct usb_descriptor_header *) &obex_hs_ep_in_desc, |
| 158 | (struct usb_descriptor_header *) &obex_hs_ep_out_desc, |
| 159 | NULL, |
| 160 | }; |
| 161 | |
| 162 | /* Full-Speed Support */ |
| 163 | |
Andrzej Pietrasiewicz | 1d8fc25 | 2013-03-21 15:33:42 +0100 | [diff] [blame] | 164 | static struct usb_endpoint_descriptor obex_fs_ep_in_desc = { |
Felipe Balbi | 3086775 | 2008-08-18 17:39:30 -0700 | [diff] [blame] | 165 | .bLength = USB_DT_ENDPOINT_SIZE, |
| 166 | .bDescriptorType = USB_DT_ENDPOINT, |
| 167 | |
| 168 | .bEndpointAddress = USB_DIR_IN, |
| 169 | .bmAttributes = USB_ENDPOINT_XFER_BULK, |
| 170 | }; |
| 171 | |
Andrzej Pietrasiewicz | 1d8fc25 | 2013-03-21 15:33:42 +0100 | [diff] [blame] | 172 | static struct usb_endpoint_descriptor obex_fs_ep_out_desc = { |
Felipe Balbi | 3086775 | 2008-08-18 17:39:30 -0700 | [diff] [blame] | 173 | .bLength = USB_DT_ENDPOINT_SIZE, |
| 174 | .bDescriptorType = USB_DT_ENDPOINT, |
| 175 | |
| 176 | .bEndpointAddress = USB_DIR_OUT, |
| 177 | .bmAttributes = USB_ENDPOINT_XFER_BULK, |
| 178 | }; |
| 179 | |
Andrzej Pietrasiewicz | 1d8fc25 | 2013-03-21 15:33:42 +0100 | [diff] [blame] | 180 | static struct usb_descriptor_header *fs_function[] = { |
Felipe Balbi | 3086775 | 2008-08-18 17:39:30 -0700 | [diff] [blame] | 181 | (struct usb_descriptor_header *) &obex_control_intf, |
| 182 | (struct usb_descriptor_header *) &obex_cdc_header_desc, |
| 183 | (struct usb_descriptor_header *) &obex_desc, |
| 184 | (struct usb_descriptor_header *) &obex_cdc_union_desc, |
| 185 | |
| 186 | (struct usb_descriptor_header *) &obex_data_nop_intf, |
| 187 | (struct usb_descriptor_header *) &obex_data_intf, |
| 188 | (struct usb_descriptor_header *) &obex_fs_ep_in_desc, |
| 189 | (struct usb_descriptor_header *) &obex_fs_ep_out_desc, |
| 190 | NULL, |
| 191 | }; |
| 192 | |
| 193 | /*-------------------------------------------------------------------------*/ |
| 194 | |
| 195 | static int obex_set_alt(struct usb_function *f, unsigned intf, unsigned alt) |
| 196 | { |
| 197 | struct f_obex *obex = func_to_obex(f); |
| 198 | struct usb_composite_dev *cdev = f->config->cdev; |
| 199 | |
| 200 | if (intf == obex->ctrl_id) { |
| 201 | if (alt != 0) |
| 202 | goto fail; |
| 203 | /* NOP */ |
Richard Leitner | b8b0ea5 | 2014-08-21 08:31:39 +0200 | [diff] [blame] | 204 | dev_dbg(&cdev->gadget->dev, |
| 205 | "reset obex ttyGS%d control\n", obex->port_num); |
Felipe Balbi | 3086775 | 2008-08-18 17:39:30 -0700 | [diff] [blame] | 206 | |
| 207 | } else if (intf == obex->data_id) { |
| 208 | if (alt > 1) |
| 209 | goto fail; |
| 210 | |
| 211 | if (obex->port.in->driver_data) { |
Richard Leitner | b8b0ea5 | 2014-08-21 08:31:39 +0200 | [diff] [blame] | 212 | dev_dbg(&cdev->gadget->dev, |
| 213 | "reset obex ttyGS%d\n", obex->port_num); |
Felipe Balbi | 3086775 | 2008-08-18 17:39:30 -0700 | [diff] [blame] | 214 | gserial_disconnect(&obex->port); |
| 215 | } |
| 216 | |
Tatyana Brokhman | ea2a1df | 2011-06-28 16:33:50 +0300 | [diff] [blame] | 217 | if (!obex->port.in->desc || !obex->port.out->desc) { |
Richard Leitner | b8b0ea5 | 2014-08-21 08:31:39 +0200 | [diff] [blame] | 218 | dev_dbg(&cdev->gadget->dev, |
| 219 | "init obex ttyGS%d\n", obex->port_num); |
Tatyana Brokhman | ea2a1df | 2011-06-28 16:33:50 +0300 | [diff] [blame] | 220 | if (config_ep_by_speed(cdev->gadget, f, |
| 221 | obex->port.in) || |
| 222 | config_ep_by_speed(cdev->gadget, f, |
| 223 | obex->port.out)) { |
| 224 | obex->port.out->desc = NULL; |
| 225 | obex->port.in->desc = NULL; |
| 226 | goto fail; |
| 227 | } |
Felipe Balbi | 3086775 | 2008-08-18 17:39:30 -0700 | [diff] [blame] | 228 | } |
| 229 | |
| 230 | if (alt == 1) { |
Richard Leitner | b8b0ea5 | 2014-08-21 08:31:39 +0200 | [diff] [blame] | 231 | dev_dbg(&cdev->gadget->dev, |
| 232 | "activate obex ttyGS%d\n", obex->port_num); |
Felipe Balbi | 3086775 | 2008-08-18 17:39:30 -0700 | [diff] [blame] | 233 | gserial_connect(&obex->port, obex->port_num); |
| 234 | } |
| 235 | |
| 236 | } else |
| 237 | goto fail; |
| 238 | |
Felipe Balbi | 3985f3a | 2014-09-29 15:18:20 -0500 | [diff] [blame] | 239 | obex->cur_alt = alt; |
| 240 | |
Felipe Balbi | 3086775 | 2008-08-18 17:39:30 -0700 | [diff] [blame] | 241 | return 0; |
| 242 | |
| 243 | fail: |
| 244 | return -EINVAL; |
| 245 | } |
| 246 | |
| 247 | static int obex_get_alt(struct usb_function *f, unsigned intf) |
| 248 | { |
| 249 | struct f_obex *obex = func_to_obex(f); |
| 250 | |
Felipe Balbi | 3985f3a | 2014-09-29 15:18:20 -0500 | [diff] [blame] | 251 | return obex->cur_alt; |
Felipe Balbi | 3086775 | 2008-08-18 17:39:30 -0700 | [diff] [blame] | 252 | } |
| 253 | |
| 254 | static void obex_disable(struct usb_function *f) |
| 255 | { |
| 256 | struct f_obex *obex = func_to_obex(f); |
| 257 | struct usb_composite_dev *cdev = f->config->cdev; |
| 258 | |
Richard Leitner | b8b0ea5 | 2014-08-21 08:31:39 +0200 | [diff] [blame] | 259 | dev_dbg(&cdev->gadget->dev, "obex ttyGS%d disable\n", obex->port_num); |
Felipe Balbi | 3086775 | 2008-08-18 17:39:30 -0700 | [diff] [blame] | 260 | gserial_disconnect(&obex->port); |
| 261 | } |
| 262 | |
| 263 | /*-------------------------------------------------------------------------*/ |
| 264 | |
David Brownell | 2121427 | 2008-08-18 17:45:25 -0700 | [diff] [blame] | 265 | static void obex_connect(struct gserial *g) |
| 266 | { |
| 267 | struct f_obex *obex = port_to_obex(g); |
| 268 | struct usb_composite_dev *cdev = g->func.config->cdev; |
| 269 | int status; |
| 270 | |
| 271 | if (!obex->can_activate) |
| 272 | return; |
| 273 | |
| 274 | status = usb_function_activate(&g->func); |
| 275 | if (status) |
Richard Leitner | b8b0ea5 | 2014-08-21 08:31:39 +0200 | [diff] [blame] | 276 | dev_dbg(&cdev->gadget->dev, |
| 277 | "obex ttyGS%d function activate --> %d\n", |
David Brownell | 2121427 | 2008-08-18 17:45:25 -0700 | [diff] [blame] | 278 | obex->port_num, status); |
| 279 | } |
| 280 | |
| 281 | static void obex_disconnect(struct gserial *g) |
| 282 | { |
| 283 | struct f_obex *obex = port_to_obex(g); |
| 284 | struct usb_composite_dev *cdev = g->func.config->cdev; |
| 285 | int status; |
| 286 | |
| 287 | if (!obex->can_activate) |
| 288 | return; |
| 289 | |
| 290 | status = usb_function_deactivate(&g->func); |
| 291 | if (status) |
Richard Leitner | b8b0ea5 | 2014-08-21 08:31:39 +0200 | [diff] [blame] | 292 | dev_dbg(&cdev->gadget->dev, |
| 293 | "obex ttyGS%d function deactivate --> %d\n", |
David Brownell | 2121427 | 2008-08-18 17:45:25 -0700 | [diff] [blame] | 294 | obex->port_num, status); |
| 295 | } |
| 296 | |
| 297 | /*-------------------------------------------------------------------------*/ |
| 298 | |
Andrzej Pietrasiewicz | 1d8fc25 | 2013-03-21 15:33:42 +0100 | [diff] [blame] | 299 | /* Some controllers can't support CDC OBEX ... */ |
| 300 | static inline bool can_support_obex(struct usb_configuration *c) |
| 301 | { |
| 302 | /* Since the first interface is a NOP, we can ignore the |
| 303 | * issue of multi-interface support on most controllers. |
| 304 | * |
| 305 | * Altsettings are mandatory, however... |
| 306 | */ |
| 307 | if (!gadget_supports_altsettings(c->cdev->gadget)) |
| 308 | return false; |
| 309 | |
| 310 | /* everything else is *probably* fine ... */ |
| 311 | return true; |
| 312 | } |
| 313 | |
| 314 | static int obex_bind(struct usb_configuration *c, struct usb_function *f) |
Felipe Balbi | 3086775 | 2008-08-18 17:39:30 -0700 | [diff] [blame] | 315 | { |
| 316 | struct usb_composite_dev *cdev = c->cdev; |
| 317 | struct f_obex *obex = func_to_obex(f); |
Andrzej Pietrasiewicz | 1af877c | 2013-05-23 10:51:07 +0200 | [diff] [blame] | 318 | struct usb_string *us; |
Felipe Balbi | 3086775 | 2008-08-18 17:39:30 -0700 | [diff] [blame] | 319 | int status; |
| 320 | struct usb_ep *ep; |
| 321 | |
Andrzej Pietrasiewicz | 1d8fc25 | 2013-03-21 15:33:42 +0100 | [diff] [blame] | 322 | if (!can_support_obex(c)) |
| 323 | return -EINVAL; |
| 324 | |
Andrzej Pietrasiewicz | 1af877c | 2013-05-23 10:51:07 +0200 | [diff] [blame] | 325 | us = usb_gstrings_attach(cdev, obex_strings, |
| 326 | ARRAY_SIZE(obex_string_defs)); |
| 327 | if (IS_ERR(us)) |
| 328 | return PTR_ERR(us); |
| 329 | obex_control_intf.iInterface = us[OBEX_CTRL_IDX].id; |
| 330 | obex_data_nop_intf.iInterface = us[OBEX_DATA_IDX].id; |
| 331 | obex_data_intf.iInterface = us[OBEX_DATA_IDX].id; |
Andrzej Pietrasiewicz | 1d8fc25 | 2013-03-21 15:33:42 +0100 | [diff] [blame] | 332 | |
Felipe Balbi | 3086775 | 2008-08-18 17:39:30 -0700 | [diff] [blame] | 333 | /* allocate instance-specific interface IDs, and patch descriptors */ |
| 334 | |
| 335 | status = usb_interface_id(c, f); |
| 336 | if (status < 0) |
| 337 | goto fail; |
| 338 | obex->ctrl_id = status; |
| 339 | |
| 340 | obex_control_intf.bInterfaceNumber = status; |
| 341 | obex_cdc_union_desc.bMasterInterface0 = status; |
| 342 | |
| 343 | status = usb_interface_id(c, f); |
| 344 | if (status < 0) |
| 345 | goto fail; |
| 346 | obex->data_id = status; |
| 347 | |
| 348 | obex_data_nop_intf.bInterfaceNumber = status; |
| 349 | obex_data_intf.bInterfaceNumber = status; |
| 350 | obex_cdc_union_desc.bSlaveInterface0 = status; |
| 351 | |
| 352 | /* allocate instance-specific endpoints */ |
| 353 | |
Wei Yongjun | 6ee3e8e | 2013-04-06 12:39:49 +0800 | [diff] [blame] | 354 | status = -ENODEV; |
Felipe Balbi | 3086775 | 2008-08-18 17:39:30 -0700 | [diff] [blame] | 355 | ep = usb_ep_autoconfig(cdev->gadget, &obex_fs_ep_in_desc); |
| 356 | if (!ep) |
| 357 | goto fail; |
| 358 | obex->port.in = ep; |
| 359 | ep->driver_data = cdev; /* claim */ |
| 360 | |
| 361 | ep = usb_ep_autoconfig(cdev->gadget, &obex_fs_ep_out_desc); |
| 362 | if (!ep) |
| 363 | goto fail; |
| 364 | obex->port.out = ep; |
| 365 | ep->driver_data = cdev; /* claim */ |
| 366 | |
Felipe Balbi | 3086775 | 2008-08-18 17:39:30 -0700 | [diff] [blame] | 367 | /* support all relevant hardware speeds... we expect that when |
| 368 | * hardware is dual speed, all bulk-capable endpoints work at |
| 369 | * both speeds |
| 370 | */ |
Felipe Balbi | 3086775 | 2008-08-18 17:39:30 -0700 | [diff] [blame] | 371 | |
Sebastian Andrzej Siewior | 10287ba | 2012-10-22 22:15:06 +0200 | [diff] [blame] | 372 | obex_hs_ep_in_desc.bEndpointAddress = |
| 373 | obex_fs_ep_in_desc.bEndpointAddress; |
| 374 | obex_hs_ep_out_desc.bEndpointAddress = |
| 375 | obex_fs_ep_out_desc.bEndpointAddress; |
Felipe Balbi | 3086775 | 2008-08-18 17:39:30 -0700 | [diff] [blame] | 376 | |
Sebastian Andrzej Siewior | 10287ba | 2012-10-22 22:15:06 +0200 | [diff] [blame] | 377 | status = usb_assign_descriptors(f, fs_function, hs_function, NULL); |
| 378 | if (status) |
| 379 | goto fail; |
Felipe Balbi | 3086775 | 2008-08-18 17:39:30 -0700 | [diff] [blame] | 380 | |
David Brownell | 2121427 | 2008-08-18 17:45:25 -0700 | [diff] [blame] | 381 | /* Avoid letting this gadget enumerate until the userspace |
| 382 | * OBEX server is active. |
| 383 | */ |
| 384 | status = usb_function_deactivate(f); |
| 385 | if (status < 0) |
| 386 | WARNING(cdev, "obex ttyGS%d: can't prevent enumeration, %d\n", |
| 387 | obex->port_num, status); |
| 388 | else |
| 389 | obex->can_activate = true; |
| 390 | |
| 391 | |
Richard Leitner | b8b0ea5 | 2014-08-21 08:31:39 +0200 | [diff] [blame] | 392 | dev_dbg(&cdev->gadget->dev, "obex ttyGS%d: %s speed IN/%s OUT/%s\n", |
| 393 | obex->port_num, |
| 394 | gadget_is_dualspeed(c->cdev->gadget) ? "dual" : "full", |
| 395 | obex->port.in->name, obex->port.out->name); |
Felipe Balbi | 3086775 | 2008-08-18 17:39:30 -0700 | [diff] [blame] | 396 | |
| 397 | return 0; |
| 398 | |
| 399 | fail: |
| 400 | /* we might as well release our claims on endpoints */ |
| 401 | if (obex->port.out) |
| 402 | obex->port.out->driver_data = NULL; |
| 403 | if (obex->port.in) |
| 404 | obex->port.in->driver_data = NULL; |
| 405 | |
| 406 | ERROR(cdev, "%s/%p: can't bind, err %d\n", f->name, f, status); |
| 407 | |
| 408 | return status; |
| 409 | } |
| 410 | |
Andrzej Pietrasiewicz | ecfd3f7 | 2013-03-27 12:13:25 +0100 | [diff] [blame] | 411 | static inline struct f_serial_opts *to_f_serial_opts(struct config_item *item) |
| 412 | { |
| 413 | return container_of(to_config_group(item), struct f_serial_opts, |
| 414 | func_inst.group); |
| 415 | } |
| 416 | |
| 417 | CONFIGFS_ATTR_STRUCT(f_serial_opts); |
| 418 | static ssize_t f_obex_attr_show(struct config_item *item, |
| 419 | struct configfs_attribute *attr, |
| 420 | char *page) |
| 421 | { |
| 422 | struct f_serial_opts *opts = to_f_serial_opts(item); |
| 423 | struct f_serial_opts_attribute *f_serial_opts_attr = |
| 424 | container_of(attr, struct f_serial_opts_attribute, attr); |
| 425 | ssize_t ret = 0; |
| 426 | |
| 427 | if (f_serial_opts_attr->show) |
| 428 | ret = f_serial_opts_attr->show(opts, page); |
| 429 | |
| 430 | return ret; |
| 431 | } |
| 432 | |
| 433 | static void obex_attr_release(struct config_item *item) |
| 434 | { |
| 435 | struct f_serial_opts *opts = to_f_serial_opts(item); |
| 436 | |
| 437 | usb_put_function_instance(&opts->func_inst); |
| 438 | } |
| 439 | |
| 440 | static struct configfs_item_operations obex_item_ops = { |
| 441 | .release = obex_attr_release, |
| 442 | .show_attribute = f_obex_attr_show, |
| 443 | }; |
| 444 | |
| 445 | static ssize_t f_obex_port_num_show(struct f_serial_opts *opts, char *page) |
| 446 | { |
| 447 | return sprintf(page, "%u\n", opts->port_num); |
| 448 | } |
| 449 | |
| 450 | static struct f_serial_opts_attribute f_obex_port_num = |
| 451 | __CONFIGFS_ATTR_RO(port_num, f_obex_port_num_show); |
| 452 | |
| 453 | static struct configfs_attribute *acm_attrs[] = { |
| 454 | &f_obex_port_num.attr, |
| 455 | NULL, |
| 456 | }; |
| 457 | |
| 458 | static struct config_item_type obex_func_type = { |
| 459 | .ct_item_ops = &obex_item_ops, |
| 460 | .ct_attrs = acm_attrs, |
| 461 | .ct_owner = THIS_MODULE, |
| 462 | }; |
| 463 | |
Andrzej Pietrasiewicz | 1d8fc25 | 2013-03-21 15:33:42 +0100 | [diff] [blame] | 464 | static void obex_free_inst(struct usb_function_instance *f) |
| 465 | { |
| 466 | struct f_serial_opts *opts; |
| 467 | |
| 468 | opts = container_of(f, struct f_serial_opts, func_inst); |
| 469 | gserial_free_line(opts->port_num); |
| 470 | kfree(opts); |
| 471 | } |
| 472 | |
| 473 | static struct usb_function_instance *obex_alloc_inst(void) |
| 474 | { |
| 475 | struct f_serial_opts *opts; |
| 476 | int ret; |
| 477 | |
| 478 | opts = kzalloc(sizeof(*opts), GFP_KERNEL); |
| 479 | if (!opts) |
| 480 | return ERR_PTR(-ENOMEM); |
| 481 | |
| 482 | opts->func_inst.free_func_inst = obex_free_inst; |
| 483 | ret = gserial_alloc_line(&opts->port_num); |
| 484 | if (ret) { |
| 485 | kfree(opts); |
| 486 | return ERR_PTR(ret); |
| 487 | } |
Andrzej Pietrasiewicz | ecfd3f7 | 2013-03-27 12:13:25 +0100 | [diff] [blame] | 488 | config_group_init_type_name(&opts->func_inst.group, "", |
| 489 | &obex_func_type); |
Andrzej Pietrasiewicz | 1d8fc25 | 2013-03-21 15:33:42 +0100 | [diff] [blame] | 490 | |
| 491 | return &opts->func_inst; |
| 492 | } |
| 493 | |
| 494 | static void obex_free(struct usb_function *f) |
| 495 | { |
| 496 | struct f_obex *obex; |
| 497 | |
| 498 | obex = func_to_obex(f); |
| 499 | kfree(obex); |
| 500 | } |
| 501 | |
| 502 | static void obex_unbind(struct usb_configuration *c, struct usb_function *f) |
| 503 | { |
Andrzej Pietrasiewicz | 1d8fc25 | 2013-03-21 15:33:42 +0100 | [diff] [blame] | 504 | usb_free_all_descriptors(f); |
| 505 | } |
| 506 | |
Jingoo Han | 9272fe5 | 2013-12-16 18:43:50 +0900 | [diff] [blame] | 507 | static struct usb_function *obex_alloc(struct usb_function_instance *fi) |
Andrzej Pietrasiewicz | 1d8fc25 | 2013-03-21 15:33:42 +0100 | [diff] [blame] | 508 | { |
| 509 | struct f_obex *obex; |
| 510 | struct f_serial_opts *opts; |
| 511 | |
| 512 | /* allocate and initialize one new instance */ |
| 513 | obex = kzalloc(sizeof(*obex), GFP_KERNEL); |
| 514 | if (!obex) |
| 515 | return ERR_PTR(-ENOMEM); |
| 516 | |
| 517 | opts = container_of(fi, struct f_serial_opts, func_inst); |
| 518 | |
| 519 | obex->port_num = opts->port_num; |
| 520 | |
| 521 | obex->port.connect = obex_connect; |
| 522 | obex->port.disconnect = obex_disconnect; |
| 523 | |
| 524 | obex->port.func.name = "obex"; |
Andrzej Pietrasiewicz | 1d8fc25 | 2013-03-21 15:33:42 +0100 | [diff] [blame] | 525 | /* descriptors are per-instance copies */ |
| 526 | obex->port.func.bind = obex_bind; |
| 527 | obex->port.func.unbind = obex_unbind; |
| 528 | obex->port.func.set_alt = obex_set_alt; |
| 529 | obex->port.func.get_alt = obex_get_alt; |
| 530 | obex->port.func.disable = obex_disable; |
| 531 | obex->port.func.free_func = obex_free; |
| 532 | |
| 533 | return &obex->port.func; |
| 534 | } |
| 535 | |
| 536 | DECLARE_USB_FUNCTION_INIT(obex, obex_alloc_inst, obex_alloc); |
Felipe Balbi | 3086775 | 2008-08-18 17:39:30 -0700 | [diff] [blame] | 537 | MODULE_AUTHOR("Felipe Balbi"); |
| 538 | MODULE_LICENSE("GPL"); |