dcdbas.c 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659
  1. /*
  2. * dcdbas.c: Dell Systems Management Base Driver
  3. *
  4. * The Dell Systems Management Base Driver provides a sysfs interface for
  5. * systems management software to perform System Management Interrupts (SMIs)
  6. * and Host Control Actions (power cycle or power off after OS shutdown) on
  7. * Dell systems.
  8. *
  9. * See Documentation/dcdbas.txt for more information.
  10. *
  11. * Copyright (C) 1995-2006 Dell Inc.
  12. *
  13. * This program is free software; you can redistribute it and/or modify
  14. * it under the terms of the GNU General Public License v2.0 as published by
  15. * the Free Software Foundation.
  16. *
  17. * This program is distributed in the hope that it will be useful,
  18. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  20. * GNU General Public License for more details.
  21. */
  22. #include <linux/platform_device.h>
  23. #include <linux/dma-mapping.h>
  24. #include <linux/errno.h>
  25. #include <linux/init.h>
  26. #include <linux/kernel.h>
  27. #include <linux/mc146818rtc.h>
  28. #include <linux/module.h>
  29. #include <linux/reboot.h>
  30. #include <linux/sched.h>
  31. #include <linux/smp.h>
  32. #include <linux/spinlock.h>
  33. #include <linux/string.h>
  34. #include <linux/types.h>
  35. #include <linux/mutex.h>
  36. #include <asm/io.h>
  37. #include <asm/semaphore.h>
  38. #include "dcdbas.h"
  39. #define DRIVER_NAME "dcdbas"
  40. #define DRIVER_VERSION "5.6.0-3.2"
  41. #define DRIVER_DESCRIPTION "Dell Systems Management Base Driver"
  42. static struct platform_device *dcdbas_pdev;
  43. static u8 *smi_data_buf;
  44. static dma_addr_t smi_data_buf_handle;
  45. static unsigned long smi_data_buf_size;
  46. static u32 smi_data_buf_phys_addr;
  47. static DEFINE_MUTEX(smi_data_lock);
  48. static unsigned int host_control_action;
  49. static unsigned int host_control_smi_type;
  50. static unsigned int host_control_on_shutdown;
  51. /**
  52. * smi_data_buf_free: free SMI data buffer
  53. */
  54. static void smi_data_buf_free(void)
  55. {
  56. if (!smi_data_buf)
  57. return;
  58. dev_dbg(&dcdbas_pdev->dev, "%s: phys: %x size: %lu\n",
  59. __FUNCTION__, smi_data_buf_phys_addr, smi_data_buf_size);
  60. dma_free_coherent(&dcdbas_pdev->dev, smi_data_buf_size, smi_data_buf,
  61. smi_data_buf_handle);
  62. smi_data_buf = NULL;
  63. smi_data_buf_handle = 0;
  64. smi_data_buf_phys_addr = 0;
  65. smi_data_buf_size = 0;
  66. }
  67. /**
  68. * smi_data_buf_realloc: grow SMI data buffer if needed
  69. */
  70. static int smi_data_buf_realloc(unsigned long size)
  71. {
  72. void *buf;
  73. dma_addr_t handle;
  74. if (smi_data_buf_size >= size)
  75. return 0;
  76. if (size > MAX_SMI_DATA_BUF_SIZE)
  77. return -EINVAL;
  78. /* new buffer is needed */
  79. buf = dma_alloc_coherent(&dcdbas_pdev->dev, size, &handle, GFP_KERNEL);
  80. if (!buf) {
  81. dev_dbg(&dcdbas_pdev->dev,
  82. "%s: failed to allocate memory size %lu\n",
  83. __FUNCTION__, size);
  84. return -ENOMEM;
  85. }
  86. /* memory zeroed by dma_alloc_coherent */
  87. if (smi_data_buf)
  88. memcpy(buf, smi_data_buf, smi_data_buf_size);
  89. /* free any existing buffer */
  90. smi_data_buf_free();
  91. /* set up new buffer for use */
  92. smi_data_buf = buf;
  93. smi_data_buf_handle = handle;
  94. smi_data_buf_phys_addr = (u32) virt_to_phys(buf);
  95. smi_data_buf_size = size;
  96. dev_dbg(&dcdbas_pdev->dev, "%s: phys: %x size: %lu\n",
  97. __FUNCTION__, smi_data_buf_phys_addr, smi_data_buf_size);
  98. return 0;
  99. }
  100. static ssize_t smi_data_buf_phys_addr_show(struct device *dev,
  101. struct device_attribute *attr,
  102. char *buf)
  103. {
  104. return sprintf(buf, "%x\n", smi_data_buf_phys_addr);
  105. }
  106. static ssize_t smi_data_buf_size_show(struct device *dev,
  107. struct device_attribute *attr,
  108. char *buf)
  109. {
  110. return sprintf(buf, "%lu\n", smi_data_buf_size);
  111. }
  112. static ssize_t smi_data_buf_size_store(struct device *dev,
  113. struct device_attribute *attr,
  114. const char *buf, size_t count)
  115. {
  116. unsigned long buf_size;
  117. ssize_t ret;
  118. buf_size = simple_strtoul(buf, NULL, 10);
  119. /* make sure SMI data buffer is at least buf_size */
  120. mutex_lock(&smi_data_lock);
  121. ret = smi_data_buf_realloc(buf_size);
  122. mutex_unlock(&smi_data_lock);
  123. if (ret)
  124. return ret;
  125. return count;
  126. }
  127. static ssize_t smi_data_read(struct kobject *kobj, char *buf, loff_t pos,
  128. size_t count)
  129. {
  130. size_t max_read;
  131. ssize_t ret;
  132. mutex_lock(&smi_data_lock);
  133. if (pos >= smi_data_buf_size) {
  134. ret = 0;
  135. goto out;
  136. }
  137. max_read = smi_data_buf_size - pos;
  138. ret = min(max_read, count);
  139. memcpy(buf, smi_data_buf + pos, ret);
  140. out:
  141. mutex_unlock(&smi_data_lock);
  142. return ret;
  143. }
  144. static ssize_t smi_data_write(struct kobject *kobj, char *buf, loff_t pos,
  145. size_t count)
  146. {
  147. ssize_t ret;
  148. if ((pos + count) > MAX_SMI_DATA_BUF_SIZE)
  149. return -EINVAL;
  150. mutex_lock(&smi_data_lock);
  151. ret = smi_data_buf_realloc(pos + count);
  152. if (ret)
  153. goto out;
  154. memcpy(smi_data_buf + pos, buf, count);
  155. ret = count;
  156. out:
  157. mutex_unlock(&smi_data_lock);
  158. return ret;
  159. }
  160. static ssize_t host_control_action_show(struct device *dev,
  161. struct device_attribute *attr,
  162. char *buf)
  163. {
  164. return sprintf(buf, "%u\n", host_control_action);
  165. }
  166. static ssize_t host_control_action_store(struct device *dev,
  167. struct device_attribute *attr,
  168. const char *buf, size_t count)
  169. {
  170. ssize_t ret;
  171. /* make sure buffer is available for host control command */
  172. mutex_lock(&smi_data_lock);
  173. ret = smi_data_buf_realloc(sizeof(struct apm_cmd));
  174. mutex_unlock(&smi_data_lock);
  175. if (ret)
  176. return ret;
  177. host_control_action = simple_strtoul(buf, NULL, 10);
  178. return count;
  179. }
  180. static ssize_t host_control_smi_type_show(struct device *dev,
  181. struct device_attribute *attr,
  182. char *buf)
  183. {
  184. return sprintf(buf, "%u\n", host_control_smi_type);
  185. }
  186. static ssize_t host_control_smi_type_store(struct device *dev,
  187. struct device_attribute *attr,
  188. const char *buf, size_t count)
  189. {
  190. host_control_smi_type = simple_strtoul(buf, NULL, 10);
  191. return count;
  192. }
  193. static ssize_t host_control_on_shutdown_show(struct device *dev,
  194. struct device_attribute *attr,
  195. char *buf)
  196. {
  197. return sprintf(buf, "%u\n", host_control_on_shutdown);
  198. }
  199. static ssize_t host_control_on_shutdown_store(struct device *dev,
  200. struct device_attribute *attr,
  201. const char *buf, size_t count)
  202. {
  203. host_control_on_shutdown = simple_strtoul(buf, NULL, 10);
  204. return count;
  205. }
  206. /**
  207. * smi_request: generate SMI request
  208. *
  209. * Called with smi_data_lock.
  210. */
  211. static int smi_request(struct smi_cmd *smi_cmd)
  212. {
  213. cpumask_t old_mask;
  214. int ret = 0;
  215. if (smi_cmd->magic != SMI_CMD_MAGIC) {
  216. dev_info(&dcdbas_pdev->dev, "%s: invalid magic value\n",
  217. __FUNCTION__);
  218. return -EBADR;
  219. }
  220. /* SMI requires CPU 0 */
  221. old_mask = current->cpus_allowed;
  222. set_cpus_allowed(current, cpumask_of_cpu(0));
  223. if (smp_processor_id() != 0) {
  224. dev_dbg(&dcdbas_pdev->dev, "%s: failed to get CPU 0\n",
  225. __FUNCTION__);
  226. ret = -EBUSY;
  227. goto out;
  228. }
  229. /* generate SMI */
  230. asm volatile (
  231. "outb %b0,%w1"
  232. : /* no output args */
  233. : "a" (smi_cmd->command_code),
  234. "d" (smi_cmd->command_address),
  235. "b" (smi_cmd->ebx),
  236. "c" (smi_cmd->ecx)
  237. : "memory"
  238. );
  239. out:
  240. set_cpus_allowed(current, old_mask);
  241. return ret;
  242. }
  243. /**
  244. * smi_request_store:
  245. *
  246. * The valid values are:
  247. * 0: zero SMI data buffer
  248. * 1: generate calling interface SMI
  249. * 2: generate raw SMI
  250. *
  251. * User application writes smi_cmd to smi_data before telling driver
  252. * to generate SMI.
  253. */
  254. static ssize_t smi_request_store(struct device *dev,
  255. struct device_attribute *attr,
  256. const char *buf, size_t count)
  257. {
  258. struct smi_cmd *smi_cmd;
  259. unsigned long val = simple_strtoul(buf, NULL, 10);
  260. ssize_t ret;
  261. mutex_lock(&smi_data_lock);
  262. if (smi_data_buf_size < sizeof(struct smi_cmd)) {
  263. ret = -ENODEV;
  264. goto out;
  265. }
  266. smi_cmd = (struct smi_cmd *)smi_data_buf;
  267. switch (val) {
  268. case 2:
  269. /* Raw SMI */
  270. ret = smi_request(smi_cmd);
  271. if (!ret)
  272. ret = count;
  273. break;
  274. case 1:
  275. /* Calling Interface SMI */
  276. smi_cmd->ebx = (u32) virt_to_phys(smi_cmd->command_buffer);
  277. ret = smi_request(smi_cmd);
  278. if (!ret)
  279. ret = count;
  280. break;
  281. case 0:
  282. memset(smi_data_buf, 0, smi_data_buf_size);
  283. ret = count;
  284. break;
  285. default:
  286. ret = -EINVAL;
  287. break;
  288. }
  289. out:
  290. mutex_unlock(&smi_data_lock);
  291. return ret;
  292. }
  293. /**
  294. * host_control_smi: generate host control SMI
  295. *
  296. * Caller must set up the host control command in smi_data_buf.
  297. */
  298. static int host_control_smi(void)
  299. {
  300. struct apm_cmd *apm_cmd;
  301. u8 *data;
  302. unsigned long flags;
  303. u32 num_ticks;
  304. s8 cmd_status;
  305. u8 index;
  306. apm_cmd = (struct apm_cmd *)smi_data_buf;
  307. apm_cmd->status = ESM_STATUS_CMD_UNSUCCESSFUL;
  308. switch (host_control_smi_type) {
  309. case HC_SMITYPE_TYPE1:
  310. spin_lock_irqsave(&rtc_lock, flags);
  311. /* write SMI data buffer physical address */
  312. data = (u8 *)&smi_data_buf_phys_addr;
  313. for (index = PE1300_CMOS_CMD_STRUCT_PTR;
  314. index < (PE1300_CMOS_CMD_STRUCT_PTR + 4);
  315. index++, data++) {
  316. outb(index,
  317. (CMOS_BASE_PORT + CMOS_PAGE2_INDEX_PORT_PIIX4));
  318. outb(*data,
  319. (CMOS_BASE_PORT + CMOS_PAGE2_DATA_PORT_PIIX4));
  320. }
  321. /* first set status to -1 as called by spec */
  322. cmd_status = ESM_STATUS_CMD_UNSUCCESSFUL;
  323. outb((u8) cmd_status, PCAT_APM_STATUS_PORT);
  324. /* generate SMM call */
  325. outb(ESM_APM_CMD, PCAT_APM_CONTROL_PORT);
  326. spin_unlock_irqrestore(&rtc_lock, flags);
  327. /* wait a few to see if it executed */
  328. num_ticks = TIMEOUT_USEC_SHORT_SEMA_BLOCKING;
  329. while ((cmd_status = inb(PCAT_APM_STATUS_PORT))
  330. == ESM_STATUS_CMD_UNSUCCESSFUL) {
  331. num_ticks--;
  332. if (num_ticks == EXPIRED_TIMER)
  333. return -ETIME;
  334. }
  335. break;
  336. case HC_SMITYPE_TYPE2:
  337. case HC_SMITYPE_TYPE3:
  338. spin_lock_irqsave(&rtc_lock, flags);
  339. /* write SMI data buffer physical address */
  340. data = (u8 *)&smi_data_buf_phys_addr;
  341. for (index = PE1400_CMOS_CMD_STRUCT_PTR;
  342. index < (PE1400_CMOS_CMD_STRUCT_PTR + 4);
  343. index++, data++) {
  344. outb(index, (CMOS_BASE_PORT + CMOS_PAGE1_INDEX_PORT));
  345. outb(*data, (CMOS_BASE_PORT + CMOS_PAGE1_DATA_PORT));
  346. }
  347. /* generate SMM call */
  348. if (host_control_smi_type == HC_SMITYPE_TYPE3)
  349. outb(ESM_APM_CMD, PCAT_APM_CONTROL_PORT);
  350. else
  351. outb(ESM_APM_CMD, PE1400_APM_CONTROL_PORT);
  352. /* restore RTC index pointer since it was written to above */
  353. CMOS_READ(RTC_REG_C);
  354. spin_unlock_irqrestore(&rtc_lock, flags);
  355. /* read control port back to serialize write */
  356. cmd_status = inb(PE1400_APM_CONTROL_PORT);
  357. /* wait a few to see if it executed */
  358. num_ticks = TIMEOUT_USEC_SHORT_SEMA_BLOCKING;
  359. while (apm_cmd->status == ESM_STATUS_CMD_UNSUCCESSFUL) {
  360. num_ticks--;
  361. if (num_ticks == EXPIRED_TIMER)
  362. return -ETIME;
  363. }
  364. break;
  365. default:
  366. dev_dbg(&dcdbas_pdev->dev, "%s: invalid SMI type %u\n",
  367. __FUNCTION__, host_control_smi_type);
  368. return -ENOSYS;
  369. }
  370. return 0;
  371. }
  372. /**
  373. * dcdbas_host_control: initiate host control
  374. *
  375. * This function is called by the driver after the system has
  376. * finished shutting down if the user application specified a
  377. * host control action to perform on shutdown. It is safe to
  378. * use smi_data_buf at this point because the system has finished
  379. * shutting down and no userspace apps are running.
  380. */
  381. static void dcdbas_host_control(void)
  382. {
  383. struct apm_cmd *apm_cmd;
  384. u8 action;
  385. if (host_control_action == HC_ACTION_NONE)
  386. return;
  387. action = host_control_action;
  388. host_control_action = HC_ACTION_NONE;
  389. if (!smi_data_buf) {
  390. dev_dbg(&dcdbas_pdev->dev, "%s: no SMI buffer\n", __FUNCTION__);
  391. return;
  392. }
  393. if (smi_data_buf_size < sizeof(struct apm_cmd)) {
  394. dev_dbg(&dcdbas_pdev->dev, "%s: SMI buffer too small\n",
  395. __FUNCTION__);
  396. return;
  397. }
  398. apm_cmd = (struct apm_cmd *)smi_data_buf;
  399. /* power off takes precedence */
  400. if (action & HC_ACTION_HOST_CONTROL_POWEROFF) {
  401. apm_cmd->command = ESM_APM_POWER_CYCLE;
  402. apm_cmd->reserved = 0;
  403. *((s16 *)&apm_cmd->parameters.shortreq.parm[0]) = (s16) 0;
  404. host_control_smi();
  405. } else if (action & HC_ACTION_HOST_CONTROL_POWERCYCLE) {
  406. apm_cmd->command = ESM_APM_POWER_CYCLE;
  407. apm_cmd->reserved = 0;
  408. *((s16 *)&apm_cmd->parameters.shortreq.parm[0]) = (s16) 20;
  409. host_control_smi();
  410. }
  411. }
  412. /**
  413. * dcdbas_reboot_notify: handle reboot notification for host control
  414. */
  415. static int dcdbas_reboot_notify(struct notifier_block *nb, unsigned long code,
  416. void *unused)
  417. {
  418. switch (code) {
  419. case SYS_DOWN:
  420. case SYS_HALT:
  421. case SYS_POWER_OFF:
  422. if (host_control_on_shutdown) {
  423. /* firmware is going to perform host control action */
  424. printk(KERN_WARNING "Please wait for shutdown "
  425. "action to complete...\n");
  426. dcdbas_host_control();
  427. }
  428. break;
  429. }
  430. return NOTIFY_DONE;
  431. }
  432. static struct notifier_block dcdbas_reboot_nb = {
  433. .notifier_call = dcdbas_reboot_notify,
  434. .next = NULL,
  435. .priority = INT_MIN
  436. };
  437. static DCDBAS_BIN_ATTR_RW(smi_data);
  438. static struct bin_attribute *dcdbas_bin_attrs[] = {
  439. &bin_attr_smi_data,
  440. NULL
  441. };
  442. static DCDBAS_DEV_ATTR_RW(smi_data_buf_size);
  443. static DCDBAS_DEV_ATTR_RO(smi_data_buf_phys_addr);
  444. static DCDBAS_DEV_ATTR_WO(smi_request);
  445. static DCDBAS_DEV_ATTR_RW(host_control_action);
  446. static DCDBAS_DEV_ATTR_RW(host_control_smi_type);
  447. static DCDBAS_DEV_ATTR_RW(host_control_on_shutdown);
  448. static struct attribute *dcdbas_dev_attrs[] = {
  449. &dev_attr_smi_data_buf_size.attr,
  450. &dev_attr_smi_data_buf_phys_addr.attr,
  451. &dev_attr_smi_request.attr,
  452. &dev_attr_host_control_action.attr,
  453. &dev_attr_host_control_smi_type.attr,
  454. &dev_attr_host_control_on_shutdown.attr,
  455. NULL
  456. };
  457. static struct attribute_group dcdbas_attr_group = {
  458. .attrs = dcdbas_dev_attrs,
  459. };
  460. static int __devinit dcdbas_probe(struct platform_device *dev)
  461. {
  462. int i, error;
  463. host_control_action = HC_ACTION_NONE;
  464. host_control_smi_type = HC_SMITYPE_NONE;
  465. /*
  466. * BIOS SMI calls require buffer addresses be in 32-bit address space.
  467. * This is done by setting the DMA mask below.
  468. */
  469. dcdbas_pdev->dev.coherent_dma_mask = DMA_32BIT_MASK;
  470. dcdbas_pdev->dev.dma_mask = &dcdbas_pdev->dev.coherent_dma_mask;
  471. error = sysfs_create_group(&dev->dev.kobj, &dcdbas_attr_group);
  472. if (error)
  473. return error;
  474. for (i = 0; dcdbas_bin_attrs[i]; i++) {
  475. error = sysfs_create_bin_file(&dev->dev.kobj,
  476. dcdbas_bin_attrs[i]);
  477. if (error) {
  478. while (--i >= 0)
  479. sysfs_remove_bin_file(&dev->dev.kobj,
  480. dcdbas_bin_attrs[i]);
  481. sysfs_remove_group(&dev->dev.kobj, &dcdbas_attr_group);
  482. return error;
  483. }
  484. }
  485. register_reboot_notifier(&dcdbas_reboot_nb);
  486. dev_info(&dev->dev, "%s (version %s)\n",
  487. DRIVER_DESCRIPTION, DRIVER_VERSION);
  488. return 0;
  489. }
  490. static int __devexit dcdbas_remove(struct platform_device *dev)
  491. {
  492. int i;
  493. unregister_reboot_notifier(&dcdbas_reboot_nb);
  494. for (i = 0; dcdbas_bin_attrs[i]; i++)
  495. sysfs_remove_bin_file(&dev->dev.kobj, dcdbas_bin_attrs[i]);
  496. sysfs_remove_group(&dev->dev.kobj, &dcdbas_attr_group);
  497. return 0;
  498. }
  499. static struct platform_driver dcdbas_driver = {
  500. .driver = {
  501. .name = DRIVER_NAME,
  502. .owner = THIS_MODULE,
  503. },
  504. .probe = dcdbas_probe,
  505. .remove = __devexit_p(dcdbas_remove),
  506. };
  507. /**
  508. * dcdbas_init: initialize driver
  509. */
  510. static int __init dcdbas_init(void)
  511. {
  512. int error;
  513. error = platform_driver_register(&dcdbas_driver);
  514. if (error)
  515. return error;
  516. dcdbas_pdev = platform_device_alloc(DRIVER_NAME, -1);
  517. if (!dcdbas_pdev) {
  518. error = -ENOMEM;
  519. goto err_unregister_driver;
  520. }
  521. error = platform_device_add(dcdbas_pdev);
  522. if (error)
  523. goto err_free_device;
  524. return 0;
  525. err_free_device:
  526. platform_device_put(dcdbas_pdev);
  527. err_unregister_driver:
  528. platform_driver_unregister(&dcdbas_driver);
  529. return error;
  530. }
  531. /**
  532. * dcdbas_exit: perform driver cleanup
  533. */
  534. static void __exit dcdbas_exit(void)
  535. {
  536. /*
  537. * make sure functions that use dcdbas_pdev are called
  538. * before platform_device_unregister
  539. */
  540. unregister_reboot_notifier(&dcdbas_reboot_nb);
  541. smi_data_buf_free();
  542. platform_device_unregister(dcdbas_pdev);
  543. platform_driver_unregister(&dcdbas_driver);
  544. /*
  545. * We have to free the buffer here instead of dcdbas_remove
  546. * because only in module exit function we can be sure that
  547. * all sysfs attributes belonging to this module have been
  548. * released.
  549. */
  550. smi_data_buf_free();
  551. }
  552. module_init(dcdbas_init);
  553. module_exit(dcdbas_exit);
  554. MODULE_DESCRIPTION(DRIVER_DESCRIPTION " (version " DRIVER_VERSION ")");
  555. MODULE_VERSION(DRIVER_VERSION);
  556. MODULE_AUTHOR("Dell Inc.");
  557. MODULE_LICENSE("GPL");