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 switch (req_cmd->cmd) {
251 case W1_CMD_ALARM_SEARCH:
252 case W1_CMD_LIST_SLAVES:
253 err = w1_get_slaves(dev, req_msg, req_hdr, req_cmd);
258 err = w1_process_command_io(dev, req_msg, req_hdr, req_cmd);
261 err = w1_reset_bus(dev);
263 case W1_CMD_SLAVE_ADD:
264 case W1_CMD_SLAVE_REMOVE:
265 err = w1_process_command_addremove(dev, req_msg, req_hdr,
276 static int w1_process_command_slave(struct w1_slave *sl, struct cn_msg *msg,
277 struct w1_netlink_msg *hdr, struct w1_netlink_cmd *cmd)
279 dev_dbg(&sl->master->dev, "%s: %02x.%012llx.%02x: cmd=%02x, len=%u.\n",
280 __func__, sl->reg_num.family, (unsigned long long)sl->reg_num.id,
281 sl->reg_num.crc, cmd->cmd, cmd->len);
283 return w1_process_command_io(sl->master, msg, hdr, cmd);
286 static int w1_process_command_root(struct cn_msg *msg,
287 struct w1_netlink_msg *mcmd, u32 portid)
291 struct w1_netlink_msg *w;
294 if (mcmd->type != W1_LIST_MASTERS) {
295 printk(KERN_NOTICE "%s: msg: %x.%x, wrong type: %u, len: %u.\n",
296 __func__, msg->id.idx, msg->id.val, mcmd->type, mcmd->len);
300 cn = kmalloc(PAGE_SIZE, GFP_KERNEL);
304 cn->id.idx = CN_W1_IDX;
305 cn->id.val = CN_W1_VAL;
309 cn->len = sizeof(struct w1_netlink_msg);
310 w = (struct w1_netlink_msg *)(cn + 1);
312 w->type = W1_LIST_MASTERS;
317 mutex_lock(&w1_mlock);
318 list_for_each_entry(m, &w1_masters, w1_master_entry) {
319 if (cn->len + sizeof(*id) > PAGE_SIZE - sizeof(struct cn_msg)) {
320 cn_netlink_send(cn, portid, 0, GFP_KERNEL);
322 cn->len = sizeof(struct w1_netlink_msg);
328 w->len += sizeof(*id);
329 cn->len += sizeof(*id);
333 cn_netlink_send(cn, portid, 0, GFP_KERNEL);
334 mutex_unlock(&w1_mlock);
340 static int w1_netlink_send_error(struct cn_msg *rcmsg, struct w1_netlink_msg *rmsg,
341 struct w1_netlink_cmd *rcmd, int portid, int error)
344 struct w1_netlink_msg *msg;
345 struct w1_netlink_cmd *cmd;
347 cmsg = kzalloc(sizeof(*msg) + sizeof(*cmd) + sizeof(*cmsg), GFP_KERNEL);
351 msg = (struct w1_netlink_msg *)(cmsg + 1);
352 cmd = (struct w1_netlink_cmd *)(msg + 1);
354 memcpy(cmsg, rcmsg, sizeof(*cmsg));
355 cmsg->len = sizeof(*msg);
357 memcpy(msg, rmsg, sizeof(*msg));
359 msg->status = (short)-error;
362 memcpy(cmd, rcmd, sizeof(*cmd));
364 msg->len += sizeof(*cmd);
365 cmsg->len += sizeof(*cmd);
368 error = cn_netlink_send(cmsg, portid, 0, GFP_KERNEL);
374 /* Bundle together a reference count, the full message, and broken out
375 * commands to be executed on each w1 master kthread in one memory allocation.
379 u32 portid; /* Sending process port ID */
382 /* one or more variable length struct w1_cb_node */
385 struct w1_async_cmd async;
386 /* pointers within w1_cb_block and msg data */
387 struct w1_cb_block *block;
388 struct w1_netlink_msg *m;
390 struct w1_master *dev;
393 static void w1_process_cb(struct w1_master *dev, struct w1_async_cmd *async_cmd)
395 struct w1_cb_node *node = container_of(async_cmd, struct w1_cb_node,
397 u16 mlen = node->m->len;
398 u8 *cmd_data = node->m->data;
400 struct w1_slave *sl = node->sl;
401 struct w1_netlink_cmd *cmd = NULL;
403 mutex_lock(&dev->mutex);
404 dev->portid = node->block->portid;
405 if (sl && w1_reset_select_slave(sl))
408 while (mlen && !err) {
409 cmd = (struct w1_netlink_cmd *)cmd_data;
411 if (cmd->len + sizeof(struct w1_netlink_cmd) > mlen) {
417 err = w1_process_command_slave(sl, &node->block->msg,
420 err = w1_process_command_master(dev, &node->block->msg,
423 w1_netlink_send_error(&node->block->msg, node->m, cmd,
424 node->block->portid, err);
427 cmd_data += cmd->len + sizeof(struct w1_netlink_cmd);
428 mlen -= cmd->len + sizeof(struct w1_netlink_cmd);
432 w1_netlink_send_error(&node->block->msg, node->m, cmd,
433 node->block->portid, err);
438 atomic_dec(&dev->refcnt);
440 mutex_unlock(&dev->mutex);
442 mutex_lock(&dev->list_mutex);
443 list_del(&async_cmd->async_entry);
444 mutex_unlock(&dev->list_mutex);
446 if (atomic_sub_return(1, &node->block->refcnt) == 0)
450 static void w1_cn_callback(struct cn_msg *msg, struct netlink_skb_parms *nsp)
452 struct w1_netlink_msg *m = (struct w1_netlink_msg *)(msg + 1);
454 struct w1_master *dev;
457 struct w1_cb_block *block = NULL;
458 struct w1_cb_node *node = NULL;
461 /* Count the number of master or slave commands there are to allocate
462 * space for one cb_node each.
465 while (msg_len && !err) {
466 if (m->len + sizeof(struct w1_netlink_msg) > msg_len) {
471 if (m->type == W1_MASTER_CMD || m->type == W1_SLAVE_CMD)
474 msg_len -= sizeof(struct w1_netlink_msg) + m->len;
475 m = (struct w1_netlink_msg *)(((u8 *)m) +
476 sizeof(struct w1_netlink_msg) + m->len);
478 m = (struct w1_netlink_msg *)(msg + 1);
480 /* msg->len doesn't include itself */
481 long size = sizeof(struct w1_cb_block) + msg->len +
482 node_count*sizeof(struct w1_cb_node);
483 block = kmalloc(size, GFP_KERNEL);
485 w1_netlink_send_error(msg, m, NULL, nsp->portid,
489 atomic_set(&block->refcnt, 1);
490 block->portid = nsp->portid;
491 memcpy(&block->msg, msg, sizeof(*msg) + msg->len);
492 node = (struct w1_cb_node *)((u8 *)block->msg.data + msg->len);
496 while (msg_len && !err) {
497 struct w1_reg_num id;
503 memcpy(&id, m->id.id, sizeof(id));
505 printk("%s: %02x.%012llx.%02x: type=%02x, len=%u.\n",
506 __func__, id.family, (unsigned long long)id.id, id.crc, m->type, m->len);
508 if (m->len + sizeof(struct w1_netlink_msg) > msg_len) {
513 if (m->type == W1_MASTER_CMD) {
514 dev = w1_search_master_id(m->id.mst.id);
515 } else if (m->type == W1_SLAVE_CMD) {
516 sl = w1_search_slave(&id);
520 err = w1_process_command_root(msg, m, nsp->portid);
533 atomic_inc(&block->refcnt);
534 node->async.cb = w1_process_cb;
536 node->m = (struct w1_netlink_msg *)((u8 *)&block->msg +
537 (size_t)((u8 *)m - (u8 *)msg));
541 mutex_lock(&dev->list_mutex);
542 list_add_tail(&node->async.async_entry, &dev->async_list);
543 wake_up_process(dev->thread);
544 mutex_unlock(&dev->list_mutex);
549 w1_netlink_send_error(msg, m, NULL, nsp->portid, err);
550 msg_len -= sizeof(struct w1_netlink_msg) + m->len;
551 m = (struct w1_netlink_msg *)(((u8 *)m) + sizeof(struct w1_netlink_msg) + m->len);
554 * Let's allow requests for nonexisting devices.
559 if (block && atomic_sub_return(1, &block->refcnt) == 0)
563 int w1_init_netlink(void)
565 struct cb_id w1_id = {.idx = CN_W1_IDX, .val = CN_W1_VAL};
567 return cn_add_callback(&w1_id, "w1", &w1_cn_callback);
570 void w1_fini_netlink(void)
572 struct cb_id w1_id = {.idx = CN_W1_IDX, .val = CN_W1_VAL};
574 cn_del_callback(&w1_id);
577 void w1_netlink_send(struct w1_master *dev, struct w1_netlink_msg *msg)
581 int w1_init_netlink(void)
586 void w1_fini_netlink(void)