Changeset c028b22 in mainline for uspace/drv/bus


Ignore:
Timestamp:
2011-07-08T17:01:01Z (15 years ago)
Author:
Martin Sucha <sucha14@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
cc1a727
Parents:
4e36219 (diff), 026793d (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge mainline changes

Location:
uspace/drv/bus
Files:
133 added
12 moved

Legend:

Unmodified
Added
Removed

  • uspace/drv/bus/isa/Makefile

    r4e36219 rc028b22  
    2727#
    2828
    29 USPACE_PREFIX = ../..
     29USPACE_PREFIX = ../../..
    3030LIBS = $(LIBDRV_PREFIX)/libdrv.a
    3131EXTRA_CFLAGS += -I$(LIBDRV_PREFIX)/include

  • uspace/drv/bus/pci/pciintel/Makefile

    r4e36219 rc028b22  
    2727#
    2828
    29 USPACE_PREFIX = ../..
     29USPACE_PREFIX = ../../../..
    3030LIBS = $(LIBDRV_PREFIX)/libdrv.a
    3131EXTRA_CFLAGS += -I$(LIBDRV_PREFIX)/include

  • uspace/drv/bus/pci/pciintel/pci.c

    r4e36219 rc028b22  
    5252#include <ipc/devman.h>
    5353#include <ipc/dev_iface.h>
     54#include <ipc/irc.h>
     55#include <ns.h>
     56#include <ipc/services.h>
     57#include <sysinfo.h>
    5458#include <ops/hw_res.h>
    5559#include <device/hw_res.h>
    5660#include <ddi.h>
    5761#include <libarch/ddi.h>
     62#include <pci_dev_iface.h>
    5863
    5964#include "pci.h"
    … …  
    8489static bool pciintel_enable_interrupt(ddf_fun_t *fnode)
    8590{
    86         /* TODO */
    87        
    88         return false;
     91        /* This is an old ugly way, copied from ne2000 driver */
     92        assert(fnode);
     93        pci_fun_t *dev_data = (pci_fun_t *) fnode->driver_data;
     94       
     95        sysarg_t apic;
     96        sysarg_t i8259;
     97       
     98        async_sess_t *irc_sess = NULL;
     99       
     100        if (((sysinfo_get_value("apic", &apic) == EOK) && (apic))
     101            || ((sysinfo_get_value("i8259", &i8259) == EOK) && (i8259))) {
     102                irc_sess = service_connect_blocking(EXCHANGE_SERIALIZE,
     103                    SERVICE_IRC, 0, 0);
     104        }
     105       
     106        if (!irc_sess)
     107                return false;
     108       
     109        size_t i = 0;
     110        hw_resource_list_t *res = &dev_data->hw_resources;
     111        for (; i < res->count; i++) {
     112                if (res->resources[i].type == INTERRUPT) {
     113                        const int irq = res->resources[i].res.interrupt.irq;
     114                       
     115                        async_exch_t *exch = async_exchange_begin(irc_sess);
     116                        const int rc =
     117                            async_req_1_0(exch, IRC_ENABLE_INTERRUPT, irq);
     118                        async_exchange_end(exch);
     119                       
     120                        if (rc != EOK) {
     121                                async_hangup(irc_sess);
     122                                return false;
     123                        }
     124                }
     125        }
     126       
     127        async_hangup(irc_sess);
     128        return true;
     129}
     130
     131static int pci_config_space_write_32(ddf_fun_t *fun, uint32_t address,
     132    uint32_t data)
     133{
     134        if (address > 252)
     135                return EINVAL;
     136        pci_conf_write_32(PCI_FUN(fun), address, data);
     137        return EOK;
     138}
     139
     140static int pci_config_space_write_16(
     141    ddf_fun_t *fun, uint32_t address, uint16_t data)
     142{
     143        if (address > 254)
     144                return EINVAL;
     145        pci_conf_write_16(PCI_FUN(fun), address, data);
     146        return EOK;
     147}
     148
     149static int pci_config_space_write_8(
     150    ddf_fun_t *fun, uint32_t address, uint8_t data)
     151{
     152        if (address > 255)
     153                return EINVAL;
     154        pci_conf_write_8(PCI_FUN(fun), address, data);
     155        return EOK;
     156}
     157
     158static int pci_config_space_read_32(
     159    ddf_fun_t *fun, uint32_t address, uint32_t *data)
     160{
     161        if (address > 252)
     162                return EINVAL;
     163        *data = pci_conf_read_32(PCI_FUN(fun), address);
     164        return EOK;
     165}
     166
     167static int pci_config_space_read_16(
     168    ddf_fun_t *fun, uint32_t address, uint16_t *data)
     169{
     170        if (address > 254)
     171                return EINVAL;
     172        *data = pci_conf_read_16(PCI_FUN(fun), address);
     173        return EOK;
     174}
     175
     176static int pci_config_space_read_8(
     177    ddf_fun_t *fun, uint32_t address, uint8_t *data)
     178{
     179        if (address > 255)
     180                return EINVAL;
     181        *data = pci_conf_read_8(PCI_FUN(fun), address);
     182        return EOK;
    89183}
    90184
    … …  
    94188};
    95189
    96 static ddf_dev_ops_t pci_fun_ops;
     190static pci_dev_iface_t pci_dev_ops = {
     191        .config_space_read_8 = &pci_config_space_read_8,
     192        .config_space_read_16 = &pci_config_space_read_16,
     193        .config_space_read_32 = &pci_config_space_read_32,
     194        .config_space_write_8 = &pci_config_space_write_8,
     195        .config_space_write_16 = &pci_config_space_write_16,
     196        .config_space_write_32 = &pci_config_space_write_32
     197};
     198
     199static ddf_dev_ops_t pci_fun_ops = {
     200        .interfaces[HW_RES_DEV_IFACE] = &pciintel_hw_res_ops,
     201        .interfaces[PCI_DEV_IFACE] = &pci_dev_ops
     202};
    97203
    98204static int pci_add_device(ddf_dev_t *);
    … …  
    288394        /* Get the value of the BAR. */
    289395        val = pci_conf_read_32(fun, addr);
     396
     397#define IO_MASK  (~0x3)
     398#define MEM_MASK (~0xf)
    290399       
    291400        io = (bool) (val & 1);
    292401        if (io) {
    293402                addrw64 = false;
     403                mask = IO_MASK;
    294404        } else {
     405                mask = MEM_MASK;
    295406                switch ((val >> 1) & 3) {
    296407                case 0:
    … …  
    308419        /* Get the address mask. */
    309420        pci_conf_write_32(fun, addr, 0xffffffff);
    310         mask = pci_conf_read_32(fun, addr);
     421        mask &= pci_conf_read_32(fun, addr);
    311422       
    312423        /* Restore the original value. */
    … …  
    469580       
    470581        ddf_msg(LVL_DEBUG, "pci_add_device");
    471         dnode->parent_phone = -1;
     582        dnode->parent_sess = NULL;
    472583       
    473584        bus = pci_bus_new();
    … …  
    480591        dnode->driver_data = bus;
    481592       
    482         dnode->parent_phone = devman_parent_device_connect(dnode->handle,
    483             IPC_FLAG_BLOCKING);
    484         if (dnode->parent_phone < 0) {
     593        dnode->parent_sess = devman_parent_device_connect(EXCHANGE_SERIALIZE,
     594            dnode->handle, IPC_FLAG_BLOCKING);
     595        if (!dnode->parent_sess) {
    485596                ddf_msg(LVL_ERROR, "pci_add_device failed to connect to the "
    486                     "parent's driver.");
    487                 rc = dnode->parent_phone;
     597                    "parent driver.");
     598                rc = ENOENT;
    488599                goto fail;
    489600        }
    … …  
    491602        hw_resource_list_t hw_resources;
    492603       
    493         rc = hw_res_get_resource_list(dnode->parent_phone, &hw_resources);
     604        rc = hw_res_get_resource_list(dnode->parent_sess, &hw_resources);
    494605        if (rc != EOK) {
    495606                ddf_msg(LVL_ERROR, "pci_add_device failed to get hw resources "
    … …  
    544655        if (bus != NULL)
    545656                pci_bus_delete(bus);
    546         if (dnode->parent_phone >= 0)
    547                 async_hangup(dnode->parent_phone);
     657       
     658        if (dnode->parent_sess)
     659                async_hangup(dnode->parent_sess);
     660       
    548661        if (got_res)
    549662                hw_res_clean_resource_list(&hw_resources);
     663       
    550664        if (ctl != NULL)
    551665                ddf_fun_destroy(ctl);
    552 
     666       
    553667        return rc;
    554668}
    … …  
    558672        ddf_log_init(NAME, LVL_ERROR);
    559673        pci_fun_ops.interfaces[HW_RES_DEV_IFACE] = &pciintel_hw_res_ops;
     674        pci_fun_ops.interfaces[PCI_DEV_IFACE] = &pci_dev_ops;
    560675}
    561676
    … …  
    629744size_t pci_bar_mask_to_size(uint32_t mask)
    630745{
    631         return ((mask & 0xfffffff0) ^ 0xffffffff) + 1;
     746        size_t size = mask & ~(mask - 1);
     747        return size;
    632748}
    633749

  • uspace/drv/bus/usb/ehci/ehci.h

    r4e36219 rc028b22  
    11/*
    2  * Copyright (c) 2009 Jiri Svoboda
     2 * Copyright (c) 2011 Vojtech Horky
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup mouse
    30  * @brief
     29/** @addtogroup drvusbehci
    3130 * @{
    3231 */
    3332/** @file
     33 * Common EHCI definitions.
    3434 */
     35#ifndef DRV_EHCI_EHCI_H
     36#define DRV_EHCI_EHCI_H
    3537
    36 #ifndef LIBC_IPC_MOUSE_H_
    37 #define LIBC_IPC_MOUSE_H_
     38#include <usbhc_iface.h>
    3839
    39 #include <ipc/common.h>
     40#define NAME "ehci"
    4041
    41 typedef enum {
    42         MEVENT_BUTTON = IPC_FIRST_USER_METHOD,
    43         MEVENT_MOVE
    44 } mouse_notif_t;
     42extern usbhc_iface_t ehci_hc_iface;
    4543
    4644#endif
    47 
    4845/**
    4946 * @}
    5047 */
     48

  • uspace/drv/bus/usb/uhci/uhci.h

    r4e36219 rc028b22  
    11/*
    2  * Copyright (c) 2009 Jiri Svoboda
     2 * Copyright (c) 2011 Jan Vesely
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup mouse
    30  * @brief
     29/** @addtogroup drvusbuhci
    3130 * @{
    3231 */
    3332/** @file
     33 * @brief UHCI driver main structure for both host controller and root-hub.
    3434 */
     35#ifndef DRV_UHCI_UHCI_H
     36#define DRV_UHCI_UHCI_H
     37#include <ddf/driver.h>
    3538
    36 #ifndef CHAR_MOUSE_H_
    37 #define CHAR_MOUSE_H_
    38 
    39 extern void mouse_handle_byte(int);
    40 extern void mouse_ev_btn(int button, int press);
    41 extern void mouse_ev_move(int dx, int dy);
    42 
     39int device_setup_uhci(ddf_dev_t *device);
    4340#endif
    44 
    4541/**
    4642 * @}

  • uspace/drv/bus/usb/usbhub/main.c

    r4e36219 rc028b22  
    11/*
    2  * Copyright (c) 2010 Jiri Svoboda
     2 * Copyright (c) 2010 Vojtech Horky
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup mouse
     29/** @addtogroup drvusbhub
    3030 * @{
    31  */
    32 /** @file
    33  * @brief
    3431 */
    3532
    36 #include <ipc/adb.h>
     33#include <ddf/driver.h>
     34#include <errno.h>
    3735#include <async.h>
    38 #include <vfs/vfs.h>
    39 #include <fcntl.h>
    40 #include <errno.h>
     36#include <stdio.h>
    4137
    42 #include "adb_mouse.h"
    43 #include "adb_dev.h"
     38#include <usb/dev/driver.h>
     39#include <usb/classes/classes.h>
    4440
    45 static void adb_dev_events(ipc_callid_t iid, ipc_call_t *icall);
     41#include "usbhub.h"
     42#include "usbhub_private.h"
    4643
    47 static int dev_phone;
     44/** Hub status-change endpoint description.
     45 *
     46 * For more information see section 11.15.1 of USB 1.1 specification.
     47 */
     48static usb_endpoint_description_t hub_status_change_endpoint_description = {
     49        .transfer_type = USB_TRANSFER_INTERRUPT,
     50        .direction = USB_DIRECTION_IN,
     51        .interface_class = USB_CLASS_HUB,
     52        .interface_subclass = 0,
     53        .interface_protocol = 0,
     54        .flags = 0
     55};
    4856
    49 int adb_dev_init(void)
     57/**
     58 * usb hub driver operations
     59 *
     60 * The most important one is add_device, which is set to usb_hub_add_device.
     61 */
     62static usb_driver_ops_t usb_hub_driver_ops = {
     63        .add_device = usb_hub_add_device
     64};
     65
     66/**
     67 * hub endpoints, excluding control endpoint
     68 */
     69static usb_endpoint_description_t *usb_hub_endpoints[] = {
     70        &hub_status_change_endpoint_description,
     71        NULL
     72};
     73
     74/**
     75 * static usb hub driver information
     76 */
     77static usb_driver_t usb_hub_driver = {
     78        .name = NAME,
     79        .ops = &usb_hub_driver_ops,
     80        .endpoints = usb_hub_endpoints
     81};
     82
     83
     84int main(int argc, char *argv[])
    5085{
    51         const char *input = "/dev/adb/mouse";
    52         int input_fd;
     86        printf(NAME ": HelenOS USB hub driver.\n");
    5387
    54         printf(NAME ": open %s\n", input);
     88        usb_log_enable(USB_LOG_LEVEL_DEFAULT, NAME);
    5589
    56         input_fd = open(input, O_RDONLY);
    57         if (input_fd < 0) {
    58                 printf(NAME ": Failed opening %s (%d)\n", input, input_fd);
    59                 return false;
    60         }
    61 
    62         dev_phone = fd_phone(input_fd);
    63         if (dev_phone < 0) {
    64                 printf(NAME ": Failed to connect to device\n");
    65                 return false;
    66         }
    67 
    68         /* NB: The callback connection is slotted for removal */
    69         if (async_connect_to_me(dev_phone, 0, 0, 0, adb_dev_events) != 0) {
    70                 printf(NAME ": Failed to create callback from device\n");
    71                 return false;
    72         }
    73        
    74         return 0;
    75 }
    76 
    77 static void adb_dev_events(ipc_callid_t iid, ipc_call_t *icall)
    78 {
    79         /* Ignore parameters, the connection is already opened */
    80         while (true) {
    81 
    82                 ipc_call_t call;
    83                 ipc_callid_t callid = async_get_call(&call);
    84 
    85                 int retval;
    86 
    87                 switch (IPC_GET_IMETHOD(call)) {
    88                 case IPC_M_PHONE_HUNGUP:
    89                         /* TODO: Handle hangup */
    90                         return;
    91                 case IPC_FIRST_USER_METHOD:
    92                         mouse_handle_data(IPC_GET_ARG1(call));
    93                         break;
    94                 default:
    95                         retval = ENOENT;
    96                 }
    97                 async_answer_0(callid, retval);
    98         }
     90        return usb_driver_main(&usb_hub_driver);
    9991}
    10092
    … …  
    10294 * @}
    10395 */
     96
Note: See TracChangeset for help on using the changeset viewer.