/drivers/char/ipmi/ipmi_si_intf.c

https://bitbucket.org/ndreys/linux-sunxi · C · 3587 lines · 2596 code · 516 blank · 475 comment · 442 complexity · b3c08cb63e79106bd6485557688e6098 MD5 · raw file

Large files are truncated click here to view the full file

  1. /*
  2. * ipmi_si.c
  3. *
  4. * The interface to the IPMI driver for the system interfaces (KCS, SMIC,
  5. * BT).
  6. *
  7. * Author: MontaVista Software, Inc.
  8. * Corey Minyard <minyard@mvista.com>
  9. * source@mvista.com
  10. *
  11. * Copyright 2002 MontaVista Software Inc.
  12. * Copyright 2006 IBM Corp., Christian Krafft <krafft@de.ibm.com>
  13. *
  14. * This program is free software; you can redistribute it and/or modify it
  15. * under the terms of the GNU General Public License as published by the
  16. * Free Software Foundation; either version 2 of the License, or (at your
  17. * option) any later version.
  18. *
  19. *
  20. * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
  21. * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  22. * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  23. * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  24. * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  25. * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
  26. * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  27. * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
  28. * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  29. * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30. *
  31. * You should have received a copy of the GNU General Public License along
  32. * with this program; if not, write to the Free Software Foundation, Inc.,
  33. * 675 Mass Ave, Cambridge, MA 02139, USA.
  34. */
  35. /*
  36. * This file holds the "policy" for the interface to the SMI state
  37. * machine. It does the configuration, handles timers and interrupts,
  38. * and drives the real SMI state machine.
  39. */
  40. #include <linux/module.h>
  41. #include <linux/moduleparam.h>
  42. #include <asm/system.h>
  43. #include <linux/sched.h>
  44. #include <linux/seq_file.h>
  45. #include <linux/timer.h>
  46. #include <linux/errno.h>
  47. #include <linux/spinlock.h>
  48. #include <linux/slab.h>
  49. #include <linux/delay.h>
  50. #include <linux/list.h>
  51. #include <linux/pci.h>
  52. #include <linux/ioport.h>
  53. #include <linux/notifier.h>
  54. #include <linux/mutex.h>
  55. #include <linux/kthread.h>
  56. #include <asm/irq.h>
  57. #include <linux/interrupt.h>
  58. #include <linux/rcupdate.h>
  59. #include <linux/ipmi.h>
  60. #include <linux/ipmi_smi.h>
  61. #include <asm/io.h>
  62. #include "ipmi_si_sm.h"
  63. #include <linux/init.h>
  64. #include <linux/dmi.h>
  65. #include <linux/string.h>
  66. #include <linux/ctype.h>
  67. #include <linux/pnp.h>
  68. #include <linux/of_device.h>
  69. #include <linux/of_platform.h>
  70. #include <linux/of_address.h>
  71. #include <linux/of_irq.h>
  72. #define PFX "ipmi_si: "
  73. /* Measure times between events in the driver. */
  74. #undef DEBUG_TIMING
  75. /* Call every 10 ms. */
  76. #define SI_TIMEOUT_TIME_USEC 10000
  77. #define SI_USEC_PER_JIFFY (1000000/HZ)
  78. #define SI_TIMEOUT_JIFFIES (SI_TIMEOUT_TIME_USEC/SI_USEC_PER_JIFFY)
  79. #define SI_SHORT_TIMEOUT_USEC 250 /* .25ms when the SM request a
  80. short timeout */
  81. enum si_intf_state {
  82. SI_NORMAL,
  83. SI_GETTING_FLAGS,
  84. SI_GETTING_EVENTS,
  85. SI_CLEARING_FLAGS,
  86. SI_CLEARING_FLAGS_THEN_SET_IRQ,
  87. SI_GETTING_MESSAGES,
  88. SI_ENABLE_INTERRUPTS1,
  89. SI_ENABLE_INTERRUPTS2,
  90. SI_DISABLE_INTERRUPTS1,
  91. SI_DISABLE_INTERRUPTS2
  92. /* FIXME - add watchdog stuff. */
  93. };
  94. /* Some BT-specific defines we need here. */
  95. #define IPMI_BT_INTMASK_REG 2
  96. #define IPMI_BT_INTMASK_CLEAR_IRQ_BIT 2
  97. #define IPMI_BT_INTMASK_ENABLE_IRQ_BIT 1
  98. enum si_type {
  99. SI_KCS, SI_SMIC, SI_BT
  100. };
  101. static char *si_to_str[] = { "kcs", "smic", "bt" };
  102. static char *ipmi_addr_src_to_str[] = { NULL, "hotmod", "hardcoded", "SPMI",
  103. "ACPI", "SMBIOS", "PCI",
  104. "device-tree", "default" };
  105. #define DEVICE_NAME "ipmi_si"
  106. static struct platform_driver ipmi_driver;
  107. /*
  108. * Indexes into stats[] in smi_info below.
  109. */
  110. enum si_stat_indexes {
  111. /*
  112. * Number of times the driver requested a timer while an operation
  113. * was in progress.
  114. */
  115. SI_STAT_short_timeouts = 0,
  116. /*
  117. * Number of times the driver requested a timer while nothing was in
  118. * progress.
  119. */
  120. SI_STAT_long_timeouts,
  121. /* Number of times the interface was idle while being polled. */
  122. SI_STAT_idles,
  123. /* Number of interrupts the driver handled. */
  124. SI_STAT_interrupts,
  125. /* Number of time the driver got an ATTN from the hardware. */
  126. SI_STAT_attentions,
  127. /* Number of times the driver requested flags from the hardware. */
  128. SI_STAT_flag_fetches,
  129. /* Number of times the hardware didn't follow the state machine. */
  130. SI_STAT_hosed_count,
  131. /* Number of completed messages. */
  132. SI_STAT_complete_transactions,
  133. /* Number of IPMI events received from the hardware. */
  134. SI_STAT_events,
  135. /* Number of watchdog pretimeouts. */
  136. SI_STAT_watchdog_pretimeouts,
  137. /* Number of asyncronous messages received. */
  138. SI_STAT_incoming_messages,
  139. /* This *must* remain last, add new values above this. */
  140. SI_NUM_STATS
  141. };
  142. struct smi_info {
  143. int intf_num;
  144. ipmi_smi_t intf;
  145. struct si_sm_data *si_sm;
  146. struct si_sm_handlers *handlers;
  147. enum si_type si_type;
  148. spinlock_t si_lock;
  149. spinlock_t msg_lock;
  150. struct list_head xmit_msgs;
  151. struct list_head hp_xmit_msgs;
  152. struct ipmi_smi_msg *curr_msg;
  153. enum si_intf_state si_state;
  154. /*
  155. * Used to handle the various types of I/O that can occur with
  156. * IPMI
  157. */
  158. struct si_sm_io io;
  159. int (*io_setup)(struct smi_info *info);
  160. void (*io_cleanup)(struct smi_info *info);
  161. int (*irq_setup)(struct smi_info *info);
  162. void (*irq_cleanup)(struct smi_info *info);
  163. unsigned int io_size;
  164. enum ipmi_addr_src addr_source; /* ACPI, PCI, SMBIOS, hardcode, etc. */
  165. void (*addr_source_cleanup)(struct smi_info *info);
  166. void *addr_source_data;
  167. /*
  168. * Per-OEM handler, called from handle_flags(). Returns 1
  169. * when handle_flags() needs to be re-run or 0 indicating it
  170. * set si_state itself.
  171. */
  172. int (*oem_data_avail_handler)(struct smi_info *smi_info);
  173. /*
  174. * Flags from the last GET_MSG_FLAGS command, used when an ATTN
  175. * is set to hold the flags until we are done handling everything
  176. * from the flags.
  177. */
  178. #define RECEIVE_MSG_AVAIL 0x01
  179. #define EVENT_MSG_BUFFER_FULL 0x02
  180. #define WDT_PRE_TIMEOUT_INT 0x08
  181. #define OEM0_DATA_AVAIL 0x20
  182. #define OEM1_DATA_AVAIL 0x40
  183. #define OEM2_DATA_AVAIL 0x80
  184. #define OEM_DATA_AVAIL (OEM0_DATA_AVAIL | \
  185. OEM1_DATA_AVAIL | \
  186. OEM2_DATA_AVAIL)
  187. unsigned char msg_flags;
  188. /* Does the BMC have an event buffer? */
  189. char has_event_buffer;
  190. /*
  191. * If set to true, this will request events the next time the
  192. * state machine is idle.
  193. */
  194. atomic_t req_events;
  195. /*
  196. * If true, run the state machine to completion on every send
  197. * call. Generally used after a panic to make sure stuff goes
  198. * out.
  199. */
  200. int run_to_completion;
  201. /* The I/O port of an SI interface. */
  202. int port;
  203. /*
  204. * The space between start addresses of the two ports. For
  205. * instance, if the first port is 0xca2 and the spacing is 4, then
  206. * the second port is 0xca6.
  207. */
  208. unsigned int spacing;
  209. /* zero if no irq; */
  210. int irq;
  211. /* The timer for this si. */
  212. struct timer_list si_timer;
  213. /* The time (in jiffies) the last timeout occurred at. */
  214. unsigned long last_timeout_jiffies;
  215. /* Used to gracefully stop the timer without race conditions. */
  216. atomic_t stop_operation;
  217. /*
  218. * The driver will disable interrupts when it gets into a
  219. * situation where it cannot handle messages due to lack of
  220. * memory. Once that situation clears up, it will re-enable
  221. * interrupts.
  222. */
  223. int interrupt_disabled;
  224. /* From the get device id response... */
  225. struct ipmi_device_id device_id;
  226. /* Driver model stuff. */
  227. struct device *dev;
  228. struct platform_device *pdev;
  229. /*
  230. * True if we allocated the device, false if it came from
  231. * someplace else (like PCI).
  232. */
  233. int dev_registered;
  234. /* Slave address, could be reported from DMI. */
  235. unsigned char slave_addr;
  236. /* Counters and things for the proc filesystem. */
  237. atomic_t stats[SI_NUM_STATS];
  238. struct task_struct *thread;
  239. struct list_head link;
  240. union ipmi_smi_info_union addr_info;
  241. };
  242. #define smi_inc_stat(smi, stat) \
  243. atomic_inc(&(smi)->stats[SI_STAT_ ## stat])
  244. #define smi_get_stat(smi, stat) \
  245. ((unsigned int) atomic_read(&(smi)->stats[SI_STAT_ ## stat]))
  246. #define SI_MAX_PARMS 4
  247. static int force_kipmid[SI_MAX_PARMS];
  248. static int num_force_kipmid;
  249. #ifdef CONFIG_PCI
  250. static int pci_registered;
  251. #endif
  252. #ifdef CONFIG_ACPI
  253. static int pnp_registered;
  254. #endif
  255. static unsigned int kipmid_max_busy_us[SI_MAX_PARMS];
  256. static int num_max_busy_us;
  257. static int unload_when_empty = 1;
  258. static int add_smi(struct smi_info *smi);
  259. static int try_smi_init(struct smi_info *smi);
  260. static void cleanup_one_si(struct smi_info *to_clean);
  261. static void cleanup_ipmi_si(void);
  262. static ATOMIC_NOTIFIER_HEAD(xaction_notifier_list);
  263. static int register_xaction_notifier(struct notifier_block *nb)
  264. {
  265. return atomic_notifier_chain_register(&xaction_notifier_list, nb);
  266. }
  267. static void deliver_recv_msg(struct smi_info *smi_info,
  268. struct ipmi_smi_msg *msg)
  269. {
  270. /* Deliver the message to the upper layer with the lock
  271. released. */
  272. if (smi_info->run_to_completion) {
  273. ipmi_smi_msg_received(smi_info->intf, msg);
  274. } else {
  275. spin_unlock(&(smi_info->si_lock));
  276. ipmi_smi_msg_received(smi_info->intf, msg);
  277. spin_lock(&(smi_info->si_lock));
  278. }
  279. }
  280. static void return_hosed_msg(struct smi_info *smi_info, int cCode)
  281. {
  282. struct ipmi_smi_msg *msg = smi_info->curr_msg;
  283. if (cCode < 0 || cCode > IPMI_ERR_UNSPECIFIED)
  284. cCode = IPMI_ERR_UNSPECIFIED;
  285. /* else use it as is */
  286. /* Make it a response */
  287. msg->rsp[0] = msg->data[0] | 4;
  288. msg->rsp[1] = msg->data[1];
  289. msg->rsp[2] = cCode;
  290. msg->rsp_size = 3;
  291. smi_info->curr_msg = NULL;
  292. deliver_recv_msg(smi_info, msg);
  293. }
  294. static enum si_sm_result start_next_msg(struct smi_info *smi_info)
  295. {
  296. int rv;
  297. struct list_head *entry = NULL;
  298. #ifdef DEBUG_TIMING
  299. struct timeval t;
  300. #endif
  301. /*
  302. * No need to save flags, we aleady have interrupts off and we
  303. * already hold the SMI lock.
  304. */
  305. if (!smi_info->run_to_completion)
  306. spin_lock(&(smi_info->msg_lock));
  307. /* Pick the high priority queue first. */
  308. if (!list_empty(&(smi_info->hp_xmit_msgs))) {
  309. entry = smi_info->hp_xmit_msgs.next;
  310. } else if (!list_empty(&(smi_info->xmit_msgs))) {
  311. entry = smi_info->xmit_msgs.next;
  312. }
  313. if (!entry) {
  314. smi_info->curr_msg = NULL;
  315. rv = SI_SM_IDLE;
  316. } else {
  317. int err;
  318. list_del(entry);
  319. smi_info->curr_msg = list_entry(entry,
  320. struct ipmi_smi_msg,
  321. link);
  322. #ifdef DEBUG_TIMING
  323. do_gettimeofday(&t);
  324. printk(KERN_DEBUG "**Start2: %d.%9.9d\n", t.tv_sec, t.tv_usec);
  325. #endif
  326. err = atomic_notifier_call_chain(&xaction_notifier_list,
  327. 0, smi_info);
  328. if (err & NOTIFY_STOP_MASK) {
  329. rv = SI_SM_CALL_WITHOUT_DELAY;
  330. goto out;
  331. }
  332. err = smi_info->handlers->start_transaction(
  333. smi_info->si_sm,
  334. smi_info->curr_msg->data,
  335. smi_info->curr_msg->data_size);
  336. if (err)
  337. return_hosed_msg(smi_info, err);
  338. rv = SI_SM_CALL_WITHOUT_DELAY;
  339. }
  340. out:
  341. if (!smi_info->run_to_completion)
  342. spin_unlock(&(smi_info->msg_lock));
  343. return rv;
  344. }
  345. static void start_enable_irq(struct smi_info *smi_info)
  346. {
  347. unsigned char msg[2];
  348. /*
  349. * If we are enabling interrupts, we have to tell the
  350. * BMC to use them.
  351. */
  352. msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
  353. msg[1] = IPMI_GET_BMC_GLOBAL_ENABLES_CMD;
  354. smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
  355. smi_info->si_state = SI_ENABLE_INTERRUPTS1;
  356. }
  357. static void start_disable_irq(struct smi_info *smi_info)
  358. {
  359. unsigned char msg[2];
  360. msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
  361. msg[1] = IPMI_GET_BMC_GLOBAL_ENABLES_CMD;
  362. smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
  363. smi_info->si_state = SI_DISABLE_INTERRUPTS1;
  364. }
  365. static void start_clear_flags(struct smi_info *smi_info)
  366. {
  367. unsigned char msg[3];
  368. /* Make sure the watchdog pre-timeout flag is not set at startup. */
  369. msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
  370. msg[1] = IPMI_CLEAR_MSG_FLAGS_CMD;
  371. msg[2] = WDT_PRE_TIMEOUT_INT;
  372. smi_info->handlers->start_transaction(smi_info->si_sm, msg, 3);
  373. smi_info->si_state = SI_CLEARING_FLAGS;
  374. }
  375. /*
  376. * When we have a situtaion where we run out of memory and cannot
  377. * allocate messages, we just leave them in the BMC and run the system
  378. * polled until we can allocate some memory. Once we have some
  379. * memory, we will re-enable the interrupt.
  380. */
  381. static inline void disable_si_irq(struct smi_info *smi_info)
  382. {
  383. if ((smi_info->irq) && (!smi_info->interrupt_disabled)) {
  384. start_disable_irq(smi_info);
  385. smi_info->interrupt_disabled = 1;
  386. if (!atomic_read(&smi_info->stop_operation))
  387. mod_timer(&smi_info->si_timer,
  388. jiffies + SI_TIMEOUT_JIFFIES);
  389. }
  390. }
  391. static inline void enable_si_irq(struct smi_info *smi_info)
  392. {
  393. if ((smi_info->irq) && (smi_info->interrupt_disabled)) {
  394. start_enable_irq(smi_info);
  395. smi_info->interrupt_disabled = 0;
  396. }
  397. }
  398. static void handle_flags(struct smi_info *smi_info)
  399. {
  400. retry:
  401. if (smi_info->msg_flags & WDT_PRE_TIMEOUT_INT) {
  402. /* Watchdog pre-timeout */
  403. smi_inc_stat(smi_info, watchdog_pretimeouts);
  404. start_clear_flags(smi_info);
  405. smi_info->msg_flags &= ~WDT_PRE_TIMEOUT_INT;
  406. spin_unlock(&(smi_info->si_lock));
  407. ipmi_smi_watchdog_pretimeout(smi_info->intf);
  408. spin_lock(&(smi_info->si_lock));
  409. } else if (smi_info->msg_flags & RECEIVE_MSG_AVAIL) {
  410. /* Messages available. */
  411. smi_info->curr_msg = ipmi_alloc_smi_msg();
  412. if (!smi_info->curr_msg) {
  413. disable_si_irq(smi_info);
  414. smi_info->si_state = SI_NORMAL;
  415. return;
  416. }
  417. enable_si_irq(smi_info);
  418. smi_info->curr_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2);
  419. smi_info->curr_msg->data[1] = IPMI_GET_MSG_CMD;
  420. smi_info->curr_msg->data_size = 2;
  421. smi_info->handlers->start_transaction(
  422. smi_info->si_sm,
  423. smi_info->curr_msg->data,
  424. smi_info->curr_msg->data_size);
  425. smi_info->si_state = SI_GETTING_MESSAGES;
  426. } else if (smi_info->msg_flags & EVENT_MSG_BUFFER_FULL) {
  427. /* Events available. */
  428. smi_info->curr_msg = ipmi_alloc_smi_msg();
  429. if (!smi_info->curr_msg) {
  430. disable_si_irq(smi_info);
  431. smi_info->si_state = SI_NORMAL;
  432. return;
  433. }
  434. enable_si_irq(smi_info);
  435. smi_info->curr_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2);
  436. smi_info->curr_msg->data[1] = IPMI_READ_EVENT_MSG_BUFFER_CMD;
  437. smi_info->curr_msg->data_size = 2;
  438. smi_info->handlers->start_transaction(
  439. smi_info->si_sm,
  440. smi_info->curr_msg->data,
  441. smi_info->curr_msg->data_size);
  442. smi_info->si_state = SI_GETTING_EVENTS;
  443. } else if (smi_info->msg_flags & OEM_DATA_AVAIL &&
  444. smi_info->oem_data_avail_handler) {
  445. if (smi_info->oem_data_avail_handler(smi_info))
  446. goto retry;
  447. } else
  448. smi_info->si_state = SI_NORMAL;
  449. }
  450. static void handle_transaction_done(struct smi_info *smi_info)
  451. {
  452. struct ipmi_smi_msg *msg;
  453. #ifdef DEBUG_TIMING
  454. struct timeval t;
  455. do_gettimeofday(&t);
  456. printk(KERN_DEBUG "**Done: %d.%9.9d\n", t.tv_sec, t.tv_usec);
  457. #endif
  458. switch (smi_info->si_state) {
  459. case SI_NORMAL:
  460. if (!smi_info->curr_msg)
  461. break;
  462. smi_info->curr_msg->rsp_size
  463. = smi_info->handlers->get_result(
  464. smi_info->si_sm,
  465. smi_info->curr_msg->rsp,
  466. IPMI_MAX_MSG_LENGTH);
  467. /*
  468. * Do this here becase deliver_recv_msg() releases the
  469. * lock, and a new message can be put in during the
  470. * time the lock is released.
  471. */
  472. msg = smi_info->curr_msg;
  473. smi_info->curr_msg = NULL;
  474. deliver_recv_msg(smi_info, msg);
  475. break;
  476. case SI_GETTING_FLAGS:
  477. {
  478. unsigned char msg[4];
  479. unsigned int len;
  480. /* We got the flags from the SMI, now handle them. */
  481. len = smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
  482. if (msg[2] != 0) {
  483. /* Error fetching flags, just give up for now. */
  484. smi_info->si_state = SI_NORMAL;
  485. } else if (len < 4) {
  486. /*
  487. * Hmm, no flags. That's technically illegal, but
  488. * don't use uninitialized data.
  489. */
  490. smi_info->si_state = SI_NORMAL;
  491. } else {
  492. smi_info->msg_flags = msg[3];
  493. handle_flags(smi_info);
  494. }
  495. break;
  496. }
  497. case SI_CLEARING_FLAGS:
  498. case SI_CLEARING_FLAGS_THEN_SET_IRQ:
  499. {
  500. unsigned char msg[3];
  501. /* We cleared the flags. */
  502. smi_info->handlers->get_result(smi_info->si_sm, msg, 3);
  503. if (msg[2] != 0) {
  504. /* Error clearing flags */
  505. dev_warn(smi_info->dev,
  506. "Error clearing flags: %2.2x\n", msg[2]);
  507. }
  508. if (smi_info->si_state == SI_CLEARING_FLAGS_THEN_SET_IRQ)
  509. start_enable_irq(smi_info);
  510. else
  511. smi_info->si_state = SI_NORMAL;
  512. break;
  513. }
  514. case SI_GETTING_EVENTS:
  515. {
  516. smi_info->curr_msg->rsp_size
  517. = smi_info->handlers->get_result(
  518. smi_info->si_sm,
  519. smi_info->curr_msg->rsp,
  520. IPMI_MAX_MSG_LENGTH);
  521. /*
  522. * Do this here becase deliver_recv_msg() releases the
  523. * lock, and a new message can be put in during the
  524. * time the lock is released.
  525. */
  526. msg = smi_info->curr_msg;
  527. smi_info->curr_msg = NULL;
  528. if (msg->rsp[2] != 0) {
  529. /* Error getting event, probably done. */
  530. msg->done(msg);
  531. /* Take off the event flag. */
  532. smi_info->msg_flags &= ~EVENT_MSG_BUFFER_FULL;
  533. handle_flags(smi_info);
  534. } else {
  535. smi_inc_stat(smi_info, events);
  536. /*
  537. * Do this before we deliver the message
  538. * because delivering the message releases the
  539. * lock and something else can mess with the
  540. * state.
  541. */
  542. handle_flags(smi_info);
  543. deliver_recv_msg(smi_info, msg);
  544. }
  545. break;
  546. }
  547. case SI_GETTING_MESSAGES:
  548. {
  549. smi_info->curr_msg->rsp_size
  550. = smi_info->handlers->get_result(
  551. smi_info->si_sm,
  552. smi_info->curr_msg->rsp,
  553. IPMI_MAX_MSG_LENGTH);
  554. /*
  555. * Do this here becase deliver_recv_msg() releases the
  556. * lock, and a new message can be put in during the
  557. * time the lock is released.
  558. */
  559. msg = smi_info->curr_msg;
  560. smi_info->curr_msg = NULL;
  561. if (msg->rsp[2] != 0) {
  562. /* Error getting event, probably done. */
  563. msg->done(msg);
  564. /* Take off the msg flag. */
  565. smi_info->msg_flags &= ~RECEIVE_MSG_AVAIL;
  566. handle_flags(smi_info);
  567. } else {
  568. smi_inc_stat(smi_info, incoming_messages);
  569. /*
  570. * Do this before we deliver the message
  571. * because delivering the message releases the
  572. * lock and something else can mess with the
  573. * state.
  574. */
  575. handle_flags(smi_info);
  576. deliver_recv_msg(smi_info, msg);
  577. }
  578. break;
  579. }
  580. case SI_ENABLE_INTERRUPTS1:
  581. {
  582. unsigned char msg[4];
  583. /* We got the flags from the SMI, now handle them. */
  584. smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
  585. if (msg[2] != 0) {
  586. dev_warn(smi_info->dev, "Could not enable interrupts"
  587. ", failed get, using polled mode.\n");
  588. smi_info->si_state = SI_NORMAL;
  589. } else {
  590. msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
  591. msg[1] = IPMI_SET_BMC_GLOBAL_ENABLES_CMD;
  592. msg[2] = (msg[3] |
  593. IPMI_BMC_RCV_MSG_INTR |
  594. IPMI_BMC_EVT_MSG_INTR);
  595. smi_info->handlers->start_transaction(
  596. smi_info->si_sm, msg, 3);
  597. smi_info->si_state = SI_ENABLE_INTERRUPTS2;
  598. }
  599. break;
  600. }
  601. case SI_ENABLE_INTERRUPTS2:
  602. {
  603. unsigned char msg[4];
  604. /* We got the flags from the SMI, now handle them. */
  605. smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
  606. if (msg[2] != 0)
  607. dev_warn(smi_info->dev, "Could not enable interrupts"
  608. ", failed set, using polled mode.\n");
  609. else
  610. smi_info->interrupt_disabled = 0;
  611. smi_info->si_state = SI_NORMAL;
  612. break;
  613. }
  614. case SI_DISABLE_INTERRUPTS1:
  615. {
  616. unsigned char msg[4];
  617. /* We got the flags from the SMI, now handle them. */
  618. smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
  619. if (msg[2] != 0) {
  620. dev_warn(smi_info->dev, "Could not disable interrupts"
  621. ", failed get.\n");
  622. smi_info->si_state = SI_NORMAL;
  623. } else {
  624. msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
  625. msg[1] = IPMI_SET_BMC_GLOBAL_ENABLES_CMD;
  626. msg[2] = (msg[3] &
  627. ~(IPMI_BMC_RCV_MSG_INTR |
  628. IPMI_BMC_EVT_MSG_INTR));
  629. smi_info->handlers->start_transaction(
  630. smi_info->si_sm, msg, 3);
  631. smi_info->si_state = SI_DISABLE_INTERRUPTS2;
  632. }
  633. break;
  634. }
  635. case SI_DISABLE_INTERRUPTS2:
  636. {
  637. unsigned char msg[4];
  638. /* We got the flags from the SMI, now handle them. */
  639. smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
  640. if (msg[2] != 0) {
  641. dev_warn(smi_info->dev, "Could not disable interrupts"
  642. ", failed set.\n");
  643. }
  644. smi_info->si_state = SI_NORMAL;
  645. break;
  646. }
  647. }
  648. }
  649. /*
  650. * Called on timeouts and events. Timeouts should pass the elapsed
  651. * time, interrupts should pass in zero. Must be called with
  652. * si_lock held and interrupts disabled.
  653. */
  654. static enum si_sm_result smi_event_handler(struct smi_info *smi_info,
  655. int time)
  656. {
  657. enum si_sm_result si_sm_result;
  658. restart:
  659. /*
  660. * There used to be a loop here that waited a little while
  661. * (around 25us) before giving up. That turned out to be
  662. * pointless, the minimum delays I was seeing were in the 300us
  663. * range, which is far too long to wait in an interrupt. So
  664. * we just run until the state machine tells us something
  665. * happened or it needs a delay.
  666. */
  667. si_sm_result = smi_info->handlers->event(smi_info->si_sm, time);
  668. time = 0;
  669. while (si_sm_result == SI_SM_CALL_WITHOUT_DELAY)
  670. si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
  671. if (si_sm_result == SI_SM_TRANSACTION_COMPLETE) {
  672. smi_inc_stat(smi_info, complete_transactions);
  673. handle_transaction_done(smi_info);
  674. si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
  675. } else if (si_sm_result == SI_SM_HOSED) {
  676. smi_inc_stat(smi_info, hosed_count);
  677. /*
  678. * Do the before return_hosed_msg, because that
  679. * releases the lock.
  680. */
  681. smi_info->si_state = SI_NORMAL;
  682. if (smi_info->curr_msg != NULL) {
  683. /*
  684. * If we were handling a user message, format
  685. * a response to send to the upper layer to
  686. * tell it about the error.
  687. */
  688. return_hosed_msg(smi_info, IPMI_ERR_UNSPECIFIED);
  689. }
  690. si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
  691. }
  692. /*
  693. * We prefer handling attn over new messages. But don't do
  694. * this if there is not yet an upper layer to handle anything.
  695. */
  696. if (likely(smi_info->intf) && si_sm_result == SI_SM_ATTN) {
  697. unsigned char msg[2];
  698. smi_inc_stat(smi_info, attentions);
  699. /*
  700. * Got a attn, send down a get message flags to see
  701. * what's causing it. It would be better to handle
  702. * this in the upper layer, but due to the way
  703. * interrupts work with the SMI, that's not really
  704. * possible.
  705. */
  706. msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
  707. msg[1] = IPMI_GET_MSG_FLAGS_CMD;
  708. smi_info->handlers->start_transaction(
  709. smi_info->si_sm, msg, 2);
  710. smi_info->si_state = SI_GETTING_FLAGS;
  711. goto restart;
  712. }
  713. /* If we are currently idle, try to start the next message. */
  714. if (si_sm_result == SI_SM_IDLE) {
  715. smi_inc_stat(smi_info, idles);
  716. si_sm_result = start_next_msg(smi_info);
  717. if (si_sm_result != SI_SM_IDLE)
  718. goto restart;
  719. }
  720. if ((si_sm_result == SI_SM_IDLE)
  721. && (atomic_read(&smi_info->req_events))) {
  722. /*
  723. * We are idle and the upper layer requested that I fetch
  724. * events, so do so.
  725. */
  726. atomic_set(&smi_info->req_events, 0);
  727. smi_info->curr_msg = ipmi_alloc_smi_msg();
  728. if (!smi_info->curr_msg)
  729. goto out;
  730. smi_info->curr_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2);
  731. smi_info->curr_msg->data[1] = IPMI_READ_EVENT_MSG_BUFFER_CMD;
  732. smi_info->curr_msg->data_size = 2;
  733. smi_info->handlers->start_transaction(
  734. smi_info->si_sm,
  735. smi_info->curr_msg->data,
  736. smi_info->curr_msg->data_size);
  737. smi_info->si_state = SI_GETTING_EVENTS;
  738. goto restart;
  739. }
  740. out:
  741. return si_sm_result;
  742. }
  743. static void sender(void *send_info,
  744. struct ipmi_smi_msg *msg,
  745. int priority)
  746. {
  747. struct smi_info *smi_info = send_info;
  748. enum si_sm_result result;
  749. unsigned long flags;
  750. #ifdef DEBUG_TIMING
  751. struct timeval t;
  752. #endif
  753. if (atomic_read(&smi_info->stop_operation)) {
  754. msg->rsp[0] = msg->data[0] | 4;
  755. msg->rsp[1] = msg->data[1];
  756. msg->rsp[2] = IPMI_ERR_UNSPECIFIED;
  757. msg->rsp_size = 3;
  758. deliver_recv_msg(smi_info, msg);
  759. return;
  760. }
  761. #ifdef DEBUG_TIMING
  762. do_gettimeofday(&t);
  763. printk("**Enqueue: %d.%9.9d\n", t.tv_sec, t.tv_usec);
  764. #endif
  765. /*
  766. * last_timeout_jiffies is updated here to avoid
  767. * smi_timeout() handler passing very large time_diff
  768. * value to smi_event_handler() that causes
  769. * the send command to abort.
  770. */
  771. smi_info->last_timeout_jiffies = jiffies;
  772. mod_timer(&smi_info->si_timer, jiffies + SI_TIMEOUT_JIFFIES);
  773. if (smi_info->thread)
  774. wake_up_process(smi_info->thread);
  775. if (smi_info->run_to_completion) {
  776. /*
  777. * If we are running to completion, then throw it in
  778. * the list and run transactions until everything is
  779. * clear. Priority doesn't matter here.
  780. */
  781. /*
  782. * Run to completion means we are single-threaded, no
  783. * need for locks.
  784. */
  785. list_add_tail(&(msg->link), &(smi_info->xmit_msgs));
  786. result = smi_event_handler(smi_info, 0);
  787. while (result != SI_SM_IDLE) {
  788. udelay(SI_SHORT_TIMEOUT_USEC);
  789. result = smi_event_handler(smi_info,
  790. SI_SHORT_TIMEOUT_USEC);
  791. }
  792. return;
  793. }
  794. spin_lock_irqsave(&smi_info->msg_lock, flags);
  795. if (priority > 0)
  796. list_add_tail(&msg->link, &smi_info->hp_xmit_msgs);
  797. else
  798. list_add_tail(&msg->link, &smi_info->xmit_msgs);
  799. spin_unlock_irqrestore(&smi_info->msg_lock, flags);
  800. spin_lock_irqsave(&smi_info->si_lock, flags);
  801. if (smi_info->si_state == SI_NORMAL && smi_info->curr_msg == NULL)
  802. start_next_msg(smi_info);
  803. spin_unlock_irqrestore(&smi_info->si_lock, flags);
  804. }
  805. static void set_run_to_completion(void *send_info, int i_run_to_completion)
  806. {
  807. struct smi_info *smi_info = send_info;
  808. enum si_sm_result result;
  809. smi_info->run_to_completion = i_run_to_completion;
  810. if (i_run_to_completion) {
  811. result = smi_event_handler(smi_info, 0);
  812. while (result != SI_SM_IDLE) {
  813. udelay(SI_SHORT_TIMEOUT_USEC);
  814. result = smi_event_handler(smi_info,
  815. SI_SHORT_TIMEOUT_USEC);
  816. }
  817. }
  818. }
  819. /*
  820. * Use -1 in the nsec value of the busy waiting timespec to tell that
  821. * we are spinning in kipmid looking for something and not delaying
  822. * between checks
  823. */
  824. static inline void ipmi_si_set_not_busy(struct timespec *ts)
  825. {
  826. ts->tv_nsec = -1;
  827. }
  828. static inline int ipmi_si_is_busy(struct timespec *ts)
  829. {
  830. return ts->tv_nsec != -1;
  831. }
  832. static int ipmi_thread_busy_wait(enum si_sm_result smi_result,
  833. const struct smi_info *smi_info,
  834. struct timespec *busy_until)
  835. {
  836. unsigned int max_busy_us = 0;
  837. if (smi_info->intf_num < num_max_busy_us)
  838. max_busy_us = kipmid_max_busy_us[smi_info->intf_num];
  839. if (max_busy_us == 0 || smi_result != SI_SM_CALL_WITH_DELAY)
  840. ipmi_si_set_not_busy(busy_until);
  841. else if (!ipmi_si_is_busy(busy_until)) {
  842. getnstimeofday(busy_until);
  843. timespec_add_ns(busy_until, max_busy_us*NSEC_PER_USEC);
  844. } else {
  845. struct timespec now;
  846. getnstimeofday(&now);
  847. if (unlikely(timespec_compare(&now, busy_until) > 0)) {
  848. ipmi_si_set_not_busy(busy_until);
  849. return 0;
  850. }
  851. }
  852. return 1;
  853. }
  854. /*
  855. * A busy-waiting loop for speeding up IPMI operation.
  856. *
  857. * Lousy hardware makes this hard. This is only enabled for systems
  858. * that are not BT and do not have interrupts. It starts spinning
  859. * when an operation is complete or until max_busy tells it to stop
  860. * (if that is enabled). See the paragraph on kimid_max_busy_us in
  861. * Documentation/IPMI.txt for details.
  862. */
  863. static int ipmi_thread(void *data)
  864. {
  865. struct smi_info *smi_info = data;
  866. unsigned long flags;
  867. enum si_sm_result smi_result;
  868. struct timespec busy_until;
  869. ipmi_si_set_not_busy(&busy_until);
  870. set_user_nice(current, 19);
  871. while (!kthread_should_stop()) {
  872. int busy_wait;
  873. spin_lock_irqsave(&(smi_info->si_lock), flags);
  874. smi_result = smi_event_handler(smi_info, 0);
  875. spin_unlock_irqrestore(&(smi_info->si_lock), flags);
  876. busy_wait = ipmi_thread_busy_wait(smi_result, smi_info,
  877. &busy_until);
  878. if (smi_result == SI_SM_CALL_WITHOUT_DELAY)
  879. ; /* do nothing */
  880. else if (smi_result == SI_SM_CALL_WITH_DELAY && busy_wait)
  881. schedule();
  882. else if (smi_result == SI_SM_IDLE)
  883. schedule_timeout_interruptible(100);
  884. else
  885. schedule_timeout_interruptible(1);
  886. }
  887. return 0;
  888. }
  889. static void poll(void *send_info)
  890. {
  891. struct smi_info *smi_info = send_info;
  892. unsigned long flags;
  893. /*
  894. * Make sure there is some delay in the poll loop so we can
  895. * drive time forward and timeout things.
  896. */
  897. udelay(10);
  898. spin_lock_irqsave(&smi_info->si_lock, flags);
  899. smi_event_handler(smi_info, 10);
  900. spin_unlock_irqrestore(&smi_info->si_lock, flags);
  901. }
  902. static void request_events(void *send_info)
  903. {
  904. struct smi_info *smi_info = send_info;
  905. if (atomic_read(&smi_info->stop_operation) ||
  906. !smi_info->has_event_buffer)
  907. return;
  908. atomic_set(&smi_info->req_events, 1);
  909. }
  910. static int initialized;
  911. static void smi_timeout(unsigned long data)
  912. {
  913. struct smi_info *smi_info = (struct smi_info *) data;
  914. enum si_sm_result smi_result;
  915. unsigned long flags;
  916. unsigned long jiffies_now;
  917. long time_diff;
  918. long timeout;
  919. #ifdef DEBUG_TIMING
  920. struct timeval t;
  921. #endif
  922. spin_lock_irqsave(&(smi_info->si_lock), flags);
  923. #ifdef DEBUG_TIMING
  924. do_gettimeofday(&t);
  925. printk(KERN_DEBUG "**Timer: %d.%9.9d\n", t.tv_sec, t.tv_usec);
  926. #endif
  927. jiffies_now = jiffies;
  928. time_diff = (((long)jiffies_now - (long)smi_info->last_timeout_jiffies)
  929. * SI_USEC_PER_JIFFY);
  930. smi_result = smi_event_handler(smi_info, time_diff);
  931. spin_unlock_irqrestore(&(smi_info->si_lock), flags);
  932. smi_info->last_timeout_jiffies = jiffies_now;
  933. if ((smi_info->irq) && (!smi_info->interrupt_disabled)) {
  934. /* Running with interrupts, only do long timeouts. */
  935. timeout = jiffies + SI_TIMEOUT_JIFFIES;
  936. smi_inc_stat(smi_info, long_timeouts);
  937. goto do_mod_timer;
  938. }
  939. /*
  940. * If the state machine asks for a short delay, then shorten
  941. * the timer timeout.
  942. */
  943. if (smi_result == SI_SM_CALL_WITH_DELAY) {
  944. smi_inc_stat(smi_info, short_timeouts);
  945. timeout = jiffies + 1;
  946. } else {
  947. smi_inc_stat(smi_info, long_timeouts);
  948. timeout = jiffies + SI_TIMEOUT_JIFFIES;
  949. }
  950. do_mod_timer:
  951. if (smi_result != SI_SM_IDLE)
  952. mod_timer(&(smi_info->si_timer), timeout);
  953. }
  954. static irqreturn_t si_irq_handler(int irq, void *data)
  955. {
  956. struct smi_info *smi_info = data;
  957. unsigned long flags;
  958. #ifdef DEBUG_TIMING
  959. struct timeval t;
  960. #endif
  961. spin_lock_irqsave(&(smi_info->si_lock), flags);
  962. smi_inc_stat(smi_info, interrupts);
  963. #ifdef DEBUG_TIMING
  964. do_gettimeofday(&t);
  965. printk(KERN_DEBUG "**Interrupt: %d.%9.9d\n", t.tv_sec, t.tv_usec);
  966. #endif
  967. smi_event_handler(smi_info, 0);
  968. spin_unlock_irqrestore(&(smi_info->si_lock), flags);
  969. return IRQ_HANDLED;
  970. }
  971. static irqreturn_t si_bt_irq_handler(int irq, void *data)
  972. {
  973. struct smi_info *smi_info = data;
  974. /* We need to clear the IRQ flag for the BT interface. */
  975. smi_info->io.outputb(&smi_info->io, IPMI_BT_INTMASK_REG,
  976. IPMI_BT_INTMASK_CLEAR_IRQ_BIT
  977. | IPMI_BT_INTMASK_ENABLE_IRQ_BIT);
  978. return si_irq_handler(irq, data);
  979. }
  980. static int smi_start_processing(void *send_info,
  981. ipmi_smi_t intf)
  982. {
  983. struct smi_info *new_smi = send_info;
  984. int enable = 0;
  985. new_smi->intf = intf;
  986. /* Try to claim any interrupts. */
  987. if (new_smi->irq_setup)
  988. new_smi->irq_setup(new_smi);
  989. /* Set up the timer that drives the interface. */
  990. setup_timer(&new_smi->si_timer, smi_timeout, (long)new_smi);
  991. new_smi->last_timeout_jiffies = jiffies;
  992. mod_timer(&new_smi->si_timer, jiffies + SI_TIMEOUT_JIFFIES);
  993. /*
  994. * Check if the user forcefully enabled the daemon.
  995. */
  996. if (new_smi->intf_num < num_force_kipmid)
  997. enable = force_kipmid[new_smi->intf_num];
  998. /*
  999. * The BT interface is efficient enough to not need a thread,
  1000. * and there is no need for a thread if we have interrupts.
  1001. */
  1002. else if ((new_smi->si_type != SI_BT) && (!new_smi->irq))
  1003. enable = 1;
  1004. if (enable) {
  1005. new_smi->thread = kthread_run(ipmi_thread, new_smi,
  1006. "kipmi%d", new_smi->intf_num);
  1007. if (IS_ERR(new_smi->thread)) {
  1008. dev_notice(new_smi->dev, "Could not start"
  1009. " kernel thread due to error %ld, only using"
  1010. " timers to drive the interface\n",
  1011. PTR_ERR(new_smi->thread));
  1012. new_smi->thread = NULL;
  1013. }
  1014. }
  1015. return 0;
  1016. }
  1017. static int get_smi_info(void *send_info, struct ipmi_smi_info *data)
  1018. {
  1019. struct smi_info *smi = send_info;
  1020. data->addr_src = smi->addr_source;
  1021. data->dev = smi->dev;
  1022. data->addr_info = smi->addr_info;
  1023. get_device(smi->dev);
  1024. return 0;
  1025. }
  1026. static void set_maintenance_mode(void *send_info, int enable)
  1027. {
  1028. struct smi_info *smi_info = send_info;
  1029. if (!enable)
  1030. atomic_set(&smi_info->req_events, 0);
  1031. }
  1032. static struct ipmi_smi_handlers handlers = {
  1033. .owner = THIS_MODULE,
  1034. .start_processing = smi_start_processing,
  1035. .get_smi_info = get_smi_info,
  1036. .sender = sender,
  1037. .request_events = request_events,
  1038. .set_maintenance_mode = set_maintenance_mode,
  1039. .set_run_to_completion = set_run_to_completion,
  1040. .poll = poll,
  1041. };
  1042. /*
  1043. * There can be 4 IO ports passed in (with or without IRQs), 4 addresses,
  1044. * a default IO port, and 1 ACPI/SPMI address. That sets SI_MAX_DRIVERS.
  1045. */
  1046. static LIST_HEAD(smi_infos);
  1047. static DEFINE_MUTEX(smi_infos_lock);
  1048. static int smi_num; /* Used to sequence the SMIs */
  1049. #define DEFAULT_REGSPACING 1
  1050. #define DEFAULT_REGSIZE 1
  1051. static int si_trydefaults = 1;
  1052. static char *si_type[SI_MAX_PARMS];
  1053. #define MAX_SI_TYPE_STR 30
  1054. static char si_type_str[MAX_SI_TYPE_STR];
  1055. static unsigned long addrs[SI_MAX_PARMS];
  1056. static unsigned int num_addrs;
  1057. static unsigned int ports[SI_MAX_PARMS];
  1058. static unsigned int num_ports;
  1059. static int irqs[SI_MAX_PARMS];
  1060. static unsigned int num_irqs;
  1061. static int regspacings[SI_MAX_PARMS];
  1062. static unsigned int num_regspacings;
  1063. static int regsizes[SI_MAX_PARMS];
  1064. static unsigned int num_regsizes;
  1065. static int regshifts[SI_MAX_PARMS];
  1066. static unsigned int num_regshifts;
  1067. static int slave_addrs[SI_MAX_PARMS]; /* Leaving 0 chooses the default value */
  1068. static unsigned int num_slave_addrs;
  1069. #define IPMI_IO_ADDR_SPACE 0
  1070. #define IPMI_MEM_ADDR_SPACE 1
  1071. static char *addr_space_to_str[] = { "i/o", "mem" };
  1072. static int hotmod_handler(const char *val, struct kernel_param *kp);
  1073. module_param_call(hotmod, hotmod_handler, NULL, NULL, 0200);
  1074. MODULE_PARM_DESC(hotmod, "Add and remove interfaces. See"
  1075. " Documentation/IPMI.txt in the kernel sources for the"
  1076. " gory details.");
  1077. module_param_named(trydefaults, si_trydefaults, bool, 0);
  1078. MODULE_PARM_DESC(trydefaults, "Setting this to 'false' will disable the"
  1079. " default scan of the KCS and SMIC interface at the standard"
  1080. " address");
  1081. module_param_string(type, si_type_str, MAX_SI_TYPE_STR, 0);
  1082. MODULE_PARM_DESC(type, "Defines the type of each interface, each"
  1083. " interface separated by commas. The types are 'kcs',"
  1084. " 'smic', and 'bt'. For example si_type=kcs,bt will set"
  1085. " the first interface to kcs and the second to bt");
  1086. module_param_array(addrs, ulong, &num_addrs, 0);
  1087. MODULE_PARM_DESC(addrs, "Sets the memory address of each interface, the"
  1088. " addresses separated by commas. Only use if an interface"
  1089. " is in memory. Otherwise, set it to zero or leave"
  1090. " it blank.");
  1091. module_param_array(ports, uint, &num_ports, 0);
  1092. MODULE_PARM_DESC(ports, "Sets the port address of each interface, the"
  1093. " addresses separated by commas. Only use if an interface"
  1094. " is a port. Otherwise, set it to zero or leave"
  1095. " it blank.");
  1096. module_param_array(irqs, int, &num_irqs, 0);
  1097. MODULE_PARM_DESC(irqs, "Sets the interrupt of each interface, the"
  1098. " addresses separated by commas. Only use if an interface"
  1099. " has an interrupt. Otherwise, set it to zero or leave"
  1100. " it blank.");
  1101. module_param_array(regspacings, int, &num_regspacings, 0);
  1102. MODULE_PARM_DESC(regspacings, "The number of bytes between the start address"
  1103. " and each successive register used by the interface. For"
  1104. " instance, if the start address is 0xca2 and the spacing"
  1105. " is 2, then the second address is at 0xca4. Defaults"
  1106. " to 1.");
  1107. module_param_array(regsizes, int, &num_regsizes, 0);
  1108. MODULE_PARM_DESC(regsizes, "The size of the specific IPMI register in bytes."
  1109. " This should generally be 1, 2, 4, or 8 for an 8-bit,"
  1110. " 16-bit, 32-bit, or 64-bit register. Use this if you"
  1111. " the 8-bit IPMI register has to be read from a larger"
  1112. " register.");
  1113. module_param_array(regshifts, int, &num_regshifts, 0);
  1114. MODULE_PARM_DESC(regshifts, "The amount to shift the data read from the."
  1115. " IPMI register, in bits. For instance, if the data"
  1116. " is read from a 32-bit word and the IPMI data is in"
  1117. " bit 8-15, then the shift would be 8");
  1118. module_param_array(slave_addrs, int, &num_slave_addrs, 0);
  1119. MODULE_PARM_DESC(slave_addrs, "Set the default IPMB slave address for"
  1120. " the controller. Normally this is 0x20, but can be"
  1121. " overridden by this parm. This is an array indexed"
  1122. " by interface number.");
  1123. module_param_array(force_kipmid, int, &num_force_kipmid, 0);
  1124. MODULE_PARM_DESC(force_kipmid, "Force the kipmi daemon to be enabled (1) or"
  1125. " disabled(0). Normally the IPMI driver auto-detects"
  1126. " this, but the value may be overridden by this parm.");
  1127. module_param(unload_when_empty, int, 0);
  1128. MODULE_PARM_DESC(unload_when_empty, "Unload the module if no interfaces are"
  1129. " specified or found, default is 1. Setting to 0"
  1130. " is useful for hot add of devices using hotmod.");
  1131. module_param_array(kipmid_max_busy_us, uint, &num_max_busy_us, 0644);
  1132. MODULE_PARM_DESC(kipmid_max_busy_us,
  1133. "Max time (in microseconds) to busy-wait for IPMI data before"
  1134. " sleeping. 0 (default) means to wait forever. Set to 100-500"
  1135. " if kipmid is using up a lot of CPU time.");
  1136. static void std_irq_cleanup(struct smi_info *info)
  1137. {
  1138. if (info->si_type == SI_BT)
  1139. /* Disable the interrupt in the BT interface. */
  1140. info->io.outputb(&info->io, IPMI_BT_INTMASK_REG, 0);
  1141. free_irq(info->irq, info);
  1142. }
  1143. static int std_irq_setup(struct smi_info *info)
  1144. {
  1145. int rv;
  1146. if (!info->irq)
  1147. return 0;
  1148. if (info->si_type == SI_BT) {
  1149. rv = request_irq(info->irq,
  1150. si_bt_irq_handler,
  1151. IRQF_SHARED | IRQF_DISABLED,
  1152. DEVICE_NAME,
  1153. info);
  1154. if (!rv)
  1155. /* Enable the interrupt in the BT interface. */
  1156. info->io.outputb(&info->io, IPMI_BT_INTMASK_REG,
  1157. IPMI_BT_INTMASK_ENABLE_IRQ_BIT);
  1158. } else
  1159. rv = request_irq(info->irq,
  1160. si_irq_handler,
  1161. IRQF_SHARED | IRQF_DISABLED,
  1162. DEVICE_NAME,
  1163. info);
  1164. if (rv) {
  1165. dev_warn(info->dev, "%s unable to claim interrupt %d,"
  1166. " running polled\n",
  1167. DEVICE_NAME, info->irq);
  1168. info->irq = 0;
  1169. } else {
  1170. info->irq_cleanup = std_irq_cleanup;
  1171. dev_info(info->dev, "Using irq %d\n", info->irq);
  1172. }
  1173. return rv;
  1174. }
  1175. static unsigned char port_inb(struct si_sm_io *io, unsigned int offset)
  1176. {
  1177. unsigned int addr = io->addr_data;
  1178. return inb(addr + (offset * io->regspacing));
  1179. }
  1180. static void port_outb(struct si_sm_io *io, unsigned int offset,
  1181. unsigned char b)
  1182. {
  1183. unsigned int addr = io->addr_data;
  1184. outb(b, addr + (offset * io->regspacing));
  1185. }
  1186. static unsigned char port_inw(struct si_sm_io *io, unsigned int offset)
  1187. {
  1188. unsigned int addr = io->addr_data;
  1189. return (inw(addr + (offset * io->regspacing)) >> io->regshift) & 0xff;
  1190. }
  1191. static void port_outw(struct si_sm_io *io, unsigned int offset,
  1192. unsigned char b)
  1193. {
  1194. unsigned int addr = io->addr_data;
  1195. outw(b << io->regshift, addr + (offset * io->regspacing));
  1196. }
  1197. static unsigned char port_inl(struct si_sm_io *io, unsigned int offset)
  1198. {
  1199. unsigned int addr = io->addr_data;
  1200. return (inl(addr + (offset * io->regspacing)) >> io->regshift) & 0xff;
  1201. }
  1202. static void port_outl(struct si_sm_io *io, unsigned int offset,
  1203. unsigned char b)
  1204. {
  1205. unsigned int addr = io->addr_data;
  1206. outl(b << io->regshift, addr+(offset * io->regspacing));
  1207. }
  1208. static void port_cleanup(struct smi_info *info)
  1209. {
  1210. unsigned int addr = info->io.addr_data;
  1211. int idx;
  1212. if (addr) {
  1213. for (idx = 0; idx < info->io_size; idx++)
  1214. release_region(addr + idx * info->io.regspacing,
  1215. info->io.regsize);
  1216. }
  1217. }
  1218. static int port_setup(struct smi_info *info)
  1219. {
  1220. unsigned int addr = info->io.addr_data;
  1221. int idx;
  1222. if (!addr)
  1223. return -ENODEV;
  1224. info->io_cleanup = port_cleanup;
  1225. /*
  1226. * Figure out the actual inb/inw/inl/etc routine to use based
  1227. * upon the register size.
  1228. */
  1229. switch (info->io.regsize) {
  1230. case 1:
  1231. info->io.inputb = port_inb;
  1232. info->io.outputb = port_outb;
  1233. break;
  1234. case 2:
  1235. info->io.inputb = port_inw;
  1236. info->io.outputb = port_outw;
  1237. break;
  1238. case 4:
  1239. info->io.inputb = port_inl;
  1240. info->io.outputb = port_outl;
  1241. break;
  1242. default:
  1243. dev_warn(info->dev, "Invalid register size: %d\n",
  1244. info->io.regsize);
  1245. return -EINVAL;
  1246. }
  1247. /*
  1248. * Some BIOSes reserve disjoint I/O regions in their ACPI
  1249. * tables. This causes problems when trying to register the
  1250. * entire I/O region. Therefore we must register each I/O
  1251. * port separately.
  1252. */
  1253. for (idx = 0; idx < info->io_size; idx++) {
  1254. if (request_region(addr + idx * info->io.regspacing,
  1255. info->io.regsize, DEVICE_NAME) == NULL) {
  1256. /* Undo allocations */
  1257. while (idx--) {
  1258. release_region(addr + idx * info->io.regspacing,
  1259. info->io.regsize);
  1260. }
  1261. return -EIO;
  1262. }
  1263. }
  1264. return 0;
  1265. }
  1266. static unsigned char intf_mem_inb(struct si_sm_io *io, unsigned int offset)
  1267. {
  1268. return readb((io->addr)+(offset * io->regspacing));
  1269. }
  1270. static void intf_mem_outb(struct si_sm_io *io, unsigned int offset,
  1271. unsigned char b)
  1272. {
  1273. writeb(b, (io->addr)+(offset * io->regspacing));
  1274. }
  1275. static unsigned char intf_mem_inw(struct si_sm_io *io, unsigned int offset)
  1276. {
  1277. return (readw((io->addr)+(offset * io->regspacing)) >> io->regshift)
  1278. & 0xff;
  1279. }
  1280. static void intf_mem_outw(struct si_sm_io *io, unsigned int offset,
  1281. unsigned char b)
  1282. {
  1283. writeb(b << io->regshift, (io->addr)+(offset * io->regspacing));
  1284. }
  1285. static unsigned char intf_mem_inl(struct si_sm_io *io, unsigned int offset)
  1286. {
  1287. return (readl((io->addr)+(offset * io->regspacing)) >> io->regshift)
  1288. & 0xff;
  1289. }
  1290. static void intf_mem_outl(struct si_sm_io *io, unsigned int offset,
  1291. unsigned char b)
  1292. {
  1293. writel(b << io->regshift, (io->addr)+(offset * io->regspacing));
  1294. }
  1295. #ifdef readq
  1296. static unsigned char mem_inq(struct si_sm_io *io, unsigned int offset)
  1297. {
  1298. return (readq((io->addr)+(offset * io->regspacing)) >> io->regshift)
  1299. & 0xff;
  1300. }
  1301. static void mem_outq(struct si_sm_io *io, unsigned int offset,
  1302. unsigned char b)
  1303. {
  1304. writeq(b << io->regshift, (io->addr)+(offset * io->regspacing));
  1305. }
  1306. #endif
  1307. static void mem_cleanup(struct smi_info *info)
  1308. {
  1309. unsigned long addr = info->io.addr_data;
  1310. int mapsize;
  1311. if (info->io.addr) {
  1312. iounmap(info->io.addr);
  1313. mapsize = ((info->io_size * info->io.regspacing)
  1314. - (info->io.regspacing - info->io.regsize));
  1315. release_mem_region(addr, mapsize);
  1316. }
  1317. }
  1318. static int mem_setup(struct smi_info *info)
  1319. {
  1320. unsigned long addr = info->io.addr_data;
  1321. int mapsize;
  1322. if (!addr)
  1323. return -ENODEV;
  1324. info->io_cleanup = mem_cleanup;
  1325. /*
  1326. * Figure out the actual readb/readw/readl/etc routine to use based
  1327. * upon the register size.
  1328. */
  1329. switch (info->io.regsize) {
  1330. case 1:
  1331. info->io.inputb = intf_mem_inb;
  1332. info->io.outputb = intf_mem_outb;
  1333. break;
  1334. case 2:
  1335. info->io.inputb = intf_mem_inw;
  1336. info->io.outputb = intf_mem_outw;
  1337. break;
  1338. case 4:
  1339. info->io.inputb = intf_mem_inl;
  1340. info->io.outputb = intf_mem_outl;
  1341. break;
  1342. #ifdef readq
  1343. case 8:
  1344. info->io.inputb = mem_inq;
  1345. info->io.outputb = mem_outq;
  1346. break;
  1347. #endif
  1348. default:
  1349. dev_warn(info->dev, "Invalid register size: %d\n",
  1350. info->io.regsize);
  1351. return -EINVAL;
  1352. }
  1353. /*
  1354. * Calculate the total amount of memory to claim. This is an
  1355. * unusual looking calculation, but it avoids claiming any
  1356. * more memory than it has to. It will claim everything
  1357. * between the first address to the end of the last full
  1358. * register.
  1359. */
  1360. mapsize = ((info->io_size * info->io.regspacing)
  1361. - (info->io.regspacing - info->io.regsize));
  1362. if (request_mem_region(addr, mapsize, DEVICE_NAME) == NULL)
  1363. return -EIO;
  1364. info->io.addr = ioremap(addr, mapsize);
  1365. if (info->io.addr == NULL) {
  1366. release_mem_region(addr, mapsize);
  1367. return -EIO;
  1368. }
  1369. return 0;
  1370. }
  1371. /*
  1372. * Parms come in as <op1>[:op2[:op3...]]. ops are:
  1373. * add|remove,kcs|bt|smic,mem|i/o,<address>[,<opt1>[,<opt2>[,...]]]
  1374. * Options are:
  1375. * rsp=<regspacing>
  1376. * rsi=<regsize>
  1377. * rsh=<regshift>
  1378. * irq=<irq>
  1379. * ipmb=<ipmb addr>
  1380. */
  1381. enum hotmod_op { HM_ADD, HM_REMOVE };
  1382. struct hotmod_vals {
  1383. char *name;
  1384. int val;
  1385. };
  1386. static struct hotmod_vals hotmod_ops[] = {
  1387. { "add", HM_ADD },
  1388. { "remove", HM_REMOVE },
  1389. { NULL }
  1390. };
  1391. static struct hotmod_vals hotmod_si[] = {
  1392. { "kcs", SI_KCS },
  1393. { "smic", SI_SMIC },
  1394. { "bt", SI_BT },
  1395. { NULL }
  1396. };
  1397. static struct hotmod_vals hotmod_as[] = {
  1398. { "mem", IPMI_MEM_ADDR_SPACE },
  1399. { "i/o", IPMI_IO_ADDR_SPACE },
  1400. { NULL }
  1401. };
  1402. static int parse_str(struct hotmod_vals *v, int *val, char *name, char **curr)
  1403. {
  1404. char *s;
  1405. int i;
  1406. s = strchr(*curr, ',');
  1407. if (!s) {
  1408. printk(KERN_WARNING PFX "No hotmod %s given.\n", name);
  1409. return -EINVAL;
  1410. }
  1411. *s = '\0';
  1412. s++;
  1413. for (i = 0; hotmod_ops[i].name; i++) {
  1414. if (strcmp(*curr, v[i].name) == 0) {
  1415. *val = v[i].val;
  1416. *curr = s;
  1417. return 0;
  1418. }
  1419. }
  1420. printk(KERN_WARNING PFX "Invalid hotmod %s '%s'\n", name, *curr);
  1421. return -EINVAL;
  1422. }
  1423. static int check_hotmod_int_op(const char *curr, const char *option,
  1424. const char *name, int *val)
  1425. {
  1426. char *n;
  1427. if (strcmp(curr, name) == 0) {
  1428. if (!option) {
  1429. printk(KERN_WARNING PFX
  1430. "No option given for '%s'\n",
  1431. curr);
  1432. return -EINVAL;
  1433. }
  1434. *val = simple_strtoul(option, &n, 0);
  1435. if ((*n != '\0') || (*option == '\0')) {
  1436. printk(KERN_WARNING PFX
  1437. "Bad option given for '%s'\n",
  1438. curr);
  1439. return -EINVAL;
  1440. }
  1441. return 1;
  1442. }
  1443. return 0;
  1444. }
  1445. static struct smi_info *smi_info_alloc(void)
  1446. {
  1447. struct smi_info *info = kzalloc(sizeof(*info), GFP_KERNEL);
  1448. if (info) {
  1449. spin_lock_init(&info->si_lock);
  1450. spin_lock_init(&info->msg_lock);
  1451. }
  1452. return info;
  1453. }
  1454. static int hotmod_handler(const char *val, struct kernel_param *kp)
  1455. {
  1456. char *str = kstrdup(val, GFP_KERNEL);
  1457. int rv;
  1458. char *next, *curr, *s, *n, *o;
  1459. enum hotmod_op op;
  1460. enum si_type si_type;
  1461. int addr_space;
  1462. unsigned long addr;
  1463. int regspacing;
  1464. int regsize;
  1465. int regshift;
  1466. int irq;
  1467. int ipmb;
  1468. int ival;
  1469. int len;
  1470. struct smi_info *info;
  1471. if (!str)
  1472. return -ENOMEM;
  1473. /* Kill any trailing spaces, as we can get a "\n" from echo. */
  1474. len = strlen(str);
  1475. ival = len - 1;
  1476. while ((ival >= 0) && isspace(str[ival])) {
  1477. str[ival] = '\0';
  1478. ival--;
  1479. }
  1480. for (curr = str; curr; curr = next) {
  1481. regspacing = 1;
  1482. regsize = 1;
  1483. regshift = 0;
  1484. irq = 0;
  1485. ipmb = 0; /* Choose the default if not specified */
  1486. next = strchr(curr, ':');
  1487. if (next) {
  1488. *next = '\0';
  1489. next++;
  1490. }
  1491. rv = parse_str(hotmod_ops, &ival, "operation", &curr);
  1492. if (rv)
  1493. break;
  1494. op = ival;
  1495. rv = parse_str(hotmod_si, &ival, "interface type", &curr);
  1496. if (rv)
  1497. break;
  1498. si_type = ival;
  1499. rv = parse_str(hotmod_as, &addr_space, "address space", &curr);
  1500. if (rv)
  1501. break;
  1502. s = strchr(curr, ',');
  1503. if (s) {
  1504. *s = '\0';
  1505. s++;
  1506. }
  1507. addr = simple_strtoul(curr, &n, 0);
  1508. if ((*n != '\0') || (*curr == '\0')) {
  1509. printk(KERN_WARNING PFX "Invalid hotmod address"
  1510. " '%s'\n", curr);
  1511. break;
  1512. }
  1513. while (s) {
  1514. curr = s;
  1515. s = strchr(curr, ',');
  1516. if (s) {
  1517. *s = '\0';
  1518. s++;
  1519. }
  1520. o = strchr(curr, '=');
  1521. if (o) {
  1522. *o = '\0';
  1523. o++;
  1524. }
  1525. rv = check_hotmod_int_op(curr, o, "rsp", &regspacing);
  1526. if (rv < 0)
  1527. goto out;
  1528. else if (rv)
  1529. continue;
  1530. rv = check_hotmod_int_op(curr, o, "rsi", &regsize);
  1531. if (rv < 0)
  1532. goto out;
  1533. else if (rv)
  1534. continue;
  1535. rv = check_hotmod_int_op(curr, o, "rsh", &regshift);
  1536. if (rv < 0)
  1537. goto out;
  1538. else if (rv)
  1539. continue;
  1540. rv = check_hotmod_int_op(curr, o, "irq", &irq);
  1541. if (rv < 0)
  1542. goto out;
  1543. else if (rv)
  1544. continue;
  1545. rv = check_hotmod_int_op(curr, o, "ipmb", &ipmb);
  1546. if (rv < 0)
  1547. goto out;
  1548. else if (rv)
  1549. continue;
  1550. rv = -EINVAL;
  1551. printk(KERN_WARNING PFX
  1552. "Invalid hotmod option '%s'\n",
  1553. curr);
  1554. goto out;
  1555. }
  1556. if (op == HM_ADD) {
  1557. info = smi_info_alloc();
  1558. if (!info) {
  1559. rv = -ENOMEM;
  1560. goto out;
  1561. }
  1562. info->addr_source = SI_HOTMOD;
  1563. info->si_type = si_type;
  1564. info->io.addr_data = addr;
  1565. info->io.addr_type = addr_space;
  1566. if (addr_space == IPMI_MEM_ADDR_SPACE)
  1567. info->io_setup = mem_setup;
  1568. else
  1569. info->io_setup = port_setup;
  1570. info->io.addr = NULL;
  1571. info->io.regspacing = regspacing;
  1572. if (!info->io.regspacing)
  1573. info->io.regspacing = DEFAULT_REGSPACING;
  1574. info->io.regsize = regsize;
  1575. if (!info->io.regsize)
  1576. info->io.regsize = DEFAULT_REGSPACING;
  1577. info->io.regshift = regshift;
  1578. info->irq = irq;
  1579. if (info->irq)
  1580. info->irq_setup = std_irq_setup;
  1581. info->slave_addr = ipmb;
  1582. if (!add_smi(info)) {
  1583. if (try_smi_init(info))
  1584. cleanup_one_si(info);
  1585. } else {
  1586. kfree(info);
  1587. }
  1588. } else {
  1589. /* remove */
  1590. struct smi_info *e, *tmp_e;
  1591. mutex_lock(&smi_infos_lock);
  1592. list_for_each_entry_safe(e, tmp_e, &smi_infos, link) {
  1593. if (e->io.addr_type != addr_space)
  1594. continue;
  1595. if (e->si_type != si_type)
  1596. continue;
  1597. if (e->io.addr_data == addr)
  1598. cleanup_one_si(e);
  1599. }
  1600. mutex_unlock(&smi_infos_lock);
  1601. }
  1602. }
  1603. rv = len;
  1604. out:
  1605. kfree(str);
  1606. return rv;
  1607. }
  1608. static int __devinit hardcode_find_bmc(void)
  1609. {
  1610. int ret = -ENODEV;
  1611. int i;
  1612. struct smi_info *info;
  1613. for (i = 0; i < SI_MAX_PARMS; i++) {
  1614. if (!ports[i] && !addrs[i])
  1615. continue;
  1616. info = smi_info_alloc();
  1617. if (!info)
  1618. return -ENOMEM;
  1619. info->addr_source = SI_HARDCODED;
  1620. printk(KERN_INFO PFX "probing via hardcoded address\n");
  1621. if (!si_type[i] || strcmp(si_type[i], "kcs") == 0) {
  1622. info->si_type = SI_KCS;
  1623. } else if (strcmp(si_type[i], "smic") == 0) {
  1624. info->si_type = SI_SMIC;
  1625. } else if (strcmp(si_type[i], "bt") == 0) {
  1626. info->si_type = SI_BT;
  1627. } else {
  1628. printk(KERN_WARNING PFX "Interface type specified "
  1629. "for interface %d, was invalid: %s\n",
  1630. i, si_type[i]);
  1631. kfree(info);
  1632. continue;
  1633. }
  1634. if (ports[i]) {
  1635. /* An I/O port */
  1636. info->io_setup = port_setup;
  1637. info->io.addr_data = ports[i];
  1638. info->io.addr_type = IPMI_IO_ADDR_SPACE;
  1639. } else if (addrs[i]) {
  1640. /* A memory port */
  1641. info->io_setup = mem_setup;
  1642. info->io.addr_data = addrs[i];
  1643. info->io.addr_type = IPMI_MEM_ADDR_SPACE;
  1644. } e