Eric Lee / 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/genhd.h>

21

#include <linux/genhd.h>

22

#include <linux/kallsyms.h>

22

#include <linux/kallsyms.h>

23

#include <linux/semaphore.h>

23

#include <linux/semaphore.h>

24

#include <linux/mutex.h>

24

#include <linux/mutex.h>

25

26

#include "base.h"

26

#include "base.h"

27

#include "power/power.h"

27

#include "power/power.h"

28

29

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

29

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

30

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

30

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

31

static struct kobject *dev_kobj;

31

static struct kobject *dev_kobj;

32

struct kobject *sysfs_dev_char_kobj;

32

struct kobject *sysfs_dev_char_kobj;

33

struct kobject *sysfs_dev_block_kobj;

33

struct kobject *sysfs_dev_block_kobj;

34

35

#ifdef CONFIG_BLOCK

35

#ifdef CONFIG_BLOCK

36

static inline int device_is_not_partition(struct device *dev)

36

static inline int device_is_not_partition(struct device *dev)

37

{

37

{

38

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

38

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

39

}

39

}

40

#else

40

#else

41

static inline int device_is_not_partition(struct device *dev)

41

static inline int device_is_not_partition(struct device *dev)

42

{

42

{

43

return 1;

43

return 1;

44

}

44

}

45

#endif

45

#endif

46

47

/**

47

/**

48

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

48

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

49

* @dev: struct device to get the name of

49

* @dev: struct device to get the name of

50

*

50

*

51

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

51

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

52

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

52

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

53

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

53

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

54

* string will be returned.

54

* string will be returned.

55

*/

55

*/

56

const char *dev_driver_string(const struct device *dev)

56

const char *dev_driver_string(const struct device *dev)

57

{

57

{

58

return dev->driver ? dev->driver->name :

58

return dev->driver ? dev->driver->name :

59

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

59

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

60

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

60

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

61

}

61

}

62

EXPORT_SYMBOL(dev_driver_string);

62

EXPORT_SYMBOL(dev_driver_string);

63

64

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

64

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

65

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

65

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

66

67

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

67

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

68

char *buf)

68

char *buf)

69

{

69

{

70

struct device_attribute *dev_attr = to_dev_attr(attr);

70

struct device_attribute *dev_attr = to_dev_attr(attr);

71

struct device *dev = to_dev(kobj);

71

struct device *dev = to_dev(kobj);

72

ssize_t ret = -EIO;

72

ssize_t ret = -EIO;

73

74

if (dev_attr->show)

74

if (dev_attr->show)

75

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

75

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

76

if (ret >= (ssize_t)PAGE_SIZE) {

76

if (ret >= (ssize_t)PAGE_SIZE) {

77

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

77

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

78

(unsigned long)dev_attr->show);

78

(unsigned long)dev_attr->show);

79

}

79

}

80

return ret;

80

return ret;

81

}

81

}

82

83

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

83

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

84

const char *buf, size_t count)

84

const char *buf, size_t count)

85

{

85

{

86

struct device_attribute *dev_attr = to_dev_attr(attr);

86

struct device_attribute *dev_attr = to_dev_attr(attr);

87

struct device *dev = to_dev(kobj);

87

struct device *dev = to_dev(kobj);

88

ssize_t ret = -EIO;

88

ssize_t ret = -EIO;

89

90

if (dev_attr->store)

90

if (dev_attr->store)

91

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

91

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

92

return ret;

92

return ret;

93

}

93

}

94

95

static struct sysfs_ops dev_sysfs_ops = {

95

static struct sysfs_ops dev_sysfs_ops = {

96

.show = dev_attr_show,

96

.show = dev_attr_show,

97

.store = dev_attr_store,

97

.store = dev_attr_store,

98

};

98

};

99

100

101

/**

101

/**

102

* device_release - free device structure.

102

* device_release - free device structure.

103

* @kobj: device's kobject.

103

* @kobj: device's kobject.

104

*

104

*

105

* This is called once the reference count for the object

105

* This is called once the reference count for the object

106

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

106

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

107

* method, which should handle actually freeing the structure.

107

* method, which should handle actually freeing the structure.

108

*/

108

*/

109

static void device_release(struct kobject *kobj)

109

static void device_release(struct kobject *kobj)

110

{

110

{

111

struct device *dev = to_dev(kobj);

111

struct device *dev = to_dev(kobj);

112

113

if (dev->release)

113

if (dev->release)

114

dev->release(dev);

114

dev->release(dev);

115

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

115

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

116

dev->type->release(dev);

116

dev->type->release(dev);

117

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

117

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

118

dev->class->dev_release(dev);

118

dev->class->dev_release(dev);

119

else

119

else

120

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

120

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

121

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

121

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

122

dev_name(dev));

122

dev_name(dev));

123

}

123

}

124

125

static struct kobj_type device_ktype = {

125

static struct kobj_type device_ktype = {

126

.release = device_release,

126

.release = device_release,

127

.sysfs_ops = &dev_sysfs_ops,

127

.sysfs_ops = &dev_sysfs_ops,

128

};

128

};

129

130

131

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

131

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

132

{

132

{

133

struct kobj_type *ktype = get_ktype(kobj);

133

struct kobj_type *ktype = get_ktype(kobj);

134

135

if (ktype == &device_ktype) {

135

if (ktype == &device_ktype) {

136

struct device *dev = to_dev(kobj);

136

struct device *dev = to_dev(kobj);

137

if (dev->uevent_suppress)

137

if (dev->uevent_suppress)

138

return 0;

138

return 0;

139

if (dev->bus)

139

if (dev->bus)

140

return 1;

140

return 1;

141

if (dev->class)

141

if (dev->class)

142

return 1;

142

return 1;

143

}

143

}

144

return 0;

144

return 0;

145

}

145

}

146

147

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

147

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

148

{

148

{

149

struct device *dev = to_dev(kobj);

149

struct device *dev = to_dev(kobj);

150

151

if (dev->bus)

151

if (dev->bus)

152

return dev->bus->name;

152

return dev->bus->name;

153

if (dev->class)

153

if (dev->class)

154

return dev->class->name;

154

return dev->class->name;

155

return NULL;

155

return NULL;

156

}

156

}

157

158

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

158

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

159

struct kobj_uevent_env *env)

159

struct kobj_uevent_env *env)

160

{

160

{

161

struct device *dev = to_dev(kobj);

161

struct device *dev = to_dev(kobj);

162

int retval = 0;

162

int retval = 0;

163

164

/* add the major/minor if present */

164

/* add the major/minor if present */

165

if (MAJOR(dev->devt)) {

165

if (MAJOR(dev->devt)) {

166

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

166

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

167

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

167

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

168

}

168

}

169

170

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

170

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

171

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

171

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

172

173

if (dev->driver)

173

if (dev->driver)

174

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

174

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

175

176

#ifdef CONFIG_SYSFS_DEPRECATED

176

#ifdef CONFIG_SYSFS_DEPRECATED

177

if (dev->class) {

177

if (dev->class) {

178

struct device *parent = dev->parent;

178

struct device *parent = dev->parent;

179

180

/* find first bus device in parent chain */

180

/* find first bus device in parent chain */

181

while (parent && !parent->bus)

181

while (parent && !parent->bus)

182

parent = parent->parent;

182

parent = parent->parent;

183

if (parent && parent->bus) {

183

if (parent && parent->bus) {

184

const char *path;

184

const char *path;

185

186

path = kobject_get_path(&parent->kobj, GFP_KERNEL);

186

path = kobject_get_path(&parent->kobj, GFP_KERNEL);

187

if (path) {

187

if (path) {

188

add_uevent_var(env, "PHYSDEVPATH=%s", path);

188

add_uevent_var(env, "PHYSDEVPATH=%s", path);

189

kfree(path);

189

kfree(path);

190

}

190

}

191

192

add_uevent_var(env, "PHYSDEVBUS=%s", parent->bus->name);

192

add_uevent_var(env, "PHYSDEVBUS=%s", parent->bus->name);

193

194

if (parent->driver)

194

if (parent->driver)

195

add_uevent_var(env, "PHYSDEVDRIVER=%s",

195

add_uevent_var(env, "PHYSDEVDRIVER=%s",

196

parent->driver->name);

196

parent->driver->name);

197

}

197

}

198

} else if (dev->bus) {

198

} else if (dev->bus) {

199

add_uevent_var(env, "PHYSDEVBUS=%s", dev->bus->name);

199

add_uevent_var(env, "PHYSDEVBUS=%s", dev->bus->name);

200

201

if (dev->driver)

201

if (dev->driver)

202

add_uevent_var(env, "PHYSDEVDRIVER=%s",

202

add_uevent_var(env, "PHYSDEVDRIVER=%s",

203

dev->driver->name);

203

dev->driver->name);

204

}

204

}

205

#endif

205

#endif

206

207

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

207

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

208

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

208

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

209

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

209

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

210

if (retval)

210

if (retval)

211

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

211

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

212

dev_name(dev), __func__, retval);

212

dev_name(dev), __func__, retval);

213

}

213

}

214

215

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

215

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

216

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

216

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

217

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

217

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

218

if (retval)

218

if (retval)

219

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

219

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

220

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

220

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

221

__func__, retval);

221

__func__, retval);

222

}

222

}

223

224

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

224

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

225

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

225

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

226

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

226

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

227

if (retval)

227

if (retval)

228

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

228

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

229

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

229

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

230

__func__, retval);

230

__func__, retval);

231

}

231

}

232

233

return retval;

233

return retval;

234

}

234

}

235

236

static struct kset_uevent_ops device_uevent_ops = {

236

static struct kset_uevent_ops device_uevent_ops = {

237

.filter = dev_uevent_filter,

237

.filter = dev_uevent_filter,

238

.name = dev_uevent_name,

238

.name = dev_uevent_name,

239

.uevent = dev_uevent,

239

.uevent = dev_uevent,

240

};

240

};

241

242

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

242

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

243

char *buf)

243

char *buf)

244

{

244

{

245

struct kobject *top_kobj;

245

struct kobject *top_kobj;

246

struct kset *kset;

246

struct kset *kset;

247

struct kobj_uevent_env *env = NULL;

247

struct kobj_uevent_env *env = NULL;

248

int i;

248

int i;

249

size_t count = 0;

249

size_t count = 0;

250

int retval;

250

int retval;

251

252

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

252

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

253

top_kobj = &dev->kobj;

253

top_kobj = &dev->kobj;

254

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

254

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

255

top_kobj = top_kobj->parent;

255

top_kobj = top_kobj->parent;

256

if (!top_kobj->kset)

256

if (!top_kobj->kset)

257

goto out;

257

goto out;

258

259

kset = top_kobj->kset;

259

kset = top_kobj->kset;

260

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

260

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

261

goto out;

261

goto out;

262

263

/* respect filter */

263

/* respect filter */

264

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

264

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

265

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

265

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

266

goto out;

266

goto out;

267

268

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

268

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

269

if (!env)

269

if (!env)

270

return -ENOMEM;

270

return -ENOMEM;

271

272

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

272

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

273

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

273

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

274

if (retval)

274

if (retval)

275

goto out;

275

goto out;

276

277

/* copy keys to file */

277

/* copy keys to file */

278

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

278

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

279

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

279

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

280

out:

280

out:

281

kfree(env);

281

kfree(env);

282

return count;

282

return count;

283

}

283

}

284

285

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

285

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

286

const char *buf, size_t count)

286

const char *buf, size_t count)

287

{

287

{

288

enum kobject_action action;

288

enum kobject_action action;

289

290

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

290

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

291

kobject_uevent(&dev->kobj, action);

291

kobject_uevent(&dev->kobj, action);

292

goto out;

292

goto out;

293

}

293

}

294

295

dev_err(dev, "uevent: unsupported action-string; this will "

295

dev_err(dev, "uevent: unsupported action-string; this will "

296

"be ignored in a future kernel version\n");

296

"be ignored in a future kernel version\n");

297

kobject_uevent(&dev->kobj, KOBJ_ADD);

297

kobject_uevent(&dev->kobj, KOBJ_ADD);

298

out:

298

out:

299

return count;

299

return count;

300

}

300

}

301

302

static struct device_attribute uevent_attr =

302

static struct device_attribute uevent_attr =

303

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

303

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

304

305

static int device_add_attributes(struct device *dev,

305

static int device_add_attributes(struct device *dev,

306

struct device_attribute *attrs)

306

struct device_attribute *attrs)

307

{

307

{

308

int error = 0;

308

int error = 0;

309

int i;

309

int i;

310

311

if (attrs) {

311

if (attrs) {

312

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

312

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

313

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

313

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

314

if (error)

314

if (error)

315

break;

315

break;

316

}

316

}

317

if (error)

317

if (error)

318

while (--i >= 0)

318

while (--i >= 0)

319

device_remove_file(dev, &attrs[i]);

319

device_remove_file(dev, &attrs[i]);

320

}

320

}

321

return error;

321

return error;

322

}

322

}

323

324

static void device_remove_attributes(struct device *dev,

324

static void device_remove_attributes(struct device *dev,

325

struct device_attribute *attrs)

325

struct device_attribute *attrs)

326

{

326

{

327

int i;

327

int i;

328

329

if (attrs)

329

if (attrs)

330

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

330

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

331

device_remove_file(dev, &attrs[i]);

331

device_remove_file(dev, &attrs[i]);

332

}

332

}

333

334

static int device_add_groups(struct device *dev,

334

static int device_add_groups(struct device *dev,

335

struct attribute_group **groups)

335

struct attribute_group **groups)

336

{

336

{

337

int error = 0;

337

int error = 0;

338

int i;

338

int i;

339

340

if (groups) {

340

if (groups) {

341

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

341

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

342

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

342

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

343

if (error) {

343

if (error) {

344

while (--i >= 0)

344

while (--i >= 0)

345

sysfs_remove_group(&dev->kobj,

345

sysfs_remove_group(&dev->kobj,

346

groups[i]);

346

groups[i]);

347

break;

347

break;

348

}

348

}

349

}

349

}

350

}

350

}

351

return error;

351

return error;

352

}

352

}

353

354

static void device_remove_groups(struct device *dev,

354

static void device_remove_groups(struct device *dev,

355

struct attribute_group **groups)

355

struct attribute_group **groups)

356

{

356

{

357

int i;

357

int i;

358

359

if (groups)

359

if (groups)

360

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

360

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

361

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

361

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

362

}

362

}

363

364

static int device_add_attrs(struct device *dev)

364

static int device_add_attrs(struct device *dev)

365

{

365

{

366

struct class *class = dev->class;

366

struct class *class = dev->class;

367

struct device_type *type = dev->type;

367

struct device_type *type = dev->type;

368

int error;

368

int error;

369

370

if (class) {

370

if (class) {

371

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

371

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

372

if (error)

372

if (error)

373

return error;

373

return error;

374

}

374

}

375

376

if (type) {

376

if (type) {

377

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

377

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

378

if (error)

378

if (error)

379

goto err_remove_class_attrs;

379

goto err_remove_class_attrs;

380

}

380

}

381

382

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

382

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

383

if (error)

383

if (error)

384

goto err_remove_type_groups;

384

goto err_remove_type_groups;

385

386

return 0;

386

return 0;

387

388

err_remove_type_groups:

388

err_remove_type_groups:

389

if (type)

389

if (type)

390

device_remove_groups(dev, type->groups);

390

device_remove_groups(dev, type->groups);

391

err_remove_class_attrs:

391

err_remove_class_attrs:

392

if (class)

392

if (class)

393

device_remove_attributes(dev, class->dev_attrs);

393

device_remove_attributes(dev, class->dev_attrs);

394

395

return error;

395

return error;

396

}

396

}

397

398

static void device_remove_attrs(struct device *dev)

398

static void device_remove_attrs(struct device *dev)

399

{

399

{

400

struct class *class = dev->class;

400

struct class *class = dev->class;

401

struct device_type *type = dev->type;

401

struct device_type *type = dev->type;

402

403

device_remove_groups(dev, dev->groups);

403

device_remove_groups(dev, dev->groups);

404

405

if (type)

405

if (type)

406

device_remove_groups(dev, type->groups);

406

device_remove_groups(dev, type->groups);

407

408

if (class)

408

if (class)

409

device_remove_attributes(dev, class->dev_attrs);

409

device_remove_attributes(dev, class->dev_attrs);

410

}

410

}

411

412

413

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

413

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

414

char *buf)

414

char *buf)

415

{

415

{

416

return print_dev_t(buf, dev->devt);

416

return print_dev_t(buf, dev->devt);

417

}

417

}

418

419

static struct device_attribute devt_attr =

419

static struct device_attribute devt_attr =

420

__ATTR(dev, S_IRUGO, show_dev, NULL);

420

__ATTR(dev, S_IRUGO, show_dev, NULL);

421

422

/* kset to create /sys/devices/ */

422

/* kset to create /sys/devices/ */

423

struct kset *devices_kset;

423

struct kset *devices_kset;

424

425

/**

425

/**

426

* device_create_file - create sysfs attribute file for device.

426

* device_create_file - create sysfs attribute file for device.

427

* @dev: device.

427

* @dev: device.

428

* @attr: device attribute descriptor.

428

* @attr: device attribute descriptor.

429

*/

429

*/

430

int device_create_file(struct device *dev, struct device_attribute *attr)

430

int device_create_file(struct device *dev, struct device_attribute *attr)

431

{

431

{

432

int error = 0;

432

int error = 0;

433

if (dev)

433

if (dev)

434

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

434

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

435

return error;

435

return error;

436

}

436

}

437

438

/**

438

/**

439

* device_remove_file - remove sysfs attribute file.

439

* device_remove_file - remove sysfs attribute file.

440

* @dev: device.

440

* @dev: device.

441

* @attr: device attribute descriptor.

441

* @attr: device attribute descriptor.

442

*/

442

*/

443

void device_remove_file(struct device *dev, struct device_attribute *attr)

443

void device_remove_file(struct device *dev, struct device_attribute *attr)

444

{

444

{

445

if (dev)

445

if (dev)

446

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

446

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

447

}

447

}

448

449

/**

449

/**

450

* device_create_bin_file - create sysfs binary attribute file for device.

450

* device_create_bin_file - create sysfs binary attribute file for device.

451

* @dev: device.

451

* @dev: device.

452

* @attr: device binary attribute descriptor.

452

* @attr: device binary attribute descriptor.

453

*/

453

*/

454

int device_create_bin_file(struct device *dev, struct bin_attribute *attr)

454

int device_create_bin_file(struct device *dev, struct bin_attribute *attr)

455

{

455

{

456

int error = -EINVAL;

456

int error = -EINVAL;

457

if (dev)

457

if (dev)

458

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

458

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

459

return error;

459

return error;

460

}

460

}

461

EXPORT_SYMBOL_GPL(device_create_bin_file);

461

EXPORT_SYMBOL_GPL(device_create_bin_file);

462

463

/**

463

/**

464

* device_remove_bin_file - remove sysfs binary attribute file

464

* device_remove_bin_file - remove sysfs binary attribute file

465

* @dev: device.

465

* @dev: device.

466

* @attr: device binary attribute descriptor.

466

* @attr: device binary attribute descriptor.

467

*/

467

*/

468

void device_remove_bin_file(struct device *dev, struct bin_attribute *attr)

468

void device_remove_bin_file(struct device *dev, struct bin_attribute *attr)

469

{

469

{

470

if (dev)

470

if (dev)

471

sysfs_remove_bin_file(&dev->kobj, attr);

471

sysfs_remove_bin_file(&dev->kobj, attr);

472

}

472

}

473

EXPORT_SYMBOL_GPL(device_remove_bin_file);

473

EXPORT_SYMBOL_GPL(device_remove_bin_file);

474

475

/**

475

/**

476

* device_schedule_callback_owner - helper to schedule a callback for a device

476

* device_schedule_callback_owner - helper to schedule a callback for a device

477

* @dev: device.

477

* @dev: device.

478

* @func: callback function to invoke later.

478

* @func: callback function to invoke later.

479

* @owner: module owning the callback routine

479

* @owner: module owning the callback routine

480

*

480

*

481

* Attribute methods must not unregister themselves or their parent device

481

* Attribute methods must not unregister themselves or their parent device

482

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

482

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

483

* since unregistration is mutually exclusive with driver callbacks.

483

* since unregistration is mutually exclusive with driver callbacks.

484

*

484

*

485

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

485

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

486

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

486

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

487

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

487

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

488

* @func returns.

488

* @func returns.

489

*

489

*

490

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

490

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

491

* which automatically sets @owner to THIS_MODULE.

491

* which automatically sets @owner to THIS_MODULE.

492

*

492

*

493

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

493

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

494

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

494

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

495

*

495

*

496

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

496

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

497

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

497

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

498

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

498

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

499

*/

499

*/

500

int device_schedule_callback_owner(struct device *dev,

500

int device_schedule_callback_owner(struct device *dev,

501

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

501

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

502

{

502

{

503

return sysfs_schedule_callback(&dev->kobj,

503

return sysfs_schedule_callback(&dev->kobj,

504

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

504

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

505

}

505

}

506

EXPORT_SYMBOL_GPL(device_schedule_callback_owner);

506

EXPORT_SYMBOL_GPL(device_schedule_callback_owner);

507

508

static void klist_children_get(struct klist_node *n)

508

static void klist_children_get(struct klist_node *n)

509

{

509

{

510

struct device *dev = container_of(n, struct device, knode_parent);

510

struct device *dev = container_of(n, struct device, knode_parent);

511

512

get_device(dev);

512

get_device(dev);

513

}

513

}

514

515

static void klist_children_put(struct klist_node *n)

515

static void klist_children_put(struct klist_node *n)

516

{

516

{

517

struct device *dev = container_of(n, struct device, knode_parent);

517

struct device *dev = container_of(n, struct device, knode_parent);

518

519

put_device(dev);

519

put_device(dev);

520

}

520

}

521

522

/**

522

/**

523

* device_initialize - init device structure.

523

* device_initialize - init device structure.

524

* @dev: device.

524

* @dev: device.

525

*

525

*

526

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

526

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

527

* its fields.

527

* its fields.

528

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

528

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

529

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

529

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

530

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

530

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

531

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

531

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

532

* function.

532

* function.

533

*

533

*

534

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

534

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

535

* @dev directly once you have called this function.

535

* @dev directly once you have called this function.

536

*/

536

*/

537

void device_initialize(struct device *dev)

537

void device_initialize(struct device *dev)

538

{

538

{

539

dev->kobj.kset = devices_kset;

539

dev->kobj.kset = devices_kset;

540

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

540

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

541

klist_init(&dev->klist_children, klist_children_get,

541

klist_init(&dev->klist_children, klist_children_get,

542

klist_children_put);

542

klist_children_put);

543

INIT_LIST_HEAD(&dev->dma_pools);

543

INIT_LIST_HEAD(&dev->dma_pools);

544

init_MUTEX(&dev->sem);

544

init_MUTEX(&dev->sem);

545

spin_lock_init(&dev->devres_lock);

545

spin_lock_init(&dev->devres_lock);

546

INIT_LIST_HEAD(&dev->devres_head);

546

INIT_LIST_HEAD(&dev->devres_head);

547

device_init_wakeup(dev, 0);

547

device_init_wakeup(dev, 0);

548

device_pm_init(dev);

548

device_pm_init(dev);

549

set_dev_node(dev, -1);

549

set_dev_node(dev, -1);

550

}

550

}

551

552

#ifdef CONFIG_SYSFS_DEPRECATED

552

#ifdef CONFIG_SYSFS_DEPRECATED

553

static struct kobject *get_device_parent(struct device *dev,

553

static struct kobject *get_device_parent(struct device *dev,

554

struct device *parent)

554

struct device *parent)

555

{

555

{

556

/* class devices without a parent live in /sys/class/<classname>/ */

556

/* class devices without a parent live in /sys/class/<classname>/ */

557

if (dev->class && (!parent || parent->class != dev->class))

557

if (dev->class && (!parent || parent->class != dev->class))

558

return &dev->class->p->class_subsys.kobj;

558

return &dev->class->p->class_subsys.kobj;

559

/* all other devices keep their parent */

559

/* all other devices keep their parent */

560

else if (parent)

560

else if (parent)

561

return &parent->kobj;

561

return &parent->kobj;

562

563

return NULL;

563

return NULL;

564

}

564

}

565

566

static inline void cleanup_device_parent(struct device *dev) {}

566

static inline void cleanup_device_parent(struct device *dev) {}

567

static inline void cleanup_glue_dir(struct device *dev,

567

static inline void cleanup_glue_dir(struct device *dev,

568

struct kobject *glue_dir) {}

568

struct kobject *glue_dir) {}

569

#else

569

#else

570

static struct kobject *virtual_device_parent(struct device *dev)

570

static struct kobject *virtual_device_parent(struct device *dev)

571

{

571

{

572

static struct kobject *virtual_dir = NULL;

572

static struct kobject *virtual_dir = NULL;

573

574

if (!virtual_dir)

574

if (!virtual_dir)

575

virtual_dir = kobject_create_and_add("virtual",

575

virtual_dir = kobject_create_and_add("virtual",

576

&devices_kset->kobj);

576

&devices_kset->kobj);

577

578

return virtual_dir;

578

return virtual_dir;

579

}

579

}

580

581

static struct kobject *get_device_parent(struct device *dev,

581

static struct kobject *get_device_parent(struct device *dev,

582

struct device *parent)

582

struct device *parent)

583

{

583

{

584

int retval;

584

int retval;

585

586

if (dev->class) {

586

if (dev->class) {

587

struct kobject *kobj = NULL;

587

struct kobject *kobj = NULL;

588

struct kobject *parent_kobj;

588

struct kobject *parent_kobj;

589

struct kobject *k;

589

struct kobject *k;

590

591

/*

591

/*

592

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

592

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

593

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

593

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

594

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

594

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

595

*/

595

*/

596

if (parent == NULL)

596

if (parent == NULL)

597

parent_kobj = virtual_device_parent(dev);

597

parent_kobj = virtual_device_parent(dev);

598

else if (parent->class)

598

else if (parent->class)

599

return &parent->kobj;

599

return &parent->kobj;

600

else

600

else

601

parent_kobj = &parent->kobj;

601

parent_kobj = &parent->kobj;

602

603

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

603

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

604

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

604

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

605

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

605

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

606

if (k->parent == parent_kobj) {

606

if (k->parent == parent_kobj) {

607

kobj = kobject_get(k);

607

kobj = kobject_get(k);

608

break;

608

break;

609

}

609

}

610

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

610

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

611

if (kobj)

611

if (kobj)

612

return kobj;

612

return kobj;

613

614

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

614

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

615

k = kobject_create();

615

k = kobject_create();

616

if (!k)

616

if (!k)

617

return NULL;

617

return NULL;

618

k->kset = &dev->class->p->class_dirs;

618

k->kset = &dev->class->p->class_dirs;

619

retval = kobject_add(k, parent_kobj, "%s", dev->class->name);

619

retval = kobject_add(k, parent_kobj, "%s", dev->class->name);

620

if (retval < 0) {

620

if (retval < 0) {

621

kobject_put(k);

621

kobject_put(k);

622

return NULL;

622

return NULL;

623

}

623

}

624

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

624

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

625

return k;

625

return k;

626

}

626

}

627

628

if (parent)

628

if (parent)

629

return &parent->kobj;

629

return &parent->kobj;

630

return NULL;

630

return NULL;

631

}

631

}

632

633

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

633

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

634

{

634

{

635

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

635

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

636

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

636

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

637

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

637

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

638

return;

638

return;

639

640

kobject_put(glue_dir);

640

kobject_put(glue_dir);

641

}

641

}

642

643

static void cleanup_device_parent(struct device *dev)

643

static void cleanup_device_parent(struct device *dev)

644

{

644

{

645

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

645

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

646

}

646

}

647

#endif

647

#endif

648

649

static void setup_parent(struct device *dev, struct device *parent)

649

static void setup_parent(struct device *dev, struct device *parent)

650

{

650

{

651

struct kobject *kobj;

651

struct kobject *kobj;

652

kobj = get_device_parent(dev, parent);

652

kobj = get_device_parent(dev, parent);

653

if (kobj)

653

if (kobj)

654

dev->kobj.parent = kobj;

654

dev->kobj.parent = kobj;

655

}

655

}

656

657

static int device_add_class_symlinks(struct device *dev)

657

static int device_add_class_symlinks(struct device *dev)

658

{

658

{

659

int error;

659

int error;

660

661

if (!dev->class)

661

if (!dev->class)

662

return 0;

662

return 0;

663

664

error = sysfs_create_link(&dev->kobj,

664

error = sysfs_create_link(&dev->kobj,

665

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

665

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

666

"subsystem");

666

"subsystem");

667

if (error)

667

if (error)

668

goto out;

668

goto out;

669

670

#ifdef CONFIG_SYSFS_DEPRECATED

670

#ifdef CONFIG_SYSFS_DEPRECATED

671

/* stacked class devices need a symlink in the class directory */

671

/* stacked class devices need a symlink in the class directory */

672

if (dev->kobj.parent != &dev->class->p->class_subsys.kobj &&

672

if (dev->kobj.parent != &dev->class->p->class_subsys.kobj &&

673

device_is_not_partition(dev)) {

673

device_is_not_partition(dev)) {

674

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

674

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

675

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

675

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

676

if (error)

676

if (error)

677

goto out_subsys;

677

goto out_subsys;

678

}

678

}

679

680

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

680

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

681

struct device *parent = dev->parent;

681

struct device *parent = dev->parent;

682

char *class_name;

682

char *class_name;

683

684

/*

684

/*

685

* stacked class devices have the 'device' link

685

* stacked class devices have the 'device' link

686

* pointing to the bus device instead of the parent

686

* pointing to the bus device instead of the parent

687

*/

687

*/

688

while (parent->class && !parent->bus && parent->parent)

688

while (parent->class && !parent->bus && parent->parent)

689

parent = parent->parent;

689

parent = parent->parent;

690

691

error = sysfs_create_link(&dev->kobj,

691

error = sysfs_create_link(&dev->kobj,

692

&parent->kobj,

692

&parent->kobj,

693

"device");

693

"device");

694

if (error)

694

if (error)

695

goto out_busid;

695

goto out_busid;

696

697

class_name = make_class_name(dev->class->name,

697

class_name = make_class_name(dev->class->name,

698

&dev->kobj);

698

&dev->kobj);

699

if (class_name)

699

if (class_name)

700

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

700

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

701

&dev->kobj, class_name);

701

&dev->kobj, class_name);

702

kfree(class_name);

702

kfree(class_name);

703

if (error)

703

if (error)

704

goto out_device;

704

goto out_device;

705

}

705

}

706

return 0;

706

return 0;

707

708

out_device:

708

out_device:

709

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

709

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

710

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

710

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

711

out_busid:

711

out_busid:

712

if (dev->kobj.parent != &dev->class->p->class_subsys.kobj &&

712

if (dev->kobj.parent != &dev->class->p->class_subsys.kobj &&

713

device_is_not_partition(dev))

713

device_is_not_partition(dev))

714

sysfs_remove_link(&dev->class->p->class_subsys.kobj,

714

sysfs_remove_link(&dev->class->p->class_subsys.kobj,

715

dev_name(dev));

715

dev_name(dev));

716

#else

716

#else

717

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

717

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

718

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

718

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

719

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

719

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

720

if (error)

720

if (error)

721

goto out_subsys;

721

goto out_subsys;

722

723

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

723

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

724

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

724

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

725

"device");

725

"device");

726

if (error)

726

if (error)

727

goto out_busid;

727

goto out_busid;

728

}

728

}

729

return 0;

729

return 0;

730

731

out_busid:

731

out_busid:

732

sysfs_remove_link(&dev->class->p->class_subsys.kobj, dev_name(dev));

732

sysfs_remove_link(&dev->class->p->class_subsys.kobj, dev_name(dev));

733

#endif

733

#endif

734

735

out_subsys:

735

out_subsys:

736

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

736

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

737

out:

737

out:

738

return error;

738

return error;

739

}

739

}

740

741

static void device_remove_class_symlinks(struct device *dev)

741

static void device_remove_class_symlinks(struct device *dev)

742

{

742

{

743

if (!dev->class)

743

if (!dev->class)

744

return;

744

return;

745

746

#ifdef CONFIG_SYSFS_DEPRECATED

746

#ifdef CONFIG_SYSFS_DEPRECATED

747

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

747

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

748

char *class_name;

748

char *class_name;

749

750

class_name = make_class_name(dev->class->name, &dev->kobj);

750

class_name = make_class_name(dev->class->name, &dev->kobj);

751

if (class_name) {

751

if (class_name) {

752

sysfs_remove_link(&dev->parent->kobj, class_name);

752

sysfs_remove_link(&dev->parent->kobj, class_name);

753

kfree(class_name);

753

kfree(class_name);

754

}

754

}

755

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

755

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

756

}

756

}

757

758

if (dev->kobj.parent != &dev->class->p->class_subsys.kobj &&

758

if (dev->kobj.parent != &dev->class->p->class_subsys.kobj &&

759

device_is_not_partition(dev))

759

device_is_not_partition(dev))

760

sysfs_remove_link(&dev->class->p->class_subsys.kobj,

760

sysfs_remove_link(&dev->class->p->class_subsys.kobj,

761

dev_name(dev));

761

dev_name(dev));

762

#else

762

#else

763

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

763

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

764

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

764

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

765

766

sysfs_remove_link(&dev->class->p->class_subsys.kobj, dev_name(dev));

766

sysfs_remove_link(&dev->class->p->class_subsys.kobj, dev_name(dev));

767

#endif

767

#endif

768

769

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

769

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

770

}

770

}

771

772

/**

772

/**

773

* dev_set_name - set a device name

773

* dev_set_name - set a device name

774

* @dev: device

774

* @dev: device

775

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

775

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

776

*/

776

*/

777

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

777

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

778

{

778

{

779

va_list vargs;

779

va_list vargs;

780

char *s;

780

char *s;

781

782

va_start(vargs, fmt);

782

va_start(vargs, fmt);

783

vsnprintf(dev->bus_id, sizeof(dev->bus_id), fmt, vargs);

783

vsnprintf(dev->bus_id, sizeof(dev->bus_id), fmt, vargs);

784

va_end(vargs);

784

va_end(vargs);

785

786

/* ewww... some of these buggers have / in the name... */

786

/* ewww... some of these buggers have / in the name... */

787

while ((s = strchr(dev->bus_id, '/')))

787

while ((s = strchr(dev->bus_id, '/')))

788

*s = '!';

788

*s = '!';

789

790

return 0;

790

return 0;

791

}

791

}

792

EXPORT_SYMBOL_GPL(dev_set_name);

792

EXPORT_SYMBOL_GPL(dev_set_name);

793

794

/**

794

/**

795

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

795

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

796

* @dev: device

796

* @dev: device

797

*

797

*

798

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

798

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

799

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

799

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

800

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

800

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

801

* otherwise device_create_sys_dev_entry() and

801

* otherwise device_create_sys_dev_entry() and

802

* device_remove_sys_dev_entry() will disagree about the the presence

802

* device_remove_sys_dev_entry() will disagree about the the presence

803

* of the link.

803

* of the link.

804

*/

804

*/

805

static struct kobject *device_to_dev_kobj(struct device *dev)

805

static struct kobject *device_to_dev_kobj(struct device *dev)

806

{

806

{

807

struct kobject *kobj;

807

struct kobject *kobj;

808

809

if (dev->class)

809

if (dev->class)

810

kobj = dev->class->dev_kobj;

810

kobj = dev->class->dev_kobj;

811

else

811

else

812

kobj = sysfs_dev_char_kobj;

812

kobj = sysfs_dev_char_kobj;

813

814

return kobj;

814

return kobj;

815

}

815

}

816

817

static int device_create_sys_dev_entry(struct device *dev)

817

static int device_create_sys_dev_entry(struct device *dev)

818

{

818

{

819

struct kobject *kobj = device_to_dev_kobj(dev);

819

struct kobject *kobj = device_to_dev_kobj(dev);

820

int error = 0;

820

int error = 0;

821

char devt_str[15];

821

char devt_str[15];

822

823

if (kobj) {

823

if (kobj) {

824

format_dev_t(devt_str, dev->devt);

824

format_dev_t(devt_str, dev->devt);

825

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

825

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

826

}

826

}

827

828

return error;

828

return error;

829

}

829

}

830

831

static void device_remove_sys_dev_entry(struct device *dev)

831

static void device_remove_sys_dev_entry(struct device *dev)

832

{

832

{

833

struct kobject *kobj = device_to_dev_kobj(dev);

833

struct kobject *kobj = device_to_dev_kobj(dev);

834

char devt_str[15];

834

char devt_str[15];

835

836

if (kobj) {

836

if (kobj) {

837

format_dev_t(devt_str, dev->devt);

837

format_dev_t(devt_str, dev->devt);

838

sysfs_remove_link(kobj, devt_str);

838

sysfs_remove_link(kobj, devt_str);

839

}

839

}

840

}

840

}

841

842

/**

842

/**

843

* device_add - add device to device hierarchy.

843

* device_add - add device to device hierarchy.

844

* @dev: device.

844

* @dev: device.

845

*

845

*

846

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

846

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

847

* separately _iff_ device_initialize() has been called separately.

847

* separately _iff_ device_initialize() has been called separately.

848

*

848

*

849

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

849

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

850

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

850

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

851

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

851

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

852

*

852

*

853

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

853

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

854

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

854

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

855

* reference instead.

855

* reference instead.

856

*/

856

*/

857

int device_add(struct device *dev)

857

int device_add(struct device *dev)

858

{

858

{

859

struct device *parent = NULL;

859

struct device *parent = NULL;

860

struct class_interface *class_intf;

860

struct class_interface *class_intf;

861

int error = -EINVAL;

861

int error = -EINVAL;

862

863

dev = get_device(dev);

863

dev = get_device(dev);

864

if (!dev)

864

if (!dev)

865

goto done;

865

goto done;

866

867

/* Temporarily support init_name if it is set.

867

/* Temporarily support init_name if it is set.

868

* It will override bus_id for now */

868

* It will override bus_id for now */

869

if (dev->init_name)

869

if (dev->init_name)

870

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

870

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

871

872

if (!strlen(dev->bus_id))

872

if (!strlen(dev->bus_id))

873

goto done;

873

goto done;

874

875

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

875

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

876

877

parent = get_device(dev->parent);

877

parent = get_device(dev->parent);

878

setup_parent(dev, parent);

878

setup_parent(dev, parent);

879

880

/* use parent numa_node */

880

/* use parent numa_node */

881

if (parent)

881

if (parent)

882

set_dev_node(dev, dev_to_node(parent));

882

set_dev_node(dev, dev_to_node(parent));

883

884

/* first, register with generic layer. */

884

/* first, register with generic layer. */

885

error = kobject_add(&dev->kobj, dev->kobj.parent, "%s", dev_name(dev));

885

error = kobject_add(&dev->kobj, dev->kobj.parent, "%s", dev_name(dev));

886

if (error)

886

if (error)

887

goto Error;

887

goto Error;

888

889

/* notify platform of device entry */

889

/* notify platform of device entry */

890

if (platform_notify)

890

if (platform_notify)

891

platform_notify(dev);

891

platform_notify(dev);

892

893

error = device_create_file(dev, &uevent_attr);

893

error = device_create_file(dev, &uevent_attr);

894

if (error)

894

if (error)

895

goto attrError;

895

goto attrError;

896

897

if (MAJOR(dev->devt)) {

897

if (MAJOR(dev->devt)) {

898

error = device_create_file(dev, &devt_attr);

898

error = device_create_file(dev, &devt_attr);

899

if (error)

899

if (error)

900

goto ueventattrError;

900

goto ueventattrError;

901

902

error = device_create_sys_dev_entry(dev);

902

error = device_create_sys_dev_entry(dev);

903

if (error)

903

if (error)

904

goto devtattrError;

904

goto devtattrError;

905

}

905

}

906

907

error = device_add_class_symlinks(dev);

907

error = device_add_class_symlinks(dev);

908

if (error)

908

if (error)

909

goto SymlinkError;

909

goto SymlinkError;

910

error = device_add_attrs(dev);

910

error = device_add_attrs(dev);

911

if (error)

911

if (error)

912

goto AttrsError;

912

goto AttrsError;

913

error = bus_add_device(dev);

913

error = bus_add_device(dev);

914

if (error)

914

if (error)

915

goto BusError;

915

goto BusError;

916

error = dpm_sysfs_add(dev);

916

error = dpm_sysfs_add(dev);

917

if (error)

917

if (error)

918

goto DPMError;

918

goto DPMError;

919

device_pm_add(dev);

919

device_pm_add(dev);

920

921

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

921

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

922

* after dpm_sysf_add() and before kobject_uevent().

922

* after dpm_sysf_add() and before kobject_uevent().

923

*/

923

*/

924

if (dev->bus)

924

if (dev->bus)

925

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

925

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

926

BUS_NOTIFY_ADD_DEVICE, dev);

926

BUS_NOTIFY_ADD_DEVICE, dev);

927

928

kobject_uevent(&dev->kobj, KOBJ_ADD);

928

kobject_uevent(&dev->kobj, KOBJ_ADD);

929

bus_attach_device(dev);

929

bus_attach_device(dev);

930

if (parent)

930

if (parent)

931

klist_add_tail(&dev->knode_parent, &parent->klist_children);

931

klist_add_tail(&dev->knode_parent, &parent->klist_children);

932

933

if (dev->class) {

933

if (dev->class) {

934

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

934

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

935

/* tie the class to the device */

935

/* tie the class to the device */

936

klist_add_tail(&dev->knode_class,

936

klist_add_tail(&dev->knode_class,

937

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

937

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

938

939

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

939

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

940

list_for_each_entry(class_intf,

940

list_for_each_entry(class_intf,

941

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

941

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

942

if (class_intf->add_dev)

942

if (class_intf->add_dev)

943

class_intf->add_dev(dev, class_intf);

943

class_intf->add_dev(dev, class_intf);

944

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

944

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

945

}

945

}

946

done:

946

done:

947

put_device(dev);

947

put_device(dev);

948

return error;

948

return error;

949

DPMError:

949

DPMError:

950

bus_remove_device(dev);

950

bus_remove_device(dev);

951

BusError:

951

BusError:

952

device_remove_attrs(dev);

952

device_remove_attrs(dev);

953

AttrsError:

953

AttrsError:

954

device_remove_class_symlinks(dev);

954

device_remove_class_symlinks(dev);

955

SymlinkError:

955

SymlinkError:

956

if (MAJOR(dev->devt))

956

if (MAJOR(dev->devt))

957

device_remove_sys_dev_entry(dev);

957

device_remove_sys_dev_entry(dev);

958

devtattrError:

958

devtattrError:

959

if (MAJOR(dev->devt))

959

if (MAJOR(dev->devt))

960

device_remove_file(dev, &devt_attr);

960

device_remove_file(dev, &devt_attr);

961

ueventattrError:

961

ueventattrError:

962

device_remove_file(dev, &uevent_attr);

962

device_remove_file(dev, &uevent_attr);

963

attrError:

963

attrError:

964

kobject_uevent(&dev->kobj, KOBJ_REMOVE);

964

kobject_uevent(&dev->kobj, KOBJ_REMOVE);

965

kobject_del(&dev->kobj);

965

kobject_del(&dev->kobj);

966

Error:

966

Error:

967

cleanup_device_parent(dev);

967

cleanup_device_parent(dev);

968

if (parent)

968

if (parent)

969

put_device(parent);

969

put_device(parent);

970

goto done;

970

goto done;

971

}

971

}

972

973

/**

973

/**

974

* device_register - register a device with the system.

974

* device_register - register a device with the system.

975

* @dev: pointer to the device structure

975

* @dev: pointer to the device structure

976

*

976

*

977

* This happens in two clean steps - initialize the device

977

* This happens in two clean steps - initialize the device

978

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

978

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

979

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

979

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

980

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

980

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

981

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

981

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

982

* before it is added to the hierarchy.

982

* before it is added to the hierarchy.

983

*

983

*

984

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

984

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

985

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

985

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

986

* reference initialized in this function instead.

986

* reference initialized in this function instead.

987

*/

987

*/

988

int device_register(struct device *dev)

988

int device_register(struct device *dev)

989

{

989

{

990

device_initialize(dev);

990

device_initialize(dev);

991

return device_add(dev);

991

return device_add(dev);

992

}

992

}

993

994

/**

994

/**

995

* get_device - increment reference count for device.

995

* get_device - increment reference count for device.

996

* @dev: device.

996

* @dev: device.

997

*

997

*

998

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

998

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

999

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

999

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

1000

* pointer passed in.

1000

* pointer passed in.

1001

*/

1001

*/

1002

struct device *get_device(struct device *dev)

1002

struct device *get_device(struct device *dev)

1003

{

1003

{

1004

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

1004

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

1005

}

1005

}

1006

1007

/**

1007

/**

1008

* put_device - decrement reference count.

1008

* put_device - decrement reference count.

1009

* @dev: device in question.

1009

* @dev: device in question.

1010

*/

1010

*/

1011

void put_device(struct device *dev)

1011

void put_device(struct device *dev)

1012

{

1012

{

1013

/* might_sleep(); */

1013

/* might_sleep(); */

1014

if (dev)

1014

if (dev)

1015

kobject_put(&dev->kobj);

1015

kobject_put(&dev->kobj);

1016

}

1016

}

1017

1018

/**

1018

/**

1019

* device_del - delete device from system.

1019

* device_del - delete device from system.

1020

* @dev: device.

1020

* @dev: device.

1021

*

1021

*

1022

* This is the first part of the device unregistration

1022

* This is the first part of the device unregistration

1023

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

1023

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

1024

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

1024

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

1025

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

1025

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

1026

* from the kobject hierarchy.

1026

* from the kobject hierarchy.

1027

*

1027

*

1028

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

1028

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

1029

* also called manually.

1029

* also called manually.

1030

*/

1030

*/

1031

void device_del(struct device *dev)

1031

void device_del(struct device *dev)

1032

{

1032

{

1033

struct device *parent = dev->parent;

1033

struct device *parent = dev->parent;

1034

struct class_interface *class_intf;

1034

struct class_interface *class_intf;

1035

1036

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

1036

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

1037

* before dpm_sysfs_remove().

1037

* before dpm_sysfs_remove().

1038

*/

1038

*/

1039

if (dev->bus)

1039

if (dev->bus)

1040

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

1040

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

1041

BUS_NOTIFY_DEL_DEVICE, dev);

1041

BUS_NOTIFY_DEL_DEVICE, dev);

1042

device_pm_remove(dev);

1042

device_pm_remove(dev);

1043

dpm_sysfs_remove(dev);

1043

dpm_sysfs_remove(dev);

1044

if (parent)

1044

if (parent)

1045

klist_del(&dev->knode_parent);

1045

klist_del(&dev->knode_parent);

1046

if (MAJOR(dev->devt)) {

1046

if (MAJOR(dev->devt)) {

1047

device_remove_sys_dev_entry(dev);

1047

device_remove_sys_dev_entry(dev);

1048

device_remove_file(dev, &devt_attr);

1048

device_remove_file(dev, &devt_attr);

1049

}

1049

}

1050

if (dev->class) {

1050

if (dev->class) {

1051

device_remove_class_symlinks(dev);

1051

device_remove_class_symlinks(dev);

1052

1053

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

1053

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

1054

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

1054

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

1055

list_for_each_entry(class_intf,

1055

list_for_each_entry(class_intf,

1056

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

1056

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

1057

if (class_intf->remove_dev)

1057

if (class_intf->remove_dev)

1058

class_intf->remove_dev(dev, class_intf);

1058

class_intf->remove_dev(dev, class_intf);

1059

/* remove the device from the class list */

1059

/* remove the device from the class list */

1060

klist_del(&dev->knode_class);

1060

klist_del(&dev->knode_class);

1061

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

1061

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

1062

}

1062

}

1063

device_remove_file(dev, &uevent_attr);

1063

device_remove_file(dev, &uevent_attr);

1064

device_remove_attrs(dev);

1064

device_remove_attrs(dev);

1065

bus_remove_device(dev);

1065

bus_remove_device(dev);

1066

1067

/*

1067

/*

1068

* Some platform devices are driven without driver attached

1068

* Some platform devices are driven without driver attached

1069

* and managed resources may have been acquired. Make sure

1069

* and managed resources may have been acquired. Make sure

1070

* all resources are released.

1070

* all resources are released.

1071

*/

1071

*/

1072

devres_release_all(dev);

1072

devres_release_all(dev);

1073

1074

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

1074

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

1075

* need to do anything...

1075

* need to do anything...

1076

*/

1076

*/

1077

if (platform_notify_remove)

1077

if (platform_notify_remove)

1078

platform_notify_remove(dev);

1078

platform_notify_remove(dev);

1079

kobject_uevent(&dev->kobj, KOBJ_REMOVE);

1079

kobject_uevent(&dev->kobj, KOBJ_REMOVE);

1080

cleanup_device_parent(dev);

1080

cleanup_device_parent(dev);

1081

kobject_del(&dev->kobj);

1081

kobject_del(&dev->kobj);

1082

put_device(parent);

1082

put_device(parent);

1083

}

1083

}

1084

1085

/**

1085

/**

1086

* device_unregister - unregister device from system.

1086

* device_unregister - unregister device from system.

1087

* @dev: device going away.

1087

* @dev: device going away.

1088

*

1088

*

1089

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

1089

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

1090

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

1090

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

1091

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

1091

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

1092

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

1092

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

1093

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

1093

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

1094

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

1094

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

1095

*/

1095

*/

1096

void device_unregister(struct device *dev)

1096

void device_unregister(struct device *dev)

1097

{

1097

{

1098

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

1098

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

1099

device_del(dev);

1099

device_del(dev);

1100

put_device(dev);

1100

put_device(dev);

1101

}

1101

}

1102

1103

static struct device *next_device(struct klist_iter *i)

1103

static struct device *next_device(struct klist_iter *i)

1104

{

1104

{

1105

struct klist_node *n = klist_next(i);

1105

struct klist_node *n = klist_next(i);

1106

return n ? container_of(n, struct device, knode_parent) : NULL;

1106

return n ? container_of(n, struct device, knode_parent) : NULL;

1107

}

1107

}

1108

1109

/**

1109

/**

1110

* device_for_each_child - device child iterator.

1110

* device_for_each_child - device child iterator.

1111

* @parent: parent struct device.

1111

* @parent: parent struct device.

1112

* @data: data for the callback.

1112

* @data: data for the callback.

1113

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

1113

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

1114

*

1114

*

1115

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

1115

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

1116

* passing it @data.

1116

* passing it @data.

1117

*

1117

*

1118

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

1118

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

1119

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

1119

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

1120

*/

1120

*/

1121

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

1121

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

1122

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

1122

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

1123

{

1123

{

1124

struct klist_iter i;

1124

struct klist_iter i;

1125

struct device *child;

1125

struct device *child;

1126

int error = 0;

1126

int error = 0;

1127

1128

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

1128

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

1129

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

1129

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

1130

error = fn(child, data);

1130

error = fn(child, data);

1131

klist_iter_exit(&i);

1131

klist_iter_exit(&i);

1132

return error;

1132

return error;

1133

}

1133

}

1134

1135

/**

1135

/**

1136

* device_find_child - device iterator for locating a particular device.

1136

* device_find_child - device iterator for locating a particular device.

1137

* @parent: parent struct device

1137

* @parent: parent struct device

1138

* @data: Data to pass to match function

1138

* @data: Data to pass to match function

1139

* @match: Callback function to check device

1139

* @match: Callback function to check device

1140

*

1140

*

1141

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

1141

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

1142

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

1142

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

1143

* determined by the @match callback.

1143

* determined by the @match callback.

1144

*

1144

*

1145

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

1145

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

1146

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

1146

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

1147

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

1147

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

1148

* and not iterate over any more devices.

1148

* and not iterate over any more devices.

1149

*/

1149

*/

1150

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

1150

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

1151

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

1151

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

1152

{

1152

{

1153

struct klist_iter i;

1153

struct klist_iter i;

1154

struct device *child;

1154

struct device *child;

1155

1156

if (!parent)

1156

if (!parent)

1157

return NULL;

1157

return NULL;

1158

1159

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

1159

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

1160

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

1160

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

1161

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

1161

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

1162

break;

1162

break;

1163

klist_iter_exit(&i);

1163

klist_iter_exit(&i);

1164

return child;

1164

return child;

1165

}

1165

}

1166

1167

int __init devices_init(void)

1167

int __init devices_init(void)

1168

{

1168

{

1169

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

1169

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

1170

if (!devices_kset)

1170

if (!devices_kset)

1171

return -ENOMEM;

1171

return -ENOMEM;

1172

dev_kobj = kobject_create_and_add("dev", NULL);

1172

dev_kobj = kobject_create_and_add("dev", NULL);

1173

if (!dev_kobj)

1173

if (!dev_kobj)

1174

goto dev_kobj_err;

1174

goto dev_kobj_err;

1175

sysfs_dev_block_kobj = kobject_create_and_add("block", dev_kobj);

1175

sysfs_dev_block_kobj = kobject_create_and_add("block", dev_kobj);

1176

if (!sysfs_dev_block_kobj)

1176

if (!sysfs_dev_block_kobj)

1177

goto block_kobj_err;

1177

goto block_kobj_err;

1178

sysfs_dev_char_kobj = kobject_create_and_add("char", dev_kobj);

1178

sysfs_dev_char_kobj = kobject_create_and_add("char", dev_kobj);

1179

if (!sysfs_dev_char_kobj)

1179

if (!sysfs_dev_char_kobj)

1180

goto char_kobj_err;

1180

goto char_kobj_err;

1181

1182

return 0;

1182

return 0;

1183

1184

char_kobj_err:

1184

char_kobj_err:

1185

kobject_put(sysfs_dev_block_kobj);

1185

kobject_put(sysfs_dev_block_kobj);

1186

block_kobj_err:

1186

block_kobj_err:

1187

kobject_put(dev_kobj);

1187

kobject_put(dev_kobj);

1188

dev_kobj_err:

1188

dev_kobj_err:

1189

kset_unregister(devices_kset);

1189

kset_unregister(devices_kset);

1190

return -ENOMEM;

1190

return -ENOMEM;

1191

}

1191

}

1192

1193

EXPORT_SYMBOL_GPL(device_for_each_child);

1193

EXPORT_SYMBOL_GPL(device_for_each_child);

1194

EXPORT_SYMBOL_GPL(device_find_child);

1194

EXPORT_SYMBOL_GPL(device_find_child);

1195

1196

EXPORT_SYMBOL_GPL(device_initialize);

1196

EXPORT_SYMBOL_GPL(device_initialize);

1197

EXPORT_SYMBOL_GPL(device_add);

1197

EXPORT_SYMBOL_GPL(device_add);

1198

EXPORT_SYMBOL_GPL(device_register);

1198

EXPORT_SYMBOL_GPL(device_register);

1199

1200

EXPORT_SYMBOL_GPL(device_del);

1200

EXPORT_SYMBOL_GPL(device_del);

1201

EXPORT_SYMBOL_GPL(device_unregister);

1201

EXPORT_SYMBOL_GPL(device_unregister);

1202

EXPORT_SYMBOL_GPL(get_device);

1202

EXPORT_SYMBOL_GPL(get_device);

1203

EXPORT_SYMBOL_GPL(put_device);

1203

EXPORT_SYMBOL_GPL(put_device);

1204

1205

EXPORT_SYMBOL_GPL(device_create_file);

1205

EXPORT_SYMBOL_GPL(device_create_file);

1206

EXPORT_SYMBOL_GPL(device_remove_file);

1206

EXPORT_SYMBOL_GPL(device_remove_file);

1207

1208

struct root_device

1208

struct root_device

1209

{

1209

{

1210

struct device dev;

1210

struct device dev;

1211

struct module *owner;

1211

struct module *owner;

1212

};

1212

};

1213

1214

#define to_root_device(dev) container_of(dev, struct root_device, dev)

1214

#define to_root_device(dev) container_of(dev, struct root_device, dev)

1215

1216

static void root_device_release(struct device *dev)

1216

static void root_device_release(struct device *dev)

1217

{

1217

{

1218

kfree(to_root_device(dev));

1218

kfree(to_root_device(dev));

1219

}

1219

}

1220

1221

/**

1221

/**

1222

* __root_device_register - allocate and register a root device

1222

* __root_device_register - allocate and register a root device

1223

* @name: root device name

1223

* @name: root device name

1224

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

1224

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

1225

*

1225

*

1226

* This function allocates a root device and registers it

1226

* This function allocates a root device and registers it

1227

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

1227

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

1228

* device, use root_device_unregister().

1228

* device, use root_device_unregister().

1229

*

1229

*

1230

* Root devices are dummy devices which allow other devices

1230

* Root devices are dummy devices which allow other devices

1231

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

1231

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

1232

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

1232

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

1233

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

1233

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

1234

*

1234

*

1235

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

1235

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

1236

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

1236

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

1237

* in sysfs.

1237

* in sysfs.

1238

*

1238

*

1239

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

1239

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

1240

*/

1240

*/

1241

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

1241

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

1242

{

1242

{

1243

struct root_device *root;

1243

struct root_device *root;

1244

int err = -ENOMEM;

1244

int err = -ENOMEM;

1245

1246

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

1246

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

1247

if (!root)

1247

if (!root)

1248

return ERR_PTR(err);

1248

return ERR_PTR(err);

1249

1250

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

1250

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

1251

if (err) {

1251

if (err) {

1252

kfree(root);

1252

kfree(root);

1253

return ERR_PTR(err);

1253

return ERR_PTR(err);

1254

}

1254

}

1255

1256

root->dev.release = root_device_release;

1256

root->dev.release = root_device_release;

1257

1258

err = device_register(&root->dev);

1258

err = device_register(&root->dev);

1259

if (err) {

1259

if (err) {

1260

put_device(&root->dev);

1260

put_device(&root->dev);

1261

return ERR_PTR(err);

1261

return ERR_PTR(err);

1262

}

1262

}

1263

1264

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

1264

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

1265

if (owner) {

1265

if (owner) {

1266

struct module_kobject *mk = &owner->mkobj;

1266

struct module_kobject *mk = &owner->mkobj;

1267

1268

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

1268

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

1269

if (err) {

1269

if (err) {

1270

device_unregister(&root->dev);

1270

device_unregister(&root->dev);

1271

return ERR_PTR(err);

1271

return ERR_PTR(err);

1272

}

1272

}

1273

root->owner = owner;

1273

root->owner = owner;

1274

}

1274

}

1275

#endif

1275

#endif

1276

1277

return &root->dev;

1277

return &root->dev;

1278

}

1278

}

1279

EXPORT_SYMBOL_GPL(__root_device_register);

1279

EXPORT_SYMBOL_GPL(__root_device_register);

1280

1281

/**

1281

/**

1282

* root_device_unregister - unregister and free a root device

1282

* root_device_unregister - unregister and free a root device

1283

* @root: device going away.

1283

* @dev: device going away

1284

*

1284

*

1285

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

1285

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

1286

* root_device_register().

1286

* root_device_register().

1287

*/

1287

*/

1288

void root_device_unregister(struct device *dev)

1288

void root_device_unregister(struct device *dev)

1289

{

1289

{

1290

struct root_device *root = to_root_device(dev);

1290

struct root_device *root = to_root_device(dev);

1291

1292

if (root->owner)

1292

if (root->owner)

1293

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

1293

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

1294

1295

device_unregister(dev);

1295

device_unregister(dev);

1296

}

1296

}

1297

EXPORT_SYMBOL_GPL(root_device_unregister);

1297

EXPORT_SYMBOL_GPL(root_device_unregister);

1298

1299

1300

static void device_create_release(struct device *dev)

1300

static void device_create_release(struct device *dev)

1301

{

1301

{

1302

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

1302

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

1303

kfree(dev);

1303

kfree(dev);

1304

}

1304

}

1305

1306

/**

1306

/**

1307

* device_create_vargs - creates a device and registers it with sysfs

1307

* device_create_vargs - creates a device and registers it with sysfs

1308

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

1308

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

1309

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

1309

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

1310

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

1310

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

1311

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

1311

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

1312

* @fmt: string for the device's name

1312

* @fmt: string for the device's name

1313

* @args: va_list for the device's name

1313

* @args: va_list for the device's name

1314

*

1314

*

1315

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

1315

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

1316

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

1316

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

1317

*

1317

*

1318

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

1318

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

1319

* the dev_t is not 0,0.

1319

* the dev_t is not 0,0.

1320

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

1320

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

1321

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

1321

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

1322

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

1322

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

1323

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

1323

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

1324

* pointer.

1324

* pointer.

1325

*

1325

*

1326

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

1326

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

1327

* been created with a call to class_create().

1327

* been created with a call to class_create().

1328

*/

1328

*/

1329

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

1329

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

1330

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

1330

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

1331

va_list args)

1331

va_list args)

1332

{

1332

{

1333

struct device *dev = NULL;

1333

struct device *dev = NULL;

1334

int retval = -ENODEV;

1334

int retval = -ENODEV;

1335

1336

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

1336

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

1337

goto error;

1337

goto error;

1338

1339

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

1339

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

1340

if (!dev) {

1340

if (!dev) {

1341

retval = -ENOMEM;

1341

retval = -ENOMEM;

1342

goto error;

1342

goto error;

1343

}

1343

}

1344

1345

dev->devt = devt;

1345

dev->devt = devt;

1346

dev->class = class;

1346

dev->class = class;

1347

dev->parent = parent;

1347

dev->parent = parent;

1348

dev->release = device_create_release;

1348

dev->release = device_create_release;

1349

dev_set_drvdata(dev, drvdata);

1349

dev_set_drvdata(dev, drvdata);

1350

1351

vsnprintf(dev->bus_id, BUS_ID_SIZE, fmt, args);

1351

vsnprintf(dev->bus_id, BUS_ID_SIZE, fmt, args);

1352

retval = device_register(dev);

1352

retval = device_register(dev);

1353

if (retval)

1353

if (retval)

1354

goto error;

1354

goto error;

1355

1356

return dev;

1356

return dev;

1357

1358

error:

1358

error:

1359

put_device(dev);

1359

put_device(dev);

1360

return ERR_PTR(retval);

1360

return ERR_PTR(retval);

1361

}

1361

}

1362

EXPORT_SYMBOL_GPL(device_create_vargs);

1362

EXPORT_SYMBOL_GPL(device_create_vargs);

1363

1364

/**

1364

/**

1365

* device_create - creates a device and registers it with sysfs

1365

* device_create - creates a device and registers it with sysfs

1366

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

1366

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

1367

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

1367

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

1368

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

1368

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

1369

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

1369

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

1370

* @fmt: string for the device's name

1370

* @fmt: string for the device's name

1371

*

1371

*

1372

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

1372

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

1373

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

1373

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

1374

*

1374

*

1375

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

1375

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

1376

* the dev_t is not 0,0.

1376

* the dev_t is not 0,0.

1377

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

1377

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

1378

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

1378

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

1379

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

1379

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

1380

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

1380

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

1381

* pointer.

1381

* pointer.

1382

*

1382

*

1383

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

1383

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

1384

* been created with a call to class_create().

1384

* been created with a call to class_create().

1385

*/

1385

*/

1386

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

1386

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

1387

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

1387

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

1388

{

1388

{

1389

va_list vargs;

1389

va_list vargs;

1390

struct device *dev;

1390

struct device *dev;

1391

1392

va_start(vargs, fmt);

1392

va_start(vargs, fmt);

1393

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

1393

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

1394

va_end(vargs);

1394

va_end(vargs);

1395

return dev;

1395

return dev;

1396

}

1396

}

1397

EXPORT_SYMBOL_GPL(device_create);

1397

EXPORT_SYMBOL_GPL(device_create);

1398

1399

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

1399

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

1400

{

1400

{

1401

dev_t *devt = data;

1401

dev_t *devt = data;

1402

1403

return dev->devt == *devt;

1403

return dev->devt == *devt;

1404

}

1404

}

1405

1406

/**

1406

/**

1407

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

1407

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

1408

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

1408

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

1409

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

1409

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

1410

*

1410

*

1411

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

1411

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

1412

* call to device_create().

1412

* call to device_create().

1413

*/

1413

*/

1414

void device_destroy(struct class *class, dev_t devt)

1414

void device_destroy(struct class *class, dev_t devt)

1415

{

1415

{

1416

struct device *dev;

1416

struct device *dev;

1417

1418

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

1418

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

1419

if (dev) {

1419

if (dev) {

1420

put_device(dev);

1420

put_device(dev);

1421

device_unregister(dev);

1421

device_unregister(dev);

1422

}

1422

}

1423

}

1423

}

1424

EXPORT_SYMBOL_GPL(device_destroy);

1424

EXPORT_SYMBOL_GPL(device_destroy);

1425

1426

/**

1426

/**

1427

* device_rename - renames a device

1427

* device_rename - renames a device

1428

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

1428

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

1429

* @new_name: the new name of the device

1429

* @new_name: the new name of the device

1430

*

1430

*

1431

* It is the responsibility of the caller to provide mutual

1431

* It is the responsibility of the caller to provide mutual

1432

* exclusion between two different calls of device_rename

1432

* exclusion between two different calls of device_rename

1433

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

1433

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

1434

* won't conflict with other devices.

1434

* won't conflict with other devices.

1435

*/

1435

*/

1436

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

1436

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

1437

{

1437

{

1438

char *old_class_name = NULL;

1438

char *old_class_name = NULL;

1439

char *new_class_name = NULL;

1439

char *new_class_name = NULL;

1440

char *old_device_name = NULL;

1440

char *old_device_name = NULL;

1441

int error;

1441

int error;

1442

1443

dev = get_device(dev);

1443

dev = get_device(dev);

1444

if (!dev)

1444

if (!dev)

1445

return -EINVAL;

1445

return -EINVAL;

1446

1447

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

1447

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

1448

__func__, new_name);

1448

__func__, new_name);

1449

1450

#ifdef CONFIG_SYSFS_DEPRECATED

1450

#ifdef CONFIG_SYSFS_DEPRECATED

1451

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

1451

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

1452

old_class_name = make_class_name(dev->class->name, &dev->kobj);

1452

old_class_name = make_class_name(dev->class->name, &dev->kobj);

1453

#endif

1453

#endif

1454

1455

old_device_name = kmalloc(BUS_ID_SIZE, GFP_KERNEL);

1455

old_device_name = kmalloc(BUS_ID_SIZE, GFP_KERNEL);

1456

if (!old_device_name) {

1456

if (!old_device_name) {

1457

error = -ENOMEM;

1457

error = -ENOMEM;

1458

goto out;

1458

goto out;

1459

}

1459

}

1460

strlcpy(old_device_name, dev->bus_id, BUS_ID_SIZE);

1460

strlcpy(old_device_name, dev->bus_id, BUS_ID_SIZE);

1461

strlcpy(dev->bus_id, new_name, BUS_ID_SIZE);

1461

strlcpy(dev->bus_id, new_name, BUS_ID_SIZE);

1462

1463

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

1463

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

1464

if (error) {

1464

if (error) {

1465

strlcpy(dev->bus_id, old_device_name, BUS_ID_SIZE);

1465

strlcpy(dev->bus_id, old_device_name, BUS_ID_SIZE);

1466

goto out;

1466

goto out;

1467

}

1467

}

1468

1469

#ifdef CONFIG_SYSFS_DEPRECATED

1469

#ifdef CONFIG_SYSFS_DEPRECATED

1470

if (old_class_name) {

1470

if (old_class_name) {

1471

new_class_name = make_class_name(dev->class->name, &dev->kobj);

1471

new_class_name = make_class_name(dev->class->name, &dev->kobj);

1472

if (new_class_name) {

1472

if (new_class_name) {

1473

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

1473

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

1474

&dev->kobj,

1474

&dev->kobj,

1475

new_class_name);

1475

new_class_name);

1476

if (error)

1476

if (error)

1477

goto out;

1477

goto out;

1478

sysfs_remove_link(&dev->parent->kobj, old_class_name);

1478

sysfs_remove_link(&dev->parent->kobj, old_class_name);

1479

}

1479

}

1480

}

1480

}

1481

#else

1481

#else

1482

if (dev->class) {

1482

if (dev->class) {

1483

error = sysfs_create_link_nowarn(&dev->class->p->class_subsys.kobj,

1483

error = sysfs_create_link_nowarn(&dev->class->p->class_subsys.kobj,

1484

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

1484

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

1485

if (error)

1485

if (error)

1486

goto out;

1486

goto out;

1487

sysfs_remove_link(&dev->class->p->class_subsys.kobj,

1487

sysfs_remove_link(&dev->class->p->class_subsys.kobj,

1488

old_device_name);

1488

old_device_name);

1489

}

1489

}

1490

#endif

1490

#endif

1491

1492

out:

1492

out:

1493

put_device(dev);

1493

put_device(dev);

1494

1495

kfree(new_class_name);

1495

kfree(new_class_name);

1496

kfree(old_class_name);

1496

kfree(old_class_name);

1497

kfree(old_device_name);

1497

kfree(old_device_name);

1498

1499

return error;

1499

return error;

1500

}

1500

}

1501

EXPORT_SYMBOL_GPL(device_rename);

1501

EXPORT_SYMBOL_GPL(device_rename);

1502

1503

static int device_move_class_links(struct device *dev,

1503

static int device_move_class_links(struct device *dev,

1504

struct device *old_parent,

1504

struct device *old_parent,

1505

struct device *new_parent)

1505

struct device *new_parent)

1506

{

1506

{

1507

int error = 0;

1507

int error = 0;

1508

#ifdef CONFIG_SYSFS_DEPRECATED

1508

#ifdef CONFIG_SYSFS_DEPRECATED

1509

char *class_name;

1509

char *class_name;

1510

1511

class_name = make_class_name(dev->class->name, &dev->kobj);

1511

class_name = make_class_name(dev->class->name, &dev->kobj);

1512

if (!class_name) {

1512

if (!class_name) {

1513

error = -ENOMEM;

1513

error = -ENOMEM;

1514

goto out;

1514

goto out;

1515

}

1515

}

1516

if (old_parent) {

1516

if (old_parent) {

1517

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

1517

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

1518

sysfs_remove_link(&old_parent->kobj, class_name);

1518

sysfs_remove_link(&old_parent->kobj, class_name);

1519

}

1519

}

1520

if (new_parent) {

1520

if (new_parent) {

1521

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

1521

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

1522

"device");

1522

"device");

1523

if (error)

1523

if (error)

1524

goto out;

1524

goto out;

1525

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

1525

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

1526

class_name);

1526

class_name);

1527

if (error)

1527

if (error)

1528

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

1528

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

1529

} else

1529

} else

1530

error = 0;

1530

error = 0;

1531

out:

1531

out:

1532

kfree(class_name);

1532

kfree(class_name);

1533

return error;

1533

return error;

1534

#else

1534

#else

1535

if (old_parent)

1535

if (old_parent)

1536

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

1536

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

1537

if (new_parent)

1537

if (new_parent)

1538

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

1538

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

1539

"device");

1539

"device");

1540

return error;

1540

return error;

1541

#endif

1541

#endif

1542

}

1542

}

1543

1544

/**

1544

/**

1545

* device_move - moves a device to a new parent

1545

* device_move - moves a device to a new parent

1546

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

1546

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

1547

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

1547

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

1548

*/

1548

*/

1549

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

1549

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

1550

{

1550

{

1551

int error;

1551

int error;

1552

struct device *old_parent;

1552

struct device *old_parent;

1553

struct kobject *new_parent_kobj;

1553

struct kobject *new_parent_kobj;

1554

1555

dev = get_device(dev);

1555

dev = get_device(dev);

1556

if (!dev)

1556

if (!dev)

1557

return -EINVAL;

1557

return -EINVAL;

1558

1559

new_parent = get_device(new_parent);

1559

new_parent = get_device(new_parent);

1560

new_parent_kobj = get_device_parent(dev, new_parent);

1560

new_parent_kobj = get_device_parent(dev, new_parent);

1561

1562

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

1562

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

1563

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

1563

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

1564

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

1564

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

1565

if (error) {

1565

if (error) {

1566

cleanup_glue_dir(dev, new_parent_kobj);

1566

cleanup_glue_dir(dev, new_parent_kobj);

1567

put_device(new_parent);

1567

put_device(new_parent);

1568

goto out;

1568

goto out;

1569

}

1569

}

1570

old_parent = dev->parent;

1570

old_parent = dev->parent;

1571

dev->parent = new_parent;

1571

dev->parent = new_parent;

1572

if (old_parent)

1572

if (old_parent)

1573

klist_remove(&dev->knode_parent);

1573

klist_remove(&dev->knode_parent);

1574

if (new_parent) {

1574

if (new_parent) {

1575

klist_add_tail(&dev->knode_parent, &new_parent->klist_children);

1575

klist_add_tail(&dev->knode_parent, &new_parent->klist_children);

1576

set_dev_node(dev, dev_to_node(new_parent));

1576

set_dev_node(dev, dev_to_node(new_parent));

1577

}

1577

}

1578

1579

if (!dev->class)

1579

if (!dev->class)

1580

goto out_put;

1580

goto out_put;

1581

error = device_move_class_links(dev, old_parent, new_parent);

1581

error = device_move_class_links(dev, old_parent, new_parent);

1582

if (error) {

1582

if (error) {

1583

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

1583

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

1584

device_move_class_links(dev, new_parent, old_parent);

1584

device_move_class_links(dev, new_parent, old_parent);

1585

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

1585

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

1586

if (new_parent)

1586

if (new_parent)

1587

klist_remove(&dev->knode_parent);

1587

klist_remove(&dev->knode_parent);

1588

dev->parent = old_parent;

1588

dev->parent = old_parent;

1589

if (old_parent) {

1589

if (old_parent) {

1590

klist_add_tail(&dev->knode_parent,

1590

klist_add_tail(&dev->knode_parent,

1591

&old_parent->klist_children);

1591

&old_parent->klist_children);

1592

set_dev_node(dev, dev_to_node(old_parent));

1592

set_dev_node(dev, dev_to_node(old_parent));

1593

}

1593

}

1594

}

1594

}

1595

cleanup_glue_dir(dev, new_parent_kobj);

1595

cleanup_glue_dir(dev, new_parent_kobj);

1596

put_device(new_parent);

1596

put_device(new_parent);

1597

goto out;

1597

goto out;

1598

}

1598

}

1599

out_put:

1599

out_put:

1600

put_device(old_parent);

1600

put_device(old_parent);

1601

out:

1601

out:

1602

put_device(dev);

1602

put_device(dev);

1603

return error;

1603

return error;

1604

}

1604

}

1605

EXPORT_SYMBOL_GPL(device_move);

1605

EXPORT_SYMBOL_GPL(device_move);

1606

1607

/**

1607

/**

1608

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

1608

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

1609

*/

1609

*/

1610

void device_shutdown(void)

1610

void device_shutdown(void)

1611

{

1611

{

1612

struct device *dev, *devn;

1612

struct device *dev, *devn;

1613

1614

list_for_each_entry_safe_reverse(dev, devn, &devices_kset->list,

1614

list_for_each_entry_safe_reverse(dev, devn, &devices_kset->list,

1615

kobj.entry) {

1615

kobj.entry) {

1616

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

1616

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

1617

dev_dbg(dev, "shutdown\n");

1617

dev_dbg(dev, "shutdown\n");

1618

dev->bus->shutdown(dev);

1618

dev->bus->shutdown(dev);

1619

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

1619

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

1620

dev_dbg(dev, "shutdown\n");

1620

dev_dbg(dev, "shutdown\n");

1621

dev->driver->shutdown(dev);

1621

dev->driver->shutdown(dev);

1622

}

1622

}

1623

}

1623

}

1624

kobject_put(sysfs_dev_char_kobj);

1624

kobject_put(sysfs_dev_char_kobj);

1625

kobject_put(sysfs_dev_block_kobj);

1625

kobject_put(sysfs_dev_block_kobj);

1626

kobject_put(dev_kobj);

1626

kobject_put(dev_kobj);

1627

}

1627

}

1628

GITLAB

Eric Lee / smarc-fsl-linux-kernel

driver-core: fix kernel-doc parameter name