Changes in / [ef521d4:66b3e0b] in mainline


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

Legend:

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

    ref521d4 r66b3e0b  
    267267        assert(addr);
    268268       
    269         // TODO
     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);
    270295}
    271296
     
    492517        nic_t *nic = nic_get_from_ddf_dev(dev);
    493518       
    494         /* TODO: Report HW address here. */
     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        */
    495526       
    496527        /* Create AR9271 function.*/
  • uspace/drv/bus/usb/ar9271/htc.c

    ref521d4 r66b3e0b  
    5050static inline uint8_t wmi_service_to_download_pipe(wmi_services_t service_id)
    5151{
    52         return (service_id == WMI_CONTROL_SERVICE) ? 3 : 2;
     52        switch(service_id) {
     53                case WMI_CONTROL_SERVICE:
     54                        return 3;
     55                default:
     56                        return 2;
     57        }
    5358}
    5459
     
    6267static inline uint8_t wmi_service_to_upload_pipe(wmi_services_t service_id)
    6368{
    64         return (service_id == WMI_CONTROL_SERVICE) ? 4 : 1;
     69        switch(service_id) {
     70                case WMI_CONTROL_SERVICE:
     71                        return 4;
     72                default:
     73                        return 1;
     74        }
    6575}
    6676
     
    116126 * @param response_endpoint_no HTC endpoint to be used for this service.
    117127 *
    118  * @return EOK if succeed, EINVAL when failed to connect service,
    119  * negative error code otherwise.
     128 * @return EOK if succeed, negative error code otherwise.
    120129 */
    121130static int htc_connect_service(htc_device_t *htc_device,
     
    143152                htc_device->endpoints.ctrl_endpoint);
    144153        if(rc != EOK) {
    145                 free(buffer);
    146154                usb_log_error("Failed to send HTC message. Error: %d\n", rc);
    147155                return rc;
     
    156164        rc = htc_read_message(htc_device, buffer, buffer_size, NULL);
    157165        if(rc != EOK) {
    158                 free(buffer);
    159166                usb_log_error("Failed to receive HTC service connect response. "
    160167                        "Error: %d\n", rc);
     
    169176        if(response_message->status == HTC_SERVICE_SUCCESS) {
    170177                *response_endpoint_no = response_message->endpoint_id;
    171                 rc = EOK;
     178                return EOK;
    172179        } else {
    173180                usb_log_error("Failed to connect HTC service. "
    174181                        "Message status: %d\n", response_message->status);
    175                 rc = EINVAL;
     182                return rc;
    176183        }
    177        
    178         free(buffer);
    179        
    180         return rc;
    181184}
    182185
     
    190193static int htc_config_credits(htc_device_t *htc_device)
    191194{
    192         size_t buffer_size = sizeof(htc_frame_header_t) +
    193                 sizeof(htc_config_msg_t);
     195        size_t buffer_size = sizeof(htc_frame_header_t) + 50;
    194196        void *buffer = malloc(buffer_size);
    195197        htc_config_msg_t *config_message = (htc_config_msg_t *)
     
    202204        config_message->pipe_id = 1;
    203205
    204         /* Send HTC message. */
    205206        int rc = htc_send_message(htc_device, buffer, buffer_size,
    206207                htc_device->endpoints.ctrl_endpoint);
    207208        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         }
    225        
    226         free(buffer);
     224                return rc;
     225        }
    227226
    228227        return rc;
     
    238237static int htc_complete_setup(htc_device_t *htc_device)
    239238{
    240         size_t buffer_size = sizeof(htc_frame_header_t) +
    241                 sizeof(htc_setup_complete_msg_t);
     239        size_t buffer_size = sizeof(htc_frame_header_t) + 50;
    242240        void *buffer = malloc(buffer_size);
    243241        htc_setup_complete_msg_t *complete_message =
     
    248246                host2uint16_t_be(HTC_MESSAGE_SETUP_COMPLETE);
    249247
    250         /* Send HTC message. */
    251248        int rc = htc_send_message(htc_device, buffer, buffer_size,
    252249                htc_device->endpoints.ctrl_endpoint);
     
    254251                usb_log_error("Failed to send HTC setup complete message. "
    255252                        "Error: %d\n", rc);
    256         }
    257        
    258         free(buffer);
     253                return rc;
     254        }
    259255
    260256        return rc;
     
    267263 * @param htc_device HTC device structure.
    268264 *
    269  * @return EOK if succeed, EINVAL if response error, negative error code
    270  * otherwise.
     265 * @return EOK if succeed, negative error code otherwise.
    271266 */
    272267static int htc_check_ready(htc_device_t *htc_device)
     
    275270        void *buffer = malloc(buffer_size);
    276271
    277         /* Read response from device. */
    278272        int rc = htc_read_message(htc_device, buffer, buffer_size, NULL);
    279273        if(rc != EOK) {
    280                 free(buffer);
    281274                usb_log_error("Failed to receive HTC check ready message. "
    282275                        "Error: %d\n", rc);
     
    287280                sizeof(htc_frame_header_t));
    288281        if(uint16_t_be2host(*message_id) == HTC_MESSAGE_READY) {
    289                 rc = EOK;
     282                return EOK;
    290283        } else {
    291                 rc = EINVAL;
    292         }
    293        
    294         free(buffer);
    295        
    296         return rc;
     284                return EINVAL;
     285        }
    297286}
    298287
  • uspace/drv/bus/usb/ar9271/hw.c

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

    ref521d4 r66b3e0b  
    163163                host2uint16_t_be(++htc_device->sequence_number);
    164164       
    165         /* Send message. */
    166165        int rc = htc_send_message(htc_device, buffer, buffer_size,
    167166                htc_device->endpoints.wmi_endpoint);
    168167        if(rc != EOK) {
    169                 free(buffer);
    170168                usb_log_error("Failed to send WMI message. Error: %d\n", rc);
    171                 return rc;
    172169        }
    173170       
     
    177174        buffer = malloc(buffer_size);
    178175       
    179         /* Read response. */
    180176        rc = htc_read_message(htc_device, buffer, buffer_size, NULL);
    181177        if(rc != EOK) {
Note: See TracChangeset for help on using the changeset viewer.