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/signal.h>
  18 #include <linux/delay.h>
  19 #include <linux/export.h>
  20
  21 #include "w1_internal.h"
  22
  23 DEFINE_SPINLOCK(w1_flock);
  24 static LIST_HEAD(w1_families);
  25
  26 /**
  27  * w1_register_family() - register a device family driver
  28  * @newf:       family to register
  29  */
  30 int 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 }
  57 EXPORT_SYMBOL(w1_register_family);
  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 EXPORT_SYMBOL(w1_unregister_family);
  91
  92 /*
  93  * Should be called under w1_flock held.
  94  */
  95 struct 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
 113 static void __w1_family_put(struct w1_family *f)
 114 {
 115         atomic_dec(&f->refcnt);
 116 }
 117
 118 void 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
 126 void 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
 134 void __w1_family_get(struct w1_family *f)
 135 {
 136         smp_mb__before_atomic();
 137         atomic_inc(&f->refcnt);
 138         smp_mb__after_atomic();
 139 }