blob: fc82743aefb6574f6a1e47ecd68e1d0b1557507f [file] [log] [blame]
Dan Williams45def222015-04-26 19:26:48 -04001/*
2 * Copyright(c) 2013-2015 Intel Corporation. All rights reserved.
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of version 2 of the GNU General Public License as
6 * published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope that it will be useful, but
9 * WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 * General Public License for more details.
12 */
13#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
Dan Williams62232e452015-06-08 14:27:06 -040014#include <linux/vmalloc.h>
Dan Williams45def222015-04-26 19:26:48 -040015#include <linux/uaccess.h>
Dan Williams3d880022015-05-31 15:02:11 -040016#include <linux/module.h>
Dan Williams8c2f7e82015-06-25 04:20:04 -040017#include <linux/blkdev.h>
Dan Williams45def222015-04-26 19:26:48 -040018#include <linux/fcntl.h>
Dan Williamse6dfb2d2015-04-25 03:56:17 -040019#include <linux/async.h>
Dan Williams8c2f7e82015-06-25 04:20:04 -040020#include <linux/genhd.h>
Dan Williams62232e452015-06-08 14:27:06 -040021#include <linux/ndctl.h>
Dan Williams4d88a972015-05-31 14:41:48 -040022#include <linux/sched.h>
Dan Williams45def222015-04-26 19:26:48 -040023#include <linux/slab.h>
24#include <linux/fs.h>
25#include <linux/io.h>
Dan Williams62232e452015-06-08 14:27:06 -040026#include <linux/mm.h>
Dan Williams4d88a972015-05-31 14:41:48 -040027#include <linux/nd.h>
Dan Williams45def222015-04-26 19:26:48 -040028#include "nd-core.h"
Dan Williams4d88a972015-05-31 14:41:48 -040029#include "nd.h"
Dan Williams45def222015-04-26 19:26:48 -040030
Dan Williams62232e452015-06-08 14:27:06 -040031int nvdimm_major;
Dan Williams45def222015-04-26 19:26:48 -040032static int nvdimm_bus_major;
33static struct class *nd_class;
34
Dan Williams4d88a972015-05-31 14:41:48 -040035static int to_nd_device_type(struct device *dev)
36{
37 if (is_nvdimm(dev))
38 return ND_DEVICE_DIMM;
Dan Williams3d880022015-05-31 15:02:11 -040039 else if (is_nd_pmem(dev))
40 return ND_DEVICE_REGION_PMEM;
41 else if (is_nd_blk(dev))
42 return ND_DEVICE_REGION_BLK;
43 else if (is_nd_pmem(dev->parent) || is_nd_blk(dev->parent))
44 return nd_region_to_nstype(to_nd_region(dev->parent));
Dan Williams4d88a972015-05-31 14:41:48 -040045
46 return 0;
47}
48
49static int nvdimm_bus_uevent(struct device *dev, struct kobj_uevent_env *env)
50{
Toshi Kani41d7a6d2015-06-19 12:18:33 -060051 /*
52 * Ensure that region devices always have their numa node set as
53 * early as possible.
54 */
55 if (is_nd_pmem(dev) || is_nd_blk(dev))
56 set_dev_node(dev, to_nd_region(dev)->numa_node);
Dan Williams4d88a972015-05-31 14:41:48 -040057 return add_uevent_var(env, "MODALIAS=" ND_DEVICE_MODALIAS_FMT,
58 to_nd_device_type(dev));
59}
60
61static int nvdimm_bus_match(struct device *dev, struct device_driver *drv)
62{
63 struct nd_device_driver *nd_drv = to_nd_device_driver(drv);
64
Dan Williams82ec2ba2016-02-15 09:22:36 +010065 return !!test_bit(to_nd_device_type(dev), &nd_drv->type);
Dan Williams4d88a972015-05-31 14:41:48 -040066}
67
Dan Williams3d880022015-05-31 15:02:11 -040068static struct module *to_bus_provider(struct device *dev)
69{
70 /* pin bus providers while regions are enabled */
71 if (is_nd_pmem(dev) || is_nd_blk(dev)) {
72 struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev);
73
74 return nvdimm_bus->module;
75 }
76 return NULL;
77}
78
Dan Williamseaf96152015-05-01 13:11:27 -040079static void nvdimm_bus_probe_start(struct nvdimm_bus *nvdimm_bus)
80{
81 nvdimm_bus_lock(&nvdimm_bus->dev);
82 nvdimm_bus->probe_active++;
83 nvdimm_bus_unlock(&nvdimm_bus->dev);
84}
85
86static void nvdimm_bus_probe_end(struct nvdimm_bus *nvdimm_bus)
87{
88 nvdimm_bus_lock(&nvdimm_bus->dev);
89 if (--nvdimm_bus->probe_active == 0)
90 wake_up(&nvdimm_bus->probe_wait);
91 nvdimm_bus_unlock(&nvdimm_bus->dev);
92}
93
Dan Williams4d88a972015-05-31 14:41:48 -040094static int nvdimm_bus_probe(struct device *dev)
95{
96 struct nd_device_driver *nd_drv = to_nd_device_driver(dev->driver);
Dan Williams3d880022015-05-31 15:02:11 -040097 struct module *provider = to_bus_provider(dev);
Dan Williams4d88a972015-05-31 14:41:48 -040098 struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev);
99 int rc;
100
Dan Williams3d880022015-05-31 15:02:11 -0400101 if (!try_module_get(provider))
102 return -ENXIO;
103
Dan Williamseaf96152015-05-01 13:11:27 -0400104 nvdimm_bus_probe_start(nvdimm_bus);
Dan Williams4d88a972015-05-31 14:41:48 -0400105 rc = nd_drv->probe(dev);
Dan Williamseaf96152015-05-01 13:11:27 -0400106 if (rc == 0)
107 nd_region_probe_success(nvdimm_bus, dev);
Dan Williamsbf9bccc2015-06-17 17:14:46 -0400108 else
109 nd_region_disable(nvdimm_bus, dev);
Dan Williamseaf96152015-05-01 13:11:27 -0400110 nvdimm_bus_probe_end(nvdimm_bus);
111
Dan Williams4d88a972015-05-31 14:41:48 -0400112 dev_dbg(&nvdimm_bus->dev, "%s.probe(%s) = %d\n", dev->driver->name,
113 dev_name(dev), rc);
Dan Williams8c2f7e82015-06-25 04:20:04 -0400114
Dan Williams3d880022015-05-31 15:02:11 -0400115 if (rc != 0)
116 module_put(provider);
Dan Williams4d88a972015-05-31 14:41:48 -0400117 return rc;
118}
119
120static int nvdimm_bus_remove(struct device *dev)
121{
122 struct nd_device_driver *nd_drv = to_nd_device_driver(dev->driver);
Dan Williams3d880022015-05-31 15:02:11 -0400123 struct module *provider = to_bus_provider(dev);
Dan Williams4d88a972015-05-31 14:41:48 -0400124 struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev);
125 int rc;
126
127 rc = nd_drv->remove(dev);
Dan Williamseaf96152015-05-01 13:11:27 -0400128 nd_region_disable(nvdimm_bus, dev);
129
Dan Williams4d88a972015-05-31 14:41:48 -0400130 dev_dbg(&nvdimm_bus->dev, "%s.remove(%s) = %d\n", dev->driver->name,
131 dev_name(dev), rc);
Dan Williams3d880022015-05-31 15:02:11 -0400132 module_put(provider);
Dan Williams4d88a972015-05-31 14:41:48 -0400133 return rc;
134}
135
Dan Williams71999462016-02-18 10:29:49 -0800136void nd_device_notify(struct device *dev, enum nvdimm_event event)
137{
138 device_lock(dev);
139 if (dev->driver) {
140 struct nd_device_driver *nd_drv;
141
142 nd_drv = to_nd_device_driver(dev->driver);
143 if (nd_drv->notify)
144 nd_drv->notify(dev, event);
145 }
146 device_unlock(dev);
147}
148EXPORT_SYMBOL(nd_device_notify);
149
150void nvdimm_region_notify(struct nd_region *nd_region, enum nvdimm_event event)
151{
152 struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(&nd_region->dev);
153
154 if (!nvdimm_bus)
155 return;
156
157 /* caller is responsible for holding a reference on the device */
158 nd_device_notify(&nd_region->dev, event);
159}
160EXPORT_SYMBOL_GPL(nvdimm_region_notify);
161
Dan Williams59e64732016-03-08 07:16:07 -0800162long nvdimm_clear_poison(struct device *dev, phys_addr_t phys,
163 unsigned int len)
164{
165 struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev);
166 struct nvdimm_bus_descriptor *nd_desc;
167 struct nd_cmd_clear_error clear_err;
168 struct nd_cmd_ars_cap ars_cap;
169 u32 clear_err_unit, mask;
170 int cmd_rc, rc;
171
172 if (!nvdimm_bus)
173 return -ENXIO;
174
175 nd_desc = nvdimm_bus->nd_desc;
176 if (!nd_desc->ndctl)
177 return -ENXIO;
178
179 memset(&ars_cap, 0, sizeof(ars_cap));
180 ars_cap.address = phys;
181 ars_cap.length = len;
182 rc = nd_desc->ndctl(nd_desc, NULL, ND_CMD_ARS_CAP, &ars_cap,
183 sizeof(ars_cap), &cmd_rc);
184 if (rc < 0)
185 return rc;
186 if (cmd_rc < 0)
187 return cmd_rc;
188 clear_err_unit = ars_cap.clear_err_unit;
189 if (!clear_err_unit || !is_power_of_2(clear_err_unit))
190 return -ENXIO;
191
192 mask = clear_err_unit - 1;
193 if ((phys | len) & mask)
194 return -ENXIO;
195 memset(&clear_err, 0, sizeof(clear_err));
196 clear_err.address = phys;
197 clear_err.length = len;
198 rc = nd_desc->ndctl(nd_desc, NULL, ND_CMD_CLEAR_ERROR, &clear_err,
199 sizeof(clear_err), &cmd_rc);
200 if (rc < 0)
201 return rc;
202 if (cmd_rc < 0)
203 return cmd_rc;
204 return clear_err.cleared;
205}
206EXPORT_SYMBOL_GPL(nvdimm_clear_poison);
207
Dan Williams4d88a972015-05-31 14:41:48 -0400208static struct bus_type nvdimm_bus_type = {
Dan Williamse6dfb2d2015-04-25 03:56:17 -0400209 .name = "nd",
Dan Williams4d88a972015-05-31 14:41:48 -0400210 .uevent = nvdimm_bus_uevent,
211 .match = nvdimm_bus_match,
212 .probe = nvdimm_bus_probe,
213 .remove = nvdimm_bus_remove,
Dan Williamse6dfb2d2015-04-25 03:56:17 -0400214};
215
Dan Williams4d88a972015-05-31 14:41:48 -0400216static ASYNC_DOMAIN_EXCLUSIVE(nd_async_domain);
217
218void nd_synchronize(void)
219{
220 async_synchronize_full_domain(&nd_async_domain);
221}
222EXPORT_SYMBOL_GPL(nd_synchronize);
223
224static void nd_async_device_register(void *d, async_cookie_t cookie)
225{
226 struct device *dev = d;
227
228 if (device_add(dev) != 0) {
229 dev_err(dev, "%s: failed\n", __func__);
230 put_device(dev);
231 }
232 put_device(dev);
233}
234
235static void nd_async_device_unregister(void *d, async_cookie_t cookie)
236{
237 struct device *dev = d;
238
Dan Williams0ba1c632015-05-30 12:35:36 -0400239 /* flush bus operations before delete */
240 nvdimm_bus_lock(dev);
241 nvdimm_bus_unlock(dev);
242
Dan Williams4d88a972015-05-31 14:41:48 -0400243 device_unregister(dev);
244 put_device(dev);
245}
246
Dan Williams8c2f7e82015-06-25 04:20:04 -0400247void __nd_device_register(struct device *dev)
Dan Williams4d88a972015-05-31 14:41:48 -0400248{
249 dev->bus = &nvdimm_bus_type;
Dan Williams4d88a972015-05-31 14:41:48 -0400250 get_device(dev);
251 async_schedule_domain(nd_async_device_register, dev,
252 &nd_async_domain);
253}
Dan Williams8c2f7e82015-06-25 04:20:04 -0400254
255void nd_device_register(struct device *dev)
256{
257 device_initialize(dev);
258 __nd_device_register(dev);
259}
Dan Williams4d88a972015-05-31 14:41:48 -0400260EXPORT_SYMBOL(nd_device_register);
261
262void nd_device_unregister(struct device *dev, enum nd_async_mode mode)
263{
264 switch (mode) {
265 case ND_ASYNC:
266 get_device(dev);
267 async_schedule_domain(nd_async_device_unregister, dev,
268 &nd_async_domain);
269 break;
270 case ND_SYNC:
271 nd_synchronize();
272 device_unregister(dev);
273 break;
274 }
275}
276EXPORT_SYMBOL(nd_device_unregister);
277
278/**
279 * __nd_driver_register() - register a region or a namespace driver
280 * @nd_drv: driver to register
281 * @owner: automatically set by nd_driver_register() macro
282 * @mod_name: automatically set by nd_driver_register() macro
283 */
284int __nd_driver_register(struct nd_device_driver *nd_drv, struct module *owner,
285 const char *mod_name)
286{
287 struct device_driver *drv = &nd_drv->drv;
288
289 if (!nd_drv->type) {
290 pr_debug("driver type bitmask not set (%pf)\n",
291 __builtin_return_address(0));
292 return -EINVAL;
293 }
294
295 if (!nd_drv->probe || !nd_drv->remove) {
296 pr_debug("->probe() and ->remove() must be specified\n");
297 return -EINVAL;
298 }
299
300 drv->bus = &nvdimm_bus_type;
301 drv->owner = owner;
302 drv->mod_name = mod_name;
303
304 return driver_register(drv);
305}
306EXPORT_SYMBOL(__nd_driver_register);
307
Dan Williams58138822015-06-23 20:08:34 -0400308int nvdimm_revalidate_disk(struct gendisk *disk)
309{
310 struct device *dev = disk->driverfs_dev;
311 struct nd_region *nd_region = to_nd_region(dev->parent);
312 const char *pol = nd_region->ro ? "only" : "write";
313
314 if (nd_region->ro == get_disk_ro(disk))
315 return 0;
316
317 dev_info(dev, "%s read-%s, marking %s read-%s\n",
318 dev_name(&nd_region->dev), pol, disk->disk_name, pol);
319 set_disk_ro(disk, nd_region->ro);
320
321 return 0;
322
323}
324EXPORT_SYMBOL(nvdimm_revalidate_disk);
325
Dan Williams4d88a972015-05-31 14:41:48 -0400326static ssize_t modalias_show(struct device *dev, struct device_attribute *attr,
327 char *buf)
328{
329 return sprintf(buf, ND_DEVICE_MODALIAS_FMT "\n",
330 to_nd_device_type(dev));
331}
332static DEVICE_ATTR_RO(modalias);
333
334static ssize_t devtype_show(struct device *dev, struct device_attribute *attr,
335 char *buf)
336{
337 return sprintf(buf, "%s\n", dev->type->name);
338}
339static DEVICE_ATTR_RO(devtype);
340
341static struct attribute *nd_device_attributes[] = {
342 &dev_attr_modalias.attr,
343 &dev_attr_devtype.attr,
344 NULL,
345};
346
347/**
348 * nd_device_attribute_group - generic attributes for all devices on an nd bus
349 */
350struct attribute_group nd_device_attribute_group = {
351 .attrs = nd_device_attributes,
352};
353EXPORT_SYMBOL_GPL(nd_device_attribute_group);
354
Toshi Kani74ae66c2015-06-19 12:18:34 -0600355static ssize_t numa_node_show(struct device *dev,
356 struct device_attribute *attr, char *buf)
357{
358 return sprintf(buf, "%d\n", dev_to_node(dev));
359}
360static DEVICE_ATTR_RO(numa_node);
361
362static struct attribute *nd_numa_attributes[] = {
363 &dev_attr_numa_node.attr,
364 NULL,
365};
366
367static umode_t nd_numa_attr_visible(struct kobject *kobj, struct attribute *a,
368 int n)
369{
370 if (!IS_ENABLED(CONFIG_NUMA))
371 return 0;
372
373 return a->mode;
374}
375
376/**
377 * nd_numa_attribute_group - NUMA attributes for all devices on an nd bus
378 */
379struct attribute_group nd_numa_attribute_group = {
380 .attrs = nd_numa_attributes,
381 .is_visible = nd_numa_attr_visible,
382};
383EXPORT_SYMBOL_GPL(nd_numa_attribute_group);
384
Dan Williams45def222015-04-26 19:26:48 -0400385int nvdimm_bus_create_ndctl(struct nvdimm_bus *nvdimm_bus)
386{
387 dev_t devt = MKDEV(nvdimm_bus_major, nvdimm_bus->id);
388 struct device *dev;
389
390 dev = device_create(nd_class, &nvdimm_bus->dev, devt, nvdimm_bus,
391 "ndctl%d", nvdimm_bus->id);
392
393 if (IS_ERR(dev)) {
394 dev_dbg(&nvdimm_bus->dev, "failed to register ndctl%d: %ld\n",
395 nvdimm_bus->id, PTR_ERR(dev));
396 return PTR_ERR(dev);
397 }
398 return 0;
399}
400
401void nvdimm_bus_destroy_ndctl(struct nvdimm_bus *nvdimm_bus)
402{
403 device_destroy(nd_class, MKDEV(nvdimm_bus_major, nvdimm_bus->id));
404}
405
Dan Williams62232e452015-06-08 14:27:06 -0400406static const struct nd_cmd_desc __nd_cmd_dimm_descs[] = {
407 [ND_CMD_IMPLEMENTED] = { },
408 [ND_CMD_SMART] = {
409 .out_num = 2,
410 .out_sizes = { 4, 8, },
411 },
412 [ND_CMD_SMART_THRESHOLD] = {
413 .out_num = 2,
414 .out_sizes = { 4, 8, },
415 },
416 [ND_CMD_DIMM_FLAGS] = {
417 .out_num = 2,
418 .out_sizes = { 4, 4 },
419 },
420 [ND_CMD_GET_CONFIG_SIZE] = {
421 .out_num = 3,
422 .out_sizes = { 4, 4, 4, },
423 },
424 [ND_CMD_GET_CONFIG_DATA] = {
425 .in_num = 2,
426 .in_sizes = { 4, 4, },
427 .out_num = 2,
428 .out_sizes = { 4, UINT_MAX, },
429 },
430 [ND_CMD_SET_CONFIG_DATA] = {
431 .in_num = 3,
432 .in_sizes = { 4, 4, UINT_MAX, },
433 .out_num = 1,
434 .out_sizes = { 4, },
435 },
436 [ND_CMD_VENDOR] = {
437 .in_num = 3,
438 .in_sizes = { 4, 4, UINT_MAX, },
439 .out_num = 3,
440 .out_sizes = { 4, 4, UINT_MAX, },
441 },
442};
443
444const struct nd_cmd_desc *nd_cmd_dimm_desc(int cmd)
445{
446 if (cmd < ARRAY_SIZE(__nd_cmd_dimm_descs))
447 return &__nd_cmd_dimm_descs[cmd];
448 return NULL;
449}
450EXPORT_SYMBOL_GPL(nd_cmd_dimm_desc);
451
452static const struct nd_cmd_desc __nd_cmd_bus_descs[] = {
453 [ND_CMD_IMPLEMENTED] = { },
454 [ND_CMD_ARS_CAP] = {
455 .in_num = 2,
456 .in_sizes = { 8, 8, },
Dan Williams4577b062016-02-17 13:08:58 -0800457 .out_num = 4,
458 .out_sizes = { 4, 4, 4, 4, },
Dan Williams62232e452015-06-08 14:27:06 -0400459 },
460 [ND_CMD_ARS_START] = {
Dan Williams4577b062016-02-17 13:08:58 -0800461 .in_num = 5,
462 .in_sizes = { 8, 8, 2, 1, 5, },
463 .out_num = 2,
464 .out_sizes = { 4, 4, },
Dan Williams62232e452015-06-08 14:27:06 -0400465 },
466 [ND_CMD_ARS_STATUS] = {
Dan Williams747ffe12016-02-19 15:21:14 -0800467 .out_num = 3,
468 .out_sizes = { 4, 4, UINT_MAX, },
Dan Williams62232e452015-06-08 14:27:06 -0400469 },
Dan Williamsd4f32362016-03-03 16:08:54 -0800470 [ND_CMD_CLEAR_ERROR] = {
471 .in_num = 2,
472 .in_sizes = { 8, 8, },
473 .out_num = 3,
474 .out_sizes = { 4, 4, 8, },
475 },
Dan Williams62232e452015-06-08 14:27:06 -0400476};
477
478const struct nd_cmd_desc *nd_cmd_bus_desc(int cmd)
479{
480 if (cmd < ARRAY_SIZE(__nd_cmd_bus_descs))
481 return &__nd_cmd_bus_descs[cmd];
482 return NULL;
483}
484EXPORT_SYMBOL_GPL(nd_cmd_bus_desc);
485
486u32 nd_cmd_in_size(struct nvdimm *nvdimm, int cmd,
487 const struct nd_cmd_desc *desc, int idx, void *buf)
488{
489 if (idx >= desc->in_num)
490 return UINT_MAX;
491
492 if (desc->in_sizes[idx] < UINT_MAX)
493 return desc->in_sizes[idx];
494
495 if (nvdimm && cmd == ND_CMD_SET_CONFIG_DATA && idx == 2) {
496 struct nd_cmd_set_config_hdr *hdr = buf;
497
498 return hdr->in_length;
499 } else if (nvdimm && cmd == ND_CMD_VENDOR && idx == 2) {
500 struct nd_cmd_vendor_hdr *hdr = buf;
501
502 return hdr->in_length;
503 }
504
505 return UINT_MAX;
506}
507EXPORT_SYMBOL_GPL(nd_cmd_in_size);
508
509u32 nd_cmd_out_size(struct nvdimm *nvdimm, int cmd,
510 const struct nd_cmd_desc *desc, int idx, const u32 *in_field,
511 const u32 *out_field)
512{
513 if (idx >= desc->out_num)
514 return UINT_MAX;
515
516 if (desc->out_sizes[idx] < UINT_MAX)
517 return desc->out_sizes[idx];
518
519 if (nvdimm && cmd == ND_CMD_GET_CONFIG_DATA && idx == 1)
520 return in_field[1];
521 else if (nvdimm && cmd == ND_CMD_VENDOR && idx == 2)
522 return out_field[1];
Dan Williams747ffe12016-02-19 15:21:14 -0800523 else if (!nvdimm && cmd == ND_CMD_ARS_STATUS && idx == 2)
524 return out_field[1] - 8;
Dan Williams62232e452015-06-08 14:27:06 -0400525
526 return UINT_MAX;
527}
528EXPORT_SYMBOL_GPL(nd_cmd_out_size);
529
Dan Williamsbf9bccc2015-06-17 17:14:46 -0400530void wait_nvdimm_bus_probe_idle(struct device *dev)
Dan Williamseaf96152015-05-01 13:11:27 -0400531{
Dan Williamsbf9bccc2015-06-17 17:14:46 -0400532 struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev);
533
Dan Williamseaf96152015-05-01 13:11:27 -0400534 do {
535 if (nvdimm_bus->probe_active == 0)
536 break;
537 nvdimm_bus_unlock(&nvdimm_bus->dev);
538 wait_event(nvdimm_bus->probe_wait,
539 nvdimm_bus->probe_active == 0);
540 nvdimm_bus_lock(&nvdimm_bus->dev);
541 } while (true);
542}
543
Dan Williamsd4f32362016-03-03 16:08:54 -0800544static int pmem_active(struct device *dev, void *data)
545{
546 if (is_nd_pmem(dev) && dev->driver)
547 return -EBUSY;
548 return 0;
549}
550
Dan Williamseaf96152015-05-01 13:11:27 -0400551/* set_config requires an idle interleave set */
Dan Williams87bf5722016-02-22 21:50:31 -0800552static int nd_cmd_clear_to_send(struct nvdimm_bus *nvdimm_bus,
553 struct nvdimm *nvdimm, unsigned int cmd)
Dan Williamseaf96152015-05-01 13:11:27 -0400554{
Dan Williams87bf5722016-02-22 21:50:31 -0800555 struct nvdimm_bus_descriptor *nd_desc = nvdimm_bus->nd_desc;
556
557 /* ask the bus provider if it would like to block this request */
558 if (nd_desc->clear_to_send) {
559 int rc = nd_desc->clear_to_send(nd_desc, nvdimm, cmd);
560
561 if (rc)
562 return rc;
563 }
Dan Williamseaf96152015-05-01 13:11:27 -0400564
Dan Williamsd4f32362016-03-03 16:08:54 -0800565 /* require clear error to go through the pmem driver */
566 if (!nvdimm && cmd == ND_CMD_CLEAR_ERROR)
567 return device_for_each_child(&nvdimm_bus->dev, NULL,
568 pmem_active);
569
Dan Williamseaf96152015-05-01 13:11:27 -0400570 if (!nvdimm || cmd != ND_CMD_SET_CONFIG_DATA)
571 return 0;
572
Dan Williams87bf5722016-02-22 21:50:31 -0800573 /* prevent label manipulation while the kernel owns label updates */
Dan Williamsbf9bccc2015-06-17 17:14:46 -0400574 wait_nvdimm_bus_probe_idle(&nvdimm_bus->dev);
Dan Williamseaf96152015-05-01 13:11:27 -0400575 if (atomic_read(&nvdimm->busy))
576 return -EBUSY;
577 return 0;
578}
579
Dan Williams62232e452015-06-08 14:27:06 -0400580static int __nd_ioctl(struct nvdimm_bus *nvdimm_bus, struct nvdimm *nvdimm,
581 int read_only, unsigned int ioctl_cmd, unsigned long arg)
582{
583 struct nvdimm_bus_descriptor *nd_desc = nvdimm_bus->nd_desc;
584 size_t buf_len = 0, in_len = 0, out_len = 0;
585 static char out_env[ND_CMD_MAX_ENVELOPE];
586 static char in_env[ND_CMD_MAX_ENVELOPE];
587 const struct nd_cmd_desc *desc = NULL;
588 unsigned int cmd = _IOC_NR(ioctl_cmd);
589 void __user *p = (void __user *) arg;
590 struct device *dev = &nvdimm_bus->dev;
591 const char *cmd_name, *dimm_name;
592 unsigned long dsm_mask;
593 void *buf;
594 int rc, i;
595
596 if (nvdimm) {
597 desc = nd_cmd_dimm_desc(cmd);
598 cmd_name = nvdimm_cmd_name(cmd);
599 dsm_mask = nvdimm->dsm_mask ? *(nvdimm->dsm_mask) : 0;
600 dimm_name = dev_name(&nvdimm->dev);
601 } else {
602 desc = nd_cmd_bus_desc(cmd);
603 cmd_name = nvdimm_bus_cmd_name(cmd);
604 dsm_mask = nd_desc->dsm_mask;
605 dimm_name = "bus";
606 }
607
608 if (!desc || (desc->out_num + desc->in_num == 0) ||
609 !test_bit(cmd, &dsm_mask))
610 return -ENOTTY;
611
612 /* fail write commands (when read-only) */
613 if (read_only)
Jerry Hoemann07accfa2016-01-06 16:03:41 -0700614 switch (cmd) {
615 case ND_CMD_VENDOR:
616 case ND_CMD_SET_CONFIG_DATA:
617 case ND_CMD_ARS_START:
Dan Williamsd4f32362016-03-03 16:08:54 -0800618 case ND_CMD_CLEAR_ERROR:
Dan Williams62232e452015-06-08 14:27:06 -0400619 dev_dbg(&nvdimm_bus->dev, "'%s' command while read-only.\n",
620 nvdimm ? nvdimm_cmd_name(cmd)
621 : nvdimm_bus_cmd_name(cmd));
622 return -EPERM;
623 default:
624 break;
625 }
626
627 /* process an input envelope */
628 for (i = 0; i < desc->in_num; i++) {
629 u32 in_size, copy;
630
631 in_size = nd_cmd_in_size(nvdimm, cmd, desc, i, in_env);
632 if (in_size == UINT_MAX) {
633 dev_err(dev, "%s:%s unknown input size cmd: %s field: %d\n",
634 __func__, dimm_name, cmd_name, i);
635 return -ENXIO;
636 }
Dan Williams62232e452015-06-08 14:27:06 -0400637 if (in_len < sizeof(in_env))
638 copy = min_t(u32, sizeof(in_env) - in_len, in_size);
639 else
640 copy = 0;
641 if (copy && copy_from_user(&in_env[in_len], p + in_len, copy))
642 return -EFAULT;
643 in_len += in_size;
644 }
645
646 /* process an output envelope */
647 for (i = 0; i < desc->out_num; i++) {
648 u32 out_size = nd_cmd_out_size(nvdimm, cmd, desc, i,
649 (u32 *) in_env, (u32 *) out_env);
650 u32 copy;
651
652 if (out_size == UINT_MAX) {
653 dev_dbg(dev, "%s:%s unknown output size cmd: %s field: %d\n",
654 __func__, dimm_name, cmd_name, i);
655 return -EFAULT;
656 }
Dan Williams62232e452015-06-08 14:27:06 -0400657 if (out_len < sizeof(out_env))
658 copy = min_t(u32, sizeof(out_env) - out_len, out_size);
659 else
660 copy = 0;
661 if (copy && copy_from_user(&out_env[out_len],
662 p + in_len + out_len, copy))
663 return -EFAULT;
664 out_len += out_size;
665 }
666
667 buf_len = out_len + in_len;
Dan Williams62232e452015-06-08 14:27:06 -0400668 if (buf_len > ND_IOCTL_MAX_BUFLEN) {
669 dev_dbg(dev, "%s:%s cmd: %s buf_len: %zu > %d\n", __func__,
670 dimm_name, cmd_name, buf_len,
671 ND_IOCTL_MAX_BUFLEN);
672 return -EINVAL;
673 }
674
675 buf = vmalloc(buf_len);
676 if (!buf)
677 return -ENOMEM;
678
679 if (copy_from_user(buf, p, buf_len)) {
680 rc = -EFAULT;
681 goto out;
682 }
683
Dan Williamseaf96152015-05-01 13:11:27 -0400684 nvdimm_bus_lock(&nvdimm_bus->dev);
Dan Williams87bf5722016-02-22 21:50:31 -0800685 rc = nd_cmd_clear_to_send(nvdimm_bus, nvdimm, cmd);
Dan Williamseaf96152015-05-01 13:11:27 -0400686 if (rc)
687 goto out_unlock;
688
Dan Williamsaef25332016-02-12 17:01:11 -0800689 rc = nd_desc->ndctl(nd_desc, nvdimm, cmd, buf, buf_len, NULL);
Dan Williams62232e452015-06-08 14:27:06 -0400690 if (rc < 0)
Dan Williamseaf96152015-05-01 13:11:27 -0400691 goto out_unlock;
Dan Williams62232e452015-06-08 14:27:06 -0400692 if (copy_to_user(p, buf, buf_len))
693 rc = -EFAULT;
Dan Williamseaf96152015-05-01 13:11:27 -0400694 out_unlock:
695 nvdimm_bus_unlock(&nvdimm_bus->dev);
Dan Williams62232e452015-06-08 14:27:06 -0400696 out:
697 vfree(buf);
698 return rc;
699}
700
Dan Williams45def222015-04-26 19:26:48 -0400701static long nd_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
702{
Dan Williams62232e452015-06-08 14:27:06 -0400703 long id = (long) file->private_data;
Jerry Hoemann4dc0e7b2016-01-06 16:03:39 -0700704 int rc = -ENXIO, ro;
Dan Williams62232e452015-06-08 14:27:06 -0400705 struct nvdimm_bus *nvdimm_bus;
706
Jerry Hoemann4dc0e7b2016-01-06 16:03:39 -0700707 ro = ((file->f_flags & O_ACCMODE) == O_RDONLY);
Dan Williams62232e452015-06-08 14:27:06 -0400708 mutex_lock(&nvdimm_bus_list_mutex);
709 list_for_each_entry(nvdimm_bus, &nvdimm_bus_list, list) {
710 if (nvdimm_bus->id == id) {
Jerry Hoemann4dc0e7b2016-01-06 16:03:39 -0700711 rc = __nd_ioctl(nvdimm_bus, NULL, ro, cmd, arg);
Dan Williams62232e452015-06-08 14:27:06 -0400712 break;
713 }
714 }
715 mutex_unlock(&nvdimm_bus_list_mutex);
716
717 return rc;
718}
719
720static int match_dimm(struct device *dev, void *data)
721{
722 long id = (long) data;
723
724 if (is_nvdimm(dev)) {
725 struct nvdimm *nvdimm = to_nvdimm(dev);
726
727 return nvdimm->id == id;
728 }
729
730 return 0;
731}
732
733static long nvdimm_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
734{
Jerry Hoemann4dc0e7b2016-01-06 16:03:39 -0700735 int rc = -ENXIO, ro;
Dan Williams62232e452015-06-08 14:27:06 -0400736 struct nvdimm_bus *nvdimm_bus;
737
Jerry Hoemann4dc0e7b2016-01-06 16:03:39 -0700738 ro = ((file->f_flags & O_ACCMODE) == O_RDONLY);
Dan Williams62232e452015-06-08 14:27:06 -0400739 mutex_lock(&nvdimm_bus_list_mutex);
740 list_for_each_entry(nvdimm_bus, &nvdimm_bus_list, list) {
741 struct device *dev = device_find_child(&nvdimm_bus->dev,
742 file->private_data, match_dimm);
743 struct nvdimm *nvdimm;
744
745 if (!dev)
746 continue;
747
748 nvdimm = to_nvdimm(dev);
Jerry Hoemann4dc0e7b2016-01-06 16:03:39 -0700749 rc = __nd_ioctl(nvdimm_bus, nvdimm, ro, cmd, arg);
Dan Williams62232e452015-06-08 14:27:06 -0400750 put_device(dev);
751 break;
752 }
753 mutex_unlock(&nvdimm_bus_list_mutex);
754
755 return rc;
756}
757
758static int nd_open(struct inode *inode, struct file *file)
759{
760 long minor = iminor(inode);
761
762 file->private_data = (void *) minor;
763 return 0;
Dan Williams45def222015-04-26 19:26:48 -0400764}
765
766static const struct file_operations nvdimm_bus_fops = {
767 .owner = THIS_MODULE,
Dan Williams62232e452015-06-08 14:27:06 -0400768 .open = nd_open,
Dan Williams45def222015-04-26 19:26:48 -0400769 .unlocked_ioctl = nd_ioctl,
770 .compat_ioctl = nd_ioctl,
771 .llseek = noop_llseek,
772};
773
Dan Williams62232e452015-06-08 14:27:06 -0400774static const struct file_operations nvdimm_fops = {
775 .owner = THIS_MODULE,
776 .open = nd_open,
777 .unlocked_ioctl = nvdimm_ioctl,
778 .compat_ioctl = nvdimm_ioctl,
779 .llseek = noop_llseek,
780};
781
Dan Williams45def222015-04-26 19:26:48 -0400782int __init nvdimm_bus_init(void)
783{
784 int rc;
785
Dan Williamse6dfb2d2015-04-25 03:56:17 -0400786 rc = bus_register(&nvdimm_bus_type);
787 if (rc)
788 return rc;
789
Dan Williams45def222015-04-26 19:26:48 -0400790 rc = register_chrdev(0, "ndctl", &nvdimm_bus_fops);
791 if (rc < 0)
Dan Williams62232e452015-06-08 14:27:06 -0400792 goto err_bus_chrdev;
Dan Williams45def222015-04-26 19:26:48 -0400793 nvdimm_bus_major = rc;
794
Dan Williams62232e452015-06-08 14:27:06 -0400795 rc = register_chrdev(0, "dimmctl", &nvdimm_fops);
796 if (rc < 0)
797 goto err_dimm_chrdev;
798 nvdimm_major = rc;
799
Dan Williams45def222015-04-26 19:26:48 -0400800 nd_class = class_create(THIS_MODULE, "nd");
Axel Lindaa1dee2015-06-28 17:00:57 +0800801 if (IS_ERR(nd_class)) {
802 rc = PTR_ERR(nd_class);
Dan Williams45def222015-04-26 19:26:48 -0400803 goto err_class;
Axel Lindaa1dee2015-06-28 17:00:57 +0800804 }
Dan Williams45def222015-04-26 19:26:48 -0400805
806 return 0;
807
808 err_class:
Dan Williams62232e452015-06-08 14:27:06 -0400809 unregister_chrdev(nvdimm_major, "dimmctl");
810 err_dimm_chrdev:
Dan Williams45def222015-04-26 19:26:48 -0400811 unregister_chrdev(nvdimm_bus_major, "ndctl");
Dan Williams62232e452015-06-08 14:27:06 -0400812 err_bus_chrdev:
Dan Williamse6dfb2d2015-04-25 03:56:17 -0400813 bus_unregister(&nvdimm_bus_type);
Dan Williams45def222015-04-26 19:26:48 -0400814
815 return rc;
816}
817
Dan Williams4d88a972015-05-31 14:41:48 -0400818void nvdimm_bus_exit(void)
Dan Williams45def222015-04-26 19:26:48 -0400819{
820 class_destroy(nd_class);
821 unregister_chrdev(nvdimm_bus_major, "ndctl");
Dan Williams62232e452015-06-08 14:27:06 -0400822 unregister_chrdev(nvdimm_major, "dimmctl");
Dan Williamse6dfb2d2015-04-25 03:56:17 -0400823 bus_unregister(&nvdimm_bus_type);
Dan Williams45def222015-04-26 19:26:48 -0400824}