LXR linux/drivers/w1/w1

   1/*
   2 * Copyright (c) 2004 Evgeniy Polyakov <zbr@ioremap.net>
   3 *
   4 * This program is free software; you can redistribute it and/or modify
   5 * it under the terms of the GNU General Public License as published by
   6 * the Free Software Foundation; either version 2 of the License, or
   7 * (at your option) any later version.
   8 *
   9 * This program is distributed in the hope that it will be useful,
  10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 * GNU General Public License for more details.
  13 */
  14
  15#include <linux/spinlock.h>
  16#include <linux/list.h>
  17#include <linux/sched/signal.h>
  18#include <linux/delay.h>
  19#include <linux/export.h>
  20
  21#include "w1_internal.h"
  22
  23DEFINE_SPINLOCK(w1_flock);
  24static LIST_HEAD(w1_families);
  25
  26/**
  27 * w1_register_family() - register a device family driver
  28 * @newf:       family to register
  29 */
  30int w1_register_family(struct w1_family *newf)
  31{
  32        struct list_head *ent, *n;
  33        struct w1_family *f;
  34        int ret = 0;
  35
  36        spin_lock(&w1_flock);
  37        list_for_each_safe(ent, n, &w1_families) {
  38                f = list_entry(ent, struct w1_family, family_entry);
  39
  40                if (f->fid == newf->fid) {
  41                        ret = -EEXIST;
  42                        break;
  43                }
  44        }
  45
  46        if (!ret) {
  47                atomic_set(&newf->refcnt, 0);
  48                list_add_tail(&newf->family_entry, &w1_families);
  49        }
  50        spin_unlock(&w1_flock);
  51
  52        /* check default devices against the new set of drivers */
  53        w1_reconnect_slaves(newf, 1);
  54
  55        return ret;
  56}
  57EXPORT_SYMBOL(w1_register_family);
  58
  59/**
  60 * w1_unregister_family() - unregister a device family driver
  61 * @fent:       family to unregister
  62 */
  63void w1_unregister_family(struct w1_family *fent)
  64{
  65        struct list_head *ent, *n;
  66        struct w1_family *f;
  67
  68        spin_lock(&w1_flock);
  69        list_for_each_safe(ent, n, &w1_families) {
  70                f = list_entry(ent, struct w1_family, family_entry);
  71
  72                if (f->fid == fent->fid) {
  73                        list_del(&fent->family_entry);
  74                        break;
  75                }
  76        }
  77        spin_unlock(&w1_flock);
  78
  79        /* deatch devices using this family code */
  80        w1_reconnect_slaves(fent, 0);
  81
  82        while (atomic_read(&fent->refcnt)) {
  83                pr_info("Waiting for family %u to become free: refcnt=%d.\n",
  84                                fent->fid, atomic_read(&fent->refcnt));
  85
  86                if (msleep_interruptible(1000))
  87                        flush_signals(current);
  88        }
  89}
  90EXPORT_SYMBOL(w1_unregister_family);
  91
  92/*
  93 * Should be called under w1_flock held.
  94 */
  95struct w1_family * w1_family_registered(u8 fid)
  96{
  97        struct list_head *ent, *n;
  98        struct w1_family *f = NULL;
  99        int ret = 0;
 100
 101        list_for_each_safe(ent, n, &w1_families) {
 102                f = list_entry(ent, struct w1_family, family_entry);
 103
 104                if (f->fid == fid) {
 105                        ret = 1;
 106                        break;
 107                }
 108        }
 109
 110        return (ret) ? f : NULL;
 111}
 112
 113static void __w1_family_put(struct w1_family *f)
 114{
 115        atomic_dec(&f->refcnt);
 116}
 117
 118void w1_family_put(struct w1_family *f)
 119{
 120        spin_lock(&w1_flock);
 121        __w1_family_put(f);
 122        spin_unlock(&w1_flock);
 123}
 124
 125#if 0
 126void w1_family_get(struct w1_family *f)
 127{
 128        spin_lock(&w1_flock);
 129        __w1_family_get(f);
 130        spin_unlock(&w1_flock);
 131}
 132#endif  /*  0  */
 133
 134void __w1_family_get(struct w1_family *f)
 135{
 136        smp_mb__before_atomic();
 137        atomic_inc(&f->refcnt);
 138        smp_mb__after_atomic();
 139}
 140