drivers/w1/w1_family.c

   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.h>        /* schedule_timeout() */
  18 #include <linux/delay.h>
  19 #include <linux/export.h>
  20
  21 #include "w1_family.h"
  22 #include "w1.h"
  23
  24 DEFINE_SPINLOCK(w1_flock);
  25 static LIST_HEAD(w1_families);
  26
  27 /**
  28  * w1_register_family() - register a device family driver
  29  * @newf:       family to register
  30  */
  31 int w1_register_family(struct w1_family *newf)
  32 {
  33         struct list_head *ent, *n;
  34         struct w1_family *f;
  35         int ret = 0;
  36
  37         spin_lock(&w1_flock);
  38         list_for_each_safe(ent, n, &w1_families) {
  39                 f = list_entry(ent, struct w1_family, family_entry);
  40
  41                 if (f->fid == newf->fid) {
  42                         ret = -EEXIST;
  43                         break;
  44                 }
  45         }
  46
  47         if (!ret) {
  48                 atomic_set(&newf->refcnt, 0);
  49                 list_add_tail(&newf->family_entry, &w1_families);
  50         }
  51         spin_unlock(&w1_flock);
  52
  53         /* check default devices against the new set of drivers */
  54         w1_reconnect_slaves(newf, 1);
  55
  56         return ret;
  57 }
  58
  59 /**
  60  * w1_unregister_family() - unregister a device family driver
  61  * @fent:       family to unregister
  62  */
  63 void 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 }
  90
  91 /*
  92  * Should be called under w1_flock held.
  93  */
  94 struct w1_family * w1_family_registered(u8 fid)
  95 {
  96         struct list_head *ent, *n;
  97         struct w1_family *f = NULL;
  98         int ret = 0;
  99
 100         list_for_each_safe(ent, n, &w1_families) {
 101                 f = list_entry(ent, struct w1_family, family_entry);
 102
 103                 if (f->fid == fid) {
 104                         ret = 1;
 105                         break;
 106                 }
 107         }
 108
 109         return (ret) ? f : NULL;
 110 }
 111
 112 static void __w1_family_put(struct w1_family *f)
 113 {
 114         atomic_dec(&f->refcnt);
 115 }
 116
 117 void w1_family_put(struct w1_family *f)
 118 {
 119         spin_lock(&w1_flock);
 120         __w1_family_put(f);
 121         spin_unlock(&w1_flock);
 122 }
 123
 124 #if 0
 125 void w1_family_get(struct w1_family *f)
 126 {
 127         spin_lock(&w1_flock);
 128         __w1_family_get(f);
 129         spin_unlock(&w1_flock);
 130 }
 131 #endif  /*  0  */
 132
 133 void __w1_family_get(struct w1_family *f)
 134 {
 135         smp_mb__before_atomic();
 136         atomic_inc(&f->refcnt);
 137         smp_mb__after_atomic();
 138 }
 139
 140 EXPORT_SYMBOL(w1_unregister_family);
 141 EXPORT_SYMBOL(w1_register_family);