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 if (mcmd->type != W1_LIST_MASTERS) {
304 printk(KERN_NOTICE "%s: msg: %x.%x, wrong type: %u, len: %u.\n",
305 __func__, msg->id.idx, msg->id.val, mcmd->type, mcmd->len);
309 cn = kmalloc(PAGE_SIZE, GFP_KERNEL);
313 cn->id.idx = CN_W1_IDX;
314 cn->id.val = CN_W1_VAL;
318 cn->len = sizeof(struct w1_netlink_msg);
319 w = (struct w1_netlink_msg *)(cn + 1);
321 w->type = W1_LIST_MASTERS;
326 mutex_lock(&w1_mlock);
327 list_for_each_entry(m, &w1_masters, w1_master_entry) {
328 if (cn->len + sizeof(*id) > PAGE_SIZE - sizeof(struct cn_msg)) {
329 cn_netlink_send(cn, portid, 0, GFP_KERNEL);
331 cn->len = sizeof(struct w1_netlink_msg);
337 w->len += sizeof(*id);
338 cn->len += sizeof(*id);
342 cn_netlink_send(cn, portid, 0, GFP_KERNEL);
343 mutex_unlock(&w1_mlock);
349 static int w1_netlink_send_error(struct cn_msg *rcmsg, struct w1_netlink_msg *rmsg,
350 struct w1_netlink_cmd *rcmd, int portid, int error)
353 struct w1_netlink_msg *msg;
354 struct w1_netlink_cmd *cmd;
356 cmsg = kzalloc(sizeof(*msg) + sizeof(*cmd) + sizeof(*cmsg), GFP_KERNEL);
360 msg = (struct w1_netlink_msg *)(cmsg + 1);
361 cmd = (struct w1_netlink_cmd *)(msg + 1);
363 memcpy(cmsg, rcmsg, sizeof(*cmsg));
364 cmsg->len = sizeof(*msg);
366 memcpy(msg, rmsg, sizeof(*msg));
368 msg->status = (short)-error;
371 memcpy(cmd, rcmd, sizeof(*cmd));
373 msg->len += sizeof(*cmd);
374 cmsg->len += sizeof(*cmd);
377 error = cn_netlink_send(cmsg, portid, 0, GFP_KERNEL);
383 /* Bundle together a reference count, the full message, and broken out
384 * commands to be executed on each w1 master kthread in one memory allocation.
388 u32 portid; /* Sending process port ID */
391 /* one or more variable length struct w1_cb_node */
394 struct w1_async_cmd async;
395 /* pointers within w1_cb_block and msg data */
396 struct w1_cb_block *block;
397 struct w1_netlink_msg *m;
399 struct w1_master *dev;
402 static void w1_process_cb(struct w1_master *dev, struct w1_async_cmd *async_cmd)
404 struct w1_cb_node *node = container_of(async_cmd, struct w1_cb_node,
406 u16 mlen = node->m->len;
407 u8 *cmd_data = node->m->data;
409 struct w1_slave *sl = node->sl;
410 struct w1_netlink_cmd *cmd = NULL;
412 mutex_lock(&dev->bus_mutex);
413 dev->portid = node->block->portid;
414 if (sl && w1_reset_select_slave(sl))
417 while (mlen && !err) {
418 cmd = (struct w1_netlink_cmd *)cmd_data;
420 if (cmd->len + sizeof(struct w1_netlink_cmd) > mlen) {
426 err = w1_process_command_slave(sl, &node->block->msg,
429 err = w1_process_command_master(dev, &node->block->msg,
432 w1_netlink_send_error(&node->block->msg, node->m, cmd,
433 node->block->portid, err);
436 cmd_data += cmd->len + sizeof(struct w1_netlink_cmd);
437 mlen -= cmd->len + sizeof(struct w1_netlink_cmd);
441 w1_netlink_send_error(&node->block->msg, node->m, cmd,
442 node->block->portid, err);
447 atomic_dec(&dev->refcnt);
449 mutex_unlock(&dev->bus_mutex);
451 mutex_lock(&dev->list_mutex);
452 list_del(&async_cmd->async_entry);
453 mutex_unlock(&dev->list_mutex);
455 if (atomic_sub_return(1, &node->block->refcnt) == 0)
459 static void w1_cn_callback(struct cn_msg *msg, struct netlink_skb_parms *nsp)
461 struct w1_netlink_msg *m = (struct w1_netlink_msg *)(msg + 1);
463 struct w1_master *dev;
466 struct w1_cb_block *block = NULL;
467 struct w1_cb_node *node = NULL;
470 /* Count the number of master or slave commands there are to allocate
471 * space for one cb_node each.
474 while (msg_len && !err) {
475 if (m->len + sizeof(struct w1_netlink_msg) > msg_len) {
480 if (m->type == W1_MASTER_CMD || m->type == W1_SLAVE_CMD)
483 msg_len -= sizeof(struct w1_netlink_msg) + m->len;
484 m = (struct w1_netlink_msg *)(((u8 *)m) +
485 sizeof(struct w1_netlink_msg) + m->len);
487 m = (struct w1_netlink_msg *)(msg + 1);
489 /* msg->len doesn't include itself */
490 long size = sizeof(struct w1_cb_block) + msg->len +
491 node_count*sizeof(struct w1_cb_node);
492 block = kmalloc(size, GFP_KERNEL);
494 w1_netlink_send_error(msg, m, NULL, nsp->portid,
498 atomic_set(&block->refcnt, 1);
499 block->portid = nsp->portid;
500 memcpy(&block->msg, msg, sizeof(*msg) + msg->len);
501 node = (struct w1_cb_node *)((u8 *)block->msg.data + msg->len);
505 while (msg_len && !err) {
506 struct w1_reg_num id;
512 memcpy(&id, m->id.id, sizeof(id));
514 printk("%s: %02x.%012llx.%02x: type=%02x, len=%u.\n",
515 __func__, id.family, (unsigned long long)id.id, id.crc, m->type, m->len);
517 if (m->len + sizeof(struct w1_netlink_msg) > msg_len) {
522 if (m->type == W1_MASTER_CMD) {
523 dev = w1_search_master_id(m->id.mst.id);
524 } else if (m->type == W1_SLAVE_CMD) {
525 sl = w1_search_slave(&id);
529 err = w1_process_command_root(msg, m, nsp->portid);
542 atomic_inc(&block->refcnt);
543 node->async.cb = w1_process_cb;
545 node->m = (struct w1_netlink_msg *)((u8 *)&block->msg +
546 (size_t)((u8 *)m - (u8 *)msg));
550 mutex_lock(&dev->list_mutex);
551 list_add_tail(&node->async.async_entry, &dev->async_list);
552 wake_up_process(dev->thread);
553 mutex_unlock(&dev->list_mutex);
558 w1_netlink_send_error(msg, m, NULL, nsp->portid, err);
559 msg_len -= sizeof(struct w1_netlink_msg) + m->len;
560 m = (struct w1_netlink_msg *)(((u8 *)m) + sizeof(struct w1_netlink_msg) + m->len);
563 * Let's allow requests for nonexisting devices.
568 if (block && atomic_sub_return(1, &block->refcnt) == 0)
572 int w1_init_netlink(void)
574 struct cb_id w1_id = {.idx = CN_W1_IDX, .val = CN_W1_VAL};
576 return cn_add_callback(&w1_id, "w1", &w1_cn_callback);
579 void w1_fini_netlink(void)
581 struct cb_id w1_id = {.idx = CN_W1_IDX, .val = CN_W1_VAL};
583 cn_del_callback(&w1_id);
586 void w1_netlink_send(struct w1_master *dev, struct w1_netlink_msg *msg)
590 int w1_init_netlink(void)
595 void w1_fini_netlink(void)