static void setup_early_ipmi_serial() { unsigned char result; char channel_access[]={0x06<<2,0x40,0x04,0x80,0x05}; char serialmodem_conf[]={0x0c<<2,0x10,0x04,0x08,0x00,0x0f}; char serial_mux1[]={0x0c<<2,0x12,0x04,0x06}; char serial_mux2[]={0x0c<<2,0x12,0x04,0x03}; char serial_mux3[]={0x0c<<2,0x12,0x04,0x07}; // earlydbg(0x0d); //set channel access system only ipmi_request(5,channel_access); // earlydbg(result); /* //Set serial/modem config result=ipmi_request(6,serialmodem_conf); earlydbg(result); //Set serial mux 1 result=ipmi_request(4,serial_mux1); earlydbg(result); //Set serial mux 2 result=ipmi_request(4,serial_mux2); earlydbg(result); //Set serial mux 3 result=ipmi_request(4,serial_mux3); earlydbg(result); */ // earlydbg(0x0e); }
static int ipmi_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long data) { int rv = -EINVAL; struct ipmi_file_private *priv = file->private_data; switch (cmd) { case IPMICTL_SEND_COMMAND: { struct ipmi_req req; struct ipmi_addr addr; unsigned char msgdata[IPMI_MAX_MSG_LENGTH]; if (copy_from_user(&req, (void *) data, sizeof(req))) { rv = -EFAULT; break; } if (req.addr_len > sizeof(struct ipmi_addr)) { rv = -EINVAL; break; } if (copy_from_user(&addr, req.addr, req.addr_len)) { rv = -EFAULT; break; } rv = ipmi_validate_addr(&addr, req.addr_len); if (rv) break; if (req.msg.data != NULL) { if (req.msg.data_len > IPMI_MAX_MSG_LENGTH) { rv = -EMSGSIZE; break; } if (copy_from_user(&msgdata, req.msg.data, req.msg.data_len)) { rv = -EFAULT; break; } } else { req.msg.data_len = 0; } req.msg.data = msgdata; rv = ipmi_request(priv->user, &addr, req.msgid, &(req.msg), 0); break; } case IPMICTL_RECEIVE_MSG: case IPMICTL_RECEIVE_MSG_TRUNC: { struct ipmi_recv rsp; int addr_len; struct list_head *entry; struct ipmi_recv_msg *msg; unsigned long flags; rv = 0; if (copy_from_user(&rsp, (void *) data, sizeof(rsp))) { rv = -EFAULT; break; } /* We claim a semaphore because we don't want two users getting something from the queue at a time. Since we have to release the spinlock before we can copy the data to the user, it's possible another user will grab something from the queue, too. Then the messages might get out of order if something fails and the message gets put back onto the queue. This semaphore prevents that problem. */ down(&(priv->recv_sem)); /* Grab the message off the list. */ spin_lock_irqsave(&(priv->recv_msg_lock), flags); if (list_empty(&(priv->recv_msgs))) { spin_unlock_irqrestore(&(priv->recv_msg_lock), flags); rv = -EAGAIN; goto recv_err; } entry = priv->recv_msgs.next; msg = list_entry(entry, struct ipmi_recv_msg, link); list_del(entry); spin_unlock_irqrestore(&(priv->recv_msg_lock), flags); addr_len = ipmi_addr_length(msg->addr.addr_type); if (rsp.addr_len < addr_len) { rv = -EINVAL; goto recv_putback_on_err; } if (copy_to_user(rsp.addr, &(msg->addr), addr_len)) { rv = -EFAULT; goto recv_putback_on_err; } rsp.addr_len = addr_len; rsp.recv_type = msg->recv_type; rsp.msgid = msg->msgid; rsp.msg.netfn = msg->msg.netfn; rsp.msg.cmd = msg->msg.cmd; if (msg->msg.data_len > 0) { if (rsp.msg.data_len < msg->msg.data_len) { rv = -EMSGSIZE; if (cmd == IPMICTL_RECEIVE_MSG_TRUNC) { msg->msg.data_len = rsp.msg.data_len; } else { goto recv_putback_on_err; } } if (copy_to_user(rsp.msg.data, msg->msg.data, msg->msg.data_len)) { rv = -EFAULT; goto recv_putback_on_err; } rsp.msg.data_len = msg->msg.data_len; } else { rsp.msg.data_len = 0; } if (copy_to_user((void *) data, &rsp, sizeof(rsp))) { rv = -EFAULT; goto recv_putback_on_err; } up(&(priv->recv_sem)); ipmi_free_recv_msg(msg); break; recv_putback_on_err: /* If we got an error, put the message back onto the head of the queue. */ spin_lock_irqsave(&(priv->recv_msg_lock), flags); list_add(entry, &(priv->recv_msgs)); spin_unlock_irqrestore(&(priv->recv_msg_lock), flags); up(&(priv->recv_sem)); break; recv_err: up(&(priv->recv_sem)); break; } case IPMICTL_REGISTER_FOR_CMD: { struct ipmi_cmdspec val; if (copy_from_user(&val, (void *) data, sizeof(val))) { rv = -EFAULT; break; } rv = ipmi_register_for_cmd(priv->user, val.netfn, val.cmd); break; } case IPMICTL_UNREGISTER_FOR_CMD: { struct ipmi_cmdspec val; if (copy_from_user(&val, (void *) data, sizeof(val))) { rv = -EFAULT; break; } rv = ipmi_unregister_for_cmd(priv->user, val.netfn, val.cmd); break; } case IPMICTL_SET_GETS_EVENTS_CMD: { int val; if (copy_from_user(&val, (void *) data, sizeof(val))) { rv = -EFAULT; break; } rv = ipmi_set_gets_events(priv->user, val); break; } case IPMICTL_SET_MY_ADDRESS_CMD: { unsigned int val; if (copy_from_user(&val, (void *) data, sizeof(val))) { rv = -EFAULT; break; } ipmi_set_my_address(priv->user, val); rv = 0; break; } case IPMICTL_GET_MY_ADDRESS_CMD: { unsigned int val; val = ipmi_get_my_address(priv->user); if (copy_to_user((void *) data, &val, sizeof(val))) { rv = -EFAULT; break; } rv = 0; break; } case IPMICTL_SET_MY_LUN_CMD: { unsigned int val; if (copy_from_user(&val, (void *) data, sizeof(val))) { rv = -EFAULT; break; } ipmi_set_my_LUN(priv->user, val); rv = 0; break; } case IPMICTL_GET_MY_LUN_CMD: { unsigned int val; val = ipmi_get_my_LUN(priv->user); if (copy_to_user((void *) data, &val, sizeof(val))) { rv = -EFAULT; break; } rv = 0; break; } } return rv; }