diff options
author | Jeffrey Gardner <je_fro@gentoo.org> | 2008-04-04 19:12:38 +0000 |
---|---|---|
committer | Jeffrey Gardner <je_fro@gentoo.org> | 2008-04-04 19:12:38 +0000 |
commit | f7973225130b3645ce213031f35730fee79c1539 (patch) | |
tree | 9cce8ddeaeb0c19c90f7d534e8258669ba2278db /sys-kernel/mactel-linux-sources | |
parent | added to portage tree (diff) | |
download | je_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')
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" +} + |