2019-05-24 10:03:49 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
2005-04-16 22:20:36 +00:00
|
|
|
/* toshiba.c -- Linux driver for accessing the SMM on Toshiba laptops
|
|
|
|
*
|
|
|
|
* Copyright (c) 1996-2001 Jonathan A. Buzzard (jonathan@buzzard.org.uk)
|
|
|
|
*
|
|
|
|
* Valuable assistance and patches from:
|
|
|
|
* Tom May <tom@you-bastards.com>
|
|
|
|
* Rob Napier <rnapier@employees.org>
|
|
|
|
*
|
|
|
|
* Fn status port numbers for machine ID's courtesy of
|
|
|
|
* 0xfc02: Scott Eisert <scott.e@sky-eye.com>
|
|
|
|
* 0xfc04: Steve VanDevender <stevev@efn.org>
|
|
|
|
* 0xfc08: Garth Berry <garth@itsbruce.net>
|
|
|
|
* 0xfc0a: Egbert Eich <eich@xfree86.org>
|
|
|
|
* 0xfc10: Andrew Lofthouse <Andrew.Lofthouse@robins.af.mil>
|
|
|
|
* 0xfc11: Spencer Olson <solson@novell.com>
|
|
|
|
* 0xfc13: Claudius Frankewitz <kryp@gmx.de>
|
|
|
|
* 0xfc15: Tom May <tom@you-bastards.com>
|
|
|
|
* 0xfc17: Dave Konrad <konrad@xenia.it>
|
|
|
|
* 0xfc1a: George Betzos <betzos@engr.colostate.edu>
|
|
|
|
* 0xfc1b: Munemasa Wada <munemasa@jnovel.co.jp>
|
|
|
|
* 0xfc1d: Arthur Liu <armie@slap.mine.nu>
|
|
|
|
* 0xfc5a: Jacques L'helgoualc'h <lhh@free.fr>
|
|
|
|
* 0xfcd1: Mr. Dave Konrad <konrad@xenia.it>
|
|
|
|
*
|
|
|
|
* WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING
|
|
|
|
*
|
|
|
|
* This code is covered by the GNU GPL and you are free to make any
|
|
|
|
* changes you wish to it under the terms of the license. However the
|
|
|
|
* code has the potential to render your computer and/or someone else's
|
|
|
|
* unusable. Please proceed with care when modifying the code.
|
|
|
|
*
|
|
|
|
* Note: Unfortunately the laptop hardware can close the System Configuration
|
|
|
|
* Interface on it's own accord. It is therefore necessary for *all*
|
|
|
|
* programs using this driver to be aware that *any* SCI call can fail at
|
|
|
|
* *any* time. It is up to any program to be aware of this eventuality
|
|
|
|
* and take appropriate steps.
|
|
|
|
*
|
|
|
|
* The information used to write this driver has been obtained by reverse
|
|
|
|
* engineering the software supplied by Toshiba for their portable computers in
|
|
|
|
* strict accordance with the European Council Directive 92/250/EEC on the legal
|
|
|
|
* protection of computer programs, and it's implementation into English Law by
|
|
|
|
* the Copyright (Computer Programs) Regulations 1992 (S.I. 1992 No.3233).
|
|
|
|
*/
|
|
|
|
|
|
|
|
#define TOSH_VERSION "1.11 26/9/2001"
|
|
|
|
#define TOSH_DEBUG 0
|
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/fcntl.h>
|
|
|
|
#include <linux/miscdevice.h>
|
|
|
|
#include <linux/ioport.h>
|
|
|
|
#include <asm/io.h>
|
2016-12-24 19:46:01 +00:00
|
|
|
#include <linux/uaccess.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/stat.h>
|
|
|
|
#include <linux/proc_fs.h>
|
2007-02-10 09:46:15 +00:00
|
|
|
#include <linux/seq_file.h>
|
2010-06-02 12:28:52 +00:00
|
|
|
#include <linux/mutex.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/toshiba.h>
|
|
|
|
|
2005-06-25 21:54:22 +00:00
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
MODULE_AUTHOR("Jonathan Buzzard <jonathan@buzzard.org.uk>");
|
|
|
|
MODULE_DESCRIPTION("Toshiba laptop SMM driver");
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-06-02 12:28:52 +00:00
|
|
|
static DEFINE_MUTEX(tosh_mutex);
|
2005-06-25 21:54:22 +00:00
|
|
|
static int tosh_fn;
|
|
|
|
module_param_named(fn, tosh_fn, int, 0);
|
|
|
|
MODULE_PARM_DESC(fn, "User specified Fn key detection port");
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-06-25 21:54:22 +00:00
|
|
|
static int tosh_id;
|
|
|
|
static int tosh_bios;
|
|
|
|
static int tosh_date;
|
|
|
|
static int tosh_sci;
|
|
|
|
static int tosh_fan;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-01-04 16:19:55 +00:00
|
|
|
static long tosh_ioctl(struct file *, unsigned int,
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned long);
|
|
|
|
|
|
|
|
|
2006-07-03 07:24:21 +00:00
|
|
|
static const struct file_operations tosh_fops = {
|
2005-04-16 22:20:36 +00:00
|
|
|
.owner = THIS_MODULE,
|
2010-01-04 16:19:55 +00:00
|
|
|
.unlocked_ioctl = tosh_ioctl,
|
llseek: automatically add .llseek fop
All file_operations should get a .llseek operation so we can make
nonseekable_open the default for future file operations without a
.llseek pointer.
The three cases that we can automatically detect are no_llseek, seq_lseek
and default_llseek. For cases where we can we can automatically prove that
the file offset is always ignored, we use noop_llseek, which maintains
the current behavior of not returning an error from a seek.
New drivers should normally not use noop_llseek but instead use no_llseek
and call nonseekable_open at open time. Existing drivers can be converted
to do the same when the maintainer knows for certain that no user code
relies on calling seek on the device file.
The generated code is often incorrectly indented and right now contains
comments that clarify for each added line why a specific variant was
chosen. In the version that gets submitted upstream, the comments will
be gone and I will manually fix the indentation, because there does not
seem to be a way to do that using coccinelle.
Some amount of new code is currently sitting in linux-next that should get
the same modifications, which I will do at the end of the merge window.
Many thanks to Julia Lawall for helping me learn to write a semantic
patch that does all this.
===== begin semantic patch =====
// This adds an llseek= method to all file operations,
// as a preparation for making no_llseek the default.
//
// The rules are
// - use no_llseek explicitly if we do nonseekable_open
// - use seq_lseek for sequential files
// - use default_llseek if we know we access f_pos
// - use noop_llseek if we know we don't access f_pos,
// but we still want to allow users to call lseek
//
@ open1 exists @
identifier nested_open;
@@
nested_open(...)
{
<+...
nonseekable_open(...)
...+>
}
@ open exists@
identifier open_f;
identifier i, f;
identifier open1.nested_open;
@@
int open_f(struct inode *i, struct file *f)
{
<+...
(
nonseekable_open(...)
|
nested_open(...)
)
...+>
}
@ read disable optional_qualifier exists @
identifier read_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
expression E;
identifier func;
@@
ssize_t read_f(struct file *f, char *p, size_t s, loff_t *off)
{
<+...
(
*off = E
|
*off += E
|
func(..., off, ...)
|
E = *off
)
...+>
}
@ read_no_fpos disable optional_qualifier exists @
identifier read_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
@@
ssize_t read_f(struct file *f, char *p, size_t s, loff_t *off)
{
... when != off
}
@ write @
identifier write_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
expression E;
identifier func;
@@
ssize_t write_f(struct file *f, const char *p, size_t s, loff_t *off)
{
<+...
(
*off = E
|
*off += E
|
func(..., off, ...)
|
E = *off
)
...+>
}
@ write_no_fpos @
identifier write_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
@@
ssize_t write_f(struct file *f, const char *p, size_t s, loff_t *off)
{
... when != off
}
@ fops0 @
identifier fops;
@@
struct file_operations fops = {
...
};
@ has_llseek depends on fops0 @
identifier fops0.fops;
identifier llseek_f;
@@
struct file_operations fops = {
...
.llseek = llseek_f,
...
};
@ has_read depends on fops0 @
identifier fops0.fops;
identifier read_f;
@@
struct file_operations fops = {
...
.read = read_f,
...
};
@ has_write depends on fops0 @
identifier fops0.fops;
identifier write_f;
@@
struct file_operations fops = {
...
.write = write_f,
...
};
@ has_open depends on fops0 @
identifier fops0.fops;
identifier open_f;
@@
struct file_operations fops = {
...
.open = open_f,
...
};
// use no_llseek if we call nonseekable_open
////////////////////////////////////////////
@ nonseekable1 depends on !has_llseek && has_open @
identifier fops0.fops;
identifier nso ~= "nonseekable_open";
@@
struct file_operations fops = {
... .open = nso, ...
+.llseek = no_llseek, /* nonseekable */
};
@ nonseekable2 depends on !has_llseek @
identifier fops0.fops;
identifier open.open_f;
@@
struct file_operations fops = {
... .open = open_f, ...
+.llseek = no_llseek, /* open uses nonseekable */
};
// use seq_lseek for sequential files
/////////////////////////////////////
@ seq depends on !has_llseek @
identifier fops0.fops;
identifier sr ~= "seq_read";
@@
struct file_operations fops = {
... .read = sr, ...
+.llseek = seq_lseek, /* we have seq_read */
};
// use default_llseek if there is a readdir
///////////////////////////////////////////
@ fops1 depends on !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier readdir_e;
@@
// any other fop is used that changes pos
struct file_operations fops = {
... .readdir = readdir_e, ...
+.llseek = default_llseek, /* readdir is present */
};
// use default_llseek if at least one of read/write touches f_pos
/////////////////////////////////////////////////////////////////
@ fops2 depends on !fops1 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier read.read_f;
@@
// read fops use offset
struct file_operations fops = {
... .read = read_f, ...
+.llseek = default_llseek, /* read accesses f_pos */
};
@ fops3 depends on !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier write.write_f;
@@
// write fops use offset
struct file_operations fops = {
... .write = write_f, ...
+ .llseek = default_llseek, /* write accesses f_pos */
};
// Use noop_llseek if neither read nor write accesses f_pos
///////////////////////////////////////////////////////////
@ fops4 depends on !fops1 && !fops2 && !fops3 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier read_no_fpos.read_f;
identifier write_no_fpos.write_f;
@@
// write fops use offset
struct file_operations fops = {
...
.write = write_f,
.read = read_f,
...
+.llseek = noop_llseek, /* read and write both use no f_pos */
};
@ depends on has_write && !has_read && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier write_no_fpos.write_f;
@@
struct file_operations fops = {
... .write = write_f, ...
+.llseek = noop_llseek, /* write uses no f_pos */
};
@ depends on has_read && !has_write && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier read_no_fpos.read_f;
@@
struct file_operations fops = {
... .read = read_f, ...
+.llseek = noop_llseek, /* read uses no f_pos */
};
@ depends on !has_read && !has_write && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
@@
struct file_operations fops = {
...
+.llseek = noop_llseek, /* no read or write fn */
};
===== End semantic patch =====
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
Cc: Julia Lawall <julia@diku.dk>
Cc: Christoph Hellwig <hch@infradead.org>
2010-08-15 16:52:59 +00:00
|
|
|
.llseek = noop_llseek,
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static struct miscdevice tosh_device = {
|
|
|
|
TOSH_MINOR_DEV,
|
|
|
|
"toshiba",
|
|
|
|
&tosh_fops
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Read the Fn key status
|
|
|
|
*/
|
|
|
|
#ifdef CONFIG_PROC_FS
|
|
|
|
static int tosh_fn_status(void)
|
|
|
|
{
|
|
|
|
unsigned char scan;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
if (tosh_fn!=0) {
|
|
|
|
scan = inb(tosh_fn);
|
|
|
|
} else {
|
|
|
|
local_irq_save(flags);
|
|
|
|
outb(0x8e, 0xe4);
|
|
|
|
scan = inb(0xe5);
|
|
|
|
local_irq_restore(flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
return (int) scan;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* For the Portage 610CT and the Tecra 700CS/700CDT emulate the HCI fan function
|
|
|
|
*/
|
|
|
|
static int tosh_emulate_fan(SMMRegisters *regs)
|
|
|
|
{
|
|
|
|
unsigned long eax,ecx,flags;
|
|
|
|
unsigned char al;
|
|
|
|
|
|
|
|
eax = regs->eax & 0xff00;
|
|
|
|
ecx = regs->ecx & 0xffff;
|
|
|
|
|
|
|
|
/* Portage 610CT */
|
|
|
|
|
|
|
|
if (tosh_id==0xfccb) {
|
|
|
|
if (eax==0xfe00) {
|
|
|
|
/* fan status */
|
|
|
|
local_irq_save(flags);
|
|
|
|
outb(0xbe, 0xe4);
|
|
|
|
al = inb(0xe5);
|
|
|
|
local_irq_restore(flags);
|
|
|
|
regs->eax = 0x00;
|
|
|
|
regs->ecx = (unsigned int) (al & 0x01);
|
|
|
|
}
|
|
|
|
if ((eax==0xff00) && (ecx==0x0000)) {
|
|
|
|
/* fan off */
|
|
|
|
local_irq_save(flags);
|
|
|
|
outb(0xbe, 0xe4);
|
|
|
|
al = inb(0xe5);
|
|
|
|
outb(0xbe, 0xe4);
|
|
|
|
outb (al | 0x01, 0xe5);
|
|
|
|
local_irq_restore(flags);
|
|
|
|
regs->eax = 0x00;
|
|
|
|
regs->ecx = 0x00;
|
|
|
|
}
|
|
|
|
if ((eax==0xff00) && (ecx==0x0001)) {
|
|
|
|
/* fan on */
|
|
|
|
local_irq_save(flags);
|
|
|
|
outb(0xbe, 0xe4);
|
|
|
|
al = inb(0xe5);
|
|
|
|
outb(0xbe, 0xe4);
|
|
|
|
outb(al & 0xfe, 0xe5);
|
|
|
|
local_irq_restore(flags);
|
|
|
|
regs->eax = 0x00;
|
|
|
|
regs->ecx = 0x01;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Tecra 700CS/CDT */
|
|
|
|
|
|
|
|
if (tosh_id==0xfccc) {
|
|
|
|
if (eax==0xfe00) {
|
|
|
|
/* fan status */
|
|
|
|
local_irq_save(flags);
|
|
|
|
outb(0xe0, 0xe4);
|
|
|
|
al = inb(0xe5);
|
|
|
|
local_irq_restore(flags);
|
|
|
|
regs->eax = 0x00;
|
|
|
|
regs->ecx = al & 0x01;
|
|
|
|
}
|
|
|
|
if ((eax==0xff00) && (ecx==0x0000)) {
|
|
|
|
/* fan off */
|
|
|
|
local_irq_save(flags);
|
|
|
|
outb(0xe0, 0xe4);
|
|
|
|
al = inb(0xe5);
|
|
|
|
outw(0xe0 | ((al & 0xfe) << 8), 0xe4);
|
|
|
|
local_irq_restore(flags);
|
|
|
|
regs->eax = 0x00;
|
|
|
|
regs->ecx = 0x00;
|
|
|
|
}
|
|
|
|
if ((eax==0xff00) && (ecx==0x0001)) {
|
|
|
|
/* fan on */
|
|
|
|
local_irq_save(flags);
|
|
|
|
outb(0xe0, 0xe4);
|
|
|
|
al = inb(0xe5);
|
|
|
|
outw(0xe0 | ((al | 0x01) << 8), 0xe4);
|
|
|
|
local_irq_restore(flags);
|
|
|
|
regs->eax = 0x00;
|
|
|
|
regs->ecx = 0x01;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Put the laptop into System Management Mode
|
|
|
|
*/
|
|
|
|
int tosh_smm(SMMRegisters *regs)
|
|
|
|
{
|
|
|
|
int eax;
|
|
|
|
|
|
|
|
asm ("# load the values into the registers\n\t" \
|
|
|
|
"pushl %%eax\n\t" \
|
|
|
|
"movl 0(%%eax),%%edx\n\t" \
|
|
|
|
"push %%edx\n\t" \
|
|
|
|
"movl 4(%%eax),%%ebx\n\t" \
|
|
|
|
"movl 8(%%eax),%%ecx\n\t" \
|
|
|
|
"movl 12(%%eax),%%edx\n\t" \
|
|
|
|
"movl 16(%%eax),%%esi\n\t" \
|
|
|
|
"movl 20(%%eax),%%edi\n\t" \
|
|
|
|
"popl %%eax\n\t" \
|
|
|
|
"# call the System Management mode\n\t" \
|
|
|
|
"inb $0xb2,%%al\n\t"
|
|
|
|
"# fill out the memory with the values in the registers\n\t" \
|
|
|
|
"xchgl %%eax,(%%esp)\n\t"
|
|
|
|
"movl %%ebx,4(%%eax)\n\t" \
|
|
|
|
"movl %%ecx,8(%%eax)\n\t" \
|
|
|
|
"movl %%edx,12(%%eax)\n\t" \
|
|
|
|
"movl %%esi,16(%%eax)\n\t" \
|
|
|
|
"movl %%edi,20(%%eax)\n\t" \
|
|
|
|
"popl %%edx\n\t" \
|
|
|
|
"movl %%edx,0(%%eax)\n\t" \
|
|
|
|
"# setup the return value to the carry flag\n\t" \
|
|
|
|
"lahf\n\t" \
|
|
|
|
"shrl $8,%%eax\n\t" \
|
|
|
|
"andl $1,%%eax\n" \
|
|
|
|
: "=a" (eax)
|
|
|
|
: "a" (regs)
|
|
|
|
: "%ebx", "%ecx", "%edx", "%esi", "%edi", "memory");
|
|
|
|
|
|
|
|
return eax;
|
|
|
|
}
|
2006-12-07 04:38:41 +00:00
|
|
|
EXPORT_SYMBOL(tosh_smm);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
2010-01-04 16:19:55 +00:00
|
|
|
static long tosh_ioctl(struct file *fp, unsigned int cmd, unsigned long arg)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
SMMRegisters regs;
|
|
|
|
SMMRegisters __user *argp = (SMMRegisters __user *)arg;
|
|
|
|
unsigned short ax,bx;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
if (!argp)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (copy_from_user(®s, argp, sizeof(SMMRegisters)))
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
switch (cmd) {
|
|
|
|
case TOSH_SMM:
|
|
|
|
ax = regs.eax & 0xff00;
|
|
|
|
bx = regs.ebx & 0xffff;
|
|
|
|
/* block HCI calls to read/write memory & PCI devices */
|
|
|
|
if (((ax==0xff00) || (ax==0xfe00)) && (bx>0x0069))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
/* do we need to emulate the fan ? */
|
2010-06-02 12:28:52 +00:00
|
|
|
mutex_lock(&tosh_mutex);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (tosh_fan==1) {
|
|
|
|
if (((ax==0xf300) || (ax==0xf400)) && (bx==0x0004)) {
|
|
|
|
err = tosh_emulate_fan(®s);
|
2010-06-02 12:28:52 +00:00
|
|
|
mutex_unlock(&tosh_mutex);
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
err = tosh_smm(®s);
|
2010-06-02 12:28:52 +00:00
|
|
|
mutex_unlock(&tosh_mutex);
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (copy_to_user(argp, ®s, sizeof(SMMRegisters)))
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
return (err==0) ? 0:-EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Print the information for /proc/toshiba
|
|
|
|
*/
|
|
|
|
#ifdef CONFIG_PROC_FS
|
2007-02-10 09:46:15 +00:00
|
|
|
static int proc_toshiba_show(struct seq_file *m, void *v)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
int key;
|
|
|
|
|
|
|
|
key = tosh_fn_status();
|
|
|
|
|
|
|
|
/* Arguments
|
|
|
|
0) Linux driver version (this will change if format changes)
|
|
|
|
1) Machine ID
|
|
|
|
2) SCI version
|
|
|
|
3) BIOS version (major, minor)
|
|
|
|
4) BIOS date (in SCI date format)
|
|
|
|
5) Fn Key status
|
|
|
|
*/
|
2007-02-10 09:46:15 +00:00
|
|
|
seq_printf(m, "1.1 0x%04x %d.%d %d.%d 0x%04x 0x%02x\n",
|
2005-04-16 22:20:36 +00:00
|
|
|
tosh_id,
|
|
|
|
(tosh_sci & 0xff00)>>8,
|
|
|
|
tosh_sci & 0xff,
|
|
|
|
(tosh_bios & 0xff00)>>8,
|
|
|
|
tosh_bios & 0xff,
|
|
|
|
tosh_date,
|
|
|
|
key);
|
2007-02-10 09:46:15 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Determine which port to use for the Fn key status
|
|
|
|
*/
|
|
|
|
static void tosh_set_fn_port(void)
|
|
|
|
{
|
|
|
|
switch (tosh_id) {
|
|
|
|
case 0xfc02: case 0xfc04: case 0xfc09: case 0xfc0a: case 0xfc10:
|
|
|
|
case 0xfc11: case 0xfc13: case 0xfc15: case 0xfc1a: case 0xfc1b:
|
|
|
|
case 0xfc5a:
|
|
|
|
tosh_fn = 0x62;
|
|
|
|
break;
|
|
|
|
case 0xfc08: case 0xfc17: case 0xfc1d: case 0xfcd1: case 0xfce0:
|
|
|
|
case 0xfce2:
|
|
|
|
tosh_fn = 0x68;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
tosh_fn = 0x00;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Get the machine identification number of the current model
|
|
|
|
*/
|
2006-03-24 11:15:36 +00:00
|
|
|
static int tosh_get_machine_id(void __iomem *bios)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
int id;
|
|
|
|
SMMRegisters regs;
|
|
|
|
unsigned short bx,cx;
|
|
|
|
unsigned long address;
|
|
|
|
|
2006-03-24 11:15:36 +00:00
|
|
|
id = (0x100*(int) readb(bios+0xfffe))+((int) readb(bios+0xfffa));
|
2005-06-25 21:54:22 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* do we have a SCTTable machine identication number on our hands */
|
|
|
|
|
|
|
|
if (id==0xfc2f) {
|
|
|
|
|
|
|
|
/* start by getting a pointer into the BIOS */
|
|
|
|
|
|
|
|
regs.eax = 0xc000;
|
|
|
|
regs.ebx = 0x0000;
|
|
|
|
regs.ecx = 0x0000;
|
|
|
|
tosh_smm(®s);
|
|
|
|
bx = (unsigned short) (regs.ebx & 0xffff);
|
|
|
|
|
|
|
|
/* At this point in the Toshiba routines under MS Windows
|
|
|
|
the bx register holds 0xe6f5. However my code is producing
|
|
|
|
a different value! For the time being I will just fudge the
|
|
|
|
value. This has been verified on a Satellite Pro 430CDT,
|
|
|
|
Tecra 750CDT, Tecra 780DVD and Satellite 310CDT. */
|
|
|
|
#if TOSH_DEBUG
|
2019-08-18 07:34:31 +00:00
|
|
|
pr_debug("toshiba: debugging ID ebx=0x%04x\n", regs.ebx);
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif
|
|
|
|
bx = 0xe6f5;
|
|
|
|
|
|
|
|
/* now twiddle with our pointer a bit */
|
|
|
|
|
2006-03-24 11:15:36 +00:00
|
|
|
address = bx;
|
|
|
|
cx = readw(bios + address);
|
|
|
|
address = 9+bx+cx;
|
|
|
|
cx = readw(bios + address);
|
|
|
|
address = 0xa+cx;
|
|
|
|
cx = readw(bios + address);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* now construct our machine identification number */
|
|
|
|
|
|
|
|
id = ((cx & 0xff)<<8)+((cx & 0xff00)>>8);
|
|
|
|
}
|
|
|
|
|
|
|
|
return id;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Probe for the presence of a Toshiba laptop
|
|
|
|
*
|
|
|
|
* returns and non-zero if unable to detect the presence of a Toshiba
|
|
|
|
* laptop, otherwise zero and determines the Machine ID, BIOS version and
|
|
|
|
* date, and SCI version.
|
|
|
|
*/
|
|
|
|
static int tosh_probe(void)
|
|
|
|
{
|
|
|
|
int i,major,minor,day,year,month,flag;
|
|
|
|
unsigned char signature[7] = { 0x54,0x4f,0x53,0x48,0x49,0x42,0x41 };
|
|
|
|
SMMRegisters regs;
|
2015-07-30 16:54:40 +00:00
|
|
|
void __iomem *bios = ioremap(0xf0000, 0x10000);
|
2006-03-24 11:15:36 +00:00
|
|
|
|
|
|
|
if (!bios)
|
|
|
|
return -ENOMEM;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* extra sanity check for the string "TOSHIBA" in the BIOS because
|
|
|
|
some machines that are not Toshiba's pass the next test */
|
|
|
|
|
|
|
|
for (i=0;i<7;i++) {
|
2006-03-24 11:15:36 +00:00
|
|
|
if (readb(bios+0xe010+i)!=signature[i]) {
|
2019-08-18 07:34:31 +00:00
|
|
|
pr_err("toshiba: not a supported Toshiba laptop\n");
|
2006-03-24 11:15:36 +00:00
|
|
|
iounmap(bios);
|
2005-04-16 22:20:36 +00:00
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* call the Toshiba SCI support check routine */
|
2005-06-25 21:54:22 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
regs.eax = 0xf0f0;
|
|
|
|
regs.ebx = 0x0000;
|
|
|
|
regs.ecx = 0x0000;
|
|
|
|
flag = tosh_smm(®s);
|
|
|
|
|
|
|
|
/* if this is not a Toshiba laptop carry flag is set and ah=0x86 */
|
|
|
|
|
|
|
|
if ((flag==1) || ((regs.eax & 0xff00)==0x8600)) {
|
2019-08-18 07:34:31 +00:00
|
|
|
pr_err("toshiba: not a supported Toshiba laptop\n");
|
2006-03-24 11:15:36 +00:00
|
|
|
iounmap(bios);
|
2005-04-16 22:20:36 +00:00
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* if we get this far then we are running on a Toshiba (probably)! */
|
|
|
|
|
|
|
|
tosh_sci = regs.edx & 0xffff;
|
2005-06-25 21:54:22 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* next get the machine ID of the current laptop */
|
|
|
|
|
2006-03-24 11:15:36 +00:00
|
|
|
tosh_id = tosh_get_machine_id(bios);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* get the BIOS version */
|
|
|
|
|
2006-03-24 11:15:36 +00:00
|
|
|
major = readb(bios+0xe009)-'0';
|
|
|
|
minor = ((readb(bios+0xe00b)-'0')*10)+(readb(bios+0xe00c)-'0');
|
2005-04-16 22:20:36 +00:00
|
|
|
tosh_bios = (major*0x100)+minor;
|
|
|
|
|
|
|
|
/* get the BIOS date */
|
|
|
|
|
2006-03-24 11:15:36 +00:00
|
|
|
day = ((readb(bios+0xfff5)-'0')*10)+(readb(bios+0xfff6)-'0');
|
|
|
|
month = ((readb(bios+0xfff8)-'0')*10)+(readb(bios+0xfff9)-'0');
|
|
|
|
year = ((readb(bios+0xfffb)-'0')*10)+(readb(bios+0xfffc)-'0');
|
2005-04-16 22:20:36 +00:00
|
|
|
tosh_date = (((year-90) & 0x1f)<<10) | ((month & 0xf)<<6)
|
|
|
|
| ((day & 0x1f)<<1);
|
|
|
|
|
|
|
|
|
|
|
|
/* in theory we should check the ports we are going to use for the
|
|
|
|
fn key detection (and the fan on the Portage 610/Tecra700), and
|
|
|
|
then request them to stop other drivers using them. However as
|
|
|
|
the keyboard driver grabs 0x60-0x6f and the pic driver grabs
|
|
|
|
0xa0-0xbf we can't. We just have to live dangerously and use the
|
|
|
|
ports anyway, oh boy! */
|
|
|
|
|
|
|
|
/* do we need to emulate the fan? */
|
|
|
|
|
|
|
|
if ((tosh_id==0xfccb) || (tosh_id==0xfccc))
|
|
|
|
tosh_fan = 1;
|
|
|
|
|
2006-03-24 11:15:36 +00:00
|
|
|
iounmap(bios);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-06-25 21:54:22 +00:00
|
|
|
static int __init toshiba_init(void)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
int retval;
|
|
|
|
/* are we running on a Toshiba laptop */
|
|
|
|
|
2005-06-25 21:54:22 +00:00
|
|
|
if (tosh_probe())
|
|
|
|
return -ENODEV;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2019-08-18 07:34:31 +00:00
|
|
|
pr_info("Toshiba System Management Mode driver v" TOSH_VERSION "\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* set the port to use for Fn status if not specified as a parameter */
|
|
|
|
if (tosh_fn==0x00)
|
|
|
|
tosh_set_fn_port();
|
|
|
|
|
|
|
|
/* register the device file */
|
|
|
|
retval = misc_register(&tosh_device);
|
2005-06-25 21:54:22 +00:00
|
|
|
if (retval < 0)
|
2005-04-16 22:20:36 +00:00
|
|
|
return retval;
|
|
|
|
|
|
|
|
#ifdef CONFIG_PROC_FS
|
2007-02-10 09:46:15 +00:00
|
|
|
{
|
|
|
|
struct proc_dir_entry *pde;
|
|
|
|
|
2018-05-15 13:57:23 +00:00
|
|
|
pde = proc_create_single("toshiba", 0, NULL, proc_toshiba_show);
|
2007-02-10 09:46:15 +00:00
|
|
|
if (!pde) {
|
|
|
|
misc_deregister(&tosh_device);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-06-25 21:54:22 +00:00
|
|
|
static void __exit toshiba_exit(void)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
remove_proc_entry("toshiba", NULL);
|
|
|
|
misc_deregister(&tosh_device);
|
|
|
|
}
|
|
|
|
|
2005-06-25 21:54:22 +00:00
|
|
|
module_init(toshiba_init);
|
|
|
|
module_exit(toshiba_exit);
|
2005-04-16 22:20:36 +00:00
|
|
|
|