old mode 100644new mode 100755.. | .. |
---|
| 1 | +/* SPDX-License-Identifier: GPL-2.0 */ |
---|
1 | 2 | /* |
---|
2 | 3 | * Dongle BUS interface |
---|
3 | 4 | * USB Linux Implementation |
---|
.. | .. |
---|
476 | 477 | |
---|
477 | 478 | /** functions called by the Linux kernel USB subsystem */ |
---|
478 | 479 | static struct usb_driver dbus_usbdev = { |
---|
479 | | - name: "dbus_usbdev"BUS_TYPE, |
---|
| 480 | + name: "dbus_usbdev", |
---|
480 | 481 | probe: dbus_usbos_probe, |
---|
481 | 482 | disconnect: dbus_usbos_disconnect, |
---|
482 | 483 | id_table: devid_table, |
---|
.. | .. |
---|
510 | 511 | enum usbos_suspend_state suspend_state; |
---|
511 | 512 | struct usb_interface *intf; |
---|
512 | 513 | } probe_info_t; |
---|
513 | | - |
---|
514 | | -/* driver info, initialized when bcmsdh_register is called */ |
---|
515 | | -static dbus_driver_t drvinfo = {NULL, NULL, NULL, NULL}; |
---|
516 | 514 | |
---|
517 | 515 | /* |
---|
518 | 516 | * USB Linux dbus_intf_t |
---|
.. | .. |
---|
591 | 589 | }; |
---|
592 | 590 | |
---|
593 | 591 | static probe_info_t g_probe_info; |
---|
| 592 | +static probe_cb_t probe_cb = NULL; |
---|
| 593 | +static disconnect_cb_t disconnect_cb = NULL; |
---|
| 594 | +static void *probe_arg = NULL; |
---|
594 | 595 | static void *disc_arg = NULL; |
---|
595 | 596 | |
---|
596 | 597 | |
---|
.. | .. |
---|
1232 | 1233 | dbus_usbos_suspend(struct usb_interface *intf, |
---|
1233 | 1234 | pm_message_t message) |
---|
1234 | 1235 | { |
---|
1235 | | - usbos_info_t *usbos_info = (usbos_info_t *) g_probe_info.usbos_info; |
---|
1236 | | - int err = 0; |
---|
1237 | | - |
---|
1238 | | - printf("%s Enter\n", __FUNCTION__); |
---|
1239 | | - |
---|
| 1236 | + DBUSERR(("%s suspend state: %d\n", __FUNCTION__, g_probe_info.suspend_state)); |
---|
1240 | 1237 | /* DHD for full dongle model */ |
---|
1241 | 1238 | g_probe_info.suspend_state = USBOS_SUSPEND_STATE_SUSPEND_PENDING; |
---|
1242 | | - if (drvinfo.suspend && disc_arg) |
---|
1243 | | - err = drvinfo.suspend(disc_arg); |
---|
1244 | | - if (err) { |
---|
1245 | | - printf("%s: err=%d\n", __FUNCTION__, err); |
---|
1246 | | -// g_probe_info.suspend_state = USBOS_SUSPEND_STATE_DEVICE_ACTIVE; |
---|
1247 | | -// return err; |
---|
1248 | | - } |
---|
1249 | | - usbos_info->pub->busstate = DBUS_STATE_SLEEP; |
---|
1250 | | - |
---|
| 1239 | + dbus_usbos_state_change((usbos_info_t*)g_probe_info.usbos_info, DBUS_STATE_SLEEP); |
---|
1251 | 1240 | dbus_usbos_cancel_all_urbs((usbos_info_t*)g_probe_info.usbos_info); |
---|
1252 | 1241 | g_probe_info.suspend_state = USBOS_SUSPEND_STATE_SUSPENDED; |
---|
1253 | 1242 | |
---|
1254 | | - printf("%s Exit err=%d\n", __FUNCTION__, err); |
---|
1255 | | - return err; |
---|
| 1243 | + return 0; |
---|
1256 | 1244 | } |
---|
1257 | 1245 | |
---|
1258 | 1246 | /** |
---|
1259 | 1247 | * The resume method is called to tell the driver that the device has been resumed and the driver |
---|
1260 | 1248 | * can return to normal operation. URBs may once more be submitted. |
---|
1261 | 1249 | */ |
---|
1262 | | -static int |
---|
1263 | | -dbus_usbos_resume(struct usb_interface *intf) |
---|
| 1250 | +static int dbus_usbos_resume(struct usb_interface *intf) |
---|
1264 | 1251 | { |
---|
1265 | | - usbos_info_t *usbos_info = (usbos_info_t *) g_probe_info.usbos_info; |
---|
| 1252 | + DBUSERR(("%s Device resumed\n", __FUNCTION__)); |
---|
1266 | 1253 | |
---|
1267 | | - printf("%s Enter\n", __FUNCTION__); |
---|
1268 | | - |
---|
| 1254 | + dbus_usbos_state_change((usbos_info_t*)g_probe_info.usbos_info, DBUS_STATE_UP); |
---|
1269 | 1255 | g_probe_info.suspend_state = USBOS_SUSPEND_STATE_DEVICE_ACTIVE; |
---|
1270 | | - if (drvinfo.resume && disc_arg) |
---|
1271 | | - drvinfo.resume(disc_arg); |
---|
1272 | | - usbos_info->pub->busstate = DBUS_STATE_UP; |
---|
1273 | | - |
---|
1274 | | - printf("%s Exit\n", __FUNCTION__); |
---|
1275 | 1256 | return 0; |
---|
1276 | 1257 | } |
---|
1277 | 1258 | |
---|
.. | .. |
---|
1279 | 1260 | * This function is directly called by the Linux kernel, when the suspended device has been reset |
---|
1280 | 1261 | * instead of being resumed |
---|
1281 | 1262 | */ |
---|
1282 | | -static int |
---|
1283 | | -dbus_usbos_reset_resume(struct usb_interface *intf) |
---|
| 1263 | +static int dbus_usbos_reset_resume(struct usb_interface *intf) |
---|
1284 | 1264 | { |
---|
1285 | | - printf("%s Enter\n", __FUNCTION__); |
---|
| 1265 | + DBUSERR(("%s Device reset resumed\n", __FUNCTION__)); |
---|
1286 | 1266 | |
---|
| 1267 | + /* The device may have lost power, so a firmware download may be required */ |
---|
| 1268 | + dbus_usbos_state_change((usbos_info_t*)g_probe_info.usbos_info, DBUS_STATE_DL_NEEDED); |
---|
1287 | 1269 | g_probe_info.suspend_state = USBOS_SUSPEND_STATE_DEVICE_ACTIVE; |
---|
1288 | | - if (drvinfo.resume && disc_arg) |
---|
1289 | | - drvinfo.resume(disc_arg); |
---|
1290 | | - |
---|
1291 | | - printf("%s Exit\n", __FUNCTION__); |
---|
1292 | 1270 | return 0; |
---|
1293 | 1271 | } |
---|
1294 | 1272 | |
---|
.. | .. |
---|
1332 | 1310 | usb->portnum, WIFI_STATUS_POWER_ON); |
---|
1333 | 1311 | if (adapter == NULL) { |
---|
1334 | 1312 | DBUSERR(("%s: can't find adapter info for this chip\n", __FUNCTION__)); |
---|
1335 | | - ret = -ENOMEM; |
---|
1336 | 1313 | goto fail; |
---|
1337 | 1314 | } |
---|
1338 | 1315 | |
---|
.. | .. |
---|
1578 | 1555 | g_probe_info.device_speed = FULL_SPEED; |
---|
1579 | 1556 | DBUSERR(("full speed device detected\n")); |
---|
1580 | 1557 | } |
---|
1581 | | - if (g_probe_info.dereged == FALSE && drvinfo.probe) { |
---|
1582 | | - disc_arg = drvinfo.probe(usb->bus->busnum, usb->portnum, 0); |
---|
| 1558 | + if (g_probe_info.dereged == FALSE && probe_cb) { |
---|
| 1559 | + disc_arg = probe_cb(probe_arg, "", USB_BUS, usb->bus->busnum, usb->portnum, 0); |
---|
1583 | 1560 | } |
---|
1584 | 1561 | |
---|
1585 | 1562 | g_probe_info.disc_cb_done = FALSE; |
---|
.. | .. |
---|
1640 | 1617 | if (probe_usb_init_data) { |
---|
1641 | 1618 | usbos_info = (usbos_info_t *) probe_usb_init_data->usbos_info; |
---|
1642 | 1619 | if (usbos_info) { |
---|
1643 | | - if ((probe_usb_init_data->dereged == FALSE) && drvinfo.remove && disc_arg) { |
---|
1644 | | - drvinfo.remove(disc_arg); |
---|
| 1620 | + if ((probe_usb_init_data->dereged == FALSE) && disconnect_cb && disc_arg) { |
---|
| 1621 | + disconnect_cb(disc_arg); |
---|
1645 | 1622 | disc_arg = NULL; |
---|
1646 | 1623 | probe_usb_init_data->disc_cb_done = TRUE; |
---|
1647 | 1624 | } |
---|
.. | .. |
---|
2578 | 2555 | } |
---|
2579 | 2556 | |
---|
2580 | 2557 | int |
---|
2581 | | -dbus_bus_osl_register(dbus_driver_t *driver, dbus_intf_t **intf) |
---|
| 2558 | +dbus_bus_osl_register(int vid, int pid, probe_cb_t prcb, |
---|
| 2559 | + disconnect_cb_t discb, void *prarg, dbus_intf_t **intf, void *param1, void *param2) |
---|
2582 | 2560 | { |
---|
2583 | 2561 | bzero(&g_probe_info, sizeof(probe_info_t)); |
---|
2584 | 2562 | |
---|
2585 | | - drvinfo = *driver; |
---|
| 2563 | + probe_cb = prcb; |
---|
| 2564 | + disconnect_cb = discb; |
---|
| 2565 | + probe_arg = prarg; |
---|
| 2566 | + |
---|
| 2567 | + devid_table[0].idVendor = vid; |
---|
| 2568 | + devid_table[0].idProduct = pid; |
---|
| 2569 | + |
---|
2586 | 2570 | *intf = &dbus_usbos_intf; |
---|
2587 | 2571 | |
---|
2588 | 2572 | USB_REGISTER(); |
---|
.. | .. |
---|
2596 | 2580 | g_probe_info.dereged = TRUE; |
---|
2597 | 2581 | |
---|
2598 | 2582 | DHD_MUTEX_LOCK(); |
---|
2599 | | - if (drvinfo.remove && disc_arg && (g_probe_info.disc_cb_done == FALSE)) { |
---|
2600 | | - drvinfo.remove(disc_arg); |
---|
| 2583 | + if (disconnect_cb && disc_arg && (g_probe_info.disc_cb_done == FALSE)) { |
---|
| 2584 | + disconnect_cb(disc_arg); |
---|
2601 | 2585 | disc_arg = NULL; |
---|
2602 | 2586 | } |
---|
2603 | 2587 | DHD_MUTEX_UNLOCK(); |
---|
.. | .. |
---|
2649 | 2633 | } |
---|
2650 | 2634 | |
---|
2651 | 2635 | if (usbos_info->tx_pipe) |
---|
2652 | | -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5, 19, 0)) |
---|
2653 | | - usbos_info->maxps = usb_maxpacket(usbos_info->usb, |
---|
2654 | | - usbos_info->tx_pipe); |
---|
2655 | | -#else |
---|
2656 | 2636 | usbos_info->maxps = usb_maxpacket(usbos_info->usb, |
---|
2657 | 2637 | usbos_info->tx_pipe, usb_pipeout(usbos_info->tx_pipe)); |
---|
2658 | | -#endif /* #if (LINUX_VERSION_CODE < KERNEL_VERSION(5, 19, 0)) */ |
---|
2659 | 2638 | |
---|
2660 | 2639 | INIT_LIST_HEAD(&usbos_info->req_rxfreeq); |
---|
2661 | 2640 | INIT_LIST_HEAD(&usbos_info->req_txfreeq); |
---|
.. | .. |
---|
3204 | 3183 | return *firmware != NULL ? 0 : -ENOENT; |
---|
3205 | 3184 | } |
---|
3206 | 3185 | |
---|
3207 | | -#ifndef DHD_LINUX_STD_FW_API |
---|
3208 | 3186 | static void * |
---|
3209 | | -dbus_get_fwfile(int devid, int chiprev, uint8 **fw, int *fwlen, |
---|
3210 | | - uint16 boardtype, uint16 boardrev, char *path) |
---|
| 3187 | +dbus_get_fwfile(int devid, int chiprev, uint8 **fw, int *fwlen, uint16 boardtype, uint16 boardrev) |
---|
3211 | 3188 | { |
---|
3212 | 3189 | const struct firmware *firmware = NULL; |
---|
3213 | 3190 | #ifndef OEM_ANDROID |
---|
.. | .. |
---|
3270 | 3247 | snprintf(file_name, sizeof(file_name), "%s", CONFIG_ANDROID_BCMDHD_FW_PATH); |
---|
3271 | 3248 | #endif /* OEM_ANDROID */ |
---|
3272 | 3249 | |
---|
3273 | | - ret = dbus_request_firmware(path, &firmware); |
---|
| 3250 | + ret = dbus_request_firmware(file_name, &firmware); |
---|
3274 | 3251 | if (ret) { |
---|
3275 | | - DBUSERR(("fail to request firmware %s\n", path)); |
---|
| 3252 | + DBUSERR(("fail to request firmware %s\n", file_name)); |
---|
3276 | 3253 | return NULL; |
---|
3277 | | - } else |
---|
3278 | | - DBUSERR(("%s: %s (%zu bytes) open success\n", __FUNCTION__, path, firmware->size)); |
---|
| 3254 | + } |
---|
3279 | 3255 | |
---|
3280 | 3256 | *fwlen = firmware->size; |
---|
3281 | 3257 | *fw = (uint8 *)firmware->data; |
---|
.. | .. |
---|
3284 | 3260 | } |
---|
3285 | 3261 | |
---|
3286 | 3262 | static void * |
---|
3287 | | -dbus_get_nvfile(int devid, int chiprev, uint8 **fw, int *fwlen, |
---|
3288 | | - uint16 boardtype, uint16 boardrev, char *path) |
---|
| 3263 | +dbus_get_nvfile(int devid, int chiprev, uint8 **fw, int *fwlen, uint16 boardtype, uint16 boardrev) |
---|
3289 | 3264 | { |
---|
3290 | 3265 | const struct firmware *firmware = NULL; |
---|
3291 | 3266 | #ifndef OEM_ANDROID |
---|
.. | .. |
---|
3353 | 3328 | snprintf(file_name, sizeof(file_name), "%s", CONFIG_ANDROID_BCMDHD_NVRAM_PATH); |
---|
3354 | 3329 | #endif /* OEM_ANDROID */ |
---|
3355 | 3330 | |
---|
3356 | | - ret = dbus_request_firmware(path, &firmware); |
---|
| 3331 | + ret = dbus_request_firmware(file_name, &firmware); |
---|
3357 | 3332 | if (ret) { |
---|
3358 | | - DBUSERR(("fail to request nvram %s\n", path)); |
---|
| 3333 | + DBUSERR(("fail to request nvram %s\n", file_name)); |
---|
3359 | 3334 | |
---|
3360 | 3335 | #ifndef OEM_ANDROID |
---|
3361 | 3336 | /* Load generic nvram file */ |
---|
.. | .. |
---|
3366 | 3341 | #endif /* OEM_ANDROID */ |
---|
3367 | 3342 | |
---|
3368 | 3343 | if (ret) { |
---|
3369 | | - DBUSERR(("fail to request nvram %s\n", path)); |
---|
| 3344 | + DBUSERR(("fail to request nvram %s\n", file_name)); |
---|
3370 | 3345 | return NULL; |
---|
3371 | 3346 | } |
---|
3372 | | - } else |
---|
3373 | | - DBUSERR(("%s: %s (%zu bytes) open success\n", __FUNCTION__, path, firmware->size)); |
---|
| 3347 | + } |
---|
3374 | 3348 | |
---|
3375 | 3349 | *fwlen = firmware->size; |
---|
3376 | 3350 | *fw = (uint8 *)firmware->data; |
---|
.. | .. |
---|
3379 | 3353 | |
---|
3380 | 3354 | void * |
---|
3381 | 3355 | dbus_get_fw_nvfile(int devid, int chiprev, uint8 **fw, int *fwlen, int type, uint16 boardtype, |
---|
3382 | | - uint16 boardrev, char *path) |
---|
| 3356 | + uint16 boardrev) |
---|
3383 | 3357 | { |
---|
3384 | 3358 | switch (type) { |
---|
3385 | 3359 | case DBUS_FIRMWARE: |
---|
3386 | | - return dbus_get_fwfile(devid, chiprev, fw, fwlen, boardtype, boardrev, path); |
---|
| 3360 | + return dbus_get_fwfile(devid, chiprev, fw, fwlen, boardtype, boardrev); |
---|
3387 | 3361 | case DBUS_NVFILE: |
---|
3388 | | - return dbus_get_nvfile(devid, chiprev, fw, fwlen, boardtype, boardrev, path); |
---|
| 3362 | + return dbus_get_nvfile(devid, chiprev, fw, fwlen, boardtype, boardrev); |
---|
3389 | 3363 | default: |
---|
3390 | 3364 | return NULL; |
---|
3391 | 3365 | } |
---|
3392 | 3366 | } |
---|
3393 | | -#else |
---|
3394 | | -void * |
---|
3395 | | -dbus_get_fw_nvfile(int devid, int chiprev, uint8 **fw, int *fwlen, int type, uint16 boardtype, |
---|
3396 | | - uint16 boardrev, char *path) |
---|
3397 | | -{ |
---|
3398 | | - const struct firmware *firmware = NULL; |
---|
3399 | | - int err = DBUS_OK; |
---|
3400 | | - |
---|
3401 | | - err = dbus_request_firmware(path, &firmware); |
---|
3402 | | - if (err) { |
---|
3403 | | - DBUSERR(("fail to request firmware %s\n", path)); |
---|
3404 | | - return NULL; |
---|
3405 | | - } else { |
---|
3406 | | - DBUSERR(("%s: %s (%zu bytes) open success\n", |
---|
3407 | | - __FUNCTION__, path, firmware->size)); |
---|
3408 | | - } |
---|
3409 | | - |
---|
3410 | | - *fwlen = firmware->size; |
---|
3411 | | - *fw = (uint8 *)firmware->data; |
---|
3412 | | - return (void *)firmware; |
---|
3413 | | -} |
---|
3414 | | -#endif |
---|
3415 | 3367 | |
---|
3416 | 3368 | void |
---|
3417 | 3369 | dbus_release_fw_nvfile(void *firmware) |
---|
.. | .. |
---|
3452 | 3404 | return intf_wlan; |
---|
3453 | 3405 | } |
---|
3454 | 3406 | #endif /* BCMUSBDEV_COMPOSITE */ |
---|
3455 | | - |
---|
3456 | | -#ifdef LINUX |
---|
3457 | | -struct device * dbus_get_dev(void) |
---|
3458 | | -{ |
---|
3459 | | - return &g_probe_info.usb->dev; |
---|
3460 | | -} |
---|
3461 | | -#endif /* LINUX */ |
---|