summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorJeffrey Gardner <je_fro@gentoo.org>2008-04-04 19:12:38 +0000
committerJeffrey Gardner <je_fro@gentoo.org>2008-04-04 19:12:38 +0000
commitf7973225130b3645ce213031f35730fee79c1539 (patch)
tree9cce8ddeaeb0c19c90f7d534e8258669ba2278db /sys-kernel/mactel-linux-sources
parentadded to portage tree (diff)
downloadje_fro-f7973225130b3645ce213031f35730fee79c1539.tar.gz
je_fro-f7973225130b3645ce213031f35730fee79c1539.tar.bz2
je_fro-f7973225130b3645ce213031f35730fee79c1539.zip
new svn and new kernel revisions
svn path=/; revision=197
Diffstat (limited to 'sys-kernel/mactel-linux-sources')
-rw-r--r--sys-kernel/mactel-linux-sources/Manifest14
-rw-r--r--sys-kernel/mactel-linux-sources/files/2.6.24-mactel-patches-r153/applesmc-int-protect.patch304
-rw-r--r--sys-kernel/mactel-linux-sources/files/2.6.24-mactel-patches-r153/applesmc-macbook2.patch77
-rw-r--r--sys-kernel/mactel-linux-sources/files/2.6.24-mactel-patches-r153/applesmc-retry-when-accessing-keys.patch116
-rw-r--r--sys-kernel/mactel-linux-sources/files/2.6.24-mactel-patches-r153/applesmc_int.patch415
-rw-r--r--sys-kernel/mactel-linux-sources/files/2.6.24-mactel-patches-r153/appletouch-new.patch377
-rw-r--r--sys-kernel/mactel-linux-sources/files/2.6.24-mactel-patches-r153/appletouch.patch24
-rw-r--r--sys-kernel/mactel-linux-sources/files/2.6.24-mactel-patches-r153/disk-protect-fix-2.6.24-crash.patch49
-rw-r--r--sys-kernel/mactel-linux-sources/files/2.6.24-mactel-patches-r153/disk-protect-update.patch37
-rw-r--r--sys-kernel/mactel-linux-sources/files/2.6.24-mactel-patches-r153/disk-protect.patch826
-rw-r--r--sys-kernel/mactel-linux-sources/files/2.6.24-mactel-patches-r153/export-lookup_dev.patch24
-rw-r--r--sys-kernel/mactel-linux-sources/files/2.6.24-mactel-patches-r153/hid-add-new-apple-keyboard.patch182
-rw-r--r--sys-kernel/mactel-linux-sources/files/2.6.24-mactel-patches-r153/sigmatel_audio_display_all_controls_when_subsystem_id_is_wrong.patch29
-rw-r--r--sys-kernel/mactel-linux-sources/files/2.6.24-mactel-patches-r153/sigmatel_audio_fix_macbook_v2.patch31
-rw-r--r--sys-kernel/mactel-linux-sources/mactel-linux-sources-2.6.24-r4.ebuild45
15 files changed, 2550 insertions, 0 deletions
diff --git a/sys-kernel/mactel-linux-sources/Manifest b/sys-kernel/mactel-linux-sources/Manifest
index a72d2e0..d1040ce 100644
--- a/sys-kernel/mactel-linux-sources/Manifest
+++ b/sys-kernel/mactel-linux-sources/Manifest
@@ -23,6 +23,19 @@ AUX 2.6.24-mactel-patches-r151/appletouch.patch 653 RMD160 7af72520cfc712a37ad3a
AUX 2.6.24-mactel-patches-r151/hid-add-new-apple-keyboard.patch 7103 RMD160 8bdb5b56f18d76dc6b4e88f66a4a0879f17b239e SHA1 b316416b5f218a058468de523716ba11316fa342 SHA256 6d6bc7bb44d08ee10ed7c386b67601a30ef292daa7343ea966eab998b88150d7
AUX 2.6.24-mactel-patches-r151/sigmatel_audio_display_all_controls_when_subsystem_id_is_wrong.patch 819 RMD160 8bec3f90f028e060695aebf0f8bae63778cd013c SHA1 19142c8fd86614727b95a0374539315995768e25 SHA256 94e7415487d455cbd1d0f6a3d5a393b4d008ac6dedf1a335a2aa40b70d6767f2
AUX 2.6.24-mactel-patches-r151/sigmatel_audio_fix_macbook_v2.patch 855 RMD160 f9a8a9c67f2a69e9e6cd5012c4a58e493d05930b SHA1 677656bd94f432aa92ad77b13c8fe32fd738a71b SHA256 4ad9524f09b2d3ffc2d3643be844a25e5ad11e7e7b4638e98340d10d27c5a722
+AUX 2.6.24-mactel-patches-r153/applesmc-int-protect.patch 8678 RMD160 434a853f53e97959dd6e97d4814b2e491cb2c999 SHA1 f7da3957a247b5bc6a4deac7b02d9780ac59fa85 SHA256 5f7900f749670874802662c4bfb4e5991e5b25588f50cfa39fa2123bf2ea03ea
+AUX 2.6.24-mactel-patches-r153/applesmc-macbook2.patch 3088 RMD160 447b80e268c997780a2b48d518e5a5c1956fb119 SHA1 df37a98f40ab1d118274e2f240b1878d8af25d0c SHA256 84a025192e47dcfbfcc39a4b638434df8e034057bded9eb31a9be3cf81c93374
+AUX 2.6.24-mactel-patches-r153/applesmc-retry-when-accessing-keys.patch 3005 RMD160 7edff70b59f6bb1e27e9594d5ac3789207a2d203 SHA1 103d650a667b86b454ecbfd8ffacaf3894f21236 SHA256 5d6395ceba951ebd6d75e7d5f97f1dae8a4971dd2d4a3abae59f96a53c663c44
+AUX 2.6.24-mactel-patches-r153/applesmc_int.patch 11195 RMD160 72dfd4248cdaa4babac0bdd236f920a4b9462f4e SHA1 831db7f1a4e4438fc4e13d356e138c321de218bd SHA256 e1432c2ac7c35790f2560e482ec1ecfdaff637fff078137d4bf8ef4ddd82cb10
+AUX 2.6.24-mactel-patches-r153/appletouch-new.patch 11927 RMD160 ada04ab11c9602b8d9e5e9f8a0fce5769200dde6 SHA1 6582d125c5edce8b32db396ddd28884d434279ff SHA256 585dc12ec28f3b4dfa377deccae1ac8b8d5a37190dd6cfdfdc0d302215bde8a6
+AUX 2.6.24-mactel-patches-r153/appletouch.patch 654 RMD160 71fe6e4b886063601fa71dde4401d0003c17b5ba SHA1 fd599a2b5ff9dea91ff4b8eff956bebededf9abd SHA256 5143872df96fa8e79a0602af15ef9bc9cd880bd88e39c1d3a0bbc4659516d4c8
+AUX 2.6.24-mactel-patches-r153/disk-protect-fix-2.6.24-crash.patch 1690 RMD160 cfc272937096214b6a90b90a8fec45946d727f6b SHA1 a53e30d013e910e4089cb62eb0a8eb5075bde2bd SHA256 21f319713860d982dea4ee8293be72354605c91cd112fd40b0370ffe1a89b641
+AUX 2.6.24-mactel-patches-r153/disk-protect-update.patch 1130 RMD160 ea48d721ef45a80a8a341a0e62e47483e19f8441 SHA1 4428a17a9ed5ff3c09b48e563ee8e6dd9d64f614 SHA256 02b91671fc86186b7547a0468b3dbd4804959d076807140c271433b96a11aa6a
+AUX 2.6.24-mactel-patches-r153/disk-protect.patch 24637 RMD160 7e43c5ca0ed7a01c01a397faa54174e5bf4cf8e7 SHA1 150dfe2897262da5404d122be858b1281a1d54c0 SHA256 ad5f2d8f3c0acbffaaf2fadbe26ec2fa0bb5ca6c8c90eeb97d0c9576368e0078
+AUX 2.6.24-mactel-patches-r153/export-lookup_dev.patch 423 RMD160 b0362beae6dfac8be4d37ec34337c0fa48ae1be9 SHA1 4a521886503f2675dcf7ec3cee9469fa86311781 SHA256 bd5015342217a7df1596b0be8c122c64bc52b09e0921afada64e3ba176e8b2b9
+AUX 2.6.24-mactel-patches-r153/hid-add-new-apple-keyboard.patch 8440 RMD160 78b893ab1e6d7d8a2b217c01a0f2b15a9fd6863f SHA1 e662407bb1a610d93569fd82a4a8e8c9c61d07dd SHA256 9691663c497723c200543ea2869f180f0b77997e2374aa7ddfa78990eb68910c
+AUX 2.6.24-mactel-patches-r153/sigmatel_audio_display_all_controls_when_subsystem_id_is_wrong.patch 820 RMD160 94de76a57d94cfedf6261cc849e9316c100d3f0f SHA1 250486062646728b0d8fb4aad4cfa7bcd861238a SHA256 af3f2cc085444027d712ed1a1e078608f8141f4253292d0043e5b992d11396c6
+AUX 2.6.24-mactel-patches-r153/sigmatel_audio_fix_macbook_v2.patch 856 RMD160 8d343c8b0f4eec70a449e2bda987edeb9fafbd6f SHA1 eda6c5f026936addff8ad090df24d2c5658ca5fe SHA256 9bd96288b95d94111b19c1d055d98088d414bbfed5d38c2bbf82a1563ec1fb5a
AUX mactel-patches-r147/applesmc-for-mac-pro-2-x-quad-core.patch 7939 RMD160 f6974a36923a13d82565c7828e74656bf422df88 SHA1 146adfb5bab85466fefaff3f1066f52c74b0ddeb SHA256 5af5d1a007507126745cd29bbb2972e64232d83b7fb32e69f2fd0d147806f346
AUX mactel-patches-r147/applesmc-int-protect.patch 8677 RMD160 43683284d005614ecea1098c99b884561536b7c9 SHA1 b52899fd258ffed5dde19c5d8f9958a46a35accd SHA256 7d4079e50cfc9f26ca68ce08cb7f4dbe1ae02ce06762be90a8678ae0290a2c75
AUX mactel-patches-r147/applesmc-macbook2.patch 3087 RMD160 a9f6f3932c83306cc3f6e86793204d460893d750 SHA1 381bd9d153fca5b51820152855bdd346f7bb94f1 SHA256 513eba6bc15f9d37d537657450227e23d7aaddf25e99b1a1f2d7fceaac9f99f7
@@ -51,3 +64,4 @@ EBUILD mactel-linux-sources-2.6.23-r4.ebuild 1399 RMD160 8e498711091da40a9043349
EBUILD mactel-linux-sources-2.6.24-r1.ebuild 1151 RMD160 6ef9ab524a56008e0536378cfa3e112fc835dc45 SHA1 c18c164d49f76106c15110b44d83ab4311cc45c7 SHA256 b7520cdb8c33451468f85fbe8d7af1cdf47ca10a815e740cd53bedbc9f1a9b17
EBUILD mactel-linux-sources-2.6.24-r2.ebuild 1151 RMD160 3062875a537f2bc7b2f70eabbc3b92fdf18c1efe SHA1 8402bc13eecff1b22d86204971e5fae1fc5161aa SHA256 f8a459ee7d302c6ab1dff77ad2f632cbec43655ed02854548f55cef3fbfa5293
EBUILD mactel-linux-sources-2.6.24-r3.ebuild 1196 RMD160 f5e02f5dc00c27d1af90a7fda0c259f5f79b6b3a SHA1 0b90bd716953e5fad55ac6ea05265a9db162191c SHA256 62933738e49924e7b33d0af3bcec6d43671bb82df2d9bf745f7014bad832a82f
+EBUILD mactel-linux-sources-2.6.24-r4.ebuild 1347 RMD160 089274c3635fb12e86479a8cec253a64d47dc0a4 SHA1 b1c1db8e05c9d0a591b54b8a191178bd200fc324 SHA256 3c9fa5098addc57c818c761fe3e5f879750c5a896b7620dbccd6ee50f1a69ea4
diff --git a/sys-kernel/mactel-linux-sources/files/2.6.24-mactel-patches-r153/applesmc-int-protect.patch b/sys-kernel/mactel-linux-sources/files/2.6.24-mactel-patches-r153/applesmc-int-protect.patch
new file mode 100644
index 0000000..41ac501
--- /dev/null
+++ b/sys-kernel/mactel-linux-sources/files/2.6.24-mactel-patches-r153/applesmc-int-protect.patch
@@ -0,0 +1,304 @@
+AppleSMC: use interrupts to protect a block device.
+
+From: Nicolas Boichat <nicolas@boichat.ch>
+
+
+---
+
+ drivers/hwmon/Kconfig | 7 ++
+ drivers/hwmon/Makefile | 4 +
+ drivers/hwmon/applesmc.c | 155 +++++++++++++++++++++++++++++++++++++++++++---
+ 3 files changed, 156 insertions(+), 10 deletions(-)
+
+
+diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig
+index a0445be..1e857c0 100644
+--- a/drivers/hwmon/Kconfig
++++ b/drivers/hwmon/Kconfig
+@@ -754,6 +754,13 @@ config SENSORS_APPLESMC
+ Say Y here if you have an applicable laptop and want to experience
+ the awesome power of applesmc.
+
++config SENSORS_APPLESMC_PROTECT
++ bool "Apple SMC - Protect block devices on shock/free fall"
++ depends on SENSORS_APPLESMC
++ default n
++ help
++ Fill in......
++
+ config HWMON_DEBUG_CHIP
+ bool "Hardware Monitoring Chip debugging messages"
+ default n
+diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile
+index 55595f6..4225f3d 100644
+--- a/drivers/hwmon/Makefile
++++ b/drivers/hwmon/Makefile
+@@ -73,3 +73,7 @@ ifeq ($(CONFIG_HWMON_DEBUG_CHIP),y)
+ EXTRA_CFLAGS += -DDEBUG
+ endif
+
++ifeq ($(CONFIG_SENSORS_APPLESMC_PROTECT),y)
++EXTRA_CFLAGS += -DAPPLESMC_PROTECT
++endif
++
+diff --git a/drivers/hwmon/applesmc.c b/drivers/hwmon/applesmc.c
+index 8f75b57..4186974 100644
+--- a/drivers/hwmon/applesmc.c
++++ b/drivers/hwmon/applesmc.c
+@@ -40,6 +40,12 @@
+ #include <linux/hwmon.h>
+ #include <linux/workqueue.h>
+ #include <linux/interrupt.h>
++#ifdef APPLESMC_PROTECT
++#include <linux/fs.h>
++#include <linux/blkdev.h>
++#include <linux/namei.h>
++#include <linux/mount.h>
++#endif
+
+ /* data port used by Apple SMC */
+ #define APPLESMC_DATA_PORT 0x300
+@@ -170,6 +176,11 @@ static unsigned int applesmc_light;
+ /* Indicates which temperature sensors set to use. */
+ static unsigned int applesmc_temperature_set;
+
++#ifdef APPLESMC_PROTECT
++/* Device to protect in case of shock or free fall. */
++struct block_device *bdev_protect;
++#endif
++
+ static DEFINE_MUTEX(applesmc_lock);
+
+ /*
+@@ -450,6 +461,35 @@ static int applesmc_init_check_key_value(const char *key, u8 *buffer, u8 len)
+ return -EIO;
+ }
+
++#ifdef APPLESMC_PROTECT
++static void protect_callback(struct work_struct *ignored) {
++ char b[BDEVNAME_SIZE];
++ /* This code comes from queue_protect_store (block/ll_rw_blk.c) */
++ if (bdev_protect && bdev_protect->bd_disk &&
++ bdev_protect->bd_disk->queue &&
++ bdev_protect->bd_disk->queue->issue_protect_fn) {
++ struct request_queue *q = bdev_protect->bd_disk->queue;
++
++ printk(KERN_INFO "applesmc: protecting the device (%s)\n",
++ bdevname(bdev_protect, b));
++
++ /* Park and freeze */
++ if (!blk_queue_stopped(q))
++ q->issue_protect_fn(q);
++
++ /* freeze for 2 seconds (we will receive interrupt often
++ * enough to reenable this if needed) */
++ spin_lock_irq(q->queue_lock);
++ blk_freeze_queue(q, 2);
++ spin_unlock_irq(q->queue_lock);
++
++ printk(KERN_INFO "applesmc: device protected\n");
++ }
++}
++
++static DECLARE_WORK(protect_work, protect_callback);
++#endif
++
+ irqreturn_t applesmc_irq_handler(int irq, void *dev_id)
+ {
+ u8 int_type = inb(APPLESMC_INT_PORT);
+@@ -471,14 +511,24 @@ irqreturn_t applesmc_irq_handler(int irq, void *dev_id)
+ int_type);
+ }
+
++#ifdef APPLESMC_PROTECT
++ if (bdev_protect && bdev_protect->bd_disk &&
++ bdev_protect->bd_disk->queue &&
++ bdev_protect->bd_disk->queue->issue_protect_fn) {
++ schedule_work(&protect_work);
++ }
++#endif
++
+ return IRQ_HANDLED;
+ }
+
+ /*
+ * applesmc_device_init - initialize the accelerometer. Returns zero on success
+ * and negative error code on failure. Can sleep.
++ * - resume is true if we are waking up from a resume, so we don't need
++ * to setup interrupt handling again, and probe for a device to protect.
+ */
+-static int applesmc_device_init(void)
++static int applesmc_device_init(int resume)
+ {
+ int total;
+ int ret = -ENXIO;
+@@ -553,17 +603,21 @@ static int applesmc_device_init(void)
+ goto out;
+ }
+
+- ret1 = request_irq(APPLESMC_IRQ, applesmc_irq_handler, IRQF_DISABLED,
+- "applesmc_irq_handler", NULL);
++ if (!resume) {
++ ret1 = request_irq(APPLESMC_IRQ, applesmc_irq_handler,
++ IRQF_DISABLED, "applesmc_irq_handler",
++ NULL);
+
+- if (ret1) {
+- printk(KERN_WARNING "applesmc: cannot setup irq handler\n");
+- }
++ if (ret1) {
++ printk(KERN_WARNING "applesmc: cannot setup "
++ "irq handler\n");
++ }
+
+- printk(KERN_DEBUG "applesmc: accelerometer "
++ printk(KERN_DEBUG "applesmc: accelerometer "
+ "successfully initialized.\n");
+- ret = 0;
++ }
+
++ ret = 0;
+ out:
+ mutex_unlock(&applesmc_lock);
+ return ret;
+@@ -594,7 +648,7 @@ static int applesmc_probe(struct platform_device *dev)
+ {
+ int ret;
+
+- ret = applesmc_device_init();
++ ret = applesmc_device_init(0);
+ if (ret)
+ return ret;
+
+@@ -604,7 +658,7 @@ static int applesmc_probe(struct platform_device *dev)
+
+ static int applesmc_resume(struct platform_device *dev)
+ {
+- return applesmc_device_init();
++ return applesmc_device_init(1);
+ }
+
+ static int applesmc_remove(struct platform_device *dev)
+@@ -901,6 +955,46 @@ static ssize_t applesmc_calibrate_store(struct device *dev,
+ return count;
+ }
+
++#ifdef APPLESMC_PROTECT
++static ssize_t applesmc_protect_device_show(struct device *dev,
++ struct device_attribute *attr, char *sysfsbuf)
++{
++ char b[BDEVNAME_SIZE];
++
++ return snprintf(sysfsbuf, PAGE_SIZE, "%s\n", bdevname(bdev_protect, b));
++}
++
++static ssize_t applesmc_protect_device_store(struct device *dev,
++ struct device_attribute *attr, const char *sysfsbuf, size_t count)
++{
++ char b[BDEVNAME_SIZE];
++ struct block_device *bdev;
++
++ if (bdev_protect)
++ bdput(bdev_protect);
++
++ bdev = lookup_bdev(sysfsbuf);
++
++ if (IS_ERR(bdev)) {
++ bdev_protect = NULL;
++ return -EIO; /* Could be more precise? */
++ }
++
++ if (bdev->bd_disk && bdev->bd_disk->queue
++ && bdev->bd_disk->queue->issue_protect_fn) {
++ bdev_protect = bdev;
++ printk(KERN_INFO "applesmc: accelerometer will now "
++ "protect %s.\n", bdevname(bdev, b));
++ return count;
++ }
++ else {
++ bdput(bdev);
++ bdev_protect = NULL;
++ return -EIO; /* Could be more precise? */
++ }
++}
++#endif
++
+ /* Store the next backlight value to be written by the work */
+ static unsigned int backlight_value;
+
+@@ -1205,6 +1299,10 @@ static DEVICE_ATTR(name, 0444, applesmc_name_show, NULL);
+ static DEVICE_ATTR(position, 0444, applesmc_position_show, NULL);
+ static DEVICE_ATTR(calibrate, 0644,
+ applesmc_calibrate_show, applesmc_calibrate_store);
++#ifdef APPLESMC_PROTECT
++static DEVICE_ATTR(protect_device, 0644,
++ applesmc_protect_device_show, applesmc_protect_device_store);
++#endif
+ static SENSOR_DEVICE_ATTR(low_norm_trigger_interval, 0644,
+ applesmc_accelerometer_show, applesmc_accelerometer_store, 0);
+ static SENSOR_DEVICE_ATTR(high_norm_trigger_interval, 0644,
+@@ -1217,6 +1315,9 @@ static SENSOR_DEVICE_ATTR(high_norm_trigger, 0644,
+ static struct attribute *accelerometer_attributes[] = {
+ &dev_attr_position.attr,
+ &dev_attr_calibrate.attr,
++#ifdef APPLESMC_PROTECT
++ &dev_attr_protect_device.attr,
++#endif
+ &sensor_dev_attr_low_norm_trigger.dev_attr.attr,
+ &sensor_dev_attr_high_norm_trigger.dev_attr.attr,
+ &sensor_dev_attr_low_norm_trigger_interval.dev_attr.attr,
+@@ -1457,6 +1558,10 @@ static int applesmc_create_accelerometer(void)
+ {
+ struct input_dev *idev;
+ int ret;
++#ifdef APPLESMC_PROTECT
++ char b[BDEVNAME_SIZE];
++ int major, minor;
++#endif
+
+ ret = sysfs_create_group(&pdev->dev.kobj,
+ &accelerometer_attributes_group);
+@@ -1490,6 +1595,30 @@ static int applesmc_create_accelerometer(void)
+ if (ret)
+ goto out_idev;
+
++#ifdef APPLESMC_PROTECT
++ /* Try to find a suitable block device to protect */
++ bdev_protect = NULL;
++ major = SCSI_DISK0_MAJOR;
++
++ /* Iterate over a maximum of 16 SCSI devices to find one that
++ * can be protected.
++ * Note: other devices could also be protected. */
++ for (minor = 0; minor < 256; minor += 16) {
++ dev_t dev = MKDEV(major, minor);
++ struct block_device *bdev = bdget(dev);
++ if (bdev->bd_disk && bdev->bd_disk->queue
++ && bdev->bd_disk->queue->issue_protect_fn) {
++ bdev_protect = bdev;
++ printk(KERN_INFO "applesmc: accelerometer "
++ "will protect %s (%d:%d).\n",
++ bdevname(bdev, b),
++ major, minor);
++ break;
++ }
++ bdput(bdev);
++ }
++#endif
++
+ return 0;
+
+ out_idev:
+@@ -1509,6 +1638,12 @@ static void applesmc_release_accelerometer(void)
+ input_unregister_polled_device(applesmc_idev);
+ input_free_polled_device(applesmc_idev);
+ sysfs_remove_group(&pdev->dev.kobj, &accelerometer_attributes_group);
++#ifdef APPLESMC_PROTECT
++ if (bdev_protect) {
++ bdput(bdev_protect);
++ bdev_protect = NULL;
++ }
++#endif
+ }
+
+ static __initdata struct dmi_match_data applesmc_dmi_data[] = {
diff --git a/sys-kernel/mactel-linux-sources/files/2.6.24-mactel-patches-r153/applesmc-macbook2.patch b/sys-kernel/mactel-linux-sources/files/2.6.24-mactel-patches-r153/applesmc-macbook2.patch
new file mode 100644
index 0000000..0733cbe
--- /dev/null
+++ b/sys-kernel/mactel-linux-sources/files/2.6.24-mactel-patches-r153/applesmc-macbook2.patch
@@ -0,0 +1,77 @@
+Add sensors set for MacBook2, from register dump on a mid-2007 MacBook2.
+
+From: Riki Oktarianto <rkoktarianto@gmail.com>
+
+
+---
+
+ drivers/hwmon/applesmc.c | 29 +++++++++++++++++++----------
+ 1 files changed, 19 insertions(+), 10 deletions(-)
+
+
+diff --git a/drivers/hwmon/applesmc.c b/drivers/hwmon/applesmc.c
+index 86c66c3..c0dd9b1 100644
+--- a/drivers/hwmon/applesmc.c
++++ b/drivers/hwmon/applesmc.c
+@@ -84,12 +84,15 @@ static const char* temperature_sensors_sets[][36] = {
+ /* Set 0: Macbook Pro */
+ { "TA0P", "TB0T", "TC0D", "TC0P", "TG0H", "TG0P", "TG0T", "Th0H",
+ "Th1H", "Tm0P", "Ts0P", "Ts1P", NULL },
+-/* Set 1: Macbook set */
++/* Set 1: Macbook2 set */
++ { "TB0T", "TC0D", "TC0P", "TM0P", "TN0P", "TN1P", "TTF0", "Th0H",
++ "Th0S", "Th1H", NULL },
++/* Set 2: Macbook set */
+ { "TB0T", "TC0D", "TC0P", "TM0P", "TN0P", "TN1P", "Th0H", "Th0S",
+ "Th1H", "Ts0P", NULL },
+-/* Set 2: Macmini set */
++/* Set 3: Macmini set */
+ { "TC0D", "TC0P", NULL },
+-/* Set 3: Mac Pro (2 x Quad-Core) */
++/* Set 4: Mac Pro (2 x Quad-Core) */
+ { "TA0P", "TCAG", "TCAH", "TCBG", "TCBH", "TC0C", "TC0D", "TC0P",
+ "TC1C", "TC1D", "TC2C", "TC2D", "TC3C", "TC3D", "THTG", "TH0P",
+ "TH1P", "TH2P", "TH3P", "TMAP", "TMAS", "TMBS", "TM0P", "TM0S",
+@@ -1212,12 +1215,14 @@ static void applesmc_release_accelerometer(void)
+ static __initdata struct dmi_match_data applesmc_dmi_data[] = {
+ /* MacBook Pro: accelerometer, backlight and temperature set 0 */
+ { .accelerometer = 1, .light = 1, .temperature_set = 0 },
+-/* MacBook: accelerometer and temperature set 1 */
++/* MacBook2: accelerometer and temperature set 1 */
+ { .accelerometer = 1, .light = 0, .temperature_set = 1 },
+-/* MacMini: temperature set 2 */
+- { .accelerometer = 0, .light = 0, .temperature_set = 2 },
+-/* MacPro: temperature set 3 */
++/* MacBook: accelerometer and temperature set 2 */
++ { .accelerometer = 1, .light = 0, .temperature_set = 2 },
++/* MacMini: temperature set 3 */
+ { .accelerometer = 0, .light = 0, .temperature_set = 3 },
++/* MacPro: temperature set 4 */
++ { .accelerometer = 0, .light = 0, .temperature_set = 4 },
+ };
+
+ /* Note that DMI_MATCH(...,"MacBook") will match "MacBookPro1,1".
+@@ -1229,16 +1234,20 @@ static __initdata struct dmi_system_id applesmc_whitelist[] = {
+ (void*)&applesmc_dmi_data[0]},
+ { applesmc_dmi_match, "Apple MacBook", {
+ DMI_MATCH(DMI_BOARD_VENDOR,"Apple"),
+- DMI_MATCH(DMI_PRODUCT_NAME,"MacBook") },
++ DMI_MATCH(DMI_PRODUCT_NAME,"MacBook2") },
+ (void*)&applesmc_dmi_data[1]},
++ { applesmc_dmi_match, "Apple MacBook", {
++ DMI_MATCH(DMI_BOARD_VENDOR,"Apple"),
++ DMI_MATCH(DMI_PRODUCT_NAME,"MacBook") },
++ (void*)&applesmc_dmi_data[2]},
+ { applesmc_dmi_match, "Apple Macmini", {
+ DMI_MATCH(DMI_BOARD_VENDOR,"Apple"),
+ DMI_MATCH(DMI_PRODUCT_NAME,"Macmini") },
+- (void*)&applesmc_dmi_data[2]},
++ (void*)&applesmc_dmi_data[3]},
+ { applesmc_dmi_match, "Apple MacPro2", {
+ DMI_MATCH(DMI_BOARD_VENDOR,"Apple"),
+ DMI_MATCH(DMI_PRODUCT_NAME,"MacPro2") },
+- (void*)&applesmc_dmi_data[3]},
++ (void*)&applesmc_dmi_data[4]},
+ { .ident = NULL }
+ };
+
diff --git a/sys-kernel/mactel-linux-sources/files/2.6.24-mactel-patches-r153/applesmc-retry-when-accessing-keys.patch b/sys-kernel/mactel-linux-sources/files/2.6.24-mactel-patches-r153/applesmc-retry-when-accessing-keys.patch
new file mode 100644
index 0000000..a5ee733
--- /dev/null
+++ b/sys-kernel/mactel-linux-sources/files/2.6.24-mactel-patches-r153/applesmc-retry-when-accessing-keys.patch
@@ -0,0 +1,116 @@
+Retry up to 200 ms when reading or writing keys.
+
+From: Nicolas Boichat <nicolas@boichat.ch>
+
+
+---
+
+ drivers/hwmon/applesmc.c | 69 +++++++++++++++++++++++++++++++---------------
+ 1 files changed, 47 insertions(+), 22 deletions(-)
+
+
+diff --git a/drivers/hwmon/applesmc.c b/drivers/hwmon/applesmc.c
+index c0dd9b1..3b09cdb 100644
+--- a/drivers/hwmon/applesmc.c
++++ b/drivers/hwmon/applesmc.c
+@@ -112,6 +112,9 @@ static const char* fan_speed_keys[] = {
+ #define INIT_TIMEOUT_MSECS 5000 /* wait up to 5s for device init ... */
+ #define INIT_WAIT_MSECS 50 /* ... in 50ms increments */
+
++#define ACCESS_TIMEOUT_MSECS 500 /* wait up to 500ms when accessing a key */
++#define ACCESS_WAIT_MSECS 5 /* ... in 5ms increments */
++
+ #define APPLESMC_POLL_INTERVAL 50 /* msecs */
+ #define APPLESMC_INPUT_FUZZ 4 /* input event threshold */
+ #define APPLESMC_INPUT_FLAT 4
+@@ -186,12 +189,13 @@ static int __wait_status(u8 val)
+
+ /*
+ * applesmc_read_key - reads len bytes from a given key, and put them in buffer.
++ * Tries up to ACCESS_WAIT_MSECS to read the value.
+ * Returns zero on success or a negative error on failure. Callers must
+ * hold applesmc_lock.
+ */
+ static int applesmc_read_key(const char* key, u8* buffer, u8 len)
+ {
+- int i;
++ int i, total, ret;
+
+ if (len > APPLESMC_MAX_DATA_LENGTH) {
+ printk(KERN_ERR "applesmc_read_key: cannot read more than "
+@@ -199,33 +203,54 @@ static int applesmc_read_key(const char* key, u8* buffer, u8 len)
+ return -EINVAL;
+ }
+
+- outb(APPLESMC_READ_CMD, APPLESMC_CMD_PORT);
+- if (__wait_status(0x0c))
+- return -EIO;
++ for (total = ACCESS_TIMEOUT_MSECS; total > 0;
++ total -= ACCESS_WAIT_MSECS) {
++ ret = 0;
++ outb(APPLESMC_READ_CMD, APPLESMC_CMD_PORT);
++ if (__wait_status(0x0c)) {
++ ret = -EIO;
++ goto wait_fail;
++ }
+
+- for (i = 0; i < 4; i++) {
+- outb(key[i], APPLESMC_DATA_PORT);
+- if (__wait_status(0x04))
+- return -EIO;
+- }
+- if (debug)
+- printk(KERN_DEBUG "<%s", key);
++ for (i = 0; i < 4; i++) {
++ outb(key[i], APPLESMC_DATA_PORT);
++ if (__wait_status(0x04)) {
++ ret = -EIO;
++ goto wait_fail;
++ }
++ }
++ if (debug)
++ printk(KERN_DEBUG "<%s", key);
+
+- outb(len, APPLESMC_DATA_PORT);
+- if (debug)
+- printk(KERN_DEBUG ">%x", len);
++ outb(len, APPLESMC_DATA_PORT);
++ if (debug)
++ printk(KERN_DEBUG ">%x", len);
+
+- for (i = 0; i < len; i++) {
+- if (__wait_status(0x05))
+- return -EIO;
+- buffer[i] = inb(APPLESMC_DATA_PORT);
++ for (i = 0; i < len; i++) {
++ if (__wait_status(0x05)) {
++ ret = -EIO;
++ goto wait_fail;
++ }
++ buffer[i] = inb(APPLESMC_DATA_PORT);
++ if (debug)
++ printk(KERN_DEBUG "<%x", buffer[i]);
++ }
+ if (debug)
+- printk(KERN_DEBUG "<%x", buffer[i]);
++ printk(KERN_DEBUG "\n");
++
++ break;
++
++wait_fail:
++ msleep(ACCESS_WAIT_MSECS);
++ continue;
+ }
+- if (debug)
+- printk(KERN_DEBUG "\n");
+
+- return 0;
++ if (total != ACCESS_TIMEOUT_MSECS) {
++ printk(KERN_DEBUG "Read: Waited %d ms for the value\n",
++ ACCESS_TIMEOUT_MSECS-total);
++ }
++
++ return ret;
+ }
+
+ /*
diff --git a/sys-kernel/mactel-linux-sources/files/2.6.24-mactel-patches-r153/applesmc_int.patch b/sys-kernel/mactel-linux-sources/files/2.6.24-mactel-patches-r153/applesmc_int.patch
new file mode 100644
index 0000000..87122db
--- /dev/null
+++ b/sys-kernel/mactel-linux-sources/files/2.6.24-mactel-patches-r153/applesmc_int.patch
@@ -0,0 +1,415 @@
+Add interrupt support for the accelerometer. A message is printed in dmesg when an interrupt occurs, but no further handling is done.
+
+From: Nicolas Boichat <nicolas@boichat.ch>
+
+
+---
+
+ drivers/hwmon/applesmc.c | 320 +++++++++++++++++++++++++++++++++++++++++++---
+ 1 files changed, 297 insertions(+), 23 deletions(-)
+
+
+diff --git a/drivers/hwmon/applesmc.c b/drivers/hwmon/applesmc.c
+index 3b09cdb..8f75b57 100644
+--- a/drivers/hwmon/applesmc.c
++++ b/drivers/hwmon/applesmc.c
+@@ -39,14 +39,20 @@
+ #include <linux/leds.h>
+ #include <linux/hwmon.h>
+ #include <linux/workqueue.h>
++#include <linux/interrupt.h>
+
+ /* data port used by Apple SMC */
+ #define APPLESMC_DATA_PORT 0x300
+ /* command/status port used by Apple SMC */
+ #define APPLESMC_CMD_PORT 0x304
++/* status port used by Apple SMC to get which interrupt type just happened */
++#define APPLESMC_INT_PORT 0x31f
+
+ #define APPLESMC_NR_PORTS 32 /* 0x300-0x31f */
+
++/* Defined in ACPI DSDT table, should we read it from there? */
++#define APPLESMC_IRQ 6
++
+ #define APPLESMC_MAX_DATA_LENGTH 32
+
+ #define APPLESMC_STATUS_MASK 0x0f
+@@ -57,6 +63,8 @@
+
+ #define KEY_COUNT_KEY "#KEY" /* r-o ui32 */
+
++#define INTERRUPT_OK_KEY "NTOK" /* w-o ui8 */
++
+ #define LIGHT_SENSOR_LEFT_KEY "ALV0" /* r-o {alv (6 bytes) */
+ #define LIGHT_SENSOR_RIGHT_KEY "ALV1" /* r-o {alv (6 bytes) */
+ #define BACKLIGHT_KEY "LKSB" /* w-o {lkb (2 bytes) */
+@@ -68,6 +76,19 @@
+ #define MOTION_SENSOR_Z_KEY "MO_Z" /* r-o sp78 (2 bytes) */
+ #define MOTION_SENSOR_KEY "MOCN" /* r/w ui16 */
+
++/*
++ * Interrupt controls.
++ * If the norm of the position (sqrt(MO_X^2+MO_Y^2+MO_Z^2)) is smaller than
++ * MOLT (free fall), or bigger than MOHT (high acceleration) for longer than the
++ * value of MOLD (or MOHD), SMC will trigger an interrupt.
++ */
++#define MOTION_LOW_NORM "MOLT" /* r/w sp78 (2 bytes) */
++#define MOTION_HIGH_NORM "MOHT" /* r/w sp78 (2 bytes) */
++#define MOTION_LOW_NORM_INTERVAL "MOLD" /* r/w ui8 */
++#define MOTION_HIGH_NORM_INTERVAL "MOHD" /* r/w ui8 */
++
++#define MSDW_KEY "MSDW" /* r/w flag (1 byte) */
++
+ #define FANS_COUNT "FNum" /* r-o ui8 */
+ #define FANS_MANUAL "FS! " /* r-w ui16 */
+ #define FAN_ACTUAL_SPEED "F0Ac" /* r-o fpe2 (2 bytes) */
+@@ -385,12 +406,83 @@ static int applesmc_read_motion_sensor(int index, s16* value)
+ }
+
+ /*
++ * applesmc_init_check_key_value - checks if a given key contains the bytes in
++ * buffer, if not, writes these bytes.
++ * In case of failure retry every INIT_WAIT_MSECS msec, and timeout if it
++ * waited more than INIT_TIMEOUT_MSECS in total.
++ * Returns zero on success or a negative error on failure. Callers must
++ * hold applesmc_lock.
++ */
++static int applesmc_init_check_key_value(const char *key, u8 *buffer, u8 len)
++{
++ int total, ret, i, compare;
++ u8 rdbuffer[APPLESMC_MAX_DATA_LENGTH];
++
++ if (len > APPLESMC_MAX_DATA_LENGTH) {
++ printk(KERN_ERR "applesmc_init_check_key_value: cannot "
++ "read/write more than %d bytes",
++ APPLESMC_MAX_DATA_LENGTH);
++ return -EINVAL;
++ }
++
++ for (total = INIT_TIMEOUT_MSECS; total > 0; total -= INIT_WAIT_MSECS) {
++ ret = applesmc_read_key(key, rdbuffer, len);
++ if (!ret) {
++ compare = 1;
++ for (i = 0; i < len; i++) {
++ if (rdbuffer[i] != buffer[i]) {
++ compare = 0;
++ break;
++ }
++ }
++
++ if (compare) {
++ return 0;
++ }
++ }
++ ret = applesmc_write_key(key, buffer, len);
++ msleep(INIT_WAIT_MSECS);
++ }
++
++ if (ret)
++ return ret;
++ else
++ return -EIO;
++}
++
++irqreturn_t applesmc_irq_handler(int irq, void *dev_id)
++{
++ u8 int_type = inb(APPLESMC_INT_PORT);
++
++ switch (int_type) {
++ case 0x60:
++ printk(KERN_INFO "applesmc: received a free fall interrupt\n");
++ break;
++ case 0x6f:
++ printk(KERN_INFO
++ "applesmc: received a high acceleration interrupt\n");
++ break;
++ case 0x80:
++ printk(KERN_INFO "applesmc: received a shock interrupt\n");
++ break;
++ default:
++ printk(KERN_INFO
++ "applesmc: received an unknown interrupt %x\n",
++ int_type);
++ }
++
++ return IRQ_HANDLED;
++}
++
++/*
+ * applesmc_device_init - initialize the accelerometer. Returns zero on success
+ * and negative error code on failure. Can sleep.
+ */
+ static int applesmc_device_init(void)
+ {
+- int total, ret = -ENXIO;
++ int total;
++ int ret = -ENXIO;
++ int ret1, ret2;
+ u8 buffer[2];
+
+ if (!applesmc_accelerometer)
+@@ -398,32 +490,79 @@ static int applesmc_device_init(void)
+
+ mutex_lock(&applesmc_lock);
+
++ /* Accept interrupts */
++ buffer[0] = 0x01;
+ for (total = INIT_TIMEOUT_MSECS; total > 0; total -= INIT_WAIT_MSECS) {
+- if (debug)
+- printk(KERN_DEBUG "applesmc try %d\n", total);
+- if (!applesmc_read_key(MOTION_SENSOR_KEY, buffer, 2) &&
+- (buffer[0] != 0x00 || buffer[1] != 0x00)) {
+- if (total == INIT_TIMEOUT_MSECS) {
+- printk(KERN_DEBUG "applesmc: device has"
+- " already been initialized"
+- " (0x%02x, 0x%02x).\n",
+- buffer[0], buffer[1]);
+- } else {
+- printk(KERN_DEBUG "applesmc: device"
+- " successfully initialized"
+- " (0x%02x, 0x%02x).\n",
+- buffer[0], buffer[1]);
+- }
+- ret = 0;
+- goto out;
+- }
+- buffer[0] = 0xe0;
+- buffer[1] = 0x00;
+- applesmc_write_key(MOTION_SENSOR_KEY, buffer, 2);
++ ret1 = applesmc_write_key(INTERRUPT_OK_KEY, buffer, 1);
++ msleep(INIT_WAIT_MSECS);
++
++ if (!ret1)
++ break;
++ }
++ if (ret1)
++ printk(KERN_WARNING "applesmc: Cannot set NTOK key, "
++ "will not receive interrupts.\n");
++
++ /* Setup interrupt controls. */
++ buffer[0] = 20; /* 20 msecs */
++ ret1 = applesmc_init_check_key_value(MOTION_LOW_NORM_INTERVAL,
++ buffer, 1);
++
++ buffer[0] = 20; /* 20 msecs */
++ ret2 = applesmc_init_check_key_value(MOTION_HIGH_NORM_INTERVAL,
++ buffer, 1);
++
++ if (ret1 || ret2) {
++ printk(KERN_WARNING "applesmc: Cannot set motion sensor "
++ "interrupt interval, might not receive "
++ "some interrupts.");
++ }
++
++ buffer[0] = 0x00;
++ buffer[1] = 0x60;
++ ret1 = applesmc_init_check_key_value(MOTION_LOW_NORM, buffer, 2);
++
++ buffer[0] = 0x01;
++ buffer[1] = 0xc0;
++ ret2 = applesmc_init_check_key_value(MOTION_HIGH_NORM, buffer, 2);
++
++ if (ret1 || ret2) {
++ printk(KERN_WARNING "applesmc: Cannot set motion sensor "
++ "min/max norm parameters, "
++ "might not receive some interrupts.");
++ }
++
++ /* Mysterious key. */
++ buffer[0] = 0x01;
++ for (total = INIT_TIMEOUT_MSECS; total > 0; total -= INIT_WAIT_MSECS) {
++ ret1 = applesmc_write_key(MSDW_KEY, buffer, 1);
+ msleep(INIT_WAIT_MSECS);
++
++ if (!ret1)
++ break;
++ }
++ if (ret1)
++ printk(KERN_WARNING "applesmc: Cannot set MSDW key\n");
++
++ /* Initialize the device. */
++ buffer[0] = 0xe0;
++ buffer[1] = 0xf8;
++ if (applesmc_init_check_key_value(MOTION_SENSOR_KEY, buffer, 2)) {
++ printk(KERN_WARNING "applesmc: failed to init "
++ "the accelerometer\n");
++ goto out;
+ }
+
+- printk(KERN_WARNING "applesmc: failed to init the device\n");
++ ret1 = request_irq(APPLESMC_IRQ, applesmc_irq_handler, IRQF_DISABLED,
++ "applesmc_irq_handler", NULL);
++
++ if (ret1) {
++ printk(KERN_WARNING "applesmc: cannot setup irq handler\n");
++ }
++
++ printk(KERN_DEBUG "applesmc: accelerometer "
++ "successfully initialized.\n");
++ ret = 0;
+
+ out:
+ mutex_unlock(&applesmc_lock);
+@@ -468,9 +607,16 @@ static int applesmc_resume(struct platform_device *dev)
+ return applesmc_device_init();
+ }
+
++static int applesmc_remove(struct platform_device *dev)
++{
++ free_irq(APPLESMC_IRQ, NULL);
++ return 0;
++}
++
+ static struct platform_driver applesmc_driver = {
+ .probe = applesmc_probe,
+ .resume = applesmc_resume,
++ .remove = applesmc_remove,
+ .driver = {
+ .name = "applesmc",
+ .owner = THIS_MODULE,
+@@ -932,6 +1078,122 @@ static ssize_t applesmc_key_at_index_store(struct device *dev,
+ return count;
+ }
+
++static ssize_t applesmc_accelerometer_show(struct device *dev,
++ struct device_attribute *attr, char *sysfsbuf)
++{
++ int ret;
++ unsigned int value = 0;
++ u8 buffer[2];
++ char *key;
++ int length;
++ struct sensor_device_attribute_2 *sensor_attr =
++ to_sensor_dev_attr_2(attr);
++
++ switch (sensor_attr->index) {
++ case 0:
++ key = MOTION_LOW_NORM_INTERVAL;
++ length = 1;
++ break;
++ case 1:
++ key = MOTION_HIGH_NORM_INTERVAL;
++ length = 1;
++ break;
++ case 2:
++ key = MOTION_LOW_NORM;
++ length = 2;
++ break;
++ case 3:
++ key = MOTION_HIGH_NORM;
++ length = 2;
++ break;
++ default:
++ printk(KERN_ERR
++ "Invalid index for applesmc_accelerometer_show");
++ return -EINVAL;
++ }
++
++ mutex_lock(&applesmc_lock);
++
++ ret = applesmc_read_key(key, buffer, length);
++ if (length == 2)
++ value = ((unsigned int)buffer[0] << 8) | buffer[1];
++ else if (length == 1)
++ value = buffer[0];
++ else {
++ printk("Invalid length for applesmc_param_show");
++ ret = -EINVAL;
++ }
++
++ mutex_unlock(&applesmc_lock);
++ if (ret)
++ return ret;
++ else
++ return snprintf(sysfsbuf, PAGE_SIZE, "%u\n", value);
++}
++
++static ssize_t applesmc_accelerometer_store(struct device *dev,
++ struct device_attribute *attr,
++ const char *sysfsbuf, size_t count)
++{
++ int ret;
++ u32 value;
++ u8 buffer[2];
++ char *key;
++ int length;
++ struct sensor_device_attribute_2 *sensor_attr =
++ to_sensor_dev_attr_2(attr);
++
++ switch (sensor_attr->index) {
++ case 0:
++ key = MOTION_LOW_NORM_INTERVAL;
++ length = 1;
++ break;
++ case 1:
++ key = MOTION_HIGH_NORM_INTERVAL;
++ length = 1;
++ break;
++ case 2:
++ key = MOTION_LOW_NORM;
++ length = 2;
++ break;
++ case 3:
++ key = MOTION_HIGH_NORM;
++ length = 2;
++ break;
++ default:
++ printk("Invalid index for applesmc_accelerometer_show");
++ return -EINVAL;
++ }
++
++ value = simple_strtoul(sysfsbuf, NULL, 10);
++
++ if (length == 2) {
++ if (value > 0xffff)
++ return -EINVAL;
++
++ buffer[0] = (value >> 8) & 0xff;
++ buffer[1] = value & 0xff;
++ } else if (length == 1) {
++ if (value > 0xff)
++ return -EINVAL;
++
++ buffer[0] = value & 0xff;
++ } else {
++ printk("Invalid length for applesmc_param_store");
++ return -EINVAL;
++ }
++
++ mutex_lock(&applesmc_lock);
++
++ ret = applesmc_write_key(key, buffer, length);
++
++ mutex_unlock(&applesmc_lock);
++
++ if (ret)
++ return ret;
++ else
++ return count;
++}
+ static struct led_classdev applesmc_backlight = {
+ .name = "smc:kbd_backlight",
+ .default_trigger = "nand-disk",
+@@ -943,10 +1205,22 @@ static DEVICE_ATTR(name, 0444, applesmc_name_show, NULL);
+ static DEVICE_ATTR(position, 0444, applesmc_position_show, NULL);
+ static DEVICE_ATTR(calibrate, 0644,
+ applesmc_calibrate_show, applesmc_calibrate_store);
++static SENSOR_DEVICE_ATTR(low_norm_trigger_interval, 0644,
++ applesmc_accelerometer_show, applesmc_accelerometer_store, 0);
++static SENSOR_DEVICE_ATTR(high_norm_trigger_interval, 0644,
++ applesmc_accelerometer_show, applesmc_accelerometer_store, 1);
++static SENSOR_DEVICE_ATTR(low_norm_trigger, 0644,
++ applesmc_accelerometer_show, applesmc_accelerometer_store, 2);
++static SENSOR_DEVICE_ATTR(high_norm_trigger, 0644,
++ applesmc_accelerometer_show, applesmc_accelerometer_store, 3);
+
+ static struct attribute *accelerometer_attributes[] = {
+ &dev_attr_position.attr,
+ &dev_attr_calibrate.attr,
++ &sensor_dev_attr_low_norm_trigger.dev_attr.attr,
++ &sensor_dev_attr_high_norm_trigger.dev_attr.attr,
++ &sensor_dev_attr_low_norm_trigger_interval.dev_attr.attr,
++ &sensor_dev_attr_high_norm_trigger_interval.dev_attr.attr,
+ NULL
+ };
+
diff --git a/sys-kernel/mactel-linux-sources/files/2.6.24-mactel-patches-r153/appletouch-new.patch b/sys-kernel/mactel-linux-sources/files/2.6.24-mactel-patches-r153/appletouch-new.patch
new file mode 100644
index 0000000..f995c7a
--- /dev/null
+++ b/sys-kernel/mactel-linux-sources/files/2.6.24-mactel-patches-r153/appletouch-new.patch
@@ -0,0 +1,377 @@
+
+
+From: Sven Anders <anders@anduras.de>
+
+
+---
+
+ drivers/input/mouse/appletouch.c | 165 +++++++++++++++++++++++++++++---------
+ 1 files changed, 125 insertions(+), 40 deletions(-)
+
+
+diff --git a/drivers/input/mouse/appletouch.c b/drivers/input/mouse/appletouch.c
+index b4423a4..b42c1ed 100644
+--- a/drivers/input/mouse/appletouch.c
++++ b/drivers/input/mouse/appletouch.c
+@@ -8,6 +8,7 @@
+ * Copyright (C) 2005 Peter Osterlund (petero2@telia.com)
+ * Copyright (C) 2005 Michael Hanselmann (linux-kernel@hansmi.ch)
+ * Copyright (C) 2006 Nicolas Boichat (nicolas@boichat.ch)
++ * Copyright (C) 2007-2008 Sven Anders (anders@anduras.de)
+ *
+ * Thanks to Alex Harper <basilisk@foobox.net> for his inputs.
+ *
+@@ -38,16 +39,18 @@
+ #define APPLE_VENDOR_ID 0x05AC
+
+ /* These names come from Info.plist in AppleUSBTrackpad.kext */
++
++/* PowerBooks Feb 2005 / iBooks */
+ #define FOUNTAIN_ANSI_PRODUCT_ID 0x020E
+ #define FOUNTAIN_ISO_PRODUCT_ID 0x020F
+-
+ #define FOUNTAIN_TP_ONLY_PRODUCT_ID 0x030A
+
+ #define GEYSER1_TP_ONLY_PRODUCT_ID 0x030B
+
+-#define GEYSER_ANSI_PRODUCT_ID 0x0214
+-#define GEYSER_ISO_PRODUCT_ID 0x0215
+-#define GEYSER_JIS_PRODUCT_ID 0x0216
++/* PowerBooks Oct 2005 */
++#define GEYSER2_ANSI_PRODUCT_ID 0x0214
++#define GEYSER2_ISO_PRODUCT_ID 0x0215
++#define GEYSER2_JIS_PRODUCT_ID 0x0216
+
+ /* MacBook devices */
+ #define GEYSER3_ANSI_PRODUCT_ID 0x0217
+@@ -58,9 +61,14 @@
+ * Geyser IV: same as Geyser III according to Info.plist in AppleUSBTrackpad.kext
+ * -> same IOClass (AppleUSBGrIIITrackpad), same acceleration tables
+ */
+-#define GEYSER4_ANSI_PRODUCT_ID 0x021A
+-#define GEYSER4_ISO_PRODUCT_ID 0x021B
+-#define GEYSER4_JIS_PRODUCT_ID 0x021C
++#define GEYSER4_ANSI_PRODUCT_ID 0x021A
++#define GEYSER4_ISO_PRODUCT_ID 0x021B
++#define GEYSER4_JIS_PRODUCT_ID 0x021C
++
++/* Macbook3,1 devices */
++#define GEYSER4_HF_ANSI_PRODUCT_ID 0x0229
++#define GEYSER4_HF_ISO_PRODUCT_ID 0x022A
++#define GEYSER4_HF_JIS_PRODUCT_ID 0x022B
+
+ #define ATP_DEVICE(prod) \
+ .match_flags = USB_DEVICE_ID_MATCH_DEVICE | \
+@@ -73,15 +81,17 @@
+
+ /* table of devices that work with this driver */
+ static struct usb_device_id atp_table [] = {
++
++ /* PowerBooks Feb 2005, iBooks G4 */
+ { ATP_DEVICE(FOUNTAIN_ANSI_PRODUCT_ID) },
+ { ATP_DEVICE(FOUNTAIN_ISO_PRODUCT_ID) },
+ { ATP_DEVICE(FOUNTAIN_TP_ONLY_PRODUCT_ID) },
+ { ATP_DEVICE(GEYSER1_TP_ONLY_PRODUCT_ID) },
+
+ /* PowerBooks Oct 2005 */
+- { ATP_DEVICE(GEYSER_ANSI_PRODUCT_ID) },
+- { ATP_DEVICE(GEYSER_ISO_PRODUCT_ID) },
+- { ATP_DEVICE(GEYSER_JIS_PRODUCT_ID) },
++ { ATP_DEVICE(GEYSER2_ANSI_PRODUCT_ID) },
++ { ATP_DEVICE(GEYSER2_ISO_PRODUCT_ID) },
++ { ATP_DEVICE(GEYSER2_JIS_PRODUCT_ID) },
+
+ /* Core Duo MacBook & MacBook Pro */
+ { ATP_DEVICE(GEYSER3_ANSI_PRODUCT_ID) },
+@@ -93,6 +103,11 @@ static struct usb_device_id atp_table [] = {
+ { ATP_DEVICE(GEYSER4_ISO_PRODUCT_ID) },
+ { ATP_DEVICE(GEYSER4_JIS_PRODUCT_ID) },
+
++ /* Core2 Duo MacBook3,1 */
++ { ATP_DEVICE(GEYSER4_HF_ANSI_PRODUCT_ID) },
++ { ATP_DEVICE(GEYSER4_HF_ISO_PRODUCT_ID) },
++ { ATP_DEVICE(GEYSER4_HF_JIS_PRODUCT_ID) },
++
+ /* Terminating entry */
+ { }
+ };
+@@ -136,12 +151,21 @@ MODULE_DEVICE_TABLE (usb, atp_table);
+ #define ATP_GEYSER_MODE_REQUEST_INDEX 0
+ #define ATP_GEYSER_MODE_VENDOR_VALUE 0x04
+
++/*
++ * Meaning of the status bits (only Geyser 3/4?)
++ */
++#define ATP_STATUS_BIT_BUTTON 0x01 /* The button was pressed */
++#define ATP_STATUS_BIT_UNKNOWN1 0x02 /* Unknown or unused */
++#define ATP_STATUS_BIT_BASE_UPDATE 0x04 /* Update of the base values (untouched pad) */
++#define ATP_STATUS_BIT_UNKNOWN2 0x08 /* Unknown or unused */
++#define ATP_STATUS_BIT_FROM_RESET 0x10 /* Reset previously performed */
++
+ /* Structure to hold all of our device specific stuff */
+ struct atp {
+ char phys[64];
+ struct usb_device * udev; /* usb device */
+ struct urb * urb; /* usb request block */
+- signed char * data; /* transferred data */
++ u8 * data; /* transferred data */
+ struct input_dev * input; /* input dev */
+ unsigned char open; /* non-zero if opened */
+ unsigned char valid; /* are the sensors valid ? */
+@@ -156,8 +180,8 @@ struct atp {
+ /* accumulated sensors */
+ int xy_acc[ATP_XSENSORS + ATP_YSENSORS];
+ int datalen; /* size of an USB urb transfer */
+- int idlecount; /* number of empty packets */
+- struct work_struct work;
++ int idle_counter; /* number of empty packets */
++ struct work_struct work; /* kernel workqueue entry (for re-init) */
+ };
+
+ #define dbg_dump(msg, tab) \
+@@ -174,8 +198,12 @@ struct atp {
+ if (debug) printk(KERN_DEBUG format, ##a); \
+ } while (0)
+
+-MODULE_AUTHOR("Johannes Berg, Stelian Pop, Frank Arnold, Michael Hanselmann");
+-MODULE_DESCRIPTION("Apple PowerBooks USB touchpad driver");
++MODULE_AUTHOR("Johannes Berg");
++MODULE_AUTHOR("Stelian Pop");
++MODULE_AUTHOR("Frank Arnold");
++MODULE_AUTHOR("Michael Hanselmann");
++MODULE_AUTHOR("Sven Anders");
++MODULE_DESCRIPTION("Apple PowerBook and MacBook USB touchpad driver");
+ MODULE_LICENSE("GPL");
+
+ /*
+@@ -185,7 +213,7 @@ static int threshold = ATP_THRESHOLD;
+ module_param(threshold, int, 0644);
+ MODULE_PARM_DESC(threshold, "Discards any change in data from a sensor (trackpad has hundreds of these sensors) less than this value");
+
+-static int debug = 1;
++static int debug;
+ module_param(debug, int, 0644);
+ MODULE_PARM_DESC(debug, "Activate debugging output");
+
+@@ -203,12 +231,12 @@ static inline int atp_is_geyser_2(struct atp *dev)
+ {
+ u16 productId = le16_to_cpu(dev->udev->descriptor.idProduct);
+
+- return (productId == GEYSER_ANSI_PRODUCT_ID) ||
+- (productId == GEYSER_ISO_PRODUCT_ID) ||
+- (productId == GEYSER_JIS_PRODUCT_ID);
++ return (productId == GEYSER2_ANSI_PRODUCT_ID) ||
++ (productId == GEYSER2_ISO_PRODUCT_ID) ||
++ (productId == GEYSER2_JIS_PRODUCT_ID);
+ }
+
+-static inline int atp_is_geyser_3(struct atp *dev)
++static inline int atp_is_geyser_3_4(struct atp *dev)
+ {
+ u16 productId = le16_to_cpu(dev->udev->descriptor.idProduct);
+
+@@ -217,7 +245,10 @@ static inline int atp_is_geyser_3(struct atp *dev)
+ (productId == GEYSER3_JIS_PRODUCT_ID) ||
+ (productId == GEYSER4_ANSI_PRODUCT_ID) ||
+ (productId == GEYSER4_ISO_PRODUCT_ID) ||
+- (productId == GEYSER4_JIS_PRODUCT_ID);
++ (productId == GEYSER4_JIS_PRODUCT_ID) ||
++ (productId == GEYSER4_HF_ANSI_PRODUCT_ID) ||
++ (productId == GEYSER4_HF_ISO_PRODUCT_ID) ||
++ (productId == GEYSER4_HF_JIS_PRODUCT_ID);
+ }
+
+ /*
+@@ -229,7 +260,7 @@ static int atp_geyser_init(struct usb_device *udev)
+ {
+ char data[8];
+ int size;
+-
++
+ size = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
+ ATP_GEYSER_MODE_READ_REQUEST_ID,
+ USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
+@@ -237,6 +268,13 @@ static int atp_geyser_init(struct usb_device *udev)
+ ATP_GEYSER_MODE_REQUEST_INDEX, &data, 8, 5000);
+
+ if (size != 8) {
++ if (debug)
++ {
++ int i;
++ printk("appletouch atp_geyser_init READ error\n");
++ for (i=0; i<8; i++)
++ printk("appletouch[%d]: %d\n", i, (int) data[i]);
++ }
+ err("Could not do mode read request from device"
+ " (Geyser Raw mode)");
+ return -EIO;
+@@ -252,6 +290,13 @@ static int atp_geyser_init(struct usb_device *udev)
+ ATP_GEYSER_MODE_REQUEST_INDEX, &data, 8, 5000);
+
+ if (size != 8) {
++ if (debug)
++ {
++ int i;
++ printk("appletouch atp_geyser_init WRITE error\n");
++ for (i=0; i<8; i++)
++ printk("appletouch[%d]: %d\n", i, (int) data[i]);
++ }
+ err("Could not do mode write request to device"
+ " (Geyser Raw mode)");
+ return -EIO;
+@@ -269,8 +314,7 @@ static void atp_reinit(struct work_struct *work)
+ struct usb_device *udev = dev->udev;
+ int retval;
+
+- dev->idlecount = 0;
+-
++ dprintk("appletouch: putting appletouch to sleep (reinit)\n");
+ atp_geyser_init(udev);
+
+ retval = usb_submit_urb(dev->urb, GFP_ATOMIC);
+@@ -385,7 +429,7 @@ static void atp_complete(struct urb* urb)
+ }
+
+ /* reorder the sensors values */
+- if (atp_is_geyser_3(dev)) {
++ if (atp_is_geyser_3_4(dev)) {
+ memset(dev->xy_cur, 0, sizeof(dev->xy_cur));
+
+ /*
+@@ -442,13 +486,20 @@ static void atp_complete(struct urb* urb)
+ dbg_dump("sample", dev->xy_cur);
+
+ if (!dev->valid) {
+- /* first sample */
++ /* first sample after init or resume */
+ dev->valid = 1;
+ dev->x_old = dev->y_old = -1;
+ memcpy(dev->xy_old, dev->xy_cur, sizeof(dev->xy_old));
++ dev->idle_counter = 0;
++
++ /* store first sample on older Geyser */
++ if ((dev->data[dev->datalen-1] & ATP_STATUS_BIT_BASE_UPDATE) ||
++ !atp_is_geyser_3_4(dev))
++ memcpy(dev->xy_old, dev->xy_cur, sizeof(dev->xy_old));
++
+
+ if (dev->size_detect_done ||
+- atp_is_geyser_3(dev)) /* No 17" Macbooks (yet) */
++ atp_is_geyser_3_4(dev)) /* No 17" Macbooks (yet) */
+ goto exit;
+
+ /* 17" Powerbooks have extra X sensors */
+@@ -474,26 +525,47 @@ static void atp_complete(struct urb* urb)
+ goto exit;
+ }
+
++ /* Just update the base values (i.e. touchpad in untouched state) */
++ if (dev->data[dev->datalen-1] & ATP_STATUS_BIT_BASE_UPDATE)
++ {
++ if (debug > 0) printk("appletouch: updated base values\n");
++
++ memcpy(dev->xy_old, dev->xy_cur, sizeof(dev->xy_old));
++ goto exit;
++ }
++
+ for (i = 0; i < ATP_XSENSORS + ATP_YSENSORS; i++) {
+- /* accumulate the change */
+- signed char change = dev->xy_old[i] - dev->xy_cur[i];
+- dev->xy_acc[i] -= change;
++ /* calculate the change */
++ dev->xy_acc[i] = dev->xy_cur[i] - dev->xy_old[i];
++
++ /* this is a round-robin value, so couple with that */
++ if (dev->xy_acc[i] > 127)
++ dev->xy_acc[i] -= 256;
++
++ if (dev->xy_acc[i] < -127)
++ dev->xy_acc[i] += 256;
++
++ /* Needed for the older Geyser */
++ if (!atp_is_geyser_3_4(dev))
++ {
++ /* store new 'untouched' value, if any new */
++ if (dev->xy_acc[i] < -1)
++ dev->xy_old[i] = dev->xy_cur[i];
++ }
+
+ /* prevent down drifting */
+ if (dev->xy_acc[i] < 0)
+ dev->xy_acc[i] = 0;
+ }
+
+- memcpy(dev->xy_old, dev->xy_cur, sizeof(dev->xy_old));
+-
+ dbg_dump("accumulator", dev->xy_acc);
+
+ x = atp_calculate_abs(dev->xy_acc, ATP_XSENSORS,
+ ATP_XFACT, &x_z, &x_f);
+ y = atp_calculate_abs(dev->xy_acc + ATP_XSENSORS, ATP_YSENSORS,
+ ATP_YFACT, &y_z, &y_f);
+- key = dev->data[dev->datalen - 1] & 1;
+-
++ key = dev->data[dev->datalen - 1] & ATP_STATUS_BIT_BUTTON;
++
+ if (x && y) {
+ if (dev->x_old != -1) {
+ x = (dev->x_old * 3 + x) >> 2;
+@@ -538,16 +610,28 @@ static void atp_complete(struct urb* urb)
+ * work on Fountain touchpads.
+ */
+ if (!atp_is_fountain(dev)) {
++
++ /* Button must not be pressed when entering suspend,
++ otherwise we will never release the button. */
+ if (!x && !y && !key) {
+- dev->idlecount++;
+- if (dev->idlecount == 10) {
+- dev->valid = 0;
++
++ /* Idle counter */
++ dev->idle_counter++;
++
++ /* Wait for 10 more packages before suspending */
++ if (dev->idle_counter > 10) {
++
++ /* Reset counter */
++ dev->idle_counter = 0;
++
++ /* Prepare for device reset */
+ schedule_work(&dev->work);
++
+ /* Don't resubmit urb here, wait for reinit */
+ return;
+ }
+ } else
+- dev->idlecount = 0;
++ dev->idle_counter = 0;
+ }
+
+ exit:
+@@ -615,7 +699,7 @@ static int atp_probe(struct usb_interface *iface, const struct usb_device_id *id
+ dev->udev = udev;
+ dev->input = input_dev;
+ dev->overflowwarn = 0;
+- if (atp_is_geyser_3(dev))
++ if (atp_is_geyser_3_4(dev))
+ dev->datalen = 64;
+ else if (atp_is_geyser_2(dev))
+ dev->datalen = 64;
+@@ -658,7 +742,7 @@ static int atp_probe(struct usb_interface *iface, const struct usb_device_id *id
+
+ set_bit(EV_ABS, input_dev->evbit);
+
+- if (atp_is_geyser_3(dev)) {
++ if (atp_is_geyser_3_4(dev)) {
+ /*
+ * MacBook have 20 X sensors, 10 Y sensors
+ */
+@@ -701,6 +785,7 @@ static int atp_probe(struct usb_interface *iface, const struct usb_device_id *id
+ /* save our data pointer in this interface device */
+ usb_set_intfdata(iface, dev);
+
++ /* initialize kernel work queue for re-init out of interrupt context */
+ INIT_WORK(&dev->work, atp_reinit);
+
+ return 0;
diff --git a/sys-kernel/mactel-linux-sources/files/2.6.24-mactel-patches-r153/appletouch.patch b/sys-kernel/mactel-linux-sources/files/2.6.24-mactel-patches-r153/appletouch.patch
new file mode 100644
index 0000000..036655a
--- /dev/null
+++ b/sys-kernel/mactel-linux-sources/files/2.6.24-mactel-patches-r153/appletouch.patch
@@ -0,0 +1,24 @@
+Appletouch driver ATP_THRESHOLD fix.
+
+From: Ortwin Glück <odi@odi.ch>
+
+
+---
+
+ drivers/input/mouse/appletouch.c | 2 +-
+ 1 files changed, 1 insertions(+), 1 deletions(-)
+
+
+diff --git a/drivers/input/mouse/appletouch.c b/drivers/input/mouse/appletouch.c
+index b42c1ed..805cc5e 100644
+--- a/drivers/input/mouse/appletouch.c
++++ b/drivers/input/mouse/appletouch.c
+@@ -142,7 +142,7 @@ MODULE_DEVICE_TABLE (usb, atp_table);
+ * Threshold for the touchpad sensors. Any change less than ATP_THRESHOLD is
+ * ignored.
+ */
+-#define ATP_THRESHOLD 5
++#define ATP_THRESHOLD 3
+
+ /* Geyser initialization constants */
+ #define ATP_GEYSER_MODE_READ_REQUEST_ID 1
diff --git a/sys-kernel/mactel-linux-sources/files/2.6.24-mactel-patches-r153/disk-protect-fix-2.6.24-crash.patch b/sys-kernel/mactel-linux-sources/files/2.6.24-mactel-patches-r153/disk-protect-fix-2.6.24-crash.patch
new file mode 100644
index 0000000..0c6c494
--- /dev/null
+++ b/sys-kernel/mactel-linux-sources/files/2.6.24-mactel-patches-r153/disk-protect-fix-2.6.24-crash.patch
@@ -0,0 +1,49 @@
+Elias Oltmanns linux-thinkpad@linux-thinkpad.org
+
+From: Nicolas Boichat <nicolas@boichat.ch>
+
+Wed, 13 Feb 2008 12:39:17 +0100
+
+Anyway, there is a temporary solution to this problem. If you apply the
+little patch attached to this email, the usual disk-protect patch will
+work on 2.6.24. This change is supposed to fix a generic problem in
+libata and may eventually be merged upstream, but Tejun Heo (libata
+developer) said that some testing was required first.
+
+This change is absolutely safe for everyone using a non-NCQ capable
+system. In particular, ata_piix doesn't support NCQ. If you are using
+ahci and /sys/class/scsi_disk/.../device/queue_depth reports a value
+greater than 1, i.e. NCQ is enabled, then the patch shouldn't cause any
+harm either but it may or may not affect I/O performance.
+
+Enjoy,
+
+Elias
+---
+
+ drivers/ata/libata-scsi.c | 4 ++--
+ 1 files changed, 2 insertions(+), 2 deletions(-)
+
+
+diff --git a/drivers/ata/libata-scsi.c b/drivers/ata/libata-scsi.c
+index 6b02998..82ec82a 100644
+--- a/drivers/ata/libata-scsi.c
++++ b/drivers/ata/libata-scsi.c
+@@ -823,7 +823,7 @@ static void ata_scsi_sdev_config(struct scsi_device *sdev)
+ * prevent SCSI midlayer from automatically deferring
+ * requests.
+ */
+- sdev->max_device_blocked = 1;
++ sdev->max_device_blocked = 2;
+ }
+
+ static void ata_scsi_dev_config(struct scsi_device *sdev,
+@@ -3156,7 +3156,7 @@ int ata_scsi_add_hosts(struct ata_host *host, struct scsi_host_template *sht)
+ * Set host_blocked to 1 to prevent SCSI midlayer from
+ * automatically deferring requests.
+ */
+- shost->max_host_blocked = 1;
++ shost->max_host_blocked = 2;
+
+ rc = scsi_add_host(ap->scsi_host, ap->host->dev);
+ if (rc)
diff --git a/sys-kernel/mactel-linux-sources/files/2.6.24-mactel-patches-r153/disk-protect-update.patch b/sys-kernel/mactel-linux-sources/files/2.6.24-mactel-patches-r153/disk-protect-update.patch
new file mode 100644
index 0000000..af6afd4
--- /dev/null
+++ b/sys-kernel/mactel-linux-sources/files/2.6.24-mactel-patches-r153/disk-protect-update.patch
@@ -0,0 +1,37 @@
+Disk protect patch update.
+
+From: Nicolas Boichat <nicolas@boichat.ch>
+
+
+---
+
+ block/ll_rw_blk.c | 1 +
+ include/linux/blkdev.h | 2 ++
+ 2 files changed, 3 insertions(+), 0 deletions(-)
+
+
+diff --git a/block/ll_rw_blk.c b/block/ll_rw_blk.c
+index 31f0c22..9d7864a 100644
+--- a/block/ll_rw_blk.c
++++ b/block/ll_rw_blk.c
+@@ -4308,6 +4308,7 @@ static ssize_t queue_protect_show(struct request_queue *q, char *page)
+ spin_unlock_irq(q->queue_lock);
+ return queue_var_show(seconds, (page));
+ }
++EXPORT_SYMBOL(blk_freeze_queue);
+
+ /*
+ * When writing the 'protect' attribute, input is the number of seconds
+diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
+index e10f40b..3e53289 100644
+--- a/include/linux/blkdev.h
++++ b/include/linux/blkdev.h
+@@ -114,6 +114,8 @@ struct io_context *get_io_context(gfp_t gfp_flags, int node);
+ void copy_io_context(struct io_context **pdst, struct io_context **psrc);
+ void swap_io_context(struct io_context **ioc1, struct io_context **ioc2);
+
++void blk_freeze_queue(struct request_queue *q, int seconds);
++
+ struct request;
+ typedef void (rq_end_io_fn)(struct request *, int);
+
diff --git a/sys-kernel/mactel-linux-sources/files/2.6.24-mactel-patches-r153/disk-protect.patch b/sys-kernel/mactel-linux-sources/files/2.6.24-mactel-patches-r153/disk-protect.patch
new file mode 100644
index 0000000..c7c9ae7
--- /dev/null
+++ b/sys-kernel/mactel-linux-sources/files/2.6.24-mactel-patches-r153/disk-protect.patch
@@ -0,0 +1,826 @@
+From: Elias Oltmanns <eo@...>
+
+From: Nicolas Boichat <nicolas@boichat.ch>
+
+Subject: disk-protect patch for kernel 2.6.24-rc3
+Newsgroups: gmane.linux.drivers.hdaps.devel
+Date: 2007-11-18 16:19:24 GMT (16 weeks, 20 hours and 52 minutes ago)
+
+For those who can't wait. Mind you, it's compile tested only. But then
+you all know about rc versions and the usual disclaimers with regard to
+your precious data.
+---
+
+ block/ll_rw_blk.c | 236 ++++++++++++++++++++++++++++++++++++++++++++-
+ drivers/ata/libata-scsi.c | 36 +++++++
+ drivers/ide/ide-disk.c | 142 +++++++++++++++++++++++++++
+ drivers/ide/ide-io.c | 14 +++
+ drivers/scsi/scsi_lib.c | 169 ++++++++++++++++++++++++++++++++
+ include/linux/ata.h | 12 ++
+ include/linux/blkdev.h | 14 +++
+ include/linux/ide.h | 1
+ 8 files changed, 621 insertions(+), 3 deletions(-)
+
+
+diff --git a/block/ll_rw_blk.c b/block/ll_rw_blk.c
+index 8b91994..31f0c22 100644
+--- a/block/ll_rw_blk.c
++++ b/block/ll_rw_blk.c
+@@ -39,6 +39,10 @@
+
+ static void blk_unplug_work(struct work_struct *work);
+ static void blk_unplug_timeout(unsigned long data);
++static void blk_unfreeze_work(struct work_struct *work);
++static void blk_unfreeze_timeout(unsigned long data);
++static int blk_protect_register(struct request_queue *q);
++static void blk_protect_unregister(struct request_queue *q);
+ static void drive_stat_acct(struct request *rq, int new_io);
+ static void init_request_from_bio(struct request *req, struct bio *bio);
+ static int __make_request(struct request_queue *q, struct bio *bio);
+@@ -231,6 +235,16 @@ void blk_queue_make_request(struct request_queue * q, make_request_fn * mfn)
+ q->unplug_timer.function = blk_unplug_timeout;
+ q->unplug_timer.data = (unsigned long)q;
+
++ q->max_unfreeze = 30;
++
++ INIT_WORK(&q->unfreeze_work, blk_unfreeze_work);
++
++ q->unfreeze_timer.function = blk_unfreeze_timeout;
++ q->unfreeze_timer.data = (unsigned long)q;
++
++ /* Set protect_method to auto detection initially */
++ q->protect_method = 2;
++
+ /*
+ * by default assume old behaviour and bounce for any highmem page
+ */
+@@ -263,6 +277,18 @@ static void rq_init(struct request_queue *q, struct request *rq)
+ rq->next_rq = NULL;
+ }
+
++void blk_queue_issue_protect_fn(struct request_queue *q, issue_protect_fn *ipf)
++{
++ q->issue_protect_fn = ipf;
++}
++EXPORT_SYMBOL(blk_queue_issue_protect_fn);
++
++void blk_queue_issue_unprotect_fn(struct request_queue *q, issue_unprotect_fn *iuf)
++{
++ q->issue_unprotect_fn = iuf;
++}
++EXPORT_SYMBOL(blk_queue_issue_unprotect_fn);
++
+ /**
+ * blk_queue_ordered - does this queue support ordered writes
+ * @q: the request queue
+@@ -1861,6 +1887,7 @@ struct request_queue *blk_alloc_queue_node(gfp_t gfp_mask, int node_id)
+ }
+
+ init_timer(&q->unplug_timer);
++ init_timer(&q->unfreeze_timer);
+
+ kobject_set_name(&q->kobj, "%s", "queue");
+ q->kobj.ktype = &queue_ktype;
+@@ -4191,13 +4218,21 @@ int blk_register_queue(struct gendisk *disk)
+ kobject_uevent(&q->kobj, KOBJ_ADD);
+
+ ret = elv_register_queue(q);
++ if (ret)
++ goto err;
++
++ ret = blk_protect_register(q);
+ if (ret) {
+- kobject_uevent(&q->kobj, KOBJ_REMOVE);
+- kobject_del(&q->kobj);
+- return ret;
++ elv_unregister_queue(q);
++ goto err;
+ }
+
+ return 0;
++
++err:
++ kobject_uevent(&q->kobj, KOBJ_REMOVE);
++ kobject_del(&q->kobj);
++ return ret;
+ }
+
+ void blk_unregister_queue(struct gendisk *disk)
+@@ -4205,6 +4240,7 @@ void blk_unregister_queue(struct gendisk *disk)
+ struct request_queue *q = disk->queue;
+
+ if (q && q->request_fn) {
++ blk_protect_unregister(q);
+ elv_unregister_queue(q);
+
+ kobject_uevent(&q->kobj, KOBJ_REMOVE);
+@@ -4212,3 +4248,197 @@ void blk_unregister_queue(struct gendisk *disk)
+ kobject_put(&disk->kobj);
+ }
+ }
++
++/*
++ * Issue lower level unprotect function if no timers are pending.
++ */
++static void blk_unfreeze_work(struct work_struct *work)
++{
++ struct request_queue *q = container_of(work, struct request_queue, unfreeze_work);
++ int pending;
++ unsigned long flags;
++
++ spin_lock_irqsave(q->queue_lock, flags);
++ pending = timer_pending(&q->unfreeze_timer);
++ spin_unlock_irqrestore(q->queue_lock, flags);
++ if (!pending)
++ q->issue_unprotect_fn(q);
++}
++
++/*
++ * Called when the queue freeze timeout expires...
++ */
++static void blk_unfreeze_timeout(unsigned long data)
++{
++ struct request_queue *q = (struct request_queue *) data;
++
++ kblockd_schedule_work(&q->unfreeze_work);
++}
++
++/*
++ * The lower level driver parks and freezes the queue, and this block layer
++ * function sets up the freeze timeout timer on return. If the queue is
++ * already frozen then this is called to extend the timer...
++ */
++void blk_freeze_queue(struct request_queue *q, int seconds)
++{
++ /* Don't accept arbitrarily long freezes */
++ if (seconds >= q->max_unfreeze)
++ seconds = q->max_unfreeze;
++ /* set/reset the timer */
++ mod_timer(&q->unfreeze_timer, msecs_to_jiffies(seconds*1000) + jiffies);
++}
++
++/*
++ * When reading the 'protect' attribute, we return seconds remaining
++ * before unfreeze timeout expires
++ */
++static ssize_t queue_protect_show(struct request_queue *q, char *page)
++{
++ unsigned int seconds = 0;
++
++ spin_lock_irq(q->queue_lock);
++ if (blk_queue_stopped(q) && timer_pending(&q->unfreeze_timer))
++ /*
++ * Adding 1 in order to guarantee nonzero value until timer
++ * has actually expired.
++ */
++ seconds = jiffies_to_msecs(q->unfreeze_timer.expires
++ - jiffies) / 1000 + 1;
++ spin_unlock_irq(q->queue_lock);
++ return queue_var_show(seconds, (page));
++}
++
++/*
++ * When writing the 'protect' attribute, input is the number of seconds
++ * to freeze the queue for. We call a lower level helper function to
++ * park the heads and freeze/block the queue, then we make a block layer
++ * call to setup the thaw timeout. If input is 0, then we thaw the queue.
++ */
++static ssize_t queue_protect_store(struct request_queue *q,
++ const char *page, size_t count)
++{
++ unsigned long freeze = 0;
++
++ queue_var_store(&freeze, page, count);
++
++ if (freeze>0) {
++ /* Park and freeze */
++ if (!blk_queue_stopped(q))
++ q->issue_protect_fn(q);
++ /* set / reset the thaw timer */
++ spin_lock_irq(q->queue_lock);
++ blk_freeze_queue(q, freeze);
++ spin_unlock_irq(q->queue_lock);
++ } else {
++ spin_lock_irq(q->queue_lock);
++ freeze = del_timer(&q->unfreeze_timer);
++ spin_unlock_irq(q->queue_lock);
++ if (freeze)
++ q->issue_unprotect_fn(q);
++ }
++
++ return count;
++}
++
++static ssize_t
++queue_str_show(char *page, char *str, int status)
++{
++ ssize_t len;
++
++ if (status & 1)
++ len = sprintf(page, "[%s]", str);
++ else
++ len = sprintf(page, "%s", str);
++ if (status & 2)
++ len += sprintf(page+len, "\n");
++ else
++ len += sprintf(page+len, " ");
++ return len;
++}
++
++/*
++ * Returns current protect_method.
++ */
++static ssize_t queue_protect_method_show(struct request_queue *q, char *page)
++{
++ int len = 0;
++ int unload = q->protect_method;
++
++ len += queue_str_show(page+len, "auto", (unload & 2) >> 1);
++ len += queue_str_show(page+len, "unload", unload & 1);
++ len += queue_str_show(page+len, "standby", !unload ? 3 : 2);
++ return len;
++}
++
++/*
++ * Stores the device protect method.
++ */
++static ssize_t queue_protect_method_store(struct request_queue *q,
++ const char *page, size_t count)
++{
++ spin_lock_irq(q->queue_lock);
++ if (!strcmp(page, "auto") || !strcmp(page, "auto\n"))
++ q->protect_method = 2;
++ else if (!strcmp(page, "unload") || !strcmp(page, "unload\n"))
++ q->protect_method = 1;
++ else if (!strcmp(page, "standby") || !strcmp(page, "standby\n"))
++ q->protect_method = 0;
++ else {
++ spin_unlock_irq(q->queue_lock);
++ return -EINVAL;
++ }
++ spin_unlock_irq(q->queue_lock);
++ return count;
++}
++
++static struct queue_sysfs_entry queue_protect_entry = {
++ .attr = { .name = "protect", .mode = S_IRUGO | S_IWUSR },
++ .show = queue_protect_show,
++ .store = queue_protect_store,
++};
++static struct queue_sysfs_entry queue_protect_method_entry = {
++ .attr = { .name = "protect_method", .mode = S_IRUGO | S_IWUSR },
++ .show = queue_protect_method_show,
++ .store = queue_protect_method_store,
++};
++
++static int blk_protect_register(struct request_queue *q)
++{
++ int error = 0;
++
++ /* check that the lower level driver has a protect handler */
++ if (!q->issue_protect_fn)
++ return 0;
++
++ /* create the attributes */
++ error = sysfs_create_file(&q->kobj, &queue_protect_entry.attr);
++ if (error) {
++ printk(KERN_ERR
++ "blk_protect_register(): failed to create protect queue attribute!\n");
++ return error;
++ }
++
++ error = sysfs_create_file(&q->kobj, &queue_protect_method_entry.attr);
++ if (error) {
++ sysfs_remove_file(&q->kobj, &queue_protect_entry.attr);
++ printk(KERN_ERR
++ "blk_protect_register(): failed to create protect_method attribute!\n");
++ return error;
++ }
++ kobject_get(&q->kobj);
++
++ return 0;
++}
++
++static void blk_protect_unregister(struct request_queue *q)
++{
++ /* check that the lower level driver has a protect handler */
++ if (!q->issue_protect_fn)
++ return;
++
++ /* remove the attributes */
++ sysfs_remove_file(&q->kobj, &queue_protect_method_entry.attr);
++ sysfs_remove_file(&q->kobj, &queue_protect_entry.attr);
++ kobject_put(&q->kobj);
++}
+diff --git a/drivers/ata/libata-scsi.c b/drivers/ata/libata-scsi.c
+index 14daf48..6b02998 100644
+--- a/drivers/ata/libata-scsi.c
++++ b/drivers/ata/libata-scsi.c
+@@ -856,6 +856,38 @@ static void ata_scsi_dev_config(struct scsi_device *sdev,
+ }
+ }
+
++extern int scsi_protect_queue(struct request_queue *q, int unload);
++extern int scsi_unprotect_queue(struct request_queue *q);
++
++static int ata_scsi_issue_protect_fn(struct request_queue *q)
++{
++ struct scsi_device *sdev = q->queuedata;
++ struct ata_port *ap = ata_shost_to_port(sdev->host);
++ struct ata_device *dev = ata_scsi_find_dev(ap, sdev);
++ int unload = q->protect_method;
++ unsigned long flags;
++
++ if (!dev) {
++ printk(KERN_DEBUG "ata_scsi_issue_protect_fn(): Couldn't find ATA device to be parked.\n");
++ return -ENXIO;
++ }
++
++ if (unload == 2) {
++ unload = ata_id_has_unload(dev->id) ? 1 : 0;
++ spin_lock_irqsave(q->queue_lock, flags);
++ q->protect_method = unload;
++ spin_unlock_irqrestore(q->queue_lock, flags);
++ }
++
++ /* call scsi_protect_queue, requesting either unload or standby */
++ return scsi_protect_queue(q, unload);
++}
++
++static int ata_scsi_issue_unprotect_fn(struct request_queue *q)
++{
++ return scsi_unprotect_queue(q);
++}
++
+ /**
+ * ata_scsi_slave_config - Set SCSI device attributes
+ * @sdev: SCSI device to examine
+@@ -877,6 +909,10 @@ int ata_scsi_slave_config(struct scsi_device *sdev)
+
+ if (dev)
+ ata_scsi_dev_config(sdev, dev);
++ blk_queue_issue_protect_fn(sdev->request_queue,
++ ata_scsi_issue_protect_fn);
++ blk_queue_issue_unprotect_fn(sdev->request_queue,
++ ata_scsi_issue_unprotect_fn);
+
+ return 0; /* scsi layer doesn't check return value, sigh */
+ }
+diff --git a/drivers/ide/ide-disk.c b/drivers/ide/ide-disk.c
+index b178190..1ef536f 100644
+--- a/drivers/ide/ide-disk.c
++++ b/drivers/ide/ide-disk.c
+@@ -675,6 +675,145 @@ static void idedisk_prepare_flush(struct request_queue *q, struct request *rq)
+ }
+
+ /*
++ * todo:
++ * - we freeze the queue regardless of success and rely on the
++ * ide_protect_queue function to thaw immediately if the command
++ * failed (to be consistent with the libata handler)... should
++ * we also inspect here?
++ */
++void ide_end_protect_rq(struct request *rq, int error)
++{
++ struct completion *waiting = rq->end_io_data;
++
++ rq->end_io_data = NULL;
++ /* spin lock already accquired */
++ if (!blk_queue_stopped(rq->q))
++ blk_stop_queue(rq->q);
++
++ complete(waiting);
++}
++
++int ide_unprotect_queue(struct request_queue *q)
++{
++ struct request rq;
++ unsigned long flags;
++ int pending = 0, rc = 0;
++ ide_drive_t *drive = q->queuedata;
++ u8 args[7], *argbuf = args;
++
++ if (!blk_queue_stopped(q))
++ return -EIO;
++
++ /* Are there any pending jobs on the queue? */
++ pending = ((q->rq.count[READ] > 0) || (q->rq.count[WRITE] > 0)) ? 1 : 0;
++
++ spin_lock_irqsave(q->queue_lock, flags);
++ blk_start_queue(q);
++ spin_unlock_irqrestore(q->queue_lock, flags);
++
++ /* The unload feature of the IDLE_IMMEDIATE command
++ temporarily disables HD power management from spinning down
++ the disk. Any other command will reenable HD pm, so, if
++ there are no pending jobs on the queue, another
++ CHECK_POWER_MODE1 command without the unload feature should do
++ just fine. */
++ if (!pending) {
++ printk(KERN_DEBUG "ide_unprotect_queue(): No pending I/O, re-enabling power management..\n");
++ memset(args, 0, sizeof(args));
++ argbuf[0] = 0xe5; /* CHECK_POWER_MODE1 */
++ ide_init_drive_cmd(&rq);
++ rq.cmd_type = REQ_TYPE_ATA_TASK;
++ rq.buffer = argbuf;
++ rc = ide_do_drive_cmd(drive, &rq, ide_head_wait);
++ }
++
++ return rc;
++}
++
++int ide_protect_queue(struct request_queue *q, int unload)
++{
++ ide_drive_t *drive = q->queuedata;
++ struct request rq;
++ u8 args[7], *argbuf = args;
++ int ret = 0;
++ DECLARE_COMPLETION(wait);
++
++ memset(&rq, 0, sizeof(rq));
++ memset(args, 0, sizeof(args));
++
++ if (blk_queue_stopped(q))
++ return -EIO;
++
++ if (unload) {
++ argbuf[0] = 0xe1;
++ argbuf[1] = 0x44;
++ argbuf[3] = 0x4c;
++ argbuf[4] = 0x4e;
++ argbuf[5] = 0x55;
++ } else
++ argbuf[0] = 0xe0;
++
++ /* Issue the park command & freeze */
++ ide_init_drive_cmd(&rq);
++
++ rq.cmd_type = REQ_TYPE_ATA_TASK;
++ rq.buffer = argbuf;
++ rq.end_io_data = &wait;
++ rq.end_io = ide_end_protect_rq;
++
++ ret = ide_do_drive_cmd(drive, &rq, ide_next);
++ wait_for_completion(&wait);
++
++ if (ret)
++ {
++ printk(KERN_DEBUG "ide_protect_queue(): Warning: head NOT parked!..\n");
++ ide_unprotect_queue(q);
++ return ret;
++ }
++
++ if (unload) {
++ if (args[3] == 0xc4)
++ printk(KERN_DEBUG "ide_protect_queue(): head parked..\n");
++ else {
++ /* error parking the head */
++ printk(KERN_DEBUG "ide_protect_queue(): head NOT parked!..\n");
++ ret = -EIO;
++ ide_unprotect_queue(q);
++ }
++ } else
++ printk(KERN_DEBUG "ide_protect_queue(): head park not requested, used standby!..\n");
++
++ return ret;
++}
++
++int idedisk_issue_protect_fn(struct request_queue *q)
++{
++ ide_drive_t *drive = q->queuedata;
++ int unload = q->protect_method;
++ unsigned long flags;
++
++ /*
++ * Check capability of the device -
++ * - if "idle immediate with unload" is supported we use that, else
++ * we use "standby immediate" and live with spinning down the drive..
++ * (Word 84, bit 13 of IDENTIFY DEVICE data)
++ */
++ if (unload == 2) {
++ unload = drive->id->cfsse & (1 << 13) ? 1 : 0;
++ spin_lock_irqsave(q->queue_lock, flags);
++ q->protect_method = unload;
++ spin_unlock_irqrestore(q->queue_lock, flags);
++ }
++
++ return ide_protect_queue(q, unload);
++}
++
++int idedisk_issue_unprotect_fn(struct request_queue *q)
++{
++ return ide_unprotect_queue(q);
++}
++
++/*
+ * This is tightly woven into the driver->do_special can not touch.
+ * DON'T do it again until a total personality rewrite is committed.
+ */
+@@ -943,6 +1082,9 @@ static void idedisk_setup (ide_drive_t *drive)
+ drive->wcache = 1;
+
+ write_cache(drive, 1);
++
++ blk_queue_issue_protect_fn(drive->queue, idedisk_issue_protect_fn);
++ blk_queue_issue_unprotect_fn(drive->queue, idedisk_issue_unprotect_fn);
+ }
+
+ static void ide_cacheflush_p(ide_drive_t *drive)
+diff --git a/drivers/ide/ide-io.c b/drivers/ide/ide-io.c
+index bef781f..873764e 100644
+--- a/drivers/ide/ide-io.c
++++ b/drivers/ide/ide-io.c
+@@ -1271,6 +1271,17 @@ static void ide_do_request (ide_hwgroup_t *hwgroup, int masked_irq)
+ }
+
+ /*
++ * Don't accept a request when the queue is stopped (unless we
++ * are resuming from suspend). Prevents existing queue entries
++ * being processed after queue is stopped by the hard disk
++ * protection mechanism...
++ */
++ if (test_bit(QUEUE_FLAG_STOPPED, &drive->queue->queue_flags) && !blk_pm_resume_request(rq)) {
++ hwgroup->busy = 0;
++ break;
++ }
++
++ /*
+ * Sanity: don't accept a request that isn't a PM request
+ * if we are currently power managed. This is very important as
+ * blk_stop_queue() doesn't prevent the elv_next_request()
+@@ -1768,6 +1779,9 @@ int ide_do_drive_cmd (ide_drive_t *drive, struct request *rq, ide_action_t actio
+ where = ELEVATOR_INSERT_FRONT;
+ rq->cmd_flags |= REQ_PREEMPT;
+ }
++ if (action == ide_next)
++ where = ELEVATOR_INSERT_FRONT;
++
+ __elv_add_request(drive->queue, rq, where, 0);
+ ide_do_request(hwgroup, IDE_NO_IRQ);
+ spin_unlock_irqrestore(&ide_lock, flags);
+diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
+index a9ac5b1..58049e7 100644
+--- a/drivers/scsi/scsi_lib.c
++++ b/drivers/scsi/scsi_lib.c
+@@ -2268,7 +2268,13 @@ EXPORT_SYMBOL_GPL(sdev_evt_send_simple);
+ int
+ scsi_device_quiesce(struct scsi_device *sdev)
+ {
++ int i;
+ int err = scsi_device_set_state(sdev, SDEV_QUIESCE);
++ for (i = 0; err && (sdev->sdev_state == SDEV_BLOCK) && (i < 100);
++ i++) {
++ msleep_interruptible(200);
++ err = scsi_device_set_state(sdev, SDEV_QUIESCE);
++ }
+ if (err)
+ return err;
+
+@@ -2518,3 +2524,166 @@ void scsi_kunmap_atomic_sg(void *virt)
+ kunmap_atomic(virt, KM_BIO_SRC_IRQ);
+ }
+ EXPORT_SYMBOL(scsi_kunmap_atomic_sg);
++
++/*
++ * Structure required for synchronous io completion after queue freezing
++ */
++struct scsi_protect_io_context_sync {
++ struct scsi_device *sdev;
++ int result;
++ char *sense;
++ struct completion *waiting;
++};
++
++/*
++ * scsi_protect_wait_done()
++ * Command completion handler for scsi_protect_queue().
++ *
++ * Unable to call scsi_internal_device_block() as
++ * scsi_end_request() already has the spinlock. So,
++ * we put the necessary functionality inline.
++ *
++ * todo:
++ * - we block the queue regardless of success and rely on the
++ * scsi_protect_queue function to unblock if the command
++ * failed... should we also inspect here?
++ */
++static void scsi_protect_wait_done(void *data, char *sense, int result, int resid)
++{
++ struct scsi_protect_io_context_sync *siocs = data;
++ struct completion *waiting = siocs->waiting;
++ struct request_queue *q = siocs->sdev->request_queue;
++
++ siocs->waiting = NULL;
++ siocs->result = result;
++ memcpy(siocs->sense, sense, SCSI_SENSE_BUFFERSIZE);
++
++ if (!scsi_device_set_state(siocs->sdev, SDEV_BLOCK))
++ blk_stop_queue(q);
++
++ complete(waiting);
++}
++
++/*
++ * scsi_unprotect_queue()
++ * - release the queue that was previously blocked
++ */
++int scsi_unprotect_queue(struct request_queue *q)
++{
++ struct scsi_device *sdev = q->queuedata;
++ int rc = 0, pending = 0;
++ u8 scsi_cmd[MAX_COMMAND_SIZE];
++ struct scsi_sense_hdr sshdr;
++
++ if (sdev->sdev_state != SDEV_BLOCK)
++ return -ENXIO;
++
++ /* Are there any pending jobs on the queue? */
++ pending = ((q->rq.count[READ] > 0) || (q->rq.count[WRITE] > 0)) ? 1 : 0;
++
++ rc = scsi_internal_device_unblock(sdev);
++ if (rc)
++ return rc;
++
++ if (!pending) {
++ printk(KERN_DEBUG "scsi_unprotect_queue(): No pending I/O, re-enabling power management..\n");
++
++ memset(scsi_cmd, 0, sizeof(scsi_cmd));
++ scsi_cmd[0] = ATA_16;
++ scsi_cmd[1] = (3 << 1); /* Non-data */
++ /* scsi_cmd[2] is already 0 -- no off.line, cc, or data xfer */
++ scsi_cmd[14] = 0xe5; /* CHECK_POWER_MODE1 */
++
++ /* Good values for timeout and retries? Values below
++ from scsi_ioctl_send_command() for default case... */
++ if (scsi_execute_req(sdev, scsi_cmd, DMA_NONE, NULL, 0, &sshdr,
++ (10*HZ), 5))
++ rc = -EIO;
++ }
++ return rc;
++}
++EXPORT_SYMBOL_GPL(scsi_unprotect_queue);
++
++/*
++ * scsi_protect_queue()
++ * - build and issue the park/standby command..
++ * - queue is blocked during command completion handler
++ */
++int scsi_protect_queue(struct request_queue *q, int unload)
++{
++ struct scsi_protect_io_context_sync siocs;
++ struct scsi_device *sdev = q->queuedata;
++ int rc = 0;
++ u8 args[7];
++ u8 scsi_cmd[MAX_COMMAND_SIZE];
++ unsigned char sense[SCSI_SENSE_BUFFERSIZE];
++ unsigned char *desc;
++ DECLARE_COMPLETION_ONSTACK(wait);
++
++ if (sdev->sdev_state != SDEV_RUNNING)
++ return -ENXIO;
++
++ memset(args, 0, sizeof(args));
++ memset(sense, 0, sizeof(sense));
++
++ if (unload) {
++ args[0] = 0xe1;
++ args[1] = 0x44;
++ args[3] = 0x4c;
++ args[4] = 0x4e;
++ args[5] = 0x55;
++ } else
++ args[0] = 0xe0;
++
++ memset(scsi_cmd, 0, sizeof(scsi_cmd));
++ scsi_cmd[0] = ATA_16;
++ scsi_cmd[1] = (3 << 1); /* Non-data */
++ scsi_cmd[2] = 0x20; /* no off.line, or data xfer, request cc */
++ scsi_cmd[4] = args[1];
++ scsi_cmd[6] = args[2];
++ scsi_cmd[8] = args[3];
++ scsi_cmd[10] = args[4];
++ scsi_cmd[12] = args[5];
++ scsi_cmd[14] = args[0];
++ siocs.sdev = sdev;
++ siocs.sense = sense;
++ siocs.waiting = &wait;
++
++ scsi_execute_async(sdev, scsi_cmd, COMMAND_SIZE(scsi_cmd[0]),
++ DMA_NONE, NULL, 0, 0, (10*HZ), 5,
++ &siocs, &scsi_protect_wait_done, GFP_NOWAIT);
++ wait_for_completion(&wait);
++
++ if (siocs.result != ((DRIVER_SENSE << 24) + SAM_STAT_CHECK_CONDITION)) {
++ printk(KERN_DEBUG "scsi_protect_queue(): head NOT parked!..\n");
++ scsi_unprotect_queue(q); /* just in case we still managed to block */
++ rc = -EIO;
++ goto out;
++ }
++
++ desc = sense + 8;
++
++ /* Retrieve data from check condition */
++ args[1] = desc[3];
++ args[2] = desc[5];
++ args[3] = desc[7];
++ args[4] = desc[9];
++ args[5] = desc[11];
++ args[0] = desc[13];
++
++ if (unload) {
++ if (args[3] == 0xc4)
++ printk(KERN_DEBUG "scsi_protect_queue(): head parked..\n");
++ else {
++ /* error parking the head */
++ printk(KERN_DEBUG "scsi_protect_queue(): head NOT parked!..\n");
++ rc = -EIO;
++ scsi_unprotect_queue(q);
++ }
++ } else
++ printk(KERN_DEBUG "scsi_protect_queue(): head park not requested, used standby!..\n");
++
++out:
++ return rc;
++}
++EXPORT_SYMBOL_GPL(scsi_protect_queue);
+diff --git a/include/linux/ata.h b/include/linux/ata.h
+index e672e80..aa16cbb 100644
+--- a/include/linux/ata.h
++++ b/include/linux/ata.h
+@@ -395,6 +395,18 @@ struct ata_taskfile {
+
+ #define ata_id_cdb_intr(id) (((id)[0] & 0x60) == 0x20)
+
++static inline int ata_id_has_unload(const u16 *id)
++{
++ /* ATA-7 specifies two places to indicate unload feature support.
++ * Since I don't really understand the difference, I'll just check
++ * both and only return zero if none of them indicates otherwise. */
++ if ((id[84] & 0xC000) == 0x4000 && id[84] & (1 << 13))
++ return id[84] & (1 << 13);
++ if ((id[87] & 0xC000) == 0x4000)
++ return id[87] & (1 << 13);
++ return 0;
++}
++
+ static inline bool ata_id_has_hipm(const u16 *id)
+ {
+ u16 val = id[76];
+diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
+index d18ee67..e10f40b 100644
+--- a/include/linux/blkdev.h
++++ b/include/linux/blkdev.h
+@@ -332,6 +332,8 @@ struct bio_vec;
+ typedef int (merge_bvec_fn) (struct request_queue *, struct bio *, struct bio_vec *);
+ typedef void (prepare_flush_fn) (struct request_queue *, struct request *);
+ typedef void (softirq_done_fn)(struct request *);
++typedef int (issue_protect_fn) (struct request_queue *);
++typedef int (issue_unprotect_fn) (struct request_queue *);
+
+ enum blk_queue_state {
+ Queue_down,
+@@ -368,6 +370,8 @@ struct request_queue
+ merge_bvec_fn *merge_bvec_fn;
+ prepare_flush_fn *prepare_flush_fn;
+ softirq_done_fn *softirq_done_fn;
++ issue_protect_fn *issue_protect_fn;
++ issue_unprotect_fn *issue_unprotect_fn;
+
+ /*
+ * Dispatch queue sorting
+@@ -383,6 +387,14 @@ struct request_queue
+ unsigned long unplug_delay; /* After this many jiffies */
+ struct work_struct unplug_work;
+
++ /*
++ * Auto-unfreeze state
++ */
++ struct timer_list unfreeze_timer;
++ int max_unfreeze; /* At most this many seconds */
++ struct work_struct unfreeze_work;
++ int protect_method;
++
+ struct backing_dev_info backing_dev_info;
+
+ /*
+@@ -773,6 +785,8 @@ extern int blk_do_ordered(struct request_queue *, struct request **);
+ extern unsigned blk_ordered_cur_seq(struct request_queue *);
+ extern unsigned blk_ordered_req_seq(struct request *);
+ extern void blk_ordered_complete_seq(struct request_queue *, unsigned, int);
++extern void blk_queue_issue_protect_fn(struct request_queue *, issue_protect_fn *);
++extern void blk_queue_issue_unprotect_fn(struct request_queue *, issue_unprotect_fn *);
+
+ extern int blk_rq_map_sg(struct request_queue *, struct request *, struct scatterlist *);
+ extern void blk_dump_rq_flags(struct request *, char *);
+diff --git a/include/linux/ide.h b/include/linux/ide.h
+index 9a6a41e..a8f12f5 100644
+--- a/include/linux/ide.h
++++ b/include/linux/ide.h
+@@ -1045,6 +1045,7 @@ extern void ide_init_drive_cmd (struct request *rq);
+ */
+ typedef enum {
+ ide_wait, /* insert rq at end of list, and wait for it */
++ ide_next, /* insert rq immediately after current request */
+ ide_preempt, /* insert rq in front of current request */
+ ide_head_wait, /* insert rq in front of current request and wait for it */
+ ide_end /* insert rq at end of list, but don't wait for it */
diff --git a/sys-kernel/mactel-linux-sources/files/2.6.24-mactel-patches-r153/export-lookup_dev.patch b/sys-kernel/mactel-linux-sources/files/2.6.24-mactel-patches-r153/export-lookup_dev.patch
new file mode 100644
index 0000000..38e671a
--- /dev/null
+++ b/sys-kernel/mactel-linux-sources/files/2.6.24-mactel-patches-r153/export-lookup_dev.patch
@@ -0,0 +1,24 @@
+Export lookup_dev.
+
+From: Nicolas Boichat <nicolas@boichat.ch>
+
+
+---
+
+ fs/block_dev.c | 2 ++
+ 1 files changed, 2 insertions(+), 0 deletions(-)
+
+
+diff --git a/fs/block_dev.c b/fs/block_dev.c
+index 993f78c..3df9250 100644
+--- a/fs/block_dev.c
++++ b/fs/block_dev.c
+@@ -1417,6 +1417,8 @@ fail:
+ goto out;
+ }
+
++EXPORT_SYMBOL(lookup_bdev);
++
+ /**
+ * open_bdev_excl - open a block device by name and set it up for use
+ *
diff --git a/sys-kernel/mactel-linux-sources/files/2.6.24-mactel-patches-r153/hid-add-new-apple-keyboard.patch b/sys-kernel/mactel-linux-sources/files/2.6.24-mactel-patches-r153/hid-add-new-apple-keyboard.patch
new file mode 100644
index 0000000..e2fbf92
--- /dev/null
+++ b/sys-kernel/mactel-linux-sources/files/2.6.24-mactel-patches-r153/hid-add-new-apple-keyboard.patch
@@ -0,0 +1,182 @@
+
+
+From: Nicolas Boichat <nicolas@boichat.ch>
+
+
+---
+
+ drivers/hid/hid-input.c | 48 +++++++++++++++++++++++++++++++++---
+ drivers/hid/usbhid/hid-quirks.c | 52 +++++++++++++++++++++++++++++++++++++++
+ include/linux/hid.h | 1 +
+ 3 files changed, 97 insertions(+), 4 deletions(-)
+
+
+diff --git a/drivers/hid/hid-input.c b/drivers/hid/hid-input.c
+index 0b27da7..a39de6c 100644
+--- a/drivers/hid/hid-input.c
++++ b/drivers/hid/hid-input.c
+@@ -119,6 +119,30 @@ static struct hidinput_key_translation powerbook_fn_keys[] = {
+ { }
+ };
+
++static struct hidinput_key_translation apple_keyboard_fn_keys[] = {
++ { KEY_BACKSPACE, KEY_DELETE },
++ { KEY_F1, KEY_BRIGHTNESSDOWN, POWERBOOK_FLAG_FKEY },
++ { KEY_F2, KEY_BRIGHTNESSUP, POWERBOOK_FLAG_FKEY },
++ { KEY_F3, KEY_CYCLEWINDOWS, POWERBOOK_FLAG_FKEY },
++ { KEY_F4, KEY_CONFIG, POWERBOOK_FLAG_FKEY },
++ { KEY_F7, KEY_PREVIOUSSONG, POWERBOOK_FLAG_FKEY },
++ { KEY_F8, KEY_PLAYPAUSE, POWERBOOK_FLAG_FKEY },
++ { KEY_F9, KEY_NEXTSONG, POWERBOOK_FLAG_FKEY },
++ { KEY_F10, KEY_MUTE, POWERBOOK_FLAG_FKEY },
++ { KEY_F11, KEY_VOLUMEDOWN, POWERBOOK_FLAG_FKEY },
++ { KEY_F12, KEY_VOLUMEUP, POWERBOOK_FLAG_FKEY },
++ { KEY_UP, KEY_PAGEUP },
++ { KEY_DOWN, KEY_PAGEDOWN },
++ { KEY_LEFT, KEY_HOME },
++ { KEY_RIGHT, KEY_END },
++ { }
++};
++
++static struct hidinput_key_translation apple_keyboard[] = {
++ { KEY_VOLUMEUP, KEY_EJECTCD },
++ { }
++};
++
+ static struct hidinput_key_translation powerbook_numlock_keys[] = {
+ { KEY_J, KEY_KP1 },
+ { KEY_K, KEY_KP2 },
+@@ -176,8 +200,10 @@ static int hidinput_pb_event(struct hid_device *hid, struct input_dev *input,
+
+ if (hid_pb_fnmode) {
+ int do_translate;
+-
+- trans = find_translation(powerbook_fn_keys, usage->code);
++ if (hid->quirks & HID_QUIRK_APPLE_KEYBOARD)
++ trans = find_translation(apple_keyboard_fn_keys, usage->code);
++ else
++ trans = find_translation(powerbook_fn_keys, usage->code);
+ if (trans) {
+ if (test_bit(usage->code, hid->pb_pressed_fn))
+ do_translate = 1;
+@@ -200,8 +226,8 @@ static int hidinput_pb_event(struct hid_device *hid, struct input_dev *input,
+ }
+ }
+
+- if (test_bit(usage->code, hid->pb_pressed_numlock) ||
+- test_bit(LED_NUML, input->led)) {
++ if (!(hid->quirks & HID_QUIRK_APPLE_KEYBOARD) && (test_bit(usage->code, hid->pb_pressed_numlock) ||
++ test_bit(LED_NUML, input->led))) {
+ trans = find_translation(powerbook_numlock_keys, usage->code);
+
+ if (trans) {
+@@ -217,6 +243,14 @@ static int hidinput_pb_event(struct hid_device *hid, struct input_dev *input,
+ }
+ }
+
++ if (hid->quirks & HID_QUIRK_APPLE_KEYBOARD) {
++ trans = find_translation(apple_keyboard, usage->code);
++ if (trans) {
++ input_event(input, usage->type, trans->to, value);
++ return 1;
++ }
++ }
++
+ if (hid->quirks & HID_QUIRK_POWERBOOK_ISO_KEYBOARD) {
+ trans = find_translation(powerbook_iso_keyboard, usage->code);
+ if (trans) {
+@@ -241,6 +275,12 @@ static void hidinput_pb_setup(struct input_dev *input)
+ for (trans = powerbook_numlock_keys; trans->from; trans++)
+ set_bit(trans->to, input->keybit);
+
++ for (trans = apple_keyboard_fn_keys; trans->from; trans++)
++ set_bit(trans->to, input->keybit);
++
++ for (trans = apple_keyboard; trans->from; trans++)
++ set_bit(trans->to, input->keybit);
++
+ for (trans = powerbook_iso_keyboard; trans->from; trans++)
+ set_bit(trans->to, input->keybit);
+
+diff --git a/drivers/hid/usbhid/hid-quirks.c b/drivers/hid/usbhid/hid-quirks.c
+index a255285..8d21c83 100644
+--- a/drivers/hid/usbhid/hid-quirks.c
++++ b/drivers/hid/usbhid/hid-quirks.c
+@@ -59,6 +59,32 @@
+ #define USB_DEVICE_ID_APPLE_GEYSER4_ANSI 0x021a
+ #define USB_DEVICE_ID_APPLE_GEYSER4_ISO 0x021b
+ #define USB_DEVICE_ID_APPLE_GEYSER4_JIS 0x021c
++
++/* Apple 2007 Wired keyboards */
++#define USB_DEVICE_ID_APPLE_KEYBOARD_ANSI 0x0220
++#define USB_DEVICE_ID_APPLE_KEYBOARD_ISO 0x0221
++#define USB_DEVICE_ID_APPLE_KEYBOARD_JIS 0x0222
++
++/* macbook3,1 keyboards */
++#define USB_DEVICE_ID_APPLE_GEYSER4_HF_ANSI 0x0229
++#define USB_DEVICE_ID_APPLE_GEYSER4_HF_ISO 0x022a
++#define USB_DEVICE_ID_APPLE_GEYSER4_HF_JIS 0x022b
++
++/* Apple WellSpring keyboard + trackpad */
++#define USB_PRODUCT_ID_WELLSPRING_ANSI 0x0223
++#define USB_PRODUCT_ID_WELLSPRING_ISO 0x0224
++#define USB_PRODUCT_ID_WELLSPRING_JIS 0x0225
++
++/* Apple WellSpring II keyboard + trackpad */
++#define USB_PRODUCT_ID_WELLSPRING2_ANSI 0x0230
++#define USB_PRODUCT_ID_WELLSPRING2_ISO 0x0231
++#define USB_PRODUCT_ID_WELLSPRING2_JIS 0x0232
++
++/* Apple 2007 Wireless keyboards */
++#define USB_DEVICE_ID_APPLE_WIRELESS_KEYBOARD_ANSI 0x022c
++#define USB_DEVICE_ID_APPLE_WIRELESS_KEYBOARD_ISO 0x022d
++#define USB_DEVICE_ID_APPLE_WIRELESS_KEYBOARD_JIS 0x022e
++
+ #define USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY 0x030a
+ #define USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY 0x030b
+ #define USB_DEVICE_ID_APPLE_IRCONTROL4 0x8242
+@@ -551,6 +577,32 @@ static const struct hid_blacklist {
+ { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ANSI, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
+ { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ISO, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_IGNORE_MOUSE | HID_QUIRK_POWERBOOK_ISO_KEYBOARD},
+ { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_JIS, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
++
++ /* Apple 2007 Wired keyboards */
++ { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_KEYBOARD_ANSI, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_IGNORE_MOUSE | HID_QUIRK_APPLE_KEYBOARD},
++ { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_KEYBOARD_ISO, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_IGNORE_MOUSE | HID_QUIRK_APPLE_KEYBOARD | HID_QUIRK_POWERBOOK_ISO_KEYBOARD},
++ { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_KEYBOARD_JIS, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_IGNORE_MOUSE | HID_QUIRK_APPLE_KEYBOARD},
++
++ /* macbook3,1 keyboards */
++ { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ANSI, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_IGNORE_MOUSE | HID_QUIRK_APPLE_KEYBOARD},
++ { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ISO, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_IGNORE_MOUSE | HID_QUIRK_APPLE_KEYBOARD | HID_QUIRK_POWERBOOK_ISO_KEYBOARD},
++ { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_JIS, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_IGNORE_MOUSE | HID_QUIRK_APPLE_KEYBOARD},
++
++ /* Apple 2007 Wireless keyboards */
++ { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WIRELESS_KEYBOARD_ANSI, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_IGNORE_MOUSE | HID_QUIRK_APPLE_KEYBOARD},
++ { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WIRELESS_KEYBOARD_ISO, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_IGNORE_MOUSE | HID_QUIRK_APPLE_KEYBOARD | HID_QUIRK_POWERBOOK_ISO_KEYBOARD},
++ { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WIRELESS_KEYBOARD_JIS, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_IGNORE_MOUSE | HID_QUIRK_APPLE_KEYBOARD},
++
++ /* Apple WellSpring keyboard + trackpad */
++ { USB_VENDOR_ID_APPLE, USB_PRODUCT_ID_WELLSPRING_ANSI, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_APPLE_KEYBOARD},
++ { USB_VENDOR_ID_APPLE, USB_PRODUCT_ID_WELLSPRING_ISO, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_APPLE_KEYBOARD | HID_QUIRK_POWERBOOK_ISO_KEYBOARD},
++ { USB_VENDOR_ID_APPLE, USB_PRODUCT_ID_WELLSPRING_JIS, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_APPLE_KEYBOARD},
++
++ /* Apple WellSpring II keyboard + trackpad */
++ { USB_VENDOR_ID_APPLE, USB_PRODUCT_ID_WELLSPRING2_ANSI, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_APPLE_KEYBOARD},
++ { USB_VENDOR_ID_APPLE, USB_PRODUCT_ID_WELLSPRING2_ISO, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_APPLE_KEYBOARD | HID_QUIRK_POWERBOOK_ISO_KEYBOARD},
++ { USB_VENDOR_ID_APPLE, USB_PRODUCT_ID_WELLSPRING2_JIS, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_APPLE_KEYBOARD},
++
+ { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
+ { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
+
+diff --git a/include/linux/hid.h b/include/linux/hid.h
+index 6e35b92..04b26b5 100644
+--- a/include/linux/hid.h
++++ b/include/linux/hid.h
+@@ -281,6 +281,7 @@ struct hid_item {
+ #define HID_QUIRK_LOGITECH_IGNORE_DOUBLED_WHEEL 0x00400000
+ #define HID_QUIRK_LOGITECH_EXPANDED_KEYMAP 0x00800000
+ #define HID_QUIRK_IGNORE_HIDINPUT 0x01000000
++#define HID_QUIRK_APPLE_KEYBOARD 0x02000000
+
+ /*
+ * Separate quirks for runtime report descriptor fixup
diff --git a/sys-kernel/mactel-linux-sources/files/2.6.24-mactel-patches-r153/sigmatel_audio_display_all_controls_when_subsystem_id_is_wrong.patch b/sys-kernel/mactel-linux-sources/files/2.6.24-mactel-patches-r153/sigmatel_audio_display_all_controls_when_subsystem_id_is_wrong.patch
new file mode 100644
index 0000000..235146d
--- /dev/null
+++ b/sys-kernel/mactel-linux-sources/files/2.6.24-mactel-patches-r153/sigmatel_audio_display_all_controls_when_subsystem_id_is_wrong.patch
@@ -0,0 +1,29 @@
+Display Macbook Pro 1st gen controls when the subsystem id is wrong (0x100).
+
+From: Nicolas Boichat <nicolas@boichat.ch>
+
+
+---
+
+ sound/pci/hda/patch_sigmatel.c | 4 +++-
+ 1 files changed, 3 insertions(+), 1 deletions(-)
+
+
+diff --git a/sound/pci/hda/patch_sigmatel.c b/sound/pci/hda/patch_sigmatel.c
+index 0401223..c0e626b 100644
+--- a/sound/pci/hda/patch_sigmatel.c
++++ b/sound/pci/hda/patch_sigmatel.c
+@@ -2587,10 +2587,12 @@ static int patch_stac922x(struct hda_codec *codec)
+ case 0x106b1700:
+ case 0x106b0200:
+ case 0x106b1e00:
++ case 0x100: /* Invalid subsystem ID, happens randomly on
++ * MacBook Pro 1st generation
++ */
+ spec->board_config = STAC_INTEL_MAC_V3;
+ break;
+ case 0x106b1a00:
+- case 0x00000100:
+ spec->board_config = STAC_INTEL_MAC_V4;
+ break;
+ case 0x106b0a00:
diff --git a/sys-kernel/mactel-linux-sources/files/2.6.24-mactel-patches-r153/sigmatel_audio_fix_macbook_v2.patch b/sys-kernel/mactel-linux-sources/files/2.6.24-mactel-patches-r153/sigmatel_audio_fix_macbook_v2.patch
new file mode 100644
index 0000000..e35465b
--- /dev/null
+++ b/sys-kernel/mactel-linux-sources/files/2.6.24-mactel-patches-r153/sigmatel_audio_fix_macbook_v2.patch
@@ -0,0 +1,31 @@
+Fixes audio on Macbook v2.
+
+From: Marek Sterzik <marek@milimetr.org>
+
+
+---
+
+ sound/pci/hda/patch_sigmatel.c | 2 ++
+ 1 files changed, 2 insertions(+), 0 deletions(-)
+
+
+diff --git a/sound/pci/hda/patch_sigmatel.c b/sound/pci/hda/patch_sigmatel.c
+index c0e626b..e7995f6 100644
+--- a/sound/pci/hda/patch_sigmatel.c
++++ b/sound/pci/hda/patch_sigmatel.c
+@@ -81,6 +81,7 @@ enum {
+ /* for backward compatibility */
+ STAC_MACMINI,
+ STAC_MACBOOK,
++ STAC_MACBOOK_V2,
+ STAC_MACBOOK_PRO_V1,
+ STAC_MACBOOK_PRO_V2,
+ STAC_IMAC_INTEL,
+@@ -905,6 +906,7 @@ static const char *stac922x_models[STAC_922X_MODELS] = {
+ /* for backward compatibility */
+ [STAC_MACMINI] = "macmini",
+ [STAC_MACBOOK] = "macbook",
++ [STAC_MACBOOK_V2] = "macbook-v2",
+ [STAC_MACBOOK_PRO_V1] = "macbook-pro-v1",
+ [STAC_MACBOOK_PRO_V2] = "macbook-pro",
+ [STAC_IMAC_INTEL] = "imac-intel",
diff --git a/sys-kernel/mactel-linux-sources/mactel-linux-sources-2.6.24-r4.ebuild b/sys-kernel/mactel-linux-sources/mactel-linux-sources-2.6.24-r4.ebuild
new file mode 100644
index 0000000..872945a
--- /dev/null
+++ b/sys-kernel/mactel-linux-sources/mactel-linux-sources-2.6.24-r4.ebuild
@@ -0,0 +1,45 @@
+# Copyright 1999-2007 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+# $Header: $
+
+ETYPE="sources"
+K_WANT_GENPATCHES="base extras"
+K_GENPATCHES_VER="4"
+K_SECURITY_UNSUPPORTED="1"
+inherit kernel-2
+detect_version
+detect_arch
+
+DESCRIPTION="Sources for the Linux kernel with mactel-linux and gentoo patches."
+HOMEPAGE="http://www.kernel.org
+ http://dev.gentoo.org/~dsd/genpatches
+ http://mactel-linux.org"
+
+SRC_URI="${KERNEL_URI} ${GENPATCHES_URI} ${ARCH_URI}"
+KEYWORDS="~amd64 ~x86"
+
+PATCHDIR="${FILESDIR}/${PV}-mactel-patches-r153/"
+
+UNIPATCH_LIST="${PATCHDIR}/appletouch-new.patch \
+${PATCHDIR}/appletouch.patch \
+${PATCHDIR}/applesmc-macbook2.patch \
+${PATCHDIR}/applesmc-retry-when-accessing-keys.patch \
+${PATCHDIR}/applesmc_int.patch \
+${PATCHDIR}/sigmatel_audio_display_all_controls_when_subsystem_id_is_wrong.patch \
+${PATCHDIR}/sigmatel_audio_fix_macbook_v2.patch \
+${PATCHDIR}/disk-protect.patch \
+${PATCHDIR}/disk-protect-fix-2.6.24-crash.patch \
+${PATCHDIR}/disk-protect-update.patch \
+${PATCHDIR}/export-lookup_dev.patch \
+${PATCHDIR}/applesmc-int-protect.patch \
+${PATCHDIR}/hid-add-new-apple-keyboard.patch"
+
+UNIPATCH_STRICTORDER="1"
+
+pkg_postinst() {
+ kernel-2_pkg_postinst
+ einfo "For more info on this patchset, see:"
+ einfo "${HOMEPAGE}"
+ einfo "Report any problems to je_fro@gentoo.org"
+}
+