/** * qla2x00_prep_ms_iocb() - Prepare common MS/CT IOCB fields for SNS CT query. * @ha: HA context * @req_size: request size in bytes * @rsp_size: response size in bytes * * Returns a pointer to the @ha's ms_iocb. */ void * qla2x00_prep_ms_iocb(scsi_qla_host_t *vha, uint32_t req_size, uint32_t rsp_size) { struct qla_hw_data *ha = vha->hw; ms_iocb_entry_t *ms_pkt; ms_pkt = ha->ms_iocb; memset(ms_pkt, 0, sizeof(ms_iocb_entry_t)); ms_pkt->entry_type = MS_IOCB_TYPE; ms_pkt->entry_count = 1; SET_TARGET_ID(ha, ms_pkt->loop_id, SIMPLE_NAME_SERVER); ms_pkt->control_flags = __constant_cpu_to_le16(CF_READ | CF_HEAD_TAG); ms_pkt->timeout = cpu_to_le16(ha->r_a_tov / 10 * 2); ms_pkt->cmd_dsd_count = __constant_cpu_to_le16(1); ms_pkt->total_dsd_count = __constant_cpu_to_le16(2); ms_pkt->rsp_bytecount = cpu_to_le32(rsp_size); ms_pkt->req_bytecount = cpu_to_le32(req_size); ms_pkt->dseg_req_address[0] = cpu_to_le32(LSD(ha->ct_sns_dma)); ms_pkt->dseg_req_address[1] = cpu_to_le32(MSD(ha->ct_sns_dma)); ms_pkt->dseg_req_length = ms_pkt->req_bytecount; ms_pkt->dseg_rsp_address[0] = cpu_to_le32(LSD(ha->ct_sns_dma)); ms_pkt->dseg_rsp_address[1] = cpu_to_le32(MSD(ha->ct_sns_dma)); ms_pkt->dseg_rsp_length = ms_pkt->rsp_bytecount; return (ms_pkt); }
/** * qla24xx_prep_ms_fdmi_iocb() - Prepare common MS IOCB fields for FDMI query. * @ha: HA context * @req_size: request size in bytes * @rsp_size: response size in bytes * * Returns a pointer to the @ha's ms_iocb. */ void * qla24xx_prep_ms_fdmi_iocb(scsi_qla_host_t *ha, uint32_t req_size, uint32_t rsp_size) { struct ct_entry_24xx *ct_pkt; ct_pkt = (struct ct_entry_24xx *)ha->ms_iocb; memset(ct_pkt, 0, sizeof(struct ct_entry_24xx)); ct_pkt->entry_type = CT_IOCB_TYPE; ct_pkt->entry_count = 1; ct_pkt->nport_handle = cpu_to_le16(ha->mgmt_svr_loop_id); ct_pkt->timeout = __constant_cpu_to_le16(59); ct_pkt->cmd_dsd_count = __constant_cpu_to_le16(1); ct_pkt->rsp_dsd_count = __constant_cpu_to_le16(1); ct_pkt->rsp_byte_count = cpu_to_le32(rsp_size); ct_pkt->cmd_byte_count = cpu_to_le32(req_size); ct_pkt->dseg_0_address[0] = cpu_to_le32(LSD(ha->ct_sns_dma)); ct_pkt->dseg_0_address[1] = cpu_to_le32(MSD(ha->ct_sns_dma)); ct_pkt->dseg_0_len = ct_pkt->cmd_byte_count; ct_pkt->dseg_1_address[0] = cpu_to_le32(LSD(ha->ct_sns_dma)); ct_pkt->dseg_1_address[1] = cpu_to_le32(MSD(ha->ct_sns_dma)); ct_pkt->dseg_1_len = ct_pkt->rsp_byte_count; return ct_pkt; }
/** * qla24xx_prep_ms_iocb() - Prepare common CT IOCB fields for SNS CT query. * @ha: HA context * @req_size: request size in bytes * @rsp_size: response size in bytes * * Returns a pointer to the @ha's ms_iocb. */ void * qla24xx_prep_ms_iocb(scsi_qla_host_t *vha, uint32_t req_size, uint32_t rsp_size) { struct qla_hw_data *ha = vha->hw; struct ct_entry_24xx *ct_pkt; ct_pkt = (struct ct_entry_24xx *)ha->ms_iocb; memset(ct_pkt, 0, sizeof(struct ct_entry_24xx)); ct_pkt->entry_type = CT_IOCB_TYPE; ct_pkt->entry_count = 1; ct_pkt->nport_handle = __constant_cpu_to_le16(NPH_SNS); ct_pkt->timeout = cpu_to_le16(ha->r_a_tov / 10 * 2); ct_pkt->cmd_dsd_count = __constant_cpu_to_le16(1); ct_pkt->rsp_dsd_count = __constant_cpu_to_le16(1); ct_pkt->rsp_byte_count = cpu_to_le32(rsp_size); ct_pkt->cmd_byte_count = cpu_to_le32(req_size); ct_pkt->dseg_0_address[0] = cpu_to_le32(LSD(ha->ct_sns_dma)); ct_pkt->dseg_0_address[1] = cpu_to_le32(MSD(ha->ct_sns_dma)); ct_pkt->dseg_0_len = ct_pkt->cmd_byte_count; ct_pkt->dseg_1_address[0] = cpu_to_le32(LSD(ha->ct_sns_dma)); ct_pkt->dseg_1_address[1] = cpu_to_le32(MSD(ha->ct_sns_dma)); ct_pkt->dseg_1_len = ct_pkt->rsp_byte_count; ct_pkt->vp_index = vha->vp_idx; return (ct_pkt); }
/** * qla2x00_prep_ms_fdmi_iocb() - Prepare common MS IOCB fields for FDMI query. * @ha: HA context * @req_size: request size in bytes * @rsp_size: response size in bytes * * Returns a pointer to the @ha's ms_iocb. */ void * qla2x00_prep_ms_fdmi_iocb(scsi_qla_host_t *ha, uint32_t req_size, uint32_t rsp_size) { ms_iocb_entry_t *ms_pkt; ms_pkt = ha->ms_iocb; memset(ms_pkt, 0, sizeof(ms_iocb_entry_t)); ms_pkt->entry_type = MS_IOCB_TYPE; ms_pkt->entry_count = 1; SET_TARGET_ID(ha, ms_pkt->loop_id, ha->mgmt_svr_loop_id); ms_pkt->control_flags = __constant_cpu_to_le16(CF_READ | CF_HEAD_TAG); ms_pkt->timeout = __constant_cpu_to_le16(59); ms_pkt->cmd_dsd_count = __constant_cpu_to_le16(1); ms_pkt->total_dsd_count = __constant_cpu_to_le16(2); ms_pkt->rsp_bytecount = cpu_to_le32(rsp_size); ms_pkt->req_bytecount = cpu_to_le32(req_size); ms_pkt->dseg_req_address[0] = cpu_to_le32(LSD(ha->ct_sns_dma)); ms_pkt->dseg_req_address[1] = cpu_to_le32(MSD(ha->ct_sns_dma)); ms_pkt->dseg_req_length = ms_pkt->req_bytecount; ms_pkt->dseg_rsp_address[0] = cpu_to_le32(LSD(ha->ct_sns_dma)); ms_pkt->dseg_rsp_address[1] = cpu_to_le32(MSD(ha->ct_sns_dma)); ms_pkt->dseg_rsp_length = ms_pkt->rsp_bytecount; return ms_pkt; }
int g_dnl_bind_fixup(struct usb_device_descriptor *dev, const char *name) { if (!strcmp(name, "usb_dnl_ums")) { dev->idVendor = __constant_cpu_to_le16(CONFIG_G_DNL_UMS_VENDOR_NUM); dev->idProduct = __constant_cpu_to_le16(CONFIG_G_DNL_UMS_PRODUCT_NUM); } else { dev->idVendor = __constant_cpu_to_le16(CONFIG_G_DNL_VENDOR_NUM); dev->idProduct = __constant_cpu_to_le16(CONFIG_G_DNL_PRODUCT_NUM); } return 0; }
static long modem_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { int ret = 0; printk(KERN_INFO "modem_ioctl: cmd=0x%x, arg=%lu\n", cmd, arg); /* handle ioctls */ switch (cmd) { case GS_CDC_NOTIFY_SERIAL_STATE: ret = acm_notify(acm_data, __constant_cpu_to_le16(arg)); return ret; case GS_IOC_NOTIFY_DTR_TEST: { printk(KERN_ALERT"DUN : DTR %d\n", (int)arg); notify_control_line_state((int)arg); break; } default: printk(KERN_INFO "modem_ioctl: Unknown ioctl cmd(0x%x).\n", cmd); return -ENOIOCTLCMD; } return 0; }
static long modem_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { int status = 0; printk(KERN_DEBUG "ACM_dun modem_ioctl: cmd=0x%x, arg=%lu\n", cmd, arg); if (!atomic_read(&link_state)) { printk(KERN_DEBUG "Cannot ioctl ACM_dun(not connected)\n"); return -ENODEV; } /* handle ioctls */ switch (cmd) { case GS_CDC_NOTIFY_SERIAL_STATE: status = acm_notify(s_acm_dev->acm_data, __constant_cpu_to_le16(arg)); break; case GS_IOC_NOTIFY_DTR_TEST: printk(KERN_ALERT"DUN : DTR %d\n", (int)arg); notify_control_line_state((int)arg); break; default: printk(KERN_ERR "ACM_dun: Unknown ioctl cmd(0x%x).\n", cmd); status = -ENOIOCTLCMD; } return status; }
static int modem_ioctl (struct inode *inode, struct file *file, unsigned int cmd,unsigned long arg) { //hdlnc_ysyim_2010-4-26: remove log for popupnois when usb unmout //printk("modem_ioctl: cmd=0x%x, arg=%lu\n", cmd, arg); /* handle ioctls */ switch (cmd) { case GS_CDC_NOTIFY_SERIAL_STATE: acm_notify(acm_data, __constant_cpu_to_le16(arg)); break; case GS_IOC_NOTIFY_DTR_TEST: { printk(KERN_ALERT"DUN : DTR %d\n",(int)arg); notify_control_line_state((int)arg); break; } default: printk("modem_ioctl: Unknown ioctl cmd(0x%x).\n", cmd); return -ENOIOCTLCMD; } return 0; }
static struct sk_buff *smp_build_cmd(struct l2cap_conn *conn, u8 code, u16 dlen, void *data) { struct sk_buff *skb; struct l2cap_hdr *lh; int len; len = L2CAP_HDR_SIZE + sizeof(code) + dlen; if (len > conn->mtu) return NULL; skb = bt_skb_alloc(len, GFP_ATOMIC); if (!skb) return NULL; lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE); lh->len = cpu_to_le16(sizeof(code) + dlen); lh->cid = __constant_cpu_to_le16(L2CAP_CID_SMP); memcpy(skb_put(skb, sizeof(code)), &code, sizeof(code)); memcpy(skb_put(skb, dlen), data, dlen); return skb; }
/** * e100_diag_loopback_alloc - alloc & initate tcb and rfd for the loopback * @bdp: atapter's private data struct * */ static u8 e100_diag_loopback_alloc(struct e100_private *bdp) { dma_addr_t dma_handle; tcb_t *tcb; rfd_t *rfd; tbd_t *tbd; /* tcb, tbd and transmit buffer are allocated */ tcb = pci_alloc_consistent(bdp->pdev, (sizeof (tcb_t) + sizeof (tbd_t) + LB_PACKET_SIZE), &dma_handle); if (tcb == NULL) return false; memset(tcb, 0x00, sizeof (tcb_t) + sizeof (tbd_t) + LB_PACKET_SIZE); tcb->tcb_phys = dma_handle; tcb->tcb_hdr.cb_status = 0; tcb->tcb_hdr.cb_cmd = cpu_to_le16(CB_EL_BIT | CB_TRANSMIT | CB_TX_SF_BIT); /* Next command is null */ tcb->tcb_hdr.cb_lnk_ptr = cpu_to_le32(0xffffffff); tcb->tcb_cnt = 0; tcb->tcb_thrshld = bdp->tx_thld; tcb->tcb_tbd_num = 1; /* Set up tcb tbd pointer */ tcb->tcb_tbd_ptr = cpu_to_le32(tcb->tcb_phys + sizeof (tcb_t)); tbd = (tbd_t *) ((u8 *) tcb + sizeof (tcb_t)); /* Set up tbd transmit buffer */ tbd->tbd_buf_addr = cpu_to_le32(le32_to_cpu(tcb->tcb_tbd_ptr) + sizeof (tbd_t)); tbd->tbd_buf_cnt = __constant_cpu_to_le16(1024); /* The value of first 512 bytes is FF */ memset((void *) ((u8 *) tbd + sizeof (tbd_t)), 0xFF, 512); /* The value of second 512 bytes is BA */ memset((void *) ((u8 *) tbd + sizeof (tbd_t) + 512), 0xBA, 512); wmb(); rfd = pci_alloc_consistent(bdp->pdev, sizeof (rfd_t), &dma_handle); if (rfd == NULL) { pci_free_consistent(bdp->pdev, sizeof (tcb_t) + sizeof (tbd_t) + LB_PACKET_SIZE, tcb, tcb->tcb_phys); return false; } memset(rfd, 0x00, sizeof (rfd_t)); /* init all fields in rfd */ rfd->rfd_header.cb_cmd = cpu_to_le16(RFD_EL_BIT); rfd->rfd_sz = cpu_to_le16(ETH_FRAME_LEN + CHKSUM_SIZE); /* dma_handle is physical address of rfd */ bdp->loopback.dma_handle = dma_handle; bdp->loopback.tcb = tcb; bdp->loopback.rfd = rfd; wmb(); return true; }
static int g_dnl_bind(struct usb_composite_dev *cdev) { struct usb_gadget *gadget = cdev->gadget; int id, ret; int gcnum; char *s=NULL; debug("%s: gadget: 0x%p cdev: 0x%p\n", __func__, gadget, cdev); id = usb_string_id(cdev); if (id < 0) return id; g_dnl_string_defs[0].id = id; device_desc.iManufacturer = id; id = usb_string_id(cdev); if (id < 0) return id; g_dnl_string_defs[1].id = id; device_desc.iProduct = id; id = usb_string_id(cdev); if (id < 0) return id; g_dnl_string_defs[2].id = id; device_desc.iSerialNumber = id; s = get_usid_string(); if (s) g_dnl_set_serialnumber(s); g_dnl_bind_fixup(&device_desc, cdev->driver->name); ret = g_dnl_config_register(cdev); if (ret) goto error; gcnum = g_dnl_get_bcd_device_number(cdev); if (gcnum >= 0) device_desc.bcdDevice = cpu_to_le16(gcnum); else { debug("%s: controller '%s' not recognized\n", __func__, gadget->name); device_desc.bcdDevice = __constant_cpu_to_le16(0x9999); } debug("%s: calling usb_gadget_connect for " "controller '%s'\n", __func__, gadget->name); usb_gadget_connect(gadget); return 0; error: g_dnl_unbind(cdev); return -ENOMEM; }
static int __init init(void) { /* We *could* export two configs; that'd be much cleaner... * but neither of these product IDs was defined that way. */ if (use_acm) { serial_config_driver.label = "CDC ACM config"; serial_config_driver.bConfigurationValue = 2; device_desc.bDeviceClass = USB_CLASS_COMM; device_desc.idProduct = __constant_cpu_to_le16(GS_CDC_PRODUCT_ID); } else { serial_config_driver.label = "Generic Serial config"; serial_config_driver.bConfigurationValue = 1; device_desc.bDeviceClass = USB_CLASS_VENDOR_SPEC; device_desc.idProduct = __constant_cpu_to_le16(GS_PRODUCT_ID); } strings_dev[STRING_DESCRIPTION_IDX].s = serial_config_driver.label; return usb_composite_register(&gserial_driver); }
static __u32 cifs_ssetup_hdr(struct cifs_ses *ses, SESSION_SETUP_ANDX *pSMB) { __u32 capabilities = 0; /* init fields common to all four types of SessSetup */ /* Note that offsets for first seven fields in req struct are same */ /* in CIFS Specs so does not matter which of 3 forms of struct */ /* that we use in next few lines */ /* Note that header is initialized to zero in header_assemble */ pSMB->req.AndXCommand = 0xFF; pSMB->req.MaxBufferSize = cpu_to_le16(min_t(u32, CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4, USHRT_MAX)); pSMB->req.MaxMpxCount = cpu_to_le16(ses->server->maxReq); pSMB->req.VcNumber = __constant_cpu_to_le16(1); /* Now no need to set SMBFLG_CASELESS or obsolete CANONICAL PATH */ /* BB verify whether signing required on neg or just on auth frame (and NTLM case) */ capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS | CAP_LARGE_WRITE_X | CAP_LARGE_READ_X; if (ses->server->sign) pSMB->req.hdr.Flags2 |= SMBFLG2_SECURITY_SIGNATURE; if (ses->capabilities & CAP_UNICODE) { pSMB->req.hdr.Flags2 |= SMBFLG2_UNICODE; capabilities |= CAP_UNICODE; } if (ses->capabilities & CAP_STATUS32) { pSMB->req.hdr.Flags2 |= SMBFLG2_ERR_STATUS; capabilities |= CAP_STATUS32; } if (ses->capabilities & CAP_DFS) { pSMB->req.hdr.Flags2 |= SMBFLG2_DFS; capabilities |= CAP_DFS; } if (ses->capabilities & CAP_UNIX) capabilities |= CAP_UNIX; return capabilities; }
static int __init audio_bind(struct usb_composite_dev *cdev) { int gcnum; int status; gcnum = usb_gadget_controller_number(cdev->gadget); if (gcnum >= 0) device_desc.bcdDevice = cpu_to_le16(0x0300 | gcnum); else { ERROR(cdev, "controller '%s' not recognized; trying %s\n", cdev->gadget->name, audio_config_driver.label); device_desc.bcdDevice = __constant_cpu_to_le16(0x0300 | 0x0099); } /* device descriptor strings: manufacturer, product */ snprintf(manufacturer, sizeof manufacturer, "%s %s with %s", init_utsname()->sysname, init_utsname()->release, cdev->gadget->name); status = usb_string_id(cdev); if (status < 0) goto fail; strings_dev[STRING_MANUFACTURER_IDX].id = status; device_desc.iManufacturer = status; status = usb_string_id(cdev); if (status < 0) goto fail; strings_dev[STRING_PRODUCT_IDX].id = status; device_desc.iProduct = status; status = usb_add_config(cdev, &audio_config_driver); if (status < 0) goto fail; INFO(cdev, "%s, version: %s\n", DRIVER_DESC, DRIVER_VERSION); return 0; fail: return status; }
/** * e100_config - issue a configure command * @bdp: atapter's private data struct * * This routine will issue a configure command to the 82557. * This command will be executed in polled mode as interrupts * are _disabled_ at this time. * * Returns: * true: if the configure command was successfully issued and completed * false: otherwise */ unsigned char e100_config(struct e100_private *bdp) { cb_header_t *pntcb_hdr; unsigned char res = true; nxmit_cb_entry_t *cmd; if (bdp->config[0] == 0) { goto exit; } if ((cmd = e100_alloc_non_tx_cmd(bdp)) == NULL) { res = false; goto exit; } pntcb_hdr = (cb_header_t *) cmd->non_tx_cmd; pntcb_hdr->cb_cmd = __constant_cpu_to_le16(CB_CONFIGURE); spin_lock_bh(&bdp->config_lock); if (bdp->config[0] < CB_CFIG_MIN_PARAMS) { bdp->config[0] = CB_CFIG_MIN_PARAMS; } /* Copy the device's config block to the device's memory */ memcpy(cmd->non_tx_cmd->ntcb.config.cfg_byte, bdp->config, bdp->config[0]); /* reset number of bytes to config next time */ bdp->config[0] = 0; spin_unlock_bh(&bdp->config_lock); res = e100_exec_non_cu_cmd(bdp, cmd); exit: if (netif_running(bdp->device)) netif_wake_queue(bdp->device); return res; }
/** * qla4xxx_initialize_fw_cb - initializes firmware control block. * @ha: Pointer to host adapter structure. **/ int qla4xxx_initialize_fw_cb(struct scsi_qla_host * ha) { struct init_fw_ctrl_blk *init_fw_cb; dma_addr_t init_fw_cb_dma; uint32_t mbox_cmd[MBOX_REG_COUNT]; uint32_t mbox_sts[MBOX_REG_COUNT]; int status = QLA_ERROR; init_fw_cb = dma_alloc_coherent(&ha->pdev->dev, sizeof(struct init_fw_ctrl_blk), &init_fw_cb_dma, GFP_KERNEL); if (init_fw_cb == NULL) { DEBUG2(printk("scsi%ld: %s: Unable to alloc init_cb\n", ha->host_no, __func__)); return 10; } memset(init_fw_cb, 0, sizeof(struct init_fw_ctrl_blk)); /* Get Initialize Firmware Control Block. */ memset(&mbox_cmd, 0, sizeof(mbox_cmd)); memset(&mbox_sts, 0, sizeof(mbox_sts)); mbox_cmd[0] = MBOX_CMD_GET_INIT_FW_CTRL_BLOCK; mbox_cmd[2] = LSDW(init_fw_cb_dma); mbox_cmd[3] = MSDW(init_fw_cb_dma); mbox_cmd[4] = sizeof(struct init_fw_ctrl_blk); if (qla4xxx_mailbox_command(ha, MBOX_REG_COUNT, 1, &mbox_cmd[0], &mbox_sts[0]) != QLA_SUCCESS) { dma_free_coherent(&ha->pdev->dev, sizeof(struct init_fw_ctrl_blk), init_fw_cb, init_fw_cb_dma); return status; } /* Initialize request and response queues. */ qla4xxx_init_rings(ha); /* Fill in the request and response queue information. */ init_fw_cb->pri.rqq_consumer_idx = cpu_to_le16(ha->request_out); init_fw_cb->pri.compq_producer_idx = cpu_to_le16(ha->response_in); init_fw_cb->pri.rqq_len = __constant_cpu_to_le16(REQUEST_QUEUE_DEPTH); init_fw_cb->pri.compq_len = __constant_cpu_to_le16(RESPONSE_QUEUE_DEPTH); init_fw_cb->pri.rqq_addr_lo = cpu_to_le32(LSDW(ha->request_dma)); init_fw_cb->pri.rqq_addr_hi = cpu_to_le32(MSDW(ha->request_dma)); init_fw_cb->pri.compq_addr_lo = cpu_to_le32(LSDW(ha->response_dma)); init_fw_cb->pri.compq_addr_hi = cpu_to_le32(MSDW(ha->response_dma)); init_fw_cb->pri.shdwreg_addr_lo = cpu_to_le32(LSDW(ha->shadow_regs_dma)); init_fw_cb->pri.shdwreg_addr_hi = cpu_to_le32(MSDW(ha->shadow_regs_dma)); /* Set up required options. */ init_fw_cb->pri.fw_options |= __constant_cpu_to_le16(FWOPT_SESSION_MODE | FWOPT_INITIATOR_MODE); init_fw_cb->pri.fw_options &= __constant_cpu_to_le16(~FWOPT_TARGET_MODE); /* Save some info in adapter structure. */ ha->firmware_options = le16_to_cpu(init_fw_cb->pri.fw_options); ha->tcp_options = le16_to_cpu(init_fw_cb->pri.ipv4_tcp_opts); ha->heartbeat_interval = init_fw_cb->pri.hb_interval; memcpy(ha->ip_address, init_fw_cb->pri.ipv4_addr, min(sizeof(ha->ip_address), sizeof(init_fw_cb->pri.ipv4_addr))); memcpy(ha->subnet_mask, init_fw_cb->pri.ipv4_subnet, min(sizeof(ha->subnet_mask), sizeof(init_fw_cb->pri.ipv4_subnet))); memcpy(ha->gateway, init_fw_cb->pri.ipv4_gw_addr, min(sizeof(ha->gateway), sizeof(init_fw_cb->pri.ipv4_gw_addr))); memcpy(ha->name_string, init_fw_cb->pri.iscsi_name, min(sizeof(ha->name_string), sizeof(init_fw_cb->pri.iscsi_name))); /*memcpy(ha->alias, init_fw_cb->Alias, min(sizeof(ha->alias), sizeof(init_fw_cb->Alias)));*/ /* Save Command Line Paramater info */ ha->port_down_retry_count = le16_to_cpu(init_fw_cb->pri.conn_ka_timeout); ha->discovery_wait = ql4xdiscoverywait; /* Send Initialize Firmware Control Block. */ memset(&mbox_cmd, 0, sizeof(mbox_cmd)); memset(&mbox_sts, 0, sizeof(mbox_sts)); mbox_cmd[0] = MBOX_CMD_INITIALIZE_FIRMWARE; mbox_cmd[1] = 0; mbox_cmd[2] = LSDW(init_fw_cb_dma); mbox_cmd[3] = MSDW(init_fw_cb_dma); mbox_cmd[4] = sizeof(struct init_fw_ctrl_blk); if (qla4xxx_mailbox_command(ha, MBOX_REG_COUNT, 1, &mbox_cmd[0], &mbox_sts[0]) == QLA_SUCCESS) status = QLA_SUCCESS; else { DEBUG2(printk("scsi%ld: %s: MBOX_CMD_INITIALIZE_FIRMWARE " "failed w/ status %04X\n", ha->host_no, __func__, mbox_sts[0])); } dma_free_coherent(&ha->pdev->dev, sizeof(struct init_fw_ctrl_blk), init_fw_cb, init_fw_cb_dma); return status; }
static struct usb_interface_descriptor intf_desc = { .bLength = sizeof intf_desc, .bDescriptorType = USB_DT_INTERFACE, .bNumEndpoints = 2, .bInterfaceClass = 0xFF, .bInterfaceSubClass = 0xFF, .bInterfaceProtocol = 0xFF, }; static struct usb_endpoint_descriptor hs_bulk_in_desc = { .bLength = USB_DT_ENDPOINT_SIZE, .bDescriptorType = USB_DT_ENDPOINT, .bEndpointAddress = USB_DIR_IN, .bmAttributes = USB_ENDPOINT_XFER_BULK, .wMaxPacketSize = __constant_cpu_to_le16(512), .bInterval = 0, }; static struct usb_endpoint_descriptor fs_bulk_in_desc = { .bLength = USB_DT_ENDPOINT_SIZE, .bDescriptorType = USB_DT_ENDPOINT, .bEndpointAddress = USB_DIR_IN, .bmAttributes = USB_ENDPOINT_XFER_BULK, .wMaxPacketSize = __constant_cpu_to_le16(64), .bInterval = 0, }; static struct usb_endpoint_descriptor hs_bulk_out_desc = { .bLength = USB_DT_ENDPOINT_SIZE, .bDescriptorType = USB_DT_ENDPOINT, .bEndpointAddress = USB_DIR_OUT,
/*! Mouse Configuration Description */ struct usbd_configuration_description mouse_cf_configuration_description[] = { { //.configuration_descriptor = &mouse_configuration_descriptor, .iConfiguration = "USB Random Mouse Configuration", }, }; #if 0 /*! Device Description */ static struct usbd_device_descriptor mouse_cf_device_descriptor = { .bLength = sizeof(struct usbd_device_descriptor), .bDescriptorType = USB_DT_DEVICE, .bcdUSB = __constant_cpu_to_le16(USB_BCD_VERSION), .bDeviceClass = 0x00, .bDeviceSubClass = 0x00, .bDeviceProtocol = 0x00, .bMaxPacketSize0 = 0x00, .idVendor = __constant_cpu_to_le16(CONFIG_OTG_MOUSE_VENDORID), .idProduct = __constant_cpu_to_le16(CONFIG_OTG_MOUSE_PRODUCTID), .bcdDevice = __constant_cpu_to_le16(CONFIG_OTG_MOUSE_BCDDEVICE), }; #ifdef CONFIG_OTG_HIGH_SPEED /*! High Speed Device Description */ static struct usbd_device_qualifier_descriptor mouse_device_qualifier_descriptor = { .bLength = sizeof(struct usbd_device_qualifier_descriptor), .bDescriptorType = USB_DT_DEVICE_QUALIFIER,
void mouse_cf_global_init(void) { /*! Configuration description(s) */ ZERO(mouse_configuration_descriptor); mouse_configuration_descriptor.bLength = 0x09; mouse_configuration_descriptor.bDescriptorType = USB_DT_CONFIGURATION; mouse_configuration_descriptor.wTotalLength = 0x00; /*! Mouse Configuration Description */ ZERO(mouse_cf_configuration_description); //mouse_cf_configuration_description[0].configuration_descriptor = &mouse_configuration_descriptor; mouse_cf_configuration_description[0].iConfiguration = "USB Random Mouse Configuration"; #if 0 /*! Device Description */ ZERO(mouse_cf_device_descriptor); mouse_cf_device_descriptor.bLength = sizeof(struct usbd_device_descriptor); mouse_cf_device_descriptor.bDescriptorType = USB_DT_DEVICE; mouse_cf_device_descriptor.bcdUSB = __constant_cpu_to_le16(USB_BCD_VERSION); mouse_cf_device_descriptor.bDeviceClass = 0x00; mouse_cf_device_descriptor.bDeviceSubClass = 0x00; mouse_cf_device_descriptor.bDeviceProtocol = 0x00; mouse_cf_device_descriptor.bMaxPacketSize0 = 0x00; mouse_cf_device_descriptor.idVendor = __constant_cpu_to_le16(CONFIG_OTG_MOUSE_VENDORID); mouse_cf_device_descriptor.idProduct = __constant_cpu_to_le16(CONFIG_OTG_MOUSE_PRODUCTID); mouse_cf_device_descriptor.bcdDevice = __constant_cpu_to_le16(CONFIG_OTG_MOUSE_BCDDEVICE); #ifdef CONFIG_OTG_HIGH_SPEED /*! High Speed Device Description */ ZERO(mouse_device_qualifier_descriptor); mouse_device_qualifier_descriptor.bLength = sizeof(struct usbd_device_qualifier_descriptor); mouse_device_qualifier_descriptor.bDescriptorType = USB_DT_DEVICE_QUALIFIER; mouse_device_qualifier_descriptor.bcdUSB = __constant_cpu_to_le16(USB_BCD_VERSION); mouse_device_qualifier_descriptor.bDeviceClass = 0x00; mouse_device_qualifier_descriptor.bDeviceSubClass = 0x00; mouse_device_qualifier_descriptor.bDeviceProtocol = 0x00; mouse_device_qualifier_descriptor.bMaxPacketSize0 = 0x00; #endif /* CONFIG_OTG_HIGH_SPEED */ #endif /*! OTG Descriptor */ ZERO(mouse_otg_descriptor); mouse_otg_descriptor.bLength = sizeof(struct usbd_otg_descriptor); mouse_otg_descriptor.bDescriptorType = USB_DT_OTG; mouse_otg_descriptor.bmAttributes = 0; /*! Device Description */ ZERO(mouse_cf_device_description); //mouse_cf_device_description.device_descriptor = &mouse_cf_device_descriptor; #ifdef CONFIG_OTG_HIGH_SPEED mouse_cf_device_description.device_qualifier_descriptor = &mouse_device_qualifier_descriptor; #endif /* CONFIG_OTG_HIGH_SPEED */ mouse_cf_device_description.bDeviceClass = 0x00; mouse_cf_device_description.bDeviceSubClass = 0x00; mouse_cf_device_description.bDeviceProtocol = 0x00; mouse_cf_device_description.bMaxPacketSize0 = 0x00; mouse_cf_device_description.idVendor = __constant_cpu_to_le16(CONFIG_OTG_MOUSE_VENDORID); mouse_cf_device_description.idProduct = __constant_cpu_to_le16(CONFIG_OTG_MOUSE_PRODUCTID); mouse_cf_device_description.bcdDevice = __constant_cpu_to_le16(CONFIG_OTG_MOUSE_BCDDEVICE); mouse_cf_device_description.otg_descriptor = &mouse_otg_descriptor; mouse_cf_device_description.iManufacturer = CONFIG_OTG_MOUSE_MANUFACTURER; mouse_cf_device_description.iProduct = CONFIG_OTG_MOUSE_PRODUCT_NAME; #if !defined(CONFIG_OTG_NO_SERIAL_NUMBER) && defined(CONFIG_OTG_SERIAL_NUMBER_STR) mouse_cf_device_description.iSerialNumber = CONFIG_OTG_SERIAL_NUMBER_STR; #endif }
.bInterfaceClass = USB_CLASS_VENDOR_SPEC, .bInterfaceSubClass = 0, .bInterfaceProtocol = 0, /* .iInterface = DYNAMIC */ }; #ifdef CONFIG_MODEM_SUPPORT static struct usb_cdc_header_desc gser_header_desc = { .bLength = sizeof(gser_header_desc), .bDescriptorType = USB_DT_CS_INTERFACE, .bDescriptorSubType = USB_CDC_HEADER_TYPE, .bcdCDC = __constant_cpu_to_le16(0x0110), }; static struct usb_cdc_call_mgmt_descriptor gser_call_mgmt_descriptor = { .bLength = sizeof(gser_call_mgmt_descriptor), .bDescriptorType = USB_DT_CS_INTERFACE, .bDescriptorSubType = USB_CDC_CALL_MANAGEMENT_TYPE, .bmCapabilities = 0, /* .bDataInterface = DYNAMIC */ }; static struct usb_cdc_acm_descriptor gser_descriptor = { .bLength = sizeof(gser_descriptor), .bDescriptorType = USB_DT_CS_INTERFACE, .bDescriptorSubType = USB_CDC_ACM_TYPE,
}; #define TOTAL_LENGTH ( \ UAC_DT_AC_HEADER_SIZE(2) + \ UAC_DT_INPUT_TERMINAL_SIZE + \ UAC_DT_OUTPUT_TERMINAL_SIZE + \ UAC_DT_INPUT_TERMINAL_SIZE + \ UAC_DT_OUTPUT_TERMINAL_SIZE \ ) /* B.3.2 Class-Specific AC Interface Descriptor */ struct uac1_ac_header_descriptor_2 ac_header_desc = { .bLength = UAC_DT_AC_HEADER_SIZE(2), .bDescriptorType = USB_DT_CS_INTERFACE, .bDescriptorSubtype = UAC_HEADER, .bcdADC = __constant_cpu_to_le16(0x0100), .wTotalLength = __constant_cpu_to_le16(TOTAL_LENGTH), .bInCollection = F_AUDIO_NUM_INTERFACES, /*.baInterfaceNr = { [0] = F_AUDIO_INTERFACE_MICROPHONE, [1] = F_AUDIO_INTERFACE_SPEAKER, } */ }; /*---------------------------------*/ struct uac_input_terminal_descriptor speaker_input_terminal_desc = { .bLength = UAC_DT_INPUT_TERMINAL_SIZE, .bDescriptorType = USB_DT_CS_INTERFACE, .bDescriptorSubtype = UAC_INPUT_TERMINAL,
}; static struct usb_gadget_strings stringtab_dev = { .language = 0x0409, /* en-us */ .strings = strings_dev, }; static struct usb_gadget_strings *dev_strings[] = { &stringtab_dev, NULL, }; static struct usb_device_descriptor device_desc = { .bLength = USB_DT_DEVICE_SIZE, .bDescriptorType = USB_DT_DEVICE, .bcdUSB = __constant_cpu_to_le16(0x0200), .bDeviceClass = USB_CLASS_COMM, .idVendor = __constant_cpu_to_le16(NOKIA_VENDOR_ID), .idProduct = __constant_cpu_to_le16(NOKIA_PRODUCT_ID), /* .iManufacturer = DYNAMIC */ /* .iProduct = DYNAMIC */ .bNumConfigurations = 1, }; /*-------------------------------------------------------------------------*/ #ifdef CONFIG_USB_G_NOKIA_EEM static int use_eem = 1; #else static int use_eem; #endif
}; struct usb_interface_descriptor eth_control_intf = { .bLength = USB_DT_INTERFACE_SIZE, .bDescriptorType = USB_DT_INTERFACE, .bNumEndpoints = 1, .bInterfaceClass = USB_CLASS_COMM, .bInterfaceSubClass = USB_CDC_SUBCLASS_ETHERNET, .bInterfaceProtocol = USB_CDC_PROTO_NONE, }; struct usb_cdc_header_desc eth_header_desc = { .bLength = sizeof(struct usb_cdc_header_desc), .bDescriptorType = USB_DT_CS_INTERFACE, .bDescriptorSubType = USB_CDC_HEADER_TYPE, .bcdCDC = __constant_cpu_to_le16(0x0110), }; struct usb_cdc_union_desc eth_union_desc = { .bLength = sizeof(struct usb_cdc_union_desc), .bDescriptorType = USB_DT_CS_INTERFACE, .bDescriptorSubType = USB_CDC_UNION_TYPE, }; struct usb_cdc_ether_desc eth_ether_desc = { .bLength = sizeof(struct usb_cdc_ether_desc), .bDescriptorType = USB_DT_CS_INTERFACE, .bDescriptorSubType = USB_CDC_ETHERNET_TYPE, .bmEthernetStatistics = __constant_cpu_to_le32(0), .wMaxSegmentSize = __constant_cpu_to_le16(ETH_FRAME_LEN),
cifs_dbg(VFS, "Mids do not match: %llu and %llu\n", mid, hdr->MessageId); } cifs_dbg(VFS, "Bad SMB detected. The Mid=%llu\n", hdr->MessageId); return 1; } /* * The following table defines the expected "StructureSize" of SMB2 responses * in order by SMB2 command. This is similar to "wct" in SMB/CIFS responses. * * Note that commands are defined in smb2pdu.h in le16 but the array below is * indexed by command in host byte order */ static const __le16 smb2_rsp_struct_sizes[NUMBER_OF_SMB2_COMMANDS] = { /* SMB2_NEGOTIATE */ __constant_cpu_to_le16(65), /* SMB2_SESSION_SETUP */ __constant_cpu_to_le16(9), /* SMB2_LOGOFF */ __constant_cpu_to_le16(4), /* SMB2_TREE_CONNECT */ __constant_cpu_to_le16(16), /* SMB2_TREE_DISCONNECT */ __constant_cpu_to_le16(4), /* SMB2_CREATE */ __constant_cpu_to_le16(89), /* SMB2_CLOSE */ __constant_cpu_to_le16(60), /* SMB2_FLUSH */ __constant_cpu_to_le16(4), /* SMB2_READ */ __constant_cpu_to_le16(17), /* SMB2_WRITE */ __constant_cpu_to_le16(17), /* SMB2_LOCK */ __constant_cpu_to_le16(4), /* SMB2_IOCTL */ __constant_cpu_to_le16(49), /* BB CHECK this ... not listed in documentation */ /* SMB2_CANCEL */ __constant_cpu_to_le16(0), /* SMB2_ECHO */ __constant_cpu_to_le16(4), /* SMB2_QUERY_DIRECTORY */ __constant_cpu_to_le16(9),
.bInterfaceClass = USB_CLASS_AUDIO, .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL, }; #define UAC_DT_AC_HEADER_LENGTH UAC_DT_AC_HEADER_SIZE(AUDIO_NUM_INTERFACES) /* 1 input terminal, 1 output terminal and 1 feature unit */ #define UAC_DT_TOTAL_LENGTH (UAC_DT_AC_HEADER_LENGTH \ + UAC_DT_INPUT_TERMINAL_SIZE + UAC_DT_OUTPUT_TERMINAL_SIZE \ + UAC_DT_FEATURE_UNIT_SIZE(0)) /* B.3.2 Class-Specific AC Interface Descriptor */ static struct uac1_ac_header_descriptor_2 audio_source_ac_header_desc = { .bLength = UAC_DT_AC_HEADER_LENGTH, .bDescriptorType = USB_DT_CS_INTERFACE, .bDescriptorSubtype = UAC_HEADER, .bcdADC = __constant_cpu_to_le16(0x0100), .wTotalLength = __constant_cpu_to_le16(UAC_DT_TOTAL_LENGTH), .bInCollection = AUDIO_NUM_INTERFACES, .baInterfaceNr = { [0] = AUDIO_AC_INTERFACE, [1] = AUDIO_AS_INTERFACE, } }; #define INPUT_TERMINAL_ID 1 static struct uac_input_terminal_descriptor input_terminal_desc = { .bLength = UAC_DT_INPUT_TERMINAL_SIZE, .bDescriptorType = USB_DT_CS_INTERFACE, .bDescriptorSubtype = UAC_INPUT_TERMINAL, .bTerminalID = INPUT_TERMINAL_ID, .wTerminalType = UAC_INPUT_TERMINAL_MICROPHONE,
static int __init zero_bind(struct usb_gadget *gadget) { struct zero_dev *dev; struct usb_ep *ep; int gcnum; /* FIXME this can't yet work right with SH ... it has only * one configuration, numbered one. */ if (gadget_is_sh(gadget)) return -ENODEV; /* Bulk-only drivers like this one SHOULD be able to * autoconfigure on any sane usb controller driver, * but there may also be important quirks to address. */ usb_ep_autoconfig_reset(gadget); ep = usb_ep_autoconfig(gadget, &fs_source_desc); if (!ep) { autoconf_fail: pr_err("%s: can't autoconfigure on %s\n", shortname, gadget->name); return -ENODEV; } EP_IN_NAME = ep->name; ep->driver_data = ep; /* claim */ ep = usb_ep_autoconfig(gadget, &fs_sink_desc); if (!ep) goto autoconf_fail; EP_OUT_NAME = ep->name; ep->driver_data = ep; /* claim */ gcnum = usb_gadget_controller_number(gadget); if (gcnum >= 0) device_desc.bcdDevice = cpu_to_le16(0x0200 + gcnum); else { /* gadget zero is so simple (for now, no altsettings) that * it SHOULD NOT have problems with bulk-capable hardware. * so warn about unrcognized controllers, don't panic. * * things like configuration and altsetting numbering * can need hardware-specific attention though. */ pr_warning("%s: controller '%s' not recognized\n", shortname, gadget->name); device_desc.bcdDevice = __constant_cpu_to_le16(0x9999); } /* ok, we made sense of the hardware ... */ dev = kzalloc(sizeof(*dev), GFP_KERNEL); if (!dev) return -ENOMEM; spin_lock_init(&dev->lock); dev->gadget = gadget; set_gadget_data(gadget, dev); init_timer(&dev->resume); dev->resume.function = zero_autoresume; dev->resume.data = (unsigned long) dev; /* preallocate control response and buffer */ dev->req = usb_ep_alloc_request(gadget->ep0, GFP_KERNEL); if (!dev->req) goto enomem; dev->req->buf = kmalloc(USB_BUFSIZ, GFP_KERNEL); if (!dev->req->buf) goto enomem; dev->req->complete = zero_setup_complete; device_desc.bMaxPacketSize0 = gadget->ep0->maxpacket; if (gadget_is_dualspeed(gadget)) { /* assume ep0 uses the same value for both speeds ... */ dev_qualifier.bMaxPacketSize0 = device_desc.bMaxPacketSize0; /* and that all endpoints are dual-speed */ hs_source_desc.bEndpointAddress = fs_source_desc.bEndpointAddress; hs_sink_desc.bEndpointAddress = fs_sink_desc.bEndpointAddress; } if (gadget_is_otg(gadget)) { otg_descriptor.bmAttributes |= USB_OTG_HNP, source_sink_config.bmAttributes |= USB_CONFIG_ATT_WAKEUP; loopback_config.bmAttributes |= USB_CONFIG_ATT_WAKEUP; } usb_gadget_set_selfpowered(gadget); if (autoresume) { source_sink_config.bmAttributes |= USB_CONFIG_ATT_WAKEUP; loopback_config.bmAttributes |= USB_CONFIG_ATT_WAKEUP; } gadget->ep0->driver_data = dev; INFO(dev, "%s, version: " DRIVER_VERSION "\n", longname); INFO(dev, "using %s, OUT %s IN %s\n", gadget->name, EP_OUT_NAME, EP_IN_NAME); snprintf(manufacturer, sizeof manufacturer, "%s %s with %s", init_utsname()->sysname, init_utsname()->release, gadget->name); return 0; enomem: zero_unbind(gadget); return -ENOMEM; }
static int __init gs_bind(struct usb_composite_dev *cdev) { int gcnum; struct usb_gadget *gadget = cdev->gadget; int status; status = gserial_setup(cdev->gadget, n_ports); if (status < 0) return status; /* Allocate string descriptor numbers ... note that string * contents can be overridden by the composite_dev glue. */ /* device description: manufacturer, product */ snprintf(manufacturer, sizeof manufacturer, "%s %s with %s", init_utsname()->sysname, init_utsname()->release, gadget->name); status = usb_string_id(cdev); if (status < 0) goto fail; strings_dev[STRING_MANUFACTURER_IDX].id = status; device_desc.iManufacturer = status; status = usb_string_id(cdev); if (status < 0) goto fail; strings_dev[STRING_PRODUCT_IDX].id = status; device_desc.iProduct = status; /* config description */ status = usb_string_id(cdev); if (status < 0) goto fail; strings_dev[STRING_DESCRIPTION_IDX].id = status; serial_config_driver.iConfiguration = status; /* set up other descriptors */ gcnum = usb_gadget_controller_number(gadget); if (gcnum >= 0) device_desc.bcdDevice = cpu_to_le16(GS_VERSION_NUM | gcnum); else { /* this is so simple (for now, no altsettings) that it * SHOULD NOT have problems with bulk-capable hardware. * so warn about unrcognized controllers -- don't panic. * * things like configuration and altsetting numbering * can need hardware-specific attention though. */ pr_warning("gs_bind: controller '%s' not recognized\n", gadget->name); device_desc.bcdDevice = __constant_cpu_to_le16(GS_VERSION_NUM | 0x0099); } if (gadget_is_otg(cdev->gadget)) { serial_config_driver.descriptors = otg_desc; serial_config_driver.bmAttributes |= USB_CONFIG_ATT_WAKEUP; } /* register our configuration */ status = usb_add_config(cdev, &serial_config_driver); if (status < 0) goto fail; INFO(cdev, "%s\n", GS_VERSION_NAME); return 0; fail: gserial_cleanup(); return status; }
}; static struct usb_gadget_strings stringtab_dev = { .language = 0x0409, /* en-us */ .strings = strings_dev, }; static struct usb_gadget_strings *dev_strings[] = { &stringtab_dev, NULL, }; static struct usb_device_descriptor device_desc = { .bLength = USB_DT_DEVICE_SIZE, .bDescriptorType = USB_DT_DEVICE, .bcdUSB = __constant_cpu_to_le16(0x0200), /* .bDeviceClass = f(use_acm) */ .bDeviceSubClass = 0, .bDeviceProtocol = 0, /* .bMaxPacketSize0 = f(hardware) */ .idVendor = __constant_cpu_to_le16(GS_VENDOR_ID), /* .idProduct = f(use_acm) */ /* .bcdDevice = f(hardware) */ /* .iManufacturer = DYNAMIC */ /* .iProduct = DYNAMIC */ .bNumConfigurations = 1, }; static struct usb_otg_descriptor otg_descriptor = { .bLength = sizeof otg_descriptor, .bDescriptorType = USB_DT_OTG,
ret = amlkey_isexsit((const uint8_t *)USID_KEY); if (ret) { ret = amlkey_size((const uint8_t *)USID_KEY); if (ret && ret < MAX_STRING_SERIAL) { amlkey_read((const uint8_t *)USID_KEY, (uint8_t *)usid_string, ret); return usid_string; } } return NULL; } static struct usb_device_descriptor device_desc = { .bLength = sizeof device_desc, .bDescriptorType = USB_DT_DEVICE, .bcdUSB = __constant_cpu_to_le16(0x0200), .bDeviceClass = USB_CLASS_COMM, .bDeviceSubClass = 0x02, /*0x02:CDC-modem , 0x00:CDC-serial*/ .idVendor = 0x18d1, .idProduct = 0x0d02, .iProduct = STRING_PRODUCT, .iSerialNumber = STRING_SERIAL, .bNumConfigurations = 1, }; /* * static strings, in UTF-8 * IDs for those strings are assigned dynamically at g_dnl_bind() */ static struct usb_string g_dnl_string_defs[] = {
#include "f_audio.c" /*-------------------------------------------------------------------------*/ /* Thanks to Linux Foundation for donating this product ID. */ #define AUDIO_VENDOR_NUM 0x1d6b /* Linux Foundation */ #define AUDIO_PRODUCT_NUM 0x0101 /* Linux-USB Audio Gadget */ /*-------------------------------------------------------------------------*/ static struct usb_device_descriptor device_desc = { .bLength = sizeof device_desc, .bDescriptorType = USB_DT_DEVICE, .bcdUSB = __constant_cpu_to_le16(0x200), .bDeviceClass = USB_CLASS_PER_INTERFACE, .bDeviceSubClass = 0, .bDeviceProtocol = 0, /* .bMaxPacketSize0 = f(hardware) */ /* Vendor and product id defaults change according to what configs * we support. (As does bNumConfigurations.) These values can * also be overridden by module parameters. */ .idVendor = __constant_cpu_to_le16(AUDIO_VENDOR_NUM), .idProduct = __constant_cpu_to_le16(AUDIO_PRODUCT_NUM), /* .bcdDevice = f(hardware) */ /* .iManufacturer = DYNAMIC */ /* .iProduct = DYNAMIC */