1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright 2010 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 /*
28 * USB Ethernet Control Model
29 *
30 * USB-IF defines three ethernet network related specifications: EEM,
31 * ECM and NCM. This driver focuses specifically on ECM compatible
32 * devices. This kind of devices generally have one pair of bulk
33 * endpoints for in/out packet data and one interrupt endpoint for
34 * device notification.
35 *
36 * Devices which don't report ECM compatibility through descriptors but
37 * implement the ECM functions may also bind to this driver. This driver
38 * will try to find at least a bulk in endpoint and a bulk out endpoint
39 * in this case. If the non-compatible devices use vendor specific data
40 * format, this driver will not function.
41 *
42 * This driver is a normal USBA client driver. It's also a GLDv3 driver,
43 * which provides the necessary interfaces the GLDv3 framework requires.
44 *
45 */
46
47 #include <sys/types.h>
48 #include <sys/strsun.h>
49 #include <sys/ddi.h>
50 #include <sys/sunddi.h>
51 #include <sys/byteorder.h>
52 #include <sys/usb/usba/usbai_version.h>
53 #include <sys/usb/usba.h>
54 #include <sys/usb/usba/usba_types.h>
55 #include <sys/usb/clients/usbcdc/usb_cdc.h>
56 #include <sys/usb/clients/usbecm/usbecm.h>
57 #include <sys/mac_provider.h>
58 #include <sys/strsubr.h>
59 #include <sys/ethernet.h>
60 #include <sys/mac_ether.h> /* MAC_PLUGIN_IDENT_ETHER */
61 #include <sys/random.h> /* random_get_bytes */
62 #include <sys/sdt.h> /* sdt */
63 #include <inet/nd.h>
64
65 /* MAC callbacks */
66 static int usbecm_m_stat(void *arg, uint_t stat, uint64_t *val);
67 static int usbecm_m_start(void *arg);
68 static void usbecm_m_stop(void *arg);
69 static int usbecm_m_unicst(void *arg, const uint8_t *macaddr);
70 static int usbecm_m_multicst(void *arg, boolean_t add, const uint8_t *m);
71 static int usbecm_m_promisc(void *arg, boolean_t on);
72 static void usbecm_m_ioctl(void *arg, queue_t *wq, mblk_t *mp);
73 static mblk_t *usbecm_m_tx(void *arg, mblk_t *mp);
74 static int usbecm_m_getprop(void *arg, const char *pr_name,
75 mac_prop_id_t wldp_pr_num, uint_t wldp_length, void *wldp_buf);
76 static int usbecm_m_setprop(void *arg, const char *pr_name,
77 mac_prop_id_t wldp_pr_num, uint_t wldp_length, const void *wldp_buf);
78
79 static int usbecm_usb_init(usbecm_state_t *ecmp);
80 static int usbecm_mac_init(usbecm_state_t *ecmp);
81 static int usbecm_mac_fini(usbecm_state_t *ecmp);
82
83
84 /* utils */
85 static void generate_ether_addr(uint8_t *mac_addr);
86 static int usbecm_rx_start(usbecm_state_t *ecmp);
87
88 static void usbecm_pipe_start_polling(usbecm_state_t *ecmp);
89 static void usbecm_intr_cb(usb_pipe_handle_t ph, usb_intr_req_t *req);
90 static void usbecm_intr_ex_cb(usb_pipe_handle_t ph, usb_intr_req_t *req);
91 static void usbecm_parse_intr_data(usbecm_state_t *ecmp, mblk_t *data);
92
93 static int usbecm_reconnect_event_cb(dev_info_t *dip);
94 static int usbecm_disconnect_event_cb(dev_info_t *dip);
95
96 static int usbecm_open_pipes(usbecm_state_t *ecmp);
97 static void usbecm_close_pipes(usbecm_state_t *ecmp);
98
99 static int usbecm_ctrl_read(usbecm_state_t *ecmp, uchar_t request,
100 uint16_t value, mblk_t **data, int len);
101 static int usbecm_ctrl_write(usbecm_state_t *ecmp, uchar_t request,
102 uint16_t value, mblk_t **data);
103 static int usbecm_send_data(usbecm_state_t *ecmp, mblk_t *data);
104 static int usbecm_send_zero_data(usbecm_state_t *ecmp);
105 static int usbecm_get_statistics(usbecm_state_t *ecmp, uint32_t fs,
106 uint32_t *stat_data);
107
108 static int usbecm_create_pm_components(usbecm_state_t *ecmp);
109 static void usbecm_destroy_pm_components(usbecm_state_t *ecmp);
110 static int usbecm_power(dev_info_t *dip, int comp, int level);
111 static void usbecm_pm_set_busy(usbecm_state_t *ecmp);
112 static void usbecm_pm_set_idle(usbecm_state_t *ecmp);
113
114 static int usbecm_attach(dev_info_t *dip, ddi_attach_cmd_t cmd);
115 static int usbecm_detach(dev_info_t *dip, ddi_detach_cmd_t cmd);
116
117 static int usbecm_suspend(usbecm_state_t *ecmp);
118 static int usbecm_resume(usbecm_state_t *ecmp);
119 static int usbecm_restore_device_state(usbecm_state_t *ecmp);
120 static void usbecm_cleanup(usbecm_state_t *ecmp);
121
122 /* Driver identification */
123 static char usbecm_ident[] = "usbecm 1.0";
124
125 /* Global state pointer for managing per-device soft states */
126 void *usbecm_statep;
127
128 /* print levels */
129 static uint_t usbecm_errlevel = USB_LOG_L3;
130 static uint_t usbecm_errmask = 0xffffffff;
131 static uint_t usbecm_instance_debug = (uint_t)-1;
132
133 /*
134 * to prevent upper layers packet flood from exhausting system
135 * resources(USBA does not set limitation of requests on a pipe),
136 * we set a upper limit for the transfer queue length.
137 */
138 static int usbecm_tx_max = 32;
139
140 #define SUN_SP_VENDOR_ID 0x0430
141 #define SUN_SP_PRODUCT_ID 0xa4a2
142
143 static uint8_t usbecm_broadcast[ETHERADDRL] = {
144 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
145 };
146
147 static usb_event_t usbecm_events = {
148 usbecm_disconnect_event_cb,
149 usbecm_reconnect_event_cb,
150 NULL, NULL
151 };
152
153 #define ECM_DS_OP_VALID(op) ((ecmp->ecm_ds_ops) && (ecmp->ecm_ds_ops->op))
154
155 /*
156 * MAC Call Back entries
157 */
158 static mac_callbacks_t usbecm_m_callbacks = {
159 MC_IOCTL | MC_SETPROP | MC_GETPROP,
160 usbecm_m_stat, /* Get the value of a statistic */
161 usbecm_m_start, /* Start the device */
162 usbecm_m_stop, /* Stop the device */
163 usbecm_m_promisc, /* Enable or disable promiscuous mode */
164 usbecm_m_multicst, /* Enable or disable a multicast addr */
165 usbecm_m_unicst, /* Set the unicast MAC address */
166 usbecm_m_tx, /* Transmit a packet */
167 NULL,
168 usbecm_m_ioctl, /* Process an unknown ioctl */
169 NULL, /* mc_getcapab */
170 NULL, /* mc_open */
171 NULL, /* mc_close */
172 usbecm_m_setprop, /* mc_setprop */
173 usbecm_m_getprop, /* mc_getprop */
174 NULL
175 };
176
177
178 /*
179 * Module Loading Data & Entry Points
180 * Can't use DDI_DEFINE_STREAM_OPS, since it does
181 * not provide devo_power entry.
182 */
183 static struct cb_ops cb_usbecm = {
184 nulldev, /* cb_open */
185 nulldev, /* cb_close */
186 nodev, /* cb_strategy */
187 nodev, /* cb_print */
188 nodev, /* cb_dump */
189 nodev, /* cb_read */
190 nodev, /* cb_write */
191 nodev, /* cb_ioctl */
192 nodev, /* cb_devmap */
193 nodev, /* cb_mmap */
194 nodev, /* cb_segmap */
195 nochpoll, /* cb_chpoll */
196 ddi_prop_op, /* cb_prop_op */
197 NULL, /* cb_stream */
198 D_MP, /* cb_flag */
199 CB_REV, /* cb_rev */
200 nodev, /* cb_aread */
201 nodev, /* cb_awrite */
202 };
203
204 static struct dev_ops usbecm_devops = {
205 DEVO_REV, /* devo_rev */
206 0, /* devo_refcnt */
207 NULL, /* devo_getinfo */
208 nulldev, /* devo_identify */
209 nulldev, /* devo_probe */
210 usbecm_attach, /* devo_attach */
211 usbecm_detach, /* devo_detach */
212 nodev, /* devo_reset */
213 &(cb_usbecm), /* devo_cb_ops */
214 (struct bus_ops *)NULL, /* devo_bus_ops */
215 usbecm_power, /* devo_power */
216 ddi_quiesce_not_needed /* devo_quiesce */
217 };
218
219 static struct modldrv usbecm_modldrv = {
220 &mod_driverops, /* drv_modops */
221 usbecm_ident, /* drv_linkinfo */
222 &usbecm_devops /* drv_dev_ops */
223 };
224
225 static struct modlinkage usbecm_ml = {
226 MODREV_1, /* ml_rev */
227 &usbecm_modldrv, NULL /* ml_linkage */
228 };
229
230
231 /*
232 * Device operations
233 */
234 /*
235 * Binding the driver to a device.
236 *
237 * Concurrency: Until usbecm_attach() returns with success,
238 * the only other entry point that can be executed is getinfo().
239 * Thus no locking here yet.
240 */
241 static int
242 usbecm_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
243 {
244 char strbuf[32];
245 int instance;
246 int err;
247 usbecm_state_t *ecmp = NULL;
248
249 switch (cmd) {
250 case DDI_ATTACH:
251 break;
252
253 case DDI_RESUME:
254 ecmp = (usbecm_state_t *)ddi_get_soft_state(usbecm_statep,
255 ddi_get_instance(dip));
256
257 (void) usbecm_resume(ecmp);
258
259 return (DDI_SUCCESS);
260
261 default:
262 return (DDI_FAILURE);
263 }
264
265 instance = ddi_get_instance(dip);
266
267 if (ddi_soft_state_zalloc(usbecm_statep, instance) == DDI_SUCCESS) {
268 ecmp = ddi_get_soft_state(usbecm_statep, instance);
269 }
270 if (ecmp == NULL) {
271 cmn_err(CE_WARN, "usbecm_attach: fail to get soft state");
272
273 return (DDI_FAILURE);
274 }
275
276 ecmp->ecm_dip = dip;
277
278 ecmp->ecm_lh = usb_alloc_log_hdl(ecmp->ecm_dip, "usbecm",
279 &usbecm_errlevel, &usbecm_errmask, &usbecm_instance_debug, 0);
280
281 if (usbecm_usb_init(ecmp) != USB_SUCCESS) {
282 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
283 "usbecm_attach: failed to init usb");
284
285 goto fail;
286 }
287
288 if (ECM_DS_OP_VALID(ecm_ds_init)) {
289 if (ecmp->ecm_ds_ops->ecm_ds_init(ecmp) != USB_SUCCESS) {
290 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
291 "usbecm_attach: failed to init DS");
292
293 goto fail;
294 }
295 }
296
297 if (usbecm_mac_init(ecmp) != DDI_SUCCESS) {
298 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
299 "usbecm_attach: failed to init mac");
300
301 goto fail;
302 }
303 ecmp->ecm_init_flags |= USBECM_INIT_MAC;
304
305 /*
306 * Create minor node of type usb_net. Not necessary to create
307 * DDI_NT_NET since it's created in mac_register(). Otherwise,
308 * system will panic.
309 */
310 (void) snprintf(strbuf, sizeof (strbuf), "usbecm%d", instance);
311 err = ddi_create_minor_node(dip, strbuf, S_IFCHR,
312 instance + 1, "usb_net", 0);
313 if (err != DDI_SUCCESS) {
314 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
315 "failed to create minor node");
316
317 goto fail;
318 }
319
320 /* always busy. May change to a more precise PM in future */
321 usbecm_pm_set_busy(ecmp);
322
323 ddi_report_dev(dip);
324
325 USB_DPRINTF_L4(PRINT_MASK_ATTA, ecmp->ecm_lh,
326 "usbecm_attach: succeed!");
327
328 return (DDI_SUCCESS);
329
330 fail:
331 USB_DPRINTF_L1(PRINT_MASK_ATTA, ecmp->ecm_lh,
332 "usbecm_attach: Attach fail");
333
334 usbecm_cleanup(ecmp);
335 ddi_prop_remove_all(dip);
336 ddi_soft_state_free(usbecm_statep, instance);
337
338 return (DDI_FAILURE);
339
340 }
341
342
343 /*
344 * Detach the driver from a device.
345 *
346 * Concurrency: Will be called only after a successful attach
347 * (and not concurrently).
348 */
349 static int
350 usbecm_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
351 {
352 usbecm_state_t *ecmp = NULL;
353 int instance;
354
355 instance = ddi_get_instance(dip);
356 ecmp = ddi_get_soft_state(usbecm_statep, instance);
357 ASSERT(ecmp != NULL);
358
359 USB_DPRINTF_L4(PRINT_MASK_ATTA, ecmp->ecm_lh,
360 "usbecm_detach: entry ");
361
362 switch (cmd) {
363 case DDI_DETACH:
364 break;
365
366 case DDI_SUSPEND:
367
368 return (usbecm_suspend(ecmp));
369
370 default:
371 return (DDI_FAILURE);
372 }
373
374 usbecm_pm_set_idle(ecmp);
375
376 if (ECM_DS_OP_VALID(ecm_ds_fini)) {
377 if (ecmp->ecm_ds_ops->ecm_ds_fini(ecmp) != USB_SUCCESS) {
378 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
379 "usbecm_detach: deinitialize DS fail!");
380
381 return (DDI_FAILURE);
382 }
383 }
384
385 if (usbecm_mac_fini(ecmp) != 0) {
386
387 return (DDI_FAILURE);
388 }
389
390 USB_DPRINTF_L4(PRINT_MASK_ATTA, ecmp->ecm_lh,
391 "usbecm_detach: exit");
392
393 usbecm_cleanup(ecmp);
394 ddi_soft_state_free(usbecm_statep, instance);
395
396 return (DDI_SUCCESS);
397 }
398
399
400 /*
401 * Mac Call Back functions
402 */
403
404 /*
405 * Read device statistic information.
406 */
407 static int
408 usbecm_m_stat(void *arg, uint_t stat, uint64_t *val)
409 {
410 usbecm_state_t *ecmp = (usbecm_state_t *)arg;
411 uint32_t stats;
412 int rval;
413 uint32_t fs;
414
415 USB_DPRINTF_L4(PRINT_MASK_OPS, ecmp->ecm_lh,
416 "usbecm_m_stat: entry, stat=%d", stat);
417
418 /*
419 * Some of the stats are MII specific. We try to
420 * resolve all the statistics we understand. If
421 * the usb device can't provide it, return ENOTSUP.
422 */
423 switch (stat) {
424 case MAC_STAT_IFSPEED:
425 /* return link speed */
426 mutex_enter(&ecmp->ecm_mutex);
427 if (ecmp->ecm_stat.es_downspeed) {
428 *val = ecmp->ecm_stat.es_downspeed;
429 } else {
430 *val = 10 * 1000000ull; /* set a default value */
431 }
432 mutex_exit(&ecmp->ecm_mutex);
433
434 return (0);
435 case ETHER_STAT_LINK_DUPLEX:
436 *val = LINK_DUPLEX_FULL;
437
438 return (0);
439
440 case ETHER_STAT_SQE_ERRORS:
441 *val = 0;
442
443 return (0);
444
445 /* Map MAC/Ether stats to ECM statistics */
446 case MAC_STAT_NORCVBUF:
447 fs = ECM_RCV_NO_BUFFER;
448
449 break;
450 case MAC_STAT_NOXMTBUF:
451 fs = ECM_XMIT_ERROR;
452
453 break;
454 case MAC_STAT_IERRORS:
455 fs = ECM_RCV_ERROR;
456
457 break;
458 case MAC_STAT_OERRORS:
459 fs = ECM_XMIT_ERROR;
460
461 break;
462 case MAC_STAT_RBYTES:
463 fs = ECM_DIRECTED_BYTES_RCV;
464
465 break;
466 case MAC_STAT_IPACKETS:
467 fs = ECM_RCV_OK; /* frames */
468
469 break;
470 case MAC_STAT_OBYTES:
471 fs = ECM_DIRECTED_BYTES_XMIT;
472
473 break;
474 case MAC_STAT_OPACKETS:
475 fs = ECM_XMIT_OK; /* frames */
476
477 break;
478 case MAC_STAT_MULTIRCV:
479 fs = ECM_MULTICAST_FRAMES_RCV;
480
481 break;
482 case MAC_STAT_BRDCSTRCV:
483 fs = ECM_BROADCAST_FRAMES_RCV;
484
485 break;
486 case MAC_STAT_MULTIXMT:
487 fs = ECM_MULTICAST_FRAMES_XMIT;
488
489 break;
490 case MAC_STAT_BRDCSTXMT:
491 fs = ECM_BROADCAST_FRAMES_XMIT;
492
493 break;
494 case MAC_STAT_COLLISIONS:
495 fs = ECM_XMIT_MAX_COLLISIONS;
496
497 break;
498 case MAC_STAT_OVERFLOWS:
499 fs = ECM_RCV_OVERRUN;
500
501 break;
502 case MAC_STAT_UNDERFLOWS:
503 fs = ECM_XMIT_UNDERRUN;
504
505 break;
506 case ETHER_STAT_FCS_ERRORS:
507 fs = ECM_RCV_CRC_ERROR;
508
509 break;
510 case ETHER_STAT_ALIGN_ERRORS:
511 fs = ECM_RCV_ERROR_ALIGNMENT;
512
513 break;
514 case ETHER_STAT_DEFER_XMTS:
515 fs = ECM_XMIT_DEFERRED;
516
517 break;
518 case ETHER_STAT_FIRST_COLLISIONS:
519 fs = ECM_XMIT_ONE_COLLISION;
520
521 break;
522 case ETHER_STAT_MULTI_COLLISIONS:
523 fs = ECM_XMIT_MORE_COLLISIONS;
524
525 break;
526 case ETHER_STAT_TX_LATE_COLLISIONS:
527 fs = ECM_XMIT_LATE_COLLISIONS;
528
529 break;
530
531 default:
532 return (ENOTSUP);
533 }
534
535 /*
536 * we need to access device to get required stats,
537 * so check device state first
538 */
539 mutex_enter(&ecmp->ecm_mutex);
540 if (ecmp->ecm_dev_state != USB_DEV_ONLINE) {
541 USB_DPRINTF_L2(PRINT_MASK_OPS, ecmp->ecm_lh,
542 "usbecm_m_stat: device not ONLINE");
543
544 mutex_exit(&ecmp->ecm_mutex);
545
546 return (EIO);
547 }
548 mutex_exit(&ecmp->ecm_mutex);
549
550 rval = usbecm_get_statistics(ecmp,
551 ECM_STAT_SELECTOR(fs), &stats);
552 if (rval != USB_SUCCESS) {
553 mutex_enter(&ecmp->ecm_mutex);
554 switch (stat) {
555 case MAC_STAT_IERRORS:
556 *val = ecmp->ecm_stat.es_ierrors;
557
558 break;
559 case MAC_STAT_OERRORS:
560 *val = ecmp->ecm_stat.es_oerrors;
561
562 break;
563 case MAC_STAT_RBYTES:
564 *val = ecmp->ecm_stat.es_ibytes;
565
566 break;
567 case MAC_STAT_IPACKETS:
568 *val = ecmp->ecm_stat.es_ipackets;
569
570 break;
571 case MAC_STAT_OBYTES:
572 *val = ecmp->ecm_stat.es_obytes;
573
574 break;
575 case MAC_STAT_OPACKETS:
576 *val = ecmp->ecm_stat.es_opackets;
577
578 break;
579 case MAC_STAT_MULTIRCV:
580 *val = ecmp->ecm_stat.es_multircv;
581
582 break;
583 case MAC_STAT_MULTIXMT:
584 *val = ecmp->ecm_stat.es_multixmt;
585
586 break;
587 case MAC_STAT_BRDCSTRCV:
588 *val = ecmp->ecm_stat.es_brdcstrcv;
589
590 break;
591 case MAC_STAT_BRDCSTXMT:
592 *val = ecmp->ecm_stat.es_brdcstxmt;
593
594 break;
595 case ETHER_STAT_MACXMT_ERRORS:
596 *val = ecmp->ecm_stat.es_macxmt_err;
597 break;
598 default:
599 *val = 0;
600
601 break;
602 }
603 mutex_exit(&ecmp->ecm_mutex);
604 } else {
605 *val = stats;
606 }
607
608 USB_DPRINTF_L4(PRINT_MASK_OPS, ecmp->ecm_lh,
609 "usbecm_m_stat: end");
610
611 return (0);
612 }
613
614
615 /*
616 * Start the device:
617 * - Set proper altsettings of the data interface
618 * - Open status and data endpoints
619 * - Start status polling
620 * - Get bulk-in ep ready to receive data from ethernet
621 *
622 * Concurrency: Presumably fully concurrent, must lock.
623 */
624 static int
625 usbecm_m_start(void *arg)
626 {
627 usbecm_state_t *ecmp = (usbecm_state_t *)arg;
628 int rval;
629
630 USB_DPRINTF_L4(PRINT_MASK_OPS, ecmp->ecm_lh,
631 "usbecm_m_start: entry");
632
633 (void) usb_serialize_access(ecmp->ecm_ser_acc, USB_WAIT, 0);
634 mutex_enter(&ecmp->ecm_mutex);
635 if (ecmp->ecm_dev_state != USB_DEV_ONLINE) {
636 USB_DPRINTF_L2(PRINT_MASK_OPS, ecmp->ecm_lh,
637 "usbecm_m_start: device not online");
638 rval = ENODEV;
639 mutex_exit(&ecmp->ecm_mutex);
640
641 goto fail;
642 }
643 mutex_exit(&ecmp->ecm_mutex);
644
645 if (usbecm_open_pipes(ecmp) != USB_SUCCESS) {
646 USB_DPRINTF_L2(PRINT_MASK_OPS, ecmp->ecm_lh,
647 "usbecm_m_start: open pipes fail");
648 rval = EIO;
649
650 goto fail;
651 }
652
653 mutex_enter(&ecmp->ecm_mutex);
654 if (usbecm_rx_start(ecmp) != USB_SUCCESS) {
655 USB_DPRINTF_L2(PRINT_MASK_OPS, ecmp->ecm_lh,
656 "usbecm_m_start: fail to start_rx");
657 mutex_exit(&ecmp->ecm_mutex);
658 rval = EIO;
659
660 goto fail;
661 }
662 ecmp->ecm_mac_state = USBECM_MAC_STARTED;
663 mutex_exit(&ecmp->ecm_mutex);
664
665 /* set the device to receive all multicast/broadcast pkts */
666 rval = usbecm_ctrl_write(ecmp, CDC_ECM_SET_ETH_PKT_FLT,
667 CDC_ECM_PKT_TYPE_DIRECTED | CDC_ECM_PKT_TYPE_ALL_MCAST |
668 CDC_ECM_PKT_TYPE_BCAST, NULL);
669 if (rval != USB_SUCCESS) {
670 USB_DPRINTF_L3(PRINT_MASK_OPS, ecmp->ecm_lh,
671 "usbecm_m_start: set packet filters fail,"
672 " rval=%d, continue", rval);
673 }
674
675 if (ECM_DS_OP_VALID(ecm_ds_start)) {
676 if (ecmp->ecm_ds_ops->ecm_ds_start(ecmp) != USB_SUCCESS) {
677 USB_DPRINTF_L2(PRINT_MASK_OPS, ecmp->ecm_lh,
678 "usbecm_m_start: Can't start hardware");
679
680 goto fail;
681 }
682 }
683
684 usb_release_access(ecmp->ecm_ser_acc);
685
686 USB_DPRINTF_L4(PRINT_MASK_OPS, ecmp->ecm_lh,
687 "usbecm_m_start: end");
688
689 /*
690 * To mark the link as RUNNING.
691 *
692 * ECM spec doesn't provide a way for host to get the status
693 * of the physical link initiatively. Only the device can
694 * report the link state through interrupt endpoints.
695 */
696 mac_link_update(ecmp->ecm_mh, LINK_STATE_UP);
697 mutex_enter(&ecmp->ecm_mutex);
698 ecmp->ecm_stat.es_linkstate = LINK_STATE_UP;
699 mutex_exit(&ecmp->ecm_mutex);
700
701 return (DDI_SUCCESS);
702 fail:
703 usb_release_access(ecmp->ecm_ser_acc);
704
705 return (rval);
706 }
707
708 /*
709 * Stop the device.
710 */
711 static void
712 usbecm_m_stop(void *arg)
713 {
714 usbecm_state_t *ecmp = (usbecm_state_t *)arg;
715
716 USB_DPRINTF_L4(PRINT_MASK_OPS, ecmp->ecm_lh,
717 "usbecm_m_stop: entry");
718
719 (void) usb_serialize_access(ecmp->ecm_ser_acc, USB_WAIT, 0);
720 if (ECM_DS_OP_VALID(ecm_ds_stop)) {
721 if (ecmp->ecm_ds_ops->ecm_ds_stop(ecmp) != USB_SUCCESS) {
722 USB_DPRINTF_L4(PRINT_MASK_OPS, ecmp->ecm_lh,
723 "usbecm_m_stop: fail to stop hardware");
724 }
725 }
726
727 usbecm_close_pipes(ecmp);
728 usb_release_access(ecmp->ecm_ser_acc);
729
730 mutex_enter(&ecmp->ecm_mutex);
731 ecmp->ecm_mac_state = USBECM_MAC_STOPPED;
732 mutex_exit(&ecmp->ecm_mutex);
733
734 mac_link_update(ecmp->ecm_mh, LINK_STATE_DOWN);
735 mutex_enter(&ecmp->ecm_mutex);
736 ecmp->ecm_stat.es_linkstate = LINK_STATE_DOWN;
737 mutex_exit(&ecmp->ecm_mutex);
738
739 USB_DPRINTF_L4(PRINT_MASK_OPS, ecmp->ecm_lh,
740 "usbecm_m_stop: end");
741 }
742
743 /*
744 * Change the MAC address of the device.
745 */
746 /*ARGSUSED*/
747 static int
748 usbecm_m_unicst(void *arg, const uint8_t *macaddr)
749 {
750 usbecm_state_t *ecmp = (usbecm_state_t *)arg;
751 uint16_t filter;
752 int rval;
753
754 USB_DPRINTF_L4(PRINT_MASK_OPS, ecmp->ecm_lh,
755 "usbecm_m_unicst: entry");
756
757 /*
758 * The device doesn't support to set a different MAC addr.
759 * Hence, it's not necessary to stop the device first if
760 * the mac addresses are identical. And we just set unicast
761 * filter only.
762 */
763 if (bcmp(macaddr, ecmp->ecm_srcaddr, ETHERADDRL) != 0) {
764 USB_DPRINTF_L3(PRINT_MASK_OPS, ecmp->ecm_lh,
765 "usbecm_m_unicst: not supported to set a"
766 " different MAC addr");
767
768 return (DDI_FAILURE);
769 }
770 mutex_enter(&ecmp->ecm_mutex);
771 filter = ecmp->ecm_pkt_flt |= CDC_ECM_PKT_TYPE_DIRECTED;
772 mutex_exit(&ecmp->ecm_mutex);
773
774 (void) usb_serialize_access(ecmp->ecm_ser_acc, USB_WAIT, 0);
775 rval = usbecm_ctrl_write(ecmp, CDC_ECM_SET_ETH_PKT_FLT,
776 filter, NULL);
777 usb_release_access(ecmp->ecm_ser_acc);
778
779 USB_DPRINTF_L4(PRINT_MASK_OPS, ecmp->ecm_lh,
780 "usbecm_m_unicst: rval = %d", rval);
781
782 /* some devices may not support this request, we just return success */
783 return (DDI_SUCCESS);
784 }
785
786 /*
787 * Enable/disable multicast.
788 */
789 /*ARGSUSED*/
790 static int
791 usbecm_m_multicst(void *arg, boolean_t add, const uint8_t *m)
792 {
793 usbecm_state_t *ecmp = (usbecm_state_t *)arg;
794 uint16_t filter;
795 int rval = 0;
796
797 USB_DPRINTF_L4(PRINT_MASK_OPS, ecmp->ecm_lh,
798 "usbecm_m_multicst: entry");
799 mutex_enter(&ecmp->ecm_mutex);
800
801 /*
802 * To simplify the implementation, we support switching
803 * all multicast on/off feature only
804 */
805 if (add == B_TRUE) {
806 ecmp->ecm_pkt_flt |= CDC_ECM_PKT_TYPE_ALL_MCAST;
807 } else {
808 ecmp->ecm_pkt_flt &= ~CDC_ECM_PKT_TYPE_ALL_MCAST;
809 }
810 filter = ecmp->ecm_pkt_flt;
811 mutex_exit(&ecmp->ecm_mutex);
812
813 (void) usb_serialize_access(ecmp->ecm_ser_acc, USB_WAIT, 0);
814 if (ecmp->ecm_compatibility &&
815 (ecmp->ecm_desc.wNumberMCFilters & 0x7F)) {
816 /* Device supports SetEthernetMulticastFilters request */
817 rval = usbecm_ctrl_write(ecmp, CDC_ECM_SET_ETH_PKT_FLT,
818 filter, NULL);
819 USB_DPRINTF_L4(PRINT_MASK_OPS, ecmp->ecm_lh,
820 "usbecm_m_multicst: rval = %d", rval);
821 }
822 usb_release_access(ecmp->ecm_ser_acc);
823
824 /* some devices may not support this request, we just return success */
825 return (DDI_SUCCESS);
826 }
827
828 /*
829 * Enable/disable promiscuous mode.
830 */
831 static int
832 usbecm_m_promisc(void *arg, boolean_t on)
833 {
834 usbecm_state_t *ecmp = (usbecm_state_t *)arg;
835 uint16_t filter;
836 int rval;
837
838 USB_DPRINTF_L4(PRINT_MASK_OPS, ecmp->ecm_lh,
839 "usbecm_m_promisc: entry");
840
841 mutex_enter(&ecmp->ecm_mutex);
842 if (ecmp->ecm_dev_state != USB_DEV_ONLINE) {
843 USB_DPRINTF_L2(PRINT_MASK_OPS, ecmp->ecm_lh,
844 "usbecm_m_promisc: device not ONLINE");
845 mutex_exit(&ecmp->ecm_mutex);
846
847 return (DDI_FAILURE);
848 }
849
850
851 if (on == B_TRUE) {
852 ecmp->ecm_pkt_flt |= CDC_ECM_PKT_TYPE_PROMISC;
853 } else {
854 ecmp->ecm_pkt_flt &= ~CDC_ECM_PKT_TYPE_PROMISC;
855 }
856 filter = ecmp->ecm_pkt_flt;
857 mutex_exit(&ecmp->ecm_mutex);
858
859 (void) usb_serialize_access(ecmp->ecm_ser_acc, USB_WAIT, 0);
860 rval = usbecm_ctrl_write(ecmp, CDC_ECM_SET_ETH_PKT_FLT,
861 filter, NULL);
862 usb_release_access(ecmp->ecm_ser_acc);
863
864 USB_DPRINTF_L4(PRINT_MASK_OPS, ecmp->ecm_lh,
865 "usbecm_m_promisc: rval=%d", rval);
866
867 /*
868 * devices may not support this request, we just
869 * return success to let upper layer to do further
870 * operation.
871 */
872 return (DDI_SUCCESS);
873 }
874
875 /*
876 * IOCTL request: Does not do anything. Will be enhanced
877 * in future.
878 */
879 static void
880 usbecm_m_ioctl(void *arg, queue_t *wq, mblk_t *mp)
881 {
882 usbecm_state_t *ecmp = (usbecm_state_t *)arg;
883 struct iocblk *iocp;
884 int cmd;
885
886 USB_DPRINTF_L4(PRINT_MASK_OPS, ecmp->ecm_lh,
887 "usbecm_m_ioctl: entry");
888
889 mutex_enter(&ecmp->ecm_mutex);
890 if (ecmp->ecm_dev_state != USB_DEV_ONLINE) {
891 USB_DPRINTF_L2(PRINT_MASK_OPS, ecmp->ecm_lh,
892 "usbecm_m_ioctl: device not ONLINE");
893 mutex_exit(&ecmp->ecm_mutex);
894
895 miocnak(wq, mp, 0, EIO);
896
897 return;
898 }
899 mutex_exit(&ecmp->ecm_mutex);
900
901 iocp = (void *)mp->b_rptr;
902 iocp->ioc_error = 0;
903 cmd = iocp->ioc_cmd;
904
905 (void) usb_serialize_access(ecmp->ecm_ser_acc, USB_WAIT, 0);
906
907 switch (cmd) {
908 default:
909 USB_DPRINTF_L4(PRINT_MASK_OPS, ecmp->ecm_lh,
910 "unknown cmd 0x%x", cmd);
911 usb_release_access(ecmp->ecm_ser_acc);
912 miocnak(wq, mp, 0, EINVAL);
913
914 return;
915 }
916 }
917
918 /*
919 * callback functions for get/set properties
920 * Does not do anything. Will be enhanced to
921 * support set/get properties in future.
922 */
923 /*ARGSUSED*/
924 static int
925 usbecm_m_setprop(void *arg, const char *pr_name, mac_prop_id_t wldp_pr_num,
926 uint_t wldp_length, const void *wldp_buf)
927 {
928 usbecm_state_t *ecmp = (usbecm_state_t *)arg;
929 int err = ENOTSUP;
930
931 USB_DPRINTF_L4(PRINT_MASK_OPS, ecmp->ecm_lh,
932 "usbecm_m_setprop: entry");
933
934 return (err);
935 }
936
937 /*ARGSUSED*/
938 static int usbecm_m_getprop(void *arg, const char *pr_name,
939 mac_prop_id_t wldp_pr_num, uint_t wldp_length, void *wldp_buf)
940 {
941 usbecm_state_t *ecmp = (usbecm_state_t *)arg;
942 int err = ENOTSUP;
943
944 USB_DPRINTF_L4(PRINT_MASK_OPS, ecmp->ecm_lh,
945 "usbecm_m_getprop: entry");
946
947 mutex_enter(&ecmp->ecm_mutex);
948 if (ecmp->ecm_dev_state != USB_DEV_ONLINE) {
949 mutex_exit(&ecmp->ecm_mutex);
950
951 return (EIO);
952 }
953 mutex_exit(&ecmp->ecm_mutex);
954
955 return (err);
956 }
957
958 /*
959 * Transmit a data frame.
960 */
961 static mblk_t *
962 usbecm_m_tx(void *arg, mblk_t *mp)
963 {
964 usbecm_state_t *ecmp = (usbecm_state_t *)arg;
965 mblk_t *next;
966 int count = 0;
967
968 ASSERT(mp != NULL);
969
970 USB_DPRINTF_L4(PRINT_MASK_OPS, ecmp->ecm_lh,
971 "usbecm_m_tx: entry");
972
973 mutex_enter(&ecmp->ecm_mutex);
974 if (ecmp->ecm_dev_state != USB_DEV_ONLINE) {
975 USB_DPRINTF_L2(PRINT_MASK_OPS, ecmp->ecm_lh,
976 "usbecm_m_tx: device not ONLINE");
977 mutex_exit(&ecmp->ecm_mutex);
978
979 return (mp);
980 }
981 mutex_exit(&ecmp->ecm_mutex);
982
983 (void) usb_serialize_access(ecmp->ecm_ser_acc, USB_WAIT, 0);
984
985 /*
986 * To make use of the device maximum capability,
987 * concatenate msg blocks in a msg to ETHERMAX length.
988 */
989 while (mp != NULL) {
990 next = mp->b_next;
991 mp->b_next = NULL;
992
993 if (usbecm_send_data(ecmp, mp) != DDI_SUCCESS) {
994 USB_DPRINTF_L3(PRINT_MASK_OPS, ecmp->ecm_lh,
995 "usbecm_m_tx: send data fail");
996
997 /* failure statistics */
998 mutex_enter(&ecmp->ecm_mutex);
999 ecmp->ecm_stat.es_oerrors++;
1000 mutex_exit(&ecmp->ecm_mutex);
1001
1002 mp->b_next = next;
1003
1004 break;
1005 }
1006
1007 /*
1008 * To make it simple, we count all packets, no matter
1009 * the device supports ethernet statistics or not.
1010 */
1011 mutex_enter(&ecmp->ecm_mutex);
1012 ecmp->ecm_stat.es_opackets++;
1013 ecmp->ecm_stat.es_obytes += MBLKL(mp);
1014 mutex_exit(&ecmp->ecm_mutex);
1015
1016 freemsg(mp); /* free this msg upon success */
1017
1018 mp = next;
1019 USB_DPRINTF_L4(PRINT_MASK_OPS, ecmp->ecm_lh,
1020 "usbecm_m_tx: %d msgs processed", ++count);
1021 }
1022
1023 usb_release_access(ecmp->ecm_ser_acc);
1024
1025 return (mp);
1026 }
1027
1028 /*
1029 * usbecm_bulkin_cb:
1030 * Bulk In regular and exeception callback;
1031 * USBA framework will call this callback
1032 * after deal with bulkin request.
1033 */
1034 /*ARGSUSED*/
1035 static void
1036 usbecm_bulkin_cb(usb_pipe_handle_t pipe, usb_bulk_req_t *req)
1037 {
1038 usbecm_state_t *ecmp = (usbecm_state_t *)req->bulk_client_private;
1039 mblk_t *data, *mp;
1040 int data_len;
1041 int max_pkt_size = ecmp->ecm_bulkin_sz;
1042
1043 data = req->bulk_data;
1044 data_len = (data) ? MBLKL(data) : 0;
1045
1046 ASSERT(data->b_cont == NULL);
1047
1048 mutex_enter(&ecmp->ecm_mutex);
1049
1050 USB_DPRINTF_L4(PRINT_MASK_CB, ecmp->ecm_lh,
1051 "usbecm_bulkin_cb: state=%d, len=%d", ecmp->ecm_bulkin_state,
1052 data_len);
1053
1054 /*
1055 * may receive a zero length packet according
1056 * to USB short packet semantics
1057 */
1058 if ((ecmp->ecm_dev_state == USB_DEV_ONLINE) &&
1059 (req->bulk_completion_reason == USB_CR_OK)) {
1060 if (data_len) {
1061 if (ecmp->ecm_rcv_queue == NULL) {
1062 ecmp->ecm_rcv_queue = data;
1063 } else {
1064 if ((msgsize(ecmp->ecm_rcv_queue) + data_len)
1065 > ETHERMAX) {
1066 /*
1067 * Exceed the ethernet maximum length, we think
1068 * something is wrong with this frame and hence
1069 * free older data. Accept new data instead.
1070 */
1071 freemsg(ecmp->ecm_rcv_queue);
1072 ecmp->ecm_rcv_queue = data;
1073 } else {
1074 linkb(ecmp->ecm_rcv_queue, data);
1075 }
1076 }
1077 } else {
1078 /*
1079 * Do not put zero length packet to receive queue.
1080 * Otherwise, msgpullup will dupmsg() a zero length
1081 * mblk, which will cause memleaks.
1082 */
1083 freemsg(data);
1084 }
1085
1086 /*
1087 * ECM V1.2, section 3.3.1, a short(including zero length)
1088 * packet signifies end of frame. We can submit this frame
1089 * to upper layer now.
1090 */
1091 if ((data_len < max_pkt_size) &&
1092 (msgsize(ecmp->ecm_rcv_queue) > 0)) {
1093 mp = msgpullup(ecmp->ecm_rcv_queue, -1);
1094 freemsg(ecmp->ecm_rcv_queue);
1095 ecmp->ecm_rcv_queue = NULL;
1096
1097 ecmp->ecm_stat.es_ipackets++;
1098 ecmp->ecm_stat.es_ibytes += msgsize(mp);
1099 if (mp && (mp->b_rptr[0] & 0x01)) {
1100 if (bcmp(mp->b_rptr, usbecm_broadcast,
1101 ETHERADDRL) != 0) {
1102 ecmp->ecm_stat.es_multircv++;
1103 } else {
1104 ecmp->ecm_stat.es_brdcstrcv++;
1105 }
1106 }
1107
1108 if (mp) {
1109 mutex_exit(&ecmp->ecm_mutex);
1110 mac_rx(ecmp->ecm_mh, NULL, mp);
1111 mutex_enter(&ecmp->ecm_mutex);
1112 }
1113 }
1114
1115 /* prevent USBA from freeing data along with the request */
1116 req->bulk_data = NULL;
1117 } else if (req->bulk_completion_reason != USB_CR_OK) {
1118 ecmp->ecm_stat.es_ierrors++;
1119 }
1120 mutex_exit(&ecmp->ecm_mutex);
1121
1122 usb_free_bulk_req(req);
1123
1124 /* receive more */
1125 mutex_enter(&ecmp->ecm_mutex);
1126 if (((ecmp->ecm_bulkin_state == USBECM_PIPE_BUSY) ||
1127 (ecmp->ecm_bulkin_state == USBECM_PIPE_IDLE)) &&
1128 (ecmp->ecm_dev_state == USB_DEV_ONLINE)) {
1129 if (usbecm_rx_start(ecmp) != USB_SUCCESS) {
1130 USB_DPRINTF_L2(PRINT_MASK_CB, ecmp->ecm_lh,
1131 "usbecm_bulkin_cb: restart rx fail "
1132 "ecmp_state = %d", ecmp->ecm_bulkin_state);
1133 }
1134 } else if (ecmp->ecm_bulkin_state == USBECM_PIPE_BUSY) {
1135 ecmp->ecm_bulkin_state = USBECM_PIPE_IDLE;
1136 }
1137 mutex_exit(&ecmp->ecm_mutex);
1138 }
1139
1140 /*
1141 * usbsecm_rx_start:
1142 * start data receipt
1143 */
1144 static int
1145 usbecm_rx_start(usbecm_state_t *ecmp)
1146 {
1147 usb_bulk_req_t *br;
1148 int rval = USB_FAILURE;
1149 int data_len;
1150
1151 ASSERT(mutex_owned(&ecmp->ecm_mutex));
1152
1153 DTRACE_PROBE2(usbecm_rx__start, int, ecmp->ecm_xfer_sz,
1154 int, ecmp->ecm_bulkin_sz);
1155
1156 ecmp->ecm_bulkin_state = USBECM_PIPE_BUSY;
1157 data_len = ecmp->ecm_bulkin_sz;
1158
1159 mutex_exit(&ecmp->ecm_mutex);
1160 br = usb_alloc_bulk_req(ecmp->ecm_dip, data_len, USB_FLAGS_SLEEP);
1161 if (br == NULL) {
1162 USB_DPRINTF_L2(PRINT_MASK_CB, ecmp->ecm_lh,
1163 "usbsecm_rx_start: allocate bulk request failed");
1164
1165 mutex_enter(&ecmp->ecm_mutex);
1166
1167 return (USB_FAILURE);
1168 }
1169 /* initialize bulk in request. */
1170 br->bulk_len = data_len;
1171 br->bulk_timeout = 0;
1172 br->bulk_cb = usbecm_bulkin_cb;
1173 br->bulk_exc_cb = usbecm_bulkin_cb;
1174 br->bulk_client_private = (usb_opaque_t)ecmp;
1175 br->bulk_attributes = USB_ATTRS_AUTOCLEARING
1176 | USB_ATTRS_SHORT_XFER_OK;
1177
1178 rval = usb_pipe_bulk_xfer(ecmp->ecm_bulkin_ph, br, 0);
1179 mutex_enter(&ecmp->ecm_mutex);
1180 if (rval != USB_SUCCESS) {
1181 USB_DPRINTF_L2(PRINT_MASK_CB, ecmp->ecm_lh,
1182 "usbsecm_rx_start: bulk transfer failed %d", rval);
1183 usb_free_bulk_req(br);
1184 ecmp->ecm_bulkin_state = USBECM_PIPE_IDLE;
1185 }
1186
1187 return (rval);
1188 }
1189
1190 /*
1191 * usbecm_bulkout_cb:
1192 * Bulk Out regular and exeception callback;
1193 * USBA framework will call this callback function
1194 * after deal with bulkout request.
1195 */
1196 /*ARGSUSED*/
1197 static void
1198 usbecm_bulkout_cb(usb_pipe_handle_t pipe, usb_bulk_req_t *req)
1199 {
1200 usbecm_state_t *ecmp = (usbecm_state_t *)req->bulk_client_private;
1201 int data_len;
1202 boolean_t need_update = B_FALSE;
1203
1204 data_len = (req->bulk_data) ? MBLKL(req->bulk_data) : 0;
1205
1206 USB_DPRINTF_L4(PRINT_MASK_CB, ecmp->ecm_lh,
1207 "usbecm_bulkout_cb: data_len = %d, cr=%d", data_len,
1208 req->bulk_completion_reason);
1209
1210 mutex_enter(&ecmp->ecm_mutex);
1211 if ((data_len > 0) && (ecmp->ecm_tx_cnt > 0)) {
1212 if (ecmp->ecm_tx_cnt == usbecm_tx_max) {
1213 need_update = B_TRUE;
1214 }
1215 ecmp->ecm_tx_cnt--;
1216 }
1217 mutex_exit(&ecmp->ecm_mutex);
1218
1219 if (req->bulk_completion_reason && (data_len > 0)) {
1220 mutex_enter(&ecmp->ecm_mutex);
1221 ecmp->ecm_stat.es_oerrors++;
1222 mutex_exit(&ecmp->ecm_mutex);
1223
1224 need_update = B_TRUE;
1225 }
1226
1227 /*
1228 * notify MAC layer to retransfer the failed packet
1229 * Or notity MAC that we have more buffer now.
1230 */
1231 if (need_update) {
1232 mac_tx_update(ecmp->ecm_mh);
1233 }
1234
1235 usb_free_bulk_req(req);
1236 }
1237
1238 static int
1239 usbecm_send_data(usbecm_state_t *ecmp, mblk_t *data)
1240 {
1241 usb_bulk_req_t *br;
1242 int rval = USB_FAILURE;
1243 int data_len = MBLKL(data);
1244 int max_pkt_size;
1245 mblk_t *new_data = NULL;
1246 int new_data_len = 0;
1247
1248 USB_DPRINTF_L4(PRINT_MASK_OPS, ecmp->ecm_lh,
1249 "usbecm_send_data: length = %d, total len=%d",
1250 data_len, (int)msgdsize(data));
1251
1252 mutex_enter(&ecmp->ecm_mutex);
1253 if (ecmp->ecm_tx_cnt >= usbecm_tx_max) {
1254 USB_DPRINTF_L4(PRINT_MASK_OPS, ecmp->ecm_lh,
1255 "usbecm_send_data: (%d) exceeds TX max queue length",
1256 ecmp->ecm_tx_cnt);
1257 mutex_exit(&ecmp->ecm_mutex);
1258
1259 return (USB_FAILURE);
1260 }
1261 mutex_exit(&ecmp->ecm_mutex);
1262
1263 data_len = msgsize(data);
1264 if (data_len > ETHERMAX) {
1265 mutex_enter(&ecmp->ecm_mutex);
1266 ecmp->ecm_stat.es_macxmt_err++;
1267 mutex_exit(&ecmp->ecm_mutex);
1268
1269 USB_DPRINTF_L2(PRINT_MASK_OPS, ecmp->ecm_lh,
1270 "usbecm_send_data: packet too long, %d", data_len);
1271
1272 return (USB_FAILURE);
1273 }
1274
1275 if (data_len < ETHERMIN) {
1276 mblk_t *tmp;
1277
1278 USB_DPRINTF_L4(PRINT_MASK_OPS, ecmp->ecm_lh,
1279 "usbecm_send_data: short packet, padding to ETHERMIN");
1280
1281 new_data_len = ETHERMIN;
1282 if ((new_data = allocb(new_data_len, 0)) == NULL) {
1283 USB_DPRINTF_L2(PRINT_MASK_OPS, ecmp->ecm_lh,
1284 "usbecm_send_data: fail to allocb");
1285
1286 return (USB_FAILURE);
1287 }
1288 bzero(new_data->b_wptr, new_data_len);
1289 for (tmp = data; tmp != NULL; tmp = tmp->b_cont) {
1290 bcopy(tmp->b_rptr, new_data->b_wptr, MBLKL(tmp));
1291 new_data->b_wptr += MBLKL(tmp);
1292 }
1293
1294 new_data->b_wptr = new_data->b_rptr + new_data_len;
1295 }
1296
1297 br = usb_alloc_bulk_req(ecmp->ecm_dip, 0, USB_FLAGS_SLEEP);
1298 if (br == NULL) {
1299 USB_DPRINTF_L2(PRINT_MASK_OPS, ecmp->ecm_lh,
1300 "usbecm_send_data: alloc req failed.");
1301
1302 return (USB_FAILURE);
1303 }
1304
1305 /* initialize the bulk out request */
1306 if (new_data) {
1307 br->bulk_data = msgpullup(new_data, -1); /* msg allocated! */
1308 br->bulk_len = new_data_len;
1309 } else {
1310 br->bulk_data = msgpullup(data, -1); /* msg allocated! */
1311 br->bulk_len = data_len;
1312 }
1313
1314 USB_DPRINTF_L4(PRINT_MASK_OPS, ecmp->ecm_lh,
1315 "usbecm_send_data: bulk_len = %d", br->bulk_len);
1316
1317 br->bulk_timeout = USBECM_BULKOUT_TIMEOUT;
1318 br->bulk_cb = usbecm_bulkout_cb;
1319 br->bulk_exc_cb = usbecm_bulkout_cb;
1320 br->bulk_client_private = (usb_opaque_t)ecmp;
1321 br->bulk_attributes = USB_ATTRS_AUTOCLEARING;
1322
1323 if (br->bulk_data != NULL) {
1324 if (br->bulk_data->b_rptr[0] & 0x01) {
1325 mutex_enter(&ecmp->ecm_mutex);
1326 if (bcmp(br->bulk_data->b_rptr, usbecm_broadcast,
1327 ETHERADDRL) != 0) {
1328 ecmp->ecm_stat.es_multixmt++;
1329 } else {
1330 ecmp->ecm_stat.es_brdcstxmt++;
1331 }
1332 mutex_exit(&ecmp->ecm_mutex);
1333 }
1334 rval = usb_pipe_bulk_xfer(ecmp->ecm_bulkout_ph, br, 0);
1335 }
1336
1337 if (rval != USB_SUCCESS) {
1338 USB_DPRINTF_L2(PRINT_MASK_OPS, ecmp->ecm_lh,
1339 "usbecm_send_data: Send Data failed.");
1340
1341 /*
1342 * br->bulk_data should be freed because we allocated
1343 * it in this function.
1344 */
1345 usb_free_bulk_req(br);
1346
1347 } else {
1348 mutex_enter(&ecmp->ecm_mutex);
1349 ecmp->ecm_tx_cnt++;
1350 mutex_exit(&ecmp->ecm_mutex);
1351
1352 /*
1353 * ECM V1.2, section 3.3.1, a short(including zero length)
1354 * packet signifies end of frame. We should send a zero length
1355 * packet to device if the total data lenght is multiple of
1356 * bulkout endpoint's max packet size.
1357 */
1358 max_pkt_size = ecmp->ecm_bulk_out_ep->ep_descr.wMaxPacketSize;
1359 if ((data_len % max_pkt_size) == 0) {
1360 if ((rval = usbecm_send_zero_data(ecmp))
1361 != USB_SUCCESS) {
1362 USB_DPRINTF_L2(PRINT_MASK_OPS, ecmp->ecm_lh,
1363 "usbecm_send_data: fail to send padding");
1364 }
1365 }
1366 }
1367
1368 if (new_data) {
1369 freemsg(new_data);
1370 }
1371
1372 USB_DPRINTF_L4(PRINT_MASK_EVENTS, ecmp->ecm_lh,
1373 "usbecm_send_data: len(%d) data sent, rval=%d",
1374 new_data_len ? new_data_len : data_len, rval);
1375
1376 return (rval);
1377 }
1378
1379 static int
1380 usbecm_send_zero_data(usbecm_state_t *ecmp)
1381 {
1382 usb_bulk_req_t *br;
1383 int rval = USB_FAILURE;
1384
1385 USB_DPRINTF_L4(PRINT_MASK_OPS, ecmp->ecm_lh,
1386 "usbecm_send_zero_data: entry");
1387
1388 br = usb_alloc_bulk_req(ecmp->ecm_dip, 0, USB_FLAGS_SLEEP);
1389 if (br == NULL) {
1390 USB_DPRINTF_L2(PRINT_MASK_OPS, ecmp->ecm_lh,
1391 "usbecm_send_data: alloc req failed.");
1392
1393 return (USB_FAILURE);
1394 }
1395
1396 /* initialize the bulk out request */
1397 br->bulk_len = 0;
1398 br->bulk_timeout = USBECM_BULKOUT_TIMEOUT;
1399 br->bulk_cb = usbecm_bulkout_cb;
1400 br->bulk_exc_cb = usbecm_bulkout_cb;
1401 br->bulk_client_private = (usb_opaque_t)ecmp;
1402 br->bulk_attributes = USB_ATTRS_AUTOCLEARING;
1403
1404 rval = usb_pipe_bulk_xfer(ecmp->ecm_bulkout_ph, br, 0);
1405
1406 if (rval != USB_SUCCESS) {
1407 USB_DPRINTF_L2(PRINT_MASK_OPS, ecmp->ecm_lh,
1408 "usbecm_send_zero_data: Send data failed, rval=%d",
1409 rval);
1410
1411 /*
1412 * br->bulk_data should be freed because we allocated
1413 * it in this function.
1414 */
1415 usb_free_bulk_req(br);
1416
1417 }
1418
1419 USB_DPRINTF_L4(PRINT_MASK_OPS, ecmp->ecm_lh,
1420 "usbecm_send_zero_data: end");
1421
1422 return (rval);
1423 }
1424
1425 /*
1426 * Loadable module configuration entry points
1427 */
1428
1429 /*
1430 * _init module entry point.
1431 *
1432 * Called when the module is being loaded into memory.
1433 */
1434 int
1435 _init(void)
1436 {
1437 int err;
1438
1439 err = ddi_soft_state_init(&usbecm_statep, sizeof (usbecm_state_t), 1);
1440
1441 if (err != DDI_SUCCESS)
1442 return (err);
1443
1444 mac_init_ops(&usbecm_devops, "usbecm");
1445 err = mod_install(&usbecm_ml);
1446
1447 if (err != DDI_SUCCESS) {
1448 mac_fini_ops(&usbecm_devops);
1449 ddi_soft_state_fini(&usbecm_statep);
1450 }
1451
1452 return (err);
1453 }
1454
1455 /*
1456 * _info module entry point.
1457 *
1458 * Called to obtain information about the module.
1459 */
1460 int
1461 _info(struct modinfo *modinfop)
1462 {
1463 return (mod_info(&usbecm_ml, modinfop));
1464 }
1465
1466 /*
1467 * _fini module entry point.
1468 *
1469 * Called when the module is being unloaded.
1470 */
1471 int
1472 _fini(void)
1473 {
1474 int err;
1475
1476 err = mod_remove(&usbecm_ml);
1477 if (err == DDI_SUCCESS) {
1478 mac_fini_ops(&usbecm_devops);
1479 ddi_soft_state_fini(&usbecm_statep);
1480 }
1481
1482 return (err);
1483 }
1484
1485 /*
1486 * usbecm_pipe_start_polling:
1487 * start polling on the interrupt pipe
1488 */
1489 static void
1490 usbecm_pipe_start_polling(usbecm_state_t *ecmp)
1491 {
1492 usb_intr_req_t *intr;
1493 int rval;
1494
1495 USB_DPRINTF_L4(PRINT_MASK_OPEN, ecmp->ecm_lh,
1496 "usbecm_pipe_start_polling: ");
1497
1498 if (ecmp->ecm_intr_ph == NULL) {
1499
1500 return;
1501 }
1502
1503 intr = usb_alloc_intr_req(ecmp->ecm_dip, 0, USB_FLAGS_SLEEP);
1504
1505 /*
1506 * If it is in interrupt context, usb_alloc_intr_req will return NULL if
1507 * called with SLEEP flag.
1508 */
1509 if (!intr) {
1510 USB_DPRINTF_L2(PRINT_MASK_OPEN, ecmp->ecm_lh,
1511 "usbecm_pipe_start_polling: alloc req failed.");
1512
1513 return;
1514 }
1515
1516 /* initialize the interrupt request. */
1517 intr->intr_attributes = USB_ATTRS_SHORT_XFER_OK |
1518 USB_ATTRS_AUTOCLEARING;
1519 intr->intr_len = ecmp->ecm_intr_ep->ep_descr.wMaxPacketSize;
1520 intr->intr_client_private = (usb_opaque_t)ecmp;
1521 intr->intr_cb = usbecm_intr_cb;
1522 intr->intr_exc_cb = usbecm_intr_ex_cb;
1523
1524 rval = usb_pipe_intr_xfer(ecmp->ecm_intr_ph, intr, USB_FLAGS_SLEEP);
1525
1526 mutex_enter(&ecmp->ecm_mutex);
1527 if (rval == USB_SUCCESS) {
1528 ecmp->ecm_intr_state = USBECM_PIPE_BUSY;
1529 } else {
1530 usb_free_intr_req(intr);
1531 ecmp->ecm_intr_state = USBECM_PIPE_IDLE;
1532 USB_DPRINTF_L3(PRINT_MASK_OPEN, ecmp->ecm_lh,
1533 "usbecm_pipe_start_polling: failed (%d)", rval);
1534 }
1535 mutex_exit(&ecmp->ecm_mutex);
1536
1537 USB_DPRINTF_L3(PRINT_MASK_OPEN, ecmp->ecm_lh,
1538 "usbecm_pipe_start_polling: end, rval=%d", rval);
1539 }
1540
1541
1542 /*
1543 * usbsecm_intr_cb:
1544 * interrupt pipe normal callback
1545 */
1546 /*ARGSUSED*/
1547 static void
1548 usbecm_intr_cb(usb_pipe_handle_t ph, usb_intr_req_t *req)
1549 {
1550 usbecm_state_t *ecmp = (usbecm_state_t *)req->intr_client_private;
1551 mblk_t *data = req->intr_data;
1552 int data_len;
1553
1554 data_len = (data) ? MBLKL(data) : 0;
1555
1556 DTRACE_PROBE2(usbecm_intr__cb, (usb_intr_req_t *), req, int, data_len);
1557
1558 /* check data length */
1559 if (data_len < 8) {
1560 USB_DPRINTF_L2(PRINT_MASK_CB, ecmp->ecm_lh,
1561 "usbsecm_intr_cb: %d packet too short", data_len);
1562 usb_free_intr_req(req);
1563
1564 return;
1565 }
1566 req->intr_data = NULL;
1567 usb_free_intr_req(req);
1568
1569 mutex_enter(&ecmp->ecm_mutex);
1570 /* parse interrupt data -- notifications */
1571 usbecm_parse_intr_data(ecmp, data);
1572 mutex_exit(&ecmp->ecm_mutex);
1573 }
1574
1575
1576 /*
1577 * usbsecm_intr_ex_cb:
1578 * interrupt pipe exception callback
1579 */
1580 /*ARGSUSED*/
1581 static void
1582 usbecm_intr_ex_cb(usb_pipe_handle_t ph, usb_intr_req_t *req)
1583 {
1584 usbecm_state_t *ecmp = (usbecm_state_t *)req->intr_client_private;
1585 usb_cr_t cr = req->intr_completion_reason;
1586
1587 DTRACE_PROBE2(usbecm_intr_ex__cb, int, ecmp->ecm_dev_state,
1588 (usb_cr_t), cr);
1589
1590 usb_free_intr_req(req);
1591
1592 /*
1593 * If completion reason isn't USB_CR_PIPE_CLOSING and
1594 * USB_CR_STOPPED_POLLING, restart polling.
1595 */
1596 if ((cr != USB_CR_PIPE_CLOSING) && (cr != USB_CR_STOPPED_POLLING)) {
1597 mutex_enter(&ecmp->ecm_mutex);
1598
1599 if (ecmp->ecm_dev_state != USB_DEV_ONLINE) {
1600
1601 USB_DPRINTF_L2(PRINT_MASK_CB, ecmp->ecm_lh,
1602 "usbsecm_intr_ex_cb: state = %d",
1603 ecmp->ecm_dev_state);
1604
1605 mutex_exit(&ecmp->ecm_mutex);
1606
1607 return;
1608 }
1609 mutex_exit(&ecmp->ecm_mutex);
1610
1611 usbecm_pipe_start_polling(ecmp);
1612 }
1613 }
1614
1615
1616 /*
1617 * usbsecm_parse_intr_data:
1618 * Parse data received from interrupt callback
1619 */
1620 static void
1621 usbecm_parse_intr_data(usbecm_state_t *ecmp, mblk_t *data)
1622 {
1623 uint8_t bmRequestType;
1624 uint8_t bNotification;
1625 uint16_t wValue;
1626 uint16_t wLength;
1627 int linkstate;
1628
1629 bmRequestType = data->b_rptr[0];
1630 bNotification = data->b_rptr[1];
1631 /*
1632 * If Notification type is NETWORK_CONNECTION, wValue is 0 or 1,
1633 * mLength is 0. If Notification type is SERIAL_TYPE, mValue is 0,
1634 * mLength is 2. So we directly get the value from the byte.
1635 */
1636 wValue = data->b_rptr[2];
1637 wLength = data->b_rptr[6];
1638
1639 if (ecmp->ecm_compatibility) {
1640 if (bmRequestType != USB_CDC_NOTIFICATION_REQUEST_TYPE) {
1641 USB_DPRINTF_L2(PRINT_MASK_CB, ecmp->ecm_lh,
1642 "usbsecm_parse_intr_data: unknown request "
1643 "type - 0x%x", bmRequestType);
1644
1645 freemsg(data);
1646
1647 return;
1648 }
1649 } else {
1650 /* non-compatible device specific parsing */
1651 if (ECM_DS_OP_VALID(ecm_ds_intr_cb)) {
1652 if (ecmp->ecm_ds_ops->ecm_ds_intr_cb(ecmp, data)
1653 != USB_SUCCESS) {
1654 USB_DPRINTF_L2(PRINT_MASK_CB, ecmp->ecm_lh,
1655 "usbsecm_parse_intr_data: unknown request"
1656 "type - 0x%x", bmRequestType);
1657 }
1658 }
1659 freemsg(data);
1660
1661 return;
1662 }
1663
1664 /*
1665 * Check the return value of compatible devices
1666 */
1667 switch (bNotification) {
1668 case USB_CDC_NOTIFICATION_NETWORK_CONNECTION:
1669 USB_DPRINTF_L3(PRINT_MASK_CB, ecmp->ecm_lh,
1670 "usbsecm_parse_intr_data: %s network!",
1671 wValue ? "connected to" :"disconnected from");
1672
1673 linkstate = wValue ? LINK_STATE_UP:LINK_STATE_DOWN;
1674 if (ecmp->ecm_stat.es_linkstate == linkstate) {
1675 /* no changes to previous state */
1676 break;
1677 }
1678
1679 ecmp->ecm_stat.es_linkstate = linkstate;
1680 mutex_exit(&ecmp->ecm_mutex);
1681 mac_link_update(ecmp->ecm_mh, linkstate);
1682 mutex_enter(&ecmp->ecm_mutex);
1683
1684 break;
1685 case USB_CDC_NOTIFICATION_RESPONSE_AVAILABLE:
1686 USB_DPRINTF_L3(PRINT_MASK_CB, ecmp->ecm_lh,
1687 "usbsecm_parse_intr_data: A response is a available.");
1688
1689 break;
1690 case USB_CDC_NOTIFICATION_SPEED_CHANGE:
1691 USB_DPRINTF_L3(PRINT_MASK_CB, ecmp->ecm_lh,
1692 "usbsecm_parse_intr_data: speed change");
1693
1694 /* check the parameter's length. */
1695 if (wLength != 8) {
1696 USB_DPRINTF_L3(PRINT_MASK_CB, ecmp->ecm_lh,
1697 "usbsecm_parse_intr_data: error data length.");
1698 } else {
1699 uint32_t us_rate, ds_rate;
1700 uint8_t *sp;
1701
1702 sp = &data->b_rptr[8];
1703 LE_TO_UINT32(sp, us_rate);
1704 sp = &data->b_rptr[12];
1705 LE_TO_UINT32(sp, ds_rate);
1706 ecmp->ecm_stat.es_upspeed = us_rate;
1707 ecmp->ecm_stat.es_downspeed = ds_rate;
1708 }
1709
1710 break;
1711 default:
1712 USB_DPRINTF_L3(PRINT_MASK_CB, ecmp->ecm_lh,
1713 "usbsecm_parse_intr_data: unknown notification - 0x%x!",
1714 bNotification);
1715
1716 break;
1717 }
1718
1719 freemsg(data);
1720 }
1721
1722 /*
1723 * usbecm_restore_device_state:
1724 * restore device state after CPR resume or reconnect
1725 */
1726 static int
1727 usbecm_restore_device_state(usbecm_state_t *ecmp)
1728 {
1729 int state;
1730
1731 USB_DPRINTF_L4(PRINT_MASK_EVENTS, ecmp->ecm_lh,
1732 "usbecm_restore_device_state: ");
1733
1734 mutex_enter(&ecmp->ecm_mutex);
1735 state = ecmp->ecm_dev_state;
1736 mutex_exit(&ecmp->ecm_mutex);
1737
1738 /* Check device status */
1739 if ((state != USB_DEV_DISCONNECTED) && (state != USB_DEV_SUSPENDED)) {
1740
1741 return (state);
1742 }
1743
1744 /* Check if we are talking to the same device */
1745 if (usb_check_same_device(ecmp->ecm_dip, ecmp->ecm_lh, USB_LOG_L0,
1746 -1, USB_CHK_ALL, NULL) != USB_SUCCESS) {
1747 mutex_enter(&ecmp->ecm_mutex);
1748 state = ecmp->ecm_dev_state = USB_DEV_DISCONNECTED;
1749 mutex_exit(&ecmp->ecm_mutex);
1750
1751 return (state);
1752 }
1753
1754 if (state == USB_DEV_DISCONNECTED) {
1755 USB_DPRINTF_L1(PRINT_MASK_EVENTS, ecmp->ecm_lh,
1756 "usbecm_restore_device_state: Device has been reconnected "
1757 "but data may have been lost");
1758 }
1759
1760 /* if MAC was started, restarted it */
1761 mutex_enter(&ecmp->ecm_mutex);
1762 if (ecmp->ecm_mac_state == USBECM_MAC_STARTED) {
1763 USB_DPRINTF_L3(PRINT_MASK_EVENTS, ecmp->ecm_lh,
1764 "usbecm_restore_device_state: MAC was started");
1765
1766 mutex_exit(&ecmp->ecm_mutex);
1767 /* Do the same operation as usbecm_m_start() does */
1768 if (usbecm_open_pipes(ecmp) != USB_SUCCESS) {
1769
1770 return (state);
1771 }
1772
1773 mutex_enter(&ecmp->ecm_mutex);
1774 if (usbecm_rx_start(ecmp) != USB_SUCCESS) {
1775 mutex_exit(&ecmp->ecm_mutex);
1776
1777 return (state);
1778 }
1779 }
1780 mutex_exit(&ecmp->ecm_mutex);
1781
1782 /*
1783 * init device state
1784 */
1785 mutex_enter(&ecmp->ecm_mutex);
1786 state = ecmp->ecm_dev_state = USB_DEV_ONLINE;
1787 mutex_exit(&ecmp->ecm_mutex);
1788
1789 return (state);
1790 }
1791
1792 /*
1793 * usbecm_reconnect_event_cb:
1794 * called upon when the device is hotplugged back
1795 */
1796 /*ARGSUSED*/
1797 static int
1798 usbecm_reconnect_event_cb(dev_info_t *dip)
1799 {
1800 usbecm_state_t *ecmp =
1801 (usbecm_state_t *)ddi_get_soft_state(usbecm_statep,
1802 ddi_get_instance(dip));
1803
1804 ASSERT(ecmp != NULL);
1805
1806 USB_DPRINTF_L4(PRINT_MASK_EVENTS, ecmp->ecm_lh,
1807 "usbecm_reconnect_event_cb: entry");
1808
1809 (void) usb_serialize_access(ecmp->ecm_ser_acc, USB_WAIT, 0);
1810
1811 mutex_enter(&ecmp->ecm_mutex);
1812 ASSERT(ecmp->ecm_dev_state == USB_DEV_DISCONNECTED);
1813
1814 mutex_exit(&ecmp->ecm_mutex);
1815
1816 if (usbecm_restore_device_state(ecmp) != USB_DEV_ONLINE) {
1817 usb_release_access(ecmp->ecm_ser_acc);
1818
1819 return (USB_FAILURE);
1820 }
1821
1822 usb_release_access(ecmp->ecm_ser_acc);
1823
1824 return (USB_SUCCESS);
1825 }
1826
1827
1828 /*
1829 * usbecm_disconnect_event_cb:
1830 * callback for disconnect events
1831 */
1832 /*ARGSUSED*/
1833 static int
1834 usbecm_disconnect_event_cb(dev_info_t *dip)
1835 {
1836 usbecm_state_t *ecmp = (usbecm_state_t *)ddi_get_soft_state(
1837 usbecm_statep, ddi_get_instance(dip));
1838
1839 USB_DPRINTF_L4(PRINT_MASK_EVENTS, ecmp->ecm_lh,
1840 "usbecm_disconnect_event_cb: entry");
1841
1842 (void) usb_serialize_access(ecmp->ecm_ser_acc, USB_WAIT, 0);
1843
1844 mutex_enter(&ecmp->ecm_mutex);
1845 ecmp->ecm_dev_state = USB_DEV_DISCONNECTED;
1846 mutex_exit(&ecmp->ecm_mutex);
1847
1848 usbecm_close_pipes(ecmp);
1849
1850 usb_release_access(ecmp->ecm_ser_acc);
1851
1852 USB_DPRINTF_L4(PRINT_MASK_EVENTS, ecmp->ecm_lh,
1853 "usbecm_disconnect_event_cb: End");
1854
1855 return (USB_SUCCESS);
1856 }
1857
1858 /*
1859 * power management
1860 * ----------------
1861 *
1862 * usbecm_create_pm_components:
1863 * create PM components
1864 */
1865 static int
1866 usbecm_create_pm_components(usbecm_state_t *ecmp)
1867 {
1868 dev_info_t *dip = ecmp->ecm_dip;
1869 usbecm_pm_t *pm;
1870 uint_t pwr_states;
1871
1872 USB_DPRINTF_L4(PRINT_MASK_PM, ecmp->ecm_lh,
1873 "usbecm_create_pm_components: entry");
1874
1875 if (usb_create_pm_components(dip, &pwr_states) != USB_SUCCESS) {
1876 USB_DPRINTF_L2(PRINT_MASK_PM, ecmp->ecm_lh,
1877 "usbecm_create_pm_components: failed");
1878
1879 /* don't fail the attach process */
1880 return (USB_SUCCESS);
1881 }
1882
1883 pm = ecmp->ecm_pm =
1884 (usbecm_pm_t *)kmem_zalloc(sizeof (usbecm_pm_t), KM_SLEEP);
1885
1886 pm->pm_pwr_states = (uint8_t)pwr_states;
1887 pm->pm_cur_power = USB_DEV_OS_FULL_PWR;
1888 pm->pm_wakeup_enabled = (usb_handle_remote_wakeup(dip,
1889 USB_REMOTE_WAKEUP_ENABLE) == USB_SUCCESS);
1890
1891 (void) pm_raise_power(dip, 0, USB_DEV_OS_FULL_PWR);
1892
1893 return (USB_SUCCESS);
1894 }
1895
1896 /*
1897 * usbecm_cleanup:
1898 * Release resources of current device during detach.
1899 */
1900 static void
1901 usbecm_cleanup(usbecm_state_t *ecmp)
1902 {
1903 USB_DPRINTF_L4(PRINT_MASK_CLOSE, ecmp->ecm_lh,
1904 "usbecm_cleanup: ");
1905
1906 if (ecmp == NULL) {
1907
1908 return;
1909 }
1910
1911 usbecm_close_pipes(ecmp);
1912
1913 /* unregister callback function */
1914 if (ecmp->ecm_init_flags & USBECM_INIT_EVENTS) {
1915 USB_DPRINTF_L4(PRINT_MASK_CLOSE, ecmp->ecm_lh,
1916 "usbecm_cleanup: unregister events");
1917
1918 usb_unregister_event_cbs(ecmp->ecm_dip, &usbecm_events);
1919 }
1920
1921 /* destroy power management components */
1922 if (ecmp->ecm_pm != NULL) {
1923 USB_DPRINTF_L4(PRINT_MASK_CLOSE, ecmp->ecm_lh,
1924 "usbecm_cleanup: destroy pm");
1925 usbecm_destroy_pm_components(ecmp);
1926 }
1927
1928 /* free description of device tree. */
1929 if (ecmp->ecm_def_ph != NULL) {
1930 mutex_destroy(&ecmp->ecm_mutex);
1931
1932 usb_free_descr_tree(ecmp->ecm_dip, ecmp->ecm_dev_data);
1933 ecmp->ecm_def_ph = NULL;
1934 }
1935
1936 if (ecmp->ecm_lh != NULL) {
1937 usb_free_log_hdl(ecmp->ecm_lh);
1938 ecmp->ecm_lh = NULL;
1939 }
1940
1941 /* detach client device */
1942 if (ecmp->ecm_dev_data != NULL) {
1943 usb_client_detach(ecmp->ecm_dip, ecmp->ecm_dev_data);
1944 }
1945
1946 if (ecmp->ecm_init_flags & USBECM_INIT_MAC) {
1947 (void) usbecm_mac_fini(ecmp);
1948 }
1949
1950 if (ecmp->ecm_init_flags & USBECM_INIT_SER) {
1951 usb_fini_serialization(ecmp->ecm_ser_acc);
1952 }
1953
1954 ddi_prop_remove_all(ecmp->ecm_dip);
1955 ddi_remove_minor_node(ecmp->ecm_dip, NULL);
1956 }
1957
1958 /*
1959 * usbecm_destroy_pm_components:
1960 * destroy PM components
1961 */
1962 static void
1963 usbecm_destroy_pm_components(usbecm_state_t *ecmp)
1964 {
1965 usbecm_pm_t *pm = ecmp->ecm_pm;
1966 dev_info_t *dip = ecmp->ecm_dip;
1967 int rval;
1968
1969 USB_DPRINTF_L4(PRINT_MASK_PM, ecmp->ecm_lh,
1970 "usbecm_destroy_pm_components: ");
1971
1972 if (ecmp->ecm_dev_state != USB_DEV_DISCONNECTED) {
1973 if (pm->pm_wakeup_enabled) {
1974 rval = pm_raise_power(dip, 0, USB_DEV_OS_FULL_PWR);
1975 if (rval != DDI_SUCCESS) {
1976 USB_DPRINTF_L2(PRINT_MASK_PM, ecmp->ecm_lh,
1977 "usbecm_destroy_pm_components: "
1978 "raising power failed (%d)", rval);
1979 }
1980
1981 rval = usb_handle_remote_wakeup(dip,
1982 USB_REMOTE_WAKEUP_DISABLE);
1983 if (rval != USB_SUCCESS) {
1984 USB_DPRINTF_L2(PRINT_MASK_PM, ecmp->ecm_lh,
1985 "usbecm_destroy_pm_components: "
1986 "disable remote wakeup failed (%d)", rval);
1987 }
1988 }
1989
1990 (void) pm_lower_power(dip, 0, USB_DEV_OS_PWR_OFF);
1991 }
1992 kmem_free((caddr_t)pm, sizeof (usbecm_pm_t));
1993 ecmp->ecm_pm = NULL;
1994 }
1995
1996 /*
1997 * usbecm_pm_set_busy:
1998 * mark device busy and raise power
1999 */
2000 static void
2001 usbecm_pm_set_busy(usbecm_state_t *ecmp)
2002 {
2003 usbecm_pm_t *pm = ecmp->ecm_pm;
2004 dev_info_t *dip = ecmp->ecm_dip;
2005 int rval;
2006
2007 USB_DPRINTF_L4(PRINT_MASK_PM, ecmp->ecm_lh,
2008 "usbecm_pm_set_busy: pm = 0x%p", (void *)pm);
2009
2010 if (pm == NULL) {
2011
2012 return;
2013 }
2014
2015 mutex_enter(&ecmp->ecm_mutex);
2016 /* if already marked busy, just increment the counter */
2017 if (pm->pm_busy_cnt++ > 0) {
2018 mutex_exit(&ecmp->ecm_mutex);
2019
2020 return;
2021 }
2022
2023 (void) pm_busy_component(dip, 0);
2024
2025 if (pm->pm_cur_power == USB_DEV_OS_FULL_PWR) {
2026 mutex_exit(&ecmp->ecm_mutex);
2027
2028 return;
2029 }
2030
2031 /* need to raise power */
2032 pm->pm_raise_power = B_TRUE;
2033 mutex_exit(&ecmp->ecm_mutex);
2034
2035 rval = pm_raise_power(dip, 0, USB_DEV_OS_FULL_PWR);
2036 if (rval != DDI_SUCCESS) {
2037 USB_DPRINTF_L2(PRINT_MASK_PM, ecmp->ecm_lh,
2038 "usbecm_pm_set_busy: raising power failed");
2039 }
2040
2041 mutex_enter(&ecmp->ecm_mutex);
2042 pm->pm_raise_power = B_FALSE;
2043 mutex_exit(&ecmp->ecm_mutex);
2044 }
2045
2046
2047 /*
2048 * usbecm_pm_set_idle:
2049 * mark device idle
2050 */
2051 static void
2052 usbecm_pm_set_idle(usbecm_state_t *ecmp)
2053 {
2054 usbecm_pm_t *pm = ecmp->ecm_pm;
2055 dev_info_t *dip = ecmp->ecm_dip;
2056
2057 USB_DPRINTF_L4(PRINT_MASK_PM, ecmp->ecm_lh,
2058 "usbecm_pm_set_idle: ");
2059
2060 if (pm == NULL) {
2061
2062 return;
2063 }
2064
2065 mutex_enter(&ecmp->ecm_mutex);
2066 if (--pm->pm_busy_cnt > 0) {
2067 mutex_exit(&ecmp->ecm_mutex);
2068
2069 return;
2070 }
2071
2072 if (pm) {
2073 (void) pm_idle_component(dip, 0);
2074 }
2075 mutex_exit(&ecmp->ecm_mutex);
2076 }
2077
2078
2079 /*
2080 * usbecm_pwrlvl0:
2081 * Functions to handle power transition for OS levels 0 -> 3
2082 * The same level as OS state, different from USB state
2083 */
2084 static int
2085 usbecm_pwrlvl0(usbecm_state_t *ecmp)
2086 {
2087 int rval;
2088
2089 ASSERT(mutex_owned(&ecmp->ecm_mutex));
2090
2091 USB_DPRINTF_L4(PRINT_MASK_PM, ecmp->ecm_lh,
2092 "usbecm_pwrlvl0: ");
2093
2094 switch (ecmp->ecm_dev_state) {
2095 case USB_DEV_ONLINE:
2096 /* issue USB D3 command to the device */
2097 rval = usb_set_device_pwrlvl3(ecmp->ecm_dip);
2098 ASSERT(rval == USB_SUCCESS);
2099 if ((ecmp->ecm_intr_ph != NULL) &&
2100 (ecmp->ecm_intr_state == USBECM_PIPE_BUSY)) {
2101 mutex_exit(&ecmp->ecm_mutex);
2102 usb_pipe_stop_intr_polling(ecmp->ecm_intr_ph,
2103 USB_FLAGS_SLEEP);
2104 mutex_enter(&ecmp->ecm_mutex);
2105
2106 ecmp->ecm_intr_state = USBECM_PIPE_IDLE;
2107 }
2108 ecmp->ecm_dev_state = USB_DEV_PWRED_DOWN;
2109 ecmp->ecm_pm->pm_cur_power = USB_DEV_OS_PWR_OFF;
2110
2111 /* FALLTHRU */
2112 case USB_DEV_DISCONNECTED:
2113 case USB_DEV_SUSPENDED:
2114 /* allow a disconnect/cpr'ed device to go to lower power */
2115
2116 return (USB_SUCCESS);
2117 case USB_DEV_PWRED_DOWN:
2118 default:
2119 USB_DPRINTF_L2(PRINT_MASK_PM, ecmp->ecm_lh,
2120 "usbecm_pwrlvl0: illegal device state");
2121
2122 return (USB_FAILURE);
2123 }
2124 }
2125
2126
2127 /*
2128 * usbecm_pwrlvl1:
2129 * Functions to handle power transition for OS levels 1 -> 2
2130 */
2131 static int
2132 usbecm_pwrlvl1(usbecm_state_t *ecmp)
2133 {
2134 /* issue USB D2 command to the device */
2135 (void) usb_set_device_pwrlvl2(ecmp->ecm_dip);
2136
2137 return (USB_FAILURE);
2138 }
2139
2140
2141 /*
2142 * usbecm_pwrlvl2:
2143 * Functions to handle power transition for OS levels 2 -> 1
2144 */
2145 static int
2146 usbecm_pwrlvl2(usbecm_state_t *ecmp)
2147 {
2148 /* issue USB D1 command to the device */
2149 (void) usb_set_device_pwrlvl1(ecmp->ecm_dip);
2150
2151 return (USB_FAILURE);
2152 }
2153
2154
2155 /*
2156 * usbecm_pwrlvl3:
2157 * Functions to handle power transition for OS levels 3 -> 0
2158 * The same level as OS state, different from USB state
2159 */
2160 static int
2161 usbecm_pwrlvl3(usbecm_state_t *ecmp)
2162 {
2163 int rval;
2164
2165 USB_DPRINTF_L4(PRINT_MASK_PM, ecmp->ecm_lh,
2166 "usbecm_pwrlvl3: ");
2167
2168 ASSERT(mutex_owned(&ecmp->ecm_mutex));
2169
2170 switch (ecmp->ecm_dev_state) {
2171 case USB_DEV_PWRED_DOWN:
2172 /* Issue USB D0 command to the device here */
2173 rval = usb_set_device_pwrlvl0(ecmp->ecm_dip);
2174 ASSERT(rval == USB_SUCCESS);
2175
2176 if (ecmp->ecm_intr_ph != NULL &&
2177 ecmp->ecm_intr_state == USBECM_PIPE_IDLE) {
2178 mutex_exit(&ecmp->ecm_mutex);
2179 usbecm_pipe_start_polling(ecmp);
2180 mutex_enter(&ecmp->ecm_mutex);
2181 }
2182
2183 ecmp->ecm_dev_state = USB_DEV_ONLINE;
2184 ecmp->ecm_pm->pm_cur_power = USB_DEV_OS_FULL_PWR;
2185
2186 /* FALLTHRU */
2187 case USB_DEV_ONLINE:
2188 /* we are already in full power */
2189
2190 /* FALLTHRU */
2191 case USB_DEV_DISCONNECTED:
2192 case USB_DEV_SUSPENDED:
2193
2194 return (USB_SUCCESS);
2195 default:
2196 USB_DPRINTF_L2(PRINT_MASK_PM, ecmp->ecm_lh,
2197 "usbecm_pwrlvl3: illegal device state");
2198
2199 return (USB_FAILURE);
2200 }
2201 }
2202
2203 /*ARGSUSED*/
2204 static int
2205 usbecm_power(dev_info_t *dip, int comp, int level)
2206 {
2207 usbecm_state_t *ecmp;
2208 usbecm_pm_t *pm;
2209 int rval = USB_SUCCESS;
2210
2211 ecmp = ddi_get_soft_state(usbecm_statep, ddi_get_instance(dip));
2212 pm = ecmp->ecm_pm;
2213
2214 USB_DPRINTF_L4(PRINT_MASK_PM, ecmp->ecm_lh,
2215 "usbecm_power: entry");
2216
2217 /* check if pm is NULL */
2218 if (pm == NULL) {
2219 USB_DPRINTF_L2(PRINT_MASK_PM, ecmp->ecm_lh,
2220 "usbecm_power: pm is NULL.");
2221
2222 return (USB_FAILURE);
2223 }
2224
2225 mutex_enter(&ecmp->ecm_mutex);
2226 /*
2227 * check if we are transitioning to a legal power level
2228 */
2229 if (USB_DEV_PWRSTATE_OK(pm->pm_pwr_states, level)) {
2230 USB_DPRINTF_L2(PRINT_MASK_PM, ecmp->ecm_lh,
2231 "usbecm_power: "
2232 "illegal power level %d, pwr_states=%x",
2233 level, pm->pm_pwr_states);
2234 mutex_exit(&ecmp->ecm_mutex);
2235
2236 return (USB_FAILURE);
2237 }
2238
2239 /*
2240 * if we are about to raise power and asked to lower power, fail
2241 */
2242 if (pm->pm_raise_power && (level < (int)pm->pm_cur_power)) {
2243 USB_DPRINTF_L2(PRINT_MASK_PM, ecmp->ecm_lh,
2244 "usbecm_power: wrong condition.");
2245 mutex_exit(&ecmp->ecm_mutex);
2246
2247 return (USB_FAILURE);
2248 }
2249
2250 /*
2251 * Set the power status of device by request level.
2252 */
2253 switch (level) {
2254 case USB_DEV_OS_PWR_OFF:
2255 rval = usbecm_pwrlvl0(ecmp);
2256
2257 break;
2258 case USB_DEV_OS_PWR_1:
2259 rval = usbecm_pwrlvl1(ecmp);
2260
2261 break;
2262 case USB_DEV_OS_PWR_2:
2263 rval = usbecm_pwrlvl2(ecmp);
2264
2265 break;
2266 case USB_DEV_OS_FULL_PWR:
2267 rval = usbecm_pwrlvl3(ecmp);
2268
2269 break;
2270 }
2271
2272 mutex_exit(&ecmp->ecm_mutex);
2273
2274 return (rval);
2275 }
2276
2277 /*
2278 * Register with the MAC layer.
2279 */
2280 static int
2281 usbecm_mac_init(usbecm_state_t *ecmp)
2282 {
2283 mac_register_t *macp;
2284 int err;
2285
2286 /*
2287 * Initialize mac structure
2288 */
2289 macp = mac_alloc(MAC_VERSION);
2290 if (macp == NULL) {
2291 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
2292 "failed to allocate MAC structure");
2293
2294 return (USB_FAILURE);
2295 }
2296
2297 /*
2298 * Initialize pointer to device specific functions
2299 */
2300 macp->m_type_ident = MAC_PLUGIN_IDENT_ETHER;
2301 macp->m_driver = ecmp;
2302 macp->m_dip = ecmp->ecm_dip;
2303
2304 macp->m_src_addr = ecmp->ecm_srcaddr;
2305 macp->m_callbacks = &usbecm_m_callbacks;
2306 macp->m_min_sdu = 0;
2307 macp->m_max_sdu = ETHERMTU;
2308
2309 /*
2310 * Register the macp to mac
2311 */
2312 err = mac_register(macp, &ecmp->ecm_mh);
2313 mac_free(macp);
2314
2315 if (err != DDI_SUCCESS) {
2316 USB_DPRINTF_L1(PRINT_MASK_ATTA, ecmp->ecm_lh,
2317 "failed to register MAC structure");
2318
2319 return (USB_FAILURE);
2320 }
2321
2322 mac_link_update(ecmp->ecm_mh, LINK_STATE_DOWN);
2323 ecmp->ecm_stat.es_linkstate = LINK_STATE_DOWN;
2324 ecmp->ecm_tx_cnt = 0;
2325
2326 return (USB_SUCCESS);
2327 }
2328
2329 static int
2330 usbecm_mac_fini(usbecm_state_t *ecmp)
2331 {
2332 int rval = DDI_SUCCESS;
2333
2334 if ((ecmp->ecm_init_flags & USBECM_INIT_MAC) == 0) {
2335 return (DDI_SUCCESS);
2336 }
2337
2338 ecmp->ecm_init_flags &= ~USBECM_INIT_MAC;
2339 if ((rval = mac_disable(ecmp->ecm_mh)) != 0) {
2340 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
2341 "failed to disable MAC");
2342
2343 return (rval);
2344 }
2345
2346 (void) mac_unregister(ecmp->ecm_mh);
2347
2348 return (rval);
2349 }
2350
2351 static int
2352 usbecm_resume(usbecm_state_t *ecmp)
2353 {
2354 int current_state;
2355 int ret;
2356
2357 USB_DPRINTF_L4(PRINT_MASK_PM, ecmp->ecm_lh,
2358 "usbecm_resume: ");
2359
2360 mutex_enter(&ecmp->ecm_mutex);
2361 current_state = ecmp->ecm_dev_state;
2362 mutex_exit(&ecmp->ecm_mutex);
2363
2364 /* restore the status of device */
2365 if (current_state != USB_DEV_ONLINE) {
2366 ret = usbecm_restore_device_state(ecmp);
2367 } else {
2368 ret = USB_DEV_ONLINE;
2369 }
2370
2371 return (ret);
2372 }
2373
2374 static int
2375 usbecm_suspend(usbecm_state_t *ecmp)
2376 {
2377 (void) usb_serialize_access(ecmp->ecm_ser_acc, USB_WAIT, 0);
2378
2379 mutex_enter(&ecmp->ecm_mutex);
2380 ecmp->ecm_dev_state = USB_DEV_SUSPENDED;
2381 mutex_exit(&ecmp->ecm_mutex);
2382
2383 usbecm_close_pipes(ecmp);
2384
2385 usb_release_access(ecmp->ecm_ser_acc);
2386
2387 return (0);
2388 }
2389
2390 /*
2391 * Translate MAC address from string to 6 bytes array int value
2392 * Can't use ether_aton() since it requires format of x:x:x:x:x:x
2393 */
2394 void
2395 label_to_mac(char *hex, unsigned char *mac)
2396 {
2397 int i;
2398 char c;
2399
2400 /* can only count 6 bytes! */
2401 for (i = 0; i < 6; i++) {
2402 /* upper 4 bits */
2403 if (!isdigit(hex[2*i])) {
2404 c = (toupper(hex[2 * i]) - 'A' + 10);
2405 } else {
2406 c = (hex[2 * i] - '0');
2407 }
2408 mac[i] = c * 16;
2409
2410 /* lower 4 bits */
2411 if (!isdigit(hex[2*i + 1])) {
2412 c = (toupper(hex[2 * i + 1]) - 'A' + 10);
2413 } else {
2414 c = hex[2 * i + 1] - '0';
2415 }
2416 mac[i] += c;
2417 }
2418 }
2419
2420 /*
2421 * usbecm_get_descriptors:
2422 * parse functional descriptors of ecm compatible device
2423 */
2424 static int
2425 usbecm_get_descriptors(usbecm_state_t *ecmp)
2426 {
2427 int i;
2428 usb_cfg_data_t *cfg;
2429 usb_alt_if_data_t *altif;
2430 usb_cvs_data_t *cvs;
2431 int16_t master_if = -1, slave_if = -1;
2432 usb_cdc_ecm_descr_t ecm_desc;
2433 usb_ep_data_t *ep_data;
2434 usb_dev_descr_t *usb_dev_desc;
2435
2436 USB_DPRINTF_L4(PRINT_MASK_ATTA, ecmp->ecm_lh,
2437 "usbecm_get_descriptors: ");
2438
2439 usb_dev_desc = ecmp->ecm_dev_data->dev_descr;
2440
2441 /*
2442 * Special treatment of Sun's SP Ethernet device.
2443 */
2444 if ((usb_dev_desc->idVendor == SUN_SP_VENDOR_ID) &&
2445 (usb_dev_desc->idProduct == SUN_SP_PRODUCT_ID)) {
2446 if (usb_set_cfg(ecmp->ecm_dip, ecmp->ecm_cfg_index,
2447 USB_FLAGS_SLEEP, NULL, NULL) != USB_SUCCESS) {
2448 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
2449 "usbecm_get_descriptors: fail to set cfg ");
2450 } else {
2451 usb_free_dev_data(ecmp->ecm_dip, ecmp->ecm_dev_data);
2452 if (usb_get_dev_data(ecmp->ecm_dip, &ecmp->ecm_dev_data,
2453 USB_PARSE_LVL_ALL, 0) != USB_SUCCESS) {
2454 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
2455 "usbecm_get_descriptors: fail to get"
2456 " dev_data");
2457
2458 return (USB_FAILURE);
2459 }
2460 }
2461 }
2462
2463 cfg = ecmp->ecm_dev_data->dev_curr_cfg;
2464
2465 /* set default control and data interface */
2466 ecmp->ecm_ctrl_if_no = ecmp->ecm_data_if_no = 0;
2467
2468 /* get current interfaces */
2469 ecmp->ecm_ctrl_if_no = ecmp->ecm_dev_data->dev_curr_if;
2470 if (cfg->cfg_if[ecmp->ecm_ctrl_if_no].if_n_alt == 0) {
2471 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
2472 "usbecm_get_descriptors: elements in if_alt is %d",
2473 cfg->cfg_if[ecmp->ecm_ctrl_if_no].if_n_alt);
2474
2475 return (USB_FAILURE);
2476 }
2477
2478 altif = &cfg->cfg_if[ecmp->ecm_ctrl_if_no].if_alt[0];
2479
2480 /*
2481 * Based on CDC specification, ECM devices usually include the
2482 * following function descriptors: Header, Union and ECM
2483 * Contry Selection function descriptors. This loop search tree data
2484 * structure for each ecm class descriptor.
2485 */
2486 for (i = 0; i < altif->altif_n_cvs; i++) {
2487 cvs = &altif->altif_cvs[i];
2488
2489 if ((cvs->cvs_buf == NULL) ||
2490 (cvs->cvs_buf[1] != USB_CDC_CS_INTERFACE)) {
2491 continue;
2492 }
2493
2494 switch (cvs->cvs_buf[2]) {
2495 case USB_CDC_DESCR_TYPE_HEADER:
2496 /*
2497 * parse header functional descriptor
2498 * Just to check integrity.
2499 */
2500 if (cvs->cvs_buf_len != 5) {
2501 return (USB_FAILURE);
2502 }
2503 break;
2504 case USB_CDC_DESCR_TYPE_ETHERNET:
2505 /* parse ECM functional descriptor */
2506 if (cvs->cvs_buf_len >= USB_CDC_ECM_LEN) {
2507 char buf[USB_MAXSTRINGLEN];
2508
2509 if (usb_parse_data("4cl2sc", cvs->cvs_buf,
2510 cvs->cvs_buf_len, (void *)&ecm_desc,
2511 (size_t)USB_CDC_ECM_LEN) <
2512 USB_CDC_ECM_LEN) {
2513
2514 return (USB_FAILURE);
2515 }
2516
2517 /* get the MAC address */
2518 if (usb_get_string_descr(ecmp->ecm_dip,
2519 USB_LANG_ID, ecm_desc.iMACAddress, buf,
2520 USB_MAXSTRINGLEN) != USB_SUCCESS) {
2521
2522 return (USB_FAILURE);
2523 }
2524
2525 USB_DPRINTF_L3(PRINT_MASK_ATTA, ecmp->ecm_lh,
2526 "usbecm_get_descriptors: macaddr=%s ",
2527 buf);
2528
2529 /* expects 12 characters */
2530 if (strlen(buf) < 12) {
2531 return (USB_FAILURE);
2532 }
2533 label_to_mac(buf, ecmp->ecm_srcaddr);
2534
2535 bcopy(&ecm_desc, &ecmp->ecm_desc,
2536 USB_CDC_ECM_LEN);
2537 }
2538 break;
2539 case USB_CDC_DESCR_TYPE_UNION:
2540 /* parse Union functional descriptor. */
2541 if (cvs->cvs_buf_len >= 5) {
2542 master_if = cvs->cvs_buf[3];
2543 slave_if = cvs->cvs_buf[4];
2544 }
2545 break;
2546 default:
2547 break;
2548 }
2549 }
2550
2551 /* For usb ecm devices, it must satisfy the following options. */
2552 if (cfg->cfg_n_if < 2) {
2553 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
2554 "usbecm_get_descriptors: # of interfaces %d < 2",
2555 cfg->cfg_n_if);
2556
2557 return (USB_FAILURE);
2558 }
2559
2560 if (ecmp->ecm_data_if_no == 0 &&
2561 slave_if != ecmp->ecm_data_if_no) {
2562 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
2563 "usbecm_get_descriptors: Device has no call management "
2564 "descriptor and use Union Descriptor.");
2565
2566 ecmp->ecm_data_if_no = slave_if;
2567 }
2568
2569 if ((master_if != ecmp->ecm_ctrl_if_no) ||
2570 (slave_if != ecmp->ecm_data_if_no)) {
2571 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
2572 "usbecm_get_descriptors: control interface or "
2573 "data interface don't match.");
2574
2575 return (USB_FAILURE);
2576 }
2577
2578 if ((ecmp->ecm_ctrl_if_no >= cfg->cfg_n_if) ||
2579 (ecmp->ecm_data_if_no >= cfg->cfg_n_if)) {
2580 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
2581 "usbecm_get_descriptors: control interface %d or "
2582 "data interface %d out of range.",
2583 ecmp->ecm_ctrl_if_no, ecmp->ecm_data_if_no);
2584
2585 return (USB_FAILURE);
2586 }
2587
2588 /* ECM data interface has a minimal of two altsettings */
2589 if (cfg->cfg_if[ecmp->ecm_data_if_no].if_n_alt < 2) {
2590 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
2591 "usbecm_get_descriptors: elements in if_alt is %d,"
2592 " MUST >= 2", cfg->cfg_if[ecmp->ecm_ctrl_if_no].if_n_alt);
2593
2594 return (USB_FAILURE);
2595 }
2596
2597 /* control interface must have interrupt endpoint */
2598 if ((ep_data = usb_lookup_ep_data(ecmp->ecm_dip, ecmp->ecm_dev_data,
2599 ecmp->ecm_ctrl_if_no, 0, 0, USB_EP_ATTR_INTR,
2600 USB_EP_DIR_IN)) == NULL) {
2601 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
2602 "usbecm_get_descriptors: "
2603 "ctrl interface %d has no interrupt endpoint",
2604 ecmp->ecm_data_if_no);
2605
2606 return (USB_FAILURE);
2607 }
2608 ecmp->ecm_intr_ep = ep_data;
2609
2610 /* data interface alt 1 must have bulk in and out(ECM v1.2,p5) */
2611 if ((ep_data = usb_lookup_ep_data(ecmp->ecm_dip, ecmp->ecm_dev_data,
2612 ecmp->ecm_data_if_no, 1, 0, USB_EP_ATTR_BULK,
2613 USB_EP_DIR_IN)) == NULL) {
2614 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
2615 "usbecm_get_descriptors: "
2616 "data interface %d has no bulk in endpoint",
2617 ecmp->ecm_data_if_no);
2618
2619 return (USB_FAILURE);
2620 }
2621 ecmp->ecm_bulk_in_ep = ep_data;
2622
2623 if ((ep_data = usb_lookup_ep_data(ecmp->ecm_dip, ecmp->ecm_dev_data,
2624 ecmp->ecm_data_if_no, 1, 0, USB_EP_ATTR_BULK,
2625 USB_EP_DIR_OUT)) == NULL) {
2626 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
2627 "usbecm_get_descriptors: "
2628 "data interface %d has no bulk out endpoint",
2629 ecmp->ecm_data_if_no);
2630
2631 return (USB_FAILURE);
2632 }
2633 ecmp->ecm_bulk_out_ep = ep_data;
2634
2635 /* set default value for ethernet packet filter */
2636 ecmp->ecm_pkt_flt = CDC_ECM_PKT_TYPE_DIRECTED;
2637
2638 return (USB_SUCCESS);
2639 }
2640
2641 /* Generate IEEE802 style MAC address */
2642 static void
2643 generate_ether_addr(uint8_t *mac_addr)
2644 {
2645 (void) random_get_bytes(mac_addr, 6);
2646 mac_addr [0] &= 0xfe; /* unicast only */
2647 mac_addr [0] |= 0x02; /* set locally administered bit */
2648 }
2649
2650 /*
2651 * Find a pair of bulk In/Out endpoints
2652 */
2653 int usbecm_find_bulk_in_out_eps(usbecm_state_t *ecmp,
2654 uint16_t ifc, usb_if_data_t *intf)
2655 {
2656 uint16_t alt, alt_num;
2657 usb_ep_data_t *intr_ep = NULL;
2658 usb_ep_data_t *bulk_in, *bulk_out, *ep;
2659
2660 alt_num = intf->if_n_alt;
2661
2662 /*
2663 * for the non-compatible devices, to make it simple, we
2664 * suppose the devices have this kind of configuration:
2665 * INTR In EP(if exists) + BULK In + Bulk Out in the
2666 * same altsetting of the same interface
2667 */
2668 for (alt = 0; alt < alt_num; alt++) {
2669 /* search pair of bulk in/out EPs */
2670 if (((bulk_in = usb_lookup_ep_data(ecmp->ecm_dip,
2671 ecmp->ecm_dev_data, ifc, alt, 0,
2672 USB_EP_ATTR_BULK,
2673 USB_EP_DIR_IN)) == NULL) ||
2674 (bulk_out = usb_lookup_ep_data(ecmp->ecm_dip,
2675 ecmp->ecm_dev_data, ifc, alt, 0,
2676 USB_EP_ATTR_BULK,
2677 USB_EP_DIR_OUT)) == NULL) {
2678
2679 continue;
2680 }
2681
2682 /*
2683 * search interrupt pipe.
2684 */
2685 if ((ep = usb_lookup_ep_data(ecmp->ecm_dip,
2686 ecmp->ecm_dev_data, ifc, alt, 0,
2687 USB_EP_ATTR_INTR, USB_EP_DIR_IN)) != NULL) {
2688 intr_ep = ep;
2689 }
2690
2691
2692 ecmp->ecm_data_if_no = ifc;
2693 ecmp->ecm_data_if_alt = alt;
2694 ecmp->ecm_intr_ep = intr_ep;
2695 ecmp->ecm_ctrl_if_no = ifc;
2696 ecmp->ecm_bulk_in_ep = bulk_in;
2697 ecmp->ecm_bulk_out_ep = bulk_out;
2698
2699 return (USB_SUCCESS);
2700 }
2701
2702 return (USB_FAILURE);
2703 }
2704
2705 static int
2706 usbecm_init_non_compatible_device(usbecm_state_t *ecmp)
2707 {
2708 usb_if_data_t *cur_if;
2709 uint16_t if_num, i;
2710
2711 /*
2712 * If device don't conform to spec, search pairs of bulk in/out
2713 * endpoints and fill related structure. We suppose this driver
2714 * is bound to a interface.
2715 */
2716 cur_if = ecmp->ecm_dev_data->dev_curr_cfg->cfg_if;
2717 if_num = ecmp->ecm_dev_data->dev_curr_cfg->cfg_n_if;
2718
2719 /* search each interface which have bulk in and out */
2720 for (i = 0; i < if_num; i++) {
2721 if (usbecm_find_bulk_in_out_eps(ecmp, i,
2722 cur_if) == USB_SUCCESS) {
2723
2724 break;
2725 }
2726 cur_if++;
2727 }
2728
2729 USB_DPRINTF_L4(PRINT_MASK_ATTA, ecmp->ecm_lh,
2730 "usbecm_init_non_compatible_device: ctrl_if=%d,"
2731 " data_if=%d, alt=%d", ecmp->ecm_ctrl_if_no,
2732 ecmp->ecm_data_if_no, ecmp->ecm_data_if_alt);
2733
2734 return (USB_SUCCESS);
2735 }
2736
2737 static boolean_t
2738 usbecm_is_compatible(usbecm_state_t *ecmp)
2739 {
2740 usb_cfg_data_t *cfg_data;
2741 usb_if_data_t *intf;
2742 usb_alt_if_data_t *alt;
2743 int alt_num, if_num, cfg_num;
2744 int i, j, cfg_index;
2745
2746 cfg_num = ecmp->ecm_dev_data->dev_n_cfg;
2747 USB_DPRINTF_L3(PRINT_MASK_ATTA, ecmp->ecm_lh,
2748 "usbecm_is_compatible: entry, cfg_num=%d", cfg_num);
2749
2750 for (cfg_index = 0; cfg_index < cfg_num; cfg_index++) {
2751 cfg_data = &(ecmp->ecm_dev_data->dev_cfg[cfg_index]);
2752
2753 USB_DPRINTF_L3(PRINT_MASK_ATTA, ecmp->ecm_lh,
2754 "usbecm_is_compatible: cfg_index=%d, value=%d",
2755 cfg_index, cfg_data->cfg_descr.bConfigurationValue);
2756
2757 intf = cfg_data->cfg_if;
2758 if_num = cfg_data->cfg_n_if;
2759
2760 for (i = 0; i < if_num; i++) {
2761 alt_num = intf->if_n_alt;
2762 for (j = 0; j < alt_num; j++) {
2763 alt = &intf->if_alt[j];
2764 if ((alt->altif_descr.bInterfaceClass == 0x02) &&
2765 (alt->altif_descr.bInterfaceSubClass == 0x06)) {
2766 ecmp->ecm_cfg_index = cfg_index;
2767
2768 USB_DPRINTF_L3(PRINT_MASK_ATTA, ecmp->ecm_lh,
2769 "usbecm_is_compatible: cfg_index=%d",
2770 cfg_index);
2771
2772 return (B_TRUE);
2773 }
2774 }
2775 intf++;
2776 }
2777 }
2778
2779 return (B_FALSE);
2780 }
2781
2782
2783 static int
2784 usbecm_usb_init(usbecm_state_t *ecmp)
2785 {
2786
2787 if (usb_client_attach(ecmp->ecm_dip, USBDRV_VERSION, 0) !=
2788 USB_SUCCESS) {
2789 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
2790 "usbecm_usb_init: fail to attach");
2791
2792 return (USB_FAILURE);
2793 }
2794
2795 /* Get the configuration information of device */
2796 if (usb_get_dev_data(ecmp->ecm_dip, &ecmp->ecm_dev_data,
2797 USB_PARSE_LVL_ALL, 0) != USB_SUCCESS) {
2798 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
2799 "usbecm_usb_init: fail to get_dev_data");
2800
2801 return (USB_FAILURE);
2802 }
2803 ecmp->ecm_def_ph = ecmp->ecm_dev_data->dev_default_ph;
2804 ecmp->ecm_dev_state = USB_DEV_ONLINE;
2805
2806 mutex_init(&ecmp->ecm_mutex, NULL, MUTEX_DRIVER,
2807 ecmp->ecm_dev_data->dev_iblock_cookie);
2808
2809 if ((strcmp(ddi_binding_name(ecmp->ecm_dip),
2810 "usbif,class2.6") == 0) ||
2811 ((strcmp(ddi_binding_name(ecmp->ecm_dip),
2812 "usb,class2.6.0") == 0))) {
2813 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
2814 "usbecm_usb_init: A CDC ECM device is attached");
2815 ecmp->ecm_compatibility = B_TRUE;
2816 } else if (usb_owns_device(ecmp->ecm_dip) &&
2817 usbecm_is_compatible(ecmp)) {
2818 /*
2819 * Current Sun SP ECM device has two configurations. Hence
2820 * USBA doesn't create interface level compatible names
2821 * for it, see usba_ready_device_node(). We have to check
2822 * manually to see if compatible interfaces exist, when
2823 * the driver owns the entire device.
2824 */
2825 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
2826 "usbecm_usb_init: A CDC ECM device is attached");
2827 ecmp->ecm_compatibility = B_TRUE;
2828 } else {
2829 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
2830 "usbecm_usb_init: A nonstandard device is attached to "
2831 "usbecm(7D) driver. This device doesn't conform to "
2832 "usb cdc spec.");
2833 ecmp->ecm_compatibility = B_FALSE;
2834
2835 /* generate a random MAC addr */
2836 generate_ether_addr(ecmp->ecm_srcaddr);
2837 }
2838
2839 if ((ecmp->ecm_compatibility == B_TRUE) &&
2840 (usbecm_get_descriptors(ecmp) != USB_SUCCESS)) {
2841 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
2842 "usbecm_usb_init: A compatible device is attached, but "
2843 "fail to get standard descriptors");
2844
2845 return (USB_FAILURE);
2846 }
2847
2848 if (ecmp->ecm_compatibility == B_FALSE) {
2849 (void) usbecm_init_non_compatible_device(ecmp);
2850 }
2851
2852 /* Create power management components */
2853 if (usbecm_create_pm_components(ecmp) != USB_SUCCESS) {
2854 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
2855 "usbecm_usb_init: create pm components failed.");
2856
2857 return (USB_FAILURE);
2858 }
2859
2860 /* Register to get callbacks for USB events */
2861 if (usb_register_event_cbs(ecmp->ecm_dip, &usbecm_events, 0)
2862 != USB_SUCCESS) {
2863 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
2864 "usbsecm_attach: register event callback failed.");
2865
2866 return (USB_FAILURE);
2867 }
2868 ecmp->ecm_init_flags |= USBECM_INIT_EVENTS;
2869
2870
2871 /* Get max data size of bulk transfer */
2872 if (usb_pipe_get_max_bulk_transfer_size(ecmp->ecm_dip,
2873 &ecmp->ecm_xfer_sz) != USB_SUCCESS) {
2874 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
2875 "usbsecm_ds_attach: get max size of transfer failed.");
2876
2877 return (USB_FAILURE);
2878 }
2879
2880
2881 ecmp->ecm_ser_acc = usb_init_serialization(ecmp->ecm_dip,
2882 USB_INIT_SER_CHECK_SAME_THREAD);
2883 ecmp->ecm_init_flags |= USBECM_INIT_SER;
2884
2885 return (USB_SUCCESS);
2886 }
2887
2888
2889 /*
2890 * Open operation pipes. Each ECM device should have Bulk In, Bulk Out
2891 * and Interrupt In endpoints
2892 */
2893 static int
2894 usbecm_open_pipes(usbecm_state_t *ecmp)
2895 {
2896 int rval = USB_SUCCESS;
2897 usb_ep_data_t *in_data, *out_data, *intr_pipe;
2898 usb_pipe_policy_t policy;
2899 int altif;
2900
2901 ASSERT(!mutex_owned(&ecmp->ecm_mutex));
2902
2903 USB_DPRINTF_L4(PRINT_MASK_OPEN, ecmp->ecm_lh,
2904 "usbsecm_open_pipes: ecmp = 0x%p", (void *)ecmp);
2905
2906 if (ecmp->ecm_compatibility == B_TRUE) {
2907 /* compatible device has minimum of 2 altsetting, select alt 1 */
2908 altif = 1;
2909 } else {
2910 altif = ecmp->ecm_data_if_alt;
2911 }
2912 intr_pipe = ecmp->ecm_intr_ep;
2913 in_data = ecmp->ecm_bulk_in_ep;
2914 out_data = ecmp->ecm_bulk_out_ep;
2915
2916 /* Bulk in and out must exist simultaneously. */
2917 if ((in_data == NULL) || (out_data == NULL)) {
2918 USB_DPRINTF_L2(PRINT_MASK_OPEN, ecmp->ecm_lh,
2919 "usbsecm_open_pipes: look up bulk pipe failed in "
2920 "interface %d ",
2921 ecmp->ecm_data_if_no);
2922
2923 return (USB_FAILURE);
2924 }
2925 /*
2926 * If device conform to ecm spec, it must have an interrupt pipe
2927 * for this device.
2928 */
2929 if (ecmp->ecm_compatibility == B_TRUE && intr_pipe == NULL) {
2930 USB_DPRINTF_L2(PRINT_MASK_OPEN, ecmp->ecm_lh,
2931 "usbecm_open_pipes: look up interrupt pipe failed in "
2932 "interface %d", ecmp->ecm_ctrl_if_no);
2933
2934 return (USB_FAILURE);
2935 }
2936
2937 USB_DPRINTF_L3(PRINT_MASK_OPEN, ecmp->ecm_lh,
2938 "usbsecm_open_pipes: open intr %02x, bulkin %02x bulkout %02x",
2939 intr_pipe?intr_pipe->ep_descr.bEndpointAddress:0,
2940 in_data->ep_descr.bEndpointAddress,
2941 out_data->ep_descr.bEndpointAddress);
2942
2943 USB_DPRINTF_L3(PRINT_MASK_OPEN, ecmp->ecm_lh,
2944 "usbsecm_open_pipes: set data if(%d) alt(%d) ",
2945 ecmp->ecm_data_if_no, altif);
2946
2947 if ((rval = usb_set_alt_if(ecmp->ecm_dip, ecmp->ecm_data_if_no,
2948 altif, USB_FLAGS_SLEEP, NULL, NULL)) != USB_SUCCESS) {
2949 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
2950 "usbecm_open_pipes: set alternate failed (%d)",
2951 rval);
2952
2953 return (rval);
2954 }
2955
2956 policy.pp_max_async_reqs = 2;
2957
2958 /* Open bulk in endpoint */
2959 if (usb_pipe_open(ecmp->ecm_dip, &in_data->ep_descr, &policy,
2960 USB_FLAGS_SLEEP, &ecmp->ecm_bulkin_ph) != USB_SUCCESS) {
2961 USB_DPRINTF_L2(PRINT_MASK_OPEN, ecmp->ecm_lh,
2962 "usbecm_open_pipes: open bulkin pipe failed!");
2963
2964 return (USB_FAILURE);
2965 }
2966
2967 /* Open bulk out endpoint */
2968 if (usb_pipe_open(ecmp->ecm_dip, &out_data->ep_descr, &policy,
2969 USB_FLAGS_SLEEP, &ecmp->ecm_bulkout_ph) != USB_SUCCESS) {
2970 USB_DPRINTF_L2(PRINT_MASK_OPEN, ecmp->ecm_lh,
2971 "usbecm_open_pipes: open bulkout pipe failed!");
2972
2973 usb_pipe_close(ecmp->ecm_dip, ecmp->ecm_bulkin_ph,
2974 USB_FLAGS_SLEEP, NULL, NULL);
2975
2976 return (USB_FAILURE);
2977 }
2978
2979 /* Open interrupt endpoint if found. */
2980 if (intr_pipe != NULL) {
2981 if (usb_pipe_open(ecmp->ecm_dip, &intr_pipe->ep_descr, &policy,
2982 USB_FLAGS_SLEEP, &ecmp->ecm_intr_ph) != USB_SUCCESS) {
2983 USB_DPRINTF_L2(PRINT_MASK_OPEN, ecmp->ecm_lh,
2984 "usbecm_open_pipes: "
2985 "open intr pipe failed");
2986
2987 usb_pipe_close(ecmp->ecm_dip, ecmp->ecm_bulkin_ph,
2988 USB_FLAGS_SLEEP, NULL, NULL);
2989 usb_pipe_close(ecmp->ecm_dip, ecmp->ecm_bulkout_ph,
2990 USB_FLAGS_SLEEP, NULL, NULL);
2991
2992 return (USB_FAILURE);
2993 }
2994 }
2995
2996 /* initialize the pipe related data */
2997 mutex_enter(&ecmp->ecm_mutex);
2998 ecmp->ecm_bulkin_sz = in_data->ep_descr.wMaxPacketSize;
2999 ecmp->ecm_bulkin_state = USBECM_PIPE_IDLE;
3000 ecmp->ecm_bulkout_state = USBECM_PIPE_IDLE;
3001 if (ecmp->ecm_intr_ph != NULL) {
3002 ecmp->ecm_intr_state = USBECM_PIPE_IDLE;
3003 }
3004 mutex_exit(&ecmp->ecm_mutex);
3005
3006 if (ecmp->ecm_intr_ph != NULL) {
3007
3008 usbecm_pipe_start_polling(ecmp);
3009 }
3010
3011 USB_DPRINTF_L4(PRINT_MASK_OPEN, ecmp->ecm_lh,
3012 "usbsecm_open_pipes: end");
3013
3014 return (rval);
3015 }
3016
3017
3018 /*
3019 * usbsecm_close_pipes:
3020 * Close pipes
3021 * Each device could include three pipes: bulk in, bulk out and interrupt.
3022 */
3023 static void
3024 usbecm_close_pipes(usbecm_state_t *ecmp)
3025 {
3026
3027 mutex_enter(&ecmp->ecm_mutex);
3028
3029 USB_DPRINTF_L4(PRINT_MASK_CLOSE, ecmp->ecm_lh,
3030 "usbsecm_close_pipes: ecm_bulkin_state = %d",
3031 ecmp->ecm_bulkin_state);
3032
3033 /*
3034 * Check the status of the pipes. If pipe is closing or closed,
3035 * return directly.
3036 */
3037 if ((ecmp->ecm_bulkin_state == USBECM_PIPE_CLOSED) ||
3038 (ecmp->ecm_bulkin_state == USBECM_PIPE_CLOSING)) {
3039 USB_DPRINTF_L2(PRINT_MASK_CLOSE, ecmp->ecm_lh,
3040 "usbsecm_close_pipes: pipe is closing or has closed");
3041 mutex_exit(&ecmp->ecm_mutex);
3042
3043 return;
3044 }
3045
3046 ecmp->ecm_bulkin_state = USBECM_PIPE_CLOSING;
3047 mutex_exit(&ecmp->ecm_mutex);
3048
3049 /* reset the data interface's altsetting to 0 */
3050 if ((ecmp->ecm_dev_state == USB_DEV_ONLINE) &&
3051 (usb_set_alt_if(ecmp->ecm_dip, ecmp->ecm_data_if_no,
3052 0, USB_FLAGS_SLEEP, NULL, NULL) != USB_SUCCESS)) {
3053 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
3054 "usbecm_close_pipes: reset alternate failed ");
3055 }
3056
3057 /* Close pipes */
3058 usb_pipe_reset(ecmp->ecm_dip, ecmp->ecm_bulkin_ph,
3059 USB_FLAGS_SLEEP, NULL, 0);
3060 usb_pipe_close(ecmp->ecm_dip, ecmp->ecm_bulkin_ph,
3061 USB_FLAGS_SLEEP, NULL, 0);
3062 usb_pipe_close(ecmp->ecm_dip, ecmp->ecm_bulkout_ph,
3063 USB_FLAGS_SLEEP, NULL, 0);
3064
3065 if (ecmp->ecm_intr_ph != NULL) {
3066 usb_pipe_stop_intr_polling(ecmp->ecm_intr_ph,
3067 USB_FLAGS_SLEEP);
3068 usb_pipe_close(ecmp->ecm_dip, ecmp->ecm_intr_ph,
3069 USB_FLAGS_SLEEP, NULL, 0);
3070 }
3071
3072 mutex_enter(&ecmp->ecm_mutex);
3073 /* Reset the status of pipes to closed */
3074 ecmp->ecm_bulkin_state = USBECM_PIPE_CLOSED;
3075 ecmp->ecm_bulkin_ph = NULL;
3076 ecmp->ecm_bulkout_state = USBECM_PIPE_CLOSED;
3077 ecmp->ecm_bulkout_ph = NULL;
3078 if (ecmp->ecm_intr_ph != NULL) {
3079 ecmp->ecm_intr_state = USBECM_PIPE_CLOSED;
3080 ecmp->ecm_intr_ph = NULL;
3081 }
3082
3083 mutex_exit(&ecmp->ecm_mutex);
3084
3085 USB_DPRINTF_L4(PRINT_MASK_CLOSE, ecmp->ecm_lh,
3086 "usbsecm_close_pipes: pipes have been closed.");
3087 }
3088
3089
3090 static int
3091 usbecm_ctrl_write(usbecm_state_t *ecmp, uchar_t request,
3092 uint16_t value, mblk_t **data)
3093 {
3094 usb_ctrl_setup_t setup;
3095 usb_cb_flags_t cb_flags;
3096 usb_cr_t cr;
3097 int rval;
3098
3099 USB_DPRINTF_L4(PRINT_MASK_ALL, ecmp->ecm_lh,
3100 "usbecm_ctrl_write: ");
3101
3102 /* initialize the control request. */
3103 setup.bmRequestType = USB_DEV_REQ_HOST_TO_DEV |
3104 USB_DEV_REQ_TYPE_CLASS | USB_DEV_REQ_RCPT_IF;
3105 setup.bRequest = request;
3106 setup.wValue = value;
3107 setup.wIndex = ecmp->ecm_ctrl_if_no;
3108 setup.wLength = ((data != NULL) && (*data != NULL)) ? MBLKL(*data) : 0;
3109 setup.attrs = 0;
3110
3111 rval = usb_pipe_ctrl_xfer_wait(ecmp->ecm_def_ph, &setup, data,
3112 &cr, &cb_flags, 0);
3113
3114 USB_DPRINTF_L4(PRINT_MASK_ALL, ecmp->ecm_lh,
3115 "usbecm_ctrl_write: rval = %d", rval);
3116
3117 return (rval);
3118 }
3119
3120 static int
3121 usbecm_ctrl_read(usbecm_state_t *ecmp, uchar_t request,
3122 uint16_t value, mblk_t **data, int len)
3123 {
3124 usb_ctrl_setup_t setup;
3125 usb_cb_flags_t cb_flags;
3126 usb_cr_t cr;
3127
3128 USB_DPRINTF_L4(PRINT_MASK_ALL, ecmp->ecm_lh,
3129 "usbecm_ctrl_read: ");
3130
3131 /* initialize the control request. */
3132 setup.bmRequestType = USB_DEV_REQ_DEV_TO_HOST |
3133 USB_DEV_REQ_TYPE_CLASS | USB_DEV_REQ_RCPT_IF;
3134 setup.bRequest = request;
3135 setup.wValue = value;
3136 setup.wIndex = ecmp->ecm_ctrl_if_no;
3137 setup.wLength = (uint16_t)len;
3138 setup.attrs = 0;
3139
3140 return (usb_pipe_ctrl_xfer_wait(ecmp->ecm_def_ph, &setup, data,
3141 &cr, &cb_flags, 0));
3142 }
3143
3144 /* Get specific statistic data from device */
3145 static int
3146 usbecm_get_statistics(usbecm_state_t *ecmp, uint32_t fs, uint32_t *stat_data)
3147 {
3148 mblk_t *data = NULL;
3149 uint32_t stat;
3150
3151 /* first check to see if this stat is collected by device */
3152 if ((ecmp->ecm_compatibility == B_TRUE) &&
3153 (ecmp->ecm_desc.bmEthernetStatistics & ECM_STAT_CAP_MASK(fs))) {
3154 if (usbecm_ctrl_read(ecmp, CDC_ECM_GET_ETH_STAT,
3155 ecmp->ecm_ctrl_if_no, &data, 4) != USB_SUCCESS) {
3156
3157 return (USB_FAILURE);
3158 }
3159 stat = (data->b_rptr[3] << 24) | (data->b_rptr[2] << 16) |
3160 (data->b_rptr[1] << 8) | (data->b_rptr[0]);
3161 *stat_data = stat;
3162
3163 freemsg(data);
3164
3165 return (USB_SUCCESS);
3166 }
3167
3168 return (USB_FAILURE);
3169 }