Programming Languages Research Group: Git - firefly-linux-kernel-4.4.55.git/blob

1 /*

2 * w1.c

3 *

5 *

6 *

7 * This program is free software; you can redistribute it and/or modify

8 * it under the terms of the GNU General Public License as published by

9 * the Free Software Foundation; either version 2 of the License, or

10 * (at your option) any later version.

11 *

12 * This program is distributed in the hope that it will be useful,

13 * but WITHOUT ANY WARRANTY; without even the implied warranty of

14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

15 * GNU General Public License for more details.

16 *

17 * You should have received a copy of the GNU General Public License

18 * along with this program; if not, write to the Free Software

19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

20 */

22 #include <linux/delay.h>

23 #include <linux/kernel.h>

24 #include <linux/module.h>

25 #include <linux/moduleparam.h>

26 #include <linux/list.h>

27 #include <linux/interrupt.h>

28 #include <linux/spinlock.h>

29 #include <linux/timer.h>

30 #include <linux/device.h>

31 #include <linux/slab.h>

32 #include <linux/sched.h>

33 #include <linux/kthread.h>

34 #include <linux/freezer.h>

36 #include <linux/atomic.h>

38 #include "w1.h"

39 #include "w1_log.h"

40 #include "w1_int.h"

41 #include "w1_family.h"

42 #include "w1_netlink.h"

44 MODULE_LICENSE("GPL");

45 MODULE_AUTHOR("Evgeniy Polyakov <zbr@ioremap.net>");

46 MODULE_DESCRIPTION("Driver for 1-wire Dallas network protocol.");

48 static int w1_timeout = 10;

49 int w1_max_slave_count = 10;

50 int w1_max_slave_ttl = 10;

52 module_param_named(timeout, w1_timeout, int, 0);

53 module_param_named(max_slave_count, w1_max_slave_count, int, 0);

54 module_param_named(slave_ttl, w1_max_slave_ttl, int, 0);

56 DEFINE_MUTEX(w1_mlock);

57 LIST_HEAD(w1_masters);

59 static int w1_attach_slave_device(struct w1_master *dev, struct w1_reg_num *rn);

61 static int w1_master_match(struct device *dev, struct device_driver *drv)

62 {

63 return 1;

64 }

66 static int w1_master_probe(struct device *dev)

67 {

68 return -ENODEV;

69 }

71 static void w1_master_release(struct device *dev)

72 {

73 struct w1_master *md = dev_to_w1_master(dev);

75 dev_dbg(dev, "%s: Releasing %s.\n", __func__, md->name);

76 memset(md, 0, sizeof(struct w1_master) + sizeof(struct w1_bus_master));

77 kfree(md);

78 }

80 static void w1_slave_release(struct device *dev)

81 {

82 struct w1_slave *sl = dev_to_w1_slave(dev);

84 dev_dbg(dev, "%s: Releasing %s.\n", __func__, sl->name);

86 while (atomic_read(&sl->refcnt)) {

87 dev_dbg(dev, "Waiting for %s to become free: refcnt=%d.\n",

88 sl->name, atomic_read(&sl->refcnt));

89 if (msleep_interruptible(1000))

90 flush_signals(current);

91 }

93 w1_family_put(sl->family);

94 sl->master->slave_count--;

96 complete(&sl->released);

97 }

99 static ssize_t w1_slave_read_name(struct device *dev, struct device_attribute *attr, char *buf)

100 {

101 struct w1_slave *sl = dev_to_w1_slave(dev);

102

103 return sprintf(buf, "%s\n", sl->name);

104 }

105

106 static ssize_t w1_slave_read_id(struct device *dev,

107 struct device_attribute *attr, char *buf)

108 {

109 struct w1_slave *sl = dev_to_w1_slave(dev);

110 ssize_t count = sizeof(sl->reg_num);

111

112 memcpy(buf, (u8 *)&sl->reg_num, count);

113 return count;

114 }

115

116 static struct device_attribute w1_slave_attr_name =

117 __ATTR(name, S_IRUGO, w1_slave_read_name, NULL);

118 static struct device_attribute w1_slave_attr_id =

119 __ATTR(id, S_IRUGO, w1_slave_read_id, NULL);

120

121 /* Default family */

122

123 static ssize_t w1_default_write(struct file *filp, struct kobject *kobj,

124 struct bin_attribute *bin_attr,

125 char *buf, loff_t off, size_t count)

126 {

127 struct w1_slave *sl = kobj_to_w1_slave(kobj);

128

129 mutex_lock(&sl->master->mutex);

130 if (w1_reset_select_slave(sl)) {

131 count = 0;

132 goto out_up;

133 }

134

135 w1_write_block(sl->master, buf, count);

136

137 out_up:

138 mutex_unlock(&sl->master->mutex);

139 return count;

140 }

141

142 static ssize_t w1_default_read(struct file *filp, struct kobject *kobj,

143 struct bin_attribute *bin_attr,

144 char *buf, loff_t off, size_t count)

145 {

146 struct w1_slave *sl = kobj_to_w1_slave(kobj);

147

148 mutex_lock(&sl->master->mutex);

149 w1_read_block(sl->master, buf, count);

150 mutex_unlock(&sl->master->mutex);

151 return count;

152 }

153

154 static struct bin_attribute w1_default_attr = {

155 .attr = {

156 .name = "rw",

157 .mode = S_IRUGO | S_IWUSR,

158 },

159 .size = PAGE_SIZE,

160 .read = w1_default_read,

161 .write = w1_default_write,

162 };

163

164 static int w1_default_add_slave(struct w1_slave *sl)

165 {

166 return sysfs_create_bin_file(&sl->dev.kobj, &w1_default_attr);

167 }

168

169 static void w1_default_remove_slave(struct w1_slave *sl)

170 {

171 sysfs_remove_bin_file(&sl->dev.kobj, &w1_default_attr);

172 }

173

174 static struct w1_family_ops w1_default_fops = {

175 .add_slave = w1_default_add_slave,

176 .remove_slave = w1_default_remove_slave,

177 };

178

179 static struct w1_family w1_default_family = {

180 .fops = &w1_default_fops,

181 };

182

183 static int w1_uevent(struct device *dev, struct kobj_uevent_env *env);

184

185 static struct bus_type w1_bus_type = {

186 .name = "w1",

187 .match = w1_master_match,

188 .uevent = w1_uevent,

189 };

190

191 struct device_driver w1_master_driver = {

192 .name = "w1_master_driver",

193 .bus = &w1_bus_type,

194 .probe = w1_master_probe,

195 };

196

197 struct device w1_master_device = {

198 .parent = NULL,

199 .bus = &w1_bus_type,

200 .init_name = "w1 bus master",

201 .driver = &w1_master_driver,

202 .release = &w1_master_release

203 };

204

205 static struct device_driver w1_slave_driver = {

206 .name = "w1_slave_driver",

207 .bus = &w1_bus_type,

208 };

209

210 #if 0

211 struct device w1_slave_device = {

212 .parent = NULL,

213 .bus = &w1_bus_type,

214 .init_name = "w1 bus slave",

215 .driver = &w1_slave_driver,

216 .release = &w1_slave_release

217 };

218 #endif /* 0 */

219

220 static ssize_t w1_master_attribute_show_name(struct device *dev, struct device_attribute *attr, char *buf)

221 {

222 struct w1_master *md = dev_to_w1_master(dev);

223 ssize_t count;

224

225 mutex_lock(&md->mutex);

226 count = sprintf(buf, "%s\n", md->name);

227 mutex_unlock(&md->mutex);

228

229 return count;

230 }

231

232 static ssize_t w1_master_attribute_store_search(struct device * dev,

233 struct device_attribute *attr,

234 const char * buf, size_t count)

235 {

236 long tmp;

237 struct w1_master *md = dev_to_w1_master(dev);

238

239 if (strict_strtol(buf, 0, &tmp) == -EINVAL)

240 return -EINVAL;

241

242 mutex_lock(&md->mutex);

243 md->search_count = tmp;

244 mutex_unlock(&md->mutex);

245 wake_up_process(md->thread);

246

247 return count;

248 }

249

250 static ssize_t w1_master_attribute_show_search(struct device *dev,

251 struct device_attribute *attr,

252 char *buf)

253 {

254 struct w1_master *md = dev_to_w1_master(dev);

255 ssize_t count;

256

257 mutex_lock(&md->mutex);

258 count = sprintf(buf, "%d\n", md->search_count);

259 mutex_unlock(&md->mutex);

260

261 return count;

262 }

263

264 static ssize_t w1_master_attribute_store_pullup(struct device *dev,

265 struct device_attribute *attr,

266 const char *buf, size_t count)

267 {

268 long tmp;

269 struct w1_master *md = dev_to_w1_master(dev);

270

271 if (strict_strtol(buf, 0, &tmp) == -EINVAL)

272 return -EINVAL;

273

274 mutex_lock(&md->mutex);

275 md->enable_pullup = tmp;

276 mutex_unlock(&md->mutex);

277 wake_up_process(md->thread);

278

279 return count;

280 }

281

282 static ssize_t w1_master_attribute_show_pullup(struct device *dev,

283 struct device_attribute *attr,

284 char *buf)

285 {

286 struct w1_master *md = dev_to_w1_master(dev);

287 ssize_t count;

288

289 mutex_lock(&md->mutex);

290 count = sprintf(buf, "%d\n", md->enable_pullup);

291 mutex_unlock(&md->mutex);

292

293 return count;

294 }

295

296 static ssize_t w1_master_attribute_show_pointer(struct device *dev, struct device_attribute *attr, char *buf)

297 {

298 struct w1_master *md = dev_to_w1_master(dev);

299 ssize_t count;

300

301 mutex_lock(&md->mutex);

302 count = sprintf(buf, "0x%p\n", md->bus_master);

303 mutex_unlock(&md->mutex);

304 return count;

305 }

306

307 static ssize_t w1_master_attribute_show_timeout(struct device *dev, struct device_attribute *attr, char *buf)

308 {

309 ssize_t count;

310 count = sprintf(buf, "%d\n", w1_timeout);

311 return count;

312 }

313

314 static ssize_t w1_master_attribute_show_max_slave_count(struct device *dev, struct device_attribute *attr, char *buf)

315 {

316 struct w1_master *md = dev_to_w1_master(dev);

317 ssize_t count;

318

319 mutex_lock(&md->mutex);

320 count = sprintf(buf, "%d\n", md->max_slave_count);

321 mutex_unlock(&md->mutex);

322 return count;

323 }

324

325 static ssize_t w1_master_attribute_show_attempts(struct device *dev, struct device_attribute *attr, char *buf)

326 {

327 struct w1_master *md = dev_to_w1_master(dev);

328 ssize_t count;

329

330 mutex_lock(&md->mutex);

331 count = sprintf(buf, "%lu\n", md->attempts);

332 mutex_unlock(&md->mutex);

333 return count;

334 }

335

336 static ssize_t w1_master_attribute_show_slave_count(struct device *dev, struct device_attribute *attr, char *buf)

337 {

338 struct w1_master *md = dev_to_w1_master(dev);

339 ssize_t count;

340

341 mutex_lock(&md->mutex);

342 count = sprintf(buf, "%d\n", md->slave_count);

343 mutex_unlock(&md->mutex);

344 return count;

345 }

346

347 static ssize_t w1_master_attribute_show_slaves(struct device *dev,

348 struct device_attribute *attr, char *buf)

349 {

350 struct w1_master *md = dev_to_w1_master(dev);

351 int c = PAGE_SIZE;

352

353 mutex_lock(&md->mutex);

354

355 if (md->slave_count == 0)

356 c -= snprintf(buf + PAGE_SIZE - c, c, "not found.\n");

357 else {

358 struct list_head *ent, *n;

359 struct w1_slave *sl;

360

361 list_for_each_safe(ent, n, &md->slist) {

362 sl = list_entry(ent, struct w1_slave, w1_slave_entry);

363

364 c -= snprintf(buf + PAGE_SIZE - c, c, "%s\n", sl->name);

365 }

366 }

367

368 mutex_unlock(&md->mutex);

369

370 return PAGE_SIZE - c;

371 }

372

373 static ssize_t w1_master_attribute_show_add(struct device *dev,

374 struct device_attribute *attr, char *buf)

375 {

376 int c = PAGE_SIZE;

377 c -= snprintf(buf+PAGE_SIZE - c, c,

378 "write device id xx-xxxxxxxxxxxx to add slave\n");

379 return PAGE_SIZE - c;

380 }

381

382 static int w1_atoreg_num(struct device *dev, const char *buf, size_t count,

383 struct w1_reg_num *rn)

384 {

385 unsigned int family;

386 unsigned long long id;

387 int i;

388 u64 rn64_le;

389

390 /* The CRC value isn't read from the user because the sysfs directory

391 * doesn't include it and most messages from the bus search don't

392 * print it either. It would be unreasonable for the user to then

393 * provide it.

394 */

395 const char *error_msg = "bad slave string format, expecting "

396 "ff-dddddddddddd\n";

397

398 if (buf[2] != '-') {

399 dev_err(dev, "%s", error_msg);

400 return -EINVAL;

401 }

402 i = sscanf(buf, "%02x-%012llx", &family, &id);

403 if (i != 2) {

404 dev_err(dev, "%s", error_msg);

405 return -EINVAL;

406 }

407 rn->family = family;

408 rn->id = id;

409

410 rn64_le = cpu_to_le64(*(u64 *)rn);

411 rn->crc = w1_calc_crc8((u8 *)&rn64_le, 7);

412

413 #if 0

414 dev_info(dev, "With CRC device is %02x.%012llx.%02x.\n",

415 rn->family, (unsigned long long)rn->id, rn->crc);

416 #endif

417

418 return 0;

419 }

420

421 /* Searches the slaves in the w1_master and returns a pointer or NULL.

422 * Note: must hold the mutex

423 */

424 static struct w1_slave *w1_slave_search_device(struct w1_master *dev,

425 struct w1_reg_num *rn)

426 {

427 struct w1_slave *sl;

428 list_for_each_entry(sl, &dev->slist, w1_slave_entry) {

429 if (sl->reg_num.family == rn->family &&

430 sl->reg_num.id == rn->id &&

431 sl->reg_num.crc == rn->crc) {

432 return sl;

433 }

434 }

435 return NULL;

436 }

437

438 static ssize_t w1_master_attribute_store_add(struct device *dev,

439 struct device_attribute *attr,

440 const char *buf, size_t count)

441 {

442 struct w1_master *md = dev_to_w1_master(dev);

443 struct w1_reg_num rn;

444 struct w1_slave *sl;

445 ssize_t result = count;

446

447 if (w1_atoreg_num(dev, buf, count, &rn))

448 return -EINVAL;

449

450 mutex_lock(&md->mutex);

451 sl = w1_slave_search_device(md, &rn);

452 /* It would be nice to do a targeted search one the one-wire bus

453 * for the new device to see if it is out there or not. But the

454 * current search doesn't support that.

455 */

456 if (sl) {

457 dev_info(dev, "Device %s already exists\n", sl->name);

458 result = -EINVAL;

459 } else {

460 w1_attach_slave_device(md, &rn);

461 }

462 mutex_unlock(&md->mutex);

463

464 return result;

465 }

466

467 static ssize_t w1_master_attribute_show_remove(struct device *dev,

468 struct device_attribute *attr, char *buf)

469 {

470 int c = PAGE_SIZE;

471 c -= snprintf(buf+PAGE_SIZE - c, c,

472 "write device id xx-xxxxxxxxxxxx to remove slave\n");

473 return PAGE_SIZE - c;

474 }

475

476 static ssize_t w1_master_attribute_store_remove(struct device *dev,

477 struct device_attribute *attr,

478 const char *buf, size_t count)

479 {

480 struct w1_master *md = dev_to_w1_master(dev);

481 struct w1_reg_num rn;

482 struct w1_slave *sl;

483 ssize_t result = count;

484

485 if (w1_atoreg_num(dev, buf, count, &rn))

486 return -EINVAL;

487

488 mutex_lock(&md->mutex);

489 sl = w1_slave_search_device(md, &rn);

490 if (sl) {

491 w1_slave_detach(sl);

492 } else {

493 dev_info(dev, "Device %02x-%012llx doesn't exists\n", rn.family,

494 (unsigned long long)rn.id);

495 result = -EINVAL;

496 }

497 mutex_unlock(&md->mutex);

498

499 return result;

500 }

501

502 #define W1_MASTER_ATTR_RO(_name, _mode) \

503 struct device_attribute w1_master_attribute_##_name = \

504 __ATTR(w1_master_##_name, _mode, \

505 w1_master_attribute_show_##_name, NULL)

506

507 #define W1_MASTER_ATTR_RW(_name, _mode) \

508 struct device_attribute w1_master_attribute_##_name = \

509 __ATTR(w1_master_##_name, _mode, \

510 w1_master_attribute_show_##_name, \

511 w1_master_attribute_store_##_name)

512

513 static W1_MASTER_ATTR_RO(name, S_IRUGO);

514 static W1_MASTER_ATTR_RO(slaves, S_IRUGO);

515 static W1_MASTER_ATTR_RO(slave_count, S_IRUGO);

516 static W1_MASTER_ATTR_RO(max_slave_count, S_IRUGO);

517 static W1_MASTER_ATTR_RO(attempts, S_IRUGO);

518 static W1_MASTER_ATTR_RO(timeout, S_IRUGO);

519 static W1_MASTER_ATTR_RO(pointer, S_IRUGO);

520 static W1_MASTER_ATTR_RW(search, S_IRUGO | S_IWUSR | S_IWGRP);

521 static W1_MASTER_ATTR_RW(pullup, S_IRUGO | S_IWUSR | S_IWGRP);

522 static W1_MASTER_ATTR_RW(add, S_IRUGO | S_IWUSR | S_IWGRP);

523 static W1_MASTER_ATTR_RW(remove, S_IRUGO | S_IWUSR | S_IWGRP);

524

525 static struct attribute *w1_master_default_attrs[] = {

526 &w1_master_attribute_name.attr,

527 &w1_master_attribute_slaves.attr,

528 &w1_master_attribute_slave_count.attr,

529 &w1_master_attribute_max_slave_count.attr,

530 &w1_master_attribute_attempts.attr,

531 &w1_master_attribute_timeout.attr,

532 &w1_master_attribute_pointer.attr,

533 &w1_master_attribute_search.attr,

534 &w1_master_attribute_pullup.attr,

535 &w1_master_attribute_add.attr,

536 &w1_master_attribute_remove.attr,

537 NULL

538 };

539

540 static struct attribute_group w1_master_defattr_group = {

541 .attrs = w1_master_default_attrs,

542 };

543

544 int w1_create_master_attributes(struct w1_master *master)

545 {

546 return sysfs_create_group(&master->dev.kobj, &w1_master_defattr_group);

547 }

548

549 void w1_destroy_master_attributes(struct w1_master *master)

550 {

551 sysfs_remove_group(&master->dev.kobj, &w1_master_defattr_group);

552 }

553

554 #ifdef CONFIG_HOTPLUG

555 static int w1_uevent(struct device *dev, struct kobj_uevent_env *env)

556 {

557 struct w1_master *md = NULL;

558 struct w1_slave *sl = NULL;

559 char *event_owner, *name;

560 int err;

561

562 if (dev->driver == &w1_master_driver) {

563 md = container_of(dev, struct w1_master, dev);

564 event_owner = "master";

565 name = md->name;

566 } else if (dev->driver == &w1_slave_driver) {

567 sl = container_of(dev, struct w1_slave, dev);

568 event_owner = "slave";

569 name = sl->name;

570 } else {

571 dev_dbg(dev, "Unknown event.\n");

572 return -EINVAL;

573 }

574

575 dev_dbg(dev, "Hotplug event for %s %s, bus_id=%s.\n",

576 event_owner, name, dev_name(dev));

577

578 if (dev->driver != &w1_slave_driver || !sl)

579 return 0;

580

581 err = add_uevent_var(env, "W1_FID=%02X", sl->reg_num.family);

582 if (err)

583 return err;

584

585 err = add_uevent_var(env, "W1_SLAVE_ID=%024LX",

586 (unsigned long long)sl->reg_num.id);

587 if (err)

588 return err;

589

590 return 0;

591 };

592 #else

593 static int w1_uevent(struct device *dev, struct kobj_uevent_env *env)

594 {

595 return 0;

596 }

597 #endif

598

599 static int __w1_attach_slave_device(struct w1_slave *sl)

600 {

601 int err;

602

603 sl->dev.parent = &sl->master->dev;

604 sl->dev.driver = &w1_slave_driver;

605 sl->dev.bus = &w1_bus_type;

606 sl->dev.release = &w1_slave_release;

607

608 dev_set_name(&sl->dev, "%02x-%012llx",

609 (unsigned int) sl->reg_num.family,

610 (unsigned long long) sl->reg_num.id);

611 snprintf(&sl->name[0], sizeof(sl->name),

612 "%02x-%012llx",

613 (unsigned int) sl->reg_num.family,

614 (unsigned long long) sl->reg_num.id);

615

616 dev_dbg(&sl->dev, "%s: registering %s as %p.\n", __func__,

617 dev_name(&sl->dev), sl);

618

619 err = device_register(&sl->dev);

620 if (err < 0) {

621 dev_err(&sl->dev,

622 "Device registration [%s] failed. err=%d\n",

623 dev_name(&sl->dev), err);

624 return err;

625 }

626

627 /* Create "name" entry */

628 err = device_create_file(&sl->dev, &w1_slave_attr_name);

629 if (err < 0) {

630 dev_err(&sl->dev,

631 "sysfs file creation for [%s] failed. err=%d\n",

632 dev_name(&sl->dev), err);

633 goto out_unreg;

634 }

635

636 /* Create "id" entry */

637 err = device_create_file(&sl->dev, &w1_slave_attr_id);

638 if (err < 0) {

639 dev_err(&sl->dev,

640 "sysfs file creation for [%s] failed. err=%d\n",

641 dev_name(&sl->dev), err);

642 goto out_rem1;

643 }

644

645 /* if the family driver needs to initialize something... */

646 if (sl->family->fops && sl->family->fops->add_slave &&

647 ((err = sl->family->fops->add_slave(sl)) < 0)) {

648 dev_err(&sl->dev,

649 "sysfs file creation for [%s] failed. err=%d\n",

650 dev_name(&sl->dev), err);

651 goto out_rem2;

652 }

653

654 list_add_tail(&sl->w1_slave_entry, &sl->master->slist);

655

656 return 0;

657

658 out_rem2:

659 device_remove_file(&sl->dev, &w1_slave_attr_id);

660 out_rem1:

661 device_remove_file(&sl->dev, &w1_slave_attr_name);

662 out_unreg:

663 device_unregister(&sl->dev);

664 return err;

665 }

666

667 static int w1_attach_slave_device(struct w1_master *dev, struct w1_reg_num *rn)

668 {

669 struct w1_slave *sl;

670 struct w1_family *f;

671 int err;

672 struct w1_netlink_msg msg;

673

674 sl = kzalloc(sizeof(struct w1_slave), GFP_KERNEL);

675 if (!sl) {

676 dev_err(&dev->dev,

677 "%s: failed to allocate new slave device.\n",

678 __func__);

679 return -ENOMEM;

680 }

681

682

683 sl->owner = THIS_MODULE;

684 sl->master = dev;

685 set_bit(W1_SLAVE_ACTIVE, (long *)&sl->flags);

686

687 memset(&msg, 0, sizeof(msg));

688 memcpy(&sl->reg_num, rn, sizeof(sl->reg_num));

689 atomic_set(&sl->refcnt, 0);

690 init_completion(&sl->released);

691

692 spin_lock(&w1_flock);

693 f = w1_family_registered(rn->family);

694 if (!f) {

695 f= &w1_default_family;

696 dev_info(&dev->dev, "Family %x for %02x.%012llx.%02x is not registered.\n",

697 rn->family, rn->family,

698 (unsigned long long)rn->id, rn->crc);

699 }

700 __w1_family_get(f);

701 spin_unlock(&w1_flock);

702

703 sl->family = f;

704

705

706 err = __w1_attach_slave_device(sl);

707 if (err < 0) {

708 dev_err(&dev->dev, "%s: Attaching %s failed.\n", __func__,

709 sl->name);

710 w1_family_put(sl->family);

711 kfree(sl);

712 return err;

713 }

714

715 sl->ttl = dev->slave_ttl;

716 dev->slave_count++;

717

718 memcpy(msg.id.id, rn, sizeof(msg.id));

719 msg.type = W1_SLAVE_ADD;

720 w1_netlink_send(dev, &msg);

721

722 return 0;

723 }

724

725 void w1_slave_detach(struct w1_slave *sl)

726 {

727 struct w1_netlink_msg msg;

728

729 dev_dbg(&sl->dev, "%s: detaching %s [%p].\n", __func__, sl->name, sl);

730

731 list_del(&sl->w1_slave_entry);

732

733 if (sl->family->fops && sl->family->fops->remove_slave)

734 sl->family->fops->remove_slave(sl);

735

736 memset(&msg, 0, sizeof(msg));

737 memcpy(msg.id.id, &sl->reg_num, sizeof(msg.id));

738 msg.type = W1_SLAVE_REMOVE;

739 w1_netlink_send(sl->master, &msg);

740

741 device_remove_file(&sl->dev, &w1_slave_attr_id);

742 device_remove_file(&sl->dev, &w1_slave_attr_name);

743 device_unregister(&sl->dev);

744

745 wait_for_completion(&sl->released);

746 kfree(sl);

747 }

748

749 struct w1_master *w1_search_master_id(u32 id)

750 {

751 struct w1_master *dev;

752 int found = 0;

753

754 mutex_lock(&w1_mlock);

755 list_for_each_entry(dev, &w1_masters, w1_master_entry) {

756 if (dev->id == id) {

757 found = 1;

758 atomic_inc(&dev->refcnt);

759 break;

760 }

761 }

762 mutex_unlock(&w1_mlock);

763

764 return (found)?dev:NULL;

765 }

766

767 struct w1_slave *w1_search_slave(struct w1_reg_num *id)

768 {

769 struct w1_master *dev;

770 struct w1_slave *sl = NULL;

771 int found = 0;

772

773 mutex_lock(&w1_mlock);

774 list_for_each_entry(dev, &w1_masters, w1_master_entry) {

775 mutex_lock(&dev->mutex);

776 list_for_each_entry(sl, &dev->slist, w1_slave_entry) {

777 if (sl->reg_num.family == id->family &&

778 sl->reg_num.id == id->id &&

779 sl->reg_num.crc == id->crc) {

780 found = 1;

781 atomic_inc(&dev->refcnt);

782 atomic_inc(&sl->refcnt);

783 break;

784 }

785 }

786 mutex_unlock(&dev->mutex);

787

788 if (found)

789 break;

790 }

791 mutex_unlock(&w1_mlock);

792

793 return (found)?sl:NULL;

794 }

795

796 void w1_reconnect_slaves(struct w1_family *f, int attach)

797 {

798 struct w1_slave *sl, *sln;

799 struct w1_master *dev;

800

801 mutex_lock(&w1_mlock);

802 list_for_each_entry(dev, &w1_masters, w1_master_entry) {

803 dev_dbg(&dev->dev, "Reconnecting slaves in device %s "

804 "for family %02x.\n", dev->name, f->fid);

805 mutex_lock(&dev->mutex);

806 list_for_each_entry_safe(sl, sln, &dev->slist, w1_slave_entry) {

807 /* If it is a new family, slaves with the default

808 * family driver and are that family will be

809 * connected. If the family is going away, devices

810 * matching that family are reconneced.

811 */

812 if ((attach && sl->family->fid == W1_FAMILY_DEFAULT

813 && sl->reg_num.family == f->fid) ||

814 (!attach && sl->family->fid == f->fid)) {

815 struct w1_reg_num rn;

816

817 memcpy(&rn, &sl->reg_num, sizeof(rn));

818 w1_slave_detach(sl);

819

820 w1_attach_slave_device(dev, &rn);

821 }

822 }

823 dev_dbg(&dev->dev, "Reconnecting slaves in device %s "

824 "has been finished.\n", dev->name);

825 mutex_unlock(&dev->mutex);

826 }

827 mutex_unlock(&w1_mlock);

828 }

829

830 void w1_slave_found(struct w1_master *dev, u64 rn)

831 {

832 struct w1_slave *sl;

833 struct w1_reg_num *tmp;

834 u64 rn_le = cpu_to_le64(rn);

835

836 atomic_inc(&dev->refcnt);

837

838 tmp = (struct w1_reg_num *) &rn;

839

840 sl = w1_slave_search_device(dev, tmp);

841 if (sl) {

842 set_bit(W1_SLAVE_ACTIVE, (long *)&sl->flags);

843 } else {

844 if (rn && tmp->crc == w1_calc_crc8((u8 *)&rn_le, 7))

845 w1_attach_slave_device(dev, tmp);

846 }

847

848 atomic_dec(&dev->refcnt);

849 }

850

851 /**

852 * Performs a ROM Search & registers any devices found.

853 * The 1-wire search is a simple binary tree search.

854 * For each bit of the address, we read two bits and write one bit.

855 * The bit written will put to sleep all devies that don't match that bit.

856 * When the two reads differ, the direction choice is obvious.

857 * When both bits are 0, we must choose a path to take.

858 * When we can scan all 64 bits without having to choose a path, we are done.

859 *

860 * See "Application note 187 1-wire search algorithm" at www.maxim-ic.com

861 *

862 * @dev The master device to search

863 * @cb Function to call when a device is found

864 */

865 void w1_search(struct w1_master *dev, u8 search_type, w1_slave_found_callback cb)

866 {

867 u64 last_rn, rn, tmp64;

868 int i, slave_count = 0;

869 int last_zero, last_device;

870 int search_bit, desc_bit;

871 u8 triplet_ret = 0;

872

873 search_bit = 0;

874 rn = last_rn = 0;

875 last_device = 0;

876 last_zero = -1;

877

878 desc_bit = 64;

879

880 while ( !last_device && (slave_count++ < dev->max_slave_count) ) {

881 last_rn = rn;

882 rn = 0;

883

884 /*

885 * Reset bus and all 1-wire device state machines

886 * so they can respond to our requests.

887 *

888 * Return 0 - device(s) present, 1 - no devices present.

889 */

890 if (w1_reset_bus(dev)) {

891 dev_dbg(&dev->dev, "No devices present on the wire.\n");

892 break;

893 }

894

895 /* Do fast search on single slave bus */

896 if (dev->max_slave_count == 1) {

897 w1_write_8(dev, W1_READ_ROM);

898

899 if (w1_read_block(dev, (u8 *)&rn, 8) == 8 && rn)

900 cb(dev, rn);

901

902 break;

903 }

904

905 /* Start the search */

906 w1_write_8(dev, search_type);

907 for (i = 0; i < 64; ++i) {

908 /* Determine the direction/search bit */

909 if (i == desc_bit)

910 search_bit = 1; /* took the 0 path last time, so take the 1 path */

911 else if (i > desc_bit)

912 search_bit = 0; /* take the 0 path on the next branch */

913 else

914 search_bit = ((last_rn >> i) & 0x1);

915

916 /** Read two bits and write one bit */

917 triplet_ret = w1_triplet(dev, search_bit);

918

919 /* quit if no device responded */

920 if ( (triplet_ret & 0x03) == 0x03 )

921 break;

922

923 /* If both directions were valid, and we took the 0 path... */

924 if (triplet_ret == 0)

925 last_zero = i;

926

927 /* extract the direction taken & update the device number */

928 tmp64 = (triplet_ret >> 2);

929 rn |= (tmp64 << i);

930

931 if (kthread_should_stop()) {

932 dev_dbg(&dev->dev, "Abort w1_search\n");

933 return;

934 }

935 }

936

937 if ( (triplet_ret & 0x03) != 0x03 ) {

938 if ( (desc_bit == last_zero) || (last_zero < 0))

939 last_device = 1;

940 desc_bit = last_zero;

941 cb(dev, rn);

942 }

943 }

944 }

945

946 void w1_search_process_cb(struct w1_master *dev, u8 search_type,

947 w1_slave_found_callback cb)

948 {

949 struct w1_slave *sl, *sln;

950

951 list_for_each_entry(sl, &dev->slist, w1_slave_entry)

952 clear_bit(W1_SLAVE_ACTIVE, (long *)&sl->flags);

953

954 w1_search_devices(dev, search_type, cb);

955

956 list_for_each_entry_safe(sl, sln, &dev->slist, w1_slave_entry) {

957 if (!test_bit(W1_SLAVE_ACTIVE, (unsigned long *)&sl->flags) && !--sl->ttl)

958 w1_slave_detach(sl);

959 else if (test_bit(W1_SLAVE_ACTIVE, (unsigned long *)&sl->flags))

960 sl->ttl = dev->slave_ttl;

961 }

962

963 if (dev->search_count > 0)

964 dev->search_count--;

965 }

966

967 static void w1_search_process(struct w1_master *dev, u8 search_type)

968 {

969 w1_search_process_cb(dev, search_type, w1_slave_found);

970 }

971

972 int w1_process(void *data)

973 {

974 struct w1_master *dev = (struct w1_master *) data;

975 /* As long as w1_timeout is only set by a module parameter the sleep

976 * time can be calculated in jiffies once.

977 */

978 const unsigned long jtime = msecs_to_jiffies(w1_timeout * 1000);

979

980 while (!kthread_should_stop()) {

981 if (dev->search_count) {

982 mutex_lock(&dev->mutex);

983 w1_search_process(dev, W1_SEARCH);

984 mutex_unlock(&dev->mutex);

985 }

986

987 try_to_freeze();

988 __set_current_state(TASK_INTERRUPTIBLE);

989

990 if (kthread_should_stop())

991 break;

992

993 /* Only sleep when the search is active. */

994 if (dev->search_count)

995 schedule_timeout(jtime);

996 else

997 schedule();

998 }

999

1000 atomic_dec(&dev->refcnt);

1001

1002 return 0;

1003 }

1004

1005 static int __init w1_init(void)

1006 {

1007 int retval;

1008

1009 printk(KERN_INFO "Driver for 1-wire Dallas network protocol.\n");

1010

1011 w1_init_netlink();

1012

1013 retval = bus_register(&w1_bus_type);

1014 if (retval) {

1015 printk(KERN_ERR "Failed to register bus. err=%d.\n", retval);

1016 goto err_out_exit_init;

1017 }

1018

1019 retval = driver_register(&w1_master_driver);

1020 if (retval) {

1021 printk(KERN_ERR

1022 "Failed to register master driver. err=%d.\n",

1023 retval);

1024 goto err_out_bus_unregister;

1025 }

1026

1027 retval = driver_register(&w1_slave_driver);

1028 if (retval) {

1029 printk(KERN_ERR

1030 "Failed to register master driver. err=%d.\n",

1031 retval);

1032 goto err_out_master_unregister;

1033 }

1034

1035 return 0;

1036

1037 #if 0

1038 /* For undoing the slave register if there was a step after it. */

1039 err_out_slave_unregister:

1040 driver_unregister(&w1_slave_driver);

1041 #endif

1042

1043 err_out_master_unregister:

1044 driver_unregister(&w1_master_driver);

1045

1046 err_out_bus_unregister:

1047 bus_unregister(&w1_bus_type);

1048

1049 err_out_exit_init:

1050 return retval;

1051 }

1052

1053 static void __exit w1_fini(void)

1054 {

1055 struct w1_master *dev;

1056

1057 /* Set netlink removal messages and some cleanup */

1058 list_for_each_entry(dev, &w1_masters, w1_master_entry)

1059 __w1_remove_master_device(dev);

1060

1061 w1_fini_netlink();

1062

1063 driver_unregister(&w1_slave_driver);

1064 driver_unregister(&w1_master_driver);

1065 bus_unregister(&w1_bus_type);

1066 }

1067

1068 module_init(w1_init);

1069 module_exit(w1_fini);