开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
i8k.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：16k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

i8k.c：源码内容
  1. /*
  2.  * i8k.c -- Linux driver for accessing the SMM BIOS on Dell laptops.
  3.  *     See http://www.debian.org/~dz/i8k/ for more information
  4.  *     and for latest version of this driver.
  5.  *
  6.  * Copyright (C) 2001  Massimo Dal Zotto <dz@debian.org>
  7.  *
  8.  * This program is free software; you can redistribute it and/or modify it
  9.  * under the terms of the GNU General Public License as published by the
  10.  * Free Software Foundation; either version 2, or (at your option) any
  11.  * later version.
  12.  *
  13.  * This program is distributed in the hope that it will be useful, but
  14.  * WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16.  * General Public License for more details.
  17.  */
  19. #include <linux/module.h>
  20. #include <linux/version.h>
  21. #include <linux/types.h>
  22. #include <linux/init.h>
  23. #include <linux/proc_fs.h>
  24. #include <linux/apm_bios.h>
  25. #include <asm/uaccess.h>
  26. #include <asm/io.h>
  28. #include <linux/i8k.h>
  30. #define I8K_VERSION "1.7 21/11/2001"
  32. #define I8K_SMM_FN_STATUS 0x0025
  33. #define I8K_SMM_POWER_STATUS 0x0069
  34. #define I8K_SMM_SET_FAN 0x01a3
  35. #define I8K_SMM_GET_FAN 0x00a3
  36. #define I8K_SMM_GET_SPEED 0x02a3
  37. #define I8K_SMM_GET_TEMP 0x10a3
  38. #define I8K_SMM_GET_DELL_SIG 0xffa3
  39. #define I8K_SMM_BIOS_VERSION 0x00a6
  41. #define I8K_FAN_MULT 30
  42. #define I8K_MAX_TEMP 127
  44. #define I8K_FN_NONE 0x00
  45. #define I8K_FN_UP 0x01
  46. #define I8K_FN_DOWN 0x02
  47. #define I8K_FN_MUTE 0x04
  48. #define I8K_FN_MASK 0x07
  49. #define I8K_FN_SHIFT 8
  51. #define I8K_POWER_AC 0x05
  52. #define I8K_POWER_BATTERY 0x01
  54. #define I8K_TEMPERATURE_BUG 1
  56. #define DELL_SIGNATURE "Dell Computer"
  58. static char *supported_models[] = {
  59.     "Inspiron",
  60.     "Latitude",
  61.     NULL
  62. };
  64. static char system_vendor[48] = "?";
  65. static char product_name [48] = "?";
  66. static char bios_version [4]  = "?";
  67. static char serial_number[16] = "?";
  69. int force = 0;
  70. int power_status = 0;
  72. MODULE_AUTHOR("Massimo Dal Zotto (dz@debian.org)");
  73. MODULE_DESCRIPTION("Driver for accessing SMM BIOS on Dell laptops");
  74. MODULE_LICENSE("GPL");
  75. MODULE_PARM(force, "i");
  76. MODULE_PARM(power_status, "i");
  77. MODULE_PARM_DESC(force, "Force loading without checking for supported models");
  78. MODULE_PARM_DESC(power_status, "Report power status in /proc/i8k");
  80. static ssize_t i8k_read(struct file *, char *, size_t, loff_t *);
  81. static int i8k_ioctl(struct inode *, struct file *, unsigned int,
  82.      unsigned long);
  84. static struct file_operations i8k_fops = {
  85.     read: i8k_read,
  86.     ioctl: i8k_ioctl,
  87. };
  89. typedef struct {
  90.     unsigned int eax;
  91.     unsigned int ebx __attribute__ ((packed));
  92.     unsigned int ecx __attribute__ ((packed));
  93.     unsigned int edx __attribute__ ((packed));
  94.     unsigned int esi __attribute__ ((packed));
  95.     unsigned int edi __attribute__ ((packed));
  96. } SMMRegisters;
  98. typedef struct {
  99.     u8 type;
  100.     u8 length;
  101.     u16 handle;
  102. } DMIHeader;
  104. /*
  105.  * Call the System Management Mode BIOS. Code provided by Jonathan Buzzard.
  106.  */
  107. static int i8k_smm(SMMRegisters *regs)
  108. {
  109.     int rc;
  110.     int eax = regs->eax;
  112.     asm("pushl %%eaxnt" 
  113. "movl 0(%%eax),%%edxnt" 
  114. "push %%edxnt" 
  115. "movl 4(%%eax),%%ebxnt" 
  116. "movl 8(%%eax),%%ecxnt" 
  117. "movl 12(%%eax),%%edxnt" 
  118. "movl 16(%%eax),%%esint" 
  119. "movl 20(%%eax),%%edint" 
  120. "popl %%eaxnt" 
  121. "out %%al,$0xb2nt" 
  122. "out %%al,$0x84nt" 
  123. "xchgl %%eax,(%%esp)nt"
  124. "movl %%ebx,4(%%eax)nt" 
  125. "movl %%ecx,8(%%eax)nt" 
  126. "movl %%edx,12(%%eax)nt" 
  127. "movl %%esi,16(%%eax)nt" 
  128. "movl %%edi,20(%%eax)nt" 
  129. "popl %%edxnt" 
  130. "movl %%edx,0(%%eax)nt" 
  131. "lahfnt" 
  132. "shrl $8,%%eaxnt" 
  133. "andl $1,%%eaxn" 
  134. : "=a" (rc)
  135. : "a" (regs)
  136. : "%ebx", "%ecx", "%edx", "%esi", "%edi", "memory");
  138.     if ((rc != 0) || ((regs->eax & 0xffff) == 0xffff) || (regs->eax == eax)) {
  139. return -EINVAL;
  140.     }
  142.     return 0;
  143. }
  145. /*
  146.  * Read the bios version. Return the version as an integer corresponding
  147.  * to the ascii value, for example "A17" is returned as 0x00413137.
  148.  */
  149. static int i8k_get_bios_version(void)
  150. {
  151.     SMMRegisters regs = { 0, 0, 0, 0, 0, 0 };
  152.     int rc;
  154.     regs.eax = I8K_SMM_BIOS_VERSION;
  155.     if ((rc=i8k_smm(&regs)) < 0) {
  156. return rc;
  157.     }
  159.     return regs.eax;
  160. }
  162. /*
  163.  * Read the machine id.
  164.  */
  165. static int i8k_get_serial_number(unsigned char *buff)
  166. {
  167.     strncpy(buff, serial_number, 16);
  168.     return 0;
  169. }
  171. /*
  172.  * Read the Fn key status.
  173.  */
  174. static int i8k_get_fn_status(void)
  175. {
  176.     SMMRegisters regs = { 0, 0, 0, 0, 0, 0 };
  177.     int rc;
  179.     regs.eax = I8K_SMM_FN_STATUS;
  180.     if ((rc=i8k_smm(&regs)) < 0) {
  181. return rc;
  182.     }
  184.     switch ((regs.eax >> I8K_FN_SHIFT) & I8K_FN_MASK) {
  185.     case I8K_FN_UP:
  186. return I8K_VOL_UP;
  187.     case I8K_FN_DOWN:
  188. return I8K_VOL_DOWN;
  189.     case I8K_FN_MUTE:
  190. return I8K_VOL_MUTE;
  191.     default:
  192. return 0;
  193.     }
  194. }
  196. /*
  197.  * Read the power status.
  198.  */
  199. static int i8k_get_power_status(void)
  200. {
  201.     SMMRegisters regs = { 0, 0, 0, 0, 0, 0 };
  202.     int rc;
  204.     regs.eax = I8K_SMM_POWER_STATUS;
  205.     if ((rc=i8k_smm(&regs)) < 0) {
  206. return rc;
  207.     }
  209.     switch (regs.eax & 0xff) {
  210.     case I8K_POWER_AC:
  211. return I8K_AC;
  212.     default:
  213. return I8K_BATTERY;
  214.     }
  215. }
  217. /*
  218.  * Read the fan status.
  219.  */
  220. static int i8k_get_fan_status(int fan)
  221. {
  222.     SMMRegisters regs = { 0, 0, 0, 0, 0, 0 };
  223.     int rc;
  225.     regs.eax = I8K_SMM_GET_FAN;
  226.     regs.ebx = fan & 0xff;
  227.     if ((rc=i8k_smm(&regs)) < 0) {
  228. return rc;
  229.     }
  231.     return (regs.eax & 0xff);
  232. }
  234. /*
  235.  * Read the fan speed in RPM.
  236.  */
  237. static int i8k_get_fan_speed(int fan)
  238. {
  239.     SMMRegisters regs = { 0, 0, 0, 0, 0, 0 };
  240.     int rc;
  242.     regs.eax = I8K_SMM_GET_SPEED;
  243.     regs.ebx = fan & 0xff;
  244.     if ((rc=i8k_smm(&regs)) < 0) {
  245. return rc;
  246.     }
  248.     return (regs.eax & 0xffff) * I8K_FAN_MULT;
  249. }
  251. /*
  252.  * Set the fan speed (off, low, high). Returns the new fan status.
  253.  */
  254. static int i8k_set_fan(int fan, int speed)
  255. {
  256.     SMMRegisters regs = { 0, 0, 0, 0, 0, 0 };
  257.     int rc;
  259.     speed = (speed < 0) ? 0 : ((speed > I8K_FAN_MAX) ? I8K_FAN_MAX : speed);
  261.     regs.eax = I8K_SMM_SET_FAN;
  262.     regs.ebx = (fan & 0xff) | (speed << 8);
  263.     if ((rc=i8k_smm(&regs)) < 0) {
  264. return rc;
  265.     }
  267.     return (i8k_get_fan_status(fan));
  268. }
  270. /*
  271.  * Read the cpu temperature.
  272.  */
  273. static int i8k_get_cpu_temp(void)
  274. {
  275.     SMMRegisters regs = { 0, 0, 0, 0, 0, 0 };
  276.     int rc;
  277.     int temp;
  279. #ifdef I8K_TEMPERATURE_BUG
  280.     static int prev = 0;
  281. #endif
  283.     regs.eax = I8K_SMM_GET_TEMP;
  284.     if ((rc=i8k_smm(&regs)) < 0) {
  285. return rc;
  286.     }
  287.     temp = regs.eax & 0xff;
  289. #ifdef I8K_TEMPERATURE_BUG
  290.     /*
  291.      * Sometimes the temperature sensor returns 0x99, which is out of range.
  292.      * In this case we return (once) the previous cached value. For example:
  293.      # 1003655137 00000058 00005a4b
  294.      # 1003655138 00000099 00003a80 <--- 0x99 = 153 degrees
  295.      # 1003655139 00000054 00005c52
  296.      */
  297.     if (temp > I8K_MAX_TEMP) {
  298. temp = prev;
  299. prev = I8K_MAX_TEMP;
  300.     } else {
  301. prev = temp;
  302.     }
  303. #endif
  305.     return temp;
  306. }
  308. static int i8k_get_dell_signature(void)
  309. {
  310.     SMMRegisters regs = { 0, 0, 0, 0, 0, 0 };
  311.     int rc;
  313.     regs.eax = I8K_SMM_GET_DELL_SIG;
  314.     if ((rc=i8k_smm(&regs)) < 0) {
  315. return rc;
  316.     }
  318.     if ((regs.eax == 1145651527) && (regs.edx == 1145392204)) {
  319. return 0;
  320.     } else {
  321. return -1;
  322.     }
  323. }
  325. static int i8k_ioctl(struct inode *ip, struct file *fp, unsigned int cmd,
  326.      unsigned long arg)
  327. {
  328.     int val;
  329.     int speed;
  330.     unsigned char buff[16];
  332.     if (!arg) {
  333. return -EINVAL;
  334.     }
  336.     switch (cmd) {
  337.     case I8K_BIOS_VERSION:
  338. val = i8k_get_bios_version();
  339. break;
  341.     case I8K_MACHINE_ID:
  342. memset(buff, 0, 16);
  343. val = i8k_get_serial_number(buff);
  344. break;
  346.     case I8K_FN_STATUS:
  347. val = i8k_get_fn_status();
  348. break;
  350.     case I8K_POWER_STATUS:
  351. val = i8k_get_power_status();
  352. break;
  354.     case I8K_GET_TEMP:
  355. val = i8k_get_cpu_temp();
  356. break;
  358.     case I8K_GET_SPEED:
  359. if (copy_from_user(&val, (int *)arg, sizeof(int))) {
  360.     return -EFAULT;
  361. }
  362. val = i8k_get_fan_speed(val);
  363. break;
  365.     case I8K_GET_FAN:
  366. if (copy_from_user(&val, (int *)arg, sizeof(int))) {
  367.     return -EFAULT;
  368. }
  369. val = i8k_get_fan_status(val);
  370. break;
  372.     case I8K_SET_FAN:
  373. if (copy_from_user(&val, (int *)arg, sizeof(int))) {
  374.     return -EFAULT;
  375. }
  376. if (copy_from_user(&speed, (int *)arg+1, sizeof(int))) {
  377.     return -EFAULT;
  378. }
  379. val = i8k_set_fan(val, speed);
  380. break;
  382.     default:
  383. return -EINVAL;
  384.     }
  386.     if (val < 0) {
  387. return val;
  388.     }
  390.     switch (cmd) {
  391.     case I8K_BIOS_VERSION:
  392. if (copy_to_user((int *)arg, &val, 4)) {
  393.     return -EFAULT;
  394. }
  395. break;
  396.     case I8K_MACHINE_ID:
  397. if (copy_to_user((int *)arg, buff, 16)) {
  398.     return -EFAULT;
  399. }
  400. break;
  401.     default:
  402. if (copy_to_user((int *)arg, &val, sizeof(int))) {
  403.     return -EFAULT;
  404. }
  405. break;
  406.     }
  408.     return 0;
  409. }
  411. /*
  412.  * Print the information for /proc/i8k.
  413.  */
  414. static int i8k_get_info(char *buffer, char **start, off_t fpos, int length)
  415. {
  416.     int n, fn_key, cpu_temp, ac_power;
  417.     int left_fan, right_fan, left_speed, right_speed;
  419.     cpu_temp     = i8k_get_cpu_temp(); /* 11100 祍 */
  420.     left_fan     = i8k_get_fan_status(I8K_FAN_LEFT); /*   580 祍 */
  421.     right_fan    = i8k_get_fan_status(I8K_FAN_RIGHT); /*   580 祍 */
  422.     left_speed   = i8k_get_fan_speed(I8K_FAN_LEFT); /*   580 祍 */
  423.     right_speed  = i8k_get_fan_speed(I8K_FAN_RIGHT); /*   580 祍 */
  424.     fn_key       = i8k_get_fn_status(); /*   750 祍 */
  425.     if (power_status) {
  426. ac_power = i8k_get_power_status(); /* 14700 祍 */
  427.     } else {
  428. ac_power = -1;
  429.     }
  431.     /*
  432.      * Info:
  433.      *
  434.      * 1)  Format version (this will change if format changes)
  435.      * 2)  BIOS version
  436.      * 3)  BIOS machine ID
  437.      * 4)  Cpu temperature
  438.      * 5)  Left fan status
  439.      * 6)  Right fan status
  440.      * 7)  Left fan speed
  441.      * 8)  Right fan speed
  442.      * 9)  AC power
  443.      * 10) Fn Key status
  444.      */
  445.     n = sprintf(buffer, "%s %s %s %d %d %d %d %d %d %dn",
  446. I8K_PROC_FMT,
  447. bios_version,
  448. serial_number,
  449. cpu_temp,
  450. left_fan,
  451. right_fan,
  452. left_speed,
  453. right_speed,
  454. ac_power,
  455. fn_key);
  457.     return n;
  458. }
  460. static ssize_t i8k_read(struct file *f, char *buffer, size_t len, loff_t *fpos)
  461. {
  462.     int n;
  463.     char info[128];
  465.     n = i8k_get_info(info, NULL, 0, 128);
  466.     if (n <= 0) {
  467. return n;
  468.     }
  470.     if (*fpos >= n) {
  471. return 0;
  472.     }
  474.     if ((*fpos + len) >= n) {
  475. len = n - *fpos;
  476.     }
  478.     if (copy_to_user(buffer, info, len) != 0) {
  479. return -EFAULT;
  480.     }
  482.     *fpos += len;
  483.     return len;
  484. }
  486. static char* __init string_trim(char *s, int size)
  487. {
  488.     int len;
  489.     char *p;
  491.     if ((len = strlen(s)) > size) {
  492. len = size;
  493.     }
  495.     for (p=s+len-1; len && (*p==' '); len--,p--) {
  496. *p = '';
  497.     }
  499.     return s;
  500. }
  502. /* DMI code, stolen from arch/i386/kernel/dmi_scan.c */
  504. /*
  505.  * |<-- dmi->length -->|
  506.  * |                   |
  507.  * |dmi header    s=N  | string1,, ..., stringN,, ..., 
  508.  *                |                       |
  509.  *                +-----------------------+
  510.  */
  511. static char* __init dmi_string(DMIHeader *dmi, u8 s)
  512. {
  513.     u8 *p;
  515.     if (!s) {
  516. return "";
  517.     }
  518.     s--;
  520.     p = (u8 *)dmi + dmi->length;
  521.     while (s > 0) {
  522. p += strlen(p);
  523. p++;
  524. s--;
  525.     }
  527.     return p;
  528. }
  530. static void __init dmi_decode(DMIHeader *dmi)
  531. {
  532.     u8 *data = (u8 *) dmi;
  533.     char *p;
  535. #ifdef I8K_DEBUG
  536.     int i;
  537.     printk("%08x ", (int)data);
  538.     for (i=0; i<data[1] && i<64; i++) {
  539. printk("%02x ", data[i]);
  540.     }
  541.     printk("n");
  542. #endif
  544.     switch (dmi->type) {
  545.     case  0: /* BIOS Information */
  546. p = dmi_string(dmi,data[5]);
  547. if (*p) {
  548.     strncpy(bios_version, p, sizeof(bios_version));
  549.     string_trim(bios_version, sizeof(bios_version));
  550. }
  551. break;
  552.     case 1: /* System Information */
  553. p = dmi_string(dmi,data[4]);
  554. if (*p) {
  555.     strncpy(system_vendor, p, sizeof(system_vendor));
  556.     string_trim(system_vendor, sizeof(system_vendor));
  557. }
  558. p = dmi_string(dmi,data[5]);
  559. if (*p) {
  560.     strncpy(product_name, p, sizeof(product_name));
  561.     string_trim(product_name, sizeof(product_name));
  562. }
  563. p = dmi_string(dmi,data[7]);
  564. if (*p) {
  565.     strncpy(serial_number, p, sizeof(serial_number));
  566.     string_trim(serial_number, sizeof(serial_number));
  567. }
  568. break;
  569.     }
  570. }
  572. static int __init dmi_table(u32 base, int len, int num, void (*fn)(DMIHeader*))
  573. {
  574.     u8 *buf;
  575.     u8 *data;
  576.     DMIHeader *dmi;
  577.     int i = 1;
  579.     buf = ioremap(base, len);
  580.     if (buf == NULL) {
  581. return -1;
  582.     }
  583.     data = buf;
  585.     /*
  586.      * Stop when we see al the items the table claimed to have
  587.      * or we run off the end of the table (also happens)
  588.      */
  589.     while ((i<num) && ((data-buf) < len)) {
  590. dmi = (DMIHeader *)data;
  591. /*
  592.  * Avoid misparsing crud if the length of the last
  593.  * record is crap
  594.  */
  595. if ((data-buf+dmi->length) >= len) {
  596.     break;
  597. }
  598. fn(dmi);
  599. data += dmi->length;
  600. /*
  601.  * Don't go off the end of the data if there is
  602.  * stuff looking like string fill past the end
  603.  */
  604. while (((data-buf) < len) && (*data || data[1])) {
  605.     data++;
  606. }
  607. data += 2;
  608. i++;
  609.     }
  610.     iounmap(buf);
  612.     return 0;
  613. }
  615. static int __init dmi_iterate(void (*decode)(DMIHeader *))
  616. {
  617.     unsigned char buf[20];
  618.     long fp = 0x000e0000L;
  619.     fp -= 16;
  621.     while (fp < 0x000fffffL) {
  622. fp += 16;
  623. isa_memcpy_fromio(buf, fp, 20);
  624. if (memcmp(buf, "_DMI_", 5)==0) {
  625.     u16 num  = buf[13]<<8  | buf[12];
  626.     u16 len  = buf [7]<<8  | buf [6];
  627.     u32 base = buf[11]<<24 | buf[10]<<16 | buf[9]<<8 | buf[8];
  628. #ifdef I8K_DEBUG
  629.     printk(KERN_INFO "DMI %d.%d present.n",
  630.    buf[14]>>4, buf[14]&0x0F);
  631.     printk(KERN_INFO "%d structures occupying %d bytes.n",
  632.    buf[13]<<8 | buf[12],
  633.    buf [7]<<8 | buf[6]);
  634.     printk(KERN_INFO "DMI table at 0x%08X.n",
  635.    buf[11]<<24 | buf[10]<<16 | buf[9]<<8 | buf[8]);
  636. #endif
  637.     if (dmi_table(base, len, num, decode)==0) {
  638. return 0;
  639.     }
  640. }
  641.     }
  642.     return -1;
  643. }
  644. /* end of DMI code */
  646. /*
  647.  * Get DMI information.
  648.  */
  649. static int __init i8k_dmi_probe(void)
  650. {
  651.     char **p;
  653.     if (dmi_iterate(dmi_decode) != 0) {
  654. printk(KERN_INFO "i8k: unable to get DMI informationn");
  655. return -ENODEV;
  656.     }
  658.     if (strncmp(system_vendor,DELL_SIGNATURE,strlen(DELL_SIGNATURE)) != 0) {
  659. printk(KERN_INFO "i8k: not running on a Dell systemn");
  660. return -ENODEV;
  661.     }
  663.     for (p=supported_models; ; p++) {
  664. if (!*p) {
  665.     printk(KERN_INFO "i8k: unsupported model: %sn", product_name);
  666.     return -ENODEV;
  667. }
  668. if (strncmp(product_name,*p,strlen(*p)) == 0) {
  669.     break;
  670. }
  671.     }
  673.     return 0;
  674. }
  676. /*
  677.  * Probe for the presence of a supported laptop.
  678.  */
  679. static int __init i8k_probe(void)
  680. {
  681.     char buff[4];
  682.     int version;
  683.     int smm_found = 0;
  685.     /*
  686.      * Get DMI information
  687.      */
  688.     if (i8k_dmi_probe() != 0) {
  689. printk(KERN_INFO "i8k: vendor=%s, model=%s, version=%sn",
  690.        system_vendor, product_name, bios_version);
  691.     }
  693.     /*
  694.      * Get SMM Dell signature
  695.      */
  696.     if (i8k_get_dell_signature() != 0) {
  697. printk(KERN_INFO "i8k: unable to get SMM Dell signaturen");
  698.     } else {
  699. smm_found = 1;
  700.     }
  702.     /*
  703.      * Get SMM BIOS version.
  704.      */
  705.     version = i8k_get_bios_version();
  706.     if (version <= 0) {
  707. printk(KERN_INFO "i8k: unable to get SMM BIOS versionn");
  708.     } else {
  709. smm_found = 1;
  710. buff[0] = (version >> 16) & 0xff;
  711. buff[1] = (version >>  8) & 0xff;
  712. buff[2] = (version)       & 0xff;
  713. buff[3] = '';
  714. /*
  715.  * If DMI BIOS version is unknown use SMM BIOS version.
  716.  */
  717. if (bios_version[0] == '?') {
  718.     strcpy(bios_version, buff);
  719. }
  720. /*
  721.  * Check if the two versions match.
  722.  */
  723. if (strncmp(buff,bios_version,sizeof(bios_version)) != 0) {
  724.     printk(KERN_INFO "i8k: BIOS version mismatch: %s != %sn",
  725.    buff, bios_version);
  726. }
  727.     }
  729.     if (!smm_found && !force) {
  730. return -ENODEV;
  731.     }
  733.     return 0;
  734. }
  736. #ifdef MODULE
  737. static
  738. #endif
  739. int __init i8k_init(void)
  740. {
  741.     struct proc_dir_entry *proc_i8k;
  743.     /* Are we running on an supported laptop? */
  744.     if (i8k_probe() != 0) {
  745. return -ENODEV;
  746.     }
  748.     /* Register the proc entry */
  749.     proc_i8k = create_proc_info_entry("i8k", 0, NULL, i8k_get_info);
  750.     if (!proc_i8k) {
  751. return -ENOENT;
  752.     }
  753.     proc_i8k->proc_fops = &i8k_fops;
  754.     SET_MODULE_OWNER(proc_i8k);
  756.     printk(KERN_INFO
  757.    "Dell laptop SMM driver v%s Massimo Dal Zotto (dz@debian.org)n",
  758.    I8K_VERSION);
  760.     return 0;
  761. }
  763. #ifdef MODULE
  764. int init_module(void)
  765. {
  766.     return i8k_init();
  767. }
  769. void cleanup_module(void)
  770. {
  771.     /* Remove the proc entry */
  772.     remove_proc_entry("i8k", NULL);
  774.     printk(KERN_INFO "i8k: module unloadedn");
  775. }
  776. #endif
  778. /* end of file */