Changeset a1b7e80 in mainline for uspace/drv


Ignore:
Timestamp:
2011-09-02T16:54:18Z (15 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/fix-logger-deadlock, topic/msim-upgrade, topic/simplify-dev-export
Children:
f480d7e
Parents:
7a72ce1a (diff), 224c0e7 (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 basic infrastructure for anticipated device removal from
lp:~jsvoboda/helenos/devrem

Location:
uspace/drv
Files:
14 edited

Legend:

Unmodified
Added
Removed

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

    r7a72ce1a ra1b7e80  
    215215};
    216216
    217 static pci_bus_t *pci_bus_new(void)
    218 {
    219         pci_bus_t *bus;
    220        
    221         bus = (pci_bus_t *) calloc(1, sizeof(pci_bus_t));
    222         if (bus == NULL)
    223                 return NULL;
    224        
    225         fibril_mutex_initialize(&bus->conf_mutex);
    226         return bus;
    227 }
    228 
    229 static void pci_bus_delete(pci_bus_t *bus)
    230 {
    231         assert(bus != NULL);
    232         free(bus);
    233 }
    234 
    235217static void pci_conf_read(pci_fun_t *fun, int reg, uint8_t *buf, size_t len)
    236218{
    … …  
    584566        dnode->parent_sess = NULL;
    585567       
    586         bus = pci_bus_new();
     568        bus = ddf_dev_data_alloc(dnode, sizeof(pci_bus_t));
    587569        if (bus == NULL) {
    588570                ddf_msg(LVL_ERROR, "pci_add_device allocation failed.");
    … …  
    590572                goto fail;
    591573        }
     574        fibril_mutex_initialize(&bus->conf_mutex);
     575
    592576        bus->dnode = dnode;
    593577        dnode->driver_data = bus;
    … …  
    655639       
    656640fail:
    657         if (bus != NULL)
    658                 pci_bus_delete(bus);
    659        
    660641        if (dnode->parent_sess)
    661642                async_hangup(dnode->parent_sess);

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

    r7a72ce1a ra1b7e80  
    192192                ddf_fun_destroy(instance->rh_fun); \
    193193        } \
    194         free(instance); \
    195194        device->driver_data = NULL; \
    196195        usb_log_error(message); \

  • uspace/drv/bus/usb/usbhid/kbd/kbddev.c

    r7a72ce1a ra1b7e80  
    734734        int rc = usb_kbd_create_function(hid_dev, kbd_dev);
    735735        if (rc != EOK) {
    736                 usb_kbd_free(&kbd_dev);
     736                usb_kbd_destroy(kbd_dev);
    737737                return rc;
    738738        }
    … …  
    779779 * @param kbd_dev Pointer to the structure to be destroyed.
    780780 */
    781 void usb_kbd_free(usb_kbd_t **kbd_dev)
    782 {
    783         if (kbd_dev == NULL || *kbd_dev == NULL) {
     781void usb_kbd_destroy(usb_kbd_t *kbd_dev)
     782{
     783        if (kbd_dev == NULL) {
    784784                return;
    785785        }
    786786       
    787787        // hangup phone to the console
    788         async_obsolete_hangup((*kbd_dev)->console_phone);
    789        
    790         if ((*kbd_dev)->repeat_mtx != NULL) {
     788        async_obsolete_hangup(kbd_dev->console_phone);
     789       
     790        if (kbd_dev->repeat_mtx != NULL) {
    791791                //assert(!fibril_mutex_is_locked((*kbd_dev)->repeat_mtx));
    792792                // FIXME - the fibril_mutex_is_locked may not cause
    793793                // fibril scheduling
    794                 while (fibril_mutex_is_locked((*kbd_dev)->repeat_mtx)) {}
    795                 free((*kbd_dev)->repeat_mtx);
     794                while (fibril_mutex_is_locked(kbd_dev->repeat_mtx)) {}
     795                free(kbd_dev->repeat_mtx);
    796796        }
    797797       
    798798        // free all buffers
    799         if ((*kbd_dev)->keys != NULL) {
    800                 free((*kbd_dev)->keys);
    801         }
    802         if ((*kbd_dev)->keys_old != NULL) {
    803                 free((*kbd_dev)->keys_old);
    804         }
    805         if ((*kbd_dev)->led_data != NULL) {
    806                 free((*kbd_dev)->led_data);
    807         }
    808         if ((*kbd_dev)->led_path != NULL) {
    809                 usb_hid_report_path_free((*kbd_dev)->led_path);
    810         }
    811         if ((*kbd_dev)->output_buffer != NULL) {
    812                 usb_hid_report_output_free((*kbd_dev)->output_buffer);
    813         }
    814 
    815         free(*kbd_dev);
    816         *kbd_dev = NULL;
     799        if (kbd_dev->keys != NULL) {
     800                free(kbd_dev->keys);
     801        }
     802        if (kbd_dev->keys_old != NULL) {
     803                free(kbd_dev->keys_old);
     804        }
     805        if (kbd_dev->led_data != NULL) {
     806                free(kbd_dev->led_data);
     807        }
     808        if (kbd_dev->led_path != NULL) {
     809                usb_hid_report_path_free(kbd_dev->led_path);
     810        }
     811        if (kbd_dev->output_buffer != NULL) {
     812                usb_hid_report_output_free(kbd_dev->output_buffer);
     813        }
    817814}
    818815
    … …  
    830827                        usb_kbd_mark_unusable(kbd_dev);
    831828                } else {
    832                         usb_kbd_free(&kbd_dev);
     829                        usb_kbd_destroy(kbd_dev);
    833830                }
    834831        }

  • uspace/drv/bus/usb/usbhid/kbd/kbddev.h

    r7a72ce1a ra1b7e80  
    131131int usb_kbd_is_ready_to_destroy(const usb_kbd_t *kbd_dev);
    132132
    133 void usb_kbd_free(usb_kbd_t **kbd_dev);
     133void usb_kbd_destroy(usb_kbd_t *kbd_dev);
    134134
    135135void usb_kbd_push_ev(struct usb_hid_dev *hid_dev, usb_kbd_t *kbd_dev,

  • uspace/drv/bus/usb/usbhid/kbd/kbdrepeat.c

    r7a72ce1a ra1b7e80  
    8080                if (!usb_kbd_is_initialized(kbd)) {
    8181                        if (usb_kbd_is_ready_to_destroy(kbd)) {
    82                                 usb_kbd_free(&kbd);
    83                                 assert(kbd == NULL);
     82                                usb_kbd_destroy(kbd);
    8483                        }
    8584                        return;

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

    r7a72ce1a ra1b7e80  
    9393        if (rc != EOK) {
    9494                usb_log_error("Failed to initialize USB/HID device.\n");
    95                 usb_hid_free(&hid_dev);
     95                usb_hid_destroy(hid_dev);
    9696                return rc;
    9797        }       

  • uspace/drv/bus/usb/usbhid/mouse/mousedev.c

    r7a72ce1a ra1b7e80  
    183183/*----------------------------------------------------------------------------*/
    184184
    185 static void usb_mouse_free(usb_mouse_t **mouse_dev)
    186 {
    187         assert(mouse_dev != NULL && *mouse_dev != NULL);
     185static void usb_mouse_destroy(usb_mouse_t *mouse_dev)
     186{
     187        assert(mouse_dev != NULL);
    188188       
    189189        // hangup phone to the console
    190         if ((*mouse_dev)->mouse_phone >= 0) {
    191                 async_obsolete_hangup((*mouse_dev)->mouse_phone);
    192         }
    193        
    194         if ((*mouse_dev)->wheel_phone >= 0) {
    195                 async_obsolete_hangup((*mouse_dev)->wheel_phone);
    196         }
    197        
    198         free(*mouse_dev);
    199         *mouse_dev = NULL;
     190        if (mouse_dev->mouse_phone >= 0) {
     191                async_obsolete_hangup(mouse_dev->mouse_phone);
     192        }
     193       
     194        if (mouse_dev->wheel_phone >= 0) {
     195                async_obsolete_hangup(mouse_dev->wheel_phone);
     196        }
    200197}
    201198
    … …  
    437434        int rc = usb_mouse_create_function(hid_dev, mouse_dev);
    438435        if (rc != EOK) {
    439                 usb_mouse_free(&mouse_dev);
     436                usb_mouse_destroy(mouse_dev);
    440437                return rc;
    441438        }
    … …  
    464461{
    465462        if (data != NULL) {
    466                 usb_mouse_free((usb_mouse_t **)&data);
     463                usb_mouse_destroy((usb_mouse_t *)data);
    467464        }
    468465}

  • uspace/drv/bus/usb/usbhid/multimedia/multimedia.c

    r7a72ce1a ra1b7e80  
    167167/*----------------------------------------------------------------------------*/
    168168
    169 static void usb_multimedia_free(usb_multimedia_t **multim_dev)
    170 {
    171         if (multim_dev == NULL || *multim_dev == NULL) {
    172                 return;
    173         }
    174        
    175         // hangup phone to the console
    176         async_obsolete_hangup((*multim_dev)->console_phone);
    177 
    178         free(*multim_dev);
    179         *multim_dev = NULL;
    180 }
    181 
    182 /*----------------------------------------------------------------------------*/
    183 
    184169static int usb_multimedia_create_function(usb_hid_dev_t *hid_dev,
    185170    usb_multimedia_t *multim_dev)
    … …  
    247232       
    248233        int rc = usb_multimedia_create_function(hid_dev, multim_dev);
    249         if (rc != EOK) {
    250                 usb_multimedia_free(&multim_dev);
     234        if (rc != EOK)
    251235                return rc;
    252         }
    253236       
    254237        usb_log_debug(NAME " HID/multimedia structure initialized.\n");
    … …  
    267250        if (data != NULL) {
    268251                usb_multimedia_t *multim_dev = (usb_multimedia_t *)data;
    269                 usb_multimedia_free(&multim_dev);
     252                // hangup phone to the console
     253                async_obsolete_hangup(multim_dev->console_phone);
    270254        }
    271255}

  • uspace/drv/bus/usb/usbhid/usbhid.c

    r7a72ce1a ra1b7e80  
    627627        }
    628628       
    629         usb_hid_free(&hid_dev);
     629        usb_hid_destroy(hid_dev);
    630630}
    631631
    … …  
    646646/*----------------------------------------------------------------------------*/
    647647
    648 void usb_hid_free(usb_hid_dev_t **hid_dev)
     648void usb_hid_destroy(usb_hid_dev_t *hid_dev)
    649649{
    650650        int i;
    651651       
    652         if (hid_dev == NULL || *hid_dev == NULL) {
     652        if (hid_dev == NULL) {
    653653                return;
    654654        }
    655655       
    656656        usb_log_debug("Subdrivers: %p, subdriver count: %d\n",
    657             (*hid_dev)->subdrivers, (*hid_dev)->subdriver_count);
    658        
    659         assert((*hid_dev)->subdrivers != NULL
    660             || (*hid_dev)->subdriver_count == 0);
    661        
    662         for (i = 0; i < (*hid_dev)->subdriver_count; ++i) {
    663                 if ((*hid_dev)->subdrivers[i].deinit != NULL) {
    664                         (*hid_dev)->subdrivers[i].deinit(*hid_dev,
    665                             (*hid_dev)->subdrivers[i].data);
     657            hid_dev->subdrivers, hid_dev->subdriver_count);
     658       
     659        assert(hid_dev->subdrivers != NULL
     660            || hid_dev->subdriver_count == 0);
     661       
     662        for (i = 0; i < hid_dev->subdriver_count; ++i) {
     663                if (hid_dev->subdrivers[i].deinit != NULL) {
     664                        hid_dev->subdrivers[i].deinit(hid_dev,
     665                            hid_dev->subdrivers[i].data);
    666666                }
    667667        }
    668668       
    669669        // free the subdrivers info
    670         if ((*hid_dev)->subdrivers != NULL) {
    671                 free((*hid_dev)->subdrivers);
     670        if (hid_dev->subdrivers != NULL) {
     671                free(hid_dev->subdrivers);
    672672        }
    673673
    674674        // destroy the parser
    675         if ((*hid_dev)->report != NULL) {
    676                 usb_hid_free_report((*hid_dev)->report);
    677         }
    678 
    679         if ((*hid_dev)->report_desc != NULL) {
    680                 free((*hid_dev)->report_desc);
    681         }
    682 
    683         free(*hid_dev);
    684         *hid_dev = NULL;
     675        if (hid_dev->report != NULL) {
     676                usb_hid_free_report(hid_dev->report);
     677        }
     678
     679        if (hid_dev->report_desc != NULL) {
     680                free(hid_dev->report_desc);
     681        }
    685682}
    686683

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

    r7a72ce1a ra1b7e80  
    158158int usb_hid_report_number(usb_hid_dev_t *hid_dev);
    159159
    160 void usb_hid_free(usb_hid_dev_t **hid_dev);
     160void usb_hid_destroy(usb_hid_dev_t *hid_dev);
    161161
    162162#endif /* USB_HID_USBHID_H_ */

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

    r7a72ce1a ra1b7e80  
    145145        usbmast_fun_t *mfun = NULL;
    146146
    147         /* Allocate softstate */
    148         mfun = calloc(1, sizeof(usbmast_fun_t));
    149         if (mfun == NULL) {
    150                 usb_log_error("Failed allocating softstate.\n");
    151                 rc = ENOMEM;
    152                 goto error;
    153         }
    154 
    155         mfun->mdev = mdev;
    156         mfun->lun = lun;
    157 
    158147        if (asprintf(&fun_name, "l%u", lun) < 0) {
    159148                usb_log_error("Out of memory.\n");
    … …  
    170159
    171160        free(fun_name);
     161
     162        /* Allocate soft state */
     163        mfun = ddf_dev_data_alloc(mdev->ddf_dev, sizeof(usbmast_fun_t));
     164        if (mfun == NULL) {
     165                usb_log_error("Failed allocating softstate.\n");
     166                rc = ENOMEM;
     167                goto error;
     168        }
     169
     170        mfun->mdev = mdev;
     171        mfun->lun = lun;
     172
    172173        fun_name = NULL;
    173174
    … …  
    227228        if (fun_name != NULL)
    228229                free(fun_name);
    229         if (mfun != NULL)
    230                 free(mfun);
    231230        return rc;
    232231}

  • uspace/drv/char/ns8250/ns8250.c

    r7a72ce1a ra1b7e80  
    112112        fibril_mutex_t mutex;
    113113} ns8250_t;
    114 
    115 /** Create per-device soft-state structure.
    116  *
    117  * @return      Pointer to soft-state structure.
    118  */
    119 static ns8250_t *ns8250_new(void)
    120 {
    121         ns8250_t *ns;
    122        
    123         ns = (ns8250_t *) calloc(1, sizeof(ns8250_t));
    124         if (ns == NULL)
    125                 return NULL;
    126        
    127         fibril_mutex_initialize(&ns->mutex);
    128         return ns;
    129 }
    130 
    131 /** Delete soft-state structure.
    132  *
    133  * @param ns    The driver data structure.
    134  */
    135 static void ns8250_delete(ns8250_t *ns)
    136 {
    137         assert(ns != NULL);
    138         free(ns);
    139 }
    140114
    141115/** Find out if there is some incomming data available on the serial port.
    … …  
    721695       
    722696        /* Allocate soft-state for the device */
    723         ns = ns8250_new();
     697        ns = ddf_dev_data_alloc(dev, sizeof(ns8250_t));
    724698        if (ns == NULL) {
    725699                rc = ENOMEM;
    … …  
    727701        }
    728702       
     703        fibril_mutex_initialize(&ns->mutex);
    729704        ns->dev = dev;
    730         dev->driver_data = ns;
    731705       
    732706        rc = ns8250_dev_initialize(ns);
    … …  
    792766        if (need_cleanup)
    793767                ns8250_dev_cleanup(ns);
    794         if (ns != NULL)
    795                 ns8250_delete(ns);
    796768        return rc;
    797769}

  • uspace/drv/infrastructure/rootvirt/rootvirt.c

    r7a72ce1a ra1b7e80  
    6363
    6464static int rootvirt_add_device(ddf_dev_t *dev);
     65static int rootvirt_fun_online(ddf_fun_t *fun);
     66static int rootvirt_fun_offline(ddf_fun_t *fun);
    6567
    6668static driver_ops_t rootvirt_ops = {
    67         .add_device = &rootvirt_add_device
     69        .add_device = &rootvirt_add_device,
     70        .fun_online = &rootvirt_fun_online,
     71        .fun_offline = &rootvirt_fun_offline
    6872};
    6973
    … …  
    140144}
    141145
     146static int rootvirt_fun_online(ddf_fun_t *fun)
     147{
     148        ddf_msg(LVL_DEBUG, "rootvirt_fun_online()");
     149        return ddf_fun_online(fun);
     150}
     151
     152static int rootvirt_fun_offline(ddf_fun_t *fun)
     153{
     154        ddf_msg(LVL_DEBUG, "rootvirt_fun_offline()");
     155        return ddf_fun_offline(fun);
     156}
     157
    142158int main(int argc, char *argv[])
    143159{

  • uspace/drv/test/test1/test1.c

    r7a72ce1a ra1b7e80  
    11/*
    22 * Copyright (c) 2010 Vojtech Horky
     3 * Copyright (c) 2011 Jiri Svoboda
    34 * All rights reserved.
    45 *
    … …  
    4041
    4142static int test1_add_device(ddf_dev_t *dev);
     43static int test1_dev_remove(ddf_dev_t *dev);
     44static int test1_fun_online(ddf_fun_t *fun);
     45static int test1_fun_offline(ddf_fun_t *fun);
    4246
    4347static driver_ops_t driver_ops = {
    44         .add_device = &test1_add_device
     48        .add_device = &test1_add_device,
     49        .dev_remove = &test1_dev_remove,
     50        .fun_online = &test1_fun_online,
     51        .fun_offline = &test1_fun_offline
    4552};
    4653
    … …  
    4956        .driver_ops = &driver_ops
    5057};
     58
     59typedef struct {
     60        ddf_fun_t *fun_a;
     61        ddf_fun_t *clone;
     62        ddf_fun_t *child;
     63} test1_t;
    5164
    5265/** Register child and inform user about it.
    … …  
    6073static int register_fun_verbose(ddf_dev_t *parent, const char *message,
    6174    const char *name, const char *match_id, int match_score,
    62     int expected_rc)
     75    int expected_rc, ddf_fun_t **pfun)
    6376{
    6477        ddf_fun_t *fun = NULL;
    … …  
    103116        }
    104117
     118        if (pfun != NULL)
     119                *pfun = fun;
     120
    105121        return rc;
    106122}
    … …  
    126142{
    127143        ddf_fun_t *fun_a;
     144        test1_t *test1;
    128145        int rc;
    129146
    130147        ddf_msg(LVL_DEBUG, "add_device(name=\"%s\", handle=%d)",
    131148            dev->name, (int) dev->handle);
     149
     150        test1 = ddf_dev_data_alloc(dev, sizeof(test1_t));
     151        if (test1 == NULL) {
     152                ddf_msg(LVL_ERROR, "Failed allocating soft state.\n");
     153                return ENOMEM;
     154        }
    132155
    133156        fun_a = ddf_fun_create(dev, fun_exposed, "a");
    … …  
    137160        }
    138161
     162        test1->fun_a = fun_a;
     163
    139164        rc = ddf_fun_bind(fun_a);
    140165        if (rc != EOK) {
    141166                ddf_msg(LVL_ERROR, "Failed binding function 'a'.");
     167                ddf_fun_destroy(fun_a);
    142168                return rc;
    143169        }
    … …  
    151177                (void) register_fun_verbose(dev,
    152178                    "cloning myself ;-)", "clone",
    153                     "virtual&test1", 10, EOK);
     179                    "virtual&test1", 10, EOK, &test1->clone);
    154180                (void) register_fun_verbose(dev,
    155181                    "cloning myself twice ;-)", "clone",
    156                     "virtual&test1", 10, EEXISTS);
     182                    "virtual&test1", 10, EEXISTS, NULL);
    157183        } else if (str_cmp(dev->name, "clone") == 0) {
    158184                (void) register_fun_verbose(dev,
    159185                    "run by the same task", "child",
    160                     "virtual&test1&child", 10, EOK);
     186                    "virtual&test1&child", 10, EOK, &test1->child);
    161187        }
    162188
    … …  
    164190
    165191        return EOK;
     192}
     193
     194static int fun_remove(ddf_fun_t *fun, const char *name)
     195{
     196        int rc;
     197
     198        ddf_msg(LVL_DEBUG, "fun_remove(%p, '%s')\n", fun, name);
     199        rc = ddf_fun_offline(fun);
     200        if (rc != EOK) {
     201                ddf_msg(LVL_ERROR, "Error offlining function '%s'.", name);
     202                return rc;
     203        }
     204
     205        rc = ddf_fun_unbind(fun);
     206        if (rc != EOK) {
     207                ddf_msg(LVL_ERROR, "Failed offlining function '%s'.", name);
     208                return rc;
     209        }
     210
     211        ddf_fun_destroy(fun);
     212        return EOK;
     213}
     214
     215static int test1_dev_remove(ddf_dev_t *dev)
     216{
     217        test1_t *test1 = (test1_t *)dev->driver_data;
     218        int rc;
     219
     220        ddf_msg(LVL_DEBUG, "test1_dev_remove(%p)", dev);
     221
     222        if (test1->fun_a != NULL) {
     223                rc = fun_remove(test1->fun_a, "a");
     224                if (rc != EOK)
     225                        return rc;
     226        }
     227
     228        if (test1->clone != NULL) {
     229                rc = fun_remove(test1->clone, "clone");
     230                if (rc != EOK)
     231                        return rc;
     232        }
     233
     234        if (test1->child != NULL) {
     235                rc = fun_remove(test1->child, "child");
     236                if (rc != EOK)
     237                        return rc;
     238        }
     239
     240        return EOK;
     241}
     242
     243static int test1_fun_online(ddf_fun_t *fun)
     244{
     245        ddf_msg(LVL_DEBUG, "test1_fun_online()");
     246        return ddf_fun_online(fun);
     247}
     248
     249static int test1_fun_offline(ddf_fun_t *fun)
     250{
     251        ddf_msg(LVL_DEBUG, "test1_fun_offline()");
     252        return ddf_fun_offline(fun);
    166253}
    167254
Note: See TracChangeset for help on using the changeset viewer.