Changes in / [66b3e0b:ef521d4] in mainline


Ignore:
Location:
uspace/drv/bus/usb/ar9271
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • uspace/drv/bus/usb/ar9271/ar9271.c

    r66b3e0b ref521d4  
    267267        assert(addr);
    268268       
    269         fibril_mutex_lock(&ar9271->htc_device->rx_lock);
    270        
    271         uint32_t *mac0_dest = (uint32_t *)(addr->address);
    272         uint16_t *mac4_dest = (uint16_t *)(addr->address + 4);
    273        
    274         void *ar9271_mac_addr = 0;
    275 
    276         /* Read MAC address from the i/o (4byte + 2byte reads) */
    277         // TODO: Now just testing register address
    278         /*
    279         usb_log_info("Trying to get some testing register from device.\n");
    280        
    281         uint32_t result;
    282         int rc = wmi_reg_read(ar9271->usb_device,
    283             0x50040,
    284             //AR9271_MAC_REG_OFFSET | AR9271_MAC_PCU_STA_ADDR_L32,
    285             &result);
    286         if(rc != EOK) {
    287                 usb_log_info("Failed to read registry value. Error: %d\n", rc);
    288                 return rc;
    289         }
    290        
    291         usb_log_info("Registry value: %x\n", result);
    292          */
    293        
    294         fibril_mutex_unlock(&ar9271->htc_device->rx_lock);
     269        // TODO
    295270}
    296271
     
    517492        nic_t *nic = nic_get_from_ddf_dev(dev);
    518493       
    519         /*
    520         nic_address_t addr;
    521         ar9271_hw_get_addr(ar9271, &addr);
    522         rc = nic_report_address(nic, &addr);
    523        
    524         usb_log_info("Reported address.\n");
    525         */
     494        /* TODO: Report HW address here. */
    526495       
    527496        /* Create AR9271 function.*/
  • uspace/drv/bus/usb/ar9271/htc.c

    r66b3e0b ref521d4  
    5050static inline uint8_t wmi_service_to_download_pipe(wmi_services_t service_id)
    5151{
    52         switch(service_id) {
    53                 case WMI_CONTROL_SERVICE:
    54                         return 3;
    55                 default:
    56                         return 2;
    57         }
     52        return (service_id == WMI_CONTROL_SERVICE) ? 3 : 2;
    5853}
    5954
     
    6762static inline uint8_t wmi_service_to_upload_pipe(wmi_services_t service_id)
    6863{
    69         switch(service_id) {
    70                 case WMI_CONTROL_SERVICE:
    71                         return 4;
    72                 default:
    73                         return 1;
    74         }
     64        return (service_id == WMI_CONTROL_SERVICE) ? 4 : 1;
    7565}
    7666
     
    126116 * @param response_endpoint_no HTC endpoint to be used for this service.
    127117 *
    128  * @return EOK if succeed, negative error code otherwise.
     118 * @return EOK if succeed, EINVAL when failed to connect service,
     119 * negative error code otherwise.
    129120 */
    130121static int htc_connect_service(htc_device_t *htc_device,
     
    152143                htc_device->endpoints.ctrl_endpoint);
    153144        if(rc != EOK) {
     145                free(buffer);
    154146                usb_log_error("Failed to send HTC message. Error: %d\n", rc);
    155147                return rc;
     
    164156        rc = htc_read_message(htc_device, buffer, buffer_size, NULL);
    165157        if(rc != EOK) {
     158                free(buffer);
    166159                usb_log_error("Failed to receive HTC service connect response. "
    167160                        "Error: %d\n", rc);
     
    176169        if(response_message->status == HTC_SERVICE_SUCCESS) {
    177170                *response_endpoint_no = response_message->endpoint_id;
    178                 return EOK;
     171                rc = EOK;
    179172        } else {
    180173                usb_log_error("Failed to connect HTC service. "
    181174                        "Message status: %d\n", response_message->status);
    182                 return rc;
     175                rc = EINVAL;
    183176        }
     177       
     178        free(buffer);
     179       
     180        return rc;
    184181}
    185182
     
    193190static int htc_config_credits(htc_device_t *htc_device)
    194191{
    195         size_t buffer_size = sizeof(htc_frame_header_t) + 50;
     192        size_t buffer_size = sizeof(htc_frame_header_t) +
     193                sizeof(htc_config_msg_t);
    196194        void *buffer = malloc(buffer_size);
    197195        htc_config_msg_t *config_message = (htc_config_msg_t *)
     
    204202        config_message->pipe_id = 1;
    205203
     204        /* Send HTC message. */
    206205        int rc = htc_send_message(htc_device, buffer, buffer_size,
    207206                htc_device->endpoints.ctrl_endpoint);
    208207        if(rc != EOK) {
     208                free(buffer);
    209209                usb_log_error("Failed to send HTC config message. "
    210210                        "Error: %d\n", rc);
     
    222222                usb_log_error("Failed to receive HTC config response message. "
    223223                        "Error: %d\n", rc);
    224                 return rc;
    225         }
     224        }
     225       
     226        free(buffer);
    226227
    227228        return rc;
     
    237238static int htc_complete_setup(htc_device_t *htc_device)
    238239{
    239         size_t buffer_size = sizeof(htc_frame_header_t) + 50;
     240        size_t buffer_size = sizeof(htc_frame_header_t) +
     241                sizeof(htc_setup_complete_msg_t);
    240242        void *buffer = malloc(buffer_size);
    241243        htc_setup_complete_msg_t *complete_message =
     
    246248                host2uint16_t_be(HTC_MESSAGE_SETUP_COMPLETE);
    247249
     250        /* Send HTC message. */
    248251        int rc = htc_send_message(htc_device, buffer, buffer_size,
    249252                htc_device->endpoints.ctrl_endpoint);
     
    251254                usb_log_error("Failed to send HTC setup complete message. "
    252255                        "Error: %d\n", rc);
    253                 return rc;
    254         }
     256        }
     257       
     258        free(buffer);
    255259
    256260        return rc;
     
    263267 * @param htc_device HTC device structure.
    264268 *
    265  * @return EOK if succeed, negative error code otherwise.
     269 * @return EOK if succeed, EINVAL if response error, negative error code
     270 * otherwise.
    266271 */
    267272static int htc_check_ready(htc_device_t *htc_device)
     
    270275        void *buffer = malloc(buffer_size);
    271276
     277        /* Read response from device. */
    272278        int rc = htc_read_message(htc_device, buffer, buffer_size, NULL);
    273279        if(rc != EOK) {
     280                free(buffer);
    274281                usb_log_error("Failed to receive HTC check ready message. "
    275282                        "Error: %d\n", rc);
     
    280287                sizeof(htc_frame_header_t));
    281288        if(uint16_t_be2host(*message_id) == HTC_MESSAGE_READY) {
    282                 return EOK;
     289                rc = EOK;
    283290        } else {
    284                 return EINVAL;
    285         }
     291                rc = EINVAL;
     292        }
     293       
     294        free(buffer);
     295       
     296        return rc;
    286297}
    287298
  • uspace/drv/bus/usb/ar9271/hw.c

    r66b3e0b ref521d4  
    128128        }
    129129       
     130        /* TODO: Finish HW init. */
     131       
    130132        return EOK;
    131133}
  • uspace/drv/bus/usb/ar9271/wmi.c

    r66b3e0b ref521d4  
    163163                host2uint16_t_be(++htc_device->sequence_number);
    164164       
     165        /* Send message. */
    165166        int rc = htc_send_message(htc_device, buffer, buffer_size,
    166167                htc_device->endpoints.wmi_endpoint);
    167168        if(rc != EOK) {
     169                free(buffer);
    168170                usb_log_error("Failed to send WMI message. Error: %d\n", rc);
     171                return rc;
    169172        }
    170173       
     
    174177        buffer = malloc(buffer_size);
    175178       
     179        /* Read response. */
    176180        rc = htc_read_message(htc_device, buffer, buffer_size, NULL);
    177181        if(rc != EOK) {
Note: See TracChangeset for help on using the changeset viewer.