double unlock

|enum si_intf_state {
| SI_NORMAL,
| SI_GETTING_FLAGS,
| SI_GETTING_EVENTS,
| SI_CLEARING_FLAGS,
| SI_CLEARING_FLAGS_THEN_SET_IRQ,
| SI_GETTING_MESSAGES,
| SI_ENABLE_INTERRUPTS1,
| SI_ENABLE_INTERRUPTS2,
| SI_DISABLE_INTERRUPTS1,
| SI_DISABLE_INTERRUPTS2
|
|};
|
|
|
|
|
|
|enum si_type {
|    SI_KCS, SI_SMIC, SI_BT
|};
|static char *si_to_str[] = { "kcs", "smic", "bt" };
|
|enum ipmi_addr_src {
| SI_INVALID = 0, SI_HOTMOD, SI_HARDCODED, SI_SPMI, SI_ACPI, SI_SMBIOS,
| SI_PCI, SI_DEVICETREE, SI_DEFAULT
|};
|static char *ipmi_addr_src_to_str[] = { ((void *)0), "hotmod", "hardcoded", "SPMI",
|     "ACPI", "SMBIOS", "PCI",
|     "device-tree", "default" };
|
|
|
|static struct platform_driver ipmi_driver = {
| .driver = {
|  .name = "ipmi_si",
|  .bus = &platform_bus_type
| }
|};
|
|
|
|
|
|enum si_stat_indexes {
|
|
|
|
| SI_STAT_short_timeouts = 0,
|
|
|
|
|
| SI_STAT_long_timeouts,
|
|
| SI_STAT_idles,
|
|
| SI_STAT_interrupts,
|
|
| SI_STAT_attentions,
|
|
| SI_STAT_flag_fetches,
|
|
| SI_STAT_hosed_count,
|
|
| SI_STAT_complete_transactions,
|
|
| SI_STAT_events,
|
|
| SI_STAT_watchdog_pretimeouts,
|
|
| SI_STAT_incoming_messages,
|
|
|
| SI_NUM_STATS
|};
|
|struct smi_info {
| int intf_num;
| ipmi_smi_t intf;
| struct si_sm_data *si_sm;
| struct si_sm_handlers *handlers;
| enum si_type si_type;
| spinlock_t si_lock;
| spinlock_t msg_lock;
| struct list_head xmit_msgs;
| struct list_head hp_xmit_msgs;
| struct ipmi_smi_msg *curr_msg;
| enum si_intf_state si_state;
|
|
|
|
|
| struct si_sm_io io;
| int (*io_setup)(struct smi_info *info);
| void (*io_cleanup)(struct smi_info *info);
| int (*irq_setup)(struct smi_info *info);
| void (*irq_cleanup)(struct smi_info *info);
| unsigned int io_size;
| enum ipmi_addr_src addr_source;
| void (*addr_source_cleanup)(struct smi_info *info);
| void *addr_source_data;
|
|
|
|
|
|
| int (*oem_data_avail_handler)(struct smi_info *smi_info);
| unsigned char msg_flags;
|
|
| char has_event_buffer;
|
|
|
|
|
| atomic_t req_events;
|
|
|
|
|
|
| int run_to_completion;
|
|
| int port;
|
|
|
|
|
|
| unsigned int spacing;
|
|
| int irq;
|
|
| struct timer_list si_timer;
|
|
| unsigned long last_timeout_jiffies;
|
|
| atomic_t stop_operation;
|
|
|
|
|
|
|
| int interrupt_disabled;
|
|
| struct ipmi_device_id device_id;
|
|
| struct device *dev;
| struct platform_device *pdev;
|
|
|
|
|
| int dev_registered;
|
|
| unsigned char slave_addr;
|
|
| atomic_t stats[SI_NUM_STATS];
|
| struct task_struct *thread;
|
| struct list_head link;
|};
|static int force_kipmid[4];
|static int num_force_kipmid;
|
|static int pci_registered;
|
|
|static int pnp_registered;
|
|
|
|
|
|static unsigned int kipmid_max_busy_us[4];
|static int num_max_busy_us;
|
|static int unload_when_empty = 1;
|
|static int add_smi(struct smi_info *smi);
|static int try_smi_init(struct smi_info *smi);
|static void cleanup_one_si(struct smi_info *to_clean);
|
|static struct atomic_notifier_head xaction_notifier_list = { .lock = (spinlock_t ) { { .rlock = { .raw_lock = { 0 }, .magic = 0xdead4ead, .owner_cpu = -1, .owner = ((void *)-1L), .dep_map = { .name = "xaction_notifier_list.lock" } } } }, .head = ((void *)0) };
|static int register_xaction_notifier(struct notifier_block *nb)
|{
| return atomic_notifier_chain_register(&xaction_notifier_list, nb);
|}
|
|static void deliver_recv_msg(struct smi_info *smi_info,
|        struct ipmi_smi_msg *msg)
|{
|
|
|
| if (smi_info->run_to_completion) {
|  ipmi_smi_msg_received(smi_info->intf, msg);
| } else {
|  __st_spin_unlock_st__(&(smi_info->si_lock));
|  ipmi_smi_msg_received(smi_info->intf, msg);
|  __st_spin_lock_st__(&(smi_info->si_lock));
| }
|}
|
|static void return_hosed_msg(struct smi_info *smi_info, int cCode)
|{
| struct ipmi_smi_msg *msg = smi_info->curr_msg;
|
| if (cCode < 0 || cCode > 0xff)
|  cCode = 0xff;
|
|
|
| msg->rsp[0] = msg->data[0] | 4;
| msg->rsp[1] = msg->data[1];
| msg->rsp[2] = cCode;
| msg->rsp_size = 3;
|
| smi_info->curr_msg = ((void *)0);
| deliver_recv_msg(smi_info, msg);
|}
|
|static enum si_sm_result start_next_msg(struct smi_info *smi_info)
|{
| int rv;
| struct list_head *entry = ((void *)0);
     |not affected ==> the lock is still unlocked. prev next
| if (!smi_info->run_to_completion)
     |not affected ==> the lock is still unlocked. prev next
|  __st_spin_lock_st__(&(smi_info->msg_lock));
|
|
| if (!list_empty(&(smi_info->hp_xmit_msgs))) {
     |not affected ==> the lock is still unlocked. prev next
|  entry = smi_info->hp_xmit_msgs.next;
     |not affected ==> the lock is still unlocked. prev next
| } else if (!list_empty(&(smi_info->xmit_msgs))) {
|  entry = smi_info->xmit_msgs.next;
| }
|
| if (!entry) {
     |not affected ==> the lock is still unlocked. prev next
|  smi_info->curr_msg = ((void *)0);
     |not affected ==> the lock is still unlocked. prev next
|  rv = SI_SM_IDLE;
     |not affected ==> the lock is still unlocked. prev next
| } else {
|  int err;
|
|  list_del(entry);
|  smi_info->curr_msg = ({ const typeof( ((struct ipmi_smi_msg *)0)->link ) *__mptr = (entry); (struct ipmi_smi_msg *)( (char *)__mptr - 1 );})
|
|           ;
|
|
|
|
|  err = atomic_notifier_call_chain(&xaction_notifier_list,
|    0, smi_info);
|  if (err & 0x8000) {
|   rv = SI_SM_CALL_WITHOUT_DELAY;
|   goto out;
|  }
|  err = smi_info->handlers->start_transaction(
|   smi_info->si_sm,
|   smi_info->curr_msg->data,
|   smi_info->curr_msg->data_size);
|  if (err)
|   return_hosed_msg(smi_info, err);
|
|  rv = SI_SM_CALL_WITHOUT_DELAY;
| }
| out:
| if (!smi_info->run_to_completion)
     |not affected ==> the lock is still unlocked. prev next
|  __st_spin_unlock_st__(&(smi_info->msg_lock));
     |The lock is unlocked and here is an attempt to unlock it twice.[& . * smi_info msg_lock] prev
|
| return rv;
|}
|
|static void start_enable_irq(struct smi_info *smi_info)
|{
| unsigned char msg[2];
|
|
|
|
|
| msg[0] = (0x06 << 2);
| msg[1] = 0x2f;
|
| smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
| smi_info->si_state = SI_ENABLE_INTERRUPTS1;
|}
|
|static void start_disable_irq(struct smi_info *smi_info)
|{
| unsigned char msg[2];
|
| msg[0] = (0x06 << 2);
| msg[1] = 0x2f;
|
| smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
| smi_info->si_state = SI_DISABLE_INTERRUPTS1;
|}
|
|static void start_clear_flags(struct smi_info *smi_info)
|{
| unsigned char msg[3];
|
|
| msg[0] = (0x06 << 2);
| msg[1] = 0x30;
| msg[2] = 0x08;
|
| smi_info->handlers->start_transaction(smi_info->si_sm, msg, 3);
| smi_info->si_state = SI_CLEARING_FLAGS;
|}
|
|
|
|
|
|
|
|static inline void disable_si_irq(struct smi_info *smi_info)
|{
| if ((smi_info->irq) && (!smi_info->interrupt_disabled)) {
|  start_disable_irq(smi_info);
|  smi_info->interrupt_disabled = 1;
|  if (!atomic_read(&smi_info->stop_operation))
|   mod_timer(&smi_info->si_timer,
|      jiffies + (10000/(1000000/250)));
| }
|}
|
|static inline void enable_si_irq(struct smi_info *smi_info)
|{
| if ((smi_info->irq) && (smi_info->interrupt_disabled)) {
|  start_enable_irq(smi_info);
|  smi_info->interrupt_disabled = 0;
| }
|}
|
|static void handle_flags(struct smi_info *smi_info)
|{
| retry:
| if (smi_info->msg_flags & 0x08) {
|
|  atomic_inc(&(smi_info)->stats[SI_STAT_watchdog_pretimeouts]);
|
|  start_clear_flags(smi_info);
|  smi_info->msg_flags &= ~0x08;
|  __st_spin_unlock_st__(&(smi_info->si_lock));
|  ipmi_smi_watchdog_pretimeout(smi_info->intf);
|  __st_spin_lock_st__(&(smi_info->si_lock));
| } else if (smi_info->msg_flags & 0x01) {
|
|  smi_info->curr_msg = ipmi_alloc_smi_msg();
|  if (!smi_info->curr_msg) {
|   disable_si_irq(smi_info);
|   smi_info->si_state = SI_NORMAL;
|   return;
|  }
|  enable_si_irq(smi_info);
|
|  smi_info->curr_msg->data[0] = (0x06 << 2);
|  smi_info->curr_msg->data[1] = 0x33;
|  smi_info->curr_msg->data_size = 2;
|
|  smi_info->handlers->start_transaction(
|   smi_info->si_sm,
|   smi_info->curr_msg->data,
|   smi_info->curr_msg->data_size);
|  smi_info->si_state = SI_GETTING_MESSAGES;
| } else if (smi_info->msg_flags & 0x02) {
|
|  smi_info->curr_msg = ipmi_alloc_smi_msg();
|  if (!smi_info->curr_msg) {
|   disable_si_irq(smi_info);
|   smi_info->si_state = SI_NORMAL;
|   return;
|  }
|  enable_si_irq(smi_info);
|
|  smi_info->curr_msg->data[0] = (0x06 << 2);
|  smi_info->curr_msg->data[1] = 0x35;
|  smi_info->curr_msg->data_size = 2;
|
|  smi_info->handlers->start_transaction(
|   smi_info->si_sm,
|   smi_info->curr_msg->data,
|   smi_info->curr_msg->data_size);
|  smi_info->si_state = SI_GETTING_EVENTS;
| } else if (smi_info->msg_flags & (0x20 | 0x40 | 0x80) &&
|     smi_info->oem_data_avail_handler) {
|  if (smi_info->oem_data_avail_handler(smi_info))
|   goto retry;
| } else
|  smi_info->si_state = SI_NORMAL;
|}
|
|static void handle_transaction_done(struct smi_info *smi_info)
|{
| struct ipmi_smi_msg *msg;
|
|
|
|
|
|
| switch (smi_info->si_state) {
| case SI_NORMAL:
|  if (!smi_info->curr_msg)
|   break;
|
|  smi_info->curr_msg->rsp_size
|   = smi_info->handlers->get_result(
|    smi_info->si_sm,
|    smi_info->curr_msg->rsp,
|    272);
|
|
|
|
|
|
|  msg = smi_info->curr_msg;
|  smi_info->curr_msg = ((void *)0);
|  deliver_recv_msg(smi_info, msg);
|  break;
|
| case SI_GETTING_FLAGS:
| {
|  unsigned char msg[4];
|  unsigned int len;
|
|
|  len = smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
|  if (msg[2] != 0) {
|
|   smi_info->si_state = SI_NORMAL;
|  } else if (len < 4) {
|
|
|
|
|   smi_info->si_state = SI_NORMAL;
|  } else {
|   smi_info->msg_flags = msg[3];
|   handle_flags(smi_info);
|  }
|  break;
| }
|
| case SI_CLEARING_FLAGS:
| case SI_CLEARING_FLAGS_THEN_SET_IRQ:
| {
|  unsigned char msg[3];
|
|
|  smi_info->handlers->get_result(smi_info->si_sm, msg, 3);
|  if (msg[2] != 0) {
|
|   dev_warn(smi_info->dev,
|     "Error clearing flags: %2.2x\n", msg[2]);
|  }
|  if (smi_info->si_state == SI_CLEARING_FLAGS_THEN_SET_IRQ)
|   start_enable_irq(smi_info);
|  else
|   smi_info->si_state = SI_NORMAL;
|  break;
| }
|
| case SI_GETTING_EVENTS:
| {
|  smi_info->curr_msg->rsp_size
|   = smi_info->handlers->get_result(
|    smi_info->si_sm,
|    smi_info->curr_msg->rsp,
|    272);
|
|
|
|
|
|
|  msg = smi_info->curr_msg;
|  smi_info->curr_msg = ((void *)0);
|  if (msg->rsp[2] != 0) {
|
|   msg->done(msg);
|
|
|   smi_info->msg_flags &= ~0x02;
|   handle_flags(smi_info);
|  } else {
|   atomic_inc(&(smi_info)->stats[SI_STAT_events]);
|
|
|
|
|
|
|
|   handle_flags(smi_info);
|
|   deliver_recv_msg(smi_info, msg);
|  }
|  break;
| }
|
| case SI_GETTING_MESSAGES:
| {
|  smi_info->curr_msg->rsp_size
|   = smi_info->handlers->get_result(
|    smi_info->si_sm,
|    smi_info->curr_msg->rsp,
|    272);
|
|
|
|
|
|
|  msg = smi_info->curr_msg;
|  smi_info->curr_msg = ((void *)0);
|  if (msg->rsp[2] != 0) {
|
|   msg->done(msg);
|
|
|   smi_info->msg_flags &= ~0x01;
|   handle_flags(smi_info);
|  } else {
|   atomic_inc(&(smi_info)->stats[SI_STAT_incoming_messages]);
|
|
|
|
|
|
|
|   handle_flags(smi_info);
|
|   deliver_recv_msg(smi_info, msg);
|  }
|  break;
| }
|
| case SI_ENABLE_INTERRUPTS1:
| {
|  unsigned char msg[4];
|
|
|  smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
|  if (msg[2] != 0) {
|   dev_warn(smi_info->dev, "Could not enable interrupts"
|     ", failed get, using polled mode.\n");
|   smi_info->si_state = SI_NORMAL;
|  } else {
|   msg[0] = (0x06 << 2);
|   msg[1] = 0x2e;
|   msg[2] = (msg[3] |
|      0x01 |
|      0x02);
|   smi_info->handlers->start_transaction(
|    smi_info->si_sm, msg, 3);
|   smi_info->si_state = SI_ENABLE_INTERRUPTS2;
|  }
|  break;
| }
|
| case SI_ENABLE_INTERRUPTS2:
| {
|  unsigned char msg[4];
|
|
|  smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
|  if (msg[2] != 0)
|   dev_warn(smi_info->dev, "Could not enable interrupts"
|     ", failed set, using polled mode.\n");
|  else
|   smi_info->interrupt_disabled = 0;
|  smi_info->si_state = SI_NORMAL;
|  break;
| }
|
| case SI_DISABLE_INTERRUPTS1:
| {
|  unsigned char msg[4];
|
|
|  smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
|  if (msg[2] != 0) {
|   dev_warn(smi_info->dev, "Could not disable interrupts"
|     ", failed get.\n");
|   smi_info->si_state = SI_NORMAL;
|  } else {
|   msg[0] = (0x06 << 2);
|   msg[1] = 0x2e;
|   msg[2] = (msg[3] &
|      ~(0x01 |
|        0x02));
|   smi_info->handlers->start_transaction(
|    smi_info->si_sm, msg, 3);
|   smi_info->si_state = SI_DISABLE_INTERRUPTS2;
|  }
|  break;
| }
|
| case SI_DISABLE_INTERRUPTS2:
| {
|  unsigned char msg[4];
|
|
|  smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
|  if (msg[2] != 0) {
|   dev_warn(smi_info->dev, "Could not disable interrupts"
|     ", failed set.\n");
|  }
|  smi_info->si_state = SI_NORMAL;
|  break;
| }
| }
|}
|
|
|
|
|
|
|static enum si_sm_result smi_event_handler(struct smi_info *smi_info,
|        int time)
|{
| enum si_sm_result si_sm_result;
|
| restart:
| si_sm_result = smi_info->handlers->event(smi_info->si_sm, time);
| time = 0;
| while (si_sm_result == SI_SM_CALL_WITHOUT_DELAY)
|  si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
|
| if (si_sm_result == SI_SM_TRANSACTION_COMPLETE) {
|  atomic_inc(&(smi_info)->stats[SI_STAT_complete_transactions]);
|
|  handle_transaction_done(smi_info);
|  si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
| } else if (si_sm_result == SI_SM_HOSED) {
|  atomic_inc(&(smi_info)->stats[SI_STAT_hosed_count]);
|
|
|
|
|
|  smi_info->si_state = SI_NORMAL;
|  if (smi_info->curr_msg != ((void *)0)) {
|
|
|
|
|
|   return_hosed_msg(smi_info, 0xff);
|  }
|  si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
| }
|
|
|
|
|
| if (smi_info->intf && si_sm_result == SI_SM_ATTN) {
|  unsigned char msg[2];
|
|  atomic_inc(&(smi_info)->stats[SI_STAT_attentions]);
|  msg[0] = (0x06 << 2);
|  msg[1] = 0x31;
|
|  smi_info->handlers->start_transaction(
|   smi_info->si_sm, msg, 2);
|  smi_info->si_state = SI_GETTING_FLAGS;
|  goto restart;
| }
|
|
| if (si_sm_result == SI_SM_IDLE) {
|  atomic_inc(&(smi_info)->stats[SI_STAT_idles]);
|
|  si_sm_result = start_next_msg(smi_info);
|  if (si_sm_result != SI_SM_IDLE)
|   goto restart;
| }
|
| if ((si_sm_result == SI_SM_IDLE)
|     && (atomic_read(&smi_info->req_events))) {
|
|
|
|
|  atomic_set(&smi_info->req_events, 0);
|
|  smi_info->curr_msg = ipmi_alloc_smi_msg();
|  if (!smi_info->curr_msg)
|   goto out;
|
|  smi_info->curr_msg->data[0] = (0x06 << 2);
|  smi_info->curr_msg->data[1] = 0x35;
|  smi_info->curr_msg->data_size = 2;
|
|  smi_info->handlers->start_transaction(
|   smi_info->si_sm,
|   smi_info->curr_msg->data,
|   smi_info->curr_msg->data_size);
|  smi_info->si_state = SI_GETTING_EVENTS;
|  goto restart;
| }
| out:
| return si_sm_result;
|}
|
|static void sender(void *send_info,
|     struct ipmi_smi_msg *msg,
|     int priority)
|{
| struct smi_info *smi_info = send_info;
| enum si_sm_result result;
| unsigned long flags;
|
|
|
|
| if (atomic_read(&smi_info->stop_operation)) {
|  msg->rsp[0] = msg->data[0] | 4;
|  msg->rsp[1] = msg->data[1];
|  msg->rsp[2] = 0xff;
|  msg->rsp_size = 3;
|  deliver_recv_msg(smi_info, msg);
|  return;
| }
|
|
|
|
|
|
| mod_timer(&smi_info->si_timer, jiffies + (10000/(1000000/250)));
|
| if (smi_info->thread)
|  wake_up_process(smi_info->thread);
|
| if (smi_info->run_to_completion) {
|  list_add_tail(&(msg->link), &(smi_info->xmit_msgs));
|
|  result = smi_event_handler(smi_info, 0);
|  while (result != SI_SM_IDLE) {
|   (__builtin_constant_p(250) ? ((250) > 20000 ? __bad_udelay() : __const_udelay((250) * 0x10c7ul)) : __udelay(250));
|   result = smi_event_handler(smi_info,
|         250);
|  }
|  return;
| }
|
| __st_spin_lock_irqsave_st__(&smi_info->msg_lock, flags);
| if (priority > 0)
|  list_add_tail(&msg->link, &smi_info->hp_xmit_msgs);
| else
|  list_add_tail(&msg->link, &smi_info->xmit_msgs);
| __st_spin_unlock_irqrestore_st__(&smi_info->msg_lock, flags);
     |The lock is unlocked here. next
|
| __st_spin_lock_irqsave_st__(&smi_info->si_lock, flags);
     |not affected ==> the lock is still unlocked. prev next
| if (smi_info->si_state == SI_NORMAL && smi_info->curr_msg == ((void *)0))
     |not affected ==> the lock is still unlocked. prev next
|  start_next_msg(smi_info);
     |not affected ==> the lock is still unlocked. prev next
| __st_spin_unlock_irqrestore_st__(&smi_info->si_lock, flags);
|}
|
|static void set_run_to_completion(void *send_info, int i_run_to_completion)
|{
| struct smi_info *smi_info = send_info;
| enum si_sm_result result;
|
| smi_info->run_to_completion = i_run_to_completion;
| if (i_run_to_completion) {
|  result = smi_event_handler(smi_info, 0);
|  while (result != SI_SM_IDLE) {
|   (__builtin_constant_p(250) ? ((250) > 20000 ? __bad_udelay() : __const_udelay((250) * 0x10c7ul)) : __udelay(250));
|   result = smi_event_handler(smi_info,
|         250);
|  }
| }
|}
|
|
|
|
|
|
|static inline void ipmi_si_set_not_busy(struct timespec *ts)
|{
| ts->tv_nsec = -1;
|}
|static inline int ipmi_si_is_busy(struct timespec *ts)
|{
| return ts->tv_nsec != -1;
|}
|
|static int ipmi_thread_busy_wait(enum si_sm_result smi_result,
|     const struct smi_info *smi_info,
|     struct timespec *busy_until)
|{
| unsigned int max_busy_us = 0;
|
| if (smi_info->intf_num < num_max_busy_us)
|  max_busy_us = kipmid_max_busy_us[smi_info->intf_num];
| if (max_busy_us == 0 || smi_result != SI_SM_CALL_WITH_DELAY)
|  ipmi_si_set_not_busy(busy_until);
| else if (!ipmi_si_is_busy(busy_until)) {
|  getnstimeofday(busy_until);
|  timespec_add_ns(busy_until, max_busy_us*1000L);
| } else {
|  struct timespec now;
|  getnstimeofday(&now);
|  if (timespec_compare(&now, busy_until) > 0) {
|   ipmi_si_set_not_busy(busy_until);
|   return 0;
|  }
| }
| return 1;
|}
|static int ipmi_thread(void *data)
|{
| struct smi_info *smi_info = data;
| unsigned long flags;
| enum si_sm_result smi_result;
| struct timespec busy_until;
|
| ipmi_si_set_not_busy(&busy_until);
| set_user_nice(get_current(), 19);
| while (!kthread_should_stop()) {
|  int busy_wait;
|
|  __st_spin_lock_irqsave_st__(&(smi_info->si_lock), flags);
|  smi_result = smi_event_handler(smi_info, 0);
|  __st_spin_unlock_irqrestore_st__(&(smi_info->si_lock), flags);
|  busy_wait = ipmi_thread_busy_wait(smi_result, smi_info,
|        &busy_until);
|  if (smi_result == SI_SM_CALL_WITHOUT_DELAY)
|   ;
|  else if (smi_result == SI_SM_CALL_WITH_DELAY && busy_wait)
|   schedule();
|  else if (smi_result == SI_SM_IDLE)
|   schedule_timeout_interruptible(100);
|  else
|   schedule_timeout_interruptible(1);
| }
| return 0;
|}
|
|
|static void poll(void *send_info)
|{
| struct smi_info *smi_info = send_info;
| unsigned long flags;
|
|
|
|
|
| (__builtin_constant_p(10) ? ((10) > 20000 ? __bad_udelay() : __const_udelay((10) * 0x10c7ul)) : __udelay(10));
| __st_spin_lock_irqsave_st__(&smi_info->si_lock, flags);
| smi_event_handler(smi_info, 10);
| __st_spin_unlock_irqrestore_st__(&smi_info->si_lock, flags);
|}
|
|static void request_events(void *send_info)
|{
| struct smi_info *smi_info = send_info;
|
| if (atomic_read(&smi_info->stop_operation) ||
|    !smi_info->has_event_buffer)
|  return;
|
| atomic_set(&smi_info->req_events, 1);
|}
|
|static int initialized;
|
|static void smi_timeout(unsigned long data)
|{
| struct smi_info *smi_info = (struct smi_info *) data;
| enum si_sm_result smi_result;
| unsigned long flags;
| unsigned long jiffies_now;
| long time_diff;
| long timeout;
|
|
|
|
| __st_spin_lock_irqsave_st__(&(smi_info->si_lock), flags);
|
|
|
|
| jiffies_now = jiffies;
| time_diff = (((long)jiffies_now - (long)smi_info->last_timeout_jiffies)
|       * (1000000/250));
| smi_result = smi_event_handler(smi_info, time_diff);
|
| __st_spin_unlock_irqrestore_st__(&(smi_info->si_lock), flags);
|
| smi_info->last_timeout_jiffies = jiffies_now;
|
| if ((smi_info->irq) && (!smi_info->interrupt_disabled)) {
|
|  timeout = jiffies + (10000/(1000000/250));
|  atomic_inc(&(smi_info)->stats[SI_STAT_long_timeouts]);
|  goto do_mod_timer;
| }
|
|
|
|
|
| if (smi_result == SI_SM_CALL_WITH_DELAY) {
|  atomic_inc(&(smi_info)->stats[SI_STAT_short_timeouts]);
|  timeout = jiffies + 1;
| } else {
|  atomic_inc(&(smi_info)->stats[SI_STAT_long_timeouts]);
|  timeout = jiffies + (10000/(1000000/250));
| }
|
| do_mod_timer:
| if (smi_result != SI_SM_IDLE)
|  mod_timer(&(smi_info->si_timer), timeout);
|}
|
|static irqreturn_t si_irq_handler(int irq, void *data)
|{
| struct smi_info *smi_info = data;
| unsigned long flags;
|
|
|
|
| __st_spin_lock_irqsave_st__(&(smi_info->si_lock), flags);
|
| atomic_inc(&(smi_info)->stats[SI_STAT_interrupts]);
|
|
|
|
|
| smi_event_handler(smi_info, 0);
| __st_spin_unlock_irqrestore_st__(&(smi_info->si_lock), flags);
| return IRQ_HANDLED;
|}
|
|static irqreturn_t si_bt_irq_handler(int irq, void *data)
|{
| struct smi_info *smi_info = data;
|
| smi_info->io.outputb(&smi_info->io, 2,
|        2
|        | 1);
| return si_irq_handler(irq, data);
|}
|
|static int smi_start_processing(void *send_info,
|    ipmi_smi_t intf)
|{
| struct smi_info *new_smi = send_info;
| int enable = 0;
|
| new_smi->intf = intf;
|
|
| if (new_smi->irq_setup)
|  new_smi->irq_setup(new_smi);
|
|
| do { static struct lock_class_key __key; setup_timer_key((&new_smi->si_timer), "&new_smi->si_timer", &__key, (smi_timeout), ((long)new_smi)); } while (0);
| new_smi->last_timeout_jiffies = jiffies;
| mod_timer(&new_smi->si_timer, jiffies + (10000/(1000000/250)));
|
|
|
|
| if (new_smi->intf_num < num_force_kipmid)
|  enable = force_kipmid[new_smi->intf_num];
|
|
|
|
| else if ((new_smi->si_type != SI_BT) && (!new_smi->irq))
|  enable = 1;
|
| if (enable) {
|  new_smi->thread = ({ struct task_struct *__k = kthread_create(ipmi_thread, new_smi, "kipmi%d", new_smi->intf_num); if (!IS_ERR(__k)) wake_up_process(__k); __k; })
|                                        ;
|  if (IS_ERR(new_smi->thread)) {
|   dev_notice(new_smi->dev, "Could not start"
|       " kernel thread due to error %ld, only using"
|       " timers to drive the interface\n",
|       PTR_ERR(new_smi->thread));
|   new_smi->thread = ((void *)0);
|  }
| }
|
| return 0;
|}
|
|static void set_maintenance_mode(void *send_info, int enable)
|{
| struct smi_info *smi_info = send_info;
|
| if (!enable)
|  atomic_set(&smi_info->req_events, 0);
|}
|
|static struct ipmi_smi_handlers handlers = {
| .owner = (&__this_module),
| .start_processing = smi_start_processing,
| .sender = sender,
| .request_events = request_events,
| .set_maintenance_mode = set_maintenance_mode,
| .set_run_to_completion = set_run_to_completion,
| .poll = poll,
|};
|
|
|
|
|
|
|static struct list_head smi_infos = { &(smi_infos), &(smi_infos) };
|static struct mutex smi_infos_lock = { .count = { (1) } , .wait_lock = (spinlock_t ) { { .rlock = { .raw_lock = { 0 }, .magic = 0xdead4ead, .owner_cpu = -1, .owner = ((void *)-1L), .dep_map = { .name = "smi_infos_lock.wait_lock" } } } } , .wait_list = { &(smi_infos_lock.wait_list), &(smi_infos_lock.wait_list) } , .magic = &smi_infos_lock , .dep_map = { .name = "smi_infos_lock" } };
|static int smi_num;
|
|
|
|
|static int si_trydefaults = 1;
|static char *si_type[4];
|
|static char si_type_str[30];
|static unsigned long addrs[4];
|static unsigned int num_addrs;
|static unsigned int ports[4];
|static unsigned int num_ports;
|static int irqs[4];
|static unsigned int num_irqs;
|static int regspacings[4];
|static unsigned int num_regspacings;
|static int regsizes[4];
|static unsigned int num_regsizes;
|static int regshifts[4];
|static unsigned int num_regshifts;
|static int slave_addrs[4];
|static unsigned int num_slave_addrs;
|
|
|
|static char *addr_space_to_str[] = { "i/o", "mem" };
|
|static int hotmod_handler(const char *val, struct kernel_param *kp);
|
|static struct kernel_param_ops __param_ops_hotmod = { (void *)hotmod_handler, (void *)((void *)0) }; static int __param_perm_check_hotmod = (sizeof(struct { int:-!!(((0200) + sizeof(__check_old_set_param(hotmod_handler))*0) < 0 || ((0200) + sizeof(__check_old_set_param(hotmod_handler))*0) > 0777 || (((0200) + sizeof(__check_old_set_param(hotmod_handler))*0) & 2)); })) + (sizeof(struct { int:-!!(sizeof("") > (64 - sizeof(unsigned long))); })); static const char __param_str_hotmod[] = "hotmod"; static struct kernel_param const __param_hotmod = { __param_str_hotmod, &__param_ops_hotmod, (0200) + sizeof(__check_old_set_param(hotmod_handler))*0, 0 ? 2 : 0, { ((void *)0) } };
|static const char
|
| __mod_hotmod1247
| [] = "parm" "=" "hotmod" ":" "Add and remove interfaces.  See" " Documentation/IPMI.txt in the kernel sources for the" " gory details."
|
|                    ;
|
|static inline void __check_trydefaults(void) { ((void)(sizeof(struct { int:-!!(!0 && !0 && !0); }))); }; static int __param_perm_check_trydefaults = (sizeof(struct { int:-!!((0) < 0 || (0) > 0777 || ((0) & 2)); })) + (sizeof(struct { int:-!!(sizeof("") > (64 - sizeof(unsigned long))); })); static const char __param_str_trydefaults[] = "trydefaults"; static struct kernel_param const __param_trydefaults = { __param_str_trydefaults, ¶m_ops_bool, 0, 0 ? 2 : 0, { &si_trydefaults } }; static const char __mod_trydefaultstype1249[] = "parmtype" "=" "trydefaults" ":" "bool";
|static const char
|
| __mod_trydefaults1252
| [] = "parm" "=" "trydefaults" ":" "Setting this to 'false' will disable the" " default scan of the KCS and SMIC interface at the standard" " address"
|
|              ;
|static const struct kparam_string __param_string_type = { 30, si_type_str }; static int __param_perm_check_type = (sizeof(struct { int:-!!((0) < 0 || (0) > 0777 || ((0) & 2)); })) + (sizeof(struct { int:-!!(sizeof("") > (64 - sizeof(unsigned long))); })); static const char __param_str_type[] = "type"; static struct kernel_param const __param_type = { __param_str_type, ¶m_ops_string, 0, 0 ? 2 : 0, { .str = &__param_string_type } }; static const char __mod_typetype1253[] = "parmtype" "=" "type" ":" "string";
|static const char
|
|
| __mod_type1257
| [] = "parm" "=" "type" ":" "Defines the type of each interface, each" " interface separated by commas.  The types are 'kcs'," " 'smic', and 'bt'.  For example si_type=kcs,bt will set" " the first interface to kcs and the second to bt"
|
|
|                                                      ;
|static const struct kparam_array __param_arr_addrs = { (sizeof(addrs) / sizeof((addrs)[0]) + (sizeof(struct { int:-!!(0); }))), &num_addrs, ¶m_ops_ulong, sizeof(addrs[0]), addrs }; static int __param_perm_check_addrs = (sizeof(struct { int:-!!((0) < 0 || (0) > 0777 || ((0) & 2)); })) + (sizeof(struct { int:-!!(sizeof("") > (64 - sizeof(unsigned long))); })); static const char __param_str_addrs[] = "addrs"; static struct kernel_param const __param_addrs = { __param_str_addrs, ¶m_array_ops, 0, 0 ? 2 : 0, { .arr = &__param_arr_addrs } }; static const char __mod_addrstype1258[] = "parmtype" "=" "addrs" ":" "array of " "ulong";
|static const char
|
|
| __mod_addrs1262
| [] = "parm" "=" "addrs" ":" "Sets the memory address of each interface, the" " addresses separated by commas.  Only use if an interface" " is in memory.  Otherwise, set it to zero or leave" " it blank."
|
|
|                ;
|static const struct kparam_array __param_arr_ports = { (sizeof(ports) / sizeof((ports)[0]) + (sizeof(struct { int:-!!(0); }))), &num_ports, ¶m_ops_uint, sizeof(ports[0]), ports }; static int __param_perm_check_ports = (sizeof(struct { int:-!!((0) < 0 || (0) > 0777 || ((0) & 2)); })) + (sizeof(struct { int:-!!(sizeof("") > (64 - sizeof(unsigned long))); })); static const char __param_str_ports[] = "ports"; static struct kernel_param const __param_ports = { __param_str_ports, ¶m_array_ops, 0, 0 ? 2 : 0, { .arr = &__param_arr_ports } }; static const char __mod_portstype1263[] = "parmtype" "=" "ports" ":" "array of " "uint";
|static const char
|
|
| __mod_ports1267
| [] = "parm" "=" "ports" ":" "Sets the port address of each interface, the" " addresses separated by commas.  Only use if an interface" " is a port.  Otherwise, set it to zero or leave" " it blank."
|
|
|                ;
|static const struct kparam_array __param_arr_irqs = { (sizeof(irqs) / sizeof((irqs)[0]) + (sizeof(struct { int:-!!(0); }))), &num_irqs, ¶m_ops_int, sizeof(irqs[0]), irqs }; static int __param_perm_check_irqs = (sizeof(struct { int:-!!((0) < 0 || (0) > 0777 || ((0) & 2)); })) + (sizeof(struct { int:-!!(sizeof("") > (64 - sizeof(unsigned long))); })); static const char __param_str_irqs[] = "irqs"; static struct kernel_param const __param_irqs = { __param_str_irqs, ¶m_array_ops, 0, 0 ? 2 : 0, { .arr = &__param_arr_irqs } }; static const char __mod_irqstype1268[] = "parmtype" "=" "irqs" ":" "array of " "int";
|static const char
|
|
| __mod_irqs1272
| [] = "parm" "=" "irqs" ":" "Sets the interrupt of each interface, the" " addresses separated by commas.  Only use if an interface" " has an interrupt.  Otherwise, set it to zero or leave" " it blank."
|
|
|                ;
|static const struct kparam_array __param_arr_regspacings = { (sizeof(regspacings) / sizeof((regspacings)[0]) + (sizeof(struct { int:-!!(0); }))), &num_regspacings, ¶m_ops_int, sizeof(regspacings[0]), regspacings }; static int __param_perm_check_regspacings = (sizeof(struct { int:-!!((0) < 0 || (0) > 0777 || ((0) & 2)); })) + (sizeof(struct { int:-!!(sizeof("") > (64 - sizeof(unsigned long))); })); static const char __param_str_regspacings[] = "regspacings"; static struct kernel_param const __param_regspacings = { __param_str_regspacings, ¶m_array_ops, 0, 0 ? 2 : 0, { .arr = &__param_arr_regspacings } }; static const char __mod_regspacingstype1273[] = "parmtype" "=" "regspacings" ":" "array of " "int";
|static const char
|
|
|
| __mod_regspacings1278
| [] = "parm" "=" "regspacings" ":" "The number of bytes between the start address" " and each successive register used by the interface.  For" " instance, if the start address is 0xca2 and the spacing" " is 2, then the second address is at 0xca4.  Defaults" " to 1."
|
|
|
|            ;
|static const struct kparam_array __param_arr_regsizes = { (sizeof(regsizes) / sizeof((regsizes)[0]) + (sizeof(struct { int:-!!(0); }))), &num_regsizes, ¶m_ops_int, sizeof(regsizes[0]), regsizes }; static int __param_perm_check_regsizes = (sizeof(struct { int:-!!((0) < 0 || (0) > 0777 || ((0) & 2)); })) + (sizeof(struct { int:-!!(sizeof("") > (64 - sizeof(unsigned long))); })); static const char __param_str_regsizes[] = "regsizes"; static struct kernel_param const __param_regsizes = { __param_str_regsizes, ¶m_array_ops, 0, 0 ? 2 : 0, { .arr = &__param_arr_regsizes } }; static const char __mod_regsizestype1279[] = "parmtype" "=" "regsizes" ":" "array of " "int";
|static const char
|
|
|
| __mod_regsizes1284
| [] = "parm" "=" "regsizes" ":" "The size of the specific IPMI register in bytes." " This should generally be 1, 2, 4, or 8 for an 8-bit," " 16-bit, 32-bit, or 64-bit register.  Use this if you" " the 8-bit IPMI register has to be read from a larger" " register."
|
|
|
|                ;
|static const struct kparam_array __param_arr_regshifts = { (sizeof(regshifts) / sizeof((regshifts)[0]) + (sizeof(struct { int:-!!(0); }))), &num_regshifts, ¶m_ops_int, sizeof(regshifts[0]), regshifts }; static int __param_perm_check_regshifts = (sizeof(struct { int:-!!((0) < 0 || (0) > 0777 || ((0) & 2)); })) + (sizeof(struct { int:-!!(sizeof("") > (64 - sizeof(unsigned long))); })); static const char __param_str_regshifts[] = "regshifts"; static struct kernel_param const __param_regshifts = { __param_str_regshifts, ¶m_array_ops, 0, 0 ? 2 : 0, { .arr = &__param_arr_regshifts } }; static const char __mod_regshiftstype1285[] = "parmtype" "=" "regshifts" ":" "array of " "int";
|static const char
|
|
| __mod_regshifts1289
| [] = "parm" "=" "regshifts" ":" "The amount to shift the data read from the." " IPMI register, in bits.  For instance, if the data" " is read from a 32-bit word and the IPMI data is in" " bit 8-15, then the shift would be 8"
|
|
|                                          ;
|static const struct kparam_array __param_arr_slave_addrs = { (sizeof(slave_addrs) / sizeof((slave_addrs)[0]) + (sizeof(struct { int:-!!(0); }))), &num_slave_addrs, ¶m_ops_int, sizeof(slave_addrs[0]), slave_addrs }; static int __param_perm_check_slave_addrs = (sizeof(struct { int:-!!((0) < 0 || (0) > 0777 || ((0) & 2)); })) + (sizeof(struct { int:-!!(sizeof("") > (64 - sizeof(unsigned long))); })); static const char __param_str_slave_addrs[] = "slave_addrs"; static struct kernel_param const __param_slave_addrs = { __param_str_slave_addrs, ¶m_array_ops, 0, 0 ? 2 : 0, { .arr = &__param_arr_slave_addrs } }; static const char __mod_slave_addrstype1290[] = "parmtype" "=" "slave_addrs" ":" "array of " "int";
|static const char
|
|
| __mod_slave_addrs1294
| [] = "parm" "=" "slave_addrs" ":" "Set the default IPMB slave address for" " the controller.  Normally this is 0x20, but can be" " overridden by this parm.  This is an array indexed" " by interface number."
|
|
|                           ;
|static const struct kparam_array __param_arr_force_kipmid = { (sizeof(force_kipmid) / sizeof((force_kipmid)[0]) + (sizeof(struct { int:-!!(0); }))), &num_force_kipmid, ¶m_ops_int, sizeof(force_kipmid[0]), force_kipmid }; static int __param_perm_check_force_kipmid = (sizeof(struct { int:-!!((0) < 0 || (0) > 0777 || ((0) & 2)); })) + (sizeof(struct { int:-!!(sizeof("") > (64 - sizeof(unsigned long))); })); static const char __param_str_force_kipmid[] = "force_kipmid"; static struct kernel_param const __param_force_kipmid = { __param_str_force_kipmid, ¶m_array_ops, 0, 0 ? 2 : 0, { .arr = &__param_arr_force_kipmid } }; static const char __mod_force_kipmidtype1295[] = "parmtype" "=" "force_kipmid" ":" "array of " "int";
|static const char
|
| __mod_force_kipmid1298
| [] = "parm" "=" "force_kipmid" ":" "Force the kipmi daemon to be enabled (1) or" " disabled(0).  Normally the IPMI driver auto-detects" " this, but the value may be overridden by this parm."
|
|                                                          ;
|static inline int *__check_unload_when_empty(void) { return(&(unload_when_empty)); }; static int __param_perm_check_unload_when_empty = (sizeof(struct { int:-!!((0) < 0 || (0) > 0777 || ((0) & 2)); })) + (sizeof(struct { int:-!!(sizeof("") > (64 - sizeof(unsigned long))); })); static const char __param_str_unload_when_empty[] = "unload_when_empty"; static struct kernel_param const __param_unload_when_empty = { __param_str_unload_when_empty, ¶m_ops_int, 0, 0 ? 2 : 0, { &unload_when_empty } }; static const char __mod_unload_when_emptytype1299[] = "parmtype" "=" "unload_when_empty" ":" "int";
|static const char
|
| __mod_unload_when_empty1302
| [] = "parm" "=" "unload_when_empty" ":" "Unload the module if no interfaces are" " specified or found, default is 1.  Setting to 0" " is useful for hot add of devices using hotmod."
|
|                                                     ;
|static const struct kparam_array __param_arr_kipmid_max_busy_us = { (sizeof(kipmid_max_busy_us) / sizeof((kipmid_max_busy_us)[0]) + (sizeof(struct { int:-!!(0); }))), &num_max_busy_us, ¶m_ops_uint, sizeof(kipmid_max_busy_us[0]), kipmid_max_busy_us }; static int __param_perm_check_kipmid_max_busy_us = (sizeof(struct { int:-!!((0644) < 0 || (0644) > 0777 || ((0644) & 2)); })) + (sizeof(struct { int:-!!(sizeof("") > (64 - sizeof(unsigned long))); })); static const char __param_str_kipmid_max_busy_us[] = "kipmid_max_busy_us"; static struct kernel_param const __param_kipmid_max_busy_us = { __param_str_kipmid_max_busy_us, ¶m_array_ops, 0644, 0 ? 2 : 0, { .arr = &__param_arr_kipmid_max_busy_us } }; static const char __mod_kipmid_max_busy_ustype1303[] = "parmtype" "=" "kipmid_max_busy_us" ":" "array of " "uint";
|static const char
|
|
| __mod_kipmid_max_busy_us1307
| [] = "parm" "=" "kipmid_max_busy_us" ":" "Max time (in microseconds) to busy-wait for IPMI data before" " sleeping. 0 (default) means to wait forever. Set to 100-500" " if kipmid is using up a lot of CPU time."
|
|
|                                               ;
|
|
|static void std_irq_cleanup(struct smi_info *info)
|{
| if (info->si_type == SI_BT)
|
|  info->io.outputb(&info->io, 2, 0);
| free_irq(info->irq, info);
|}
|
|static int std_irq_setup(struct smi_info *info)
|{
| int rv;
|
| if (!info->irq)
|  return 0;
|
| if (info->si_type == SI_BT) {
|  rv = request_irq(info->irq,
|     si_bt_irq_handler,
|     0x00000080 | 0x00000020,
|     "ipmi_si",
|     info);
|  if (!rv)
|
|   info->io.outputb(&info->io, 2,
|      1);
| } else
|  rv = request_irq(info->irq,
|     si_irq_handler,
|     0x00000080 | 0x00000020,
|     "ipmi_si",
|     info);
| if (rv) {
|  dev_warn(info->dev, "%s unable to claim interrupt %d,"
|    " running polled\n",
|    "ipmi_si", info->irq);
|  info->irq = 0;
| } else {
|  info->irq_cleanup = std_irq_cleanup;
|  _dev_info(info->dev, "Using irq %d\n", info->irq);
| }
|
| return rv;
|}
|
|static unsigned char port_inb(struct si_sm_io *io, unsigned int offset)
|{
| unsigned int addr = io->addr_data;
|
| return inb(addr + (offset * io->regspacing));
|}
|
|static void port_outb(struct si_sm_io *io, unsigned int offset,
|        unsigned char b)
|{
| unsigned int addr = io->addr_data;
|
| outb(b, addr + (offset * io->regspacing));
|}
|
|static unsigned char port_inw(struct si_sm_io *io, unsigned int offset)
|{
| unsigned int addr = io->addr_data;
|
| return (inw(addr + (offset * io->regspacing)) >> io->regshift) & 0xff;
|}
|
|static void port_outw(struct si_sm_io *io, unsigned int offset,
|        unsigned char b)
|{
| unsigned int addr = io->addr_data;
|
| outw(b << io->regshift, addr + (offset * io->regspacing));
|}
|
|static unsigned char port_inl(struct si_sm_io *io, unsigned int offset)
|{
| unsigned int addr = io->addr_data;
|
| return (inl(addr + (offset * io->regspacing)) >> io->regshift) & 0xff;
|}
|
|static void port_outl(struct si_sm_io *io, unsigned int offset,
|        unsigned char b)
|{
| unsigned int addr = io->addr_data;
|
| outl(b << io->regshift, addr+(offset * io->regspacing));
|}
|
|static void port_cleanup(struct smi_info *info)
|{
| unsigned int addr = info->io.addr_data;
| int idx;
|
| if (addr) {
|  for (idx = 0; idx < info->io_size; idx++)
|   __release_region(&ioport_resource, (addr + idx * info->io.regspacing), (info->io.regsize))
|                            ;
| }
|}
|
|static int port_setup(struct smi_info *info)
|{
| unsigned int addr = info->io.addr_data;
| int idx;
|
| if (!addr)
|  return -19;
|
| info->io_cleanup = port_cleanup;
|
|
|
|
|
| switch (info->io.regsize) {
| case 1:
|  info->io.inputb = port_inb;
|  info->io.outputb = port_outb;
|  break;
| case 2:
|  info->io.inputb = port_inw;
|  info->io.outputb = port_outw;
|  break;
| case 4:
|  info->io.inputb = port_inl;
|  info->io.outputb = port_outl;
|  break;
| default:
|  dev_warn(info->dev, "Invalid register size: %d\n",
|    info->io.regsize);
|  return -22;
| }
|
|
|
|
|
|
|
| for (idx = 0; idx < info->io_size; idx++) {
|  if (__request_region(&ioport_resource, (addr + idx * info->io.regspacing), (info->io.regsize), ("ipmi_si"), 0)
|                                      == ((void *)0)) {
|
|   while (idx--) {
|    __release_region(&ioport_resource, (addr + idx * info->io.regspacing), (info->io.regsize))
|                             ;
|   }
|   return -5;
|  }
| }
| return 0;
|}
|
|static unsigned char intf_mem_inb(struct si_sm_io *io, unsigned int offset)
|{
| return readb((io->addr)+(offset * io->regspacing));
|}
|
|static void intf_mem_outb(struct si_sm_io *io, unsigned int offset,
|       unsigned char b)
|{
| writeb(b, (io->addr)+(offset * io->regspacing));
|}
|
|static unsigned char intf_mem_inw(struct si_sm_io *io, unsigned int offset)
|{
| return (readw((io->addr)+(offset * io->regspacing)) >> io->regshift)
|  & 0xff;
|}
|
|static void intf_mem_outw(struct si_sm_io *io, unsigned int offset,
|       unsigned char b)
|{
| writeb(b << io->regshift, (io->addr)+(offset * io->regspacing));
|}
|
|static unsigned char intf_mem_inl(struct si_sm_io *io, unsigned int offset)
|{
| return (readl((io->addr)+(offset * io->regspacing)) >> io->regshift)
|  & 0xff;
|}
|
|static void intf_mem_outl(struct si_sm_io *io, unsigned int offset,
|       unsigned char b)
|{
| writel(b << io->regshift, (io->addr)+(offset * io->regspacing));
|}
|
|
|static unsigned char mem_inq(struct si_sm_io *io, unsigned int offset)
|{
| return (readq((io->addr)+(offset * io->regspacing)) >> io->regshift)
|  & 0xff;
|}
|
|static void mem_outq(struct si_sm_io *io, unsigned int offset,
|       unsigned char b)
|{
| writeq(b << io->regshift, (io->addr)+(offset * io->regspacing));
|}
|
|
|static void mem_cleanup(struct smi_info *info)
|{
| unsigned long addr = info->io.addr_data;
| int mapsize;
|
| if (info->io.addr) {
|  iounmap(info->io.addr);
|
|  mapsize = ((info->io_size * info->io.regspacing)
|      - (info->io.regspacing - info->io.regsize));
|
|  __release_region(&iomem_resource, (addr), (mapsize));
| }
|}
|
|static int mem_setup(struct smi_info *info)
|{
| unsigned long addr = info->io.addr_data;
| int mapsize;
|
| if (!addr)
|  return -19;
|
| info->io_cleanup = mem_cleanup;
|
|
|
|
|
| switch (info->io.regsize) {
| case 1:
|  info->io.inputb = intf_mem_inb;
|  info->io.outputb = intf_mem_outb;
|  break;
| case 2:
|  info->io.inputb = intf_mem_inw;
|  info->io.outputb = intf_mem_outw;
|  break;
| case 4:
|  info->io.inputb = intf_mem_inl;
|  info->io.outputb = intf_mem_outl;
|  break;
|
| case 8:
|  info->io.inputb = mem_inq;
|  info->io.outputb = mem_outq;
|  break;
|
| default:
|  dev_warn(info->dev, "Invalid register size: %d\n",
|    info->io.regsize);
|  return -22;
| }
| mapsize = ((info->io_size * info->io.regspacing)
|     - (info->io.regspacing - info->io.regsize));
|
| if (__request_region(&iomem_resource, (addr), (mapsize), ("ipmi_si"), 0) == ((void *)0))
|  return -5;
|
| info->io.addr = ioremap(addr, mapsize);
| if (info->io.addr == ((void *)0)) {
|  __release_region(&iomem_resource, (addr), (mapsize));
|  return -5;
| }
| return 0;
|}
|enum hotmod_op { HM_ADD, HM_REMOVE };
|struct hotmod_vals {
| char *name;
| int val;
|};
|static struct hotmod_vals hotmod_ops[] = {
| { "add", HM_ADD },
| { "remove", HM_REMOVE },
| { ((void *)0) }
|};
|static struct hotmod_vals hotmod_si[] = {
| { "kcs", SI_KCS },
| { "smic", SI_SMIC },
| { "bt", SI_BT },
| { ((void *)0) }
|};
|static struct hotmod_vals hotmod_as[] = {
| { "mem", 1 },
| { "i/o", 0 },
| { ((void *)0) }
|};
|
|static int parse_str(struct hotmod_vals *v, int *val, char *name, char **curr)
|{
| char *s;
| int i;
|
| s = strchr(*curr, ',');
| if (!s) {
|  printk("<4>" "ipmi_si: " "No hotmod %s given.\n", name);
|  return -22;
| }
| *s = '\0';
| s++;
| for (i = 0; hotmod_ops[i].name; i++) {
|  if (strcmp(*curr, v[i].name) == 0) {
|   *val = v[i].val;
|   *curr = s;
|   return 0;
|  }
| }
|
| printk("<4>" "ipmi_si: " "Invalid hotmod %s '%s'\n", name, *curr);
| return -22;
|}
|
|static int check_hotmod_int_op(const char *curr, const char *option,
|          const char *name, int *val)
|{
| char *n;
|
| if (strcmp(curr, name) == 0) {
|  if (!option) {
|   printk("<4>" "ipmi_si: "
|          "No option given for '%s'\n",
|          curr);
|   return -22;
|  }
|  *val = simple_strtoul(option, &n, 0);
|  if ((*n != '\0') || (*option == '\0')) {
|   printk("<4>" "ipmi_si: "
|          "Bad option given for '%s'\n",
|          curr);
|   return -22;
|  }
|  return 1;
| }
| return 0;
|}
|
|static struct smi_info *smi_info_alloc(void)
|{
| struct smi_info *info = kzalloc(sizeof(*info), __st_GFP_KERNEL_st__);
|
| if (info) {
|  do { spinlock_check(&info->si_lock); do { static struct lock_class_key __key; __raw_spin_lock_init((&(&info->si_lock)->rlock), "&(&info->si_lock)->rlock", &__key); } while (0); } while (0);
|  do { spinlock_check(&info->msg_lock); do { static struct lock_class_key __key; __raw_spin_lock_init((&(&info->msg_lock)->rlock), "&(&info->msg_lock)->rlock", &__key); } while (0); } while (0);
| }
| return info;
|}
|
|static int hotmod_handler(const char *val, struct kernel_param *kp)
|{
| char *str = kstrdup(val, __st_GFP_KERNEL_st__);
| int rv;
| char *next, *curr, *s, *n, *o;
| enum hotmod_op op;
| enum si_type si_type;
| int addr_space;
| unsigned long addr;
| int regspacing;
| int regsize;
| int regshift;
| int irq;
| int ipmb;
| int ival;
| int len;
| struct smi_info *info;
|
| if (!str)
|  return -12;
|
|
| len = strlen(str);
| ival = len - 1;
| while ((ival >= 0) && (((_ctype[(int)(unsigned char)(str[ival])])&(0x20)) != 0)) {
|  str[ival] = '\0';
|  ival--;
| }
|
| for (curr = str; curr; curr = next) {
|  regspacing = 1;
|  regsize = 1;
|  regshift = 0;
|  irq = 0;
|  ipmb = 0;
|
|  next = strchr(curr, ':');
|  if (next) {
|   *next = '\0';
|   next++;
|  }
|
|  rv = parse_str(hotmod_ops, &ival, "operation", &curr);
|  if (rv)
|   break;
|  op = ival;
|
|  rv = parse_str(hotmod_si, &ival, "interface type", &curr);
|  if (rv)
|   break;
|  si_type = ival;
|
|  rv = parse_str(hotmod_as, &addr_space, "address space", &curr);
|  if (rv)
|   break;
|
|  s = strchr(curr, ',');
|  if (s) {
|   *s = '\0';
|   s++;
|  }
|  addr = simple_strtoul(curr, &n, 0);
|  if ((*n != '\0') || (*curr == '\0')) {
|   printk("<4>" "ipmi_si: " "Invalid hotmod address"
|          " '%s'\n", curr);
|   break;
|  }
|
|  while (s) {
|   curr = s;
|   s = strchr(curr, ',');
|   if (s) {
|    *s = '\0';
|    s++;
|   }
|   o = strchr(curr, '=');
|   if (o) {
|    *o = '\0';
|    o++;
|   }
|   rv = check_hotmod_int_op(curr, o, "rsp", ®spacing);
|   if (rv < 0)
|    goto out;
|   else if (rv)
|    continue;
|   rv = check_hotmod_int_op(curr, o, "rsi", ®size);
|   if (rv < 0)
|    goto out;
|   else if (rv)
|    continue;
|   rv = check_hotmod_int_op(curr, o, "rsh", ®shift);
|   if (rv < 0)
|    goto out;
|   else if (rv)
|    continue;
|   rv = check_hotmod_int_op(curr, o, "irq", &irq);
|   if (rv < 0)
|    goto out;
|   else if (rv)
|    continue;
|   rv = check_hotmod_int_op(curr, o, "ipmb", &ipmb);
|   if (rv < 0)
|    goto out;
|   else if (rv)
|    continue;
|
|   rv = -22;
|   printk("<4>" "ipmi_si: "
|          "Invalid hotmod option '%s'\n",
|          curr);
|   goto out;
|  }
|
|  if (op == HM_ADD) {
|   info = smi_info_alloc();
|   if (!info) {
|    rv = -12;
|    goto out;
|   }
|
|   info->addr_source = SI_HOTMOD;
|   info->si_type = si_type;
|   info->io.addr_data = addr;
|   info->io.addr_type = addr_space;
|   if (addr_space == 1)
|    info->io_setup = mem_setup;
|   else
|    info->io_setup = port_setup;
|
|   info->io.addr = ((void *)0);
|   info->io.regspacing = regspacing;
|   if (!info->io.regspacing)
|    info->io.regspacing = 1;
|   info->io.regsize = regsize;
|   if (!info->io.regsize)
|    info->io.regsize = 1;
|   info->io.regshift = regshift;
|   info->irq = irq;
|   if (info->irq)
|    info->irq_setup = std_irq_setup;
|   info->slave_addr = ipmb;
|
|   if (!add_smi(info)) {
|    if (try_smi_init(info))
|     cleanup_one_si(info);
|   } else {
|    kfree(info);
|   }
|  } else {
|
|   struct smi_info *e, *tmp_e;
|
|   __st_mutex_lock_st__(&smi_infos_lock);
|   for (e = ({ const typeof( ((typeof(*e) *)0)->link ) *__mptr = ((&smi_infos)->next); (typeof(*e) *)( (char *)__mptr - 1 );}), tmp_e = ({ const typeof( ((typeof(*e) *)0)->link ) *__mptr = (e->link.next); (typeof(*e) *)( (char *)__mptr - 1 );}); &e->link != (&smi_infos); e = tmp_e, tmp_e = ({ const typeof( ((typeof(*tmp_e) *)0)->link ) *__mptr = (tmp_e->link.next); (typeof(*tmp_e) *)( (char *)__mptr - 1 );})) {
|    if (e->io.addr_type != addr_space)
|     continue;
|    if (e->si_type != si_type)
|     continue;
|    if (e->io.addr_data == addr)
|     cleanup_one_si(e);
|   }
|   __st_mutex_unlock_st__(&smi_infos_lock);
|  }
| }
| rv = len;
| out:
| kfree(str);
| return rv;
|}
|
|static void hardcode_find_bmc(void)
|{
| int i;
| struct smi_info *info;
|
| for (i = 0; i < 4; i++) {
|  if (!ports[i] && !addrs[i])
|   continue;
|
|  info = smi_info_alloc();
|  if (!info)
|   return;
|
|  info->addr_source = SI_HARDCODED;
|  printk("<6>" "ipmi_si: " "probing via hardcoded address\n");
|
|  if (!si_type[i] || strcmp(si_type[i], "kcs") == 0) {
|   info->si_type = SI_KCS;
|  } else if (strcmp(si_type[i], "smic") == 0) {
|   info->si_type = SI_SMIC;
|  } else if (strcmp(si_type[i], "bt") == 0) {
|   info->si_type = SI_BT;
|  } else {
|   printk("<4>" "ipmi_si: " "Interface type specified "
|          "for interface %d, was invalid: %s\n",
|          i, si_type[i]);
|   kfree(info);
|   continue;
|  }
|
|  if (ports[i]) {
|
|   info->io_setup = port_setup;
|   info->io.addr_data = ports[i];
|   info->io.addr_type = 0;
|  } else if (addrs[i]) {
|
|   info->io_setup = mem_setup;
|   info->io.addr_data = addrs[i];
|   info->io.addr_type = 1;
|  } else {
|   printk("<4>" "ipmi_si: " "Interface type specified "
|          "for interface %d, but port and address were "
|          "not set or set to zero.\n", i);
|   kfree(info);
|   continue;
|  }
|
|  info->io.addr = ((void *)0);
|  info->io.regspacing = regspacings[i];
|  if (!info->io.regspacing)
|   info->io.regspacing = 1;
|  info->io.regsize = regsizes[i];
|  if (!info->io.regsize)
|   info->io.regsize = 1;
|  info->io.regshift = regshifts[i];
|  info->irq = irqs[i];
|  if (info->irq)
|   info->irq_setup = std_irq_setup;
|  info->slave_addr = slave_addrs[i];
|
|  if (!add_smi(info)) {
|   if (try_smi_init(info))
|    cleanup_one_si(info);
|  } else {
|   kfree(info);
|  }
| }
|}
|
|
|
|
|
|
|typedef unsigned char BOOLEAN;
|typedef unsigned char UINT8;
|typedef unsigned short UINT16;
|typedef unsigned long long UINT64;
|typedef long long INT64;
|typedef unsigned int UINT32;
|typedef int INT32;
|
|
|
|typedef s64 acpi_native_int;
|
|typedef u64 acpi_size;
|typedef u64 acpi_io_address;
|typedef u64 acpi_physical_address;
|typedef u32 acpi_status;
|typedef u32 acpi_name;
|typedef char *acpi_string;
|typedef void *acpi_handle;
|
|
|
|typedef u8 acpi_owner_id;
|typedef u64 acpi_integer;
|typedef u32 acpi_object_type;
|typedef u32 acpi_event_type;
|typedef u32 acpi_event_status;
|typedef u8 acpi_adr_space_type;
|union acpi_object {
| acpi_object_type type;
| struct {
|  acpi_object_type type;
|  u64 value;
| } integer;
|
| struct {
|  acpi_object_type type;
|  u32 length;
|  char *pointer;
| } string;
|
| struct {
|  acpi_object_type type;
|  u32 length;
|  u8 *pointer;
| } buffer;
|
| struct {
|  acpi_object_type type;
|  u32 count;
|  union acpi_object *elements;
| } package;
|
| struct {
|  acpi_object_type type;
|  acpi_object_type actual_type;
|  acpi_handle handle;
| } reference;
|
| struct {
|  acpi_object_type type;
|  u32 proc_id;
|  acpi_io_address pblk_address;
|  u32 pblk_length;
| } processor;
|
| struct {
|  acpi_object_type type;
|  u32 system_level;
|  u32 resource_order;
| } power_resource;
|};
|
|
|
|
|struct acpi_object_list {
| u32 count;
| union acpi_object *pointer;
|};
|struct acpi_buffer {
| acpi_size length;
| void *pointer;
|};
|struct acpi_predefined_names {
| char *name;
| u8 type;
| char *val;
|};
|struct acpi_system_info {
| u32 acpi_ca_version;
| u32 flags;
| u32 timer_resolution;
| u32 reserved1;
| u32 reserved2;
| u32 debug_level;
| u32 debug_layer;
|};
|typedef u32( * acpi_osd_handler) (void *context);
|
|typedef void
| ( * acpi_osd_exec_callback) (void *context);
|
|
|
|
|typedef u32(*acpi_event_handler) (void *context);
|
|typedef
|void (*acpi_notify_handler) (acpi_handle device, u32 value, void *context);
|
|typedef
|void (*acpi_object_handler) (acpi_handle object, void *data);
|
|typedef acpi_status(*acpi_init_handler) (acpi_handle object, u32 function);
|
|
|
|typedef
|acpi_status(*acpi_exception_handler) (acpi_status aml_status,
|          acpi_name name,
|          u16 opcode,
|          u32 aml_offset, void *context);
|
|
|
|typedef
|acpi_status(*acpi_tbl_handler) (u32 event, void *table, void *context);
|
|
|
|typedef
|acpi_status(*acpi_adr_space_handler) (u32 function,
|          acpi_physical_address address,
|          u32 bit_width,
|          u64 *value,
|          void *handler_context,
|          void *region_context);
|
|
|
|typedef
|acpi_status(*acpi_adr_space_setup) (acpi_handle region_handle,
|        u32 function,
|        void *handler_context,
|        void **region_context);
|
|
|
|
|typedef
|acpi_status(*acpi_walk_callback) (acpi_handle object,
|      u32 nesting_level,
|      void *context, void **return_value);
|
|typedef
|u32 (*acpi_interface_handler) (acpi_string interface_name, u32 supported);
|struct acpica_device_id {
| u32 length;
| char *string;
|};
|
|struct acpica_device_id_list {
| u32 count;
| u32 list_size;
| struct acpica_device_id ids[1];
|};
|
|
|
|
|
|struct acpi_device_info {
| u32 info_size;
| u32 name;
| acpi_object_type type;
| u8 param_count;
| u8 valid;
| u8 flags;
| u8 highest_dstates[4];
| u8 lowest_dstates[5];
| u32 current_status;
| u64 address;
| struct acpica_device_id hardware_id;
| struct acpica_device_id unique_id;
| struct acpica_device_id_list compatible_id_list;
|};
|struct acpi_pci_id {
| u16 segment;
| u16 bus;
| u16 device;
| u16 function;
|};
|
|struct acpi_mem_space_context {
| u32 length;
| acpi_physical_address address;
| acpi_physical_address mapped_physical_address;
| u8 *mapped_logical_address;
| acpi_size mapped_length;
|};
|
|
|
|
|struct acpi_memory_list {
| char *list_name;
| void *list_head;
| u16 object_size;
| u16 max_depth;
| u16 current_depth;
| u16 link_offset;
|};
|
|
|
|static inline u64 acpi_os_get_thread_id(void)
|{
| return (u64)(unsigned long)get_current();
|}
|
|
|
|
|
|
|
|static inline void *acpi_os_allocate(acpi_size size)
|{
| return kmalloc(size, ({ unsigned long _flags; do { ({ unsigned long __dummy; typeof(_flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); _flags = arch_local_save_flags(); } while (0); ({ ({ unsigned long __dummy; typeof(_flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_irqs_disabled_flags(_flags); }); }) ? ((( gfp_t)0x20u)) : ((( gfp_t)0x10u) | (( gfp_t)0x40u) | (( gfp_t)0x80u)));
|}
|
|static inline void *acpi_os_allocate_zeroed(acpi_size size)
|{
| return kzalloc(size, ({ unsigned long _flags; do { ({ unsigned long __dummy; typeof(_flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); _flags = arch_local_save_flags(); } while (0); ({ ({ unsigned long __dummy; typeof(_flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_irqs_disabled_flags(_flags); }); }) ? ((( gfp_t)0x20u)) : ((( gfp_t)0x10u) | (( gfp_t)0x40u) | (( gfp_t)0x80u)));
|}
|
|static inline void *acpi_os_acquire_object(struct kmem_cache * cache)
|{
| return kmem_cache_zalloc(cache,
|  ({ unsigned long _flags; do { ({ unsigned long __dummy; typeof(_flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); _flags = arch_local_save_flags(); } while (0); ({ ({ unsigned long __dummy; typeof(_flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_irqs_disabled_flags(_flags); }); }) ? ((( gfp_t)0x20u)) : ((( gfp_t)0x10u) | (( gfp_t)0x40u) | (( gfp_t)0x80u)));
|}
|struct acpi_table_header {
| char signature[4];
| u32 length;
| u8 revision;
| u8 checksum;
| char oem_id[6];
| char oem_table_id[8];
| u32 oem_revision;
| char asl_compiler_id[4];
| u32 asl_compiler_revision;
|};
|struct acpi_generic_address {
| u8 space_id;
| u8 bit_width;
| u8 bit_offset;
| u8 access_width;
| u64 address;
|};
|struct acpi_table_rsdp {
| char signature[8];
| u8 checksum;
| char oem_id[6];
| u8 revision;
| u32 rsdt_physical_address;
| u32 length;
| u64 xsdt_physical_address;
| u8 extended_checksum;
| u8 reserved[3];
|};
|struct acpi_table_rsdt {
| struct acpi_table_header header;
| u32 table_offset_entry[1];
|};
|
|struct acpi_table_xsdt {
| struct acpi_table_header header;
| u64 table_offset_entry[1];
|};
|
|
|
|
|
|
|
|struct acpi_table_facs {
| char signature[4];
| u32 length;
| u32 hardware_signature;
| u32 firmware_waking_vector;
| u32 global_lock;
| u32 flags;
| u64 xfirmware_waking_vector;
| u8 version;
| u8 reserved[3];
| u32 ospm_flags;
| u8 reserved1[24];
|};
|struct acpi_table_fadt {
| struct acpi_table_header header;
| u32 facs;
| u32 dsdt;
| u8 model;
| u8 preferred_profile;
| u16 sci_interrupt;
| u32 smi_command;
| u8 acpi_enable;
| u8 acpi_disable;
| u8 S4bios_request;
| u8 pstate_control;
| u32 pm1a_event_block;
| u32 pm1b_event_block;
| u32 pm1a_control_block;
| u32 pm1b_control_block;
| u32 pm2_control_block;
| u32 pm_timer_block;
| u32 gpe0_block;
| u32 gpe1_block;
| u8 pm1_event_length;
| u8 pm1_control_length;
| u8 pm2_control_length;
| u8 pm_timer_length;
| u8 gpe0_block_length;
| u8 gpe1_block_length;
| u8 gpe1_base;
| u8 cst_control;
| u16 C2latency;
| u16 C3latency;
| u16 flush_size;
| u16 flush_stride;
| u8 duty_offset;
| u8 duty_width;
| u8 day_alarm;
| u8 month_alarm;
| u8 century;
| u16 boot_flags;
| u8 reserved;
| u32 flags;
| struct acpi_generic_address reset_register;
| u8 reset_value;
| u8 reserved4[3];
| u64 Xfacs;
| u64 Xdsdt;
| struct acpi_generic_address xpm1a_event_block;
| struct acpi_generic_address xpm1b_event_block;
| struct acpi_generic_address xpm1a_control_block;
| struct acpi_generic_address xpm1b_control_block;
| struct acpi_generic_address xpm2_control_block;
| struct acpi_generic_address xpm_timer_block;
| struct acpi_generic_address xgpe0_block;
| struct acpi_generic_address xgpe1_block;
|};
|enum acpi_prefered_pm_profiles {
| PM_UNSPECIFIED = 0,
| PM_DESKTOP = 1,
| PM_MOBILE = 2,
| PM_WORKSTATION = 3,
| PM_ENTERPRISE_SERVER = 4,
| PM_SOHO_SERVER = 5,
| PM_APPLIANCE_PC = 6
|};
|
|
|
|
|
|
|
|
|
|union acpi_name_union {
| u32 integer;
| char ascii[4];
|};
|
|
|
|struct acpi_table_desc {
| acpi_physical_address address;
| struct acpi_table_header *pointer;
| u32 length;
| union acpi_name_union signature;
| acpi_owner_id owner_id;
| u8 flags;
|};
|struct acpi_subtable_header {
| u8 type;
| u8 length;
|};
|
|
|
|struct acpi_whea_header {
| u8 action;
| u8 instruction;
| u8 flags;
| u8 reserved;
| struct acpi_generic_address register_region;
| u64 value;
| u64 mask;
|};
|struct acpi_table_bert {
| struct acpi_table_header header;
| u32 region_length;
| u64 address;
|};
|
|
|
|struct acpi_bert_region {
| u32 block_status;
| u32 raw_data_offset;
| u32 raw_data_length;
| u32 data_length;
| u32 error_severity;
|};
|enum acpi_bert_error_severity {
| ACPI_BERT_ERROR_CORRECTABLE = 0,
| ACPI_BERT_ERROR_FATAL = 1,
| ACPI_BERT_ERROR_CORRECTED = 2,
| ACPI_BERT_ERROR_NONE = 3,
| ACPI_BERT_ERROR_RESERVED = 4
|};
|struct acpi_table_cpep {
| struct acpi_table_header header;
| u64 reserved;
|};
|
|
|
|struct acpi_cpep_polling {
| struct acpi_subtable_header header;
| u8 id;
| u8 eid;
| u32 interval;
|};
|struct acpi_table_ecdt {
| struct acpi_table_header header;
| struct acpi_generic_address control;
| struct acpi_generic_address data;
| u32 uid;
| u8 gpe;
| u8 id[1];
|};
|struct acpi_table_einj {
| struct acpi_table_header header;
| u32 header_length;
| u8 flags;
| u8 reserved[3];
| u32 entries;
|};
|
|
|
|struct acpi_einj_entry {
| struct acpi_whea_header whea_header;
|};
|
|
|
|
|
|
|
|enum acpi_einj_actions {
| ACPI_EINJ_BEGIN_OPERATION = 0,
| ACPI_EINJ_GET_TRIGGER_TABLE = 1,
| ACPI_EINJ_SET_ERROR_TYPE = 2,
| ACPI_EINJ_GET_ERROR_TYPE = 3,
| ACPI_EINJ_END_OPERATION = 4,
| ACPI_EINJ_EXECUTE_OPERATION = 5,
| ACPI_EINJ_CHECK_BUSY_STATUS = 6,
| ACPI_EINJ_GET_COMMAND_STATUS = 7,
| ACPI_EINJ_ACTION_RESERVED = 8,
| ACPI_EINJ_TRIGGER_ERROR = 0xFF
|};
|
|
|
|enum acpi_einj_instructions {
| ACPI_EINJ_READ_REGISTER = 0,
| ACPI_EINJ_READ_REGISTER_VALUE = 1,
| ACPI_EINJ_WRITE_REGISTER = 2,
| ACPI_EINJ_WRITE_REGISTER_VALUE = 3,
| ACPI_EINJ_NOOP = 4,
| ACPI_EINJ_INSTRUCTION_RESERVED = 5
|};
|
|
|
|struct acpi_einj_trigger {
| u32 header_size;
| u32 revision;
| u32 table_size;
| u32 entry_count;
|};
|
|
|
|enum acpi_einj_command_status {
| ACPI_EINJ_SUCCESS = 0,
| ACPI_EINJ_FAILURE = 1,
| ACPI_EINJ_INVALID_ACCESS = 2,
| ACPI_EINJ_STATUS_RESERVED = 3
|};
|struct acpi_table_erst {
| struct acpi_table_header header;
| u32 header_length;
| u32 reserved;
| u32 entries;
|};
|
|
|
|struct acpi_erst_entry {
| struct acpi_whea_header whea_header;
|};
|
|
|
|
|
|
|
|enum acpi_erst_actions {
| ACPI_ERST_BEGIN_WRITE = 0,
| ACPI_ERST_BEGIN_READ = 1,
| ACPI_ERST_BEGIN_CLEAR = 2,
| ACPI_ERST_END = 3,
| ACPI_ERST_SET_RECORD_OFFSET = 4,
| ACPI_ERST_EXECUTE_OPERATION = 5,
| ACPI_ERST_CHECK_BUSY_STATUS = 6,
| ACPI_ERST_GET_COMMAND_STATUS = 7,
| ACPI_ERST_GET_RECORD_ID = 8,
| ACPI_ERST_SET_RECORD_ID = 9,
| ACPI_ERST_GET_RECORD_COUNT = 10,
| ACPI_ERST_BEGIN_DUMMY_WRIITE = 11,
| ACPI_ERST_NOT_USED = 12,
| ACPI_ERST_GET_ERROR_RANGE = 13,
| ACPI_ERST_GET_ERROR_LENGTH = 14,
| ACPI_ERST_GET_ERROR_ATTRIBUTES = 15,
| ACPI_ERST_ACTION_RESERVED = 16
|};
|
|
|
|enum acpi_erst_instructions {
| ACPI_ERST_READ_REGISTER = 0,
| ACPI_ERST_READ_REGISTER_VALUE = 1,
| ACPI_ERST_WRITE_REGISTER = 2,
| ACPI_ERST_WRITE_REGISTER_VALUE = 3,
| ACPI_ERST_NOOP = 4,
| ACPI_ERST_LOAD_VAR1 = 5,
| ACPI_ERST_LOAD_VAR2 = 6,
| ACPI_ERST_STORE_VAR1 = 7,
| ACPI_ERST_ADD = 8,
| ACPI_ERST_SUBTRACT = 9,
| ACPI_ERST_ADD_VALUE = 10,
| ACPI_ERST_SUBTRACT_VALUE = 11,
| ACPI_ERST_STALL = 12,
| ACPI_ERST_STALL_WHILE_TRUE = 13,
| ACPI_ERST_SKIP_NEXT_IF_TRUE = 14,
| ACPI_ERST_GOTO = 15,
| ACPI_ERST_SET_SRC_ADDRESS_BASE = 16,
| ACPI_ERST_SET_DST_ADDRESS_BASE = 17,
| ACPI_ERST_MOVE_DATA = 18,
| ACPI_ERST_INSTRUCTION_RESERVED = 19
|};
|
|
|
|enum acpi_erst_command_status {
| ACPI_ERST_SUCESS = 0,
| ACPI_ERST_NO_SPACE = 1,
| ACPI_ERST_NOT_AVAILABLE = 2,
| ACPI_ERST_FAILURE = 3,
| ACPI_ERST_RECORD_EMPTY = 4,
| ACPI_ERST_NOT_FOUND = 5,
| ACPI_ERST_STATUS_RESERVED = 6
|};
|
|
|
|struct acpi_erst_info {
| u16 signature;
| u8 data[48];
|};
|struct acpi_table_hest {
| struct acpi_table_header header;
| u32 error_source_count;
|};
|
|
|
|struct acpi_hest_header {
| u16 type;
| u16 source_id;
|};
|
|
|
|enum acpi_hest_types {
| ACPI_HEST_TYPE_IA32_CHECK = 0,
| ACPI_HEST_TYPE_IA32_CORRECTED_CHECK = 1,
| ACPI_HEST_TYPE_IA32_NMI = 2,
| ACPI_HEST_TYPE_NOT_USED3 = 3,
| ACPI_HEST_TYPE_NOT_USED4 = 4,
| ACPI_HEST_TYPE_NOT_USED5 = 5,
| ACPI_HEST_TYPE_AER_ROOT_PORT = 6,
| ACPI_HEST_TYPE_AER_ENDPOINT = 7,
| ACPI_HEST_TYPE_AER_BRIDGE = 8,
| ACPI_HEST_TYPE_GENERIC_ERROR = 9,
| ACPI_HEST_TYPE_RESERVED = 10
|};
|struct acpi_hest_ia_error_bank {
| u8 bank_number;
| u8 clear_status_on_init;
| u8 status_format;
| u8 reserved;
| u32 control_register;
| u64 control_data;
| u32 status_register;
| u32 address_register;
| u32 misc_register;
|};
|
|
|
|struct acpi_hest_aer_common {
| u16 reserved1;
| u8 flags;
| u8 enabled;
| u32 records_to_preallocate;
| u32 max_sections_per_record;
| u32 bus;
| u16 device;
| u16 function;
| u16 device_control;
| u16 reserved2;
| u32 uncorrectable_mask;
| u32 uncorrectable_severity;
| u32 correctable_mask;
| u32 advanced_capabilities;
|};
|struct acpi_hest_notify {
| u8 type;
| u8 length;
| u16 config_write_enable;
| u32 poll_interval;
| u32 vector;
| u32 polling_threshold_value;
| u32 polling_threshold_window;
| u32 error_threshold_value;
| u32 error_threshold_window;
|};
|
|
|
|enum acpi_hest_notify_types {
| ACPI_HEST_NOTIFY_POLLED = 0,
| ACPI_HEST_NOTIFY_EXTERNAL = 1,
| ACPI_HEST_NOTIFY_LOCAL = 2,
| ACPI_HEST_NOTIFY_SCI = 3,
| ACPI_HEST_NOTIFY_NMI = 4,
| ACPI_HEST_NOTIFY_RESERVED = 5
|};
|struct acpi_hest_ia_machine_check {
| struct acpi_hest_header header;
| u16 reserved1;
| u8 flags;
| u8 enabled;
| u32 records_to_preallocate;
| u32 max_sections_per_record;
| u64 global_capability_data;
| u64 global_control_data;
| u8 num_hardware_banks;
| u8 reserved3[7];
|};
|
|
|
|struct acpi_hest_ia_corrected {
| struct acpi_hest_header header;
| u16 reserved1;
| u8 flags;
| u8 enabled;
| u32 records_to_preallocate;
| u32 max_sections_per_record;
| struct acpi_hest_notify notify;
| u8 num_hardware_banks;
| u8 reserved2[3];
|};
|
|
|
|struct acpi_hest_ia_nmi {
| struct acpi_hest_header header;
| u32 reserved;
| u32 records_to_preallocate;
| u32 max_sections_per_record;
| u32 max_raw_data_length;
|};
|
|
|
|
|
|struct acpi_hest_aer_root {
| struct acpi_hest_header header;
| struct acpi_hest_aer_common aer;
| u32 root_error_command;
|};
|
|
|
|struct acpi_hest_aer {
| struct acpi_hest_header header;
| struct acpi_hest_aer_common aer;
|};
|
|
|
|struct acpi_hest_aer_bridge {
| struct acpi_hest_header header;
| struct acpi_hest_aer_common aer;
| u32 uncorrectable_mask2;
| u32 uncorrectable_severity2;
| u32 advanced_capabilities2;
|};
|
|
|
|struct acpi_hest_generic {
| struct acpi_hest_header header;
| u16 related_source_id;
| u8 reserved;
| u8 enabled;
| u32 records_to_preallocate;
| u32 max_sections_per_record;
| u32 max_raw_data_length;
| struct acpi_generic_address error_status_address;
| struct acpi_hest_notify notify;
| u32 error_block_length;
|};
|
|
|
|struct acpi_hest_generic_status {
| u32 block_status;
| u32 raw_data_offset;
| u32 raw_data_length;
| u32 data_length;
| u32 error_severity;
|};
|struct acpi_hest_generic_data {
| u8 section_type[16];
| u32 error_severity;
| u16 revision;
| u8 validation_bits;
| u8 flags;
| u32 error_data_length;
| u8 fru_id[16];
| u8 fru_text[20];
|};
|struct acpi_table_madt {
| struct acpi_table_header header;
| u32 address;
| u32 flags;
|};
|enum acpi_madt_type {
| ACPI_MADT_TYPE_LOCAL_APIC = 0,
| ACPI_MADT_TYPE_IO_APIC = 1,
| ACPI_MADT_TYPE_INTERRUPT_OVERRIDE = 2,
| ACPI_MADT_TYPE_NMI_SOURCE = 3,
| ACPI_MADT_TYPE_LOCAL_APIC_NMI = 4,
| ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE = 5,
| ACPI_MADT_TYPE_IO_SAPIC = 6,
| ACPI_MADT_TYPE_LOCAL_SAPIC = 7,
| ACPI_MADT_TYPE_INTERRUPT_SOURCE = 8,
| ACPI_MADT_TYPE_LOCAL_X2APIC = 9,
| ACPI_MADT_TYPE_LOCAL_X2APIC_NMI = 10,
| ACPI_MADT_TYPE_RESERVED = 11
|};
|
|
|
|
|
|
|
|struct acpi_madt_local_apic {
| struct acpi_subtable_header header;
| u8 processor_id;
| u8 id;
| u32 lapic_flags;
|};
|
|
|
|struct acpi_madt_io_apic {
| struct acpi_subtable_header header;
| u8 id;
| u8 reserved;
| u32 address;
| u32 global_irq_base;
|};
|
|
|
|struct acpi_madt_interrupt_override {
| struct acpi_subtable_header header;
| u8 bus;
| u8 source_irq;
| u32 global_irq;
| u16 inti_flags;
|};
|
|
|
|struct acpi_madt_nmi_source {
| struct acpi_subtable_header header;
| u16 inti_flags;
| u32 global_irq;
|};
|
|
|
|struct acpi_madt_local_apic_nmi {
| struct acpi_subtable_header header;
| u8 processor_id;
| u16 inti_flags;
| u8 lint;
|};
|
|
|
|struct acpi_madt_local_apic_override {
| struct acpi_subtable_header header;
| u16 reserved;
| u64 address;
|};
|
|
|
|struct acpi_madt_io_sapic {
| struct acpi_subtable_header header;
| u8 id;
| u8 reserved;
| u32 global_irq_base;
| u64 address;
|};
|
|
|
|struct acpi_madt_local_sapic {
| struct acpi_subtable_header header;
| u8 processor_id;
| u8 id;
| u8 eid;
| u8 reserved[3];
| u32 lapic_flags;
| u32 uid;
| char uid_string[1];
|};
|
|
|
|struct acpi_madt_interrupt_source {
| struct acpi_subtable_header header;
| u16 inti_flags;
| u8 type;
| u8 id;
| u8 eid;
| u8 io_sapic_vector;
| u32 global_irq;
| u32 flags;
|};
|
|
|
|
|
|
|
|struct acpi_madt_local_x2apic {
| struct acpi_subtable_header header;
| u16 reserved;
| u32 local_apic_id;
| u32 lapic_flags;
| u32 uid;
|};
|
|
|
|struct acpi_madt_local_x2apic_nmi {
| struct acpi_subtable_header header;
| u16 inti_flags;
| u32 uid;
| u8 lint;
| u8 reserved[3];
|};
|struct acpi_table_msct {
| struct acpi_table_header header;
| u32 proximity_offset;
| u32 max_proximity_domains;
| u32 max_clock_domains;
| u64 max_address;
|};
|
|
|
|struct acpi_msct_proximity {
| u8 revision;
| u8 length;
| u32 range_start;
| u32 range_end;
| u32 processor_capacity;
| u64 memory_capacity;
|};
|struct acpi_table_sbst {
| struct acpi_table_header header;
| u32 warning_level;
| u32 low_level;
| u32 critical_level;
|};
|struct acpi_table_slit {
| struct acpi_table_header header;
| u64 locality_count;
| u8 entry[1];
|};
|struct acpi_table_srat {
| struct acpi_table_header header;
| u32 table_revision;
| u64 reserved;
|};
|
|
|
|enum acpi_srat_type {
| ACPI_SRAT_TYPE_CPU_AFFINITY = 0,
| ACPI_SRAT_TYPE_MEMORY_AFFINITY = 1,
| ACPI_SRAT_TYPE_X2APIC_CPU_AFFINITY = 2,
| ACPI_SRAT_TYPE_RESERVED = 3
|};
|
|
|
|
|
|
|
|struct acpi_srat_cpu_affinity {
| struct acpi_subtable_header header;
| u8 proximity_domain_lo;
| u8 apic_id;
| u32 flags;
| u8 local_sapic_eid;
| u8 proximity_domain_hi[3];
| u32 reserved;
|};
|
|
|
|
|
|
|
|struct acpi_srat_mem_affinity {
| struct acpi_subtable_header header;
| u32 proximity_domain;
| u16 reserved;
| u64 base_address;
| u64 length;
|       u32 reserved1;
| u32 flags;
|       u64 reserved2;
|};
|struct acpi_srat_x2apic_cpu_affinity {
| struct acpi_subtable_header header;
| u16 reserved;
| u32 proximity_domain;
| u32 apic_id;
| u32 flags;
| u32 clock_domain;
| u32 reserved2;
|};
|
|
|
|
|
|
|
|struct acpi_table_asf {
| struct acpi_table_header header;
|};
|
|
|
|struct acpi_asf_header {
| u8 type;
| u8 reserved;
| u16 length;
|};
|
|
|
|enum acpi_asf_type {
| ACPI_ASF_TYPE_INFO = 0,
| ACPI_ASF_TYPE_ALERT = 1,
| ACPI_ASF_TYPE_CONTROL = 2,
| ACPI_ASF_TYPE_BOOT = 3,
| ACPI_ASF_TYPE_ADDRESS = 4,
| ACPI_ASF_TYPE_RESERVED = 5
|};
|
|
|
|
|
|
|
|struct acpi_asf_info {
| struct acpi_asf_header header;
| u8 min_reset_value;
| u8 min_poll_interval;
| u16 system_id;
| u32 mfg_id;
| u8 flags;
| u8 reserved2[3];
|};
|
|
|
|
|
|
|
|struct acpi_asf_alert {
| struct acpi_asf_header header;
| u8 assert_mask;
| u8 deassert_mask;
| u8 alerts;
| u8 data_length;
|};
|
|struct acpi_asf_alert_data {
| u8 address;
| u8 command;
| u8 mask;
| u8 value;
| u8 sensor_type;
| u8 type;
| u8 offset;
| u8 source_type;
| u8 severity;
| u8 sensor_number;
| u8 entity;
| u8 instance;
|};
|
|
|
|struct acpi_asf_remote {
| struct acpi_asf_header header;
| u8 controls;
| u8 data_length;
| u16 reserved2;
|};
|
|struct acpi_asf_control_data {
| u8 function;
| u8 address;
| u8 command;
| u8 value;
|};
|
|
|
|struct acpi_asf_rmcp {
| struct acpi_asf_header header;
| u8 capabilities[7];
| u8 completion_code;
| u32 enterprise_id;
| u8 command;
| u16 parameter;
| u16 boot_options;
| u16 oem_parameters;
|};
|
|
|
|struct acpi_asf_address {
| struct acpi_asf_header header;
| u8 eprom_address;
| u8 devices;
|};
|struct acpi_table_boot {
| struct acpi_table_header header;
| u8 cmos_index;
| u8 reserved[3];
|};
|struct acpi_table_dbgp {
| struct acpi_table_header header;
| u8 type;
| u8 reserved[3];
| struct acpi_generic_address debug_port;
|};
|struct acpi_table_dmar {
| struct acpi_table_header header;
| u8 width;
| u8 flags;
| u8 reserved[10];
|};
|
|
|
|
|
|
|
|struct acpi_dmar_header {
| u16 type;
| u16 length;
|};
|
|
|
|enum acpi_dmar_type {
| ACPI_DMAR_TYPE_HARDWARE_UNIT = 0,
| ACPI_DMAR_TYPE_RESERVED_MEMORY = 1,
| ACPI_DMAR_TYPE_ATSR = 2,
| ACPI_DMAR_HARDWARE_AFFINITY = 3,
| ACPI_DMAR_TYPE_RESERVED = 4
|};
|
|
|
|struct acpi_dmar_device_scope {
| u8 entry_type;
| u8 length;
| u16 reserved;
| u8 enumeration_id;
| u8 bus;
|};
|
|
|
|enum acpi_dmar_scope_type {
| ACPI_DMAR_SCOPE_TYPE_NOT_USED = 0,
| ACPI_DMAR_SCOPE_TYPE_ENDPOINT = 1,
| ACPI_DMAR_SCOPE_TYPE_BRIDGE = 2,
| ACPI_DMAR_SCOPE_TYPE_IOAPIC = 3,
| ACPI_DMAR_SCOPE_TYPE_HPET = 4,
| ACPI_DMAR_SCOPE_TYPE_RESERVED = 5
|};
|
|struct acpi_dmar_pci_path {
| u8 dev;
| u8 fn;
|};
|
|
|
|
|
|
|
|struct acpi_dmar_hardware_unit {
| struct acpi_dmar_header header;
| u8 flags;
| u8 reserved;
| u16 segment;
| u64 address;
|};
|
|
|
|
|
|
|
|struct acpi_dmar_reserved_memory {
| struct acpi_dmar_header header;
| u16 reserved;
| u16 segment;
| u64 base_address;
| u64 end_address;
|};
|
|
|
|
|
|
|
|struct acpi_dmar_atsr {
| struct acpi_dmar_header header;
| u8 flags;
| u8 reserved;
| u16 segment;
|};
|
|
|
|
|
|
|
|struct acpi_dmar_rhsa {
| struct acpi_dmar_header header;
| u32 reserved;
| u64 base_address;
| u32 proximity_domain;
|};
|struct acpi_table_hpet {
| struct acpi_table_header header;
| u32 id;
| struct acpi_generic_address address;
| u8 sequence;
| u16 minimum_tick;
| u8 flags;
|};
|
|
|
|
|
|
|
|enum acpi_hpet_page_protect {
| ACPI_HPET_NO_PAGE_PROTECT = 0,
| ACPI_HPET_PAGE_PROTECT4 = 1,
| ACPI_HPET_PAGE_PROTECT64 = 2
|};
|struct acpi_table_ibft {
| struct acpi_table_header header;
| u8 reserved[12];
|};
|
|
|
|struct acpi_ibft_header {
| u8 type;
| u8 version;
| u16 length;
| u8 index;
| u8 flags;
|};
|
|
|
|enum acpi_ibft_type {
| ACPI_IBFT_TYPE_NOT_USED = 0,
| ACPI_IBFT_TYPE_CONTROL = 1,
| ACPI_IBFT_TYPE_INITIATOR = 2,
| ACPI_IBFT_TYPE_NIC = 3,
| ACPI_IBFT_TYPE_TARGET = 4,
| ACPI_IBFT_TYPE_EXTENSIONS = 5,
| ACPI_IBFT_TYPE_RESERVED = 6
|};
|
|
|
|struct acpi_ibft_control {
| struct acpi_ibft_header header;
| u16 extensions;
| u16 initiator_offset;
| u16 nic0_offset;
| u16 target0_offset;
| u16 nic1_offset;
| u16 target1_offset;
|};
|
|struct acpi_ibft_initiator {
| struct acpi_ibft_header header;
| u8 sns_server[16];
| u8 slp_server[16];
| u8 primary_server[16];
| u8 secondary_server[16];
| u16 name_length;
| u16 name_offset;
|};
|
|struct acpi_ibft_nic {
| struct acpi_ibft_header header;
| u8 ip_address[16];
| u8 subnet_mask_prefix;
| u8 origin;
| u8 gateway[16];
| u8 primary_dns[16];
| u8 secondary_dns[16];
| u8 dhcp[16];
| u16 vlan;
| u8 mac_address[6];
| u16 pci_address;
| u16 name_length;
| u16 name_offset;
|};
|
|struct acpi_ibft_target {
| struct acpi_ibft_header header;
| u8 target_ip_address[16];
| u16 target_ip_socket;
| u8 target_boot_lun[8];
| u8 chap_type;
| u8 nic_association;
| u16 target_name_length;
| u16 target_name_offset;
| u16 chap_name_length;
| u16 chap_name_offset;
| u16 chap_secret_length;
| u16 chap_secret_offset;
| u16 reverse_chap_name_length;
| u16 reverse_chap_name_offset;
| u16 reverse_chap_secret_length;
| u16 reverse_chap_secret_offset;
|};
|struct acpi_table_ivrs {
| struct acpi_table_header header;
| u32 info;
| u64 reserved;
|};
|struct acpi_ivrs_header {
| u8 type;
| u8 flags;
| u16 length;
| u16 device_id;
|};
|
|
|
|enum acpi_ivrs_type {
| ACPI_IVRS_TYPE_HARDWARE = 0x10,
| ACPI_IVRS_TYPE_MEMORY1 = 0x20,
| ACPI_IVRS_TYPE_MEMORY2 = 0x21,
| ACPI_IVRS_TYPE_MEMORY3 = 0x22
|};
|struct acpi_ivrs_hardware {
| struct acpi_ivrs_header header;
| u16 capability_offset;
| u64 base_address;
| u16 pci_segment_group;
| u16 info;
| u32 reserved;
|};
|struct acpi_ivrs_de_header {
| u8 type;
| u16 id;
| u8 data_setting;
|};
|
|
|
|
|
|
|
|enum acpi_ivrs_device_entry_type {
|
|
| ACPI_IVRS_TYPE_PAD4 = 0,
| ACPI_IVRS_TYPE_ALL = 1,
| ACPI_IVRS_TYPE_SELECT = 2,
| ACPI_IVRS_TYPE_START = 3,
| ACPI_IVRS_TYPE_END = 4,
|
|
|
| ACPI_IVRS_TYPE_PAD8 = 64,
| ACPI_IVRS_TYPE_NOT_USED = 65,
| ACPI_IVRS_TYPE_ALIAS_SELECT = 66,
| ACPI_IVRS_TYPE_ALIAS_START = 67,
| ACPI_IVRS_TYPE_EXT_SELECT = 70,
| ACPI_IVRS_TYPE_EXT_START = 71,
| ACPI_IVRS_TYPE_SPECIAL = 72
|};
|struct acpi_ivrs_device4 {
| struct acpi_ivrs_de_header header;
|};
|
|
|
|struct acpi_ivrs_device8a {
| struct acpi_ivrs_de_header header;
| u8 reserved1;
| u16 used_id;
| u8 reserved2;
|};
|
|
|
|struct acpi_ivrs_device8b {
| struct acpi_ivrs_de_header header;
| u32 extended_data;
|};
|
|
|
|
|
|
|
|struct acpi_ivrs_device8c {
| struct acpi_ivrs_de_header header;
| u8 handle;
| u16 used_id;
| u8 variety;
|};
|struct acpi_ivrs_memory {
| struct acpi_ivrs_header header;
| u16 aux_data;
| u64 reserved;
| u64 start_address;
| u64 memory_length;
|};
|struct acpi_table_mcfg {
| struct acpi_table_header header;
| u8 reserved[8];
|};
|
|
|
|struct acpi_mcfg_allocation {
| u64 address;
| u16 pci_segment;
| u8 start_bus_number;
| u8 end_bus_number;
| u32 reserved;
|};
|struct acpi_table_mchi {
| struct acpi_table_header header;
| u8 interface_type;
| u8 protocol;
| u64 protocol_data;
| u8 interrupt_type;
| u8 gpe;
| u8 pci_device_flag;
| u32 global_interrupt;
| struct acpi_generic_address control_register;
| u8 pci_segment;
| u8 pci_bus;
| u8 pci_device;
| u8 pci_function;
|};
|struct acpi_table_spcr {
| struct acpi_table_header header;
| u8 interface_type;
| u8 reserved[3];
| struct acpi_generic_address serial_port;
| u8 interrupt_type;
| u8 pc_interrupt;
| u32 interrupt;
| u8 baud_rate;
| u8 parity;
| u8 stop_bits;
| u8 flow_control;
| u8 terminal_type;
| u8 reserved1;
| u16 pci_device_id;
| u16 pci_vendor_id;
| u8 pci_bus;
| u8 pci_device;
| u8 pci_function;
| u32 pci_flags;
| u8 pci_segment;
| u32 reserved2;
|};
|struct acpi_table_spmi {
| struct acpi_table_header header;
| u8 interface_type;
| u8 reserved;
| u16 spec_revision;
| u8 interrupt_type;
| u8 gpe_number;
| u8 reserved1;
| u8 pci_device_flag;
| u32 interrupt;
| struct acpi_generic_address ipmi_register;
| u8 pci_segment;
| u8 pci_bus;
| u8 pci_device;
| u8 pci_function;
| u8 reserved2;
|};
|
|
|
|enum acpi_spmi_interface_types {
| ACPI_SPMI_NOT_USED = 0,
| ACPI_SPMI_KEYBOARD = 1,
| ACPI_SPMI_SMI = 2,
| ACPI_SPMI_BLOCK_TRANSFER = 3,
| ACPI_SPMI_SMBUS = 4,
| ACPI_SPMI_RESERVED = 5
|};
|struct acpi_table_tcpa {
| struct acpi_table_header header;
| u16 reserved;
| u32 max_log_length;
| u64 log_address;
|};
|struct acpi_table_uefi {
| struct acpi_table_header header;
| u8 identifier[16];
| u16 data_offset;
|};
|struct acpi_table_waet {
| struct acpi_table_header header;
| u32 flags;
|};
|struct acpi_table_wdat {
| struct acpi_table_header header;
| u32 header_length;
| u16 pci_segment;
| u8 pci_bus;
| u8 pci_device;
| u8 pci_function;
| u8 reserved[3];
| u32 timer_period;
| u32 max_count;
| u32 min_count;
| u8 flags;
| u8 reserved2[3];
| u32 entries;
|};
|struct acpi_wdat_entry {
| u8 action;
| u8 instruction;
| u16 reserved;
| struct acpi_generic_address register_region;
| u32 value;
| u32 mask;
|};
|
|
|
|enum acpi_wdat_actions {
| ACPI_WDAT_RESET = 1,
| ACPI_WDAT_GET_CURRENT_COUNTDOWN = 4,
| ACPI_WDAT_GET_COUNTDOWN = 5,
| ACPI_WDAT_SET_COUNTDOWN = 6,
| ACPI_WDAT_GET_RUNNING_STATE = 8,
| ACPI_WDAT_SET_RUNNING_STATE = 9,
| ACPI_WDAT_GET_STOPPED_STATE = 10,
| ACPI_WDAT_SET_STOPPED_STATE = 11,
| ACPI_WDAT_GET_REBOOT = 16,
| ACPI_WDAT_SET_REBOOT = 17,
| ACPI_WDAT_GET_SHUTDOWN = 18,
| ACPI_WDAT_SET_SHUTDOWN = 19,
| ACPI_WDAT_GET_STATUS = 32,
| ACPI_WDAT_SET_STATUS = 33,
| ACPI_WDAT_ACTION_RESERVED = 34
|};
|
|
|
|enum acpi_wdat_instructions {
| ACPI_WDAT_READ_VALUE = 0,
| ACPI_WDAT_READ_COUNTDOWN = 1,
| ACPI_WDAT_WRITE_VALUE = 2,
| ACPI_WDAT_WRITE_COUNTDOWN = 3,
| ACPI_WDAT_INSTRUCTION_RESERVED = 4,
| ACPI_WDAT_PRESERVE_REGISTER = 0x80
|};
|struct acpi_table_wddt {
| struct acpi_table_header header;
| u16 spec_version;
| u16 table_version;
| u16 pci_vendor_id;
| struct acpi_generic_address address;
| u16 max_count;
| u16 min_count;
| u16 period;
| u16 status;
| u16 capability;
|};
|struct acpi_table_wdrt {
| struct acpi_table_header header;
| struct acpi_generic_address control_register;
| struct acpi_generic_address count_register;
| u16 pci_device_id;
| u16 pci_vendor_id;
| u8 pci_bus;
| u8 pci_device;
| u8 pci_function;
| u8 pci_segment;
| u16 max_count;
| u8 units;
|};
|
|
|
|typedef u16 acpi_rs_length;
|typedef u32 acpi_rsdesc_size;
|
|
|
|
|struct acpi_uuid {
| u8 data[16];
|};
|
|struct acpi_vendor_uuid {
| u8 subtype;
| u8 data[16];
|};
|
|
|
|
|struct acpi_resource_irq {
| u8 descriptor_length;
| u8 triggering;
| u8 polarity;
| u8 sharable;
| u8 interrupt_count;
| u8 interrupts[1];
|};
|
|struct acpi_resource_dma {
| u8 type;
| u8 bus_master;
| u8 transfer;
| u8 channel_count;
| u8 channels[1];
|};
|
|struct acpi_resource_start_dependent {
| u8 descriptor_length;
| u8 compatibility_priority;
| u8 performance_robustness;
|};
|
|
|
|
|
|
|struct acpi_resource_io {
| u8 io_decode;
| u8 alignment;
| u8 address_length;
| u16 minimum;
| u16 maximum;
|};
|
|struct acpi_resource_fixed_io {
| u16 address;
| u8 address_length;
|};
|
|struct acpi_resource_vendor {
| u16 byte_length;
| u8 byte_data[1];
|};
|
|
|
|struct acpi_resource_vendor_typed {
| u16 byte_length;
| u8 uuid_subtype;
| u8 uuid[16];
| u8 byte_data[1];
|};
|
|struct acpi_resource_end_tag {
| u8 checksum;
|};
|
|struct acpi_resource_memory24 {
| u8 write_protect;
| u16 minimum;
| u16 maximum;
| u16 alignment;
| u16 address_length;
|};
|
|struct acpi_resource_memory32 {
| u8 write_protect;
| u32 minimum;
| u32 maximum;
| u32 alignment;
| u32 address_length;
|};
|
|struct acpi_resource_fixed_memory32 {
| u8 write_protect;
| u32 address;
| u32 address_length;
|};
|
|struct acpi_memory_attribute {
| u8 write_protect;
| u8 caching;
| u8 range_type;
| u8 translation;
|};
|
|struct acpi_io_attribute {
| u8 range_type;
| u8 translation;
| u8 translation_type;
| u8 reserved1;
|};
|
|union acpi_resource_attribute {
| struct acpi_memory_attribute mem;
| struct acpi_io_attribute io;
|
|
|
| u8 type_specific;
|};
|
|struct acpi_resource_source {
| u8 index;
| u16 string_length;
| char *string_ptr;
|};
|struct acpi_resource_address {
|u8 resource_type; u8 producer_consumer; u8 decode; u8 min_address_fixed; u8 max_address_fixed; union acpi_resource_attribute info;};
|
|struct acpi_resource_address16 {
| u8 resource_type; u8 producer_consumer; u8 decode; u8 min_address_fixed; u8 max_address_fixed; union acpi_resource_attribute info; u16 granularity;
| u16 minimum;
| u16 maximum;
| u16 translation_offset;
| u16 address_length;
| struct acpi_resource_source resource_source;
|};
|
|struct acpi_resource_address32 {
| u8 resource_type; u8 producer_consumer; u8 decode; u8 min_address_fixed; u8 max_address_fixed; union acpi_resource_attribute info; u32 granularity;
| u32 minimum;
| u32 maximum;
| u32 translation_offset;
| u32 address_length;
| struct acpi_resource_source resource_source;
|};
|
|struct acpi_resource_address64 {
| u8 resource_type; u8 producer_consumer; u8 decode; u8 min_address_fixed; u8 max_address_fixed; union acpi_resource_attribute info; u64 granularity;
| u64 minimum;
| u64 maximum;
| u64 translation_offset;
| u64 address_length;
| struct acpi_resource_source resource_source;
|};
|
|struct acpi_resource_extended_address64 {
| u8 resource_type; u8 producer_consumer; u8 decode; u8 min_address_fixed; u8 max_address_fixed; union acpi_resource_attribute info; u8 revision_iD;
| u64 granularity;
| u64 minimum;
| u64 maximum;
| u64 translation_offset;
| u64 address_length;
| u64 type_specific;
|};
|
|struct acpi_resource_extended_irq {
| u8 producer_consumer;
| u8 triggering;
| u8 polarity;
| u8 sharable;
| u8 interrupt_count;
| struct acpi_resource_source resource_source;
| u32 interrupts[1];
|};
|
|struct acpi_resource_generic_register {
| u8 space_id;
| u8 bit_width;
| u8 bit_offset;
| u8 access_size;
| u64 address;
|};
|union acpi_resource_data {
| struct acpi_resource_irq irq;
| struct acpi_resource_dma dma;
| struct acpi_resource_start_dependent start_dpf;
| struct acpi_resource_io io;
| struct acpi_resource_fixed_io fixed_io;
| struct acpi_resource_vendor vendor;
| struct acpi_resource_vendor_typed vendor_typed;
| struct acpi_resource_end_tag end_tag;
| struct acpi_resource_memory24 memory24;
| struct acpi_resource_memory32 memory32;
| struct acpi_resource_fixed_memory32 fixed_memory32;
| struct acpi_resource_address16 address16;
| struct acpi_resource_address32 address32;
| struct acpi_resource_address64 address64;
| struct acpi_resource_extended_address64 ext_address64;
| struct acpi_resource_extended_irq extended_irq;
| struct acpi_resource_generic_register generic_reg;
|
|
|
| struct acpi_resource_address address;
|};
|
|
|
|struct acpi_resource {
| u32 type;
| u32 length;
| union acpi_resource_data data;
|};
|
|
|
|
|
|
|
|
|
|
|struct acpi_pci_routing_table {
| u32 length;
| u32 pin;
| u64 address;
| u32 source_index;
| char source[4];
|};
|typedef enum {
| OSL_GLOBAL_LOCK_HANDLER,
| OSL_NOTIFY_HANDLER,
| OSL_GPE_HANDLER,
| OSL_DEBUGGER_THREAD,
| OSL_EC_POLL_HANDLER,
| OSL_EC_BURST_HANDLER
|} acpi_execute_type;
|struct acpi_signal_fatal_info {
| u32 type;
| u32 code;
| u32 argument;
|};
|
|
|
|
|acpi_status acpi_os_initialize(void);
|
|acpi_status acpi_os_terminate(void);
|
|
|
|
|acpi_physical_address acpi_os_get_root_pointer(void);
|
|acpi_status
|acpi_os_predefined_override(const struct acpi_predefined_names *init_val,
|       acpi_string * new_val);
|
|acpi_status
|acpi_os_table_override(struct acpi_table_header *existing_table,
|         struct acpi_table_header **new_table);
|
|
|
|
|void acpi_os_delete_lock(spinlock_t * handle);
|
|unsigned long acpi_os_acquire_lock(spinlock_t * handle);
|
|void acpi_os_release_lock(spinlock_t * handle, unsigned long flags);
|
|
|
|
|acpi_status
|acpi_os_create_semaphore(u32 max_units,
|    u32 initial_units, void * * out_handle);
|
|acpi_status acpi_os_delete_semaphore(void * handle);
|
|acpi_status
|acpi_os_wait_semaphore(void * handle, u32 units, u16 timeout);
|
|acpi_status acpi_os_signal_semaphore(void * handle, u32 units);
|void *acpi_os_allocate(acpi_size size);
|
|void *acpi_os_map_memory(acpi_physical_address where,
|    acpi_size length);
|
|void acpi_os_unmap_memory(void * logical_address, acpi_size size);
|void early_acpi_os_unmap_memory(void * virt, acpi_size size);
|acpi_status
|acpi_os_create_cache(char *cache_name,
|       u16 object_size,
|       u16 max_depth, struct kmem_cache ** return_cache);
|
|acpi_status acpi_os_delete_cache(struct kmem_cache * cache);
|
|acpi_status acpi_os_purge_cache(struct kmem_cache * cache);
|
|void *acpi_os_acquire_object(struct kmem_cache * cache);
|
|acpi_status acpi_os_release_object(struct kmem_cache * cache, void *object);
|
|
|
|
|acpi_status
|acpi_os_install_interrupt_handler(u32 gsi,
|      acpi_osd_handler service_routine,
|      void *context);
|
|acpi_status
|acpi_os_remove_interrupt_handler(u32 gsi, acpi_osd_handler service_routine);
|
|void acpi_os_gpe_count(u32 gpe_number);
|void acpi_os_fixed_event_count(u32 fixed_event_number);
|
|
|
|
|u64 acpi_os_get_thread_id(void);
|
|acpi_status
|acpi_os_execute(acpi_execute_type type,
|  acpi_osd_exec_callback function, void *context);
|
|acpi_status
|acpi_os_hotplug_execute(acpi_osd_exec_callback function, void *context);
|
|void acpi_os_wait_events_complete(void *context);
|
|void acpi_os_sleep(u64 milliseconds);
|
|void acpi_os_stall(u32 microseconds);
|
|
|
|
|acpi_status acpi_os_read_port(acpi_io_address address, u32 * value, u32 width);
|
|acpi_status acpi_os_write_port(acpi_io_address address, u32 value, u32 width);
|
|
|
|
|acpi_status
|acpi_os_read_memory(acpi_physical_address address, u32 * value, u32 width);
|
|acpi_status
|acpi_os_write_memory(acpi_physical_address address, u32 value, u32 width);
|
|
|
|
|
|
|acpi_status
|acpi_os_read_pci_configuration(struct acpi_pci_id *pci_id,
|          u32 reg, u64 *value, u32 width);
|
|acpi_status
|acpi_os_write_pci_configuration(struct acpi_pci_id *pci_id,
|    u32 reg, u64 value, u32 width);
|
|
|
|
|acpi_status
|acpi_os_validate_address(u8 space_id, acpi_physical_address address,
|    acpi_size length, char *name);
|acpi_status
|acpi_os_invalidate_address(u8 space_id, acpi_physical_address address,
|    acpi_size length);
|
|u64 acpi_os_get_timer(void);
|
|acpi_status acpi_os_signal(u32 function, void *info);
|
|
|
|
|void acpi_os_printf(const char *format, ...);
|
|void acpi_os_vprintf(const char *format, int args);
|
|void acpi_os_redirect_output(void *destination);
|void *acpi_os_open_directory(char *pathname,
|        char *wildcard_spec, char requested_file_type);
|
|
|
|
|
|
|char *acpi_os_get_next_filename(void *dir_handle);
|
|void acpi_os_close_directory(void *dir_handle);
|extern u8 acpi_gbl_permanent_mmap;
|
|
|
|
|
|extern u32 acpi_dbg_level;
|extern u32 acpi_dbg_layer;
|extern u8 acpi_gbl_enable_interpreter_slack;
|extern u8 acpi_gbl_all_methods_serialized;
|extern u8 acpi_gbl_create_osi_method;
|extern u8 acpi_gbl_use_default_register_widths;
|extern acpi_name acpi_gbl_trace_method_name;
|extern u32 acpi_gbl_trace_flags;
|extern u32 acpi_gbl_enable_aml_debug_object;
|extern u8 acpi_gbl_copy_dsdt_locally;
|extern u8 acpi_gbl_truncate_io_addresses;
|
|extern u32 acpi_current_gpe_count;
|extern struct acpi_table_fadt acpi_gbl_FADT;
|extern u8 acpi_gbl_system_awake_and_running;
|
|extern u32 acpi_rsdt_forced;
|
|
|
|acpi_status
|acpi_initialize_tables(struct acpi_table_desc *initial_storage,
|         u32 initial_table_count, u8 allow_resize);
|
|acpi_status acpi_initialize_subsystem(void);
|
|acpi_status acpi_enable_subsystem(u32 flags);
|
|acpi_status acpi_initialize_objects(u32 flags);
|
|acpi_status acpi_terminate(void);
|
|
|
|
|
|acpi_status acpi_enable(void);
|
|acpi_status acpi_disable(void);
|
|
|
|
|
|const char *acpi_format_exception(acpi_status exception);
|
|acpi_status acpi_purge_cached_objects(void);
|
|acpi_status acpi_install_interface(acpi_string interface_name);
|
|acpi_status acpi_remove_interface(acpi_string interface_name);
|
|
|
|
|void *acpi_allocate(u32 size);
|
|void *acpi_callocate(u32 size);
|
|void acpi_free(void *address);
|
|
|
|
|acpi_status acpi_reallocate_root_table(void);
|
|acpi_status acpi_find_root_pointer(acpi_size *rsdp_address);
|
|acpi_status acpi_load_tables(void);
|
|acpi_status acpi_load_table(struct acpi_table_header *table_ptr);
|
|acpi_status acpi_unload_table_id(acpi_owner_id id);
|
|acpi_status
|acpi_get_table_header(acpi_string signature,
|        u32 instance,
|        struct acpi_table_header *out_table_header);
|
|acpi_status
|acpi_get_table_with_size(acpi_string signature,
|        u32 instance, struct acpi_table_header **out_table,
|        acpi_size *tbl_size);
|acpi_status
|acpi_get_table(acpi_string signature,
|        u32 instance, struct acpi_table_header **out_table);
|
|acpi_status
|acpi_get_table_by_index(u32 table_index,
|   struct acpi_table_header **out_table);
|
|acpi_status
|acpi_install_table_handler(acpi_tbl_handler handler, void *context);
|
|acpi_status acpi_remove_table_handler(acpi_tbl_handler handler);
|
|
|
|
|acpi_status
|acpi_walk_namespace(acpi_object_type type,
|      acpi_handle start_object,
|      u32 max_depth,
|      acpi_walk_callback pre_order_visit,
|      acpi_walk_callback post_order_visit,
|      void *context, void **return_value);
|
|acpi_status
|acpi_get_devices(const char *HID,
|   acpi_walk_callback user_function,
|   void *context, void **return_value);
|
|acpi_status
|acpi_get_name(acpi_handle object,
|       u32 name_type, struct acpi_buffer *ret_path_ptr);
|
|acpi_status
|acpi_get_handle(acpi_handle parent,
|  acpi_string pathname, acpi_handle * ret_handle);
|
|acpi_status
|acpi_attach_data(acpi_handle object, acpi_object_handler handler, void *data);
|
|acpi_status acpi_detach_data(acpi_handle object, acpi_object_handler handler);
|
|acpi_status
|acpi_get_data(acpi_handle object, acpi_object_handler handler, void **data);
|
|acpi_status
|acpi_debug_trace(char *name, u32 debug_level, u32 debug_layer, u32 flags);
|
|
|
|
|acpi_status
|acpi_evaluate_object(acpi_handle object,
|       acpi_string pathname,
|       struct acpi_object_list *parameter_objects,
|       struct acpi_buffer *return_object_buffer);
|
|acpi_status
|acpi_evaluate_object_typed(acpi_handle object,
|      acpi_string pathname,
|      struct acpi_object_list *external_params,
|      struct acpi_buffer *return_buffer,
|      acpi_object_type return_type);
|
|acpi_status
|acpi_get_object_info(acpi_handle object,
|       struct acpi_device_info **return_buffer);
|
|acpi_status acpi_install_method(u8 *buffer);
|
|acpi_status
|acpi_get_next_object(acpi_object_type type,
|       acpi_handle parent,
|       acpi_handle child, acpi_handle * out_handle);
|
|acpi_status acpi_get_type(acpi_handle object, acpi_object_type * out_type);
|
|acpi_status acpi_get_id(acpi_handle object, acpi_owner_id * out_type);
|
|acpi_status acpi_get_parent(acpi_handle object, acpi_handle * out_handle);
|
|
|
|
|acpi_status
|acpi_install_initialization_handler(acpi_init_handler handler, u32 function);
|
|acpi_status
|acpi_install_fixed_event_handler(u32 acpi_event,
|     acpi_event_handler handler, void *context);
|
|acpi_status
|acpi_remove_fixed_event_handler(u32 acpi_event, acpi_event_handler handler);
|
|acpi_status
|acpi_install_notify_handler(acpi_handle device,
|       u32 handler_type,
|       acpi_notify_handler handler, void *context);
|
|acpi_status
|acpi_remove_notify_handler(acpi_handle device,
|      u32 handler_type, acpi_notify_handler handler);
|
|acpi_status
|acpi_install_address_space_handler(acpi_handle device,
|       acpi_adr_space_type space_id,
|       acpi_adr_space_handler handler,
|       acpi_adr_space_setup setup, void *context);
|
|acpi_status
|acpi_remove_address_space_handler(acpi_handle device,
|      acpi_adr_space_type space_id,
|      acpi_adr_space_handler handler);
|
|acpi_status
|acpi_install_gpe_handler(acpi_handle gpe_device,
|    u32 gpe_number,
|    u32 type, acpi_event_handler address, void *context);
|
|acpi_status
|acpi_remove_gpe_handler(acpi_handle gpe_device,
|   u32 gpe_number, acpi_event_handler address);
|
|
|
|
|
|acpi_status acpi_install_interface_handler(acpi_interface_handler handler);
|
|
|
|
|acpi_status acpi_acquire_global_lock(u16 timeout, u32 * handle);
|
|acpi_status acpi_release_global_lock(u32 handle);
|
|acpi_status acpi_enable_event(u32 event, u32 flags);
|
|acpi_status acpi_disable_event(u32 event, u32 flags);
|
|acpi_status acpi_clear_event(u32 event);
|
|acpi_status acpi_get_event_status(u32 event, acpi_event_status * event_status);
|
|
|
|
|acpi_status acpi_enable_gpe(acpi_handle gpe_device, u32 gpe_number);
|
|acpi_status acpi_disable_gpe(acpi_handle gpe_device, u32 gpe_number);
|
|acpi_status acpi_gpe_can_wake(acpi_handle gpe_device, u32 gpe_number);
|
|acpi_status acpi_clear_gpe(acpi_handle gpe_device, u32 gpe_number);
|
|acpi_status acpi_gpe_wakeup(acpi_handle gpe_device, u32 gpe_number, u8 action);
|
|acpi_status
|acpi_get_gpe_status(acpi_handle gpe_device,
|      u32 gpe_number, acpi_event_status *event_status);
|
|acpi_status acpi_disable_all_gpes(void);
|
|acpi_status acpi_enable_all_runtime_gpes(void);
|
|acpi_status acpi_get_gpe_device(u32 gpe_index, acpi_handle *gpe_device);
|
|acpi_status
|acpi_install_gpe_block(acpi_handle gpe_device,
|         struct acpi_generic_address *gpe_block_address,
|         u32 register_count, u32 interrupt_number);
|
|acpi_status acpi_remove_gpe_block(acpi_handle gpe_device);
|
|acpi_status acpi_update_gpes(void);
|
|
|
|
|typedef
|acpi_status(*acpi_walk_resource_callback) (struct acpi_resource * resource,
|        void *context);
|
|acpi_status
|acpi_get_vendor_resource(acpi_handle device,
|    char *name,
|    struct acpi_vendor_uuid *uuid,
|    struct acpi_buffer *ret_buffer);
|
|acpi_status
|acpi_get_current_resources(acpi_handle device, struct acpi_buffer *ret_buffer);
|
|
|
|
|
|
|acpi_status
|acpi_walk_resources(acpi_handle device,
|      char *name,
|      acpi_walk_resource_callback user_function, void *context);
|
|acpi_status
|acpi_set_current_resources(acpi_handle device, struct acpi_buffer *in_buffer);
|
|acpi_status
|acpi_get_irq_routing_table(acpi_handle device, struct acpi_buffer *ret_buffer);
|
|acpi_status
|acpi_resource_to_address64(struct acpi_resource *resource,
|      struct acpi_resource_address64 *out);
|
|
|
|
|acpi_status acpi_reset(void);
|
|acpi_status acpi_read_bit_register(u32 register_id, u32 *return_value);
|
|acpi_status acpi_write_bit_register(u32 register_id, u32 value);
|
|acpi_status acpi_set_firmware_waking_vector(u32 physical_address);
|
|
|acpi_status acpi_set_firmware_waking_vector64(u64 physical_address);
|
|
|acpi_status acpi_read(u64 *value, struct acpi_generic_address *reg);
|
|acpi_status acpi_write(u64 value, struct acpi_generic_address *reg);
|
|acpi_status
|acpi_get_sleep_type_data(u8 sleep_state, u8 * slp_typ_a, u8 * slp_typ_b);
|
|acpi_status acpi_enter_sleep_state_prep(u8 sleep_state);
|
|acpi_status acpi_enter_sleep_state(u8 sleep_state);
|
|acpi_status acpi_enter_sleep_state_s4bios(void);
|
|acpi_status acpi_leave_sleep_state_prep(u8 sleep_state);
|
|acpi_status acpi_leave_sleep_state(u8 sleep_state);
|
|
|
|
|void
|acpi_error(const char *module_name,
|    u32 line_number, const char *format, ...) ;
|
|void
|acpi_exception(const char *module_name,
|        u32 line_number,
|        acpi_status status, const char *format, ...) ;
|
|void
|acpi_warning(const char *module_name,
|      u32 line_number, const char *format, ...) ;
|
|void
|acpi_info(const char *module_name,
|   u32 line_number, const char *format, ...) ;
|struct acpi_handle_list {
| u32 count;
| acpi_handle handles[10];
|};
|
|
|acpi_status
|acpi_extract_package(union acpi_object *package,
|       struct acpi_buffer *format, struct acpi_buffer *buffer);
|acpi_status
|acpi_evaluate_integer(acpi_handle handle,
|        acpi_string pathname,
|        struct acpi_object_list *arguments, unsigned long long *data);
|acpi_status
|acpi_evaluate_reference(acpi_handle handle,
|   acpi_string pathname,
|   struct acpi_object_list *arguments,
|   struct acpi_handle_list *list);
|
|
|
|
|
|
|extern struct proc_dir_entry *acpi_root_dir;
|
|enum acpi_bus_removal_type {
| ACPI_BUS_REMOVAL_NORMAL = 0,
| ACPI_BUS_REMOVAL_EJECT,
| ACPI_BUS_REMOVAL_SUPRISE,
| ACPI_BUS_REMOVAL_TYPE_COUNT
|};
|
|enum acpi_bus_device_type {
| ACPI_BUS_TYPE_DEVICE = 0,
| ACPI_BUS_TYPE_POWER,
| ACPI_BUS_TYPE_PROCESSOR,
| ACPI_BUS_TYPE_THERMAL,
| ACPI_BUS_TYPE_POWER_BUTTON,
| ACPI_BUS_TYPE_SLEEP_BUTTON,
| ACPI_BUS_DEVICE_TYPE_COUNT
|};
|
|struct acpi_driver;
|struct acpi_device;
|
|
|
|
|
|
|typedef int (*acpi_op_add) (struct acpi_device * device);
|typedef int (*acpi_op_remove) (struct acpi_device * device, int type);
|typedef int (*acpi_op_start) (struct acpi_device * device);
|typedef int (*acpi_op_suspend) (struct acpi_device * device,
|    pm_message_t state);
|typedef int (*acpi_op_resume) (struct acpi_device * device);
|typedef int (*acpi_op_bind) (struct acpi_device * device);
|typedef int (*acpi_op_unbind) (struct acpi_device * device);
|typedef void (*acpi_op_notify) (struct acpi_device * device, u32 event);
|
|struct acpi_bus_ops {
| u32 acpi_op_add:1;
| u32 acpi_op_start:1;
|};
|
|struct acpi_device_ops {
| acpi_op_add add;
| acpi_op_remove remove;
| acpi_op_start start;
| acpi_op_suspend suspend;
| acpi_op_resume resume;
| acpi_op_bind bind;
| acpi_op_unbind unbind;
| acpi_op_notify notify;
|};
|
|
|
|struct acpi_driver {
| char name[80];
| char class[80];
| const struct acpi_device_id *ids;
| unsigned int flags;
| struct acpi_device_ops ops;
| struct device_driver drv;
| struct module *owner;
|};
|struct acpi_device_status {
| u32 present:1;
| u32 enabled:1;
| u32 show_in_ui:1;
| u32 functional:1;
| u32 battery_present:1;
| u32 reserved:27;
|};
|
|
|
|struct acpi_device_flags {
| u32 dynamic_status:1;
| u32 bus_address:1;
| u32 removable:1;
| u32 ejectable:1;
| u32 lockable:1;
| u32 suprise_removal_ok:1;
| u32 power_manageable:1;
| u32 performance_manageable:1;
| u32 wake_capable:1;
| u32 force_power_state:1;
| u32 reserved:22;
|};
|
|
|
|struct acpi_device_dir {
| struct proc_dir_entry *entry;
|};
|
|
|
|
|
|typedef char acpi_bus_id[8];
|typedef unsigned long acpi_bus_address;
|typedef char acpi_device_name[40];
|typedef char acpi_device_class[20];
|
|struct acpi_hardware_id {
| struct list_head list;
| char *id;
|};
|
|struct acpi_device_pnp {
| acpi_bus_id bus_id;
| acpi_bus_address bus_address;
| char *unique_id;
| struct list_head ids;
| acpi_device_name device_name;
| acpi_device_class device_class;
|};
|
|
|
|const char *acpi_device_hid(struct acpi_device *device);
|
|
|
|
|
|struct acpi_device_power_flags {
| u32 explicit_get:1;
| u32 power_resources:1;
| u32 inrush_current:1;
| u32 power_removed:1;
| u32 reserved:28;
|};
|
|struct acpi_device_power_state {
| struct {
|  u8 valid:1;
|  u8 explicit_set:1;
|  u8 reserved:6;
| } flags;
| int power;
| int latency;
| struct acpi_handle_list resources;
|};
|
|struct acpi_device_power {
| int state;
| struct acpi_device_power_flags flags;
| struct acpi_device_power_state states[4];
|};
|
|
|
|struct acpi_device_perf_flags {
| u8 reserved:8;
|};
|
|struct acpi_device_perf_state {
| struct {
|  u8 valid:1;
|  u8 reserved:7;
| } flags;
| u8 power;
| u8 performance;
| int latency;
|};
|
|struct acpi_device_perf {
| int state;
| struct acpi_device_perf_flags flags;
| int state_count;
| struct acpi_device_perf_state *states;
|};
|
|
|struct acpi_device_wakeup_flags {
| u8 valid:1;
| u8 run_wake:1;
| u8 always_enabled:1;
| u8 notifier_present:1;
|};
|
|struct acpi_device_wakeup_state {
| u8 enabled:1;
|};
|
|struct acpi_device_wakeup {
| acpi_handle gpe_device;
| u64 gpe_number;
| u64 sleep_state;
| struct acpi_handle_list resources;
| struct acpi_device_wakeup_state state;
| struct acpi_device_wakeup_flags flags;
| int prepare_count;
| int run_wake_count;
|};
|
|
|
|struct acpi_device {
| int device_type;
| acpi_handle handle;
| struct acpi_device *parent;
| struct list_head children;
| struct list_head node;
| struct list_head wakeup_list;
| struct acpi_device_status status;
| struct acpi_device_flags flags;
| struct acpi_device_pnp pnp;
| struct acpi_device_power power;
| struct acpi_device_wakeup wakeup;
| struct acpi_device_perf performance;
| struct acpi_device_dir dir;
| struct acpi_device_ops ops;
| struct acpi_driver *driver;
| void *driver_data;
| struct device dev;
| struct acpi_bus_ops bus_ops;
| enum acpi_bus_removal_type removal_type;
|};
|
|static inline void *acpi_driver_data(struct acpi_device *d)
|{
| return d->driver_data;
|}
|
|
|
|
|
|extern struct bus_type acpi_bus_type;
|
|
|
|
|
|
|struct acpi_bus_event {
| struct list_head node;
| acpi_device_class device_class;
| acpi_bus_id bus_id;
| u32 type;
| u32 data;
|};
|
|extern struct kobject *acpi_kobj;
|extern int acpi_bus_generate_netlink_event(const char*, const char*, u8, int);
|void acpi_bus_private_data_handler(acpi_handle, void *);
|int acpi_bus_get_private_data(acpi_handle, void **);
|extern int acpi_notifier_call_chain(struct acpi_device *, u32, u32);
|extern int register_acpi_notifier(struct notifier_block *);
|extern int unregister_acpi_notifier(struct notifier_block *);
|
|extern int register_acpi_bus_notifier(struct notifier_block *nb);
|extern void unregister_acpi_bus_notifier(struct notifier_block *nb);
|
|
|
|
|int acpi_bus_get_device(acpi_handle handle, struct acpi_device **device);
|void acpi_bus_data_handler(acpi_handle handle, void *context);
|acpi_status acpi_bus_get_status_handle(acpi_handle handle,
|           unsigned long long *sta);
|int acpi_bus_get_status(struct acpi_device *device);
|int acpi_bus_get_power(acpi_handle handle, int *state);
|int acpi_bus_set_power(acpi_handle handle, int state);
|bool acpi_bus_power_manageable(acpi_handle handle);
|bool acpi_bus_can_wakeup(acpi_handle handle);
|
|int acpi_bus_generate_proc_event(struct acpi_device *device, u8 type, int data);
|int acpi_bus_generate_proc_event4(const char *class, const char *bid, u8 type, int data);
|int acpi_bus_receive_event(struct acpi_bus_event *event);
|
|
|
|
|int acpi_bus_register_driver(struct acpi_driver *driver);
|void acpi_bus_unregister_driver(struct acpi_driver *driver);
|int acpi_bus_add(struct acpi_device **child, struct acpi_device *parent,
|   acpi_handle handle, int type);
|int acpi_bus_trim(struct acpi_device *start, int rmdevice);
|int acpi_bus_start(struct acpi_device *device);
|acpi_status acpi_bus_get_ejd(acpi_handle handle, acpi_handle * ejd);
|int acpi_match_device_ids(struct acpi_device *device,
|     const struct acpi_device_id *ids);
|int acpi_create_dir(struct acpi_device *);
|void acpi_remove_dir(struct acpi_device *);
|
|
|
|
|struct acpi_bus_type {
| struct list_head list;
| struct bus_type *bus;
|
| int (*find_device) (struct device *, acpi_handle *);
|
| int (*find_bridge) (struct device *, acpi_handle *);
|};
|int register_acpi_bus_type(struct acpi_bus_type *);
|int unregister_acpi_bus_type(struct acpi_bus_type *);
|struct device *acpi_get_physical_device(acpi_handle);
|
|struct acpi_pci_root {
| struct list_head node;
| struct acpi_device * device;
| struct acpi_pci_id id;
| struct pci_bus *bus;
| u16 segment;
| struct resource secondary;
|
| u32 osc_support_set;
| u32 osc_control_set;
|};
|
|
|acpi_handle acpi_get_child(acpi_handle, u64);
|int acpi_is_root_bridge(acpi_handle);
|acpi_handle acpi_get_pci_rootbridge_handle(unsigned int, unsigned int);
|struct acpi_pci_root *acpi_pci_find_root(acpi_handle handle);
|
|
|int acpi_enable_wakeup_device_power(struct acpi_device *dev, int state);
|int acpi_disable_wakeup_device_power(struct acpi_device *dev);
|
|
|int acpi_pm_device_sleep_state(struct device *, int *);
|int acpi_pm_device_sleep_wake(struct device *, bool);
|int acpi_irq_penalty_init(void);
|int acpi_pci_link_allocate_irq(acpi_handle handle, int index, int *triggering,
|          int *polarity, char **name);
|int acpi_pci_link_free_irq(acpi_handle handle);
|
|
|
|int acpi_pci_irq_add_prt(acpi_handle handle, struct pci_bus *bus);
|void acpi_pci_irq_del_prt(struct pci_bus *bus);
|
|
|
|struct pci_bus;
|
|struct pci_dev *acpi_get_pci_dev(acpi_handle);
|int acpi_pci_bind_root(struct acpi_device *device);
|
|
|
|struct pci_bus *pci_acpi_scan_root(struct acpi_pci_root *root);
|void pci_acpi_crs_quirks(void);
|struct acpi_dock_ops {
| acpi_notify_handler handler;
| acpi_notify_handler uevent;
|};
|
|
|extern int is_dock_device(acpi_handle handle);
|extern int register_dock_notifier(struct notifier_block *nb);
|extern void unregister_dock_notifier(struct notifier_block *nb);
|extern int register_hotplug_dock_device(acpi_handle handle,
|     struct acpi_dock_ops *ops,
|     void *context);
|extern void unregister_hotplug_dock_device(acpi_handle handle);
|extern int pxm_to_node(int);
|extern int node_to_pxm(int);
|extern void __acpi_map_pxm_to_node(int, int);
|extern int acpi_map_pxm_to_node(int);
|
|
|enum acpi_irq_model_id {
| ACPI_IRQ_MODEL_PIC = 0,
| ACPI_IRQ_MODEL_IOAPIC,
| ACPI_IRQ_MODEL_IOSAPIC,
| ACPI_IRQ_MODEL_PLATFORM,
| ACPI_IRQ_MODEL_COUNT
|};
|
|extern enum acpi_irq_model_id acpi_irq_model;
|
|enum acpi_interrupt_id {
| ACPI_INTERRUPT_PMI = 1,
| ACPI_INTERRUPT_INIT,
| ACPI_INTERRUPT_CPEI,
| ACPI_INTERRUPT_COUNT
|};
|
|
|
|enum acpi_address_range_id {
| ACPI_ADDRESS_RANGE_MEMORY = 1,
| ACPI_ADDRESS_RANGE_RESERVED = 2,
| ACPI_ADDRESS_RANGE_ACPI = 3,
| ACPI_ADDRESS_RANGE_NVS = 4,
| ACPI_ADDRESS_RANGE_COUNT
|};
|
|
|
|
|typedef int (*acpi_table_handler) (struct acpi_table_header *table);
|
|typedef int (*acpi_table_entry_handler) (struct acpi_subtable_header *header, const unsigned long end);
|
|char * __acpi_map_table (unsigned long phys_addr, unsigned long size);
|void __acpi_unmap_table(char *map, unsigned long size);
|int early_acpi_boot_init(void);
|int acpi_boot_init (void);
|void acpi_boot_table_init (void);
|int acpi_mps_check (void);
|int acpi_numa_init (void);
|
|int acpi_table_init (void);
|int acpi_table_parse (char *id, acpi_table_handler handler);
|int acpi_table_parse_entries(char *id, unsigned long table_size,
| int entry_id, acpi_table_entry_handler handler, unsigned int max_entries);
|int acpi_table_parse_madt (enum acpi_madt_type id, acpi_table_entry_handler handler, unsigned int max_entries);
|int acpi_parse_mcfg (struct acpi_table_header *header);
|void acpi_table_print_madt_entry (struct acpi_subtable_header *madt);
|
|
|void acpi_numa_slit_init (struct acpi_table_slit *slit);
|void acpi_numa_processor_affinity_init (struct acpi_srat_cpu_affinity *pa);
|void acpi_numa_x2apic_affinity_init(struct acpi_srat_x2apic_cpu_affinity *pa);
|void acpi_numa_memory_affinity_init (struct acpi_srat_mem_affinity *ma);
|void acpi_numa_arch_fixup(void);
|
|
|
|int acpi_map_lsapic(acpi_handle handle, int *pcpu);
|int acpi_unmap_lsapic(int cpu);
|
|
|int acpi_register_ioapic(acpi_handle handle, u64 phys_addr, u32 gsi_base);
|int acpi_unregister_ioapic(acpi_handle handle, u32 gsi_base);
|void acpi_irq_stats_init(void);
|extern u32 acpi_irq_handled;
|extern u32 acpi_irq_not_handled;
|
|extern int sbf_port;
|extern unsigned long acpi_realmode_flags;
|
|int acpi_register_gsi (struct device *dev, u32 gsi, int triggering, int polarity);
|int acpi_gsi_to_irq (u32 gsi, unsigned int *irq);
|int acpi_isa_irq_to_gsi (unsigned isa_irq, u32 *gsi);
|
|
|extern int acpi_get_override_irq(u32 gsi, int *trigger, int *polarity);
|void acpi_unregister_gsi (u32 gsi);
|
|struct pci_dev;
|
|int acpi_pci_irq_enable (struct pci_dev *dev);
|void acpi_penalize_isa_irq(int irq, int active);
|
|void acpi_pci_irq_disable (struct pci_dev *dev);
|
|struct acpi_pci_driver {
| struct acpi_pci_driver *next;
| int (*add)(acpi_handle handle);
| void (*remove)(acpi_handle handle);
|};
|
|int acpi_pci_register_driver(struct acpi_pci_driver *driver);
|void acpi_pci_unregister_driver(struct acpi_pci_driver *driver);
|
|extern int ec_read(u8 addr, u8 *val);
|extern int ec_write(u8 addr, u8 val);
|extern int ec_transaction(u8 command,
|                          const u8 *wdata, unsigned wdata_len,
|                          u8 *rdata, unsigned rdata_len,
|     int force_poll);
|
|
|
|typedef void (*wmi_notify_handler) (u32 value, void *context);
|
|extern acpi_status wmi_evaluate_method(const char *guid, u8 instance,
|     u32 method_id,
|     const struct acpi_buffer *in,
|     struct acpi_buffer *out);
|extern acpi_status wmi_query_block(const char *guid, u8 instance,
|     struct acpi_buffer *out);
|extern acpi_status wmi_set_block(const char *guid, u8 instance,
|     const struct acpi_buffer *in);
|extern acpi_status wmi_install_notify_handler(const char *guid,
|     wmi_notify_handler handler, void *data);
|extern acpi_status wmi_remove_notify_handler(const char *guid);
|extern acpi_status wmi_get_event_data(u32 event, struct acpi_buffer *out);
|extern bool wmi_has_guid(const char *guid);
|extern long acpi_video_get_capabilities(acpi_handle graphics_dev_handle);
|extern long acpi_is_video_device(struct acpi_device *device);
|extern int acpi_video_backlight_support(void);
|extern int acpi_video_display_switch_support(void);
|extern int acpi_blacklisted(void);
|extern void acpi_dmi_osi_linux(int enable, const struct dmi_system_id *d);
|extern int acpi_osi_setup(char *str);
|
|
|int acpi_get_pxm(acpi_handle handle);
|int acpi_get_node(acpi_handle *handle);
|extern int acpi_paddr_to_node(u64 start_addr, u64 size);
|
|extern int pnpacpi_disabled;
|
|
|
|
|int acpi_check_resource_conflict(const struct resource *res);
|
|int acpi_check_region(resource_size_t start, resource_size_t n,
|        const char *name);
|
|int acpi_resources_are_enforced(void);
|
|
|void acpi_no_s4_hw_signature(void);
|void acpi_old_suspend_ordering(void);
|void acpi_nvs_nosave(void);
|
|
|struct acpi_osc_context {
| char *uuid_str;
| int rev;
| struct acpi_buffer cap;
| struct acpi_buffer ret;
|};
|acpi_status acpi_run_osc(acpi_handle handle, struct acpi_osc_context *context);
|extern acpi_status acpi_pci_osc_control_set(acpi_handle handle,
|          u32 *mask, u32 req);
|extern void acpi_early_init(void);
|
|int acpi_os_map_generic_address(struct acpi_generic_address *addr);
|void acpi_os_unmap_generic_address(struct acpi_generic_address *addr);
|
|
|
|
|
|
|static int acpi_failure;
|
|
|static u32 ipmi_acpi_gpe(void *context)
|{
| struct smi_info *smi_info = context;
| unsigned long flags;
|
|
|
|
| __st_spin_lock_irqsave_st__(&(smi_info->si_lock), flags);
|
| atomic_inc(&(smi_info)->stats[SI_STAT_interrupts]);
|
|
|
|
|
| smi_event_handler(smi_info, 0);
| __st_spin_unlock_irqrestore_st__(&(smi_info->si_lock), flags);
|
| return 0x01;
|}
|
|static void acpi_gpe_irq_cleanup(struct smi_info *info)
|{
| if (!info->irq)
|  return;
|
| acpi_remove_gpe_handler(((void *)0), info->irq, &ipmi_acpi_gpe);
|}
|
|static int acpi_gpe_irq_setup(struct smi_info *info)
|{
| acpi_status status;
|
| if (!info->irq)
|  return 0;
|
|
| status = acpi_install_gpe_handler(((void *)0),
|       info->irq,
|       (u8) 0x01,
|       &ipmi_acpi_gpe,
|       info);
| if (status != (acpi_status) 0x0000) {
|  dev_warn(info->dev, "%s unable to claim ACPI GPE %d,"
|    " running polled\n", "ipmi_si", info->irq);
|  info->irq = 0;
|  return -22;
| } else {
|  info->irq_cleanup = acpi_gpe_irq_cleanup;
|  _dev_info(info->dev, "Using ACPI GPE %d\n", info->irq);
|  return 0;
| }
|}
|
|
|
|
|
|struct SPMITable {
| s8 Signature[4];
| u32 Length;
| u8 Revision;
| u8 Checksum;
| s8 OEMID[6];
| s8 OEMTableID[8];
| s8 OEMRevision[4];
| s8 CreatorID[4];
| s8 CreatorRevision[4];
| u8 InterfaceType;
| u8 IPMIlegacy;
| s16 SpecificationRevision;
|
|
|
|
|
| u8 InterruptType;
|
|
|
|
|
| u8 GPE;
|
| s16 Reserved;
|
|
|
|
|
| u32 GlobalSystemInterrupt;
|
|
| struct acpi_generic_address addr;
|
| u8 UID[4];
|
| s8 spmi_id[1];
|};
|
|static int try_init_spmi(struct SPMITable *spmi)
|{
| struct smi_info *info;
|
| if (spmi->IPMIlegacy != 1) {
|  printk("<6>" "ipmi_si: " "Bad SPMI legacy %d\n", spmi->IPMIlegacy);
|  return -19;
| }
|
| info = smi_info_alloc();
| if (!info) {
|  printk("<3>" "ipmi_si: " "Could not allocate SI data (3)\n");
|  return -12;
| }
|
| info->addr_source = SI_SPMI;
| printk("<6>" "ipmi_si: " "probing via SPMI\n");
|
|
| switch (spmi->InterfaceType) {
| case 1:
|  info->si_type = SI_KCS;
|  break;
| case 2:
|  info->si_type = SI_SMIC;
|  break;
| case 3:
|  info->si_type = SI_BT;
|  break;
| default:
|  printk("<6>" "ipmi_si: " "Unknown ACPI/SPMI SI type %d\n",
|         spmi->InterfaceType);
|  kfree(info);
|  return -5;
| }
|
| if (spmi->InterruptType & 1) {
|
|  info->irq = spmi->GPE;
|  info->irq_setup = acpi_gpe_irq_setup;
| } else if (spmi->InterruptType & 2) {
|
|  info->irq = spmi->GlobalSystemInterrupt;
|  info->irq_setup = std_irq_setup;
| } else {
|
|  info->irq = 0;
|  info->irq_setup = ((void *)0);
| }
|
| if (spmi->addr.bit_width) {
|
|  info->io.regspacing = spmi->addr.bit_width / 8;
| } else {
|  info->io.regspacing = 1;
| }
| info->io.regsize = info->io.regspacing;
| info->io.regshift = spmi->addr.bit_offset;
|
| if (spmi->addr.space_id == (acpi_adr_space_type) 0) {
|  info->io_setup = mem_setup;
|  info->io.addr_type = 1;
| } else if (spmi->addr.space_id == (acpi_adr_space_type) 1) {
|  info->io_setup = port_setup;
|  info->io.addr_type = 0;
| } else {
|  kfree(info);
|  printk("<4>" "ipmi_si: " "Unknown ACPI I/O Address type\n");
|  return -5;
| }
| info->io.addr_data = spmi->addr.address;
|
| printk("<6>" "ipmi_si: SPMI: %s %#lx regsize %d spacing %d irq %d\n", (info->io.addr_type == 0) ? "io" : "mem", info->io.addr_data, info->io.regsize, info->io.regspacing, info->irq)
|
|
|             ;
|
| if (add_smi(info))
|  kfree(info);
|
| return 0;
|}
|
|static void spmi_find_bmc(void)
|{
| acpi_status status;
| struct SPMITable *spmi;
| int i;
|
| if (acpi_disabled)
|  return;
|
| if (acpi_failure)
|  return;
|
| for (i = 0; ; i++) {
|  status = acpi_get_table("SPMI", i+1,
|     (struct acpi_table_header **)&spmi);
|  if (status != (acpi_status) 0x0000)
|   return;
|
|  try_init_spmi(spmi);
| }
|}
|
|static int ipmi_pnp_probe(struct pnp_dev *dev,
|        const struct pnp_device_id *dev_id)
|{
| struct acpi_device *acpi_dev;
| struct smi_info *info;
| struct resource *res, *res_second;
| acpi_handle handle;
| acpi_status status;
| unsigned long long tmp;
|
| acpi_dev = pnp_acpi_device(dev);
| if (!acpi_dev)
|  return -19;
|
| info = smi_info_alloc();
| if (!info)
|  return -12;
|
| info->addr_source = SI_ACPI;
| printk("<6>" "ipmi_si: " "probing via ACPI\n");
|
| handle = acpi_dev->handle;
|
|
| status = acpi_evaluate_integer(handle, "_IFT", ((void *)0), &tmp);
| if ((status))
|  goto err_free;
|
| switch (tmp) {
| case 1:
|  info->si_type = SI_KCS;
|  break;
| case 2:
|  info->si_type = SI_SMIC;
|  break;
| case 3:
|  info->si_type = SI_BT;
|  break;
| default:
|  _dev_info(&dev->dev, "unknown IPMI type %lld\n", tmp);
|  goto err_free;
| }
|
| res = pnp_get_resource(dev, 0x00000100, 0);
| if (res) {
|  info->io_setup = port_setup;
|  info->io.addr_type = 0;
| } else {
|  res = pnp_get_resource(dev, 0x00000200, 0);
|  if (res) {
|   info->io_setup = mem_setup;
|   info->io.addr_type = 1;
|  }
| }
| if (!res) {
|  dev_err(&dev->dev, "no I/O or memory address\n");
|  goto err_free;
| }
| info->io.addr_data = res->start;
|
| info->io.regspacing = 1;
| res_second = pnp_get_resource(dev,
|          (info->io.addr_type == 0) ?
|     0x00000100 : 0x00000200,
|          1);
| if (res_second) {
|  if (res_second->start > info->io.addr_data)
|   info->io.regspacing = res_second->start - info->io.addr_data;
| }
| info->io.regsize = 1;
| info->io.regshift = 0;
|
|
| status = acpi_evaluate_integer(handle, "_GPE", ((void *)0), &tmp);
| if ((!(status))) {
|  info->irq = tmp;
|  info->irq_setup = acpi_gpe_irq_setup;
| } else if (pnp_irq_valid(dev, 0)) {
|  info->irq = pnp_irq(dev, 0);
|  info->irq_setup = std_irq_setup;
| }
|
| info->dev = &dev->dev;
| pnp_set_drvdata(dev, info);
|
| _dev_info(info->dev, "%pR regsize %d spacing %d irq %d\n", res, info->io.regsize, info->io.regspacing, info->irq)
|
|             ;
|
| if (add_smi(info))
|  goto err_free;
|
| return 0;
|
|err_free:
| kfree(info);
| return -22;
|}
|
|static void ipmi_pnp_remove(struct pnp_dev *dev)
|{
| struct smi_info *info = pnp_get_drvdata(dev);
|
| cleanup_one_si(info);
|}
|
|static const struct pnp_device_id pnp_dev_table[] = {
| {"IPI0001", 0},
| {"", 0},
|};
|
|static struct pnp_driver ipmi_pnp_driver = {
| .name = "ipmi_si",
| .probe = ipmi_pnp_probe,
| .remove = ipmi_pnp_remove,
| .id_table = pnp_dev_table,
|};
|
|
|
|struct dmi_ipmi_data {
| u8 type;
| u8 addr_space;
| unsigned long base_addr;
| u8 irq;
| u8 offset;
| u8 slave_addr;
|};
|
|static int decode_dmi(const struct dmi_header *dm,
|    struct dmi_ipmi_data *dmi)
|{
| const u8 *data = (const u8 *)dm;
| unsigned long base_addr;
| u8 reg_spacing;
| u8 len = dm->length;
|
| dmi->type = data[4];
|
| __st_memcpy_st__(&base_addr, data+8, sizeof(unsigned long));
| if (len >= 0x11) {
|  if (base_addr & 1) {
|
|   base_addr &= 0xFFFE;
|   dmi->addr_space = 0;
|  } else
|
|   dmi->addr_space = 1;
|
|
|
|  dmi->base_addr = base_addr | ((data[0x10] & 0x10) >> 4);
|
|  dmi->irq = data[0x11];
|
|
|  reg_spacing = (data[0x10] & 0xC0) >> 6;
|  switch (reg_spacing) {
|  case 0x00:
|      dmi->offset = 1;
|      break;
|  case 0x01:
|      dmi->offset = 4;
|      break;
|  case 0x02:
|      dmi->offset = 16;
|      break;
|  default:
|
|      return -5;
|  }
| } else {
|  dmi->base_addr = base_addr & 0xfffe;
|  dmi->addr_space = 0;
|  dmi->offset = 1;
| }
|
| dmi->slave_addr = data[6];
|
| return 0;
|}
|
|static void try_init_dmi(struct dmi_ipmi_data *ipmi_data)
|{
| struct smi_info *info;
|
| info = smi_info_alloc();
| if (!info) {
|  printk("<3>" "ipmi_si: " "Could not allocate SI data\n");
|  return;
| }
|
| info->addr_source = SI_SMBIOS;
| printk("<6>" "ipmi_si: " "probing via SMBIOS\n");
|
| switch (ipmi_data->type) {
| case 0x01:
|  info->si_type = SI_KCS;
|  break;
| case 0x02:
|  info->si_type = SI_SMIC;
|  break;
| case 0x03:
|  info->si_type = SI_BT;
|  break;
| default:
|  kfree(info);
|  return;
| }
|
| switch (ipmi_data->addr_space) {
| case 1:
|  info->io_setup = mem_setup;
|  info->io.addr_type = 1;
|  break;
|
| case 0:
|  info->io_setup = port_setup;
|  info->io.addr_type = 0;
|  break;
|
| default:
|  kfree(info);
|  printk("<4>" "ipmi_si: " "Unknown SMBIOS I/O Address type: %d\n",
|         ipmi_data->addr_space);
|  return;
| }
| info->io.addr_data = ipmi_data->base_addr;
|
| info->io.regspacing = ipmi_data->offset;
| if (!info->io.regspacing)
|  info->io.regspacing = 1;
| info->io.regsize = 1;
| info->io.regshift = 0;
|
| info->slave_addr = ipmi_data->slave_addr;
|
| info->irq = ipmi_data->irq;
| if (info->irq)
|  info->irq_setup = std_irq_setup;
|
| printk("<6>" "ipmi_si: SMBIOS: %s %#lx regsize %d spacing %d irq %d\n", (info->io.addr_type == 0) ? "io" : "mem", info->io.addr_data, info->io.regsize, info->io.regspacing, info->irq)
|
|
|             ;
|
| if (add_smi(info))
|  kfree(info);
|}
|
|static void dmi_find_bmc(void)
|{
| const struct dmi_device *dev = ((void *)0);
| struct dmi_ipmi_data data;
| int rv;
|
| while ((dev = dmi_find_device(DMI_DEV_TYPE_IPMI, ((void *)0), dev))) {
|  __st_memset_st__(&data, 0, sizeof(data));
|  rv = decode_dmi((const struct dmi_header *) dev->device_data,
|    &data);
|  if (!rv)
|   try_init_dmi(&data);
| }
|}
|static void ipmi_pci_cleanup(struct smi_info *info)
|{
| struct pci_dev *pdev = info->addr_source_data;
|
| pci_disable_device(pdev);
|}
|
|static int ipmi_pci_probe(struct pci_dev *pdev,
|        const struct pci_device_id *ent)
|{
| int rv;
| int class_type = pdev->class & 0xff;
| struct smi_info *info;
|
| info = smi_info_alloc();
| if (!info)
|  return -12;
|
| info->addr_source = SI_PCI;
| _dev_info(&pdev->dev, "probing via PCI");
|
| switch (class_type) {
| case 0x00:
|  info->si_type = SI_SMIC;
|  break;
|
| case 0x01:
|  info->si_type = SI_KCS;
|  break;
|
| case 0x02:
|  info->si_type = SI_BT;
|  break;
|
| default:
|  kfree(info);
|  _dev_info(&pdev->dev, "Unknown IPMI type: %d\n", class_type);
|  return -12;
| }
|
| rv = pci_enable_device(pdev);
| if (rv) {
|  dev_err(&pdev->dev, "couldn't enable PCI device\n");
|  kfree(info);
|  return rv;
| }
|
| info->addr_source_cleanup = ipmi_pci_cleanup;
| info->addr_source_data = pdev;
|
| if (((pdev)->resource[(0)].flags) & 0x00000100) {
|  info->io_setup = port_setup;
|  info->io.addr_type = 0;
| } else {
|  info->io_setup = mem_setup;
|  info->io.addr_type = 1;
| }
| info->io.addr_data = ((pdev)->resource[(0)].start);
|
| info->io.regspacing = 1;
| info->io.regsize = 1;
| info->io.regshift = 0;
|
| info->irq = pdev->irq;
| if (info->irq)
|  info->irq_setup = std_irq_setup;
|
| info->dev = &pdev->dev;
| pci_set_drvdata(pdev, info);
|
| _dev_info(&pdev->dev, "%pR regsize %d spacing %d irq %d\n", &pdev->resource[0], info->io.regsize, info->io.regspacing, info->irq)
|
|            ;
|
| if (add_smi(info))
|  kfree(info);
|
| return 0;
|}
|
|static void ipmi_pci_remove(struct pci_dev *pdev)
|{
| struct smi_info *info = pci_get_drvdata(pdev);
| cleanup_one_si(info);
|}
|
|
|static int ipmi_pci_suspend(struct pci_dev *pdev, pm_message_t state)
|{
| return 0;
|}
|
|static int ipmi_pci_resume(struct pci_dev *pdev)
|{
| return 0;
|}
|
|
|static struct pci_device_id ipmi_pci_devices[] = {
| { .vendor = (0x103C), .device = (0x121A), .subvendor = (~0), .subdevice = (~0) },
| { .class = (0x0C0700), .class_mask = (0xffffff00), .vendor = (~0), .device = (~0), .subvendor = (~0), .subdevice = (~0) },
| { 0, }
|};
|extern const struct pci_device_id __mod_pci_device_table ;
|
|static struct pci_driver ipmi_pci_driver = {
| .name = "ipmi_si",
| .id_table = ipmi_pci_devices,
| .probe = ipmi_pci_probe,
| .remove = ipmi_pci_remove,
|
| .suspend = ipmi_pci_suspend,
| .resume = ipmi_pci_resume,
|
|};
|static int wait_for_msg_done(struct smi_info *smi_info)
|{
| enum si_sm_result smi_result;
|
| smi_result = smi_info->handlers->event(smi_info->si_sm, 0);
| for (;;) {
|  if (smi_result == SI_SM_CALL_WITH_DELAY ||
|      smi_result == SI_SM_CALL_WITH_TICK_DELAY) {
|   schedule_timeout_uninterruptible(1);
|   smi_result = smi_info->handlers->event(
|    smi_info->si_sm, 100);
|  } else if (smi_result == SI_SM_CALL_WITHOUT_DELAY) {
|   smi_result = smi_info->handlers->event(
|    smi_info->si_sm, 0);
|  } else
|   break;
| }
| if (smi_result == SI_SM_HOSED)
|
|
|
|
|  return -19;
|
| return 0;
|}
|
|static int try_get_dev_id(struct smi_info *smi_info)
|{
| unsigned char msg[2];
| unsigned char *resp;
| unsigned long resp_len;
| int rv = 0;
|
| resp = kmalloc(272, __st_GFP_KERNEL_st__);
| if (!resp)
|  return -12;
|
|
|
|
|
| msg[0] = 0x06 << 2;
| msg[1] = 0x01;
| smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
|
| rv = wait_for_msg_done(smi_info);
| if (rv)
|  goto out;
|
| resp_len = smi_info->handlers->get_result(smi_info->si_sm,
|        resp, 272);
|
|
| rv = ipmi_demangle_device_id(resp, resp_len, &smi_info->device_id);
|
| out:
| kfree(resp);
| return rv;
|}
|
|static int try_enable_event_buffer(struct smi_info *smi_info)
|{
| unsigned char msg[3];
| unsigned char *resp;
| unsigned long resp_len;
| int rv = 0;
|
| resp = kmalloc(272, __st_GFP_KERNEL_st__);
| if (!resp)
|  return -12;
|
| msg[0] = 0x06 << 2;
| msg[1] = 0x2f;
| smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
|
| rv = wait_for_msg_done(smi_info);
| if (rv) {
|  printk("<4>" "ipmi_si: " "Error getting response from get"
|         " global enables command, the event buffer is not"
|         " enabled.\n");
|  goto out;
| }
|
| resp_len = smi_info->handlers->get_result(smi_info->si_sm,
|        resp, 272);
|
| if (resp_len < 4 ||
|   resp[0] != (0x06 | 1) << 2 ||
|   resp[1] != 0x2f ||
|   resp[2] != 0) {
|  printk("<4>" "ipmi_si: " "Invalid return from get global"
|         " enables command, cannot enable the event buffer.\n");
|  rv = -22;
|  goto out;
| }
|
| if (resp[3] & 0x04)
|
|  goto out;
|
| msg[0] = 0x06 << 2;
| msg[1] = 0x2e;
| msg[2] = resp[3] | 0x04;
| smi_info->handlers->start_transaction(smi_info->si_sm, msg, 3);
|
| rv = wait_for_msg_done(smi_info);
| if (rv) {
|  printk("<4>" "ipmi_si: " "Error getting response from set"
|         " global, enables command, the event buffer is not"
|         " enabled.\n");
|  goto out;
| }
|
| resp_len = smi_info->handlers->get_result(smi_info->si_sm,
|        resp, 272);
|
| if (resp_len < 3 ||
|   resp[0] != (0x06 | 1) << 2 ||
|   resp[1] != 0x2e) {
|  printk("<4>" "ipmi_si: " "Invalid return from get global,"
|         "enables command, not enable the event buffer.\n");
|  rv = -22;
|  goto out;
| }
|
| if (resp[2] != 0)
|
|
|
|
|  rv = -2;
| out:
| kfree(resp);
| return rv;
|}
|
|static int type_file_read_proc(char *page, char **start, off_t off,
|          int count, int *eof, void *data)
|{
| struct smi_info *smi = data;
|
| return sprintf(page, "%s\n", si_to_str[smi->si_type]);
|}
|
|static int stat_file_read_proc(char *page, char **start, off_t off,
|          int count, int *eof, void *data)
|{
| char *out = (char *) page;
| struct smi_info *smi = data;
|
| out += sprintf(out, "interrupts_enabled:    %d\n",
|         smi->irq && !smi->interrupt_disabled);
| out += sprintf(out, "short_timeouts:        %u\n",
|         ((unsigned int) atomic_read(&(smi)->stats[SI_STAT_short_timeouts])));
| out += sprintf(out, "long_timeouts:         %u\n",
|         ((unsigned int) atomic_read(&(smi)->stats[SI_STAT_long_timeouts])));
| out += sprintf(out, "idles:                 %u\n",
|         ((unsigned int) atomic_read(&(smi)->stats[SI_STAT_idles])));
| out += sprintf(out, "interrupts:            %u\n",
|         ((unsigned int) atomic_read(&(smi)->stats[SI_STAT_interrupts])));
| out += sprintf(out, "attentions:            %u\n",
|         ((unsigned int) atomic_read(&(smi)->stats[SI_STAT_attentions])));
| out += sprintf(out, "flag_fetches:          %u\n",
|         ((unsigned int) atomic_read(&(smi)->stats[SI_STAT_flag_fetches])));
| out += sprintf(out, "hosed_count:           %u\n",
|         ((unsigned int) atomic_read(&(smi)->stats[SI_STAT_hosed_count])));
| out += sprintf(out, "complete_transactions: %u\n",
|         ((unsigned int) atomic_read(&(smi)->stats[SI_STAT_complete_transactions])));
| out += sprintf(out, "events:                %u\n",
|         ((unsigned int) atomic_read(&(smi)->stats[SI_STAT_events])));
| out += sprintf(out, "watchdog_pretimeouts:  %u\n",
|         ((unsigned int) atomic_read(&(smi)->stats[SI_STAT_watchdog_pretimeouts])));
| out += sprintf(out, "incoming_messages:     %u\n",
|         ((unsigned int) atomic_read(&(smi)->stats[SI_STAT_incoming_messages])));
|
| return out - page;
|}
|
|static int param_read_proc(char *page, char **start, off_t off,
|      int count, int *eof, void *data)
|{
| struct smi_info *smi = data;
|
| return sprintf(page,
|         "%s,%s,0x%lx,rsp=%d,rsi=%d,rsh=%d,irq=%d,ipmb=%d\n",
|         si_to_str[smi->si_type],
|         addr_space_to_str[smi->io.addr_type],
|         smi->io.addr_data,
|         smi->io.regspacing,
|         smi->io.regsize,
|         smi->io.regshift,
|         smi->irq,
|         smi->slave_addr);
|}
|static int oem_data_avail_to_receive_msg_avail(struct smi_info *smi_info)
|{
| smi_info->msg_flags = ((smi_info->msg_flags & ~(0x20 | 0x40 | 0x80)) |
|          0x01);
| return 1;
|}
|static void setup_dell_poweredge_oem_data_handler(struct smi_info *smi_info)
|{
| struct ipmi_device_id *id = &smi_info->device_id;
| if (id->manufacturer_id == 0x0002a2) {
|  if (id->device_id == 0x20 &&
|      id->device_revision == 0x80 &&
|      id->ipmi_version == 0x51) {
|   smi_info->oem_data_avail_handler =
|    oem_data_avail_to_receive_msg_avail;
|  } else if (((id)->ipmi_version & 0xf) < 1 ||
|      (((id)->ipmi_version & 0xf) == 1 &&
|       ((id)->ipmi_version >> 4) < 5)) {
|   smi_info->oem_data_avail_handler =
|    oem_data_avail_to_receive_msg_avail;
|  }
| }
|}
|
|
|static void return_hosed_msg_badsize(struct smi_info *smi_info)
|{
| struct ipmi_smi_msg *msg = smi_info->curr_msg;
|
|
| msg->rsp[0] = msg->data[0] | 4;
| msg->rsp[1] = msg->data[1];
| msg->rsp[2] = 0xCA;
| msg->rsp_size = 3;
| smi_info->curr_msg = ((void *)0);
| deliver_recv_msg(smi_info, msg);
|}
|static int dell_poweredge_bt_xaction_handler(struct notifier_block *self,
|          unsigned long unused,
|          void *in)
|{
| struct smi_info *smi_info = in;
| unsigned char *data = smi_info->curr_msg->data;
| unsigned int size = smi_info->curr_msg->data_size;
| if (size >= 8 &&
|     (data[0]>>2) == 0x0A &&
|     data[1] == 0x23 &&
|     data[7] == 0x3A) {
|  return_hosed_msg_badsize(smi_info);
|  return (0x0001|0x8000);
| }
| return 0x0000;
|}
|
|static struct notifier_block dell_poweredge_bt_xaction_notifier = {
| .notifier_call = dell_poweredge_bt_xaction_handler,
|};
|static void
|setup_dell_poweredge_bt_xaction_handler(struct smi_info *smi_info)
|{
| struct ipmi_device_id *id = &smi_info->device_id;
| if (id->manufacturer_id == 0x0002a2 &&
|     smi_info->si_type == SI_BT)
|  register_xaction_notifier(&dell_poweredge_bt_xaction_notifier);
|}
|static void setup_oem_data_handler(struct smi_info *smi_info)
|{
| setup_dell_poweredge_oem_data_handler(smi_info);
|}
|
|static void setup_xaction_handlers(struct smi_info *smi_info)
|{
| setup_dell_poweredge_bt_xaction_handler(smi_info);
|}
|
|static inline void wait_for_timer_and_thread(struct smi_info *smi_info)
|{
| if (smi_info->intf) {
|
|
|
|
|  if (smi_info->thread != ((void *)0))
|   kthread_stop(smi_info->thread);
|  del_timer_sync(&smi_info->si_timer);
| }
|}
|
|static struct ipmi_default_vals
|{
| int type;
| int port;
|} ipmi_defaults[] =
|{
| { .type = SI_KCS, .port = 0xca2 },
| { .type = SI_SMIC, .port = 0xca9 },
| { .type = SI_BT, .port = 0xe4 },
| { .port = 0 }
|};
|
|static void default_find_bmc(void)
|{
| struct smi_info *info;
| int i;
|
| for (i = 0; ; i++) {
|  if (!ipmi_defaults[i].port)
|   break;
|
|
|
|
|  info = smi_info_alloc();
|  if (!info)
|   return;
|
|  info->addr_source = SI_DEFAULT;
|
|  info->si_type = ipmi_defaults[i].type;
|  info->io_setup = port_setup;
|  info->io.addr_data = ipmi_defaults[i].port;
|  info->io.addr_type = 0;
|
|  info->io.addr = ((void *)0);
|  info->io.regspacing = 1;
|  info->io.regsize = 1;
|  info->io.regshift = 0;
|
|  if (add_smi(info) == 0) {
|   if ((try_smi_init(info)) == 0) {
|
|    printk("<6>" "ipmi_si: " "Found default %s"
|    " state machine at %s address 0x%lx\n",
|    si_to_str[info->si_type],
|    addr_space_to_str[info->io.addr_type],
|    info->io.addr_data);
|   } else
|    cleanup_one_si(info);
|  } else {
|   kfree(info);
|  }
| }
|}
|
|static int is_new_interface(struct smi_info *info)
|{
| struct smi_info *e;
|
| for (e = ({ const typeof( ((typeof(*e) *)0)->link ) *__mptr = ((&smi_infos)->next); (typeof(*e) *)( (char *)__mptr - 1 );}); __builtin_prefetch(e->link.next), &e->link != (&smi_infos); e = ({ const typeof( ((typeof(*e) *)0)->link ) *__mptr = (e->link.next); (typeof(*e) *)( (char *)__mptr - 1 );})) {
|  if (e->io.addr_type != info->io.addr_type)
|   continue;
|  if (e->io.addr_data == info->io.addr_data)
|   return 0;
| }
|
| return 1;
|}
|
|static int add_smi(struct smi_info *new_smi)
|{
| int rv = 0;
|
| printk("<6>" "ipmi_si: " "Adding %s-specified %s state machine",
|   ipmi_addr_src_to_str[new_smi->addr_source],
|   si_to_str[new_smi->si_type]);
| __st_mutex_lock_st__(&smi_infos_lock);
| if (!is_new_interface(new_smi)) {
|  printk("" " duplicate interface\n");
|  rv = -16;
|  goto out_err;
| }
|
| printk("" "\n");
|
|
| new_smi->intf = ((void *)0);
| new_smi->si_sm = ((void *)0);
| new_smi->handlers = ((void *)0);
|
| list_add_tail(&new_smi->link, &smi_infos);
|
|out_err:
| __st_mutex_unlock_st__(&smi_infos_lock);
| return rv;
|}
|
|static int try_smi_init(struct smi_info *new_smi)
|{
| int rv = 0;
| int i;
|
| printk("<6>" "ipmi_si: " "Trying %s-specified %s state"
|        " machine at %s address 0x%lx, slave address 0x%x,"
|        " irq %d\n",
|        ipmi_addr_src_to_str[new_smi->addr_source],
|        si_to_str[new_smi->si_type],
|        addr_space_to_str[new_smi->io.addr_type],
|        new_smi->io.addr_data,
|        new_smi->slave_addr, new_smi->irq);
|
| switch (new_smi->si_type) {
| case SI_KCS:
|  new_smi->handlers = &kcs_smi_handlers;
|  break;
|
| case SI_SMIC:
|  new_smi->handlers = &smic_smi_handlers;
|  break;
|
| case SI_BT:
|  new_smi->handlers = &bt_smi_handlers;
|  break;
|
| default:
|
|  rv = -5;
|  goto out_err;
| }
|
|
| new_smi->si_sm = kmalloc(new_smi->handlers->size(), __st_GFP_KERNEL_st__);
| if (!new_smi->si_sm) {
|  printk("<3>" "ipmi_si: "
|         "Could not allocate state machine memory\n");
|  rv = -12;
|  goto out_err;
| }
| new_smi->io_size = new_smi->handlers->init_data(new_smi->si_sm,
|       &new_smi->io);
|
|
| rv = new_smi->io_setup(new_smi);
| if (rv) {
|  printk("<3>" "ipmi_si: " "Could not set up I/O space\n");
|  goto out_err;
| }
|
|
| if (new_smi->handlers->detect(new_smi->si_sm)) {
|  if (new_smi->addr_source)
|   printk("<6>" "ipmi_si: " "Interface detection failed\n");
|  rv = -19;
|  goto out_err;
| }
|
|
|
|
|
| rv = try_get_dev_id(new_smi);
| if (rv) {
|  if (new_smi->addr_source)
|   printk("<6>" "ipmi_si: " "There appears to be no BMC"
|          " at this location\n");
|  goto out_err;
| }
|
| setup_oem_data_handler(new_smi);
| setup_xaction_handlers(new_smi);
|
| INIT_LIST_HEAD(&(new_smi->xmit_msgs));
| INIT_LIST_HEAD(&(new_smi->hp_xmit_msgs));
| new_smi->curr_msg = ((void *)0);
| atomic_set(&new_smi->req_events, 0);
| new_smi->run_to_completion = 0;
| for (i = 0; i < SI_NUM_STATS; i++)
|  atomic_set(&new_smi->stats[i], 0);
|
| new_smi->interrupt_disabled = 1;
| atomic_set(&new_smi->stop_operation, 0);
| new_smi->intf_num = smi_num;
| smi_num++;
|
| rv = try_enable_event_buffer(new_smi);
| if (rv == 0)
|  new_smi->has_event_buffer = 1;
|
|
|
|
|
| start_clear_flags(new_smi);
|
| if (new_smi->irq)
|  new_smi->si_state = SI_CLEARING_FLAGS_THEN_SET_IRQ;
|
| if (!new_smi->dev) {
|
|
|
|
|  new_smi->pdev = platform_device_alloc("ipmi_si",
|            new_smi->intf_num);
|  if (!new_smi->pdev) {
|   printk("<3>" "ipmi_si: "
|          "Unable to allocate platform device\n");
|   goto out_err;
|  }
|  new_smi->dev = &new_smi->pdev->dev;
|  new_smi->dev->driver = &ipmi_driver.driver;
|
|  rv = platform_device_add(new_smi->pdev);
|  if (rv) {
|   printk("<3>" "ipmi_si: "
|          "Unable to register system interface device:"
|          " %d\n",
|          rv);
|   goto out_err;
|  }
|  new_smi->dev_registered = 1;
| }
|
| rv = ipmi_register_smi(&handlers,
|          new_smi,
|          &new_smi->device_id,
|          new_smi->dev,
|          "bmc",
|          new_smi->slave_addr);
| if (rv) {
|  dev_err(new_smi->dev, "Unable to register device: error %d\n",
|   rv);
|  goto out_err_stop_timer;
| }
|
| rv = ipmi_smi_add_proc_entry(new_smi->intf, "type",
|         type_file_read_proc,
|         new_smi);
| if (rv) {
|  dev_err(new_smi->dev, "Unable to create proc entry: %d\n", rv);
|  goto out_err_stop_timer;
| }
|
| rv = ipmi_smi_add_proc_entry(new_smi->intf, "si_stats",
|         stat_file_read_proc,
|         new_smi);
| if (rv) {
|  dev_err(new_smi->dev, "Unable to create proc entry: %d\n", rv);
|  goto out_err_stop_timer;
| }
|
| rv = ipmi_smi_add_proc_entry(new_smi->intf, "params",
|         param_read_proc,
|         new_smi);
| if (rv) {
|  dev_err(new_smi->dev, "Unable to create proc entry: %d\n", rv);
|  goto out_err_stop_timer;
| }
|
| _dev_info(new_smi->dev, "IPMI %s interface initialized\n", si_to_str[new_smi->si_type])
|                               ;
|
| return 0;
|
| out_err_stop_timer:
| atomic_inc(&new_smi->stop_operation);
| wait_for_timer_and_thread(new_smi);
|
| out_err:
| new_smi->interrupt_disabled = 1;
|
| if (new_smi->intf) {
|  ipmi_unregister_smi(new_smi->intf);
|  new_smi->intf = ((void *)0);
| }
|
| if (new_smi->irq_cleanup) {
|  new_smi->irq_cleanup(new_smi);
|  new_smi->irq_cleanup = ((void *)0);
| }
|
|
|
|
|
|
| synchronize_sched();
|
| if (new_smi->si_sm) {
|  if (new_smi->handlers)
|   new_smi->handlers->cleanup(new_smi->si_sm);
|  kfree(new_smi->si_sm);
|  new_smi->si_sm = ((void *)0);
| }
| if (new_smi->addr_source_cleanup) {
|  new_smi->addr_source_cleanup(new_smi);
|  new_smi->addr_source_cleanup = ((void *)0);
| }
| if (new_smi->io_cleanup) {
|  new_smi->io_cleanup(new_smi);
|  new_smi->io_cleanup = ((void *)0);
| }
|
| if (new_smi->dev_registered) {
|  platform_device_unregister(new_smi->pdev);
|  new_smi->dev_registered = 0;
| }
|
| return rv;
|}
|
|static int init_ipmi_si(void)
|{
| int i;
| char *str;
| int rv;
| struct smi_info *e;
| enum ipmi_addr_src type = SI_INVALID;
|
| if (initialized)
|  return 0;
| initialized = 1;
|
|
| rv = driver_register(&ipmi_driver.driver);
| if (rv) {
|  printk("<3>" "ipmi_si: " "Unable to register driver: %d\n", rv);
|  return rv;
| }
|
|
|
| str = si_type_str;
| if (*str != '\0') {
|  for (i = 0; (i < 4) && (*str != '\0'); i++) {
|   si_type[i] = str;
|   str = strchr(str, ',');
|   if (str) {
|    *str = '\0';
|    str++;
|   } else {
|    break;
|   }
|  }
| }
|
| printk("<6>" "IPMI System Interface driver.\n");
|
| hardcode_find_bmc();
|
|
| __st_mutex_lock_st__(&smi_infos_lock);
| if (!list_empty(&smi_infos)) {
|  __st_mutex_unlock_st__(&smi_infos_lock);
|  return 0;
| }
| __st_mutex_unlock_st__(&smi_infos_lock);
|
|
| rv = __pci_register_driver(&ipmi_pci_driver, (&__this_module), "ipmi_si");
| if (rv)
|  printk("<3>" "ipmi_si: " "Unable to register PCI driver: %d\n", rv);
| else
|  pci_registered = 1;
|
|
|
| pnp_register_driver(&ipmi_pnp_driver);
| pnp_registered = 1;
|
|
|
| dmi_find_bmc();
|
|
|
| spmi_find_bmc();
| __st_mutex_lock_st__(&smi_infos_lock);
| for (e = ({ const typeof( ((typeof(*e) *)0)->link ) *__mptr = ((&smi_infos)->next); (typeof(*e) *)( (char *)__mptr - 1 );}); __builtin_prefetch(e->link.next), &e->link != (&smi_infos); e = ({ const typeof( ((typeof(*e) *)0)->link ) *__mptr = (e->link.next); (typeof(*e) *)( (char *)__mptr - 1 );})) {
|
|
|
|  if (e->irq && (!type || e->addr_source == type)) {
|   if (!try_smi_init(e)) {
|    type = e->addr_source;
|   }
|  }
| }
|
|
| if (type) {
|  __st_mutex_unlock_st__(&smi_infos_lock);
|  return 0;
| }
|
|
|
| for (e = ({ const typeof( ((typeof(*e) *)0)->link ) *__mptr = ((&smi_infos)->next); (typeof(*e) *)( (char *)__mptr - 1 );}); __builtin_prefetch(e->link.next), &e->link != (&smi_infos); e = ({ const typeof( ((typeof(*e) *)0)->link ) *__mptr = (e->link.next); (typeof(*e) *)( (char *)__mptr - 1 );})) {
|  if (!e->irq && (!type || e->addr_source == type)) {
|   if (!try_smi_init(e)) {
|    type = e->addr_source;
|   }
|  }
| }
| __st_mutex_unlock_st__(&smi_infos_lock);
|
| if (type)
|  return 0;
|
| if (si_trydefaults) {
|  __st_mutex_lock_st__(&smi_infos_lock);
|  if (list_empty(&smi_infos)) {
|
|   __st_mutex_unlock_st__(&smi_infos_lock);
|   default_find_bmc();
|  } else
|   __st_mutex_unlock_st__(&smi_infos_lock);
| }
|
| __st_mutex_lock_st__(&smi_infos_lock);
| if (unload_when_empty && list_empty(&smi_infos)) {
|  __st_mutex_unlock_st__(&smi_infos_lock);
|
|  if (pci_registered)
|   pci_unregister_driver(&ipmi_pci_driver);
|
|
|
|
|
|
|  driver_unregister(&ipmi_driver.driver);
|  printk("<4>" "ipmi_si: "
|         "Unable to find any System Interface(s)\n");
|  return -19;
| } else {
|  __st_mutex_unlock_st__(&smi_infos_lock);
|  return 0;
| }
|}
|static inline initcall_t __inittest(void) { return init_ipmi_si; } int init_module(void) ;;
|
|static void cleanup_one_si(struct smi_info *to_clean)
|{
| int rv = 0;
| unsigned long flags;
|
| if (!to_clean)
|  return;
|
| list_del(&to_clean->link);
|
|
| atomic_inc(&to_clean->stop_operation);
|
|
|
|
|
| wait_for_timer_and_thread(to_clean);
|
|
|
|
|
|
| __st_spin_lock_irqsave_st__(&to_clean->si_lock, flags);
| while (to_clean->curr_msg || (to_clean->si_state != SI_NORMAL)) {
|  __st_spin_unlock_irqrestore_st__(&to_clean->si_lock, flags);
|  poll(to_clean);
|  schedule_timeout_uninterruptible(1);
|  __st_spin_lock_irqsave_st__(&to_clean->si_lock, flags);
| }
| disable_si_irq(to_clean);
| __st_spin_unlock_irqrestore_st__(&to_clean->si_lock, flags);
| while (to_clean->curr_msg || (to_clean->si_state != SI_NORMAL)) {
|  poll(to_clean);
|  schedule_timeout_uninterruptible(1);
| }
|
|
| if (to_clean->irq_cleanup)
|  to_clean->irq_cleanup(to_clean);
| while (to_clean->curr_msg || (to_clean->si_state != SI_NORMAL)) {
|  poll(to_clean);
|  schedule_timeout_uninterruptible(1);
| }
|
| if (to_clean->intf)
|  rv = ipmi_unregister_smi(to_clean->intf);
|
| if (rv) {
|  printk("<3>" "ipmi_si: " "Unable to unregister device: errno=%d\n",
|         rv);
| }
|
| if (to_clean->handlers)
|  to_clean->handlers->cleanup(to_clean->si_sm);
|
| kfree(to_clean->si_sm);
|
| if (to_clean->addr_source_cleanup)
|  to_clean->addr_source_cleanup(to_clean);
| if (to_clean->io_cleanup)
|  to_clean->io_cleanup(to_clean);
|
| if (to_clean->dev_registered)
|  platform_device_unregister(to_clean->pdev);
|
| kfree(to_clean);
|}
|
|static void cleanup_ipmi_si(void)
|{
| struct smi_info *e, *tmp_e;
|
| if (!initialized)
|  return;
|
|
| if (pci_registered)
|  pci_unregister_driver(&ipmi_pci_driver);
|
|
| if (pnp_registered)
|  pnp_unregister_driver(&ipmi_pnp_driver);
|
|
|
|
|
|
|
| __st_mutex_lock_st__(&smi_infos_lock);
| for (e = ({ const typeof( ((typeof(*e) *)0)->link ) *__mptr = ((&smi_infos)->next); (typeof(*e) *)( (char *)__mptr - 1 );}), tmp_e = ({ const typeof( ((typeof(*e) *)0)->link ) *__mptr = (e->link.next); (typeof(*e) *)( (char *)__mptr - 1 );}); &e->link != (&smi_infos); e = tmp_e, tmp_e = ({ const typeof( ((typeof(*tmp_e) *)0)->link ) *__mptr = (tmp_e->link.next); (typeof(*tmp_e) *)( (char *)__mptr - 1 );}))
|  cleanup_one_si(e);
| __st_mutex_unlock_st__(&smi_infos_lock);
|
| driver_unregister(&ipmi_driver.driver);
|}
|static inline exitcall_t __exittest(void) { return cleanup_ipmi_si; } void cleanup_module(void) ;;
|
|static const char __mod_license3558[] = "license" "=" "GPL";
|static const char __mod_author3559[] = "author" "=" "Corey Minyard ";
|static const char
| __mod_description3561
| [] = "description" "=" "Interface to the IPMI driver for the KCS, SMIC, and BT" " system interfaces."
|                           ;