Doug / smarc-fsl-linux-kernel

1

/*

1

/*

2

* drivers/base/core.c - core driver model code (device registration, etc)

2

* drivers/base/core.c - core driver model code (device registration, etc)

3

*

3

*

4

5

6

7

8

*

8

*

9

* This file is released under the GPLv2

9

* This file is released under the GPLv2

10

*

10

*

11

*/

11

*/

12

13

#include <linux/device.h>

13

#include <linux/device.h>

14

#include <linux/err.h>

14

#include <linux/err.h>

15

#include <linux/init.h>

15

#include <linux/init.h>

16

#include <linux/module.h>

16

#include <linux/module.h>

17

#include <linux/slab.h>

17

#include <linux/slab.h>

18

#include <linux/string.h>

18

#include <linux/string.h>

19

#include <linux/kdev_t.h>

19

#include <linux/kdev_t.h>

20

#include <linux/notifier.h>

20

#include <linux/notifier.h>

21

#include <linux/of.h>

21

#include <linux/of.h>

22

#include <linux/of_device.h>

22

#include <linux/of_device.h>

23

#include <linux/genhd.h>

23

#include <linux/genhd.h>

24

#include <linux/kallsyms.h>

24

#include <linux/kallsyms.h>

25

#include <linux/mutex.h>

25

#include <linux/mutex.h>

26

#include <linux/async.h>

26

#include <linux/async.h>

27

#include <linux/pm_runtime.h>

27

#include <linux/pm_runtime.h>

28

#include <linux/netdevice.h>

28

29

#include "base.h"

30

#include "base.h"

30

#include "power/power.h"

31

#include "power/power.h"

31

32

#ifdef CONFIG_SYSFS_DEPRECATED

33

#ifdef CONFIG_SYSFS_DEPRECATED

33

#ifdef CONFIG_SYSFS_DEPRECATED_V2

34

#ifdef CONFIG_SYSFS_DEPRECATED_V2

34

long sysfs_deprecated = 1;

35

long sysfs_deprecated = 1;

35

#else

36

#else

36

long sysfs_deprecated = 0;

37

long sysfs_deprecated = 0;

37

#endif

38

#endif

38

static __init int sysfs_deprecated_setup(char *arg)

39

static __init int sysfs_deprecated_setup(char *arg)

39

{

40

{

40

return strict_strtol(arg, 10, &sysfs_deprecated);

41

return strict_strtol(arg, 10, &sysfs_deprecated);

41

}

42

}

42

early_param("sysfs.deprecated", sysfs_deprecated_setup);

43

early_param("sysfs.deprecated", sysfs_deprecated_setup);

43

#endif

44

#endif

44

45

int (*platform_notify)(struct device *dev) = NULL;

46

int (*platform_notify)(struct device *dev) = NULL;

46

int (*platform_notify_remove)(struct device *dev) = NULL;

47

int (*platform_notify_remove)(struct device *dev) = NULL;

47

static struct kobject *dev_kobj;

48

static struct kobject *dev_kobj;

48

struct kobject *sysfs_dev_char_kobj;

49

struct kobject *sysfs_dev_char_kobj;

49

struct kobject *sysfs_dev_block_kobj;

50

struct kobject *sysfs_dev_block_kobj;

50

51

#ifdef CONFIG_BLOCK

52

#ifdef CONFIG_BLOCK

52

static inline int device_is_not_partition(struct device *dev)

53

static inline int device_is_not_partition(struct device *dev)

53

{

54

{

54

return !(dev->type == &part_type);

55

return !(dev->type == &part_type);

55

}

56

}

56

#else

57

#else

57

static inline int device_is_not_partition(struct device *dev)

58

static inline int device_is_not_partition(struct device *dev)

58

{

59

{

59

return 1;

60

return 1;

60

}

61

}

61

#endif

62

#endif

62

63

/**

64

/**

64

* dev_driver_string - Return a device's driver name, if at all possible

65

* dev_driver_string - Return a device's driver name, if at all possible

65

* @dev: struct device to get the name of

66

* @dev: struct device to get the name of

66

*

67

*

67

* Will return the device's driver's name if it is bound to a device. If

68

* Will return the device's driver's name if it is bound to a device. If

68

* the device is not bound to a driver, it will return the name of the bus

69

* the device is not bound to a driver, it will return the name of the bus

69

* it is attached to. If it is not attached to a bus either, an empty

70

* it is attached to. If it is not attached to a bus either, an empty

70

* string will be returned.

71

* string will be returned.

71

*/

72

*/

72

const char *dev_driver_string(const struct device *dev)

73

const char *dev_driver_string(const struct device *dev)

73

{

74

{

74

struct device_driver *drv;

75

struct device_driver *drv;

75

76

/* dev->driver can change to NULL underneath us because of unbinding,

77

/* dev->driver can change to NULL underneath us because of unbinding,

77

* so be careful about accessing it. dev->bus and dev->class should

78

* so be careful about accessing it. dev->bus and dev->class should

78

* never change once they are set, so they don't need special care.

79

* never change once they are set, so they don't need special care.

79

*/

80

*/

80

drv = ACCESS_ONCE(dev->driver);

81

drv = ACCESS_ONCE(dev->driver);

81

return drv ? drv->name :

82

return drv ? drv->name :

82

(dev->bus ? dev->bus->name :

83

(dev->bus ? dev->bus->name :

83

(dev->class ? dev->class->name : ""));

84

(dev->class ? dev->class->name : ""));

84

}

85

}

85

EXPORT_SYMBOL(dev_driver_string);

86

EXPORT_SYMBOL(dev_driver_string);

86

87

#define to_dev(obj) container_of(obj, struct device, kobj)

88

#define to_dev(obj) container_of(obj, struct device, kobj)

88

#define to_dev_attr(_attr) container_of(_attr, struct device_attribute, attr)

89

#define to_dev_attr(_attr) container_of(_attr, struct device_attribute, attr)

89

90

static ssize_t dev_attr_show(struct kobject *kobj, struct attribute *attr,

91

static ssize_t dev_attr_show(struct kobject *kobj, struct attribute *attr,

91

char *buf)

92

char *buf)

92

{

93

{

93

struct device_attribute *dev_attr = to_dev_attr(attr);

94

struct device_attribute *dev_attr = to_dev_attr(attr);

94

struct device *dev = to_dev(kobj);

95

struct device *dev = to_dev(kobj);

95

ssize_t ret = -EIO;

96

ssize_t ret = -EIO;

96

97

if (dev_attr->show)

98

if (dev_attr->show)

98

ret = dev_attr->show(dev, dev_attr, buf);

99

ret = dev_attr->show(dev, dev_attr, buf);

99

if (ret >= (ssize_t)PAGE_SIZE) {

100

if (ret >= (ssize_t)PAGE_SIZE) {

100

print_symbol("dev_attr_show: %s returned bad count\n",

101

print_symbol("dev_attr_show: %s returned bad count\n",

101

(unsigned long)dev_attr->show);

102

(unsigned long)dev_attr->show);

102

}

103

}

103

return ret;

104

return ret;

104

}

105

}

105

106

static ssize_t dev_attr_store(struct kobject *kobj, struct attribute *attr,

107

static ssize_t dev_attr_store(struct kobject *kobj, struct attribute *attr,

107

const char *buf, size_t count)

108

const char *buf, size_t count)

108

{

109

{

109

struct device_attribute *dev_attr = to_dev_attr(attr);

110

struct device_attribute *dev_attr = to_dev_attr(attr);

110

struct device *dev = to_dev(kobj);

111

struct device *dev = to_dev(kobj);

111

ssize_t ret = -EIO;

112

ssize_t ret = -EIO;

112

113

if (dev_attr->store)

114

if (dev_attr->store)

114

ret = dev_attr->store(dev, dev_attr, buf, count);

115

ret = dev_attr->store(dev, dev_attr, buf, count);

115

return ret;

116

return ret;

116

}

117

}

117

118

static const struct sysfs_ops dev_sysfs_ops = {

119

static const struct sysfs_ops dev_sysfs_ops = {

119

.show = dev_attr_show,

120

.show = dev_attr_show,

120

.store = dev_attr_store,

121

.store = dev_attr_store,

121

};

122

};

122

123

#define to_ext_attr(x) container_of(x, struct dev_ext_attribute, attr)

124

#define to_ext_attr(x) container_of(x, struct dev_ext_attribute, attr)

124

125

ssize_t device_store_ulong(struct device *dev,

126

ssize_t device_store_ulong(struct device *dev,

126

struct device_attribute *attr,

127

struct device_attribute *attr,

127

const char *buf, size_t size)

128

const char *buf, size_t size)

128

{

129

{

129

struct dev_ext_attribute *ea = to_ext_attr(attr);

130

struct dev_ext_attribute *ea = to_ext_attr(attr);

130

char *end;

131

char *end;

131

unsigned long new = simple_strtoul(buf, &end, 0);

132

unsigned long new = simple_strtoul(buf, &end, 0);

132

if (end == buf)

133

if (end == buf)

133

return -EINVAL;

134

return -EINVAL;

134

*(unsigned long *)(ea->var) = new;

135

*(unsigned long *)(ea->var) = new;

135

/* Always return full write size even if we didn't consume all */

136

/* Always return full write size even if we didn't consume all */

136

return size;

137

return size;

137

}

138

}

138

EXPORT_SYMBOL_GPL(device_store_ulong);

139

EXPORT_SYMBOL_GPL(device_store_ulong);

139

140

ssize_t device_show_ulong(struct device *dev,

141

ssize_t device_show_ulong(struct device *dev,

141

struct device_attribute *attr,

142

struct device_attribute *attr,

142

char *buf)

143

char *buf)

143

{

144

{

144

struct dev_ext_attribute *ea = to_ext_attr(attr);

145

struct dev_ext_attribute *ea = to_ext_attr(attr);

145

return snprintf(buf, PAGE_SIZE, "%lx\n", *(unsigned long *)(ea->var));

146

return snprintf(buf, PAGE_SIZE, "%lx\n", *(unsigned long *)(ea->var));

146

}

147

}

147

EXPORT_SYMBOL_GPL(device_show_ulong);

148

EXPORT_SYMBOL_GPL(device_show_ulong);

148

149

ssize_t device_store_int(struct device *dev,

150

ssize_t device_store_int(struct device *dev,

150

struct device_attribute *attr,

151

struct device_attribute *attr,

151

const char *buf, size_t size)

152

const char *buf, size_t size)

152

{

153

{

153

struct dev_ext_attribute *ea = to_ext_attr(attr);

154

struct dev_ext_attribute *ea = to_ext_attr(attr);

154

char *end;

155

char *end;

155

long new = simple_strtol(buf, &end, 0);

156

long new = simple_strtol(buf, &end, 0);

156

if (end == buf || new > INT_MAX || new < INT_MIN)

157

if (end == buf || new > INT_MAX || new < INT_MIN)

157

return -EINVAL;

158

return -EINVAL;

158

*(int *)(ea->var) = new;

159

*(int *)(ea->var) = new;

159

/* Always return full write size even if we didn't consume all */

160

/* Always return full write size even if we didn't consume all */

160

return size;

161

return size;

161

}

162

}

162

EXPORT_SYMBOL_GPL(device_store_int);

163

EXPORT_SYMBOL_GPL(device_store_int);

163

164

ssize_t device_show_int(struct device *dev,

165

ssize_t device_show_int(struct device *dev,

165

struct device_attribute *attr,

166

struct device_attribute *attr,

166

char *buf)

167

char *buf)

167

{

168

{

168

struct dev_ext_attribute *ea = to_ext_attr(attr);

169

struct dev_ext_attribute *ea = to_ext_attr(attr);

169

170

return snprintf(buf, PAGE_SIZE, "%d\n", *(int *)(ea->var));

171

return snprintf(buf, PAGE_SIZE, "%d\n", *(int *)(ea->var));

171

}

172

}

172

EXPORT_SYMBOL_GPL(device_show_int);

173

EXPORT_SYMBOL_GPL(device_show_int);

173

174

/**

175

/**

175

* device_release - free device structure.

176

* device_release - free device structure.

176

* @kobj: device's kobject.

177

* @kobj: device's kobject.

177

*

178

*

178

* This is called once the reference count for the object

179

* This is called once the reference count for the object

179

* reaches 0. We forward the call to the device's release

180

* reaches 0. We forward the call to the device's release

180

* method, which should handle actually freeing the structure.

181

* method, which should handle actually freeing the structure.

181

*/

182

*/

182

static void device_release(struct kobject *kobj)

183

static void device_release(struct kobject *kobj)

183

{

184

{

184

struct device *dev = to_dev(kobj);

185

struct device *dev = to_dev(kobj);

185

struct device_private *p = dev->p;

186

struct device_private *p = dev->p;

186

187

if (dev->release)

188

if (dev->release)

188

dev->release(dev);

189

dev->release(dev);

189

else if (dev->type && dev->type->release)

190

else if (dev->type && dev->type->release)

190

dev->type->release(dev);

191

dev->type->release(dev);

191

else if (dev->class && dev->class->dev_release)

192

else if (dev->class && dev->class->dev_release)

192

dev->class->dev_release(dev);

193

dev->class->dev_release(dev);

193

else

194

else

194

WARN(1, KERN_ERR "Device '%s' does not have a release() "

195

WARN(1, KERN_ERR "Device '%s' does not have a release() "

195

"function, it is broken and must be fixed.\n",

196

"function, it is broken and must be fixed.\n",

196

dev_name(dev));

197

dev_name(dev));

197

kfree(p);

198

kfree(p);

198

}

199

}

199

200

static const void *device_namespace(struct kobject *kobj)

201

static const void *device_namespace(struct kobject *kobj)

201

{

202

{

202

struct device *dev = to_dev(kobj);

203

struct device *dev = to_dev(kobj);

203

const void *ns = NULL;

204

const void *ns = NULL;

204

205

if (dev->class && dev->class->ns_type)

206

if (dev->class && dev->class->ns_type)

206

ns = dev->class->namespace(dev);

207

ns = dev->class->namespace(dev);

207

208

return ns;

209

return ns;

209

}

210

}

210

211

static struct kobj_type device_ktype = {

212

static struct kobj_type device_ktype = {

212

.release = device_release,

213

.release = device_release,

213

.sysfs_ops = &dev_sysfs_ops,

214

.sysfs_ops = &dev_sysfs_ops,

214

.namespace = device_namespace,

215

.namespace = device_namespace,

215

};

216

};

216

217

218

static int dev_uevent_filter(struct kset *kset, struct kobject *kobj)

219

static int dev_uevent_filter(struct kset *kset, struct kobject *kobj)

219

{

220

{

220

struct kobj_type *ktype = get_ktype(kobj);

221

struct kobj_type *ktype = get_ktype(kobj);

221

222

if (ktype == &device_ktype) {

223

if (ktype == &device_ktype) {

223

struct device *dev = to_dev(kobj);

224

struct device *dev = to_dev(kobj);

224

if (dev->bus)

225

if (dev->bus)

225

return 1;

226

return 1;

226

if (dev->class)

227

if (dev->class)

227

return 1;

228

return 1;

228

}

229

}

229

return 0;

230

return 0;

230

}

231

}

231

232

static const char *dev_uevent_name(struct kset *kset, struct kobject *kobj)

233

static const char *dev_uevent_name(struct kset *kset, struct kobject *kobj)

233

{

234

{

234

struct device *dev = to_dev(kobj);

235

struct device *dev = to_dev(kobj);

235

236

if (dev->bus)

237

if (dev->bus)

237

return dev->bus->name;

238

return dev->bus->name;

238

if (dev->class)

239

if (dev->class)

239

return dev->class->name;

240

return dev->class->name;

240

return NULL;

241

return NULL;

241

}

242

}

242

243

static int dev_uevent(struct kset *kset, struct kobject *kobj,

244

static int dev_uevent(struct kset *kset, struct kobject *kobj,

244

struct kobj_uevent_env *env)

245

struct kobj_uevent_env *env)

245

{

246

{

246

struct device *dev = to_dev(kobj);

247

struct device *dev = to_dev(kobj);

247

int retval = 0;

248

int retval = 0;

248

249

/* add device node properties if present */

250

/* add device node properties if present */

250

if (MAJOR(dev->devt)) {

251

if (MAJOR(dev->devt)) {

251

const char *tmp;

252

const char *tmp;

252

const char *name;

253

const char *name;

253

umode_t mode = 0;

254

umode_t mode = 0;

254

255

add_uevent_var(env, "MAJOR=%u", MAJOR(dev->devt));

256

add_uevent_var(env, "MAJOR=%u", MAJOR(dev->devt));

256

add_uevent_var(env, "MINOR=%u", MINOR(dev->devt));

257

add_uevent_var(env, "MINOR=%u", MINOR(dev->devt));

257

name = device_get_devnode(dev, &mode, &tmp);

258

name = device_get_devnode(dev, &mode, &tmp);

258

if (name) {

259

if (name) {

259

add_uevent_var(env, "DEVNAME=%s", name);

260

add_uevent_var(env, "DEVNAME=%s", name);

260

kfree(tmp);

261

kfree(tmp);

261

if (mode)

262

if (mode)

262

add_uevent_var(env, "DEVMODE=%#o", mode & 0777);

263

add_uevent_var(env, "DEVMODE=%#o", mode & 0777);

263

}

264

}

264

}

265

}

265

266

if (dev->type && dev->type->name)

267

if (dev->type && dev->type->name)

267

add_uevent_var(env, "DEVTYPE=%s", dev->type->name);

268

add_uevent_var(env, "DEVTYPE=%s", dev->type->name);

268

269

if (dev->driver)

270

if (dev->driver)

270

add_uevent_var(env, "DRIVER=%s", dev->driver->name);

271

add_uevent_var(env, "DRIVER=%s", dev->driver->name);

271

272

/* Add common DT information about the device */

273

/* Add common DT information about the device */

273

of_device_uevent(dev, env);

274

of_device_uevent(dev, env);

274

275

/* have the bus specific function add its stuff */

276

/* have the bus specific function add its stuff */

276

if (dev->bus && dev->bus->uevent) {

277

if (dev->bus && dev->bus->uevent) {

277

retval = dev->bus->uevent(dev, env);

278

retval = dev->bus->uevent(dev, env);

278

if (retval)

279

if (retval)

279

pr_debug("device: '%s': %s: bus uevent() returned %d\n",

280

pr_debug("device: '%s': %s: bus uevent() returned %d\n",

280

dev_name(dev), __func__, retval);

281

dev_name(dev), __func__, retval);

281

}

282

}

282

283

/* have the class specific function add its stuff */

284

/* have the class specific function add its stuff */

284

if (dev->class && dev->class->dev_uevent) {

285

if (dev->class && dev->class->dev_uevent) {

285

retval = dev->class->dev_uevent(dev, env);

286

retval = dev->class->dev_uevent(dev, env);

286

if (retval)

287

if (retval)

287

pr_debug("device: '%s': %s: class uevent() "

288

pr_debug("device: '%s': %s: class uevent() "

288

"returned %d\n", dev_name(dev),

289

"returned %d\n", dev_name(dev),

289

__func__, retval);

290

__func__, retval);

290

}

291

}

291

292

/* have the device type specific function add its stuff */

293

/* have the device type specific function add its stuff */

293

if (dev->type && dev->type->uevent) {

294

if (dev->type && dev->type->uevent) {

294

retval = dev->type->uevent(dev, env);

295

retval = dev->type->uevent(dev, env);

295

if (retval)

296

if (retval)

296

pr_debug("device: '%s': %s: dev_type uevent() "

297

pr_debug("device: '%s': %s: dev_type uevent() "

297

"returned %d\n", dev_name(dev),

298

"returned %d\n", dev_name(dev),

298

__func__, retval);

299

__func__, retval);

299

}

300

}

300

301

return retval;

302

return retval;

302

}

303

}

303

304

static const struct kset_uevent_ops device_uevent_ops = {

305

static const struct kset_uevent_ops device_uevent_ops = {

305

.filter = dev_uevent_filter,

306

.filter = dev_uevent_filter,

306

.name = dev_uevent_name,

307

.name = dev_uevent_name,

307

.uevent = dev_uevent,

308

.uevent = dev_uevent,

308

};

309

};

309

310

static ssize_t show_uevent(struct device *dev, struct device_attribute *attr,

311

static ssize_t show_uevent(struct device *dev, struct device_attribute *attr,

311

char *buf)

312

char *buf)

312

{

313

{

313

struct kobject *top_kobj;

314

struct kobject *top_kobj;

314

struct kset *kset;

315

struct kset *kset;

315

struct kobj_uevent_env *env = NULL;

316

struct kobj_uevent_env *env = NULL;

316

int i;

317

int i;

317

size_t count = 0;

318

size_t count = 0;

318

int retval;

319

int retval;

319

320

/* search the kset, the device belongs to */

321

/* search the kset, the device belongs to */

321

top_kobj = &dev->kobj;

322

top_kobj = &dev->kobj;

322

while (!top_kobj->kset && top_kobj->parent)

323

while (!top_kobj->kset && top_kobj->parent)

323

top_kobj = top_kobj->parent;

324

top_kobj = top_kobj->parent;

324

if (!top_kobj->kset)

325

if (!top_kobj->kset)

325

goto out;

326

goto out;

326

327

kset = top_kobj->kset;

328

kset = top_kobj->kset;

328

if (!kset->uevent_ops || !kset->uevent_ops->uevent)

329

if (!kset->uevent_ops || !kset->uevent_ops->uevent)

329

goto out;

330

goto out;

330

331

/* respect filter */

332

/* respect filter */

332

if (kset->uevent_ops && kset->uevent_ops->filter)

333

if (kset->uevent_ops && kset->uevent_ops->filter)

333

if (!kset->uevent_ops->filter(kset, &dev->kobj))

334

if (!kset->uevent_ops->filter(kset, &dev->kobj))

334

goto out;

335

goto out;

335

336

env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL);

337

env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL);

337

if (!env)

338

if (!env)

338

return -ENOMEM;

339

return -ENOMEM;

339

340

/* let the kset specific function add its keys */

341

/* let the kset specific function add its keys */

341

retval = kset->uevent_ops->uevent(kset, &dev->kobj, env);

342

retval = kset->uevent_ops->uevent(kset, &dev->kobj, env);

342

if (retval)

343

if (retval)

343

goto out;

344

goto out;

344

345

/* copy keys to file */

346

/* copy keys to file */

346

for (i = 0; i < env->envp_idx; i++)

347

for (i = 0; i < env->envp_idx; i++)

347

count += sprintf(&buf[count], "%s\n", env->envp[i]);

348

count += sprintf(&buf[count], "%s\n", env->envp[i]);

348

out:

349

out:

349

kfree(env);

350

kfree(env);

350

return count;

351

return count;

351

}

352

}

352

353

static ssize_t store_uevent(struct device *dev, struct device_attribute *attr,

354

static ssize_t store_uevent(struct device *dev, struct device_attribute *attr,

354

const char *buf, size_t count)

355

const char *buf, size_t count)

355

{

356

{

356

enum kobject_action action;

357

enum kobject_action action;

357

358

if (kobject_action_type(buf, count, &action) == 0)

359

if (kobject_action_type(buf, count, &action) == 0)

359

kobject_uevent(&dev->kobj, action);

360

kobject_uevent(&dev->kobj, action);

360

else

361

else

361

dev_err(dev, "uevent: unknown action-string\n");

362

dev_err(dev, "uevent: unknown action-string\n");

362

return count;

363

return count;

363

}

364

}

364

365

static struct device_attribute uevent_attr =

366

static struct device_attribute uevent_attr =

366

__ATTR(uevent, S_IRUGO | S_IWUSR, show_uevent, store_uevent);

367

__ATTR(uevent, S_IRUGO | S_IWUSR, show_uevent, store_uevent);

367

368

static int device_add_attributes(struct device *dev,

369

static int device_add_attributes(struct device *dev,

369

struct device_attribute *attrs)

370

struct device_attribute *attrs)

370

{

371

{

371

int error = 0;

372

int error = 0;

372

int i;

373

int i;

373

374

if (attrs) {

375

if (attrs) {

375

for (i = 0; attr_name(attrs[i]); i++) {

376

for (i = 0; attr_name(attrs[i]); i++) {

376

error = device_create_file(dev, &attrs[i]);

377

error = device_create_file(dev, &attrs[i]);

377

if (error)

378

if (error)

378

break;

379

break;

379

}

380

}

380

if (error)

381

if (error)

381

while (--i >= 0)

382

while (--i >= 0)

382

device_remove_file(dev, &attrs[i]);

383

device_remove_file(dev, &attrs[i]);

383

}

384

}

384

return error;

385

return error;

385

}

386

}

386

387

static void device_remove_attributes(struct device *dev,

388

static void device_remove_attributes(struct device *dev,

388

struct device_attribute *attrs)

389

struct device_attribute *attrs)

389

{

390

{

390

int i;

391

int i;

391

392

if (attrs)

393

if (attrs)

393

for (i = 0; attr_name(attrs[i]); i++)

394

for (i = 0; attr_name(attrs[i]); i++)

394

device_remove_file(dev, &attrs[i]);

395

device_remove_file(dev, &attrs[i]);

395

}

396

}

396

397

static int device_add_bin_attributes(struct device *dev,

398

static int device_add_bin_attributes(struct device *dev,

398

struct bin_attribute *attrs)

399

struct bin_attribute *attrs)

399

{

400

{

400

int error = 0;

401

int error = 0;

401

int i;

402

int i;

402

403

if (attrs) {

404

if (attrs) {

404

for (i = 0; attr_name(attrs[i]); i++) {

405

for (i = 0; attr_name(attrs[i]); i++) {

405

error = device_create_bin_file(dev, &attrs[i]);

406

error = device_create_bin_file(dev, &attrs[i]);

406

if (error)

407

if (error)

407

break;

408

break;

408

}

409

}

409

if (error)

410

if (error)

410

while (--i >= 0)

411

while (--i >= 0)

411

device_remove_bin_file(dev, &attrs[i]);

412

device_remove_bin_file(dev, &attrs[i]);

412

}

413

}

413

return error;

414

return error;

414

}

415

}

415

416

static void device_remove_bin_attributes(struct device *dev,

417

static void device_remove_bin_attributes(struct device *dev,

417

struct bin_attribute *attrs)

418

struct bin_attribute *attrs)

418

{

419

{

419

int i;

420

int i;

420

421

if (attrs)

422

if (attrs)

422

for (i = 0; attr_name(attrs[i]); i++)

423

for (i = 0; attr_name(attrs[i]); i++)

423

device_remove_bin_file(dev, &attrs[i]);

424

device_remove_bin_file(dev, &attrs[i]);

424

}

425

}

425

426

static int device_add_groups(struct device *dev,

427

static int device_add_groups(struct device *dev,

427

const struct attribute_group **groups)

428

const struct attribute_group **groups)

428

{

429

{

429

int error = 0;

430

int error = 0;

430

int i;

431

int i;

431

432

if (groups) {

433

if (groups) {

433

for (i = 0; groups[i]; i++) {

434

for (i = 0; groups[i]; i++) {

434

error = sysfs_create_group(&dev->kobj, groups[i]);

435

error = sysfs_create_group(&dev->kobj, groups[i]);

435

if (error) {

436

if (error) {

436

while (--i >= 0)

437

while (--i >= 0)

437

sysfs_remove_group(&dev->kobj,

438

sysfs_remove_group(&dev->kobj,

438

groups[i]);

439

groups[i]);

439

break;

440

break;

440

}

441

}

441

}

442

}

442

}

443

}

443

return error;

444

return error;

444

}

445

}

445

446

static void device_remove_groups(struct device *dev,

447

static void device_remove_groups(struct device *dev,

447

const struct attribute_group **groups)

448

const struct attribute_group **groups)

448

{

449

{

449

int i;

450

int i;

450

451

if (groups)

452

if (groups)

452

for (i = 0; groups[i]; i++)

453

for (i = 0; groups[i]; i++)

453

sysfs_remove_group(&dev->kobj, groups[i]);

454

sysfs_remove_group(&dev->kobj, groups[i]);

454

}

455

}

455

456

static int device_add_attrs(struct device *dev)

457

static int device_add_attrs(struct device *dev)

457

{

458

{

458

struct class *class = dev->class;

459

struct class *class = dev->class;

459

const struct device_type *type = dev->type;

460

const struct device_type *type = dev->type;

460

int error;

461

int error;

461

462

if (class) {

463

if (class) {

463

error = device_add_attributes(dev, class->dev_attrs);

464

error = device_add_attributes(dev, class->dev_attrs);

464

if (error)

465

if (error)

465

return error;

466

return error;

466

error = device_add_bin_attributes(dev, class->dev_bin_attrs);

467

error = device_add_bin_attributes(dev, class->dev_bin_attrs);

467

if (error)

468

if (error)

468

goto err_remove_class_attrs;

469

goto err_remove_class_attrs;

469

}

470

}

470

471

if (type) {

472

if (type) {

472

error = device_add_groups(dev, type->groups);

473

error = device_add_groups(dev, type->groups);

473

if (error)

474

if (error)

474

goto err_remove_class_bin_attrs;

475

goto err_remove_class_bin_attrs;

475

}

476

}

476

477

error = device_add_groups(dev, dev->groups);

478

error = device_add_groups(dev, dev->groups);

478

if (error)

479

if (error)

479

goto err_remove_type_groups;

480

goto err_remove_type_groups;

480

481

return 0;

482

return 0;

482

483

err_remove_type_groups:

484

err_remove_type_groups:

484

if (type)

485

if (type)

485

device_remove_groups(dev, type->groups);

486

device_remove_groups(dev, type->groups);

486

err_remove_class_bin_attrs:

487

err_remove_class_bin_attrs:

487

if (class)

488

if (class)

488

device_remove_bin_attributes(dev, class->dev_bin_attrs);

489

device_remove_bin_attributes(dev, class->dev_bin_attrs);

489

err_remove_class_attrs:

490

err_remove_class_attrs:

490

if (class)

491

if (class)

491

device_remove_attributes(dev, class->dev_attrs);

492

device_remove_attributes(dev, class->dev_attrs);

492

493

return error;

494

return error;

494

}

495

}

495

496

static void device_remove_attrs(struct device *dev)

497

static void device_remove_attrs(struct device *dev)

497

{

498

{

498

struct class *class = dev->class;

499

struct class *class = dev->class;

499

const struct device_type *type = dev->type;

500

const struct device_type *type = dev->type;

500

501

device_remove_groups(dev, dev->groups);

502

device_remove_groups(dev, dev->groups);

502

503

if (type)

504

if (type)

504

device_remove_groups(dev, type->groups);

505

device_remove_groups(dev, type->groups);

505

506

if (class) {

507

if (class) {

507

device_remove_attributes(dev, class->dev_attrs);

508

device_remove_attributes(dev, class->dev_attrs);

508

device_remove_bin_attributes(dev, class->dev_bin_attrs);

509

device_remove_bin_attributes(dev, class->dev_bin_attrs);

509

}

510

}

510

}

511

}

511

512

513

static ssize_t show_dev(struct device *dev, struct device_attribute *attr,

514

static ssize_t show_dev(struct device *dev, struct device_attribute *attr,

514

char *buf)

515

char *buf)

515

{

516

{

516

return print_dev_t(buf, dev->devt);

517

return print_dev_t(buf, dev->devt);

517

}

518

}

518

519

static struct device_attribute devt_attr =

520

static struct device_attribute devt_attr =

520

__ATTR(dev, S_IRUGO, show_dev, NULL);

521

__ATTR(dev, S_IRUGO, show_dev, NULL);

521

522

/* /sys/devices/ */

523

/* /sys/devices/ */

523

struct kset *devices_kset;

524

struct kset *devices_kset;

524

525

/**

526

/**

526

* device_create_file - create sysfs attribute file for device.

527

* device_create_file - create sysfs attribute file for device.

527

* @dev: device.

528

* @dev: device.

528

* @attr: device attribute descriptor.

529

* @attr: device attribute descriptor.

529

*/

530

*/

530

int device_create_file(struct device *dev,

531

int device_create_file(struct device *dev,

531

const struct device_attribute *attr)

532

const struct device_attribute *attr)

532

{

533

{

533

int error = 0;

534

int error = 0;

534

if (dev)

535

if (dev)

535

error = sysfs_create_file(&dev->kobj, &attr->attr);

536

error = sysfs_create_file(&dev->kobj, &attr->attr);

536

return error;

537

return error;

537

}

538

}

538

539

/**

540

/**

540

* device_remove_file - remove sysfs attribute file.

541

* device_remove_file - remove sysfs attribute file.

541

* @dev: device.

542

* @dev: device.

542

* @attr: device attribute descriptor.

543

* @attr: device attribute descriptor.

543

*/

544

*/

544

void device_remove_file(struct device *dev,

545

void device_remove_file(struct device *dev,

545

const struct device_attribute *attr)

546

const struct device_attribute *attr)

546

{

547

{

547

if (dev)

548

if (dev)

548

sysfs_remove_file(&dev->kobj, &attr->attr);

549

sysfs_remove_file(&dev->kobj, &attr->attr);

549

}

550

}

550

551

/**

552

/**

552

* device_create_bin_file - create sysfs binary attribute file for device.

553

* device_create_bin_file - create sysfs binary attribute file for device.

553

* @dev: device.

554

* @dev: device.

554

* @attr: device binary attribute descriptor.

555

* @attr: device binary attribute descriptor.

555

*/

556

*/

556

int device_create_bin_file(struct device *dev,

557

int device_create_bin_file(struct device *dev,

557

const struct bin_attribute *attr)

558

const struct bin_attribute *attr)

558

{

559

{

559

int error = -EINVAL;

560

int error = -EINVAL;

560

if (dev)

561

if (dev)

561

error = sysfs_create_bin_file(&dev->kobj, attr);

562

error = sysfs_create_bin_file(&dev->kobj, attr);

562

return error;

563

return error;

563

}

564

}

564

EXPORT_SYMBOL_GPL(device_create_bin_file);

565

EXPORT_SYMBOL_GPL(device_create_bin_file);

565

566

/**

567

/**

567

* device_remove_bin_file - remove sysfs binary attribute file

568

* device_remove_bin_file - remove sysfs binary attribute file

568

* @dev: device.

569

* @dev: device.

569

* @attr: device binary attribute descriptor.

570

* @attr: device binary attribute descriptor.

570

*/

571

*/

571

void device_remove_bin_file(struct device *dev,

572

void device_remove_bin_file(struct device *dev,

572

const struct bin_attribute *attr)

573

const struct bin_attribute *attr)

573

{

574

{

574

if (dev)

575

if (dev)

575

sysfs_remove_bin_file(&dev->kobj, attr);

576

sysfs_remove_bin_file(&dev->kobj, attr);

576

}

577

}

577

EXPORT_SYMBOL_GPL(device_remove_bin_file);

578

EXPORT_SYMBOL_GPL(device_remove_bin_file);

578

579

/**

580

/**

580

* device_schedule_callback_owner - helper to schedule a callback for a device

581

* device_schedule_callback_owner - helper to schedule a callback for a device

581

* @dev: device.

582

* @dev: device.

582

* @func: callback function to invoke later.

583

* @func: callback function to invoke later.

583

* @owner: module owning the callback routine

584

* @owner: module owning the callback routine

584

*

585

*

585

* Attribute methods must not unregister themselves or their parent device

586

* Attribute methods must not unregister themselves or their parent device

586

* (which would amount to the same thing). Attempts to do so will deadlock,

587

* (which would amount to the same thing). Attempts to do so will deadlock,

587

* since unregistration is mutually exclusive with driver callbacks.

588

* since unregistration is mutually exclusive with driver callbacks.

588

*

589

*

589

* Instead methods can call this routine, which will attempt to allocate

590

* Instead methods can call this routine, which will attempt to allocate

590

* and schedule a workqueue request to call back @func with @dev as its

591

* and schedule a workqueue request to call back @func with @dev as its

591

* argument in the workqueue's process context. @dev will be pinned until

592

* argument in the workqueue's process context. @dev will be pinned until

592

* @func returns.

593

* @func returns.

593

*

594

*

594

* This routine is usually called via the inline device_schedule_callback(),

595

* This routine is usually called via the inline device_schedule_callback(),

595

* which automatically sets @owner to THIS_MODULE.

596

* which automatically sets @owner to THIS_MODULE.

596

*

597

*

597

* Returns 0 if the request was submitted, -ENOMEM if storage could not

598

* Returns 0 if the request was submitted, -ENOMEM if storage could not

598

* be allocated, -ENODEV if a reference to @owner isn't available.

599

* be allocated, -ENODEV if a reference to @owner isn't available.

599

*

600

*

600

* NOTE: This routine won't work if CONFIG_SYSFS isn't set! It uses an

601

* NOTE: This routine won't work if CONFIG_SYSFS isn't set! It uses an

601

* underlying sysfs routine (since it is intended for use by attribute

602

* underlying sysfs routine (since it is intended for use by attribute

602

* methods), and if sysfs isn't available you'll get nothing but -ENOSYS.

603

* methods), and if sysfs isn't available you'll get nothing but -ENOSYS.

603

*/

604

*/

604

int device_schedule_callback_owner(struct device *dev,

605

int device_schedule_callback_owner(struct device *dev,

605

void (*func)(struct device *), struct module *owner)

606

void (*func)(struct device *), struct module *owner)

606

{

607

{

607

return sysfs_schedule_callback(&dev->kobj,

608

return sysfs_schedule_callback(&dev->kobj,

608

(void (*)(void *)) func, dev, owner);

609

(void (*)(void *)) func, dev, owner);

609

}

610

}

610

EXPORT_SYMBOL_GPL(device_schedule_callback_owner);

611

EXPORT_SYMBOL_GPL(device_schedule_callback_owner);

611

612

static void klist_children_get(struct klist_node *n)

613

static void klist_children_get(struct klist_node *n)

613

{

614

{

614

struct device_private *p = to_device_private_parent(n);

615

struct device_private *p = to_device_private_parent(n);

615

struct device *dev = p->device;

616

struct device *dev = p->device;

616

617

get_device(dev);

618

get_device(dev);

618

}

619

}

619

620

static void klist_children_put(struct klist_node *n)

621

static void klist_children_put(struct klist_node *n)

621

{

622

{

622

struct device_private *p = to_device_private_parent(n);

623

struct device_private *p = to_device_private_parent(n);

623

struct device *dev = p->device;

624

struct device *dev = p->device;

624

625

put_device(dev);

626

put_device(dev);

626

}

627

}

627

628

/**

629

/**

629

* device_initialize - init device structure.

630

* device_initialize - init device structure.

630

* @dev: device.

631

* @dev: device.

631

*

632

*

632

* This prepares the device for use by other layers by initializing

633

* This prepares the device for use by other layers by initializing

633

* its fields.

634

* its fields.

634

* It is the first half of device_register(), if called by

635

* It is the first half of device_register(), if called by

635

* that function, though it can also be called separately, so one

636

* that function, though it can also be called separately, so one

636

* may use @dev's fields. In particular, get_device()/put_device()

637

* may use @dev's fields. In particular, get_device()/put_device()

637

* may be used for reference counting of @dev after calling this

638

* may be used for reference counting of @dev after calling this

638

* function.

639

* function.

639

*

640

*

640

* All fields in @dev must be initialized by the caller to 0, except

641

* All fields in @dev must be initialized by the caller to 0, except

641

* for those explicitly set to some other value. The simplest

642

* for those explicitly set to some other value. The simplest

642

* approach is to use kzalloc() to allocate the structure containing

643

* approach is to use kzalloc() to allocate the structure containing

643

* @dev.

644

* @dev.

644

*

645

*

645

* NOTE: Use put_device() to give up your reference instead of freeing

646

* NOTE: Use put_device() to give up your reference instead of freeing

646

* @dev directly once you have called this function.

647

* @dev directly once you have called this function.

647

*/

648

*/

648

void device_initialize(struct device *dev)

649

void device_initialize(struct device *dev)

649

{

650

{

650

dev->kobj.kset = devices_kset;

651

dev->kobj.kset = devices_kset;

651

kobject_init(&dev->kobj, &device_ktype);

652

kobject_init(&dev->kobj, &device_ktype);

652

INIT_LIST_HEAD(&dev->dma_pools);

653

INIT_LIST_HEAD(&dev->dma_pools);

653

mutex_init(&dev->mutex);

654

mutex_init(&dev->mutex);

654

lockdep_set_novalidate_class(&dev->mutex);

655

lockdep_set_novalidate_class(&dev->mutex);

655

spin_lock_init(&dev->devres_lock);

656

spin_lock_init(&dev->devres_lock);

656

INIT_LIST_HEAD(&dev->devres_head);

657

INIT_LIST_HEAD(&dev->devres_head);

657

device_pm_init(dev);

658

device_pm_init(dev);

658

set_dev_node(dev, -1);

659

set_dev_node(dev, -1);

659

}

660

}

660

661

static struct kobject *virtual_device_parent(struct device *dev)

662

static struct kobject *virtual_device_parent(struct device *dev)

662

{

663

{

663

static struct kobject *virtual_dir = NULL;

664

static struct kobject *virtual_dir = NULL;

664

665

if (!virtual_dir)

666

if (!virtual_dir)

666

virtual_dir = kobject_create_and_add("virtual",

667

virtual_dir = kobject_create_and_add("virtual",

667

&devices_kset->kobj);

668

&devices_kset->kobj);

668

669

return virtual_dir;

670

return virtual_dir;

670

}

671

}

671

672

struct class_dir {

673

struct class_dir {

673

struct kobject kobj;

674

struct kobject kobj;

674

struct class *class;

675

struct class *class;

675

};

676

};

676

677

#define to_class_dir(obj) container_of(obj, struct class_dir, kobj)

678

#define to_class_dir(obj) container_of(obj, struct class_dir, kobj)

678

679

static void class_dir_release(struct kobject *kobj)

680

static void class_dir_release(struct kobject *kobj)

680

{

681

{

681

struct class_dir *dir = to_class_dir(kobj);

682

struct class_dir *dir = to_class_dir(kobj);

682

kfree(dir);

683

kfree(dir);

683

}

684

}

684

685

static const

686

static const

686

struct kobj_ns_type_operations *class_dir_child_ns_type(struct kobject *kobj)

687

struct kobj_ns_type_operations *class_dir_child_ns_type(struct kobject *kobj)

687

{

688

{

688

struct class_dir *dir = to_class_dir(kobj);

689

struct class_dir *dir = to_class_dir(kobj);

689

return dir->class->ns_type;

690

return dir->class->ns_type;

690

}

691

}

691

692

static struct kobj_type class_dir_ktype = {

693

static struct kobj_type class_dir_ktype = {

693

.release = class_dir_release,

694

.release = class_dir_release,

694

.sysfs_ops = &kobj_sysfs_ops,

695

.sysfs_ops = &kobj_sysfs_ops,

695

.child_ns_type = class_dir_child_ns_type

696

.child_ns_type = class_dir_child_ns_type

696

};

697

};

697

698

static struct kobject *

699

static struct kobject *

699

class_dir_create_and_add(struct class *class, struct kobject *parent_kobj)

700

class_dir_create_and_add(struct class *class, struct kobject *parent_kobj)

700

{

701

{

701

struct class_dir *dir;

702

struct class_dir *dir;

702

int retval;

703

int retval;

703

704

dir = kzalloc(sizeof(*dir), GFP_KERNEL);

705

dir = kzalloc(sizeof(*dir), GFP_KERNEL);

705

if (!dir)

706

if (!dir)

706

return NULL;

707

return NULL;

707

708

dir->class = class;

709

dir->class = class;

709

kobject_init(&dir->kobj, &class_dir_ktype);

710

kobject_init(&dir->kobj, &class_dir_ktype);

710

711

dir->kobj.kset = &class->p->glue_dirs;

712

dir->kobj.kset = &class->p->glue_dirs;

712

713

retval = kobject_add(&dir->kobj, parent_kobj, "%s", class->name);

714

retval = kobject_add(&dir->kobj, parent_kobj, "%s", class->name);

714

if (retval < 0) {

715

if (retval < 0) {

715

kobject_put(&dir->kobj);

716

kobject_put(&dir->kobj);

716

return NULL;

717

return NULL;

717

}

718

}

718

return &dir->kobj;

719

return &dir->kobj;

719

}

720

}

720

721

722

static struct kobject *get_device_parent(struct device *dev,

723

static struct kobject *get_device_parent(struct device *dev,

723

struct device *parent)

724

struct device *parent)

724

{

725

{

725

if (dev->class) {

726

if (dev->class) {

726

static DEFINE_MUTEX(gdp_mutex);

727

static DEFINE_MUTEX(gdp_mutex);

727

struct kobject *kobj = NULL;

728

struct kobject *kobj = NULL;

728

struct kobject *parent_kobj;

729

struct kobject *parent_kobj;

729

struct kobject *k;

730

struct kobject *k;

730

731

#ifdef CONFIG_BLOCK

732

#ifdef CONFIG_BLOCK

732

/* block disks show up in /sys/block */

733

/* block disks show up in /sys/block */

733

if (sysfs_deprecated && dev->class == &block_class) {

734

if (sysfs_deprecated && dev->class == &block_class) {

734

if (parent && parent->class == &block_class)

735

if (parent && parent->class == &block_class)

735

return &parent->kobj;

736

return &parent->kobj;

736

return &block_class.p->subsys.kobj;

737

return &block_class.p->subsys.kobj;

737

}

738

}

738

#endif

739

#endif

739

740

/*

741

/*

741

* If we have no parent, we live in "virtual".

742

* If we have no parent, we live in "virtual".

742

* Class-devices with a non class-device as parent, live

743

* Class-devices with a non class-device as parent, live

743

* in a "glue" directory to prevent namespace collisions.

744

* in a "glue" directory to prevent namespace collisions.

744

*/

745

*/

745

if (parent == NULL)

746

if (parent == NULL)

746

parent_kobj = virtual_device_parent(dev);

747

parent_kobj = virtual_device_parent(dev);

747

else if (parent->class && !dev->class->ns_type)

748

else if (parent->class && !dev->class->ns_type)

748

return &parent->kobj;

749

return &parent->kobj;

749

else

750

else

750

parent_kobj = &parent->kobj;

751

parent_kobj = &parent->kobj;

751

752

mutex_lock(&gdp_mutex);

753

mutex_lock(&gdp_mutex);

753

754

/* find our class-directory at the parent and reference it */

755

/* find our class-directory at the parent and reference it */

755

spin_lock(&dev->class->p->glue_dirs.list_lock);

756

spin_lock(&dev->class->p->glue_dirs.list_lock);

756

list_for_each_entry(k, &dev->class->p->glue_dirs.list, entry)

757

list_for_each_entry(k, &dev->class->p->glue_dirs.list, entry)

757

if (k->parent == parent_kobj) {

758

if (k->parent == parent_kobj) {

758

kobj = kobject_get(k);

759

kobj = kobject_get(k);

759

break;

760

break;

760

}

761

}

761

spin_unlock(&dev->class->p->glue_dirs.list_lock);

762

spin_unlock(&dev->class->p->glue_dirs.list_lock);

762

if (kobj) {

763

if (kobj) {

763

mutex_unlock(&gdp_mutex);

764

mutex_unlock(&gdp_mutex);

764

return kobj;

765

return kobj;

765

}

766

}

766

767

/* or create a new class-directory at the parent device */

768

/* or create a new class-directory at the parent device */

768

k = class_dir_create_and_add(dev->class, parent_kobj);

769

k = class_dir_create_and_add(dev->class, parent_kobj);

769

/* do not emit an uevent for this simple "glue" directory */

770

/* do not emit an uevent for this simple "glue" directory */

770

mutex_unlock(&gdp_mutex);

771

mutex_unlock(&gdp_mutex);

771

return k;

772

return k;

772

}

773

}

773

774

/* subsystems can specify a default root directory for their devices */

775

/* subsystems can specify a default root directory for their devices */

775

if (!parent && dev->bus && dev->bus->dev_root)

776

if (!parent && dev->bus && dev->bus->dev_root)

776

return &dev->bus->dev_root->kobj;

777

return &dev->bus->dev_root->kobj;

777

778

if (parent)

779

if (parent)

779

return &parent->kobj;

780

return &parent->kobj;

780

return NULL;

781

return NULL;

781

}

782

}

782

783

static void cleanup_glue_dir(struct device *dev, struct kobject *glue_dir)

784

static void cleanup_glue_dir(struct device *dev, struct kobject *glue_dir)

784

{

785

{

785

/* see if we live in a "glue" directory */

786

/* see if we live in a "glue" directory */

786

if (!glue_dir || !dev->class ||

787

if (!glue_dir || !dev->class ||

787

glue_dir->kset != &dev->class->p->glue_dirs)

788

glue_dir->kset != &dev->class->p->glue_dirs)

788

return;

789

return;

789

790

kobject_put(glue_dir);

791

kobject_put(glue_dir);

791

}

792

}

792

793

static void cleanup_device_parent(struct device *dev)

794

static void cleanup_device_parent(struct device *dev)

794

{

795

{

795

cleanup_glue_dir(dev, dev->kobj.parent);

796

cleanup_glue_dir(dev, dev->kobj.parent);

796

}

797

}

797

798

static int device_add_class_symlinks(struct device *dev)

799

static int device_add_class_symlinks(struct device *dev)

799

{

800

{

800

int error;

801

int error;

801

802

if (!dev->class)

803

if (!dev->class)

803

return 0;

804

return 0;

804

805

error = sysfs_create_link(&dev->kobj,

806

error = sysfs_create_link(&dev->kobj,

806

&dev->class->p->subsys.kobj,

807

&dev->class->p->subsys.kobj,

807

"subsystem");

808

"subsystem");

808

if (error)

809

if (error)

809

goto out;

810

goto out;

810

811

if (dev->parent && device_is_not_partition(dev)) {

812

if (dev->parent && device_is_not_partition(dev)) {

812

error = sysfs_create_link(&dev->kobj, &dev->parent->kobj,

813

error = sysfs_create_link(&dev->kobj, &dev->parent->kobj,

813

"device");

814

"device");

814

if (error)

815

if (error)

815

goto out_subsys;

816

goto out_subsys;

816

}

817

}

817

818

#ifdef CONFIG_BLOCK

819

#ifdef CONFIG_BLOCK

819

/* /sys/block has directories and does not need symlinks */

820

/* /sys/block has directories and does not need symlinks */

820

if (sysfs_deprecated && dev->class == &block_class)

821

if (sysfs_deprecated && dev->class == &block_class)

821

return 0;

822

return 0;

822

#endif

823

#endif

823

824

/* link in the class directory pointing to the device */

825

/* link in the class directory pointing to the device */

825

error = sysfs_create_link(&dev->class->p->subsys.kobj,

826

error = sysfs_create_link(&dev->class->p->subsys.kobj,

826

&dev->kobj, dev_name(dev));

827

&dev->kobj, dev_name(dev));

827

if (error)

828

if (error)

828

goto out_device;

829

goto out_device;

829

830

return 0;

831

return 0;

831

832

out_device:

833

out_device:

833

sysfs_remove_link(&dev->kobj, "device");

834

sysfs_remove_link(&dev->kobj, "device");

834

835

out_subsys:

836

out_subsys:

836

sysfs_remove_link(&dev->kobj, "subsystem");

837

sysfs_remove_link(&dev->kobj, "subsystem");

837

out:

838

out:

838

return error;

839

return error;

839

}

840

}

840

841

static void device_remove_class_symlinks(struct device *dev)

842

static void device_remove_class_symlinks(struct device *dev)

842

{

843

{

843

if (!dev->class)

844

if (!dev->class)

844

return;

845

return;

845

846

if (dev->parent && device_is_not_partition(dev))

847

if (dev->parent && device_is_not_partition(dev))

847

sysfs_remove_link(&dev->kobj, "device");

848

sysfs_remove_link(&dev->kobj, "device");

848

sysfs_remove_link(&dev->kobj, "subsystem");

849

sysfs_remove_link(&dev->kobj, "subsystem");

849

#ifdef CONFIG_BLOCK

850

#ifdef CONFIG_BLOCK

850

if (sysfs_deprecated && dev->class == &block_class)

851

if (sysfs_deprecated && dev->class == &block_class)

851

return;

852

return;

852

#endif

853

#endif

853

sysfs_delete_link(&dev->class->p->subsys.kobj, &dev->kobj, dev_name(dev));

854

sysfs_delete_link(&dev->class->p->subsys.kobj, &dev->kobj, dev_name(dev));

854

}

855

}

855

856

/**

857

/**

857

* dev_set_name - set a device name

858

* dev_set_name - set a device name

858

* @dev: device

859

* @dev: device

859

* @fmt: format string for the device's name

860

* @fmt: format string for the device's name

860

*/

861

*/

861

int dev_set_name(struct device *dev, const char *fmt, ...)

862

int dev_set_name(struct device *dev, const char *fmt, ...)

862

{

863

{

863

va_list vargs;

864

va_list vargs;

864

int err;

865

int err;

865

866

va_start(vargs, fmt);

867

va_start(vargs, fmt);

867

err = kobject_set_name_vargs(&dev->kobj, fmt, vargs);

868

err = kobject_set_name_vargs(&dev->kobj, fmt, vargs);

868

va_end(vargs);

869

va_end(vargs);

869

return err;

870

return err;

870

}

871

}

871

EXPORT_SYMBOL_GPL(dev_set_name);

872

EXPORT_SYMBOL_GPL(dev_set_name);

872

873

/**

874

/**

874

* device_to_dev_kobj - select a /sys/dev/ directory for the device

875

* device_to_dev_kobj - select a /sys/dev/ directory for the device

875

* @dev: device

876

* @dev: device

876

*

877

*

877

* By default we select char/ for new entries. Setting class->dev_obj

878

* By default we select char/ for new entries. Setting class->dev_obj

878

* to NULL prevents an entry from being created. class->dev_kobj must

879

* to NULL prevents an entry from being created. class->dev_kobj must

879

* be set (or cleared) before any devices are registered to the class

880

* be set (or cleared) before any devices are registered to the class

880

* otherwise device_create_sys_dev_entry() and

881

* otherwise device_create_sys_dev_entry() and

881

* device_remove_sys_dev_entry() will disagree about the presence of

882

* device_remove_sys_dev_entry() will disagree about the presence of

882

* the link.

883

* the link.

883

*/

884

*/

884

static struct kobject *device_to_dev_kobj(struct device *dev)

885

static struct kobject *device_to_dev_kobj(struct device *dev)

885

{

886

{

886

struct kobject *kobj;

887

struct kobject *kobj;

887

888

if (dev->class)

889

if (dev->class)

889

kobj = dev->class->dev_kobj;

890

kobj = dev->class->dev_kobj;

890

else

891

else

891

kobj = sysfs_dev_char_kobj;

892

kobj = sysfs_dev_char_kobj;

892

893

return kobj;

894

return kobj;

894

}

895

}

895

896

static int device_create_sys_dev_entry(struct device *dev)

897

static int device_create_sys_dev_entry(struct device *dev)

897

{

898

{

898

struct kobject *kobj = device_to_dev_kobj(dev);

899

struct kobject *kobj = device_to_dev_kobj(dev);

899

int error = 0;

900

int error = 0;

900

char devt_str[15];

901

char devt_str[15];

901

902

if (kobj) {

903

if (kobj) {

903

format_dev_t(devt_str, dev->devt);

904

format_dev_t(devt_str, dev->devt);

904

error = sysfs_create_link(kobj, &dev->kobj, devt_str);

905

error = sysfs_create_link(kobj, &dev->kobj, devt_str);

905

}

906

}

906

907

return error;

908

return error;

908

}

909

}

909

910

static void device_remove_sys_dev_entry(struct device *dev)

911

static void device_remove_sys_dev_entry(struct device *dev)

911

{

912

{

912

struct kobject *kobj = device_to_dev_kobj(dev);

913

struct kobject *kobj = device_to_dev_kobj(dev);

913

char devt_str[15];

914

char devt_str[15];

914

915

if (kobj) {

916

if (kobj) {

916

format_dev_t(devt_str, dev->devt);

917

format_dev_t(devt_str, dev->devt);

917

sysfs_remove_link(kobj, devt_str);

918

sysfs_remove_link(kobj, devt_str);

918

}

919

}

919

}

920

}

920

921

int device_private_init(struct device *dev)

922

int device_private_init(struct device *dev)

922

{

923

{

923

dev->p = kzalloc(sizeof(*dev->p), GFP_KERNEL);

924

dev->p = kzalloc(sizeof(*dev->p), GFP_KERNEL);

924

if (!dev->p)

925

if (!dev->p)

925

return -ENOMEM;

926

return -ENOMEM;

926

dev->p->device = dev;

927

dev->p->device = dev;

927

klist_init(&dev->p->klist_children, klist_children_get,

928

klist_init(&dev->p->klist_children, klist_children_get,

928

klist_children_put);

929

klist_children_put);

929

INIT_LIST_HEAD(&dev->p->deferred_probe);

930

INIT_LIST_HEAD(&dev->p->deferred_probe);

930

return 0;

931

return 0;

931

}

932

}

932

933

/**

934

/**

934

* device_add - add device to device hierarchy.

935

* device_add - add device to device hierarchy.

935

* @dev: device.

936

* @dev: device.

936

*

937

*

937

* This is part 2 of device_register(), though may be called

938

* This is part 2 of device_register(), though may be called

938

* separately _iff_ device_initialize() has been called separately.

939

* separately _iff_ device_initialize() has been called separately.

939

*

940

*

940

* This adds @dev to the kobject hierarchy via kobject_add(), adds it

941

* This adds @dev to the kobject hierarchy via kobject_add(), adds it

941

* to the global and sibling lists for the device, then

942

* to the global and sibling lists for the device, then

942

* adds it to the other relevant subsystems of the driver model.

943

* adds it to the other relevant subsystems of the driver model.

943

*

944

*

944

* Do not call this routine or device_register() more than once for

945

* Do not call this routine or device_register() more than once for

945

* any device structure. The driver model core is not designed to work

946

* any device structure. The driver model core is not designed to work

946

* with devices that get unregistered and then spring back to life.

947

* with devices that get unregistered and then spring back to life.

947

* (Among other things, it's very hard to guarantee that all references

948

* (Among other things, it's very hard to guarantee that all references

948

* to the previous incarnation of @dev have been dropped.) Allocate

949

* to the previous incarnation of @dev have been dropped.) Allocate

949

* and register a fresh new struct device instead.

950

* and register a fresh new struct device instead.

950

*

951

*

951

* NOTE: _Never_ directly free @dev after calling this function, even

952

* NOTE: _Never_ directly free @dev after calling this function, even

952

* if it returned an error! Always use put_device() to give up your

953

* if it returned an error! Always use put_device() to give up your

953

* reference instead.

954

* reference instead.

954

*/

955

*/

955

int device_add(struct device *dev)

956

int device_add(struct device *dev)

956

{

957

{

957

struct device *parent = NULL;

958

struct device *parent = NULL;

958

struct kobject *kobj;

959

struct kobject *kobj;

959

struct class_interface *class_intf;

960

struct class_interface *class_intf;

960

int error = -EINVAL;

961

int error = -EINVAL;

961

962

dev = get_device(dev);

963

dev = get_device(dev);

963

if (!dev)

964

if (!dev)

964

goto done;

965

goto done;

965

966

if (!dev->p) {

967

if (!dev->p) {

967

error = device_private_init(dev);

968

error = device_private_init(dev);

968

if (error)

969

if (error)

969

goto done;

970

goto done;

970

}

971

}

971

972

/*

973

/*

973

* for statically allocated devices, which should all be converted

974

* for statically allocated devices, which should all be converted

974

* some day, we need to initialize the name. We prevent reading back

975

* some day, we need to initialize the name. We prevent reading back

975

* the name, and force the use of dev_name()

976

* the name, and force the use of dev_name()

976

*/

977

*/

977

if (dev->init_name) {

978

if (dev->init_name) {

978

dev_set_name(dev, "%s", dev->init_name);

979

dev_set_name(dev, "%s", dev->init_name);

979

dev->init_name = NULL;

980

dev->init_name = NULL;

980

}

981

}

981

982

/* subsystems can specify simple device enumeration */

983

/* subsystems can specify simple device enumeration */

983

if (!dev_name(dev) && dev->bus && dev->bus->dev_name)

984

if (!dev_name(dev) && dev->bus && dev->bus->dev_name)

984

dev_set_name(dev, "%s%u", dev->bus->dev_name, dev->id);

985

dev_set_name(dev, "%s%u", dev->bus->dev_name, dev->id);

985

986

if (!dev_name(dev)) {

987

if (!dev_name(dev)) {

987

error = -EINVAL;

988

error = -EINVAL;

988

goto name_error;

989

goto name_error;

989

}

990

}

990

991

pr_debug("device: '%s': %s\n", dev_name(dev), __func__);

992

pr_debug("device: '%s': %s\n", dev_name(dev), __func__);

992

993

parent = get_device(dev->parent);

994

parent = get_device(dev->parent);

994

kobj = get_device_parent(dev, parent);

995

kobj = get_device_parent(dev, parent);

995

if (kobj)

996

if (kobj)

996

dev->kobj.parent = kobj;

997

dev->kobj.parent = kobj;

997

998

/* use parent numa_node */

999

/* use parent numa_node */

999

if (parent)

1000

if (parent)

1000

set_dev_node(dev, dev_to_node(parent));

1001

set_dev_node(dev, dev_to_node(parent));

1001

1002

/* first, register with generic layer. */

1003

/* first, register with generic layer. */

1003

/* we require the name to be set before, and pass NULL */

1004

/* we require the name to be set before, and pass NULL */

1004

error = kobject_add(&dev->kobj, dev->kobj.parent, NULL);

1005

error = kobject_add(&dev->kobj, dev->kobj.parent, NULL);

1005

if (error)

1006

if (error)

1006

goto Error;

1007

goto Error;

1007

1008

/* notify platform of device entry */

1009

/* notify platform of device entry */

1009

if (platform_notify)

1010

if (platform_notify)

1010

platform_notify(dev);

1011

platform_notify(dev);

1011

1012

error = device_create_file(dev, &uevent_attr);

1013

error = device_create_file(dev, &uevent_attr);

1013

if (error)

1014

if (error)

1014

goto attrError;

1015

goto attrError;

1015

1016

if (MAJOR(dev->devt)) {

1017

if (MAJOR(dev->devt)) {

1017

error = device_create_file(dev, &devt_attr);

1018

error = device_create_file(dev, &devt_attr);

1018

if (error)

1019

if (error)

1019

goto ueventattrError;

1020

goto ueventattrError;

1020

1021

error = device_create_sys_dev_entry(dev);

1022

error = device_create_sys_dev_entry(dev);

1022

if (error)

1023

if (error)

1023

goto devtattrError;

1024

goto devtattrError;

1024

1025

devtmpfs_create_node(dev);

1026

devtmpfs_create_node(dev);

1026

}

1027

}

1027

1028

error = device_add_class_symlinks(dev);

1029

error = device_add_class_symlinks(dev);

1029

if (error)

1030

if (error)

1030

goto SymlinkError;

1031

goto SymlinkError;

1031

error = device_add_attrs(dev);

1032

error = device_add_attrs(dev);

1032

if (error)

1033

if (error)

1033

goto AttrsError;

1034

goto AttrsError;

1034

error = bus_add_device(dev);

1035

error = bus_add_device(dev);

1035

if (error)

1036

if (error)

1036

goto BusError;

1037

goto BusError;

1037

error = dpm_sysfs_add(dev);

1038

error = dpm_sysfs_add(dev);

1038

if (error)

1039

if (error)

1039

goto DPMError;

1040

goto DPMError;

1040

device_pm_add(dev);

1041

device_pm_add(dev);

1041

1042

/* Notify clients of device addition. This call must come

1043

/* Notify clients of device addition. This call must come

1043

* after dpm_sysfs_add() and before kobject_uevent().

1044

* after dpm_sysfs_add() and before kobject_uevent().

1044

*/

1045

*/

1045

if (dev->bus)

1046

if (dev->bus)

1046

blocking_notifier_call_chain(&dev->bus->p->bus_notifier,

1047

blocking_notifier_call_chain(&dev->bus->p->bus_notifier,

1047

BUS_NOTIFY_ADD_DEVICE, dev);

1048

BUS_NOTIFY_ADD_DEVICE, dev);

1048

1049

kobject_uevent(&dev->kobj, KOBJ_ADD);

1050

kobject_uevent(&dev->kobj, KOBJ_ADD);

1050

bus_probe_device(dev);

1051

bus_probe_device(dev);

1051

if (parent)

1052

if (parent)

1052

klist_add_tail(&dev->p->knode_parent,

1053

klist_add_tail(&dev->p->knode_parent,

1053

&parent->p->klist_children);

1054

&parent->p->klist_children);

1054

1055

if (dev->class) {

1056

if (dev->class) {

1056

mutex_lock(&dev->class->p->mutex);

1057

mutex_lock(&dev->class->p->mutex);

1057

/* tie the class to the device */

1058

/* tie the class to the device */

1058

klist_add_tail(&dev->knode_class,

1059

klist_add_tail(&dev->knode_class,

1059

&dev->class->p->klist_devices);

1060

&dev->class->p->klist_devices);

1060

1061

/* notify any interfaces that the device is here */

1062

/* notify any interfaces that the device is here */

1062

list_for_each_entry(class_intf,

1063

list_for_each_entry(class_intf,

1063

&dev->class->p->interfaces, node)

1064

&dev->class->p->interfaces, node)

1064

if (class_intf->add_dev)

1065

if (class_intf->add_dev)

1065

class_intf->add_dev(dev, class_intf);

1066

class_intf->add_dev(dev, class_intf);

1066

mutex_unlock(&dev->class->p->mutex);

1067

mutex_unlock(&dev->class->p->mutex);

1067

}

1068

}

1068

done:

1069

done:

1069

put_device(dev);

1070

put_device(dev);

1070

return error;

1071

return error;

1071

DPMError:

1072

DPMError:

1072

bus_remove_device(dev);

1073

bus_remove_device(dev);

1073

BusError:

1074

BusError:

1074

device_remove_attrs(dev);

1075

device_remove_attrs(dev);

1075

AttrsError:

1076

AttrsError:

1076

device_remove_class_symlinks(dev);

1077

device_remove_class_symlinks(dev);

1077

SymlinkError:

1078

SymlinkError:

1078

if (MAJOR(dev->devt))

1079

if (MAJOR(dev->devt))

1079

devtmpfs_delete_node(dev);

1080

devtmpfs_delete_node(dev);

1080

if (MAJOR(dev->devt))

1081

if (MAJOR(dev->devt))

1081

device_remove_sys_dev_entry(dev);

1082

device_remove_sys_dev_entry(dev);

1082

devtattrError:

1083

devtattrError:

1083

if (MAJOR(dev->devt))

1084

if (MAJOR(dev->devt))

1084

device_remove_file(dev, &devt_attr);

1085

device_remove_file(dev, &devt_attr);

1085

ueventattrError:

1086

ueventattrError:

1086

device_remove_file(dev, &uevent_attr);

1087

device_remove_file(dev, &uevent_attr);

1087

attrError:

1088

attrError:

1088

kobject_uevent(&dev->kobj, KOBJ_REMOVE);

1089

kobject_uevent(&dev->kobj, KOBJ_REMOVE);

1089

kobject_del(&dev->kobj);

1090

kobject_del(&dev->kobj);

1090

Error:

1091

Error:

1091

cleanup_device_parent(dev);

1092

cleanup_device_parent(dev);

1092

if (parent)

1093

if (parent)

1093

put_device(parent);

1094

put_device(parent);

1094

name_error:

1095

name_error:

1095

kfree(dev->p);

1096

kfree(dev->p);

1096

dev->p = NULL;

1097

dev->p = NULL;

1097

goto done;

1098

goto done;

1098

}

1099

}

1099

1100

/**

1101

/**

1101

* device_register - register a device with the system.

1102

* device_register - register a device with the system.

1102

* @dev: pointer to the device structure

1103

* @dev: pointer to the device structure

1103

*

1104

*

1104

* This happens in two clean steps - initialize the device

1105

* This happens in two clean steps - initialize the device

1105

* and add it to the system. The two steps can be called

1106

* and add it to the system. The two steps can be called

1106

* separately, but this is the easiest and most common.

1107

* separately, but this is the easiest and most common.

1107

* I.e. you should only call the two helpers separately if

1108

* I.e. you should only call the two helpers separately if

1108

* have a clearly defined need to use and refcount the device

1109

* have a clearly defined need to use and refcount the device

1109

* before it is added to the hierarchy.

1110

* before it is added to the hierarchy.

1110

*

1111

*

1111

* For more information, see the kerneldoc for device_initialize()

1112

* For more information, see the kerneldoc for device_initialize()

1112

* and device_add().

1113

* and device_add().

1113

*

1114

*

1114

* NOTE: _Never_ directly free @dev after calling this function, even

1115

* NOTE: _Never_ directly free @dev after calling this function, even

1115

* if it returned an error! Always use put_device() to give up the

1116

* if it returned an error! Always use put_device() to give up the

1116

* reference initialized in this function instead.

1117

* reference initialized in this function instead.

1117

*/

1118

*/

1118

int device_register(struct device *dev)

1119

int device_register(struct device *dev)

1119

{

1120

{

1120

device_initialize(dev);

1121

device_initialize(dev);

1121

return device_add(dev);

1122

return device_add(dev);

1122

}

1123

}

1123

1124

/**

1125

/**

1125

* get_device - increment reference count for device.

1126

* get_device - increment reference count for device.

1126

* @dev: device.

1127

* @dev: device.

1127

*

1128

*

1128

* This simply forwards the call to kobject_get(), though

1129

* This simply forwards the call to kobject_get(), though

1129

* we do take care to provide for the case that we get a NULL

1130

* we do take care to provide for the case that we get a NULL

1130

* pointer passed in.

1131

* pointer passed in.

1131

*/

1132

*/

1132

struct device *get_device(struct device *dev)

1133

struct device *get_device(struct device *dev)

1133

{

1134

{

1134

return dev ? to_dev(kobject_get(&dev->kobj)) : NULL;

1135

return dev ? to_dev(kobject_get(&dev->kobj)) : NULL;

1135

}

1136

}

1136

1137

/**

1138

/**

1138

* put_device - decrement reference count.

1139

* put_device - decrement reference count.

1139

* @dev: device in question.

1140

* @dev: device in question.

1140

*/

1141

*/

1141

void put_device(struct device *dev)

1142

void put_device(struct device *dev)

1142

{

1143

{

1143

/* might_sleep(); */

1144

/* might_sleep(); */

1144

if (dev)

1145

if (dev)

1145

kobject_put(&dev->kobj);

1146

kobject_put(&dev->kobj);

1146

}

1147

}

1147

1148

/**

1149

/**

1149

* device_del - delete device from system.

1150

* device_del - delete device from system.

1150

* @dev: device.

1151

* @dev: device.

1151

*

1152

*

1152

* This is the first part of the device unregistration

1153

* This is the first part of the device unregistration

1153

* sequence. This removes the device from the lists we control

1154

* sequence. This removes the device from the lists we control

1154

* from here, has it removed from the other driver model

1155

* from here, has it removed from the other driver model

1155

* subsystems it was added to in device_add(), and removes it

1156

* subsystems it was added to in device_add(), and removes it

1156

* from the kobject hierarchy.

1157

* from the kobject hierarchy.

1157

*

1158

*

1158

* NOTE: this should be called manually _iff_ device_add() was

1159

* NOTE: this should be called manually _iff_ device_add() was

1159

* also called manually.

1160

* also called manually.

1160

*/

1161

*/

1161

void device_del(struct device *dev)

1162

void device_del(struct device *dev)

1162

{

1163

{

1163

struct device *parent = dev->parent;

1164

struct device *parent = dev->parent;

1164

struct class_interface *class_intf;

1165

struct class_interface *class_intf;

1165

1166

/* Notify clients of device removal. This call must come

1167

/* Notify clients of device removal. This call must come

1167

* before dpm_sysfs_remove().

1168

* before dpm_sysfs_remove().

1168

*/

1169

*/

1169

if (dev->bus)

1170

if (dev->bus)

1170

blocking_notifier_call_chain(&dev->bus->p->bus_notifier,

1171

blocking_notifier_call_chain(&dev->bus->p->bus_notifier,

1171

BUS_NOTIFY_DEL_DEVICE, dev);

1172

BUS_NOTIFY_DEL_DEVICE, dev);

1172

device_pm_remove(dev);

1173

device_pm_remove(dev);

1173

dpm_sysfs_remove(dev);

1174

dpm_sysfs_remove(dev);

1174

if (parent)

1175

if (parent)

1175

klist_del(&dev->p->knode_parent);

1176

klist_del(&dev->p->knode_parent);

1176

if (MAJOR(dev->devt)) {

1177

if (MAJOR(dev->devt)) {

1177

devtmpfs_delete_node(dev);

1178

devtmpfs_delete_node(dev);

1178

device_remove_sys_dev_entry(dev);

1179

device_remove_sys_dev_entry(dev);

1179

device_remove_file(dev, &devt_attr);

1180

device_remove_file(dev, &devt_attr);

1180

}

1181

}

1181

if (dev->class) {

1182

if (dev->class) {

1182

device_remove_class_symlinks(dev);

1183

device_remove_class_symlinks(dev);

1183

1184

mutex_lock(&dev->class->p->mutex);

1185

mutex_lock(&dev->class->p->mutex);

1185

/* notify any interfaces that the device is now gone */

1186

/* notify any interfaces that the device is now gone */

1186

list_for_each_entry(class_intf,

1187

list_for_each_entry(class_intf,

1187

&dev->class->p->interfaces, node)

1188

&dev->class->p->interfaces, node)

1188

if (class_intf->remove_dev)

1189

if (class_intf->remove_dev)

1189

class_intf->remove_dev(dev, class_intf);

1190

class_intf->remove_dev(dev, class_intf);

1190

/* remove the device from the class list */

1191

/* remove the device from the class list */

1191

klist_del(&dev->knode_class);

1192

klist_del(&dev->knode_class);

1192

mutex_unlock(&dev->class->p->mutex);

1193

mutex_unlock(&dev->class->p->mutex);

1193

}

1194

}

1194

device_remove_file(dev, &uevent_attr);

1195

device_remove_file(dev, &uevent_attr);

1195

device_remove_attrs(dev);

1196

device_remove_attrs(dev);

1196

bus_remove_device(dev);

1197

bus_remove_device(dev);

1197

driver_deferred_probe_del(dev);

1198

driver_deferred_probe_del(dev);

1198

1199

/*

1200

/*

1200

* Some platform devices are driven without driver attached

1201

* Some platform devices are driven without driver attached

1201

* and managed resources may have been acquired. Make sure

1202

* and managed resources may have been acquired. Make sure

1202

* all resources are released.

1203

* all resources are released.

1203

*/

1204

*/

1204

devres_release_all(dev);

1205

devres_release_all(dev);

1205

1206

/* Notify the platform of the removal, in case they

1207

/* Notify the platform of the removal, in case they

1207

* need to do anything...

1208

* need to do anything...

1208

*/

1209

*/

1209

if (platform_notify_remove)

1210

if (platform_notify_remove)

1210

platform_notify_remove(dev);

1211

platform_notify_remove(dev);

1211

kobject_uevent(&dev->kobj, KOBJ_REMOVE);

1212

kobject_uevent(&dev->kobj, KOBJ_REMOVE);

1212

cleanup_device_parent(dev);

1213

cleanup_device_parent(dev);

1213

kobject_del(&dev->kobj);

1214

kobject_del(&dev->kobj);

1214

put_device(parent);

1215

put_device(parent);

1215

}

1216

}

1216

1217

/**

1218

/**

1218

* device_unregister - unregister device from system.

1219

* device_unregister - unregister device from system.

1219

* @dev: device going away.

1220

* @dev: device going away.

1220

*

1221

*

1221

* We do this in two parts, like we do device_register(). First,

1222

* We do this in two parts, like we do device_register(). First,

1222

* we remove it from all the subsystems with device_del(), then

1223

* we remove it from all the subsystems with device_del(), then

1223

* we decrement the reference count via put_device(). If that

1224

* we decrement the reference count via put_device(). If that

1224

* is the final reference count, the device will be cleaned up

1225

* is the final reference count, the device will be cleaned up

1225

* via device_release() above. Otherwise, the structure will

1226

* via device_release() above. Otherwise, the structure will

1226

* stick around until the final reference to the device is dropped.

1227

* stick around until the final reference to the device is dropped.

1227

*/

1228

*/

1228

void device_unregister(struct device *dev)

1229

void device_unregister(struct device *dev)

1229

{

1230

{

1230

pr_debug("device: '%s': %s\n", dev_name(dev), __func__);

1231

pr_debug("device: '%s': %s\n", dev_name(dev), __func__);

1231

device_del(dev);

1232

device_del(dev);

1232

put_device(dev);

1233

put_device(dev);

1233

}

1234

}

1234

1235

static struct device *next_device(struct klist_iter *i)

1236

static struct device *next_device(struct klist_iter *i)

1236

{

1237

{

1237

struct klist_node *n = klist_next(i);

1238

struct klist_node *n = klist_next(i);

1238

struct device *dev = NULL;

1239

struct device *dev = NULL;

1239

struct device_private *p;

1240

struct device_private *p;

1240

1241

if (n) {

1242

if (n) {

1242

p = to_device_private_parent(n);

1243

p = to_device_private_parent(n);

1243

dev = p->device;

1244

dev = p->device;

1244

}

1245

}

1245

return dev;

1246

return dev;

1246

}

1247

}

1247

1248

/**

1249

/**

1249

* device_get_devnode - path of device node file

1250

* device_get_devnode - path of device node file

1250

* @dev: device

1251

* @dev: device

1251

* @mode: returned file access mode

1252

* @mode: returned file access mode

1252

* @tmp: possibly allocated string

1253

* @tmp: possibly allocated string

1253

*

1254

*

1254

* Return the relative path of a possible device node.

1255

* Return the relative path of a possible device node.

1255

* Non-default names may need to allocate a memory to compose

1256

* Non-default names may need to allocate a memory to compose

1256

* a name. This memory is returned in tmp and needs to be

1257

* a name. This memory is returned in tmp and needs to be

1257

* freed by the caller.

1258

* freed by the caller.

1258

*/

1259

*/

1259

const char *device_get_devnode(struct device *dev,

1260

const char *device_get_devnode(struct device *dev,

1260

umode_t *mode, const char **tmp)

1261

umode_t *mode, const char **tmp)

1261

{

1262

{

1262

char *s;

1263

char *s;

1263

1264

*tmp = NULL;

1265

*tmp = NULL;

1265

1266

/* the device type may provide a specific name */

1267

/* the device type may provide a specific name */

1267

if (dev->type && dev->type->devnode)

1268

if (dev->type && dev->type->devnode)

1268

*tmp = dev->type->devnode(dev, mode);

1269

*tmp = dev->type->devnode(dev, mode);

1269

if (*tmp)

1270

if (*tmp)

1270

return *tmp;

1271

return *tmp;

1271

1272

/* the class may provide a specific name */

1273

/* the class may provide a specific name */

1273

if (dev->class && dev->class->devnode)

1274

if (dev->class && dev->class->devnode)

1274

*tmp = dev->class->devnode(dev, mode);

1275

*tmp = dev->class->devnode(dev, mode);

1275

if (*tmp)

1276

if (*tmp)

1276

return *tmp;

1277

return *tmp;

1277

1278

/* return name without allocation, tmp == NULL */

1279

/* return name without allocation, tmp == NULL */

1279

if (strchr(dev_name(dev), '!') == NULL)

1280

if (strchr(dev_name(dev), '!') == NULL)

1280

return dev_name(dev);

1281

return dev_name(dev);

1281

1282

/* replace '!' in the name with '/' */

1283

/* replace '!' in the name with '/' */

1283

*tmp = kstrdup(dev_name(dev), GFP_KERNEL);

1284

*tmp = kstrdup(dev_name(dev), GFP_KERNEL);

1284

if (!*tmp)

1285

if (!*tmp)

1285

return NULL;

1286

return NULL;

1286

while ((s = strchr(*tmp, '!')))

1287

while ((s = strchr(*tmp, '!')))

1287

s[0] = '/';

1288

s[0] = '/';

1288

return *tmp;

1289

return *tmp;

1289

}

1290

}

1290

1291

/**

1292

/**

1292

* device_for_each_child - device child iterator.

1293

* device_for_each_child - device child iterator.

1293

* @parent: parent struct device.

1294

* @parent: parent struct device.

1294

* @data: data for the callback.

1295

* @data: data for the callback.

1295

* @fn: function to be called for each device.

1296

* @fn: function to be called for each device.

1296

*

1297

*

1297

* Iterate over @parent's child devices, and call @fn for each,

1298

* Iterate over @parent's child devices, and call @fn for each,

1298

* passing it @data.

1299

* passing it @data.

1299

*

1300

*

1300

* We check the return of @fn each time. If it returns anything

1301

* We check the return of @fn each time. If it returns anything

1301

* other than 0, we break out and return that value.

1302

* other than 0, we break out and return that value.

1302

*/

1303

*/

1303

int device_for_each_child(struct device *parent, void *data,

1304

int device_for_each_child(struct device *parent, void *data,

1304

int (*fn)(struct device *dev, void *data))

1305

int (*fn)(struct device *dev, void *data))

1305

{

1306

{

1306

struct klist_iter i;

1307

struct klist_iter i;

1307

struct device *child;

1308

struct device *child;

1308

int error = 0;

1309

int error = 0;

1309

1310

if (!parent->p)

1311

if (!parent->p)

1311

return 0;

1312

return 0;

1312

1313

klist_iter_init(&parent->p->klist_children, &i);

1314

klist_iter_init(&parent->p->klist_children, &i);

1314

while ((child = next_device(&i)) && !error)

1315

while ((child = next_device(&i)) && !error)

1315

error = fn(child, data);

1316

error = fn(child, data);

1316

klist_iter_exit(&i);

1317

klist_iter_exit(&i);

1317

return error;

1318

return error;

1318

}

1319

}

1319

1320

/**

1321

/**

1321

* device_find_child - device iterator for locating a particular device.

1322

* device_find_child - device iterator for locating a particular device.

1322

* @parent: parent struct device

1323

* @parent: parent struct device

1323

* @data: Data to pass to match function

1324

* @data: Data to pass to match function

1324

* @match: Callback function to check device

1325

* @match: Callback function to check device

1325

*

1326

*

1326

* This is similar to the device_for_each_child() function above, but it

1327

* This is similar to the device_for_each_child() function above, but it

1327

* returns a reference to a device that is 'found' for later use, as

1328

* returns a reference to a device that is 'found' for later use, as

1328

* determined by the @match callback.

1329

* determined by the @match callback.

1329

*

1330

*

1330

* The callback should return 0 if the device doesn't match and non-zero

1331

* The callback should return 0 if the device doesn't match and non-zero

1331

* if it does. If the callback returns non-zero and a reference to the

1332

* if it does. If the callback returns non-zero and a reference to the

1332

* current device can be obtained, this function will return to the caller

1333

* current device can be obtained, this function will return to the caller

1333

* and not iterate over any more devices.

1334

* and not iterate over any more devices.

1334

*/

1335

*/

1335

struct device *device_find_child(struct device *parent, void *data,

1336

struct device *device_find_child(struct device *parent, void *data,

1336

int (*match)(struct device *dev, void *data))

1337

int (*match)(struct device *dev, void *data))

1337

{

1338

{

1338

struct klist_iter i;

1339

struct klist_iter i;

1339

struct device *child;

1340

struct device *child;

1340

1341

if (!parent)

1342

if (!parent)

1342

return NULL;

1343

return NULL;

1343

1344

klist_iter_init(&parent->p->klist_children, &i);

1345

klist_iter_init(&parent->p->klist_children, &i);

1345

while ((child = next_device(&i)))

1346

while ((child = next_device(&i)))

1346

if (match(child, data) && get_device(child))

1347

if (match(child, data) && get_device(child))

1347

break;

1348

break;

1348

klist_iter_exit(&i);

1349

klist_iter_exit(&i);

1349

return child;

1350

return child;

1350

}

1351

}

1351

1352

int __init devices_init(void)

1353

int __init devices_init(void)

1353

{

1354

{

1354

devices_kset = kset_create_and_add("devices", &device_uevent_ops, NULL);

1355

devices_kset = kset_create_and_add("devices", &device_uevent_ops, NULL);

1355

if (!devices_kset)

1356

if (!devices_kset)

1356

return -ENOMEM;

1357

return -ENOMEM;

1357

dev_kobj = kobject_create_and_add("dev", NULL);

1358

dev_kobj = kobject_create_and_add("dev", NULL);

1358

if (!dev_kobj)

1359

if (!dev_kobj)

1359

goto dev_kobj_err;

1360

goto dev_kobj_err;

1360

sysfs_dev_block_kobj = kobject_create_and_add("block", dev_kobj);

1361

sysfs_dev_block_kobj = kobject_create_and_add("block", dev_kobj);

1361

if (!sysfs_dev_block_kobj)

1362

if (!sysfs_dev_block_kobj)

1362

goto block_kobj_err;

1363

goto block_kobj_err;

1363

sysfs_dev_char_kobj = kobject_create_and_add("char", dev_kobj);

1364

sysfs_dev_char_kobj = kobject_create_and_add("char", dev_kobj);

1364

if (!sysfs_dev_char_kobj)

1365

if (!sysfs_dev_char_kobj)

1365

goto char_kobj_err;

1366

goto char_kobj_err;

1366

1367

return 0;

1368

return 0;

1368

1369

char_kobj_err:

1370

char_kobj_err:

1370

kobject_put(sysfs_dev_block_kobj);

1371

kobject_put(sysfs_dev_block_kobj);

1371

block_kobj_err:

1372

block_kobj_err:

1372

kobject_put(dev_kobj);

1373

kobject_put(dev_kobj);

1373

dev_kobj_err:

1374

dev_kobj_err:

1374

kset_unregister(devices_kset);

1375

kset_unregister(devices_kset);

1375

return -ENOMEM;

1376

return -ENOMEM;

1376

}

1377

}

1377

1378

EXPORT_SYMBOL_GPL(device_for_each_child);

1379

EXPORT_SYMBOL_GPL(device_for_each_child);

1379

EXPORT_SYMBOL_GPL(device_find_child);

1380

EXPORT_SYMBOL_GPL(device_find_child);

1380

1381

EXPORT_SYMBOL_GPL(device_initialize);

1382

EXPORT_SYMBOL_GPL(device_initialize);

1382

EXPORT_SYMBOL_GPL(device_add);

1383

EXPORT_SYMBOL_GPL(device_add);

1383

EXPORT_SYMBOL_GPL(device_register);

1384

EXPORT_SYMBOL_GPL(device_register);

1384

1385

EXPORT_SYMBOL_GPL(device_del);

1386

EXPORT_SYMBOL_GPL(device_del);

1386

EXPORT_SYMBOL_GPL(device_unregister);

1387

EXPORT_SYMBOL_GPL(device_unregister);

1387

EXPORT_SYMBOL_GPL(get_device);

1388

EXPORT_SYMBOL_GPL(get_device);

1388

EXPORT_SYMBOL_GPL(put_device);

1389

EXPORT_SYMBOL_GPL(put_device);

1389

1390

EXPORT_SYMBOL_GPL(device_create_file);

1391

EXPORT_SYMBOL_GPL(device_create_file);

1391

EXPORT_SYMBOL_GPL(device_remove_file);

1392

EXPORT_SYMBOL_GPL(device_remove_file);

1392

1393

struct root_device {

1394

struct root_device {

1394

struct device dev;

1395

struct device dev;

1395

struct module *owner;

1396

struct module *owner;

1396

};

1397

};

1397

1398

inline struct root_device *to_root_device(struct device *d)

1399

inline struct root_device *to_root_device(struct device *d)

1399

{

1400

{

1400

return container_of(d, struct root_device, dev);

1401

return container_of(d, struct root_device, dev);

1401

}

1402

}

1402

1403

static void root_device_release(struct device *dev)

1404

static void root_device_release(struct device *dev)

1404

{

1405

{

1405

kfree(to_root_device(dev));

1406

kfree(to_root_device(dev));

1406

}

1407

}

1407

1408

/**

1409

/**

1409

* __root_device_register - allocate and register a root device

1410

* __root_device_register - allocate and register a root device

1410

* @name: root device name

1411

* @name: root device name

1411

* @owner: owner module of the root device, usually THIS_MODULE

1412

* @owner: owner module of the root device, usually THIS_MODULE

1412

*

1413

*

1413

* This function allocates a root device and registers it

1414

* This function allocates a root device and registers it

1414

* using device_register(). In order to free the returned

1415

* using device_register(). In order to free the returned

1415

* device, use root_device_unregister().

1416

* device, use root_device_unregister().

1416

*

1417

*

1417

* Root devices are dummy devices which allow other devices

1418

* Root devices are dummy devices which allow other devices

1418

* to be grouped under /sys/devices. Use this function to

1419

* to be grouped under /sys/devices. Use this function to

1419

* allocate a root device and then use it as the parent of

1420

* allocate a root device and then use it as the parent of

1420

* any device which should appear under /sys/devices/{name}

1421

* any device which should appear under /sys/devices/{name}

1421

*

1422

*

1422

* The /sys/devices/{name} directory will also contain a

1423

* The /sys/devices/{name} directory will also contain a

1423

* 'module' symlink which points to the @owner directory

1424

* 'module' symlink which points to the @owner directory

1424

* in sysfs.

1425

* in sysfs.

1425

*

1426

*

1426

* Returns &struct device pointer on success, or ERR_PTR() on error.

1427

* Returns &struct device pointer on success, or ERR_PTR() on error.

1427

*

1428

*

1428

* Note: You probably want to use root_device_register().

1429

* Note: You probably want to use root_device_register().

1429

*/

1430

*/

1430

struct device *__root_device_register(const char *name, struct module *owner)

1431

struct device *__root_device_register(const char *name, struct module *owner)

1431

{

1432

{

1432

struct root_device *root;

1433

struct root_device *root;

1433

int err = -ENOMEM;

1434

int err = -ENOMEM;

1434

1435

root = kzalloc(sizeof(struct root_device), GFP_KERNEL);

1436

root = kzalloc(sizeof(struct root_device), GFP_KERNEL);

1436

if (!root)

1437

if (!root)

1437

return ERR_PTR(err);

1438

return ERR_PTR(err);

1438

1439

err = dev_set_name(&root->dev, "%s", name);

1440

err = dev_set_name(&root->dev, "%s", name);

1440

if (err) {

1441

if (err) {

1441

kfree(root);

1442

kfree(root);

1442

return ERR_PTR(err);

1443

return ERR_PTR(err);

1443

}

1444

}

1444

1445

root->dev.release = root_device_release;

1446

root->dev.release = root_device_release;

1446

1447

err = device_register(&root->dev);

1448

err = device_register(&root->dev);

1448

if (err) {

1449

if (err) {

1449

put_device(&root->dev);

1450

put_device(&root->dev);

1450

return ERR_PTR(err);

1451

return ERR_PTR(err);

1451

}

1452

}

1452

1453

#ifdef CONFIG_MODULES /* gotta find a "cleaner" way to do this */

1454

#ifdef CONFIG_MODULES /* gotta find a "cleaner" way to do this */

1454

if (owner) {

1455

if (owner) {

1455

struct module_kobject *mk = &owner->mkobj;

1456

struct module_kobject *mk = &owner->mkobj;

1456

1457

err = sysfs_create_link(&root->dev.kobj, &mk->kobj, "module");

1458

err = sysfs_create_link(&root->dev.kobj, &mk->kobj, "module");

1458

if (err) {

1459

if (err) {

1459

device_unregister(&root->dev);

1460

device_unregister(&root->dev);

1460

return ERR_PTR(err);

1461

return ERR_PTR(err);

1461

}

1462

}

1462

root->owner = owner;

1463

root->owner = owner;

1463

}

1464

}

1464

#endif

1465

#endif

1465

1466

return &root->dev;

1467

return &root->dev;

1467

}

1468

}

1468

EXPORT_SYMBOL_GPL(__root_device_register);

1469

EXPORT_SYMBOL_GPL(__root_device_register);

1469

1470

/**

1471

/**

1471

* root_device_unregister - unregister and free a root device

1472

* root_device_unregister - unregister and free a root device

1472

* @dev: device going away

1473

* @dev: device going away

1473

*

1474

*

1474

* This function unregisters and cleans up a device that was created by

1475

* This function unregisters and cleans up a device that was created by

1475

* root_device_register().

1476

* root_device_register().

1476

*/

1477

*/

1477

void root_device_unregister(struct device *dev)

1478

void root_device_unregister(struct device *dev)

1478

{

1479

{

1479

struct root_device *root = to_root_device(dev);

1480

struct root_device *root = to_root_device(dev);

1480

1481

if (root->owner)

1482

if (root->owner)

1482

sysfs_remove_link(&root->dev.kobj, "module");

1483

sysfs_remove_link(&root->dev.kobj, "module");

1483

1484

device_unregister(dev);

1485

device_unregister(dev);

1485

}

1486

}

1486

EXPORT_SYMBOL_GPL(root_device_unregister);

1487

EXPORT_SYMBOL_GPL(root_device_unregister);

1487

1488

1489

static void device_create_release(struct device *dev)

1490

static void device_create_release(struct device *dev)

1490

{

1491

{

1491

pr_debug("device: '%s': %s\n", dev_name(dev), __func__);

1492

pr_debug("device: '%s': %s\n", dev_name(dev), __func__);

1492

kfree(dev);

1493

kfree(dev);

1493

}

1494

}

1494

1495

/**

1496

/**

1496

* device_create_vargs - creates a device and registers it with sysfs

1497

* device_create_vargs - creates a device and registers it with sysfs

1497

* @class: pointer to the struct class that this device should be registered to

1498

* @class: pointer to the struct class that this device should be registered to

1498

* @parent: pointer to the parent struct device of this new device, if any

1499

* @parent: pointer to the parent struct device of this new device, if any

1499

* @devt: the dev_t for the char device to be added

1500

* @devt: the dev_t for the char device to be added

1500

* @drvdata: the data to be added to the device for callbacks

1501

* @drvdata: the data to be added to the device for callbacks

1501

* @fmt: string for the device's name

1502

* @fmt: string for the device's name

1502

* @args: va_list for the device's name

1503

* @args: va_list for the device's name

1503

*

1504

*

1504

* This function can be used by char device classes. A struct device

1505

* This function can be used by char device classes. A struct device

1505

* will be created in sysfs, registered to the specified class.

1506

* will be created in sysfs, registered to the specified class.

1506

*

1507

*

1507

* A "dev" file will be created, showing the dev_t for the device, if

1508

* A "dev" file will be created, showing the dev_t for the device, if

1508

* the dev_t is not 0,0.

1509

* the dev_t is not 0,0.

1509

* If a pointer to a parent struct device is passed in, the newly created

1510

* If a pointer to a parent struct device is passed in, the newly created

1510

* struct device will be a child of that device in sysfs.

1511

* struct device will be a child of that device in sysfs.

1511

* The pointer to the struct device will be returned from the call.

1512

* The pointer to the struct device will be returned from the call.

1512

* Any further sysfs files that might be required can be created using this

1513

* Any further sysfs files that might be required can be created using this

1513

* pointer.

1514

* pointer.

1514

*

1515

*

1515

* Returns &struct device pointer on success, or ERR_PTR() on error.

1516

* Returns &struct device pointer on success, or ERR_PTR() on error.

1516

*

1517

*

1517

* Note: the struct class passed to this function must have previously

1518

* Note: the struct class passed to this function must have previously

1518

* been created with a call to class_create().

1519

* been created with a call to class_create().

1519

*/

1520

*/

1520

struct device *device_create_vargs(struct class *class, struct device *parent,

1521

struct device *device_create_vargs(struct class *class, struct device *parent,

1521

dev_t devt, void *drvdata, const char *fmt,

1522

dev_t devt, void *drvdata, const char *fmt,

1522

va_list args)

1523

va_list args)

1523

{

1524

{

1524

struct device *dev = NULL;

1525

struct device *dev = NULL;

1525

int retval = -ENODEV;

1526

int retval = -ENODEV;

1526

1527

if (class == NULL || IS_ERR(class))

1528

if (class == NULL || IS_ERR(class))

1528

goto error;

1529

goto error;

1529

1530

dev = kzalloc(sizeof(*dev), GFP_KERNEL);

1531

dev = kzalloc(sizeof(*dev), GFP_KERNEL);

1531

if (!dev) {

1532

if (!dev) {

1532

retval = -ENOMEM;

1533

retval = -ENOMEM;

1533

goto error;

1534

goto error;

1534

}

1535

}

1535

1536

dev->devt = devt;

1537

dev->devt = devt;

1537

dev->class = class;

1538

dev->class = class;

1538

dev->parent = parent;

1539

dev->parent = parent;

1539

dev->release = device_create_release;

1540

dev->release = device_create_release;

1540

dev_set_drvdata(dev, drvdata);

1541

dev_set_drvdata(dev, drvdata);

1541

1542

retval = kobject_set_name_vargs(&dev->kobj, fmt, args);

1543

retval = kobject_set_name_vargs(&dev->kobj, fmt, args);

1543

if (retval)

1544

if (retval)

1544

goto error;

1545

goto error;

1545

1546

retval = device_register(dev);

1547

retval = device_register(dev);

1547

if (retval)

1548

if (retval)

1548

goto error;

1549

goto error;

1549

1550

return dev;

1551

return dev;

1551

1552

error:

1553

error:

1553

put_device(dev);

1554

put_device(dev);

1554

return ERR_PTR(retval);

1555

return ERR_PTR(retval);

1555

}

1556

}

1556

EXPORT_SYMBOL_GPL(device_create_vargs);

1557

EXPORT_SYMBOL_GPL(device_create_vargs);

1557

1558

/**

1559

/**

1559

* device_create - creates a device and registers it with sysfs

1560

* device_create - creates a device and registers it with sysfs

1560

* @class: pointer to the struct class that this device should be registered to

1561

* @class: pointer to the struct class that this device should be registered to

1561

* @parent: pointer to the parent struct device of this new device, if any

1562

* @parent: pointer to the parent struct device of this new device, if any

1562

* @devt: the dev_t for the char device to be added

1563

* @devt: the dev_t for the char device to be added

1563

* @drvdata: the data to be added to the device for callbacks

1564

* @drvdata: the data to be added to the device for callbacks

1564

* @fmt: string for the device's name

1565

* @fmt: string for the device's name

1565

*

1566

*

1566

* This function can be used by char device classes. A struct device

1567

* This function can be used by char device classes. A struct device

1567

* will be created in sysfs, registered to the specified class.

1568

* will be created in sysfs, registered to the specified class.

1568

*

1569

*

1569

* A "dev" file will be created, showing the dev_t for the device, if

1570

* A "dev" file will be created, showing the dev_t for the device, if

1570

* the dev_t is not 0,0.

1571

* the dev_t is not 0,0.

1571

* If a pointer to a parent struct device is passed in, the newly created

1572

* If a pointer to a parent struct device is passed in, the newly created

1572

* struct device will be a child of that device in sysfs.

1573

* struct device will be a child of that device in sysfs.

1573

* The pointer to the struct device will be returned from the call.

1574

* The pointer to the struct device will be returned from the call.

1574

* Any further sysfs files that might be required can be created using this

1575

* Any further sysfs files that might be required can be created using this

1575

* pointer.

1576

* pointer.

1576

*

1577

*

1577

* Returns &struct device pointer on success, or ERR_PTR() on error.

1578

* Returns &struct device pointer on success, or ERR_PTR() on error.

1578

*

1579

*

1579

* Note: the struct class passed to this function must have previously

1580

* Note: the struct class passed to this function must have previously

1580

* been created with a call to class_create().

1581

* been created with a call to class_create().

1581

*/

1582

*/

1582

struct device *device_create(struct class *class, struct device *parent,

1583

struct device *device_create(struct class *class, struct device *parent,

1583

dev_t devt, void *drvdata, const char *fmt, ...)

1584

dev_t devt, void *drvdata, const char *fmt, ...)

1584

{

1585

{

1585

va_list vargs;

1586

va_list vargs;

1586

struct device *dev;

1587

struct device *dev;

1587

1588

va_start(vargs, fmt);

1589

va_start(vargs, fmt);

1589

dev = device_create_vargs(class, parent, devt, drvdata, fmt, vargs);

1590

dev = device_create_vargs(class, parent, devt, drvdata, fmt, vargs);

1590

va_end(vargs);

1591

va_end(vargs);

1591

return dev;

1592

return dev;

1592

}

1593

}

1593

EXPORT_SYMBOL_GPL(device_create);

1594

EXPORT_SYMBOL_GPL(device_create);

1594

1595

static int __match_devt(struct device *dev, void *data)

1596

static int __match_devt(struct device *dev, void *data)

1596

{

1597

{

1597

dev_t *devt = data;

1598

dev_t *devt = data;

1598

1599

return dev->devt == *devt;

1600

return dev->devt == *devt;

1600

}

1601

}

1601

1602

/**

1603

/**

1603

* device_destroy - removes a device that was created with device_create()

1604

* device_destroy - removes a device that was created with device_create()

1604

* @class: pointer to the struct class that this device was registered with

1605

* @class: pointer to the struct class that this device was registered with

1605

* @devt: the dev_t of the device that was previously registered

1606

* @devt: the dev_t of the device that was previously registered

1606

*

1607

*

1607

* This call unregisters and cleans up a device that was created with a

1608

* This call unregisters and cleans up a device that was created with a

1608

* call to device_create().

1609

* call to device_create().

1609

*/

1610

*/

1610

void device_destroy(struct class *class, dev_t devt)

1611

void device_destroy(struct class *class, dev_t devt)

1611

{

1612

{

1612

struct device *dev;

1613

struct device *dev;

1613

1614

dev = class_find_device(class, NULL, &devt, __match_devt);

1615

dev = class_find_device(class, NULL, &devt, __match_devt);

1615

if (dev) {

1616

if (dev) {

1616

put_device(dev);

1617

put_device(dev);

1617

device_unregister(dev);

1618

device_unregister(dev);

1618

}

1619

}

1619

}

1620

}

1620

EXPORT_SYMBOL_GPL(device_destroy);

1621

EXPORT_SYMBOL_GPL(device_destroy);

1621

1622

/**

1623

/**

1623

* device_rename - renames a device

1624

* device_rename - renames a device

1624

* @dev: the pointer to the struct device to be renamed

1625

* @dev: the pointer to the struct device to be renamed

1625

* @new_name: the new name of the device

1626

* @new_name: the new name of the device

1626

*

1627

*

1627

* It is the responsibility of the caller to provide mutual

1628

* It is the responsibility of the caller to provide mutual

1628

* exclusion between two different calls of device_rename

1629

* exclusion between two different calls of device_rename

1629

* on the same device to ensure that new_name is valid and

1630

* on the same device to ensure that new_name is valid and

1630

* won't conflict with other devices.

1631

* won't conflict with other devices.

1631

*

1632

*

1632

* Note: Don't call this function. Currently, the networking layer calls this

1633

* Note: Don't call this function. Currently, the networking layer calls this

1633

* function, but that will change. The following text from Kay Sievers offers

1634

* function, but that will change. The following text from Kay Sievers offers

1634

* some insight:

1635

* some insight:

1635

*

1636

*

1636

* Renaming devices is racy at many levels, symlinks and other stuff are not

1637

* Renaming devices is racy at many levels, symlinks and other stuff are not

1637

* replaced atomically, and you get a "move" uevent, but it's not easy to

1638

* replaced atomically, and you get a "move" uevent, but it's not easy to

1638

* connect the event to the old and new device. Device nodes are not renamed at

1639

* connect the event to the old and new device. Device nodes are not renamed at

1639

* all, there isn't even support for that in the kernel now.

1640

* all, there isn't even support for that in the kernel now.

1640

*

1641

*

1641

* In the meantime, during renaming, your target name might be taken by another

1642

* In the meantime, during renaming, your target name might be taken by another

1642

* driver, creating conflicts. Or the old name is taken directly after you

1643

* driver, creating conflicts. Or the old name is taken directly after you

1643

* renamed it -- then you get events for the same DEVPATH, before you even see

1644

* renamed it -- then you get events for the same DEVPATH, before you even see

1644

* the "move" event. It's just a mess, and nothing new should ever rely on

1645

* the "move" event. It's just a mess, and nothing new should ever rely on

1645

* kernel device renaming. Besides that, it's not even implemented now for

1646

* kernel device renaming. Besides that, it's not even implemented now for

1646

* other things than (driver-core wise very simple) network devices.

1647

* other things than (driver-core wise very simple) network devices.

1647

*

1648

*

1648

* We are currently about to change network renaming in udev to completely

1649

* We are currently about to change network renaming in udev to completely

1649

* disallow renaming of devices in the same namespace as the kernel uses,

1650

* disallow renaming of devices in the same namespace as the kernel uses,

1650

* because we can't solve the problems properly, that arise with swapping names

1651

* because we can't solve the problems properly, that arise with swapping names

1651

* of multiple interfaces without races. Means, renaming of eth[0-9]* will only

1652

* of multiple interfaces without races. Means, renaming of eth[0-9]* will only

1652

* be allowed to some other name than eth[0-9]*, for the aforementioned

1653

* be allowed to some other name than eth[0-9]*, for the aforementioned

1653

* reasons.

1654

* reasons.

1654

*

1655

*

1655

* Make up a "real" name in the driver before you register anything, or add

1656

* Make up a "real" name in the driver before you register anything, or add

1656

* some other attributes for userspace to find the device, or use udev to add

1657

* some other attributes for userspace to find the device, or use udev to add

1657

* symlinks -- but never rename kernel devices later, it's a complete mess. We

1658

* symlinks -- but never rename kernel devices later, it's a complete mess. We

1658

* don't even want to get into that and try to implement the missing pieces in

1659

* don't even want to get into that and try to implement the missing pieces in

1659

* the core. We really have other pieces to fix in the driver core mess. :)

1660

* the core. We really have other pieces to fix in the driver core mess. :)

1660

*/

1661

*/

1661

int device_rename(struct device *dev, const char *new_name)

1662

int device_rename(struct device *dev, const char *new_name)

1662

{

1663

{

1663

char *old_class_name = NULL;

1664

char *old_class_name = NULL;

1664

char *new_class_name = NULL;

1665

char *new_class_name = NULL;

1665

char *old_device_name = NULL;

1666

char *old_device_name = NULL;

1666

int error;

1667

int error;

1667

1668

dev = get_device(dev);

1669

dev = get_device(dev);

1669

if (!dev)

1670

if (!dev)

1670

return -EINVAL;

1671

return -EINVAL;

1671

1672

pr_debug("device: '%s': %s: renaming to '%s'\n", dev_name(dev),

1673

pr_debug("device: '%s': %s: renaming to '%s'\n", dev_name(dev),

1673

__func__, new_name);

1674

__func__, new_name);

1674

1675

old_device_name = kstrdup(dev_name(dev), GFP_KERNEL);

1676

old_device_name = kstrdup(dev_name(dev), GFP_KERNEL);

1676

if (!old_device_name) {

1677

if (!old_device_name) {

1677

error = -ENOMEM;

1678

error = -ENOMEM;

1678

goto out;

1679

goto out;

1679

}

1680

}

1680

1681

if (dev->class) {

1682

if (dev->class) {

1682

error = sysfs_rename_link(&dev->class->p->subsys.kobj,

1683

error = sysfs_rename_link(&dev->class->p->subsys.kobj,

1683

&dev->kobj, old_device_name, new_name);

1684

&dev->kobj, old_device_name, new_name);

1684

if (error)

1685

if (error)

1685

goto out;

1686

goto out;

1686

}

1687

}

1687

1688

error = kobject_rename(&dev->kobj, new_name);

1689

error = kobject_rename(&dev->kobj, new_name);

1689

if (error)

1690

if (error)

1690

goto out;

1691

goto out;

1691

1692

out:

1693

out:

1693

put_device(dev);

1694

put_device(dev);

1694

1695

kfree(new_class_name);

1696

kfree(new_class_name);

1696

kfree(old_class_name);

1697

kfree(old_class_name);

1697

kfree(old_device_name);

1698

kfree(old_device_name);

1698

1699

return error;

1700

return error;

1700

}

1701

}

1701

EXPORT_SYMBOL_GPL(device_rename);

1702

EXPORT_SYMBOL_GPL(device_rename);

1702

1703

static int device_move_class_links(struct device *dev,

1704

static int device_move_class_links(struct device *dev,

1704

struct device *old_parent,

1705

struct device *old_parent,

1705

struct device *new_parent)

1706

struct device *new_parent)

1706

{

1707

{

1707

int error = 0;

1708

int error = 0;

1708

1709

if (old_parent)

1710

if (old_parent)

1710

sysfs_remove_link(&dev->kobj, "device");

1711

sysfs_remove_link(&dev->kobj, "device");

1711

if (new_parent)

1712

if (new_parent)

1712

error = sysfs_create_link(&dev->kobj, &new_parent->kobj,

1713

error = sysfs_create_link(&dev->kobj, &new_parent->kobj,

1713

"device");

1714

"device");

1714

return error;

1715

return error;

1715

}

1716

}

1716

1717

/**

1718

/**

1718

* device_move - moves a device to a new parent

1719

* device_move - moves a device to a new parent

1719

* @dev: the pointer to the struct device to be moved

1720

* @dev: the pointer to the struct device to be moved

1720

* @new_parent: the new parent of the device (can by NULL)

1721

* @new_parent: the new parent of the device (can by NULL)

1721

* @dpm_order: how to reorder the dpm_list

1722

* @dpm_order: how to reorder the dpm_list

1722

*/

1723

*/

1723

int device_move(struct device *dev, struct device *new_parent,

1724

int device_move(struct device *dev, struct device *new_parent,

1724

enum dpm_order dpm_order)

1725

enum dpm_order dpm_order)

1725

{

1726

{

1726

int error;

1727

int error;

1727

struct device *old_parent;

1728

struct device *old_parent;

1728

struct kobject *new_parent_kobj;

1729

struct kobject *new_parent_kobj;

1729

1730

dev = get_device(dev);

1731

dev = get_device(dev);

1731

if (!dev)

1732

if (!dev)

1732

return -EINVAL;

1733

return -EINVAL;

1733

1734

device_pm_lock();

1735

device_pm_lock();

1735

new_parent = get_device(new_parent);

1736

new_parent = get_device(new_parent);

1736

new_parent_kobj = get_device_parent(dev, new_parent);

1737

new_parent_kobj = get_device_parent(dev, new_parent);

1737

1738

pr_debug("device: '%s': %s: moving to '%s'\n", dev_name(dev),

1739

pr_debug("device: '%s': %s: moving to '%s'\n", dev_name(dev),

1739

__func__, new_parent ? dev_name(new_parent) : "<NULL>");

1740

__func__, new_parent ? dev_name(new_parent) : "<NULL>");

1740

error = kobject_move(&dev->kobj, new_parent_kobj);

1741

error = kobject_move(&dev->kobj, new_parent_kobj);

1741

if (error) {

1742

if (error) {

1742

cleanup_glue_dir(dev, new_parent_kobj);

1743

cleanup_glue_dir(dev, new_parent_kobj);

1743

put_device(new_parent);

1744

put_device(new_parent);

1744

goto out;

1745

goto out;

1745

}

1746

}

1746

old_parent = dev->parent;

1747

old_parent = dev->parent;

1747

dev->parent = new_parent;

1748

dev->parent = new_parent;

1748

if (old_parent)

1749

if (old_parent)

1749

klist_remove(&dev->p->knode_parent);

1750

klist_remove(&dev->p->knode_parent);

1750

if (new_parent) {

1751

if (new_parent) {

1751

klist_add_tail(&dev->p->knode_parent,

1752

klist_add_tail(&dev->p->knode_parent,

1752

&new_parent->p->klist_children);

1753

&new_parent->p->klist_children);

1753

set_dev_node(dev, dev_to_node(new_parent));

1754

set_dev_node(dev, dev_to_node(new_parent));

1754

}

1755

}

1755

1756

if (!dev->class)

1757

if (!dev->class)

1757

goto out_put;

1758

goto out_put;

1758

error = device_move_class_links(dev, old_parent, new_parent);

1759

error = device_move_class_links(dev, old_parent, new_parent);

1759

if (error) {

1760

if (error) {

1760

/* We ignore errors on cleanup since we're hosed anyway... */

1761

/* We ignore errors on cleanup since we're hosed anyway... */

1761

device_move_class_links(dev, new_parent, old_parent);

1762

device_move_class_links(dev, new_parent, old_parent);

1762

if (!kobject_move(&dev->kobj, &old_parent->kobj)) {

1763

if (!kobject_move(&dev->kobj, &old_parent->kobj)) {

1763

if (new_parent)

1764

if (new_parent)

1764

klist_remove(&dev->p->knode_parent);

1765

klist_remove(&dev->p->knode_parent);

1765

dev->parent = old_parent;

1766

dev->parent = old_parent;

1766

if (old_parent) {

1767

if (old_parent) {

1767

klist_add_tail(&dev->p->knode_parent,

1768

klist_add_tail(&dev->p->knode_parent,

1768

&old_parent->p->klist_children);

1769

&old_parent->p->klist_children);

1769

set_dev_node(dev, dev_to_node(old_parent));

1770

set_dev_node(dev, dev_to_node(old_parent));

1770

}

1771

}

1771

}

1772

}

1772

cleanup_glue_dir(dev, new_parent_kobj);

1773

cleanup_glue_dir(dev, new_parent_kobj);

1773

put_device(new_parent);

1774

put_device(new_parent);

1774

goto out;

1775

goto out;

1775

}

1776

}

1776

switch (dpm_order) {

1777

switch (dpm_order) {

1777

case DPM_ORDER_NONE:

1778

case DPM_ORDER_NONE:

1778

break;

1779

break;

1779

case DPM_ORDER_DEV_AFTER_PARENT:

1780

case DPM_ORDER_DEV_AFTER_PARENT:

1780

device_pm_move_after(dev, new_parent);

1781

device_pm_move_after(dev, new_parent);

1781

break;

1782

break;

1782

case DPM_ORDER_PARENT_BEFORE_DEV:

1783

case DPM_ORDER_PARENT_BEFORE_DEV:

1783

device_pm_move_before(new_parent, dev);

1784

device_pm_move_before(new_parent, dev);

1784

break;

1785

break;

1785

case DPM_ORDER_DEV_LAST:

1786

case DPM_ORDER_DEV_LAST:

1786

device_pm_move_last(dev);

1787

device_pm_move_last(dev);

1787

break;

1788

break;

1788

}

1789

}

1789

out_put:

1790

out_put:

1790

put_device(old_parent);

1791

put_device(old_parent);

1791

out:

1792

out:

1792

device_pm_unlock();

1793

device_pm_unlock();

1793

put_device(dev);

1794

put_device(dev);

1794

return error;

1795

return error;

1795

}

1796

}

1796

EXPORT_SYMBOL_GPL(device_move);

1797

EXPORT_SYMBOL_GPL(device_move);

1797

1798

/**

1799

/**

1799

* device_shutdown - call ->shutdown() on each device to shutdown.

1800

* device_shutdown - call ->shutdown() on each device to shutdown.

1800

*/

1801

*/

1801

void device_shutdown(void)

1802

void device_shutdown(void)

1802

{

1803

{

1803

struct device *dev;

1804

struct device *dev;

1804

1805

spin_lock(&devices_kset->list_lock);

1806

spin_lock(&devices_kset->list_lock);

1806

/*

1807

/*

1807

* Walk the devices list backward, shutting down each in turn.

1808

* Walk the devices list backward, shutting down each in turn.

1808

* Beware that device unplug events may also start pulling

1809

* Beware that device unplug events may also start pulling

1809

* devices offline, even as the system is shutting down.

1810

* devices offline, even as the system is shutting down.

1810

*/

1811

*/

1811

while (!list_empty(&devices_kset->list)) {

1812

while (!list_empty(&devices_kset->list)) {

1812

dev = list_entry(devices_kset->list.prev, struct device,

1813

dev = list_entry(devices_kset->list.prev, struct device,

1813

kobj.entry);

1814

kobj.entry);

1814

get_device(dev);

1815

get_device(dev);

1815

/*

1816

/*

1816

* Make sure the device is off the kset list, in the

1817

* Make sure the device is off the kset list, in the

1817

* event that dev->*->shutdown() doesn't remove it.

1818

* event that dev->*->shutdown() doesn't remove it.

1818

*/

1819

*/

1819

list_del_init(&dev->kobj.entry);

1820

list_del_init(&dev->kobj.entry);

1820

spin_unlock(&devices_kset->list_lock);

1821

spin_unlock(&devices_kset->list_lock);

1821

1822

/* Don't allow any more runtime suspends */

1823

/* Don't allow any more runtime suspends */

1823

pm_runtime_get_noresume(dev);

1824

pm_runtime_get_noresume(dev);

1824

pm_runtime_barrier(dev);

1825

pm_runtime_barrier(dev);

1825

1826

if (dev->bus && dev->bus->shutdown) {

1827

if (dev->bus && dev->bus->shutdown) {

1827

dev_dbg(dev, "shutdown\n");

1828

dev_dbg(dev, "shutdown\n");

1828

dev->bus->shutdown(dev);

1829

dev->bus->shutdown(dev);

1829

} else if (dev->driver && dev->driver->shutdown) {

1830

} else if (dev->driver && dev->driver->shutdown) {

1830

dev_dbg(dev, "shutdown\n");

1831

dev_dbg(dev, "shutdown\n");

1831

dev->driver->shutdown(dev);

1832

dev->driver->shutdown(dev);

1832

}

1833

}

1833

put_device(dev);

1834

put_device(dev);

1834

1835

spin_lock(&devices_kset->list_lock);

1836

spin_lock(&devices_kset->list_lock);

1836

}

1837

}

1837

spin_unlock(&devices_kset->list_lock);

1838

spin_unlock(&devices_kset->list_lock);

1838

async_synchronize_full();

1839

async_synchronize_full();

1839

}

1840

}

1840

1841

/*

1842

/*

1842

* Device logging functions

1843

* Device logging functions

1843

*/

1844

*/

1844

1845

#ifdef CONFIG_PRINTK

1846

#ifdef CONFIG_PRINTK

1846

1847

int __dev_printk(const char *level, const struct device *dev,

1847

int __dev_printk(const char *level, const struct device *dev,

1848

struct va_format *vaf)

1848

struct va_format *vaf)

1849

{

1849

{

1850

char dict[128];

1851

size_t dictlen = 0;

1852

const char *subsys;

1853

1850

if (!dev)

1854

if (!dev)

1851

return printk("%s(NULL device *): %pV", level, vaf);

1855

return printk("%s(NULL device *): %pV", level, vaf);

1852

1856

1853

return printk("%s%s %s: %pV",

1857

if (dev->class)

1854

level, dev_driver_string(dev), dev_name(dev), vaf);

1858

subsys = dev->class->name;

1859

else if (dev->bus)

1860

subsys = dev->bus->name;

1861

else

1862

goto skip;

1863

1864

dictlen += snprintf(dict + dictlen, sizeof(dict) - dictlen,

1865

"SUBSYSTEM=%s", subsys);

1866

1867

/*

1868

* Add device identifier DEVICE=:

1869

* b12:8 block dev_t

1870

* c127:3 char dev_t

1871

* n8 netdev ifindex

1872

* +sound:card0 subsystem:devname

1873

*/

1874

if (MAJOR(dev->devt)) {

1875

char c;

1876

1877

if (strcmp(subsys, "block") == 0)

1878

c = 'b';

1879

else

1880

c = 'c';

1881

dictlen++;

1882

dictlen += snprintf(dict + dictlen, sizeof(dict) - dictlen,

1883

"DEVICE=%c%u:%u",

1884

c, MAJOR(dev->devt), MINOR(dev->devt));

1885

} else if (strcmp(subsys, "net") == 0) {

1886

struct net_device *net = to_net_dev(dev);

1887

1888

dictlen++;

1889

dictlen += snprintf(dict + dictlen, sizeof(dict) - dictlen,

1890

"DEVICE=n%u", net->ifindex);

1891

} else {

1892

dictlen++;

1893

dictlen += snprintf(dict + dictlen, sizeof(dict) - dictlen,

1894

"DEVICE=+%s:%s", subsys, dev_name(dev));

1895

}

1896

skip:

1897

return printk_emit(0, level[1] - '0',

1898

dictlen ? dict : NULL, dictlen,

1899

"%s %s: %pV",

1900

dev_driver_string(dev), dev_name(dev), vaf);

1855

}

1901

}

1856

EXPORT_SYMBOL(__dev_printk);

1902

EXPORT_SYMBOL(__dev_printk);

1857

1903

1858

int dev_printk(const char *level, const struct device *dev,

1904

int dev_printk(const char *level, const struct device *dev,

1859

const char *fmt, ...)

1905

const char *fmt, ...)

1860

{

1906

{

1861

struct va_format vaf;

1907

struct va_format vaf;

1862

va_list args;

1908

va_list args;

1863

int r;

1909

int r;

1864

1910

1865

va_start(args, fmt);

1911

va_start(args, fmt);

1866

1912

1867

vaf.fmt = fmt;

1913

vaf.fmt = fmt;

1868

vaf.va = &args;

1914

vaf.va = &args;

1869

1915

1870

r = __dev_printk(level, dev, &vaf);

1916

r = __dev_printk(level, dev, &vaf);

1871

va_end(args);

1917

va_end(args);

1872

1918

1873

return r;

1919

return r;

1874

}

1920

}

1875

EXPORT_SYMBOL(dev_printk);

1921

EXPORT_SYMBOL(dev_printk);

1876

1922

1877

#define define_dev_printk_level(func, kern_level) \

1923

#define define_dev_printk_level(func, kern_level) \

1878

int func(const struct device *dev, const char *fmt, ...) \

1924

int func(const struct device *dev, const char *fmt, ...) \

1879

{ \

1925

{ \

1880

struct va_format vaf; \

1926

struct va_format vaf; \

1881

va_list args; \

1927

va_list args; \

1882

int r; \

1928

int r; \

1883

\

1929

\

1884

va_start(args, fmt); \

1930

va_start(args, fmt); \

1885

\

1931

\

1886

vaf.fmt = fmt; \

1932

vaf.fmt = fmt; \

1887

vaf.va = &args; \

1933

vaf.va = &args; \

1888

\

1934

\

1889

r = __dev_printk(kern_level, dev, &vaf); \

1935

r = __dev_printk(kern_level, dev, &vaf); \

1890

va_end(args); \

1936

va_end(args); \

1891

\

1937

\

1892

return r; \

1938

return r; \

1893

} \

1939

} \

1894

EXPORT_SYMBOL(func);

1940

EXPORT_SYMBOL(func);

1895

1941

1896

define_dev_printk_level(dev_emerg, KERN_EMERG);

1942

define_dev_printk_level(dev_emerg, KERN_EMERG);

1897

define_dev_printk_level(dev_alert, KERN_ALERT);

1943

define_dev_printk_level(dev_alert, KERN_ALERT);

1898

define_dev_printk_level(dev_crit, KERN_CRIT);

1944

define_dev_printk_level(dev_crit, KERN_CRIT);

1899

define_dev_printk_level(dev_err, KERN_ERR);

1945

define_dev_printk_level(dev_err, KERN_ERR);

1900

define_dev_printk_level(dev_warn, KERN_WARNING);

1946

define_dev_printk_level(dev_warn, KERN_WARNING);

1901

define_dev_printk_level(dev_notice, KERN_NOTICE);

1947

define_dev_printk_level(dev_notice, KERN_NOTICE);

1902

define_dev_printk_level(_dev_info, KERN_INFO);

1948

define_dev_printk_level(_dev_info, KERN_INFO);

1903

1949

1904

#endif

1950

#endif

GITLAB

driver-core: extend dev_printk() to pass structured data

 /*
  * drivers/base/core.c - core driver model code (device registration, etc)
  *
  * Copyright (c) 2002-3 Patrick Mochel
  * Copyright (c) 2002-3 Open Source Development Labs
  * Copyright (c) 2006 Greg Kroah-Hartman <gregkh@suse.de>
  * Copyright (c) 2006 Novell, Inc.
  *
  * This file is released under the GPLv2
  *
  */
 #include <linux/device.h>
 #include <linux/err.h>
 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/string.h>
 #include <linux/kdev_t.h>
 #include <linux/notifier.h>
 #include <linux/of.h>
 #include <linux/of_device.h>
 #include <linux/genhd.h>
 #include <linux/kallsyms.h>
 #include <linux/mutex.h>
 #include <linux/async.h>
 #include <linux/pm_runtime.h>
+#include <linux/netdevice.h>
 #include "base.h"
 #include "power/power.h"
 #ifdef CONFIG_SYSFS_DEPRECATED
 #ifdef CONFIG_SYSFS_DEPRECATED_V2
 long sysfs_deprecated = 1;
 #else
 long sysfs_deprecated = 0;
 #endif
 static __init int sysfs_deprecated_setup(char *arg)
 {
 	return strict_strtol(arg, 10, &sysfs_deprecated);
 }
 early_param("sysfs.deprecated", sysfs_deprecated_setup);
 #endif
 int (*platform_notify)(struct device *dev) = NULL;
 int (*platform_notify_remove)(struct device *dev) = NULL;
 static struct kobject *dev_kobj;
 struct kobject *sysfs_dev_char_kobj;
 struct kobject *sysfs_dev_block_kobj;
 #ifdef CONFIG_BLOCK
 static inline int device_is_not_partition(struct device *dev)
 {
 	return !(dev->type == &part_type);
 }
 #else
 static inline int device_is_not_partition(struct device *dev)
 {
 	return 1;
 }
 #endif
 /**
  * dev_driver_string - Return a device's driver name, if at all possible
  * @dev: struct device to get the name of
  *
  * Will return the device's driver's name if it is bound to a device.  If
  * the device is not bound to a driver, it will return the name of the bus
  * it is attached to.  If it is not attached to a bus either, an empty
  * string will be returned.
  */
 const char *dev_driver_string(const struct device *dev)
 {
 	struct device_driver *drv;
 	/* dev->driver can change to NULL underneath us because of unbinding,
 	 * so be careful about accessing it.  dev->bus and dev->class should
 	 * never change once they are set, so they don't need special care.
 	 */
 	drv = ACCESS_ONCE(dev->driver);
 	return drv ? drv->name :
 			(dev->bus ? dev->bus->name :
 			(dev->class ? dev->class->name : ""));
 }
 EXPORT_SYMBOL(dev_driver_string);
 #define to_dev(obj) container_of(obj, struct device, kobj)
 #define to_dev_attr(_attr) container_of(_attr, struct device_attribute, attr)
 static ssize_t dev_attr_show(struct kobject *kobj, struct attribute *attr,
 			     char *buf)
 {
 	struct device_attribute *dev_attr = to_dev_attr(attr);
 	struct device *dev = to_dev(kobj);
 	ssize_t ret = -EIO;
 	if (dev_attr->show)
 		ret = dev_attr->show(dev, dev_attr, buf);
 	if (ret >= (ssize_t)PAGE_SIZE) {
 		print_symbol("dev_attr_show: %s returned bad count\n",
 				(unsigned long)dev_attr->show);
 	}
 	return ret;
 }
 static ssize_t dev_attr_store(struct kobject *kobj, struct attribute *attr,
 			      const char *buf, size_t count)
 {
 	struct device_attribute *dev_attr = to_dev_attr(attr);
 	struct device *dev = to_dev(kobj);
 	ssize_t ret = -EIO;
 	if (dev_attr->store)
 		ret = dev_attr->store(dev, dev_attr, buf, count);
 	return ret;
 }
 static const struct sysfs_ops dev_sysfs_ops = {
 	.show	= dev_attr_show,
 	.store	= dev_attr_store,
 };
 #define to_ext_attr(x) container_of(x, struct dev_ext_attribute, attr)
 ssize_t device_store_ulong(struct device *dev,
 			   struct device_attribute *attr,
 			   const char *buf, size_t size)
 {
 	struct dev_ext_attribute *ea = to_ext_attr(attr);
 	char *end;
 	unsigned long new = simple_strtoul(buf, &end, 0);
 	if (end == buf)
 		return -EINVAL;
 	*(unsigned long *)(ea->var) = new;
 	/* Always return full write size even if we didn't consume all */
 	return size;
 }
 EXPORT_SYMBOL_GPL(device_store_ulong);
 ssize_t device_show_ulong(struct device *dev,
 			  struct device_attribute *attr,
 			  char *buf)
 {
 	struct dev_ext_attribute *ea = to_ext_attr(attr);
 	return snprintf(buf, PAGE_SIZE, "%lx\n", *(unsigned long *)(ea->var));
 }
 EXPORT_SYMBOL_GPL(device_show_ulong);
 ssize_t device_store_int(struct device *dev,
 			 struct device_attribute *attr,
 			 const char *buf, size_t size)
 {
 	struct dev_ext_attribute *ea = to_ext_attr(attr);
 	char *end;
 	long new = simple_strtol(buf, &end, 0);
 	if (end == buf || new > INT_MAX || new < INT_MIN)
 		return -EINVAL;
 	*(int *)(ea->var) = new;
 	/* Always return full write size even if we didn't consume all */
 	return size;
 }
 EXPORT_SYMBOL_GPL(device_store_int);
 ssize_t device_show_int(struct device *dev,
 			struct device_attribute *attr,
 			char *buf)
 {
 	struct dev_ext_attribute *ea = to_ext_attr(attr);
 	return snprintf(buf, PAGE_SIZE, "%d\n", *(int *)(ea->var));
 }
 EXPORT_SYMBOL_GPL(device_show_int);
 /**
  *	device_release - free device structure.
  *	@kobj:	device's kobject.
  *
  *	This is called once the reference count for the object
  *	reaches 0. We forward the call to the device's release
  *	method, which should handle actually freeing the structure.
  */
 static void device_release(struct kobject *kobj)
 {
 	struct device *dev = to_dev(kobj);
 	struct device_private *p = dev->p;
 	if (dev->release)
 		dev->release(dev);
 	else if (dev->type && dev->type->release)
 		dev->type->release(dev);
 	else if (dev->class && dev->class->dev_release)
 		dev->class->dev_release(dev);
 	else
 		WARN(1, KERN_ERR "Device '%s' does not have a release() "
 			"function, it is broken and must be fixed.\n",
 			dev_name(dev));
 	kfree(p);
 }
 static const void *device_namespace(struct kobject *kobj)
 {
 	struct device *dev = to_dev(kobj);
 	const void *ns = NULL;
 	if (dev->class && dev->class->ns_type)
 		ns = dev->class->namespace(dev);
 	return ns;
 }
 static struct kobj_type device_ktype = {
 	.release	= device_release,
 	.sysfs_ops	= &dev_sysfs_ops,
 	.namespace	= device_namespace,
 };
 static int dev_uevent_filter(struct kset *kset, struct kobject *kobj)
 {
 	struct kobj_type *ktype = get_ktype(kobj);
 	if (ktype == &device_ktype) {
 		struct device *dev = to_dev(kobj);
 		if (dev->bus)
 			return 1;
 		if (dev->class)
 			return 1;
 	}
 	return 0;
 }
 static const char *dev_uevent_name(struct kset *kset, struct kobject *kobj)
 {
 	struct device *dev = to_dev(kobj);
 	if (dev->bus)
 		return dev->bus->name;
 	if (dev->class)
 		return dev->class->name;
 	return NULL;
 }
 static int dev_uevent(struct kset *kset, struct kobject *kobj,
 		      struct kobj_uevent_env *env)
 {
 	struct device *dev = to_dev(kobj);
 	int retval = 0;
 	/* add device node properties if present */
 	if (MAJOR(dev->devt)) {
 		const char *tmp;
 		const char *name;
 		umode_t mode = 0;
 		add_uevent_var(env, "MAJOR=%u", MAJOR(dev->devt));
 		add_uevent_var(env, "MINOR=%u", MINOR(dev->devt));
 		name = device_get_devnode(dev, &mode, &tmp);
 		if (name) {
 			add_uevent_var(env, "DEVNAME=%s", name);
 			kfree(tmp);
 			if (mode)
 				add_uevent_var(env, "DEVMODE=%#o", mode & 0777);
 		}
 	}
 	if (dev->type && dev->type->name)
 		add_uevent_var(env, "DEVTYPE=%s", dev->type->name);
 	if (dev->driver)
 		add_uevent_var(env, "DRIVER=%s", dev->driver->name);
 	/* Add common DT information about the device */
 	of_device_uevent(dev, env);
 	/* have the bus specific function add its stuff */
 	if (dev->bus && dev->bus->uevent) {
 		retval = dev->bus->uevent(dev, env);
 		if (retval)
 			pr_debug("device: '%s': %s: bus uevent() returned %d\n",
 				 dev_name(dev), __func__, retval);
 	}
 	/* have the class specific function add its stuff */
 	if (dev->class && dev->class->dev_uevent) {
 		retval = dev->class->dev_uevent(dev, env);
 		if (retval)
 			pr_debug("device: '%s': %s: class uevent() "
 				 "returned %d\n", dev_name(dev),
 				 __func__, retval);
 	}
 	/* have the device type specific function add its stuff */
 	if (dev->type && dev->type->uevent) {
 		retval = dev->type->uevent(dev, env);
 		if (retval)
 			pr_debug("device: '%s': %s: dev_type uevent() "
 				 "returned %d\n", dev_name(dev),
 				 __func__, retval);
 	}
 	return retval;
 }
 static const struct kset_uevent_ops device_uevent_ops = {
 	.filter =	dev_uevent_filter,
 	.name =		dev_uevent_name,
 	.uevent =	dev_uevent,
 };
 static ssize_t show_uevent(struct device *dev, struct device_attribute *attr,
 			   char *buf)
 {
 	struct kobject *top_kobj;
 	struct kset *kset;
 	struct kobj_uevent_env *env = NULL;
 	int i;
 	size_t count = 0;
 	int retval;
 	/* search the kset, the device belongs to */
 	top_kobj = &dev->kobj;
 	while (!top_kobj->kset && top_kobj->parent)
 		top_kobj = top_kobj->parent;
 	if (!top_kobj->kset)
 		goto out;
 	kset = top_kobj->kset;
 	if (!kset->uevent_ops || !kset->uevent_ops->uevent)
 		goto out;
 	/* respect filter */
 	if (kset->uevent_ops && kset->uevent_ops->filter)
 		if (!kset->uevent_ops->filter(kset, &dev->kobj))
 			goto out;
 	env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL);
 	if (!env)
 		return -ENOMEM;
 	/* let the kset specific function add its keys */
 	retval = kset->uevent_ops->uevent(kset, &dev->kobj, env);
 	if (retval)
 		goto out;
 	/* copy keys to file */
 	for (i = 0; i < env->envp_idx; i++)
 		count += sprintf(&buf[count], "%s\n", env->envp[i]);
 out:
 	kfree(env);
 	return count;
 }
 static ssize_t store_uevent(struct device *dev, struct device_attribute *attr,
 			    const char *buf, size_t count)
 {
 	enum kobject_action action;
 	if (kobject_action_type(buf, count, &action) == 0)
 		kobject_uevent(&dev->kobj, action);
 	else
 		dev_err(dev, "uevent: unknown action-string\n");
 	return count;
 }
 static struct device_attribute uevent_attr =
 	__ATTR(uevent, S_IRUGO | S_IWUSR, show_uevent, store_uevent);
 static int device_add_attributes(struct device *dev,
 				 struct device_attribute *attrs)
 {
 	int error = 0;
 	int i;
 	if (attrs) {
 		for (i = 0; attr_name(attrs[i]); i++) {
 			error = device_create_file(dev, &attrs[i]);
 			if (error)
 				break;
 		}
 		if (error)
 			while (--i >= 0)
 				device_remove_file(dev, &attrs[i]);
 	}
 	return error;
 }
 static void device_remove_attributes(struct device *dev,
 				     struct device_attribute *attrs)
 {
 	int i;
 	if (attrs)
 		for (i = 0; attr_name(attrs[i]); i++)
 			device_remove_file(dev, &attrs[i]);
 }
 static int device_add_bin_attributes(struct device *dev,
 				     struct bin_attribute *attrs)
 {
 	int error = 0;
 	int i;
 	if (attrs) {
 		for (i = 0; attr_name(attrs[i]); i++) {
 			error = device_create_bin_file(dev, &attrs[i]);
 			if (error)
 				break;
 		}
 		if (error)
 			while (--i >= 0)
 				device_remove_bin_file(dev, &attrs[i]);
 	}
 	return error;
 }
 static void device_remove_bin_attributes(struct device *dev,
 					 struct bin_attribute *attrs)
 {
 	int i;
 	if (attrs)
 		for (i = 0; attr_name(attrs[i]); i++)
 			device_remove_bin_file(dev, &attrs[i]);
 }
 static int device_add_groups(struct device *dev,
 			     const struct attribute_group **groups)
 {
 	int error = 0;
 	int i;
 	if (groups) {
 		for (i = 0; groups[i]; i++) {
 			error = sysfs_create_group(&dev->kobj, groups[i]);
 			if (error) {
 				while (--i >= 0)
 					sysfs_remove_group(&dev->kobj,
 							   groups[i]);
 				break;
 			}
 		}
 	}
 	return error;
 }
 static void device_remove_groups(struct device *dev,
 				 const struct attribute_group **groups)
 {
 	int i;
 	if (groups)
 		for (i = 0; groups[i]; i++)
 			sysfs_remove_group(&dev->kobj, groups[i]);
 }
 static int device_add_attrs(struct device *dev)
 {
 	struct class *class = dev->class;
 	const struct device_type *type = dev->type;
 	int error;
 	if (class) {
 		error = device_add_attributes(dev, class->dev_attrs);
 		if (error)
 			return error;
 		error = device_add_bin_attributes(dev, class->dev_bin_attrs);
 		if (error)
 			goto err_remove_class_attrs;
 	}
 	if (type) {
 		error = device_add_groups(dev, type->groups);
 		if (error)
 			goto err_remove_class_bin_attrs;
 	}
 	error = device_add_groups(dev, dev->groups);
 	if (error)
 		goto err_remove_type_groups;
 	return 0;
  err_remove_type_groups:
 	if (type)
 		device_remove_groups(dev, type->groups);
  err_remove_class_bin_attrs:
 	if (class)
 		device_remove_bin_attributes(dev, class->dev_bin_attrs);
  err_remove_class_attrs:
 	if (class)
 		device_remove_attributes(dev, class->dev_attrs);
 	return error;
 }
 static void device_remove_attrs(struct device *dev)
 {
 	struct class *class = dev->class;
 	const struct device_type *type = dev->type;
 	device_remove_groups(dev, dev->groups);
 	if (type)
 		device_remove_groups(dev, type->groups);
 	if (class) {
 		device_remove_attributes(dev, class->dev_attrs);
 		device_remove_bin_attributes(dev, class->dev_bin_attrs);
 	}
 }
 static ssize_t show_dev(struct device *dev, struct device_attribute *attr,
 			char *buf)
 {
 	return print_dev_t(buf, dev->devt);
 }
 static struct device_attribute devt_attr =
 	__ATTR(dev, S_IRUGO, show_dev, NULL);
 /* /sys/devices/ */
 struct kset *devices_kset;
 /**
  * device_create_file - create sysfs attribute file for device.
  * @dev: device.
  * @attr: device attribute descriptor.
  */
 int device_create_file(struct device *dev,
 		       const struct device_attribute *attr)
 {
 	int error = 0;
 	if (dev)
 		error = sysfs_create_file(&dev->kobj, &attr->attr);
 	return error;
 }
 /**
  * device_remove_file - remove sysfs attribute file.
  * @dev: device.
  * @attr: device attribute descriptor.
  */
 void device_remove_file(struct device *dev,
 			const struct device_attribute *attr)
 {
 	if (dev)
 		sysfs_remove_file(&dev->kobj, &attr->attr);
 }
 /**
  * device_create_bin_file - create sysfs binary attribute file for device.
  * @dev: device.
  * @attr: device binary attribute descriptor.
  */
 int device_create_bin_file(struct device *dev,
 			   const struct bin_attribute *attr)
 {
 	int error = -EINVAL;
 	if (dev)
 		error = sysfs_create_bin_file(&dev->kobj, attr);
 	return error;
 }
 EXPORT_SYMBOL_GPL(device_create_bin_file);
 /**
  * device_remove_bin_file - remove sysfs binary attribute file
  * @dev: device.
  * @attr: device binary attribute descriptor.
  */
 void device_remove_bin_file(struct device *dev,
 			    const struct bin_attribute *attr)
 {
 	if (dev)
 		sysfs_remove_bin_file(&dev->kobj, attr);
 }
 EXPORT_SYMBOL_GPL(device_remove_bin_file);
 /**
  * device_schedule_callback_owner - helper to schedule a callback for a device
  * @dev: device.
  * @func: callback function to invoke later.
  * @owner: module owning the callback routine
  *
  * Attribute methods must not unregister themselves or their parent device
  * (which would amount to the same thing).  Attempts to do so will deadlock,
  * since unregistration is mutually exclusive with driver callbacks.
  *
  * Instead methods can call this routine, which will attempt to allocate
  * and schedule a workqueue request to call back @func with @dev as its
  * argument in the workqueue's process context.  @dev will be pinned until
  * @func returns.
  *
  * This routine is usually called via the inline device_schedule_callback(),
  * which automatically sets @owner to THIS_MODULE.
  *
  * Returns 0 if the request was submitted, -ENOMEM if storage could not
  * be allocated, -ENODEV if a reference to @owner isn't available.
  *
  * NOTE: This routine won't work if CONFIG_SYSFS isn't set!  It uses an
  * underlying sysfs routine (since it is intended for use by attribute
  * methods), and if sysfs isn't available you'll get nothing but -ENOSYS.
  */
 int device_schedule_callback_owner(struct device *dev,
 		void (*func)(struct device *), struct module *owner)
 {
 	return sysfs_schedule_callback(&dev->kobj,
 			(void (*)(void *)) func, dev, owner);
 }
 EXPORT_SYMBOL_GPL(device_schedule_callback_owner);
 static void klist_children_get(struct klist_node *n)
 {
 	struct device_private *p = to_device_private_parent(n);
 	struct device *dev = p->device;
 	get_device(dev);
 }
 static void klist_children_put(struct klist_node *n)
 {
 	struct device_private *p = to_device_private_parent(n);
 	struct device *dev = p->device;
 	put_device(dev);
 }
 /**
  * device_initialize - init device structure.
  * @dev: device.
  *
  * This prepares the device for use by other layers by initializing
  * its fields.
  * It is the first half of device_register(), if called by
  * that function, though it can also be called separately, so one
  * may use @dev's fields. In particular, get_device()/put_device()
  * may be used for reference counting of @dev after calling this
  * function.
  *
  * All fields in @dev must be initialized by the caller to 0, except
  * for those explicitly set to some other value.  The simplest
  * approach is to use kzalloc() to allocate the structure containing
  * @dev.
  *
  * NOTE: Use put_device() to give up your reference instead of freeing
  * @dev directly once you have called this function.
  */
 void device_initialize(struct device *dev)
 {
 	dev->kobj.kset = devices_kset;
 	kobject_init(&dev->kobj, &device_ktype);
 	INIT_LIST_HEAD(&dev->dma_pools);
 	mutex_init(&dev->mutex);
 	lockdep_set_novalidate_class(&dev->mutex);
 	spin_lock_init(&dev->devres_lock);
 	INIT_LIST_HEAD(&dev->devres_head);
 	device_pm_init(dev);
 	set_dev_node(dev, -1);
 }
 static struct kobject *virtual_device_parent(struct device *dev)
 {
 	static struct kobject *virtual_dir = NULL;
 	if (!virtual_dir)
 		virtual_dir = kobject_create_and_add("virtual",
 						     &devices_kset->kobj);
 	return virtual_dir;
 }
 struct class_dir {
 	struct kobject kobj;
 	struct class *class;
 };
 #define to_class_dir(obj) container_of(obj, struct class_dir, kobj)
 static void class_dir_release(struct kobject *kobj)
 {
 	struct class_dir *dir = to_class_dir(kobj);
 	kfree(dir);
 }
 static const
 struct kobj_ns_type_operations *class_dir_child_ns_type(struct kobject *kobj)
 {
 	struct class_dir *dir = to_class_dir(kobj);
 	return dir->class->ns_type;
 }
 static struct kobj_type class_dir_ktype = {
 	.release	= class_dir_release,
 	.sysfs_ops	= &kobj_sysfs_ops,
 	.child_ns_type	= class_dir_child_ns_type
 };
 static struct kobject *
 class_dir_create_and_add(struct class *class, struct kobject *parent_kobj)
 {
 	struct class_dir *dir;
 	int retval;
 	dir = kzalloc(sizeof(*dir), GFP_KERNEL);
 	if (!dir)
 		return NULL;
 	dir->class = class;
 	kobject_init(&dir->kobj, &class_dir_ktype);
 	dir->kobj.kset = &class->p->glue_dirs;
 	retval = kobject_add(&dir->kobj, parent_kobj, "%s", class->name);
 	if (retval < 0) {
 		kobject_put(&dir->kobj);
 		return NULL;
 	}
 	return &dir->kobj;
 }
 static struct kobject *get_device_parent(struct device *dev,
 					 struct device *parent)
 {
 	if (dev->class) {
 		static DEFINE_MUTEX(gdp_mutex);
 		struct kobject *kobj = NULL;
 		struct kobject *parent_kobj;
 		struct kobject *k;
 #ifdef CONFIG_BLOCK
 		/* block disks show up in /sys/block */
 		if (sysfs_deprecated && dev->class == &block_class) {
 			if (parent && parent->class == &block_class)
 				return &parent->kobj;
 			return &block_class.p->subsys.kobj;
 		}
 #endif
 		/*
 		 * If we have no parent, we live in "virtual".
 		 * Class-devices with a non class-device as parent, live
 		 * in a "glue" directory to prevent namespace collisions.
 		 */
 		if (parent == NULL)
 			parent_kobj = virtual_device_parent(dev);
 		else if (parent->class && !dev->class->ns_type)
 			return &parent->kobj;
 		else
 			parent_kobj = &parent->kobj;
 		mutex_lock(&gdp_mutex);
 		/* find our class-directory at the parent and reference it */
 		spin_lock(&dev->class->p->glue_dirs.list_lock);
 		list_for_each_entry(k, &dev->class->p->glue_dirs.list, entry)
 			if (k->parent == parent_kobj) {
 				kobj = kobject_get(k);
 				break;
 			}
 		spin_unlock(&dev->class->p->glue_dirs.list_lock);
 		if (kobj) {
 			mutex_unlock(&gdp_mutex);
 			return kobj;
 		}
 		/* or create a new class-directory at the parent device */
 		k = class_dir_create_and_add(dev->class, parent_kobj);
 		/* do not emit an uevent for this simple "glue" directory */
 		mutex_unlock(&gdp_mutex);
 		return k;
 	}
 	/* subsystems can specify a default root directory for their devices */
 	if (!parent && dev->bus && dev->bus->dev_root)
 		return &dev->bus->dev_root->kobj;
 	if (parent)
 		return &parent->kobj;
 	return NULL;
 }
 static void cleanup_glue_dir(struct device *dev, struct kobject *glue_dir)
 {
 	/* see if we live in a "glue" directory */
 	if (!glue_dir || !dev->class ||
 	    glue_dir->kset != &dev->class->p->glue_dirs)
 		return;
 	kobject_put(glue_dir);
 }
 static void cleanup_device_parent(struct device *dev)
 {
 	cleanup_glue_dir(dev, dev->kobj.parent);
 }
 static int device_add_class_symlinks(struct device *dev)
 {
 	int error;
 	if (!dev->class)
 		return 0;
 	error = sysfs_create_link(&dev->kobj,
 				  &dev->class->p->subsys.kobj,
 				  "subsystem");
 	if (error)
 		goto out;
 	if (dev->parent && device_is_not_partition(dev)) {
 		error = sysfs_create_link(&dev->kobj, &dev->parent->kobj,
 					  "device");
 		if (error)
 			goto out_subsys;
 	}
 #ifdef CONFIG_BLOCK
 	/* /sys/block has directories and does not need symlinks */
 	if (sysfs_deprecated && dev->class == &block_class)
 		return 0;
 #endif
 	/* link in the class directory pointing to the device */
 	error = sysfs_create_link(&dev->class->p->subsys.kobj,
 				  &dev->kobj, dev_name(dev));
 	if (error)
 		goto out_device;
 	return 0;
 out_device:
 	sysfs_remove_link(&dev->kobj, "device");
 out_subsys:
 	sysfs_remove_link(&dev->kobj, "subsystem");
 out:
 	return error;
 }
 static void device_remove_class_symlinks(struct device *dev)
 {
 	if (!dev->class)
 		return;
 	if (dev->parent && device_is_not_partition(dev))
 		sysfs_remove_link(&dev->kobj, "device");
 	sysfs_remove_link(&dev->kobj, "subsystem");
 #ifdef CONFIG_BLOCK
 	if (sysfs_deprecated && dev->class == &block_class)
 		return;
 #endif
 	sysfs_delete_link(&dev->class->p->subsys.kobj, &dev->kobj, dev_name(dev));
 }
 /**
  * dev_set_name - set a device name
  * @dev: device
  * @fmt: format string for the device's name
  */
 int dev_set_name(struct device *dev, const char *fmt, ...)
 {
 	va_list vargs;
 	int err;
 	va_start(vargs, fmt);
 	err = kobject_set_name_vargs(&dev->kobj, fmt, vargs);
 	va_end(vargs);
 	return err;
 }
 EXPORT_SYMBOL_GPL(dev_set_name);
 /**
  * device_to_dev_kobj - select a /sys/dev/ directory for the device
  * @dev: device
  *
  * By default we select char/ for new entries.  Setting class->dev_obj
  * to NULL prevents an entry from being created.  class->dev_kobj must
  * be set (or cleared) before any devices are registered to the class
  * otherwise device_create_sys_dev_entry() and
  * device_remove_sys_dev_entry() will disagree about the presence of
  * the link.
  */
 static struct kobject *device_to_dev_kobj(struct device *dev)
 {
 	struct kobject *kobj;
 	if (dev->class)
 		kobj = dev->class->dev_kobj;
 	else
 		kobj = sysfs_dev_char_kobj;
 	return kobj;
 }
 static int device_create_sys_dev_entry(struct device *dev)
 {
 	struct kobject *kobj = device_to_dev_kobj(dev);
 	int error = 0;
 	char devt_str[15];
 	if (kobj) {
 		format_dev_t(devt_str, dev->devt);
 		error = sysfs_create_link(kobj, &dev->kobj, devt_str);
 	}
 	return error;
 }
 static void device_remove_sys_dev_entry(struct device *dev)
 {
 	struct kobject *kobj = device_to_dev_kobj(dev);
 	char devt_str[15];
 	if (kobj) {
 		format_dev_t(devt_str, dev->devt);
 		sysfs_remove_link(kobj, devt_str);
 	}
 }
 int device_private_init(struct device *dev)
 {
 	dev->p = kzalloc(sizeof(*dev->p), GFP_KERNEL);
 	if (!dev->p)
 		return -ENOMEM;
 	dev->p->device = dev;
 	klist_init(&dev->p->klist_children, klist_children_get,
 		   klist_children_put);
 	INIT_LIST_HEAD(&dev->p->deferred_probe);
 	return 0;
 }
 /**
  * device_add - add device to device hierarchy.
  * @dev: device.
  *
  * This is part 2 of device_register(), though may be called
  * separately _iff_ device_initialize() has been called separately.
  *
  * This adds @dev to the kobject hierarchy via kobject_add(), adds it
  * to the global and sibling lists for the device, then
  * adds it to the other relevant subsystems of the driver model.
  *
  * Do not call this routine or device_register() more than once for
  * any device structure.  The driver model core is not designed to work
  * with devices that get unregistered and then spring back to life.
  * (Among other things, it's very hard to guarantee that all references
  * to the previous incarnation of @dev have been dropped.)  Allocate
  * and register a fresh new struct device instead.
  *
  * NOTE: _Never_ directly free @dev after calling this function, even
  * if it returned an error! Always use put_device() to give up your
  * reference instead.
  */
 int device_add(struct device *dev)
 {
 	struct device *parent = NULL;
 	struct kobject *kobj;
 	struct class_interface *class_intf;
 	int error = -EINVAL;
 	dev = get_device(dev);
 	if (!dev)
 		goto done;
 	if (!dev->p) {
 		error = device_private_init(dev);
 		if (error)
 			goto done;
 	}
 	/*
 	 * for statically allocated devices, which should all be converted
 	 * some day, we need to initialize the name. We prevent reading back
 	 * the name, and force the use of dev_name()
 	 */
 	if (dev->init_name) {
 		dev_set_name(dev, "%s", dev->init_name);
 		dev->init_name = NULL;
 	}
 	/* subsystems can specify simple device enumeration */
 	if (!dev_name(dev) && dev->bus && dev->bus->dev_name)
 		dev_set_name(dev, "%s%u", dev->bus->dev_name, dev->id);
 	if (!dev_name(dev)) {
 		error = -EINVAL;
 		goto name_error;
 	}
 	pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
 	parent = get_device(dev->parent);
 	kobj = get_device_parent(dev, parent);
 	if (kobj)
 		dev->kobj.parent = kobj;
 	/* use parent numa_node */
 	if (parent)
 		set_dev_node(dev, dev_to_node(parent));
 	/* first, register with generic layer. */
 	/* we require the name to be set before, and pass NULL */
 	error = kobject_add(&dev->kobj, dev->kobj.parent, NULL);
 	if (error)
 		goto Error;
 	/* notify platform of device entry */
 	if (platform_notify)
 		platform_notify(dev);
 	error = device_create_file(dev, &uevent_attr);
 	if (error)
 		goto attrError;
 	if (MAJOR(dev->devt)) {
 		error = device_create_file(dev, &devt_attr);
 		if (error)
 			goto ueventattrError;
 		error = device_create_sys_dev_entry(dev);
 		if (error)
 			goto devtattrError;
 		devtmpfs_create_node(dev);
 	}
 	error = device_add_class_symlinks(dev);
 	if (error)
 		goto SymlinkError;
 	error = device_add_attrs(dev);
 	if (error)
 		goto AttrsError;
 	error = bus_add_device(dev);
 	if (error)
 		goto BusError;
 	error = dpm_sysfs_add(dev);
 	if (error)
 		goto DPMError;
 	device_pm_add(dev);
 	/* Notify clients of device addition.  This call must come
 	 * after dpm_sysfs_add() and before kobject_uevent().
 	 */
 	if (dev->bus)
 		blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
 					     BUS_NOTIFY_ADD_DEVICE, dev);
 	kobject_uevent(&dev->kobj, KOBJ_ADD);
 	bus_probe_device(dev);
 	if (parent)
 		klist_add_tail(&dev->p->knode_parent,
 			       &parent->p->klist_children);
 	if (dev->class) {
 		mutex_lock(&dev->class->p->mutex);
 		/* tie the class to the device */
 		klist_add_tail(&dev->knode_class,
 			       &dev->class->p->klist_devices);
 		/* notify any interfaces that the device is here */
 		list_for_each_entry(class_intf,
 				    &dev->class->p->interfaces, node)
 			if (class_intf->add_dev)
 				class_intf->add_dev(dev, class_intf);
 		mutex_unlock(&dev->class->p->mutex);
 	}
 done:
 	put_device(dev);
 	return error;
  DPMError:
 	bus_remove_device(dev);
  BusError:
 	device_remove_attrs(dev);
  AttrsError:
 	device_remove_class_symlinks(dev);
  SymlinkError:
 	if (MAJOR(dev->devt))
 		devtmpfs_delete_node(dev);
 	if (MAJOR(dev->devt))
 		device_remove_sys_dev_entry(dev);
  devtattrError:
 	if (MAJOR(dev->devt))
 		device_remove_file(dev, &devt_attr);
  ueventattrError:
 	device_remove_file(dev, &uevent_attr);
  attrError:
 	kobject_uevent(&dev->kobj, KOBJ_REMOVE);
 	kobject_del(&dev->kobj);
  Error:
 	cleanup_device_parent(dev);
 	if (parent)
 		put_device(parent);
 name_error:
 	kfree(dev->p);
 	dev->p = NULL;
 	goto done;
 }
 /**
  * device_register - register a device with the system.
  * @dev: pointer to the device structure
  *
  * This happens in two clean steps - initialize the device
  * and add it to the system. The two steps can be called
  * separately, but this is the easiest and most common.
  * I.e. you should only call the two helpers separately if
  * have a clearly defined need to use and refcount the device
  * before it is added to the hierarchy.
  *
  * For more information, see the kerneldoc for device_initialize()
  * and device_add().
  *
  * NOTE: _Never_ directly free @dev after calling this function, even
  * if it returned an error! Always use put_device() to give up the
  * reference initialized in this function instead.
  */
 int device_register(struct device *dev)
 {
 	device_initialize(dev);
 	return device_add(dev);
 }
 /**
  * get_device - increment reference count for device.
  * @dev: device.
  *
  * This simply forwards the call to kobject_get(), though
  * we do take care to provide for the case that we get a NULL
  * pointer passed in.
  */
 struct device *get_device(struct device *dev)
 {
 	return dev ? to_dev(kobject_get(&dev->kobj)) : NULL;
 }
 /**
  * put_device - decrement reference count.
  * @dev: device in question.
  */
 void put_device(struct device *dev)
 {
 	/* might_sleep(); */
 	if (dev)
 		kobject_put(&dev->kobj);
 }
 /**
  * device_del - delete device from system.
  * @dev: device.
  *
  * This is the first part of the device unregistration
  * sequence. This removes the device from the lists we control
  * from here, has it removed from the other driver model
  * subsystems it was added to in device_add(), and removes it
  * from the kobject hierarchy.
  *
  * NOTE: this should be called manually _iff_ device_add() was
  * also called manually.
  */
 void device_del(struct device *dev)
 {
 	struct device *parent = dev->parent;
 	struct class_interface *class_intf;
 	/* Notify clients of device removal.  This call must come
 	 * before dpm_sysfs_remove().
 	 */
 	if (dev->bus)
 		blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
 					     BUS_NOTIFY_DEL_DEVICE, dev);
 	device_pm_remove(dev);
 	dpm_sysfs_remove(dev);
 	if (parent)
 		klist_del(&dev->p->knode_parent);
 	if (MAJOR(dev->devt)) {
 		devtmpfs_delete_node(dev);
 		device_remove_sys_dev_entry(dev);
 		device_remove_file(dev, &devt_attr);
 	}
 	if (dev->class) {
 		device_remove_class_symlinks(dev);
 		mutex_lock(&dev->class->p->mutex);
 		/* notify any interfaces that the device is now gone */
 		list_for_each_entry(class_intf,
 				    &dev->class->p->interfaces, node)
 			if (class_intf->remove_dev)
 				class_intf->remove_dev(dev, class_intf);
 		/* remove the device from the class list */
 		klist_del(&dev->knode_class);
 		mutex_unlock(&dev->class->p->mutex);
 	}
 	device_remove_file(dev, &uevent_attr);
 	device_remove_attrs(dev);
 	bus_remove_device(dev);
 	driver_deferred_probe_del(dev);
 	/*
 	 * Some platform devices are driven without driver attached
 	 * and managed resources may have been acquired.  Make sure
 	 * all resources are released.
 	 */
 	devres_release_all(dev);
 	/* Notify the platform of the removal, in case they
 	 * need to do anything...
 	 */
 	if (platform_notify_remove)
 		platform_notify_remove(dev);
 	kobject_uevent(&dev->kobj, KOBJ_REMOVE);
 	cleanup_device_parent(dev);
 	kobject_del(&dev->kobj);
 	put_device(parent);
 }
 /**
  * device_unregister - unregister device from system.
  * @dev: device going away.
  *
  * We do this in two parts, like we do device_register(). First,
  * we remove it from all the subsystems with device_del(), then
  * we decrement the reference count via put_device(). If that
  * is the final reference count, the device will be cleaned up
  * via device_release() above. Otherwise, the structure will
  * stick around until the final reference to the device is dropped.
  */
 void device_unregister(struct device *dev)
 {
 	pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
 	device_del(dev);
 	put_device(dev);
 }
 static struct device *next_device(struct klist_iter *i)
 {
 	struct klist_node *n = klist_next(i);
 	struct device *dev = NULL;
 	struct device_private *p;
 	if (n) {
 		p = to_device_private_parent(n);
 		dev = p->device;
 	}
 	return dev;
 }
 /**
  * device_get_devnode - path of device node file
  * @dev: device
  * @mode: returned file access mode
  * @tmp: possibly allocated string
  *
  * Return the relative path of a possible device node.
  * Non-default names may need to allocate a memory to compose
  * a name. This memory is returned in tmp and needs to be
  * freed by the caller.
  */
 const char *device_get_devnode(struct device *dev,
 			       umode_t *mode, const char **tmp)
 {
 	char *s;
 	*tmp = NULL;
 	/* the device type may provide a specific name */
 	if (dev->type && dev->type->devnode)
 		*tmp = dev->type->devnode(dev, mode);
 	if (*tmp)
 		return *tmp;
 	/* the class may provide a specific name */
 	if (dev->class && dev->class->devnode)
 		*tmp = dev->class->devnode(dev, mode);
 	if (*tmp)
 		return *tmp;
 	/* return name without allocation, tmp == NULL */
 	if (strchr(dev_name(dev), '!') == NULL)
 		return dev_name(dev);
 	/* replace '!' in the name with '/' */
 	*tmp = kstrdup(dev_name(dev), GFP_KERNEL);
 	if (!*tmp)
 		return NULL;
 	while ((s = strchr(*tmp, '!')))
 		s[0] = '/';
 	return *tmp;
 }
 /**
  * device_for_each_child - device child iterator.
  * @parent: parent struct device.
  * @data: data for the callback.
  * @fn: function to be called for each device.
  *
  * Iterate over @parent's child devices, and call @fn for each,
  * passing it @data.
  *
  * We check the return of @fn each time. If it returns anything
  * other than 0, we break out and return that value.
  */
 int device_for_each_child(struct device *parent, void *data,
 			  int (*fn)(struct device *dev, void *data))
 {
 	struct klist_iter i;
 	struct device *child;
 	int error = 0;
 	if (!parent->p)
 		return 0;
 	klist_iter_init(&parent->p->klist_children, &i);
 	while ((child = next_device(&i)) && !error)
 		error = fn(child, data);
 	klist_iter_exit(&i);
 	return error;
 }
 /**
  * device_find_child - device iterator for locating a particular device.
  * @parent: parent struct device
  * @data: Data to pass to match function
  * @match: Callback function to check device
  *
  * This is similar to the device_for_each_child() function above, but it
  * returns a reference to a device that is 'found' for later use, as
  * determined by the @match callback.
  *
  * The callback should return 0 if the device doesn't match and non-zero
  * if it does.  If the callback returns non-zero and a reference to the
  * current device can be obtained, this function will return to the caller
  * and not iterate over any more devices.
  */
 struct device *device_find_child(struct device *parent, void *data,
 				 int (*match)(struct device *dev, void *data))
 {
 	struct klist_iter i;
 	struct device *child;
 	if (!parent)
 		return NULL;
 	klist_iter_init(&parent->p->klist_children, &i);
 	while ((child = next_device(&i)))
 		if (match(child, data) && get_device(child))
 			break;
 	klist_iter_exit(&i);
 	return child;
 }
 int __init devices_init(void)
 {
 	devices_kset = kset_create_and_add("devices", &device_uevent_ops, NULL);
 	if (!devices_kset)
 		return -ENOMEM;
 	dev_kobj = kobject_create_and_add("dev", NULL);
 	if (!dev_kobj)
 		goto dev_kobj_err;
 	sysfs_dev_block_kobj = kobject_create_and_add("block", dev_kobj);
 	if (!sysfs_dev_block_kobj)
 		goto block_kobj_err;
 	sysfs_dev_char_kobj = kobject_create_and_add("char", dev_kobj);
 	if (!sysfs_dev_char_kobj)
 		goto char_kobj_err;
 	return 0;
  char_kobj_err:
 	kobject_put(sysfs_dev_block_kobj);
  block_kobj_err:
 	kobject_put(dev_kobj);
  dev_kobj_err:
 	kset_unregister(devices_kset);
 	return -ENOMEM;
 }
 EXPORT_SYMBOL_GPL(device_for_each_child);
 EXPORT_SYMBOL_GPL(device_find_child);
 EXPORT_SYMBOL_GPL(device_initialize);
 EXPORT_SYMBOL_GPL(device_add);
 EXPORT_SYMBOL_GPL(device_register);
 EXPORT_SYMBOL_GPL(device_del);
 EXPORT_SYMBOL_GPL(device_unregister);
 EXPORT_SYMBOL_GPL(get_device);
 EXPORT_SYMBOL_GPL(put_device);
 EXPORT_SYMBOL_GPL(device_create_file);
 EXPORT_SYMBOL_GPL(device_remove_file);
 struct root_device {
 	struct device dev;
 	struct module *owner;
 };
 inline struct root_device *to_root_device(struct device *d)
 {
 	return container_of(d, struct root_device, dev);
 }
 static void root_device_release(struct device *dev)
 {
 	kfree(to_root_device(dev));
 }
 /**
  * __root_device_register - allocate and register a root device
  * @name: root device name
  * @owner: owner module of the root device, usually THIS_MODULE
  *
  * This function allocates a root device and registers it
  * using device_register(). In order to free the returned
  * device, use root_device_unregister().
  *
  * Root devices are dummy devices which allow other devices
  * to be grouped under /sys/devices. Use this function to
  * allocate a root device and then use it as the parent of
  * any device which should appear under /sys/devices/{name}
  *
  * The /sys/devices/{name} directory will also contain a
  * 'module' symlink which points to the @owner directory
  * in sysfs.
  *
  * Returns &struct device pointer on success, or ERR_PTR() on error.
  *
  * Note: You probably want to use root_device_register().
  */
 struct device *__root_device_register(const char *name, struct module *owner)
 {
 	struct root_device *root;
 	int err = -ENOMEM;
 	root = kzalloc(sizeof(struct root_device), GFP_KERNEL);
 	if (!root)
 		return ERR_PTR(err);
 	err = dev_set_name(&root->dev, "%s", name);
 	if (err) {
 		kfree(root);
 		return ERR_PTR(err);
 	}
 	root->dev.release = root_device_release;
 	err = device_register(&root->dev);
 	if (err) {
 		put_device(&root->dev);
 		return ERR_PTR(err);
 	}
 #ifdef CONFIG_MODULES	/* gotta find a "cleaner" way to do this */
 	if (owner) {
 		struct module_kobject *mk = &owner->mkobj;
 		err = sysfs_create_link(&root->dev.kobj, &mk->kobj, "module");
 		if (err) {
 			device_unregister(&root->dev);
 			return ERR_PTR(err);
 		}
 		root->owner = owner;
 	}
 #endif
 	return &root->dev;
 }
 EXPORT_SYMBOL_GPL(__root_device_register);
 /**
  * root_device_unregister - unregister and free a root device
  * @dev: device going away
  *
  * This function unregisters and cleans up a device that was created by
  * root_device_register().
  */
 void root_device_unregister(struct device *dev)
 {
 	struct root_device *root = to_root_device(dev);
 	if (root->owner)
 		sysfs_remove_link(&root->dev.kobj, "module");
 	device_unregister(dev);
 }
 EXPORT_SYMBOL_GPL(root_device_unregister);
 static void device_create_release(struct device *dev)
 {
 	pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
 	kfree(dev);
 }
 /**
  * device_create_vargs - creates a device and registers it with sysfs
  * @class: pointer to the struct class that this device should be registered to
  * @parent: pointer to the parent struct device of this new device, if any
  * @devt: the dev_t for the char device to be added
  * @drvdata: the data to be added to the device for callbacks
  * @fmt: string for the device's name
  * @args: va_list for the device's name
  *
  * This function can be used by char device classes.  A struct device
  * will be created in sysfs, registered to the specified class.
  *
  * A "dev" file will be created, showing the dev_t for the device, if
  * the dev_t is not 0,0.
  * If a pointer to a parent struct device is passed in, the newly created
  * struct device will be a child of that device in sysfs.
  * The pointer to the struct device will be returned from the call.
  * Any further sysfs files that might be required can be created using this
  * pointer.
  *
  * Returns &struct device pointer on success, or ERR_PTR() on error.
  *
  * Note: the struct class passed to this function must have previously
  * been created with a call to class_create().
  */
 struct device *device_create_vargs(struct class *class, struct device *parent,
 				   dev_t devt, void *drvdata, const char *fmt,
 				   va_list args)
 {
 	struct device *dev = NULL;
 	int retval = -ENODEV;
 	if (class == NULL || IS_ERR(class))
 		goto error;
 	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
 	if (!dev) {
 		retval = -ENOMEM;
 		goto error;
 	}
 	dev->devt = devt;
 	dev->class = class;
 	dev->parent = parent;
 	dev->release = device_create_release;
 	dev_set_drvdata(dev, drvdata);
 	retval = kobject_set_name_vargs(&dev->kobj, fmt, args);
 	if (retval)
 		goto error;
 	retval = device_register(dev);
 	if (retval)
 		goto error;
 	return dev;
 error:
 	put_device(dev);
 	return ERR_PTR(retval);
 }
 EXPORT_SYMBOL_GPL(device_create_vargs);
 /**
  * device_create - creates a device and registers it with sysfs
  * @class: pointer to the struct class that this device should be registered to
  * @parent: pointer to the parent struct device of this new device, if any
  * @devt: the dev_t for the char device to be added
  * @drvdata: the data to be added to the device for callbacks
  * @fmt: string for the device's name
  *
  * This function can be used by char device classes.  A struct device
  * will be created in sysfs, registered to the specified class.
  *
  * A "dev" file will be created, showing the dev_t for the device, if
  * the dev_t is not 0,0.
  * If a pointer to a parent struct device is passed in, the newly created
  * struct device will be a child of that device in sysfs.
  * The pointer to the struct device will be returned from the call.
  * Any further sysfs files that might be required can be created using this
  * pointer.
  *
  * Returns &struct device pointer on success, or ERR_PTR() on error.
  *
  * Note: the struct class passed to this function must have previously
  * been created with a call to class_create().
  */
 struct device *device_create(struct class *class, struct device *parent,
 			     dev_t devt, void *drvdata, const char *fmt, ...)
 {
 	va_list vargs;
 	struct device *dev;
 	va_start(vargs, fmt);
 	dev = device_create_vargs(class, parent, devt, drvdata, fmt, vargs);
 	va_end(vargs);
 	return dev;
 }
 EXPORT_SYMBOL_GPL(device_create);
 static int __match_devt(struct device *dev, void *data)
 {
 	dev_t *devt = data;
 	return dev->devt == *devt;
 }
 /**
  * device_destroy - removes a device that was created with device_create()
  * @class: pointer to the struct class that this device was registered with
  * @devt: the dev_t of the device that was previously registered
  *
  * This call unregisters and cleans up a device that was created with a
  * call to device_create().
  */
 void device_destroy(struct class *class, dev_t devt)
 {
 	struct device *dev;
 	dev = class_find_device(class, NULL, &devt, __match_devt);
 	if (dev) {
 		put_device(dev);
 		device_unregister(dev);
 	}
 }
 EXPORT_SYMBOL_GPL(device_destroy);
 /**
  * device_rename - renames a device
  * @dev: the pointer to the struct device to be renamed
  * @new_name: the new name of the device
  *
  * It is the responsibility of the caller to provide mutual
  * exclusion between two different calls of device_rename
  * on the same device to ensure that new_name is valid and
  * won't conflict with other devices.
  *
  * Note: Don't call this function.  Currently, the networking layer calls this
  * function, but that will change.  The following text from Kay Sievers offers
  * some insight:
  *
  * Renaming devices is racy at many levels, symlinks and other stuff are not
  * replaced atomically, and you get a "move" uevent, but it's not easy to
  * connect the event to the old and new device. Device nodes are not renamed at
  * all, there isn't even support for that in the kernel now.
  *
  * In the meantime, during renaming, your target name might be taken by another
  * driver, creating conflicts. Or the old name is taken directly after you
  * renamed it -- then you get events for the same DEVPATH, before you even see
  * the "move" event. It's just a mess, and nothing new should ever rely on
  * kernel device renaming. Besides that, it's not even implemented now for
  * other things than (driver-core wise very simple) network devices.
  *
  * We are currently about to change network renaming in udev to completely
  * disallow renaming of devices in the same namespace as the kernel uses,
  * because we can't solve the problems properly, that arise with swapping names
  * of multiple interfaces without races. Means, renaming of eth[0-9]* will only
  * be allowed to some other name than eth[0-9]*, for the aforementioned
  * reasons.
  *
  * Make up a "real" name in the driver before you register anything, or add
  * some other attributes for userspace to find the device, or use udev to add
  * symlinks -- but never rename kernel devices later, it's a complete mess. We
  * don't even want to get into that and try to implement the missing pieces in
  * the core. We really have other pieces to fix in the driver core mess. :)
  */
 int device_rename(struct device *dev, const char *new_name)
 {
 	char *old_class_name = NULL;
 	char *new_class_name = NULL;
 	char *old_device_name = NULL;
 	int error;
 	dev = get_device(dev);
 	if (!dev)
 		return -EINVAL;
 	pr_debug("device: '%s': %s: renaming to '%s'\n", dev_name(dev),
 		 __func__, new_name);
 	old_device_name = kstrdup(dev_name(dev), GFP_KERNEL);
 	if (!old_device_name) {
 		error = -ENOMEM;
 		goto out;
 	}
 	if (dev->class) {
 		error = sysfs_rename_link(&dev->class->p->subsys.kobj,
 			&dev->kobj, old_device_name, new_name);
 		if (error)
 			goto out;
 	}
 	error = kobject_rename(&dev->kobj, new_name);
 	if (error)
 		goto out;
 out:
 	put_device(dev);
 	kfree(new_class_name);
 	kfree(old_class_name);
 	kfree(old_device_name);
 	return error;
 }
 EXPORT_SYMBOL_GPL(device_rename);
 static int device_move_class_links(struct device *dev,
 				   struct device *old_parent,
 				   struct device *new_parent)
 {
 	int error = 0;
 	if (old_parent)
 		sysfs_remove_link(&dev->kobj, "device");
 	if (new_parent)
 		error = sysfs_create_link(&dev->kobj, &new_parent->kobj,
 					  "device");
 	return error;
 }
 /**
  * device_move - moves a device to a new parent
  * @dev: the pointer to the struct device to be moved
  * @new_parent: the new parent of the device (can by NULL)
  * @dpm_order: how to reorder the dpm_list
  */
 int device_move(struct device *dev, struct device *new_parent,
 		enum dpm_order dpm_order)
 {
 	int error;
 	struct device *old_parent;
 	struct kobject *new_parent_kobj;
 	dev = get_device(dev);
 	if (!dev)
 		return -EINVAL;
 	device_pm_lock();
 	new_parent = get_device(new_parent);
 	new_parent_kobj = get_device_parent(dev, new_parent);
 	pr_debug("device: '%s': %s: moving to '%s'\n", dev_name(dev),
 		 __func__, new_parent ? dev_name(new_parent) : "<NULL>");
 	error = kobject_move(&dev->kobj, new_parent_kobj);
 	if (error) {
 		cleanup_glue_dir(dev, new_parent_kobj);
 		put_device(new_parent);
 		goto out;
 	}
 	old_parent = dev->parent;
 	dev->parent = new_parent;
 	if (old_parent)
 		klist_remove(&dev->p->knode_parent);
 	if (new_parent) {
 		klist_add_tail(&dev->p->knode_parent,
 			       &new_parent->p->klist_children);
 		set_dev_node(dev, dev_to_node(new_parent));
 	}
 	if (!dev->class)
 		goto out_put;
 	error = device_move_class_links(dev, old_parent, new_parent);
 	if (error) {
 		/* We ignore errors on cleanup since we're hosed anyway... */
 		device_move_class_links(dev, new_parent, old_parent);
 		if (!kobject_move(&dev->kobj, &old_parent->kobj)) {
 			if (new_parent)
 				klist_remove(&dev->p->knode_parent);
 			dev->parent = old_parent;
 			if (old_parent) {
 				klist_add_tail(&dev->p->knode_parent,
 					       &old_parent->p->klist_children);
 				set_dev_node(dev, dev_to_node(old_parent));
 			}
 		}
 		cleanup_glue_dir(dev, new_parent_kobj);
 		put_device(new_parent);
 		goto out;
 	}
 	switch (dpm_order) {
 	case DPM_ORDER_NONE:
 		break;
 	case DPM_ORDER_DEV_AFTER_PARENT:
 		device_pm_move_after(dev, new_parent);
 		break;
 	case DPM_ORDER_PARENT_BEFORE_DEV:
 		device_pm_move_before(new_parent, dev);
 		break;
 	case DPM_ORDER_DEV_LAST:
 		device_pm_move_last(dev);
 		break;
 	}
 out_put:
 	put_device(old_parent);
 out:
 	device_pm_unlock();
 	put_device(dev);
 	return error;
 }
 EXPORT_SYMBOL_GPL(device_move);
 /**
  * device_shutdown - call ->shutdown() on each device to shutdown.
  */
 void device_shutdown(void)
 {
 	struct device *dev;
 	spin_lock(&devices_kset->list_lock);
 	/*
 	 * Walk the devices list backward, shutting down each in turn.
 	 * Beware that device unplug events may also start pulling
 	 * devices offline, even as the system is shutting down.
 	 */
 	while (!list_empty(&devices_kset->list)) {
 		dev = list_entry(devices_kset->list.prev, struct device,
 				kobj.entry);
 		get_device(dev);
 		/*
 		 * Make sure the device is off the kset list, in the
 		 * event that dev->*->shutdown() doesn't remove it.
 		 */
 		list_del_init(&dev->kobj.entry);
 		spin_unlock(&devices_kset->list_lock);
 		/* Don't allow any more runtime suspends */
 		pm_runtime_get_noresume(dev);
 		pm_runtime_barrier(dev);
 		if (dev->bus && dev->bus->shutdown) {
 			dev_dbg(dev, "shutdown\n");
 			dev->bus->shutdown(dev);
 		} else if (dev->driver && dev->driver->shutdown) {
 			dev_dbg(dev, "shutdown\n");
 			dev->driver->shutdown(dev);
 		}
 		put_device(dev);
 		spin_lock(&devices_kset->list_lock);
 	}
 	spin_unlock(&devices_kset->list_lock);
 	async_synchronize_full();
 }
 /*
  * Device logging functions
  */
 #ifdef CONFIG_PRINTK
 int __dev_printk(const char *level, const struct device *dev,
 		 struct va_format *vaf)
 {
+	char dict[128];
+	size_t dictlen = 0;
+	const char *subsys;
 	if (!dev)
 		return printk("%s(NULL device *): %pV", level, vaf);
-	return printk("%s%s %s: %pV",
+	if (dev->class)
-		      level, dev_driver_string(dev), dev_name(dev), vaf);
+		subsys = dev->class->name;
+	else if (dev->bus)
+		subsys = dev->bus->name;
+	else
+		goto skip;
+	dictlen += snprintf(dict + dictlen, sizeof(dict) - dictlen,
+			    "SUBSYSTEM=%s", subsys);
+	/*
+	 * Add device identifier DEVICE=:
+	 *   b12:8         block dev_t
+	 *   c127:3        char dev_t
+	 *   n8            netdev ifindex
+	 *   +sound:card0  subsystem:devname
+	 */
+	if (MAJOR(dev->devt)) {
+		char c;
+		if (strcmp(subsys, "block") == 0)
+			c = 'b';
+		else
+			c = 'c';
+		dictlen++;
+		dictlen += snprintf(dict + dictlen, sizeof(dict) - dictlen,
+				   "DEVICE=%c%u:%u",
+				   c, MAJOR(dev->devt), MINOR(dev->devt));
+	} else if (strcmp(subsys, "net") == 0) {
+		struct net_device *net = to_net_dev(dev);
+		dictlen++;
+		dictlen += snprintf(dict + dictlen, sizeof(dict) - dictlen,
+				    "DEVICE=n%u", net->ifindex);
+	} else {
+		dictlen++;
+		dictlen += snprintf(dict + dictlen, sizeof(dict) - dictlen,
+				    "DEVICE=+%s:%s", subsys, dev_name(dev));
+	}
+skip:
+	return printk_emit(0, level[1] - '0',
+			   dictlen ? dict : NULL, dictlen,
+			   "%s %s: %pV",
+			   dev_driver_string(dev), dev_name(dev), vaf);
 }
 EXPORT_SYMBOL(__dev_printk);
 int dev_printk(const char *level, const struct device *dev,
 	       const char *fmt, ...)
 {
 	struct va_format vaf;
 	va_list args;
 	int r;
 	va_start(args, fmt);
 	vaf.fmt = fmt;
 	vaf.va = &args;
 	r = __dev_printk(level, dev, &vaf);
 	va_end(args);
 	return r;
 }
 EXPORT_SYMBOL(dev_printk);
 #define define_dev_printk_level(func, kern_level)		\
 int func(const struct device *dev, const char *fmt, ...)	\
 {								\
 	struct va_format vaf;					\
 	va_list args;						\
 	int r;							\
 								\
 	va_start(args, fmt);					\
 								\
 	vaf.fmt = fmt;						\
 	vaf.va = &args;						\
 								\
 	r = __dev_printk(kern_level, dev, &vaf);		\
 	va_end(args);						\
 								\
 	return r;						\
 }								\
 EXPORT_SYMBOL(func);
 define_dev_printk_level(dev_emerg, KERN_EMERG);
 define_dev_printk_level(dev_alert, KERN_ALERT);
 define_dev_printk_level(dev_crit, KERN_CRIT);
 define_dev_printk_level(dev_err, KERN_ERR);
 define_dev_printk_level(dev_warn, KERN_WARNING);
 define_dev_printk_level(dev_notice, KERN_NOTICE);
 define_dev_printk_level(_dev_info, KERN_INFO);
 #endif