drivers/w1/w1_int.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Copyright (c) 2004 Evgeniy Polyakov <[email protected]>
   4  */
   5
   6 #include <linux/kernel.h>
   7 #include <linux/list.h>
   8 #include <linux/delay.h>
   9 #include <linux/kthread.h>
  10 #include <linux/slab.h>
  11 #include <linux/sched/signal.h>
  12 #include <linux/export.h>
  13 #include <linux/moduleparam.h>
  14
  15 #include "w1_internal.h"
  16 #include "w1_netlink.h"
  17
  18 static int w1_search_count = -1; /* Default is continual scan */
  19 module_param_named(search_count, w1_search_count, int, 0);
  20
  21 static int w1_enable_pullup = 1;
  22 module_param_named(enable_pullup, w1_enable_pullup, int, 0);
  23
  24 static struct w1_master *w1_alloc_dev(u32 id, int slave_count, int slave_ttl,
  25                                        struct device_driver *driver,
  26                                        struct device *device)
  27 {
  28         struct w1_master *dev;
  29         int err;
  30
  31         /*
  32          * We are in process context(kernel thread), so can sleep.
  33          */
  34         dev = kzalloc(sizeof(struct w1_master) + sizeof(struct w1_bus_master), GFP_KERNEL);
  35         if (!dev)
  36                 return NULL;
  37
  38         dev->bus_master = (struct w1_bus_master *)(dev + 1);
  39
  40         dev->owner              = THIS_MODULE;
  41         dev->max_slave_count    = slave_count;
  42         dev->slave_count        = 0;
  43         dev->attempts           = 0;
  44         dev->initialized        = 0;
  45         dev->id                 = id;
  46         dev->slave_ttl          = slave_ttl;
  47         dev->search_count       = w1_search_count;
  48         dev->enable_pullup      = w1_enable_pullup;
  49
  50         /* For __w1_remove_master_device to decrement
  51          */
  52         atomic_set(&dev->refcnt, 1);
  53
  54         INIT_LIST_HEAD(&dev->slist);
  55         INIT_LIST_HEAD(&dev->async_list);
  56         mutex_init(&dev->mutex);
  57         mutex_init(&dev->bus_mutex);
  58         mutex_init(&dev->list_mutex);
  59
  60         memcpy(&dev->dev, device, sizeof(struct device));
  61         dev_set_name(&dev->dev, "w1_bus_master%u", dev->id);
  62         snprintf(dev->name, sizeof(dev->name), "w1_bus_master%u", dev->id);
  63         dev->dev.init_name = dev->name;
  64
  65         dev->driver = driver;
  66
  67         dev->seq = 1;
  68
  69         err = device_register(&dev->dev);
  70         if (err) {
  71                 pr_err("Failed to register master device. err=%d\n", err);
  72                 put_device(&dev->dev);
  73                 dev = NULL;
  74         }
  75
  76         return dev;
  77 }
  78
  79 static void w1_free_dev(struct w1_master *dev)
  80 {
  81         device_unregister(&dev->dev);
  82 }
  83
  84 /**
  85  * w1_add_master_device() - registers a new master device
  86  * @master:     master bus device to register
  87  */
  88 int w1_add_master_device(struct w1_bus_master *master)
  89 {
  90         struct w1_master *dev, *entry;
  91         int retval = 0;
  92         struct w1_netlink_msg msg;
  93         int id, found;
  94
  95         /* validate minimum functionality */
  96         if (!(master->touch_bit && master->reset_bus) &&
  97             !(master->write_bit && master->read_bit) &&
  98             !(master->write_byte && master->read_byte && master->reset_bus)) {
  99                 pr_err("w1_add_master_device: invalid function set\n");
 100                 return(-EINVAL);
 101         }
 102
 103         /* Lock until the device is added (or not) to w1_masters. */
 104         mutex_lock(&w1_mlock);
 105         /* Search for the first available id (starting at 1). */
 106         id = 0;
 107         do {
 108                 ++id;
 109                 found = 0;
 110                 list_for_each_entry(entry, &w1_masters, w1_master_entry) {
 111                         if (entry->id == id) {
 112                                 found = 1;
 113                                 break;
 114                         }
 115                 }
 116         } while (found);
 117
 118         dev = w1_alloc_dev(id, w1_max_slave_count, w1_max_slave_ttl,
 119                 &w1_master_driver, &w1_master_device);
 120         if (!dev) {
 121                 mutex_unlock(&w1_mlock);
 122                 return -ENOMEM;
 123         }
 124
 125         retval =  w1_create_master_attributes(dev);
 126         if (retval) {
 127                 mutex_unlock(&w1_mlock);
 128                 goto err_out_free_dev;
 129         }
 130
 131         memcpy(dev->bus_master, master, sizeof(struct w1_bus_master));
 132
 133         dev->initialized = 1;
 134
 135         dev->thread = kthread_run(&w1_process, dev, "%s", dev->name);
 136         if (IS_ERR(dev->thread)) {
 137                 retval = PTR_ERR(dev->thread);
 138                 dev_err(&dev->dev,
 139                          "Failed to create new kernel thread. err=%d\n",
 140                          retval);
 141                 mutex_unlock(&w1_mlock);
 142                 goto err_out_rm_attr;
 143         }
 144
 145         list_add(&dev->w1_master_entry, &w1_masters);
 146         mutex_unlock(&w1_mlock);
 147
 148         memset(&msg, 0, sizeof(msg));
 149         msg.id.mst.id = dev->id;
 150         msg.type = W1_MASTER_ADD;
 151         w1_netlink_send(dev, &msg);
 152
 153         return 0;
 154
 155 #if 0 /* Thread cleanup code, not required currently. */
 156 err_out_kill_thread:
 157         set_bit(W1_ABORT_SEARCH, &dev->flags);
 158         kthread_stop(dev->thread);
 159 #endif
 160 err_out_rm_attr:
 161         w1_destroy_master_attributes(dev);
 162 err_out_free_dev:
 163         w1_free_dev(dev);
 164
 165         return retval;
 166 }
 167 EXPORT_SYMBOL(w1_add_master_device);
 168
 169 void __w1_remove_master_device(struct w1_master *dev)
 170 {
 171         struct w1_netlink_msg msg;
 172         struct w1_slave *sl, *sln;
 173
 174         mutex_lock(&w1_mlock);
 175         list_del(&dev->w1_master_entry);
 176         mutex_unlock(&w1_mlock);
 177
 178         set_bit(W1_ABORT_SEARCH, &dev->flags);
 179         kthread_stop(dev->thread);
 180
 181         mutex_lock(&dev->mutex);
 182         mutex_lock(&dev->list_mutex);
 183         list_for_each_entry_safe(sl, sln, &dev->slist, w1_slave_entry) {
 184                 mutex_unlock(&dev->list_mutex);
 185                 w1_slave_detach(sl);
 186                 mutex_lock(&dev->list_mutex);
 187         }
 188         w1_destroy_master_attributes(dev);
 189         mutex_unlock(&dev->list_mutex);
 190         mutex_unlock(&dev->mutex);
 191         atomic_dec(&dev->refcnt);
 192
 193         while (atomic_read(&dev->refcnt)) {
 194                 dev_info(&dev->dev, "Waiting for %s to become free: refcnt=%d.\n",
 195                                 dev->name, atomic_read(&dev->refcnt));
 196
 197                 if (msleep_interruptible(1000))
 198                         flush_signals(current);
 199                 mutex_lock(&dev->list_mutex);
 200                 w1_process_callbacks(dev);
 201                 mutex_unlock(&dev->list_mutex);
 202         }
 203         mutex_lock(&dev->list_mutex);
 204         w1_process_callbacks(dev);
 205         mutex_unlock(&dev->list_mutex);
 206
 207         memset(&msg, 0, sizeof(msg));
 208         msg.id.mst.id = dev->id;
 209         msg.type = W1_MASTER_REMOVE;
 210         w1_netlink_send(dev, &msg);
 211
 212         w1_free_dev(dev);
 213 }
 214
 215 /**
 216  * w1_remove_master_device() - unregister a master device
 217  * @bm: master bus device to remove
 218  */
 219 void w1_remove_master_device(struct w1_bus_master *bm)
 220 {
 221         struct w1_master *dev, *found = NULL;
 222
 223         list_for_each_entry(dev, &w1_masters, w1_master_entry) {
 224                 if (!dev->initialized)
 225                         continue;
 226
 227                 if (dev->bus_master->data == bm->data) {
 228                         found = dev;
 229                         break;
 230                 }
 231         }
 232
 233         if (!found) {
 234                 pr_err("Device doesn't exist.\n");
 235                 return;
 236         }
 237
 238         __w1_remove_master_device(found);
 239 }
 240 EXPORT_SYMBOL(w1_remove_master_device);