Eric Lee / smarc-uboot

1

/*

1

/*

2

* ether.c -- Ethernet gadget driver, with CDC and non-CDC options

2

* ether.c -- Ethernet gadget driver, with CDC and non-CDC options

3

*

3

*

4

5

6

7

*

7

*

8

* SPDX-License-Identifier: GPL-2.0+

8

* SPDX-License-Identifier: GPL-2.0+

9

*/

9

*/

10

11

#include <common.h>

11

#include <common.h>

12

#include <asm/errno.h>

12

#include <asm/errno.h>

13

#include <linux/netdevice.h>

13

#include <linux/netdevice.h>

14

#include <linux/usb/ch9.h>

14

#include <linux/usb/ch9.h>

15

#include <linux/usb/cdc.h>

15

#include <linux/usb/cdc.h>

16

#include <linux/usb/gadget.h>

16

#include <linux/usb/gadget.h>

17

#include <net.h>

17

#include <net.h>

18

#include <malloc.h>

18

#include <malloc.h>

19

#include <linux/ctype.h>

19

#include <linux/ctype.h>

20

21

#include "gadget_chips.h"

21

#include "gadget_chips.h"

22

#include "rndis.h"

22

#include "rndis.h"

23

24

#define USB_NET_NAME "usb_ether"

24

#define USB_NET_NAME "usb_ether"

25

26

#define atomic_read

26

#define atomic_read

27

extern struct platform_data brd;

27

extern struct platform_data brd;

28

#define spin_lock(x)

28

#define spin_lock(x)

29

#define spin_unlock(x)

29

#define spin_unlock(x)

30

31

32

unsigned packet_received, packet_sent;

32

unsigned packet_received, packet_sent;

33

34

#define GFP_ATOMIC ((gfp_t) 0)

34

#define GFP_ATOMIC ((gfp_t) 0)

35

#define GFP_KERNEL ((gfp_t) 0)

35

#define GFP_KERNEL ((gfp_t) 0)

36

37

/*

37

/*

38

* Ethernet gadget driver -- with CDC and non-CDC options

38

* Ethernet gadget driver -- with CDC and non-CDC options

39

* Builds on hardware support for a full duplex link.

39

* Builds on hardware support for a full duplex link.

40

*

40

*

41

* CDC Ethernet is the standard USB solution for sending Ethernet frames

41

* CDC Ethernet is the standard USB solution for sending Ethernet frames

42

* using USB. Real hardware tends to use the same framing protocol but look

42

* using USB. Real hardware tends to use the same framing protocol but look

43

* different for control features. This driver strongly prefers to use

43

* different for control features. This driver strongly prefers to use

44

* this USB-IF standard as its open-systems interoperability solution;

44

* this USB-IF standard as its open-systems interoperability solution;

45

* most host side USB stacks (except from Microsoft) support it.

45

* most host side USB stacks (except from Microsoft) support it.

46

*

46

*

47

* This is sometimes called "CDC ECM" (Ethernet Control Model) to support

47

* This is sometimes called "CDC ECM" (Ethernet Control Model) to support

48

* TLA-soup. "CDC ACM" (Abstract Control Model) is for modems, and a new

48

* TLA-soup. "CDC ACM" (Abstract Control Model) is for modems, and a new

49

* "CDC EEM" (Ethernet Emulation Model) is starting to spread.

49

* "CDC EEM" (Ethernet Emulation Model) is starting to spread.

50

*

50

*

51

* There's some hardware that can't talk CDC ECM. We make that hardware

51

* There's some hardware that can't talk CDC ECM. We make that hardware

52

* implement a "minimalist" vendor-agnostic CDC core: same framing, but

52

* implement a "minimalist" vendor-agnostic CDC core: same framing, but

53

* link-level setup only requires activating the configuration. Only the

53

* link-level setup only requires activating the configuration. Only the

54

* endpoint descriptors, and product/vendor IDs, are relevant; no control

54

* endpoint descriptors, and product/vendor IDs, are relevant; no control

55

* operations are available. Linux supports it, but other host operating

55

* operations are available. Linux supports it, but other host operating

56

* systems may not. (This is a subset of CDC Ethernet.)

56

* systems may not. (This is a subset of CDC Ethernet.)

57

*

57

*

58

* It turns out that if you add a few descriptors to that "CDC Subset",

58

* It turns out that if you add a few descriptors to that "CDC Subset",

59

* (Windows) host side drivers from MCCI can treat it as one submode of

59

* (Windows) host side drivers from MCCI can treat it as one submode of

60

* a proprietary scheme called "SAFE" ... without needing to know about

60

* a proprietary scheme called "SAFE" ... without needing to know about

61

* specific product/vendor IDs. So we do that, making it easier to use

61

* specific product/vendor IDs. So we do that, making it easier to use

62

* those MS-Windows drivers. Those added descriptors make it resemble a

62

* those MS-Windows drivers. Those added descriptors make it resemble a

63

* CDC MDLM device, but they don't change device behavior at all. (See

63

* CDC MDLM device, but they don't change device behavior at all. (See

64

* MCCI Engineering report 950198 "SAFE Networking Functions".)

64

* MCCI Engineering report 950198 "SAFE Networking Functions".)

65

*

65

*

66

* A third option is also in use. Rather than CDC Ethernet, or something

66

* A third option is also in use. Rather than CDC Ethernet, or something

67

* simpler, Microsoft pushes their own approach: RNDIS. The published

67

* simpler, Microsoft pushes their own approach: RNDIS. The published

68

* RNDIS specs are ambiguous and appear to be incomplete, and are also

68

* RNDIS specs are ambiguous and appear to be incomplete, and are also

69

* needlessly complex. They borrow more from CDC ACM than CDC ECM.

69

* needlessly complex. They borrow more from CDC ACM than CDC ECM.

70

*/

70

*/

71

#define ETH_ALEN 6 /* Octets in one ethernet addr */

71

#define ETH_ALEN 6 /* Octets in one ethernet addr */

72

#define ETH_HLEN 14 /* Total octets in header. */

72

#define ETH_HLEN 14 /* Total octets in header. */

73

#define ETH_ZLEN 60 /* Min. octets in frame sans FCS */

73

#define ETH_ZLEN 60 /* Min. octets in frame sans FCS */

74

#define ETH_DATA_LEN 1500 /* Max. octets in payload */

74

#define ETH_DATA_LEN 1500 /* Max. octets in payload */

75

#define ETH_FRAME_LEN PKTSIZE_ALIGN /* Max. octets in frame sans FCS */

75

#define ETH_FRAME_LEN PKTSIZE_ALIGN /* Max. octets in frame sans FCS */

76

#define ETH_FCS_LEN 4 /* Octets in the FCS */

76

#define ETH_FCS_LEN 4 /* Octets in the FCS */

77

78

#define DRIVER_DESC "Ethernet Gadget"

78

#define DRIVER_DESC "Ethernet Gadget"

79

/* Based on linux 2.6.27 version */

79

/* Based on linux 2.6.27 version */

80

#define DRIVER_VERSION "May Day 2005"

80

#define DRIVER_VERSION "May Day 2005"

81

82

static const char shortname[] = "ether";

82

static const char shortname[] = "ether";

83

static const char driver_desc[] = DRIVER_DESC;

83

static const char driver_desc[] = DRIVER_DESC;

84

85

#define RX_EXTRA 20 /* guard against rx overflows */

85

#define RX_EXTRA 20 /* guard against rx overflows */

86

87

#ifndef CONFIG_USB_ETH_RNDIS

87

#ifndef CONFIG_USB_ETH_RNDIS

88

#define rndis_uninit(x) do {} while (0)

88

#define rndis_uninit(x) do {} while (0)

89

#define rndis_deregister(c) do {} while (0)

89

#define rndis_deregister(c) do {} while (0)

90

#define rndis_exit() do {} while (0)

90

#define rndis_exit() do {} while (0)

91

#endif

91

#endif

92

93

/* CDC and RNDIS support the same host-chosen outgoing packet filters. */

93

/* CDC and RNDIS support the same host-chosen outgoing packet filters. */

94

#define DEFAULT_FILTER (USB_CDC_PACKET_TYPE_BROADCAST \

94

#define DEFAULT_FILTER (USB_CDC_PACKET_TYPE_BROADCAST \

95

|USB_CDC_PACKET_TYPE_ALL_MULTICAST \

95

|USB_CDC_PACKET_TYPE_ALL_MULTICAST \

96

|USB_CDC_PACKET_TYPE_PROMISCUOUS \

96

|USB_CDC_PACKET_TYPE_PROMISCUOUS \

97

|USB_CDC_PACKET_TYPE_DIRECTED)

97

|USB_CDC_PACKET_TYPE_DIRECTED)

98

99

#define USB_CONNECT_TIMEOUT (3 * CONFIG_SYS_HZ)

99

#define USB_CONNECT_TIMEOUT (3 * CONFIG_SYS_HZ)

100

101

/*-------------------------------------------------------------------------*/

101

/*-------------------------------------------------------------------------*/

102

103

struct eth_dev {

103

struct eth_dev {

104

struct usb_gadget *gadget;

104

struct usb_gadget *gadget;

105

struct usb_request *req; /* for control responses */

105

struct usb_request *req; /* for control responses */

106

struct usb_request *stat_req; /* for cdc & rndis status */

106

struct usb_request *stat_req; /* for cdc & rndis status */

107

108

u8 config;

108

u8 config;

109

struct usb_ep *in_ep, *out_ep, *status_ep;

109

struct usb_ep *in_ep, *out_ep, *status_ep;

110

const struct usb_endpoint_descriptor

110

const struct usb_endpoint_descriptor

111

*in, *out, *status;

111

*in, *out, *status;

112

113

struct usb_request *tx_req, *rx_req;

113

struct usb_request *tx_req, *rx_req;

114

115

struct eth_device *net;

115

struct eth_device *net;

116

struct net_device_stats stats;

116

struct net_device_stats stats;

117

unsigned int tx_qlen;

117

unsigned int tx_qlen;

118

119

unsigned zlp:1;

119

unsigned zlp:1;

120

unsigned cdc:1;

120

unsigned cdc:1;

121

unsigned rndis:1;

121

unsigned rndis:1;

122

unsigned suspended:1;

122

unsigned suspended:1;

123

unsigned network_started:1;

123

unsigned network_started:1;

124

u16 cdc_filter;

124

u16 cdc_filter;

125

unsigned long todo;

125

unsigned long todo;

126

int mtu;

126

int mtu;

127

#define WORK_RX_MEMORY 0

127

#define WORK_RX_MEMORY 0

128

int rndis_config;

128

int rndis_config;

129

u8 host_mac[ETH_ALEN];

129

u8 host_mac[ETH_ALEN];

130

};

130

};

131

132

/*

132

/*

133

* This version autoconfigures as much as possible at run-time.

133

* This version autoconfigures as much as possible at run-time.

134

*

134

*

135

* It also ASSUMES a self-powered device, without remote wakeup,

135

* It also ASSUMES a self-powered device, without remote wakeup,

136

* although remote wakeup support would make sense.

136

* although remote wakeup support would make sense.

137

*/

137

*/

138

139

/*-------------------------------------------------------------------------*/

139

/*-------------------------------------------------------------------------*/

140

static struct eth_dev l_ethdev;

140

static struct eth_dev l_ethdev;

141

static struct eth_device l_netdev;

141

static struct eth_device l_netdev;

142

static struct usb_gadget_driver eth_driver;

142

static struct usb_gadget_driver eth_driver;

143

144

/*-------------------------------------------------------------------------*/

144

/*-------------------------------------------------------------------------*/

145

146

/* "main" config is either CDC, or its simple subset */

146

/* "main" config is either CDC, or its simple subset */

147

static inline int is_cdc(struct eth_dev *dev)

147

static inline int is_cdc(struct eth_dev *dev)

148

{

148

{

149

#if !defined(CONFIG_USB_ETH_SUBSET)

149

#if !defined(CONFIG_USB_ETH_SUBSET)

150

return 1; /* only cdc possible */

150

return 1; /* only cdc possible */

151

#elif !defined(CONFIG_USB_ETH_CDC)

151

#elif !defined(CONFIG_USB_ETH_CDC)

152

return 0; /* only subset possible */

152

return 0; /* only subset possible */

153

#else

153

#else

154

return dev->cdc; /* depends on what hardware we found */

154

return dev->cdc; /* depends on what hardware we found */

155

#endif

155

#endif

156

}

156

}

157

158

/* "secondary" RNDIS config may sometimes be activated */

158

/* "secondary" RNDIS config may sometimes be activated */

159

static inline int rndis_active(struct eth_dev *dev)

159

static inline int rndis_active(struct eth_dev *dev)

160

{

160

{

161

#ifdef CONFIG_USB_ETH_RNDIS

161

#ifdef CONFIG_USB_ETH_RNDIS

162

return dev->rndis;

162

return dev->rndis;

163

#else

163

#else

164

return 0;

164

return 0;

165

#endif

165

#endif

166

}

166

}

167

168

#define subset_active(dev) (!is_cdc(dev) && !rndis_active(dev))

168

#define subset_active(dev) (!is_cdc(dev) && !rndis_active(dev))

169

#define cdc_active(dev) (is_cdc(dev) && !rndis_active(dev))

169

#define cdc_active(dev) (is_cdc(dev) && !rndis_active(dev))

170

171

#define DEFAULT_QLEN 2 /* double buffering by default */

171

#define DEFAULT_QLEN 2 /* double buffering by default */

172

173

/* peak bulk transfer bits-per-second */

173

/* peak bulk transfer bits-per-second */

174

#define HS_BPS (13 * 512 * 8 * 1000 * 8)

174

#define HS_BPS (13 * 512 * 8 * 1000 * 8)

175

#define FS_BPS (19 * 64 * 1 * 1000 * 8)

175

#define FS_BPS (19 * 64 * 1 * 1000 * 8)

176

177

#ifdef CONFIG_USB_GADGET_DUALSPEED

177

#ifdef CONFIG_USB_GADGET_DUALSPEED

178

#define DEVSPEED USB_SPEED_HIGH

178

#define DEVSPEED USB_SPEED_HIGH

179

180

#ifdef CONFIG_USB_ETH_QMULT

180

#ifdef CONFIG_USB_ETH_QMULT

181

#define qmult CONFIG_USB_ETH_QMULT

181

#define qmult CONFIG_USB_ETH_QMULT

182

#else

182

#else

183

#define qmult 5

183

#define qmult 5

184

#endif

184

#endif

185

186

/* for dual-speed hardware, use deeper queues at highspeed */

186

/* for dual-speed hardware, use deeper queues at highspeed */

187

#define qlen(gadget) \

187

#define qlen(gadget) \

188

(DEFAULT_QLEN*((gadget->speed == USB_SPEED_HIGH) ? qmult : 1))

188

(DEFAULT_QLEN*((gadget->speed == USB_SPEED_HIGH) ? qmult : 1))

189

190

static inline int BITRATE(struct usb_gadget *g)

190

static inline int BITRATE(struct usb_gadget *g)

191

{

191

{

192

return (g->speed == USB_SPEED_HIGH) ? HS_BPS : FS_BPS;

192

return (g->speed == USB_SPEED_HIGH) ? HS_BPS : FS_BPS;

193

}

193

}

194

195

#else /* full speed (low speed doesn't do bulk) */

195

#else /* full speed (low speed doesn't do bulk) */

196

197

#define qmult 1

197

#define qmult 1

198

199

#define DEVSPEED USB_SPEED_FULL

199

#define DEVSPEED USB_SPEED_FULL

200

201

#define qlen(gadget) DEFAULT_QLEN

201

#define qlen(gadget) DEFAULT_QLEN

202

203

static inline int BITRATE(struct usb_gadget *g)

203

static inline int BITRATE(struct usb_gadget *g)

204

{

204

{

205

return FS_BPS;

205

return FS_BPS;

206

}

206

}

207

#endif

207

#endif

208

209

/*-------------------------------------------------------------------------*/

209

/*-------------------------------------------------------------------------*/

210

211

/*

211

/*

212

* DO NOT REUSE THESE IDs with a protocol-incompatible driver!! Ever!!

212

* DO NOT REUSE THESE IDs with a protocol-incompatible driver!! Ever!!

213

* Instead: allocate your own, using normal USB-IF procedures.

213

* Instead: allocate your own, using normal USB-IF procedures.

214

*/

214

*/

215

216

/*

216

/*

217

* Thanks to NetChip Technologies for donating this product ID.

217

* Thanks to NetChip Technologies for donating this product ID.

218

* It's for devices with only CDC Ethernet configurations.

218

* It's for devices with only CDC Ethernet configurations.

219

*/

219

*/

220

#define CDC_VENDOR_NUM 0x0525 /* NetChip */

220

#define CDC_VENDOR_NUM 0x0525 /* NetChip */

221

#define CDC_PRODUCT_NUM 0xa4a1 /* Linux-USB Ethernet Gadget */

221

#define CDC_PRODUCT_NUM 0xa4a1 /* Linux-USB Ethernet Gadget */

222

223

/*

223

/*

224

* For hardware that can't talk CDC, we use the same vendor ID that

224

* For hardware that can't talk CDC, we use the same vendor ID that

225

* ARM Linux has used for ethernet-over-usb, both with sa1100 and

225

* ARM Linux has used for ethernet-over-usb, both with sa1100 and

226

* with pxa250. We're protocol-compatible, if the host-side drivers

226

* with pxa250. We're protocol-compatible, if the host-side drivers

227

* use the endpoint descriptors. bcdDevice (version) is nonzero, so

227

* use the endpoint descriptors. bcdDevice (version) is nonzero, so

228

* drivers that need to hard-wire endpoint numbers have a hook.

228

* drivers that need to hard-wire endpoint numbers have a hook.

229

*

229

*

230

* The protocol is a minimal subset of CDC Ether, which works on any bulk

230

* The protocol is a minimal subset of CDC Ether, which works on any bulk

231

* hardware that's not deeply broken ... even on hardware that can't talk

231

* hardware that's not deeply broken ... even on hardware that can't talk

232

* RNDIS (like SA-1100, with no interrupt endpoint, or anything that

232

* RNDIS (like SA-1100, with no interrupt endpoint, or anything that

233

* doesn't handle control-OUT).

233

* doesn't handle control-OUT).

234

*/

234

*/

235

#define SIMPLE_VENDOR_NUM 0x049f /* Compaq Computer Corp. */

235

#define SIMPLE_VENDOR_NUM 0x049f /* Compaq Computer Corp. */

236

#define SIMPLE_PRODUCT_NUM 0x505a /* Linux-USB "CDC Subset" Device */

236

#define SIMPLE_PRODUCT_NUM 0x505a /* Linux-USB "CDC Subset" Device */

237

238

/*

238

/*

239

* For hardware that can talk RNDIS and either of the above protocols,

239

* For hardware that can talk RNDIS and either of the above protocols,

240

* use this ID ... the windows INF files will know it. Unless it's

240

* use this ID ... the windows INF files will know it. Unless it's

241

* used with CDC Ethernet, Linux 2.4 hosts will need updates to choose

241

* used with CDC Ethernet, Linux 2.4 hosts will need updates to choose

242

* the non-RNDIS configuration.

242

* the non-RNDIS configuration.

243

*/

243

*/

244

#define RNDIS_VENDOR_NUM 0x0525 /* NetChip */

244

#define RNDIS_VENDOR_NUM 0x0525 /* NetChip */

245

#define RNDIS_PRODUCT_NUM 0xa4a2 /* Ethernet/RNDIS Gadget */

245

#define RNDIS_PRODUCT_NUM 0xa4a2 /* Ethernet/RNDIS Gadget */

246

247

/*

247

/*

248

* Some systems will want different product identifers published in the

248

* Some systems will want different product identifers published in the

249

* device descriptor, either numbers or strings or both. These string

249

* device descriptor, either numbers or strings or both. These string

250

* parameters are in UTF-8 (superset of ASCII's 7 bit characters).

250

* parameters are in UTF-8 (superset of ASCII's 7 bit characters).

251

*/

251

*/

252

253

/*

253

/*

254

* Emulating them in eth_bind:

254

* Emulating them in eth_bind:

255

* static ushort idVendor;

255

* static ushort idVendor;

256

* static ushort idProduct;

256

* static ushort idProduct;

257

*/

257

*/

258

259

#if defined(CONFIG_USBNET_MANUFACTURER)

259

#if defined(CONFIG_USBNET_MANUFACTURER)

260

static char *iManufacturer = CONFIG_USBNET_MANUFACTURER;

260

static char *iManufacturer = CONFIG_USBNET_MANUFACTURER;

261

#else

261

#else

262

static char *iManufacturer = "U-boot";

262

static char *iManufacturer = "U-boot";

263

#endif

263

#endif

264

265

/* These probably need to be configurable. */

265

/* These probably need to be configurable. */

266

static ushort bcdDevice;

266

static ushort bcdDevice;

267

static char *iProduct;

267

static char *iProduct;

268

static char *iSerialNumber;

268

static char *iSerialNumber;

269

270

static char dev_addr[18];

270

static char dev_addr[18];

271

272

static char host_addr[18];

272

static char host_addr[18];

273

274

275

/*-------------------------------------------------------------------------*/

275

/*-------------------------------------------------------------------------*/

276

277

/*

277

/*

278

* USB DRIVER HOOKUP (to the hardware driver, below us), mostly

278

* USB DRIVER HOOKUP (to the hardware driver, below us), mostly

279

* ep0 implementation: descriptors, config management, setup().

279

* ep0 implementation: descriptors, config management, setup().

280

* also optional class-specific notification interrupt transfer.

280

* also optional class-specific notification interrupt transfer.

281

*/

281

*/

282

283

/*

283

/*

284

* DESCRIPTORS ... most are static, but strings and (full) configuration

284

* DESCRIPTORS ... most are static, but strings and (full) configuration

285

* descriptors are built on demand. For now we do either full CDC, or

285

* descriptors are built on demand. For now we do either full CDC, or

286

* our simple subset, with RNDIS as an optional second configuration.

286

* our simple subset, with RNDIS as an optional second configuration.

287

*

287

*

288

* RNDIS includes some CDC ACM descriptors ... like CDC Ethernet. But

288

* RNDIS includes some CDC ACM descriptors ... like CDC Ethernet. But

289

* the class descriptors match a modem (they're ignored; it's really just

289

* the class descriptors match a modem (they're ignored; it's really just

290

* Ethernet functionality), they don't need the NOP altsetting, and the

290

* Ethernet functionality), they don't need the NOP altsetting, and the

291

* status transfer endpoint isn't optional.

291

* status transfer endpoint isn't optional.

292

*/

292

*/

293

294

#define STRING_MANUFACTURER 1

294

#define STRING_MANUFACTURER 1

295

#define STRING_PRODUCT 2

295

#define STRING_PRODUCT 2

296

#define STRING_ETHADDR 3

296

#define STRING_ETHADDR 3

297

#define STRING_DATA 4

297

#define STRING_DATA 4

298

#define STRING_CONTROL 5

298

#define STRING_CONTROL 5

299

#define STRING_RNDIS_CONTROL 6

299

#define STRING_RNDIS_CONTROL 6

300

#define STRING_CDC 7

300

#define STRING_CDC 7

301

#define STRING_SUBSET 8

301

#define STRING_SUBSET 8

302

#define STRING_RNDIS 9

302

#define STRING_RNDIS 9

303

#define STRING_SERIALNUMBER 10

303

#define STRING_SERIALNUMBER 10

304

305

/* holds our biggest descriptor (or RNDIS response) */

305

/* holds our biggest descriptor (or RNDIS response) */

306

#define USB_BUFSIZ 256

306

#define USB_BUFSIZ 256

307

308

/*

308

/*

309

* This device advertises one configuration, eth_config, unless RNDIS

309

* This device advertises one configuration, eth_config, unless RNDIS

310

* is enabled (rndis_config) on hardware supporting at least two configs.

310

* is enabled (rndis_config) on hardware supporting at least two configs.

311

*

311

*

312

* NOTE: Controllers like superh_udc should probably be able to use

312

* NOTE: Controllers like superh_udc should probably be able to use

313

* an RNDIS-only configuration.

313

* an RNDIS-only configuration.

314

*

314

*

315

* FIXME define some higher-powered configurations to make it easier

315

* FIXME define some higher-powered configurations to make it easier

316

* to recharge batteries ...

316

* to recharge batteries ...

317

*/

317

*/

318

319

#define DEV_CONFIG_VALUE 1 /* cdc or subset */

319

#define DEV_CONFIG_VALUE 1 /* cdc or subset */

320

#define DEV_RNDIS_CONFIG_VALUE 2 /* rndis; optional */

320

#define DEV_RNDIS_CONFIG_VALUE 2 /* rndis; optional */

321

322

static struct usb_device_descriptor

322

static struct usb_device_descriptor

323

device_desc = {

323

device_desc = {

324

.bLength = sizeof device_desc,

324

.bLength = sizeof device_desc,

325

.bDescriptorType = USB_DT_DEVICE,

325

.bDescriptorType = USB_DT_DEVICE,

326

327

.bcdUSB = __constant_cpu_to_le16(0x0200),

327

.bcdUSB = __constant_cpu_to_le16(0x0200),

328

329

.bDeviceClass = USB_CLASS_COMM,

329

.bDeviceClass = USB_CLASS_COMM,

330

.bDeviceSubClass = 0,

330

.bDeviceSubClass = 0,

331

.bDeviceProtocol = 0,

331

.bDeviceProtocol = 0,

332

333

.idVendor = __constant_cpu_to_le16(CDC_VENDOR_NUM),

333

.idVendor = __constant_cpu_to_le16(CDC_VENDOR_NUM),

334

.idProduct = __constant_cpu_to_le16(CDC_PRODUCT_NUM),

334

.idProduct = __constant_cpu_to_le16(CDC_PRODUCT_NUM),

335

.iManufacturer = STRING_MANUFACTURER,

335

.iManufacturer = STRING_MANUFACTURER,

336

.iProduct = STRING_PRODUCT,

336

.iProduct = STRING_PRODUCT,

337

.bNumConfigurations = 1,

337

.bNumConfigurations = 1,

338

};

338

};

339

340

static struct usb_otg_descriptor

340

static struct usb_otg_descriptor

341

otg_descriptor = {

341

otg_descriptor = {

342

.bLength = sizeof otg_descriptor,

342

.bLength = sizeof otg_descriptor,

343

.bDescriptorType = USB_DT_OTG,

343

.bDescriptorType = USB_DT_OTG,

344

345

.bmAttributes = USB_OTG_SRP,

345

.bmAttributes = USB_OTG_SRP,

346

};

346

};

347

348

static struct usb_config_descriptor

348

static struct usb_config_descriptor

349

eth_config = {

349

eth_config = {

350

.bLength = sizeof eth_config,

350

.bLength = sizeof eth_config,

351

.bDescriptorType = USB_DT_CONFIG,

351

.bDescriptorType = USB_DT_CONFIG,

352

353

/* compute wTotalLength on the fly */

353

/* compute wTotalLength on the fly */

354

.bNumInterfaces = 2,

354

.bNumInterfaces = 2,

355

.bConfigurationValue = DEV_CONFIG_VALUE,

355

.bConfigurationValue = DEV_CONFIG_VALUE,

356

.iConfiguration = STRING_CDC,

356

.iConfiguration = STRING_CDC,

357

.bmAttributes = USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER,

357

.bmAttributes = USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER,

358

.bMaxPower = 1,

358

.bMaxPower = 1,

359

};

359

};

360

361

#ifdef CONFIG_USB_ETH_RNDIS

361

#ifdef CONFIG_USB_ETH_RNDIS

362

static struct usb_config_descriptor

362

static struct usb_config_descriptor

363

rndis_config = {

363

rndis_config = {

364

.bLength = sizeof rndis_config,

364

.bLength = sizeof rndis_config,

365

.bDescriptorType = USB_DT_CONFIG,

365

.bDescriptorType = USB_DT_CONFIG,

366

367

/* compute wTotalLength on the fly */

367

/* compute wTotalLength on the fly */

368

.bNumInterfaces = 2,

368

.bNumInterfaces = 2,

369

.bConfigurationValue = DEV_RNDIS_CONFIG_VALUE,

369

.bConfigurationValue = DEV_RNDIS_CONFIG_VALUE,

370

.iConfiguration = STRING_RNDIS,

370

.iConfiguration = STRING_RNDIS,

371

.bmAttributes = USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER,

371

.bmAttributes = USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER,

372

.bMaxPower = 1,

372

.bMaxPower = 1,

373

};

373

};

374

#endif

374

#endif

375

376

/*

376

/*

377

* Compared to the simple CDC subset, the full CDC Ethernet model adds

377

* Compared to the simple CDC subset, the full CDC Ethernet model adds

378

* three class descriptors, two interface descriptors, optional status

378

* three class descriptors, two interface descriptors, optional status

379

* endpoint. Both have a "data" interface and two bulk endpoints.

379

* endpoint. Both have a "data" interface and two bulk endpoints.

380

* There are also differences in how control requests are handled.

380

* There are also differences in how control requests are handled.

381

*

381

*

382

* RNDIS shares a lot with CDC-Ethernet, since it's a variant of the

382

* RNDIS shares a lot with CDC-Ethernet, since it's a variant of the

383

* CDC-ACM (modem) spec. Unfortunately MSFT's RNDIS driver is buggy; it

383

* CDC-ACM (modem) spec. Unfortunately MSFT's RNDIS driver is buggy; it

384

* may hang or oops. Since bugfixes (or accurate specs, letting Linux

384

* may hang or oops. Since bugfixes (or accurate specs, letting Linux

385

* work around those bugs) are unlikely to ever come from MSFT, you may

385

* work around those bugs) are unlikely to ever come from MSFT, you may

386

* wish to avoid using RNDIS.

386

* wish to avoid using RNDIS.

387

*

387

*

388

* MCCI offers an alternative to RNDIS if you need to connect to Windows

388

* MCCI offers an alternative to RNDIS if you need to connect to Windows

389

* but have hardware that can't support CDC Ethernet. We add descriptors

389

* but have hardware that can't support CDC Ethernet. We add descriptors

390

* to present the CDC Subset as a (nonconformant) CDC MDLM variant called

390

* to present the CDC Subset as a (nonconformant) CDC MDLM variant called

391

* "SAFE". That borrows from both CDC Ethernet and CDC MDLM. You can

391

* "SAFE". That borrows from both CDC Ethernet and CDC MDLM. You can

392

* get those drivers from MCCI, or bundled with various products.

392

* get those drivers from MCCI, or bundled with various products.

393

*/

393

*/

394

395

#ifdef CONFIG_USB_ETH_CDC

395

#ifdef CONFIG_USB_ETH_CDC

396

static struct usb_interface_descriptor

396

static struct usb_interface_descriptor

397

control_intf = {

397

control_intf = {

398

.bLength = sizeof control_intf,

398

.bLength = sizeof control_intf,

399

.bDescriptorType = USB_DT_INTERFACE,

399

.bDescriptorType = USB_DT_INTERFACE,

400

401

.bInterfaceNumber = 0,

401

.bInterfaceNumber = 0,

402

/* status endpoint is optional; this may be patched later */

402

/* status endpoint is optional; this may be patched later */

403

.bNumEndpoints = 1,

403

.bNumEndpoints = 1,

404

.bInterfaceClass = USB_CLASS_COMM,

404

.bInterfaceClass = USB_CLASS_COMM,

405

.bInterfaceSubClass = USB_CDC_SUBCLASS_ETHERNET,

405

.bInterfaceSubClass = USB_CDC_SUBCLASS_ETHERNET,

406

.bInterfaceProtocol = USB_CDC_PROTO_NONE,

406

.bInterfaceProtocol = USB_CDC_PROTO_NONE,

407

.iInterface = STRING_CONTROL,

407

.iInterface = STRING_CONTROL,

408

};

408

};

409

#endif

409

#endif

410

411

#ifdef CONFIG_USB_ETH_RNDIS

411

#ifdef CONFIG_USB_ETH_RNDIS

412

static const struct usb_interface_descriptor

412

static const struct usb_interface_descriptor

413

rndis_control_intf = {

413

rndis_control_intf = {

414

.bLength = sizeof rndis_control_intf,

414

.bLength = sizeof rndis_control_intf,

415

.bDescriptorType = USB_DT_INTERFACE,

415

.bDescriptorType = USB_DT_INTERFACE,

416

417

.bInterfaceNumber = 0,

417

.bInterfaceNumber = 0,

418

.bNumEndpoints = 1,

418

.bNumEndpoints = 1,

419

.bInterfaceClass = USB_CLASS_COMM,

419

.bInterfaceClass = USB_CLASS_COMM,

420

.bInterfaceSubClass = USB_CDC_SUBCLASS_ACM,

420

.bInterfaceSubClass = USB_CDC_SUBCLASS_ACM,

421

.bInterfaceProtocol = USB_CDC_ACM_PROTO_VENDOR,

421

.bInterfaceProtocol = USB_CDC_ACM_PROTO_VENDOR,

422

.iInterface = STRING_RNDIS_CONTROL,

422

.iInterface = STRING_RNDIS_CONTROL,

423

};

423

};

424

#endif

424

#endif

425

426

static const struct usb_cdc_header_desc header_desc = {

426

static const struct usb_cdc_header_desc header_desc = {

427

.bLength = sizeof header_desc,

427

.bLength = sizeof header_desc,

428

.bDescriptorType = USB_DT_CS_INTERFACE,

428

.bDescriptorType = USB_DT_CS_INTERFACE,

429

.bDescriptorSubType = USB_CDC_HEADER_TYPE,

429

.bDescriptorSubType = USB_CDC_HEADER_TYPE,

430

431

.bcdCDC = __constant_cpu_to_le16(0x0110),

431

.bcdCDC = __constant_cpu_to_le16(0x0110),

432

};

432

};

433

434

#if defined(CONFIG_USB_ETH_CDC) || defined(CONFIG_USB_ETH_RNDIS)

434

#if defined(CONFIG_USB_ETH_CDC) || defined(CONFIG_USB_ETH_RNDIS)

435

436

static const struct usb_cdc_union_desc union_desc = {

436

static const struct usb_cdc_union_desc union_desc = {

437

.bLength = sizeof union_desc,

437

.bLength = sizeof union_desc,

438

.bDescriptorType = USB_DT_CS_INTERFACE,

438

.bDescriptorType = USB_DT_CS_INTERFACE,

439

.bDescriptorSubType = USB_CDC_UNION_TYPE,

439

.bDescriptorSubType = USB_CDC_UNION_TYPE,

440

441

.bMasterInterface0 = 0, /* index of control interface */

441

.bMasterInterface0 = 0, /* index of control interface */

442

.bSlaveInterface0 = 1, /* index of DATA interface */

442

.bSlaveInterface0 = 1, /* index of DATA interface */

443

};

443

};

444

445

#endif /* CDC || RNDIS */

445

#endif /* CDC || RNDIS */

446

447

#ifdef CONFIG_USB_ETH_RNDIS

447

#ifdef CONFIG_USB_ETH_RNDIS

448

449

static const struct usb_cdc_call_mgmt_descriptor call_mgmt_descriptor = {

449

static const struct usb_cdc_call_mgmt_descriptor call_mgmt_descriptor = {

450

.bLength = sizeof call_mgmt_descriptor,

450

.bLength = sizeof call_mgmt_descriptor,

451

.bDescriptorType = USB_DT_CS_INTERFACE,

451

.bDescriptorType = USB_DT_CS_INTERFACE,

452

.bDescriptorSubType = USB_CDC_CALL_MANAGEMENT_TYPE,

452

.bDescriptorSubType = USB_CDC_CALL_MANAGEMENT_TYPE,

453

454

.bmCapabilities = 0x00,

454

.bmCapabilities = 0x00,

455

.bDataInterface = 0x01,

455

.bDataInterface = 0x01,

456

};

456

};

457

458

static const struct usb_cdc_acm_descriptor acm_descriptor = {

458

static const struct usb_cdc_acm_descriptor acm_descriptor = {

459

.bLength = sizeof acm_descriptor,

459

.bLength = sizeof acm_descriptor,

460

.bDescriptorType = USB_DT_CS_INTERFACE,

460

.bDescriptorType = USB_DT_CS_INTERFACE,

461

.bDescriptorSubType = USB_CDC_ACM_TYPE,

461

.bDescriptorSubType = USB_CDC_ACM_TYPE,

462

463

.bmCapabilities = 0x00,

463

.bmCapabilities = 0x00,

464

};

464

};

465

466

#endif

466

#endif

467

468

#ifndef CONFIG_USB_ETH_CDC

468

#ifndef CONFIG_USB_ETH_CDC

469

470

/*

470

/*

471

* "SAFE" loosely follows CDC WMC MDLM, violating the spec in various

471

* "SAFE" loosely follows CDC WMC MDLM, violating the spec in various

472

* ways: data endpoints live in the control interface, there's no data

472

* ways: data endpoints live in the control interface, there's no data

473

* interface, and it's not used to talk to a cell phone radio.

473

* interface, and it's not used to talk to a cell phone radio.

474

*/

474

*/

475

476

static const struct usb_cdc_mdlm_desc mdlm_desc = {

476

static const struct usb_cdc_mdlm_desc mdlm_desc = {

477

.bLength = sizeof mdlm_desc,

477

.bLength = sizeof mdlm_desc,

478

.bDescriptorType = USB_DT_CS_INTERFACE,

478

.bDescriptorType = USB_DT_CS_INTERFACE,

479

.bDescriptorSubType = USB_CDC_MDLM_TYPE,

479

.bDescriptorSubType = USB_CDC_MDLM_TYPE,

480

481

.bcdVersion = __constant_cpu_to_le16(0x0100),

481

.bcdVersion = __constant_cpu_to_le16(0x0100),

482

.bGUID = {

482

.bGUID = {

483

0x5d, 0x34, 0xcf, 0x66, 0x11, 0x18, 0x11, 0xd6,

483

0x5d, 0x34, 0xcf, 0x66, 0x11, 0x18, 0x11, 0xd6,

484

0xa2, 0x1a, 0x00, 0x01, 0x02, 0xca, 0x9a, 0x7f,

484

0xa2, 0x1a, 0x00, 0x01, 0x02, 0xca, 0x9a, 0x7f,

485

},

485

},

486

};

486

};

487

488

/*

488

/*

489

* since "usb_cdc_mdlm_detail_desc" is a variable length structure, we

489

* since "usb_cdc_mdlm_detail_desc" is a variable length structure, we

490

* can't really use its struct. All we do here is say that we're using

490

* can't really use its struct. All we do here is say that we're using

491

* the submode of "SAFE" which directly matches the CDC Subset.

491

* the submode of "SAFE" which directly matches the CDC Subset.

492

*/

492

*/

493

static const u8 mdlm_detail_desc[] = {

493

static const u8 mdlm_detail_desc[] = {

494

6,

494

6,

495

USB_DT_CS_INTERFACE,

495

USB_DT_CS_INTERFACE,

496

USB_CDC_MDLM_DETAIL_TYPE,

496

USB_CDC_MDLM_DETAIL_TYPE,

497

498

0, /* "SAFE" */

498

0, /* "SAFE" */

499

0, /* network control capabilities (none) */

499

0, /* network control capabilities (none) */

500

0, /* network data capabilities ("raw" encapsulation) */

500

0, /* network data capabilities ("raw" encapsulation) */

501

};

501

};

502

503

#endif

503

#endif

504

505

static const struct usb_cdc_ether_desc ether_desc = {

505

static const struct usb_cdc_ether_desc ether_desc = {

506

.bLength = sizeof(ether_desc),

506

.bLength = sizeof(ether_desc),

507

.bDescriptorType = USB_DT_CS_INTERFACE,

507

.bDescriptorType = USB_DT_CS_INTERFACE,

508

.bDescriptorSubType = USB_CDC_ETHERNET_TYPE,

508

.bDescriptorSubType = USB_CDC_ETHERNET_TYPE,

509

510

/* this descriptor actually adds value, surprise! */

510

/* this descriptor actually adds value, surprise! */

511

.iMACAddress = STRING_ETHADDR,

511

.iMACAddress = STRING_ETHADDR,

512

.bmEthernetStatistics = __constant_cpu_to_le32(0), /* no statistics */

512

.bmEthernetStatistics = __constant_cpu_to_le32(0), /* no statistics */

513

.wMaxSegmentSize = __constant_cpu_to_le16(ETH_FRAME_LEN),

513

.wMaxSegmentSize = __constant_cpu_to_le16(ETH_FRAME_LEN),

514

.wNumberMCFilters = __constant_cpu_to_le16(0),

514

.wNumberMCFilters = __constant_cpu_to_le16(0),

515

.bNumberPowerFilters = 0,

515

.bNumberPowerFilters = 0,

516

};

516

};

517

518

#if defined(CONFIG_USB_ETH_CDC) || defined(CONFIG_USB_ETH_RNDIS)

518

#if defined(CONFIG_USB_ETH_CDC) || defined(CONFIG_USB_ETH_RNDIS)

519

520

/*

520

/*

521

* include the status endpoint if we can, even where it's optional.

521

* include the status endpoint if we can, even where it's optional.

522

* use wMaxPacketSize big enough to fit CDC_NOTIFY_SPEED_CHANGE in one

522

* use wMaxPacketSize big enough to fit CDC_NOTIFY_SPEED_CHANGE in one

523

* packet, to simplify cancellation; and a big transfer interval, to

523

* packet, to simplify cancellation; and a big transfer interval, to

524

* waste less bandwidth.

524

* waste less bandwidth.

525

*

525

*

526

* some drivers (like Linux 2.4 cdc-ether!) "need" it to exist even

526

* some drivers (like Linux 2.4 cdc-ether!) "need" it to exist even

527

* if they ignore the connect/disconnect notifications that real aether

527

* if they ignore the connect/disconnect notifications that real aether

528

* can provide. more advanced cdc configurations might want to support

528

* can provide. more advanced cdc configurations might want to support

529

* encapsulated commands (vendor-specific, using control-OUT).

529

* encapsulated commands (vendor-specific, using control-OUT).

530

*

530

*

531

* RNDIS requires the status endpoint, since it uses that encapsulation

531

* RNDIS requires the status endpoint, since it uses that encapsulation

532

* mechanism for its funky RPC scheme.

532

* mechanism for its funky RPC scheme.

533

*/

533

*/

534

535

#define LOG2_STATUS_INTERVAL_MSEC 5 /* 1 << 5 == 32 msec */

535

#define LOG2_STATUS_INTERVAL_MSEC 5 /* 1 << 5 == 32 msec */

536

#define STATUS_BYTECOUNT 16 /* 8 byte header + data */

536

#define STATUS_BYTECOUNT 16 /* 8 byte header + data */

537

538

static struct usb_endpoint_descriptor

538

static struct usb_endpoint_descriptor

539

fs_status_desc = {

539

fs_status_desc = {

540

.bLength = USB_DT_ENDPOINT_SIZE,

540

.bLength = USB_DT_ENDPOINT_SIZE,

541

.bDescriptorType = USB_DT_ENDPOINT,

541

.bDescriptorType = USB_DT_ENDPOINT,

542

543

.bEndpointAddress = USB_DIR_IN,

543

.bEndpointAddress = USB_DIR_IN,

544

.bmAttributes = USB_ENDPOINT_XFER_INT,

544

.bmAttributes = USB_ENDPOINT_XFER_INT,

545

.wMaxPacketSize = __constant_cpu_to_le16(STATUS_BYTECOUNT),

545

.wMaxPacketSize = __constant_cpu_to_le16(STATUS_BYTECOUNT),

546

.bInterval = 1 << LOG2_STATUS_INTERVAL_MSEC,

546

.bInterval = 1 << LOG2_STATUS_INTERVAL_MSEC,

547

};

547

};

548

#endif

548

#endif

549

550

#ifdef CONFIG_USB_ETH_CDC

550

#ifdef CONFIG_USB_ETH_CDC

551

552

/* the default data interface has no endpoints ... */

552

/* the default data interface has no endpoints ... */

553

554

static const struct usb_interface_descriptor

554

static const struct usb_interface_descriptor

555

data_nop_intf = {

555

data_nop_intf = {

556

.bLength = sizeof data_nop_intf,

556

.bLength = sizeof data_nop_intf,

557

.bDescriptorType = USB_DT_INTERFACE,

557

.bDescriptorType = USB_DT_INTERFACE,

558

559

.bInterfaceNumber = 1,

559

.bInterfaceNumber = 1,

560

.bAlternateSetting = 0,

560

.bAlternateSetting = 0,

561

.bNumEndpoints = 0,

561

.bNumEndpoints = 0,

562

.bInterfaceClass = USB_CLASS_CDC_DATA,

562

.bInterfaceClass = USB_CLASS_CDC_DATA,

563

.bInterfaceSubClass = 0,

563

.bInterfaceSubClass = 0,

564

.bInterfaceProtocol = 0,

564

.bInterfaceProtocol = 0,

565

};

565

};

566

567

/* ... but the "real" data interface has two bulk endpoints */

567

/* ... but the "real" data interface has two bulk endpoints */

568

569

static const struct usb_interface_descriptor

569

static const struct usb_interface_descriptor

570

data_intf = {

570

data_intf = {

571

.bLength = sizeof data_intf,

571

.bLength = sizeof data_intf,

572

.bDescriptorType = USB_DT_INTERFACE,

572

.bDescriptorType = USB_DT_INTERFACE,

573

574

.bInterfaceNumber = 1,

574

.bInterfaceNumber = 1,

575

.bAlternateSetting = 1,

575

.bAlternateSetting = 1,

576

.bNumEndpoints = 2,

576

.bNumEndpoints = 2,

577

.bInterfaceClass = USB_CLASS_CDC_DATA,

577

.bInterfaceClass = USB_CLASS_CDC_DATA,

578

.bInterfaceSubClass = 0,

578

.bInterfaceSubClass = 0,

579

.bInterfaceProtocol = 0,

579

.bInterfaceProtocol = 0,

580

.iInterface = STRING_DATA,

580

.iInterface = STRING_DATA,

581

};

581

};

582

583

#endif

583

#endif

584

585

#ifdef CONFIG_USB_ETH_RNDIS

585

#ifdef CONFIG_USB_ETH_RNDIS

586

587

/* RNDIS doesn't activate by changing to the "real" altsetting */

587

/* RNDIS doesn't activate by changing to the "real" altsetting */

588

589

static const struct usb_interface_descriptor

589

static const struct usb_interface_descriptor

590

rndis_data_intf = {

590

rndis_data_intf = {

591

.bLength = sizeof rndis_data_intf,

591

.bLength = sizeof rndis_data_intf,

592

.bDescriptorType = USB_DT_INTERFACE,

592

.bDescriptorType = USB_DT_INTERFACE,

593

594

.bInterfaceNumber = 1,

594

.bInterfaceNumber = 1,

595

.bAlternateSetting = 0,

595

.bAlternateSetting = 0,

596

.bNumEndpoints = 2,

596

.bNumEndpoints = 2,

597

.bInterfaceClass = USB_CLASS_CDC_DATA,

597

.bInterfaceClass = USB_CLASS_CDC_DATA,

598

.bInterfaceSubClass = 0,

598

.bInterfaceSubClass = 0,

599

.bInterfaceProtocol = 0,

599

.bInterfaceProtocol = 0,

600

.iInterface = STRING_DATA,

600

.iInterface = STRING_DATA,

601

};

601

};

602

603

#endif

603

#endif

604

605

#ifdef CONFIG_USB_ETH_SUBSET

605

#ifdef CONFIG_USB_ETH_SUBSET

606

607

/*

607

/*

608

* "Simple" CDC-subset option is a simple vendor-neutral model that most

608

* "Simple" CDC-subset option is a simple vendor-neutral model that most

609

* full speed controllers can handle: one interface, two bulk endpoints.

609

* full speed controllers can handle: one interface, two bulk endpoints.

610

*

610

*

611

* To assist host side drivers, we fancy it up a bit, and add descriptors

611

* To assist host side drivers, we fancy it up a bit, and add descriptors

612

* so some host side drivers will understand it as a "SAFE" variant.

612

* so some host side drivers will understand it as a "SAFE" variant.

613

*/

613

*/

614

615

static const struct usb_interface_descriptor

615

static const struct usb_interface_descriptor

616

subset_data_intf = {

616

subset_data_intf = {

617

.bLength = sizeof subset_data_intf,

617

.bLength = sizeof subset_data_intf,

618

.bDescriptorType = USB_DT_INTERFACE,

618

.bDescriptorType = USB_DT_INTERFACE,

619

620

.bInterfaceNumber = 0,

620

.bInterfaceNumber = 0,

621

.bAlternateSetting = 0,

621

.bAlternateSetting = 0,

622

.bNumEndpoints = 2,

622

.bNumEndpoints = 2,

623

.bInterfaceClass = USB_CLASS_COMM,

623

.bInterfaceClass = USB_CLASS_COMM,

624

.bInterfaceSubClass = USB_CDC_SUBCLASS_MDLM,

624

.bInterfaceSubClass = USB_CDC_SUBCLASS_MDLM,

625

.bInterfaceProtocol = 0,

625

.bInterfaceProtocol = 0,

626

.iInterface = STRING_DATA,

626

.iInterface = STRING_DATA,

627

};

627

};

628

629

#endif /* SUBSET */

629

#endif /* SUBSET */

630

631

static struct usb_endpoint_descriptor

631

static struct usb_endpoint_descriptor

632

fs_source_desc = {

632

fs_source_desc = {

633

.bLength = USB_DT_ENDPOINT_SIZE,

633

.bLength = USB_DT_ENDPOINT_SIZE,

634

.bDescriptorType = USB_DT_ENDPOINT,

634

.bDescriptorType = USB_DT_ENDPOINT,

635

636

.bEndpointAddress = USB_DIR_IN,

636

.bEndpointAddress = USB_DIR_IN,

637

.bmAttributes = USB_ENDPOINT_XFER_BULK,

637

.bmAttributes = USB_ENDPOINT_XFER_BULK,

638

};

638

};

639

640

static struct usb_endpoint_descriptor

640

static struct usb_endpoint_descriptor

641

fs_sink_desc = {

641

fs_sink_desc = {

642

.bLength = USB_DT_ENDPOINT_SIZE,

642

.bLength = USB_DT_ENDPOINT_SIZE,

643

.bDescriptorType = USB_DT_ENDPOINT,

643

.bDescriptorType = USB_DT_ENDPOINT,

644

645

.bEndpointAddress = USB_DIR_OUT,

645

.bEndpointAddress = USB_DIR_OUT,

646

.bmAttributes = USB_ENDPOINT_XFER_BULK,

646

.bmAttributes = USB_ENDPOINT_XFER_BULK,

647

};

647

};

648

649

static const struct usb_descriptor_header *fs_eth_function[11] = {

649

static const struct usb_descriptor_header *fs_eth_function[11] = {

650

(struct usb_descriptor_header *) &otg_descriptor,

650

(struct usb_descriptor_header *) &otg_descriptor,

651

#ifdef CONFIG_USB_ETH_CDC

651

#ifdef CONFIG_USB_ETH_CDC

652

/* "cdc" mode descriptors */

652

/* "cdc" mode descriptors */

653

(struct usb_descriptor_header *) &control_intf,

653

(struct usb_descriptor_header *) &control_intf,

654

(struct usb_descriptor_header *) &header_desc,

654

(struct usb_descriptor_header *) &header_desc,

655

(struct usb_descriptor_header *) &union_desc,

655

(struct usb_descriptor_header *) &union_desc,

656

(struct usb_descriptor_header *) &ether_desc,

656

(struct usb_descriptor_header *) &ether_desc,

657

/* NOTE: status endpoint may need to be removed */

657

/* NOTE: status endpoint may need to be removed */

658

(struct usb_descriptor_header *) &fs_status_desc,

658

(struct usb_descriptor_header *) &fs_status_desc,

659

/* data interface, with altsetting */

659

/* data interface, with altsetting */

660

(struct usb_descriptor_header *) &data_nop_intf,

660

(struct usb_descriptor_header *) &data_nop_intf,

661

(struct usb_descriptor_header *) &data_intf,

661

(struct usb_descriptor_header *) &data_intf,

662

(struct usb_descriptor_header *) &fs_source_desc,

662

(struct usb_descriptor_header *) &fs_source_desc,

663

(struct usb_descriptor_header *) &fs_sink_desc,

663

(struct usb_descriptor_header *) &fs_sink_desc,

664

NULL,

664

NULL,

665

#endif /* CONFIG_USB_ETH_CDC */

665

#endif /* CONFIG_USB_ETH_CDC */

666

};

666

};

667

668

static inline void fs_subset_descriptors(void)

668

static inline void fs_subset_descriptors(void)

669

{

669

{

670

#ifdef CONFIG_USB_ETH_SUBSET

670

#ifdef CONFIG_USB_ETH_SUBSET

671

/* behavior is "CDC Subset"; extra descriptors say "SAFE" */

671

/* behavior is "CDC Subset"; extra descriptors say "SAFE" */

672

fs_eth_function[1] = (struct usb_descriptor_header *) &subset_data_intf;

672

fs_eth_function[1] = (struct usb_descriptor_header *) &subset_data_intf;

673

fs_eth_function[2] = (struct usb_descriptor_header *) &header_desc;

673

fs_eth_function[2] = (struct usb_descriptor_header *) &header_desc;

674

fs_eth_function[3] = (struct usb_descriptor_header *) &mdlm_desc;

674

fs_eth_function[3] = (struct usb_descriptor_header *) &mdlm_desc;

675

fs_eth_function[4] = (struct usb_descriptor_header *) &mdlm_detail_desc;

675

fs_eth_function[4] = (struct usb_descriptor_header *) &mdlm_detail_desc;

676

fs_eth_function[5] = (struct usb_descriptor_header *) &ether_desc;

676

fs_eth_function[5] = (struct usb_descriptor_header *) &ether_desc;

677

fs_eth_function[6] = (struct usb_descriptor_header *) &fs_source_desc;

677

fs_eth_function[6] = (struct usb_descriptor_header *) &fs_source_desc;

678

fs_eth_function[7] = (struct usb_descriptor_header *) &fs_sink_desc;

678

fs_eth_function[7] = (struct usb_descriptor_header *) &fs_sink_desc;

679

fs_eth_function[8] = NULL;

679

fs_eth_function[8] = NULL;

680

#else

680

#else

681

fs_eth_function[1] = NULL;

681

fs_eth_function[1] = NULL;

682

#endif

682

#endif

683

}

683

}

684

685

#ifdef CONFIG_USB_ETH_RNDIS

685

#ifdef CONFIG_USB_ETH_RNDIS

686

static const struct usb_descriptor_header *fs_rndis_function[] = {

686

static const struct usb_descriptor_header *fs_rndis_function[] = {

687

(struct usb_descriptor_header *) &otg_descriptor,

687

(struct usb_descriptor_header *) &otg_descriptor,

688

/* control interface matches ACM, not Ethernet */

688

/* control interface matches ACM, not Ethernet */

689

(struct usb_descriptor_header *) &rndis_control_intf,

689

(struct usb_descriptor_header *) &rndis_control_intf,

690

(struct usb_descriptor_header *) &header_desc,

690

(struct usb_descriptor_header *) &header_desc,

691

(struct usb_descriptor_header *) &call_mgmt_descriptor,

691

(struct usb_descriptor_header *) &call_mgmt_descriptor,

692

(struct usb_descriptor_header *) &acm_descriptor,

692

(struct usb_descriptor_header *) &acm_descriptor,

693

(struct usb_descriptor_header *) &union_desc,

693

(struct usb_descriptor_header *) &union_desc,

694

(struct usb_descriptor_header *) &fs_status_desc,

694

(struct usb_descriptor_header *) &fs_status_desc,

695

/* data interface has no altsetting */

695

/* data interface has no altsetting */

696

(struct usb_descriptor_header *) &rndis_data_intf,

696

(struct usb_descriptor_header *) &rndis_data_intf,

697

(struct usb_descriptor_header *) &fs_source_desc,

697

(struct usb_descriptor_header *) &fs_source_desc,

698

(struct usb_descriptor_header *) &fs_sink_desc,

698

(struct usb_descriptor_header *) &fs_sink_desc,

699

NULL,

699

NULL,

700

};

700

};

701

#endif

701

#endif

702

703

/*

703

/*

704

* usb 2.0 devices need to expose both high speed and full speed

704

* usb 2.0 devices need to expose both high speed and full speed

705

* descriptors, unless they only run at full speed.

705

* descriptors, unless they only run at full speed.

706

*/

706

*/

707

708

#if defined(CONFIG_USB_ETH_CDC) || defined(CONFIG_USB_ETH_RNDIS)

708

#if defined(CONFIG_USB_ETH_CDC) || defined(CONFIG_USB_ETH_RNDIS)

709

static struct usb_endpoint_descriptor

709

static struct usb_endpoint_descriptor

710

hs_status_desc = {

710

hs_status_desc = {

711

.bLength = USB_DT_ENDPOINT_SIZE,

711

.bLength = USB_DT_ENDPOINT_SIZE,

712

.bDescriptorType = USB_DT_ENDPOINT,

712

.bDescriptorType = USB_DT_ENDPOINT,

713

714

.bmAttributes = USB_ENDPOINT_XFER_INT,

714

.bmAttributes = USB_ENDPOINT_XFER_INT,

715

.wMaxPacketSize = __constant_cpu_to_le16(STATUS_BYTECOUNT),

715

.wMaxPacketSize = __constant_cpu_to_le16(STATUS_BYTECOUNT),

716

.bInterval = LOG2_STATUS_INTERVAL_MSEC + 4,

716

.bInterval = LOG2_STATUS_INTERVAL_MSEC + 4,

717

};

717

};

718

#endif /* CONFIG_USB_ETH_CDC */

718

#endif /* CONFIG_USB_ETH_CDC */

719

720

static struct usb_endpoint_descriptor

720

static struct usb_endpoint_descriptor

721

hs_source_desc = {

721

hs_source_desc = {

722

.bLength = USB_DT_ENDPOINT_SIZE,

722

.bLength = USB_DT_ENDPOINT_SIZE,

723

.bDescriptorType = USB_DT_ENDPOINT,

723

.bDescriptorType = USB_DT_ENDPOINT,

724

725

.bmAttributes = USB_ENDPOINT_XFER_BULK,

725

.bmAttributes = USB_ENDPOINT_XFER_BULK,

726

.wMaxPacketSize = __constant_cpu_to_le16(512),

726

.wMaxPacketSize = __constant_cpu_to_le16(512),

727

};

727

};

728

729

static struct usb_endpoint_descriptor

729

static struct usb_endpoint_descriptor

730

hs_sink_desc = {

730

hs_sink_desc = {

731

.bLength = USB_DT_ENDPOINT_SIZE,

731

.bLength = USB_DT_ENDPOINT_SIZE,

732

.bDescriptorType = USB_DT_ENDPOINT,

732

.bDescriptorType = USB_DT_ENDPOINT,

733

734

.bmAttributes = USB_ENDPOINT_XFER_BULK,

734

.bmAttributes = USB_ENDPOINT_XFER_BULK,

735

.wMaxPacketSize = __constant_cpu_to_le16(512),

735

.wMaxPacketSize = __constant_cpu_to_le16(512),

736

};

736

};

737

738

static struct usb_qualifier_descriptor

738

static struct usb_qualifier_descriptor

739

dev_qualifier = {

739

dev_qualifier = {

740

.bLength = sizeof dev_qualifier,

740

.bLength = sizeof dev_qualifier,

741

.bDescriptorType = USB_DT_DEVICE_QUALIFIER,

741

.bDescriptorType = USB_DT_DEVICE_QUALIFIER,

742

743

.bcdUSB = __constant_cpu_to_le16(0x0200),

743

.bcdUSB = __constant_cpu_to_le16(0x0200),

744

.bDeviceClass = USB_CLASS_COMM,

744

.bDeviceClass = USB_CLASS_COMM,

745

746

.bNumConfigurations = 1,

746

.bNumConfigurations = 1,

747

};

747

};

748

749

static const struct usb_descriptor_header *hs_eth_function[11] = {

749

static const struct usb_descriptor_header *hs_eth_function[11] = {

750

(struct usb_descriptor_header *) &otg_descriptor,

750

(struct usb_descriptor_header *) &otg_descriptor,

751

#ifdef CONFIG_USB_ETH_CDC

751

#ifdef CONFIG_USB_ETH_CDC

752

/* "cdc" mode descriptors */

752

/* "cdc" mode descriptors */

753

(struct usb_descriptor_header *) &control_intf,

753

(struct usb_descriptor_header *) &control_intf,

754

(struct usb_descriptor_header *) &header_desc,

754

(struct usb_descriptor_header *) &header_desc,

755

(struct usb_descriptor_header *) &union_desc,

755

(struct usb_descriptor_header *) &union_desc,

756

(struct usb_descriptor_header *) &ether_desc,

756

(struct usb_descriptor_header *) &ether_desc,

757

/* NOTE: status endpoint may need to be removed */

757

/* NOTE: status endpoint may need to be removed */

758

(struct usb_descriptor_header *) &hs_status_desc,

758

(struct usb_descriptor_header *) &hs_status_desc,

759

/* data interface, with altsetting */

759

/* data interface, with altsetting */

760

(struct usb_descriptor_header *) &data_nop_intf,

760

(struct usb_descriptor_header *) &data_nop_intf,

761

(struct usb_descriptor_header *) &data_intf,

761

(struct usb_descriptor_header *) &data_intf,

762

(struct usb_descriptor_header *) &hs_source_desc,

762

(struct usb_descriptor_header *) &hs_source_desc,

763

(struct usb_descriptor_header *) &hs_sink_desc,

763

(struct usb_descriptor_header *) &hs_sink_desc,

764

NULL,

764

NULL,

765

#endif /* CONFIG_USB_ETH_CDC */

765

#endif /* CONFIG_USB_ETH_CDC */

766

};

766

};

767

768

static inline void hs_subset_descriptors(void)

768

static inline void hs_subset_descriptors(void)

769

{

769

{

770

#ifdef CONFIG_USB_ETH_SUBSET

770

#ifdef CONFIG_USB_ETH_SUBSET

771

/* behavior is "CDC Subset"; extra descriptors say "SAFE" */

771

/* behavior is "CDC Subset"; extra descriptors say "SAFE" */

772

hs_eth_function[1] = (struct usb_descriptor_header *) &subset_data_intf;

772

hs_eth_function[1] = (struct usb_descriptor_header *) &subset_data_intf;

773

hs_eth_function[2] = (struct usb_descriptor_header *) &header_desc;

773

hs_eth_function[2] = (struct usb_descriptor_header *) &header_desc;

774

hs_eth_function[3] = (struct usb_descriptor_header *) &mdlm_desc;

774

hs_eth_function[3] = (struct usb_descriptor_header *) &mdlm_desc;

775

hs_eth_function[4] = (struct usb_descriptor_header *) &mdlm_detail_desc;

775

hs_eth_function[4] = (struct usb_descriptor_header *) &mdlm_detail_desc;

776

hs_eth_function[5] = (struct usb_descriptor_header *) &ether_desc;

776

hs_eth_function[5] = (struct usb_descriptor_header *) &ether_desc;

777

hs_eth_function[6] = (struct usb_descriptor_header *) &hs_source_desc;

777

hs_eth_function[6] = (struct usb_descriptor_header *) &hs_source_desc;

778

hs_eth_function[7] = (struct usb_descriptor_header *) &hs_sink_desc;

778

hs_eth_function[7] = (struct usb_descriptor_header *) &hs_sink_desc;

779

hs_eth_function[8] = NULL;

779

hs_eth_function[8] = NULL;

780

#else

780

#else

781

hs_eth_function[1] = NULL;

781

hs_eth_function[1] = NULL;

782

#endif

782

#endif

783

}

783

}

784

785

#ifdef CONFIG_USB_ETH_RNDIS

785

#ifdef CONFIG_USB_ETH_RNDIS

786

static const struct usb_descriptor_header *hs_rndis_function[] = {

786

static const struct usb_descriptor_header *hs_rndis_function[] = {

787

(struct usb_descriptor_header *) &otg_descriptor,

787

(struct usb_descriptor_header *) &otg_descriptor,

788

/* control interface matches ACM, not Ethernet */

788

/* control interface matches ACM, not Ethernet */

789

(struct usb_descriptor_header *) &rndis_control_intf,

789

(struct usb_descriptor_header *) &rndis_control_intf,

790

(struct usb_descriptor_header *) &header_desc,

790

(struct usb_descriptor_header *) &header_desc,

791

(struct usb_descriptor_header *) &call_mgmt_descriptor,

791

(struct usb_descriptor_header *) &call_mgmt_descriptor,

792

(struct usb_descriptor_header *) &acm_descriptor,

792

(struct usb_descriptor_header *) &acm_descriptor,

793

(struct usb_descriptor_header *) &union_desc,

793

(struct usb_descriptor_header *) &union_desc,

794

(struct usb_descriptor_header *) &hs_status_desc,

794

(struct usb_descriptor_header *) &hs_status_desc,

795

/* data interface has no altsetting */

795

/* data interface has no altsetting */

796

(struct usb_descriptor_header *) &rndis_data_intf,

796

(struct usb_descriptor_header *) &rndis_data_intf,

797

(struct usb_descriptor_header *) &hs_source_desc,

797

(struct usb_descriptor_header *) &hs_source_desc,

798

(struct usb_descriptor_header *) &hs_sink_desc,

798

(struct usb_descriptor_header *) &hs_sink_desc,

799

NULL,

799

NULL,

800

};

800

};

801

#endif

801

#endif

802

803

804

/* maxpacket and other transfer characteristics vary by speed. */

804

/* maxpacket and other transfer characteristics vary by speed. */

805

static inline struct usb_endpoint_descriptor *

805

static inline struct usb_endpoint_descriptor *

806

ep_desc(struct usb_gadget *g, struct usb_endpoint_descriptor *hs,

806

ep_desc(struct usb_gadget *g, struct usb_endpoint_descriptor *hs,

807

struct usb_endpoint_descriptor *fs)

807

struct usb_endpoint_descriptor *fs)

808

{

808

{

809

if (gadget_is_dualspeed(g) && g->speed == USB_SPEED_HIGH)

809

if (gadget_is_dualspeed(g) && g->speed == USB_SPEED_HIGH)

810

return hs;

810

return hs;

811

return fs;

811

return fs;

812

}

812

}

813

814

/*-------------------------------------------------------------------------*/

814

/*-------------------------------------------------------------------------*/

815

816

/* descriptors that are built on-demand */

816

/* descriptors that are built on-demand */

817

818

static char manufacturer[50];

818

static char manufacturer[50];

819

static char product_desc[40] = DRIVER_DESC;

819

static char product_desc[40] = DRIVER_DESC;

820

static char serial_number[20];

820

static char serial_number[20];

821

822

/* address that the host will use ... usually assigned at random */

822

/* address that the host will use ... usually assigned at random */

823

static char ethaddr[2 * ETH_ALEN + 1];

823

static char ethaddr[2 * ETH_ALEN + 1];

824

825

/* static strings, in UTF-8 */

825

/* static strings, in UTF-8 */

826

static struct usb_string strings[] = {

826

static struct usb_string strings[] = {

827

{ STRING_MANUFACTURER, manufacturer, },

827

{ STRING_MANUFACTURER, manufacturer, },

828

{ STRING_PRODUCT, product_desc, },

828

{ STRING_PRODUCT, product_desc, },

829

{ STRING_SERIALNUMBER, serial_number, },

829

{ STRING_SERIALNUMBER, serial_number, },

830

{ STRING_DATA, "Ethernet Data", },

830

{ STRING_DATA, "Ethernet Data", },

831

{ STRING_ETHADDR, ethaddr, },

831

{ STRING_ETHADDR, ethaddr, },

832

#ifdef CONFIG_USB_ETH_CDC

832

#ifdef CONFIG_USB_ETH_CDC

833

{ STRING_CDC, "CDC Ethernet", },

833

{ STRING_CDC, "CDC Ethernet", },

834

{ STRING_CONTROL, "CDC Communications Control", },

834

{ STRING_CONTROL, "CDC Communications Control", },

835

#endif

835

#endif

836

#ifdef CONFIG_USB_ETH_SUBSET

836

#ifdef CONFIG_USB_ETH_SUBSET

837

{ STRING_SUBSET, "CDC Ethernet Subset", },

837

{ STRING_SUBSET, "CDC Ethernet Subset", },

838

#endif

838

#endif

839

#ifdef CONFIG_USB_ETH_RNDIS

839

#ifdef CONFIG_USB_ETH_RNDIS

840

{ STRING_RNDIS, "RNDIS", },

840

{ STRING_RNDIS, "RNDIS", },

841

{ STRING_RNDIS_CONTROL, "RNDIS Communications Control", },

841

{ STRING_RNDIS_CONTROL, "RNDIS Communications Control", },

842

#endif

842

#endif

843

{ } /* end of list */

843

{ } /* end of list */

844

};

844

};

845

846

static struct usb_gadget_strings stringtab = {

846

static struct usb_gadget_strings stringtab = {

847

.language = 0x0409, /* en-us */

847

.language = 0x0409, /* en-us */

848

.strings = strings,

848

.strings = strings,

849

};

849

};

850

851

/*============================================================================*/

851

/*============================================================================*/

852

static u8 control_req[USB_BUFSIZ];

852

DEFINE_CACHE_ALIGN_BUFFER(u8, control_req, USB_BUFSIZ);

853

#if defined(CONFIG_USB_ETH_CDC) || defined(CONFIG_USB_ETH_RNDIS)

854

#if defined(CONFIG_USB_ETH_CDC) || defined(CONFIG_USB_ETH_RNDIS)

854

static u8 status_req[STATUS_BYTECOUNT] __attribute__ ((aligned(4)));

855

DEFINE_CACHE_ALIGN_BUFFER(u8, status_req, STATUS_BYTECOUNT);

855

#endif

856

#endif

856

857

858

/**

859

/**

859

* strlcpy - Copy a %NUL terminated string into a sized buffer

860

* strlcpy - Copy a %NUL terminated string into a sized buffer

860

* @dest: Where to copy the string to

861

* @dest: Where to copy the string to

861

* @src: Where to copy the string from

862

* @src: Where to copy the string from

862

* @size: size of destination buffer

863

* @size: size of destination buffer

863

*

864

*

864

* Compatible with *BSD: the result is always a valid

865

* Compatible with *BSD: the result is always a valid

865

* NUL-terminated string that fits in the buffer (unless,

866

* NUL-terminated string that fits in the buffer (unless,

866

* of course, the buffer size is zero). It does not pad

867

* of course, the buffer size is zero). It does not pad

867

* out the result like strncpy() does.

868

* out the result like strncpy() does.

868

*/

869

*/

869

size_t strlcpy(char *dest, const char *src, size_t size)

870

size_t strlcpy(char *dest, const char *src, size_t size)

870

{

871

{

871

size_t ret = strlen(src);

872

size_t ret = strlen(src);

872

873

if (size) {

874

if (size) {

874

size_t len = (ret >= size) ? size - 1 : ret;

875

size_t len = (ret >= size) ? size - 1 : ret;

875

memcpy(dest, src, len);

876

memcpy(dest, src, len);

876

dest[len] = '\0';

877

dest[len] = '\0';

877

}

878

}

878

return ret;

879

return ret;

879

}

880

}

880

881

/*============================================================================*/

882

/*============================================================================*/

882

883

/*

884

/*

884

* one config, two interfaces: control, data.

885

* one config, two interfaces: control, data.

885

* complications: class descriptors, and an altsetting.

886

* complications: class descriptors, and an altsetting.

886

*/

887

*/

887

static int

888

static int

888

config_buf(struct usb_gadget *g, u8 *buf, u8 type, unsigned index, int is_otg)

889

config_buf(struct usb_gadget *g, u8 *buf, u8 type, unsigned index, int is_otg)

889

{

890

{

890

int len;

891

int len;

891

const struct usb_config_descriptor *config;

892

const struct usb_config_descriptor *config;

892

const struct usb_descriptor_header **function;

893

const struct usb_descriptor_header **function;

893

int hs = 0;

894

int hs = 0;

894

895

if (gadget_is_dualspeed(g)) {

896

if (gadget_is_dualspeed(g)) {

896

hs = (g->speed == USB_SPEED_HIGH);

897

hs = (g->speed == USB_SPEED_HIGH);

897

if (type == USB_DT_OTHER_SPEED_CONFIG)

898

if (type == USB_DT_OTHER_SPEED_CONFIG)

898

hs = !hs;

899

hs = !hs;

899

}

900

}

900

#define which_fn(t) (hs ? hs_ ## t ## _function : fs_ ## t ## _function)

901

#define which_fn(t) (hs ? hs_ ## t ## _function : fs_ ## t ## _function)

901

902

if (index >= device_desc.bNumConfigurations)

903

if (index >= device_desc.bNumConfigurations)

903

return -EINVAL;

904

return -EINVAL;

904

905

#ifdef CONFIG_USB_ETH_RNDIS

906

#ifdef CONFIG_USB_ETH_RNDIS

906

/*

907

/*

907

* list the RNDIS config first, to make Microsoft's drivers

908

* list the RNDIS config first, to make Microsoft's drivers

908

* happy. DOCSIS 1.0 needs this too.

909

* happy. DOCSIS 1.0 needs this too.

909

*/

910

*/

910

if (device_desc.bNumConfigurations == 2 && index == 0) {

911

if (device_desc.bNumConfigurations == 2 && index == 0) {

911

config = &rndis_config;

912

config = &rndis_config;

912

function = which_fn(rndis);

913

function = which_fn(rndis);

913

} else

914

} else

914

#endif

915

#endif

915

{

916

{

916

config = &eth_config;

917

config = &eth_config;

917

function = which_fn(eth);

918

function = which_fn(eth);

918

}

919

}

919

920

/* for now, don't advertise srp-only devices */

921

/* for now, don't advertise srp-only devices */

921

if (!is_otg)

922

if (!is_otg)

922

function++;

923

function++;

923

924

len = usb_gadget_config_buf(config, buf, USB_BUFSIZ, function);

925

len = usb_gadget_config_buf(config, buf, USB_BUFSIZ, function);

925

if (len < 0)

926

if (len < 0)

926

return len;

927

return len;

927

((struct usb_config_descriptor *) buf)->bDescriptorType = type;

928

((struct usb_config_descriptor *) buf)->bDescriptorType = type;

928

return len;

929

return len;

929

}

930

}

930

931

/*-------------------------------------------------------------------------*/

932

/*-------------------------------------------------------------------------*/

932

933

static void eth_start(struct eth_dev *dev, gfp_t gfp_flags);

934

static void eth_start(struct eth_dev *dev, gfp_t gfp_flags);

934

static int alloc_requests(struct eth_dev *dev, unsigned n, gfp_t gfp_flags);

935

static int alloc_requests(struct eth_dev *dev, unsigned n, gfp_t gfp_flags);

935

936

static int

937

static int

937

set_ether_config(struct eth_dev *dev, gfp_t gfp_flags)

938

set_ether_config(struct eth_dev *dev, gfp_t gfp_flags)

938

{

939

{

939

int result = 0;

940

int result = 0;

940

struct usb_gadget *gadget = dev->gadget;

941

struct usb_gadget *gadget = dev->gadget;

941

942

#if defined(CONFIG_USB_ETH_CDC) || defined(CONFIG_USB_ETH_RNDIS)

943

#if defined(CONFIG_USB_ETH_CDC) || defined(CONFIG_USB_ETH_RNDIS)

943

/* status endpoint used for RNDIS and (optionally) CDC */

944

/* status endpoint used for RNDIS and (optionally) CDC */

944

if (!subset_active(dev) && dev->status_ep) {

945

if (!subset_active(dev) && dev->status_ep) {

945

dev->status = ep_desc(gadget, &hs_status_desc,

946

dev->status = ep_desc(gadget, &hs_status_desc,

946

&fs_status_desc);

947

&fs_status_desc);

947

dev->status_ep->driver_data = dev;

948

dev->status_ep->driver_data = dev;

948

949

result = usb_ep_enable(dev->status_ep, dev->status);

950

result = usb_ep_enable(dev->status_ep, dev->status);

950

if (result != 0) {

951

if (result != 0) {

951

debug("enable %s --> %d\n",

952

debug("enable %s --> %d\n",

952

dev->status_ep->name, result);

953

dev->status_ep->name, result);

953

goto done;

954

goto done;

954

}

955

}

955

}

956

}

956

#endif

957

#endif

957

958

dev->in = ep_desc(gadget, &hs_source_desc, &fs_source_desc);

959

dev->in = ep_desc(gadget, &hs_source_desc, &fs_source_desc);

959

dev->in_ep->driver_data = dev;

960

dev->in_ep->driver_data = dev;

960

961

dev->out = ep_desc(gadget, &hs_sink_desc, &fs_sink_desc);

962

dev->out = ep_desc(gadget, &hs_sink_desc, &fs_sink_desc);

962

dev->out_ep->driver_data = dev;

963

dev->out_ep->driver_data = dev;

963

964

/*

965

/*

965

* With CDC, the host isn't allowed to use these two data

966

* With CDC, the host isn't allowed to use these two data

966

* endpoints in the default altsetting for the interface.

967

* endpoints in the default altsetting for the interface.

967

* so we don't activate them yet. Reset from SET_INTERFACE.

968

* so we don't activate them yet. Reset from SET_INTERFACE.

968

*

969

*

969

* Strictly speaking RNDIS should work the same: activation is

970

* Strictly speaking RNDIS should work the same: activation is

970

* a side effect of setting a packet filter. Deactivation is

971

* a side effect of setting a packet filter. Deactivation is

971

* from REMOTE_NDIS_HALT_MSG, reset from REMOTE_NDIS_RESET_MSG.

972

* from REMOTE_NDIS_HALT_MSG, reset from REMOTE_NDIS_RESET_MSG.

972

*/

973

*/

973

if (!cdc_active(dev)) {

974

if (!cdc_active(dev)) {

974

result = usb_ep_enable(dev->in_ep, dev->in);

975

result = usb_ep_enable(dev->in_ep, dev->in);

975

if (result != 0) {

976

if (result != 0) {

976

debug("enable %s --> %d\n",

977

debug("enable %s --> %d\n",

977

dev->in_ep->name, result);

978

dev->in_ep->name, result);

978

goto done;

979

goto done;

979

}

980

}

980

981

result = usb_ep_enable(dev->out_ep, dev->out);

982

result = usb_ep_enable(dev->out_ep, dev->out);

982

if (result != 0) {

983

if (result != 0) {

983

debug("enable %s --> %d\n",

984

debug("enable %s --> %d\n",

984

dev->out_ep->name, result);

985

dev->out_ep->name, result);

985

goto done;

986

goto done;

986

}

987

}

987

}

988

}

988

989

done:

990

done:

990

if (result == 0)

991

if (result == 0)

991

result = alloc_requests(dev, qlen(gadget), gfp_flags);

992

result = alloc_requests(dev, qlen(gadget), gfp_flags);

992

993

/* on error, disable any endpoints */

994

/* on error, disable any endpoints */

994

if (result < 0) {

995

if (result < 0) {

995

if (!subset_active(dev) && dev->status_ep)

996

if (!subset_active(dev) && dev->status_ep)

996

(void) usb_ep_disable(dev->status_ep);

997

(void) usb_ep_disable(dev->status_ep);

997

dev->status = NULL;

998

dev->status = NULL;

998

(void) usb_ep_disable(dev->in_ep);

999

(void) usb_ep_disable(dev->in_ep);

999

(void) usb_ep_disable(dev->out_ep);

1000

(void) usb_ep_disable(dev->out_ep);

1000

dev->in = NULL;

1001

dev->in = NULL;

1001

dev->out = NULL;

1002

dev->out = NULL;

1002

} else if (!cdc_active(dev)) {

1003

} else if (!cdc_active(dev)) {

1003

/*

1004

/*

1004

* activate non-CDC configs right away

1005

* activate non-CDC configs right away

1005

* this isn't strictly according to the RNDIS spec

1006

* this isn't strictly according to the RNDIS spec

1006

*/

1007

*/

1007

eth_start(dev, GFP_ATOMIC);

1008

eth_start(dev, GFP_ATOMIC);

1008

}

1009

}

1009

1010

/* caller is responsible for cleanup on error */

1011

/* caller is responsible for cleanup on error */

1011

return result;

1012

return result;

1012

}

1013

}

1013

1014

static void eth_reset_config(struct eth_dev *dev)

1015

static void eth_reset_config(struct eth_dev *dev)

1015

{

1016

{

1016

if (dev->config == 0)

1017

if (dev->config == 0)

1017

return;

1018

return;

1018

1019

debug("%s\n", __func__);

1020

debug("%s\n", __func__);

1020

1021

rndis_uninit(dev->rndis_config);

1022

rndis_uninit(dev->rndis_config);

1022

1023

/*

1024

/*

1024

* disable endpoints, forcing (synchronous) completion of

1025

* disable endpoints, forcing (synchronous) completion of

1025

* pending i/o. then free the requests.

1026

* pending i/o. then free the requests.

1026

*/

1027

*/

1027

1028

if (dev->in) {

1029

if (dev->in) {

1029

usb_ep_disable(dev->in_ep);

1030

usb_ep_disable(dev->in_ep);

1030

if (dev->tx_req) {

1031

if (dev->tx_req) {

1031

usb_ep_free_request(dev->in_ep, dev->tx_req);

1032

usb_ep_free_request(dev->in_ep, dev->tx_req);

1032

dev->tx_req = NULL;

1033

dev->tx_req = NULL;

1033

}

1034

}

1034

}

1035

}

1035

if (dev->out) {

1036

if (dev->out) {

1036

usb_ep_disable(dev->out_ep);

1037

usb_ep_disable(dev->out_ep);

1037

if (dev->rx_req) {

1038

if (dev->rx_req) {

1038

usb_ep_free_request(dev->out_ep, dev->rx_req);

1039

usb_ep_free_request(dev->out_ep, dev->rx_req);

1039

dev->rx_req = NULL;

1040

dev->rx_req = NULL;

1040

}

1041

}

1041

}

1042

}

1042

if (dev->status)

1043

if (dev->status)

1043

usb_ep_disable(dev->status_ep);

1044

usb_ep_disable(dev->status_ep);

1044

1045

dev->rndis = 0;

1046

dev->rndis = 0;

1046

dev->cdc_filter = 0;

1047

dev->cdc_filter = 0;

1047

dev->config = 0;

1048

dev->config = 0;

1048

}

1049

}

1049

1050

/*

1051

/*

1051

* change our operational config. must agree with the code

1052

* change our operational config. must agree with the code

1052

* that returns config descriptors, and altsetting code.

1053

* that returns config descriptors, and altsetting code.

1053

*/

1054

*/

1054

static int eth_set_config(struct eth_dev *dev, unsigned number,

1055

static int eth_set_config(struct eth_dev *dev, unsigned number,

1055

gfp_t gfp_flags)

1056

gfp_t gfp_flags)

1056

{

1057

{

1057

int result = 0;

1058

int result = 0;

1058

struct usb_gadget *gadget = dev->gadget;

1059

struct usb_gadget *gadget = dev->gadget;

1059

1060

if (gadget_is_sa1100(gadget)

1061

if (gadget_is_sa1100(gadget)

1061

&& dev->config

1062

&& dev->config

1062

&& dev->tx_qlen != 0) {

1063

&& dev->tx_qlen != 0) {

1063

/* tx fifo is full, but we can't clear it...*/

1064

/* tx fifo is full, but we can't clear it...*/

1064

error("can't change configurations");

1065

error("can't change configurations");

1065

return -ESPIPE;

1066

return -ESPIPE;

1066

}

1067

}

1067

eth_reset_config(dev);

1068

eth_reset_config(dev);

1068

1069

switch (number) {

1070

switch (number) {

1070

case DEV_CONFIG_VALUE:

1071

case DEV_CONFIG_VALUE:

1071

result = set_ether_config(dev, gfp_flags);

1072

result = set_ether_config(dev, gfp_flags);

1072

break;

1073

break;

1073

#ifdef CONFIG_USB_ETH_RNDIS

1074

#ifdef CONFIG_USB_ETH_RNDIS

1074

case DEV_RNDIS_CONFIG_VALUE:

1075

case DEV_RNDIS_CONFIG_VALUE:

1075

dev->rndis = 1;

1076

dev->rndis = 1;

1076

result = set_ether_config(dev, gfp_flags);

1077

result = set_ether_config(dev, gfp_flags);

1077

break;

1078

break;

1078

#endif

1079

#endif

1079

default:

1080

default:

1080

result = -EINVAL;

1081

result = -EINVAL;

1081

/* FALL THROUGH */

1082

/* FALL THROUGH */

1082

case 0:

1083

case 0:

1083

break;

1084

break;

1084

}

1085

}

1085

1086

if (result) {

1087

if (result) {

1087

if (number)

1088

if (number)

1088

eth_reset_config(dev);

1089

eth_reset_config(dev);

1089

usb_gadget_vbus_draw(dev->gadget,

1090

usb_gadget_vbus_draw(dev->gadget,

1090

gadget_is_otg(dev->gadget) ? 8 : 100);

1091

gadget_is_otg(dev->gadget) ? 8 : 100);

1091

} else {

1092

} else {

1092

char *speed;

1093

char *speed;

1093

unsigned power;

1094

unsigned power;

1094

1095

power = 2 * eth_config.bMaxPower;

1096

power = 2 * eth_config.bMaxPower;

1096

usb_gadget_vbus_draw(dev->gadget, power);

1097

usb_gadget_vbus_draw(dev->gadget, power);

1097

1098

switch (gadget->speed) {

1099

switch (gadget->speed) {

1099

case USB_SPEED_FULL:

1100

case USB_SPEED_FULL:

1100

speed = "full"; break;

1101

speed = "full"; break;

1101

#ifdef CONFIG_USB_GADGET_DUALSPEED

1102

#ifdef CONFIG_USB_GADGET_DUALSPEED

1102

case USB_SPEED_HIGH:

1103

case USB_SPEED_HIGH:

1103

speed = "high"; break;

1104

speed = "high"; break;

1104

#endif

1105

#endif

1105

default:

1106

default:

1106

speed = "?"; break;

1107

speed = "?"; break;

1107

}

1108

}

1108

1109

dev->config = number;

1110

dev->config = number;

1110

printf("%s speed config #%d: %d mA, %s, using %s\n",

1111

printf("%s speed config #%d: %d mA, %s, using %s\n",

1111

speed, number, power, driver_desc,

1112

speed, number, power, driver_desc,

1112

rndis_active(dev)

1113

rndis_active(dev)

1113

? "RNDIS"

1114

? "RNDIS"

1114

: (cdc_active(dev)

1115

: (cdc_active(dev)

1115

? "CDC Ethernet"

1116

? "CDC Ethernet"

1116

: "CDC Ethernet Subset"));

1117

: "CDC Ethernet Subset"));

1117

}

1118

}

1118

return result;

1119

return result;

1119

}

1120

}

1120

1121

/*-------------------------------------------------------------------------*/

1122

/*-------------------------------------------------------------------------*/

1122

1123

#ifdef CONFIG_USB_ETH_CDC

1124

#ifdef CONFIG_USB_ETH_CDC

1124

1125

/*

1126

/*

1126

* The interrupt endpoint is used in CDC networking models (Ethernet, ATM)

1127

* The interrupt endpoint is used in CDC networking models (Ethernet, ATM)

1127

* only to notify the host about link status changes (which we support) or

1128

* only to notify the host about link status changes (which we support) or

1128

* report completion of some encapsulated command (as used in RNDIS). Since

1129

* report completion of some encapsulated command (as used in RNDIS). Since

1129

* we want this CDC Ethernet code to be vendor-neutral, we don't use that

1130

* we want this CDC Ethernet code to be vendor-neutral, we don't use that

1130

* command mechanism; and only one status request is ever queued.

1131

* command mechanism; and only one status request is ever queued.

1131

*/

1132

*/

1132

static void eth_status_complete(struct usb_ep *ep, struct usb_request *req)

1133

static void eth_status_complete(struct usb_ep *ep, struct usb_request *req)

1133

{

1134

{

1134

struct usb_cdc_notification *event = req->buf;

1135

struct usb_cdc_notification *event = req->buf;

1135

int value = req->status;

1136

int value = req->status;

1136

struct eth_dev *dev = ep->driver_data;

1137

struct eth_dev *dev = ep->driver_data;

1137

1138

/* issue the second notification if host reads the first */

1139

/* issue the second notification if host reads the first */

1139

if (event->bNotificationType == USB_CDC_NOTIFY_NETWORK_CONNECTION

1140

if (event->bNotificationType == USB_CDC_NOTIFY_NETWORK_CONNECTION

1140

&& value == 0) {

1141

&& value == 0) {

1141

__le32 *data = req->buf + sizeof *event;

1142

__le32 *data = req->buf + sizeof *event;

1142

1143

event->bmRequestType = 0xA1;

1144

event->bmRequestType = 0xA1;

1144

event->bNotificationType = USB_CDC_NOTIFY_SPEED_CHANGE;

1145

event->bNotificationType = USB_CDC_NOTIFY_SPEED_CHANGE;

1145

event->wValue = __constant_cpu_to_le16(0);

1146

event->wValue = __constant_cpu_to_le16(0);

1146

event->wIndex = __constant_cpu_to_le16(1);

1147

event->wIndex = __constant_cpu_to_le16(1);

1147

event->wLength = __constant_cpu_to_le16(8);

1148

event->wLength = __constant_cpu_to_le16(8);

1148

1149

/* SPEED_CHANGE data is up/down speeds in bits/sec */

1150

/* SPEED_CHANGE data is up/down speeds in bits/sec */

1150

data[0] = data[1] = cpu_to_le32(BITRATE(dev->gadget));

1151

data[0] = data[1] = cpu_to_le32(BITRATE(dev->gadget));

1151

1152

req->length = STATUS_BYTECOUNT;

1153

req->length = STATUS_BYTECOUNT;

1153

value = usb_ep_queue(ep, req, GFP_ATOMIC);

1154

value = usb_ep_queue(ep, req, GFP_ATOMIC);

1154

debug("send SPEED_CHANGE --> %d\n", value);

1155

debug("send SPEED_CHANGE --> %d\n", value);

1155

if (value == 0)

1156

if (value == 0)

1156

return;

1157

return;

1157

} else if (value != -ECONNRESET) {

1158

} else if (value != -ECONNRESET) {

1158

debug("event %02x --> %d\n",

1159

debug("event %02x --> %d\n",

1159

event->bNotificationType, value);

1160

event->bNotificationType, value);

1160

if (event->bNotificationType ==

1161

if (event->bNotificationType ==

1161

USB_CDC_NOTIFY_SPEED_CHANGE) {

1162

USB_CDC_NOTIFY_SPEED_CHANGE) {

1162

l_ethdev.network_started = 1;

1163

l_ethdev.network_started = 1;

1163

printf("USB network up!\n");

1164

printf("USB network up!\n");

1164

}

1165

}

1165

}

1166

}

1166

req->context = NULL;

1167

req->context = NULL;

1167

}

1168

}

1168

1169

static void issue_start_status(struct eth_dev *dev)

1170

static void issue_start_status(struct eth_dev *dev)

1170

{

1171

{

1171

struct usb_request *req = dev->stat_req;

1172

struct usb_request *req = dev->stat_req;

1172

struct usb_cdc_notification *event;

1173

struct usb_cdc_notification *event;

1173

int value;

1174

int value;

1174

1175

/*

1176

/*

1176

* flush old status

1177

* flush old status

1177

*

1178

*

1178

* FIXME ugly idiom, maybe we'd be better with just

1179

* FIXME ugly idiom, maybe we'd be better with just

1179

* a "cancel the whole queue" primitive since any

1180

* a "cancel the whole queue" primitive since any

1180

* unlink-one primitive has way too many error modes.

1181

* unlink-one primitive has way too many error modes.

1181

* here, we "know" toggle is already clear...

1182

* here, we "know" toggle is already clear...

1182

*

1183

*

1183

* FIXME iff req->context != null just dequeue it

1184

* FIXME iff req->context != null just dequeue it

1184

*/

1185

*/

1185

usb_ep_disable(dev->status_ep);

1186

usb_ep_disable(dev->status_ep);

1186

usb_ep_enable(dev->status_ep, dev->status);

1187

usb_ep_enable(dev->status_ep, dev->status);

1187

1188

/*

1189

/*

1189

* 3.8.1 says to issue first NETWORK_CONNECTION, then

1190

* 3.8.1 says to issue first NETWORK_CONNECTION, then

1190

* a SPEED_CHANGE. could be useful in some configs.

1191

* a SPEED_CHANGE. could be useful in some configs.

1191

*/

1192

*/

1192

event = req->buf;

1193

event = req->buf;

1193

event->bmRequestType = 0xA1;

1194

event->bmRequestType = 0xA1;

1194

event->bNotificationType = USB_CDC_NOTIFY_NETWORK_CONNECTION;

1195

event->bNotificationType = USB_CDC_NOTIFY_NETWORK_CONNECTION;

1195

event->wValue = __constant_cpu_to_le16(1); /* connected */

1196

event->wValue = __constant_cpu_to_le16(1); /* connected */

1196

event->wIndex = __constant_cpu_to_le16(1);

1197

event->wIndex = __constant_cpu_to_le16(1);

1197

event->wLength = 0;

1198

event->wLength = 0;

1198

1199

req->length = sizeof *event;

1200

req->length = sizeof *event;

1200

req->complete = eth_status_complete;

1201

req->complete = eth_status_complete;

1201

req->context = dev;

1202

req->context = dev;

1202

1203

value = usb_ep_queue(dev->status_ep, req, GFP_ATOMIC);

1204

value = usb_ep_queue(dev->status_ep, req, GFP_ATOMIC);

1204

if (value < 0)

1205

if (value < 0)

1205

debug("status buf queue --> %d\n", value);

1206

debug("status buf queue --> %d\n", value);

1206

}

1207

}

1207

1208

#endif

1209

#endif

1209

1210

/*-------------------------------------------------------------------------*/

1211

/*-------------------------------------------------------------------------*/

1211

1212

static void eth_setup_complete(struct usb_ep *ep, struct usb_request *req)

1213

static void eth_setup_complete(struct usb_ep *ep, struct usb_request *req)

1213

{

1214

{

1214

if (req->status || req->actual != req->length)

1215

if (req->status || req->actual != req->length)

1215

debug("setup complete --> %d, %d/%d\n",

1216

debug("setup complete --> %d, %d/%d\n",

1216

req->status, req->actual, req->length);

1217

req->status, req->actual, req->length);

1217

}

1218

}

1218

1219

#ifdef CONFIG_USB_ETH_RNDIS

1220

#ifdef CONFIG_USB_ETH_RNDIS

1220

1221

static void rndis_response_complete(struct usb_ep *ep, struct usb_request *req)

1222

static void rndis_response_complete(struct usb_ep *ep, struct usb_request *req)

1222

{

1223

{

1223

if (req->status || req->actual != req->length)

1224

if (req->status || req->actual != req->length)

1224

debug("rndis response complete --> %d, %d/%d\n",

1225

debug("rndis response complete --> %d, %d/%d\n",

1225

req->status, req->actual, req->length);

1226

req->status, req->actual, req->length);

1226

1227

/* done sending after USB_CDC_GET_ENCAPSULATED_RESPONSE */

1228

/* done sending after USB_CDC_GET_ENCAPSULATED_RESPONSE */

1228

}

1229

}

1229

1230

static void rndis_command_complete(struct usb_ep *ep, struct usb_request *req)

1231

static void rndis_command_complete(struct usb_ep *ep, struct usb_request *req)

1231

{

1232

{

1232

struct eth_dev *dev = ep->driver_data;

1233

struct eth_dev *dev = ep->driver_data;

1233

int status;

1234

int status;

1234

1235

/* received RNDIS command from USB_CDC_SEND_ENCAPSULATED_COMMAND */

1236

/* received RNDIS command from USB_CDC_SEND_ENCAPSULATED_COMMAND */

1236

status = rndis_msg_parser(dev->rndis_config, (u8 *) req->buf);

1237

status = rndis_msg_parser(dev->rndis_config, (u8 *) req->buf);

1237

if (status < 0)

1238

if (status < 0)

1238

error("%s: rndis parse error %d", __func__, status);

1239

error("%s: rndis parse error %d", __func__, status);

1239

}

1240

}

1240

1241

#endif /* RNDIS */

1242

#endif /* RNDIS */

1242

1243

/*

1244

/*

1244

* The setup() callback implements all the ep0 functionality that's not

1245

* The setup() callback implements all the ep0 functionality that's not

1245

* handled lower down. CDC has a number of less-common features:

1246

* handled lower down. CDC has a number of less-common features:

1246

*

1247

*

1247

* - two interfaces: control, and ethernet data

1248

* - two interfaces: control, and ethernet data

1248

* - Ethernet data interface has two altsettings: default, and active

1249

* - Ethernet data interface has two altsettings: default, and active

1249

* - class-specific descriptors for the control interface

1250

* - class-specific descriptors for the control interface

1250

* - class-specific control requests

1251

* - class-specific control requests

1251

*/

1252

*/

1252

static int

1253

static int

1253

eth_setup(struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)

1254

eth_setup(struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)

1254

{

1255

{

1255

struct eth_dev *dev = get_gadget_data(gadget);

1256

struct eth_dev *dev = get_gadget_data(gadget);

1256

struct usb_request *req = dev->req;

1257

struct usb_request *req = dev->req;

1257

int value = -EOPNOTSUPP;

1258

int value = -EOPNOTSUPP;

1258

u16 wIndex = le16_to_cpu(ctrl->wIndex);

1259

u16 wIndex = le16_to_cpu(ctrl->wIndex);

1259

u16 wValue = le16_to_cpu(ctrl->wValue);

1260

u16 wValue = le16_to_cpu(ctrl->wValue);

1260

u16 wLength = le16_to_cpu(ctrl->wLength);

1261

u16 wLength = le16_to_cpu(ctrl->wLength);

1261

1262

/*

1263

/*

1263

* descriptors just go into the pre-allocated ep0 buffer,

1264

* descriptors just go into the pre-allocated ep0 buffer,

1264

* while config change events may enable network traffic.

1265

* while config change events may enable network traffic.

1265

*/

1266

*/

1266

1267

debug("%s\n", __func__);

1268

debug("%s\n", __func__);

1268

1269

req->complete = eth_setup_complete;

1270

req->complete = eth_setup_complete;

1270

switch (ctrl->bRequest) {

1271

switch (ctrl->bRequest) {

1271

1272

case USB_REQ_GET_DESCRIPTOR:

1273

case USB_REQ_GET_DESCRIPTOR:

1273

if (ctrl->bRequestType != USB_DIR_IN)

1274

if (ctrl->bRequestType != USB_DIR_IN)

1274

break;

1275

break;

1275

switch (wValue >> 8) {

1276

switch (wValue >> 8) {

1276

1277

case USB_DT_DEVICE:

1278

case USB_DT_DEVICE:

1278

value = min(wLength, (u16) sizeof device_desc);

1279

value = min(wLength, (u16) sizeof device_desc);

1279

memcpy(req->buf, &device_desc, value);

1280

memcpy(req->buf, &device_desc, value);

1280

break;

1281

break;

1281

case USB_DT_DEVICE_QUALIFIER:

1282

case USB_DT_DEVICE_QUALIFIER:

1282

if (!gadget_is_dualspeed(gadget))

1283

if (!gadget_is_dualspeed(gadget))

1283

break;

1284

break;

1284

value = min(wLength, (u16) sizeof dev_qualifier);

1285

value = min(wLength, (u16) sizeof dev_qualifier);

1285

memcpy(req->buf, &dev_qualifier, value);

1286

memcpy(req->buf, &dev_qualifier, value);

1286

break;

1287

break;

1287

1288

case USB_DT_OTHER_SPEED_CONFIG:

1289

case USB_DT_OTHER_SPEED_CONFIG:

1289

if (!gadget_is_dualspeed(gadget))

1290

if (!gadget_is_dualspeed(gadget))

1290

break;

1291

break;

1291

/* FALLTHROUGH */

1292

/* FALLTHROUGH */

1292

case USB_DT_CONFIG:

1293

case USB_DT_CONFIG:

1293

value = config_buf(gadget, req->buf,

1294

value = config_buf(gadget, req->buf,

1294

wValue >> 8,

1295

wValue >> 8,

1295

wValue & 0xff,

1296

wValue & 0xff,

1296

gadget_is_otg(gadget));

1297

gadget_is_otg(gadget));

1297

if (value >= 0)

1298

if (value >= 0)

1298

value = min(wLength, (u16) value);

1299

value = min(wLength, (u16) value);

1299

break;

1300

break;

1300

1301

case USB_DT_STRING:

1302

case USB_DT_STRING:

1302

value = usb_gadget_get_string(&stringtab,

1303

value = usb_gadget_get_string(&stringtab,

1303

wValue & 0xff, req->buf);

1304

wValue & 0xff, req->buf);

1304

1305

if (value >= 0)

1306

if (value >= 0)

1306

value = min(wLength, (u16) value);

1307

value = min(wLength, (u16) value);

1307

1308

break;

1309

break;

1309

}

1310

}

1310

break;

1311

break;

1311

1312

case USB_REQ_SET_CONFIGURATION:

1313

case USB_REQ_SET_CONFIGURATION:

1313

if (ctrl->bRequestType != 0)

1314

if (ctrl->bRequestType != 0)

1314

break;

1315

break;

1315

if (gadget->a_hnp_support)

1316

if (gadget->a_hnp_support)

1316

debug("HNP available\n");

1317

debug("HNP available\n");

1317

else if (gadget->a_alt_hnp_support)

1318

else if (gadget->a_alt_hnp_support)

1318

debug("HNP needs a different root port\n");

1319

debug("HNP needs a different root port\n");

1319

value = eth_set_config(dev, wValue, GFP_ATOMIC);

1320

value = eth_set_config(dev, wValue, GFP_ATOMIC);

1320

break;

1321

break;

1321

case USB_REQ_GET_CONFIGURATION:

1322

case USB_REQ_GET_CONFIGURATION:

1322

if (ctrl->bRequestType != USB_DIR_IN)

1323

if (ctrl->bRequestType != USB_DIR_IN)

1323

break;

1324

break;

1324

*(u8 *)req->buf = dev->config;

1325

*(u8 *)req->buf = dev->config;

1325

value = min(wLength, (u16) 1);

1326

value = min(wLength, (u16) 1);

1326

break;

1327

break;

1327

1328

case USB_REQ_SET_INTERFACE:

1329

case USB_REQ_SET_INTERFACE:

1329

if (ctrl->bRequestType != USB_RECIP_INTERFACE

1330

if (ctrl->bRequestType != USB_RECIP_INTERFACE

1330

|| !dev->config

1331

|| !dev->config

1331

|| wIndex > 1)

1332

|| wIndex > 1)

1332

break;

1333

break;

1333

if (!cdc_active(dev) && wIndex != 0)

1334

if (!cdc_active(dev) && wIndex != 0)

1334

break;

1335

break;

1335

1336

/*

1337

/*

1337

* PXA hardware partially handles SET_INTERFACE;

1338

* PXA hardware partially handles SET_INTERFACE;

1338

* we need to kluge around that interference.

1339

* we need to kluge around that interference.

1339

*/

1340

*/

1340

if (gadget_is_pxa(gadget)) {

1341

if (gadget_is_pxa(gadget)) {

1341

value = eth_set_config(dev, DEV_CONFIG_VALUE,

1342

value = eth_set_config(dev, DEV_CONFIG_VALUE,

1342

GFP_ATOMIC);

1343

GFP_ATOMIC);

1343

/*

1344

/*

1344

* PXA25x driver use non-CDC ethernet gadget.

1345

* PXA25x driver use non-CDC ethernet gadget.

1345

* But only _CDC and _RNDIS code can signalize

1346

* But only _CDC and _RNDIS code can signalize

1346

* that network is working. So we signalize it

1347

* that network is working. So we signalize it

1347

* here.

1348

* here.

1348

*/

1349

*/

1349

l_ethdev.network_started = 1;

1350

l_ethdev.network_started = 1;

1350

debug("USB network up!\n");

1351

debug("USB network up!\n");

1351

goto done_set_intf;

1352

goto done_set_intf;

1352

}

1353

}

1353

1354

#ifdef CONFIG_USB_ETH_CDC

1355

#ifdef CONFIG_USB_ETH_CDC

1355

switch (wIndex) {

1356

switch (wIndex) {

1356

case 0: /* control/master intf */

1357

case 0: /* control/master intf */

1357

if (wValue != 0)

1358

if (wValue != 0)

1358

break;

1359

break;

1359

if (dev->status) {

1360

if (dev->status) {

1360

usb_ep_disable(dev->status_ep);

1361

usb_ep_disable(dev->status_ep);

1361

usb_ep_enable(dev->status_ep, dev->status);

1362

usb_ep_enable(dev->status_ep, dev->status);

1362

}

1363

}

1363

1364

value = 0;

1365

value = 0;

1365

break;

1366

break;

1366

case 1: /* data intf */

1367

case 1: /* data intf */

1367

if (wValue > 1)

1368

if (wValue > 1)

1368

break;

1369

break;

1369

usb_ep_disable(dev->in_ep);

1370

usb_ep_disable(dev->in_ep);

1370

usb_ep_disable(dev->out_ep);

1371

usb_ep_disable(dev->out_ep);

1371

1372

/*

1373

/*

1373

* CDC requires the data transfers not be done from

1374

* CDC requires the data transfers not be done from

1374

* the default interface setting ... also, setting

1375

* the default interface setting ... also, setting

1375

* the non-default interface resets filters etc.

1376

* the non-default interface resets filters etc.

1376

*/

1377

*/

1377

if (wValue == 1) {

1378

if (wValue == 1) {

1378

if (!cdc_active(dev))

1379

if (!cdc_active(dev))

1379

break;

1380

break;

1380

usb_ep_enable(dev->in_ep, dev->in);

1381

usb_ep_enable(dev->in_ep, dev->in);

1381

usb_ep_enable(dev->out_ep, dev->out);

1382

usb_ep_enable(dev->out_ep, dev->out);

1382

dev->cdc_filter = DEFAULT_FILTER;

1383

dev->cdc_filter = DEFAULT_FILTER;

1383

if (dev->status)

1384

if (dev->status)

1384

issue_start_status(dev);

1385

issue_start_status(dev);

1385

eth_start(dev, GFP_ATOMIC);

1386

eth_start(dev, GFP_ATOMIC);

1386

}

1387

}

1387

value = 0;

1388

value = 0;

1388

break;

1389

break;

1389

}

1390

}

1390

#else

1391

#else

1391

/*

1392

/*

1392

* FIXME this is wrong, as is the assumption that

1393

* FIXME this is wrong, as is the assumption that

1393

* all non-PXA hardware talks real CDC ...

1394

* all non-PXA hardware talks real CDC ...

1394

*/

1395

*/

1395

debug("set_interface ignored!\n");

1396

debug("set_interface ignored!\n");

1396

#endif /* CONFIG_USB_ETH_CDC */

1397

#endif /* CONFIG_USB_ETH_CDC */

1397

1398

done_set_intf:

1399

done_set_intf:

1399

break;

1400

break;

1400

case USB_REQ_GET_INTERFACE:

1401

case USB_REQ_GET_INTERFACE:

1401

if (ctrl->bRequestType != (USB_DIR_IN|USB_RECIP_INTERFACE)

1402

if (ctrl->bRequestType != (USB_DIR_IN|USB_RECIP_INTERFACE)

1402

|| !dev->config

1403

|| !dev->config

1403

|| wIndex > 1)

1404

|| wIndex > 1)

1404

break;

1405

break;

1405

if (!(cdc_active(dev) || rndis_active(dev)) && wIndex != 0)

1406

if (!(cdc_active(dev) || rndis_active(dev)) && wIndex != 0)

1406

break;

1407

break;

1407

1408

/* for CDC, iff carrier is on, data interface is active. */

1409

/* for CDC, iff carrier is on, data interface is active. */

1409

if (rndis_active(dev) || wIndex != 1)

1410

if (rndis_active(dev) || wIndex != 1)

1410

*(u8 *)req->buf = 0;

1411

*(u8 *)req->buf = 0;

1411

else {

1412

else {

1412

/* *(u8 *)req->buf = netif_carrier_ok (dev->net) ? 1 : 0; */

1413

/* *(u8 *)req->buf = netif_carrier_ok (dev->net) ? 1 : 0; */

1413

/* carrier always ok ...*/

1414

/* carrier always ok ...*/

1414

*(u8 *)req->buf = 1 ;

1415

*(u8 *)req->buf = 1 ;

1415

}

1416

}

1416

value = min(wLength, (u16) 1);

1417

value = min(wLength, (u16) 1);

1417

break;

1418

break;

1418

1419

#ifdef CONFIG_USB_ETH_CDC

1420

#ifdef CONFIG_USB_ETH_CDC

1420

case USB_CDC_SET_ETHERNET_PACKET_FILTER:

1421

case USB_CDC_SET_ETHERNET_PACKET_FILTER:

1421

/*

1422

/*

1422

* see 6.2.30: no data, wIndex = interface,

1423

* see 6.2.30: no data, wIndex = interface,

1423

* wValue = packet filter bitmap

1424

* wValue = packet filter bitmap

1424

*/

1425

*/

1425

if (ctrl->bRequestType != (USB_TYPE_CLASS|USB_RECIP_INTERFACE)

1426

if (ctrl->bRequestType != (USB_TYPE_CLASS|USB_RECIP_INTERFACE)

1426

|| !cdc_active(dev)

1427

|| !cdc_active(dev)

1427

|| wLength != 0

1428

|| wLength != 0

1428

|| wIndex > 1)

1429

|| wIndex > 1)

1429

break;

1430

break;

1430

debug("packet filter %02x\n", wValue);

1431

debug("packet filter %02x\n", wValue);

1431

dev->cdc_filter = wValue;

1432

dev->cdc_filter = wValue;

1432

value = 0;

1433

value = 0;

1433

break;

1434

break;

1434

1435

/*

1436

/*

1436

* and potentially:

1437

* and potentially:

1437

* case USB_CDC_SET_ETHERNET_MULTICAST_FILTERS:

1438

* case USB_CDC_SET_ETHERNET_MULTICAST_FILTERS:

1438

* case USB_CDC_SET_ETHERNET_PM_PATTERN_FILTER:

1439

* case USB_CDC_SET_ETHERNET_PM_PATTERN_FILTER:

1439

* case USB_CDC_GET_ETHERNET_PM_PATTERN_FILTER:

1440

* case USB_CDC_GET_ETHERNET_PM_PATTERN_FILTER:

1440

* case USB_CDC_GET_ETHERNET_STATISTIC:

1441

* case USB_CDC_GET_ETHERNET_STATISTIC:

1441

*/

1442

*/

1442

1443

#endif /* CONFIG_USB_ETH_CDC */

1444

#endif /* CONFIG_USB_ETH_CDC */

1444

1445

#ifdef CONFIG_USB_ETH_RNDIS

1446

#ifdef CONFIG_USB_ETH_RNDIS

1446

/*

1447

/*

1447

* RNDIS uses the CDC command encapsulation mechanism to implement

1448

* RNDIS uses the CDC command encapsulation mechanism to implement

1448

* an RPC scheme, with much getting/setting of attributes by OID.

1449

* an RPC scheme, with much getting/setting of attributes by OID.

1449

*/

1450

*/

1450

case USB_CDC_SEND_ENCAPSULATED_COMMAND:

1451

case USB_CDC_SEND_ENCAPSULATED_COMMAND:

1451

if (ctrl->bRequestType != (USB_TYPE_CLASS|USB_RECIP_INTERFACE)

1452

if (ctrl->bRequestType != (USB_TYPE_CLASS|USB_RECIP_INTERFACE)

1452

|| !rndis_active(dev)

1453

|| !rndis_active(dev)

1453

|| wLength > USB_BUFSIZ

1454

|| wLength > USB_BUFSIZ

1454

|| wValue

1455

|| wValue

1455

|| rndis_control_intf.bInterfaceNumber

1456

|| rndis_control_intf.bInterfaceNumber

1456

!= wIndex)

1457

!= wIndex)

1457

break;

1458

break;

1458

/* read the request, then process it */

1459

/* read the request, then process it */

1459

value = wLength;

1460

value = wLength;

1460

req->complete = rndis_command_complete;

1461

req->complete = rndis_command_complete;

1461

/* later, rndis_control_ack () sends a notification */

1462

/* later, rndis_control_ack () sends a notification */

1462

break;

1463

break;

1463

1464

case USB_CDC_GET_ENCAPSULATED_RESPONSE:

1465

case USB_CDC_GET_ENCAPSULATED_RESPONSE:

1465

if ((USB_DIR_IN|USB_TYPE_CLASS|USB_RECIP_INTERFACE)

1466

if ((USB_DIR_IN|USB_TYPE_CLASS|USB_RECIP_INTERFACE)

1466

== ctrl->bRequestType

1467

== ctrl->bRequestType

1467

&& rndis_active(dev)

1468

&& rndis_active(dev)

1468

/* && wLength >= 0x0400 */

1469

/* && wLength >= 0x0400 */

1469

&& !wValue

1470

&& !wValue

1470

&& rndis_control_intf.bInterfaceNumber

1471

&& rndis_control_intf.bInterfaceNumber

1471

== wIndex) {

1472

== wIndex) {

1472

u8 *buf;

1473

u8 *buf;

1473

u32 n;

1474

u32 n;

1474

1475

/* return the result */

1476

/* return the result */

1476

buf = rndis_get_next_response(dev->rndis_config, &n);

1477

buf = rndis_get_next_response(dev->rndis_config, &n);

1477

if (buf) {

1478

if (buf) {

1478

memcpy(req->buf, buf, n);

1479

memcpy(req->buf, buf, n);

1479

req->complete = rndis_response_complete;

1480

req->complete = rndis_response_complete;

1480

rndis_free_response(dev->rndis_config, buf);

1481

rndis_free_response(dev->rndis_config, buf);

1481

value = n;

1482

value = n;

1482

}

1483

}

1483

/* else stalls ... spec says to avoid that */

1484

/* else stalls ... spec says to avoid that */

1484

}

1485

}

1485

break;

1486

break;

1486

#endif /* RNDIS */

1487

#endif /* RNDIS */

1487

1488

default:

1489

default:

1489

debug("unknown control req%02x.%02x v%04x i%04x l%d\n",

1490

debug("unknown control req%02x.%02x v%04x i%04x l%d\n",

1490

ctrl->bRequestType, ctrl->bRequest,

1491

ctrl->bRequestType, ctrl->bRequest,

1491

wValue, wIndex, wLength);

1492

wValue, wIndex, wLength);

1492

}

1493

}

1493

1494

/* respond with data transfer before status phase? */

1495

/* respond with data transfer before status phase? */

1495

if (value >= 0) {

1496

if (value >= 0) {

1496

debug("respond with data transfer before status phase\n");

1497

debug("respond with data transfer before status phase\n");

1497

req->length = value;

1498

req->length = value;

1498

req->zero = value < wLength

1499

req->zero = value < wLength

1499

&& (value % gadget->ep0->maxpacket) == 0;

1500

&& (value % gadget->ep0->maxpacket) == 0;

1500

value = usb_ep_queue(gadget->ep0, req, GFP_ATOMIC);

1501

value = usb_ep_queue(gadget->ep0, req, GFP_ATOMIC);

1501

if (value < 0) {

1502

if (value < 0) {

1502

debug("ep_queue --> %d\n", value);

1503

debug("ep_queue --> %d\n", value);

1503

req->status = 0;

1504

req->status = 0;

1504

eth_setup_complete(gadget->ep0, req);

1505

eth_setup_complete(gadget->ep0, req);

1505

}

1506

}

1506

}

1507

}

1507

1508

/* host either stalls (value < 0) or reports success */

1509

/* host either stalls (value < 0) or reports success */

1509

return value;

1510

return value;

1510

}

1511

}

1511

1512

/*-------------------------------------------------------------------------*/

1513

/*-------------------------------------------------------------------------*/

1513

1514

static void rx_complete(struct usb_ep *ep, struct usb_request *req);

1515

static void rx_complete(struct usb_ep *ep, struct usb_request *req);

1515

1516

static int rx_submit(struct eth_dev *dev, struct usb_request *req,

1517

static int rx_submit(struct eth_dev *dev, struct usb_request *req,

1517

gfp_t gfp_flags)

1518

gfp_t gfp_flags)

1518

{

1519

{

1519

int retval = -ENOMEM;

1520

int retval = -ENOMEM;

1520

size_t size;

1521

size_t size;

1521

1522

/*

1523

/*

1523

* Padding up to RX_EXTRA handles minor disagreements with host.

1524

* Padding up to RX_EXTRA handles minor disagreements with host.

1524

* Normally we use the USB "terminate on short read" convention;

1525

* Normally we use the USB "terminate on short read" convention;

1525

* so allow up to (N*maxpacket), since that memory is normally

1526

* so allow up to (N*maxpacket), since that memory is normally

1526

* already allocated. Some hardware doesn't deal well with short

1527

* already allocated. Some hardware doesn't deal well with short

1527

* reads (e.g. DMA must be N*maxpacket), so for now don't trim a

1528

* reads (e.g. DMA must be N*maxpacket), so for now don't trim a

1528

* byte off the end (to force hardware errors on overflow).

1529

* byte off the end (to force hardware errors on overflow).

1529

*

1530

*

1530

* RNDIS uses internal framing, and explicitly allows senders to

1531

* RNDIS uses internal framing, and explicitly allows senders to

1531

* pad to end-of-packet. That's potentially nice for speed,

1532

* pad to end-of-packet. That's potentially nice for speed,

1532

* but means receivers can't recover synch on their own.

1533

* but means receivers can't recover synch on their own.

1533

*/

1534

*/

1534

1535

debug("%s\n", __func__);

1536

debug("%s\n", __func__);

1536

1537

size = (ETHER_HDR_SIZE + dev->mtu + RX_EXTRA);

1538

size = (ETHER_HDR_SIZE + dev->mtu + RX_EXTRA);

1538

size += dev->out_ep->maxpacket - 1;

1539

size += dev->out_ep->maxpacket - 1;

1539

if (rndis_active(dev))

1540

if (rndis_active(dev))

1540

size += sizeof(struct rndis_packet_msg_type);

1541

size += sizeof(struct rndis_packet_msg_type);

1541

size -= size % dev->out_ep->maxpacket;

1542

size -= size % dev->out_ep->maxpacket;

1542

1543

/*

1544

/*

1544

* Some platforms perform better when IP packets are aligned,

1545

* Some platforms perform better when IP packets are aligned,

1545

* but on at least one, checksumming fails otherwise. Note:

1546

* but on at least one, checksumming fails otherwise. Note:

1546

* RNDIS headers involve variable numbers of LE32 values.

1547

* RNDIS headers involve variable numbers of LE32 values.

1547

*/

1548

*/

1548

1549

req->buf = (u8 *) NetRxPackets[0];

1550

req->buf = (u8 *) NetRxPackets[0];

1550

req->length = size;

1551

req->length = size;

1551

req->complete = rx_complete;

1552

req->complete = rx_complete;

1552

1553

retval = usb_ep_queue(dev->out_ep, req, gfp_flags);

1554

retval = usb_ep_queue(dev->out_ep, req, gfp_flags);

1554

1555

if (retval)

1556

if (retval)

1556

error("rx submit --> %d", retval);

1557

error("rx submit --> %d", retval);

1557

1558

return retval;

1559

return retval;

1559

}

1560

}

1560

1561

static void rx_complete(struct usb_ep *ep, struct usb_request *req)

1562

static void rx_complete(struct usb_ep *ep, struct usb_request *req)

1562

{

1563

{

1563

struct eth_dev *dev = ep->driver_data;

1564

struct eth_dev *dev = ep->driver_data;

1564

1565

debug("%s: status %d\n", __func__, req->status);

1566

debug("%s: status %d\n", __func__, req->status);

1566

switch (req->status) {

1567

switch (req->status) {

1567

/* normal completion */

1568

/* normal completion */

1568

case 0:

1569

case 0:

1569

if (rndis_active(dev)) {

1570

if (rndis_active(dev)) {

1570

/* we know MaxPacketsPerTransfer == 1 here */

1571

/* we know MaxPacketsPerTransfer == 1 here */

1571

int length = rndis_rm_hdr(req->buf, req->actual);

1572

int length = rndis_rm_hdr(req->buf, req->actual);

1572

if (length < 0)

1573

if (length < 0)

1573

goto length_err;

1574

goto length_err;

1574

req->length -= length;

1575

req->length -= length;

1575

req->actual -= length;

1576

req->actual -= length;

1576

}

1577

}

1577

if (req->actual < ETH_HLEN || ETH_FRAME_LEN < req->actual) {

1578

if (req->actual < ETH_HLEN || ETH_FRAME_LEN < req->actual) {

1578

length_err:

1579

length_err:

1579

dev->stats.rx_errors++;

1580

dev->stats.rx_errors++;

1580

dev->stats.rx_length_errors++;

1581

dev->stats.rx_length_errors++;

1581

debug("rx length %d\n", req->length);

1582

debug("rx length %d\n", req->length);

1582

break;

1583

break;

1583

}

1584

}

1584

1585

dev->stats.rx_packets++;

1586

dev->stats.rx_packets++;

1586

dev->stats.rx_bytes += req->length;

1587

dev->stats.rx_bytes += req->length;

1587

break;

1588

break;

1588

1589

/* software-driven interface shutdown */

1590

/* software-driven interface shutdown */

1590

case -ECONNRESET: /* unlink */

1591

case -ECONNRESET: /* unlink */

1591

case -ESHUTDOWN: /* disconnect etc */

1592

case -ESHUTDOWN: /* disconnect etc */

1592

/* for hardware automagic (such as pxa) */

1593

/* for hardware automagic (such as pxa) */

1593

case -ECONNABORTED: /* endpoint reset */

1594

case -ECONNABORTED: /* endpoint reset */

1594

break;

1595

break;

1595

1596

/* data overrun */

1597

/* data overrun */

1597

case -EOVERFLOW:

1598

case -EOVERFLOW:

1598

dev->stats.rx_over_errors++;

1599

dev->stats.rx_over_errors++;

1599

/* FALLTHROUGH */

1600

/* FALLTHROUGH */

1600

default:

1601

default:

1601

dev->stats.rx_errors++;

1602

dev->stats.rx_errors++;

1602

break;

1603

break;

1603

}

1604

}

1604

1605

packet_received = 1;

1606

packet_received = 1;

1606

}

1607

}

1607

1608

static int alloc_requests(struct eth_dev *dev, unsigned n, gfp_t gfp_flags)

1609

static int alloc_requests(struct eth_dev *dev, unsigned n, gfp_t gfp_flags)

1609

{

1610

{

1610

1611

dev->tx_req = usb_ep_alloc_request(dev->in_ep, 0);

1612

dev->tx_req = usb_ep_alloc_request(dev->in_ep, 0);

1612

1613

if (!dev->tx_req)

1614

if (!dev->tx_req)

1614

goto fail1;

1615

goto fail1;

1615

1616

dev->rx_req = usb_ep_alloc_request(dev->out_ep, 0);

1617

dev->rx_req = usb_ep_alloc_request(dev->out_ep, 0);

1617

1618

if (!dev->rx_req)

1619

if (!dev->rx_req)

1619

goto fail2;

1620

goto fail2;

1620

1621

return 0;

1622

return 0;

1622

1623

fail2:

1624

fail2:

1624

usb_ep_free_request(dev->in_ep, dev->tx_req);

1625

usb_ep_free_request(dev->in_ep, dev->tx_req);

1625

fail1:

1626

fail1:

1626

error("can't alloc requests");

1627

error("can't alloc requests");

1627

return -1;

1628

return -1;

1628

}

1629

}

1629

1630

static void tx_complete(struct usb_ep *ep, struct usb_request *req)

1631

static void tx_complete(struct usb_ep *ep, struct usb_request *req)

1631

{

1632

{

1632

struct eth_dev *dev = ep->driver_data;

1633

struct eth_dev *dev = ep->driver_data;

1633

1634

debug("%s: status %s\n", __func__, (req->status) ? "failed" : "ok");

1635

debug("%s: status %s\n", __func__, (req->status) ? "failed" : "ok");

1635

switch (req->status) {

1636

switch (req->status) {

1636

default:

1637

default:

1637

dev->stats.tx_errors++;

1638

dev->stats.tx_errors++;

1638

debug("tx err %d\n", req->status);

1639

debug("tx err %d\n", req->status);

1639

/* FALLTHROUGH */

1640

/* FALLTHROUGH */

1640

case -ECONNRESET: /* unlink */

1641

case -ECONNRESET: /* unlink */

1641

case -ESHUTDOWN: /* disconnect etc */

1642

case -ESHUTDOWN: /* disconnect etc */

1642

break;

1643

break;

1643

case 0:

1644

case 0:

1644

dev->stats.tx_bytes += req->length;

1645

dev->stats.tx_bytes += req->length;

1645

}

1646

}

1646

dev->stats.tx_packets++;

1647

dev->stats.tx_packets++;

1647

1648

packet_sent = 1;

1649

packet_sent = 1;

1649

}

1650

}

1650

1651

static inline int eth_is_promisc(struct eth_dev *dev)

1652

static inline int eth_is_promisc(struct eth_dev *dev)

1652

{

1653

{

1653

/* no filters for the CDC subset; always promisc */

1654

/* no filters for the CDC subset; always promisc */

1654

if (subset_active(dev))

1655

if (subset_active(dev))

1655

return 1;

1656

return 1;

1656

return dev->cdc_filter & USB_CDC_PACKET_TYPE_PROMISCUOUS;

1657

return dev->cdc_filter & USB_CDC_PACKET_TYPE_PROMISCUOUS;

1657

}

1658

}

1658

1659

#if 0

1660

#if 0

1660

static int eth_start_xmit (struct sk_buff *skb, struct net_device *net)

1661

static int eth_start_xmit (struct sk_buff *skb, struct net_device *net)

1661

{

1662

{

1662

struct eth_dev *dev = netdev_priv(net);

1663

struct eth_dev *dev = netdev_priv(net);

1663

int length = skb->len;

1664

int length = skb->len;

1664

int retval;

1665

int retval;

1665

struct usb_request *req = NULL;

1666

struct usb_request *req = NULL;

1666

unsigned long flags;

1667

unsigned long flags;

1667

1668

/* apply outgoing CDC or RNDIS filters */

1669

/* apply outgoing CDC or RNDIS filters */

1669

if (!eth_is_promisc (dev)) {

1670

if (!eth_is_promisc (dev)) {

1670

u8 *dest = skb->data;

1671

u8 *dest = skb->data;

1671

1672

if (is_multicast_ether_addr(dest)) {

1673

if (is_multicast_ether_addr(dest)) {

1673

u16 type;

1674

u16 type;

1674

1675

/* ignores USB_CDC_PACKET_TYPE_MULTICAST and host

1676

/* ignores USB_CDC_PACKET_TYPE_MULTICAST and host

1676

* SET_ETHERNET_MULTICAST_FILTERS requests

1677

* SET_ETHERNET_MULTICAST_FILTERS requests

1677

*/

1678

*/

1678

if (is_broadcast_ether_addr(dest))

1679

if (is_broadcast_ether_addr(dest))

1679

type = USB_CDC_PACKET_TYPE_BROADCAST;

1680

type = USB_CDC_PACKET_TYPE_BROADCAST;

1680

else

1681

else

1681

type = USB_CDC_PACKET_TYPE_ALL_MULTICAST;

1682

type = USB_CDC_PACKET_TYPE_ALL_MULTICAST;

1682

if (!(dev->cdc_filter & type)) {

1683

if (!(dev->cdc_filter & type)) {

1683

dev_kfree_skb_any (skb);

1684

dev_kfree_skb_any (skb);

1684

return 0;

1685

return 0;

1685

}

1686

}

1686

}

1687

}

1687

/* ignores USB_CDC_PACKET_TYPE_DIRECTED */

1688

/* ignores USB_CDC_PACKET_TYPE_DIRECTED */

1688

}

1689

}

1689

1690

spin_lock_irqsave(&dev->req_lock, flags);

1691

spin_lock_irqsave(&dev->req_lock, flags);

1691

/*

1692

/*

1692

* this freelist can be empty if an interrupt triggered disconnect()

1693

* this freelist can be empty if an interrupt triggered disconnect()

1693

* and reconfigured the gadget (shutting down this queue) after the

1694

* and reconfigured the gadget (shutting down this queue) after the

1694

* network stack decided to xmit but before we got the spinlock.

1695

* network stack decided to xmit but before we got the spinlock.

1695

*/

1696

*/

1696

if (list_empty(&dev->tx_reqs)) {

1697

if (list_empty(&dev->tx_reqs)) {

1697

spin_unlock_irqrestore(&dev->req_lock, flags);

1698

spin_unlock_irqrestore(&dev->req_lock, flags);

1698

return 1;

1699

return 1;

1699

}

1700

}

1700

1701

req = container_of (dev->tx_reqs.next, struct usb_request, list);

1702

req = container_of (dev->tx_reqs.next, struct usb_request, list);

1702

list_del (&req->list);

1703

list_del (&req->list);

1703

1704

/* temporarily stop TX queue when the freelist empties */

1705

/* temporarily stop TX queue when the freelist empties */

1705

if (list_empty (&dev->tx_reqs))

1706

if (list_empty (&dev->tx_reqs))

1706

netif_stop_queue (net);

1707

netif_stop_queue (net);

1707

spin_unlock_irqrestore(&dev->req_lock, flags);

1708

spin_unlock_irqrestore(&dev->req_lock, flags);

1708

1709

/* no buffer copies needed, unless the network stack did it

1710

/* no buffer copies needed, unless the network stack did it

1710

* or the hardware can't use skb buffers.

1711

* or the hardware can't use skb buffers.

1711

* or there's not enough space for any RNDIS headers we need

1712

* or there's not enough space for any RNDIS headers we need

1712

*/

1713

*/

1713

if (rndis_active(dev)) {

1714

if (rndis_active(dev)) {

1714

struct sk_buff *skb_rndis;

1715

struct sk_buff *skb_rndis;

1715

1716

skb_rndis = skb_realloc_headroom (skb,

1717

skb_rndis = skb_realloc_headroom (skb,

1717

sizeof (struct rndis_packet_msg_type));

1718

sizeof (struct rndis_packet_msg_type));

1718

if (!skb_rndis)

1719

if (!skb_rndis)

1719

goto drop;

1720

goto drop;

1720

1721

dev_kfree_skb_any (skb);

1722

dev_kfree_skb_any (skb);

1722

skb = skb_rndis;

1723

skb = skb_rndis;

1723

rndis_add_hdr (skb);

1724

rndis_add_hdr (skb);

1724

length = skb->len;

1725

length = skb->len;

1725

}

1726

}

1726

req->buf = skb->data;

1727

req->buf = skb->data;

1727

req->context = skb;

1728

req->context = skb;

1728

req->complete = tx_complete;

1729

req->complete = tx_complete;

1729

1730

/* use zlp framing on tx for strict CDC-Ether conformance,

1731

/* use zlp framing on tx for strict CDC-Ether conformance,

1731

* though any robust network rx path ignores extra padding.

1732

* though any robust network rx path ignores extra padding.

1732

* and some hardware doesn't like to write zlps.

1733

* and some hardware doesn't like to write zlps.

1733

*/

1734

*/

1734

req->zero = 1;

1735

req->zero = 1;

1735

if (!dev->zlp && (length % dev->in_ep->maxpacket) == 0)

1736

if (!dev->zlp && (length % dev->in_ep->maxpacket) == 0)

1736

length++;

1737

length++;

1737

1738

req->length = length;

1739

req->length = length;

1739

1740

/* throttle highspeed IRQ rate back slightly */

1741

/* throttle highspeed IRQ rate back slightly */

1741

if (gadget_is_dualspeed(dev->gadget))

1742

if (gadget_is_dualspeed(dev->gadget))

1742

req->no_interrupt = (dev->gadget->speed == USB_SPEED_HIGH)

1743

req->no_interrupt = (dev->gadget->speed == USB_SPEED_HIGH)

1743

? ((atomic_read(&dev->tx_qlen) % qmult) != 0)

1744

? ((atomic_read(&dev->tx_qlen) % qmult) != 0)

1744

: 0;

1745

: 0;

1745

1746

retval = usb_ep_queue (dev->in_ep, req, GFP_ATOMIC);

1747

retval = usb_ep_queue (dev->in_ep, req, GFP_ATOMIC);

1747

switch (retval) {

1748

switch (retval) {

1748

default:

1749

default:

1749

DEBUG (dev, "tx queue err %d\n", retval);

1750

DEBUG (dev, "tx queue err %d\n", retval);

1750

break;

1751

break;

1751

case 0:

1752

case 0:

1752

net->trans_start = jiffies;

1753

net->trans_start = jiffies;

1753

atomic_inc (&dev->tx_qlen);

1754

atomic_inc (&dev->tx_qlen);

1754

}

1755

}

1755

1756

if (retval) {

1757

if (retval) {

1757

drop:

1758

drop:

1758

dev->stats.tx_dropped++;

1759

dev->stats.tx_dropped++;

1759

dev_kfree_skb_any (skb);

1760

dev_kfree_skb_any (skb);

1760

spin_lock_irqsave(&dev->req_lock, flags);

1761

spin_lock_irqsave(&dev->req_lock, flags);

1761

if (list_empty (&dev->tx_reqs))

1762

if (list_empty (&dev->tx_reqs))

1762

netif_start_queue (net);

1763

netif_start_queue (net);

1763

list_add (&req->list, &dev->tx_reqs);

1764

list_add (&req->list, &dev->tx_reqs);

1764

spin_unlock_irqrestore(&dev->req_lock, flags);

1765

spin_unlock_irqrestore(&dev->req_lock, flags);

1765

}

1766

}

1766

return 0;

1767

return 0;

1767

}

1768

}

1768

1769

/*-------------------------------------------------------------------------*/

1770

/*-------------------------------------------------------------------------*/

1770

#endif

1771

#endif

1771

1772

static void eth_unbind(struct usb_gadget *gadget)

1773

static void eth_unbind(struct usb_gadget *gadget)

1773

{

1774

{

1774

struct eth_dev *dev = get_gadget_data(gadget);

1775

struct eth_dev *dev = get_gadget_data(gadget);

1775

1776

debug("%s...\n", __func__);

1777

debug("%s...\n", __func__);

1777

rndis_deregister(dev->rndis_config);

1778

rndis_deregister(dev->rndis_config);

1778

rndis_exit();

1779

rndis_exit();

1779

1780

/* we've already been disconnected ... no i/o is active */

1781

/* we've already been disconnected ... no i/o is active */

1781

if (dev->req) {

1782

if (dev->req) {

1782

usb_ep_free_request(gadget->ep0, dev->req);

1783

usb_ep_free_request(gadget->ep0, dev->req);

1783

dev->req = NULL;

1784

dev->req = NULL;

1784

}

1785

}

1785

if (dev->stat_req) {

1786

if (dev->stat_req) {

1786

usb_ep_free_request(dev->status_ep, dev->stat_req);

1787

usb_ep_free_request(dev->status_ep, dev->stat_req);

1787

dev->stat_req = NULL;

1788

dev->stat_req = NULL;

1788

}

1789

}

1789

1790

if (dev->tx_req) {

1791

if (dev->tx_req) {

1791

usb_ep_free_request(dev->in_ep, dev->tx_req);

1792

usb_ep_free_request(dev->in_ep, dev->tx_req);

1792

dev->tx_req = NULL;

1793

dev->tx_req = NULL;

1793

}

1794

}

1794

1795

if (dev->rx_req) {

1796

if (dev->rx_req) {

1796

usb_ep_free_request(dev->out_ep, dev->rx_req);

1797

usb_ep_free_request(dev->out_ep, dev->rx_req);

1797

dev->rx_req = NULL;

1798

dev->rx_req = NULL;

1798

}

1799

}

1799

1800

/* unregister_netdev (dev->net);*/

1801

/* unregister_netdev (dev->net);*/

1801

/* free_netdev(dev->net);*/

1802

/* free_netdev(dev->net);*/

1802

1803

dev->gadget = NULL;

1804

dev->gadget = NULL;

1804

set_gadget_data(gadget, NULL);

1805

set_gadget_data(gadget, NULL);

1805

}

1806

}

1806

1807

static void eth_disconnect(struct usb_gadget *gadget)

1808

static void eth_disconnect(struct usb_gadget *gadget)

1808

{

1809

{

1809

eth_reset_config(get_gadget_data(gadget));

1810

eth_reset_config(get_gadget_data(gadget));

1810

/* FIXME RNDIS should enter RNDIS_UNINITIALIZED */

1811

/* FIXME RNDIS should enter RNDIS_UNINITIALIZED */

1811

}

1812

}

1812

1813

static void eth_suspend(struct usb_gadget *gadget)

1814

static void eth_suspend(struct usb_gadget *gadget)

1814

{

1815

{

1815

/* Not used */

1816

/* Not used */

1816

}

1817

}

1817

1818

static void eth_resume(struct usb_gadget *gadget)

1819

static void eth_resume(struct usb_gadget *gadget)

1819

{

1820

{

1820

/* Not used */

1821

/* Not used */

1821

}

1822

}

1822

1823

/*-------------------------------------------------------------------------*/

1824

/*-------------------------------------------------------------------------*/

1824

1825

#ifdef CONFIG_USB_ETH_RNDIS

1826

#ifdef CONFIG_USB_ETH_RNDIS

1826

1827

/*

1828

/*

1828

* The interrupt endpoint is used in RNDIS to notify the host when messages

1829

* The interrupt endpoint is used in RNDIS to notify the host when messages

1829

* other than data packets are available ... notably the REMOTE_NDIS_*_CMPLT

1830

* other than data packets are available ... notably the REMOTE_NDIS_*_CMPLT

1830

* messages, but also REMOTE_NDIS_INDICATE_STATUS_MSG and potentially even

1831

* messages, but also REMOTE_NDIS_INDICATE_STATUS_MSG and potentially even

1831

* REMOTE_NDIS_KEEPALIVE_MSG.

1832

* REMOTE_NDIS_KEEPALIVE_MSG.

1832

*

1833

*

1833

* The RNDIS control queue is processed by GET_ENCAPSULATED_RESPONSE, and

1834

* The RNDIS control queue is processed by GET_ENCAPSULATED_RESPONSE, and

1834

* normally just one notification will be queued.

1835

* normally just one notification will be queued.

1835

*/

1836

*/

1836

1837

static void rndis_control_ack_complete(struct usb_ep *ep,

1838

static void rndis_control_ack_complete(struct usb_ep *ep,

1838

struct usb_request *req)

1839

struct usb_request *req)

1839

{

1840

{

1840

struct eth_dev *dev = ep->driver_data;

1841

struct eth_dev *dev = ep->driver_data;

1841

1842

debug("%s...\n", __func__);

1843

debug("%s...\n", __func__);

1843

if (req->status || req->actual != req->length)

1844

if (req->status || req->actual != req->length)

1844

debug("rndis control ack complete --> %d, %d/%d\n",

1845

debug("rndis control ack complete --> %d, %d/%d\n",

1845

req->status, req->actual, req->length);

1846

req->status, req->actual, req->length);

1846

1847

if (!l_ethdev.network_started) {

1848

if (!l_ethdev.network_started) {

1848

if (rndis_get_state(dev->rndis_config)

1849

if (rndis_get_state(dev->rndis_config)

1849

== RNDIS_DATA_INITIALIZED) {

1850

== RNDIS_DATA_INITIALIZED) {

1850

l_ethdev.network_started = 1;

1851

l_ethdev.network_started = 1;

1851

printf("USB RNDIS network up!\n");

1852

printf("USB RNDIS network up!\n");

1852

}

1853

}

1853

}

1854

}

1854

1855

req->context = NULL;

1856

req->context = NULL;

1856

1857

if (req != dev->stat_req)

1858

if (req != dev->stat_req)

1858

usb_ep_free_request(ep, req);

1859

usb_ep_free_request(ep, req);

1859

}

1860

}

1860

1861

static char rndis_resp_buf[8] __attribute__((aligned(sizeof(__le32))));

1862

static char rndis_resp_buf[8] __attribute__((aligned(sizeof(__le32))));

1862

1863

static int rndis_control_ack(struct eth_device *net)

1864

static int rndis_control_ack(struct eth_device *net)

1864

{

1865

{

1865

struct eth_dev *dev = &l_ethdev;

1866

struct eth_dev *dev = &l_ethdev;

1866

int length;

1867

int length;

1867

struct usb_request *resp = dev->stat_req;

1868

struct usb_request *resp = dev->stat_req;

1868

1869

/* in case RNDIS calls this after disconnect */

1870

/* in case RNDIS calls this after disconnect */

1870

if (!dev->status) {

1871

if (!dev->status) {

1871

debug("status ENODEV\n");

1872

debug("status ENODEV\n");

1872

return -ENODEV;

1873

return -ENODEV;

1873

}

1874

}

1874

1875

/* in case queue length > 1 */

1876

/* in case queue length > 1 */

1876

if (resp->context) {

1877

if (resp->context) {

1877

resp = usb_ep_alloc_request(dev->status_ep, GFP_ATOMIC);

1878

resp = usb_ep_alloc_request(dev->status_ep, GFP_ATOMIC);

1878

if (!resp)

1879

if (!resp)

1879

return -ENOMEM;

1880

return -ENOMEM;

1880

resp->buf = rndis_resp_buf;

1881

resp->buf = rndis_resp_buf;

1881

}

1882

}

1882

1883

/*

1884

/*

1884

* Send RNDIS RESPONSE_AVAILABLE notification;

1885

* Send RNDIS RESPONSE_AVAILABLE notification;

1885

* USB_CDC_NOTIFY_RESPONSE_AVAILABLE should work too

1886

* USB_CDC_NOTIFY_RESPONSE_AVAILABLE should work too

1886

*/

1887

*/

1887

resp->length = 8;

1888

resp->length = 8;

1888

resp->complete = rndis_control_ack_complete;

1889

resp->complete = rndis_control_ack_complete;

1889

resp->context = dev;

1890

resp->context = dev;

1890

1891

*((__le32 *) resp->buf) = __constant_cpu_to_le32(1);

1892

*((__le32 *) resp->buf) = __constant_cpu_to_le32(1);

1892

*((__le32 *) (resp->buf + 4)) = __constant_cpu_to_le32(0);

1893

*((__le32 *) (resp->buf + 4)) = __constant_cpu_to_le32(0);

1893

1894

length = usb_ep_queue(dev->status_ep, resp, GFP_ATOMIC);

1895

length = usb_ep_queue(dev->status_ep, resp, GFP_ATOMIC);

1895

if (length < 0) {

1896

if (length < 0) {

1896

resp->status = 0;

1897

resp->status = 0;

1897

rndis_control_ack_complete(dev->status_ep, resp);

1898

rndis_control_ack_complete(dev->status_ep, resp);

1898

}

1899

}

1899

1900

return 0;

1901

return 0;

1901

}

1902

}

1902

1903

#else

1904

#else

1904

1905

#define rndis_control_ack NULL

1906

#define rndis_control_ack NULL

1906

1907

#endif /* RNDIS */

1908

#endif /* RNDIS */

1908

1909

static void eth_start(struct eth_dev *dev, gfp_t gfp_flags)

1910

static void eth_start(struct eth_dev *dev, gfp_t gfp_flags)

1910

{

1911

{

1911

if (rndis_active(dev)) {

1912

if (rndis_active(dev)) {

1912

rndis_set_param_medium(dev->rndis_config,

1913

rndis_set_param_medium(dev->rndis_config,

1913

NDIS_MEDIUM_802_3,

1914

NDIS_MEDIUM_802_3,

1914

BITRATE(dev->gadget)/100);

1915

BITRATE(dev->gadget)/100);

1915

rndis_signal_connect(dev->rndis_config);

1916

rndis_signal_connect(dev->rndis_config);

1916

}

1917

}

1917

}

1918

}

1918

1919

static int eth_stop(struct eth_dev *dev)

1920

static int eth_stop(struct eth_dev *dev)

1920

{

1921

{

1921

#ifdef RNDIS_COMPLETE_SIGNAL_DISCONNECT

1922

#ifdef RNDIS_COMPLETE_SIGNAL_DISCONNECT

1922

unsigned long ts;

1923

unsigned long ts;

1923

unsigned long timeout = CONFIG_SYS_HZ; /* 1 sec to stop RNDIS */

1924

unsigned long timeout = CONFIG_SYS_HZ; /* 1 sec to stop RNDIS */

1924

#endif

1925

#endif

1925

1926

if (rndis_active(dev)) {

1927

if (rndis_active(dev)) {

1927

rndis_set_param_medium(dev->rndis_config, NDIS_MEDIUM_802_3, 0);

1928

rndis_set_param_medium(dev->rndis_config, NDIS_MEDIUM_802_3, 0);

1928

rndis_signal_disconnect(dev->rndis_config);

1929

rndis_signal_disconnect(dev->rndis_config);

1929

1930

#ifdef RNDIS_COMPLETE_SIGNAL_DISCONNECT

1931

#ifdef RNDIS_COMPLETE_SIGNAL_DISCONNECT

1931

/* Wait until host receives OID_GEN_MEDIA_CONNECT_STATUS */

1932

/* Wait until host receives OID_GEN_MEDIA_CONNECT_STATUS */

1932

ts = get_timer(0);

1933

ts = get_timer(0);

1933

while (get_timer(ts) < timeout)

1934

while (get_timer(ts) < timeout)

1934

usb_gadget_handle_interrupts();

1935

usb_gadget_handle_interrupts();

1935

#endif

1936

#endif

1936

1937

rndis_uninit(dev->rndis_config);

1938

rndis_uninit(dev->rndis_config);

1938

dev->rndis = 0;

1939

dev->rndis = 0;

1939

}

1940

}

1940

1941

return 0;

1942

return 0;

1942

}

1943

}

1943

1944

/*-------------------------------------------------------------------------*/

1945

/*-------------------------------------------------------------------------*/

1945

1946

static int is_eth_addr_valid(char *str)

1947

static int is_eth_addr_valid(char *str)

1947

{

1948

{

1948

if (strlen(str) == 17) {

1949

if (strlen(str) == 17) {

1949

int i;

1950

int i;

1950

char *p, *q;

1951

char *p, *q;

1951

uchar ea[6];

1952

uchar ea[6];

1952

1953

/* see if it looks like an ethernet address */

1954

/* see if it looks like an ethernet address */

1954

1955

p = str;

1956

p = str;

1956

1957

for (i = 0; i < 6; i++) {

1958

for (i = 0; i < 6; i++) {

1958

char term = (i == 5 ? '\0' : ':');

1959

char term = (i == 5 ? '\0' : ':');

1959

1960

ea[i] = simple_strtol(p, &q, 16);

1961

ea[i] = simple_strtol(p, &q, 16);

1961

1962

if ((q - p) != 2 || *q++ != term)

1963

if ((q - p) != 2 || *q++ != term)

1963

break;

1964

break;

1964

1965

p = q;

1966

p = q;

1966

}

1967

}

1967

1968

/* Now check the contents. */

1969

/* Now check the contents. */

1969

return is_valid_ether_addr(ea);

1970

return is_valid_ether_addr(ea);

1970

}

1971

}

1971

return 0;

1972

return 0;

1972

}

1973

}

1973

1974

static u8 nibble(unsigned char c)

1975

static u8 nibble(unsigned char c)

1975

{

1976

{

1976

if (likely(isdigit(c)))

1977

if (likely(isdigit(c)))

1977

return c - '0';

1978

return c - '0';

1978

c = toupper(c);

1979

c = toupper(c);

1979

if (likely(isxdigit(c)))

1980

if (likely(isxdigit(c)))

1980

return 10 + c - 'A';

1981

return 10 + c - 'A';

1981

return 0;

1982

return 0;

1982

}

1983

}

1983

1984

static int get_ether_addr(const char *str, u8 *dev_addr)

1985

static int get_ether_addr(const char *str, u8 *dev_addr)

1985

{

1986

{

1986

if (str) {

1987

if (str) {

1987

unsigned i;

1988

unsigned i;

1988

1989

for (i = 0; i < 6; i++) {

1990

for (i = 0; i < 6; i++) {

1990

unsigned char num;

1991

unsigned char num;

1991

1992

if ((*str == '.') || (*str == ':'))

1993

if ((*str == '.') || (*str == ':'))

1993

str++;

1994

str++;

1994

num = nibble(*str++) << 4;

1995

num = nibble(*str++) << 4;

1995

num |= (nibble(*str++));

1996

num |= (nibble(*str++));

1996

dev_addr[i] = num;

1997

dev_addr[i] = num;

1997

}

1998

}

1998

if (is_valid_ether_addr(dev_addr))

1999

if (is_valid_ether_addr(dev_addr))

1999

return 0;

2000

return 0;

2000

}

2001

}

2001

return 1;

2002

return 1;

2002

}

2003

}

2003

2004

static int eth_bind(struct usb_gadget *gadget)

2005

static int eth_bind(struct usb_gadget *gadget)

2005

{

2006

{

2006

struct eth_dev *dev = &l_ethdev;

2007

struct eth_dev *dev = &l_ethdev;

2007

u8 cdc = 1, zlp = 1, rndis = 1;

2008

u8 cdc = 1, zlp = 1, rndis = 1;

2008

struct usb_ep *in_ep, *out_ep, *status_ep = NULL;

2009

struct usb_ep *in_ep, *out_ep, *status_ep = NULL;

2009

int status = -ENOMEM;

2010

int status = -ENOMEM;

2010

int gcnum;

2011

int gcnum;

2011

u8 tmp[7];

2012

u8 tmp[7];

2012

2013

/* these flags are only ever cleared; compiler take note */

2014

/* these flags are only ever cleared; compiler take note */

2014

#ifndef CONFIG_USB_ETH_CDC

2015

#ifndef CONFIG_USB_ETH_CDC

2015

cdc = 0;

2016

cdc = 0;

2016

#endif

2017

#endif

2017

#ifndef CONFIG_USB_ETH_RNDIS

2018

#ifndef CONFIG_USB_ETH_RNDIS

2018

rndis = 0;

2019

rndis = 0;

2019

#endif

2020

#endif

2020

/*

2021

/*

2021

* Because most host side USB stacks handle CDC Ethernet, that

2022

* Because most host side USB stacks handle CDC Ethernet, that

2022

* standard protocol is _strongly_ preferred for interop purposes.

2023

* standard protocol is _strongly_ preferred for interop purposes.

2023

* (By everyone except Microsoft.)

2024

* (By everyone except Microsoft.)

2024

*/

2025

*/

2025

if (gadget_is_pxa(gadget)) {

2026

if (gadget_is_pxa(gadget)) {

2026

/* pxa doesn't support altsettings */

2027

/* pxa doesn't support altsettings */

2027

cdc = 0;

2028

cdc = 0;

2028

} else if (gadget_is_musbhdrc(gadget)) {

2029

} else if (gadget_is_musbhdrc(gadget)) {

2029

/* reduce tx dma overhead by avoiding special cases */

2030

/* reduce tx dma overhead by avoiding special cases */

2030

zlp = 0;

2031

zlp = 0;

2031

} else if (gadget_is_sh(gadget)) {

2032

} else if (gadget_is_sh(gadget)) {

2032

/* sh doesn't support multiple interfaces or configs */

2033

/* sh doesn't support multiple interfaces or configs */

2033

cdc = 0;

2034

cdc = 0;

2034

rndis = 0;

2035

rndis = 0;

2035

} else if (gadget_is_sa1100(gadget)) {

2036

} else if (gadget_is_sa1100(gadget)) {

2036

/* hardware can't write zlps */

2037

/* hardware can't write zlps */

2037

zlp = 0;

2038

zlp = 0;

2038

/*

2039

/*

2039

* sa1100 CAN do CDC, without status endpoint ... we use

2040

* sa1100 CAN do CDC, without status endpoint ... we use

2040

* non-CDC to be compatible with ARM Linux-2.4 "usb-eth".

2041

* non-CDC to be compatible with ARM Linux-2.4 "usb-eth".

2041

*/

2042

*/

2042

cdc = 0;

2043

cdc = 0;

2043

}

2044

}

2044

2045

gcnum = usb_gadget_controller_number(gadget);

2046

gcnum = usb_gadget_controller_number(gadget);

2046

if (gcnum >= 0)

2047

if (gcnum >= 0)

2047

device_desc.bcdDevice = cpu_to_le16(0x0300 + gcnum);

2048

device_desc.bcdDevice = cpu_to_le16(0x0300 + gcnum);

2048

else {

2049

else {

2049

/*

2050

/*

2050

* can't assume CDC works. don't want to default to

2051

* can't assume CDC works. don't want to default to

2051

* anything less functional on CDC-capable hardware,

2052

* anything less functional on CDC-capable hardware,

2052

* so we fail in this case.

2053

* so we fail in this case.

2053

*/

2054

*/

2054

error("controller '%s' not recognized",

2055

error("controller '%s' not recognized",

2055

gadget->name);

2056

gadget->name);

2056

return -ENODEV;

2057

return -ENODEV;

2057

}

2058

}

2058

2059

/*

2060

/*

2060

* If there's an RNDIS configuration, that's what Windows wants to

2061

* If there's an RNDIS configuration, that's what Windows wants to

2061

* be using ... so use these product IDs here and in the "linux.inf"

2062

* be using ... so use these product IDs here and in the "linux.inf"

2062

* needed to install MSFT drivers. Current Linux kernels will use

2063

* needed to install MSFT drivers. Current Linux kernels will use

2063

* the second configuration if it's CDC Ethernet, and need some help

2064

* the second configuration if it's CDC Ethernet, and need some help

2064

* to choose the right configuration otherwise.

2065

* to choose the right configuration otherwise.

2065

*/

2066

*/

2066

if (rndis) {

2067

if (rndis) {

2067

#if defined(CONFIG_USB_RNDIS_VENDOR_ID) && defined(CONFIG_USB_RNDIS_PRODUCT_ID)

2068

#if defined(CONFIG_USB_RNDIS_VENDOR_ID) && defined(CONFIG_USB_RNDIS_PRODUCT_ID)

2068

device_desc.idVendor =

2069

device_desc.idVendor =

2069

__constant_cpu_to_le16(CONFIG_USB_RNDIS_VENDOR_ID);

2070

__constant_cpu_to_le16(CONFIG_USB_RNDIS_VENDOR_ID);

2070

device_desc.idProduct =

2071

device_desc.idProduct =

2071

__constant_cpu_to_le16(CONFIG_USB_RNDIS_PRODUCT_ID);

2072

__constant_cpu_to_le16(CONFIG_USB_RNDIS_PRODUCT_ID);

2072

#else

2073

#else

2073

device_desc.idVendor =

2074

device_desc.idVendor =

2074

__constant_cpu_to_le16(RNDIS_VENDOR_NUM);

2075

__constant_cpu_to_le16(RNDIS_VENDOR_NUM);

2075

device_desc.idProduct =

2076

device_desc.idProduct =

2076

__constant_cpu_to_le16(RNDIS_PRODUCT_NUM);

2077

__constant_cpu_to_le16(RNDIS_PRODUCT_NUM);

2077

#endif

2078

#endif

2078

sprintf(product_desc, "RNDIS/%s", driver_desc);

2079

sprintf(product_desc, "RNDIS/%s", driver_desc);

2079

2080

/*

2081

/*

2081

* CDC subset ... recognized by Linux since 2.4.10, but Windows

2082

* CDC subset ... recognized by Linux since 2.4.10, but Windows

2082

* drivers aren't widely available. (That may be improved by

2083

* drivers aren't widely available. (That may be improved by

2083

* supporting one submode of the "SAFE" variant of MDLM.)

2084

* supporting one submode of the "SAFE" variant of MDLM.)

2084

*/

2085

*/

2085

} else {

2086

} else {

2086

#if defined(CONFIG_USB_CDC_VENDOR_ID) && defined(CONFIG_USB_CDC_PRODUCT_ID)

2087

#if defined(CONFIG_USB_CDC_VENDOR_ID) && defined(CONFIG_USB_CDC_PRODUCT_ID)

2087

device_desc.idVendor = cpu_to_le16(CONFIG_USB_CDC_VENDOR_ID);

2088

device_desc.idVendor = cpu_to_le16(CONFIG_USB_CDC_VENDOR_ID);

2088

device_desc.idProduct = cpu_to_le16(CONFIG_USB_CDC_PRODUCT_ID);

2089

device_desc.idProduct = cpu_to_le16(CONFIG_USB_CDC_PRODUCT_ID);

2089

#else

2090

#else

2090

if (!cdc) {

2091

if (!cdc) {

2091

device_desc.idVendor =

2092

device_desc.idVendor =

2092

__constant_cpu_to_le16(SIMPLE_VENDOR_NUM);

2093

__constant_cpu_to_le16(SIMPLE_VENDOR_NUM);

2093

device_desc.idProduct =

2094

device_desc.idProduct =

2094

__constant_cpu_to_le16(SIMPLE_PRODUCT_NUM);

2095

__constant_cpu_to_le16(SIMPLE_PRODUCT_NUM);

2095

}

2096

}

2096

#endif

2097

#endif

2097

}

2098

}

2098

/* support optional vendor/distro customization */

2099

/* support optional vendor/distro customization */

2099

if (bcdDevice)

2100

if (bcdDevice)

2100

device_desc.bcdDevice = cpu_to_le16(bcdDevice);

2101

device_desc.bcdDevice = cpu_to_le16(bcdDevice);

2101

if (iManufacturer)

2102

if (iManufacturer)

2102

strlcpy(manufacturer, iManufacturer, sizeof manufacturer);

2103

strlcpy(manufacturer, iManufacturer, sizeof manufacturer);

2103

if (iProduct)

2104

if (iProduct)

2104

strlcpy(product_desc, iProduct, sizeof product_desc);

2105

strlcpy(product_desc, iProduct, sizeof product_desc);

2105

if (iSerialNumber) {

2106

if (iSerialNumber) {

2106

device_desc.iSerialNumber = STRING_SERIALNUMBER,

2107

device_desc.iSerialNumber = STRING_SERIALNUMBER,

2107

strlcpy(serial_number, iSerialNumber, sizeof serial_number);

2108

strlcpy(serial_number, iSerialNumber, sizeof serial_number);

2108

}

2109

}

2109

2110

/* all we really need is bulk IN/OUT */

2111

/* all we really need is bulk IN/OUT */

2111

usb_ep_autoconfig_reset(gadget);

2112

usb_ep_autoconfig_reset(gadget);

2112

in_ep = usb_ep_autoconfig(gadget, &fs_source_desc);

2113

in_ep = usb_ep_autoconfig(gadget, &fs_source_desc);

2113

if (!in_ep) {

2114

if (!in_ep) {

2114

autoconf_fail:

2115

autoconf_fail:

2115

error("can't autoconfigure on %s\n",

2116

error("can't autoconfigure on %s\n",

2116

gadget->name);

2117

gadget->name);

2117

return -ENODEV;

2118

return -ENODEV;

2118

}

2119

}

2119

in_ep->driver_data = in_ep; /* claim */

2120

in_ep->driver_data = in_ep; /* claim */

2120

2121

out_ep = usb_ep_autoconfig(gadget, &fs_sink_desc);

2122

out_ep = usb_ep_autoconfig(gadget, &fs_sink_desc);

2122

if (!out_ep)

2123

if (!out_ep)

2123

goto autoconf_fail;

2124

goto autoconf_fail;

2124

out_ep->driver_data = out_ep; /* claim */

2125

out_ep->driver_data = out_ep; /* claim */

2125

2126

#if defined(CONFIG_USB_ETH_CDC) || defined(CONFIG_USB_ETH_RNDIS)

2127

#if defined(CONFIG_USB_ETH_CDC) || defined(CONFIG_USB_ETH_RNDIS)

2127

/*

2128

/*

2128

* CDC Ethernet control interface doesn't require a status endpoint.

2129

* CDC Ethernet control interface doesn't require a status endpoint.

2129

* Since some hosts expect one, try to allocate one anyway.

2130

* Since some hosts expect one, try to allocate one anyway.

2130

*/

2131

*/

2131

if (cdc || rndis) {

2132

if (cdc || rndis) {

2132

status_ep = usb_ep_autoconfig(gadget, &fs_status_desc);

2133

status_ep = usb_ep_autoconfig(gadget, &fs_status_desc);

2133

if (status_ep) {

2134

if (status_ep) {

2134

status_ep->driver_data = status_ep; /* claim */

2135

status_ep->driver_data = status_ep; /* claim */

2135

} else if (rndis) {

2136

} else if (rndis) {

2136

error("can't run RNDIS on %s", gadget->name);

2137

error("can't run RNDIS on %s", gadget->name);

2137

return -ENODEV;

2138

return -ENODEV;

2138

#ifdef CONFIG_USB_ETH_CDC

2139

#ifdef CONFIG_USB_ETH_CDC

2139

} else if (cdc) {

2140

} else if (cdc) {

2140

control_intf.bNumEndpoints = 0;

2141

control_intf.bNumEndpoints = 0;

2141

/* FIXME remove endpoint from descriptor list */

2142

/* FIXME remove endpoint from descriptor list */

2142

#endif

2143

#endif

2143

}

2144

}

2144

}

2145

}

2145

#endif

2146

#endif

2146

2147

/* one config: cdc, else minimal subset */

2148

/* one config: cdc, else minimal subset */

2148

if (!cdc) {

2149

if (!cdc) {

2149

eth_config.bNumInterfaces = 1;

2150

eth_config.bNumInterfaces = 1;

2150

eth_config.iConfiguration = STRING_SUBSET;

2151

eth_config.iConfiguration = STRING_SUBSET;

2151

2152

/*

2153

/*

2153

* use functions to set these up, in case we're built to work

2154

* use functions to set these up, in case we're built to work

2154

* with multiple controllers and must override CDC Ethernet.

2155

* with multiple controllers and must override CDC Ethernet.

2155

*/

2156

*/

2156

fs_subset_descriptors();

2157

fs_subset_descriptors();

2157

hs_subset_descriptors();

2158

hs_subset_descriptors();

2158

}

2159

}

2159

2160

device_desc.bMaxPacketSize0 = gadget->ep0->maxpacket;

2161

device_desc.bMaxPacketSize0 = gadget->ep0->maxpacket;

2161

usb_gadget_set_selfpowered(gadget);

2162

usb_gadget_set_selfpowered(gadget);

2162

2163

/* For now RNDIS is always a second config */

2164

/* For now RNDIS is always a second config */

2164

if (rndis)

2165

if (rndis)

2165

device_desc.bNumConfigurations = 2;

2166

device_desc.bNumConfigurations = 2;

2166

2167

if (gadget_is_dualspeed(gadget)) {

2168

if (gadget_is_dualspeed(gadget)) {

2168

if (rndis)

2169

if (rndis)

2169

dev_qualifier.bNumConfigurations = 2;

2170

dev_qualifier.bNumConfigurations = 2;

2170

else if (!cdc)

2171

else if (!cdc)

2171

dev_qualifier.bDeviceClass = USB_CLASS_VENDOR_SPEC;

2172

dev_qualifier.bDeviceClass = USB_CLASS_VENDOR_SPEC;

2172

2173

/* assumes ep0 uses the same value for both speeds ... */

2174

/* assumes ep0 uses the same value for both speeds ... */

2174

dev_qualifier.bMaxPacketSize0 = device_desc.bMaxPacketSize0;

2175

dev_qualifier.bMaxPacketSize0 = device_desc.bMaxPacketSize0;

2175

2176

/* and that all endpoints are dual-speed */

2177

/* and that all endpoints are dual-speed */

2177

hs_source_desc.bEndpointAddress =

2178

hs_source_desc.bEndpointAddress =

2178

fs_source_desc.bEndpointAddress;

2179

fs_source_desc.bEndpointAddress;

2179

hs_sink_desc.bEndpointAddress =

2180

hs_sink_desc.bEndpointAddress =

2180

fs_sink_desc.bEndpointAddress;

2181

fs_sink_desc.bEndpointAddress;

2181

#if defined(CONFIG_USB_ETH_CDC) || defined(CONFIG_USB_ETH_RNDIS)

2182

#if defined(CONFIG_USB_ETH_CDC) || defined(CONFIG_USB_ETH_RNDIS)

2182

if (status_ep)

2183

if (status_ep)

2183

hs_status_desc.bEndpointAddress =

2184

hs_status_desc.bEndpointAddress =

2184

fs_status_desc.bEndpointAddress;

2185

fs_status_desc.bEndpointAddress;

2185

#endif

2186

#endif

2186

}

2187

}

2187

2188

if (gadget_is_otg(gadget)) {

2189

if (gadget_is_otg(gadget)) {

2189

otg_descriptor.bmAttributes |= USB_OTG_HNP,

2190

otg_descriptor.bmAttributes |= USB_OTG_HNP,

2190

eth_config.bmAttributes |= USB_CONFIG_ATT_WAKEUP;

2191

eth_config.bmAttributes |= USB_CONFIG_ATT_WAKEUP;

2191

eth_config.bMaxPower = 4;

2192

eth_config.bMaxPower = 4;

2192

#ifdef CONFIG_USB_ETH_RNDIS

2193

#ifdef CONFIG_USB_ETH_RNDIS

2193

rndis_config.bmAttributes |= USB_CONFIG_ATT_WAKEUP;

2194

rndis_config.bmAttributes |= USB_CONFIG_ATT_WAKEUP;

2194

rndis_config.bMaxPower = 4;

2195

rndis_config.bMaxPower = 4;

2195

#endif

2196

#endif

2196

}

2197

}

2197

2198

2199

/* network device setup */

2200

/* network device setup */

2200

dev->net = &l_netdev;

2201

dev->net = &l_netdev;

2201

2202

dev->cdc = cdc;

2203

dev->cdc = cdc;

2203

dev->zlp = zlp;

2204

dev->zlp = zlp;

2204

2205

dev->in_ep = in_ep;

2206

dev->in_ep = in_ep;

2206

dev->out_ep = out_ep;

2207

dev->out_ep = out_ep;

2207

dev->status_ep = status_ep;

2208

dev->status_ep = status_ep;

2208

2209

/*

2210

/*

2210

* Module params for these addresses should come from ID proms.

2211

* Module params for these addresses should come from ID proms.

2211

* The host side address is used with CDC and RNDIS, and commonly

2212

* The host side address is used with CDC and RNDIS, and commonly

2212

* ends up in a persistent config database. It's not clear if

2213

* ends up in a persistent config database. It's not clear if

2213

* host side code for the SAFE thing cares -- its original BLAN

2214

* host side code for the SAFE thing cares -- its original BLAN

2214

* thing didn't, Sharp never assigned those addresses on Zaurii.

2215

* thing didn't, Sharp never assigned those addresses on Zaurii.

2215

*/

2216

*/

2216

get_ether_addr(dev_addr, dev->net->enetaddr);

2217

get_ether_addr(dev_addr, dev->net->enetaddr);

2217

2218

memset(tmp, 0, sizeof(tmp));

2219

memset(tmp, 0, sizeof(tmp));

2219

memcpy(tmp, dev->net->enetaddr, sizeof(dev->net->enetaddr));

2220

memcpy(tmp, dev->net->enetaddr, sizeof(dev->net->enetaddr));

2220

2221

get_ether_addr(host_addr, dev->host_mac);

2222

get_ether_addr(host_addr, dev->host_mac);

2222

2223

sprintf(ethaddr, "%02X%02X%02X%02X%02X%02X",

2224

sprintf(ethaddr, "%02X%02X%02X%02X%02X%02X",

2224

dev->host_mac[0], dev->host_mac[1],

2225

dev->host_mac[0], dev->host_mac[1],

2225

dev->host_mac[2], dev->host_mac[3],

2226

dev->host_mac[2], dev->host_mac[3],

2226

dev->host_mac[4], dev->host_mac[5]);

2227

dev->host_mac[4], dev->host_mac[5]);

2227

2228

if (rndis) {

2229

if (rndis) {

2229

status = rndis_init();

2230

status = rndis_init();

2230

if (status < 0) {

2231

if (status < 0) {

2231

error("can't init RNDIS, %d", status);

2232

error("can't init RNDIS, %d", status);

2232

goto fail;

2233

goto fail;

2233

}

2234

}

2234

}

2235

}

2235

2236

/*

2237

/*

2237

* use PKTSIZE (or aligned... from u-boot) and set

2238

* use PKTSIZE (or aligned... from u-boot) and set

2238

* wMaxSegmentSize accordingly

2239

* wMaxSegmentSize accordingly

2239

*/

2240

*/

2240

dev->mtu = PKTSIZE_ALIGN; /* RNDIS does not like this, only 1514, TODO*/

2241

dev->mtu = PKTSIZE_ALIGN; /* RNDIS does not like this, only 1514, TODO*/

2241

2242

/* preallocate control message data and buffer */

2243

/* preallocate control message data and buffer */

2243

dev->req = usb_ep_alloc_request(gadget->ep0, GFP_KERNEL);

2244

dev->req = usb_ep_alloc_request(gadget->ep0, GFP_KERNEL);

2244

if (!dev->req)

2245

if (!dev->req)

2245

goto fail;

2246

goto fail;

2246

dev->req->buf = control_req;

2247

dev->req->buf = control_req;

2247

dev->req->complete = eth_setup_complete;

2248

dev->req->complete = eth_setup_complete;

2248

2249

/* ... and maybe likewise for status transfer */

2250

/* ... and maybe likewise for status transfer */

2250

#if defined(CONFIG_USB_ETH_CDC) || defined(CONFIG_USB_ETH_RNDIS)

2251

#if defined(CONFIG_USB_ETH_CDC) || defined(CONFIG_USB_ETH_RNDIS)

2251

if (dev->status_ep) {

2252

if (dev->status_ep) {

2252

dev->stat_req = usb_ep_alloc_request(dev->status_ep,

2253

dev->stat_req = usb_ep_alloc_request(dev->status_ep,

2253

GFP_KERNEL);

2254

GFP_KERNEL);

2254

if (!dev->stat_req) {

2255

if (!dev->stat_req) {

2255

usb_ep_free_request(dev->status_ep, dev->req);

2256

usb_ep_free_request(dev->status_ep, dev->req);

2256

2257

goto fail;

2258

goto fail;

2258

}

2259

}

2259

dev->stat_req->buf = status_req;

2260

dev->stat_req->buf = status_req;

2260

dev->stat_req->context = NULL;

2261

dev->stat_req->context = NULL;

2261

}

2262

}

2262

#endif

2263

#endif

2263

2264

/* finish hookup to lower layer ... */

2265

/* finish hookup to lower layer ... */

2265

dev->gadget = gadget;

2266

dev->gadget = gadget;

2266

set_gadget_data(gadget, dev);

2267

set_gadget_data(gadget, dev);

2267

gadget->ep0->driver_data = dev;

2268

gadget->ep0->driver_data = dev;

2268

2269

/*

2270

/*

2270

* two kinds of host-initiated state changes:

2271

* two kinds of host-initiated state changes:

2271

* - iff DATA transfer is active, carrier is "on"

2272

* - iff DATA transfer is active, carrier is "on"

2272

* - tx queueing enabled if open *and* carrier is "on"

2273

* - tx queueing enabled if open *and* carrier is "on"

2273

*/

2274

*/

2274

2275

printf("using %s, OUT %s IN %s%s%s\n", gadget->name,

2276

printf("using %s, OUT %s IN %s%s%s\n", gadget->name,

2276

out_ep->name, in_ep->name,

2277

out_ep->name, in_ep->name,

2277

status_ep ? " STATUS " : "",

2278

status_ep ? " STATUS " : "",

2278

status_ep ? status_ep->name : ""

2279

status_ep ? status_ep->name : ""

2279

);

2280

);

2280

printf("MAC %02x:%02x:%02x:%02x:%02x:%02x\n",

2281

printf("MAC %02x:%02x:%02x:%02x:%02x:%02x\n",

2281

dev->net->enetaddr[0], dev->net->enetaddr[1],

2282

dev->net->enetaddr[0], dev->net->enetaddr[1],

2282

dev->net->enetaddr[2], dev->net->enetaddr[3],

2283

dev->net->enetaddr[2], dev->net->enetaddr[3],

2283

dev->net->enetaddr[4], dev->net->enetaddr[5]);

2284

dev->net->enetaddr[4], dev->net->enetaddr[5]);

2284

2285

if (cdc || rndis)

2286

if (cdc || rndis)

2286

printf("HOST MAC %02x:%02x:%02x:%02x:%02x:%02x\n",

2287

printf("HOST MAC %02x:%02x:%02x:%02x:%02x:%02x\n",

2287

dev->host_mac[0], dev->host_mac[1],

2288

dev->host_mac[0], dev->host_mac[1],

2288

dev->host_mac[2], dev->host_mac[3],

2289

dev->host_mac[2], dev->host_mac[3],

2289

dev->host_mac[4], dev->host_mac[5]);

2290

dev->host_mac[4], dev->host_mac[5]);

2290

2291

if (rndis) {

2292

if (rndis) {

2292

u32 vendorID = 0;

2293

u32 vendorID = 0;

2293

2294

/* FIXME RNDIS vendor id == "vendor NIC code" == ? */

2295

/* FIXME RNDIS vendor id == "vendor NIC code" == ? */

2295

2296

dev->rndis_config = rndis_register(rndis_control_ack);

2297

dev->rndis_config = rndis_register(rndis_control_ack);

2297

if (dev->rndis_config < 0) {

2298

if (dev->rndis_config < 0) {

2298

fail0:

2299

fail0:

2299

eth_unbind(gadget);

2300

eth_unbind(gadget);

2300

debug("RNDIS setup failed\n");

2301

debug("RNDIS setup failed\n");

2301

status = -ENODEV;

2302

status = -ENODEV;

2302

goto fail;

2303

goto fail;

2303

}

2304

}

2304

2305

/* these set up a lot of the OIDs that RNDIS needs */

2306

/* these set up a lot of the OIDs that RNDIS needs */

2306

rndis_set_host_mac(dev->rndis_config, dev->host_mac);

2307

rndis_set_host_mac(dev->rndis_config, dev->host_mac);

2307

if (rndis_set_param_dev(dev->rndis_config, dev->net, dev->mtu,

2308

if (rndis_set_param_dev(dev->rndis_config, dev->net, dev->mtu,

2308

&dev->stats, &dev->cdc_filter))

2309

&dev->stats, &dev->cdc_filter))

2309

goto fail0;

2310

goto fail0;

2310

if (rndis_set_param_vendor(dev->rndis_config, vendorID,

2311

if (rndis_set_param_vendor(dev->rndis_config, vendorID,

2311

manufacturer))

2312

manufacturer))

2312

goto fail0;

2313

goto fail0;

2313

if (rndis_set_param_medium(dev->rndis_config,

2314

if (rndis_set_param_medium(dev->rndis_config,

2314

NDIS_MEDIUM_802_3, 0))

2315

NDIS_MEDIUM_802_3, 0))

2315

goto fail0;

2316

goto fail0;

2316

printf("RNDIS ready\n");

2317

printf("RNDIS ready\n");

2317

}

2318

}

2318

return 0;

2319

return 0;

2319

2320

fail:

2321

fail:

2321

error("%s failed, status = %d", __func__, status);

2322

error("%s failed, status = %d", __func__, status);

2322

eth_unbind(gadget);

2323

eth_unbind(gadget);

2323

return status;

2324

return status;

2324

}

2325

}

2325

2326

/*-------------------------------------------------------------------------*/

2327

/*-------------------------------------------------------------------------*/

2327

2328

static int usb_eth_init(struct eth_device *netdev, bd_t *bd)

2329

static int usb_eth_init(struct eth_device *netdev, bd_t *bd)

2329

{

2330

{

2330

struct eth_dev *dev = &l_ethdev;

2331

struct eth_dev *dev = &l_ethdev;

2331

struct usb_gadget *gadget;

2332

struct usb_gadget *gadget;

2332

unsigned long ts;

2333

unsigned long ts;

2333

unsigned long timeout = USB_CONNECT_TIMEOUT;

2334

unsigned long timeout = USB_CONNECT_TIMEOUT;

2334

2335

if (!netdev) {

2336

if (!netdev) {

2336

error("received NULL ptr");

2337

error("received NULL ptr");

2337

goto fail;

2338

goto fail;

2338

}

2339

}

2339

2340

/* Configure default mac-addresses for the USB ethernet device */

2341

/* Configure default mac-addresses for the USB ethernet device */

2341

#ifdef CONFIG_USBNET_DEV_ADDR

2342

#ifdef CONFIG_USBNET_DEV_ADDR

2342

strlcpy(dev_addr, CONFIG_USBNET_DEV_ADDR, sizeof(dev_addr));

2343

strlcpy(dev_addr, CONFIG_USBNET_DEV_ADDR, sizeof(dev_addr));

2343

#endif

2344

#endif

2344

#ifdef CONFIG_USBNET_HOST_ADDR

2345

#ifdef CONFIG_USBNET_HOST_ADDR

2345

strlcpy(host_addr, CONFIG_USBNET_HOST_ADDR, sizeof(host_addr));

2346

strlcpy(host_addr, CONFIG_USBNET_HOST_ADDR, sizeof(host_addr));

2346

#endif

2347

#endif

2347

/* Check if the user overruled the MAC addresses */

2348

/* Check if the user overruled the MAC addresses */

2348

if (getenv("usbnet_devaddr"))

2349

if (getenv("usbnet_devaddr"))

2349

strlcpy(dev_addr, getenv("usbnet_devaddr"),

2350

strlcpy(dev_addr, getenv("usbnet_devaddr"),

2350

sizeof(dev_addr));

2351

sizeof(dev_addr));

2351

2352

if (getenv("usbnet_hostaddr"))

2353

if (getenv("usbnet_hostaddr"))

2353

strlcpy(host_addr, getenv("usbnet_hostaddr"),

2354

strlcpy(host_addr, getenv("usbnet_hostaddr"),

2354

sizeof(host_addr));

2355

sizeof(host_addr));

2355

2356

if (!is_eth_addr_valid(dev_addr)) {

2357

if (!is_eth_addr_valid(dev_addr)) {

2357

error("Need valid 'usbnet_devaddr' to be set");

2358

error("Need valid 'usbnet_devaddr' to be set");

2358

goto fail;

2359

goto fail;

2359

}

2360

}

2360

if (!is_eth_addr_valid(host_addr)) {

2361

if (!is_eth_addr_valid(host_addr)) {

2361

error("Need valid 'usbnet_hostaddr' to be set");

2362

error("Need valid 'usbnet_hostaddr' to be set");

2362

goto fail;

2363

goto fail;

2363

}

2364

}

2364

2365

if (usb_gadget_register_driver(&eth_driver) < 0)

2366

if (usb_gadget_register_driver(&eth_driver) < 0)

2366

goto fail;

2367

goto fail;

2367

2368

dev->network_started = 0;

2369

dev->network_started = 0;

2369

2370

packet_received = 0;

2371

packet_received = 0;

2371

packet_sent = 0;

2372

packet_sent = 0;

2372

2373

gadget = dev->gadget;

2374

gadget = dev->gadget;

2374

usb_gadget_connect(gadget);

2375

usb_gadget_connect(gadget);

2375

2376

if (getenv("cdc_connect_timeout"))

2377

if (getenv("cdc_connect_timeout"))

2377

timeout = simple_strtoul(getenv("cdc_connect_timeout"),

2378

timeout = simple_strtoul(getenv("cdc_connect_timeout"),

2378

NULL, 10) * CONFIG_SYS_HZ;

2379

NULL, 10) * CONFIG_SYS_HZ;

2379

ts = get_timer(0);

2380

ts = get_timer(0);

2380

while (!l_ethdev.network_started) {

2381

while (!l_ethdev.network_started) {

2381

/* Handle control-c and timeouts */

2382

/* Handle control-c and timeouts */

2382

if (ctrlc() || (get_timer(ts) > timeout)) {

2383

if (ctrlc() || (get_timer(ts) > timeout)) {

2383

error("The remote end did not respond in time.");

2384

error("The remote end did not respond in time.");

2384

goto fail;

2385

goto fail;

2385

}

2386

}

2386

usb_gadget_handle_interrupts();

2387

usb_gadget_handle_interrupts();

2387

}

2388

}

2388

2389

packet_received = 0;

2390

packet_received = 0;

2390

rx_submit(dev, dev->rx_req, 0);

2391

rx_submit(dev, dev->rx_req, 0);

2391

return 0;

2392

return 0;

2392

fail:

2393

fail:

2393

return -1;

2394

return -1;

2394

}

2395

}

2395

2396

static int usb_eth_send(struct eth_device *netdev, void *packet, int length)

2397

static int usb_eth_send(struct eth_device *netdev, void *packet, int length)

2397

{

2398

{

2398

int retval;

2399

int retval;

2399

void *rndis_pkt = NULL;

2400

void *rndis_pkt = NULL;

2400

struct eth_dev *dev = &l_ethdev;

2401

struct eth_dev *dev = &l_ethdev;

2401

struct usb_request *req = dev->tx_req;

2402

struct usb_request *req = dev->tx_req;

2402

unsigned long ts;

2403

unsigned long ts;

2403

unsigned long timeout = USB_CONNECT_TIMEOUT;

2404

unsigned long timeout = USB_CONNECT_TIMEOUT;

2404

2405

debug("%s:...\n", __func__);

2406

debug("%s:...\n", __func__);

2406

2407

/* new buffer is needed to include RNDIS header */

2408

/* new buffer is needed to include RNDIS header */

2408

if (rndis_active(dev)) {

2409

if (rndis_active(dev)) {

2409

rndis_pkt = malloc(length +

2410

rndis_pkt = malloc(length +

2410

sizeof(struct rndis_packet_msg_type));

2411

sizeof(struct rndis_packet_msg_type));

2411

if (!rndis_pkt) {

2412

if (!rndis_pkt) {

2412

error("No memory to alloc RNDIS packet");

2413

error("No memory to alloc RNDIS packet");

2413

goto drop;

2414

goto drop;

2414

}

2415

}

2415

rndis_add_hdr(rndis_pkt, length);

2416

rndis_add_hdr(rndis_pkt, length);

2416

memcpy(rndis_pkt + sizeof(struct rndis_packet_msg_type),

2417

memcpy(rndis_pkt + sizeof(struct rndis_packet_msg_type),

2417

packet, length);

2418

packet, length);

2418

packet = rndis_pkt;

2419

packet = rndis_pkt;

2419

length += sizeof(struct rndis_packet_msg_type);

2420

length += sizeof(struct rndis_packet_msg_type);

2420

}

2421

}

2421

req->buf = packet;

2422

req->buf = packet;

2422

req->context = NULL;

2423

req->context = NULL;

2423

req->complete = tx_complete;

2424

req->complete = tx_complete;

2424

2425

/*

2426

/*

2426

* use zlp framing on tx for strict CDC-Ether conformance,

2427

* use zlp framing on tx for strict CDC-Ether conformance,

2427

* though any robust network rx path ignores extra padding.

2428

* though any robust network rx path ignores extra padding.

2428

* and some hardware doesn't like to write zlps.

2429

* and some hardware doesn't like to write zlps.

2429

*/

2430

*/

2430

req->zero = 1;

2431

req->zero = 1;

2431

if (!dev->zlp && (length % dev->in_ep->maxpacket) == 0)

2432

if (!dev->zlp && (length % dev->in_ep->maxpacket) == 0)

2432

length++;

2433

length++;

2433

2434

req->length = length;

2435

req->length = length;

2435

#if 0

2436

#if 0

2436

/* throttle highspeed IRQ rate back slightly */

2437

/* throttle highspeed IRQ rate back slightly */

2437

if (gadget_is_dualspeed(dev->gadget))

2438

if (gadget_is_dualspeed(dev->gadget))

2438

req->no_interrupt = (dev->gadget->speed == USB_SPEED_HIGH)

2439

req->no_interrupt = (dev->gadget->speed == USB_SPEED_HIGH)

2439

? ((dev->tx_qlen % qmult) != 0) : 0;

2440

? ((dev->tx_qlen % qmult) != 0) : 0;

2440

#endif

2441

#endif

2441

dev->tx_qlen = 1;

2442

dev->tx_qlen = 1;

2442

ts = get_timer(0);

2443

ts = get_timer(0);

2443

packet_sent = 0;

2444

packet_sent = 0;

2444

2445

retval = usb_ep_queue(dev->in_ep, req, GFP_ATOMIC);

2446

retval = usb_ep_queue(dev->in_ep, req, GFP_ATOMIC);

2446

2447

if (!retval)

2448

if (!retval)

2448

debug("%s: packet queued\n", __func__);

2449

debug("%s: packet queued\n", __func__);

2449

while (!packet_sent) {

2450

while (!packet_sent) {

2450

if (get_timer(ts) > timeout) {

2451

if (get_timer(ts) > timeout) {

2451

printf("timeout sending packets to usb ethernet\n");

2452

printf("timeout sending packets to usb ethernet\n");

2452

return -1;

2453

return -1;

2453

}

2454

}

2454

usb_gadget_handle_interrupts();

2455

usb_gadget_handle_interrupts();

2455

}

2456

}

2456

if (rndis_pkt)

2457

if (rndis_pkt)

2457

free(rndis_pkt);

2458

free(rndis_pkt);

2458

2459

return 0;

2460

return 0;

2460

drop:

2461

drop:

2461

dev->stats.tx_dropped++;

2462

dev->stats.tx_dropped++;

2462

return -ENOMEM;

2463

return -ENOMEM;

2463

}

2464

}

2464

2465

static int usb_eth_recv(struct eth_device *netdev)

2466

static int usb_eth_recv(struct eth_device *netdev)

2466

{

2467

{

2467

struct eth_dev *dev = &l_ethdev;

2468

struct eth_dev *dev = &l_ethdev;

2468

2469

usb_gadget_handle_interrupts();

2470

usb_gadget_handle_interrupts();

2470

2471

if (packet_received) {

2472

if (packet_received) {

2472

debug("%s: packet received\n", __func__);

2473

debug("%s: packet received\n", __func__);

2473

if (dev->rx_req) {

2474

if (dev->rx_req) {

2474

NetReceive(NetRxPackets[0], dev->rx_req->length);

2475

NetReceive(NetRxPackets[0], dev->rx_req->length);

2475

packet_received = 0;

2476

packet_received = 0;

2476

2477

rx_submit(dev, dev->rx_req, 0);

2478

rx_submit(dev, dev->rx_req, 0);

2478

} else

2479

} else

2479

error("dev->rx_req invalid");

2480

error("dev->rx_req invalid");

2480

}

2481

}

2481

return 0;

2482

return 0;

2482

}

2483

}

2483

2484

void usb_eth_halt(struct eth_device *netdev)

2485

void usb_eth_halt(struct eth_device *netdev)

2485

{

2486

{

2486

struct eth_dev *dev = &l_ethdev;

2487

struct eth_dev *dev = &l_ethdev;

2487

2488

if (!netdev) {

2489

if (!netdev) {

2489

error("received NULL ptr");

2490

error("received NULL ptr");

2490

return;

2491

return;

2491

}

2492

}

2492

2493

/* If the gadget not registered, simple return */

2494

/* If the gadget not registered, simple return */

2494

if (!dev->gadget)

2495

if (!dev->gadget)

2495

return;

2496

return;

2496

2497

/*

2498

/*

2498

* Some USB controllers may need additional deinitialization here

2499

* Some USB controllers may need additional deinitialization here

2499

* before dropping pull-up (also due to hardware issues).

2500

* before dropping pull-up (also due to hardware issues).

2500

* For example: unhandled interrupt with status stage started may

2501

* For example: unhandled interrupt with status stage started may

2501

* bring the controller to fully broken state (until board reset).

2502

* bring the controller to fully broken state (until board reset).

2502

* There are some variants to debug and fix such cases:

2503

* There are some variants to debug and fix such cases:

2503

* 1) In the case of RNDIS connection eth_stop can perform additional

2504

* 1) In the case of RNDIS connection eth_stop can perform additional

2504

* interrupt handling. See RNDIS_COMPLETE_SIGNAL_DISCONNECT definition.

2505

* interrupt handling. See RNDIS_COMPLETE_SIGNAL_DISCONNECT definition.

2505

* 2) 'pullup' callback in your UDC driver can be improved to perform

2506

* 2) 'pullup' callback in your UDC driver can be improved to perform

2506

* this deinitialization.

2507

* this deinitialization.

2507

*/

2508

*/

2508

eth_stop(dev);

2509

eth_stop(dev);

2509

2510

usb_gadget_disconnect(dev->gadget);

2511

usb_gadget_disconnect(dev->gadget);

2511

2512

/* Clear pending interrupt */

2513

/* Clear pending interrupt */

2513

if (dev->network_started) {

2514

if (dev->network_started) {

2514

usb_gadget_handle_interrupts();

2515

usb_gadget_handle_interrupts();

2515

dev->network_started = 0;

2516

dev->network_started = 0;

2516

}

2517

}

2517

2518

usb_gadget_unregister_driver(&eth_driver);

2519

usb_gadget_unregister_driver(&eth_driver);

2519

}

2520

}

2520

2521

static struct usb_gadget_driver eth_driver = {

2522

static struct usb_gadget_driver eth_driver = {

2522

.speed = DEVSPEED,

2523

.speed = DEVSPEED,

2523

2524

.bind = eth_bind,

2525

.bind = eth_bind,

2525

.unbind = eth_unbind,

2526

.unbind = eth_unbind,

2526

2527

.setup = eth_setup,

2528

.setup = eth_setup,

2528

.disconnect = eth_disconnect,

2529

.disconnect = eth_disconnect,

2529

2530

.suspend = eth_suspend,

2531

.suspend = eth_suspend,

2531

.resume = eth_resume,

2532

.resume = eth_resume,

2532

};

2533

};

2533

2534

int usb_eth_initialize(bd_t *bi)

2535

int usb_eth_initialize(bd_t *bi)

2535

{

2536

{

2536

struct eth_device *netdev = &l_netdev;

2537

struct eth_device *netdev = &l_netdev;

2537

2538

strlcpy(netdev->name, USB_NET_NAME, sizeof(netdev->name));

2539

strlcpy(netdev->name, USB_NET_NAME, sizeof(netdev->name));

2539

2540

netdev->init = usb_eth_init;

2541

netdev->init = usb_eth_init;

2541

netdev->send = usb_eth_send;

2542

netdev->send = usb_eth_send;

2542

netdev->recv = usb_eth_recv;

2543

netdev->recv = usb_eth_recv;

2543

netdev->halt = usb_eth_halt;

2544

netdev->halt = usb_eth_halt;

2544

2545

#ifdef CONFIG_MCAST_TFTP

2546

#ifdef CONFIG_MCAST_TFTP

2546

#error not supported

2547

#error not supported

2547

#endif

2548

#endif

2548

eth_register(netdev);

2549

eth_register(netdev);

2549

return 0;

2550

return 0;

2550

}

2551

}

2551

2552

GITLAB

usb: gadget: Fix data aborts during USB ethernet boot