4 * Copyright (c) 2003 Evgeniy Polyakov <zbr@ioremap.net>
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.
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.
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
22 #include <linux/slab.h>
23 #include <linux/skbuff.h>
24 #include <linux/netlink.h>
25 #include <linux/connector.h>
29 #include "w1_netlink.h"
31 #if defined(CONFIG_W1_CON) && (defined(CONFIG_CONNECTOR) || (defined(CONFIG_CONNECTOR_MODULE) && defined(CONFIG_W1_MODULE)))
32 void w1_netlink_send(struct w1_master *dev, struct w1_netlink_msg *msg)
34 char buf[sizeof(struct cn_msg) + sizeof(struct w1_netlink_msg)];
35 struct cn_msg *m = (struct cn_msg *)buf;
36 struct w1_netlink_msg *w = (struct w1_netlink_msg *)(m+1);
38 memset(buf, 0, sizeof(buf));
40 m->id.idx = CN_W1_IDX;
41 m->id.val = CN_W1_VAL;
44 m->len = sizeof(struct w1_netlink_msg);
46 memcpy(w, msg, sizeof(struct w1_netlink_msg));
48 cn_netlink_send(m, dev->portid, 0, GFP_KERNEL);
51 static void w1_send_slave(struct w1_master *dev, u64 rn)
53 struct cn_msg *msg = dev->priv;
54 struct w1_netlink_msg *hdr = (struct w1_netlink_msg *)(msg + 1);
55 struct w1_netlink_cmd *cmd = (struct w1_netlink_cmd *)(hdr + 1);
59 avail = dev->priv_size - cmd->len;
63 cn_netlink_send(msg, dev->portid, 0, GFP_KERNEL);
65 msg->len = sizeof(struct w1_netlink_msg) +
66 sizeof(struct w1_netlink_cmd);
67 hdr->len = sizeof(struct w1_netlink_cmd);
71 data = (void *)(cmd + 1) + cmd->len;
79 static void w1_found_send_slave(struct w1_master *dev, u64 rn)
81 /* update kernel slave list */
82 w1_slave_found(dev, rn);
84 w1_send_slave(dev, rn);
87 /* Get the current slave list, or search (with or without alarm) */
88 static int w1_get_slaves(struct w1_master *dev,
89 struct cn_msg *req_msg, struct w1_netlink_msg *req_hdr,
90 struct w1_netlink_cmd *req_cmd)
93 struct w1_netlink_msg *hdr;
94 struct w1_netlink_cmd *cmd;
97 msg = kzalloc(PAGE_SIZE, GFP_KERNEL);
101 msg->id = req_msg->id;
102 msg->seq = req_msg->seq;
104 msg->len = sizeof(struct w1_netlink_msg) +
105 sizeof(struct w1_netlink_cmd);
107 hdr = (struct w1_netlink_msg *)(msg + 1);
108 cmd = (struct w1_netlink_cmd *)(hdr + 1);
110 hdr->type = W1_MASTER_CMD;
111 hdr->id = req_hdr->id;
112 hdr->len = sizeof(struct w1_netlink_cmd);
114 cmd->cmd = req_cmd->cmd;
118 dev->priv_size = PAGE_SIZE - msg->len - sizeof(struct cn_msg);
120 if (req_cmd->cmd == W1_CMD_LIST_SLAVES) {
122 mutex_lock(&dev->list_mutex);
123 list_for_each_entry(sl, &dev->slist, w1_slave_entry) {
124 memcpy(&rn, &sl->reg_num, sizeof(rn));
125 w1_send_slave(dev, rn);
127 mutex_unlock(&dev->list_mutex);
129 w1_search_process_cb(dev, cmd->cmd == W1_CMD_ALARM_SEARCH ?
130 W1_ALARM_SEARCH : W1_SEARCH, w1_found_send_slave);
134 cn_netlink_send(msg, dev->portid, 0, GFP_KERNEL);
144 static int w1_send_read_reply(struct cn_msg *msg, struct w1_netlink_msg *hdr,
145 struct w1_netlink_cmd *cmd, u32 portid)
148 struct w1_netlink_msg *h;
149 struct w1_netlink_cmd *c;
153 data = kzalloc(sizeof(struct cn_msg) +
154 sizeof(struct w1_netlink_msg) +
155 sizeof(struct w1_netlink_cmd) +
156 cmd->len, GFP_KERNEL);
160 cm = (struct cn_msg *)(data);
161 h = (struct w1_netlink_msg *)(cm + 1);
162 c = (struct w1_netlink_cmd *)(h + 1);
164 memcpy(cm, msg, sizeof(struct cn_msg));
165 memcpy(h, hdr, sizeof(struct w1_netlink_msg));
166 memcpy(c, cmd, sizeof(struct w1_netlink_cmd));
168 cm->ack = msg->seq+1;
169 cm->len = sizeof(struct w1_netlink_msg) +
170 sizeof(struct w1_netlink_cmd) + cmd->len;
172 h->len = sizeof(struct w1_netlink_cmd) + cmd->len;
174 memcpy(c->data, cmd->data, c->len);
176 err = cn_netlink_send(cm, portid, 0, GFP_KERNEL);
183 static int w1_process_command_io(struct w1_master *dev, struct cn_msg *msg,
184 struct w1_netlink_msg *hdr, struct w1_netlink_cmd *cmd)
190 w1_touch_block(dev, cmd->data, cmd->len);
191 w1_send_read_reply(msg, hdr, cmd, dev->portid);
194 w1_read_block(dev, cmd->data, cmd->len);
195 w1_send_read_reply(msg, hdr, cmd, dev->portid);
198 w1_write_block(dev, cmd->data, cmd->len);
208 static int w1_process_command_addremove(struct w1_master *dev,
209 struct cn_msg *msg, struct w1_netlink_msg *hdr,
210 struct w1_netlink_cmd *cmd)
214 struct w1_reg_num *id;
219 id = (struct w1_reg_num *)cmd->data;
221 sl = w1_slave_search_device(dev, id);
223 case W1_CMD_SLAVE_ADD:
227 err = w1_attach_slave_device(dev, id);
229 case W1_CMD_SLAVE_REMOVE:
243 static int w1_process_command_master(struct w1_master *dev,
244 struct cn_msg *req_msg, struct w1_netlink_msg *req_hdr,
245 struct w1_netlink_cmd *req_cmd)
249 /* drop bus_mutex for search (does it's own locking), and add/remove
250 * which doesn't use the bus
252 switch (req_cmd->cmd) {
254 case W1_CMD_ALARM_SEARCH:
255 case W1_CMD_LIST_SLAVES:
256 mutex_unlock(&dev->bus_mutex);
257 err = w1_get_slaves(dev, req_msg, req_hdr, req_cmd);
258 mutex_lock(&dev->bus_mutex);
263 err = w1_process_command_io(dev, req_msg, req_hdr, req_cmd);
266 err = w1_reset_bus(dev);
268 case W1_CMD_SLAVE_ADD:
269 case W1_CMD_SLAVE_REMOVE:
270 mutex_unlock(&dev->bus_mutex);
271 mutex_lock(&dev->mutex);
272 err = w1_process_command_addremove(dev, req_msg, req_hdr,
274 mutex_unlock(&dev->mutex);
275 mutex_lock(&dev->bus_mutex);
285 static int w1_process_command_slave(struct w1_slave *sl, struct cn_msg *msg,
286 struct w1_netlink_msg *hdr, struct w1_netlink_cmd *cmd)
288 dev_dbg(&sl->master->dev, "%s: %02x.%012llx.%02x: cmd=%02x, len=%u.\n",
289 __func__, sl->reg_num.family, (unsigned long long)sl->reg_num.id,
290 sl->reg_num.crc, cmd->cmd, cmd->len);
292 return w1_process_command_io(sl->master, msg, hdr, cmd);
295 static int w1_process_command_root(struct cn_msg *msg,
296 struct w1_netlink_msg *mcmd, u32 portid)
300 struct w1_netlink_msg *w;
303 cn = kmalloc(PAGE_SIZE, GFP_KERNEL);
307 cn->id.idx = CN_W1_IDX;
308 cn->id.val = CN_W1_VAL;
312 cn->len = sizeof(struct w1_netlink_msg);
313 w = (struct w1_netlink_msg *)(cn + 1);
315 w->type = W1_LIST_MASTERS;
320 mutex_lock(&w1_mlock);
321 list_for_each_entry(m, &w1_masters, w1_master_entry) {
322 if (cn->len + sizeof(*id) > PAGE_SIZE - sizeof(struct cn_msg)) {
323 cn_netlink_send(cn, portid, 0, GFP_KERNEL);
325 cn->len = sizeof(struct w1_netlink_msg);
331 w->len += sizeof(*id);
332 cn->len += sizeof(*id);
336 cn_netlink_send(cn, portid, 0, GFP_KERNEL);
337 mutex_unlock(&w1_mlock);
343 static int w1_netlink_send_error(struct cn_msg *rcmsg, struct w1_netlink_msg *rmsg,
344 struct w1_netlink_cmd *rcmd, int portid, int error)
347 struct w1_netlink_msg *msg;
348 struct w1_netlink_cmd *cmd;
350 cmsg = kzalloc(sizeof(*msg) + sizeof(*cmd) + sizeof(*cmsg), GFP_KERNEL);
354 msg = (struct w1_netlink_msg *)(cmsg + 1);
355 cmd = (struct w1_netlink_cmd *)(msg + 1);
357 memcpy(cmsg, rcmsg, sizeof(*cmsg));
358 cmsg->len = sizeof(*msg);
360 memcpy(msg, rmsg, sizeof(*msg));
362 msg->status = (short)-error;
365 memcpy(cmd, rcmd, sizeof(*cmd));
367 msg->len += sizeof(*cmd);
368 cmsg->len += sizeof(*cmd);
371 error = cn_netlink_send(cmsg, portid, 0, GFP_KERNEL);
377 /* Bundle together a reference count, the full message, and broken out
378 * commands to be executed on each w1 master kthread in one memory allocation.
382 u32 portid; /* Sending process port ID */
385 /* one or more variable length struct w1_cb_node */
388 struct w1_async_cmd async;
389 /* pointers within w1_cb_block and msg data */
390 struct w1_cb_block *block;
391 struct w1_netlink_msg *m;
393 struct w1_master *dev;
396 static void w1_process_cb(struct w1_master *dev, struct w1_async_cmd *async_cmd)
398 struct w1_cb_node *node = container_of(async_cmd, struct w1_cb_node,
400 u16 mlen = node->m->len;
401 u8 *cmd_data = node->m->data;
403 struct w1_slave *sl = node->sl;
404 struct w1_netlink_cmd *cmd = NULL;
406 mutex_lock(&dev->bus_mutex);
407 dev->portid = node->block->portid;
408 if (sl && w1_reset_select_slave(sl))
411 while (mlen && !err) {
412 cmd = (struct w1_netlink_cmd *)cmd_data;
414 if (cmd->len + sizeof(struct w1_netlink_cmd) > mlen) {
420 err = w1_process_command_slave(sl, &node->block->msg,
423 err = w1_process_command_master(dev, &node->block->msg,
426 w1_netlink_send_error(&node->block->msg, node->m, cmd,
427 node->block->portid, err);
430 cmd_data += cmd->len + sizeof(struct w1_netlink_cmd);
431 mlen -= cmd->len + sizeof(struct w1_netlink_cmd);
435 w1_netlink_send_error(&node->block->msg, node->m, cmd,
436 node->block->portid, err);
438 /* ref taken in w1_search_slave or w1_search_master_id when building
444 atomic_dec(&dev->refcnt);
446 mutex_unlock(&dev->bus_mutex);
448 mutex_lock(&dev->list_mutex);
449 list_del(&async_cmd->async_entry);
450 mutex_unlock(&dev->list_mutex);
452 if (atomic_sub_return(1, &node->block->refcnt) == 0)
456 static void w1_cn_callback(struct cn_msg *msg, struct netlink_skb_parms *nsp)
458 struct w1_netlink_msg *m = (struct w1_netlink_msg *)(msg + 1);
460 struct w1_master *dev;
463 struct w1_cb_block *block = NULL;
464 struct w1_cb_node *node = NULL;
467 /* Count the number of master or slave commands there are to allocate
468 * space for one cb_node each.
471 while (msg_len && !err) {
472 if (m->len + sizeof(struct w1_netlink_msg) > msg_len) {
477 if (m->type == W1_MASTER_CMD || m->type == W1_SLAVE_CMD)
480 msg_len -= sizeof(struct w1_netlink_msg) + m->len;
481 m = (struct w1_netlink_msg *)(((u8 *)m) +
482 sizeof(struct w1_netlink_msg) + m->len);
484 m = (struct w1_netlink_msg *)(msg + 1);
486 /* msg->len doesn't include itself */
487 long size = sizeof(struct w1_cb_block) + msg->len +
488 node_count*sizeof(struct w1_cb_node);
489 block = kmalloc(size, GFP_KERNEL);
491 w1_netlink_send_error(msg, m, NULL, nsp->portid,
495 atomic_set(&block->refcnt, 1);
496 block->portid = nsp->portid;
497 memcpy(&block->msg, msg, sizeof(*msg) + msg->len);
498 node = (struct w1_cb_node *)((u8 *)block->msg.data + msg->len);
502 while (msg_len && !err) {
507 if (m->len + sizeof(struct w1_netlink_msg) > msg_len) {
512 /* execute on this thread, no need to process later */
513 if (m->type == W1_LIST_MASTERS) {
514 err = w1_process_command_root(msg, m, nsp->portid);
518 /* All following message types require additional data,
519 * check here before references are taken.
526 /* both search calls take reference counts */
527 if (m->type == W1_MASTER_CMD) {
528 dev = w1_search_master_id(m->id.mst.id);
529 } else if (m->type == W1_SLAVE_CMD) {
530 sl = w1_search_slave((struct w1_reg_num *)m->id.id);
535 "%s: msg: %x.%x, wrong type: %u, len: %u.\n",
536 __func__, msg->id.idx, msg->id.val,
549 atomic_inc(&block->refcnt);
550 node->async.cb = w1_process_cb;
552 node->m = (struct w1_netlink_msg *)((u8 *)&block->msg +
553 (size_t)((u8 *)m - (u8 *)msg));
557 mutex_lock(&dev->list_mutex);
558 list_add_tail(&node->async.async_entry, &dev->async_list);
559 wake_up_process(dev->thread);
560 mutex_unlock(&dev->list_mutex);
565 w1_netlink_send_error(msg, m, NULL, nsp->portid, err);
566 msg_len -= sizeof(struct w1_netlink_msg) + m->len;
567 m = (struct w1_netlink_msg *)(((u8 *)m) +
568 sizeof(struct w1_netlink_msg) + m->len);
571 * Let's allow requests for nonexisting devices.
576 if (block && atomic_sub_return(1, &block->refcnt) == 0)
580 int w1_init_netlink(void)
582 struct cb_id w1_id = {.idx = CN_W1_IDX, .val = CN_W1_VAL};
584 return cn_add_callback(&w1_id, "w1", &w1_cn_callback);
587 void w1_fini_netlink(void)
589 struct cb_id w1_id = {.idx = CN_W1_IDX, .val = CN_W1_VAL};
591 cn_del_callback(&w1_id);
594 void w1_netlink_send(struct w1_master *dev, struct w1_netlink_msg *msg)
598 int w1_init_netlink(void)
603 void w1_fini_netlink(void)